6545 lines
214 KiB
JavaScript
6545 lines
214 KiB
JavaScript
/*
|
|
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
|
|
if you want to view the source, please visit the github repository of this plugin
|
|
*/
|
|
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __defProps = Object.defineProperties;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __spreadValues = (a, b) => {
|
|
for (var prop in b || (b = {}))
|
|
if (__hasOwnProp.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
if (__getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(b)) {
|
|
if (__propIsEnum.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
}
|
|
return a;
|
|
};
|
|
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var __async = (__this, __arguments, generator) => {
|
|
return new Promise((resolve, reject) => {
|
|
var fulfilled = (value) => {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var rejected = (value) => {
|
|
try {
|
|
step(generator.throw(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
|
|
step((generator = generator.apply(__this, __arguments)).next());
|
|
});
|
|
};
|
|
|
|
// node_modules/moment/moment.js
|
|
var require_moment = __commonJS({
|
|
"node_modules/moment/moment.js"(exports, module2) {
|
|
(function(global2, factory) {
|
|
typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : global2.moment = factory();
|
|
})(exports, function() {
|
|
"use strict";
|
|
var hookCallback;
|
|
function hooks() {
|
|
return hookCallback.apply(null, arguments);
|
|
}
|
|
function setHookCallback(callback) {
|
|
hookCallback = callback;
|
|
}
|
|
function isArray(input) {
|
|
return input instanceof Array || Object.prototype.toString.call(input) === "[object Array]";
|
|
}
|
|
function isObject(input) {
|
|
return input != null && Object.prototype.toString.call(input) === "[object Object]";
|
|
}
|
|
function hasOwnProp(a, b) {
|
|
return Object.prototype.hasOwnProperty.call(a, b);
|
|
}
|
|
function isObjectEmpty(obj) {
|
|
if (Object.getOwnPropertyNames) {
|
|
return Object.getOwnPropertyNames(obj).length === 0;
|
|
} else {
|
|
var k;
|
|
for (k in obj) {
|
|
if (hasOwnProp(obj, k)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function isUndefined(input) {
|
|
return input === void 0;
|
|
}
|
|
function isNumber(input) {
|
|
return typeof input === "number" || Object.prototype.toString.call(input) === "[object Number]";
|
|
}
|
|
function isDate(input) {
|
|
return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
|
|
}
|
|
function map(arr, fn) {
|
|
var res = [], i, arrLen = arr.length;
|
|
for (i = 0; i < arrLen; ++i) {
|
|
res.push(fn(arr[i], i));
|
|
}
|
|
return res;
|
|
}
|
|
function extend(a, b) {
|
|
for (var i in b) {
|
|
if (hasOwnProp(b, i)) {
|
|
a[i] = b[i];
|
|
}
|
|
}
|
|
if (hasOwnProp(b, "toString")) {
|
|
a.toString = b.toString;
|
|
}
|
|
if (hasOwnProp(b, "valueOf")) {
|
|
a.valueOf = b.valueOf;
|
|
}
|
|
return a;
|
|
}
|
|
function createUTC(input, format2, locale2, strict) {
|
|
return createLocalOrUTC(input, format2, locale2, strict, 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(m) {
|
|
if (m._pf == null) {
|
|
m._pf = defaultParsingFlags();
|
|
}
|
|
return m._pf;
|
|
}
|
|
var some;
|
|
if (Array.prototype.some) {
|
|
some = Array.prototype.some;
|
|
} else {
|
|
some = function(fun) {
|
|
var t = Object(this), len = t.length >>> 0, i;
|
|
for (i = 0; i < len; i++) {
|
|
if (i in t && fun.call(this, t[i], i, t)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
function isValid(m) {
|
|
if (m._isValid == null) {
|
|
var flags = getParsingFlags(m), parsedParts = some.call(flags.parsedDateParts, function(i) {
|
|
return i != null;
|
|
}), isNowValid = !isNaN(m._d.getTime()) && flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts);
|
|
if (m._strict) {
|
|
isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === void 0;
|
|
}
|
|
if (Object.isFrozen == null || !Object.isFrozen(m)) {
|
|
m._isValid = isNowValid;
|
|
} else {
|
|
return isNowValid;
|
|
}
|
|
}
|
|
return m._isValid;
|
|
}
|
|
function createInvalid(flags) {
|
|
var m = createUTC(NaN);
|
|
if (flags != null) {
|
|
extend(getParsingFlags(m), flags);
|
|
} else {
|
|
getParsingFlags(m).userInvalidated = true;
|
|
}
|
|
return m;
|
|
}
|
|
var momentProperties = hooks.momentProperties = [], updateInProgress = false;
|
|
function copyConfig(to2, from2) {
|
|
var i, prop, val, momentPropertiesLen = momentProperties.length;
|
|
if (!isUndefined(from2._isAMomentObject)) {
|
|
to2._isAMomentObject = from2._isAMomentObject;
|
|
}
|
|
if (!isUndefined(from2._i)) {
|
|
to2._i = from2._i;
|
|
}
|
|
if (!isUndefined(from2._f)) {
|
|
to2._f = from2._f;
|
|
}
|
|
if (!isUndefined(from2._l)) {
|
|
to2._l = from2._l;
|
|
}
|
|
if (!isUndefined(from2._strict)) {
|
|
to2._strict = from2._strict;
|
|
}
|
|
if (!isUndefined(from2._tzm)) {
|
|
to2._tzm = from2._tzm;
|
|
}
|
|
if (!isUndefined(from2._isUTC)) {
|
|
to2._isUTC = from2._isUTC;
|
|
}
|
|
if (!isUndefined(from2._offset)) {
|
|
to2._offset = from2._offset;
|
|
}
|
|
if (!isUndefined(from2._pf)) {
|
|
to2._pf = getParsingFlags(from2);
|
|
}
|
|
if (!isUndefined(from2._locale)) {
|
|
to2._locale = from2._locale;
|
|
}
|
|
if (momentPropertiesLen > 0) {
|
|
for (i = 0; i < momentPropertiesLen; i++) {
|
|
prop = momentProperties[i];
|
|
val = from2[prop];
|
|
if (!isUndefined(val)) {
|
|
to2[prop] = val;
|
|
}
|
|
}
|
|
}
|
|
return to2;
|
|
}
|
|
function Moment(config) {
|
|
copyConfig(this, config);
|
|
this._d = new Date(config._d != null ? config._d.getTime() : NaN);
|
|
if (!this.isValid()) {
|
|
this._d = new Date(NaN);
|
|
}
|
|
if (updateInProgress === false) {
|
|
updateInProgress = true;
|
|
hooks.updateOffset(this);
|
|
updateInProgress = false;
|
|
}
|
|
}
|
|
function isMoment(obj) {
|
|
return obj instanceof Moment || obj != null && obj._isAMomentObject != null;
|
|
}
|
|
function warn(msg) {
|
|
if (hooks.suppressDeprecationWarnings === false && typeof console !== "undefined" && console.warn) {
|
|
console.warn("Deprecation warning: " + msg);
|
|
}
|
|
}
|
|
function deprecate(msg, fn) {
|
|
var firstTime = true;
|
|
return extend(function() {
|
|
if (hooks.deprecationHandler != null) {
|
|
hooks.deprecationHandler(null, msg);
|
|
}
|
|
if (firstTime) {
|
|
var args = [], arg, i, key, argLen = arguments.length;
|
|
for (i = 0; i < argLen; i++) {
|
|
arg = "";
|
|
if (typeof arguments[i] === "object") {
|
|
arg += "\n[" + i + "] ";
|
|
for (key in arguments[0]) {
|
|
if (hasOwnProp(arguments[0], key)) {
|
|
arg += key + ": " + arguments[0][key] + ", ";
|
|
}
|
|
}
|
|
arg = arg.slice(0, -2);
|
|
} else {
|
|
arg = arguments[i];
|
|
}
|
|
args.push(arg);
|
|
}
|
|
warn(
|
|
msg + "\nArguments: " + Array.prototype.slice.call(args).join("") + "\n" + new Error().stack
|
|
);
|
|
firstTime = false;
|
|
}
|
|
return fn.apply(this, arguments);
|
|
}, fn);
|
|
}
|
|
var deprecations = {};
|
|
function deprecateSimple(name, msg) {
|
|
if (hooks.deprecationHandler != null) {
|
|
hooks.deprecationHandler(name, msg);
|
|
}
|
|
if (!deprecations[name]) {
|
|
warn(msg);
|
|
deprecations[name] = true;
|
|
}
|
|
}
|
|
hooks.suppressDeprecationWarnings = false;
|
|
hooks.deprecationHandler = null;
|
|
function isFunction(input) {
|
|
return typeof Function !== "undefined" && input instanceof Function || Object.prototype.toString.call(input) === "[object Function]";
|
|
}
|
|
function set3(config) {
|
|
var prop, i;
|
|
for (i in config) {
|
|
if (hasOwnProp(config, i)) {
|
|
prop = config[i];
|
|
if (isFunction(prop)) {
|
|
this[i] = prop;
|
|
} else {
|
|
this["_" + i] = prop;
|
|
}
|
|
}
|
|
}
|
|
this._config = config;
|
|
this._dayOfMonthOrdinalParseLenient = new RegExp(
|
|
(this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + "|" + /\d{1,2}/.source
|
|
);
|
|
}
|
|
function mergeConfigs(parentConfig, childConfig) {
|
|
var res = extend({}, parentConfig), prop;
|
|
for (prop in childConfig) {
|
|
if (hasOwnProp(childConfig, prop)) {
|
|
if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
|
|
res[prop] = {};
|
|
extend(res[prop], parentConfig[prop]);
|
|
extend(res[prop], childConfig[prop]);
|
|
} else if (childConfig[prop] != null) {
|
|
res[prop] = childConfig[prop];
|
|
} else {
|
|
delete res[prop];
|
|
}
|
|
}
|
|
}
|
|
for (prop in parentConfig) {
|
|
if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) {
|
|
res[prop] = extend({}, res[prop]);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
function Locale(config) {
|
|
if (config != null) {
|
|
this.set(config);
|
|
}
|
|
}
|
|
var keys;
|
|
if (Object.keys) {
|
|
keys = Object.keys;
|
|
} else {
|
|
keys = function(obj) {
|
|
var i, res = [];
|
|
for (i in obj) {
|
|
if (hasOwnProp(obj, i)) {
|
|
res.push(i);
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
}
|
|
var defaultCalendar = {
|
|
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(key, mom, now2) {
|
|
var output = this._calendar[key] || this._calendar["sameElse"];
|
|
return isFunction(output) ? output.call(mom, now2) : output;
|
|
}
|
|
function zeroFill(number, targetLength, forceSign) {
|
|
var absNumber = "" + Math.abs(number), zerosToFill = targetLength - absNumber.length, sign2 = number >= 0;
|
|
return (sign2 ? forceSign ? "+" : "" : "-") + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
|
|
}
|
|
var formattingTokens = /(\[[^\[]*\])|(\\)?([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, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, formatFunctions = {}, formatTokenFunctions = {};
|
|
function addFormatToken(token2, padded, ordinal2, callback) {
|
|
var func = callback;
|
|
if (typeof callback === "string") {
|
|
func = function() {
|
|
return this[callback]();
|
|
};
|
|
}
|
|
if (token2) {
|
|
formatTokenFunctions[token2] = func;
|
|
}
|
|
if (padded) {
|
|
formatTokenFunctions[padded[0]] = function() {
|
|
return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
|
|
};
|
|
}
|
|
if (ordinal2) {
|
|
formatTokenFunctions[ordinal2] = function() {
|
|
return this.localeData().ordinal(
|
|
func.apply(this, arguments),
|
|
token2
|
|
);
|
|
};
|
|
}
|
|
}
|
|
function removeFormattingTokens(input) {
|
|
if (input.match(/\[[\s\S]/)) {
|
|
return input.replace(/^\[|\]$/g, "");
|
|
}
|
|
return input.replace(/\\/g, "");
|
|
}
|
|
function makeFormatFunction(format2) {
|
|
var array = format2.match(formattingTokens), i, length;
|
|
for (i = 0, length = array.length; i < length; i++) {
|
|
if (formatTokenFunctions[array[i]]) {
|
|
array[i] = formatTokenFunctions[array[i]];
|
|
} else {
|
|
array[i] = removeFormattingTokens(array[i]);
|
|
}
|
|
}
|
|
return function(mom) {
|
|
var output = "", i2;
|
|
for (i2 = 0; i2 < length; i2++) {
|
|
output += isFunction(array[i2]) ? array[i2].call(mom, format2) : array[i2];
|
|
}
|
|
return output;
|
|
};
|
|
}
|
|
function formatMoment(m, format2) {
|
|
if (!m.isValid()) {
|
|
return m.localeData().invalidDate();
|
|
}
|
|
format2 = expandFormat(format2, m.localeData());
|
|
formatFunctions[format2] = formatFunctions[format2] || makeFormatFunction(format2);
|
|
return formatFunctions[format2](m);
|
|
}
|
|
function expandFormat(format2, locale2) {
|
|
var i = 5;
|
|
function replaceLongDateFormatTokens(input) {
|
|
return locale2.longDateFormat(input) || input;
|
|
}
|
|
localFormattingTokens.lastIndex = 0;
|
|
while (i >= 0 && localFormattingTokens.test(format2)) {
|
|
format2 = format2.replace(
|
|
localFormattingTokens,
|
|
replaceLongDateFormatTokens
|
|
);
|
|
localFormattingTokens.lastIndex = 0;
|
|
i -= 1;
|
|
}
|
|
return format2;
|
|
}
|
|
var defaultLongDateFormat = {
|
|
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(key) {
|
|
var format2 = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()];
|
|
if (format2 || !formatUpper) {
|
|
return format2;
|
|
}
|
|
this._longDateFormat[key] = formatUpper.match(formattingTokens).map(function(tok) {
|
|
if (tok === "MMMM" || tok === "MM" || tok === "DD" || tok === "dddd") {
|
|
return tok.slice(1);
|
|
}
|
|
return tok;
|
|
}).join("");
|
|
return this._longDateFormat[key];
|
|
}
|
|
var defaultInvalidDate = "Invalid date";
|
|
function invalidDate() {
|
|
return this._invalidDate;
|
|
}
|
|
var defaultOrdinal = "%d", defaultDayOfMonthOrdinalParse = /\d{1,2}/;
|
|
function ordinal(number) {
|
|
return this._ordinal.replace("%d", number);
|
|
}
|
|
var defaultRelativeTime = {
|
|
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(number, withoutSuffix, string, isFuture) {
|
|
var output = this._relativeTime[string];
|
|
return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
|
|
}
|
|
function pastFuture(diff2, output) {
|
|
var format2 = this._relativeTime[diff2 > 0 ? "future" : "past"];
|
|
return isFunction(format2) ? format2(output) : format2.replace(/%s/i, output);
|
|
}
|
|
var aliases = {};
|
|
function addUnitAlias(unit, shorthand) {
|
|
var lowerCase = unit.toLowerCase();
|
|
aliases[lowerCase] = aliases[lowerCase + "s"] = aliases[shorthand] = unit;
|
|
}
|
|
function normalizeUnits(units) {
|
|
return typeof units === "string" ? aliases[units] || aliases[units.toLowerCase()] : void 0;
|
|
}
|
|
function normalizeObjectUnits(inputObject) {
|
|
var normalizedInput = {}, normalizedProp, prop;
|
|
for (prop in inputObject) {
|
|
if (hasOwnProp(inputObject, prop)) {
|
|
normalizedProp = normalizeUnits(prop);
|
|
if (normalizedProp) {
|
|
normalizedInput[normalizedProp] = inputObject[prop];
|
|
}
|
|
}
|
|
}
|
|
return normalizedInput;
|
|
}
|
|
var priorities = {};
|
|
function addUnitPriority(unit, priority) {
|
|
priorities[unit] = priority;
|
|
}
|
|
function getPrioritizedUnits(unitsObj) {
|
|
var units = [], u;
|
|
for (u in unitsObj) {
|
|
if (hasOwnProp(unitsObj, u)) {
|
|
units.push({ unit: u, priority: priorities[u] });
|
|
}
|
|
}
|
|
units.sort(function(a, b) {
|
|
return a.priority - b.priority;
|
|
});
|
|
return units;
|
|
}
|
|
function isLeapYear(year) {
|
|
return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
|
|
}
|
|
function absFloor(number) {
|
|
if (number < 0) {
|
|
return Math.ceil(number) || 0;
|
|
} else {
|
|
return Math.floor(number);
|
|
}
|
|
}
|
|
function toInt(argumentForCoercion) {
|
|
var coercedNumber = +argumentForCoercion, value = 0;
|
|
if (coercedNumber !== 0 && isFinite(coercedNumber)) {
|
|
value = absFloor(coercedNumber);
|
|
}
|
|
return value;
|
|
}
|
|
function makeGetSet(unit, keepTime) {
|
|
return function(value) {
|
|
if (value != null) {
|
|
set$1(this, unit, value);
|
|
hooks.updateOffset(this, keepTime);
|
|
return this;
|
|
} else {
|
|
return get(this, unit);
|
|
}
|
|
};
|
|
}
|
|
function get(mom, unit) {
|
|
return mom.isValid() ? mom._d["get" + (mom._isUTC ? "UTC" : "") + unit]() : NaN;
|
|
}
|
|
function set$1(mom, unit, value) {
|
|
if (mom.isValid() && !isNaN(value)) {
|
|
if (unit === "FullYear" && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
|
|
value = toInt(value);
|
|
mom._d["set" + (mom._isUTC ? "UTC" : "") + unit](
|
|
value,
|
|
mom.month(),
|
|
daysInMonth(value, mom.month())
|
|
);
|
|
} else {
|
|
mom._d["set" + (mom._isUTC ? "UTC" : "") + unit](value);
|
|
}
|
|
}
|
|
}
|
|
function stringGet(units) {
|
|
units = normalizeUnits(units);
|
|
if (isFunction(this[units])) {
|
|
return this[units]();
|
|
}
|
|
return this;
|
|
}
|
|
function stringSet(units, value) {
|
|
if (typeof units === "object") {
|
|
units = normalizeObjectUnits(units);
|
|
var prioritized = getPrioritizedUnits(units), i, prioritizedLen = prioritized.length;
|
|
for (i = 0; i < prioritizedLen; i++) {
|
|
this[prioritized[i].unit](units[prioritized[i].unit]);
|
|
}
|
|
} else {
|
|
units = normalizeUnits(units);
|
|
if (isFunction(this[units])) {
|
|
return this[units](value);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
var match1 = /\d/, match2 = /\d\d/, match3 = /\d{3}/, match4 = /\d{4}/, match6 = /[+-]?\d{6}/, match1to2 = /\d\d?/, match3to4 = /\d\d\d\d?/, match5to6 = /\d\d\d\d\d\d?/, match1to3 = /\d{1,3}/, match1to4 = /\d{1,4}/, match1to6 = /[+-]?\d{1,6}/, matchUnsigned = /\d+/, matchSigned = /[+-]?\d+/, matchOffset = /Z|[+-]\d\d:?\d\d/gi, matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, matchWord = /[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, regexes;
|
|
regexes = {};
|
|
function addRegexToken(token2, regex, strictRegex) {
|
|
regexes[token2] = isFunction(regex) ? regex : function(isStrict, localeData2) {
|
|
return isStrict && strictRegex ? strictRegex : regex;
|
|
};
|
|
}
|
|
function getParseRegexForToken(token2, config) {
|
|
if (!hasOwnProp(regexes, token2)) {
|
|
return new RegExp(unescapeFormat(token2));
|
|
}
|
|
return regexes[token2](config._strict, config._locale);
|
|
}
|
|
function unescapeFormat(s) {
|
|
return regexEscape(
|
|
s.replace("\\", "").replace(
|
|
/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
|
|
function(matched, p1, p2, p3, p4) {
|
|
return p1 || p2 || p3 || p4;
|
|
}
|
|
)
|
|
);
|
|
}
|
|
function regexEscape(s) {
|
|
return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
|
|
}
|
|
var tokens = {};
|
|
function addParseToken(token2, callback) {
|
|
var i, func = callback, tokenLen;
|
|
if (typeof token2 === "string") {
|
|
token2 = [token2];
|
|
}
|
|
if (isNumber(callback)) {
|
|
func = function(input, array) {
|
|
array[callback] = toInt(input);
|
|
};
|
|
}
|
|
tokenLen = token2.length;
|
|
for (i = 0; i < tokenLen; i++) {
|
|
tokens[token2[i]] = func;
|
|
}
|
|
}
|
|
function addWeekParseToken(token2, callback) {
|
|
addParseToken(token2, function(input, array, config, token3) {
|
|
config._w = config._w || {};
|
|
callback(input, config._w, config, token3);
|
|
});
|
|
}
|
|
function addTimeToArrayFromToken(token2, input, config) {
|
|
if (input != null && hasOwnProp(tokens, token2)) {
|
|
tokens[token2](input, config._a, config, token2);
|
|
}
|
|
}
|
|
var YEAR = 0, MONTH = 1, DATE = 2, HOUR = 3, MINUTE = 4, SECOND = 5, MILLISECOND = 6, WEEK = 7, WEEKDAY = 8;
|
|
function mod(n, x) {
|
|
return (n % x + x) % x;
|
|
}
|
|
var indexOf;
|
|
if (Array.prototype.indexOf) {
|
|
indexOf = Array.prototype.indexOf;
|
|
} else {
|
|
indexOf = function(o) {
|
|
var i;
|
|
for (i = 0; i < this.length; ++i) {
|
|
if (this[i] === o) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
}
|
|
function daysInMonth(year, month) {
|
|
if (isNaN(year) || isNaN(month)) {
|
|
return NaN;
|
|
}
|
|
var modMonth = mod(month, 12);
|
|
year += (month - modMonth) / 12;
|
|
return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2;
|
|
}
|
|
addFormatToken("M", ["MM", 2], "Mo", function() {
|
|
return this.month() + 1;
|
|
});
|
|
addFormatToken("MMM", 0, 0, function(format2) {
|
|
return this.localeData().monthsShort(this, format2);
|
|
});
|
|
addFormatToken("MMMM", 0, 0, function(format2) {
|
|
return this.localeData().months(this, format2);
|
|
});
|
|
addUnitAlias("month", "M");
|
|
addUnitPriority("month", 8);
|
|
addRegexToken("M", match1to2);
|
|
addRegexToken("MM", match1to2, match2);
|
|
addRegexToken("MMM", function(isStrict, locale2) {
|
|
return locale2.monthsShortRegex(isStrict);
|
|
});
|
|
addRegexToken("MMMM", function(isStrict, locale2) {
|
|
return locale2.monthsRegex(isStrict);
|
|
});
|
|
addParseToken(["M", "MM"], function(input, array) {
|
|
array[MONTH] = toInt(input) - 1;
|
|
});
|
|
addParseToken(["MMM", "MMMM"], function(input, array, config, token2) {
|
|
var month = config._locale.monthsParse(input, token2, config._strict);
|
|
if (month != null) {
|
|
array[MONTH] = month;
|
|
} else {
|
|
getParsingFlags(config).invalidMonth = input;
|
|
}
|
|
});
|
|
var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split(
|
|
"_"
|
|
), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord;
|
|
function localeMonths(m, format2) {
|
|
if (!m) {
|
|
return isArray(this._months) ? this._months : this._months["standalone"];
|
|
}
|
|
return isArray(this._months) ? this._months[m.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format2) ? "format" : "standalone"][m.month()];
|
|
}
|
|
function localeMonthsShort(m, format2) {
|
|
if (!m) {
|
|
return isArray(this._monthsShort) ? this._monthsShort : this._monthsShort["standalone"];
|
|
}
|
|
return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format2) ? "format" : "standalone"][m.month()];
|
|
}
|
|
function handleStrictParse(monthName, format2, strict) {
|
|
var i, ii, mom, llc = monthName.toLocaleLowerCase();
|
|
if (!this._monthsParse) {
|
|
this._monthsParse = [];
|
|
this._longMonthsParse = [];
|
|
this._shortMonthsParse = [];
|
|
for (i = 0; i < 12; ++i) {
|
|
mom = createUTC([2e3, i]);
|
|
this._shortMonthsParse[i] = this.monthsShort(
|
|
mom,
|
|
""
|
|
).toLocaleLowerCase();
|
|
this._longMonthsParse[i] = this.months(mom, "").toLocaleLowerCase();
|
|
}
|
|
}
|
|
if (strict) {
|
|
if (format2 === "MMM") {
|
|
ii = indexOf.call(this._shortMonthsParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else {
|
|
ii = indexOf.call(this._longMonthsParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
}
|
|
} else {
|
|
if (format2 === "MMM") {
|
|
ii = indexOf.call(this._shortMonthsParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._longMonthsParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else {
|
|
ii = indexOf.call(this._longMonthsParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._shortMonthsParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
}
|
|
}
|
|
}
|
|
function localeMonthsParse(monthName, format2, strict) {
|
|
var i, mom, regex;
|
|
if (this._monthsParseExact) {
|
|
return handleStrictParse.call(this, monthName, format2, strict);
|
|
}
|
|
if (!this._monthsParse) {
|
|
this._monthsParse = [];
|
|
this._longMonthsParse = [];
|
|
this._shortMonthsParse = [];
|
|
}
|
|
for (i = 0; i < 12; i++) {
|
|
mom = createUTC([2e3, i]);
|
|
if (strict && !this._longMonthsParse[i]) {
|
|
this._longMonthsParse[i] = new RegExp(
|
|
"^" + this.months(mom, "").replace(".", "") + "$",
|
|
"i"
|
|
);
|
|
this._shortMonthsParse[i] = new RegExp(
|
|
"^" + this.monthsShort(mom, "").replace(".", "") + "$",
|
|
"i"
|
|
);
|
|
}
|
|
if (!strict && !this._monthsParse[i]) {
|
|
regex = "^" + this.months(mom, "") + "|^" + this.monthsShort(mom, "");
|
|
this._monthsParse[i] = new RegExp(regex.replace(".", ""), "i");
|
|
}
|
|
if (strict && format2 === "MMMM" && this._longMonthsParse[i].test(monthName)) {
|
|
return i;
|
|
} else if (strict && format2 === "MMM" && this._shortMonthsParse[i].test(monthName)) {
|
|
return i;
|
|
} else if (!strict && this._monthsParse[i].test(monthName)) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
function setMonth(mom, value) {
|
|
var dayOfMonth;
|
|
if (!mom.isValid()) {
|
|
return mom;
|
|
}
|
|
if (typeof value === "string") {
|
|
if (/^\d+$/.test(value)) {
|
|
value = toInt(value);
|
|
} else {
|
|
value = mom.localeData().monthsParse(value);
|
|
if (!isNumber(value)) {
|
|
return mom;
|
|
}
|
|
}
|
|
}
|
|
dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
|
|
mom._d["set" + (mom._isUTC ? "UTC" : "") + "Month"](value, dayOfMonth);
|
|
return mom;
|
|
}
|
|
function getSetMonth(value) {
|
|
if (value != null) {
|
|
setMonth(this, value);
|
|
hooks.updateOffset(this, true);
|
|
return this;
|
|
} else {
|
|
return get(this, "Month");
|
|
}
|
|
}
|
|
function getDaysInMonth() {
|
|
return daysInMonth(this.year(), this.month());
|
|
}
|
|
function monthsShortRegex(isStrict) {
|
|
if (this._monthsParseExact) {
|
|
if (!hasOwnProp(this, "_monthsRegex")) {
|
|
computeMonthsParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._monthsShortStrictRegex;
|
|
} else {
|
|
return this._monthsShortRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, "_monthsShortRegex")) {
|
|
this._monthsShortRegex = defaultMonthsShortRegex;
|
|
}
|
|
return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex;
|
|
}
|
|
}
|
|
function monthsRegex(isStrict) {
|
|
if (this._monthsParseExact) {
|
|
if (!hasOwnProp(this, "_monthsRegex")) {
|
|
computeMonthsParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._monthsStrictRegex;
|
|
} else {
|
|
return this._monthsRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, "_monthsRegex")) {
|
|
this._monthsRegex = defaultMonthsRegex;
|
|
}
|
|
return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex;
|
|
}
|
|
}
|
|
function computeMonthsParse() {
|
|
function cmpLenRev(a, b) {
|
|
return b.length - a.length;
|
|
}
|
|
var shortPieces = [], longPieces = [], mixedPieces = [], i, mom;
|
|
for (i = 0; i < 12; i++) {
|
|
mom = createUTC([2e3, i]);
|
|
shortPieces.push(this.monthsShort(mom, ""));
|
|
longPieces.push(this.months(mom, ""));
|
|
mixedPieces.push(this.months(mom, ""));
|
|
mixedPieces.push(this.monthsShort(mom, ""));
|
|
}
|
|
shortPieces.sort(cmpLenRev);
|
|
longPieces.sort(cmpLenRev);
|
|
mixedPieces.sort(cmpLenRev);
|
|
for (i = 0; i < 12; i++) {
|
|
shortPieces[i] = regexEscape(shortPieces[i]);
|
|
longPieces[i] = regexEscape(longPieces[i]);
|
|
}
|
|
for (i = 0; i < 24; i++) {
|
|
mixedPieces[i] = regexEscape(mixedPieces[i]);
|
|
}
|
|
this._monthsRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
|
|
this._monthsShortRegex = this._monthsRegex;
|
|
this._monthsStrictRegex = new RegExp(
|
|
"^(" + longPieces.join("|") + ")",
|
|
"i"
|
|
);
|
|
this._monthsShortStrictRegex = new RegExp(
|
|
"^(" + shortPieces.join("|") + ")",
|
|
"i"
|
|
);
|
|
}
|
|
addFormatToken("Y", 0, 0, function() {
|
|
var y = this.year();
|
|
return y <= 9999 ? zeroFill(y, 4) : "+" + y;
|
|
});
|
|
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");
|
|
addUnitAlias("year", "y");
|
|
addUnitPriority("year", 1);
|
|
addRegexToken("Y", matchSigned);
|
|
addRegexToken("YY", match1to2, match2);
|
|
addRegexToken("YYYY", match1to4, match4);
|
|
addRegexToken("YYYYY", match1to6, match6);
|
|
addRegexToken("YYYYYY", match1to6, match6);
|
|
addParseToken(["YYYYY", "YYYYYY"], YEAR);
|
|
addParseToken("YYYY", function(input, array) {
|
|
array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
|
|
});
|
|
addParseToken("YY", function(input, array) {
|
|
array[YEAR] = hooks.parseTwoDigitYear(input);
|
|
});
|
|
addParseToken("Y", function(input, array) {
|
|
array[YEAR] = parseInt(input, 10);
|
|
});
|
|
function daysInYear(year) {
|
|
return isLeapYear(year) ? 366 : 365;
|
|
}
|
|
hooks.parseTwoDigitYear = function(input) {
|
|
return toInt(input) + (toInt(input) > 68 ? 1900 : 2e3);
|
|
};
|
|
var getSetYear = makeGetSet("FullYear", true);
|
|
function getIsLeapYear() {
|
|
return isLeapYear(this.year());
|
|
}
|
|
function createDate(y, m, d, h, M, s, ms) {
|
|
var date;
|
|
if (y < 100 && y >= 0) {
|
|
date = new Date(y + 400, m, d, h, M, s, ms);
|
|
if (isFinite(date.getFullYear())) {
|
|
date.setFullYear(y);
|
|
}
|
|
} else {
|
|
date = new Date(y, m, d, h, M, s, ms);
|
|
}
|
|
return date;
|
|
}
|
|
function createUTCDate(y) {
|
|
var date, args;
|
|
if (y < 100 && y >= 0) {
|
|
args = Array.prototype.slice.call(arguments);
|
|
args[0] = y + 400;
|
|
date = new Date(Date.UTC.apply(null, args));
|
|
if (isFinite(date.getUTCFullYear())) {
|
|
date.setUTCFullYear(y);
|
|
}
|
|
} else {
|
|
date = new Date(Date.UTC.apply(null, arguments));
|
|
}
|
|
return date;
|
|
}
|
|
function firstWeekOffset(year, dow, doy) {
|
|
var fwd = 7 + dow - doy, fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
|
|
return -fwdlw + fwd - 1;
|
|
}
|
|
function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
|
|
var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
|
|
if (dayOfYear <= 0) {
|
|
resYear = year - 1;
|
|
resDayOfYear = daysInYear(resYear) + dayOfYear;
|
|
} else if (dayOfYear > daysInYear(year)) {
|
|
resYear = year + 1;
|
|
resDayOfYear = dayOfYear - daysInYear(year);
|
|
} else {
|
|
resYear = year;
|
|
resDayOfYear = dayOfYear;
|
|
}
|
|
return {
|
|
year: resYear,
|
|
dayOfYear: resDayOfYear
|
|
};
|
|
}
|
|
function weekOfYear(mom, dow, doy) {
|
|
var weekOffset = firstWeekOffset(mom.year(), dow, doy), week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, resWeek, resYear;
|
|
if (week < 1) {
|
|
resYear = mom.year() - 1;
|
|
resWeek = week + weeksInYear(resYear, dow, doy);
|
|
} else if (week > weeksInYear(mom.year(), dow, doy)) {
|
|
resWeek = week - weeksInYear(mom.year(), dow, doy);
|
|
resYear = mom.year() + 1;
|
|
} else {
|
|
resYear = mom.year();
|
|
resWeek = week;
|
|
}
|
|
return {
|
|
week: resWeek,
|
|
year: resYear
|
|
};
|
|
}
|
|
function weeksInYear(year, dow, doy) {
|
|
var weekOffset = firstWeekOffset(year, dow, doy), weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
|
|
return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
|
|
}
|
|
addFormatToken("w", ["ww", 2], "wo", "week");
|
|
addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
|
|
addUnitAlias("week", "w");
|
|
addUnitAlias("isoWeek", "W");
|
|
addUnitPriority("week", 5);
|
|
addUnitPriority("isoWeek", 5);
|
|
addRegexToken("w", match1to2);
|
|
addRegexToken("ww", match1to2, match2);
|
|
addRegexToken("W", match1to2);
|
|
addRegexToken("WW", match1to2, match2);
|
|
addWeekParseToken(
|
|
["w", "ww", "W", "WW"],
|
|
function(input, week, config, token2) {
|
|
week[token2.substr(0, 1)] = toInt(input);
|
|
}
|
|
);
|
|
function localeWeek(mom) {
|
|
return weekOfYear(mom, this._week.dow, this._week.doy).week;
|
|
}
|
|
var defaultLocaleWeek = {
|
|
dow: 0,
|
|
doy: 6
|
|
};
|
|
function localeFirstDayOfWeek() {
|
|
return this._week.dow;
|
|
}
|
|
function localeFirstDayOfYear() {
|
|
return this._week.doy;
|
|
}
|
|
function getSetWeek(input) {
|
|
var week = this.localeData().week(this);
|
|
return input == null ? week : this.add((input - week) * 7, "d");
|
|
}
|
|
function getSetISOWeek(input) {
|
|
var week = weekOfYear(this, 1, 4).week;
|
|
return input == null ? week : this.add((input - week) * 7, "d");
|
|
}
|
|
addFormatToken("d", 0, "do", "day");
|
|
addFormatToken("dd", 0, 0, function(format2) {
|
|
return this.localeData().weekdaysMin(this, format2);
|
|
});
|
|
addFormatToken("ddd", 0, 0, function(format2) {
|
|
return this.localeData().weekdaysShort(this, format2);
|
|
});
|
|
addFormatToken("dddd", 0, 0, function(format2) {
|
|
return this.localeData().weekdays(this, format2);
|
|
});
|
|
addFormatToken("e", 0, 0, "weekday");
|
|
addFormatToken("E", 0, 0, "isoWeekday");
|
|
addUnitAlias("day", "d");
|
|
addUnitAlias("weekday", "e");
|
|
addUnitAlias("isoWeekday", "E");
|
|
addUnitPriority("day", 11);
|
|
addUnitPriority("weekday", 11);
|
|
addUnitPriority("isoWeekday", 11);
|
|
addRegexToken("d", match1to2);
|
|
addRegexToken("e", match1to2);
|
|
addRegexToken("E", match1to2);
|
|
addRegexToken("dd", function(isStrict, locale2) {
|
|
return locale2.weekdaysMinRegex(isStrict);
|
|
});
|
|
addRegexToken("ddd", function(isStrict, locale2) {
|
|
return locale2.weekdaysShortRegex(isStrict);
|
|
});
|
|
addRegexToken("dddd", function(isStrict, locale2) {
|
|
return locale2.weekdaysRegex(isStrict);
|
|
});
|
|
addWeekParseToken(["dd", "ddd", "dddd"], function(input, week, config, token2) {
|
|
var weekday = config._locale.weekdaysParse(input, token2, config._strict);
|
|
if (weekday != null) {
|
|
week.d = weekday;
|
|
} else {
|
|
getParsingFlags(config).invalidWeekday = input;
|
|
}
|
|
});
|
|
addWeekParseToken(["d", "e", "E"], function(input, week, config, token2) {
|
|
week[token2] = toInt(input);
|
|
});
|
|
function parseWeekday(input, locale2) {
|
|
if (typeof input !== "string") {
|
|
return input;
|
|
}
|
|
if (!isNaN(input)) {
|
|
return parseInt(input, 10);
|
|
}
|
|
input = locale2.weekdaysParse(input);
|
|
if (typeof input === "number") {
|
|
return input;
|
|
}
|
|
return null;
|
|
}
|
|
function parseIsoWeekday(input, locale2) {
|
|
if (typeof input === "string") {
|
|
return locale2.weekdaysParse(input) % 7 || 7;
|
|
}
|
|
return isNaN(input) ? null : input;
|
|
}
|
|
function shiftWeekdays(ws, n) {
|
|
return ws.slice(n, 7).concat(ws.slice(0, n));
|
|
}
|
|
var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord;
|
|
function localeWeekdays(m, format2) {
|
|
var weekdays = isArray(this._weekdays) ? this._weekdays : this._weekdays[m && m !== true && this._weekdays.isFormat.test(format2) ? "format" : "standalone"];
|
|
return m === true ? shiftWeekdays(weekdays, this._week.dow) : m ? weekdays[m.day()] : weekdays;
|
|
}
|
|
function localeWeekdaysShort(m) {
|
|
return m === true ? shiftWeekdays(this._weekdaysShort, this._week.dow) : m ? this._weekdaysShort[m.day()] : this._weekdaysShort;
|
|
}
|
|
function localeWeekdaysMin(m) {
|
|
return m === true ? shiftWeekdays(this._weekdaysMin, this._week.dow) : m ? this._weekdaysMin[m.day()] : this._weekdaysMin;
|
|
}
|
|
function handleStrictParse$1(weekdayName, format2, strict) {
|
|
var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
|
|
if (!this._weekdaysParse) {
|
|
this._weekdaysParse = [];
|
|
this._shortWeekdaysParse = [];
|
|
this._minWeekdaysParse = [];
|
|
for (i = 0; i < 7; ++i) {
|
|
mom = createUTC([2e3, 1]).day(i);
|
|
this._minWeekdaysParse[i] = this.weekdaysMin(
|
|
mom,
|
|
""
|
|
).toLocaleLowerCase();
|
|
this._shortWeekdaysParse[i] = this.weekdaysShort(
|
|
mom,
|
|
""
|
|
).toLocaleLowerCase();
|
|
this._weekdaysParse[i] = this.weekdays(mom, "").toLocaleLowerCase();
|
|
}
|
|
}
|
|
if (strict) {
|
|
if (format2 === "dddd") {
|
|
ii = indexOf.call(this._weekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else if (format2 === "ddd") {
|
|
ii = indexOf.call(this._shortWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else {
|
|
ii = indexOf.call(this._minWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
}
|
|
} else {
|
|
if (format2 === "dddd") {
|
|
ii = indexOf.call(this._weekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._shortWeekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._minWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else if (format2 === "ddd") {
|
|
ii = indexOf.call(this._shortWeekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._weekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._minWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else {
|
|
ii = indexOf.call(this._minWeekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._weekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._shortWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
}
|
|
}
|
|
}
|
|
function localeWeekdaysParse(weekdayName, format2, strict) {
|
|
var i, mom, regex;
|
|
if (this._weekdaysParseExact) {
|
|
return handleStrictParse$1.call(this, weekdayName, format2, strict);
|
|
}
|
|
if (!this._weekdaysParse) {
|
|
this._weekdaysParse = [];
|
|
this._minWeekdaysParse = [];
|
|
this._shortWeekdaysParse = [];
|
|
this._fullWeekdaysParse = [];
|
|
}
|
|
for (i = 0; i < 7; i++) {
|
|
mom = createUTC([2e3, 1]).day(i);
|
|
if (strict && !this._fullWeekdaysParse[i]) {
|
|
this._fullWeekdaysParse[i] = new RegExp(
|
|
"^" + this.weekdays(mom, "").replace(".", "\\.?") + "$",
|
|
"i"
|
|
);
|
|
this._shortWeekdaysParse[i] = new RegExp(
|
|
"^" + this.weekdaysShort(mom, "").replace(".", "\\.?") + "$",
|
|
"i"
|
|
);
|
|
this._minWeekdaysParse[i] = new RegExp(
|
|
"^" + this.weekdaysMin(mom, "").replace(".", "\\.?") + "$",
|
|
"i"
|
|
);
|
|
}
|
|
if (!this._weekdaysParse[i]) {
|
|
regex = "^" + this.weekdays(mom, "") + "|^" + this.weekdaysShort(mom, "") + "|^" + this.weekdaysMin(mom, "");
|
|
this._weekdaysParse[i] = new RegExp(regex.replace(".", ""), "i");
|
|
}
|
|
if (strict && format2 === "dddd" && this._fullWeekdaysParse[i].test(weekdayName)) {
|
|
return i;
|
|
} else if (strict && format2 === "ddd" && this._shortWeekdaysParse[i].test(weekdayName)) {
|
|
return i;
|
|
} else if (strict && format2 === "dd" && this._minWeekdaysParse[i].test(weekdayName)) {
|
|
return i;
|
|
} else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
function getSetDayOfWeek(input) {
|
|
if (!this.isValid()) {
|
|
return input != null ? this : NaN;
|
|
}
|
|
var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
|
|
if (input != null) {
|
|
input = parseWeekday(input, this.localeData());
|
|
return this.add(input - day, "d");
|
|
} else {
|
|
return day;
|
|
}
|
|
}
|
|
function getSetLocaleDayOfWeek(input) {
|
|
if (!this.isValid()) {
|
|
return input != null ? this : NaN;
|
|
}
|
|
var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
|
|
return input == null ? weekday : this.add(input - weekday, "d");
|
|
}
|
|
function getSetISODayOfWeek(input) {
|
|
if (!this.isValid()) {
|
|
return input != null ? this : NaN;
|
|
}
|
|
if (input != null) {
|
|
var weekday = parseIsoWeekday(input, this.localeData());
|
|
return this.day(this.day() % 7 ? weekday : weekday - 7);
|
|
} else {
|
|
return this.day() || 7;
|
|
}
|
|
}
|
|
function weekdaysRegex(isStrict) {
|
|
if (this._weekdaysParseExact) {
|
|
if (!hasOwnProp(this, "_weekdaysRegex")) {
|
|
computeWeekdaysParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._weekdaysStrictRegex;
|
|
} else {
|
|
return this._weekdaysRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, "_weekdaysRegex")) {
|
|
this._weekdaysRegex = defaultWeekdaysRegex;
|
|
}
|
|
return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;
|
|
}
|
|
}
|
|
function weekdaysShortRegex(isStrict) {
|
|
if (this._weekdaysParseExact) {
|
|
if (!hasOwnProp(this, "_weekdaysRegex")) {
|
|
computeWeekdaysParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._weekdaysShortStrictRegex;
|
|
} else {
|
|
return this._weekdaysShortRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, "_weekdaysShortRegex")) {
|
|
this._weekdaysShortRegex = defaultWeekdaysShortRegex;
|
|
}
|
|
return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
|
|
}
|
|
}
|
|
function weekdaysMinRegex(isStrict) {
|
|
if (this._weekdaysParseExact) {
|
|
if (!hasOwnProp(this, "_weekdaysRegex")) {
|
|
computeWeekdaysParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._weekdaysMinStrictRegex;
|
|
} else {
|
|
return this._weekdaysMinRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, "_weekdaysMinRegex")) {
|
|
this._weekdaysMinRegex = defaultWeekdaysMinRegex;
|
|
}
|
|
return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
|
|
}
|
|
}
|
|
function computeWeekdaysParse() {
|
|
function cmpLenRev(a, b) {
|
|
return b.length - a.length;
|
|
}
|
|
var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], i, mom, minp, shortp, longp;
|
|
for (i = 0; i < 7; i++) {
|
|
mom = createUTC([2e3, 1]).day(i);
|
|
minp = regexEscape(this.weekdaysMin(mom, ""));
|
|
shortp = regexEscape(this.weekdaysShort(mom, ""));
|
|
longp = regexEscape(this.weekdays(mom, ""));
|
|
minPieces.push(minp);
|
|
shortPieces.push(shortp);
|
|
longPieces.push(longp);
|
|
mixedPieces.push(minp);
|
|
mixedPieces.push(shortp);
|
|
mixedPieces.push(longp);
|
|
}
|
|
minPieces.sort(cmpLenRev);
|
|
shortPieces.sort(cmpLenRev);
|
|
longPieces.sort(cmpLenRev);
|
|
mixedPieces.sort(cmpLenRev);
|
|
this._weekdaysRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
|
|
this._weekdaysShortRegex = this._weekdaysRegex;
|
|
this._weekdaysMinRegex = this._weekdaysRegex;
|
|
this._weekdaysStrictRegex = new RegExp(
|
|
"^(" + longPieces.join("|") + ")",
|
|
"i"
|
|
);
|
|
this._weekdaysShortStrictRegex = new RegExp(
|
|
"^(" + shortPieces.join("|") + ")",
|
|
"i"
|
|
);
|
|
this._weekdaysMinStrictRegex = new RegExp(
|
|
"^(" + minPieces.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(token2, lowercase) {
|
|
addFormatToken(token2, 0, 0, function() {
|
|
return this.localeData().meridiem(
|
|
this.hours(),
|
|
this.minutes(),
|
|
lowercase
|
|
);
|
|
});
|
|
}
|
|
meridiem("a", true);
|
|
meridiem("A", false);
|
|
addUnitAlias("hour", "h");
|
|
addUnitPriority("hour", 13);
|
|
function matchMeridiem(isStrict, locale2) {
|
|
return locale2._meridiemParse;
|
|
}
|
|
addRegexToken("a", matchMeridiem);
|
|
addRegexToken("A", matchMeridiem);
|
|
addRegexToken("H", match1to2);
|
|
addRegexToken("h", match1to2);
|
|
addRegexToken("k", match1to2);
|
|
addRegexToken("HH", match1to2, match2);
|
|
addRegexToken("hh", match1to2, match2);
|
|
addRegexToken("kk", match1to2, match2);
|
|
addRegexToken("hmm", match3to4);
|
|
addRegexToken("hmmss", match5to6);
|
|
addRegexToken("Hmm", match3to4);
|
|
addRegexToken("Hmmss", match5to6);
|
|
addParseToken(["H", "HH"], HOUR);
|
|
addParseToken(["k", "kk"], function(input, array, config) {
|
|
var kInput = toInt(input);
|
|
array[HOUR] = kInput === 24 ? 0 : kInput;
|
|
});
|
|
addParseToken(["a", "A"], function(input, array, config) {
|
|
config._isPm = config._locale.isPM(input);
|
|
config._meridiem = input;
|
|
});
|
|
addParseToken(["h", "hh"], function(input, array, config) {
|
|
array[HOUR] = toInt(input);
|
|
getParsingFlags(config).bigHour = true;
|
|
});
|
|
addParseToken("hmm", function(input, array, config) {
|
|
var pos = input.length - 2;
|
|
array[HOUR] = toInt(input.substr(0, pos));
|
|
array[MINUTE] = toInt(input.substr(pos));
|
|
getParsingFlags(config).bigHour = true;
|
|
});
|
|
addParseToken("hmmss", function(input, array, config) {
|
|
var pos1 = input.length - 4, pos2 = input.length - 2;
|
|
array[HOUR] = toInt(input.substr(0, pos1));
|
|
array[MINUTE] = toInt(input.substr(pos1, 2));
|
|
array[SECOND] = toInt(input.substr(pos2));
|
|
getParsingFlags(config).bigHour = true;
|
|
});
|
|
addParseToken("Hmm", function(input, array, config) {
|
|
var pos = input.length - 2;
|
|
array[HOUR] = toInt(input.substr(0, pos));
|
|
array[MINUTE] = toInt(input.substr(pos));
|
|
});
|
|
addParseToken("Hmmss", function(input, array, config) {
|
|
var pos1 = input.length - 4, pos2 = input.length - 2;
|
|
array[HOUR] = toInt(input.substr(0, pos1));
|
|
array[MINUTE] = toInt(input.substr(pos1, 2));
|
|
array[SECOND] = toInt(input.substr(pos2));
|
|
});
|
|
function localeIsPM(input) {
|
|
return (input + "").toLowerCase().charAt(0) === "p";
|
|
}
|
|
var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i, getSetHour = makeGetSet("Hours", true);
|
|
function localeMeridiem(hours2, minutes2, isLower) {
|
|
if (hours2 > 11) {
|
|
return isLower ? "pm" : "PM";
|
|
} else {
|
|
return isLower ? "am" : "AM";
|
|
}
|
|
}
|
|
var baseConfig = {
|
|
calendar: defaultCalendar,
|
|
longDateFormat: defaultLongDateFormat,
|
|
invalidDate: defaultInvalidDate,
|
|
ordinal: defaultOrdinal,
|
|
dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
|
|
relativeTime: defaultRelativeTime,
|
|
months: defaultLocaleMonths,
|
|
monthsShort: defaultLocaleMonthsShort,
|
|
week: defaultLocaleWeek,
|
|
weekdays: defaultLocaleWeekdays,
|
|
weekdaysMin: defaultLocaleWeekdaysMin,
|
|
weekdaysShort: defaultLocaleWeekdaysShort,
|
|
meridiemParse: defaultLocaleMeridiemParse
|
|
};
|
|
var locales = {}, localeFamilies = {}, globalLocale;
|
|
function commonPrefix(arr1, arr2) {
|
|
var i, minl = Math.min(arr1.length, arr2.length);
|
|
for (i = 0; i < minl; i += 1) {
|
|
if (arr1[i] !== arr2[i]) {
|
|
return i;
|
|
}
|
|
}
|
|
return minl;
|
|
}
|
|
function normalizeLocale(key) {
|
|
return key ? key.toLowerCase().replace("_", "-") : key;
|
|
}
|
|
function chooseLocale(names) {
|
|
var i = 0, j, next, locale2, split;
|
|
while (i < names.length) {
|
|
split = normalizeLocale(names[i]).split("-");
|
|
j = split.length;
|
|
next = normalizeLocale(names[i + 1]);
|
|
next = next ? next.split("-") : null;
|
|
while (j > 0) {
|
|
locale2 = loadLocale(split.slice(0, j).join("-"));
|
|
if (locale2) {
|
|
return locale2;
|
|
}
|
|
if (next && next.length >= j && commonPrefix(split, next) >= j - 1) {
|
|
break;
|
|
}
|
|
j--;
|
|
}
|
|
i++;
|
|
}
|
|
return globalLocale;
|
|
}
|
|
function isLocaleNameSane(name) {
|
|
return name.match("^[^/\\\\]*$") != null;
|
|
}
|
|
function loadLocale(name) {
|
|
var oldLocale = null, aliasedRequire;
|
|
if (locales[name] === void 0 && typeof module2 !== "undefined" && module2 && module2.exports && isLocaleNameSane(name)) {
|
|
try {
|
|
oldLocale = globalLocale._abbr;
|
|
aliasedRequire = require;
|
|
aliasedRequire("./locale/" + name);
|
|
getSetGlobalLocale(oldLocale);
|
|
} catch (e) {
|
|
locales[name] = null;
|
|
}
|
|
}
|
|
return locales[name];
|
|
}
|
|
function getSetGlobalLocale(key, values) {
|
|
var data;
|
|
if (key) {
|
|
if (isUndefined(values)) {
|
|
data = getLocale(key);
|
|
} else {
|
|
data = defineLocale(key, values);
|
|
}
|
|
if (data) {
|
|
globalLocale = data;
|
|
} else {
|
|
if (typeof console !== "undefined" && console.warn) {
|
|
console.warn(
|
|
"Locale " + key + " not found. Did you forget to load it?"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return globalLocale._abbr;
|
|
}
|
|
function defineLocale(name, config) {
|
|
if (config !== null) {
|
|
var locale2, parentConfig = baseConfig;
|
|
config.abbr = name;
|
|
if (locales[name] != 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."
|
|
);
|
|
parentConfig = locales[name]._config;
|
|
} else if (config.parentLocale != null) {
|
|
if (locales[config.parentLocale] != null) {
|
|
parentConfig = locales[config.parentLocale]._config;
|
|
} else {
|
|
locale2 = loadLocale(config.parentLocale);
|
|
if (locale2 != null) {
|
|
parentConfig = locale2._config;
|
|
} else {
|
|
if (!localeFamilies[config.parentLocale]) {
|
|
localeFamilies[config.parentLocale] = [];
|
|
}
|
|
localeFamilies[config.parentLocale].push({
|
|
name,
|
|
config
|
|
});
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
locales[name] = new Locale(mergeConfigs(parentConfig, config));
|
|
if (localeFamilies[name]) {
|
|
localeFamilies[name].forEach(function(x) {
|
|
defineLocale(x.name, x.config);
|
|
});
|
|
}
|
|
getSetGlobalLocale(name);
|
|
return locales[name];
|
|
} else {
|
|
delete locales[name];
|
|
return null;
|
|
}
|
|
}
|
|
function updateLocale(name, config) {
|
|
if (config != null) {
|
|
var locale2, tmpLocale, parentConfig = baseConfig;
|
|
if (locales[name] != null && locales[name].parentLocale != null) {
|
|
locales[name].set(mergeConfigs(locales[name]._config, config));
|
|
} else {
|
|
tmpLocale = loadLocale(name);
|
|
if (tmpLocale != null) {
|
|
parentConfig = tmpLocale._config;
|
|
}
|
|
config = mergeConfigs(parentConfig, config);
|
|
if (tmpLocale == null) {
|
|
config.abbr = name;
|
|
}
|
|
locale2 = new Locale(config);
|
|
locale2.parentLocale = locales[name];
|
|
locales[name] = locale2;
|
|
}
|
|
getSetGlobalLocale(name);
|
|
} else {
|
|
if (locales[name] != null) {
|
|
if (locales[name].parentLocale != null) {
|
|
locales[name] = locales[name].parentLocale;
|
|
if (name === getSetGlobalLocale()) {
|
|
getSetGlobalLocale(name);
|
|
}
|
|
} else if (locales[name] != null) {
|
|
delete locales[name];
|
|
}
|
|
}
|
|
}
|
|
return locales[name];
|
|
}
|
|
function getLocale(key) {
|
|
var locale2;
|
|
if (key && key._locale && key._locale._abbr) {
|
|
key = key._locale._abbr;
|
|
}
|
|
if (!key) {
|
|
return globalLocale;
|
|
}
|
|
if (!isArray(key)) {
|
|
locale2 = loadLocale(key);
|
|
if (locale2) {
|
|
return locale2;
|
|
}
|
|
key = [key];
|
|
}
|
|
return chooseLocale(key);
|
|
}
|
|
function listLocales() {
|
|
return keys(locales);
|
|
}
|
|
function checkOverflow(m) {
|
|
var overflow, a = m._a;
|
|
if (a && getParsingFlags(m).overflow === -2) {
|
|
overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1;
|
|
if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
|
|
overflow = DATE;
|
|
}
|
|
if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
|
|
overflow = WEEK;
|
|
}
|
|
if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
|
|
overflow = WEEKDAY;
|
|
}
|
|
getParsingFlags(m).overflow = overflow;
|
|
}
|
|
return m;
|
|
}
|
|
var extendedIsoRegex = /^\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)?)?$/, basicIsoRegex = /^\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)?)?$/, tzRegex = /Z|[+-]\d\d(?::?\d\d)?/, isoDates = [
|
|
["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]
|
|
], isoTimes = [
|
|
["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/]
|
|
], aspNetJsonRegex = /^\/?Date\((-?\d+)/i, rfc2822 = /^(?:(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}))$/, obsOffsets = {
|
|
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(config) {
|
|
var i, l, string = config._i, match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat, isoDatesLen = isoDates.length, isoTimesLen = isoTimes.length;
|
|
if (match) {
|
|
getParsingFlags(config).iso = true;
|
|
for (i = 0, l = isoDatesLen; i < l; i++) {
|
|
if (isoDates[i][1].exec(match[1])) {
|
|
dateFormat = isoDates[i][0];
|
|
allowTime = isoDates[i][2] !== false;
|
|
break;
|
|
}
|
|
}
|
|
if (dateFormat == null) {
|
|
config._isValid = false;
|
|
return;
|
|
}
|
|
if (match[3]) {
|
|
for (i = 0, l = isoTimesLen; i < l; i++) {
|
|
if (isoTimes[i][1].exec(match[3])) {
|
|
timeFormat = (match[2] || " ") + isoTimes[i][0];
|
|
break;
|
|
}
|
|
}
|
|
if (timeFormat == null) {
|
|
config._isValid = false;
|
|
return;
|
|
}
|
|
}
|
|
if (!allowTime && timeFormat != null) {
|
|
config._isValid = false;
|
|
return;
|
|
}
|
|
if (match[4]) {
|
|
if (tzRegex.exec(match[4])) {
|
|
tzFormat = "Z";
|
|
} else {
|
|
config._isValid = false;
|
|
return;
|
|
}
|
|
}
|
|
config._f = dateFormat + (timeFormat || "") + (tzFormat || "");
|
|
configFromStringAndFormat(config);
|
|
} else {
|
|
config._isValid = false;
|
|
}
|
|
}
|
|
function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
|
|
var result = [
|
|
untruncateYear(yearStr),
|
|
defaultLocaleMonthsShort.indexOf(monthStr),
|
|
parseInt(dayStr, 10),
|
|
parseInt(hourStr, 10),
|
|
parseInt(minuteStr, 10)
|
|
];
|
|
if (secondStr) {
|
|
result.push(parseInt(secondStr, 10));
|
|
}
|
|
return result;
|
|
}
|
|
function untruncateYear(yearStr) {
|
|
var year = parseInt(yearStr, 10);
|
|
if (year <= 49) {
|
|
return 2e3 + year;
|
|
} else if (year <= 999) {
|
|
return 1900 + year;
|
|
}
|
|
return year;
|
|
}
|
|
function preprocessRFC2822(s) {
|
|
return s.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").replace(/^\s\s*/, "").replace(/\s\s*$/, "");
|
|
}
|
|
function checkWeekday(weekdayStr, parsedInput, config) {
|
|
if (weekdayStr) {
|
|
var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), weekdayActual = new Date(
|
|
parsedInput[0],
|
|
parsedInput[1],
|
|
parsedInput[2]
|
|
).getDay();
|
|
if (weekdayProvided !== weekdayActual) {
|
|
getParsingFlags(config).weekdayMismatch = true;
|
|
config._isValid = false;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function calculateOffset(obsOffset, militaryOffset, numOffset) {
|
|
if (obsOffset) {
|
|
return obsOffsets[obsOffset];
|
|
} else if (militaryOffset) {
|
|
return 0;
|
|
} else {
|
|
var hm = parseInt(numOffset, 10), m = hm % 100, h = (hm - m) / 100;
|
|
return h * 60 + m;
|
|
}
|
|
}
|
|
function configFromRFC2822(config) {
|
|
var match = rfc2822.exec(preprocessRFC2822(config._i)), parsedArray;
|
|
if (match) {
|
|
parsedArray = extractFromRFC2822Strings(
|
|
match[4],
|
|
match[3],
|
|
match[2],
|
|
match[5],
|
|
match[6],
|
|
match[7]
|
|
);
|
|
if (!checkWeekday(match[1], parsedArray, config)) {
|
|
return;
|
|
}
|
|
config._a = parsedArray;
|
|
config._tzm = calculateOffset(match[8], match[9], match[10]);
|
|
config._d = createUTCDate.apply(null, config._a);
|
|
config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
|
|
getParsingFlags(config).rfc2822 = true;
|
|
} else {
|
|
config._isValid = false;
|
|
}
|
|
}
|
|
function configFromString(config) {
|
|
var matched = aspNetJsonRegex.exec(config._i);
|
|
if (matched !== null) {
|
|
config._d = new Date(+matched[1]);
|
|
return;
|
|
}
|
|
configFromISO(config);
|
|
if (config._isValid === false) {
|
|
delete config._isValid;
|
|
} else {
|
|
return;
|
|
}
|
|
configFromRFC2822(config);
|
|
if (config._isValid === false) {
|
|
delete config._isValid;
|
|
} else {
|
|
return;
|
|
}
|
|
if (config._strict) {
|
|
config._isValid = false;
|
|
} else {
|
|
hooks.createFromInputFallback(config);
|
|
}
|
|
}
|
|
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(config) {
|
|
config._d = new Date(config._i + (config._useUTC ? " UTC" : ""));
|
|
}
|
|
);
|
|
function defaults(a, b, c) {
|
|
if (a != null) {
|
|
return a;
|
|
}
|
|
if (b != null) {
|
|
return b;
|
|
}
|
|
return c;
|
|
}
|
|
function currentDateArray(config) {
|
|
var nowValue = new Date(hooks.now());
|
|
if (config._useUTC) {
|
|
return [
|
|
nowValue.getUTCFullYear(),
|
|
nowValue.getUTCMonth(),
|
|
nowValue.getUTCDate()
|
|
];
|
|
}
|
|
return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
|
|
}
|
|
function configFromArray(config) {
|
|
var i, date, input = [], currentDate, expectedWeekday, yearToUse;
|
|
if (config._d) {
|
|
return;
|
|
}
|
|
currentDate = currentDateArray(config);
|
|
if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
|
|
dayOfYearFromWeekInfo(config);
|
|
}
|
|
if (config._dayOfYear != null) {
|
|
yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
|
|
if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
|
|
getParsingFlags(config)._overflowDayOfYear = true;
|
|
}
|
|
date = createUTCDate(yearToUse, 0, config._dayOfYear);
|
|
config._a[MONTH] = date.getUTCMonth();
|
|
config._a[DATE] = date.getUTCDate();
|
|
}
|
|
for (i = 0; i < 3 && config._a[i] == null; ++i) {
|
|
config._a[i] = input[i] = currentDate[i];
|
|
}
|
|
for (; i < 7; i++) {
|
|
config._a[i] = input[i] = config._a[i] == null ? i === 2 ? 1 : 0 : config._a[i];
|
|
}
|
|
if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {
|
|
config._nextDay = true;
|
|
config._a[HOUR] = 0;
|
|
}
|
|
config._d = (config._useUTC ? createUTCDate : createDate).apply(
|
|
null,
|
|
input
|
|
);
|
|
expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
|
|
if (config._tzm != null) {
|
|
config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
|
|
}
|
|
if (config._nextDay) {
|
|
config._a[HOUR] = 24;
|
|
}
|
|
if (config._w && typeof config._w.d !== "undefined" && config._w.d !== expectedWeekday) {
|
|
getParsingFlags(config).weekdayMismatch = true;
|
|
}
|
|
}
|
|
function dayOfYearFromWeekInfo(config) {
|
|
var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
|
|
w = config._w;
|
|
if (w.GG != null || w.W != null || w.E != null) {
|
|
dow = 1;
|
|
doy = 4;
|
|
weekYear = defaults(
|
|
w.GG,
|
|
config._a[YEAR],
|
|
weekOfYear(createLocal(), 1, 4).year
|
|
);
|
|
week = defaults(w.W, 1);
|
|
weekday = defaults(w.E, 1);
|
|
if (weekday < 1 || weekday > 7) {
|
|
weekdayOverflow = true;
|
|
}
|
|
} else {
|
|
dow = config._locale._week.dow;
|
|
doy = config._locale._week.doy;
|
|
curWeek = weekOfYear(createLocal(), dow, doy);
|
|
weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
|
|
week = defaults(w.w, curWeek.week);
|
|
if (w.d != null) {
|
|
weekday = w.d;
|
|
if (weekday < 0 || weekday > 6) {
|
|
weekdayOverflow = true;
|
|
}
|
|
} else if (w.e != null) {
|
|
weekday = w.e + dow;
|
|
if (w.e < 0 || w.e > 6) {
|
|
weekdayOverflow = true;
|
|
}
|
|
} else {
|
|
weekday = dow;
|
|
}
|
|
}
|
|
if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
|
|
getParsingFlags(config)._overflowWeeks = true;
|
|
} else if (weekdayOverflow != null) {
|
|
getParsingFlags(config)._overflowWeekday = true;
|
|
} else {
|
|
temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
|
|
config._a[YEAR] = temp.year;
|
|
config._dayOfYear = temp.dayOfYear;
|
|
}
|
|
}
|
|
hooks.ISO_8601 = function() {
|
|
};
|
|
hooks.RFC_2822 = function() {
|
|
};
|
|
function configFromStringAndFormat(config) {
|
|
if (config._f === hooks.ISO_8601) {
|
|
configFromISO(config);
|
|
return;
|
|
}
|
|
if (config._f === hooks.RFC_2822) {
|
|
configFromRFC2822(config);
|
|
return;
|
|
}
|
|
config._a = [];
|
|
getParsingFlags(config).empty = true;
|
|
var string = "" + config._i, i, parsedInput, tokens2, token2, skipped, stringLength = string.length, totalParsedInputLength = 0, era, tokenLen;
|
|
tokens2 = expandFormat(config._f, config._locale).match(formattingTokens) || [];
|
|
tokenLen = tokens2.length;
|
|
for (i = 0; i < tokenLen; i++) {
|
|
token2 = tokens2[i];
|
|
parsedInput = (string.match(getParseRegexForToken(token2, config)) || [])[0];
|
|
if (parsedInput) {
|
|
skipped = string.substr(0, string.indexOf(parsedInput));
|
|
if (skipped.length > 0) {
|
|
getParsingFlags(config).unusedInput.push(skipped);
|
|
}
|
|
string = string.slice(
|
|
string.indexOf(parsedInput) + parsedInput.length
|
|
);
|
|
totalParsedInputLength += parsedInput.length;
|
|
}
|
|
if (formatTokenFunctions[token2]) {
|
|
if (parsedInput) {
|
|
getParsingFlags(config).empty = false;
|
|
} else {
|
|
getParsingFlags(config).unusedTokens.push(token2);
|
|
}
|
|
addTimeToArrayFromToken(token2, parsedInput, config);
|
|
} else if (config._strict && !parsedInput) {
|
|
getParsingFlags(config).unusedTokens.push(token2);
|
|
}
|
|
}
|
|
getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
|
|
if (string.length > 0) {
|
|
getParsingFlags(config).unusedInput.push(string);
|
|
}
|
|
if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) {
|
|
getParsingFlags(config).bigHour = void 0;
|
|
}
|
|
getParsingFlags(config).parsedDateParts = config._a.slice(0);
|
|
getParsingFlags(config).meridiem = config._meridiem;
|
|
config._a[HOUR] = meridiemFixWrap(
|
|
config._locale,
|
|
config._a[HOUR],
|
|
config._meridiem
|
|
);
|
|
era = getParsingFlags(config).era;
|
|
if (era !== null) {
|
|
config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
|
|
}
|
|
configFromArray(config);
|
|
checkOverflow(config);
|
|
}
|
|
function meridiemFixWrap(locale2, hour, meridiem2) {
|
|
var isPm;
|
|
if (meridiem2 == null) {
|
|
return hour;
|
|
}
|
|
if (locale2.meridiemHour != null) {
|
|
return locale2.meridiemHour(hour, meridiem2);
|
|
} else if (locale2.isPM != null) {
|
|
isPm = locale2.isPM(meridiem2);
|
|
if (isPm && hour < 12) {
|
|
hour += 12;
|
|
}
|
|
if (!isPm && hour === 12) {
|
|
hour = 0;
|
|
}
|
|
return hour;
|
|
} else {
|
|
return hour;
|
|
}
|
|
}
|
|
function configFromStringAndArray(config) {
|
|
var tempConfig, bestMoment, scoreToBeat, i, currentScore, validFormatFound, bestFormatIsValid = false, configfLen = config._f.length;
|
|
if (configfLen === 0) {
|
|
getParsingFlags(config).invalidFormat = true;
|
|
config._d = new Date(NaN);
|
|
return;
|
|
}
|
|
for (i = 0; i < configfLen; i++) {
|
|
currentScore = 0;
|
|
validFormatFound = false;
|
|
tempConfig = copyConfig({}, config);
|
|
if (config._useUTC != null) {
|
|
tempConfig._useUTC = config._useUTC;
|
|
}
|
|
tempConfig._f = config._f[i];
|
|
configFromStringAndFormat(tempConfig);
|
|
if (isValid(tempConfig)) {
|
|
validFormatFound = true;
|
|
}
|
|
currentScore += getParsingFlags(tempConfig).charsLeftOver;
|
|
currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
|
|
getParsingFlags(tempConfig).score = currentScore;
|
|
if (!bestFormatIsValid) {
|
|
if (scoreToBeat == null || currentScore < scoreToBeat || validFormatFound) {
|
|
scoreToBeat = currentScore;
|
|
bestMoment = tempConfig;
|
|
if (validFormatFound) {
|
|
bestFormatIsValid = true;
|
|
}
|
|
}
|
|
} else {
|
|
if (currentScore < scoreToBeat) {
|
|
scoreToBeat = currentScore;
|
|
bestMoment = tempConfig;
|
|
}
|
|
}
|
|
}
|
|
extend(config, bestMoment || tempConfig);
|
|
}
|
|
function configFromObject(config) {
|
|
if (config._d) {
|
|
return;
|
|
}
|
|
var i = normalizeObjectUnits(config._i), dayOrDate = i.day === void 0 ? i.date : i.day;
|
|
config._a = map(
|
|
[i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
|
|
function(obj) {
|
|
return obj && parseInt(obj, 10);
|
|
}
|
|
);
|
|
configFromArray(config);
|
|
}
|
|
function createFromConfig(config) {
|
|
var res = new Moment(checkOverflow(prepareConfig(config)));
|
|
if (res._nextDay) {
|
|
res.add(1, "d");
|
|
res._nextDay = void 0;
|
|
}
|
|
return res;
|
|
}
|
|
function prepareConfig(config) {
|
|
var input = config._i, format2 = config._f;
|
|
config._locale = config._locale || getLocale(config._l);
|
|
if (input === null || format2 === void 0 && input === "") {
|
|
return createInvalid({ nullInput: true });
|
|
}
|
|
if (typeof input === "string") {
|
|
config._i = input = config._locale.preparse(input);
|
|
}
|
|
if (isMoment(input)) {
|
|
return new Moment(checkOverflow(input));
|
|
} else if (isDate(input)) {
|
|
config._d = input;
|
|
} else if (isArray(format2)) {
|
|
configFromStringAndArray(config);
|
|
} else if (format2) {
|
|
configFromStringAndFormat(config);
|
|
} else {
|
|
configFromInput(config);
|
|
}
|
|
if (!isValid(config)) {
|
|
config._d = null;
|
|
}
|
|
return config;
|
|
}
|
|
function configFromInput(config) {
|
|
var input = config._i;
|
|
if (isUndefined(input)) {
|
|
config._d = new Date(hooks.now());
|
|
} else if (isDate(input)) {
|
|
config._d = new Date(input.valueOf());
|
|
} else if (typeof input === "string") {
|
|
configFromString(config);
|
|
} else if (isArray(input)) {
|
|
config._a = map(input.slice(0), function(obj) {
|
|
return parseInt(obj, 10);
|
|
});
|
|
configFromArray(config);
|
|
} else if (isObject(input)) {
|
|
configFromObject(config);
|
|
} else if (isNumber(input)) {
|
|
config._d = new Date(input);
|
|
} else {
|
|
hooks.createFromInputFallback(config);
|
|
}
|
|
}
|
|
function createLocalOrUTC(input, format2, locale2, strict, isUTC) {
|
|
var c = {};
|
|
if (format2 === true || format2 === false) {
|
|
strict = format2;
|
|
format2 = void 0;
|
|
}
|
|
if (locale2 === true || locale2 === false) {
|
|
strict = locale2;
|
|
locale2 = void 0;
|
|
}
|
|
if (isObject(input) && isObjectEmpty(input) || isArray(input) && input.length === 0) {
|
|
input = void 0;
|
|
}
|
|
c._isAMomentObject = true;
|
|
c._useUTC = c._isUTC = isUTC;
|
|
c._l = locale2;
|
|
c._i = input;
|
|
c._f = format2;
|
|
c._strict = strict;
|
|
return createFromConfig(c);
|
|
}
|
|
function createLocal(input, format2, locale2, strict) {
|
|
return createLocalOrUTC(input, format2, locale2, strict, false);
|
|
}
|
|
var prototypeMin = deprecate(
|
|
"moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",
|
|
function() {
|
|
var other = createLocal.apply(null, arguments);
|
|
if (this.isValid() && other.isValid()) {
|
|
return other < this ? this : other;
|
|
} else {
|
|
return createInvalid();
|
|
}
|
|
}
|
|
), prototypeMax = deprecate(
|
|
"moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",
|
|
function() {
|
|
var other = createLocal.apply(null, arguments);
|
|
if (this.isValid() && other.isValid()) {
|
|
return other > this ? this : other;
|
|
} else {
|
|
return createInvalid();
|
|
}
|
|
}
|
|
);
|
|
function pickBy(fn, moments) {
|
|
var res, i;
|
|
if (moments.length === 1 && isArray(moments[0])) {
|
|
moments = moments[0];
|
|
}
|
|
if (!moments.length) {
|
|
return createLocal();
|
|
}
|
|
res = moments[0];
|
|
for (i = 1; i < moments.length; ++i) {
|
|
if (!moments[i].isValid() || moments[i][fn](res)) {
|
|
res = moments[i];
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
function min() {
|
|
var args = [].slice.call(arguments, 0);
|
|
return pickBy("isBefore", args);
|
|
}
|
|
function max() {
|
|
var args = [].slice.call(arguments, 0);
|
|
return pickBy("isAfter", args);
|
|
}
|
|
var now = function() {
|
|
return Date.now ? Date.now() : +new Date();
|
|
};
|
|
var ordering = [
|
|
"year",
|
|
"quarter",
|
|
"month",
|
|
"week",
|
|
"day",
|
|
"hour",
|
|
"minute",
|
|
"second",
|
|
"millisecond"
|
|
];
|
|
function isDurationValid(m) {
|
|
var key, unitHasDecimal = false, i, orderLen = ordering.length;
|
|
for (key in m) {
|
|
if (hasOwnProp(m, key) && !(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
|
|
return false;
|
|
}
|
|
}
|
|
for (i = 0; i < orderLen; ++i) {
|
|
if (m[ordering[i]]) {
|
|
if (unitHasDecimal) {
|
|
return false;
|
|
}
|
|
if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
|
|
unitHasDecimal = true;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isValid$1() {
|
|
return this._isValid;
|
|
}
|
|
function createInvalid$1() {
|
|
return createDuration(NaN);
|
|
}
|
|
function Duration(duration) {
|
|
var normalizedInput = normalizeObjectUnits(duration), years2 = normalizedInput.year || 0, quarters = normalizedInput.quarter || 0, months2 = normalizedInput.month || 0, weeks2 = normalizedInput.week || normalizedInput.isoWeek || 0, days2 = normalizedInput.day || 0, hours2 = normalizedInput.hour || 0, minutes2 = normalizedInput.minute || 0, seconds2 = normalizedInput.second || 0, milliseconds2 = normalizedInput.millisecond || 0;
|
|
this._isValid = isDurationValid(normalizedInput);
|
|
this._milliseconds = +milliseconds2 + seconds2 * 1e3 + minutes2 * 6e4 + hours2 * 1e3 * 60 * 60;
|
|
this._days = +days2 + weeks2 * 7;
|
|
this._months = +months2 + quarters * 3 + years2 * 12;
|
|
this._data = {};
|
|
this._locale = getLocale();
|
|
this._bubble();
|
|
}
|
|
function isDuration(obj) {
|
|
return obj instanceof Duration;
|
|
}
|
|
function absRound(number) {
|
|
if (number < 0) {
|
|
return Math.round(-1 * number) * -1;
|
|
} else {
|
|
return Math.round(number);
|
|
}
|
|
}
|
|
function compareArrays(array1, array2, dontConvert) {
|
|
var len = Math.min(array1.length, array2.length), lengthDiff = Math.abs(array1.length - array2.length), diffs = 0, i;
|
|
for (i = 0; i < len; i++) {
|
|
if (dontConvert && array1[i] !== array2[i] || !dontConvert && toInt(array1[i]) !== toInt(array2[i])) {
|
|
diffs++;
|
|
}
|
|
}
|
|
return diffs + lengthDiff;
|
|
}
|
|
function offset(token2, separator) {
|
|
addFormatToken(token2, 0, 0, function() {
|
|
var offset2 = this.utcOffset(), sign2 = "+";
|
|
if (offset2 < 0) {
|
|
offset2 = -offset2;
|
|
sign2 = "-";
|
|
}
|
|
return sign2 + zeroFill(~~(offset2 / 60), 2) + separator + zeroFill(~~offset2 % 60, 2);
|
|
});
|
|
}
|
|
offset("Z", ":");
|
|
offset("ZZ", "");
|
|
addRegexToken("Z", matchShortOffset);
|
|
addRegexToken("ZZ", matchShortOffset);
|
|
addParseToken(["Z", "ZZ"], function(input, array, config) {
|
|
config._useUTC = true;
|
|
config._tzm = offsetFromString(matchShortOffset, input);
|
|
});
|
|
var chunkOffset = /([\+\-]|\d\d)/gi;
|
|
function offsetFromString(matcher, string) {
|
|
var matches = (string || "").match(matcher), chunk, parts, minutes2;
|
|
if (matches === null) {
|
|
return null;
|
|
}
|
|
chunk = matches[matches.length - 1] || [];
|
|
parts = (chunk + "").match(chunkOffset) || ["-", 0, 0];
|
|
minutes2 = +(parts[1] * 60) + toInt(parts[2]);
|
|
return minutes2 === 0 ? 0 : parts[0] === "+" ? minutes2 : -minutes2;
|
|
}
|
|
function cloneWithOffset(input, model) {
|
|
var res, diff2;
|
|
if (model._isUTC) {
|
|
res = model.clone();
|
|
diff2 = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
|
|
res._d.setTime(res._d.valueOf() + diff2);
|
|
hooks.updateOffset(res, false);
|
|
return res;
|
|
} else {
|
|
return createLocal(input).local();
|
|
}
|
|
}
|
|
function getDateOffset(m) {
|
|
return -Math.round(m._d.getTimezoneOffset());
|
|
}
|
|
hooks.updateOffset = function() {
|
|
};
|
|
function getSetOffset(input, keepLocalTime, keepMinutes) {
|
|
var offset2 = this._offset || 0, localAdjust;
|
|
if (!this.isValid()) {
|
|
return input != null ? this : NaN;
|
|
}
|
|
if (input != null) {
|
|
if (typeof input === "string") {
|
|
input = offsetFromString(matchShortOffset, input);
|
|
if (input === null) {
|
|
return this;
|
|
}
|
|
} else if (Math.abs(input) < 16 && !keepMinutes) {
|
|
input = input * 60;
|
|
}
|
|
if (!this._isUTC && keepLocalTime) {
|
|
localAdjust = getDateOffset(this);
|
|
}
|
|
this._offset = input;
|
|
this._isUTC = true;
|
|
if (localAdjust != null) {
|
|
this.add(localAdjust, "m");
|
|
}
|
|
if (offset2 !== input) {
|
|
if (!keepLocalTime || this._changeInProgress) {
|
|
addSubtract(
|
|
this,
|
|
createDuration(input - offset2, "m"),
|
|
1,
|
|
false
|
|
);
|
|
} else if (!this._changeInProgress) {
|
|
this._changeInProgress = true;
|
|
hooks.updateOffset(this, true);
|
|
this._changeInProgress = null;
|
|
}
|
|
}
|
|
return this;
|
|
} else {
|
|
return this._isUTC ? offset2 : getDateOffset(this);
|
|
}
|
|
}
|
|
function getSetZone(input, keepLocalTime) {
|
|
if (input != null) {
|
|
if (typeof input !== "string") {
|
|
input = -input;
|
|
}
|
|
this.utcOffset(input, keepLocalTime);
|
|
return this;
|
|
} else {
|
|
return -this.utcOffset();
|
|
}
|
|
}
|
|
function setOffsetToUTC(keepLocalTime) {
|
|
return this.utcOffset(0, keepLocalTime);
|
|
}
|
|
function setOffsetToLocal(keepLocalTime) {
|
|
if (this._isUTC) {
|
|
this.utcOffset(0, keepLocalTime);
|
|
this._isUTC = false;
|
|
if (keepLocalTime) {
|
|
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 tZone = offsetFromString(matchOffset, this._i);
|
|
if (tZone != null) {
|
|
this.utcOffset(tZone);
|
|
} else {
|
|
this.utcOffset(0, true);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
function hasAlignedHourOffset(input) {
|
|
if (!this.isValid()) {
|
|
return false;
|
|
}
|
|
input = input ? createLocal(input).utcOffset() : 0;
|
|
return (this.utcOffset() - input) % 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 c = {}, other;
|
|
copyConfig(c, this);
|
|
c = prepareConfig(c);
|
|
if (c._a) {
|
|
other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
|
|
this._isDSTShifted = this.isValid() && compareArrays(c._a, other.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 aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, isoRegex = /^(-|\+)?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(input, key) {
|
|
var duration = input, match = null, sign2, ret, diffRes;
|
|
if (isDuration(input)) {
|
|
duration = {
|
|
ms: input._milliseconds,
|
|
d: input._days,
|
|
M: input._months
|
|
};
|
|
} else if (isNumber(input) || !isNaN(+input)) {
|
|
duration = {};
|
|
if (key) {
|
|
duration[key] = +input;
|
|
} else {
|
|
duration.milliseconds = +input;
|
|
}
|
|
} else if (match = aspNetRegex.exec(input)) {
|
|
sign2 = match[1] === "-" ? -1 : 1;
|
|
duration = {
|
|
y: 0,
|
|
d: toInt(match[DATE]) * sign2,
|
|
h: toInt(match[HOUR]) * sign2,
|
|
m: toInt(match[MINUTE]) * sign2,
|
|
s: toInt(match[SECOND]) * sign2,
|
|
ms: toInt(absRound(match[MILLISECOND] * 1e3)) * sign2
|
|
};
|
|
} else if (match = isoRegex.exec(input)) {
|
|
sign2 = match[1] === "-" ? -1 : 1;
|
|
duration = {
|
|
y: parseIso(match[2], sign2),
|
|
M: parseIso(match[3], sign2),
|
|
w: parseIso(match[4], sign2),
|
|
d: parseIso(match[5], sign2),
|
|
h: parseIso(match[6], sign2),
|
|
m: parseIso(match[7], sign2),
|
|
s: parseIso(match[8], sign2)
|
|
};
|
|
} else if (duration == null) {
|
|
duration = {};
|
|
} else if (typeof duration === "object" && ("from" in duration || "to" in duration)) {
|
|
diffRes = momentsDifference(
|
|
createLocal(duration.from),
|
|
createLocal(duration.to)
|
|
);
|
|
duration = {};
|
|
duration.ms = diffRes.milliseconds;
|
|
duration.M = diffRes.months;
|
|
}
|
|
ret = new Duration(duration);
|
|
if (isDuration(input) && hasOwnProp(input, "_locale")) {
|
|
ret._locale = input._locale;
|
|
}
|
|
if (isDuration(input) && hasOwnProp(input, "_isValid")) {
|
|
ret._isValid = input._isValid;
|
|
}
|
|
return ret;
|
|
}
|
|
createDuration.fn = Duration.prototype;
|
|
createDuration.invalid = createInvalid$1;
|
|
function parseIso(inp, sign2) {
|
|
var res = inp && parseFloat(inp.replace(",", "."));
|
|
return (isNaN(res) ? 0 : res) * sign2;
|
|
}
|
|
function positiveMomentsDifference(base, other) {
|
|
var res = {};
|
|
res.months = other.month() - base.month() + (other.year() - base.year()) * 12;
|
|
if (base.clone().add(res.months, "M").isAfter(other)) {
|
|
--res.months;
|
|
}
|
|
res.milliseconds = +other - +base.clone().add(res.months, "M");
|
|
return res;
|
|
}
|
|
function momentsDifference(base, other) {
|
|
var res;
|
|
if (!(base.isValid() && other.isValid())) {
|
|
return { milliseconds: 0, months: 0 };
|
|
}
|
|
other = cloneWithOffset(other, base);
|
|
if (base.isBefore(other)) {
|
|
res = positiveMomentsDifference(base, other);
|
|
} else {
|
|
res = positiveMomentsDifference(other, base);
|
|
res.milliseconds = -res.milliseconds;
|
|
res.months = -res.months;
|
|
}
|
|
return res;
|
|
}
|
|
function createAdder(direction, name) {
|
|
return function(val, period) {
|
|
var dur, tmp;
|
|
if (period !== null && !isNaN(+period)) {
|
|
deprecateSimple(
|
|
name,
|
|
"moment()." + name + "(period, number) is deprecated. Please use moment()." + name + "(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."
|
|
);
|
|
tmp = val;
|
|
val = period;
|
|
period = tmp;
|
|
}
|
|
dur = createDuration(val, period);
|
|
addSubtract(this, dur, direction);
|
|
return this;
|
|
};
|
|
}
|
|
function addSubtract(mom, duration, isAdding, updateOffset) {
|
|
var milliseconds2 = duration._milliseconds, days2 = absRound(duration._days), months2 = absRound(duration._months);
|
|
if (!mom.isValid()) {
|
|
return;
|
|
}
|
|
updateOffset = updateOffset == null ? true : updateOffset;
|
|
if (months2) {
|
|
setMonth(mom, get(mom, "Month") + months2 * isAdding);
|
|
}
|
|
if (days2) {
|
|
set$1(mom, "Date", get(mom, "Date") + days2 * isAdding);
|
|
}
|
|
if (milliseconds2) {
|
|
mom._d.setTime(mom._d.valueOf() + milliseconds2 * isAdding);
|
|
}
|
|
if (updateOffset) {
|
|
hooks.updateOffset(mom, days2 || months2);
|
|
}
|
|
}
|
|
var add = createAdder(1, "add"), subtract = createAdder(-1, "subtract");
|
|
function isString(input) {
|
|
return typeof input === "string" || input instanceof String;
|
|
}
|
|
function isMomentInput(input) {
|
|
return isMoment(input) || isDate(input) || isString(input) || isNumber(input) || isNumberOrStringArray(input) || isMomentInputObject(input) || input === null || input === void 0;
|
|
}
|
|
function isMomentInputObject(input) {
|
|
var objectTest = isObject(input) && !isObjectEmpty(input), propertyTest = false, properties = [
|
|
"years",
|
|
"year",
|
|
"y",
|
|
"months",
|
|
"month",
|
|
"M",
|
|
"days",
|
|
"day",
|
|
"d",
|
|
"dates",
|
|
"date",
|
|
"D",
|
|
"hours",
|
|
"hour",
|
|
"h",
|
|
"minutes",
|
|
"minute",
|
|
"m",
|
|
"seconds",
|
|
"second",
|
|
"s",
|
|
"milliseconds",
|
|
"millisecond",
|
|
"ms"
|
|
], i, property, propertyLen = properties.length;
|
|
for (i = 0; i < propertyLen; i += 1) {
|
|
property = properties[i];
|
|
propertyTest = propertyTest || hasOwnProp(input, property);
|
|
}
|
|
return objectTest && propertyTest;
|
|
}
|
|
function isNumberOrStringArray(input) {
|
|
var arrayTest = isArray(input), dataTypeTest = false;
|
|
if (arrayTest) {
|
|
dataTypeTest = input.filter(function(item) {
|
|
return !isNumber(item) && isString(input);
|
|
}).length === 0;
|
|
}
|
|
return arrayTest && dataTypeTest;
|
|
}
|
|
function isCalendarSpec(input) {
|
|
var objectTest = isObject(input) && !isObjectEmpty(input), propertyTest = false, properties = [
|
|
"sameDay",
|
|
"nextDay",
|
|
"lastDay",
|
|
"nextWeek",
|
|
"lastWeek",
|
|
"sameElse"
|
|
], i, property;
|
|
for (i = 0; i < properties.length; i += 1) {
|
|
property = properties[i];
|
|
propertyTest = propertyTest || hasOwnProp(input, property);
|
|
}
|
|
return objectTest && propertyTest;
|
|
}
|
|
function getCalendarFormat(myMoment, now2) {
|
|
var diff2 = myMoment.diff(now2, "days", true);
|
|
return diff2 < -6 ? "sameElse" : diff2 < -1 ? "lastWeek" : diff2 < 0 ? "lastDay" : diff2 < 1 ? "sameDay" : diff2 < 2 ? "nextDay" : diff2 < 7 ? "nextWeek" : "sameElse";
|
|
}
|
|
function calendar$1(time, formats) {
|
|
if (arguments.length === 1) {
|
|
if (!arguments[0]) {
|
|
time = void 0;
|
|
formats = void 0;
|
|
} else if (isMomentInput(arguments[0])) {
|
|
time = arguments[0];
|
|
formats = void 0;
|
|
} else if (isCalendarSpec(arguments[0])) {
|
|
formats = arguments[0];
|
|
time = void 0;
|
|
}
|
|
}
|
|
var now2 = time || createLocal(), sod = cloneWithOffset(now2, this).startOf("day"), format2 = hooks.calendarFormat(this, sod) || "sameElse", output = formats && (isFunction(formats[format2]) ? formats[format2].call(this, now2) : formats[format2]);
|
|
return this.format(
|
|
output || this.localeData().calendar(format2, this, createLocal(now2))
|
|
);
|
|
}
|
|
function clone() {
|
|
return new Moment(this);
|
|
}
|
|
function isAfter(input, units) {
|
|
var localInput = isMoment(input) ? input : createLocal(input);
|
|
if (!(this.isValid() && localInput.isValid())) {
|
|
return false;
|
|
}
|
|
units = normalizeUnits(units) || "millisecond";
|
|
if (units === "millisecond") {
|
|
return this.valueOf() > localInput.valueOf();
|
|
} else {
|
|
return localInput.valueOf() < this.clone().startOf(units).valueOf();
|
|
}
|
|
}
|
|
function isBefore(input, units) {
|
|
var localInput = isMoment(input) ? input : createLocal(input);
|
|
if (!(this.isValid() && localInput.isValid())) {
|
|
return false;
|
|
}
|
|
units = normalizeUnits(units) || "millisecond";
|
|
if (units === "millisecond") {
|
|
return this.valueOf() < localInput.valueOf();
|
|
} else {
|
|
return this.clone().endOf(units).valueOf() < localInput.valueOf();
|
|
}
|
|
}
|
|
function isBetween(from2, to2, units, inclusivity) {
|
|
var localFrom = isMoment(from2) ? from2 : createLocal(from2), localTo = isMoment(to2) ? to2 : createLocal(to2);
|
|
if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
|
|
return false;
|
|
}
|
|
inclusivity = inclusivity || "()";
|
|
return (inclusivity[0] === "(" ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) && (inclusivity[1] === ")" ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
|
|
}
|
|
function isSame(input, units) {
|
|
var localInput = isMoment(input) ? input : createLocal(input), inputMs;
|
|
if (!(this.isValid() && localInput.isValid())) {
|
|
return false;
|
|
}
|
|
units = normalizeUnits(units) || "millisecond";
|
|
if (units === "millisecond") {
|
|
return this.valueOf() === localInput.valueOf();
|
|
} else {
|
|
inputMs = localInput.valueOf();
|
|
return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
|
|
}
|
|
}
|
|
function isSameOrAfter(input, units) {
|
|
return this.isSame(input, units) || this.isAfter(input, units);
|
|
}
|
|
function isSameOrBefore(input, units) {
|
|
return this.isSame(input, units) || this.isBefore(input, units);
|
|
}
|
|
function diff(input, units, asFloat) {
|
|
var that, zoneDelta, output;
|
|
if (!this.isValid()) {
|
|
return NaN;
|
|
}
|
|
that = cloneWithOffset(input, this);
|
|
if (!that.isValid()) {
|
|
return NaN;
|
|
}
|
|
zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
|
|
units = normalizeUnits(units);
|
|
switch (units) {
|
|
case "year":
|
|
output = monthDiff(this, that) / 12;
|
|
break;
|
|
case "month":
|
|
output = monthDiff(this, that);
|
|
break;
|
|
case "quarter":
|
|
output = monthDiff(this, that) / 3;
|
|
break;
|
|
case "second":
|
|
output = (this - that) / 1e3;
|
|
break;
|
|
case "minute":
|
|
output = (this - that) / 6e4;
|
|
break;
|
|
case "hour":
|
|
output = (this - that) / 36e5;
|
|
break;
|
|
case "day":
|
|
output = (this - that - zoneDelta) / 864e5;
|
|
break;
|
|
case "week":
|
|
output = (this - that - zoneDelta) / 6048e5;
|
|
break;
|
|
default:
|
|
output = this - that;
|
|
}
|
|
return asFloat ? output : absFloor(output);
|
|
}
|
|
function monthDiff(a, b) {
|
|
if (a.date() < b.date()) {
|
|
return -monthDiff(b, a);
|
|
}
|
|
var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()), anchor = a.clone().add(wholeMonthDiff, "months"), anchor2, adjust;
|
|
if (b - anchor < 0) {
|
|
anchor2 = a.clone().add(wholeMonthDiff - 1, "months");
|
|
adjust = (b - anchor) / (anchor - anchor2);
|
|
} else {
|
|
anchor2 = a.clone().add(wholeMonthDiff + 1, "months");
|
|
adjust = (b - anchor) / (anchor2 - anchor);
|
|
}
|
|
return -(wholeMonthDiff + adjust) || 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(keepOffset) {
|
|
if (!this.isValid()) {
|
|
return null;
|
|
}
|
|
var utc = keepOffset !== true, m = utc ? this.clone().utc() : this;
|
|
if (m.year() < 0 || m.year() > 9999) {
|
|
return formatMoment(
|
|
m,
|
|
utc ? "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"
|
|
);
|
|
}
|
|
if (isFunction(Date.prototype.toISOString)) {
|
|
if (utc) {
|
|
return this.toDate().toISOString();
|
|
} else {
|
|
return new Date(this.valueOf() + this.utcOffset() * 60 * 1e3).toISOString().replace("Z", formatMoment(m, "Z"));
|
|
}
|
|
}
|
|
return formatMoment(
|
|
m,
|
|
utc ? "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 func = "moment", zone = "", prefix, year, datetime, suffix;
|
|
if (!this.isLocal()) {
|
|
func = this.utcOffset() === 0 ? "moment.utc" : "moment.parseZone";
|
|
zone = "Z";
|
|
}
|
|
prefix = "[" + func + '("]';
|
|
year = 0 <= this.year() && this.year() <= 9999 ? "YYYY" : "YYYYYY";
|
|
datetime = "-MM-DD[T]HH:mm:ss.SSS";
|
|
suffix = zone + '[")]';
|
|
return this.format(prefix + year + datetime + suffix);
|
|
}
|
|
function format(inputString) {
|
|
if (!inputString) {
|
|
inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
|
|
}
|
|
var output = formatMoment(this, inputString);
|
|
return this.localeData().postformat(output);
|
|
}
|
|
function from(time, withoutSuffix) {
|
|
if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {
|
|
return createDuration({ to: this, from: time }).locale(this.locale()).humanize(!withoutSuffix);
|
|
} else {
|
|
return this.localeData().invalidDate();
|
|
}
|
|
}
|
|
function fromNow(withoutSuffix) {
|
|
return this.from(createLocal(), withoutSuffix);
|
|
}
|
|
function to(time, withoutSuffix) {
|
|
if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {
|
|
return createDuration({ from: this, to: time }).locale(this.locale()).humanize(!withoutSuffix);
|
|
} else {
|
|
return this.localeData().invalidDate();
|
|
}
|
|
}
|
|
function toNow(withoutSuffix) {
|
|
return this.to(createLocal(), withoutSuffix);
|
|
}
|
|
function locale(key) {
|
|
var newLocaleData;
|
|
if (key === void 0) {
|
|
return this._locale._abbr;
|
|
} else {
|
|
newLocaleData = getLocale(key);
|
|
if (newLocaleData != null) {
|
|
this._locale = newLocaleData;
|
|
}
|
|
return this;
|
|
}
|
|
}
|
|
var lang = deprecate(
|
|
"moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",
|
|
function(key) {
|
|
if (key === void 0) {
|
|
return this.localeData();
|
|
} else {
|
|
return this.locale(key);
|
|
}
|
|
}
|
|
);
|
|
function localeData() {
|
|
return this._locale;
|
|
}
|
|
var MS_PER_SECOND = 1e3, MS_PER_MINUTE = 60 * MS_PER_SECOND, MS_PER_HOUR = 60 * MS_PER_MINUTE, MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
|
|
function mod$1(dividend, divisor) {
|
|
return (dividend % divisor + divisor) % divisor;
|
|
}
|
|
function localStartOfDate(y, m, d) {
|
|
if (y < 100 && y >= 0) {
|
|
return new Date(y + 400, m, d) - MS_PER_400_YEARS;
|
|
} else {
|
|
return new Date(y, m, d).valueOf();
|
|
}
|
|
}
|
|
function utcStartOfDate(y, m, d) {
|
|
if (y < 100 && y >= 0) {
|
|
return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
|
|
} else {
|
|
return Date.UTC(y, m, d);
|
|
}
|
|
}
|
|
function startOf(units) {
|
|
var time, startOfDate;
|
|
units = normalizeUnits(units);
|
|
if (units === void 0 || units === "millisecond" || !this.isValid()) {
|
|
return this;
|
|
}
|
|
startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
|
|
switch (units) {
|
|
case "year":
|
|
time = startOfDate(this.year(), 0, 1);
|
|
break;
|
|
case "quarter":
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month() - this.month() % 3,
|
|
1
|
|
);
|
|
break;
|
|
case "month":
|
|
time = startOfDate(this.year(), this.month(), 1);
|
|
break;
|
|
case "week":
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month(),
|
|
this.date() - this.weekday()
|
|
);
|
|
break;
|
|
case "isoWeek":
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month(),
|
|
this.date() - (this.isoWeekday() - 1)
|
|
);
|
|
break;
|
|
case "day":
|
|
case "date":
|
|
time = startOfDate(this.year(), this.month(), this.date());
|
|
break;
|
|
case "hour":
|
|
time = this._d.valueOf();
|
|
time -= mod$1(
|
|
time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
|
|
MS_PER_HOUR
|
|
);
|
|
break;
|
|
case "minute":
|
|
time = this._d.valueOf();
|
|
time -= mod$1(time, MS_PER_MINUTE);
|
|
break;
|
|
case "second":
|
|
time = this._d.valueOf();
|
|
time -= mod$1(time, MS_PER_SECOND);
|
|
break;
|
|
}
|
|
this._d.setTime(time);
|
|
hooks.updateOffset(this, true);
|
|
return this;
|
|
}
|
|
function endOf(units) {
|
|
var time, startOfDate;
|
|
units = normalizeUnits(units);
|
|
if (units === void 0 || units === "millisecond" || !this.isValid()) {
|
|
return this;
|
|
}
|
|
startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
|
|
switch (units) {
|
|
case "year":
|
|
time = startOfDate(this.year() + 1, 0, 1) - 1;
|
|
break;
|
|
case "quarter":
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month() - this.month() % 3 + 3,
|
|
1
|
|
) - 1;
|
|
break;
|
|
case "month":
|
|
time = startOfDate(this.year(), this.month() + 1, 1) - 1;
|
|
break;
|
|
case "week":
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month(),
|
|
this.date() - this.weekday() + 7
|
|
) - 1;
|
|
break;
|
|
case "isoWeek":
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month(),
|
|
this.date() - (this.isoWeekday() - 1) + 7
|
|
) - 1;
|
|
break;
|
|
case "day":
|
|
case "date":
|
|
time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
|
|
break;
|
|
case "hour":
|
|
time = this._d.valueOf();
|
|
time += MS_PER_HOUR - mod$1(
|
|
time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
|
|
MS_PER_HOUR
|
|
) - 1;
|
|
break;
|
|
case "minute":
|
|
time = this._d.valueOf();
|
|
time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
|
|
break;
|
|
case "second":
|
|
time = this._d.valueOf();
|
|
time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
|
|
break;
|
|
}
|
|
this._d.setTime(time);
|
|
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 m = this;
|
|
return [
|
|
m.year(),
|
|
m.month(),
|
|
m.date(),
|
|
m.hour(),
|
|
m.minute(),
|
|
m.second(),
|
|
m.millisecond()
|
|
];
|
|
}
|
|
function toObject() {
|
|
var m = this;
|
|
return {
|
|
years: m.year(),
|
|
months: m.month(),
|
|
date: m.date(),
|
|
hours: m.hours(),
|
|
minutes: m.minutes(),
|
|
seconds: m.seconds(),
|
|
milliseconds: m.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(input, array, config, token2) {
|
|
var era = config._locale.erasParse(input, token2, config._strict);
|
|
if (era) {
|
|
getParsingFlags(config).era = era;
|
|
} else {
|
|
getParsingFlags(config).invalidEra = input;
|
|
}
|
|
}
|
|
);
|
|
addRegexToken("y", matchUnsigned);
|
|
addRegexToken("yy", matchUnsigned);
|
|
addRegexToken("yyy", matchUnsigned);
|
|
addRegexToken("yyyy", matchUnsigned);
|
|
addRegexToken("yo", matchEraYearOrdinal);
|
|
addParseToken(["y", "yy", "yyy", "yyyy"], YEAR);
|
|
addParseToken(["yo"], function(input, array, config, token2) {
|
|
var match;
|
|
if (config._locale._eraYearOrdinalRegex) {
|
|
match = input.match(config._locale._eraYearOrdinalRegex);
|
|
}
|
|
if (config._locale.eraYearOrdinalParse) {
|
|
array[YEAR] = config._locale.eraYearOrdinalParse(input, match);
|
|
} else {
|
|
array[YEAR] = parseInt(input, 10);
|
|
}
|
|
});
|
|
function localeEras(m, format2) {
|
|
var i, l, date, eras = this._eras || getLocale("en")._eras;
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
switch (typeof eras[i].since) {
|
|
case "string":
|
|
date = hooks(eras[i].since).startOf("day");
|
|
eras[i].since = date.valueOf();
|
|
break;
|
|
}
|
|
switch (typeof eras[i].until) {
|
|
case "undefined":
|
|
eras[i].until = Infinity;
|
|
break;
|
|
case "string":
|
|
date = hooks(eras[i].until).startOf("day").valueOf();
|
|
eras[i].until = date.valueOf();
|
|
break;
|
|
}
|
|
}
|
|
return eras;
|
|
}
|
|
function localeErasParse(eraName, format2, strict) {
|
|
var i, l, eras = this.eras(), name, abbr, narrow;
|
|
eraName = eraName.toUpperCase();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
name = eras[i].name.toUpperCase();
|
|
abbr = eras[i].abbr.toUpperCase();
|
|
narrow = eras[i].narrow.toUpperCase();
|
|
if (strict) {
|
|
switch (format2) {
|
|
case "N":
|
|
case "NN":
|
|
case "NNN":
|
|
if (abbr === eraName) {
|
|
return eras[i];
|
|
}
|
|
break;
|
|
case "NNNN":
|
|
if (name === eraName) {
|
|
return eras[i];
|
|
}
|
|
break;
|
|
case "NNNNN":
|
|
if (narrow === eraName) {
|
|
return eras[i];
|
|
}
|
|
break;
|
|
}
|
|
} else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
|
|
return eras[i];
|
|
}
|
|
}
|
|
}
|
|
function localeErasConvertYear(era, year) {
|
|
var dir = era.since <= era.until ? 1 : -1;
|
|
if (year === void 0) {
|
|
return hooks(era.since).year();
|
|
} else {
|
|
return hooks(era.since).year() + (year - era.offset) * dir;
|
|
}
|
|
}
|
|
function getEraName() {
|
|
var i, l, val, eras = this.localeData().eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
val = this.clone().startOf("day").valueOf();
|
|
if (eras[i].since <= val && val <= eras[i].until) {
|
|
return eras[i].name;
|
|
}
|
|
if (eras[i].until <= val && val <= eras[i].since) {
|
|
return eras[i].name;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
function getEraNarrow() {
|
|
var i, l, val, eras = this.localeData().eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
val = this.clone().startOf("day").valueOf();
|
|
if (eras[i].since <= val && val <= eras[i].until) {
|
|
return eras[i].narrow;
|
|
}
|
|
if (eras[i].until <= val && val <= eras[i].since) {
|
|
return eras[i].narrow;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
function getEraAbbr() {
|
|
var i, l, val, eras = this.localeData().eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
val = this.clone().startOf("day").valueOf();
|
|
if (eras[i].since <= val && val <= eras[i].until) {
|
|
return eras[i].abbr;
|
|
}
|
|
if (eras[i].until <= val && val <= eras[i].since) {
|
|
return eras[i].abbr;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
function getEraYear() {
|
|
var i, l, dir, val, eras = this.localeData().eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
dir = eras[i].since <= eras[i].until ? 1 : -1;
|
|
val = this.clone().startOf("day").valueOf();
|
|
if (eras[i].since <= val && val <= eras[i].until || eras[i].until <= val && val <= eras[i].since) {
|
|
return (this.year() - hooks(eras[i].since).year()) * dir + eras[i].offset;
|
|
}
|
|
}
|
|
return this.year();
|
|
}
|
|
function erasNameRegex(isStrict) {
|
|
if (!hasOwnProp(this, "_erasNameRegex")) {
|
|
computeErasParse.call(this);
|
|
}
|
|
return isStrict ? this._erasNameRegex : this._erasRegex;
|
|
}
|
|
function erasAbbrRegex(isStrict) {
|
|
if (!hasOwnProp(this, "_erasAbbrRegex")) {
|
|
computeErasParse.call(this);
|
|
}
|
|
return isStrict ? this._erasAbbrRegex : this._erasRegex;
|
|
}
|
|
function erasNarrowRegex(isStrict) {
|
|
if (!hasOwnProp(this, "_erasNarrowRegex")) {
|
|
computeErasParse.call(this);
|
|
}
|
|
return isStrict ? this._erasNarrowRegex : this._erasRegex;
|
|
}
|
|
function matchEraAbbr(isStrict, locale2) {
|
|
return locale2.erasAbbrRegex(isStrict);
|
|
}
|
|
function matchEraName(isStrict, locale2) {
|
|
return locale2.erasNameRegex(isStrict);
|
|
}
|
|
function matchEraNarrow(isStrict, locale2) {
|
|
return locale2.erasNarrowRegex(isStrict);
|
|
}
|
|
function matchEraYearOrdinal(isStrict, locale2) {
|
|
return locale2._eraYearOrdinalRegex || matchUnsigned;
|
|
}
|
|
function computeErasParse() {
|
|
var abbrPieces = [], namePieces = [], narrowPieces = [], mixedPieces = [], i, l, eras = this.eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
namePieces.push(regexEscape(eras[i].name));
|
|
abbrPieces.push(regexEscape(eras[i].abbr));
|
|
narrowPieces.push(regexEscape(eras[i].narrow));
|
|
mixedPieces.push(regexEscape(eras[i].name));
|
|
mixedPieces.push(regexEscape(eras[i].abbr));
|
|
mixedPieces.push(regexEscape(eras[i].narrow));
|
|
}
|
|
this._erasRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i");
|
|
this._erasNameRegex = new RegExp("^(" + namePieces.join("|") + ")", "i");
|
|
this._erasAbbrRegex = new RegExp("^(" + abbrPieces.join("|") + ")", "i");
|
|
this._erasNarrowRegex = new RegExp(
|
|
"^(" + narrowPieces.join("|") + ")",
|
|
"i"
|
|
);
|
|
}
|
|
addFormatToken(0, ["gg", 2], 0, function() {
|
|
return this.weekYear() % 100;
|
|
});
|
|
addFormatToken(0, ["GG", 2], 0, function() {
|
|
return this.isoWeekYear() % 100;
|
|
});
|
|
function addWeekYearFormatToken(token2, getter) {
|
|
addFormatToken(0, [token2, token2.length], 0, getter);
|
|
}
|
|
addWeekYearFormatToken("gggg", "weekYear");
|
|
addWeekYearFormatToken("ggggg", "weekYear");
|
|
addWeekYearFormatToken("GGGG", "isoWeekYear");
|
|
addWeekYearFormatToken("GGGGG", "isoWeekYear");
|
|
addUnitAlias("weekYear", "gg");
|
|
addUnitAlias("isoWeekYear", "GG");
|
|
addUnitPriority("weekYear", 1);
|
|
addUnitPriority("isoWeekYear", 1);
|
|
addRegexToken("G", matchSigned);
|
|
addRegexToken("g", matchSigned);
|
|
addRegexToken("GG", match1to2, match2);
|
|
addRegexToken("gg", match1to2, match2);
|
|
addRegexToken("GGGG", match1to4, match4);
|
|
addRegexToken("gggg", match1to4, match4);
|
|
addRegexToken("GGGGG", match1to6, match6);
|
|
addRegexToken("ggggg", match1to6, match6);
|
|
addWeekParseToken(
|
|
["gggg", "ggggg", "GGGG", "GGGGG"],
|
|
function(input, week, config, token2) {
|
|
week[token2.substr(0, 2)] = toInt(input);
|
|
}
|
|
);
|
|
addWeekParseToken(["gg", "GG"], function(input, week, config, token2) {
|
|
week[token2] = hooks.parseTwoDigitYear(input);
|
|
});
|
|
function getSetWeekYear(input) {
|
|
return getSetWeekYearHelper.call(
|
|
this,
|
|
input,
|
|
this.week(),
|
|
this.weekday(),
|
|
this.localeData()._week.dow,
|
|
this.localeData()._week.doy
|
|
);
|
|
}
|
|
function getSetISOWeekYear(input) {
|
|
return getSetWeekYearHelper.call(
|
|
this,
|
|
input,
|
|
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 weekInfo = this.localeData()._week;
|
|
return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
|
|
}
|
|
function getWeeksInWeekYear() {
|
|
var weekInfo = this.localeData()._week;
|
|
return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
|
|
}
|
|
function getSetWeekYearHelper(input, week, weekday, dow, doy) {
|
|
var weeksTarget;
|
|
if (input == null) {
|
|
return weekOfYear(this, dow, doy).year;
|
|
} else {
|
|
weeksTarget = weeksInYear(input, dow, doy);
|
|
if (week > weeksTarget) {
|
|
week = weeksTarget;
|
|
}
|
|
return setWeekAll.call(this, input, week, weekday, dow, doy);
|
|
}
|
|
}
|
|
function setWeekAll(weekYear, week, weekday, dow, doy) {
|
|
var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
|
|
this.year(date.getUTCFullYear());
|
|
this.month(date.getUTCMonth());
|
|
this.date(date.getUTCDate());
|
|
return this;
|
|
}
|
|
addFormatToken("Q", 0, "Qo", "quarter");
|
|
addUnitAlias("quarter", "Q");
|
|
addUnitPriority("quarter", 7);
|
|
addRegexToken("Q", match1);
|
|
addParseToken("Q", function(input, array) {
|
|
array[MONTH] = (toInt(input) - 1) * 3;
|
|
});
|
|
function getSetQuarter(input) {
|
|
return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
|
|
}
|
|
addFormatToken("D", ["DD", 2], "Do", "date");
|
|
addUnitAlias("date", "D");
|
|
addUnitPriority("date", 9);
|
|
addRegexToken("D", match1to2);
|
|
addRegexToken("DD", match1to2, match2);
|
|
addRegexToken("Do", function(isStrict, locale2) {
|
|
return isStrict ? locale2._dayOfMonthOrdinalParse || locale2._ordinalParse : locale2._dayOfMonthOrdinalParseLenient;
|
|
});
|
|
addParseToken(["D", "DD"], DATE);
|
|
addParseToken("Do", function(input, array) {
|
|
array[DATE] = toInt(input.match(match1to2)[0]);
|
|
});
|
|
var getSetDayOfMonth = makeGetSet("Date", true);
|
|
addFormatToken("DDD", ["DDDD", 3], "DDDo", "dayOfYear");
|
|
addUnitAlias("dayOfYear", "DDD");
|
|
addUnitPriority("dayOfYear", 4);
|
|
addRegexToken("DDD", match1to3);
|
|
addRegexToken("DDDD", match3);
|
|
addParseToken(["DDD", "DDDD"], function(input, array, config) {
|
|
config._dayOfYear = toInt(input);
|
|
});
|
|
function getSetDayOfYear(input) {
|
|
var dayOfYear = Math.round(
|
|
(this.clone().startOf("day") - this.clone().startOf("year")) / 864e5
|
|
) + 1;
|
|
return input == null ? dayOfYear : this.add(input - dayOfYear, "d");
|
|
}
|
|
addFormatToken("m", ["mm", 2], 0, "minute");
|
|
addUnitAlias("minute", "m");
|
|
addUnitPriority("minute", 14);
|
|
addRegexToken("m", match1to2);
|
|
addRegexToken("mm", match1to2, match2);
|
|
addParseToken(["m", "mm"], MINUTE);
|
|
var getSetMinute = makeGetSet("Minutes", false);
|
|
addFormatToken("s", ["ss", 2], 0, "second");
|
|
addUnitAlias("second", "s");
|
|
addUnitPriority("second", 15);
|
|
addRegexToken("s", match1to2);
|
|
addRegexToken("ss", match1to2, match2);
|
|
addParseToken(["s", "ss"], SECOND);
|
|
var getSetSecond = 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;
|
|
});
|
|
addUnitAlias("millisecond", "ms");
|
|
addUnitPriority("millisecond", 16);
|
|
addRegexToken("S", match1to3, match1);
|
|
addRegexToken("SS", match1to3, match2);
|
|
addRegexToken("SSS", match1to3, match3);
|
|
var token, getSetMillisecond;
|
|
for (token = "SSSS"; token.length <= 9; token += "S") {
|
|
addRegexToken(token, matchUnsigned);
|
|
}
|
|
function parseMs(input, array) {
|
|
array[MILLISECOND] = toInt(("0." + input) * 1e3);
|
|
}
|
|
for (token = "S"; token.length <= 9; token += "S") {
|
|
addParseToken(token, parseMs);
|
|
}
|
|
getSetMillisecond = 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 proto = Moment.prototype;
|
|
proto.add = add;
|
|
proto.calendar = calendar$1;
|
|
proto.clone = clone;
|
|
proto.diff = diff;
|
|
proto.endOf = endOf;
|
|
proto.format = format;
|
|
proto.from = from;
|
|
proto.fromNow = fromNow;
|
|
proto.to = to;
|
|
proto.toNow = toNow;
|
|
proto.get = stringGet;
|
|
proto.invalidAt = invalidAt;
|
|
proto.isAfter = isAfter;
|
|
proto.isBefore = isBefore;
|
|
proto.isBetween = isBetween;
|
|
proto.isSame = isSame;
|
|
proto.isSameOrAfter = isSameOrAfter;
|
|
proto.isSameOrBefore = isSameOrBefore;
|
|
proto.isValid = isValid$2;
|
|
proto.lang = lang;
|
|
proto.locale = locale;
|
|
proto.localeData = localeData;
|
|
proto.max = prototypeMax;
|
|
proto.min = prototypeMin;
|
|
proto.parsingFlags = parsingFlags;
|
|
proto.set = stringSet;
|
|
proto.startOf = startOf;
|
|
proto.subtract = subtract;
|
|
proto.toArray = toArray;
|
|
proto.toObject = toObject;
|
|
proto.toDate = toDate;
|
|
proto.toISOString = toISOString;
|
|
proto.inspect = inspect;
|
|
if (typeof Symbol !== "undefined" && Symbol.for != null) {
|
|
proto[Symbol.for("nodejs.util.inspect.custom")] = function() {
|
|
return "Moment<" + this.format() + ">";
|
|
};
|
|
}
|
|
proto.toJSON = toJSON;
|
|
proto.toString = toString;
|
|
proto.unix = unix;
|
|
proto.valueOf = valueOf;
|
|
proto.creationData = creationData;
|
|
proto.eraName = getEraName;
|
|
proto.eraNarrow = getEraNarrow;
|
|
proto.eraAbbr = getEraAbbr;
|
|
proto.eraYear = getEraYear;
|
|
proto.year = getSetYear;
|
|
proto.isLeapYear = getIsLeapYear;
|
|
proto.weekYear = getSetWeekYear;
|
|
proto.isoWeekYear = getSetISOWeekYear;
|
|
proto.quarter = proto.quarters = getSetQuarter;
|
|
proto.month = getSetMonth;
|
|
proto.daysInMonth = getDaysInMonth;
|
|
proto.week = proto.weeks = getSetWeek;
|
|
proto.isoWeek = proto.isoWeeks = getSetISOWeek;
|
|
proto.weeksInYear = getWeeksInYear;
|
|
proto.weeksInWeekYear = getWeeksInWeekYear;
|
|
proto.isoWeeksInYear = getISOWeeksInYear;
|
|
proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
|
|
proto.date = getSetDayOfMonth;
|
|
proto.day = proto.days = getSetDayOfWeek;
|
|
proto.weekday = getSetLocaleDayOfWeek;
|
|
proto.isoWeekday = getSetISODayOfWeek;
|
|
proto.dayOfYear = getSetDayOfYear;
|
|
proto.hour = proto.hours = getSetHour;
|
|
proto.minute = proto.minutes = getSetMinute;
|
|
proto.second = proto.seconds = getSetSecond;
|
|
proto.millisecond = proto.milliseconds = getSetMillisecond;
|
|
proto.utcOffset = getSetOffset;
|
|
proto.utc = setOffsetToUTC;
|
|
proto.local = setOffsetToLocal;
|
|
proto.parseZone = setOffsetToParsedOffset;
|
|
proto.hasAlignedHourOffset = hasAlignedHourOffset;
|
|
proto.isDST = isDaylightSavingTime;
|
|
proto.isLocal = isLocal;
|
|
proto.isUtcOffset = isUtcOffset;
|
|
proto.isUtc = isUtc;
|
|
proto.isUTC = isUtc;
|
|
proto.zoneAbbr = getZoneAbbr;
|
|
proto.zoneName = getZoneName;
|
|
proto.dates = deprecate(
|
|
"dates accessor is deprecated. Use date instead.",
|
|
getSetDayOfMonth
|
|
);
|
|
proto.months = deprecate(
|
|
"months accessor is deprecated. Use month instead",
|
|
getSetMonth
|
|
);
|
|
proto.years = deprecate(
|
|
"years accessor is deprecated. Use year instead",
|
|
getSetYear
|
|
);
|
|
proto.zone = deprecate(
|
|
"moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",
|
|
getSetZone
|
|
);
|
|
proto.isDSTShifted = deprecate(
|
|
"isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",
|
|
isDaylightSavingTimeShifted
|
|
);
|
|
function createUnix(input) {
|
|
return createLocal(input * 1e3);
|
|
}
|
|
function createInZone() {
|
|
return createLocal.apply(null, arguments).parseZone();
|
|
}
|
|
function preParsePostFormat(string) {
|
|
return string;
|
|
}
|
|
var proto$1 = Locale.prototype;
|
|
proto$1.calendar = calendar;
|
|
proto$1.longDateFormat = longDateFormat;
|
|
proto$1.invalidDate = invalidDate;
|
|
proto$1.ordinal = ordinal;
|
|
proto$1.preparse = preParsePostFormat;
|
|
proto$1.postformat = preParsePostFormat;
|
|
proto$1.relativeTime = relativeTime;
|
|
proto$1.pastFuture = pastFuture;
|
|
proto$1.set = set3;
|
|
proto$1.eras = localeEras;
|
|
proto$1.erasParse = localeErasParse;
|
|
proto$1.erasConvertYear = localeErasConvertYear;
|
|
proto$1.erasAbbrRegex = erasAbbrRegex;
|
|
proto$1.erasNameRegex = erasNameRegex;
|
|
proto$1.erasNarrowRegex = erasNarrowRegex;
|
|
proto$1.months = localeMonths;
|
|
proto$1.monthsShort = localeMonthsShort;
|
|
proto$1.monthsParse = localeMonthsParse;
|
|
proto$1.monthsRegex = monthsRegex;
|
|
proto$1.monthsShortRegex = monthsShortRegex;
|
|
proto$1.week = localeWeek;
|
|
proto$1.firstDayOfYear = localeFirstDayOfYear;
|
|
proto$1.firstDayOfWeek = localeFirstDayOfWeek;
|
|
proto$1.weekdays = localeWeekdays;
|
|
proto$1.weekdaysMin = localeWeekdaysMin;
|
|
proto$1.weekdaysShort = localeWeekdaysShort;
|
|
proto$1.weekdaysParse = localeWeekdaysParse;
|
|
proto$1.weekdaysRegex = weekdaysRegex;
|
|
proto$1.weekdaysShortRegex = weekdaysShortRegex;
|
|
proto$1.weekdaysMinRegex = weekdaysMinRegex;
|
|
proto$1.isPM = localeIsPM;
|
|
proto$1.meridiem = localeMeridiem;
|
|
function get$1(format2, index, field, setter) {
|
|
var locale2 = getLocale(), utc = createUTC().set(setter, index);
|
|
return locale2[field](utc, format2);
|
|
}
|
|
function listMonthsImpl(format2, index, field) {
|
|
if (isNumber(format2)) {
|
|
index = format2;
|
|
format2 = void 0;
|
|
}
|
|
format2 = format2 || "";
|
|
if (index != null) {
|
|
return get$1(format2, index, field, "month");
|
|
}
|
|
var i, out = [];
|
|
for (i = 0; i < 12; i++) {
|
|
out[i] = get$1(format2, i, field, "month");
|
|
}
|
|
return out;
|
|
}
|
|
function listWeekdaysImpl(localeSorted, format2, index, field) {
|
|
if (typeof localeSorted === "boolean") {
|
|
if (isNumber(format2)) {
|
|
index = format2;
|
|
format2 = void 0;
|
|
}
|
|
format2 = format2 || "";
|
|
} else {
|
|
format2 = localeSorted;
|
|
index = format2;
|
|
localeSorted = false;
|
|
if (isNumber(format2)) {
|
|
index = format2;
|
|
format2 = void 0;
|
|
}
|
|
format2 = format2 || "";
|
|
}
|
|
var locale2 = getLocale(), shift = localeSorted ? locale2._week.dow : 0, i, out = [];
|
|
if (index != null) {
|
|
return get$1(format2, (index + shift) % 7, field, "day");
|
|
}
|
|
for (i = 0; i < 7; i++) {
|
|
out[i] = get$1(format2, (i + shift) % 7, field, "day");
|
|
}
|
|
return out;
|
|
}
|
|
function listMonths(format2, index) {
|
|
return listMonthsImpl(format2, index, "months");
|
|
}
|
|
function listMonthsShort(format2, index) {
|
|
return listMonthsImpl(format2, index, "monthsShort");
|
|
}
|
|
function listWeekdays(localeSorted, format2, index) {
|
|
return listWeekdaysImpl(localeSorted, format2, index, "weekdays");
|
|
}
|
|
function listWeekdaysShort(localeSorted, format2, index) {
|
|
return listWeekdaysImpl(localeSorted, format2, index, "weekdaysShort");
|
|
}
|
|
function listWeekdaysMin(localeSorted, format2, index) {
|
|
return listWeekdaysImpl(localeSorted, format2, index, "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(number) {
|
|
var b = number % 10, output = toInt(number % 100 / 10) === 1 ? "th" : b === 1 ? "st" : b === 2 ? "nd" : b === 3 ? "rd" : "th";
|
|
return number + output;
|
|
}
|
|
});
|
|
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 mathAbs = Math.abs;
|
|
function abs() {
|
|
var data = this._data;
|
|
this._milliseconds = mathAbs(this._milliseconds);
|
|
this._days = mathAbs(this._days);
|
|
this._months = mathAbs(this._months);
|
|
data.milliseconds = mathAbs(data.milliseconds);
|
|
data.seconds = mathAbs(data.seconds);
|
|
data.minutes = mathAbs(data.minutes);
|
|
data.hours = mathAbs(data.hours);
|
|
data.months = mathAbs(data.months);
|
|
data.years = mathAbs(data.years);
|
|
return this;
|
|
}
|
|
function addSubtract$1(duration, input, value, direction) {
|
|
var other = createDuration(input, value);
|
|
duration._milliseconds += direction * other._milliseconds;
|
|
duration._days += direction * other._days;
|
|
duration._months += direction * other._months;
|
|
return duration._bubble();
|
|
}
|
|
function add$1(input, value) {
|
|
return addSubtract$1(this, input, value, 1);
|
|
}
|
|
function subtract$1(input, value) {
|
|
return addSubtract$1(this, input, value, -1);
|
|
}
|
|
function absCeil(number) {
|
|
if (number < 0) {
|
|
return Math.floor(number);
|
|
} else {
|
|
return Math.ceil(number);
|
|
}
|
|
}
|
|
function bubble2() {
|
|
var milliseconds2 = this._milliseconds, days2 = this._days, months2 = this._months, data = this._data, seconds2, minutes2, hours2, years2, monthsFromDays;
|
|
if (!(milliseconds2 >= 0 && days2 >= 0 && months2 >= 0 || milliseconds2 <= 0 && days2 <= 0 && months2 <= 0)) {
|
|
milliseconds2 += absCeil(monthsToDays(months2) + days2) * 864e5;
|
|
days2 = 0;
|
|
months2 = 0;
|
|
}
|
|
data.milliseconds = milliseconds2 % 1e3;
|
|
seconds2 = absFloor(milliseconds2 / 1e3);
|
|
data.seconds = seconds2 % 60;
|
|
minutes2 = absFloor(seconds2 / 60);
|
|
data.minutes = minutes2 % 60;
|
|
hours2 = absFloor(minutes2 / 60);
|
|
data.hours = hours2 % 24;
|
|
days2 += absFloor(hours2 / 24);
|
|
monthsFromDays = absFloor(daysToMonths(days2));
|
|
months2 += monthsFromDays;
|
|
days2 -= absCeil(monthsToDays(monthsFromDays));
|
|
years2 = absFloor(months2 / 12);
|
|
months2 %= 12;
|
|
data.days = days2;
|
|
data.months = months2;
|
|
data.years = years2;
|
|
return this;
|
|
}
|
|
function daysToMonths(days2) {
|
|
return days2 * 4800 / 146097;
|
|
}
|
|
function monthsToDays(months2) {
|
|
return months2 * 146097 / 4800;
|
|
}
|
|
function as(units) {
|
|
if (!this.isValid()) {
|
|
return NaN;
|
|
}
|
|
var days2, months2, milliseconds2 = this._milliseconds;
|
|
units = normalizeUnits(units);
|
|
if (units === "month" || units === "quarter" || units === "year") {
|
|
days2 = this._days + milliseconds2 / 864e5;
|
|
months2 = this._months + daysToMonths(days2);
|
|
switch (units) {
|
|
case "month":
|
|
return months2;
|
|
case "quarter":
|
|
return months2 / 3;
|
|
case "year":
|
|
return months2 / 12;
|
|
}
|
|
} else {
|
|
days2 = this._days + Math.round(monthsToDays(this._months));
|
|
switch (units) {
|
|
case "week":
|
|
return days2 / 7 + milliseconds2 / 6048e5;
|
|
case "day":
|
|
return days2 + milliseconds2 / 864e5;
|
|
case "hour":
|
|
return days2 * 24 + milliseconds2 / 36e5;
|
|
case "minute":
|
|
return days2 * 1440 + milliseconds2 / 6e4;
|
|
case "second":
|
|
return days2 * 86400 + milliseconds2 / 1e3;
|
|
case "millisecond":
|
|
return Math.floor(days2 * 864e5) + milliseconds2;
|
|
default:
|
|
throw new Error("Unknown unit " + units);
|
|
}
|
|
}
|
|
}
|
|
function valueOf$1() {
|
|
if (!this.isValid()) {
|
|
return NaN;
|
|
}
|
|
return this._milliseconds + this._days * 864e5 + this._months % 12 * 2592e6 + toInt(this._months / 12) * 31536e6;
|
|
}
|
|
function makeAs(alias) {
|
|
return function() {
|
|
return this.as(alias);
|
|
};
|
|
}
|
|
var asMilliseconds = makeAs("ms"), asSeconds = makeAs("s"), asMinutes = makeAs("m"), asHours = makeAs("h"), asDays = makeAs("d"), asWeeks = makeAs("w"), asMonths = makeAs("M"), asQuarters = makeAs("Q"), asYears = makeAs("y");
|
|
function clone$1() {
|
|
return createDuration(this);
|
|
}
|
|
function get$2(units) {
|
|
units = normalizeUnits(units);
|
|
return this.isValid() ? this[units + "s"]() : NaN;
|
|
}
|
|
function makeGetter(name) {
|
|
return function() {
|
|
return this.isValid() ? this._data[name] : NaN;
|
|
};
|
|
}
|
|
var milliseconds = makeGetter("milliseconds"), seconds = makeGetter("seconds"), minutes = makeGetter("minutes"), hours = makeGetter("hours"), days = makeGetter("days"), months = makeGetter("months"), years = makeGetter("years");
|
|
function weeks() {
|
|
return absFloor(this.days() / 7);
|
|
}
|
|
var round = Math.round, thresholds = {
|
|
ss: 44,
|
|
s: 45,
|
|
m: 45,
|
|
h: 22,
|
|
d: 26,
|
|
w: null,
|
|
M: 11
|
|
};
|
|
function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale2) {
|
|
return locale2.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
|
|
}
|
|
function relativeTime$1(posNegDuration, withoutSuffix, thresholds2, locale2) {
|
|
var duration = createDuration(posNegDuration).abs(), seconds2 = round(duration.as("s")), minutes2 = round(duration.as("m")), hours2 = round(duration.as("h")), days2 = round(duration.as("d")), months2 = round(duration.as("M")), weeks2 = round(duration.as("w")), years2 = round(duration.as("y")), a = seconds2 <= thresholds2.ss && ["s", seconds2] || seconds2 < thresholds2.s && ["ss", seconds2] || minutes2 <= 1 && ["m"] || minutes2 < thresholds2.m && ["mm", minutes2] || hours2 <= 1 && ["h"] || hours2 < thresholds2.h && ["hh", hours2] || days2 <= 1 && ["d"] || days2 < thresholds2.d && ["dd", days2];
|
|
if (thresholds2.w != null) {
|
|
a = a || weeks2 <= 1 && ["w"] || weeks2 < thresholds2.w && ["ww", weeks2];
|
|
}
|
|
a = a || months2 <= 1 && ["M"] || months2 < thresholds2.M && ["MM", months2] || years2 <= 1 && ["y"] || ["yy", years2];
|
|
a[2] = withoutSuffix;
|
|
a[3] = +posNegDuration > 0;
|
|
a[4] = locale2;
|
|
return substituteTimeAgo.apply(null, a);
|
|
}
|
|
function getSetRelativeTimeRounding(roundingFunction) {
|
|
if (roundingFunction === void 0) {
|
|
return round;
|
|
}
|
|
if (typeof roundingFunction === "function") {
|
|
round = roundingFunction;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getSetRelativeTimeThreshold(threshold, limit) {
|
|
if (thresholds[threshold] === void 0) {
|
|
return false;
|
|
}
|
|
if (limit === void 0) {
|
|
return thresholds[threshold];
|
|
}
|
|
thresholds[threshold] = limit;
|
|
if (threshold === "s") {
|
|
thresholds.ss = limit - 1;
|
|
}
|
|
return true;
|
|
}
|
|
function humanize(argWithSuffix, argThresholds) {
|
|
if (!this.isValid()) {
|
|
return this.localeData().invalidDate();
|
|
}
|
|
var withSuffix = false, th = thresholds, locale2, output;
|
|
if (typeof argWithSuffix === "object") {
|
|
argThresholds = argWithSuffix;
|
|
argWithSuffix = false;
|
|
}
|
|
if (typeof argWithSuffix === "boolean") {
|
|
withSuffix = argWithSuffix;
|
|
}
|
|
if (typeof argThresholds === "object") {
|
|
th = Object.assign({}, thresholds, argThresholds);
|
|
if (argThresholds.s != null && argThresholds.ss == null) {
|
|
th.ss = argThresholds.s - 1;
|
|
}
|
|
}
|
|
locale2 = this.localeData();
|
|
output = relativeTime$1(this, !withSuffix, th, locale2);
|
|
if (withSuffix) {
|
|
output = locale2.pastFuture(+this, output);
|
|
}
|
|
return locale2.postformat(output);
|
|
}
|
|
var abs$1 = Math.abs;
|
|
function sign(x) {
|
|
return (x > 0) - (x < 0) || +x;
|
|
}
|
|
function toISOString$1() {
|
|
if (!this.isValid()) {
|
|
return this.localeData().invalidDate();
|
|
}
|
|
var seconds2 = abs$1(this._milliseconds) / 1e3, days2 = abs$1(this._days), months2 = abs$1(this._months), minutes2, hours2, years2, s, total = this.asSeconds(), totalSign, ymSign, daysSign, hmsSign;
|
|
if (!total) {
|
|
return "P0D";
|
|
}
|
|
minutes2 = absFloor(seconds2 / 60);
|
|
hours2 = absFloor(minutes2 / 60);
|
|
seconds2 %= 60;
|
|
minutes2 %= 60;
|
|
years2 = absFloor(months2 / 12);
|
|
months2 %= 12;
|
|
s = seconds2 ? seconds2.toFixed(3).replace(/\.?0+$/, "") : "";
|
|
totalSign = total < 0 ? "-" : "";
|
|
ymSign = sign(this._months) !== sign(total) ? "-" : "";
|
|
daysSign = sign(this._days) !== sign(total) ? "-" : "";
|
|
hmsSign = sign(this._milliseconds) !== sign(total) ? "-" : "";
|
|
return totalSign + "P" + (years2 ? ymSign + years2 + "Y" : "") + (months2 ? ymSign + months2 + "M" : "") + (days2 ? daysSign + days2 + "D" : "") + (hours2 || minutes2 || seconds2 ? "T" : "") + (hours2 ? hmsSign + hours2 + "H" : "") + (minutes2 ? hmsSign + minutes2 + "M" : "") + (seconds2 ? hmsSign + s + "S" : "");
|
|
}
|
|
var proto$2 = Duration.prototype;
|
|
proto$2.isValid = isValid$1;
|
|
proto$2.abs = abs;
|
|
proto$2.add = add$1;
|
|
proto$2.subtract = subtract$1;
|
|
proto$2.as = as;
|
|
proto$2.asMilliseconds = asMilliseconds;
|
|
proto$2.asSeconds = asSeconds;
|
|
proto$2.asMinutes = asMinutes;
|
|
proto$2.asHours = asHours;
|
|
proto$2.asDays = asDays;
|
|
proto$2.asWeeks = asWeeks;
|
|
proto$2.asMonths = asMonths;
|
|
proto$2.asQuarters = asQuarters;
|
|
proto$2.asYears = asYears;
|
|
proto$2.valueOf = valueOf$1;
|
|
proto$2._bubble = bubble2;
|
|
proto$2.clone = clone$1;
|
|
proto$2.get = get$2;
|
|
proto$2.milliseconds = milliseconds;
|
|
proto$2.seconds = seconds;
|
|
proto$2.minutes = minutes;
|
|
proto$2.hours = hours;
|
|
proto$2.days = days;
|
|
proto$2.weeks = weeks;
|
|
proto$2.months = months;
|
|
proto$2.years = years;
|
|
proto$2.humanize = humanize;
|
|
proto$2.toISOString = toISOString$1;
|
|
proto$2.toString = toISOString$1;
|
|
proto$2.toJSON = toISOString$1;
|
|
proto$2.locale = locale;
|
|
proto$2.localeData = localeData;
|
|
proto$2.toIsoString = deprecate(
|
|
"toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",
|
|
toISOString$1
|
|
);
|
|
proto$2.lang = lang;
|
|
addFormatToken("X", 0, 0, "unix");
|
|
addFormatToken("x", 0, 0, "valueOf");
|
|
addRegexToken("x", matchSigned);
|
|
addRegexToken("X", matchTimestamp);
|
|
addParseToken("X", function(input, array, config) {
|
|
config._d = new Date(parseFloat(input) * 1e3);
|
|
});
|
|
addParseToken("x", function(input, array, config) {
|
|
config._d = new Date(toInt(input));
|
|
});
|
|
hooks.version = "2.29.4";
|
|
setHookCallback(createLocal);
|
|
hooks.fn = proto;
|
|
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 = proto;
|
|
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;
|
|
});
|
|
}
|
|
});
|
|
|
|
// main.ts
|
|
var main_exports = {};
|
|
__export(main_exports, {
|
|
PluginStore: () => PluginStore,
|
|
default: () => NoteSharingPlugin
|
|
});
|
|
module.exports = __toCommonJS(main_exports);
|
|
var import_obsidian7 = require("obsidian");
|
|
|
|
// src/NoteSharingService.ts
|
|
var import_moment = __toESM(require_moment());
|
|
var import_obsidian = require("obsidian");
|
|
|
|
// src/crypto/crypto.ts
|
|
function generateRandomKey() {
|
|
return __async(this, null, function* () {
|
|
const seed = window.crypto.getRandomValues(new Uint8Array(64));
|
|
return _generateKey(seed);
|
|
});
|
|
}
|
|
function _generateKey(seed) {
|
|
return __async(this, null, function* () {
|
|
const keyMaterial = yield window.crypto.subtle.importKey(
|
|
"raw",
|
|
seed,
|
|
{ name: "PBKDF2" },
|
|
false,
|
|
["deriveBits"]
|
|
);
|
|
const masterKey = yield window.crypto.subtle.deriveBits(
|
|
{
|
|
name: "PBKDF2",
|
|
salt: new Uint8Array(16),
|
|
iterations: 1e5,
|
|
hash: "SHA-256"
|
|
},
|
|
keyMaterial,
|
|
256
|
|
);
|
|
return new Uint8Array(masterKey);
|
|
});
|
|
}
|
|
function masterKeyToString(masterKey) {
|
|
return arrayBufferToBase64(masterKey);
|
|
}
|
|
function encryptString(md, secret) {
|
|
return __async(this, null, function* () {
|
|
const plaintext = new TextEncoder().encode(md);
|
|
const iv = window.crypto.getRandomValues(new Uint8Array(16));
|
|
const buf_ciphertext = yield window.crypto.subtle.encrypt(
|
|
{ name: "AES-GCM", iv },
|
|
yield _getAesGcmKey(secret),
|
|
plaintext
|
|
);
|
|
const ciphertext = arrayBufferToBase64(buf_ciphertext);
|
|
return { ciphertext, iv: arrayBufferToBase64(iv) };
|
|
});
|
|
}
|
|
function arrayBufferToBase64(buffer) {
|
|
return window.btoa(String.fromCharCode(...new Uint8Array(buffer)));
|
|
}
|
|
function _getAesGcmKey(secret) {
|
|
return window.crypto.subtle.importKey(
|
|
"raw",
|
|
secret,
|
|
{ name: "AES-GCM", length: 256 },
|
|
false,
|
|
["encrypt", "decrypt"]
|
|
);
|
|
}
|
|
|
|
// src/crypto/encryption.ts
|
|
function encryptString2(plaintext) {
|
|
return __async(this, null, function* () {
|
|
const key = yield generateRandomKey();
|
|
const { ciphertext, iv } = yield encryptString(plaintext, key);
|
|
return { ciphertext, iv, key: masterKeyToString(key).slice(0, 43) };
|
|
});
|
|
}
|
|
|
|
// src/NoteSharingService.ts
|
|
var NoteSharingService = class {
|
|
constructor(serverUrl, userId, pluginVersion) {
|
|
this.serverUrl = serverUrl;
|
|
this._userId = userId;
|
|
this._pluginVersion = pluginVersion;
|
|
}
|
|
shareNote(body, options) {
|
|
return __async(this, null, function* () {
|
|
body = this.sanitizeNote(body);
|
|
const jsonPayload = {
|
|
body,
|
|
title: options == null ? void 0 : options.title
|
|
};
|
|
const stringPayload = JSON.stringify(jsonPayload);
|
|
const { ciphertext, iv, key } = yield encryptString2(stringPayload);
|
|
const res = yield this.postNote(ciphertext, iv);
|
|
res.view_url += `#${key}`;
|
|
console.log(`Note shared: ${res.view_url}`);
|
|
return res;
|
|
});
|
|
}
|
|
deleteNote(noteId, secretToken) {
|
|
return __async(this, null, function* () {
|
|
yield (0, import_obsidian.requestUrl)({
|
|
url: `${this._url}/api/note/${noteId}`,
|
|
method: "DELETE",
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
user_id: this._userId,
|
|
secret_token: secretToken
|
|
})
|
|
});
|
|
});
|
|
}
|
|
postNote(ciphertext, iv) {
|
|
return __async(this, null, function* () {
|
|
const res = yield (0, import_obsidian.requestUrl)({
|
|
url: `${this._url}/api/note`,
|
|
method: "POST",
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
ciphertext,
|
|
iv,
|
|
user_id: this._userId,
|
|
plugin_version: this._pluginVersion,
|
|
crypto_version: "v3"
|
|
})
|
|
});
|
|
if (res.status == 200 && res.json != null) {
|
|
const returnValue = res.json;
|
|
returnValue.expire_time = (0, import_moment.default)(returnValue.expire_time);
|
|
return returnValue;
|
|
}
|
|
throw Error(
|
|
`Error uploading encrypted note (${res.status}): ${res.text}`
|
|
);
|
|
});
|
|
}
|
|
sanitizeNote(mdText) {
|
|
mdText = mdText.trim();
|
|
const match = mdText.match(
|
|
/^(?:---\s*\n)(?:(?:.*?\n)*?)(?:---)((?:.|\n|\r)*)/
|
|
);
|
|
if (match) {
|
|
mdText = match[1].trim();
|
|
}
|
|
return mdText;
|
|
}
|
|
set serverUrl(newUrl) {
|
|
newUrl = newUrl.replace(/([^:]\/)\/+/g, "$1");
|
|
if (newUrl[newUrl.length - 1] == "/") {
|
|
newUrl = newUrl.substring(0, newUrl.length - 1);
|
|
}
|
|
this._url = newUrl;
|
|
}
|
|
};
|
|
|
|
// node_modules/crc/mjs/calculators/crc16.js
|
|
var TABLE = [
|
|
0,
|
|
49345,
|
|
49537,
|
|
320,
|
|
49921,
|
|
960,
|
|
640,
|
|
49729,
|
|
50689,
|
|
1728,
|
|
1920,
|
|
51009,
|
|
1280,
|
|
50625,
|
|
50305,
|
|
1088,
|
|
52225,
|
|
3264,
|
|
3456,
|
|
52545,
|
|
3840,
|
|
53185,
|
|
52865,
|
|
3648,
|
|
2560,
|
|
51905,
|
|
52097,
|
|
2880,
|
|
51457,
|
|
2496,
|
|
2176,
|
|
51265,
|
|
55297,
|
|
6336,
|
|
6528,
|
|
55617,
|
|
6912,
|
|
56257,
|
|
55937,
|
|
6720,
|
|
7680,
|
|
57025,
|
|
57217,
|
|
8e3,
|
|
56577,
|
|
7616,
|
|
7296,
|
|
56385,
|
|
5120,
|
|
54465,
|
|
54657,
|
|
5440,
|
|
55041,
|
|
6080,
|
|
5760,
|
|
54849,
|
|
53761,
|
|
4800,
|
|
4992,
|
|
54081,
|
|
4352,
|
|
53697,
|
|
53377,
|
|
4160,
|
|
61441,
|
|
12480,
|
|
12672,
|
|
61761,
|
|
13056,
|
|
62401,
|
|
62081,
|
|
12864,
|
|
13824,
|
|
63169,
|
|
63361,
|
|
14144,
|
|
62721,
|
|
13760,
|
|
13440,
|
|
62529,
|
|
15360,
|
|
64705,
|
|
64897,
|
|
15680,
|
|
65281,
|
|
16320,
|
|
16e3,
|
|
65089,
|
|
64001,
|
|
15040,
|
|
15232,
|
|
64321,
|
|
14592,
|
|
63937,
|
|
63617,
|
|
14400,
|
|
10240,
|
|
59585,
|
|
59777,
|
|
10560,
|
|
60161,
|
|
11200,
|
|
10880,
|
|
59969,
|
|
60929,
|
|
11968,
|
|
12160,
|
|
61249,
|
|
11520,
|
|
60865,
|
|
60545,
|
|
11328,
|
|
58369,
|
|
9408,
|
|
9600,
|
|
58689,
|
|
9984,
|
|
59329,
|
|
59009,
|
|
9792,
|
|
8704,
|
|
58049,
|
|
58241,
|
|
9024,
|
|
57601,
|
|
8640,
|
|
8320,
|
|
57409,
|
|
40961,
|
|
24768,
|
|
24960,
|
|
41281,
|
|
25344,
|
|
41921,
|
|
41601,
|
|
25152,
|
|
26112,
|
|
42689,
|
|
42881,
|
|
26432,
|
|
42241,
|
|
26048,
|
|
25728,
|
|
42049,
|
|
27648,
|
|
44225,
|
|
44417,
|
|
27968,
|
|
44801,
|
|
28608,
|
|
28288,
|
|
44609,
|
|
43521,
|
|
27328,
|
|
27520,
|
|
43841,
|
|
26880,
|
|
43457,
|
|
43137,
|
|
26688,
|
|
30720,
|
|
47297,
|
|
47489,
|
|
31040,
|
|
47873,
|
|
31680,
|
|
31360,
|
|
47681,
|
|
48641,
|
|
32448,
|
|
32640,
|
|
48961,
|
|
32e3,
|
|
48577,
|
|
48257,
|
|
31808,
|
|
46081,
|
|
29888,
|
|
30080,
|
|
46401,
|
|
30464,
|
|
47041,
|
|
46721,
|
|
30272,
|
|
29184,
|
|
45761,
|
|
45953,
|
|
29504,
|
|
45313,
|
|
29120,
|
|
28800,
|
|
45121,
|
|
20480,
|
|
37057,
|
|
37249,
|
|
20800,
|
|
37633,
|
|
21440,
|
|
21120,
|
|
37441,
|
|
38401,
|
|
22208,
|
|
22400,
|
|
38721,
|
|
21760,
|
|
38337,
|
|
38017,
|
|
21568,
|
|
39937,
|
|
23744,
|
|
23936,
|
|
40257,
|
|
24320,
|
|
40897,
|
|
40577,
|
|
24128,
|
|
23040,
|
|
39617,
|
|
39809,
|
|
23360,
|
|
39169,
|
|
22976,
|
|
22656,
|
|
38977,
|
|
34817,
|
|
18624,
|
|
18816,
|
|
35137,
|
|
19200,
|
|
35777,
|
|
35457,
|
|
19008,
|
|
19968,
|
|
36545,
|
|
36737,
|
|
20288,
|
|
36097,
|
|
19904,
|
|
19584,
|
|
35905,
|
|
17408,
|
|
33985,
|
|
34177,
|
|
17728,
|
|
34561,
|
|
18368,
|
|
18048,
|
|
34369,
|
|
33281,
|
|
17088,
|
|
17280,
|
|
33601,
|
|
16640,
|
|
33217,
|
|
32897,
|
|
16448
|
|
];
|
|
if (typeof Int32Array !== "undefined") {
|
|
TABLE = new Int32Array(TABLE);
|
|
}
|
|
var crc16 = (current, previous = 0) => {
|
|
let crc = ~~previous;
|
|
for (let index = 0; index < current.length; index++) {
|
|
crc = (TABLE[(crc ^ current[index]) & 255] ^ crc >> 8) & 65535;
|
|
}
|
|
return crc;
|
|
};
|
|
var crc16_default = crc16;
|
|
|
|
// src/lib/anonUserId.ts
|
|
function generateId() {
|
|
const random = Math.floor(Math.random() * 2 ** 64).toString(16);
|
|
const truncated = random.slice(0, 12).padStart(12, "0");
|
|
const buffer = new TextEncoder().encode(truncated);
|
|
const checksum = crc16_default(buffer).toString(16).padStart(4, "0");
|
|
return truncated + checksum;
|
|
}
|
|
|
|
// src/obsidian/PluginSettings.ts
|
|
var DEFAULT_SETTINGS = {
|
|
serverUrl: "https://noteshare.space",
|
|
selfHosted: false,
|
|
anonymousUserId: generateId(),
|
|
useFrontmatter: true,
|
|
frontmatterDateFormat: "YYYY-MM-DD HH:mm:ss",
|
|
shareFilenameAsTitle: true,
|
|
useFsCache: true
|
|
};
|
|
|
|
// src/obsidian/SettingsTab.ts
|
|
var import_obsidian2 = require("obsidian");
|
|
|
|
// node_modules/svelte/internal/index.mjs
|
|
function noop() {
|
|
}
|
|
function run(fn) {
|
|
return fn();
|
|
}
|
|
function blank_object() {
|
|
return /* @__PURE__ */ Object.create(null);
|
|
}
|
|
function run_all(fns) {
|
|
fns.forEach(run);
|
|
}
|
|
function is_function(thing) {
|
|
return typeof thing === "function";
|
|
}
|
|
function safe_not_equal(a, b) {
|
|
return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function");
|
|
}
|
|
function is_empty(obj) {
|
|
return Object.keys(obj).length === 0;
|
|
}
|
|
function subscribe(store, ...callbacks) {
|
|
if (store == null) {
|
|
return noop;
|
|
}
|
|
const unsub = store.subscribe(...callbacks);
|
|
return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
|
|
}
|
|
function component_subscribe(component, store, callback) {
|
|
component.$$.on_destroy.push(subscribe(store, callback));
|
|
}
|
|
function action_destroyer(action_result) {
|
|
return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;
|
|
}
|
|
var is_hydrating = false;
|
|
function start_hydrating() {
|
|
is_hydrating = true;
|
|
}
|
|
function end_hydrating() {
|
|
is_hydrating = false;
|
|
}
|
|
function append(target, node) {
|
|
target.appendChild(node);
|
|
}
|
|
function append_styles(target, style_sheet_id, styles) {
|
|
const append_styles_to = get_root_for_style(target);
|
|
if (!append_styles_to.getElementById(style_sheet_id)) {
|
|
const style = element("style");
|
|
style.id = style_sheet_id;
|
|
style.textContent = styles;
|
|
append_stylesheet(append_styles_to, style);
|
|
}
|
|
}
|
|
function get_root_for_style(node) {
|
|
if (!node)
|
|
return document;
|
|
const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
|
|
if (root && root.host) {
|
|
return root;
|
|
}
|
|
return node.ownerDocument;
|
|
}
|
|
function append_stylesheet(node, style) {
|
|
append(node.head || node, style);
|
|
}
|
|
function insert(target, node, anchor) {
|
|
target.insertBefore(node, anchor || null);
|
|
}
|
|
function detach(node) {
|
|
node.parentNode.removeChild(node);
|
|
}
|
|
function destroy_each(iterations, detaching) {
|
|
for (let i = 0; i < iterations.length; i += 1) {
|
|
if (iterations[i])
|
|
iterations[i].d(detaching);
|
|
}
|
|
}
|
|
function element(name) {
|
|
return document.createElement(name);
|
|
}
|
|
function text(data) {
|
|
return document.createTextNode(data);
|
|
}
|
|
function space() {
|
|
return text(" ");
|
|
}
|
|
function listen(node, event, handler, options) {
|
|
node.addEventListener(event, handler, options);
|
|
return () => node.removeEventListener(event, handler, options);
|
|
}
|
|
function attr(node, attribute, value) {
|
|
if (value == null)
|
|
node.removeAttribute(attribute);
|
|
else if (node.getAttribute(attribute) !== value)
|
|
node.setAttribute(attribute, value);
|
|
}
|
|
function children(element2) {
|
|
return Array.from(element2.childNodes);
|
|
}
|
|
function set_data(text2, data) {
|
|
data = "" + data;
|
|
if (text2.wholeText !== data)
|
|
text2.data = data;
|
|
}
|
|
function set_input_value(input, value) {
|
|
input.value = value == null ? "" : value;
|
|
}
|
|
function toggle_class(element2, name, toggle) {
|
|
element2.classList[toggle ? "add" : "remove"](name);
|
|
}
|
|
var current_component;
|
|
function set_current_component(component) {
|
|
current_component = component;
|
|
}
|
|
function get_current_component() {
|
|
if (!current_component)
|
|
throw new Error("Function called outside component initialization");
|
|
return current_component;
|
|
}
|
|
function onMount(fn) {
|
|
get_current_component().$$.on_mount.push(fn);
|
|
}
|
|
function bubble(component, event) {
|
|
const callbacks = component.$$.callbacks[event.type];
|
|
if (callbacks) {
|
|
callbacks.slice().forEach((fn) => fn.call(this, event));
|
|
}
|
|
}
|
|
var dirty_components = [];
|
|
var binding_callbacks = [];
|
|
var render_callbacks = [];
|
|
var flush_callbacks = [];
|
|
var resolved_promise = Promise.resolve();
|
|
var update_scheduled = false;
|
|
function schedule_update() {
|
|
if (!update_scheduled) {
|
|
update_scheduled = true;
|
|
resolved_promise.then(flush);
|
|
}
|
|
}
|
|
function add_render_callback(fn) {
|
|
render_callbacks.push(fn);
|
|
}
|
|
var seen_callbacks = /* @__PURE__ */ new Set();
|
|
var flushidx = 0;
|
|
function flush() {
|
|
const saved_component = current_component;
|
|
do {
|
|
while (flushidx < dirty_components.length) {
|
|
const component = dirty_components[flushidx];
|
|
flushidx++;
|
|
set_current_component(component);
|
|
update(component.$$);
|
|
}
|
|
set_current_component(null);
|
|
dirty_components.length = 0;
|
|
flushidx = 0;
|
|
while (binding_callbacks.length)
|
|
binding_callbacks.pop()();
|
|
for (let i = 0; i < render_callbacks.length; i += 1) {
|
|
const callback = render_callbacks[i];
|
|
if (!seen_callbacks.has(callback)) {
|
|
seen_callbacks.add(callback);
|
|
callback();
|
|
}
|
|
}
|
|
render_callbacks.length = 0;
|
|
} while (dirty_components.length);
|
|
while (flush_callbacks.length) {
|
|
flush_callbacks.pop()();
|
|
}
|
|
update_scheduled = false;
|
|
seen_callbacks.clear();
|
|
set_current_component(saved_component);
|
|
}
|
|
function update($$) {
|
|
if ($$.fragment !== null) {
|
|
$$.update();
|
|
run_all($$.before_update);
|
|
const dirty = $$.dirty;
|
|
$$.dirty = [-1];
|
|
$$.fragment && $$.fragment.p($$.ctx, dirty);
|
|
$$.after_update.forEach(add_render_callback);
|
|
}
|
|
}
|
|
var outroing = /* @__PURE__ */ new Set();
|
|
var outros;
|
|
function group_outros() {
|
|
outros = {
|
|
r: 0,
|
|
c: [],
|
|
p: outros
|
|
};
|
|
}
|
|
function check_outros() {
|
|
if (!outros.r) {
|
|
run_all(outros.c);
|
|
}
|
|
outros = outros.p;
|
|
}
|
|
function transition_in(block, local) {
|
|
if (block && block.i) {
|
|
outroing.delete(block);
|
|
block.i(local);
|
|
}
|
|
}
|
|
function transition_out(block, local, detach2, callback) {
|
|
if (block && block.o) {
|
|
if (outroing.has(block))
|
|
return;
|
|
outroing.add(block);
|
|
outros.c.push(() => {
|
|
outroing.delete(block);
|
|
if (callback) {
|
|
if (detach2)
|
|
block.d(1);
|
|
callback();
|
|
}
|
|
});
|
|
block.o(local);
|
|
} else if (callback) {
|
|
callback();
|
|
}
|
|
}
|
|
var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : global;
|
|
function create_component(block) {
|
|
block && block.c();
|
|
}
|
|
function mount_component(component, target, anchor, customElement) {
|
|
const { fragment, on_mount, on_destroy, after_update } = component.$$;
|
|
fragment && fragment.m(target, anchor);
|
|
if (!customElement) {
|
|
add_render_callback(() => {
|
|
const new_on_destroy = on_mount.map(run).filter(is_function);
|
|
if (on_destroy) {
|
|
on_destroy.push(...new_on_destroy);
|
|
} else {
|
|
run_all(new_on_destroy);
|
|
}
|
|
component.$$.on_mount = [];
|
|
});
|
|
}
|
|
after_update.forEach(add_render_callback);
|
|
}
|
|
function destroy_component(component, detaching) {
|
|
const $$ = component.$$;
|
|
if ($$.fragment !== null) {
|
|
run_all($$.on_destroy);
|
|
$$.fragment && $$.fragment.d(detaching);
|
|
$$.on_destroy = $$.fragment = null;
|
|
$$.ctx = [];
|
|
}
|
|
}
|
|
function make_dirty(component, i) {
|
|
if (component.$$.dirty[0] === -1) {
|
|
dirty_components.push(component);
|
|
schedule_update();
|
|
component.$$.dirty.fill(0);
|
|
}
|
|
component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
|
|
}
|
|
function init(component, options, instance4, create_fragment4, not_equal, props, append_styles2, dirty = [-1]) {
|
|
const parent_component = current_component;
|
|
set_current_component(component);
|
|
const $$ = component.$$ = {
|
|
fragment: null,
|
|
ctx: null,
|
|
props,
|
|
update: noop,
|
|
not_equal,
|
|
bound: blank_object(),
|
|
on_mount: [],
|
|
on_destroy: [],
|
|
on_disconnect: [],
|
|
before_update: [],
|
|
after_update: [],
|
|
context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
|
|
callbacks: blank_object(),
|
|
dirty,
|
|
skip_bound: false,
|
|
root: options.target || parent_component.$$.root
|
|
};
|
|
append_styles2 && append_styles2($$.root);
|
|
let ready = false;
|
|
$$.ctx = instance4 ? instance4(component, options.props || {}, (i, ret, ...rest) => {
|
|
const value = rest.length ? rest[0] : ret;
|
|
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
|
|
if (!$$.skip_bound && $$.bound[i])
|
|
$$.bound[i](value);
|
|
if (ready)
|
|
make_dirty(component, i);
|
|
}
|
|
return ret;
|
|
}) : [];
|
|
$$.update();
|
|
ready = true;
|
|
run_all($$.before_update);
|
|
$$.fragment = create_fragment4 ? create_fragment4($$.ctx) : false;
|
|
if (options.target) {
|
|
if (options.hydrate) {
|
|
start_hydrating();
|
|
const nodes = children(options.target);
|
|
$$.fragment && $$.fragment.l(nodes);
|
|
nodes.forEach(detach);
|
|
} else {
|
|
$$.fragment && $$.fragment.c();
|
|
}
|
|
if (options.intro)
|
|
transition_in(component.$$.fragment);
|
|
mount_component(component, options.target, options.anchor, options.customElement);
|
|
end_hydrating();
|
|
flush();
|
|
}
|
|
set_current_component(parent_component);
|
|
}
|
|
var SvelteElement;
|
|
if (typeof HTMLElement === "function") {
|
|
SvelteElement = class extends HTMLElement {
|
|
constructor() {
|
|
super();
|
|
this.attachShadow({ mode: "open" });
|
|
}
|
|
connectedCallback() {
|
|
const { on_mount } = this.$$;
|
|
this.$$.on_disconnect = on_mount.map(run).filter(is_function);
|
|
for (const key in this.$$.slotted) {
|
|
this.appendChild(this.$$.slotted[key]);
|
|
}
|
|
}
|
|
attributeChangedCallback(attr2, _oldValue, newValue) {
|
|
this[attr2] = newValue;
|
|
}
|
|
disconnectedCallback() {
|
|
run_all(this.$$.on_disconnect);
|
|
}
|
|
$destroy() {
|
|
destroy_component(this, 1);
|
|
this.$destroy = noop;
|
|
}
|
|
$on(type, callback) {
|
|
const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
|
|
callbacks.push(callback);
|
|
return () => {
|
|
const index = callbacks.indexOf(callback);
|
|
if (index !== -1)
|
|
callbacks.splice(index, 1);
|
|
};
|
|
}
|
|
$set($$props) {
|
|
if (this.$$set && !is_empty($$props)) {
|
|
this.$$.skip_bound = true;
|
|
this.$$set($$props);
|
|
this.$$.skip_bound = false;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
var SvelteComponent = class {
|
|
$destroy() {
|
|
destroy_component(this, 1);
|
|
this.$destroy = noop;
|
|
}
|
|
$on(type, callback) {
|
|
const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
|
|
callbacks.push(callback);
|
|
return () => {
|
|
const index = callbacks.indexOf(callback);
|
|
if (index !== -1)
|
|
callbacks.splice(index, 1);
|
|
};
|
|
}
|
|
$set($$props) {
|
|
if (this.$$set && !is_empty($$props)) {
|
|
this.$$.skip_bound = true;
|
|
this.$$set($$props);
|
|
this.$$.skip_bound = false;
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/svelte/store/index.mjs
|
|
var subscriber_queue = [];
|
|
function readable(value, start) {
|
|
return {
|
|
subscribe: writable(value, start).subscribe
|
|
};
|
|
}
|
|
function writable(value, start = noop) {
|
|
let stop;
|
|
const subscribers = /* @__PURE__ */ new Set();
|
|
function set3(new_value) {
|
|
if (safe_not_equal(value, new_value)) {
|
|
value = new_value;
|
|
if (stop) {
|
|
const run_queue = !subscriber_queue.length;
|
|
for (const subscriber of subscribers) {
|
|
subscriber[1]();
|
|
subscriber_queue.push(subscriber, value);
|
|
}
|
|
if (run_queue) {
|
|
for (let i = 0; i < subscriber_queue.length; i += 2) {
|
|
subscriber_queue[i][0](subscriber_queue[i + 1]);
|
|
}
|
|
subscriber_queue.length = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function update2(fn) {
|
|
set3(fn(value));
|
|
}
|
|
function subscribe5(run2, invalidate = noop) {
|
|
const subscriber = [run2, invalidate];
|
|
subscribers.add(subscriber);
|
|
if (subscribers.size === 1) {
|
|
stop = start(set3) || noop;
|
|
}
|
|
run2(value);
|
|
return () => {
|
|
subscribers.delete(subscriber);
|
|
if (subscribers.size === 0) {
|
|
stop();
|
|
stop = null;
|
|
}
|
|
};
|
|
}
|
|
return { set: set3, update: update2, subscribe: subscribe5 };
|
|
}
|
|
function derived(stores, fn, initial_value) {
|
|
const single = !Array.isArray(stores);
|
|
const stores_array = single ? [stores] : stores;
|
|
const auto = fn.length < 2;
|
|
return readable(initial_value, (set3) => {
|
|
let inited = false;
|
|
const values = [];
|
|
let pending = 0;
|
|
let cleanup = noop;
|
|
const sync = () => {
|
|
if (pending) {
|
|
return;
|
|
}
|
|
cleanup();
|
|
const result = fn(single ? values[0] : values, set3);
|
|
if (auto) {
|
|
set3(result);
|
|
} else {
|
|
cleanup = is_function(result) ? result : noop;
|
|
}
|
|
};
|
|
const unsubscribers = stores_array.map((store, i) => subscribe(store, (value) => {
|
|
values[i] = value;
|
|
pending &= ~(1 << i);
|
|
if (inited) {
|
|
sync();
|
|
}
|
|
}, () => {
|
|
pending |= 1 << i;
|
|
}));
|
|
inited = true;
|
|
sync();
|
|
return function stop() {
|
|
run_all(unsubscribers);
|
|
cleanup();
|
|
};
|
|
});
|
|
}
|
|
|
|
// src/lib/stores/CacheStore.ts
|
|
var { subscribe: subscribe2, set } = writable([]);
|
|
function updateReactiveCache(data) {
|
|
data.sort((a, b) => {
|
|
var _a, _b;
|
|
const aDate = new Date((_a = a.updated_datetime) != null ? _a : a.shared_datetime);
|
|
const bDate = new Date((_b = b.updated_datetime) != null ? _b : b.shared_datetime);
|
|
return bDate.getTime() - aDate.getTime();
|
|
});
|
|
set(data);
|
|
}
|
|
var CacheStore_default = { subscribe: subscribe2 };
|
|
|
|
// src/lib/cache/AbstractCache.ts
|
|
var AbstractCache = class {
|
|
get(fileId) {
|
|
const cache = this._getCache();
|
|
return cache[fileId];
|
|
}
|
|
set(fileId, data) {
|
|
return __async(this, null, function* () {
|
|
const cache = yield this._getCache();
|
|
if (typeof data === "function") {
|
|
if (cache[fileId] === void 0) {
|
|
throw new Error("File not found in cache.");
|
|
}
|
|
cache[fileId] = data(cache[fileId]);
|
|
} else {
|
|
cache[fileId] = data;
|
|
}
|
|
this.writeCache(cache);
|
|
});
|
|
}
|
|
has(fileId) {
|
|
const cache = this._getCache();
|
|
return cache[fileId] !== void 0;
|
|
}
|
|
rename(oldFileId, newFileId, newBasename) {
|
|
return __async(this, null, function* () {
|
|
const cache = this._getCache();
|
|
cache[newFileId] = cache[oldFileId];
|
|
delete cache[oldFileId];
|
|
if (newBasename) {
|
|
cache[newFileId].basename = newBasename;
|
|
}
|
|
return this.writeCache(cache);
|
|
});
|
|
}
|
|
list() {
|
|
return __async(this, null, function* () {
|
|
const cache = this._getCache();
|
|
return Object.entries(cache).map(([fileId, data]) => __spreadValues({
|
|
fileId
|
|
}, data));
|
|
});
|
|
}
|
|
copy(cache) {
|
|
return __async(this, null, function* () {
|
|
const data = yield cache.$getCache();
|
|
this.writeCache(data);
|
|
});
|
|
}
|
|
$getCache() {
|
|
return __async(this, null, function* () {
|
|
return this._getCache();
|
|
});
|
|
}
|
|
writeCache(object) {
|
|
return __async(this, null, function* () {
|
|
yield this._writeCache(object);
|
|
updateReactiveCache(yield this.list());
|
|
});
|
|
}
|
|
init() {
|
|
return __async(this, null, function* () {
|
|
const cache = yield this._init();
|
|
updateReactiveCache(yield this.list());
|
|
return cache;
|
|
});
|
|
}
|
|
};
|
|
|
|
// src/lib/cache/FsCache.ts
|
|
var FsCache = class extends AbstractCache {
|
|
constructor(app2) {
|
|
super();
|
|
this._app = app2;
|
|
}
|
|
_init() {
|
|
return __async(this, null, function* () {
|
|
yield this._fetchCache();
|
|
return this;
|
|
});
|
|
}
|
|
_getCache() {
|
|
var _a;
|
|
return (_a = this._cache) != null ? _a : {};
|
|
}
|
|
_writeCache(object) {
|
|
return __async(this, null, function* () {
|
|
yield this._app.vault.adapter.write(
|
|
this._cachePath,
|
|
JSON.stringify(object, null, 2)
|
|
);
|
|
this._cache = object;
|
|
});
|
|
}
|
|
_fetchCache() {
|
|
return __async(this, null, function* () {
|
|
try {
|
|
const jsonString = yield app.vault.adapter.read(this._cachePath);
|
|
this._cache = JSON.parse(jsonString);
|
|
} catch (e) {
|
|
this._cache = {};
|
|
}
|
|
});
|
|
}
|
|
$deleteAllData() {
|
|
return __async(this, null, function* () {
|
|
yield this._app.vault.adapter.remove(this._cachePath);
|
|
this._cache = {};
|
|
});
|
|
}
|
|
get _cachePath() {
|
|
return `${this._app.vault.configDir}/quickshare.json`;
|
|
}
|
|
};
|
|
|
|
// src/lib/cache/LocalStorageCache.ts
|
|
var LocalStorageCache = class extends AbstractCache {
|
|
constructor(app2) {
|
|
super();
|
|
this._app = app2;
|
|
}
|
|
_init() {
|
|
return __async(this, null, function* () {
|
|
yield this._fetchCache();
|
|
return this;
|
|
});
|
|
}
|
|
_getCache() {
|
|
var _a;
|
|
return (_a = this._cache) != null ? _a : {};
|
|
}
|
|
_writeCache(object) {
|
|
return __async(this, null, function* () {
|
|
window.localStorage.setItem(
|
|
this._cacheKey,
|
|
JSON.stringify(object, null, 2)
|
|
);
|
|
this._cache = object;
|
|
});
|
|
}
|
|
_fetchCache() {
|
|
return __async(this, null, function* () {
|
|
try {
|
|
const jsonString = window.localStorage.getItem(this._cacheKey);
|
|
if (jsonString) {
|
|
this._cache = JSON.parse(jsonString);
|
|
} else {
|
|
this._cache = {};
|
|
}
|
|
} catch (e) {
|
|
this._cache = {};
|
|
}
|
|
});
|
|
}
|
|
$deleteAllData() {
|
|
return __async(this, null, function* () {
|
|
window.localStorage.removeItem(this._cacheKey);
|
|
this._cache = {};
|
|
});
|
|
}
|
|
get _cacheKey() {
|
|
return `${this._app.appId}-quickshare`;
|
|
}
|
|
};
|
|
|
|
// src/obsidian/SettingsTab.ts
|
|
var SettingsTab = class extends import_obsidian2.PluginSettingTab {
|
|
constructor(app2, plugin) {
|
|
super(app2, plugin);
|
|
this.plugin = plugin;
|
|
this.hideSelfHosted = !plugin.settings.selfHosted;
|
|
}
|
|
display() {
|
|
const { containerEl } = this;
|
|
containerEl.empty();
|
|
containerEl.createEl("h2", { text: "QuickShare" });
|
|
new import_obsidian2.Setting(containerEl).setName("Use noteshare.space").setDesc(
|
|
"Noteshare.space is the free and official service for sharing your notes with QuickShare. Uncheck if you want to self-host."
|
|
).addToggle(
|
|
(text2) => text2.setValue(!this.plugin.settings.selfHosted).onChange((value) => __async(this, null, function* () {
|
|
this.plugin.settings.selfHosted = !value;
|
|
this.showSelfhostedSettings(
|
|
this.plugin.settings.selfHosted
|
|
);
|
|
if (this.plugin.settings.selfHosted === false) {
|
|
this.plugin.settings.serverUrl = DEFAULT_SETTINGS.serverUrl;
|
|
this.selfHostedUrl.setValue(
|
|
this.plugin.settings.serverUrl
|
|
);
|
|
}
|
|
yield this.plugin.saveSettings();
|
|
}))
|
|
);
|
|
new import_obsidian2.Setting(containerEl).setName("Sync QuickShare data across devices").setDesc(
|
|
`By default, QuickShare keeps the access keys for your shared
|
|
notes in a hidden file in your vault. This enables updating or deleting of QuickShare notes from multiple
|
|
devices when using Obsidian Sync. If your vault folder is shared or public, it is recommended that you turn this setting off.`
|
|
).addToggle(
|
|
(text2) => text2.setValue(this.plugin.settings.useFsCache).onChange((value) => __async(this, null, function* () {
|
|
try {
|
|
const newCache = value ? yield new FsCache(this.app).init() : yield new LocalStorageCache(this.app).init();
|
|
yield newCache.copy(this.plugin.$cache);
|
|
yield this.plugin.$cache.$deleteAllData();
|
|
this.plugin.$cache = newCache;
|
|
} catch (e) {
|
|
new import_obsidian2.Notice(
|
|
"Could not change cache type. Please report a bug."
|
|
);
|
|
return;
|
|
}
|
|
this.plugin.settings.useFsCache = value;
|
|
yield this.plugin.saveSettings();
|
|
}))
|
|
);
|
|
this.selfHostSettings = containerEl.createDiv();
|
|
this.selfHostSettings.createEl("h2", { text: "Self-hosting options" });
|
|
new import_obsidian2.Setting(this.selfHostSettings).setName("Server URL").setDesc(
|
|
"Server URL hosting the encrypted notes. For more information about self-hosting, see https://github.com/mcndt/noteshare.space#deployment"
|
|
).addText((text2) => {
|
|
this.selfHostedUrl = text2;
|
|
text2.setPlaceholder("enter URL").setValue(this.plugin.settings.serverUrl).onChange((value) => __async(this, null, function* () {
|
|
this.plugin.settings.serverUrl = value;
|
|
yield this.plugin.saveSettings();
|
|
}));
|
|
});
|
|
this.showSelfhostedSettings(this.plugin.settings.selfHosted);
|
|
containerEl.createEl("h2", { text: "Sharing options" });
|
|
new import_obsidian2.Setting(containerEl).setName("Share filename as note title").setDesc(
|
|
`Use the filename as the title of the note (like "Show inline title" in Obsidian's appearance settings). If unchecked, the title will be the first heading in the note.`
|
|
).addToggle(
|
|
(text2) => text2.setValue(this.plugin.settings.shareFilenameAsTitle).onChange((value) => __async(this, null, function* () {
|
|
this.plugin.settings.shareFilenameAsTitle = value;
|
|
yield this.plugin.saveSettings();
|
|
}))
|
|
);
|
|
containerEl.createEl("h2", { text: "Frontmatter options" });
|
|
new import_obsidian2.Setting(containerEl).setName("Use frontmatter").setDesc(
|
|
"Use frontmatter to store the QuickShare URL and share date after sharing."
|
|
).addToggle(
|
|
(text2) => text2.setValue(this.plugin.settings.useFrontmatter).onChange((value) => __async(this, null, function* () {
|
|
this.plugin.settings.useFrontmatter = value;
|
|
yield this.plugin.saveSettings();
|
|
this.showFrontmatterSettings(
|
|
this.plugin.settings.useFrontmatter
|
|
);
|
|
}))
|
|
);
|
|
this.frontmatterSettings = containerEl.createDiv();
|
|
new import_obsidian2.Setting(this.frontmatterSettings).setName("Frontmatter date format").setDesc(
|
|
"See https://momentjs.com/docs/#/displaying/format/ for formatting options."
|
|
).addMomentFormat(
|
|
(text2) => text2.setDefaultFormat(DEFAULT_SETTINGS.frontmatterDateFormat).setValue(this.plugin.settings.frontmatterDateFormat).onChange((value) => __async(this, null, function* () {
|
|
this.plugin.settings.frontmatterDateFormat = value;
|
|
yield this.plugin.saveSettings();
|
|
}))
|
|
);
|
|
this.showFrontmatterSettings(this.plugin.settings.useFrontmatter);
|
|
}
|
|
showSelfhostedSettings(show) {
|
|
this.selfHostSettings.hidden = !show;
|
|
}
|
|
showFrontmatterSettings(show) {
|
|
this.frontmatterSettings.hidden = !show;
|
|
}
|
|
};
|
|
|
|
// src/ui/SharedNoteSuccessModal.ts
|
|
var import_obsidian3 = require("obsidian");
|
|
|
|
// src/ui/SharedNoteSuccessComponent.svelte
|
|
var import_moment2 = __toESM(require_moment());
|
|
function add_css(target) {
|
|
append_styles(target, "svelte-1ihru9b", ".share-plugin-modal-container.svelte-1ihru9b{max-width:560px}#copytext.svelte-1ihru9b{width:100%}#url.svelte-1ihru9b{width:100%;display:flex;gap:0.5em}#url-input.svelte-1ihru9b{flex-grow:1;text-decoration-line:underline;cursor:pointer !important}.url-button.svelte-1ihru9b{margin:0px;width:5em}#subtext.svelte-1ihru9b{margin:0.5em 1px;color:var(--text-muted);font-size:0.9em}");
|
|
}
|
|
function create_fragment(ctx) {
|
|
let div1;
|
|
let p0;
|
|
let t1;
|
|
let div0;
|
|
let input;
|
|
let t2;
|
|
let button0;
|
|
let t3;
|
|
let t4;
|
|
let button1;
|
|
let t6;
|
|
let p1;
|
|
let t7;
|
|
let t8_value = ctx[1].diff((0, import_moment2.default)(), "days") + 1 + "";
|
|
let t8;
|
|
let t9;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
div1 = element("div");
|
|
p0 = element("p");
|
|
p0.textContent = "Your note has been encrypted and stored in the cloud. Only people with\n this share link can decrypt and read this file.";
|
|
t1 = space();
|
|
div0 = element("div");
|
|
input = element("input");
|
|
t2 = space();
|
|
button0 = element("button");
|
|
t3 = text(ctx[2]);
|
|
t4 = space();
|
|
button1 = element("button");
|
|
button1.textContent = "Open";
|
|
t6 = space();
|
|
p1 = element("p");
|
|
t7 = text("\u{1F510} End-to-end encrypted \u2022 Expires in ");
|
|
t8 = text(t8_value);
|
|
t9 = text("\n days");
|
|
attr(p0, "id", "copytext");
|
|
attr(p0, "class", "svelte-1ihru9b");
|
|
input.disabled = true;
|
|
attr(input, "id", "url-input");
|
|
attr(input, "type", "text");
|
|
attr(input, "class", "svelte-1ihru9b");
|
|
attr(button0, "class", "url-button svelte-1ihru9b");
|
|
attr(button0, "aria-label", "Copy link to clipboard");
|
|
attr(button1, "class", "url-button svelte-1ihru9b");
|
|
attr(button1, "aria-label", "Copy link to clipboard");
|
|
attr(div0, "id", "url");
|
|
attr(div0, "class", "svelte-1ihru9b");
|
|
attr(p1, "id", "subtext");
|
|
attr(p1, "class", "svelte-1ihru9b");
|
|
attr(div1, "class", "share-plugin-modal-container svelte-1ihru9b");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, p0);
|
|
append(div1, t1);
|
|
append(div1, div0);
|
|
append(div0, input);
|
|
set_input_value(input, ctx[0]);
|
|
append(div0, t2);
|
|
append(div0, button0);
|
|
append(button0, t3);
|
|
append(div0, t4);
|
|
append(div0, button1);
|
|
append(div1, t6);
|
|
append(div1, p1);
|
|
append(p1, t7);
|
|
append(p1, t8);
|
|
append(p1, t9);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(input, "input", ctx[5]),
|
|
listen(button0, "click", ctx[3]),
|
|
listen(button1, "click", ctx[4])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 1 && input.value !== ctx2[0]) {
|
|
set_input_value(input, ctx2[0]);
|
|
}
|
|
if (dirty & 4)
|
|
set_data(t3, ctx2[2]);
|
|
if (dirty & 2 && t8_value !== (t8_value = ctx2[1].diff((0, import_moment2.default)(), "days") + 1 + ""))
|
|
set_data(t8, t8_value);
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div1);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function instance($$self, $$props, $$invalidate) {
|
|
let { url } = $$props;
|
|
let { expireTime } = $$props;
|
|
let buttonText = "Copy";
|
|
let buttonTextTimeout;
|
|
function onCopy() {
|
|
clearTimeout(buttonTextTimeout);
|
|
navigator.clipboard.writeText(url);
|
|
$$invalidate(2, buttonText = "Copied");
|
|
buttonTextTimeout = setTimeout(
|
|
() => {
|
|
$$invalidate(2, buttonText = "Copy");
|
|
},
|
|
1500
|
|
);
|
|
}
|
|
function onOpen2() {
|
|
window.open(url, "_blank");
|
|
}
|
|
function input_input_handler() {
|
|
url = this.value;
|
|
$$invalidate(0, url);
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("url" in $$props2)
|
|
$$invalidate(0, url = $$props2.url);
|
|
if ("expireTime" in $$props2)
|
|
$$invalidate(1, expireTime = $$props2.expireTime);
|
|
};
|
|
return [url, expireTime, buttonText, onCopy, onOpen2, input_input_handler];
|
|
}
|
|
var SharedNoteSuccessComponent = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance, create_fragment, safe_not_equal, { url: 0, expireTime: 1 }, add_css);
|
|
}
|
|
};
|
|
var SharedNoteSuccessComponent_default = SharedNoteSuccessComponent;
|
|
|
|
// src/ui/SharedNoteSuccessModal.ts
|
|
var SharedNoteSuccessModal = class extends import_obsidian3.Modal {
|
|
constructor(plugin, url, expire_time) {
|
|
super(plugin.app);
|
|
this.url = url;
|
|
this.expire_time = expire_time;
|
|
this.render();
|
|
}
|
|
render() {
|
|
this.titleEl.innerText = "Shared note";
|
|
}
|
|
onOpen() {
|
|
return __async(this, null, function* () {
|
|
this.component = new SharedNoteSuccessComponent_default({
|
|
target: this.contentEl,
|
|
props: {
|
|
url: this.url,
|
|
expireTime: this.expire_time
|
|
}
|
|
});
|
|
});
|
|
}
|
|
onClose() {
|
|
return __async(this, null, function* () {
|
|
this.component.$destroy();
|
|
});
|
|
}
|
|
};
|
|
|
|
// src/obsidian/Frontmatter.ts
|
|
var keyTypetoFrontmatterKey = {
|
|
url: "quickshare-url",
|
|
datetime: "quickshare-date"
|
|
};
|
|
function _getFrontmatterKey(file, key, app2) {
|
|
const fmCache = app2.metadataCache.getFileCache(file).frontmatter;
|
|
return (fmCache == null ? void 0 : fmCache[keyTypetoFrontmatterKey[key]]) || void 0;
|
|
}
|
|
function _setFrontmatterKey(file, key, value, content) {
|
|
if (_getFrontmatterKey(file, key, app) === value) {
|
|
console.log("returning");
|
|
return;
|
|
}
|
|
if (_getFrontmatterKey(file, key, app) !== void 0) {
|
|
content = content.replace(
|
|
new RegExp(`^(${keyTypetoFrontmatterKey[key]}):\\s*(.*)$`, "m"),
|
|
`${keyTypetoFrontmatterKey[key]}: ${value}`
|
|
);
|
|
} else {
|
|
if (content.match(/^---/)) {
|
|
content = content.replace(
|
|
/^---/,
|
|
`---
|
|
${keyTypetoFrontmatterKey[key]}: ${value}`
|
|
);
|
|
} else {
|
|
content = `---
|
|
${keyTypetoFrontmatterKey[key]}: ${value}
|
|
---
|
|
${content}`;
|
|
}
|
|
}
|
|
return content;
|
|
}
|
|
function _setFrontmatterKeys(file, records, app2) {
|
|
return __async(this, null, function* () {
|
|
let content = yield app2.vault.read(file);
|
|
for (const [key, value] of Object.entries(records)) {
|
|
if (_getFrontmatterKey(file, key, app2) !== value) {
|
|
content = _setFrontmatterKey(
|
|
file,
|
|
key,
|
|
value,
|
|
content
|
|
);
|
|
}
|
|
}
|
|
yield app2.vault.modify(file, content);
|
|
});
|
|
}
|
|
function useFrontmatterHelper(app2) {
|
|
const getFrontmatterKey = (file, key) => _getFrontmatterKey(file, key, app2);
|
|
const setFrontmatterKeys = (file, records) => _setFrontmatterKeys(file, records, app2);
|
|
return {
|
|
getFrontmatterKey,
|
|
setFrontmatterKeys
|
|
};
|
|
}
|
|
|
|
// main.ts
|
|
var import_moment4 = __toESM(require_moment());
|
|
|
|
// src/ui/QuickShareSideView.ts
|
|
var import_obsidian6 = require("obsidian");
|
|
|
|
// src/ui/QuickShareSideView.svelte
|
|
var import_moment3 = __toESM(require_moment());
|
|
var import_obsidian5 = require("obsidian");
|
|
|
|
// src/lib/obsidian-svelte/useIcon.ts
|
|
var import_obsidian4 = require("obsidian");
|
|
function useIcon(node, name) {
|
|
(0, import_obsidian4.setIcon)(node, name);
|
|
return {
|
|
update(name2) {
|
|
(0, import_obsidian4.setIcon)(node, name2);
|
|
}
|
|
};
|
|
}
|
|
|
|
// src/lib/obsidian-svelte/IconButton.svelte
|
|
function add_css2(target) {
|
|
append_styles(target, "svelte-r9r5oc", ".nopadding.svelte-r9r5oc{padding:0}.icon-xs.svelte-r9r5oc{--icon-size:var(--icon-xs);--icon-stroke:var(--icon-xs-stroke-width)}.icon-sm.svelte-r9r5oc{--icon-size:var(--icon-s);--icon-stroke:var(--icon-s-stroke-width)}.icon-md.svelte-r9r5oc{--icon-size:var(--icon-m);--icon-stroke:var(--icon-m-stroke-width)}.icon-lg.svelte-r9r5oc{--icon-size:var(--icon-l);--icon-stroke:var(--icon-l-stroke-width)}");
|
|
}
|
|
function create_fragment2(ctx) {
|
|
let div;
|
|
let useIcon_action;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
attr(div, "class", "clickable-icon svelte-r9r5oc");
|
|
attr(div, "aria-label", ctx[3]);
|
|
attr(div, "disabled", ctx[5]);
|
|
toggle_class(div, "nopadding", ctx[4]);
|
|
toggle_class(div, "is-active", ctx[2]);
|
|
toggle_class(div, "icon-xs", ctx[1] === "xs");
|
|
toggle_class(div, "icon-sm", ctx[1] === "sm");
|
|
toggle_class(div, "icon-md", ctx[1] === "md");
|
|
toggle_class(div, "icon-lg", ctx[1] === "lg");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if (!mounted) {
|
|
dispose = [
|
|
action_destroyer(useIcon_action = useIcon.call(null, div, ctx[0])),
|
|
listen(div, "click", ctx[6]),
|
|
listen(div, "keypress", ctx[7])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 8) {
|
|
attr(div, "aria-label", ctx2[3]);
|
|
}
|
|
if (dirty & 32) {
|
|
attr(div, "disabled", ctx2[5]);
|
|
}
|
|
if (useIcon_action && is_function(useIcon_action.update) && dirty & 1)
|
|
useIcon_action.update.call(null, ctx2[0]);
|
|
if (dirty & 16) {
|
|
toggle_class(div, "nopadding", ctx2[4]);
|
|
}
|
|
if (dirty & 4) {
|
|
toggle_class(div, "is-active", ctx2[2]);
|
|
}
|
|
if (dirty & 2) {
|
|
toggle_class(div, "icon-xs", ctx2[1] === "xs");
|
|
}
|
|
if (dirty & 2) {
|
|
toggle_class(div, "icon-sm", ctx2[1] === "sm");
|
|
}
|
|
if (dirty & 2) {
|
|
toggle_class(div, "icon-md", ctx2[1] === "md");
|
|
}
|
|
if (dirty & 2) {
|
|
toggle_class(div, "icon-lg", ctx2[1] === "lg");
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function instance2($$self, $$props, $$invalidate) {
|
|
let { icon } = $$props;
|
|
let { size = "md" } = $$props;
|
|
let { active = false } = $$props;
|
|
let { tooltip = "" } = $$props;
|
|
let { nopadding = false } = $$props;
|
|
let { disabled = false } = $$props;
|
|
function click_handler(event) {
|
|
bubble.call(this, $$self, event);
|
|
}
|
|
function keypress_handler(event) {
|
|
bubble.call(this, $$self, event);
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("icon" in $$props2)
|
|
$$invalidate(0, icon = $$props2.icon);
|
|
if ("size" in $$props2)
|
|
$$invalidate(1, size = $$props2.size);
|
|
if ("active" in $$props2)
|
|
$$invalidate(2, active = $$props2.active);
|
|
if ("tooltip" in $$props2)
|
|
$$invalidate(3, tooltip = $$props2.tooltip);
|
|
if ("nopadding" in $$props2)
|
|
$$invalidate(4, nopadding = $$props2.nopadding);
|
|
if ("disabled" in $$props2)
|
|
$$invalidate(5, disabled = $$props2.disabled);
|
|
};
|
|
return [
|
|
icon,
|
|
size,
|
|
active,
|
|
tooltip,
|
|
nopadding,
|
|
disabled,
|
|
click_handler,
|
|
keypress_handler
|
|
];
|
|
}
|
|
var IconButton = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(
|
|
this,
|
|
options,
|
|
instance2,
|
|
create_fragment2,
|
|
safe_not_equal,
|
|
{
|
|
icon: 0,
|
|
size: 1,
|
|
active: 2,
|
|
tooltip: 3,
|
|
nopadding: 4,
|
|
disabled: 5
|
|
},
|
|
add_css2
|
|
);
|
|
}
|
|
};
|
|
var IconButton_default = IconButton;
|
|
|
|
// src/lib/stores/ActiveMdFile.ts
|
|
var { subscribe: subscribe3, set: set2 } = writable(null);
|
|
function setActiveMdFile(file) {
|
|
set2(file);
|
|
}
|
|
var ActiveMdFile_default = { subscribe: subscribe3 };
|
|
|
|
// src/lib/stores/ActiveCacheFile.ts
|
|
var ActiveCacheFile = derived(
|
|
[ActiveMdFile_default, CacheStore_default],
|
|
([$file, $cache]) => {
|
|
if (!$file)
|
|
return null;
|
|
return {
|
|
file: $file,
|
|
cache: $cache.find((o) => o.fileId === $file.path)
|
|
};
|
|
}
|
|
);
|
|
var ActiveCacheFile_default = ActiveCacheFile;
|
|
|
|
// src/ui/QuickShareSideView.svelte
|
|
function add_css3(target) {
|
|
append_styles(target, "svelte-179mnil", "#current-file.svelte-179mnil.svelte-179mnil{display:flex;flex-direction:row;justify-content:space-between;align-items:center;padding:4px 8px;column-gap:8px;font-size:var(--nav-item-size)}#current-file.svelte-179mnil .content-left.svelte-179mnil{flex:1;min-width:0}#current-file.svelte-179mnil .share-info.svelte-179mnil{display:flex;flex-direction:column}#current-file.svelte-179mnil .share-info--not-shared.svelte-179mnil{color:var(--text-faint)}#current-file.svelte-179mnil .share-info .share-info-sub.svelte-179mnil{color:var(--text-faint);font-size:85%;word-break:break-all;display:inline-block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;vertical-align:top}.divider.svelte-179mnil.svelte-179mnil{border-width:1px;margin:12px 0px 24px}#history.svelte-179mnil.svelte-179mnil{font-weight:var(--nav-item-weight);font-size:var(--nav-item-size)}#history.svelte-179mnil .history-header.svelte-179mnil{color:var(--text-normal);padding:4px 8px;font-weight:var(--font-medium)}#history.svelte-179mnil .history-list.svelte-179mnil{padding:4px 1px 16px}#history.svelte-179mnil .history-list .history-item.svelte-179mnil{padding:4px 8px;border-radius:var(--radius-s);color:var(--nav-item-color)}#history.svelte-179mnil .history-list .history-item .item-row.svelte-179mnil{display:flex;justify-content:space-between;align-items:flex-start}#history.svelte-179mnil .history-list .history-item .item-row .item-description.svelte-179mnil{flex:1}#history.svelte-179mnil .history-list .history-item .item-name.svelte-179mnil{line-height:var(--line-height-tight)}#history.svelte-179mnil .history-list .history-item .item-sub.svelte-179mnil{font-size:85%;color:var(--text-faint)}#history.svelte-179mnil .history-list .history-item .item-deleted-vault.svelte-179mnil{font-size:85%;color:var(--text-error);margin-top:4px}#history.svelte-179mnil .history-list .history-item.svelte-179mnil:hover{background-color:var(--nav-item-background-hover);font-weight:var(--nav-item-weight-hover);color:var(--nav-item-color-hover)}#history.svelte-179mnil .history-list .history-item--expired .item-name.svelte-179mnil{color:var(--text-faint)}#history.svelte-179mnil .history-list .history-item--deleted-server .item-name.svelte-179mnil{color:var(--text-faint)}#history.svelte-179mnil .history-list .history-item--deleted-vault .item-name.svelte-179mnil{color:var(--text-error)}.item-actions.svelte-179mnil.svelte-179mnil{margin-left:4px;display:flex;align-items:center;column-gap:2px}");
|
|
}
|
|
function get_each_context(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[19] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function create_if_block_2(ctx) {
|
|
var _a, _b, _c, _d;
|
|
let div4;
|
|
let div2;
|
|
let div1;
|
|
let div0;
|
|
let t0_value = ctx[7](ctx[0] && ((_a = ctx[2]) == null ? void 0 : _a.cache), { long: true }) + "";
|
|
let t0;
|
|
let t1;
|
|
let show_if_1 = ctx[6]((_b = ctx[2]) == null ? void 0 : _b.cache) && ((_d = (_c = ctx[2]) == null ? void 0 : _c.cache) == null ? void 0 : _d.view_url);
|
|
let div1_class_value;
|
|
let t2;
|
|
let div3;
|
|
let show_if;
|
|
let current_block_type_index;
|
|
let if_block1;
|
|
let t3;
|
|
let hr;
|
|
let current;
|
|
let if_block0 = show_if_1 && create_if_block_4(ctx);
|
|
const if_block_creators = [create_if_block_3, create_else_block];
|
|
const if_blocks = [];
|
|
function select_block_type(ctx2, dirty) {
|
|
var _a2, _b2;
|
|
if (dirty & 4)
|
|
show_if = null;
|
|
if (show_if == null)
|
|
show_if = !!(!((_a2 = ctx2[2]) == null ? void 0 : _a2.cache) || !ctx2[6]((_b2 = ctx2[2]) == null ? void 0 : _b2.cache));
|
|
if (show_if)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
current_block_type_index = select_block_type(ctx, -1);
|
|
if_block1 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
return {
|
|
c() {
|
|
var _a2;
|
|
div4 = element("div");
|
|
div2 = element("div");
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t2 = space();
|
|
div3 = element("div");
|
|
if_block1.c();
|
|
t3 = space();
|
|
hr = element("hr");
|
|
attr(div0, "class", "share-info-top");
|
|
attr(div1, "class", div1_class_value = "share-info " + (!ctx[6]((_a2 = ctx[2]) == null ? void 0 : _a2.cache) && "share-info--not-shared") + " svelte-179mnil");
|
|
attr(div2, "class", "content-left svelte-179mnil");
|
|
attr(div3, "class", "content-right");
|
|
attr(div4, "id", "current-file");
|
|
attr(div4, "class", "svelte-179mnil");
|
|
attr(hr, "class", "divider svelte-179mnil");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div4, anchor);
|
|
append(div4, div2);
|
|
append(div2, div1);
|
|
append(div1, div0);
|
|
append(div0, t0);
|
|
append(div1, t1);
|
|
if (if_block0)
|
|
if_block0.m(div1, null);
|
|
append(div4, t2);
|
|
append(div4, div3);
|
|
if_blocks[current_block_type_index].m(div3, null);
|
|
insert(target, t3, anchor);
|
|
insert(target, hr, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
var _a2, _b2, _c2, _d2, _e;
|
|
if ((!current || dirty & 5) && t0_value !== (t0_value = ctx2[7](ctx2[0] && ((_a2 = ctx2[2]) == null ? void 0 : _a2.cache), { long: true }) + ""))
|
|
set_data(t0, t0_value);
|
|
if (dirty & 4)
|
|
show_if_1 = ctx2[6]((_b2 = ctx2[2]) == null ? void 0 : _b2.cache) && ((_d2 = (_c2 = ctx2[2]) == null ? void 0 : _c2.cache) == null ? void 0 : _d2.view_url);
|
|
if (show_if_1) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx2, dirty);
|
|
} else {
|
|
if_block0 = create_if_block_4(ctx2);
|
|
if_block0.c();
|
|
if_block0.m(div1, null);
|
|
}
|
|
} else if (if_block0) {
|
|
if_block0.d(1);
|
|
if_block0 = null;
|
|
}
|
|
if (!current || dirty & 4 && div1_class_value !== (div1_class_value = "share-info " + (!ctx2[6]((_e = ctx2[2]) == null ? void 0 : _e.cache) && "share-info--not-shared") + " svelte-179mnil")) {
|
|
attr(div1, "class", div1_class_value);
|
|
}
|
|
let previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type(ctx2, dirty);
|
|
if (current_block_type_index === previous_block_index) {
|
|
if_blocks[current_block_type_index].p(ctx2, dirty);
|
|
} else {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
if_block1 = if_blocks[current_block_type_index];
|
|
if (!if_block1) {
|
|
if_block1 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
|
|
if_block1.c();
|
|
} else {
|
|
if_block1.p(ctx2, dirty);
|
|
}
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(div3, null);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block1);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block1);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div4);
|
|
if (if_block0)
|
|
if_block0.d();
|
|
if_blocks[current_block_type_index].d();
|
|
if (detaching)
|
|
detach(t3);
|
|
if (detaching)
|
|
detach(hr);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_4(ctx) {
|
|
var _a;
|
|
let a;
|
|
let t_value = ((_a = ctx[2]) == null ? void 0 : _a.cache.view_url) + "";
|
|
let t;
|
|
let a_href_value;
|
|
return {
|
|
c() {
|
|
var _a2, _b;
|
|
a = element("a");
|
|
t = text(t_value);
|
|
attr(a, "class", "share-info-sub svelte-179mnil");
|
|
attr(a, "href", a_href_value = (_b = (_a2 = ctx[2]) == null ? void 0 : _a2.cache) == null ? void 0 : _b.view_url);
|
|
attr(a, "target", "_blank");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, a, anchor);
|
|
append(a, t);
|
|
},
|
|
p(ctx2, dirty) {
|
|
var _a2, _b, _c;
|
|
if (dirty & 4 && t_value !== (t_value = ((_a2 = ctx2[2]) == null ? void 0 : _a2.cache.view_url) + ""))
|
|
set_data(t, t_value);
|
|
if (dirty & 4 && a_href_value !== (a_href_value = (_c = (_b = ctx2[2]) == null ? void 0 : _b.cache) == null ? void 0 : _c.view_url)) {
|
|
attr(a, "href", a_href_value);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(a);
|
|
}
|
|
};
|
|
}
|
|
function create_else_block(ctx) {
|
|
let div;
|
|
let iconbutton0;
|
|
let t;
|
|
let iconbutton1;
|
|
let current;
|
|
iconbutton0 = new IconButton_default({
|
|
props: {
|
|
icon: "reset",
|
|
size: "xs",
|
|
tooltip: "Share again"
|
|
}
|
|
});
|
|
iconbutton0.$on("click", ctx[13]);
|
|
iconbutton1 = new IconButton_default({
|
|
props: {
|
|
icon: "trash",
|
|
size: "xs",
|
|
tooltip: "Remove access"
|
|
}
|
|
});
|
|
iconbutton1.$on("click", ctx[14]);
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
create_component(iconbutton0.$$.fragment);
|
|
t = space();
|
|
create_component(iconbutton1.$$.fragment);
|
|
attr(div, "class", "item-actions svelte-179mnil");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(iconbutton0, div, null);
|
|
append(div, t);
|
|
mount_component(iconbutton1, div, null);
|
|
current = true;
|
|
},
|
|
p: noop,
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(iconbutton0.$$.fragment, local);
|
|
transition_in(iconbutton1.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(iconbutton0.$$.fragment, local);
|
|
transition_out(iconbutton1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
destroy_component(iconbutton0);
|
|
destroy_component(iconbutton1);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_3(ctx) {
|
|
let button;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
button = element("button");
|
|
button.textContent = "Share";
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, button, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(button, "click", ctx[12]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p: noop,
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(button);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_1(ctx) {
|
|
let span;
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
span.textContent = "(Deleted from vault)";
|
|
attr(span, "class", "deleted-text");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block(ctx) {
|
|
let div;
|
|
let iconbutton0;
|
|
let t;
|
|
let iconbutton1;
|
|
let current;
|
|
function click_handler_4() {
|
|
return ctx[16](ctx[19]);
|
|
}
|
|
iconbutton0 = new IconButton_default({
|
|
props: {
|
|
icon: "open-elsewhere-glyph",
|
|
size: "xs",
|
|
tooltip: "Open in browser"
|
|
}
|
|
});
|
|
iconbutton0.$on("click", click_handler_4);
|
|
function click_handler_5() {
|
|
return ctx[17](ctx[19]);
|
|
}
|
|
iconbutton1 = new IconButton_default({
|
|
props: {
|
|
icon: "trash",
|
|
size: "xs",
|
|
tooltip: "Remove access"
|
|
}
|
|
});
|
|
iconbutton1.$on("click", click_handler_5);
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
create_component(iconbutton0.$$.fragment);
|
|
t = space();
|
|
create_component(iconbutton1.$$.fragment);
|
|
attr(div, "class", "item-actions svelte-179mnil");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(iconbutton0, div, null);
|
|
append(div, t);
|
|
mount_component(iconbutton1, div, null);
|
|
current = true;
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(iconbutton0.$$.fragment, local);
|
|
transition_in(iconbutton1.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(iconbutton0.$$.fragment, local);
|
|
transition_out(iconbutton1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
destroy_component(iconbutton0);
|
|
destroy_component(iconbutton1);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block(ctx) {
|
|
let div4;
|
|
let div3;
|
|
let div2;
|
|
let div0;
|
|
let t0_value = ctx[19].basename + "";
|
|
let t0;
|
|
let t1;
|
|
let show_if_1 = ctx[4](ctx[19]);
|
|
let t2;
|
|
let div1;
|
|
let t3_value = ctx[7](ctx[19]) + "";
|
|
let t3;
|
|
let t4;
|
|
let show_if = !ctx[3](ctx[19]) && !ctx[5](ctx[19]);
|
|
let t5;
|
|
let div4_aria_label_value;
|
|
let div4_class_value;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block0 = show_if_1 && create_if_block_1(ctx);
|
|
function click_handler_3() {
|
|
return ctx[15](ctx[19]);
|
|
}
|
|
let if_block1 = show_if && create_if_block(ctx);
|
|
return {
|
|
c() {
|
|
div4 = element("div");
|
|
div3 = element("div");
|
|
div2 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t2 = space();
|
|
div1 = element("div");
|
|
t3 = text(t3_value);
|
|
t4 = space();
|
|
if (if_block1)
|
|
if_block1.c();
|
|
t5 = space();
|
|
attr(div0, "class", "item-name svelte-179mnil");
|
|
attr(div1, "class", "item-sub svelte-179mnil");
|
|
attr(div2, "class", "item-description svelte-179mnil");
|
|
attr(div3, "class", "item-row svelte-179mnil");
|
|
attr(div4, "aria-label", div4_aria_label_value = !ctx[4](ctx[19]) ? `Click to open note` : void 0);
|
|
attr(div4, "aria-label-position", "left");
|
|
attr(div4, "class", div4_class_value = "history-item " + (ctx[3](ctx[19]) && "history-item--expired") + " " + (ctx[5](ctx[19]) && "history-item--deleted-server") + " " + (ctx[4](ctx[19]) && "history-item--deleted-vault") + " svelte-179mnil");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div4, anchor);
|
|
append(div4, div3);
|
|
append(div3, div2);
|
|
append(div2, div0);
|
|
append(div0, t0);
|
|
append(div0, t1);
|
|
if (if_block0)
|
|
if_block0.m(div0, null);
|
|
append(div2, t2);
|
|
append(div2, div1);
|
|
append(div1, t3);
|
|
append(div3, t4);
|
|
if (if_block1)
|
|
if_block1.m(div3, null);
|
|
append(div4, t5);
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = listen(div2, "click", click_handler_3);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
if ((!current || dirty & 2) && t0_value !== (t0_value = ctx[19].basename + ""))
|
|
set_data(t0, t0_value);
|
|
if (dirty & 2)
|
|
show_if_1 = ctx[4](ctx[19]);
|
|
if (show_if_1) {
|
|
if (if_block0) {
|
|
} else {
|
|
if_block0 = create_if_block_1(ctx);
|
|
if_block0.c();
|
|
if_block0.m(div0, null);
|
|
}
|
|
} else if (if_block0) {
|
|
if_block0.d(1);
|
|
if_block0 = null;
|
|
}
|
|
if ((!current || dirty & 2) && t3_value !== (t3_value = ctx[7](ctx[19]) + ""))
|
|
set_data(t3, t3_value);
|
|
if (dirty & 2)
|
|
show_if = !ctx[3](ctx[19]) && !ctx[5](ctx[19]);
|
|
if (show_if) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx, dirty);
|
|
if (dirty & 2) {
|
|
transition_in(if_block1, 1);
|
|
}
|
|
} else {
|
|
if_block1 = create_if_block(ctx);
|
|
if_block1.c();
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(div3, null);
|
|
}
|
|
} else if (if_block1) {
|
|
group_outros();
|
|
transition_out(if_block1, 1, 1, () => {
|
|
if_block1 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
if (!current || dirty & 2 && div4_aria_label_value !== (div4_aria_label_value = !ctx[4](ctx[19]) ? `Click to open note` : void 0)) {
|
|
attr(div4, "aria-label", div4_aria_label_value);
|
|
}
|
|
if (!current || dirty & 2 && div4_class_value !== (div4_class_value = "history-item " + (ctx[3](ctx[19]) && "history-item--expired") + " " + (ctx[5](ctx[19]) && "history-item--deleted-server") + " " + (ctx[4](ctx[19]) && "history-item--deleted-vault") + " svelte-179mnil")) {
|
|
attr(div4, "class", div4_class_value);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block1);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block1);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div4);
|
|
if (if_block0)
|
|
if_block0.d();
|
|
if (if_block1)
|
|
if_block1.d();
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_fragment3(ctx) {
|
|
var _a;
|
|
let div3;
|
|
let t0;
|
|
let div2;
|
|
let div0;
|
|
let t2;
|
|
let div1;
|
|
let current;
|
|
let if_block = ((_a = ctx[2]) == null ? void 0 : _a.file) && create_if_block_2(ctx);
|
|
let each_value = ctx[1];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
|
|
}
|
|
const out = (i) => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
return {
|
|
c() {
|
|
div3 = element("div");
|
|
if (if_block)
|
|
if_block.c();
|
|
t0 = space();
|
|
div2 = element("div");
|
|
div0 = element("div");
|
|
div0.textContent = "Recently shared";
|
|
t2 = space();
|
|
div1 = element("div");
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(div0, "class", "history-header svelte-179mnil");
|
|
attr(div1, "class", "history-list svelte-179mnil");
|
|
attr(div2, "id", "history");
|
|
attr(div2, "class", "svelte-179mnil");
|
|
attr(div3, "id", "quickshare-pane");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div3, anchor);
|
|
if (if_block)
|
|
if_block.m(div3, null);
|
|
append(div3, t0);
|
|
append(div3, div2);
|
|
append(div2, div0);
|
|
append(div2, t2);
|
|
append(div2, div1);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
current = true;
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
var _a2;
|
|
if ((_a2 = ctx2[2]) == null ? void 0 : _a2.file) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
if (dirty & 4) {
|
|
transition_in(if_block, 1);
|
|
}
|
|
} else {
|
|
if_block = create_if_block_2(ctx2);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(div3, t0);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
if (dirty & 954) {
|
|
each_value = ctx2[1];
|
|
let i;
|
|
for (i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context(ctx2, each_value, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value.length; i < each_blocks.length; i += 1) {
|
|
out(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div3);
|
|
if (if_block)
|
|
if_block.d();
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
function onOpen(url) {
|
|
window.open(url, "_blank");
|
|
}
|
|
function instance3($$self, $$props, $$invalidate) {
|
|
let $PluginStore;
|
|
let $CacheStore;
|
|
let $ActiveCacheFile;
|
|
component_subscribe($$self, PluginStore, ($$value) => $$invalidate(18, $PluginStore = $$value));
|
|
component_subscribe($$self, CacheStore_default, ($$value) => $$invalidate(11, $CacheStore = $$value));
|
|
component_subscribe($$self, ActiveCacheFile_default, ($$value) => $$invalidate(2, $ActiveCacheFile = $$value));
|
|
let data;
|
|
let filteredData;
|
|
function hasExpired(data2) {
|
|
const expiration = (0, import_moment3.default)(data2.expire_datetime);
|
|
return (0, import_moment3.default)().isAfter(expiration);
|
|
}
|
|
function deletedFromVault(data2) {
|
|
return data2.deleted_from_vault;
|
|
}
|
|
function deletedFromServer(data2) {
|
|
return data2.deleted_from_server;
|
|
}
|
|
function isShared(data2) {
|
|
return data2 && !hasExpired(data2) && !deletedFromServer(data2);
|
|
}
|
|
function getSubText(data2, options) {
|
|
var _a;
|
|
if (!data2) {
|
|
return "Not shared";
|
|
}
|
|
if (hasExpired(data2)) {
|
|
return (options === null || options === void 0 ? void 0 : options.long) ? "Note has expired from server" : "Expired";
|
|
}
|
|
if (deletedFromServer(data2)) {
|
|
return (options === null || options === void 0 ? void 0 : options.long) ? "Removed from server" : "Unshared";
|
|
}
|
|
const timeString = (0, import_moment3.default)((_a = data2.updated_datetime) !== null && _a !== void 0 ? _a : data2.shared_datetime).locale("en-US").fromNow(true);
|
|
return data2.updated_datetime ? `Updated ${timeString} ago` : `Shared ${timeString} ago`;
|
|
}
|
|
function onOpenNote(fileId) {
|
|
let leafFound = false;
|
|
$PluginStore.app.workspace.iterateRootLeaves((leaf) => {
|
|
if (leaf.view instanceof import_obsidian5.MarkdownView) {
|
|
const view = leaf.view;
|
|
if (view.file.path === fileId) {
|
|
$PluginStore.app.workspace.setActiveLeaf(leaf);
|
|
leafFound = true;
|
|
}
|
|
}
|
|
});
|
|
if (leafFound) {
|
|
return;
|
|
}
|
|
$PluginStore.app.workspace.openLinkText(fileId, fileId, true);
|
|
}
|
|
function onUnshare(fileId) {
|
|
$PluginStore.deleteNote(fileId);
|
|
}
|
|
function onShare(file) {
|
|
$PluginStore.shareNote(file);
|
|
}
|
|
onMount(() => {
|
|
const timer = window.setInterval(
|
|
() => {
|
|
$$invalidate(0, data = [...$CacheStore]);
|
|
},
|
|
3e4
|
|
);
|
|
$PluginStore.registerInterval(timer);
|
|
return () => {
|
|
clearInterval(timer);
|
|
};
|
|
});
|
|
const click_handler = () => onShare($ActiveCacheFile.file);
|
|
const click_handler_1 = () => onShare($ActiveCacheFile.file);
|
|
const click_handler_2 = () => onUnshare($ActiveCacheFile == null ? void 0 : $ActiveCacheFile.cache.fileId);
|
|
const click_handler_3 = (item) => !deletedFromVault(item) && onOpenNote(item.fileId);
|
|
const click_handler_4 = (item) => onOpen(item.view_url);
|
|
const click_handler_5 = (item) => onUnshare(item.fileId);
|
|
$$self.$$.update = () => {
|
|
if ($$self.$$.dirty & 2048) {
|
|
$:
|
|
$$invalidate(0, data = $CacheStore);
|
|
}
|
|
if ($$self.$$.dirty & 1) {
|
|
$:
|
|
$$invalidate(1, filteredData = data === null || data === void 0 ? void 0 : data.filter((d) => !deletedFromServer(d) && !(deletedFromVault(d) && hasExpired(d))));
|
|
}
|
|
};
|
|
return [
|
|
data,
|
|
filteredData,
|
|
$ActiveCacheFile,
|
|
hasExpired,
|
|
deletedFromVault,
|
|
deletedFromServer,
|
|
isShared,
|
|
getSubText,
|
|
onOpenNote,
|
|
onUnshare,
|
|
onShare,
|
|
$CacheStore,
|
|
click_handler,
|
|
click_handler_1,
|
|
click_handler_2,
|
|
click_handler_3,
|
|
click_handler_4,
|
|
click_handler_5
|
|
];
|
|
}
|
|
var QuickShareSideView = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance3, create_fragment3, safe_not_equal, {}, add_css3);
|
|
}
|
|
};
|
|
var QuickShareSideView_default = QuickShareSideView;
|
|
|
|
// src/ui/QuickShareSideView.ts
|
|
var _QuickShareSideView = class extends import_obsidian6.ItemView {
|
|
constructor(leaf) {
|
|
super(leaf);
|
|
this.navigation = false;
|
|
}
|
|
onOpen() {
|
|
return __async(this, null, function* () {
|
|
this.component = new QuickShareSideView_default({
|
|
target: this.contentEl
|
|
});
|
|
});
|
|
}
|
|
onClose() {
|
|
return __async(this, null, function* () {
|
|
this.component.$destroy();
|
|
});
|
|
}
|
|
getViewType() {
|
|
return _QuickShareSideView.viewType;
|
|
}
|
|
getDisplayText() {
|
|
return "QuickShare";
|
|
}
|
|
getIcon() {
|
|
return "cloud";
|
|
}
|
|
};
|
|
var QuickShareSideView2 = _QuickShareSideView;
|
|
QuickShareSideView2.viewType = "QUICKSHARE_SIDE_VIEW";
|
|
|
|
// main.ts
|
|
var { subscribe: subscribe4, set: setPluginStore } = writable(null);
|
|
var PluginStore = { subscribe: subscribe4 };
|
|
var NoteSharingPlugin = class extends import_obsidian7.Plugin {
|
|
onload() {
|
|
return __async(this, null, function* () {
|
|
setPluginStore(this);
|
|
yield this.loadSettings();
|
|
this.cache = this.settings.useFsCache ? yield new FsCache(this.app).init() : yield new LocalStorageCache(this.app).init();
|
|
this.noteSharingService = new NoteSharingService(
|
|
this.settings.serverUrl,
|
|
this.settings.anonymousUserId,
|
|
this.manifest.version
|
|
);
|
|
this.addSettingTab(new SettingsTab(this.app, this));
|
|
this.addCommands();
|
|
this.fileMenuEvent = this.app.workspace.on(
|
|
"file-menu",
|
|
(menu, file, source) => this.onMenuOpenCallback(menu, file, source)
|
|
);
|
|
this.registerEvent(this.fileMenuEvent);
|
|
this.registerEvent(
|
|
this.app.vault.on("rename", (file, oldPath) => {
|
|
if (!this.cache.has(oldPath)) {
|
|
return;
|
|
}
|
|
this.cache.rename(oldPath, file.path);
|
|
console.log("renamed", file.path);
|
|
})
|
|
);
|
|
this.registerEvent(
|
|
this.app.vault.on("delete", (file) => {
|
|
if (!this.cache.has(file.path)) {
|
|
return;
|
|
}
|
|
this.cache.set(file.path, (data) => __spreadProps(__spreadValues({}, data), {
|
|
deleted_from_vault: true
|
|
}));
|
|
console.log("deleted", file.path);
|
|
})
|
|
);
|
|
this.registerEvent(
|
|
this.app.workspace.on("active-leaf-change", (leaf) => {
|
|
if (leaf.view instanceof import_obsidian7.MarkdownView) {
|
|
setActiveMdFile(leaf.view.file);
|
|
}
|
|
})
|
|
);
|
|
this.registerView(
|
|
QuickShareSideView2.viewType,
|
|
(leaf) => new QuickShareSideView2(leaf)
|
|
);
|
|
this.app.workspace.onLayoutReady(this.initLeaf.bind(this));
|
|
});
|
|
}
|
|
initLeaf() {
|
|
return __async(this, null, function* () {
|
|
if (this.app.workspace.getLeavesOfType(QuickShareSideView2.viewType).length) {
|
|
return;
|
|
}
|
|
yield this.app.workspace.getRightLeaf(false).setViewState({
|
|
type: QuickShareSideView2.viewType,
|
|
active: true
|
|
});
|
|
});
|
|
}
|
|
onunload() {
|
|
}
|
|
loadSettings() {
|
|
return __async(this, null, function* () {
|
|
this.settings = Object.assign(
|
|
{},
|
|
DEFAULT_SETTINGS,
|
|
yield this.loadData()
|
|
);
|
|
yield this.saveSettings();
|
|
});
|
|
}
|
|
saveSettings() {
|
|
return __async(this, null, function* () {
|
|
yield this.saveData(this.settings);
|
|
if (this.noteSharingService) {
|
|
this.noteSharingService.serverUrl = this.settings.serverUrl;
|
|
}
|
|
});
|
|
}
|
|
addCommands() {
|
|
this.addCommand({
|
|
id: "obsidian-quickshare-share-note",
|
|
name: "Create share link",
|
|
checkCallback: (checking) => {
|
|
const activeView = this.app.workspace.getActiveViewOfType(import_obsidian7.MarkdownView);
|
|
if (!activeView)
|
|
return false;
|
|
if (checking)
|
|
return true;
|
|
this.shareNote(activeView.file);
|
|
}
|
|
});
|
|
this.addCommand({
|
|
id: "obsidian-quickshare-delete-note",
|
|
name: "Unshare note",
|
|
checkCallback: (checking) => {
|
|
const activeView = this.app.workspace.getActiveViewOfType(import_obsidian7.MarkdownView);
|
|
if (!activeView)
|
|
return false;
|
|
if (checking && !this.cache.has(activeView.file.path) || this.cache.get(activeView.file.path).deleted_from_server) {
|
|
return false;
|
|
}
|
|
if (checking) {
|
|
return true;
|
|
}
|
|
this.deleteNote(activeView.file.path);
|
|
}
|
|
});
|
|
}
|
|
onMenuOpenCallback(menu, file, source) {
|
|
if (file instanceof import_obsidian7.TFile && file.extension === "md") {
|
|
menu.addItem((item) => {
|
|
item.setIcon("paper-plane-glyph");
|
|
item.setTitle("Create share link");
|
|
item.onClick((evt) => __async(this, null, function* () {
|
|
this.shareNote(file);
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
shareNote(file) {
|
|
return __async(this, null, function* () {
|
|
const { setFrontmatterKeys } = useFrontmatterHelper(this.app);
|
|
const body = yield this.app.vault.read(file);
|
|
const title = this.settings.shareFilenameAsTitle ? file.basename : void 0;
|
|
this.noteSharingService.shareNote(body, { title }).then((res) => {
|
|
if (this.settings.useFrontmatter) {
|
|
const datetime = (0, import_moment4.default)().format(
|
|
this.settings.frontmatterDateFormat || DEFAULT_SETTINGS.frontmatterDateFormat
|
|
);
|
|
setFrontmatterKeys(file, {
|
|
url: `"${res.view_url}"`,
|
|
datetime
|
|
});
|
|
}
|
|
this.cache.set(file.path, {
|
|
shared_datetime: (0, import_moment4.default)().toISOString(),
|
|
updated_datetime: null,
|
|
expire_datetime: res.expire_time.toISOString(),
|
|
view_url: res.view_url,
|
|
secret_token: res.secret_token,
|
|
note_id: res.note_id,
|
|
basename: file.basename
|
|
});
|
|
new SharedNoteSuccessModal(
|
|
this,
|
|
res.view_url,
|
|
res.expire_time
|
|
).open();
|
|
}).catch(this.handleSharingError);
|
|
});
|
|
}
|
|
deleteNote(fileId) {
|
|
return __async(this, null, function* () {
|
|
const { setFrontmatterKeys } = useFrontmatterHelper(this.app);
|
|
const cacheData = this.cache.get(fileId);
|
|
if (!cacheData) {
|
|
return;
|
|
}
|
|
this.noteSharingService.deleteNote(cacheData.note_id, cacheData.secret_token).then(() => {
|
|
this.cache.set(fileId, (data) => __spreadProps(__spreadValues({}, data), {
|
|
deleted_from_server: true
|
|
}));
|
|
new import_obsidian7.Notice(`Unshared note: "${cacheData.basename}"`, 7500);
|
|
console.info("Unshared note: ", fileId);
|
|
const _file = this.app.vault.getMarkdownFiles().find((f) => f.path === fileId);
|
|
if (!_file) {
|
|
return;
|
|
}
|
|
setFrontmatterKeys(_file, {
|
|
url: `"Removed"`,
|
|
datetime: `"N/A"`
|
|
});
|
|
}).catch(this.handleSharingError);
|
|
});
|
|
}
|
|
set $cache(cache) {
|
|
this.cache = cache;
|
|
}
|
|
get $cache() {
|
|
return this.cache;
|
|
}
|
|
handleSharingError(err) {
|
|
console.error(err);
|
|
new import_obsidian7.Notice(err.message, 7500);
|
|
}
|
|
};
|
|
//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
|
|
//! license : MIT
|
|
//! moment.js
|
|
//! momentjs.com
|
|
//! version : 2.29.4
|