9172 lines
356 KiB
JavaScript
9172 lines
356 KiB
JavaScript
(() => {
|
||
var e = {
|
||
5442: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
const n = r(5747);
|
||
const s = JSON.parse(
|
||
(0, n.readFileSync)("./config-gw-wa.json").toString()
|
||
);
|
||
const a = {
|
||
base_url: s["base_url"],
|
||
schedule: s["schedule"],
|
||
delay: s["delay"],
|
||
row_per_batch: s["row_per_batch"],
|
||
startDate: s["startDate"],
|
||
endDate: s["endDate"],
|
||
};
|
||
t.default = a;
|
||
},
|
||
7107: function (e, t, r) {
|
||
"use strict";
|
||
var n =
|
||
(this && this.__importDefault) ||
|
||
function (e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
};
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
const s = n(r(9623));
|
||
const getTimeStamp = () => {
|
||
const e = (0, s.default)().format("yyyy-MM-DD HH:mm:ss");
|
||
return e;
|
||
};
|
||
const info = (e, t, r) => {
|
||
if (r) {
|
||
console.log(`[${getTimeStamp()}] [INFO] [${e}] [${t}]`, r);
|
||
} else {
|
||
console.log(`[${getTimeStamp()}] [INFO] [${e}] [${t}]`);
|
||
}
|
||
};
|
||
const warning = (e, t, r) => {
|
||
if (r) {
|
||
console.log(
|
||
`[${getTimeStamp()}] [WARNING] [${e}] [${t}]`,
|
||
r
|
||
);
|
||
} else {
|
||
console.log(`[${getTimeStamp()}] [WARNING] [${e}] [${t}]`);
|
||
}
|
||
};
|
||
const error = (e, t, r) => {
|
||
if (r) {
|
||
console.log(`[${getTimeStamp()}] [ERROR] [${e}] [${t}]`, r);
|
||
} else {
|
||
console.log(`[${getTimeStamp()}] [ERROR] [${e}] [${t}]`);
|
||
}
|
||
};
|
||
const delay = e => new Promise(t => setTimeout(t, e));
|
||
t.default = {
|
||
info: info,
|
||
warning: warning,
|
||
error: error,
|
||
delay: delay,
|
||
};
|
||
},
|
||
3595: function (e, t, r) {
|
||
"use strict";
|
||
var n =
|
||
(this && this.__importDefault) ||
|
||
function (e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
};
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.changeStatusOutbox =
|
||
t.uploadFileCdn =
|
||
t.sendToQontak =
|
||
t.getListOutbox =
|
||
void 0;
|
||
const s = n(r(6545));
|
||
const a = n(r(5442));
|
||
const i = n(r(7107));
|
||
const o = r(4200);
|
||
const getListOutbox = async (e, t, r) => {
|
||
const n =
|
||
a.default.base_url + "mockup/sendwa/sendwa/listoutbox";
|
||
i.default.info(o.NAME_SPACE, "\t INFO : " + n);
|
||
i.default.info(o.NAME_SPACE, "\t INFO Status Outbox: " + e);
|
||
i.default.info(o.NAME_SPACE, "\t INFO Start Date: " + t);
|
||
i.default.info(o.NAME_SPACE, "\t INFO End Date: " + r);
|
||
try {
|
||
const a = await s.default.post(
|
||
n,
|
||
{ statusOutbox: e, startDate: t, endDate: r },
|
||
{
|
||
headers: {
|
||
"Content-Type":
|
||
"application/json; charset=UTF-8",
|
||
},
|
||
responseType: "text",
|
||
}
|
||
);
|
||
const i =
|
||
typeof a.data === "string"
|
||
? JSON.parse(a.data)
|
||
: a.data;
|
||
return i;
|
||
} catch (e) {
|
||
if (s.default.isAxiosError(e)) {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"Error di lib inject catch axios"
|
||
);
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
e.response?.data.toString()
|
||
);
|
||
} else if (e instanceof Error) {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"Error di instance of error"
|
||
);
|
||
i.default.error(o.NAME_SPACE, e.message);
|
||
}
|
||
}
|
||
};
|
||
t.getListOutbox = getListOutbox;
|
||
const sendToQontak = async e => {
|
||
const t =
|
||
a.default.base_url + "mockup/sendwa/sendwa/QontakSendMsg";
|
||
i.default.info(o.NAME_SPACE, "\t INFO : " + t);
|
||
i.default.info(
|
||
o.NAME_SPACE,
|
||
"\t INFO Payload: " + JSON.stringify(e)
|
||
);
|
||
try {
|
||
const r = await s.default.post(t, e, {
|
||
headers: {
|
||
"Content-Type": "application/json; charset=UTF-8",
|
||
},
|
||
responseType: "text",
|
||
});
|
||
const n = r.data.status;
|
||
i.default.info(
|
||
o.NAME_SPACE,
|
||
"\t INFO Resp Qontak: " + JSON.stringify(n)
|
||
);
|
||
if (n != "OK") {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"\t Error Qontak: " + JSON.stringify(r.data)
|
||
);
|
||
}
|
||
return n;
|
||
} catch (e) {
|
||
if (s.default.isAxiosError(e)) {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"Error di lib inject catch axios"
|
||
);
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
e.response?.data.toString()
|
||
);
|
||
} else if (e instanceof Error) {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"Error di instance of error"
|
||
);
|
||
i.default.error(o.NAME_SPACE, e.message);
|
||
}
|
||
}
|
||
};
|
||
t.sendToQontak = sendToQontak;
|
||
const uploadFileCdn = async e => {
|
||
const t =
|
||
a.default.base_url + "mockup/sendwa/sendwa/uploadfile";
|
||
i.default.info(o.NAME_SPACE, "\t INFO : " + t);
|
||
i.default.info(
|
||
o.NAME_SPACE,
|
||
"\t INFO Payload: " + JSON.stringify(e)
|
||
);
|
||
try {
|
||
const r = await s.default.post(t, e, {
|
||
headers: {
|
||
"Content-Type": "application/json; charset=UTF-8",
|
||
},
|
||
responseType: "text",
|
||
});
|
||
const n = r.data.status;
|
||
i.default.info(
|
||
o.NAME_SPACE,
|
||
"\t INFO Resp Upload: " + JSON.stringify(n)
|
||
);
|
||
return n;
|
||
} catch (e) {
|
||
if (s.default.isAxiosError(e)) {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"Error di lib inject catch axios"
|
||
);
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
e.response?.data.toString()
|
||
);
|
||
} else if (e instanceof Error) {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"Error di instance of error"
|
||
);
|
||
i.default.error(o.NAME_SPACE, e.message);
|
||
}
|
||
}
|
||
};
|
||
t.uploadFileCdn = uploadFileCdn;
|
||
const changeStatusOutbox = async e => {
|
||
const t =
|
||
a.default.base_url +
|
||
"mockup/sendwa/sendwa/changeStatusOutbox";
|
||
i.default.info(o.NAME_SPACE, "\t INFO : " + t);
|
||
i.default.info(
|
||
o.NAME_SPACE,
|
||
"\t INFO Payload: " + JSON.stringify(e)
|
||
);
|
||
try {
|
||
const r = await s.default.post(t, e, {
|
||
headers: {
|
||
"Content-Type": "application/json; charset=UTF-8",
|
||
},
|
||
responseType: "text",
|
||
});
|
||
const n = r.data.status;
|
||
i.default.info(
|
||
o.NAME_SPACE,
|
||
"\t INFO Resp Change Status: " + JSON.stringify(n)
|
||
);
|
||
return n;
|
||
} catch (e) {
|
||
if (s.default.isAxiosError(e)) {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"Error di lib inject catch axios"
|
||
);
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
e.response?.data.toString()
|
||
);
|
||
} else if (e instanceof Error) {
|
||
i.default.error(
|
||
o.NAME_SPACE,
|
||
"Error di instance of error"
|
||
);
|
||
i.default.error(o.NAME_SPACE, e.message);
|
||
}
|
||
}
|
||
};
|
||
t.changeStatusOutbox = changeStatusOutbox;
|
||
},
|
||
4200: function (e, t, r) {
|
||
"use strict";
|
||
var n =
|
||
(this && this.__createBinding) ||
|
||
(Object.create
|
||
? function (e, t, r, n) {
|
||
if (n === undefined) n = r;
|
||
var s = Object.getOwnPropertyDescriptor(t, r);
|
||
if (
|
||
!s ||
|
||
("get" in s
|
||
? !t.__esModule
|
||
: s.writable || s.configurable)
|
||
) {
|
||
s = {
|
||
enumerable: true,
|
||
get: function () {
|
||
return t[r];
|
||
},
|
||
};
|
||
}
|
||
Object.defineProperty(e, n, s);
|
||
}
|
||
: function (e, t, r, n) {
|
||
if (n === undefined) n = r;
|
||
e[n] = t[r];
|
||
});
|
||
var s =
|
||
(this && this.__setModuleDefault) ||
|
||
(Object.create
|
||
? function (e, t) {
|
||
Object.defineProperty(e, "default", {
|
||
enumerable: true,
|
||
value: t,
|
||
});
|
||
}
|
||
: function (e, t) {
|
||
e["default"] = t;
|
||
});
|
||
var a =
|
||
(this && this.__importStar) ||
|
||
function (e) {
|
||
if (e && e.__esModule) return e;
|
||
var t = {};
|
||
if (e != null)
|
||
for (var r in e)
|
||
if (
|
||
r !== "default" &&
|
||
Object.prototype.hasOwnProperty.call(e, r)
|
||
)
|
||
n(t, e, r);
|
||
s(t, e);
|
||
return t;
|
||
};
|
||
var i =
|
||
(this && this.__importDefault) ||
|
||
function (e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
};
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.NAME_SPACE = void 0;
|
||
const o = i(r(5442));
|
||
const u = i(r(7107));
|
||
const l = a(r(2148));
|
||
const c = r(3595);
|
||
t.NAME_SPACE = "SENT RESULT VIA WA";
|
||
const f = "1.0";
|
||
let d = false;
|
||
u.default.info(t.NAME_SPACE, "Starting. Ver:", `${f}`);
|
||
const on_init = async () => {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"-------------------- ON INIT START --------------------"
|
||
);
|
||
await main("N");
|
||
await main("E");
|
||
await main("R");
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"-------------------- ON INIT END --------------------"
|
||
);
|
||
};
|
||
on_init();
|
||
async function main(e) {
|
||
if (d) {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"Process is running. Skip this run."
|
||
);
|
||
return;
|
||
}
|
||
d = true;
|
||
try {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"Process is running. Start to get list outbox."
|
||
);
|
||
let r = await getLists(e);
|
||
if (e == "N") {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"GET Processed (N) Message"
|
||
);
|
||
for (let n = 0; n < r.length; n++) {
|
||
let s = r[n];
|
||
let a = s.XWaOutboxIsRetry;
|
||
if (s.fileUrl == null) {
|
||
let r = uploadFile(s);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Uploading File to CDN: ",
|
||
r
|
||
);
|
||
u.default.info(t.NAME_SPACE, "\t wait 2s \t");
|
||
await delay(2e3);
|
||
if ((await r) == "OK") {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t File Uploaded"
|
||
);
|
||
let r = sentMsg(s, e, a);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t wait 4s \t"
|
||
);
|
||
await delay(4e3);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Resp Qontak: ",
|
||
r
|
||
);
|
||
} else {
|
||
changeStatus(s, "E", a);
|
||
}
|
||
} else {
|
||
let r = sentMsg(s, e, a);
|
||
u.default.info(t.NAME_SPACE, "\t wait 4s \t");
|
||
await delay(4e3);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Resp Qontak: ",
|
||
r
|
||
);
|
||
}
|
||
}
|
||
} else if (e == "E") {
|
||
u.default.info(t.NAME_SPACE, "GET Error (E) Message");
|
||
for (let n = 0; n < r.length; n++) {
|
||
let s = r[n];
|
||
let a = s.XWaOutboxIsRetry;
|
||
if (a >= 5) {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Retry count more than 5. Skip this message."
|
||
);
|
||
continue;
|
||
} else {
|
||
a++;
|
||
if (s.fileUrl == null) {
|
||
let r = uploadFile(s);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Uploading File to CDN: ",
|
||
r
|
||
);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t wait 2s \t"
|
||
);
|
||
await delay(2e3);
|
||
if ((await r) == "OK") {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t File Uploaded"
|
||
);
|
||
let r = sentMsg(s, e, a);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t wait 4s \t"
|
||
);
|
||
await delay(4e3);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Resp Qontak: ",
|
||
r
|
||
);
|
||
} else {
|
||
changeStatus(s, "E", a);
|
||
}
|
||
} else {
|
||
let r = sentMsg(s, e, a);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t wait 4s \t"
|
||
);
|
||
await delay(4e3);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Resp Qontak: ",
|
||
r
|
||
);
|
||
}
|
||
}
|
||
}
|
||
} else if (e == "R") {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"GET Rejected (R) Message"
|
||
);
|
||
for (let n = 0; n < r.length; n++) {
|
||
let s = r[n];
|
||
let a = s.XWaOutboxIsRetry;
|
||
if (s.fileUrl == null) {
|
||
let r = uploadFile(s);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Uploading File to CDN: ",
|
||
r
|
||
);
|
||
u.default.info(t.NAME_SPACE, "\t wait 2s \t");
|
||
await delay(2e3);
|
||
if ((await r) == "OK") {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t File Uploaded"
|
||
);
|
||
let r = sentMsg(s, e, a);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t wait 4s \t"
|
||
);
|
||
await delay(4e3);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Resp Qontak: ",
|
||
r
|
||
);
|
||
} else {
|
||
changeStatus(s, "E", a);
|
||
}
|
||
} else {
|
||
let r = sentMsg(s, e, a);
|
||
u.default.info(t.NAME_SPACE, "\t wait 4s \t");
|
||
await delay(4e3);
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Resp Qontak: ",
|
||
r
|
||
);
|
||
}
|
||
}
|
||
}
|
||
u.default.info(t.NAME_SPACE, "End Job Get Order");
|
||
d = false;
|
||
} catch (e) {
|
||
d = false;
|
||
if (e instanceof Error) {
|
||
u.default.error(t.NAME_SPACE, e.message);
|
||
} else {
|
||
u.default.error(t.NAME_SPACE, "Unknown");
|
||
}
|
||
}
|
||
}
|
||
async function getLists(e) {
|
||
const r = e;
|
||
const n = o.default.startDate;
|
||
const s = o.default.endDate;
|
||
var a = await (0, c.getListOutbox)(r, n, s);
|
||
if (a["status"] != "OK") {
|
||
u.default.error(
|
||
t.NAME_SPACE,
|
||
"\t Error get outbox data",
|
||
a
|
||
);
|
||
u.default.error(t.NAME_SPACE, "\t Error: ", a);
|
||
} else {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"\t Success get order data found ",
|
||
a.data.length
|
||
);
|
||
}
|
||
const i =
|
||
typeof a.data === "string" ? JSON.parse(a.data) : a.data;
|
||
return i;
|
||
}
|
||
async function sentMsg(e, t, r) {
|
||
let n = {
|
||
orderID: e.orderID,
|
||
orderDate: e.orderDate,
|
||
patientDOB: e.patientDOB,
|
||
patientName: e.patientName,
|
||
patientHp: e.patientHp,
|
||
corpName: e.CorporateName,
|
||
fileName: e.fileName,
|
||
statusOutbox: t,
|
||
retryOutbox: r,
|
||
sendWaID: e.sendWaID,
|
||
};
|
||
var s = await (0, c.sendToQontak)(n);
|
||
return s;
|
||
}
|
||
async function uploadFile(e) {
|
||
let t = {
|
||
fileName: e.fileName,
|
||
rptUrl: e.localUrl,
|
||
mime: "application/pdf",
|
||
XWaOutboxID: e.sendWaID,
|
||
};
|
||
var r = await (0, c.uploadFileCdn)(t);
|
||
return r;
|
||
}
|
||
async function changeStatus(e, t, r) {
|
||
let n = { toStatus: t, XWaOutboxID: e.sendWaID, retry: r };
|
||
var s = await (0, c.changeStatusOutbox)(n);
|
||
return s;
|
||
}
|
||
async function delay(e) {
|
||
return new Promise(t => setTimeout(t, e));
|
||
}
|
||
function elseif(e) {
|
||
throw new Error("Function not implemented.");
|
||
}
|
||
for (const e of o.default.schedule) {
|
||
l.schedule(
|
||
e,
|
||
async () => {
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
" -------------------- ON INIT SCHEDULE --------------------"
|
||
);
|
||
await main("N");
|
||
await main("E");
|
||
await main("R");
|
||
u.default.info(
|
||
t.NAME_SPACE,
|
||
"-------------------- END SCHEDULE--------------------"
|
||
);
|
||
},
|
||
{ timezone: "Asia/Jakarta" }
|
||
);
|
||
}
|
||
},
|
||
6545: (e, t, r) => {
|
||
e.exports = r(2618);
|
||
},
|
||
8104: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
var s = r(3211);
|
||
var a = r(1934);
|
||
var i = r(646);
|
||
var o = r(8605);
|
||
var u = r(7211);
|
||
var l = r(7707).http;
|
||
var c = r(7707).https;
|
||
var f = r(8835);
|
||
var d = r(8761);
|
||
var h = r(696);
|
||
var m = r(5226);
|
||
var p = r(1516);
|
||
var g = /https:?/;
|
||
function setProxy(e, t, r) {
|
||
e.hostname = t.host;
|
||
e.host = t.host;
|
||
e.port = t.port;
|
||
e.path = r;
|
||
if (t.auth) {
|
||
var n = Buffer.from(
|
||
t.auth.username + ":" + t.auth.password,
|
||
"utf8"
|
||
).toString("base64");
|
||
e.headers["Proxy-Authorization"] = "Basic " + n;
|
||
}
|
||
e.beforeRedirect = function beforeRedirect(e) {
|
||
e.headers.host = e.host;
|
||
setProxy(e, t, e.href);
|
||
};
|
||
}
|
||
e.exports = function httpAdapter(e) {
|
||
return new Promise(function dispatchHttpRequest(t, r) {
|
||
var y = function resolve(e) {
|
||
t(e);
|
||
};
|
||
var _ = function reject(e) {
|
||
r(e);
|
||
};
|
||
var v = e.data;
|
||
var k = e.headers;
|
||
if ("User-Agent" in k || "user-agent" in k) {
|
||
if (!k["User-Agent"] && !k["user-agent"]) {
|
||
delete k["User-Agent"];
|
||
delete k["user-agent"];
|
||
}
|
||
} else {
|
||
k["User-Agent"] = "axios/" + h.version;
|
||
}
|
||
if (v && !n.isStream(v)) {
|
||
if (Buffer.isBuffer(v)) {
|
||
} else if (n.isArrayBuffer(v)) {
|
||
v = Buffer.from(new Uint8Array(v));
|
||
} else if (n.isString(v)) {
|
||
v = Buffer.from(v, "utf-8");
|
||
} else {
|
||
return _(
|
||
m(
|
||
"Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream",
|
||
e
|
||
)
|
||
);
|
||
}
|
||
k["Content-Length"] = v.length;
|
||
}
|
||
var w = undefined;
|
||
if (e.auth) {
|
||
var b = e.auth.username || "";
|
||
var S = e.auth.password || "";
|
||
w = b + ":" + S;
|
||
}
|
||
var O = a(e.baseURL, e.url);
|
||
var T = f.parse(O);
|
||
var M = T.protocol || "http:";
|
||
if (!w && T.auth) {
|
||
var D = T.auth.split(":");
|
||
var x = D[0] || "";
|
||
var R = D[1] || "";
|
||
w = x + ":" + R;
|
||
}
|
||
if (w) {
|
||
delete k.Authorization;
|
||
}
|
||
var E = g.test(M);
|
||
var C = E ? e.httpsAgent : e.httpAgent;
|
||
var F = {
|
||
path: i(T.path, e.params, e.paramsSerializer).replace(
|
||
/^\?/,
|
||
""
|
||
),
|
||
method: e.method.toUpperCase(),
|
||
headers: k,
|
||
agent: C,
|
||
agents: { http: e.httpAgent, https: e.httpsAgent },
|
||
auth: w,
|
||
};
|
||
if (e.socketPath) {
|
||
F.socketPath = e.socketPath;
|
||
} else {
|
||
F.hostname = T.hostname;
|
||
F.port = T.port;
|
||
}
|
||
var P = e.proxy;
|
||
if (!P && P !== false) {
|
||
var A = M.slice(0, -1) + "_proxy";
|
||
var N = process.env[A] || process.env[A.toUpperCase()];
|
||
if (N) {
|
||
var Y = f.parse(N);
|
||
var I =
|
||
process.env.no_proxy || process.env.NO_PROXY;
|
||
var U = true;
|
||
if (I) {
|
||
var L = I.split(",").map(function trim(e) {
|
||
return e.trim();
|
||
});
|
||
U = !L.some(function proxyMatch(e) {
|
||
if (!e) {
|
||
return false;
|
||
}
|
||
if (e === "*") {
|
||
return true;
|
||
}
|
||
if (
|
||
e[0] === "." &&
|
||
T.hostname.substr(
|
||
T.hostname.length - e.length
|
||
) === e
|
||
) {
|
||
return true;
|
||
}
|
||
return T.hostname === e;
|
||
});
|
||
}
|
||
if (U) {
|
||
P = {
|
||
host: Y.hostname,
|
||
port: Y.port,
|
||
protocol: Y.protocol,
|
||
};
|
||
if (Y.auth) {
|
||
var W = Y.auth.split(":");
|
||
P.auth = { username: W[0], password: W[1] };
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (P) {
|
||
F.headers.host =
|
||
T.hostname + (T.port ? ":" + T.port : "");
|
||
setProxy(
|
||
F,
|
||
P,
|
||
M +
|
||
"//" +
|
||
T.hostname +
|
||
(T.port ? ":" + T.port : "") +
|
||
F.path
|
||
);
|
||
}
|
||
var j;
|
||
var q = E && (P ? g.test(P.protocol) : true);
|
||
if (e.transport) {
|
||
j = e.transport;
|
||
} else if (e.maxRedirects === 0) {
|
||
j = q ? u : o;
|
||
} else {
|
||
if (e.maxRedirects) {
|
||
F.maxRedirects = e.maxRedirects;
|
||
}
|
||
j = q ? c : l;
|
||
}
|
||
if (e.maxBodyLength > -1) {
|
||
F.maxBodyLength = e.maxBodyLength;
|
||
}
|
||
var H = j.request(F, function handleResponse(t) {
|
||
if (H.aborted) return;
|
||
var r = t;
|
||
var a = t.req || H;
|
||
if (
|
||
t.statusCode !== 204 &&
|
||
a.method !== "HEAD" &&
|
||
e.decompress !== false
|
||
) {
|
||
switch (t.headers["content-encoding"]) {
|
||
case "gzip":
|
||
case "compress":
|
||
case "deflate":
|
||
r = r.pipe(d.createUnzip());
|
||
delete t.headers["content-encoding"];
|
||
break;
|
||
}
|
||
}
|
||
var i = {
|
||
status: t.statusCode,
|
||
statusText: t.statusMessage,
|
||
headers: t.headers,
|
||
config: e,
|
||
request: a,
|
||
};
|
||
if (e.responseType === "stream") {
|
||
i.data = r;
|
||
s(y, _, i);
|
||
} else {
|
||
var o = [];
|
||
var u = 0;
|
||
r.on("data", function handleStreamData(t) {
|
||
o.push(t);
|
||
u += t.length;
|
||
if (
|
||
e.maxContentLength > -1 &&
|
||
u > e.maxContentLength
|
||
) {
|
||
r.destroy();
|
||
_(
|
||
m(
|
||
"maxContentLength size of " +
|
||
e.maxContentLength +
|
||
" exceeded",
|
||
e,
|
||
null,
|
||
a
|
||
)
|
||
);
|
||
}
|
||
});
|
||
r.on("error", function handleStreamError(t) {
|
||
if (H.aborted) return;
|
||
_(p(t, e, null, a));
|
||
});
|
||
r.on("end", function handleStreamEnd() {
|
||
var t = Buffer.concat(o);
|
||
if (e.responseType !== "arraybuffer") {
|
||
t = t.toString(e.responseEncoding);
|
||
if (
|
||
!e.responseEncoding ||
|
||
e.responseEncoding === "utf8"
|
||
) {
|
||
t = n.stripBOM(t);
|
||
}
|
||
}
|
||
i.data = t;
|
||
s(y, _, i);
|
||
});
|
||
}
|
||
});
|
||
H.on("error", function handleRequestError(t) {
|
||
if (H.aborted && t.code !== "ERR_FR_TOO_MANY_REDIRECTS")
|
||
return;
|
||
_(p(t, e, null, H));
|
||
});
|
||
if (e.timeout) {
|
||
var B = parseInt(e.timeout, 10);
|
||
if (isNaN(B)) {
|
||
_(
|
||
m(
|
||
"error trying to parse `config.timeout` to int",
|
||
e,
|
||
"ERR_PARSE_TIMEOUT",
|
||
H
|
||
)
|
||
);
|
||
return;
|
||
}
|
||
H.setTimeout(B, function handleRequestTimeout() {
|
||
H.abort();
|
||
_(
|
||
m(
|
||
"timeout of " + B + "ms exceeded",
|
||
e,
|
||
e.transitional &&
|
||
e.transitional.clarifyTimeoutError
|
||
? "ETIMEDOUT"
|
||
: "ECONNABORTED",
|
||
H
|
||
)
|
||
);
|
||
});
|
||
}
|
||
if (e.cancelToken) {
|
||
e.cancelToken.promise.then(function onCanceled(e) {
|
||
if (H.aborted) return;
|
||
H.abort();
|
||
_(e);
|
||
});
|
||
}
|
||
if (n.isStream(v)) {
|
||
v.on("error", function handleStreamError(t) {
|
||
_(p(t, e, null, H));
|
||
}).pipe(H);
|
||
} else {
|
||
H.end(v);
|
||
}
|
||
});
|
||
};
|
||
},
|
||
3454: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
var s = r(3211);
|
||
var a = r(1545);
|
||
var i = r(646);
|
||
var o = r(1934);
|
||
var u = r(6455);
|
||
var l = r(3608);
|
||
var c = r(5226);
|
||
e.exports = function xhrAdapter(e) {
|
||
return new Promise(function dispatchXhrRequest(t, r) {
|
||
var f = e.data;
|
||
var d = e.headers;
|
||
var h = e.responseType;
|
||
if (n.isFormData(f)) {
|
||
delete d["Content-Type"];
|
||
}
|
||
var m = new XMLHttpRequest();
|
||
if (e.auth) {
|
||
var p = e.auth.username || "";
|
||
var g = e.auth.password
|
||
? unescape(encodeURIComponent(e.auth.password))
|
||
: "";
|
||
d.Authorization = "Basic " + btoa(p + ":" + g);
|
||
}
|
||
var y = o(e.baseURL, e.url);
|
||
m.open(
|
||
e.method.toUpperCase(),
|
||
i(y, e.params, e.paramsSerializer),
|
||
true
|
||
);
|
||
m.timeout = e.timeout;
|
||
function onloadend() {
|
||
if (!m) {
|
||
return;
|
||
}
|
||
var n =
|
||
"getAllResponseHeaders" in m
|
||
? u(m.getAllResponseHeaders())
|
||
: null;
|
||
var a =
|
||
!h || h === "text" || h === "json"
|
||
? m.responseText
|
||
: m.response;
|
||
var i = {
|
||
data: a,
|
||
status: m.status,
|
||
statusText: m.statusText,
|
||
headers: n,
|
||
config: e,
|
||
request: m,
|
||
};
|
||
s(t, r, i);
|
||
m = null;
|
||
}
|
||
if ("onloadend" in m) {
|
||
m.onloadend = onloadend;
|
||
} else {
|
||
m.onreadystatechange = function handleLoad() {
|
||
if (!m || m.readyState !== 4) {
|
||
return;
|
||
}
|
||
if (
|
||
m.status === 0 &&
|
||
!(
|
||
m.responseURL &&
|
||
m.responseURL.indexOf("file:") === 0
|
||
)
|
||
) {
|
||
return;
|
||
}
|
||
setTimeout(onloadend);
|
||
};
|
||
}
|
||
m.onabort = function handleAbort() {
|
||
if (!m) {
|
||
return;
|
||
}
|
||
r(c("Request aborted", e, "ECONNABORTED", m));
|
||
m = null;
|
||
};
|
||
m.onerror = function handleError() {
|
||
r(c("Network Error", e, null, m));
|
||
m = null;
|
||
};
|
||
m.ontimeout = function handleTimeout() {
|
||
var t = "timeout of " + e.timeout + "ms exceeded";
|
||
if (e.timeoutErrorMessage) {
|
||
t = e.timeoutErrorMessage;
|
||
}
|
||
r(
|
||
c(
|
||
t,
|
||
e,
|
||
e.transitional &&
|
||
e.transitional.clarifyTimeoutError
|
||
? "ETIMEDOUT"
|
||
: "ECONNABORTED",
|
||
m
|
||
)
|
||
);
|
||
m = null;
|
||
};
|
||
if (n.isStandardBrowserEnv()) {
|
||
var _ =
|
||
(e.withCredentials || l(y)) && e.xsrfCookieName
|
||
? a.read(e.xsrfCookieName)
|
||
: undefined;
|
||
if (_) {
|
||
d[e.xsrfHeaderName] = _;
|
||
}
|
||
}
|
||
if ("setRequestHeader" in m) {
|
||
n.forEach(d, function setRequestHeader(e, t) {
|
||
if (
|
||
typeof f === "undefined" &&
|
||
t.toLowerCase() === "content-type"
|
||
) {
|
||
delete d[t];
|
||
} else {
|
||
m.setRequestHeader(t, e);
|
||
}
|
||
});
|
||
}
|
||
if (!n.isUndefined(e.withCredentials)) {
|
||
m.withCredentials = !!e.withCredentials;
|
||
}
|
||
if (h && h !== "json") {
|
||
m.responseType = e.responseType;
|
||
}
|
||
if (typeof e.onDownloadProgress === "function") {
|
||
m.addEventListener("progress", e.onDownloadProgress);
|
||
}
|
||
if (typeof e.onUploadProgress === "function" && m.upload) {
|
||
m.upload.addEventListener(
|
||
"progress",
|
||
e.onUploadProgress
|
||
);
|
||
}
|
||
if (e.cancelToken) {
|
||
e.cancelToken.promise.then(function onCanceled(e) {
|
||
if (!m) {
|
||
return;
|
||
}
|
||
m.abort();
|
||
r(e);
|
||
m = null;
|
||
});
|
||
}
|
||
if (!f) {
|
||
f = null;
|
||
}
|
||
m.send(f);
|
||
});
|
||
};
|
||
},
|
||
2618: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
var s = r(7065);
|
||
var a = r(8178);
|
||
var i = r(4831);
|
||
var o = r(8190);
|
||
function createInstance(e) {
|
||
var t = new a(e);
|
||
var r = s(a.prototype.request, t);
|
||
n.extend(r, a.prototype, t);
|
||
n.extend(r, t);
|
||
return r;
|
||
}
|
||
var u = createInstance(o);
|
||
u.Axios = a;
|
||
u.create = function create(e) {
|
||
return createInstance(i(u.defaults, e));
|
||
};
|
||
u.Cancel = r(8875);
|
||
u.CancelToken = r(1587);
|
||
u.isCancel = r(4057);
|
||
u.all = function all(e) {
|
||
return Promise.all(e);
|
||
};
|
||
u.spread = r(4850);
|
||
u.isAxiosError = r(650);
|
||
e.exports = u;
|
||
e.exports.default = u;
|
||
},
|
||
8875: e => {
|
||
"use strict";
|
||
function Cancel(e) {
|
||
this.message = e;
|
||
}
|
||
Cancel.prototype.toString = function toString() {
|
||
return "Cancel" + (this.message ? ": " + this.message : "");
|
||
};
|
||
Cancel.prototype.__CANCEL__ = true;
|
||
e.exports = Cancel;
|
||
},
|
||
1587: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(8875);
|
||
function CancelToken(e) {
|
||
if (typeof e !== "function") {
|
||
throw new TypeError("executor must be a function.");
|
||
}
|
||
var t;
|
||
this.promise = new Promise(function promiseExecutor(e) {
|
||
t = e;
|
||
});
|
||
var r = this;
|
||
e(function cancel(e) {
|
||
if (r.reason) {
|
||
return;
|
||
}
|
||
r.reason = new n(e);
|
||
t(r.reason);
|
||
});
|
||
}
|
||
CancelToken.prototype.throwIfRequested =
|
||
function throwIfRequested() {
|
||
if (this.reason) {
|
||
throw this.reason;
|
||
}
|
||
};
|
||
CancelToken.source = function source() {
|
||
var e;
|
||
var t = new CancelToken(function executor(t) {
|
||
e = t;
|
||
});
|
||
return { token: t, cancel: e };
|
||
};
|
||
e.exports = CancelToken;
|
||
},
|
||
4057: e => {
|
||
"use strict";
|
||
e.exports = function isCancel(e) {
|
||
return !!(e && e.__CANCEL__);
|
||
};
|
||
},
|
||
8178: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
var s = r(646);
|
||
var a = r(3214);
|
||
var i = r(5062);
|
||
var o = r(4831);
|
||
var u = r(1632);
|
||
var l = u.validators;
|
||
function Axios(e) {
|
||
this.defaults = e;
|
||
this.interceptors = { request: new a(), response: new a() };
|
||
}
|
||
Axios.prototype.request = function request(e) {
|
||
if (typeof e === "string") {
|
||
e = arguments[1] || {};
|
||
e.url = arguments[0];
|
||
} else {
|
||
e = e || {};
|
||
}
|
||
e = o(this.defaults, e);
|
||
if (e.method) {
|
||
e.method = e.method.toLowerCase();
|
||
} else if (this.defaults.method) {
|
||
e.method = this.defaults.method.toLowerCase();
|
||
} else {
|
||
e.method = "get";
|
||
}
|
||
var t = e.transitional;
|
||
if (t !== undefined) {
|
||
u.assertOptions(
|
||
t,
|
||
{
|
||
silentJSONParsing: l.transitional(
|
||
l.boolean,
|
||
"1.0.0"
|
||
),
|
||
forcedJSONParsing: l.transitional(
|
||
l.boolean,
|
||
"1.0.0"
|
||
),
|
||
clarifyTimeoutError: l.transitional(
|
||
l.boolean,
|
||
"1.0.0"
|
||
),
|
||
},
|
||
false
|
||
);
|
||
}
|
||
var r = [];
|
||
var n = true;
|
||
this.interceptors.request.forEach(
|
||
function unshiftRequestInterceptors(t) {
|
||
if (
|
||
typeof t.runWhen === "function" &&
|
||
t.runWhen(e) === false
|
||
) {
|
||
return;
|
||
}
|
||
n = n && t.synchronous;
|
||
r.unshift(t.fulfilled, t.rejected);
|
||
}
|
||
);
|
||
var s = [];
|
||
this.interceptors.response.forEach(
|
||
function pushResponseInterceptors(e) {
|
||
s.push(e.fulfilled, e.rejected);
|
||
}
|
||
);
|
||
var a;
|
||
if (!n) {
|
||
var c = [i, undefined];
|
||
Array.prototype.unshift.apply(c, r);
|
||
c = c.concat(s);
|
||
a = Promise.resolve(e);
|
||
while (c.length) {
|
||
a = a.then(c.shift(), c.shift());
|
||
}
|
||
return a;
|
||
}
|
||
var f = e;
|
||
while (r.length) {
|
||
var d = r.shift();
|
||
var h = r.shift();
|
||
try {
|
||
f = d(f);
|
||
} catch (e) {
|
||
h(e);
|
||
break;
|
||
}
|
||
}
|
||
try {
|
||
a = i(f);
|
||
} catch (e) {
|
||
return Promise.reject(e);
|
||
}
|
||
while (s.length) {
|
||
a = a.then(s.shift(), s.shift());
|
||
}
|
||
return a;
|
||
};
|
||
Axios.prototype.getUri = function getUri(e) {
|
||
e = o(this.defaults, e);
|
||
return s(e.url, e.params, e.paramsSerializer).replace(
|
||
/^\?/,
|
||
""
|
||
);
|
||
};
|
||
n.forEach(
|
||
["delete", "get", "head", "options"],
|
||
function forEachMethodNoData(e) {
|
||
Axios.prototype[e] = function (t, r) {
|
||
return this.request(
|
||
o(r || {}, {
|
||
method: e,
|
||
url: t,
|
||
data: (r || {}).data,
|
||
})
|
||
);
|
||
};
|
||
}
|
||
);
|
||
n.forEach(
|
||
["post", "put", "patch"],
|
||
function forEachMethodWithData(e) {
|
||
Axios.prototype[e] = function (t, r, n) {
|
||
return this.request(
|
||
o(n || {}, { method: e, url: t, data: r })
|
||
);
|
||
};
|
||
}
|
||
);
|
||
e.exports = Axios;
|
||
},
|
||
3214: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
function InterceptorManager() {
|
||
this.handlers = [];
|
||
}
|
||
InterceptorManager.prototype.use = function use(e, t, r) {
|
||
this.handlers.push({
|
||
fulfilled: e,
|
||
rejected: t,
|
||
synchronous: r ? r.synchronous : false,
|
||
runWhen: r ? r.runWhen : null,
|
||
});
|
||
return this.handlers.length - 1;
|
||
};
|
||
InterceptorManager.prototype.eject = function eject(e) {
|
||
if (this.handlers[e]) {
|
||
this.handlers[e] = null;
|
||
}
|
||
};
|
||
InterceptorManager.prototype.forEach = function forEach(e) {
|
||
n.forEach(this.handlers, function forEachHandler(t) {
|
||
if (t !== null) {
|
||
e(t);
|
||
}
|
||
});
|
||
};
|
||
e.exports = InterceptorManager;
|
||
},
|
||
1934: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(1301);
|
||
var s = r(7189);
|
||
e.exports = function buildFullPath(e, t) {
|
||
if (e && !n(t)) {
|
||
return s(e, t);
|
||
}
|
||
return t;
|
||
};
|
||
},
|
||
5226: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(1516);
|
||
e.exports = function createError(e, t, r, s, a) {
|
||
var i = new Error(e);
|
||
return n(i, t, r, s, a);
|
||
};
|
||
},
|
||
5062: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
var s = r(9812);
|
||
var a = r(4057);
|
||
var i = r(8190);
|
||
function throwIfCancellationRequested(e) {
|
||
if (e.cancelToken) {
|
||
e.cancelToken.throwIfRequested();
|
||
}
|
||
}
|
||
e.exports = function dispatchRequest(e) {
|
||
throwIfCancellationRequested(e);
|
||
e.headers = e.headers || {};
|
||
e.data = s.call(e, e.data, e.headers, e.transformRequest);
|
||
e.headers = n.merge(
|
||
e.headers.common || {},
|
||
e.headers[e.method] || {},
|
||
e.headers
|
||
);
|
||
n.forEach(
|
||
["delete", "get", "head", "post", "put", "patch", "common"],
|
||
function cleanHeaderConfig(t) {
|
||
delete e.headers[t];
|
||
}
|
||
);
|
||
var t = e.adapter || i.adapter;
|
||
return t(e).then(
|
||
function onAdapterResolution(t) {
|
||
throwIfCancellationRequested(e);
|
||
t.data = s.call(
|
||
e,
|
||
t.data,
|
||
t.headers,
|
||
e.transformResponse
|
||
);
|
||
return t;
|
||
},
|
||
function onAdapterRejection(t) {
|
||
if (!a(t)) {
|
||
throwIfCancellationRequested(e);
|
||
if (t && t.response) {
|
||
t.response.data = s.call(
|
||
e,
|
||
t.response.data,
|
||
t.response.headers,
|
||
e.transformResponse
|
||
);
|
||
}
|
||
}
|
||
return Promise.reject(t);
|
||
}
|
||
);
|
||
};
|
||
},
|
||
1516: e => {
|
||
"use strict";
|
||
e.exports = function enhanceError(e, t, r, n, s) {
|
||
e.config = t;
|
||
if (r) {
|
||
e.code = r;
|
||
}
|
||
e.request = n;
|
||
e.response = s;
|
||
e.isAxiosError = true;
|
||
e.toJSON = function toJSON() {
|
||
return {
|
||
message: this.message,
|
||
name: this.name,
|
||
description: this.description,
|
||
number: this.number,
|
||
fileName: this.fileName,
|
||
lineNumber: this.lineNumber,
|
||
columnNumber: this.columnNumber,
|
||
stack: this.stack,
|
||
config: this.config,
|
||
code: this.code,
|
||
};
|
||
};
|
||
return e;
|
||
};
|
||
},
|
||
4831: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
e.exports = function mergeConfig(e, t) {
|
||
t = t || {};
|
||
var r = {};
|
||
var s = ["url", "method", "data"];
|
||
var a = ["headers", "auth", "proxy", "params"];
|
||
var i = [
|
||
"baseURL",
|
||
"transformRequest",
|
||
"transformResponse",
|
||
"paramsSerializer",
|
||
"timeout",
|
||
"timeoutMessage",
|
||
"withCredentials",
|
||
"adapter",
|
||
"responseType",
|
||
"xsrfCookieName",
|
||
"xsrfHeaderName",
|
||
"onUploadProgress",
|
||
"onDownloadProgress",
|
||
"decompress",
|
||
"maxContentLength",
|
||
"maxBodyLength",
|
||
"maxRedirects",
|
||
"transport",
|
||
"httpAgent",
|
||
"httpsAgent",
|
||
"cancelToken",
|
||
"socketPath",
|
||
"responseEncoding",
|
||
];
|
||
var o = ["validateStatus"];
|
||
function getMergedValue(e, t) {
|
||
if (n.isPlainObject(e) && n.isPlainObject(t)) {
|
||
return n.merge(e, t);
|
||
} else if (n.isPlainObject(t)) {
|
||
return n.merge({}, t);
|
||
} else if (n.isArray(t)) {
|
||
return t.slice();
|
||
}
|
||
return t;
|
||
}
|
||
function mergeDeepProperties(s) {
|
||
if (!n.isUndefined(t[s])) {
|
||
r[s] = getMergedValue(e[s], t[s]);
|
||
} else if (!n.isUndefined(e[s])) {
|
||
r[s] = getMergedValue(undefined, e[s]);
|
||
}
|
||
}
|
||
n.forEach(s, function valueFromConfig2(e) {
|
||
if (!n.isUndefined(t[e])) {
|
||
r[e] = getMergedValue(undefined, t[e]);
|
||
}
|
||
});
|
||
n.forEach(a, mergeDeepProperties);
|
||
n.forEach(i, function defaultToConfig2(s) {
|
||
if (!n.isUndefined(t[s])) {
|
||
r[s] = getMergedValue(undefined, t[s]);
|
||
} else if (!n.isUndefined(e[s])) {
|
||
r[s] = getMergedValue(undefined, e[s]);
|
||
}
|
||
});
|
||
n.forEach(o, function merge(n) {
|
||
if (n in t) {
|
||
r[n] = getMergedValue(e[n], t[n]);
|
||
} else if (n in e) {
|
||
r[n] = getMergedValue(undefined, e[n]);
|
||
}
|
||
});
|
||
var u = s.concat(a).concat(i).concat(o);
|
||
var l = Object.keys(e)
|
||
.concat(Object.keys(t))
|
||
.filter(function filterAxiosKeys(e) {
|
||
return u.indexOf(e) === -1;
|
||
});
|
||
n.forEach(l, mergeDeepProperties);
|
||
return r;
|
||
};
|
||
},
|
||
3211: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(5226);
|
||
e.exports = function settle(e, t, r) {
|
||
var s = r.config.validateStatus;
|
||
if (!r.status || !s || s(r.status)) {
|
||
e(r);
|
||
} else {
|
||
t(
|
||
n(
|
||
"Request failed with status code " + r.status,
|
||
r.config,
|
||
null,
|
||
r.request,
|
||
r
|
||
)
|
||
);
|
||
}
|
||
};
|
||
},
|
||
9812: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
var s = r(8190);
|
||
e.exports = function transformData(e, t, r) {
|
||
var a = this || s;
|
||
n.forEach(r, function transform(r) {
|
||
e = r.call(a, e, t);
|
||
});
|
||
return e;
|
||
};
|
||
},
|
||
8190: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
var s = r(6240);
|
||
var a = r(1516);
|
||
var i = { "Content-Type": "application/x-www-form-urlencoded" };
|
||
function setContentTypeIfUnset(e, t) {
|
||
if (!n.isUndefined(e) && n.isUndefined(e["Content-Type"])) {
|
||
e["Content-Type"] = t;
|
||
}
|
||
}
|
||
function getDefaultAdapter() {
|
||
var e;
|
||
if (typeof XMLHttpRequest !== "undefined") {
|
||
e = r(3454);
|
||
} else if (
|
||
typeof process !== "undefined" &&
|
||
Object.prototype.toString.call(process) ===
|
||
"[object process]"
|
||
) {
|
||
e = r(8104);
|
||
}
|
||
return e;
|
||
}
|
||
function stringifySafely(e, t, r) {
|
||
if (n.isString(e)) {
|
||
try {
|
||
(t || JSON.parse)(e);
|
||
return n.trim(e);
|
||
} catch (e) {
|
||
if (e.name !== "SyntaxError") {
|
||
throw e;
|
||
}
|
||
}
|
||
}
|
||
return (r || JSON.stringify)(e);
|
||
}
|
||
var o = {
|
||
transitional: {
|
||
silentJSONParsing: true,
|
||
forcedJSONParsing: true,
|
||
clarifyTimeoutError: false,
|
||
},
|
||
adapter: getDefaultAdapter(),
|
||
transformRequest: [
|
||
function transformRequest(e, t) {
|
||
s(t, "Accept");
|
||
s(t, "Content-Type");
|
||
if (
|
||
n.isFormData(e) ||
|
||
n.isArrayBuffer(e) ||
|
||
n.isBuffer(e) ||
|
||
n.isStream(e) ||
|
||
n.isFile(e) ||
|
||
n.isBlob(e)
|
||
) {
|
||
return e;
|
||
}
|
||
if (n.isArrayBufferView(e)) {
|
||
return e.buffer;
|
||
}
|
||
if (n.isURLSearchParams(e)) {
|
||
setContentTypeIfUnset(
|
||
t,
|
||
"application/x-www-form-urlencoded;charset=utf-8"
|
||
);
|
||
return e.toString();
|
||
}
|
||
if (
|
||
n.isObject(e) ||
|
||
(t && t["Content-Type"] === "application/json")
|
||
) {
|
||
setContentTypeIfUnset(t, "application/json");
|
||
return stringifySafely(e);
|
||
}
|
||
return e;
|
||
},
|
||
],
|
||
transformResponse: [
|
||
function transformResponse(e) {
|
||
var t = this.transitional;
|
||
var r = t && t.silentJSONParsing;
|
||
var s = t && t.forcedJSONParsing;
|
||
var i = !r && this.responseType === "json";
|
||
if (i || (s && n.isString(e) && e.length)) {
|
||
try {
|
||
return JSON.parse(e);
|
||
} catch (e) {
|
||
if (i) {
|
||
if (e.name === "SyntaxError") {
|
||
throw a(e, this, "E_JSON_PARSE");
|
||
}
|
||
throw e;
|
||
}
|
||
}
|
||
}
|
||
return e;
|
||
},
|
||
],
|
||
timeout: 0,
|
||
xsrfCookieName: "XSRF-TOKEN",
|
||
xsrfHeaderName: "X-XSRF-TOKEN",
|
||
maxContentLength: -1,
|
||
maxBodyLength: -1,
|
||
validateStatus: function validateStatus(e) {
|
||
return e >= 200 && e < 300;
|
||
},
|
||
};
|
||
o.headers = {
|
||
common: { Accept: "application/json, text/plain, */*" },
|
||
};
|
||
n.forEach(
|
||
["delete", "get", "head"],
|
||
function forEachMethodNoData(e) {
|
||
o.headers[e] = {};
|
||
}
|
||
);
|
||
n.forEach(
|
||
["post", "put", "patch"],
|
||
function forEachMethodWithData(e) {
|
||
o.headers[e] = n.merge(i);
|
||
}
|
||
);
|
||
e.exports = o;
|
||
},
|
||
7065: e => {
|
||
"use strict";
|
||
e.exports = function bind(e, t) {
|
||
return function wrap() {
|
||
var r = new Array(arguments.length);
|
||
for (var n = 0; n < r.length; n++) {
|
||
r[n] = arguments[n];
|
||
}
|
||
return e.apply(t, r);
|
||
};
|
||
};
|
||
},
|
||
646: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
function encode(e) {
|
||
return encodeURIComponent(e)
|
||
.replace(/%3A/gi, ":")
|
||
.replace(/%24/g, "$")
|
||
.replace(/%2C/gi, ",")
|
||
.replace(/%20/g, "+")
|
||
.replace(/%5B/gi, "[")
|
||
.replace(/%5D/gi, "]");
|
||
}
|
||
e.exports = function buildURL(e, t, r) {
|
||
if (!t) {
|
||
return e;
|
||
}
|
||
var s;
|
||
if (r) {
|
||
s = r(t);
|
||
} else if (n.isURLSearchParams(t)) {
|
||
s = t.toString();
|
||
} else {
|
||
var a = [];
|
||
n.forEach(t, function serialize(e, t) {
|
||
if (e === null || typeof e === "undefined") {
|
||
return;
|
||
}
|
||
if (n.isArray(e)) {
|
||
t = t + "[]";
|
||
} else {
|
||
e = [e];
|
||
}
|
||
n.forEach(e, function parseValue(e) {
|
||
if (n.isDate(e)) {
|
||
e = e.toISOString();
|
||
} else if (n.isObject(e)) {
|
||
e = JSON.stringify(e);
|
||
}
|
||
a.push(encode(t) + "=" + encode(e));
|
||
});
|
||
});
|
||
s = a.join("&");
|
||
}
|
||
if (s) {
|
||
var i = e.indexOf("#");
|
||
if (i !== -1) {
|
||
e = e.slice(0, i);
|
||
}
|
||
e += (e.indexOf("?") === -1 ? "?" : "&") + s;
|
||
}
|
||
return e;
|
||
};
|
||
},
|
||
7189: e => {
|
||
"use strict";
|
||
e.exports = function combineURLs(e, t) {
|
||
return t
|
||
? e.replace(/\/+$/, "") + "/" + t.replace(/^\/+/, "")
|
||
: e;
|
||
};
|
||
},
|
||
1545: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
e.exports = n.isStandardBrowserEnv()
|
||
? (function standardBrowserEnv() {
|
||
return {
|
||
write: function write(e, t, r, s, a, i) {
|
||
var o = [];
|
||
o.push(e + "=" + encodeURIComponent(t));
|
||
if (n.isNumber(r)) {
|
||
o.push(
|
||
"expires=" + new Date(r).toGMTString()
|
||
);
|
||
}
|
||
if (n.isString(s)) {
|
||
o.push("path=" + s);
|
||
}
|
||
if (n.isString(a)) {
|
||
o.push("domain=" + a);
|
||
}
|
||
if (i === true) {
|
||
o.push("secure");
|
||
}
|
||
document.cookie = o.join("; ");
|
||
},
|
||
read: function read(e) {
|
||
var t = document.cookie.match(
|
||
new RegExp("(^|;\\s*)(" + e + ")=([^;]*)")
|
||
);
|
||
return t ? decodeURIComponent(t[3]) : null;
|
||
},
|
||
remove: function remove(e) {
|
||
this.write(e, "", Date.now() - 864e5);
|
||
},
|
||
};
|
||
})()
|
||
: (function nonStandardBrowserEnv() {
|
||
return {
|
||
write: function write() {},
|
||
read: function read() {
|
||
return null;
|
||
},
|
||
remove: function remove() {},
|
||
};
|
||
})();
|
||
},
|
||
1301: e => {
|
||
"use strict";
|
||
e.exports = function isAbsoluteURL(e) {
|
||
return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(e);
|
||
};
|
||
},
|
||
650: e => {
|
||
"use strict";
|
||
e.exports = function isAxiosError(e) {
|
||
return typeof e === "object" && e.isAxiosError === true;
|
||
};
|
||
},
|
||
3608: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
e.exports = n.isStandardBrowserEnv()
|
||
? (function standardBrowserEnv() {
|
||
var e = /(msie|trident)/i.test(navigator.userAgent);
|
||
var t = document.createElement("a");
|
||
var r;
|
||
function resolveURL(r) {
|
||
var n = r;
|
||
if (e) {
|
||
t.setAttribute("href", n);
|
||
n = t.href;
|
||
}
|
||
t.setAttribute("href", n);
|
||
return {
|
||
href: t.href,
|
||
protocol: t.protocol
|
||
? t.protocol.replace(/:$/, "")
|
||
: "",
|
||
host: t.host,
|
||
search: t.search
|
||
? t.search.replace(/^\?/, "")
|
||
: "",
|
||
hash: t.hash ? t.hash.replace(/^#/, "") : "",
|
||
hostname: t.hostname,
|
||
port: t.port,
|
||
pathname:
|
||
t.pathname.charAt(0) === "/"
|
||
? t.pathname
|
||
: "/" + t.pathname,
|
||
};
|
||
}
|
||
r = resolveURL(window.location.href);
|
||
return function isURLSameOrigin(e) {
|
||
var t = n.isString(e) ? resolveURL(e) : e;
|
||
return t.protocol === r.protocol && t.host === r.host;
|
||
};
|
||
})()
|
||
: (function nonStandardBrowserEnv() {
|
||
return function isURLSameOrigin() {
|
||
return true;
|
||
};
|
||
})();
|
||
},
|
||
6240: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
e.exports = function normalizeHeaderName(e, t) {
|
||
n.forEach(e, function processHeader(r, n) {
|
||
if (n !== t && n.toUpperCase() === t.toUpperCase()) {
|
||
e[t] = r;
|
||
delete e[n];
|
||
}
|
||
});
|
||
};
|
||
},
|
||
6455: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(328);
|
||
var s = [
|
||
"age",
|
||
"authorization",
|
||
"content-length",
|
||
"content-type",
|
||
"etag",
|
||
"expires",
|
||
"from",
|
||
"host",
|
||
"if-modified-since",
|
||
"if-unmodified-since",
|
||
"last-modified",
|
||
"location",
|
||
"max-forwards",
|
||
"proxy-authorization",
|
||
"referer",
|
||
"retry-after",
|
||
"user-agent",
|
||
];
|
||
e.exports = function parseHeaders(e) {
|
||
var t = {};
|
||
var r;
|
||
var a;
|
||
var i;
|
||
if (!e) {
|
||
return t;
|
||
}
|
||
n.forEach(e.split("\n"), function parser(e) {
|
||
i = e.indexOf(":");
|
||
r = n.trim(e.substr(0, i)).toLowerCase();
|
||
a = n.trim(e.substr(i + 1));
|
||
if (r) {
|
||
if (t[r] && s.indexOf(r) >= 0) {
|
||
return;
|
||
}
|
||
if (r === "set-cookie") {
|
||
t[r] = (t[r] ? t[r] : []).concat([a]);
|
||
} else {
|
||
t[r] = t[r] ? t[r] + ", " + a : a;
|
||
}
|
||
}
|
||
});
|
||
return t;
|
||
};
|
||
},
|
||
4850: e => {
|
||
"use strict";
|
||
e.exports = function spread(e) {
|
||
return function wrap(t) {
|
||
return e.apply(null, t);
|
||
};
|
||
};
|
||
},
|
||
1632: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(696);
|
||
var s = {};
|
||
[
|
||
"object",
|
||
"boolean",
|
||
"number",
|
||
"function",
|
||
"string",
|
||
"symbol",
|
||
].forEach(function (e, t) {
|
||
s[e] = function validator(r) {
|
||
return typeof r === e || "a" + (t < 1 ? "n " : " ") + e;
|
||
};
|
||
});
|
||
var a = {};
|
||
var i = n.version.split(".");
|
||
function isOlderVersion(e, t) {
|
||
var r = t ? t.split(".") : i;
|
||
var n = e.split(".");
|
||
for (var s = 0; s < 3; s++) {
|
||
if (r[s] > n[s]) {
|
||
return true;
|
||
} else if (r[s] < n[s]) {
|
||
return false;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
s.transitional = function transitional(e, t, r) {
|
||
var s = t && isOlderVersion(t);
|
||
function formatMessage(e, t) {
|
||
return (
|
||
"[Axios v" +
|
||
n.version +
|
||
"] Transitional option '" +
|
||
e +
|
||
"'" +
|
||
t +
|
||
(r ? ". " + r : "")
|
||
);
|
||
}
|
||
return function (r, n, i) {
|
||
if (e === false) {
|
||
throw new Error(
|
||
formatMessage(n, " has been removed in " + t)
|
||
);
|
||
}
|
||
if (s && !a[n]) {
|
||
a[n] = true;
|
||
console.warn(
|
||
formatMessage(
|
||
n,
|
||
" has been deprecated since v" +
|
||
t +
|
||
" and will be removed in the near future"
|
||
)
|
||
);
|
||
}
|
||
return e ? e(r, n, i) : true;
|
||
};
|
||
};
|
||
function assertOptions(e, t, r) {
|
||
if (typeof e !== "object") {
|
||
throw new TypeError("options must be an object");
|
||
}
|
||
var n = Object.keys(e);
|
||
var s = n.length;
|
||
while (s-- > 0) {
|
||
var a = n[s];
|
||
var i = t[a];
|
||
if (i) {
|
||
var o = e[a];
|
||
var u = o === undefined || i(o, a, e);
|
||
if (u !== true) {
|
||
throw new TypeError(
|
||
"option " + a + " must be " + u
|
||
);
|
||
}
|
||
continue;
|
||
}
|
||
if (r !== true) {
|
||
throw Error("Unknown option " + a);
|
||
}
|
||
}
|
||
}
|
||
e.exports = {
|
||
isOlderVersion: isOlderVersion,
|
||
assertOptions: assertOptions,
|
||
validators: s,
|
||
};
|
||
},
|
||
328: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(7065);
|
||
var s = Object.prototype.toString;
|
||
function isArray(e) {
|
||
return s.call(e) === "[object Array]";
|
||
}
|
||
function isUndefined(e) {
|
||
return typeof e === "undefined";
|
||
}
|
||
function isBuffer(e) {
|
||
return (
|
||
e !== null &&
|
||
!isUndefined(e) &&
|
||
e.constructor !== null &&
|
||
!isUndefined(e.constructor) &&
|
||
typeof e.constructor.isBuffer === "function" &&
|
||
e.constructor.isBuffer(e)
|
||
);
|
||
}
|
||
function isArrayBuffer(e) {
|
||
return s.call(e) === "[object ArrayBuffer]";
|
||
}
|
||
function isFormData(e) {
|
||
return typeof FormData !== "undefined" && e instanceof FormData;
|
||
}
|
||
function isArrayBufferView(e) {
|
||
var t;
|
||
if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
|
||
t = ArrayBuffer.isView(e);
|
||
} else {
|
||
t = e && e.buffer && e.buffer instanceof ArrayBuffer;
|
||
}
|
||
return t;
|
||
}
|
||
function isString(e) {
|
||
return typeof e === "string";
|
||
}
|
||
function isNumber(e) {
|
||
return typeof e === "number";
|
||
}
|
||
function isObject(e) {
|
||
return e !== null && typeof e === "object";
|
||
}
|
||
function isPlainObject(e) {
|
||
if (s.call(e) !== "[object Object]") {
|
||
return false;
|
||
}
|
||
var t = Object.getPrototypeOf(e);
|
||
return t === null || t === Object.prototype;
|
||
}
|
||
function isDate(e) {
|
||
return s.call(e) === "[object Date]";
|
||
}
|
||
function isFile(e) {
|
||
return s.call(e) === "[object File]";
|
||
}
|
||
function isBlob(e) {
|
||
return s.call(e) === "[object Blob]";
|
||
}
|
||
function isFunction(e) {
|
||
return s.call(e) === "[object Function]";
|
||
}
|
||
function isStream(e) {
|
||
return isObject(e) && isFunction(e.pipe);
|
||
}
|
||
function isURLSearchParams(e) {
|
||
return (
|
||
typeof URLSearchParams !== "undefined" &&
|
||
e instanceof URLSearchParams
|
||
);
|
||
}
|
||
function trim(e) {
|
||
return e.trim ? e.trim() : e.replace(/^\s+|\s+$/g, "");
|
||
}
|
||
function isStandardBrowserEnv() {
|
||
if (
|
||
typeof navigator !== "undefined" &&
|
||
(navigator.product === "ReactNative" ||
|
||
navigator.product === "NativeScript" ||
|
||
navigator.product === "NS")
|
||
) {
|
||
return false;
|
||
}
|
||
return (
|
||
typeof window !== "undefined" &&
|
||
typeof document !== "undefined"
|
||
);
|
||
}
|
||
function forEach(e, t) {
|
||
if (e === null || typeof e === "undefined") {
|
||
return;
|
||
}
|
||
if (typeof e !== "object") {
|
||
e = [e];
|
||
}
|
||
if (isArray(e)) {
|
||
for (var r = 0, n = e.length; r < n; r++) {
|
||
t.call(null, e[r], r, e);
|
||
}
|
||
} else {
|
||
for (var s in e) {
|
||
if (Object.prototype.hasOwnProperty.call(e, s)) {
|
||
t.call(null, e[s], s, e);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function merge() {
|
||
var e = {};
|
||
function assignValue(t, r) {
|
||
if (isPlainObject(e[r]) && isPlainObject(t)) {
|
||
e[r] = merge(e[r], t);
|
||
} else if (isPlainObject(t)) {
|
||
e[r] = merge({}, t);
|
||
} else if (isArray(t)) {
|
||
e[r] = t.slice();
|
||
} else {
|
||
e[r] = t;
|
||
}
|
||
}
|
||
for (var t = 0, r = arguments.length; t < r; t++) {
|
||
forEach(arguments[t], assignValue);
|
||
}
|
||
return e;
|
||
}
|
||
function extend(e, t, r) {
|
||
forEach(t, function assignValue(t, s) {
|
||
if (r && typeof t === "function") {
|
||
e[s] = n(t, r);
|
||
} else {
|
||
e[s] = t;
|
||
}
|
||
});
|
||
return e;
|
||
}
|
||
function stripBOM(e) {
|
||
if (e.charCodeAt(0) === 65279) {
|
||
e = e.slice(1);
|
||
}
|
||
return e;
|
||
}
|
||
e.exports = {
|
||
isArray: isArray,
|
||
isArrayBuffer: isArrayBuffer,
|
||
isBuffer: isBuffer,
|
||
isFormData: isFormData,
|
||
isArrayBufferView: isArrayBufferView,
|
||
isString: isString,
|
||
isNumber: isNumber,
|
||
isObject: isObject,
|
||
isPlainObject: isPlainObject,
|
||
isUndefined: isUndefined,
|
||
isDate: isDate,
|
||
isFile: isFile,
|
||
isBlob: isBlob,
|
||
isFunction: isFunction,
|
||
isStream: isStream,
|
||
isURLSearchParams: isURLSearchParams,
|
||
isStandardBrowserEnv: isStandardBrowserEnv,
|
||
forEach: forEach,
|
||
merge: merge,
|
||
extend: extend,
|
||
trim: trim,
|
||
stripBOM: stripBOM,
|
||
};
|
||
},
|
||
8222: (e, t, r) => {
|
||
"use strict";
|
||
function _typeof(e) {
|
||
if (
|
||
typeof Symbol === "function" &&
|
||
typeof Symbol.iterator === "symbol"
|
||
) {
|
||
_typeof = function _typeof(e) {
|
||
return typeof e;
|
||
};
|
||
} else {
|
||
_typeof = function _typeof(e) {
|
||
return e &&
|
||
typeof Symbol === "function" &&
|
||
e.constructor === Symbol &&
|
||
e !== Symbol.prototype
|
||
? "symbol"
|
||
: typeof e;
|
||
};
|
||
}
|
||
return _typeof(e);
|
||
}
|
||
t.log = log;
|
||
t.formatArgs = formatArgs;
|
||
t.save = save;
|
||
t.load = load;
|
||
t.useColors = useColors;
|
||
t.storage = localstorage();
|
||
t.colors = [
|
||
"#0000CC",
|
||
"#0000FF",
|
||
"#0033CC",
|
||
"#0033FF",
|
||
"#0066CC",
|
||
"#0066FF",
|
||
"#0099CC",
|
||
"#0099FF",
|
||
"#00CC00",
|
||
"#00CC33",
|
||
"#00CC66",
|
||
"#00CC99",
|
||
"#00CCCC",
|
||
"#00CCFF",
|
||
"#3300CC",
|
||
"#3300FF",
|
||
"#3333CC",
|
||
"#3333FF",
|
||
"#3366CC",
|
||
"#3366FF",
|
||
"#3399CC",
|
||
"#3399FF",
|
||
"#33CC00",
|
||
"#33CC33",
|
||
"#33CC66",
|
||
"#33CC99",
|
||
"#33CCCC",
|
||
"#33CCFF",
|
||
"#6600CC",
|
||
"#6600FF",
|
||
"#6633CC",
|
||
"#6633FF",
|
||
"#66CC00",
|
||
"#66CC33",
|
||
"#9900CC",
|
||
"#9900FF",
|
||
"#9933CC",
|
||
"#9933FF",
|
||
"#99CC00",
|
||
"#99CC33",
|
||
"#CC0000",
|
||
"#CC0033",
|
||
"#CC0066",
|
||
"#CC0099",
|
||
"#CC00CC",
|
||
"#CC00FF",
|
||
"#CC3300",
|
||
"#CC3333",
|
||
"#CC3366",
|
||
"#CC3399",
|
||
"#CC33CC",
|
||
"#CC33FF",
|
||
"#CC6600",
|
||
"#CC6633",
|
||
"#CC9900",
|
||
"#CC9933",
|
||
"#CCCC00",
|
||
"#CCCC33",
|
||
"#FF0000",
|
||
"#FF0033",
|
||
"#FF0066",
|
||
"#FF0099",
|
||
"#FF00CC",
|
||
"#FF00FF",
|
||
"#FF3300",
|
||
"#FF3333",
|
||
"#FF3366",
|
||
"#FF3399",
|
||
"#FF33CC",
|
||
"#FF33FF",
|
||
"#FF6600",
|
||
"#FF6633",
|
||
"#FF9900",
|
||
"#FF9933",
|
||
"#FFCC00",
|
||
"#FFCC33",
|
||
];
|
||
function useColors() {
|
||
if (
|
||
typeof window !== "undefined" &&
|
||
window.process &&
|
||
(window.process.type === "renderer" ||
|
||
window.process.__nwjs)
|
||
) {
|
||
return true;
|
||
}
|
||
if (
|
||
typeof navigator !== "undefined" &&
|
||
navigator.userAgent &&
|
||
navigator.userAgent
|
||
.toLowerCase()
|
||
.match(/(edge|trident)\/(\d+)/)
|
||
) {
|
||
return false;
|
||
}
|
||
return (
|
||
(typeof document !== "undefined" &&
|
||
document.documentElement &&
|
||
document.documentElement.style &&
|
||
document.documentElement.style.WebkitAppearance) ||
|
||
(typeof window !== "undefined" &&
|
||
window.console &&
|
||
(window.console.firebug ||
|
||
(window.console.exception &&
|
||
window.console.table))) ||
|
||
(typeof navigator !== "undefined" &&
|
||
navigator.userAgent &&
|
||
navigator.userAgent
|
||
.toLowerCase()
|
||
.match(/firefox\/(\d+)/) &&
|
||
parseInt(RegExp.$1, 10) >= 31) ||
|
||
(typeof navigator !== "undefined" &&
|
||
navigator.userAgent &&
|
||
navigator.userAgent
|
||
.toLowerCase()
|
||
.match(/applewebkit\/(\d+)/))
|
||
);
|
||
}
|
||
function formatArgs(t) {
|
||
t[0] =
|
||
(this.useColors ? "%c" : "") +
|
||
this.namespace +
|
||
(this.useColors ? " %c" : " ") +
|
||
t[0] +
|
||
(this.useColors ? "%c " : " ") +
|
||
"+" +
|
||
e.exports.humanize(this.diff);
|
||
if (!this.useColors) {
|
||
return;
|
||
}
|
||
var r = "color: " + this.color;
|
||
t.splice(1, 0, r, "color: inherit");
|
||
var n = 0;
|
||
var s = 0;
|
||
t[0].replace(/%[a-zA-Z%]/g, function (e) {
|
||
if (e === "%%") {
|
||
return;
|
||
}
|
||
n++;
|
||
if (e === "%c") {
|
||
s = n;
|
||
}
|
||
});
|
||
t.splice(s, 0, r);
|
||
}
|
||
function log() {
|
||
var e;
|
||
return (
|
||
(typeof console === "undefined"
|
||
? "undefined"
|
||
: _typeof(console)) === "object" &&
|
||
console.log &&
|
||
(e = console).log.apply(e, arguments)
|
||
);
|
||
}
|
||
function save(e) {
|
||
try {
|
||
if (e) {
|
||
t.storage.setItem("debug", e);
|
||
} else {
|
||
t.storage.removeItem("debug");
|
||
}
|
||
} catch (e) {}
|
||
}
|
||
function load() {
|
||
var e;
|
||
try {
|
||
e = t.storage.getItem("debug");
|
||
} catch (e) {}
|
||
if (!e && typeof process !== "undefined" && "env" in process) {
|
||
e = process.env.DEBUG;
|
||
}
|
||
return e;
|
||
}
|
||
function localstorage() {
|
||
try {
|
||
return localStorage;
|
||
} catch (e) {}
|
||
}
|
||
e.exports = r(6243)(t);
|
||
var n = e.exports.formatters;
|
||
n.j = function (e) {
|
||
try {
|
||
return JSON.stringify(e);
|
||
} catch (e) {
|
||
return "[UnexpectedJSONParseError]: " + e.message;
|
||
}
|
||
};
|
||
},
|
||
6243: (e, t, r) => {
|
||
"use strict";
|
||
function setup(e) {
|
||
createDebug.debug = createDebug;
|
||
createDebug.default = createDebug;
|
||
createDebug.coerce = coerce;
|
||
createDebug.disable = disable;
|
||
createDebug.enable = enable;
|
||
createDebug.enabled = enabled;
|
||
createDebug.humanize = r(900);
|
||
Object.keys(e).forEach(function (t) {
|
||
createDebug[t] = e[t];
|
||
});
|
||
createDebug.instances = [];
|
||
createDebug.names = [];
|
||
createDebug.skips = [];
|
||
createDebug.formatters = {};
|
||
function selectColor(e) {
|
||
var t = 0;
|
||
for (var r = 0; r < e.length; r++) {
|
||
t = (t << 5) - t + e.charCodeAt(r);
|
||
t |= 0;
|
||
}
|
||
return createDebug.colors[
|
||
Math.abs(t) % createDebug.colors.length
|
||
];
|
||
}
|
||
createDebug.selectColor = selectColor;
|
||
function createDebug(e) {
|
||
var t;
|
||
function debug() {
|
||
if (!debug.enabled) {
|
||
return;
|
||
}
|
||
for (
|
||
var e = arguments.length, r = new Array(e), n = 0;
|
||
n < e;
|
||
n++
|
||
) {
|
||
r[n] = arguments[n];
|
||
}
|
||
var s = debug;
|
||
var a = Number(new Date());
|
||
var i = a - (t || a);
|
||
s.diff = i;
|
||
s.prev = t;
|
||
s.curr = a;
|
||
t = a;
|
||
r[0] = createDebug.coerce(r[0]);
|
||
if (typeof r[0] !== "string") {
|
||
r.unshift("%O");
|
||
}
|
||
var o = 0;
|
||
r[0] = r[0].replace(/%([a-zA-Z%])/g, function (e, t) {
|
||
if (e === "%%") {
|
||
return e;
|
||
}
|
||
o++;
|
||
var n = createDebug.formatters[t];
|
||
if (typeof n === "function") {
|
||
var a = r[o];
|
||
e = n.call(s, a);
|
||
r.splice(o, 1);
|
||
o--;
|
||
}
|
||
return e;
|
||
});
|
||
createDebug.formatArgs.call(s, r);
|
||
var u = s.log || createDebug.log;
|
||
u.apply(s, r);
|
||
}
|
||
debug.namespace = e;
|
||
debug.enabled = createDebug.enabled(e);
|
||
debug.useColors = createDebug.useColors();
|
||
debug.color = selectColor(e);
|
||
debug.destroy = destroy;
|
||
debug.extend = extend;
|
||
if (typeof createDebug.init === "function") {
|
||
createDebug.init(debug);
|
||
}
|
||
createDebug.instances.push(debug);
|
||
return debug;
|
||
}
|
||
function destroy() {
|
||
var e = createDebug.instances.indexOf(this);
|
||
if (e !== -1) {
|
||
createDebug.instances.splice(e, 1);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
function extend(e, t) {
|
||
return createDebug(
|
||
this.namespace +
|
||
(typeof t === "undefined" ? ":" : t) +
|
||
e
|
||
);
|
||
}
|
||
function enable(e) {
|
||
createDebug.save(e);
|
||
createDebug.names = [];
|
||
createDebug.skips = [];
|
||
var t;
|
||
var r = (typeof e === "string" ? e : "").split(/[\s,]+/);
|
||
var n = r.length;
|
||
for (t = 0; t < n; t++) {
|
||
if (!r[t]) {
|
||
continue;
|
||
}
|
||
e = r[t].replace(/\*/g, ".*?");
|
||
if (e[0] === "-") {
|
||
createDebug.skips.push(
|
||
new RegExp("^" + e.substr(1) + "$")
|
||
);
|
||
} else {
|
||
createDebug.names.push(new RegExp("^" + e + "$"));
|
||
}
|
||
}
|
||
for (t = 0; t < createDebug.instances.length; t++) {
|
||
var s = createDebug.instances[t];
|
||
s.enabled = createDebug.enabled(s.namespace);
|
||
}
|
||
}
|
||
function disable() {
|
||
createDebug.enable("");
|
||
}
|
||
function enabled(e) {
|
||
if (e[e.length - 1] === "*") {
|
||
return true;
|
||
}
|
||
var t;
|
||
var r;
|
||
for (t = 0, r = createDebug.skips.length; t < r; t++) {
|
||
if (createDebug.skips[t].test(e)) {
|
||
return false;
|
||
}
|
||
}
|
||
for (t = 0, r = createDebug.names.length; t < r; t++) {
|
||
if (createDebug.names[t].test(e)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
function coerce(e) {
|
||
if (e instanceof Error) {
|
||
return e.stack || e.message;
|
||
}
|
||
return e;
|
||
}
|
||
createDebug.enable(createDebug.load());
|
||
return createDebug;
|
||
}
|
||
e.exports = setup;
|
||
},
|
||
8237: (e, t, r) => {
|
||
"use strict";
|
||
if (
|
||
typeof process === "undefined" ||
|
||
process.type === "renderer" ||
|
||
process.browser === true ||
|
||
process.__nwjs
|
||
) {
|
||
e.exports = r(8222);
|
||
} else {
|
||
e.exports = r(4874);
|
||
}
|
||
},
|
||
4874: (e, t, r) => {
|
||
"use strict";
|
||
var n = r(3867);
|
||
var s = r(1669);
|
||
t.init = init;
|
||
t.log = log;
|
||
t.formatArgs = formatArgs;
|
||
t.save = save;
|
||
t.load = load;
|
||
t.useColors = useColors;
|
||
t.colors = [6, 2, 3, 4, 5, 1];
|
||
try {
|
||
var a = r(9318);
|
||
if (a && (a.stderr || a).level >= 2) {
|
||
t.colors = [
|
||
20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45,
|
||
56, 57, 62, 63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81,
|
||
92, 93, 98, 99, 112, 113, 128, 129, 134, 135, 148, 149,
|
||
160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
|
||
171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199,
|
||
200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 214,
|
||
215, 220, 221,
|
||
];
|
||
}
|
||
} catch (e) {}
|
||
t.inspectOpts = Object.keys(process.env)
|
||
.filter(function (e) {
|
||
return /^debug_/i.test(e);
|
||
})
|
||
.reduce(function (e, t) {
|
||
var r = t
|
||
.substring(6)
|
||
.toLowerCase()
|
||
.replace(/_([a-z])/g, function (e, t) {
|
||
return t.toUpperCase();
|
||
});
|
||
var n = process.env[t];
|
||
if (/^(yes|on|true|enabled)$/i.test(n)) {
|
||
n = true;
|
||
} else if (/^(no|off|false|disabled)$/i.test(n)) {
|
||
n = false;
|
||
} else if (n === "null") {
|
||
n = null;
|
||
} else {
|
||
n = Number(n);
|
||
}
|
||
e[r] = n;
|
||
return e;
|
||
}, {});
|
||
function useColors() {
|
||
return "colors" in t.inspectOpts
|
||
? Boolean(t.inspectOpts.colors)
|
||
: n.isatty(process.stderr.fd);
|
||
}
|
||
function formatArgs(t) {
|
||
var r = this.namespace,
|
||
n = this.useColors;
|
||
if (n) {
|
||
var s = this.color;
|
||
var a = "[3" + (s < 8 ? s : "8;5;" + s);
|
||
var i = " ".concat(a, ";1m").concat(r, " [0m");
|
||
t[0] = i + t[0].split("\n").join("\n" + i);
|
||
t.push(a + "m+" + e.exports.humanize(this.diff) + "[0m");
|
||
} else {
|
||
t[0] = getDate() + r + " " + t[0];
|
||
}
|
||
}
|
||
function getDate() {
|
||
if (t.inspectOpts.hideDate) {
|
||
return "";
|
||
}
|
||
return new Date().toISOString() + " ";
|
||
}
|
||
function log() {
|
||
return process.stderr.write(
|
||
s.format.apply(s, arguments) + "\n"
|
||
);
|
||
}
|
||
function save(e) {
|
||
if (e) {
|
||
process.env.DEBUG = e;
|
||
} else {
|
||
delete process.env.DEBUG;
|
||
}
|
||
}
|
||
function load() {
|
||
return process.env.DEBUG;
|
||
}
|
||
function init(e) {
|
||
e.inspectOpts = {};
|
||
var r = Object.keys(t.inspectOpts);
|
||
for (var n = 0; n < r.length; n++) {
|
||
e.inspectOpts[r[n]] = t.inspectOpts[r[n]];
|
||
}
|
||
}
|
||
e.exports = r(6243)(t);
|
||
var i = e.exports.formatters;
|
||
i.o = function (e) {
|
||
this.inspectOpts.colors = this.useColors;
|
||
return s
|
||
.inspect(e, this.inspectOpts)
|
||
.split("\n")
|
||
.map(function (e) {
|
||
return e.trim();
|
||
})
|
||
.join(" ");
|
||
};
|
||
i.O = function (e) {
|
||
this.inspectOpts.colors = this.useColors;
|
||
return s.inspect(e, this.inspectOpts);
|
||
};
|
||
},
|
||
1133: (e, t, r) => {
|
||
var n;
|
||
e.exports = function () {
|
||
if (!n) {
|
||
try {
|
||
n = r(8237)("follow-redirects");
|
||
} catch (e) {}
|
||
if (typeof n !== "function") {
|
||
n = function () {};
|
||
}
|
||
}
|
||
n.apply(null, arguments);
|
||
};
|
||
},
|
||
7707: (e, t, r) => {
|
||
var n = r(8835);
|
||
var s = n.URL;
|
||
var a = r(8605);
|
||
var i = r(7211);
|
||
var o = r(2413).Writable;
|
||
var u = r(2357);
|
||
var l = r(1133);
|
||
var c = false;
|
||
try {
|
||
u(new s());
|
||
} catch (e) {
|
||
c = e.code === "ERR_INVALID_URL";
|
||
}
|
||
var f = [
|
||
"auth",
|
||
"host",
|
||
"hostname",
|
||
"href",
|
||
"path",
|
||
"pathname",
|
||
"port",
|
||
"protocol",
|
||
"query",
|
||
"search",
|
||
"hash",
|
||
];
|
||
var d = [
|
||
"abort",
|
||
"aborted",
|
||
"connect",
|
||
"error",
|
||
"socket",
|
||
"timeout",
|
||
];
|
||
var h = Object.create(null);
|
||
d.forEach(function (e) {
|
||
h[e] = function (t, r, n) {
|
||
this._redirectable.emit(e, t, r, n);
|
||
};
|
||
});
|
||
var m = createErrorType(
|
||
"ERR_INVALID_URL",
|
||
"Invalid URL",
|
||
TypeError
|
||
);
|
||
var p = createErrorType(
|
||
"ERR_FR_REDIRECTION_FAILURE",
|
||
"Redirected request failed"
|
||
);
|
||
var g = createErrorType(
|
||
"ERR_FR_TOO_MANY_REDIRECTS",
|
||
"Maximum number of redirects exceeded",
|
||
p
|
||
);
|
||
var y = createErrorType(
|
||
"ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
|
||
"Request body larger than maxBodyLength limit"
|
||
);
|
||
var _ = createErrorType(
|
||
"ERR_STREAM_WRITE_AFTER_END",
|
||
"write after end"
|
||
);
|
||
var v = o.prototype.destroy || noop;
|
||
function RedirectableRequest(e, t) {
|
||
o.call(this);
|
||
this._sanitizeOptions(e);
|
||
this._options = e;
|
||
this._ended = false;
|
||
this._ending = false;
|
||
this._redirectCount = 0;
|
||
this._redirects = [];
|
||
this._requestBodyLength = 0;
|
||
this._requestBodyBuffers = [];
|
||
if (t) {
|
||
this.on("response", t);
|
||
}
|
||
var r = this;
|
||
this._onNativeResponse = function (e) {
|
||
try {
|
||
r._processResponse(e);
|
||
} catch (e) {
|
||
r.emit(
|
||
"error",
|
||
e instanceof p ? e : new p({ cause: e })
|
||
);
|
||
}
|
||
};
|
||
this._performRequest();
|
||
}
|
||
RedirectableRequest.prototype = Object.create(o.prototype);
|
||
RedirectableRequest.prototype.abort = function () {
|
||
destroyRequest(this._currentRequest);
|
||
this._currentRequest.abort();
|
||
this.emit("abort");
|
||
};
|
||
RedirectableRequest.prototype.destroy = function (e) {
|
||
destroyRequest(this._currentRequest, e);
|
||
v.call(this, e);
|
||
return this;
|
||
};
|
||
RedirectableRequest.prototype.write = function (e, t, r) {
|
||
if (this._ending) {
|
||
throw new _();
|
||
}
|
||
if (!isString(e) && !isBuffer(e)) {
|
||
throw new TypeError(
|
||
"data should be a string, Buffer or Uint8Array"
|
||
);
|
||
}
|
||
if (isFunction(t)) {
|
||
r = t;
|
||
t = null;
|
||
}
|
||
if (e.length === 0) {
|
||
if (r) {
|
||
r();
|
||
}
|
||
return;
|
||
}
|
||
if (
|
||
this._requestBodyLength + e.length <=
|
||
this._options.maxBodyLength
|
||
) {
|
||
this._requestBodyLength += e.length;
|
||
this._requestBodyBuffers.push({ data: e, encoding: t });
|
||
this._currentRequest.write(e, t, r);
|
||
} else {
|
||
this.emit("error", new y());
|
||
this.abort();
|
||
}
|
||
};
|
||
RedirectableRequest.prototype.end = function (e, t, r) {
|
||
if (isFunction(e)) {
|
||
r = e;
|
||
e = t = null;
|
||
} else if (isFunction(t)) {
|
||
r = t;
|
||
t = null;
|
||
}
|
||
if (!e) {
|
||
this._ended = this._ending = true;
|
||
this._currentRequest.end(null, null, r);
|
||
} else {
|
||
var n = this;
|
||
var s = this._currentRequest;
|
||
this.write(e, t, function () {
|
||
n._ended = true;
|
||
s.end(null, null, r);
|
||
});
|
||
this._ending = true;
|
||
}
|
||
};
|
||
RedirectableRequest.prototype.setHeader = function (e, t) {
|
||
this._options.headers[e] = t;
|
||
this._currentRequest.setHeader(e, t);
|
||
};
|
||
RedirectableRequest.prototype.removeHeader = function (e) {
|
||
delete this._options.headers[e];
|
||
this._currentRequest.removeHeader(e);
|
||
};
|
||
RedirectableRequest.prototype.setTimeout = function (e, t) {
|
||
var r = this;
|
||
function destroyOnTimeout(t) {
|
||
t.setTimeout(e);
|
||
t.removeListener("timeout", t.destroy);
|
||
t.addListener("timeout", t.destroy);
|
||
}
|
||
function startTimer(t) {
|
||
if (r._timeout) {
|
||
clearTimeout(r._timeout);
|
||
}
|
||
r._timeout = setTimeout(function () {
|
||
r.emit("timeout");
|
||
clearTimer();
|
||
}, e);
|
||
destroyOnTimeout(t);
|
||
}
|
||
function clearTimer() {
|
||
if (r._timeout) {
|
||
clearTimeout(r._timeout);
|
||
r._timeout = null;
|
||
}
|
||
r.removeListener("abort", clearTimer);
|
||
r.removeListener("error", clearTimer);
|
||
r.removeListener("response", clearTimer);
|
||
r.removeListener("close", clearTimer);
|
||
if (t) {
|
||
r.removeListener("timeout", t);
|
||
}
|
||
if (!r.socket) {
|
||
r._currentRequest.removeListener("socket", startTimer);
|
||
}
|
||
}
|
||
if (t) {
|
||
this.on("timeout", t);
|
||
}
|
||
if (this.socket) {
|
||
startTimer(this.socket);
|
||
} else {
|
||
this._currentRequest.once("socket", startTimer);
|
||
}
|
||
this.on("socket", destroyOnTimeout);
|
||
this.on("abort", clearTimer);
|
||
this.on("error", clearTimer);
|
||
this.on("response", clearTimer);
|
||
this.on("close", clearTimer);
|
||
return this;
|
||
};
|
||
[
|
||
"flushHeaders",
|
||
"getHeader",
|
||
"setNoDelay",
|
||
"setSocketKeepAlive",
|
||
].forEach(function (e) {
|
||
RedirectableRequest.prototype[e] = function (t, r) {
|
||
return this._currentRequest[e](t, r);
|
||
};
|
||
});
|
||
["aborted", "connection", "socket"].forEach(function (e) {
|
||
Object.defineProperty(RedirectableRequest.prototype, e, {
|
||
get: function () {
|
||
return this._currentRequest[e];
|
||
},
|
||
});
|
||
});
|
||
RedirectableRequest.prototype._sanitizeOptions = function (e) {
|
||
if (!e.headers) {
|
||
e.headers = {};
|
||
}
|
||
if (e.host) {
|
||
if (!e.hostname) {
|
||
e.hostname = e.host;
|
||
}
|
||
delete e.host;
|
||
}
|
||
if (!e.pathname && e.path) {
|
||
var t = e.path.indexOf("?");
|
||
if (t < 0) {
|
||
e.pathname = e.path;
|
||
} else {
|
||
e.pathname = e.path.substring(0, t);
|
||
e.search = e.path.substring(t);
|
||
}
|
||
}
|
||
};
|
||
RedirectableRequest.prototype._performRequest = function () {
|
||
var e = this._options.protocol;
|
||
var t = this._options.nativeProtocols[e];
|
||
if (!t) {
|
||
throw new TypeError("Unsupported protocol " + e);
|
||
}
|
||
if (this._options.agents) {
|
||
var r = e.slice(0, -1);
|
||
this._options.agent = this._options.agents[r];
|
||
}
|
||
var s = (this._currentRequest = t.request(
|
||
this._options,
|
||
this._onNativeResponse
|
||
));
|
||
s._redirectable = this;
|
||
for (var a of d) {
|
||
s.on(a, h[a]);
|
||
}
|
||
this._currentUrl = /^\//.test(this._options.path)
|
||
? n.format(this._options)
|
||
: this._options.path;
|
||
if (this._isRedirect) {
|
||
var i = 0;
|
||
var o = this;
|
||
var u = this._requestBodyBuffers;
|
||
(function writeNext(e) {
|
||
if (s === o._currentRequest) {
|
||
if (e) {
|
||
o.emit("error", e);
|
||
} else if (i < u.length) {
|
||
var t = u[i++];
|
||
if (!s.finished) {
|
||
s.write(t.data, t.encoding, writeNext);
|
||
}
|
||
} else if (o._ended) {
|
||
s.end();
|
||
}
|
||
}
|
||
})();
|
||
}
|
||
};
|
||
RedirectableRequest.prototype._processResponse = function (e) {
|
||
var t = e.statusCode;
|
||
if (this._options.trackRedirects) {
|
||
this._redirects.push({
|
||
url: this._currentUrl,
|
||
headers: e.headers,
|
||
statusCode: t,
|
||
});
|
||
}
|
||
var r = e.headers.location;
|
||
if (
|
||
!r ||
|
||
this._options.followRedirects === false ||
|
||
t < 300 ||
|
||
t >= 400
|
||
) {
|
||
e.responseUrl = this._currentUrl;
|
||
e.redirects = this._redirects;
|
||
this.emit("response", e);
|
||
this._requestBodyBuffers = [];
|
||
return;
|
||
}
|
||
destroyRequest(this._currentRequest);
|
||
e.destroy();
|
||
if (++this._redirectCount > this._options.maxRedirects) {
|
||
throw new g();
|
||
}
|
||
var s;
|
||
var a = this._options.beforeRedirect;
|
||
if (a) {
|
||
s = Object.assign(
|
||
{ Host: e.req.getHeader("host") },
|
||
this._options.headers
|
||
);
|
||
}
|
||
var i = this._options.method;
|
||
if (
|
||
((t === 301 || t === 302) &&
|
||
this._options.method === "POST") ||
|
||
(t === 303 && !/^(?:GET|HEAD)$/.test(this._options.method))
|
||
) {
|
||
this._options.method = "GET";
|
||
this._requestBodyBuffers = [];
|
||
removeMatchingHeaders(/^content-/i, this._options.headers);
|
||
}
|
||
var o = removeMatchingHeaders(/^host$/i, this._options.headers);
|
||
var u = parseUrl(this._currentUrl);
|
||
var c = o || u.host;
|
||
var f = /^\w+:/.test(r)
|
||
? this._currentUrl
|
||
: n.format(Object.assign(u, { host: c }));
|
||
var d = resolveUrl(r, f);
|
||
l("redirecting to", d.href);
|
||
this._isRedirect = true;
|
||
spreadUrlObject(d, this._options);
|
||
if (
|
||
(d.protocol !== u.protocol && d.protocol !== "https:") ||
|
||
(d.host !== c && !isSubdomain(d.host, c))
|
||
) {
|
||
removeMatchingHeaders(
|
||
/^(?:(?:proxy-)?authorization|cookie)$/i,
|
||
this._options.headers
|
||
);
|
||
}
|
||
if (isFunction(a)) {
|
||
var h = { headers: e.headers, statusCode: t };
|
||
var m = { url: f, method: i, headers: s };
|
||
a(this._options, h, m);
|
||
this._sanitizeOptions(this._options);
|
||
}
|
||
this._performRequest();
|
||
};
|
||
function wrap(e) {
|
||
var t = { maxRedirects: 21, maxBodyLength: 10 * 1024 * 1024 };
|
||
var r = {};
|
||
Object.keys(e).forEach(function (n) {
|
||
var s = n + ":";
|
||
var a = (r[s] = e[n]);
|
||
var i = (t[n] = Object.create(a));
|
||
function request(e, n, a) {
|
||
if (isURL(e)) {
|
||
e = spreadUrlObject(e);
|
||
} else if (isString(e)) {
|
||
e = spreadUrlObject(parseUrl(e));
|
||
} else {
|
||
a = n;
|
||
n = validateUrl(e);
|
||
e = { protocol: s };
|
||
}
|
||
if (isFunction(n)) {
|
||
a = n;
|
||
n = null;
|
||
}
|
||
n = Object.assign(
|
||
{
|
||
maxRedirects: t.maxRedirects,
|
||
maxBodyLength: t.maxBodyLength,
|
||
},
|
||
e,
|
||
n
|
||
);
|
||
n.nativeProtocols = r;
|
||
if (!isString(n.host) && !isString(n.hostname)) {
|
||
n.hostname = "::1";
|
||
}
|
||
u.equal(n.protocol, s, "protocol mismatch");
|
||
l("options", n);
|
||
return new RedirectableRequest(n, a);
|
||
}
|
||
function get(e, t, r) {
|
||
var n = i.request(e, t, r);
|
||
n.end();
|
||
return n;
|
||
}
|
||
Object.defineProperties(i, {
|
||
request: {
|
||
value: request,
|
||
configurable: true,
|
||
enumerable: true,
|
||
writable: true,
|
||
},
|
||
get: {
|
||
value: get,
|
||
configurable: true,
|
||
enumerable: true,
|
||
writable: true,
|
||
},
|
||
});
|
||
});
|
||
return t;
|
||
}
|
||
function noop() {}
|
||
function parseUrl(e) {
|
||
var t;
|
||
if (c) {
|
||
t = new s(e);
|
||
} else {
|
||
t = validateUrl(n.parse(e));
|
||
if (!isString(t.protocol)) {
|
||
throw new m({ input: e });
|
||
}
|
||
}
|
||
return t;
|
||
}
|
||
function resolveUrl(e, t) {
|
||
return c ? new s(e, t) : parseUrl(n.resolve(t, e));
|
||
}
|
||
function validateUrl(e) {
|
||
if (
|
||
/^\[/.test(e.hostname) &&
|
||
!/^\[[:0-9a-f]+\]$/i.test(e.hostname)
|
||
) {
|
||
throw new m({ input: e.href || e });
|
||
}
|
||
if (
|
||
/^\[/.test(e.host) &&
|
||
!/^\[[:0-9a-f]+\](:\d+)?$/i.test(e.host)
|
||
) {
|
||
throw new m({ input: e.href || e });
|
||
}
|
||
return e;
|
||
}
|
||
function spreadUrlObject(e, t) {
|
||
var r = t || {};
|
||
for (var n of f) {
|
||
r[n] = e[n];
|
||
}
|
||
if (r.hostname.startsWith("[")) {
|
||
r.hostname = r.hostname.slice(1, -1);
|
||
}
|
||
if (r.port !== "") {
|
||
r.port = Number(r.port);
|
||
}
|
||
r.path = r.search ? r.pathname + r.search : r.pathname;
|
||
return r;
|
||
}
|
||
function removeMatchingHeaders(e, t) {
|
||
var r;
|
||
for (var n in t) {
|
||
if (e.test(n)) {
|
||
r = t[n];
|
||
delete t[n];
|
||
}
|
||
}
|
||
return r === null || typeof r === "undefined"
|
||
? undefined
|
||
: String(r).trim();
|
||
}
|
||
function createErrorType(e, t, r) {
|
||
function CustomError(r) {
|
||
Error.captureStackTrace(this, this.constructor);
|
||
Object.assign(this, r || {});
|
||
this.code = e;
|
||
this.message = this.cause
|
||
? t + ": " + this.cause.message
|
||
: t;
|
||
}
|
||
CustomError.prototype = new (r || Error)();
|
||
Object.defineProperties(CustomError.prototype, {
|
||
constructor: { value: CustomError, enumerable: false },
|
||
name: { value: "Error [" + e + "]", enumerable: false },
|
||
});
|
||
return CustomError;
|
||
}
|
||
function destroyRequest(e, t) {
|
||
for (var r of d) {
|
||
e.removeListener(r, h[r]);
|
||
}
|
||
e.on("error", noop);
|
||
e.destroy(t);
|
||
}
|
||
function isSubdomain(e, t) {
|
||
u(isString(e) && isString(t));
|
||
var r = e.length - t.length - 1;
|
||
return r > 0 && e[r] === "." && e.endsWith(t);
|
||
}
|
||
function isString(e) {
|
||
return typeof e === "string" || e instanceof String;
|
||
}
|
||
function isFunction(e) {
|
||
return typeof e === "function";
|
||
}
|
||
function isBuffer(e) {
|
||
return typeof e === "object" && "length" in e;
|
||
}
|
||
function isURL(e) {
|
||
return s && e instanceof s;
|
||
}
|
||
e.exports = wrap({ http: a, https: i });
|
||
e.exports.wrap = wrap;
|
||
},
|
||
1621: e => {
|
||
"use strict";
|
||
e.exports = (e, t) => {
|
||
t = t || process.argv;
|
||
const r = e.startsWith("-") ? "" : e.length === 1 ? "-" : "--";
|
||
const n = t.indexOf(r + e);
|
||
const s = t.indexOf("--");
|
||
return n !== -1 && (s === -1 ? true : n < s);
|
||
};
|
||
},
|
||
9623: function (e, t, r) {
|
||
e = r.nmd(e);
|
||
//! moment.js
|
||
//! version : 2.30.1
|
||
//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
|
||
//! license : MIT
|
||
//! momentjs.com
|
||
(function (t, r) {
|
||
true ? (e.exports = r()) : 0;
|
||
})(this, function () {
|
||
"use strict";
|
||
var t;
|
||
function hooks() {
|
||
return t.apply(null, arguments);
|
||
}
|
||
function setHookCallback(e) {
|
||
t = e;
|
||
}
|
||
function isArray(e) {
|
||
return (
|
||
e instanceof Array ||
|
||
Object.prototype.toString.call(e) === "[object Array]"
|
||
);
|
||
}
|
||
function isObject(e) {
|
||
return (
|
||
e != null &&
|
||
Object.prototype.toString.call(e) === "[object Object]"
|
||
);
|
||
}
|
||
function hasOwnProp(e, t) {
|
||
return Object.prototype.hasOwnProperty.call(e, t);
|
||
}
|
||
function isObjectEmpty(e) {
|
||
if (Object.getOwnPropertyNames) {
|
||
return Object.getOwnPropertyNames(e).length === 0;
|
||
} else {
|
||
var t;
|
||
for (t in e) {
|
||
if (hasOwnProp(e, t)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
function isUndefined(e) {
|
||
return e === void 0;
|
||
}
|
||
function isNumber(e) {
|
||
return (
|
||
typeof e === "number" ||
|
||
Object.prototype.toString.call(e) === "[object Number]"
|
||
);
|
||
}
|
||
function isDate(e) {
|
||
return (
|
||
e instanceof Date ||
|
||
Object.prototype.toString.call(e) === "[object Date]"
|
||
);
|
||
}
|
||
function map(e, t) {
|
||
var r = [],
|
||
n,
|
||
s = e.length;
|
||
for (n = 0; n < s; ++n) {
|
||
r.push(t(e[n], n));
|
||
}
|
||
return r;
|
||
}
|
||
function extend(e, t) {
|
||
for (var r in t) {
|
||
if (hasOwnProp(t, r)) {
|
||
e[r] = t[r];
|
||
}
|
||
}
|
||
if (hasOwnProp(t, "toString")) {
|
||
e.toString = t.toString;
|
||
}
|
||
if (hasOwnProp(t, "valueOf")) {
|
||
e.valueOf = t.valueOf;
|
||
}
|
||
return e;
|
||
}
|
||
function createUTC(e, t, r, n) {
|
||
return createLocalOrUTC(e, t, r, n, true).utc();
|
||
}
|
||
function defaultParsingFlags() {
|
||
return {
|
||
empty: false,
|
||
unusedTokens: [],
|
||
unusedInput: [],
|
||
overflow: -2,
|
||
charsLeftOver: 0,
|
||
nullInput: false,
|
||
invalidEra: null,
|
||
invalidMonth: null,
|
||
invalidFormat: false,
|
||
userInvalidated: false,
|
||
iso: false,
|
||
parsedDateParts: [],
|
||
era: null,
|
||
meridiem: null,
|
||
rfc2822: false,
|
||
weekdayMismatch: false,
|
||
};
|
||
}
|
||
function getParsingFlags(e) {
|
||
if (e._pf == null) {
|
||
e._pf = defaultParsingFlags();
|
||
}
|
||
return e._pf;
|
||
}
|
||
var r;
|
||
if (Array.prototype.some) {
|
||
r = Array.prototype.some;
|
||
} else {
|
||
r = function (e) {
|
||
var t = Object(this),
|
||
r = t.length >>> 0,
|
||
n;
|
||
for (n = 0; n < r; n++) {
|
||
if (n in t && e.call(this, t[n], n, t)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
}
|
||
function isValid(e) {
|
||
var t = null,
|
||
n = false,
|
||
s = e._d && !isNaN(e._d.getTime());
|
||
if (s) {
|
||
t = getParsingFlags(e);
|
||
n = r.call(t.parsedDateParts, function (e) {
|
||
return e != null;
|
||
});
|
||
s =
|
||
t.overflow < 0 &&
|
||
!t.empty &&
|
||
!t.invalidEra &&
|
||
!t.invalidMonth &&
|
||
!t.invalidWeekday &&
|
||
!t.weekdayMismatch &&
|
||
!t.nullInput &&
|
||
!t.invalidFormat &&
|
||
!t.userInvalidated &&
|
||
(!t.meridiem || (t.meridiem && n));
|
||
if (e._strict) {
|
||
s =
|
||
s &&
|
||
t.charsLeftOver === 0 &&
|
||
t.unusedTokens.length === 0 &&
|
||
t.bigHour === undefined;
|
||
}
|
||
}
|
||
if (Object.isFrozen == null || !Object.isFrozen(e)) {
|
||
e._isValid = s;
|
||
} else {
|
||
return s;
|
||
}
|
||
return e._isValid;
|
||
}
|
||
function createInvalid(e) {
|
||
var t = createUTC(NaN);
|
||
if (e != null) {
|
||
extend(getParsingFlags(t), e);
|
||
} else {
|
||
getParsingFlags(t).userInvalidated = true;
|
||
}
|
||
return t;
|
||
}
|
||
var n = (hooks.momentProperties = []),
|
||
s = false;
|
||
function copyConfig(e, t) {
|
||
var r,
|
||
s,
|
||
a,
|
||
i = n.length;
|
||
if (!isUndefined(t._isAMomentObject)) {
|
||
e._isAMomentObject = t._isAMomentObject;
|
||
}
|
||
if (!isUndefined(t._i)) {
|
||
e._i = t._i;
|
||
}
|
||
if (!isUndefined(t._f)) {
|
||
e._f = t._f;
|
||
}
|
||
if (!isUndefined(t._l)) {
|
||
e._l = t._l;
|
||
}
|
||
if (!isUndefined(t._strict)) {
|
||
e._strict = t._strict;
|
||
}
|
||
if (!isUndefined(t._tzm)) {
|
||
e._tzm = t._tzm;
|
||
}
|
||
if (!isUndefined(t._isUTC)) {
|
||
e._isUTC = t._isUTC;
|
||
}
|
||
if (!isUndefined(t._offset)) {
|
||
e._offset = t._offset;
|
||
}
|
||
if (!isUndefined(t._pf)) {
|
||
e._pf = getParsingFlags(t);
|
||
}
|
||
if (!isUndefined(t._locale)) {
|
||
e._locale = t._locale;
|
||
}
|
||
if (i > 0) {
|
||
for (r = 0; r < i; r++) {
|
||
s = n[r];
|
||
a = t[s];
|
||
if (!isUndefined(a)) {
|
||
e[s] = a;
|
||
}
|
||
}
|
||
}
|
||
return e;
|
||
}
|
||
function Moment(e) {
|
||
copyConfig(this, e);
|
||
this._d = new Date(e._d != null ? e._d.getTime() : NaN);
|
||
if (!this.isValid()) {
|
||
this._d = new Date(NaN);
|
||
}
|
||
if (s === false) {
|
||
s = true;
|
||
hooks.updateOffset(this);
|
||
s = false;
|
||
}
|
||
}
|
||
function isMoment(e) {
|
||
return (
|
||
e instanceof Moment ||
|
||
(e != null && e._isAMomentObject != null)
|
||
);
|
||
}
|
||
function warn(e) {
|
||
if (
|
||
hooks.suppressDeprecationWarnings === false &&
|
||
typeof console !== "undefined" &&
|
||
console.warn
|
||
) {
|
||
console.warn("Deprecation warning: " + e);
|
||
}
|
||
}
|
||
function deprecate(e, t) {
|
||
var r = true;
|
||
return extend(function () {
|
||
if (hooks.deprecationHandler != null) {
|
||
hooks.deprecationHandler(null, e);
|
||
}
|
||
if (r) {
|
||
var n = [],
|
||
s,
|
||
a,
|
||
i,
|
||
o = arguments.length;
|
||
for (a = 0; a < o; a++) {
|
||
s = "";
|
||
if (typeof arguments[a] === "object") {
|
||
s += "\n[" + a + "] ";
|
||
for (i in arguments[0]) {
|
||
if (hasOwnProp(arguments[0], i)) {
|
||
s +=
|
||
i +
|
||
": " +
|
||
arguments[0][i] +
|
||
", ";
|
||
}
|
||
}
|
||
s = s.slice(0, -2);
|
||
} else {
|
||
s = arguments[a];
|
||
}
|
||
n.push(s);
|
||
}
|
||
warn(
|
||
e +
|
||
"\nArguments: " +
|
||
Array.prototype.slice.call(n).join("") +
|
||
"\n" +
|
||
new Error().stack
|
||
);
|
||
r = false;
|
||
}
|
||
return t.apply(this, arguments);
|
||
}, t);
|
||
}
|
||
var a = {};
|
||
function deprecateSimple(e, t) {
|
||
if (hooks.deprecationHandler != null) {
|
||
hooks.deprecationHandler(e, t);
|
||
}
|
||
if (!a[e]) {
|
||
warn(t);
|
||
a[e] = true;
|
||
}
|
||
}
|
||
hooks.suppressDeprecationWarnings = false;
|
||
hooks.deprecationHandler = null;
|
||
function isFunction(e) {
|
||
return (
|
||
(typeof Function !== "undefined" &&
|
||
e instanceof Function) ||
|
||
Object.prototype.toString.call(e) ===
|
||
"[object Function]"
|
||
);
|
||
}
|
||
function set(e) {
|
||
var t, r;
|
||
for (r in e) {
|
||
if (hasOwnProp(e, r)) {
|
||
t = e[r];
|
||
if (isFunction(t)) {
|
||
this[r] = t;
|
||
} else {
|
||
this["_" + r] = t;
|
||
}
|
||
}
|
||
}
|
||
this._config = e;
|
||
this._dayOfMonthOrdinalParseLenient = new RegExp(
|
||
(this._dayOfMonthOrdinalParse.source ||
|
||
this._ordinalParse.source) +
|
||
"|" +
|
||
/\d{1,2}/.source
|
||
);
|
||
}
|
||
function mergeConfigs(e, t) {
|
||
var r = extend({}, e),
|
||
n;
|
||
for (n in t) {
|
||
if (hasOwnProp(t, n)) {
|
||
if (isObject(e[n]) && isObject(t[n])) {
|
||
r[n] = {};
|
||
extend(r[n], e[n]);
|
||
extend(r[n], t[n]);
|
||
} else if (t[n] != null) {
|
||
r[n] = t[n];
|
||
} else {
|
||
delete r[n];
|
||
}
|
||
}
|
||
}
|
||
for (n in e) {
|
||
if (
|
||
hasOwnProp(e, n) &&
|
||
!hasOwnProp(t, n) &&
|
||
isObject(e[n])
|
||
) {
|
||
r[n] = extend({}, r[n]);
|
||
}
|
||
}
|
||
return r;
|
||
}
|
||
function Locale(e) {
|
||
if (e != null) {
|
||
this.set(e);
|
||
}
|
||
}
|
||
var i;
|
||
if (Object.keys) {
|
||
i = Object.keys;
|
||
} else {
|
||
i = function (e) {
|
||
var t,
|
||
r = [];
|
||
for (t in e) {
|
||
if (hasOwnProp(e, t)) {
|
||
r.push(t);
|
||
}
|
||
}
|
||
return r;
|
||
};
|
||
}
|
||
var o = {
|
||
sameDay: "[Today at] LT",
|
||
nextDay: "[Tomorrow at] LT",
|
||
nextWeek: "dddd [at] LT",
|
||
lastDay: "[Yesterday at] LT",
|
||
lastWeek: "[Last] dddd [at] LT",
|
||
sameElse: "L",
|
||
};
|
||
function calendar(e, t, r) {
|
||
var n = this._calendar[e] || this._calendar["sameElse"];
|
||
return isFunction(n) ? n.call(t, r) : n;
|
||
}
|
||
function zeroFill(e, t, r) {
|
||
var n = "" + Math.abs(e),
|
||
s = t - n.length,
|
||
a = e >= 0;
|
||
return (
|
||
(a ? (r ? "+" : "") : "-") +
|
||
Math.pow(10, Math.max(0, s)).toString().substr(1) +
|
||
n
|
||
);
|
||
}
|
||
var u =
|
||
/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
|
||
l = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
|
||
c = {},
|
||
f = {};
|
||
function addFormatToken(e, t, r, n) {
|
||
var s = n;
|
||
if (typeof n === "string") {
|
||
s = function () {
|
||
return this[n]();
|
||
};
|
||
}
|
||
if (e) {
|
||
f[e] = s;
|
||
}
|
||
if (t) {
|
||
f[t[0]] = function () {
|
||
return zeroFill(
|
||
s.apply(this, arguments),
|
||
t[1],
|
||
t[2]
|
||
);
|
||
};
|
||
}
|
||
if (r) {
|
||
f[r] = function () {
|
||
return this.localeData().ordinal(
|
||
s.apply(this, arguments),
|
||
e
|
||
);
|
||
};
|
||
}
|
||
}
|
||
function removeFormattingTokens(e) {
|
||
if (e.match(/\[[\s\S]/)) {
|
||
return e.replace(/^\[|\]$/g, "");
|
||
}
|
||
return e.replace(/\\/g, "");
|
||
}
|
||
function makeFormatFunction(e) {
|
||
var t = e.match(u),
|
||
r,
|
||
n;
|
||
for (r = 0, n = t.length; r < n; r++) {
|
||
if (f[t[r]]) {
|
||
t[r] = f[t[r]];
|
||
} else {
|
||
t[r] = removeFormattingTokens(t[r]);
|
||
}
|
||
}
|
||
return function (r) {
|
||
var s = "",
|
||
a;
|
||
for (a = 0; a < n; a++) {
|
||
s += isFunction(t[a]) ? t[a].call(r, e) : t[a];
|
||
}
|
||
return s;
|
||
};
|
||
}
|
||
function formatMoment(e, t) {
|
||
if (!e.isValid()) {
|
||
return e.localeData().invalidDate();
|
||
}
|
||
t = expandFormat(t, e.localeData());
|
||
c[t] = c[t] || makeFormatFunction(t);
|
||
return c[t](e);
|
||
}
|
||
function expandFormat(e, t) {
|
||
var r = 5;
|
||
function replaceLongDateFormatTokens(e) {
|
||
return t.longDateFormat(e) || e;
|
||
}
|
||
l.lastIndex = 0;
|
||
while (r >= 0 && l.test(e)) {
|
||
e = e.replace(l, replaceLongDateFormatTokens);
|
||
l.lastIndex = 0;
|
||
r -= 1;
|
||
}
|
||
return e;
|
||
}
|
||
var d = {
|
||
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",
|
||
};
|
||
function longDateFormat(e) {
|
||
var t = this._longDateFormat[e],
|
||
r = this._longDateFormat[e.toUpperCase()];
|
||
if (t || !r) {
|
||
return t;
|
||
}
|
||
this._longDateFormat[e] = r
|
||
.match(u)
|
||
.map(function (e) {
|
||
if (
|
||
e === "MMMM" ||
|
||
e === "MM" ||
|
||
e === "DD" ||
|
||
e === "dddd"
|
||
) {
|
||
return e.slice(1);
|
||
}
|
||
return e;
|
||
})
|
||
.join("");
|
||
return this._longDateFormat[e];
|
||
}
|
||
var h = "Invalid date";
|
||
function invalidDate() {
|
||
return this._invalidDate;
|
||
}
|
||
var m = "%d",
|
||
p = /\d{1,2}/;
|
||
function ordinal(e) {
|
||
return this._ordinal.replace("%d", e);
|
||
}
|
||
var g = {
|
||
future: "in %s",
|
||
past: "%s ago",
|
||
s: "a few seconds",
|
||
ss: "%d seconds",
|
||
m: "a minute",
|
||
mm: "%d minutes",
|
||
h: "an hour",
|
||
hh: "%d hours",
|
||
d: "a day",
|
||
dd: "%d days",
|
||
w: "a week",
|
||
ww: "%d weeks",
|
||
M: "a month",
|
||
MM: "%d months",
|
||
y: "a year",
|
||
yy: "%d years",
|
||
};
|
||
function relativeTime(e, t, r, n) {
|
||
var s = this._relativeTime[r];
|
||
return isFunction(s) ? s(e, t, r, n) : s.replace(/%d/i, e);
|
||
}
|
||
function pastFuture(e, t) {
|
||
var r = this._relativeTime[e > 0 ? "future" : "past"];
|
||
return isFunction(r) ? r(t) : r.replace(/%s/i, t);
|
||
}
|
||
var y = {
|
||
D: "date",
|
||
dates: "date",
|
||
date: "date",
|
||
d: "day",
|
||
days: "day",
|
||
day: "day",
|
||
e: "weekday",
|
||
weekdays: "weekday",
|
||
weekday: "weekday",
|
||
E: "isoWeekday",
|
||
isoweekdays: "isoWeekday",
|
||
isoweekday: "isoWeekday",
|
||
DDD: "dayOfYear",
|
||
dayofyears: "dayOfYear",
|
||
dayofyear: "dayOfYear",
|
||
h: "hour",
|
||
hours: "hour",
|
||
hour: "hour",
|
||
ms: "millisecond",
|
||
milliseconds: "millisecond",
|
||
millisecond: "millisecond",
|
||
m: "minute",
|
||
minutes: "minute",
|
||
minute: "minute",
|
||
M: "month",
|
||
months: "month",
|
||
month: "month",
|
||
Q: "quarter",
|
||
quarters: "quarter",
|
||
quarter: "quarter",
|
||
s: "second",
|
||
seconds: "second",
|
||
second: "second",
|
||
gg: "weekYear",
|
||
weekyears: "weekYear",
|
||
weekyear: "weekYear",
|
||
GG: "isoWeekYear",
|
||
isoweekyears: "isoWeekYear",
|
||
isoweekyear: "isoWeekYear",
|
||
w: "week",
|
||
weeks: "week",
|
||
week: "week",
|
||
W: "isoWeek",
|
||
isoweeks: "isoWeek",
|
||
isoweek: "isoWeek",
|
||
y: "year",
|
||
years: "year",
|
||
year: "year",
|
||
};
|
||
function normalizeUnits(e) {
|
||
return typeof e === "string"
|
||
? y[e] || y[e.toLowerCase()]
|
||
: undefined;
|
||
}
|
||
function normalizeObjectUnits(e) {
|
||
var t = {},
|
||
r,
|
||
n;
|
||
for (n in e) {
|
||
if (hasOwnProp(e, n)) {
|
||
r = normalizeUnits(n);
|
||
if (r) {
|
||
t[r] = e[n];
|
||
}
|
||
}
|
||
}
|
||
return t;
|
||
}
|
||
var _ = {
|
||
date: 9,
|
||
day: 11,
|
||
weekday: 11,
|
||
isoWeekday: 11,
|
||
dayOfYear: 4,
|
||
hour: 13,
|
||
millisecond: 16,
|
||
minute: 14,
|
||
month: 8,
|
||
quarter: 7,
|
||
second: 15,
|
||
weekYear: 1,
|
||
isoWeekYear: 1,
|
||
week: 5,
|
||
isoWeek: 5,
|
||
year: 1,
|
||
};
|
||
function getPrioritizedUnits(e) {
|
||
var t = [],
|
||
r;
|
||
for (r in e) {
|
||
if (hasOwnProp(e, r)) {
|
||
t.push({ unit: r, priority: _[r] });
|
||
}
|
||
}
|
||
t.sort(function (e, t) {
|
||
return e.priority - t.priority;
|
||
});
|
||
return t;
|
||
}
|
||
var v = /\d/,
|
||
k = /\d\d/,
|
||
w = /\d{3}/,
|
||
b = /\d{4}/,
|
||
S = /[+-]?\d{6}/,
|
||
O = /\d\d?/,
|
||
T = /\d\d\d\d?/,
|
||
M = /\d\d\d\d\d\d?/,
|
||
D = /\d{1,3}/,
|
||
x = /\d{1,4}/,
|
||
R = /[+-]?\d{1,6}/,
|
||
E = /\d+/,
|
||
C = /[+-]?\d+/,
|
||
F = /Z|[+-]\d\d:?\d\d/gi,
|
||
P = /Z|[+-]\d\d(?::?\d\d)?/gi,
|
||
A = /[+-]?\d+(\.\d{1,3})?/,
|
||
N =
|
||
/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
|
||
Y = /^[1-9]\d?/,
|
||
I = /^([1-9]\d|\d)/,
|
||
U;
|
||
U = {};
|
||
function addRegexToken(e, t, r) {
|
||
U[e] = isFunction(t)
|
||
? t
|
||
: function (e, n) {
|
||
return e && r ? r : t;
|
||
};
|
||
}
|
||
function getParseRegexForToken(e, t) {
|
||
if (!hasOwnProp(U, e)) {
|
||
return new RegExp(unescapeFormat(e));
|
||
}
|
||
return U[e](t._strict, t._locale);
|
||
}
|
||
function unescapeFormat(e) {
|
||
return regexEscape(
|
||
e
|
||
.replace("\\", "")
|
||
.replace(
|
||
/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
|
||
function (e, t, r, n, s) {
|
||
return t || r || n || s;
|
||
}
|
||
)
|
||
);
|
||
}
|
||
function regexEscape(e) {
|
||
return e.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
|
||
}
|
||
function absFloor(e) {
|
||
if (e < 0) {
|
||
return Math.ceil(e) || 0;
|
||
} else {
|
||
return Math.floor(e);
|
||
}
|
||
}
|
||
function toInt(e) {
|
||
var t = +e,
|
||
r = 0;
|
||
if (t !== 0 && isFinite(t)) {
|
||
r = absFloor(t);
|
||
}
|
||
return r;
|
||
}
|
||
var L = {};
|
||
function addParseToken(e, t) {
|
||
var r,
|
||
n = t,
|
||
s;
|
||
if (typeof e === "string") {
|
||
e = [e];
|
||
}
|
||
if (isNumber(t)) {
|
||
n = function (e, r) {
|
||
r[t] = toInt(e);
|
||
};
|
||
}
|
||
s = e.length;
|
||
for (r = 0; r < s; r++) {
|
||
L[e[r]] = n;
|
||
}
|
||
}
|
||
function addWeekParseToken(e, t) {
|
||
addParseToken(e, function (e, r, n, s) {
|
||
n._w = n._w || {};
|
||
t(e, n._w, n, s);
|
||
});
|
||
}
|
||
function addTimeToArrayFromToken(e, t, r) {
|
||
if (t != null && hasOwnProp(L, e)) {
|
||
L[e](t, r._a, r, e);
|
||
}
|
||
}
|
||
function isLeapYear(e) {
|
||
return (e % 4 === 0 && e % 100 !== 0) || e % 400 === 0;
|
||
}
|
||
var W = 0,
|
||
j = 1,
|
||
q = 2,
|
||
H = 3,
|
||
B = 4,
|
||
V = 5,
|
||
G = 6,
|
||
$ = 7,
|
||
z = 8;
|
||
addFormatToken("Y", 0, 0, function () {
|
||
var e = this.year();
|
||
return e <= 9999 ? zeroFill(e, 4) : "+" + e;
|
||
});
|
||
addFormatToken(0, ["YY", 2], 0, function () {
|
||
return this.year() % 100;
|
||
});
|
||
addFormatToken(0, ["YYYY", 4], 0, "year");
|
||
addFormatToken(0, ["YYYYY", 5], 0, "year");
|
||
addFormatToken(0, ["YYYYYY", 6, true], 0, "year");
|
||
addRegexToken("Y", C);
|
||
addRegexToken("YY", O, k);
|
||
addRegexToken("YYYY", x, b);
|
||
addRegexToken("YYYYY", R, S);
|
||
addRegexToken("YYYYYY", R, S);
|
||
addParseToken(["YYYYY", "YYYYYY"], W);
|
||
addParseToken("YYYY", function (e, t) {
|
||
t[W] =
|
||
e.length === 2 ? hooks.parseTwoDigitYear(e) : toInt(e);
|
||
});
|
||
addParseToken("YY", function (e, t) {
|
||
t[W] = hooks.parseTwoDigitYear(e);
|
||
});
|
||
addParseToken("Y", function (e, t) {
|
||
t[W] = parseInt(e, 10);
|
||
});
|
||
function daysInYear(e) {
|
||
return isLeapYear(e) ? 366 : 365;
|
||
}
|
||
hooks.parseTwoDigitYear = function (e) {
|
||
return toInt(e) + (toInt(e) > 68 ? 1900 : 2e3);
|
||
};
|
||
var Z = makeGetSet("FullYear", true);
|
||
function getIsLeapYear() {
|
||
return isLeapYear(this.year());
|
||
}
|
||
function makeGetSet(e, t) {
|
||
return function (r) {
|
||
if (r != null) {
|
||
set$1(this, e, r);
|
||
hooks.updateOffset(this, t);
|
||
return this;
|
||
} else {
|
||
return get(this, e);
|
||
}
|
||
};
|
||
}
|
||
function get(e, t) {
|
||
if (!e.isValid()) {
|
||
return NaN;
|
||
}
|
||
var r = e._d,
|
||
n = e._isUTC;
|
||
switch (t) {
|
||
case "Milliseconds":
|
||
return n
|
||
? r.getUTCMilliseconds()
|
||
: r.getMilliseconds();
|
||
case "Seconds":
|
||
return n ? r.getUTCSeconds() : r.getSeconds();
|
||
case "Minutes":
|
||
return n ? r.getUTCMinutes() : r.getMinutes();
|
||
case "Hours":
|
||
return n ? r.getUTCHours() : r.getHours();
|
||
case "Date":
|
||
return n ? r.getUTCDate() : r.getDate();
|
||
case "Day":
|
||
return n ? r.getUTCDay() : r.getDay();
|
||
case "Month":
|
||
return n ? r.getUTCMonth() : r.getMonth();
|
||
case "FullYear":
|
||
return n ? r.getUTCFullYear() : r.getFullYear();
|
||
default:
|
||
return NaN;
|
||
}
|
||
}
|
||
function set$1(e, t, r) {
|
||
var n, s, a, i, o;
|
||
if (!e.isValid() || isNaN(r)) {
|
||
return;
|
||
}
|
||
n = e._d;
|
||
s = e._isUTC;
|
||
switch (t) {
|
||
case "Milliseconds":
|
||
return void (s
|
||
? n.setUTCMilliseconds(r)
|
||
: n.setMilliseconds(r));
|
||
case "Seconds":
|
||
return void (s
|
||
? n.setUTCSeconds(r)
|
||
: n.setSeconds(r));
|
||
case "Minutes":
|
||
return void (s
|
||
? n.setUTCMinutes(r)
|
||
: n.setMinutes(r));
|
||
case "Hours":
|
||
return void (s ? n.setUTCHours(r) : n.setHours(r));
|
||
case "Date":
|
||
return void (s ? n.setUTCDate(r) : n.setDate(r));
|
||
case "FullYear":
|
||
break;
|
||
default:
|
||
return;
|
||
}
|
||
a = r;
|
||
i = e.month();
|
||
o = e.date();
|
||
o = o === 29 && i === 1 && !isLeapYear(a) ? 28 : o;
|
||
void (s
|
||
? n.setUTCFullYear(a, i, o)
|
||
: n.setFullYear(a, i, o));
|
||
}
|
||
function stringGet(e) {
|
||
e = normalizeUnits(e);
|
||
if (isFunction(this[e])) {
|
||
return this[e]();
|
||
}
|
||
return this;
|
||
}
|
||
function stringSet(e, t) {
|
||
if (typeof e === "object") {
|
||
e = normalizeObjectUnits(e);
|
||
var r = getPrioritizedUnits(e),
|
||
n,
|
||
s = r.length;
|
||
for (n = 0; n < s; n++) {
|
||
this[r[n].unit](e[r[n].unit]);
|
||
}
|
||
} else {
|
||
e = normalizeUnits(e);
|
||
if (isFunction(this[e])) {
|
||
return this[e](t);
|
||
}
|
||
}
|
||
return this;
|
||
}
|
||
function mod(e, t) {
|
||
return ((e % t) + t) % t;
|
||
}
|
||
var J;
|
||
if (Array.prototype.indexOf) {
|
||
J = Array.prototype.indexOf;
|
||
} else {
|
||
J = function (e) {
|
||
var t;
|
||
for (t = 0; t < this.length; ++t) {
|
||
if (this[t] === e) {
|
||
return t;
|
||
}
|
||
}
|
||
return -1;
|
||
};
|
||
}
|
||
function daysInMonth(e, t) {
|
||
if (isNaN(e) || isNaN(t)) {
|
||
return NaN;
|
||
}
|
||
var r = mod(t, 12);
|
||
e += (t - r) / 12;
|
||
return r === 1
|
||
? isLeapYear(e)
|
||
? 29
|
||
: 28
|
||
: 31 - ((r % 7) % 2);
|
||
}
|
||
addFormatToken("M", ["MM", 2], "Mo", function () {
|
||
return this.month() + 1;
|
||
});
|
||
addFormatToken("MMM", 0, 0, function (e) {
|
||
return this.localeData().monthsShort(this, e);
|
||
});
|
||
addFormatToken("MMMM", 0, 0, function (e) {
|
||
return this.localeData().months(this, e);
|
||
});
|
||
addRegexToken("M", O, Y);
|
||
addRegexToken("MM", O, k);
|
||
addRegexToken("MMM", function (e, t) {
|
||
return t.monthsShortRegex(e);
|
||
});
|
||
addRegexToken("MMMM", function (e, t) {
|
||
return t.monthsRegex(e);
|
||
});
|
||
addParseToken(["M", "MM"], function (e, t) {
|
||
t[j] = toInt(e) - 1;
|
||
});
|
||
addParseToken(["MMM", "MMMM"], function (e, t, r, n) {
|
||
var s = r._locale.monthsParse(e, n, r._strict);
|
||
if (s != null) {
|
||
t[j] = s;
|
||
} else {
|
||
getParsingFlags(r).invalidMonth = e;
|
||
}
|
||
});
|
||
var Q =
|
||
"January_February_March_April_May_June_July_August_September_October_November_December".split(
|
||
"_"
|
||
),
|
||
X = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split(
|
||
"_"
|
||
),
|
||
K = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
|
||
ee = N,
|
||
te = N;
|
||
function localeMonths(e, t) {
|
||
if (!e) {
|
||
return isArray(this._months)
|
||
? this._months
|
||
: this._months["standalone"];
|
||
}
|
||
return isArray(this._months)
|
||
? this._months[e.month()]
|
||
: this._months[
|
||
(this._months.isFormat || K).test(t)
|
||
? "format"
|
||
: "standalone"
|
||
][e.month()];
|
||
}
|
||
function localeMonthsShort(e, t) {
|
||
if (!e) {
|
||
return isArray(this._monthsShort)
|
||
? this._monthsShort
|
||
: this._monthsShort["standalone"];
|
||
}
|
||
return isArray(this._monthsShort)
|
||
? this._monthsShort[e.month()]
|
||
: this._monthsShort[
|
||
K.test(t) ? "format" : "standalone"
|
||
][e.month()];
|
||
}
|
||
function handleStrictParse(e, t, r) {
|
||
var n,
|
||
s,
|
||
a,
|
||
i = e.toLocaleLowerCase();
|
||
if (!this._monthsParse) {
|
||
this._monthsParse = [];
|
||
this._longMonthsParse = [];
|
||
this._shortMonthsParse = [];
|
||
for (n = 0; n < 12; ++n) {
|
||
a = createUTC([2e3, n]);
|
||
this._shortMonthsParse[n] = this.monthsShort(
|
||
a,
|
||
""
|
||
).toLocaleLowerCase();
|
||
this._longMonthsParse[n] = this.months(
|
||
a,
|
||
""
|
||
).toLocaleLowerCase();
|
||
}
|
||
}
|
||
if (r) {
|
||
if (t === "MMM") {
|
||
s = J.call(this._shortMonthsParse, i);
|
||
return s !== -1 ? s : null;
|
||
} else {
|
||
s = J.call(this._longMonthsParse, i);
|
||
return s !== -1 ? s : null;
|
||
}
|
||
} else {
|
||
if (t === "MMM") {
|
||
s = J.call(this._shortMonthsParse, i);
|
||
if (s !== -1) {
|
||
return s;
|
||
}
|
||
s = J.call(this._longMonthsParse, i);
|
||
return s !== -1 ? s : null;
|
||
} else {
|
||
s = J.call(this._longMonthsParse, i);
|
||
if (s !== -1) {
|
||
return s;
|
||
}
|
||
s = J.call(this._shortMonthsParse, i);
|
||
return s !== -1 ? s : null;
|
||
}
|
||
}
|
||
}
|
||
function localeMonthsParse(e, t, r) {
|
||
var n, s, a;
|
||
if (this._monthsParseExact) {
|
||
return handleStrictParse.call(this, e, t, r);
|
||
}
|
||
if (!this._monthsParse) {
|
||
this._monthsParse = [];
|
||
this._longMonthsParse = [];
|
||
this._shortMonthsParse = [];
|
||
}
|
||
for (n = 0; n < 12; n++) {
|
||
s = createUTC([2e3, n]);
|
||
if (r && !this._longMonthsParse[n]) {
|
||
this._longMonthsParse[n] = new RegExp(
|
||
"^" + this.months(s, "").replace(".", "") + "$",
|
||
"i"
|
||
);
|
||
this._shortMonthsParse[n] = new RegExp(
|
||
"^" +
|
||
this.monthsShort(s, "").replace(".", "") +
|
||
"$",
|
||
"i"
|
||
);
|
||
}
|
||
if (!r && !this._monthsParse[n]) {
|
||
a =
|
||
"^" +
|
||
this.months(s, "") +
|
||
"|^" +
|
||
this.monthsShort(s, "");
|
||
this._monthsParse[n] = new RegExp(
|
||
a.replace(".", ""),
|
||
"i"
|
||
);
|
||
}
|
||
if (
|
||
r &&
|
||
t === "MMMM" &&
|
||
this._longMonthsParse[n].test(e)
|
||
) {
|
||
return n;
|
||
} else if (
|
||
r &&
|
||
t === "MMM" &&
|
||
this._shortMonthsParse[n].test(e)
|
||
) {
|
||
return n;
|
||
} else if (!r && this._monthsParse[n].test(e)) {
|
||
return n;
|
||
}
|
||
}
|
||
}
|
||
function setMonth(e, t) {
|
||
if (!e.isValid()) {
|
||
return e;
|
||
}
|
||
if (typeof t === "string") {
|
||
if (/^\d+$/.test(t)) {
|
||
t = toInt(t);
|
||
} else {
|
||
t = e.localeData().monthsParse(t);
|
||
if (!isNumber(t)) {
|
||
return e;
|
||
}
|
||
}
|
||
}
|
||
var r = t,
|
||
n = e.date();
|
||
n = n < 29 ? n : Math.min(n, daysInMonth(e.year(), r));
|
||
void (e._isUTC
|
||
? e._d.setUTCMonth(r, n)
|
||
: e._d.setMonth(r, n));
|
||
return e;
|
||
}
|
||
function getSetMonth(e) {
|
||
if (e != null) {
|
||
setMonth(this, e);
|
||
hooks.updateOffset(this, true);
|
||
return this;
|
||
} else {
|
||
return get(this, "Month");
|
||
}
|
||
}
|
||
function getDaysInMonth() {
|
||
return daysInMonth(this.year(), this.month());
|
||
}
|
||
function monthsShortRegex(e) {
|
||
if (this._monthsParseExact) {
|
||
if (!hasOwnProp(this, "_monthsRegex")) {
|
||
computeMonthsParse.call(this);
|
||
}
|
||
if (e) {
|
||
return this._monthsShortStrictRegex;
|
||
} else {
|
||
return this._monthsShortRegex;
|
||
}
|
||
} else {
|
||
if (!hasOwnProp(this, "_monthsShortRegex")) {
|
||
this._monthsShortRegex = ee;
|
||
}
|
||
return this._monthsShortStrictRegex && e
|
||
? this._monthsShortStrictRegex
|
||
: this._monthsShortRegex;
|
||
}
|
||
}
|
||
function monthsRegex(e) {
|
||
if (this._monthsParseExact) {
|
||
if (!hasOwnProp(this, "_monthsRegex")) {
|
||
computeMonthsParse.call(this);
|
||
}
|
||
if (e) {
|
||
return this._monthsStrictRegex;
|
||
} else {
|
||
return this._monthsRegex;
|
||
}
|
||
} else {
|
||
if (!hasOwnProp(this, "_monthsRegex")) {
|
||
this._monthsRegex = te;
|
||
}
|
||
return this._monthsStrictRegex && e
|
||
? this._monthsStrictRegex
|
||
: this._monthsRegex;
|
||
}
|
||
}
|
||
function computeMonthsParse() {
|
||
function cmpLenRev(e, t) {
|
||
return t.length - e.length;
|
||
}
|
||
var e = [],
|
||
t = [],
|
||
r = [],
|
||
n,
|
||
s,
|
||
a,
|
||
i;
|
||
for (n = 0; n < 12; n++) {
|
||
s = createUTC([2e3, n]);
|
||
a = regexEscape(this.monthsShort(s, ""));
|
||
i = regexEscape(this.months(s, ""));
|
||
e.push(a);
|
||
t.push(i);
|
||
r.push(i);
|
||
r.push(a);
|
||
}
|
||
e.sort(cmpLenRev);
|
||
t.sort(cmpLenRev);
|
||
r.sort(cmpLenRev);
|
||
this._monthsRegex = new RegExp(
|
||
"^(" + r.join("|") + ")",
|
||
"i"
|
||
);
|
||
this._monthsShortRegex = this._monthsRegex;
|
||
this._monthsStrictRegex = new RegExp(
|
||
"^(" + t.join("|") + ")",
|
||
"i"
|
||
);
|
||
this._monthsShortStrictRegex = new RegExp(
|
||
"^(" + e.join("|") + ")",
|
||
"i"
|
||
);
|
||
}
|
||
function createDate(e, t, r, n, s, a, i) {
|
||
var o;
|
||
if (e < 100 && e >= 0) {
|
||
o = new Date(e + 400, t, r, n, s, a, i);
|
||
if (isFinite(o.getFullYear())) {
|
||
o.setFullYear(e);
|
||
}
|
||
} else {
|
||
o = new Date(e, t, r, n, s, a, i);
|
||
}
|
||
return o;
|
||
}
|
||
function createUTCDate(e) {
|
||
var t, r;
|
||
if (e < 100 && e >= 0) {
|
||
r = Array.prototype.slice.call(arguments);
|
||
r[0] = e + 400;
|
||
t = new Date(Date.UTC.apply(null, r));
|
||
if (isFinite(t.getUTCFullYear())) {
|
||
t.setUTCFullYear(e);
|
||
}
|
||
} else {
|
||
t = new Date(Date.UTC.apply(null, arguments));
|
||
}
|
||
return t;
|
||
}
|
||
function firstWeekOffset(e, t, r) {
|
||
var n = 7 + t - r,
|
||
s = (7 + createUTCDate(e, 0, n).getUTCDay() - t) % 7;
|
||
return -s + n - 1;
|
||
}
|
||
function dayOfYearFromWeeks(e, t, r, n, s) {
|
||
var a = (7 + r - n) % 7,
|
||
i = firstWeekOffset(e, n, s),
|
||
o = 1 + 7 * (t - 1) + a + i,
|
||
u,
|
||
l;
|
||
if (o <= 0) {
|
||
u = e - 1;
|
||
l = daysInYear(u) + o;
|
||
} else if (o > daysInYear(e)) {
|
||
u = e + 1;
|
||
l = o - daysInYear(e);
|
||
} else {
|
||
u = e;
|
||
l = o;
|
||
}
|
||
return { year: u, dayOfYear: l };
|
||
}
|
||
function weekOfYear(e, t, r) {
|
||
var n = firstWeekOffset(e.year(), t, r),
|
||
s = Math.floor((e.dayOfYear() - n - 1) / 7) + 1,
|
||
a,
|
||
i;
|
||
if (s < 1) {
|
||
i = e.year() - 1;
|
||
a = s + weeksInYear(i, t, r);
|
||
} else if (s > weeksInYear(e.year(), t, r)) {
|
||
a = s - weeksInYear(e.year(), t, r);
|
||
i = e.year() + 1;
|
||
} else {
|
||
i = e.year();
|
||
a = s;
|
||
}
|
||
return { week: a, year: i };
|
||
}
|
||
function weeksInYear(e, t, r) {
|
||
var n = firstWeekOffset(e, t, r),
|
||
s = firstWeekOffset(e + 1, t, r);
|
||
return (daysInYear(e) - n + s) / 7;
|
||
}
|
||
addFormatToken("w", ["ww", 2], "wo", "week");
|
||
addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
|
||
addRegexToken("w", O, Y);
|
||
addRegexToken("ww", O, k);
|
||
addRegexToken("W", O, Y);
|
||
addRegexToken("WW", O, k);
|
||
addWeekParseToken(
|
||
["w", "ww", "W", "WW"],
|
||
function (e, t, r, n) {
|
||
t[n.substr(0, 1)] = toInt(e);
|
||
}
|
||
);
|
||
function localeWeek(e) {
|
||
return weekOfYear(e, this._week.dow, this._week.doy).week;
|
||
}
|
||
var re = { dow: 0, doy: 6 };
|
||
function localeFirstDayOfWeek() {
|
||
return this._week.dow;
|
||
}
|
||
function localeFirstDayOfYear() {
|
||
return this._week.doy;
|
||
}
|
||
function getSetWeek(e) {
|
||
var t = this.localeData().week(this);
|
||
return e == null ? t : this.add((e - t) * 7, "d");
|
||
}
|
||
function getSetISOWeek(e) {
|
||
var t = weekOfYear(this, 1, 4).week;
|
||
return e == null ? t : this.add((e - t) * 7, "d");
|
||
}
|
||
addFormatToken("d", 0, "do", "day");
|
||
addFormatToken("dd", 0, 0, function (e) {
|
||
return this.localeData().weekdaysMin(this, e);
|
||
});
|
||
addFormatToken("ddd", 0, 0, function (e) {
|
||
return this.localeData().weekdaysShort(this, e);
|
||
});
|
||
addFormatToken("dddd", 0, 0, function (e) {
|
||
return this.localeData().weekdays(this, e);
|
||
});
|
||
addFormatToken("e", 0, 0, "weekday");
|
||
addFormatToken("E", 0, 0, "isoWeekday");
|
||
addRegexToken("d", O);
|
||
addRegexToken("e", O);
|
||
addRegexToken("E", O);
|
||
addRegexToken("dd", function (e, t) {
|
||
return t.weekdaysMinRegex(e);
|
||
});
|
||
addRegexToken("ddd", function (e, t) {
|
||
return t.weekdaysShortRegex(e);
|
||
});
|
||
addRegexToken("dddd", function (e, t) {
|
||
return t.weekdaysRegex(e);
|
||
});
|
||
addWeekParseToken(["dd", "ddd", "dddd"], function (e, t, r, n) {
|
||
var s = r._locale.weekdaysParse(e, n, r._strict);
|
||
if (s != null) {
|
||
t.d = s;
|
||
} else {
|
||
getParsingFlags(r).invalidWeekday = e;
|
||
}
|
||
});
|
||
addWeekParseToken(["d", "e", "E"], function (e, t, r, n) {
|
||
t[n] = toInt(e);
|
||
});
|
||
function parseWeekday(e, t) {
|
||
if (typeof e !== "string") {
|
||
return e;
|
||
}
|
||
if (!isNaN(e)) {
|
||
return parseInt(e, 10);
|
||
}
|
||
e = t.weekdaysParse(e);
|
||
if (typeof e === "number") {
|
||
return e;
|
||
}
|
||
return null;
|
||
}
|
||
function parseIsoWeekday(e, t) {
|
||
if (typeof e === "string") {
|
||
return t.weekdaysParse(e) % 7 || 7;
|
||
}
|
||
return isNaN(e) ? null : e;
|
||
}
|
||
function shiftWeekdays(e, t) {
|
||
return e.slice(t, 7).concat(e.slice(0, t));
|
||
}
|
||
var ne =
|
||
"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split(
|
||
"_"
|
||
),
|
||
se = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),
|
||
ae = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"),
|
||
ie = N,
|
||
oe = N,
|
||
ue = N;
|
||
function localeWeekdays(e, t) {
|
||
var r = isArray(this._weekdays)
|
||
? this._weekdays
|
||
: this._weekdays[
|
||
e && e !== true && this._weekdays.isFormat.test(t)
|
||
? "format"
|
||
: "standalone"
|
||
];
|
||
return e === true
|
||
? shiftWeekdays(r, this._week.dow)
|
||
: e
|
||
? r[e.day()]
|
||
: r;
|
||
}
|
||
function localeWeekdaysShort(e) {
|
||
return e === true
|
||
? shiftWeekdays(this._weekdaysShort, this._week.dow)
|
||
: e
|
||
? this._weekdaysShort[e.day()]
|
||
: this._weekdaysShort;
|
||
}
|
||
function localeWeekdaysMin(e) {
|
||
return e === true
|
||
? shiftWeekdays(this._weekdaysMin, this._week.dow)
|
||
: e
|
||
? this._weekdaysMin[e.day()]
|
||
: this._weekdaysMin;
|
||
}
|
||
function handleStrictParse$1(e, t, r) {
|
||
var n,
|
||
s,
|
||
a,
|
||
i = e.toLocaleLowerCase();
|
||
if (!this._weekdaysParse) {
|
||
this._weekdaysParse = [];
|
||
this._shortWeekdaysParse = [];
|
||
this._minWeekdaysParse = [];
|
||
for (n = 0; n < 7; ++n) {
|
||
a = createUTC([2e3, 1]).day(n);
|
||
this._minWeekdaysParse[n] = this.weekdaysMin(
|
||
a,
|
||
""
|
||
).toLocaleLowerCase();
|
||
this._shortWeekdaysParse[n] = this.weekdaysShort(
|
||
a,
|
||
""
|
||
).toLocaleLowerCase();
|
||
this._weekdaysParse[n] = this.weekdays(
|
||
a,
|
||
""
|
||
).toLocaleLowerCase();
|
||
}
|
||
}
|
||
if (r) {
|
||
if (t === "dddd") {
|
||
s = J.call(this._weekdaysParse, i);
|
||
return s !== -1 ? s : null;
|
||
} else if (t === "ddd") {
|
||
s = J.call(this._shortWeekdaysParse, i);
|
||
return s !== -1 ? s : null;
|
||
} else {
|
||
s = J.call(this._minWeekdaysParse, i);
|
||
return s !== -1 ? s : null;
|
||
}
|
||
} else {
|
||
if (t === "dddd") {
|
||
s = J.call(this._weekdaysParse, i);
|
||
if (s !== -1) {
|
||
return s;
|
||
}
|
||
s = J.call(this._shortWeekdaysParse, i);
|
||
if (s !== -1) {
|
||
return s;
|
||
}
|
||
s = J.call(this._minWeekdaysParse, i);
|
||
return s !== -1 ? s : null;
|
||
} else if (t === "ddd") {
|
||
s = J.call(this._shortWeekdaysParse, i);
|
||
if (s !== -1) {
|
||
return s;
|
||
}
|
||
s = J.call(this._weekdaysParse, i);
|
||
if (s !== -1) {
|
||
return s;
|
||
}
|
||
s = J.call(this._minWeekdaysParse, i);
|
||
return s !== -1 ? s : null;
|
||
} else {
|
||
s = J.call(this._minWeekdaysParse, i);
|
||
if (s !== -1) {
|
||
return s;
|
||
}
|
||
s = J.call(this._weekdaysParse, i);
|
||
if (s !== -1) {
|
||
return s;
|
||
}
|
||
s = J.call(this._shortWeekdaysParse, i);
|
||
return s !== -1 ? s : null;
|
||
}
|
||
}
|
||
}
|
||
function localeWeekdaysParse(e, t, r) {
|
||
var n, s, a;
|
||
if (this._weekdaysParseExact) {
|
||
return handleStrictParse$1.call(this, e, t, r);
|
||
}
|
||
if (!this._weekdaysParse) {
|
||
this._weekdaysParse = [];
|
||
this._minWeekdaysParse = [];
|
||
this._shortWeekdaysParse = [];
|
||
this._fullWeekdaysParse = [];
|
||
}
|
||
for (n = 0; n < 7; n++) {
|
||
s = createUTC([2e3, 1]).day(n);
|
||
if (r && !this._fullWeekdaysParse[n]) {
|
||
this._fullWeekdaysParse[n] = new RegExp(
|
||
"^" +
|
||
this.weekdays(s, "").replace(".", "\\.?") +
|
||
"$",
|
||
"i"
|
||
);
|
||
this._shortWeekdaysParse[n] = new RegExp(
|
||
"^" +
|
||
this.weekdaysShort(s, "").replace(
|
||
".",
|
||
"\\.?"
|
||
) +
|
||
"$",
|
||
"i"
|
||
);
|
||
this._minWeekdaysParse[n] = new RegExp(
|
||
"^" +
|
||
this.weekdaysMin(s, "").replace(
|
||
".",
|
||
"\\.?"
|
||
) +
|
||
"$",
|
||
"i"
|
||
);
|
||
}
|
||
if (!this._weekdaysParse[n]) {
|
||
a =
|
||
"^" +
|
||
this.weekdays(s, "") +
|
||
"|^" +
|
||
this.weekdaysShort(s, "") +
|
||
"|^" +
|
||
this.weekdaysMin(s, "");
|
||
this._weekdaysParse[n] = new RegExp(
|
||
a.replace(".", ""),
|
||
"i"
|
||
);
|
||
}
|
||
if (
|
||
r &&
|
||
t === "dddd" &&
|
||
this._fullWeekdaysParse[n].test(e)
|
||
) {
|
||
return n;
|
||
} else if (
|
||
r &&
|
||
t === "ddd" &&
|
||
this._shortWeekdaysParse[n].test(e)
|
||
) {
|
||
return n;
|
||
} else if (
|
||
r &&
|
||
t === "dd" &&
|
||
this._minWeekdaysParse[n].test(e)
|
||
) {
|
||
return n;
|
||
} else if (!r && this._weekdaysParse[n].test(e)) {
|
||
return n;
|
||
}
|
||
}
|
||
}
|
||
function getSetDayOfWeek(e) {
|
||
if (!this.isValid()) {
|
||
return e != null ? this : NaN;
|
||
}
|
||
var t = get(this, "Day");
|
||
if (e != null) {
|
||
e = parseWeekday(e, this.localeData());
|
||
return this.add(e - t, "d");
|
||
} else {
|
||
return t;
|
||
}
|
||
}
|
||
function getSetLocaleDayOfWeek(e) {
|
||
if (!this.isValid()) {
|
||
return e != null ? this : NaN;
|
||
}
|
||
var t = (this.day() + 7 - this.localeData()._week.dow) % 7;
|
||
return e == null ? t : this.add(e - t, "d");
|
||
}
|
||
function getSetISODayOfWeek(e) {
|
||
if (!this.isValid()) {
|
||
return e != null ? this : NaN;
|
||
}
|
||
if (e != null) {
|
||
var t = parseIsoWeekday(e, this.localeData());
|
||
return this.day(this.day() % 7 ? t : t - 7);
|
||
} else {
|
||
return this.day() || 7;
|
||
}
|
||
}
|
||
function weekdaysRegex(e) {
|
||
if (this._weekdaysParseExact) {
|
||
if (!hasOwnProp(this, "_weekdaysRegex")) {
|
||
computeWeekdaysParse.call(this);
|
||
}
|
||
if (e) {
|
||
return this._weekdaysStrictRegex;
|
||
} else {
|
||
return this._weekdaysRegex;
|
||
}
|
||
} else {
|
||
if (!hasOwnProp(this, "_weekdaysRegex")) {
|
||
this._weekdaysRegex = ie;
|
||
}
|
||
return this._weekdaysStrictRegex && e
|
||
? this._weekdaysStrictRegex
|
||
: this._weekdaysRegex;
|
||
}
|
||
}
|
||
function weekdaysShortRegex(e) {
|
||
if (this._weekdaysParseExact) {
|
||
if (!hasOwnProp(this, "_weekdaysRegex")) {
|
||
computeWeekdaysParse.call(this);
|
||
}
|
||
if (e) {
|
||
return this._weekdaysShortStrictRegex;
|
||
} else {
|
||
return this._weekdaysShortRegex;
|
||
}
|
||
} else {
|
||
if (!hasOwnProp(this, "_weekdaysShortRegex")) {
|
||
this._weekdaysShortRegex = oe;
|
||
}
|
||
return this._weekdaysShortStrictRegex && e
|
||
? this._weekdaysShortStrictRegex
|
||
: this._weekdaysShortRegex;
|
||
}
|
||
}
|
||
function weekdaysMinRegex(e) {
|
||
if (this._weekdaysParseExact) {
|
||
if (!hasOwnProp(this, "_weekdaysRegex")) {
|
||
computeWeekdaysParse.call(this);
|
||
}
|
||
if (e) {
|
||
return this._weekdaysMinStrictRegex;
|
||
} else {
|
||
return this._weekdaysMinRegex;
|
||
}
|
||
} else {
|
||
if (!hasOwnProp(this, "_weekdaysMinRegex")) {
|
||
this._weekdaysMinRegex = ue;
|
||
}
|
||
return this._weekdaysMinStrictRegex && e
|
||
? this._weekdaysMinStrictRegex
|
||
: this._weekdaysMinRegex;
|
||
}
|
||
}
|
||
function computeWeekdaysParse() {
|
||
function cmpLenRev(e, t) {
|
||
return t.length - e.length;
|
||
}
|
||
var e = [],
|
||
t = [],
|
||
r = [],
|
||
n = [],
|
||
s,
|
||
a,
|
||
i,
|
||
o,
|
||
u;
|
||
for (s = 0; s < 7; s++) {
|
||
a = createUTC([2e3, 1]).day(s);
|
||
i = regexEscape(this.weekdaysMin(a, ""));
|
||
o = regexEscape(this.weekdaysShort(a, ""));
|
||
u = regexEscape(this.weekdays(a, ""));
|
||
e.push(i);
|
||
t.push(o);
|
||
r.push(u);
|
||
n.push(i);
|
||
n.push(o);
|
||
n.push(u);
|
||
}
|
||
e.sort(cmpLenRev);
|
||
t.sort(cmpLenRev);
|
||
r.sort(cmpLenRev);
|
||
n.sort(cmpLenRev);
|
||
this._weekdaysRegex = new RegExp(
|
||
"^(" + n.join("|") + ")",
|
||
"i"
|
||
);
|
||
this._weekdaysShortRegex = this._weekdaysRegex;
|
||
this._weekdaysMinRegex = this._weekdaysRegex;
|
||
this._weekdaysStrictRegex = new RegExp(
|
||
"^(" + r.join("|") + ")",
|
||
"i"
|
||
);
|
||
this._weekdaysShortStrictRegex = new RegExp(
|
||
"^(" + t.join("|") + ")",
|
||
"i"
|
||
);
|
||
this._weekdaysMinStrictRegex = new RegExp(
|
||
"^(" + e.join("|") + ")",
|
||
"i"
|
||
);
|
||
}
|
||
function hFormat() {
|
||
return this.hours() % 12 || 12;
|
||
}
|
||
function kFormat() {
|
||
return this.hours() || 24;
|
||
}
|
||
addFormatToken("H", ["HH", 2], 0, "hour");
|
||
addFormatToken("h", ["hh", 2], 0, hFormat);
|
||
addFormatToken("k", ["kk", 2], 0, kFormat);
|
||
addFormatToken("hmm", 0, 0, function () {
|
||
return (
|
||
"" + hFormat.apply(this) + zeroFill(this.minutes(), 2)
|
||
);
|
||
});
|
||
addFormatToken("hmmss", 0, 0, function () {
|
||
return (
|
||
"" +
|
||
hFormat.apply(this) +
|
||
zeroFill(this.minutes(), 2) +
|
||
zeroFill(this.seconds(), 2)
|
||
);
|
||
});
|
||
addFormatToken("Hmm", 0, 0, function () {
|
||
return "" + this.hours() + zeroFill(this.minutes(), 2);
|
||
});
|
||
addFormatToken("Hmmss", 0, 0, function () {
|
||
return (
|
||
"" +
|
||
this.hours() +
|
||
zeroFill(this.minutes(), 2) +
|
||
zeroFill(this.seconds(), 2)
|
||
);
|
||
});
|
||
function meridiem(e, t) {
|
||
addFormatToken(e, 0, 0, function () {
|
||
return this.localeData().meridiem(
|
||
this.hours(),
|
||
this.minutes(),
|
||
t
|
||
);
|
||
});
|
||
}
|
||
meridiem("a", true);
|
||
meridiem("A", false);
|
||
function matchMeridiem(e, t) {
|
||
return t._meridiemParse;
|
||
}
|
||
addRegexToken("a", matchMeridiem);
|
||
addRegexToken("A", matchMeridiem);
|
||
addRegexToken("H", O, I);
|
||
addRegexToken("h", O, Y);
|
||
addRegexToken("k", O, Y);
|
||
addRegexToken("HH", O, k);
|
||
addRegexToken("hh", O, k);
|
||
addRegexToken("kk", O, k);
|
||
addRegexToken("hmm", T);
|
||
addRegexToken("hmmss", M);
|
||
addRegexToken("Hmm", T);
|
||
addRegexToken("Hmmss", M);
|
||
addParseToken(["H", "HH"], H);
|
||
addParseToken(["k", "kk"], function (e, t, r) {
|
||
var n = toInt(e);
|
||
t[H] = n === 24 ? 0 : n;
|
||
});
|
||
addParseToken(["a", "A"], function (e, t, r) {
|
||
r._isPm = r._locale.isPM(e);
|
||
r._meridiem = e;
|
||
});
|
||
addParseToken(["h", "hh"], function (e, t, r) {
|
||
t[H] = toInt(e);
|
||
getParsingFlags(r).bigHour = true;
|
||
});
|
||
addParseToken("hmm", function (e, t, r) {
|
||
var n = e.length - 2;
|
||
t[H] = toInt(e.substr(0, n));
|
||
t[B] = toInt(e.substr(n));
|
||
getParsingFlags(r).bigHour = true;
|
||
});
|
||
addParseToken("hmmss", function (e, t, r) {
|
||
var n = e.length - 4,
|
||
s = e.length - 2;
|
||
t[H] = toInt(e.substr(0, n));
|
||
t[B] = toInt(e.substr(n, 2));
|
||
t[V] = toInt(e.substr(s));
|
||
getParsingFlags(r).bigHour = true;
|
||
});
|
||
addParseToken("Hmm", function (e, t, r) {
|
||
var n = e.length - 2;
|
||
t[H] = toInt(e.substr(0, n));
|
||
t[B] = toInt(e.substr(n));
|
||
});
|
||
addParseToken("Hmmss", function (e, t, r) {
|
||
var n = e.length - 4,
|
||
s = e.length - 2;
|
||
t[H] = toInt(e.substr(0, n));
|
||
t[B] = toInt(e.substr(n, 2));
|
||
t[V] = toInt(e.substr(s));
|
||
});
|
||
function localeIsPM(e) {
|
||
return (e + "").toLowerCase().charAt(0) === "p";
|
||
}
|
||
var le = /[ap]\.?m?\.?/i,
|
||
ce = makeGetSet("Hours", true);
|
||
function localeMeridiem(e, t, r) {
|
||
if (e > 11) {
|
||
return r ? "pm" : "PM";
|
||
} else {
|
||
return r ? "am" : "AM";
|
||
}
|
||
}
|
||
var fe = {
|
||
calendar: o,
|
||
longDateFormat: d,
|
||
invalidDate: h,
|
||
ordinal: m,
|
||
dayOfMonthOrdinalParse: p,
|
||
relativeTime: g,
|
||
months: Q,
|
||
monthsShort: X,
|
||
week: re,
|
||
weekdays: ne,
|
||
weekdaysMin: ae,
|
||
weekdaysShort: se,
|
||
meridiemParse: le,
|
||
};
|
||
var de = {},
|
||
he = {},
|
||
me;
|
||
function commonPrefix(e, t) {
|
||
var r,
|
||
n = Math.min(e.length, t.length);
|
||
for (r = 0; r < n; r += 1) {
|
||
if (e[r] !== t[r]) {
|
||
return r;
|
||
}
|
||
}
|
||
return n;
|
||
}
|
||
function normalizeLocale(e) {
|
||
return e ? e.toLowerCase().replace("_", "-") : e;
|
||
}
|
||
function chooseLocale(e) {
|
||
var t = 0,
|
||
r,
|
||
n,
|
||
s,
|
||
a;
|
||
while (t < e.length) {
|
||
a = normalizeLocale(e[t]).split("-");
|
||
r = a.length;
|
||
n = normalizeLocale(e[t + 1]);
|
||
n = n ? n.split("-") : null;
|
||
while (r > 0) {
|
||
s = loadLocale(a.slice(0, r).join("-"));
|
||
if (s) {
|
||
return s;
|
||
}
|
||
if (
|
||
n &&
|
||
n.length >= r &&
|
||
commonPrefix(a, n) >= r - 1
|
||
) {
|
||
break;
|
||
}
|
||
r--;
|
||
}
|
||
t++;
|
||
}
|
||
return me;
|
||
}
|
||
function isLocaleNameSane(e) {
|
||
return !!(e && e.match("^[^/\\\\]*$"));
|
||
}
|
||
function loadLocale(t) {
|
||
var r = null,
|
||
n;
|
||
if (
|
||
de[t] === undefined &&
|
||
"object" !== "undefined" &&
|
||
e &&
|
||
e.exports &&
|
||
isLocaleNameSane(t)
|
||
) {
|
||
try {
|
||
r = me._abbr;
|
||
n = require;
|
||
n("./locale/" + t);
|
||
getSetGlobalLocale(r);
|
||
} catch (e) {
|
||
de[t] = null;
|
||
}
|
||
}
|
||
return de[t];
|
||
}
|
||
function getSetGlobalLocale(e, t) {
|
||
var r;
|
||
if (e) {
|
||
if (isUndefined(t)) {
|
||
r = getLocale(e);
|
||
} else {
|
||
r = defineLocale(e, t);
|
||
}
|
||
if (r) {
|
||
me = r;
|
||
} else {
|
||
if (
|
||
typeof console !== "undefined" &&
|
||
console.warn
|
||
) {
|
||
console.warn(
|
||
"Locale " +
|
||
e +
|
||
" not found. Did you forget to load it?"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
return me._abbr;
|
||
}
|
||
function defineLocale(e, t) {
|
||
if (t !== null) {
|
||
var r,
|
||
n = fe;
|
||
t.abbr = e;
|
||
if (de[e] != null) {
|
||
deprecateSimple(
|
||
"defineLocaleOverride",
|
||
"use moment.updateLocale(localeName, config) to change " +
|
||
"an existing locale. moment.defineLocale(localeName, " +
|
||
"config) should only be used for creating a new locale " +
|
||
"See http://momentjs.com/guides/#/warnings/define-locale/ for more info."
|
||
);
|
||
n = de[e]._config;
|
||
} else if (t.parentLocale != null) {
|
||
if (de[t.parentLocale] != null) {
|
||
n = de[t.parentLocale]._config;
|
||
} else {
|
||
r = loadLocale(t.parentLocale);
|
||
if (r != null) {
|
||
n = r._config;
|
||
} else {
|
||
if (!he[t.parentLocale]) {
|
||
he[t.parentLocale] = [];
|
||
}
|
||
he[t.parentLocale].push({
|
||
name: e,
|
||
config: t,
|
||
});
|
||
return null;
|
||
}
|
||
}
|
||
}
|
||
de[e] = new Locale(mergeConfigs(n, t));
|
||
if (he[e]) {
|
||
he[e].forEach(function (e) {
|
||
defineLocale(e.name, e.config);
|
||
});
|
||
}
|
||
getSetGlobalLocale(e);
|
||
return de[e];
|
||
} else {
|
||
delete de[e];
|
||
return null;
|
||
}
|
||
}
|
||
function updateLocale(e, t) {
|
||
if (t != null) {
|
||
var r,
|
||
n,
|
||
s = fe;
|
||
if (de[e] != null && de[e].parentLocale != null) {
|
||
de[e].set(mergeConfigs(de[e]._config, t));
|
||
} else {
|
||
n = loadLocale(e);
|
||
if (n != null) {
|
||
s = n._config;
|
||
}
|
||
t = mergeConfigs(s, t);
|
||
if (n == null) {
|
||
t.abbr = e;
|
||
}
|
||
r = new Locale(t);
|
||
r.parentLocale = de[e];
|
||
de[e] = r;
|
||
}
|
||
getSetGlobalLocale(e);
|
||
} else {
|
||
if (de[e] != null) {
|
||
if (de[e].parentLocale != null) {
|
||
de[e] = de[e].parentLocale;
|
||
if (e === getSetGlobalLocale()) {
|
||
getSetGlobalLocale(e);
|
||
}
|
||
} else if (de[e] != null) {
|
||
delete de[e];
|
||
}
|
||
}
|
||
}
|
||
return de[e];
|
||
}
|
||
function getLocale(e) {
|
||
var t;
|
||
if (e && e._locale && e._locale._abbr) {
|
||
e = e._locale._abbr;
|
||
}
|
||
if (!e) {
|
||
return me;
|
||
}
|
||
if (!isArray(e)) {
|
||
t = loadLocale(e);
|
||
if (t) {
|
||
return t;
|
||
}
|
||
e = [e];
|
||
}
|
||
return chooseLocale(e);
|
||
}
|
||
function listLocales() {
|
||
return i(de);
|
||
}
|
||
function checkOverflow(e) {
|
||
var t,
|
||
r = e._a;
|
||
if (r && getParsingFlags(e).overflow === -2) {
|
||
t =
|
||
r[j] < 0 || r[j] > 11
|
||
? j
|
||
: r[q] < 1 || r[q] > daysInMonth(r[W], r[j])
|
||
? q
|
||
: r[H] < 0 ||
|
||
r[H] > 24 ||
|
||
(r[H] === 24 &&
|
||
(r[B] !== 0 || r[V] !== 0 || r[G] !== 0))
|
||
? H
|
||
: r[B] < 0 || r[B] > 59
|
||
? B
|
||
: r[V] < 0 || r[V] > 59
|
||
? V
|
||
: r[G] < 0 || r[G] > 999
|
||
? G
|
||
: -1;
|
||
if (
|
||
getParsingFlags(e)._overflowDayOfYear &&
|
||
(t < W || t > q)
|
||
) {
|
||
t = q;
|
||
}
|
||
if (getParsingFlags(e)._overflowWeeks && t === -1) {
|
||
t = $;
|
||
}
|
||
if (getParsingFlags(e)._overflowWeekday && t === -1) {
|
||
t = z;
|
||
}
|
||
getParsingFlags(e).overflow = t;
|
||
}
|
||
return e;
|
||
}
|
||
var pe =
|
||
/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
|
||
ge =
|
||
/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
|
||
ye = /Z|[+-]\d\d(?::?\d\d)?/,
|
||
_e = [
|
||
["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/],
|
||
["YYYY-MM-DD", /\d{4}-\d\d-\d\d/],
|
||
["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/],
|
||
["GGGG-[W]WW", /\d{4}-W\d\d/, false],
|
||
["YYYY-DDD", /\d{4}-\d{3}/],
|
||
["YYYY-MM", /\d{4}-\d\d/, false],
|
||
["YYYYYYMMDD", /[+-]\d{10}/],
|
||
["YYYYMMDD", /\d{8}/],
|
||
["GGGG[W]WWE", /\d{4}W\d{3}/],
|
||
["GGGG[W]WW", /\d{4}W\d{2}/, false],
|
||
["YYYYDDD", /\d{7}/],
|
||
["YYYYMM", /\d{6}/, false],
|
||
["YYYY", /\d{4}/, false],
|
||
],
|
||
ve = [
|
||
["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/],
|
||
["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/],
|
||
["HH:mm:ss", /\d\d:\d\d:\d\d/],
|
||
["HH:mm", /\d\d:\d\d/],
|
||
["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/],
|
||
["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/],
|
||
["HHmmss", /\d\d\d\d\d\d/],
|
||
["HHmm", /\d\d\d\d/],
|
||
["HH", /\d\d/],
|
||
],
|
||
ke = /^\/?Date\((-?\d+)/i,
|
||
we =
|
||
/^(?:(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{4}))$/,
|
||
be = {
|
||
UT: 0,
|
||
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 configFromISO(e) {
|
||
var t,
|
||
r,
|
||
n = e._i,
|
||
s = pe.exec(n) || ge.exec(n),
|
||
a,
|
||
i,
|
||
o,
|
||
u,
|
||
l = _e.length,
|
||
c = ve.length;
|
||
if (s) {
|
||
getParsingFlags(e).iso = true;
|
||
for (t = 0, r = l; t < r; t++) {
|
||
if (_e[t][1].exec(s[1])) {
|
||
i = _e[t][0];
|
||
a = _e[t][2] !== false;
|
||
break;
|
||
}
|
||
}
|
||
if (i == null) {
|
||
e._isValid = false;
|
||
return;
|
||
}
|
||
if (s[3]) {
|
||
for (t = 0, r = c; t < r; t++) {
|
||
if (ve[t][1].exec(s[3])) {
|
||
o = (s[2] || " ") + ve[t][0];
|
||
break;
|
||
}
|
||
}
|
||
if (o == null) {
|
||
e._isValid = false;
|
||
return;
|
||
}
|
||
}
|
||
if (!a && o != null) {
|
||
e._isValid = false;
|
||
return;
|
||
}
|
||
if (s[4]) {
|
||
if (ye.exec(s[4])) {
|
||
u = "Z";
|
||
} else {
|
||
e._isValid = false;
|
||
return;
|
||
}
|
||
}
|
||
e._f = i + (o || "") + (u || "");
|
||
configFromStringAndFormat(e);
|
||
} else {
|
||
e._isValid = false;
|
||
}
|
||
}
|
||
function extractFromRFC2822Strings(e, t, r, n, s, a) {
|
||
var i = [
|
||
untruncateYear(e),
|
||
X.indexOf(t),
|
||
parseInt(r, 10),
|
||
parseInt(n, 10),
|
||
parseInt(s, 10),
|
||
];
|
||
if (a) {
|
||
i.push(parseInt(a, 10));
|
||
}
|
||
return i;
|
||
}
|
||
function untruncateYear(e) {
|
||
var t = parseInt(e, 10);
|
||
if (t <= 49) {
|
||
return 2e3 + t;
|
||
} else if (t <= 999) {
|
||
return 1900 + t;
|
||
}
|
||
return t;
|
||
}
|
||
function preprocessRFC2822(e) {
|
||
return e
|
||
.replace(/\([^()]*\)|[\n\t]/g, " ")
|
||
.replace(/(\s\s+)/g, " ")
|
||
.replace(/^\s\s*/, "")
|
||
.replace(/\s\s*$/, "");
|
||
}
|
||
function checkWeekday(e, t, r) {
|
||
if (e) {
|
||
var n = se.indexOf(e),
|
||
s = new Date(t[0], t[1], t[2]).getDay();
|
||
if (n !== s) {
|
||
getParsingFlags(r).weekdayMismatch = true;
|
||
r._isValid = false;
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
function calculateOffset(e, t, r) {
|
||
if (e) {
|
||
return be[e];
|
||
} else if (t) {
|
||
return 0;
|
||
} else {
|
||
var n = parseInt(r, 10),
|
||
s = n % 100,
|
||
a = (n - s) / 100;
|
||
return a * 60 + s;
|
||
}
|
||
}
|
||
function configFromRFC2822(e) {
|
||
var t = we.exec(preprocessRFC2822(e._i)),
|
||
r;
|
||
if (t) {
|
||
r = extractFromRFC2822Strings(
|
||
t[4],
|
||
t[3],
|
||
t[2],
|
||
t[5],
|
||
t[6],
|
||
t[7]
|
||
);
|
||
if (!checkWeekday(t[1], r, e)) {
|
||
return;
|
||
}
|
||
e._a = r;
|
||
e._tzm = calculateOffset(t[8], t[9], t[10]);
|
||
e._d = createUTCDate.apply(null, e._a);
|
||
e._d.setUTCMinutes(e._d.getUTCMinutes() - e._tzm);
|
||
getParsingFlags(e).rfc2822 = true;
|
||
} else {
|
||
e._isValid = false;
|
||
}
|
||
}
|
||
function configFromString(e) {
|
||
var t = ke.exec(e._i);
|
||
if (t !== null) {
|
||
e._d = new Date(+t[1]);
|
||
return;
|
||
}
|
||
configFromISO(e);
|
||
if (e._isValid === false) {
|
||
delete e._isValid;
|
||
} else {
|
||
return;
|
||
}
|
||
configFromRFC2822(e);
|
||
if (e._isValid === false) {
|
||
delete e._isValid;
|
||
} else {
|
||
return;
|
||
}
|
||
if (e._strict) {
|
||
e._isValid = false;
|
||
} else {
|
||
hooks.createFromInputFallback(e);
|
||
}
|
||
}
|
||
hooks.createFromInputFallback = deprecate(
|
||
"value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), " +
|
||
"which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are " +
|
||
"discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",
|
||
function (e) {
|
||
e._d = new Date(e._i + (e._useUTC ? " UTC" : ""));
|
||
}
|
||
);
|
||
function defaults(e, t, r) {
|
||
if (e != null) {
|
||
return e;
|
||
}
|
||
if (t != null) {
|
||
return t;
|
||
}
|
||
return r;
|
||
}
|
||
function currentDateArray(e) {
|
||
var t = new Date(hooks.now());
|
||
if (e._useUTC) {
|
||
return [
|
||
t.getUTCFullYear(),
|
||
t.getUTCMonth(),
|
||
t.getUTCDate(),
|
||
];
|
||
}
|
||
return [t.getFullYear(), t.getMonth(), t.getDate()];
|
||
}
|
||
function configFromArray(e) {
|
||
var t,
|
||
r,
|
||
n = [],
|
||
s,
|
||
a,
|
||
i;
|
||
if (e._d) {
|
||
return;
|
||
}
|
||
s = currentDateArray(e);
|
||
if (e._w && e._a[q] == null && e._a[j] == null) {
|
||
dayOfYearFromWeekInfo(e);
|
||
}
|
||
if (e._dayOfYear != null) {
|
||
i = defaults(e._a[W], s[W]);
|
||
if (
|
||
e._dayOfYear > daysInYear(i) ||
|
||
e._dayOfYear === 0
|
||
) {
|
||
getParsingFlags(e)._overflowDayOfYear = true;
|
||
}
|
||
r = createUTCDate(i, 0, e._dayOfYear);
|
||
e._a[j] = r.getUTCMonth();
|
||
e._a[q] = r.getUTCDate();
|
||
}
|
||
for (t = 0; t < 3 && e._a[t] == null; ++t) {
|
||
e._a[t] = n[t] = s[t];
|
||
}
|
||
for (; t < 7; t++) {
|
||
e._a[t] = n[t] =
|
||
e._a[t] == null ? (t === 2 ? 1 : 0) : e._a[t];
|
||
}
|
||
if (
|
||
e._a[H] === 24 &&
|
||
e._a[B] === 0 &&
|
||
e._a[V] === 0 &&
|
||
e._a[G] === 0
|
||
) {
|
||
e._nextDay = true;
|
||
e._a[H] = 0;
|
||
}
|
||
e._d = (e._useUTC ? createUTCDate : createDate).apply(
|
||
null,
|
||
n
|
||
);
|
||
a = e._useUTC ? e._d.getUTCDay() : e._d.getDay();
|
||
if (e._tzm != null) {
|
||
e._d.setUTCMinutes(e._d.getUTCMinutes() - e._tzm);
|
||
}
|
||
if (e._nextDay) {
|
||
e._a[H] = 24;
|
||
}
|
||
if (e._w && typeof e._w.d !== "undefined" && e._w.d !== a) {
|
||
getParsingFlags(e).weekdayMismatch = true;
|
||
}
|
||
}
|
||
function dayOfYearFromWeekInfo(e) {
|
||
var t, r, n, s, a, i, o, u, l;
|
||
t = e._w;
|
||
if (t.GG != null || t.W != null || t.E != null) {
|
||
a = 1;
|
||
i = 4;
|
||
r = defaults(
|
||
t.GG,
|
||
e._a[W],
|
||
weekOfYear(createLocal(), 1, 4).year
|
||
);
|
||
n = defaults(t.W, 1);
|
||
s = defaults(t.E, 1);
|
||
if (s < 1 || s > 7) {
|
||
u = true;
|
||
}
|
||
} else {
|
||
a = e._locale._week.dow;
|
||
i = e._locale._week.doy;
|
||
l = weekOfYear(createLocal(), a, i);
|
||
r = defaults(t.gg, e._a[W], l.year);
|
||
n = defaults(t.w, l.week);
|
||
if (t.d != null) {
|
||
s = t.d;
|
||
if (s < 0 || s > 6) {
|
||
u = true;
|
||
}
|
||
} else if (t.e != null) {
|
||
s = t.e + a;
|
||
if (t.e < 0 || t.e > 6) {
|
||
u = true;
|
||
}
|
||
} else {
|
||
s = a;
|
||
}
|
||
}
|
||
if (n < 1 || n > weeksInYear(r, a, i)) {
|
||
getParsingFlags(e)._overflowWeeks = true;
|
||
} else if (u != null) {
|
||
getParsingFlags(e)._overflowWeekday = true;
|
||
} else {
|
||
o = dayOfYearFromWeeks(r, n, s, a, i);
|
||
e._a[W] = o.year;
|
||
e._dayOfYear = o.dayOfYear;
|
||
}
|
||
}
|
||
hooks.ISO_8601 = function () {};
|
||
hooks.RFC_2822 = function () {};
|
||
function configFromStringAndFormat(e) {
|
||
if (e._f === hooks.ISO_8601) {
|
||
configFromISO(e);
|
||
return;
|
||
}
|
||
if (e._f === hooks.RFC_2822) {
|
||
configFromRFC2822(e);
|
||
return;
|
||
}
|
||
e._a = [];
|
||
getParsingFlags(e).empty = true;
|
||
var t = "" + e._i,
|
||
r,
|
||
n,
|
||
s,
|
||
a,
|
||
i,
|
||
o = t.length,
|
||
l = 0,
|
||
c,
|
||
d;
|
||
s = expandFormat(e._f, e._locale).match(u) || [];
|
||
d = s.length;
|
||
for (r = 0; r < d; r++) {
|
||
a = s[r];
|
||
n = (t.match(getParseRegexForToken(a, e)) || [])[0];
|
||
if (n) {
|
||
i = t.substr(0, t.indexOf(n));
|
||
if (i.length > 0) {
|
||
getParsingFlags(e).unusedInput.push(i);
|
||
}
|
||
t = t.slice(t.indexOf(n) + n.length);
|
||
l += n.length;
|
||
}
|
||
if (f[a]) {
|
||
if (n) {
|
||
getParsingFlags(e).empty = false;
|
||
} else {
|
||
getParsingFlags(e).unusedTokens.push(a);
|
||
}
|
||
addTimeToArrayFromToken(a, n, e);
|
||
} else if (e._strict && !n) {
|
||
getParsingFlags(e).unusedTokens.push(a);
|
||
}
|
||
}
|
||
getParsingFlags(e).charsLeftOver = o - l;
|
||
if (t.length > 0) {
|
||
getParsingFlags(e).unusedInput.push(t);
|
||
}
|
||
if (
|
||
e._a[H] <= 12 &&
|
||
getParsingFlags(e).bigHour === true &&
|
||
e._a[H] > 0
|
||
) {
|
||
getParsingFlags(e).bigHour = undefined;
|
||
}
|
||
getParsingFlags(e).parsedDateParts = e._a.slice(0);
|
||
getParsingFlags(e).meridiem = e._meridiem;
|
||
e._a[H] = meridiemFixWrap(e._locale, e._a[H], e._meridiem);
|
||
c = getParsingFlags(e).era;
|
||
if (c !== null) {
|
||
e._a[W] = e._locale.erasConvertYear(c, e._a[W]);
|
||
}
|
||
configFromArray(e);
|
||
checkOverflow(e);
|
||
}
|
||
function meridiemFixWrap(e, t, r) {
|
||
var n;
|
||
if (r == null) {
|
||
return t;
|
||
}
|
||
if (e.meridiemHour != null) {
|
||
return e.meridiemHour(t, r);
|
||
} else if (e.isPM != null) {
|
||
n = e.isPM(r);
|
||
if (n && t < 12) {
|
||
t += 12;
|
||
}
|
||
if (!n && t === 12) {
|
||
t = 0;
|
||
}
|
||
return t;
|
||
} else {
|
||
return t;
|
||
}
|
||
}
|
||
function configFromStringAndArray(e) {
|
||
var t,
|
||
r,
|
||
n,
|
||
s,
|
||
a,
|
||
i,
|
||
o = false,
|
||
u = e._f.length;
|
||
if (u === 0) {
|
||
getParsingFlags(e).invalidFormat = true;
|
||
e._d = new Date(NaN);
|
||
return;
|
||
}
|
||
for (s = 0; s < u; s++) {
|
||
a = 0;
|
||
i = false;
|
||
t = copyConfig({}, e);
|
||
if (e._useUTC != null) {
|
||
t._useUTC = e._useUTC;
|
||
}
|
||
t._f = e._f[s];
|
||
configFromStringAndFormat(t);
|
||
if (isValid(t)) {
|
||
i = true;
|
||
}
|
||
a += getParsingFlags(t).charsLeftOver;
|
||
a += getParsingFlags(t).unusedTokens.length * 10;
|
||
getParsingFlags(t).score = a;
|
||
if (!o) {
|
||
if (n == null || a < n || i) {
|
||
n = a;
|
||
r = t;
|
||
if (i) {
|
||
o = true;
|
||
}
|
||
}
|
||
} else {
|
||
if (a < n) {
|
||
n = a;
|
||
r = t;
|
||
}
|
||
}
|
||
}
|
||
extend(e, r || t);
|
||
}
|
||
function configFromObject(e) {
|
||
if (e._d) {
|
||
return;
|
||
}
|
||
var t = normalizeObjectUnits(e._i),
|
||
r = t.day === undefined ? t.date : t.day;
|
||
e._a = map(
|
||
[
|
||
t.year,
|
||
t.month,
|
||
r,
|
||
t.hour,
|
||
t.minute,
|
||
t.second,
|
||
t.millisecond,
|
||
],
|
||
function (e) {
|
||
return e && parseInt(e, 10);
|
||
}
|
||
);
|
||
configFromArray(e);
|
||
}
|
||
function createFromConfig(e) {
|
||
var t = new Moment(checkOverflow(prepareConfig(e)));
|
||
if (t._nextDay) {
|
||
t.add(1, "d");
|
||
t._nextDay = undefined;
|
||
}
|
||
return t;
|
||
}
|
||
function prepareConfig(e) {
|
||
var t = e._i,
|
||
r = e._f;
|
||
e._locale = e._locale || getLocale(e._l);
|
||
if (t === null || (r === undefined && t === "")) {
|
||
return createInvalid({ nullInput: true });
|
||
}
|
||
if (typeof t === "string") {
|
||
e._i = t = e._locale.preparse(t);
|
||
}
|
||
if (isMoment(t)) {
|
||
return new Moment(checkOverflow(t));
|
||
} else if (isDate(t)) {
|
||
e._d = t;
|
||
} else if (isArray(r)) {
|
||
configFromStringAndArray(e);
|
||
} else if (r) {
|
||
configFromStringAndFormat(e);
|
||
} else {
|
||
configFromInput(e);
|
||
}
|
||
if (!isValid(e)) {
|
||
e._d = null;
|
||
}
|
||
return e;
|
||
}
|
||
function configFromInput(e) {
|
||
var t = e._i;
|
||
if (isUndefined(t)) {
|
||
e._d = new Date(hooks.now());
|
||
} else if (isDate(t)) {
|
||
e._d = new Date(t.valueOf());
|
||
} else if (typeof t === "string") {
|
||
configFromString(e);
|
||
} else if (isArray(t)) {
|
||
e._a = map(t.slice(0), function (e) {
|
||
return parseInt(e, 10);
|
||
});
|
||
configFromArray(e);
|
||
} else if (isObject(t)) {
|
||
configFromObject(e);
|
||
} else if (isNumber(t)) {
|
||
e._d = new Date(t);
|
||
} else {
|
||
hooks.createFromInputFallback(e);
|
||
}
|
||
}
|
||
function createLocalOrUTC(e, t, r, n, s) {
|
||
var a = {};
|
||
if (t === true || t === false) {
|
||
n = t;
|
||
t = undefined;
|
||
}
|
||
if (r === true || r === false) {
|
||
n = r;
|
||
r = undefined;
|
||
}
|
||
if (
|
||
(isObject(e) && isObjectEmpty(e)) ||
|
||
(isArray(e) && e.length === 0)
|
||
) {
|
||
e = undefined;
|
||
}
|
||
a._isAMomentObject = true;
|
||
a._useUTC = a._isUTC = s;
|
||
a._l = r;
|
||
a._i = e;
|
||
a._f = t;
|
||
a._strict = n;
|
||
return createFromConfig(a);
|
||
}
|
||
function createLocal(e, t, r, n) {
|
||
return createLocalOrUTC(e, t, r, n, false);
|
||
}
|
||
var Se = deprecate(
|
||
"moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",
|
||
function () {
|
||
var e = createLocal.apply(null, arguments);
|
||
if (this.isValid() && e.isValid()) {
|
||
return e < this ? this : e;
|
||
} else {
|
||
return createInvalid();
|
||
}
|
||
}
|
||
),
|
||
Oe = deprecate(
|
||
"moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",
|
||
function () {
|
||
var e = createLocal.apply(null, arguments);
|
||
if (this.isValid() && e.isValid()) {
|
||
return e > this ? this : e;
|
||
} else {
|
||
return createInvalid();
|
||
}
|
||
}
|
||
);
|
||
function pickBy(e, t) {
|
||
var r, n;
|
||
if (t.length === 1 && isArray(t[0])) {
|
||
t = t[0];
|
||
}
|
||
if (!t.length) {
|
||
return createLocal();
|
||
}
|
||
r = t[0];
|
||
for (n = 1; n < t.length; ++n) {
|
||
if (!t[n].isValid() || t[n][e](r)) {
|
||
r = t[n];
|
||
}
|
||
}
|
||
return r;
|
||
}
|
||
function min() {
|
||
var e = [].slice.call(arguments, 0);
|
||
return pickBy("isBefore", e);
|
||
}
|
||
function max() {
|
||
var e = [].slice.call(arguments, 0);
|
||
return pickBy("isAfter", e);
|
||
}
|
||
var now = function () {
|
||
return Date.now ? Date.now() : +new Date();
|
||
};
|
||
var Te = [
|
||
"year",
|
||
"quarter",
|
||
"month",
|
||
"week",
|
||
"day",
|
||
"hour",
|
||
"minute",
|
||
"second",
|
||
"millisecond",
|
||
];
|
||
function isDurationValid(e) {
|
||
var t,
|
||
r = false,
|
||
n,
|
||
s = Te.length;
|
||
for (t in e) {
|
||
if (
|
||
hasOwnProp(e, t) &&
|
||
!(
|
||
J.call(Te, t) !== -1 &&
|
||
(e[t] == null || !isNaN(e[t]))
|
||
)
|
||
) {
|
||
return false;
|
||
}
|
||
}
|
||
for (n = 0; n < s; ++n) {
|
||
if (e[Te[n]]) {
|
||
if (r) {
|
||
return false;
|
||
}
|
||
if (parseFloat(e[Te[n]]) !== toInt(e[Te[n]])) {
|
||
r = true;
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
function isValid$1() {
|
||
return this._isValid;
|
||
}
|
||
function createInvalid$1() {
|
||
return createDuration(NaN);
|
||
}
|
||
function Duration(e) {
|
||
var t = normalizeObjectUnits(e),
|
||
r = t.year || 0,
|
||
n = t.quarter || 0,
|
||
s = t.month || 0,
|
||
a = t.week || t.isoWeek || 0,
|
||
i = t.day || 0,
|
||
o = t.hour || 0,
|
||
u = t.minute || 0,
|
||
l = t.second || 0,
|
||
c = t.millisecond || 0;
|
||
this._isValid = isDurationValid(t);
|
||
this._milliseconds =
|
||
+c + l * 1e3 + u * 6e4 + o * 1e3 * 60 * 60;
|
||
this._days = +i + a * 7;
|
||
this._months = +s + n * 3 + r * 12;
|
||
this._data = {};
|
||
this._locale = getLocale();
|
||
this._bubble();
|
||
}
|
||
function isDuration(e) {
|
||
return e instanceof Duration;
|
||
}
|
||
function absRound(e) {
|
||
if (e < 0) {
|
||
return Math.round(-1 * e) * -1;
|
||
} else {
|
||
return Math.round(e);
|
||
}
|
||
}
|
||
function compareArrays(e, t, r) {
|
||
var n = Math.min(e.length, t.length),
|
||
s = Math.abs(e.length - t.length),
|
||
a = 0,
|
||
i;
|
||
for (i = 0; i < n; i++) {
|
||
if (
|
||
(r && e[i] !== t[i]) ||
|
||
(!r && toInt(e[i]) !== toInt(t[i]))
|
||
) {
|
||
a++;
|
||
}
|
||
}
|
||
return a + s;
|
||
}
|
||
function offset(e, t) {
|
||
addFormatToken(e, 0, 0, function () {
|
||
var e = this.utcOffset(),
|
||
r = "+";
|
||
if (e < 0) {
|
||
e = -e;
|
||
r = "-";
|
||
}
|
||
return (
|
||
r +
|
||
zeroFill(~~(e / 60), 2) +
|
||
t +
|
||
zeroFill(~~e % 60, 2)
|
||
);
|
||
});
|
||
}
|
||
offset("Z", ":");
|
||
offset("ZZ", "");
|
||
addRegexToken("Z", P);
|
||
addRegexToken("ZZ", P);
|
||
addParseToken(["Z", "ZZ"], function (e, t, r) {
|
||
r._useUTC = true;
|
||
r._tzm = offsetFromString(P, e);
|
||
});
|
||
var Me = /([\+\-]|\d\d)/gi;
|
||
function offsetFromString(e, t) {
|
||
var r = (t || "").match(e),
|
||
n,
|
||
s,
|
||
a;
|
||
if (r === null) {
|
||
return null;
|
||
}
|
||
n = r[r.length - 1] || [];
|
||
s = (n + "").match(Me) || ["-", 0, 0];
|
||
a = +(s[1] * 60) + toInt(s[2]);
|
||
return a === 0 ? 0 : s[0] === "+" ? a : -a;
|
||
}
|
||
function cloneWithOffset(e, t) {
|
||
var r, n;
|
||
if (t._isUTC) {
|
||
r = t.clone();
|
||
n =
|
||
(isMoment(e) || isDate(e)
|
||
? e.valueOf()
|
||
: createLocal(e).valueOf()) - r.valueOf();
|
||
r._d.setTime(r._d.valueOf() + n);
|
||
hooks.updateOffset(r, false);
|
||
return r;
|
||
} else {
|
||
return createLocal(e).local();
|
||
}
|
||
}
|
||
function getDateOffset(e) {
|
||
return -Math.round(e._d.getTimezoneOffset());
|
||
}
|
||
hooks.updateOffset = function () {};
|
||
function getSetOffset(e, t, r) {
|
||
var n = this._offset || 0,
|
||
s;
|
||
if (!this.isValid()) {
|
||
return e != null ? this : NaN;
|
||
}
|
||
if (e != null) {
|
||
if (typeof e === "string") {
|
||
e = offsetFromString(P, e);
|
||
if (e === null) {
|
||
return this;
|
||
}
|
||
} else if (Math.abs(e) < 16 && !r) {
|
||
e = e * 60;
|
||
}
|
||
if (!this._isUTC && t) {
|
||
s = getDateOffset(this);
|
||
}
|
||
this._offset = e;
|
||
this._isUTC = true;
|
||
if (s != null) {
|
||
this.add(s, "m");
|
||
}
|
||
if (n !== e) {
|
||
if (!t || this._changeInProgress) {
|
||
addSubtract(
|
||
this,
|
||
createDuration(e - n, "m"),
|
||
1,
|
||
false
|
||
);
|
||
} else if (!this._changeInProgress) {
|
||
this._changeInProgress = true;
|
||
hooks.updateOffset(this, true);
|
||
this._changeInProgress = null;
|
||
}
|
||
}
|
||
return this;
|
||
} else {
|
||
return this._isUTC ? n : getDateOffset(this);
|
||
}
|
||
}
|
||
function getSetZone(e, t) {
|
||
if (e != null) {
|
||
if (typeof e !== "string") {
|
||
e = -e;
|
||
}
|
||
this.utcOffset(e, t);
|
||
return this;
|
||
} else {
|
||
return -this.utcOffset();
|
||
}
|
||
}
|
||
function setOffsetToUTC(e) {
|
||
return this.utcOffset(0, e);
|
||
}
|
||
function setOffsetToLocal(e) {
|
||
if (this._isUTC) {
|
||
this.utcOffset(0, e);
|
||
this._isUTC = false;
|
||
if (e) {
|
||
this.subtract(getDateOffset(this), "m");
|
||
}
|
||
}
|
||
return this;
|
||
}
|
||
function setOffsetToParsedOffset() {
|
||
if (this._tzm != null) {
|
||
this.utcOffset(this._tzm, false, true);
|
||
} else if (typeof this._i === "string") {
|
||
var e = offsetFromString(F, this._i);
|
||
if (e != null) {
|
||
this.utcOffset(e);
|
||
} else {
|
||
this.utcOffset(0, true);
|
||
}
|
||
}
|
||
return this;
|
||
}
|
||
function hasAlignedHourOffset(e) {
|
||
if (!this.isValid()) {
|
||
return false;
|
||
}
|
||
e = e ? createLocal(e).utcOffset() : 0;
|
||
return (this.utcOffset() - e) % 60 === 0;
|
||
}
|
||
function isDaylightSavingTime() {
|
||
return (
|
||
this.utcOffset() > this.clone().month(0).utcOffset() ||
|
||
this.utcOffset() > this.clone().month(5).utcOffset()
|
||
);
|
||
}
|
||
function isDaylightSavingTimeShifted() {
|
||
if (!isUndefined(this._isDSTShifted)) {
|
||
return this._isDSTShifted;
|
||
}
|
||
var e = {},
|
||
t;
|
||
copyConfig(e, this);
|
||
e = prepareConfig(e);
|
||
if (e._a) {
|
||
t = e._isUTC ? createUTC(e._a) : createLocal(e._a);
|
||
this._isDSTShifted =
|
||
this.isValid() &&
|
||
compareArrays(e._a, t.toArray()) > 0;
|
||
} else {
|
||
this._isDSTShifted = false;
|
||
}
|
||
return this._isDSTShifted;
|
||
}
|
||
function isLocal() {
|
||
return this.isValid() ? !this._isUTC : false;
|
||
}
|
||
function isUtcOffset() {
|
||
return this.isValid() ? this._isUTC : false;
|
||
}
|
||
function isUtc() {
|
||
return this.isValid()
|
||
? this._isUTC && this._offset === 0
|
||
: false;
|
||
}
|
||
var De =
|
||
/^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,
|
||
xe =
|
||
/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
|
||
function createDuration(e, t) {
|
||
var r = e,
|
||
n = null,
|
||
s,
|
||
a,
|
||
i;
|
||
if (isDuration(e)) {
|
||
r = { ms: e._milliseconds, d: e._days, M: e._months };
|
||
} else if (isNumber(e) || !isNaN(+e)) {
|
||
r = {};
|
||
if (t) {
|
||
r[t] = +e;
|
||
} else {
|
||
r.milliseconds = +e;
|
||
}
|
||
} else if ((n = De.exec(e))) {
|
||
s = n[1] === "-" ? -1 : 1;
|
||
r = {
|
||
y: 0,
|
||
d: toInt(n[q]) * s,
|
||
h: toInt(n[H]) * s,
|
||
m: toInt(n[B]) * s,
|
||
s: toInt(n[V]) * s,
|
||
ms: toInt(absRound(n[G] * 1e3)) * s,
|
||
};
|
||
} else if ((n = xe.exec(e))) {
|
||
s = n[1] === "-" ? -1 : 1;
|
||
r = {
|
||
y: parseIso(n[2], s),
|
||
M: parseIso(n[3], s),
|
||
w: parseIso(n[4], s),
|
||
d: parseIso(n[5], s),
|
||
h: parseIso(n[6], s),
|
||
m: parseIso(n[7], s),
|
||
s: parseIso(n[8], s),
|
||
};
|
||
} else if (r == null) {
|
||
r = {};
|
||
} else if (
|
||
typeof r === "object" &&
|
||
("from" in r || "to" in r)
|
||
) {
|
||
i = momentsDifference(
|
||
createLocal(r.from),
|
||
createLocal(r.to)
|
||
);
|
||
r = {};
|
||
r.ms = i.milliseconds;
|
||
r.M = i.months;
|
||
}
|
||
a = new Duration(r);
|
||
if (isDuration(e) && hasOwnProp(e, "_locale")) {
|
||
a._locale = e._locale;
|
||
}
|
||
if (isDuration(e) && hasOwnProp(e, "_isValid")) {
|
||
a._isValid = e._isValid;
|
||
}
|
||
return a;
|
||
}
|
||
createDuration.fn = Duration.prototype;
|
||
createDuration.invalid = createInvalid$1;
|
||
function parseIso(e, t) {
|
||
var r = e && parseFloat(e.replace(",", "."));
|
||
return (isNaN(r) ? 0 : r) * t;
|
||
}
|
||
function positiveMomentsDifference(e, t) {
|
||
var r = {};
|
||
r.months =
|
||
t.month() - e.month() + (t.year() - e.year()) * 12;
|
||
if (e.clone().add(r.months, "M").isAfter(t)) {
|
||
--r.months;
|
||
}
|
||
r.milliseconds = +t - +e.clone().add(r.months, "M");
|
||
return r;
|
||
}
|
||
function momentsDifference(e, t) {
|
||
var r;
|
||
if (!(e.isValid() && t.isValid())) {
|
||
return { milliseconds: 0, months: 0 };
|
||
}
|
||
t = cloneWithOffset(t, e);
|
||
if (e.isBefore(t)) {
|
||
r = positiveMomentsDifference(e, t);
|
||
} else {
|
||
r = positiveMomentsDifference(t, e);
|
||
r.milliseconds = -r.milliseconds;
|
||
r.months = -r.months;
|
||
}
|
||
return r;
|
||
}
|
||
function createAdder(e, t) {
|
||
return function (r, n) {
|
||
var s, a;
|
||
if (n !== null && !isNaN(+n)) {
|
||
deprecateSimple(
|
||
t,
|
||
"moment()." +
|
||
t +
|
||
"(period, number) is deprecated. Please use moment()." +
|
||
t +
|
||
"(number, period). " +
|
||
"See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."
|
||
);
|
||
a = r;
|
||
r = n;
|
||
n = a;
|
||
}
|
||
s = createDuration(r, n);
|
||
addSubtract(this, s, e);
|
||
return this;
|
||
};
|
||
}
|
||
function addSubtract(e, t, r, n) {
|
||
var s = t._milliseconds,
|
||
a = absRound(t._days),
|
||
i = absRound(t._months);
|
||
if (!e.isValid()) {
|
||
return;
|
||
}
|
||
n = n == null ? true : n;
|
||
if (i) {
|
||
setMonth(e, get(e, "Month") + i * r);
|
||
}
|
||
if (a) {
|
||
set$1(e, "Date", get(e, "Date") + a * r);
|
||
}
|
||
if (s) {
|
||
e._d.setTime(e._d.valueOf() + s * r);
|
||
}
|
||
if (n) {
|
||
hooks.updateOffset(e, a || i);
|
||
}
|
||
}
|
||
var Re = createAdder(1, "add"),
|
||
Ee = createAdder(-1, "subtract");
|
||
function isString(e) {
|
||
return typeof e === "string" || e instanceof String;
|
||
}
|
||
function isMomentInput(e) {
|
||
return (
|
||
isMoment(e) ||
|
||
isDate(e) ||
|
||
isString(e) ||
|
||
isNumber(e) ||
|
||
isNumberOrStringArray(e) ||
|
||
isMomentInputObject(e) ||
|
||
e === null ||
|
||
e === undefined
|
||
);
|
||
}
|
||
function isMomentInputObject(e) {
|
||
var t = isObject(e) && !isObjectEmpty(e),
|
||
r = false,
|
||
n = [
|
||
"years",
|
||
"year",
|
||
"y",
|
||
"months",
|
||
"month",
|
||
"M",
|
||
"days",
|
||
"day",
|
||
"d",
|
||
"dates",
|
||
"date",
|
||
"D",
|
||
"hours",
|
||
"hour",
|
||
"h",
|
||
"minutes",
|
||
"minute",
|
||
"m",
|
||
"seconds",
|
||
"second",
|
||
"s",
|
||
"milliseconds",
|
||
"millisecond",
|
||
"ms",
|
||
],
|
||
s,
|
||
a,
|
||
i = n.length;
|
||
for (s = 0; s < i; s += 1) {
|
||
a = n[s];
|
||
r = r || hasOwnProp(e, a);
|
||
}
|
||
return t && r;
|
||
}
|
||
function isNumberOrStringArray(e) {
|
||
var t = isArray(e),
|
||
r = false;
|
||
if (t) {
|
||
r =
|
||
e.filter(function (t) {
|
||
return !isNumber(t) && isString(e);
|
||
}).length === 0;
|
||
}
|
||
return t && r;
|
||
}
|
||
function isCalendarSpec(e) {
|
||
var t = isObject(e) && !isObjectEmpty(e),
|
||
r = false,
|
||
n = [
|
||
"sameDay",
|
||
"nextDay",
|
||
"lastDay",
|
||
"nextWeek",
|
||
"lastWeek",
|
||
"sameElse",
|
||
],
|
||
s,
|
||
a;
|
||
for (s = 0; s < n.length; s += 1) {
|
||
a = n[s];
|
||
r = r || hasOwnProp(e, a);
|
||
}
|
||
return t && r;
|
||
}
|
||
function getCalendarFormat(e, t) {
|
||
var r = e.diff(t, "days", true);
|
||
return r < -6
|
||
? "sameElse"
|
||
: r < -1
|
||
? "lastWeek"
|
||
: r < 0
|
||
? "lastDay"
|
||
: r < 1
|
||
? "sameDay"
|
||
: r < 2
|
||
? "nextDay"
|
||
: r < 7
|
||
? "nextWeek"
|
||
: "sameElse";
|
||
}
|
||
function calendar$1(e, t) {
|
||
if (arguments.length === 1) {
|
||
if (!arguments[0]) {
|
||
e = undefined;
|
||
t = undefined;
|
||
} else if (isMomentInput(arguments[0])) {
|
||
e = arguments[0];
|
||
t = undefined;
|
||
} else if (isCalendarSpec(arguments[0])) {
|
||
t = arguments[0];
|
||
e = undefined;
|
||
}
|
||
}
|
||
var r = e || createLocal(),
|
||
n = cloneWithOffset(r, this).startOf("day"),
|
||
s = hooks.calendarFormat(this, n) || "sameElse",
|
||
a = t && (isFunction(t[s]) ? t[s].call(this, r) : t[s]);
|
||
return this.format(
|
||
a || this.localeData().calendar(s, this, createLocal(r))
|
||
);
|
||
}
|
||
function clone() {
|
||
return new Moment(this);
|
||
}
|
||
function isAfter(e, t) {
|
||
var r = isMoment(e) ? e : createLocal(e);
|
||
if (!(this.isValid() && r.isValid())) {
|
||
return false;
|
||
}
|
||
t = normalizeUnits(t) || "millisecond";
|
||
if (t === "millisecond") {
|
||
return this.valueOf() > r.valueOf();
|
||
} else {
|
||
return r.valueOf() < this.clone().startOf(t).valueOf();
|
||
}
|
||
}
|
||
function isBefore(e, t) {
|
||
var r = isMoment(e) ? e : createLocal(e);
|
||
if (!(this.isValid() && r.isValid())) {
|
||
return false;
|
||
}
|
||
t = normalizeUnits(t) || "millisecond";
|
||
if (t === "millisecond") {
|
||
return this.valueOf() < r.valueOf();
|
||
} else {
|
||
return this.clone().endOf(t).valueOf() < r.valueOf();
|
||
}
|
||
}
|
||
function isBetween(e, t, r, n) {
|
||
var s = isMoment(e) ? e : createLocal(e),
|
||
a = isMoment(t) ? t : createLocal(t);
|
||
if (!(this.isValid() && s.isValid() && a.isValid())) {
|
||
return false;
|
||
}
|
||
n = n || "()";
|
||
return (
|
||
(n[0] === "("
|
||
? this.isAfter(s, r)
|
||
: !this.isBefore(s, r)) &&
|
||
(n[1] === ")"
|
||
? this.isBefore(a, r)
|
||
: !this.isAfter(a, r))
|
||
);
|
||
}
|
||
function isSame(e, t) {
|
||
var r = isMoment(e) ? e : createLocal(e),
|
||
n;
|
||
if (!(this.isValid() && r.isValid())) {
|
||
return false;
|
||
}
|
||
t = normalizeUnits(t) || "millisecond";
|
||
if (t === "millisecond") {
|
||
return this.valueOf() === r.valueOf();
|
||
} else {
|
||
n = r.valueOf();
|
||
return (
|
||
this.clone().startOf(t).valueOf() <= n &&
|
||
n <= this.clone().endOf(t).valueOf()
|
||
);
|
||
}
|
||
}
|
||
function isSameOrAfter(e, t) {
|
||
return this.isSame(e, t) || this.isAfter(e, t);
|
||
}
|
||
function isSameOrBefore(e, t) {
|
||
return this.isSame(e, t) || this.isBefore(e, t);
|
||
}
|
||
function diff(e, t, r) {
|
||
var n, s, a;
|
||
if (!this.isValid()) {
|
||
return NaN;
|
||
}
|
||
n = cloneWithOffset(e, this);
|
||
if (!n.isValid()) {
|
||
return NaN;
|
||
}
|
||
s = (n.utcOffset() - this.utcOffset()) * 6e4;
|
||
t = normalizeUnits(t);
|
||
switch (t) {
|
||
case "year":
|
||
a = monthDiff(this, n) / 12;
|
||
break;
|
||
case "month":
|
||
a = monthDiff(this, n);
|
||
break;
|
||
case "quarter":
|
||
a = monthDiff(this, n) / 3;
|
||
break;
|
||
case "second":
|
||
a = (this - n) / 1e3;
|
||
break;
|
||
case "minute":
|
||
a = (this - n) / 6e4;
|
||
break;
|
||
case "hour":
|
||
a = (this - n) / 36e5;
|
||
break;
|
||
case "day":
|
||
a = (this - n - s) / 864e5;
|
||
break;
|
||
case "week":
|
||
a = (this - n - s) / 6048e5;
|
||
break;
|
||
default:
|
||
a = this - n;
|
||
}
|
||
return r ? a : absFloor(a);
|
||
}
|
||
function monthDiff(e, t) {
|
||
if (e.date() < t.date()) {
|
||
return -monthDiff(t, e);
|
||
}
|
||
var r =
|
||
(t.year() - e.year()) * 12 +
|
||
(t.month() - e.month()),
|
||
n = e.clone().add(r, "months"),
|
||
s,
|
||
a;
|
||
if (t - n < 0) {
|
||
s = e.clone().add(r - 1, "months");
|
||
a = (t - n) / (n - s);
|
||
} else {
|
||
s = e.clone().add(r + 1, "months");
|
||
a = (t - n) / (s - n);
|
||
}
|
||
return -(r + a) || 0;
|
||
}
|
||
hooks.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ";
|
||
hooks.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]";
|
||
function toString() {
|
||
return this.clone()
|
||
.locale("en")
|
||
.format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
|
||
}
|
||
function toISOString(e) {
|
||
if (!this.isValid()) {
|
||
return null;
|
||
}
|
||
var t = e !== true,
|
||
r = t ? this.clone().utc() : this;
|
||
if (r.year() < 0 || r.year() > 9999) {
|
||
return formatMoment(
|
||
r,
|
||
t
|
||
? "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]"
|
||
: "YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"
|
||
);
|
||
}
|
||
if (isFunction(Date.prototype.toISOString)) {
|
||
if (t) {
|
||
return this.toDate().toISOString();
|
||
} else {
|
||
return new Date(
|
||
this.valueOf() + this.utcOffset() * 60 * 1e3
|
||
)
|
||
.toISOString()
|
||
.replace("Z", formatMoment(r, "Z"));
|
||
}
|
||
}
|
||
return formatMoment(
|
||
r,
|
||
t
|
||
? "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]"
|
||
: "YYYY-MM-DD[T]HH:mm:ss.SSSZ"
|
||
);
|
||
}
|
||
function inspect() {
|
||
if (!this.isValid()) {
|
||
return "moment.invalid(/* " + this._i + " */)";
|
||
}
|
||
var e = "moment",
|
||
t = "",
|
||
r,
|
||
n,
|
||
s,
|
||
a;
|
||
if (!this.isLocal()) {
|
||
e =
|
||
this.utcOffset() === 0
|
||
? "moment.utc"
|
||
: "moment.parseZone";
|
||
t = "Z";
|
||
}
|
||
r = "[" + e + '("]';
|
||
n =
|
||
0 <= this.year() && this.year() <= 9999
|
||
? "YYYY"
|
||
: "YYYYYY";
|
||
s = "-MM-DD[T]HH:mm:ss.SSS";
|
||
a = t + '[")]';
|
||
return this.format(r + n + s + a);
|
||
}
|
||
function format(e) {
|
||
if (!e) {
|
||
e = this.isUtc()
|
||
? hooks.defaultFormatUtc
|
||
: hooks.defaultFormat;
|
||
}
|
||
var t = formatMoment(this, e);
|
||
return this.localeData().postformat(t);
|
||
}
|
||
function from(e, t) {
|
||
if (
|
||
this.isValid() &&
|
||
((isMoment(e) && e.isValid()) ||
|
||
createLocal(e).isValid())
|
||
) {
|
||
return createDuration({ to: this, from: e })
|
||
.locale(this.locale())
|
||
.humanize(!t);
|
||
} else {
|
||
return this.localeData().invalidDate();
|
||
}
|
||
}
|
||
function fromNow(e) {
|
||
return this.from(createLocal(), e);
|
||
}
|
||
function to(e, t) {
|
||
if (
|
||
this.isValid() &&
|
||
((isMoment(e) && e.isValid()) ||
|
||
createLocal(e).isValid())
|
||
) {
|
||
return createDuration({ from: this, to: e })
|
||
.locale(this.locale())
|
||
.humanize(!t);
|
||
} else {
|
||
return this.localeData().invalidDate();
|
||
}
|
||
}
|
||
function toNow(e) {
|
||
return this.to(createLocal(), e);
|
||
}
|
||
function locale(e) {
|
||
var t;
|
||
if (e === undefined) {
|
||
return this._locale._abbr;
|
||
} else {
|
||
t = getLocale(e);
|
||
if (t != null) {
|
||
this._locale = t;
|
||
}
|
||
return this;
|
||
}
|
||
}
|
||
var Ce = deprecate(
|
||
"moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",
|
||
function (e) {
|
||
if (e === undefined) {
|
||
return this.localeData();
|
||
} else {
|
||
return this.locale(e);
|
||
}
|
||
}
|
||
);
|
||
function localeData() {
|
||
return this._locale;
|
||
}
|
||
var Fe = 1e3,
|
||
Pe = 60 * Fe,
|
||
Ae = 60 * Pe,
|
||
Ne = (365 * 400 + 97) * 24 * Ae;
|
||
function mod$1(e, t) {
|
||
return ((e % t) + t) % t;
|
||
}
|
||
function localStartOfDate(e, t, r) {
|
||
if (e < 100 && e >= 0) {
|
||
return new Date(e + 400, t, r) - Ne;
|
||
} else {
|
||
return new Date(e, t, r).valueOf();
|
||
}
|
||
}
|
||
function utcStartOfDate(e, t, r) {
|
||
if (e < 100 && e >= 0) {
|
||
return Date.UTC(e + 400, t, r) - Ne;
|
||
} else {
|
||
return Date.UTC(e, t, r);
|
||
}
|
||
}
|
||
function startOf(e) {
|
||
var t, r;
|
||
e = normalizeUnits(e);
|
||
if (
|
||
e === undefined ||
|
||
e === "millisecond" ||
|
||
!this.isValid()
|
||
) {
|
||
return this;
|
||
}
|
||
r = this._isUTC ? utcStartOfDate : localStartOfDate;
|
||
switch (e) {
|
||
case "year":
|
||
t = r(this.year(), 0, 1);
|
||
break;
|
||
case "quarter":
|
||
t = r(
|
||
this.year(),
|
||
this.month() - (this.month() % 3),
|
||
1
|
||
);
|
||
break;
|
||
case "month":
|
||
t = r(this.year(), this.month(), 1);
|
||
break;
|
||
case "week":
|
||
t = r(
|
||
this.year(),
|
||
this.month(),
|
||
this.date() - this.weekday()
|
||
);
|
||
break;
|
||
case "isoWeek":
|
||
t = r(
|
||
this.year(),
|
||
this.month(),
|
||
this.date() - (this.isoWeekday() - 1)
|
||
);
|
||
break;
|
||
case "day":
|
||
case "date":
|
||
t = r(this.year(), this.month(), this.date());
|
||
break;
|
||
case "hour":
|
||
t = this._d.valueOf();
|
||
t -= mod$1(
|
||
t + (this._isUTC ? 0 : this.utcOffset() * Pe),
|
||
Ae
|
||
);
|
||
break;
|
||
case "minute":
|
||
t = this._d.valueOf();
|
||
t -= mod$1(t, Pe);
|
||
break;
|
||
case "second":
|
||
t = this._d.valueOf();
|
||
t -= mod$1(t, Fe);
|
||
break;
|
||
}
|
||
this._d.setTime(t);
|
||
hooks.updateOffset(this, true);
|
||
return this;
|
||
}
|
||
function endOf(e) {
|
||
var t, r;
|
||
e = normalizeUnits(e);
|
||
if (
|
||
e === undefined ||
|
||
e === "millisecond" ||
|
||
!this.isValid()
|
||
) {
|
||
return this;
|
||
}
|
||
r = this._isUTC ? utcStartOfDate : localStartOfDate;
|
||
switch (e) {
|
||
case "year":
|
||
t = r(this.year() + 1, 0, 1) - 1;
|
||
break;
|
||
case "quarter":
|
||
t =
|
||
r(
|
||
this.year(),
|
||
this.month() - (this.month() % 3) + 3,
|
||
1
|
||
) - 1;
|
||
break;
|
||
case "month":
|
||
t = r(this.year(), this.month() + 1, 1) - 1;
|
||
break;
|
||
case "week":
|
||
t =
|
||
r(
|
||
this.year(),
|
||
this.month(),
|
||
this.date() - this.weekday() + 7
|
||
) - 1;
|
||
break;
|
||
case "isoWeek":
|
||
t =
|
||
r(
|
||
this.year(),
|
||
this.month(),
|
||
this.date() - (this.isoWeekday() - 1) + 7
|
||
) - 1;
|
||
break;
|
||
case "day":
|
||
case "date":
|
||
t =
|
||
r(this.year(), this.month(), this.date() + 1) -
|
||
1;
|
||
break;
|
||
case "hour":
|
||
t = this._d.valueOf();
|
||
t +=
|
||
Ae -
|
||
mod$1(
|
||
t +
|
||
(this._isUTC
|
||
? 0
|
||
: this.utcOffset() * Pe),
|
||
Ae
|
||
) -
|
||
1;
|
||
break;
|
||
case "minute":
|
||
t = this._d.valueOf();
|
||
t += Pe - mod$1(t, Pe) - 1;
|
||
break;
|
||
case "second":
|
||
t = this._d.valueOf();
|
||
t += Fe - mod$1(t, Fe) - 1;
|
||
break;
|
||
}
|
||
this._d.setTime(t);
|
||
hooks.updateOffset(this, true);
|
||
return this;
|
||
}
|
||
function valueOf() {
|
||
return this._d.valueOf() - (this._offset || 0) * 6e4;
|
||
}
|
||
function unix() {
|
||
return Math.floor(this.valueOf() / 1e3);
|
||
}
|
||
function toDate() {
|
||
return new Date(this.valueOf());
|
||
}
|
||
function toArray() {
|
||
var e = this;
|
||
return [
|
||
e.year(),
|
||
e.month(),
|
||
e.date(),
|
||
e.hour(),
|
||
e.minute(),
|
||
e.second(),
|
||
e.millisecond(),
|
||
];
|
||
}
|
||
function toObject() {
|
||
var e = this;
|
||
return {
|
||
years: e.year(),
|
||
months: e.month(),
|
||
date: e.date(),
|
||
hours: e.hours(),
|
||
minutes: e.minutes(),
|
||
seconds: e.seconds(),
|
||
milliseconds: e.milliseconds(),
|
||
};
|
||
}
|
||
function toJSON() {
|
||
return this.isValid() ? this.toISOString() : null;
|
||
}
|
||
function isValid$2() {
|
||
return isValid(this);
|
||
}
|
||
function parsingFlags() {
|
||
return extend({}, getParsingFlags(this));
|
||
}
|
||
function invalidAt() {
|
||
return getParsingFlags(this).overflow;
|
||
}
|
||
function creationData() {
|
||
return {
|
||
input: this._i,
|
||
format: this._f,
|
||
locale: this._locale,
|
||
isUTC: this._isUTC,
|
||
strict: this._strict,
|
||
};
|
||
}
|
||
addFormatToken("N", 0, 0, "eraAbbr");
|
||
addFormatToken("NN", 0, 0, "eraAbbr");
|
||
addFormatToken("NNN", 0, 0, "eraAbbr");
|
||
addFormatToken("NNNN", 0, 0, "eraName");
|
||
addFormatToken("NNNNN", 0, 0, "eraNarrow");
|
||
addFormatToken("y", ["y", 1], "yo", "eraYear");
|
||
addFormatToken("y", ["yy", 2], 0, "eraYear");
|
||
addFormatToken("y", ["yyy", 3], 0, "eraYear");
|
||
addFormatToken("y", ["yyyy", 4], 0, "eraYear");
|
||
addRegexToken("N", matchEraAbbr);
|
||
addRegexToken("NN", matchEraAbbr);
|
||
addRegexToken("NNN", matchEraAbbr);
|
||
addRegexToken("NNNN", matchEraName);
|
||
addRegexToken("NNNNN", matchEraNarrow);
|
||
addParseToken(
|
||
["N", "NN", "NNN", "NNNN", "NNNNN"],
|
||
function (e, t, r, n) {
|
||
var s = r._locale.erasParse(e, n, r._strict);
|
||
if (s) {
|
||
getParsingFlags(r).era = s;
|
||
} else {
|
||
getParsingFlags(r).invalidEra = e;
|
||
}
|
||
}
|
||
);
|
||
addRegexToken("y", E);
|
||
addRegexToken("yy", E);
|
||
addRegexToken("yyy", E);
|
||
addRegexToken("yyyy", E);
|
||
addRegexToken("yo", matchEraYearOrdinal);
|
||
addParseToken(["y", "yy", "yyy", "yyyy"], W);
|
||
addParseToken(["yo"], function (e, t, r, n) {
|
||
var s;
|
||
if (r._locale._eraYearOrdinalRegex) {
|
||
s = e.match(r._locale._eraYearOrdinalRegex);
|
||
}
|
||
if (r._locale.eraYearOrdinalParse) {
|
||
t[W] = r._locale.eraYearOrdinalParse(e, s);
|
||
} else {
|
||
t[W] = parseInt(e, 10);
|
||
}
|
||
});
|
||
function localeEras(e, t) {
|
||
var r,
|
||
n,
|
||
s,
|
||
a = this._eras || getLocale("en")._eras;
|
||
for (r = 0, n = a.length; r < n; ++r) {
|
||
switch (typeof a[r].since) {
|
||
case "string":
|
||
s = hooks(a[r].since).startOf("day");
|
||
a[r].since = s.valueOf();
|
||
break;
|
||
}
|
||
switch (typeof a[r].until) {
|
||
case "undefined":
|
||
a[r].until = +Infinity;
|
||
break;
|
||
case "string":
|
||
s = hooks(a[r].until).startOf("day").valueOf();
|
||
a[r].until = s.valueOf();
|
||
break;
|
||
}
|
||
}
|
||
return a;
|
||
}
|
||
function localeErasParse(e, t, r) {
|
||
var n,
|
||
s,
|
||
a = this.eras(),
|
||
i,
|
||
o,
|
||
u;
|
||
e = e.toUpperCase();
|
||
for (n = 0, s = a.length; n < s; ++n) {
|
||
i = a[n].name.toUpperCase();
|
||
o = a[n].abbr.toUpperCase();
|
||
u = a[n].narrow.toUpperCase();
|
||
if (r) {
|
||
switch (t) {
|
||
case "N":
|
||
case "NN":
|
||
case "NNN":
|
||
if (o === e) {
|
||
return a[n];
|
||
}
|
||
break;
|
||
case "NNNN":
|
||
if (i === e) {
|
||
return a[n];
|
||
}
|
||
break;
|
||
case "NNNNN":
|
||
if (u === e) {
|
||
return a[n];
|
||
}
|
||
break;
|
||
}
|
||
} else if ([i, o, u].indexOf(e) >= 0) {
|
||
return a[n];
|
||
}
|
||
}
|
||
}
|
||
function localeErasConvertYear(e, t) {
|
||
var r = e.since <= e.until ? +1 : -1;
|
||
if (t === undefined) {
|
||
return hooks(e.since).year();
|
||
} else {
|
||
return hooks(e.since).year() + (t - e.offset) * r;
|
||
}
|
||
}
|
||
function getEraName() {
|
||
var e,
|
||
t,
|
||
r,
|
||
n = this.localeData().eras();
|
||
for (e = 0, t = n.length; e < t; ++e) {
|
||
r = this.clone().startOf("day").valueOf();
|
||
if (n[e].since <= r && r <= n[e].until) {
|
||
return n[e].name;
|
||
}
|
||
if (n[e].until <= r && r <= n[e].since) {
|
||
return n[e].name;
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
function getEraNarrow() {
|
||
var e,
|
||
t,
|
||
r,
|
||
n = this.localeData().eras();
|
||
for (e = 0, t = n.length; e < t; ++e) {
|
||
r = this.clone().startOf("day").valueOf();
|
||
if (n[e].since <= r && r <= n[e].until) {
|
||
return n[e].narrow;
|
||
}
|
||
if (n[e].until <= r && r <= n[e].since) {
|
||
return n[e].narrow;
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
function getEraAbbr() {
|
||
var e,
|
||
t,
|
||
r,
|
||
n = this.localeData().eras();
|
||
for (e = 0, t = n.length; e < t; ++e) {
|
||
r = this.clone().startOf("day").valueOf();
|
||
if (n[e].since <= r && r <= n[e].until) {
|
||
return n[e].abbr;
|
||
}
|
||
if (n[e].until <= r && r <= n[e].since) {
|
||
return n[e].abbr;
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
function getEraYear() {
|
||
var e,
|
||
t,
|
||
r,
|
||
n,
|
||
s = this.localeData().eras();
|
||
for (e = 0, t = s.length; e < t; ++e) {
|
||
r = s[e].since <= s[e].until ? +1 : -1;
|
||
n = this.clone().startOf("day").valueOf();
|
||
if (
|
||
(s[e].since <= n && n <= s[e].until) ||
|
||
(s[e].until <= n && n <= s[e].since)
|
||
) {
|
||
return (
|
||
(this.year() - hooks(s[e].since).year()) * r +
|
||
s[e].offset
|
||
);
|
||
}
|
||
}
|
||
return this.year();
|
||
}
|
||
function erasNameRegex(e) {
|
||
if (!hasOwnProp(this, "_erasNameRegex")) {
|
||
computeErasParse.call(this);
|
||
}
|
||
return e ? this._erasNameRegex : this._erasRegex;
|
||
}
|
||
function erasAbbrRegex(e) {
|
||
if (!hasOwnProp(this, "_erasAbbrRegex")) {
|
||
computeErasParse.call(this);
|
||
}
|
||
return e ? this._erasAbbrRegex : this._erasRegex;
|
||
}
|
||
function erasNarrowRegex(e) {
|
||
if (!hasOwnProp(this, "_erasNarrowRegex")) {
|
||
computeErasParse.call(this);
|
||
}
|
||
return e ? this._erasNarrowRegex : this._erasRegex;
|
||
}
|
||
function matchEraAbbr(e, t) {
|
||
return t.erasAbbrRegex(e);
|
||
}
|
||
function matchEraName(e, t) {
|
||
return t.erasNameRegex(e);
|
||
}
|
||
function matchEraNarrow(e, t) {
|
||
return t.erasNarrowRegex(e);
|
||
}
|
||
function matchEraYearOrdinal(e, t) {
|
||
return t._eraYearOrdinalRegex || E;
|
||
}
|
||
function computeErasParse() {
|
||
var e = [],
|
||
t = [],
|
||
r = [],
|
||
n = [],
|
||
s,
|
||
a,
|
||
i,
|
||
o,
|
||
u,
|
||
l = this.eras();
|
||
for (s = 0, a = l.length; s < a; ++s) {
|
||
i = regexEscape(l[s].name);
|
||
o = regexEscape(l[s].abbr);
|
||
u = regexEscape(l[s].narrow);
|
||
t.push(i);
|
||
e.push(o);
|
||
r.push(u);
|
||
n.push(i);
|
||
n.push(o);
|
||
n.push(u);
|
||
}
|
||
this._erasRegex = new RegExp("^(" + n.join("|") + ")", "i");
|
||
this._erasNameRegex = new RegExp(
|
||
"^(" + t.join("|") + ")",
|
||
"i"
|
||
);
|
||
this._erasAbbrRegex = new RegExp(
|
||
"^(" + e.join("|") + ")",
|
||
"i"
|
||
);
|
||
this._erasNarrowRegex = new RegExp(
|
||
"^(" + r.join("|") + ")",
|
||
"i"
|
||
);
|
||
}
|
||
addFormatToken(0, ["gg", 2], 0, function () {
|
||
return this.weekYear() % 100;
|
||
});
|
||
addFormatToken(0, ["GG", 2], 0, function () {
|
||
return this.isoWeekYear() % 100;
|
||
});
|
||
function addWeekYearFormatToken(e, t) {
|
||
addFormatToken(0, [e, e.length], 0, t);
|
||
}
|
||
addWeekYearFormatToken("gggg", "weekYear");
|
||
addWeekYearFormatToken("ggggg", "weekYear");
|
||
addWeekYearFormatToken("GGGG", "isoWeekYear");
|
||
addWeekYearFormatToken("GGGGG", "isoWeekYear");
|
||
addRegexToken("G", C);
|
||
addRegexToken("g", C);
|
||
addRegexToken("GG", O, k);
|
||
addRegexToken("gg", O, k);
|
||
addRegexToken("GGGG", x, b);
|
||
addRegexToken("gggg", x, b);
|
||
addRegexToken("GGGGG", R, S);
|
||
addRegexToken("ggggg", R, S);
|
||
addWeekParseToken(
|
||
["gggg", "ggggg", "GGGG", "GGGGG"],
|
||
function (e, t, r, n) {
|
||
t[n.substr(0, 2)] = toInt(e);
|
||
}
|
||
);
|
||
addWeekParseToken(["gg", "GG"], function (e, t, r, n) {
|
||
t[n] = hooks.parseTwoDigitYear(e);
|
||
});
|
||
function getSetWeekYear(e) {
|
||
return getSetWeekYearHelper.call(
|
||
this,
|
||
e,
|
||
this.week(),
|
||
this.weekday() + this.localeData()._week.dow,
|
||
this.localeData()._week.dow,
|
||
this.localeData()._week.doy
|
||
);
|
||
}
|
||
function getSetISOWeekYear(e) {
|
||
return getSetWeekYearHelper.call(
|
||
this,
|
||
e,
|
||
this.isoWeek(),
|
||
this.isoWeekday(),
|
||
1,
|
||
4
|
||
);
|
||
}
|
||
function getISOWeeksInYear() {
|
||
return weeksInYear(this.year(), 1, 4);
|
||
}
|
||
function getISOWeeksInISOWeekYear() {
|
||
return weeksInYear(this.isoWeekYear(), 1, 4);
|
||
}
|
||
function getWeeksInYear() {
|
||
var e = this.localeData()._week;
|
||
return weeksInYear(this.year(), e.dow, e.doy);
|
||
}
|
||
function getWeeksInWeekYear() {
|
||
var e = this.localeData()._week;
|
||
return weeksInYear(this.weekYear(), e.dow, e.doy);
|
||
}
|
||
function getSetWeekYearHelper(e, t, r, n, s) {
|
||
var a;
|
||
if (e == null) {
|
||
return weekOfYear(this, n, s).year;
|
||
} else {
|
||
a = weeksInYear(e, n, s);
|
||
if (t > a) {
|
||
t = a;
|
||
}
|
||
return setWeekAll.call(this, e, t, r, n, s);
|
||
}
|
||
}
|
||
function setWeekAll(e, t, r, n, s) {
|
||
var a = dayOfYearFromWeeks(e, t, r, n, s),
|
||
i = createUTCDate(a.year, 0, a.dayOfYear);
|
||
this.year(i.getUTCFullYear());
|
||
this.month(i.getUTCMonth());
|
||
this.date(i.getUTCDate());
|
||
return this;
|
||
}
|
||
addFormatToken("Q", 0, "Qo", "quarter");
|
||
addRegexToken("Q", v);
|
||
addParseToken("Q", function (e, t) {
|
||
t[j] = (toInt(e) - 1) * 3;
|
||
});
|
||
function getSetQuarter(e) {
|
||
return e == null
|
||
? Math.ceil((this.month() + 1) / 3)
|
||
: this.month((e - 1) * 3 + (this.month() % 3));
|
||
}
|
||
addFormatToken("D", ["DD", 2], "Do", "date");
|
||
addRegexToken("D", O, Y);
|
||
addRegexToken("DD", O, k);
|
||
addRegexToken("Do", function (e, t) {
|
||
return e
|
||
? t._dayOfMonthOrdinalParse || t._ordinalParse
|
||
: t._dayOfMonthOrdinalParseLenient;
|
||
});
|
||
addParseToken(["D", "DD"], q);
|
||
addParseToken("Do", function (e, t) {
|
||
t[q] = toInt(e.match(O)[0]);
|
||
});
|
||
var Ye = makeGetSet("Date", true);
|
||
addFormatToken("DDD", ["DDDD", 3], "DDDo", "dayOfYear");
|
||
addRegexToken("DDD", D);
|
||
addRegexToken("DDDD", w);
|
||
addParseToken(["DDD", "DDDD"], function (e, t, r) {
|
||
r._dayOfYear = toInt(e);
|
||
});
|
||
function getSetDayOfYear(e) {
|
||
var t =
|
||
Math.round(
|
||
(this.clone().startOf("day") -
|
||
this.clone().startOf("year")) /
|
||
864e5
|
||
) + 1;
|
||
return e == null ? t : this.add(e - t, "d");
|
||
}
|
||
addFormatToken("m", ["mm", 2], 0, "minute");
|
||
addRegexToken("m", O, I);
|
||
addRegexToken("mm", O, k);
|
||
addParseToken(["m", "mm"], B);
|
||
var Ie = makeGetSet("Minutes", false);
|
||
addFormatToken("s", ["ss", 2], 0, "second");
|
||
addRegexToken("s", O, I);
|
||
addRegexToken("ss", O, k);
|
||
addParseToken(["s", "ss"], V);
|
||
var Ue = makeGetSet("Seconds", false);
|
||
addFormatToken("S", 0, 0, function () {
|
||
return ~~(this.millisecond() / 100);
|
||
});
|
||
addFormatToken(0, ["SS", 2], 0, function () {
|
||
return ~~(this.millisecond() / 10);
|
||
});
|
||
addFormatToken(0, ["SSS", 3], 0, "millisecond");
|
||
addFormatToken(0, ["SSSS", 4], 0, function () {
|
||
return this.millisecond() * 10;
|
||
});
|
||
addFormatToken(0, ["SSSSS", 5], 0, function () {
|
||
return this.millisecond() * 100;
|
||
});
|
||
addFormatToken(0, ["SSSSSS", 6], 0, function () {
|
||
return this.millisecond() * 1e3;
|
||
});
|
||
addFormatToken(0, ["SSSSSSS", 7], 0, function () {
|
||
return this.millisecond() * 1e4;
|
||
});
|
||
addFormatToken(0, ["SSSSSSSS", 8], 0, function () {
|
||
return this.millisecond() * 1e5;
|
||
});
|
||
addFormatToken(0, ["SSSSSSSSS", 9], 0, function () {
|
||
return this.millisecond() * 1e6;
|
||
});
|
||
addRegexToken("S", D, v);
|
||
addRegexToken("SS", D, k);
|
||
addRegexToken("SSS", D, w);
|
||
var Le, We;
|
||
for (Le = "SSSS"; Le.length <= 9; Le += "S") {
|
||
addRegexToken(Le, E);
|
||
}
|
||
function parseMs(e, t) {
|
||
t[G] = toInt(("0." + e) * 1e3);
|
||
}
|
||
for (Le = "S"; Le.length <= 9; Le += "S") {
|
||
addParseToken(Le, parseMs);
|
||
}
|
||
We = makeGetSet("Milliseconds", false);
|
||
addFormatToken("z", 0, 0, "zoneAbbr");
|
||
addFormatToken("zz", 0, 0, "zoneName");
|
||
function getZoneAbbr() {
|
||
return this._isUTC ? "UTC" : "";
|
||
}
|
||
function getZoneName() {
|
||
return this._isUTC ? "Coordinated Universal Time" : "";
|
||
}
|
||
var je = Moment.prototype;
|
||
je.add = Re;
|
||
je.calendar = calendar$1;
|
||
je.clone = clone;
|
||
je.diff = diff;
|
||
je.endOf = endOf;
|
||
je.format = format;
|
||
je.from = from;
|
||
je.fromNow = fromNow;
|
||
je.to = to;
|
||
je.toNow = toNow;
|
||
je.get = stringGet;
|
||
je.invalidAt = invalidAt;
|
||
je.isAfter = isAfter;
|
||
je.isBefore = isBefore;
|
||
je.isBetween = isBetween;
|
||
je.isSame = isSame;
|
||
je.isSameOrAfter = isSameOrAfter;
|
||
je.isSameOrBefore = isSameOrBefore;
|
||
je.isValid = isValid$2;
|
||
je.lang = Ce;
|
||
je.locale = locale;
|
||
je.localeData = localeData;
|
||
je.max = Oe;
|
||
je.min = Se;
|
||
je.parsingFlags = parsingFlags;
|
||
je.set = stringSet;
|
||
je.startOf = startOf;
|
||
je.subtract = Ee;
|
||
je.toArray = toArray;
|
||
je.toObject = toObject;
|
||
je.toDate = toDate;
|
||
je.toISOString = toISOString;
|
||
je.inspect = inspect;
|
||
if (typeof Symbol !== "undefined" && Symbol.for != null) {
|
||
je[Symbol.for("nodejs.util.inspect.custom")] = function () {
|
||
return "Moment<" + this.format() + ">";
|
||
};
|
||
}
|
||
je.toJSON = toJSON;
|
||
je.toString = toString;
|
||
je.unix = unix;
|
||
je.valueOf = valueOf;
|
||
je.creationData = creationData;
|
||
je.eraName = getEraName;
|
||
je.eraNarrow = getEraNarrow;
|
||
je.eraAbbr = getEraAbbr;
|
||
je.eraYear = getEraYear;
|
||
je.year = Z;
|
||
je.isLeapYear = getIsLeapYear;
|
||
je.weekYear = getSetWeekYear;
|
||
je.isoWeekYear = getSetISOWeekYear;
|
||
je.quarter = je.quarters = getSetQuarter;
|
||
je.month = getSetMonth;
|
||
je.daysInMonth = getDaysInMonth;
|
||
je.week = je.weeks = getSetWeek;
|
||
je.isoWeek = je.isoWeeks = getSetISOWeek;
|
||
je.weeksInYear = getWeeksInYear;
|
||
je.weeksInWeekYear = getWeeksInWeekYear;
|
||
je.isoWeeksInYear = getISOWeeksInYear;
|
||
je.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
|
||
je.date = Ye;
|
||
je.day = je.days = getSetDayOfWeek;
|
||
je.weekday = getSetLocaleDayOfWeek;
|
||
je.isoWeekday = getSetISODayOfWeek;
|
||
je.dayOfYear = getSetDayOfYear;
|
||
je.hour = je.hours = ce;
|
||
je.minute = je.minutes = Ie;
|
||
je.second = je.seconds = Ue;
|
||
je.millisecond = je.milliseconds = We;
|
||
je.utcOffset = getSetOffset;
|
||
je.utc = setOffsetToUTC;
|
||
je.local = setOffsetToLocal;
|
||
je.parseZone = setOffsetToParsedOffset;
|
||
je.hasAlignedHourOffset = hasAlignedHourOffset;
|
||
je.isDST = isDaylightSavingTime;
|
||
je.isLocal = isLocal;
|
||
je.isUtcOffset = isUtcOffset;
|
||
je.isUtc = isUtc;
|
||
je.isUTC = isUtc;
|
||
je.zoneAbbr = getZoneAbbr;
|
||
je.zoneName = getZoneName;
|
||
je.dates = deprecate(
|
||
"dates accessor is deprecated. Use date instead.",
|
||
Ye
|
||
);
|
||
je.months = deprecate(
|
||
"months accessor is deprecated. Use month instead",
|
||
getSetMonth
|
||
);
|
||
je.years = deprecate(
|
||
"years accessor is deprecated. Use year instead",
|
||
Z
|
||
);
|
||
je.zone = deprecate(
|
||
"moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",
|
||
getSetZone
|
||
);
|
||
je.isDSTShifted = deprecate(
|
||
"isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",
|
||
isDaylightSavingTimeShifted
|
||
);
|
||
function createUnix(e) {
|
||
return createLocal(e * 1e3);
|
||
}
|
||
function createInZone() {
|
||
return createLocal.apply(null, arguments).parseZone();
|
||
}
|
||
function preParsePostFormat(e) {
|
||
return e;
|
||
}
|
||
var qe = Locale.prototype;
|
||
qe.calendar = calendar;
|
||
qe.longDateFormat = longDateFormat;
|
||
qe.invalidDate = invalidDate;
|
||
qe.ordinal = ordinal;
|
||
qe.preparse = preParsePostFormat;
|
||
qe.postformat = preParsePostFormat;
|
||
qe.relativeTime = relativeTime;
|
||
qe.pastFuture = pastFuture;
|
||
qe.set = set;
|
||
qe.eras = localeEras;
|
||
qe.erasParse = localeErasParse;
|
||
qe.erasConvertYear = localeErasConvertYear;
|
||
qe.erasAbbrRegex = erasAbbrRegex;
|
||
qe.erasNameRegex = erasNameRegex;
|
||
qe.erasNarrowRegex = erasNarrowRegex;
|
||
qe.months = localeMonths;
|
||
qe.monthsShort = localeMonthsShort;
|
||
qe.monthsParse = localeMonthsParse;
|
||
qe.monthsRegex = monthsRegex;
|
||
qe.monthsShortRegex = monthsShortRegex;
|
||
qe.week = localeWeek;
|
||
qe.firstDayOfYear = localeFirstDayOfYear;
|
||
qe.firstDayOfWeek = localeFirstDayOfWeek;
|
||
qe.weekdays = localeWeekdays;
|
||
qe.weekdaysMin = localeWeekdaysMin;
|
||
qe.weekdaysShort = localeWeekdaysShort;
|
||
qe.weekdaysParse = localeWeekdaysParse;
|
||
qe.weekdaysRegex = weekdaysRegex;
|
||
qe.weekdaysShortRegex = weekdaysShortRegex;
|
||
qe.weekdaysMinRegex = weekdaysMinRegex;
|
||
qe.isPM = localeIsPM;
|
||
qe.meridiem = localeMeridiem;
|
||
function get$1(e, t, r, n) {
|
||
var s = getLocale(),
|
||
a = createUTC().set(n, t);
|
||
return s[r](a, e);
|
||
}
|
||
function listMonthsImpl(e, t, r) {
|
||
if (isNumber(e)) {
|
||
t = e;
|
||
e = undefined;
|
||
}
|
||
e = e || "";
|
||
if (t != null) {
|
||
return get$1(e, t, r, "month");
|
||
}
|
||
var n,
|
||
s = [];
|
||
for (n = 0; n < 12; n++) {
|
||
s[n] = get$1(e, n, r, "month");
|
||
}
|
||
return s;
|
||
}
|
||
function listWeekdaysImpl(e, t, r, n) {
|
||
if (typeof e === "boolean") {
|
||
if (isNumber(t)) {
|
||
r = t;
|
||
t = undefined;
|
||
}
|
||
t = t || "";
|
||
} else {
|
||
t = e;
|
||
r = t;
|
||
e = false;
|
||
if (isNumber(t)) {
|
||
r = t;
|
||
t = undefined;
|
||
}
|
||
t = t || "";
|
||
}
|
||
var s = getLocale(),
|
||
a = e ? s._week.dow : 0,
|
||
i,
|
||
o = [];
|
||
if (r != null) {
|
||
return get$1(t, (r + a) % 7, n, "day");
|
||
}
|
||
for (i = 0; i < 7; i++) {
|
||
o[i] = get$1(t, (i + a) % 7, n, "day");
|
||
}
|
||
return o;
|
||
}
|
||
function listMonths(e, t) {
|
||
return listMonthsImpl(e, t, "months");
|
||
}
|
||
function listMonthsShort(e, t) {
|
||
return listMonthsImpl(e, t, "monthsShort");
|
||
}
|
||
function listWeekdays(e, t, r) {
|
||
return listWeekdaysImpl(e, t, r, "weekdays");
|
||
}
|
||
function listWeekdaysShort(e, t, r) {
|
||
return listWeekdaysImpl(e, t, r, "weekdaysShort");
|
||
}
|
||
function listWeekdaysMin(e, t, r) {
|
||
return listWeekdaysImpl(e, t, r, "weekdaysMin");
|
||
}
|
||
getSetGlobalLocale("en", {
|
||
eras: [
|
||
{
|
||
since: "0001-01-01",
|
||
until: +Infinity,
|
||
offset: 1,
|
||
name: "Anno Domini",
|
||
narrow: "AD",
|
||
abbr: "AD",
|
||
},
|
||
{
|
||
since: "0000-12-31",
|
||
until: -Infinity,
|
||
offset: 1,
|
||
name: "Before Christ",
|
||
narrow: "BC",
|
||
abbr: "BC",
|
||
},
|
||
],
|
||
dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
|
||
ordinal: function (e) {
|
||
var t = e % 10,
|
||
r =
|
||
toInt((e % 100) / 10) === 1
|
||
? "th"
|
||
: t === 1
|
||
? "st"
|
||
: t === 2
|
||
? "nd"
|
||
: t === 3
|
||
? "rd"
|
||
: "th";
|
||
return e + r;
|
||
},
|
||
});
|
||
hooks.lang = deprecate(
|
||
"moment.lang is deprecated. Use moment.locale instead.",
|
||
getSetGlobalLocale
|
||
);
|
||
hooks.langData = deprecate(
|
||
"moment.langData is deprecated. Use moment.localeData instead.",
|
||
getLocale
|
||
);
|
||
var He = Math.abs;
|
||
function abs() {
|
||
var e = this._data;
|
||
this._milliseconds = He(this._milliseconds);
|
||
this._days = He(this._days);
|
||
this._months = He(this._months);
|
||
e.milliseconds = He(e.milliseconds);
|
||
e.seconds = He(e.seconds);
|
||
e.minutes = He(e.minutes);
|
||
e.hours = He(e.hours);
|
||
e.months = He(e.months);
|
||
e.years = He(e.years);
|
||
return this;
|
||
}
|
||
function addSubtract$1(e, t, r, n) {
|
||
var s = createDuration(t, r);
|
||
e._milliseconds += n * s._milliseconds;
|
||
e._days += n * s._days;
|
||
e._months += n * s._months;
|
||
return e._bubble();
|
||
}
|
||
function add$1(e, t) {
|
||
return addSubtract$1(this, e, t, 1);
|
||
}
|
||
function subtract$1(e, t) {
|
||
return addSubtract$1(this, e, t, -1);
|
||
}
|
||
function absCeil(e) {
|
||
if (e < 0) {
|
||
return Math.floor(e);
|
||
} else {
|
||
return Math.ceil(e);
|
||
}
|
||
}
|
||
function bubble() {
|
||
var e = this._milliseconds,
|
||
t = this._days,
|
||
r = this._months,
|
||
n = this._data,
|
||
s,
|
||
a,
|
||
i,
|
||
o,
|
||
u;
|
||
if (
|
||
!(
|
||
(e >= 0 && t >= 0 && r >= 0) ||
|
||
(e <= 0 && t <= 0 && r <= 0)
|
||
)
|
||
) {
|
||
e += absCeil(monthsToDays(r) + t) * 864e5;
|
||
t = 0;
|
||
r = 0;
|
||
}
|
||
n.milliseconds = e % 1e3;
|
||
s = absFloor(e / 1e3);
|
||
n.seconds = s % 60;
|
||
a = absFloor(s / 60);
|
||
n.minutes = a % 60;
|
||
i = absFloor(a / 60);
|
||
n.hours = i % 24;
|
||
t += absFloor(i / 24);
|
||
u = absFloor(daysToMonths(t));
|
||
r += u;
|
||
t -= absCeil(monthsToDays(u));
|
||
o = absFloor(r / 12);
|
||
r %= 12;
|
||
n.days = t;
|
||
n.months = r;
|
||
n.years = o;
|
||
return this;
|
||
}
|
||
function daysToMonths(e) {
|
||
return (e * 4800) / 146097;
|
||
}
|
||
function monthsToDays(e) {
|
||
return (e * 146097) / 4800;
|
||
}
|
||
function as(e) {
|
||
if (!this.isValid()) {
|
||
return NaN;
|
||
}
|
||
var t,
|
||
r,
|
||
n = this._milliseconds;
|
||
e = normalizeUnits(e);
|
||
if (e === "month" || e === "quarter" || e === "year") {
|
||
t = this._days + n / 864e5;
|
||
r = this._months + daysToMonths(t);
|
||
switch (e) {
|
||
case "month":
|
||
return r;
|
||
case "quarter":
|
||
return r / 3;
|
||
case "year":
|
||
return r / 12;
|
||
}
|
||
} else {
|
||
t = this._days + Math.round(monthsToDays(this._months));
|
||
switch (e) {
|
||
case "week":
|
||
return t / 7 + n / 6048e5;
|
||
case "day":
|
||
return t + n / 864e5;
|
||
case "hour":
|
||
return t * 24 + n / 36e5;
|
||
case "minute":
|
||
return t * 1440 + n / 6e4;
|
||
case "second":
|
||
return t * 86400 + n / 1e3;
|
||
case "millisecond":
|
||
return Math.floor(t * 864e5) + n;
|
||
default:
|
||
throw new Error("Unknown unit " + e);
|
||
}
|
||
}
|
||
}
|
||
function makeAs(e) {
|
||
return function () {
|
||
return this.as(e);
|
||
};
|
||
}
|
||
var Be = makeAs("ms"),
|
||
Ve = makeAs("s"),
|
||
Ge = makeAs("m"),
|
||
$e = makeAs("h"),
|
||
ze = makeAs("d"),
|
||
Ze = makeAs("w"),
|
||
Je = makeAs("M"),
|
||
Qe = makeAs("Q"),
|
||
Xe = makeAs("y"),
|
||
Ke = Be;
|
||
function clone$1() {
|
||
return createDuration(this);
|
||
}
|
||
function get$2(e) {
|
||
e = normalizeUnits(e);
|
||
return this.isValid() ? this[e + "s"]() : NaN;
|
||
}
|
||
function makeGetter(e) {
|
||
return function () {
|
||
return this.isValid() ? this._data[e] : NaN;
|
||
};
|
||
}
|
||
var et = makeGetter("milliseconds"),
|
||
tt = makeGetter("seconds"),
|
||
rt = makeGetter("minutes"),
|
||
nt = makeGetter("hours"),
|
||
st = makeGetter("days"),
|
||
at = makeGetter("months"),
|
||
it = makeGetter("years");
|
||
function weeks() {
|
||
return absFloor(this.days() / 7);
|
||
}
|
||
var ot = Math.round,
|
||
ut = { ss: 44, s: 45, m: 45, h: 22, d: 26, w: null, M: 11 };
|
||
function substituteTimeAgo(e, t, r, n, s) {
|
||
return s.relativeTime(t || 1, !!r, e, n);
|
||
}
|
||
function relativeTime$1(e, t, r, n) {
|
||
var s = createDuration(e).abs(),
|
||
a = ot(s.as("s")),
|
||
i = ot(s.as("m")),
|
||
o = ot(s.as("h")),
|
||
u = ot(s.as("d")),
|
||
l = ot(s.as("M")),
|
||
c = ot(s.as("w")),
|
||
f = ot(s.as("y")),
|
||
d =
|
||
(a <= r.ss && ["s", a]) ||
|
||
(a < r.s && ["ss", a]) ||
|
||
(i <= 1 && ["m"]) ||
|
||
(i < r.m && ["mm", i]) ||
|
||
(o <= 1 && ["h"]) ||
|
||
(o < r.h && ["hh", o]) ||
|
||
(u <= 1 && ["d"]) ||
|
||
(u < r.d && ["dd", u]);
|
||
if (r.w != null) {
|
||
d = d || (c <= 1 && ["w"]) || (c < r.w && ["ww", c]);
|
||
}
|
||
d = d ||
|
||
(l <= 1 && ["M"]) ||
|
||
(l < r.M && ["MM", l]) ||
|
||
(f <= 1 && ["y"]) || ["yy", f];
|
||
d[2] = t;
|
||
d[3] = +e > 0;
|
||
d[4] = n;
|
||
return substituteTimeAgo.apply(null, d);
|
||
}
|
||
function getSetRelativeTimeRounding(e) {
|
||
if (e === undefined) {
|
||
return ot;
|
||
}
|
||
if (typeof e === "function") {
|
||
ot = e;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
function getSetRelativeTimeThreshold(e, t) {
|
||
if (ut[e] === undefined) {
|
||
return false;
|
||
}
|
||
if (t === undefined) {
|
||
return ut[e];
|
||
}
|
||
ut[e] = t;
|
||
if (e === "s") {
|
||
ut.ss = t - 1;
|
||
}
|
||
return true;
|
||
}
|
||
function humanize(e, t) {
|
||
if (!this.isValid()) {
|
||
return this.localeData().invalidDate();
|
||
}
|
||
var r = false,
|
||
n = ut,
|
||
s,
|
||
a;
|
||
if (typeof e === "object") {
|
||
t = e;
|
||
e = false;
|
||
}
|
||
if (typeof e === "boolean") {
|
||
r = e;
|
||
}
|
||
if (typeof t === "object") {
|
||
n = Object.assign({}, ut, t);
|
||
if (t.s != null && t.ss == null) {
|
||
n.ss = t.s - 1;
|
||
}
|
||
}
|
||
s = this.localeData();
|
||
a = relativeTime$1(this, !r, n, s);
|
||
if (r) {
|
||
a = s.pastFuture(+this, a);
|
||
}
|
||
return s.postformat(a);
|
||
}
|
||
var lt = Math.abs;
|
||
function sign(e) {
|
||
return (e > 0) - (e < 0) || +e;
|
||
}
|
||
function toISOString$1() {
|
||
if (!this.isValid()) {
|
||
return this.localeData().invalidDate();
|
||
}
|
||
var e = lt(this._milliseconds) / 1e3,
|
||
t = lt(this._days),
|
||
r = lt(this._months),
|
||
n,
|
||
s,
|
||
a,
|
||
i,
|
||
o = this.asSeconds(),
|
||
u,
|
||
l,
|
||
c,
|
||
f;
|
||
if (!o) {
|
||
return "P0D";
|
||
}
|
||
n = absFloor(e / 60);
|
||
s = absFloor(n / 60);
|
||
e %= 60;
|
||
n %= 60;
|
||
a = absFloor(r / 12);
|
||
r %= 12;
|
||
i = e ? e.toFixed(3).replace(/\.?0+$/, "") : "";
|
||
u = o < 0 ? "-" : "";
|
||
l = sign(this._months) !== sign(o) ? "-" : "";
|
||
c = sign(this._days) !== sign(o) ? "-" : "";
|
||
f = sign(this._milliseconds) !== sign(o) ? "-" : "";
|
||
return (
|
||
u +
|
||
"P" +
|
||
(a ? l + a + "Y" : "") +
|
||
(r ? l + r + "M" : "") +
|
||
(t ? c + t + "D" : "") +
|
||
(s || n || e ? "T" : "") +
|
||
(s ? f + s + "H" : "") +
|
||
(n ? f + n + "M" : "") +
|
||
(e ? f + i + "S" : "")
|
||
);
|
||
}
|
||
var ct = Duration.prototype;
|
||
ct.isValid = isValid$1;
|
||
ct.abs = abs;
|
||
ct.add = add$1;
|
||
ct.subtract = subtract$1;
|
||
ct.as = as;
|
||
ct.asMilliseconds = Be;
|
||
ct.asSeconds = Ve;
|
||
ct.asMinutes = Ge;
|
||
ct.asHours = $e;
|
||
ct.asDays = ze;
|
||
ct.asWeeks = Ze;
|
||
ct.asMonths = Je;
|
||
ct.asQuarters = Qe;
|
||
ct.asYears = Xe;
|
||
ct.valueOf = Ke;
|
||
ct._bubble = bubble;
|
||
ct.clone = clone$1;
|
||
ct.get = get$2;
|
||
ct.milliseconds = et;
|
||
ct.seconds = tt;
|
||
ct.minutes = rt;
|
||
ct.hours = nt;
|
||
ct.days = st;
|
||
ct.weeks = weeks;
|
||
ct.months = at;
|
||
ct.years = it;
|
||
ct.humanize = humanize;
|
||
ct.toISOString = toISOString$1;
|
||
ct.toString = toISOString$1;
|
||
ct.toJSON = toISOString$1;
|
||
ct.locale = locale;
|
||
ct.localeData = localeData;
|
||
ct.toIsoString = deprecate(
|
||
"toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",
|
||
toISOString$1
|
||
);
|
||
ct.lang = Ce;
|
||
addFormatToken("X", 0, 0, "unix");
|
||
addFormatToken("x", 0, 0, "valueOf");
|
||
addRegexToken("x", C);
|
||
addRegexToken("X", A);
|
||
addParseToken("X", function (e, t, r) {
|
||
r._d = new Date(parseFloat(e) * 1e3);
|
||
});
|
||
addParseToken("x", function (e, t, r) {
|
||
r._d = new Date(toInt(e));
|
||
});
|
||
//! moment.js
|
||
hooks.version = "2.30.1";
|
||
setHookCallback(createLocal);
|
||
hooks.fn = je;
|
||
hooks.min = min;
|
||
hooks.max = max;
|
||
hooks.now = now;
|
||
hooks.utc = createUTC;
|
||
hooks.unix = createUnix;
|
||
hooks.months = listMonths;
|
||
hooks.isDate = isDate;
|
||
hooks.locale = getSetGlobalLocale;
|
||
hooks.invalid = createInvalid;
|
||
hooks.duration = createDuration;
|
||
hooks.isMoment = isMoment;
|
||
hooks.weekdays = listWeekdays;
|
||
hooks.parseZone = createInZone;
|
||
hooks.localeData = getLocale;
|
||
hooks.isDuration = isDuration;
|
||
hooks.monthsShort = listMonthsShort;
|
||
hooks.weekdaysMin = listWeekdaysMin;
|
||
hooks.defineLocale = defineLocale;
|
||
hooks.updateLocale = updateLocale;
|
||
hooks.locales = listLocales;
|
||
hooks.weekdaysShort = listWeekdaysShort;
|
||
hooks.normalizeUnits = normalizeUnits;
|
||
hooks.relativeTimeRounding = getSetRelativeTimeRounding;
|
||
hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
|
||
hooks.calendarFormat = getCalendarFormat;
|
||
hooks.prototype = je;
|
||
hooks.HTML5_FMT = {
|
||
DATETIME_LOCAL: "YYYY-MM-DDTHH:mm",
|
||
DATETIME_LOCAL_SECONDS: "YYYY-MM-DDTHH:mm:ss",
|
||
DATETIME_LOCAL_MS: "YYYY-MM-DDTHH:mm:ss.SSS",
|
||
DATE: "YYYY-MM-DD",
|
||
TIME: "HH:mm",
|
||
TIME_SECONDS: "HH:mm:ss",
|
||
TIME_MS: "HH:mm:ss.SSS",
|
||
WEEK: "GGGG-[W]WW",
|
||
MONTH: "YYYY-MM",
|
||
};
|
||
return hooks;
|
||
});
|
||
},
|
||
900: e => {
|
||
var t = 1e3;
|
||
var r = t * 60;
|
||
var n = r * 60;
|
||
var s = n * 24;
|
||
var a = s * 7;
|
||
var i = s * 365.25;
|
||
e.exports = function (e, t) {
|
||
t = t || {};
|
||
var r = typeof e;
|
||
if (r === "string" && e.length > 0) {
|
||
return parse(e);
|
||
} else if (r === "number" && isFinite(e)) {
|
||
return t.long ? fmtLong(e) : fmtShort(e);
|
||
}
|
||
throw new Error(
|
||
"val is not a non-empty string or a valid number. val=" +
|
||
JSON.stringify(e)
|
||
);
|
||
};
|
||
function parse(e) {
|
||
e = String(e);
|
||
if (e.length > 100) {
|
||
return;
|
||
}
|
||
var o =
|
||
/^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
|
||
e
|
||
);
|
||
if (!o) {
|
||
return;
|
||
}
|
||
var u = parseFloat(o[1]);
|
||
var l = (o[2] || "ms").toLowerCase();
|
||
switch (l) {
|
||
case "years":
|
||
case "year":
|
||
case "yrs":
|
||
case "yr":
|
||
case "y":
|
||
return u * i;
|
||
case "weeks":
|
||
case "week":
|
||
case "w":
|
||
return u * a;
|
||
case "days":
|
||
case "day":
|
||
case "d":
|
||
return u * s;
|
||
case "hours":
|
||
case "hour":
|
||
case "hrs":
|
||
case "hr":
|
||
case "h":
|
||
return u * n;
|
||
case "minutes":
|
||
case "minute":
|
||
case "mins":
|
||
case "min":
|
||
case "m":
|
||
return u * r;
|
||
case "seconds":
|
||
case "second":
|
||
case "secs":
|
||
case "sec":
|
||
case "s":
|
||
return u * t;
|
||
case "milliseconds":
|
||
case "millisecond":
|
||
case "msecs":
|
||
case "msec":
|
||
case "ms":
|
||
return u;
|
||
default:
|
||
return undefined;
|
||
}
|
||
}
|
||
function fmtShort(e) {
|
||
var a = Math.abs(e);
|
||
if (a >= s) {
|
||
return Math.round(e / s) + "d";
|
||
}
|
||
if (a >= n) {
|
||
return Math.round(e / n) + "h";
|
||
}
|
||
if (a >= r) {
|
||
return Math.round(e / r) + "m";
|
||
}
|
||
if (a >= t) {
|
||
return Math.round(e / t) + "s";
|
||
}
|
||
return e + "ms";
|
||
}
|
||
function fmtLong(e) {
|
||
var a = Math.abs(e);
|
||
if (a >= s) {
|
||
return plural(e, a, s, "day");
|
||
}
|
||
if (a >= n) {
|
||
return plural(e, a, n, "hour");
|
||
}
|
||
if (a >= r) {
|
||
return plural(e, a, r, "minute");
|
||
}
|
||
if (a >= t) {
|
||
return plural(e, a, t, "second");
|
||
}
|
||
return e + " ms";
|
||
}
|
||
function plural(e, t, r, n) {
|
||
var s = t >= r * 1.5;
|
||
return Math.round(e / r) + " " + n + (s ? "s" : "");
|
||
}
|
||
},
|
||
127: (e, t, r) => {
|
||
const n = r(8614);
|
||
const s = r(5622);
|
||
const { fork: a } = r(3129);
|
||
const i = r(5840);
|
||
const o = r.ab + "daemon.js";
|
||
class BackgroundScheduledTask extends n {
|
||
constructor(e, t, r) {
|
||
super();
|
||
if (!r) {
|
||
r = { scheduled: true, recoverMissedExecutions: false };
|
||
}
|
||
this.cronExpression = e;
|
||
this.taskPath = t;
|
||
this.options = r;
|
||
this.options.name = this.options.name || i.v4();
|
||
if (r.scheduled) {
|
||
this.start();
|
||
}
|
||
}
|
||
start() {
|
||
this.stop();
|
||
this.forkProcess = a(r.ab + "daemon.js");
|
||
this.forkProcess.on("message", e => {
|
||
switch (e.type) {
|
||
case "task-done":
|
||
this.emit("task-done", e.result);
|
||
break;
|
||
}
|
||
});
|
||
let e = this.options;
|
||
e.scheduled = true;
|
||
this.forkProcess.send({
|
||
type: "register",
|
||
path: s.resolve(this.taskPath),
|
||
cron: this.cronExpression,
|
||
options: e,
|
||
});
|
||
}
|
||
stop() {
|
||
if (this.forkProcess) {
|
||
this.forkProcess.kill();
|
||
}
|
||
}
|
||
pid() {
|
||
if (this.forkProcess) {
|
||
return this.forkProcess.pid;
|
||
}
|
||
}
|
||
isRunning() {
|
||
return !this.forkProcess.killed;
|
||
}
|
||
}
|
||
e.exports = BackgroundScheduledTask;
|
||
},
|
||
9296: e => {
|
||
"use strict";
|
||
e.exports = (() => {
|
||
function convertAsterisk(e, t) {
|
||
if (e.indexOf("*") !== -1) {
|
||
return e.replace("*", t);
|
||
}
|
||
return e;
|
||
}
|
||
function convertAsterisksToRanges(e) {
|
||
e[0] = convertAsterisk(e[0], "0-59");
|
||
e[1] = convertAsterisk(e[1], "0-59");
|
||
e[2] = convertAsterisk(e[2], "0-23");
|
||
e[3] = convertAsterisk(e[3], "1-31");
|
||
e[4] = convertAsterisk(e[4], "1-12");
|
||
e[5] = convertAsterisk(e[5], "0-6");
|
||
return e;
|
||
}
|
||
return convertAsterisksToRanges;
|
||
})();
|
||
},
|
||
3605: (e, t, r) => {
|
||
"use strict";
|
||
const n = r(422);
|
||
const s = r(7002);
|
||
const a = r(9296);
|
||
const i = r(5646);
|
||
const o = r(8524);
|
||
e.exports = (() => {
|
||
function appendSeccondExpression(e) {
|
||
if (e.length === 5) {
|
||
return ["0"].concat(e);
|
||
}
|
||
return e;
|
||
}
|
||
function removeSpaces(e) {
|
||
return e.replace(/\s{2,}/g, " ").trim();
|
||
}
|
||
function normalizeIntegers(e) {
|
||
for (let t = 0; t < e.length; t++) {
|
||
const r = e[t].split(",");
|
||
for (let e = 0; e < r.length; e++) {
|
||
r[e] = parseInt(r[e]);
|
||
}
|
||
e[t] = r;
|
||
}
|
||
return e;
|
||
}
|
||
function interprete(e) {
|
||
let t = removeSpaces(e).split(" ");
|
||
t = appendSeccondExpression(t);
|
||
t[4] = n(t[4]);
|
||
t[5] = s(t[5]);
|
||
t = a(t);
|
||
t = i(t);
|
||
t = o(t);
|
||
t = normalizeIntegers(t);
|
||
return t.join(" ");
|
||
}
|
||
return interprete;
|
||
})();
|
||
},
|
||
422: e => {
|
||
"use strict";
|
||
e.exports = (() => {
|
||
const e = [
|
||
"january",
|
||
"february",
|
||
"march",
|
||
"april",
|
||
"may",
|
||
"june",
|
||
"july",
|
||
"august",
|
||
"september",
|
||
"october",
|
||
"november",
|
||
"december",
|
||
];
|
||
const t = [
|
||
"jan",
|
||
"feb",
|
||
"mar",
|
||
"apr",
|
||
"may",
|
||
"jun",
|
||
"jul",
|
||
"aug",
|
||
"sep",
|
||
"oct",
|
||
"nov",
|
||
"dec",
|
||
];
|
||
function convertMonthName(e, t) {
|
||
for (let r = 0; r < t.length; r++) {
|
||
e = e.replace(
|
||
new RegExp(t[r], "gi"),
|
||
parseInt(r, 10) + 1
|
||
);
|
||
}
|
||
return e;
|
||
}
|
||
function interprete(r) {
|
||
r = convertMonthName(r, e);
|
||
r = convertMonthName(r, t);
|
||
return r;
|
||
}
|
||
return interprete;
|
||
})();
|
||
},
|
||
5646: e => {
|
||
"use strict";
|
||
e.exports = (() => {
|
||
function replaceWithRange(e, t, r, n) {
|
||
const s = [];
|
||
let a = parseInt(n);
|
||
let i = parseInt(r);
|
||
if (i > a) {
|
||
a = parseInt(r);
|
||
i = parseInt(n);
|
||
}
|
||
for (let e = i; e <= a; e++) {
|
||
s.push(e);
|
||
}
|
||
return e.replace(new RegExp(t, "i"), s.join());
|
||
}
|
||
function convertRange(e) {
|
||
const t = /(\d+)-(\d+)/;
|
||
let r = t.exec(e);
|
||
while (r !== null && r.length > 0) {
|
||
e = replaceWithRange(e, r[0], r[1], r[2]);
|
||
r = t.exec(e);
|
||
}
|
||
return e;
|
||
}
|
||
function convertAllRanges(e) {
|
||
for (let t = 0; t < e.length; t++) {
|
||
e[t] = convertRange(e[t]);
|
||
}
|
||
return e;
|
||
}
|
||
return convertAllRanges;
|
||
})();
|
||
},
|
||
8524: e => {
|
||
"use strict";
|
||
e.exports = (() => {
|
||
function convertSteps(e) {
|
||
var t = /^(.+)\/(\w+)$/;
|
||
for (var r = 0; r < e.length; r++) {
|
||
var n = t.exec(e[r]);
|
||
var s = n !== null && n.length > 0;
|
||
if (s) {
|
||
var a = n[2];
|
||
if (isNaN(a)) {
|
||
throw a + " is not a valid step value";
|
||
}
|
||
var i = n[1].split(",");
|
||
var o = [];
|
||
var u = parseInt(a, 10);
|
||
for (var l = 0; l <= i.length; l++) {
|
||
var c = parseInt(i[l], 10);
|
||
if (c % u === 0) {
|
||
o.push(c);
|
||
}
|
||
}
|
||
e[r] = o.join(",");
|
||
}
|
||
}
|
||
return e;
|
||
}
|
||
return convertSteps;
|
||
})();
|
||
},
|
||
7002: e => {
|
||
"use strict";
|
||
e.exports = (() => {
|
||
const e = [
|
||
"sunday",
|
||
"monday",
|
||
"tuesday",
|
||
"wednesday",
|
||
"thursday",
|
||
"friday",
|
||
"saturday",
|
||
];
|
||
const t = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
|
||
function convertWeekDayName(e, t) {
|
||
for (let r = 0; r < t.length; r++) {
|
||
e = e.replace(new RegExp(t[r], "gi"), parseInt(r, 10));
|
||
}
|
||
return e;
|
||
}
|
||
function convertWeekDays(r) {
|
||
r = r.replace("7", "0");
|
||
r = convertWeekDayName(r, e);
|
||
return convertWeekDayName(r, t);
|
||
}
|
||
return convertWeekDays;
|
||
})();
|
||
},
|
||
2148: (e, t, r) => {
|
||
"use strict";
|
||
const n = r(2356);
|
||
const s = r(127);
|
||
const a = r(5637);
|
||
const i = r(1330);
|
||
function schedule(e, t, r) {
|
||
const n = createTask(e, t, r);
|
||
i.save(n);
|
||
return n;
|
||
}
|
||
function createTask(e, t, r) {
|
||
if (typeof t === "string") return new s(e, t, r);
|
||
return new n(e, t, r);
|
||
}
|
||
function validate(e) {
|
||
try {
|
||
a(e);
|
||
return true;
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}
|
||
function getTasks() {
|
||
return i.getTasks();
|
||
}
|
||
e.exports = {
|
||
schedule: schedule,
|
||
validate: validate,
|
||
getTasks: getTasks,
|
||
};
|
||
},
|
||
5637: (e, t, r) => {
|
||
"use strict";
|
||
const n = r(3605);
|
||
const s = /^(?:\d+|\*|\*\/\d+)$/;
|
||
function isValidExpression(e, t, r) {
|
||
const n = e.split(",");
|
||
for (const e of n) {
|
||
const n = parseInt(e, 10);
|
||
if ((!Number.isNaN(n) && (n < t || n > r)) || !s.test(e))
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
function isInvalidSecond(e) {
|
||
return !isValidExpression(e, 0, 59);
|
||
}
|
||
function isInvalidMinute(e) {
|
||
return !isValidExpression(e, 0, 59);
|
||
}
|
||
function isInvalidHour(e) {
|
||
return !isValidExpression(e, 0, 23);
|
||
}
|
||
function isInvalidDayOfMonth(e) {
|
||
return !isValidExpression(e, 1, 31);
|
||
}
|
||
function isInvalidMonth(e) {
|
||
return !isValidExpression(e, 1, 12);
|
||
}
|
||
function isInvalidWeekDay(e) {
|
||
return !isValidExpression(e, 0, 7);
|
||
}
|
||
function validateFields(e, t) {
|
||
if (isInvalidSecond(t[0]))
|
||
throw new Error(
|
||
`${e[0]} is a invalid expression for second`
|
||
);
|
||
if (isInvalidMinute(t[1]))
|
||
throw new Error(
|
||
`${e[1]} is a invalid expression for minute`
|
||
);
|
||
if (isInvalidHour(t[2]))
|
||
throw new Error(`${e[2]} is a invalid expression for hour`);
|
||
if (isInvalidDayOfMonth(t[3]))
|
||
throw new Error(
|
||
`${e[3]} is a invalid expression for day of month`
|
||
);
|
||
if (isInvalidMonth(t[4]))
|
||
throw new Error(
|
||
`${e[4]} is a invalid expression for month`
|
||
);
|
||
if (isInvalidWeekDay(t[5]))
|
||
throw new Error(
|
||
`${e[5]} is a invalid expression for week day`
|
||
);
|
||
}
|
||
function validate(e) {
|
||
if (typeof e !== "string")
|
||
throw new TypeError("pattern must be a string!");
|
||
const t = e.split(" ");
|
||
const r = n(e).split(" ");
|
||
if (t.length === 5) t.unshift("0");
|
||
validateFields(t, r);
|
||
}
|
||
e.exports = validate;
|
||
},
|
||
2356: (e, t, r) => {
|
||
"use strict";
|
||
const n = r(8614);
|
||
const s = r(4554);
|
||
const a = r(450);
|
||
const i = r(5840);
|
||
class ScheduledTask extends n {
|
||
constructor(e, t, r) {
|
||
super();
|
||
if (!r) {
|
||
r = { scheduled: true, recoverMissedExecutions: false };
|
||
}
|
||
this.options = r;
|
||
this.options.name = this.options.name || i.v4();
|
||
this._task = new s(t);
|
||
this._scheduler = new a(
|
||
e,
|
||
r.timezone,
|
||
r.recoverMissedExecutions
|
||
);
|
||
this._scheduler.on("scheduled-time-matched", e => {
|
||
this.now(e);
|
||
});
|
||
if (r.scheduled !== false) {
|
||
this._scheduler.start();
|
||
}
|
||
if (r.runOnInit === true) {
|
||
this.now("init");
|
||
}
|
||
}
|
||
now(e = "manual") {
|
||
let t = this._task.execute(e);
|
||
this.emit("task-done", t);
|
||
}
|
||
start() {
|
||
this._scheduler.start();
|
||
}
|
||
stop() {
|
||
this._scheduler.stop();
|
||
}
|
||
}
|
||
e.exports = ScheduledTask;
|
||
},
|
||
450: (e, t, r) => {
|
||
"use strict";
|
||
const n = r(8614);
|
||
const s = r(9435);
|
||
class Scheduler extends n {
|
||
constructor(e, t, r) {
|
||
super();
|
||
this.timeMatcher = new s(e, t);
|
||
this.autorecover = r;
|
||
}
|
||
start() {
|
||
this.stop();
|
||
let e = process.hrtime();
|
||
let t = this.timeMatcher.apply(new Date());
|
||
const matchTime = () => {
|
||
const r = 1e3;
|
||
const n = process.hrtime(e);
|
||
const s = (n[0] * 1e9 + n[1]) / 1e6;
|
||
const a = Math.floor(s / 1e3);
|
||
for (let e = a; e >= 0; e--) {
|
||
const r = new Date(new Date().getTime() - e * 1e3);
|
||
let n = this.timeMatcher.apply(r);
|
||
if (
|
||
t.getTime() < n.getTime() &&
|
||
(e === 0 || this.autorecover) &&
|
||
this.timeMatcher.match(r)
|
||
) {
|
||
this.emit("scheduled-time-matched", n);
|
||
n.setMilliseconds(0);
|
||
t = n;
|
||
}
|
||
}
|
||
e = process.hrtime();
|
||
this.timeout = setTimeout(matchTime, r);
|
||
};
|
||
matchTime();
|
||
}
|
||
stop() {
|
||
if (this.timeout) {
|
||
clearTimeout(this.timeout);
|
||
}
|
||
this.timeout = null;
|
||
}
|
||
}
|
||
e.exports = Scheduler;
|
||
},
|
||
1330: (e, t, r) => {
|
||
e.exports = (() => {
|
||
if (!global.scheduledTasks) {
|
||
global.scheduledTasks = new Map();
|
||
}
|
||
return {
|
||
save: e => {
|
||
if (!e.options) {
|
||
const t = r(5840);
|
||
e.options = {};
|
||
e.options.name = t.v4();
|
||
}
|
||
global.scheduledTasks.set(e.options.name, e);
|
||
},
|
||
getTasks: () => global.scheduledTasks,
|
||
};
|
||
})();
|
||
},
|
||
4554: (e, t, r) => {
|
||
"use strict";
|
||
const n = r(8614);
|
||
class Task extends n {
|
||
constructor(e) {
|
||
super();
|
||
if (typeof e !== "function") {
|
||
throw "execution must be a function";
|
||
}
|
||
this._execution = e;
|
||
}
|
||
execute(e) {
|
||
let t;
|
||
try {
|
||
t = this._execution(e);
|
||
} catch (e) {
|
||
return this.emit("task-failed", e);
|
||
}
|
||
if (t instanceof Promise) {
|
||
return t
|
||
.then(() => this.emit("task-finished"))
|
||
.catch(e => this.emit("task-failed", e));
|
||
} else {
|
||
this.emit("task-finished");
|
||
return t;
|
||
}
|
||
}
|
||
}
|
||
e.exports = Task;
|
||
},
|
||
9435: (e, t, r) => {
|
||
const n = r(5637);
|
||
const s = r(3605);
|
||
function matchPattern(e, t) {
|
||
if (e.indexOf(",") !== -1) {
|
||
const r = e.split(",");
|
||
return r.indexOf(t.toString()) !== -1;
|
||
}
|
||
return e === t.toString();
|
||
}
|
||
class TimeMatcher {
|
||
constructor(e, t) {
|
||
n(e);
|
||
this.pattern = s(e);
|
||
this.timezone = t;
|
||
this.expressions = this.pattern.split(" ");
|
||
this.dtf = this.timezone
|
||
? new Intl.DateTimeFormat("en-US", {
|
||
year: "numeric",
|
||
month: "2-digit",
|
||
day: "2-digit",
|
||
hour: "2-digit",
|
||
minute: "2-digit",
|
||
second: "2-digit",
|
||
hourCycle: "h23",
|
||
fractionalSecondDigits: 3,
|
||
timeZone: this.timezone,
|
||
})
|
||
: null;
|
||
}
|
||
match(e) {
|
||
e = this.apply(e);
|
||
const t = matchPattern(this.expressions[0], e.getSeconds());
|
||
const r = matchPattern(this.expressions[1], e.getMinutes());
|
||
const n = matchPattern(this.expressions[2], e.getHours());
|
||
const s = matchPattern(this.expressions[3], e.getDate());
|
||
const a = matchPattern(
|
||
this.expressions[4],
|
||
e.getMonth() + 1
|
||
);
|
||
const i = matchPattern(this.expressions[5], e.getDay());
|
||
return t && r && n && s && a && i;
|
||
}
|
||
apply(e) {
|
||
if (this.dtf) {
|
||
return new Date(this.dtf.format(e));
|
||
}
|
||
return e;
|
||
}
|
||
}
|
||
e.exports = TimeMatcher;
|
||
},
|
||
9318: (e, t, r) => {
|
||
"use strict";
|
||
const n = r(2087);
|
||
const s = r(1621);
|
||
const a = process.env;
|
||
let i;
|
||
if (s("no-color") || s("no-colors") || s("color=false")) {
|
||
i = false;
|
||
} else if (
|
||
s("color") ||
|
||
s("colors") ||
|
||
s("color=true") ||
|
||
s("color=always")
|
||
) {
|
||
i = true;
|
||
}
|
||
if ("FORCE_COLOR" in a) {
|
||
i =
|
||
a.FORCE_COLOR.length === 0 ||
|
||
parseInt(a.FORCE_COLOR, 10) !== 0;
|
||
}
|
||
function translateLevel(e) {
|
||
if (e === 0) {
|
||
return false;
|
||
}
|
||
return {
|
||
level: e,
|
||
hasBasic: true,
|
||
has256: e >= 2,
|
||
has16m: e >= 3,
|
||
};
|
||
}
|
||
function supportsColor(e) {
|
||
if (i === false) {
|
||
return 0;
|
||
}
|
||
if (s("color=16m") || s("color=full") || s("color=truecolor")) {
|
||
return 3;
|
||
}
|
||
if (s("color=256")) {
|
||
return 2;
|
||
}
|
||
if (e && !e.isTTY && i !== true) {
|
||
return 0;
|
||
}
|
||
const t = i ? 1 : 0;
|
||
if (process.platform === "win32") {
|
||
const e = n.release().split(".");
|
||
if (
|
||
Number(process.versions.node.split(".")[0]) >= 8 &&
|
||
Number(e[0]) >= 10 &&
|
||
Number(e[2]) >= 10586
|
||
) {
|
||
return Number(e[2]) >= 14931 ? 3 : 2;
|
||
}
|
||
return 1;
|
||
}
|
||
if ("CI" in a) {
|
||
if (
|
||
["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some(
|
||
e => e in a
|
||
) ||
|
||
a.CI_NAME === "codeship"
|
||
) {
|
||
return 1;
|
||
}
|
||
return t;
|
||
}
|
||
if ("TEAMCITY_VERSION" in a) {
|
||
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(
|
||
a.TEAMCITY_VERSION
|
||
)
|
||
? 1
|
||
: 0;
|
||
}
|
||
if (a.COLORTERM === "truecolor") {
|
||
return 3;
|
||
}
|
||
if ("TERM_PROGRAM" in a) {
|
||
const e = parseInt(
|
||
(a.TERM_PROGRAM_VERSION || "").split(".")[0],
|
||
10
|
||
);
|
||
switch (a.TERM_PROGRAM) {
|
||
case "iTerm.app":
|
||
return e >= 3 ? 3 : 2;
|
||
case "Apple_Terminal":
|
||
return 2;
|
||
}
|
||
}
|
||
if (/-256(color)?$/i.test(a.TERM)) {
|
||
return 2;
|
||
}
|
||
if (
|
||
/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(
|
||
a.TERM
|
||
)
|
||
) {
|
||
return 1;
|
||
}
|
||
if ("COLORTERM" in a) {
|
||
return 1;
|
||
}
|
||
if (a.TERM === "dumb") {
|
||
return t;
|
||
}
|
||
return t;
|
||
}
|
||
function getSupportLevel(e) {
|
||
const t = supportsColor(e);
|
||
return translateLevel(t);
|
||
}
|
||
e.exports = {
|
||
supportsColor: getSupportLevel,
|
||
stdout: getSupportLevel(process.stdout),
|
||
stderr: getSupportLevel(process.stderr),
|
||
};
|
||
},
|
||
5840: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
Object.defineProperty(t, "v1", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return n.default;
|
||
},
|
||
});
|
||
Object.defineProperty(t, "v3", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return s.default;
|
||
},
|
||
});
|
||
Object.defineProperty(t, "v4", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return a.default;
|
||
},
|
||
});
|
||
Object.defineProperty(t, "v5", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return i.default;
|
||
},
|
||
});
|
||
Object.defineProperty(t, "NIL", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return o.default;
|
||
},
|
||
});
|
||
Object.defineProperty(t, "version", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return u.default;
|
||
},
|
||
});
|
||
Object.defineProperty(t, "validate", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return l.default;
|
||
},
|
||
});
|
||
Object.defineProperty(t, "stringify", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return c.default;
|
||
},
|
||
});
|
||
Object.defineProperty(t, "parse", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return f.default;
|
||
},
|
||
});
|
||
var n = _interopRequireDefault(r(8628));
|
||
var s = _interopRequireDefault(r(6409));
|
||
var a = _interopRequireDefault(r(5122));
|
||
var i = _interopRequireDefault(r(9120));
|
||
var o = _interopRequireDefault(r(5332));
|
||
var u = _interopRequireDefault(r(1595));
|
||
var l = _interopRequireDefault(r(6900));
|
||
var c = _interopRequireDefault(r(8950));
|
||
var f = _interopRequireDefault(r(2746));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
},
|
||
4569: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(6417));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
function md5(e) {
|
||
if (Array.isArray(e)) {
|
||
e = Buffer.from(e);
|
||
} else if (typeof e === "string") {
|
||
e = Buffer.from(e, "utf8");
|
||
}
|
||
return n.default.createHash("md5").update(e).digest();
|
||
}
|
||
var s = md5;
|
||
t.default = s;
|
||
},
|
||
5332: (e, t) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var r = "00000000-0000-0000-0000-000000000000";
|
||
t.default = r;
|
||
},
|
||
2746: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(6900));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
function parse(e) {
|
||
if (!(0, n.default)(e)) {
|
||
throw TypeError("Invalid UUID");
|
||
}
|
||
let t;
|
||
const r = new Uint8Array(16);
|
||
r[0] = (t = parseInt(e.slice(0, 8), 16)) >>> 24;
|
||
r[1] = (t >>> 16) & 255;
|
||
r[2] = (t >>> 8) & 255;
|
||
r[3] = t & 255;
|
||
r[4] = (t = parseInt(e.slice(9, 13), 16)) >>> 8;
|
||
r[5] = t & 255;
|
||
r[6] = (t = parseInt(e.slice(14, 18), 16)) >>> 8;
|
||
r[7] = t & 255;
|
||
r[8] = (t = parseInt(e.slice(19, 23), 16)) >>> 8;
|
||
r[9] = t & 255;
|
||
r[10] =
|
||
((t = parseInt(e.slice(24, 36), 16)) / 1099511627776) & 255;
|
||
r[11] = (t / 4294967296) & 255;
|
||
r[12] = (t >>> 24) & 255;
|
||
r[13] = (t >>> 16) & 255;
|
||
r[14] = (t >>> 8) & 255;
|
||
r[15] = t & 255;
|
||
return r;
|
||
}
|
||
var s = parse;
|
||
t.default = s;
|
||
},
|
||
814: (e, t) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var r =
|
||
/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
|
||
t.default = r;
|
||
},
|
||
807: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = rng;
|
||
var n = _interopRequireDefault(r(6417));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
const s = new Uint8Array(256);
|
||
let a = s.length;
|
||
function rng() {
|
||
if (a > s.length - 16) {
|
||
n.default.randomFillSync(s);
|
||
a = 0;
|
||
}
|
||
return s.slice(a, (a += 16));
|
||
}
|
||
},
|
||
5274: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(6417));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
function sha1(e) {
|
||
if (Array.isArray(e)) {
|
||
e = Buffer.from(e);
|
||
} else if (typeof e === "string") {
|
||
e = Buffer.from(e, "utf8");
|
||
}
|
||
return n.default.createHash("sha1").update(e).digest();
|
||
}
|
||
var s = sha1;
|
||
t.default = s;
|
||
},
|
||
8950: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(6900));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
const s = [];
|
||
for (let e = 0; e < 256; ++e) {
|
||
s.push((e + 256).toString(16).substr(1));
|
||
}
|
||
function stringify(e, t = 0) {
|
||
const r = (
|
||
s[e[t + 0]] +
|
||
s[e[t + 1]] +
|
||
s[e[t + 2]] +
|
||
s[e[t + 3]] +
|
||
"-" +
|
||
s[e[t + 4]] +
|
||
s[e[t + 5]] +
|
||
"-" +
|
||
s[e[t + 6]] +
|
||
s[e[t + 7]] +
|
||
"-" +
|
||
s[e[t + 8]] +
|
||
s[e[t + 9]] +
|
||
"-" +
|
||
s[e[t + 10]] +
|
||
s[e[t + 11]] +
|
||
s[e[t + 12]] +
|
||
s[e[t + 13]] +
|
||
s[e[t + 14]] +
|
||
s[e[t + 15]]
|
||
).toLowerCase();
|
||
if (!(0, n.default)(r)) {
|
||
throw TypeError("Stringified UUID is invalid");
|
||
}
|
||
return r;
|
||
}
|
||
var a = stringify;
|
||
t.default = a;
|
||
},
|
||
8628: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(807));
|
||
var s = _interopRequireDefault(r(8950));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
let a;
|
||
let i;
|
||
let o = 0;
|
||
let u = 0;
|
||
function v1(e, t, r) {
|
||
let l = (t && r) || 0;
|
||
const c = t || new Array(16);
|
||
e = e || {};
|
||
let f = e.node || a;
|
||
let d = e.clockseq !== undefined ? e.clockseq : i;
|
||
if (f == null || d == null) {
|
||
const t = e.random || (e.rng || n.default)();
|
||
if (f == null) {
|
||
f = a = [t[0] | 1, t[1], t[2], t[3], t[4], t[5]];
|
||
}
|
||
if (d == null) {
|
||
d = i = ((t[6] << 8) | t[7]) & 16383;
|
||
}
|
||
}
|
||
let h = e.msecs !== undefined ? e.msecs : Date.now();
|
||
let m = e.nsecs !== undefined ? e.nsecs : u + 1;
|
||
const p = h - o + (m - u) / 1e4;
|
||
if (p < 0 && e.clockseq === undefined) {
|
||
d = (d + 1) & 16383;
|
||
}
|
||
if ((p < 0 || h > o) && e.nsecs === undefined) {
|
||
m = 0;
|
||
}
|
||
if (m >= 1e4) {
|
||
throw new Error(
|
||
"uuid.v1(): Can't create more than 10M uuids/sec"
|
||
);
|
||
}
|
||
o = h;
|
||
u = m;
|
||
i = d;
|
||
h += 122192928e5;
|
||
const g = ((h & 268435455) * 1e4 + m) % 4294967296;
|
||
c[l++] = (g >>> 24) & 255;
|
||
c[l++] = (g >>> 16) & 255;
|
||
c[l++] = (g >>> 8) & 255;
|
||
c[l++] = g & 255;
|
||
const y = ((h / 4294967296) * 1e4) & 268435455;
|
||
c[l++] = (y >>> 8) & 255;
|
||
c[l++] = y & 255;
|
||
c[l++] = ((y >>> 24) & 15) | 16;
|
||
c[l++] = (y >>> 16) & 255;
|
||
c[l++] = (d >>> 8) | 128;
|
||
c[l++] = d & 255;
|
||
for (let e = 0; e < 6; ++e) {
|
||
c[l + e] = f[e];
|
||
}
|
||
return t || (0, s.default)(c);
|
||
}
|
||
var l = v1;
|
||
t.default = l;
|
||
},
|
||
6409: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(5998));
|
||
var s = _interopRequireDefault(r(4569));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
const a = (0, n.default)("v3", 48, s.default);
|
||
var i = a;
|
||
t.default = i;
|
||
},
|
||
5998: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = _default;
|
||
t.URL = t.DNS = void 0;
|
||
var n = _interopRequireDefault(r(8950));
|
||
var s = _interopRequireDefault(r(2746));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
function stringToBytes(e) {
|
||
e = unescape(encodeURIComponent(e));
|
||
const t = [];
|
||
for (let r = 0; r < e.length; ++r) {
|
||
t.push(e.charCodeAt(r));
|
||
}
|
||
return t;
|
||
}
|
||
const a = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
|
||
t.DNS = a;
|
||
const i = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
|
||
t.URL = i;
|
||
function _default(e, t, r) {
|
||
function generateUUID(e, a, i, o) {
|
||
if (typeof e === "string") {
|
||
e = stringToBytes(e);
|
||
}
|
||
if (typeof a === "string") {
|
||
a = (0, s.default)(a);
|
||
}
|
||
if (a.length !== 16) {
|
||
throw TypeError(
|
||
"Namespace must be array-like (16 iterable integer values, 0-255)"
|
||
);
|
||
}
|
||
let u = new Uint8Array(16 + e.length);
|
||
u.set(a);
|
||
u.set(e, a.length);
|
||
u = r(u);
|
||
u[6] = (u[6] & 15) | t;
|
||
u[8] = (u[8] & 63) | 128;
|
||
if (i) {
|
||
o = o || 0;
|
||
for (let e = 0; e < 16; ++e) {
|
||
i[o + e] = u[e];
|
||
}
|
||
return i;
|
||
}
|
||
return (0, n.default)(u);
|
||
}
|
||
try {
|
||
generateUUID.name = e;
|
||
} catch (e) {}
|
||
generateUUID.DNS = a;
|
||
generateUUID.URL = i;
|
||
return generateUUID;
|
||
}
|
||
},
|
||
5122: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(807));
|
||
var s = _interopRequireDefault(r(8950));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
function v4(e, t, r) {
|
||
e = e || {};
|
||
const a = e.random || (e.rng || n.default)();
|
||
a[6] = (a[6] & 15) | 64;
|
||
a[8] = (a[8] & 63) | 128;
|
||
if (t) {
|
||
r = r || 0;
|
||
for (let e = 0; e < 16; ++e) {
|
||
t[r + e] = a[e];
|
||
}
|
||
return t;
|
||
}
|
||
return (0, s.default)(a);
|
||
}
|
||
var a = v4;
|
||
t.default = a;
|
||
},
|
||
9120: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(5998));
|
||
var s = _interopRequireDefault(r(5274));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
const a = (0, n.default)("v5", 80, s.default);
|
||
var i = a;
|
||
t.default = i;
|
||
},
|
||
6900: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(814));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
function validate(e) {
|
||
return typeof e === "string" && n.default.test(e);
|
||
}
|
||
var s = validate;
|
||
t.default = s;
|
||
},
|
||
1595: (e, t, r) => {
|
||
"use strict";
|
||
Object.defineProperty(t, "__esModule", { value: true });
|
||
t.default = void 0;
|
||
var n = _interopRequireDefault(r(6900));
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : { default: e };
|
||
}
|
||
function version(e) {
|
||
if (!(0, n.default)(e)) {
|
||
throw TypeError("Invalid UUID");
|
||
}
|
||
return parseInt(e.substr(14, 1), 16);
|
||
}
|
||
var s = version;
|
||
t.default = s;
|
||
},
|
||
696: e => {
|
||
"use strict";
|
||
e.exports = JSON.parse(
|
||
'{"name":"axios","version":"0.21.4","description":"Promise based HTTP client for the browser and node.js","main":"index.js","scripts":{"test":"grunt test","start":"node ./sandbox/server.js","build":"NODE_ENV=production grunt build","preversion":"npm test","version":"npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json","postversion":"git push && git push --tags","examples":"node ./examples/server.js","coveralls":"cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js","fix":"eslint --fix lib/**/*.js"},"repository":{"type":"git","url":"https://github.com/axios/axios.git"},"keywords":["xhr","http","ajax","promise","node"],"author":"Matt Zabriskie","license":"MIT","bugs":{"url":"https://github.com/axios/axios/issues"},"homepage":"https://axios-http.com","devDependencies":{"coveralls":"^3.0.0","es6-promise":"^4.2.4","grunt":"^1.3.0","grunt-banner":"^0.6.0","grunt-cli":"^1.2.0","grunt-contrib-clean":"^1.1.0","grunt-contrib-watch":"^1.0.0","grunt-eslint":"^23.0.0","grunt-karma":"^4.0.0","grunt-mocha-test":"^0.13.3","grunt-ts":"^6.0.0-beta.19","grunt-webpack":"^4.0.2","istanbul-instrumenter-loader":"^1.0.0","jasmine-core":"^2.4.1","karma":"^6.3.2","karma-chrome-launcher":"^3.1.0","karma-firefox-launcher":"^2.1.0","karma-jasmine":"^1.1.1","karma-jasmine-ajax":"^0.1.13","karma-safari-launcher":"^1.0.0","karma-sauce-launcher":"^4.3.6","karma-sinon":"^1.0.5","karma-sourcemap-loader":"^0.3.8","karma-webpack":"^4.0.2","load-grunt-tasks":"^3.5.2","minimist":"^1.2.0","mocha":"^8.2.1","sinon":"^4.5.0","terser-webpack-plugin":"^4.2.3","typescript":"^4.0.5","url-search-params":"^0.10.0","webpack":"^4.44.2","webpack-dev-server":"^3.11.0"},"browser":{"./lib/adapters/http.js":"./lib/adapters/xhr.js"},"jsdelivr":"dist/axios.min.js","unpkg":"dist/axios.min.js","typings":"./index.d.ts","dependencies":{"follow-redirects":"^1.14.0"},"bundlesize":[{"path":"./dist/axios.min.js","threshold":"5kB"}]}'
|
||
);
|
||
},
|
||
2357: e => {
|
||
"use strict";
|
||
e.exports = require("assert");
|
||
},
|
||
3129: e => {
|
||
"use strict";
|
||
e.exports = require("child_process");
|
||
},
|
||
6417: e => {
|
||
"use strict";
|
||
e.exports = require("crypto");
|
||
},
|
||
8614: e => {
|
||
"use strict";
|
||
e.exports = require("events");
|
||
},
|
||
5747: e => {
|
||
"use strict";
|
||
e.exports = require("fs");
|
||
},
|
||
8605: e => {
|
||
"use strict";
|
||
e.exports = require("http");
|
||
},
|
||
7211: e => {
|
||
"use strict";
|
||
e.exports = require("https");
|
||
},
|
||
2087: e => {
|
||
"use strict";
|
||
e.exports = require("os");
|
||
},
|
||
5622: e => {
|
||
"use strict";
|
||
e.exports = require("path");
|
||
},
|
||
2413: e => {
|
||
"use strict";
|
||
e.exports = require("stream");
|
||
},
|
||
3867: e => {
|
||
"use strict";
|
||
e.exports = require("tty");
|
||
},
|
||
8835: e => {
|
||
"use strict";
|
||
e.exports = require("url");
|
||
},
|
||
1669: e => {
|
||
"use strict";
|
||
e.exports = require("util");
|
||
},
|
||
8761: e => {
|
||
"use strict";
|
||
e.exports = require("zlib");
|
||
},
|
||
};
|
||
var t = {};
|
||
function __nccwpck_require__(r) {
|
||
var n = t[r];
|
||
if (n !== undefined) {
|
||
return n.exports;
|
||
}
|
||
var s = (t[r] = { id: r, loaded: false, exports: {} });
|
||
var a = true;
|
||
try {
|
||
e[r].call(s.exports, s, s.exports, __nccwpck_require__);
|
||
a = false;
|
||
} finally {
|
||
if (a) delete t[r];
|
||
}
|
||
s.loaded = true;
|
||
return s.exports;
|
||
}
|
||
(() => {
|
||
__nccwpck_require__.nmd = e => {
|
||
e.paths = [];
|
||
if (!e.children) e.children = [];
|
||
return e;
|
||
};
|
||
})();
|
||
if (typeof __nccwpck_require__ !== "undefined")
|
||
__nccwpck_require__.ab = __dirname + "/";
|
||
var r = __nccwpck_require__(4200);
|
||
module.exports = r;
|
||
})();
|