date-manip
Version:
A lightweight JavaScript date utility library that provides modularity, high performance, and additional features. It supports various date operations, including date addition and subtraction, formatting, comparison, etc.
957 lines (956 loc) • 28.6 kB
JavaScript
(function(global, factory) {
typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.DateManip = {}));
})(this, function(exports2) {
"use strict";
const MS_IN_SECOND = 1e3;
const MS_IN_MINUTE = 6e4;
const MS_IN_HOUR = 36e5;
const MS_IN_DAY = 864e5;
const rangeOfUnits = [
"time",
"year",
"month",
"date",
"day",
"hour",
"minute",
"second",
"millisecond",
"utcOffset"
];
function addMilliseconds(date, ms) {
date.setTime(+date + ms);
return date;
}
function addDays(date, days) {
return addMilliseconds(date, days * MS_IN_DAY);
}
function addHours(date, hours) {
return addMilliseconds(date, hours * MS_IN_HOUR);
}
function addMinutes(date, minutes) {
return addMilliseconds(date, minutes * MS_IN_MINUTE);
}
function isLeapYear$1(year) {
return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
}
const arr = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
const arr2 = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
function daysOfYear(year) {
return isLeapYear$1(year) ? arr2 : arr;
}
function daysInMonth(date) {
return daysOfYear(date.getFullYear())[date.getMonth()];
}
function addMonths(date, months) {
const expectedMonth = date.getMonth() + months;
const tempMaxDay = daysInMonth(new Date(date.getFullYear(), expectedMonth, 1, 0, 0, 0, 0));
const currentDay = date.getDate();
date.setMonth(expectedMonth, currentDay > tempMaxDay ? tempMaxDay : currentDay);
return date;
}
function addSeconds(date, seconds) {
return addMilliseconds(date, seconds * MS_IN_SECOND);
}
function addYears(date, years) {
return addMonths(date, years * 12);
}
const units = rangeOfUnits.reduce((acc, unit) => {
acc[unit.toUpperCase()] = unit;
return acc;
}, {});
const { DATE: DATE$5, DAY: DAY$6, HOUR: HOUR$7, MILLISECOND: MILLISECOND$3, MINUTE: MINUTE$7, MONTH: MONTH$7, SECOND: SECOND$7, TIME: TIME$1, YEAR: YEAR$7 } = units;
const compatUnits = {};
function mapUnit(key, ...args) {
for (let i = 0; i < arguments.length; i++) {
compatUnits[arguments[i]] = key;
}
}
mapUnit(YEAR$7, "Y", "y", "years");
mapUnit(MONTH$7, "M", "months");
mapUnit(DATE$5, "D", "dates");
mapUnit(DAY$6, "d", "days");
mapUnit(HOUR$7, "h", "hours");
mapUnit(MINUTE$7, "m", "minutes");
mapUnit(SECOND$7, "s", "seconds");
mapUnit(MILLISECOND$3, "ms", "milliseconds");
mapUnit(TIME$1, "t");
function normalizeUnit(u) {
return compatUnits[u];
}
const { DAY: DAY$1$1, HOUR: HOUR$1$1, MINUTE: MINUTE$1$1, MONTH: MONTH$1$1, SECOND: SECOND$1$1, YEAR: YEAR$1$1 } = units;
function addNumber(date, num, unit) {
unit = normalizeUnit(unit);
switch (unit) {
case YEAR$1$1:
return addYears(date, num);
case MONTH$1$1:
return addMonths(date, num);
case DAY$1$1:
return addDays(date, num);
case HOUR$1$1:
return addHours(date, num);
case MINUTE$1$1:
return addMinutes(date, num);
case SECOND$1$1:
return addSeconds(date, num);
default:
return addMilliseconds(date, num);
}
}
const { DAY: DAY$5, HOUR: HOUR$6, MINUTE: MINUTE$6, MONTH: MONTH$6, SECOND: SECOND$6, YEAR: YEAR$6 } = units;
function addObject(date, obj, times) {
let time = 0;
let expectedMonth = 0;
let expectedDay = 0;
Object.entries(obj).forEach(([unit, num]) => {
unit = normalizeUnit(unit);
num *= times;
switch (unit) {
case YEAR$6:
expectedMonth += num * 12;
return;
case MONTH$6:
expectedMonth += date.getMonth() + num;
return;
case DAY$5:
expectedDay = num;
return;
case HOUR$6:
num *= MS_IN_HOUR;
break;
case MINUTE$6:
num *= MS_IN_MINUTE;
break;
case SECOND$6:
num *= MS_IN_SECOND;
break;
}
time += num;
});
if (expectedMonth) {
const tempMaxDay = daysInMonth(new Date(date.getFullYear(), expectedMonth, 1, 0, 0, 0, 0));
const currentDay = date.getDate();
date.setMonth(expectedMonth, (currentDay > tempMaxDay ? tempMaxDay : currentDay) + expectedDay);
}
return addMilliseconds(date, time);
}
function add(date, num, unit) {
return typeof num === "object" && num !== null ? addObject(date, num, 1) : addNumber(date, num, unit);
}
const { YEAR: YEAR$5, MONTH: MONTH$5, DATE: DATE$4, HOUR: HOUR$5, MINUTE: MINUTE$5, SECOND: SECOND$5, MILLISECOND: MILLISECOND$2, UTC_OFFSET: UTC_OFFSET$1 } = units;
function escapeRegex(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
const TOKEN_MAP = {
YYYY: { pattern: "(\\d{1,4})", key: YEAR$5 },
// 年份
// YY: { pattern: '(\\d{1,2})', key: YEAR }, // 年份
MM: { pattern: "(\\d{1,2})", key: MONTH$5 },
// 月份
DD: { pattern: "(\\d{1,2})", key: DATE$4 },
// 日期
HH: { pattern: "(\\d{1,2})", key: HOUR$5 },
// 小时
mm: { pattern: "(\\d{1,2})", key: MINUTE$5 },
// 分钟
ss: { pattern: "(\\d{1,2})", key: SECOND$5 },
// 秒
SSS: { pattern: "(\\d{1,3})", key: MILLISECOND$2 },
// 毫秒
Z: { pattern: "(Z|[+-]\\d{2}(?::?\\d{2})?)", key: UTC_OFFSET$1 }
// 时区
};
const TOKEN_KEYS = Object.keys(TOKEN_MAP).sort((a, b) => b.length - a.length);
const TOKEN_PATTERN = new RegExp(`(${TOKEN_KEYS.join("|")})`, "g");
function compile(formatString) {
const matchedTokens = [];
const pattern2 = escapeRegex(formatString).replace(TOKEN_PATTERN, (m) => {
matchedTokens.push(m);
return TOKEN_MAP[m].pattern;
});
return { pattern: pattern2, tokens: matchedTokens };
}
function dayOfYear(date, val) {
const monthDays = daysOfYear(date.getFullYear());
const currentMonth = date.getMonth();
let dayCount = date.getDate();
for (let i = 0; i < currentMonth; i++) {
dayCount += monthDays[i];
}
if (val === void 0) {
return dayCount;
}
date.setTime(+date + (val - dayCount) * MS_IN_DAY);
return date;
}
function absFloor(v) {
return v < 0 ? Math.ceil(v) || 0 : Math.floor(v);
}
const BASIC_ISO_REGEX = /^\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)?)?$/;
const EXTENDED_ISO_REGEX = /^\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)?)?$/;
const ISO_TIMES_REGEX = [
/(\d\d):(\d\d):(\d\d)\.(\d+)/,
// 'HH:mm:ss.SSSS'
/(\d\d):(\d\d):(\d\d),(\d+)/,
// 'HH:mm:ss,SSSS'
/(\d\d):(\d\d):(\d\d)/,
// 'HH:mm:ss'
/(\d\d):(\d\d)/,
// 'HH:mm'
/(\d\d)(\d\d)(\d\d)\.(\d+)/,
// 'HHmmss.SSSS'
/(\d\d)(\d\d)(\d\d),(\d+)/,
// 'HHmmss,SSSS'
/(\d\d)(\d\d)(\d\d)/,
// 'HHmmss'
/(\d\d)(\d\d)/,
// 'HHmm'
/(\d\d)/
// 'HH'
];
const TZ_REGEX = /(Z)|([+-]\d\d)(?::?(\d\d))?/;
const ISO_DATES_REGEX = [
/(\d{4})-(\d\d)-(\d\d)/,
// 'YYYY-MM-DD'
/(\d{4})-(\d\d)/,
// 'YYYY-MM'
/(\d{4})(\d\d)(\d\d)/,
// 'YYYYMMDD'
/(\d{4})(\d\d)/,
// 'YYYYMM'
/(\d{4})/
// 'YYYY'
];
function autoExtract(input) {
const dateRet = new Array(8);
let matches;
const match = EXTENDED_ISO_REGEX.exec(input) || BASIC_ISO_REGEX.exec(input);
if (match) {
const datesLen = ISO_DATES_REGEX.length;
for (let i = 0; i < datesLen; i++) {
if (matches = ISO_DATES_REGEX[i].exec(match[1])) {
for (let j = 0; j < 3; j++) {
const matched = matches[j + 1];
dateRet[j] = matched ? +matched : 1;
}
if (dateRet[1]) {
dateRet[1] -= 1;
}
break;
}
}
matches = null;
if (match[3]) {
for (let i = 0, timesLen = ISO_TIMES_REGEX.length; i < timesLen; i++) {
if (matches = ISO_TIMES_REGEX[i].exec(match[3])) {
if (matches[4]) {
matches[4] = matches[4].padEnd(3, "00");
}
for (let j = 1, len = matches.length; j < len; j++) {
dateRet[j + 2] = +matches[j];
}
break;
}
}
}
matches = null;
if (match[4]) {
matches = TZ_REGEX.exec(match[4]);
if (matches) {
dateRet[7] = matches[1] ? NaN : +matches[2] * 60 + (matches[3] ? +matches[3] : 0);
}
}
return dateRet;
}
return input;
}
function createDate(y, m, d, h, minute, s, ms) {
let date;
if (y < 100 && y >= 0) {
date = new Date(y + 400, m, d, h, minute, s, ms);
if (isFinite(date.getFullYear())) {
date.setFullYear(y);
}
} else {
date = new Date(y, m, d, h, minute, s, ms);
}
return date;
}
function createUTCDate(y, m, d, h, minute, s, ms) {
let date;
if (y < 100 && y >= 0) {
y += 400;
date = new Date(Date.UTC(y, m, d, h, minute, s, ms));
if (isFinite(date.getUTCFullYear())) {
date.setUTCFullYear(y);
}
} else {
date = new Date(Date.UTC(y, m, d, h, minute, s, ms));
}
return date;
}
function createFromArray(input) {
const utcOffset = input[7];
const currentDate = /* @__PURE__ */ new Date();
const isUTC = Number.isNaN(utcOffset);
const flag = isUTC ? "UTC" : "";
const currentStuffing = [
currentDate[`get${flag}FullYear`](),
currentDate[`get${flag}Month`](),
currentDate[`get${flag}Date`]()
];
let i = 0;
const array = new Array(7);
for (; i < 3 && input[i] == null; ++i) {
array[i] = currentStuffing[i];
}
for (; i < 7; i++) {
array[i] = input[i] == null ? 0 : input[i];
}
let day = array[2];
if (day === 0) {
day = 1;
}
let minute = array[4];
if (!isUTC && typeof utcOffset === "number") {
minute -= utcOffset + currentDate.getTimezoneOffset();
}
return (isUTC ? createUTCDate : createDate)(
array[0],
array[1],
day,
array[3],
minute,
array[5],
array[6]
);
}
function toInteger(val) {
return parseInt(val, 10);
}
function toMonth(val) {
return parseInt(val, 10) - 1;
}
function toMilliseconds(val) {
return parseInt(val.padEnd(3, "0"), 10);
}
function parseTimezone(val) {
if (val === "Z") {
return NaN;
}
const matches = TZ_REGEX.exec(val);
return +matches[2] * 60 + (matches[3] ? +matches[3] : 0);
}
function extractWithFormat(input, format2) {
const { pattern: pattern2, tokens: tokens2 } = compile(format2);
const match = new RegExp(pattern2).exec(input);
if (!match) {
return "";
}
const parts = [];
tokens2.forEach((token, i) => {
const value = match[i + 1];
switch (token) {
case "YYYY":
parts[0] = toInteger(value);
break;
// case 'YY':
// parts[0] = toInteger(value);
// break;
case "MM":
parts[1] = toMonth(value);
break;
case "DD":
parts[2] = toInteger(value);
break;
case "HH":
parts[3] = toInteger(value);
break;
case "mm":
parts[4] = toInteger(value);
break;
case "ss":
parts[5] = toInteger(value);
break;
case "SSS":
parts[6] = toMilliseconds(value);
break;
case "Z":
parts[7] = parseTimezone(value);
break;
}
});
return parts;
}
const { DATE: DATE$3, DAY: DAY$4, HOUR: HOUR$4, MILLISECOND: MILLISECOND$1, MINUTE: MINUTE$4, MONTH: MONTH$4, SECOND: SECOND$4, YEAR: YEAR$4, UTC_OFFSET } = units;
const ASP_NET_JSON_REGEX = /^\/?Date\((-?\d+)/i;
function ensureType(value, checked) {
return checked;
}
function parseObject(obj) {
const array = [];
Object.entries(obj).forEach(([unit, value]) => {
unit = normalizeUnit(unit);
switch (unit) {
case YEAR$4:
array[0] = value;
break;
case MONTH$4:
array[1] = value;
break;
case DATE$3:
case DAY$4:
array[2] = value;
break;
case HOUR$4:
array[3] = value;
break;
case MINUTE$4:
array[4] = value;
break;
case SECOND$4:
array[5] = value;
break;
case MILLISECOND$1:
array[6] = value;
break;
case UTC_OFFSET:
array[7] = value;
break;
}
});
if (array.length === 0) {
return /* @__PURE__ */ new Date();
}
return createFromArray(array);
}
function parseString(input, format2) {
const extracted = typeof format2 === "string" && format2 ? extractWithFormat(input, format2) : autoExtract(input);
if (Array.isArray(extracted)) {
return createFromArray(extracted);
}
const matched = ASP_NET_JSON_REGEX.exec(input);
return new Date(matched !== null ? +matched[1] : Date.parse(extracted));
}
function parse$1(input, format2) {
let ret;
const whatType = typeof input;
if (ensureType(input, whatType === "string")) {
ret = parseString(input, format2);
} else if (Array.isArray(input)) {
ret = createFromArray(input);
} else if (input instanceof Date) {
ret = new Date(input);
} else if (ensureType(input, whatType === "object" && input !== null)) {
if (input.isValid && input.isValid()) {
ret = /* @__PURE__ */ new Date(+input);
} else {
ret = parseObject(input);
}
} else if (ensureType(input, whatType === "number")) {
ret = new Date(input);
} else if (ensureType(input, whatType === "undefined")) {
ret = format2 ? /* @__PURE__ */ new Date(NaN) : /* @__PURE__ */ new Date();
} else {
ret = new Date(Date.parse(input));
}
return ret;
}
function diffInDays(date, input, asFloat) {
const parsed = parse$1(input);
const output = (+date - +parsed) / MS_IN_DAY;
return asFloat ? output : absFloor(output);
}
function diffInHours(date, input, asFloat) {
const parsed = parse$1(input);
const output = (+date - +parsed) / MS_IN_HOUR;
return asFloat ? output : absFloor(output);
}
function diffInMilliseconds(date, input, asFloat) {
const parsed = parse$1(input);
const output = +date - +parsed;
return asFloat ? output : absFloor(output);
}
function diffInMinutes(date, input, asFloat) {
const parsed = parse$1(input);
const output = (+date - +parsed) / MS_IN_MINUTE;
return asFloat ? output : absFloor(output);
}
function monthDiff(a, b) {
const aTime = +a;
const bTime = +b;
if (aTime < bTime) {
return -monthDiff(b, a);
}
const wholeMonthDiff = (b.getFullYear() - a.getFullYear()) * 12 + (b.getMonth() - a.getMonth());
const anchor = +addMonths(new Date(aTime), wholeMonthDiff);
let anchor2;
let adjust;
if (bTime < anchor) {
anchor2 = +addMonths(new Date(aTime), wholeMonthDiff - 1);
adjust = (bTime - anchor) / (anchor - anchor2);
} else {
anchor2 = +addMonths(new Date(aTime), wholeMonthDiff + 1);
adjust = (bTime - anchor) / (anchor2 - anchor);
}
return -(wholeMonthDiff + adjust) || 0;
}
function diffInMonths(date, input, asFloat) {
const parsed = parse$1(input);
const output = monthDiff(date, parsed);
return asFloat ? output : absFloor(output);
}
function diffInSeconds(date, input, asFloat) {
const parsed = parse$1(input);
const output = (+date - +parsed) / MS_IN_SECOND;
return asFloat ? output : absFloor(output);
}
function diffInYears(date, input, asFloat) {
const parsed = parse$1(input);
const output = monthDiff(date, parsed) / 12;
return asFloat ? output : absFloor(output);
}
const {
DAY: DAY$3,
HOUR: HOUR$3,
MINUTE: MINUTE$3,
MONTH: MONTH$3,
SECOND: SECOND$3,
YEAR: YEAR$3
} = units;
function diff(date, input, unit, asFloat) {
unit = normalizeUnit(unit);
switch (unit) {
case YEAR$3:
return diffInYears(date, input, asFloat);
case MONTH$3:
return diffInMonths(date, input, asFloat);
// case DATE:
case DAY$3:
return diffInDays(date, input, asFloat);
case HOUR$3:
return diffInHours(date, input, asFloat);
case MINUTE$3:
return diffInMinutes(date, input, asFloat);
case SECOND$3:
return diffInSeconds(date, input, asFloat);
default:
return diffInMilliseconds(date, input, asFloat);
}
}
function startOfDate(date, y, m, d) {
return +new Date(
y || date.getFullYear(),
m == null ? date.getMonth() : m,
d || date.getDate()
);
}
function startOfTime(date, ms) {
const input = +date;
return input - input % ms;
}
const { DATE: DATE$2, DAY: DAY$2, HOUR: HOUR$2, MINUTE: MINUTE$2, MONTH: MONTH$2, SECOND: SECOND$2, YEAR: YEAR$2 } = units;
function endOf(date, unit) {
unit = normalizeUnit(unit);
let time = 0;
switch (unit) {
case YEAR$2:
time = startOfDate(date, date.getFullYear() + 1, 0, 1) - 1;
break;
case MONTH$2:
time = startOfDate(date, void 0, date.getMonth() + 1, 1) - 1;
break;
case DATE$2:
case DAY$2:
time = startOfDate(date) + MS_IN_DAY - 1;
break;
case HOUR$2:
time = startOfTime(date, MS_IN_HOUR) + MS_IN_HOUR - 1;
break;
case MINUTE$2:
time = startOfTime(date, MS_IN_MINUTE) + MS_IN_MINUTE - 1;
break;
case SECOND$2:
time = startOfTime(date, MS_IN_SECOND) + MS_IN_SECOND - 1;
break;
}
time && date.setTime(time);
return date;
}
function padLeft(val, len) {
return String(val).padStart(len || 2, "0");
}
function dateTimeFormat(date, opts) {
return new Intl.DateTimeFormat("en-US", opts).format(date);
}
function getOrdinalSuffix(day) {
if (day > 3 && day < 21) {
return "th";
}
switch (day % 10) {
case 1:
return "st";
case 2:
return "nd";
case 3:
return "rd";
default:
return "th";
}
}
function timezone(date, together) {
let offset = date.getTimezoneOffset();
let prefix;
if (offset <= 0) {
prefix = "+";
offset = Math.abs(offset);
} else {
prefix = "-";
}
return `${prefix}${padLeft(Math.floor(offset / 60))}${together ? "" : ":"}${padLeft(Math.floor(offset % 60))}`;
}
const FORMAT_MAP = {
// 年份
yyyy: (d) => d.getFullYear(),
YYYY: (d) => d.getFullYear(),
YY: (d) => padLeft(d.getFullYear() % 100),
// 月份
MMMM: (d) => dateTimeFormat(d, { month: "long" }),
MMM: (d) => dateTimeFormat(d, { month: "short" }),
MM: (d) => padLeft(d.getMonth() + 1),
M: (d) => d.getMonth() + 1,
// 日期
DD: (d) => padLeft(d.getDate()),
D: (d) => d.getDate(),
Do: (d) => {
const day = d.getDate();
return String(day) + getOrdinalSuffix(day);
},
// 星期
dddd: (d) => dateTimeFormat(d, { weekday: "long" }),
ddd: (d) => dateTimeFormat(d, { weekday: "short" }),
dd: (d) => dateTimeFormat(d, { weekday: "narrow" }),
// 时间
HH: (d) => padLeft(d.getHours()),
H: (d) => d.getHours(),
hh: (d) => padLeft(d.getHours() % 12 || 12),
h: (d) => d.getHours() % 12 || 12,
mm: (d) => padLeft(d.getMinutes()),
m: (d) => d.getMinutes(),
ss: (d) => padLeft(d.getSeconds()),
s: (d) => d.getSeconds(),
SSS: (d) => padLeft(d.getMilliseconds(), 3),
// 其他
A: (d) => d.getHours() >= 12 ? "PM" : "AM",
a: (d) => d.getHours() >= 12 ? "pm" : "am",
Z: (d) => timezone(d),
ZZ: (d) => timezone(d, true)
};
const tokens = Object.keys(FORMAT_MAP).sort((a, b) => b.length - a.length).join("|");
const pattern = new RegExp(
`${tokens}|\\[([^\\]]*)]`,
"g"
);
function format(date, formatString) {
if (!formatString || formatString === "ISO") {
return date.toISOString();
}
return formatString.replace(pattern, (match, escapeContent) => {
if (escapeContent) {
return escapeContent;
}
const formatter = FORMAT_MAP[match];
return formatter ? formatter(date) : match;
});
}
const { DATE: DATE$1, DAY: DAY$1, HOUR: HOUR$1, MILLISECOND, MINUTE: MINUTE$1, MONTH: MONTH$1, SECOND: SECOND$1, TIME, YEAR: YEAR$1 } = units;
const mapping = {
[YEAR$1]: "FullYear",
[MONTH$1]: "Month",
[DATE$1]: "Date",
[DAY$1]: "Day",
[HOUR$1]: "Hours",
[MINUTE$1]: "Minutes",
[SECOND$1]: "Seconds",
[MILLISECOND]: "Milliseconds",
[TIME]: "Time"
};
const setting = {};
const getting = {};
Object.entries(mapping).forEach(([key, method]) => {
if (key === DAY$1) {
setting[key] = function(date, val) {
const day = date.getDay();
if (val !== day) {
date.setTime(+date + (val - day) * MS_IN_DAY);
}
};
} else {
setting[key] = function(date, val) {
date[`set${method}`](val);
};
}
getting[key] = function(date) {
return date[`get${method}`]();
};
});
function get$1(date, unit) {
const fn = getting[normalizeUnit(unit)];
return fn ? fn(date) : 0;
}
function set$1(date, unit, val) {
const fn = setting[normalizeUnit(unit)];
fn && fn(date, val);
return date;
}
const { DATE, DAY, HOUR, MINUTE, MONTH, SECOND, YEAR } = units;
function startOf(date, unit) {
unit = normalizeUnit(unit);
let time = 0;
switch (unit) {
case YEAR:
time = startOfDate(date, void 0, 0, 1);
break;
case MONTH:
time = startOfDate(date, void 0, void 0, 1);
break;
case DATE:
case DAY:
time = startOfDate(date);
break;
case HOUR:
time = startOfTime(date, MS_IN_HOUR);
break;
case MINUTE:
time = startOfTime(date, MS_IN_MINUTE);
break;
case SECOND:
time = startOfTime(date, MS_IN_SECOND);
break;
}
time && date.setTime(time);
return date;
}
function isAfter(date, input, unit) {
unit = normalizeUnit(unit);
const inputMs = +parse$1(input);
if (!unit) {
return +date > inputMs;
}
return +startOf(new Date(date), unit) > inputMs;
}
function isBefore(date, input, unit) {
unit = normalizeUnit(unit);
const inputMs = +parse$1(input);
if (!unit) {
return +date < inputMs;
}
return +endOf(new Date(date), unit) < inputMs;
}
function isBetween(date, from, to, unit, inclusivity) {
inclusivity = inclusivity || "()";
return (inclusivity.startsWith("(") ? isAfter(date, from, unit) : !isBefore(date, from, unit)) && (inclusivity.charAt(1) === ")" ? isBefore(date, to, unit) : !isAfter(date, to, unit));
}
function isLeapYear(date) {
return isLeapYear$1(date.getFullYear());
}
function isSame(date, input, unit) {
unit = normalizeUnit(unit);
const inputMs = +parse$1(input);
if (!unit) {
return +date === inputMs;
}
return +startOf(new Date(date), unit) <= inputMs && inputMs <= +endOf(new Date(date), unit);
}
function isSameOrAfter(date, input, unit) {
return !isBefore(date, input, unit);
}
function isSameOrBefore(date, input, unit) {
return !isAfter(date, input, unit);
}
function isValid(date) {
return date.toString() !== "Invalid Date";
}
function subDays(date, days) {
return addDays(date, -days);
}
function subHours(date, hours) {
return addHours(date, -hours);
}
function subMilliseconds(date, ms) {
return addMilliseconds(date, -ms);
}
function subMinutes(date, minutes) {
return addMinutes(date, -minutes);
}
function subMonths(date, months) {
return addMonths(date, -months);
}
function subSeconds(date, seconds) {
return addSeconds(date, -seconds);
}
function subYears(date, years) {
return addMonths(date, -years * 12);
}
function subtract(date, num, unit) {
return typeof num === "object" && num !== null ? addObject(date, num, -1) : addNumber(date, -num, unit);
}
const fns = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
__proto__: null,
add,
addDays,
addHours,
addMilliseconds,
addMinutes,
addMonths,
addSeconds,
addYears,
compile,
dayOfYear,
daysInMonth,
diff,
diffInDays,
diffInHours,
diffInMilliseconds,
diffInMinutes,
diffInMonths,
diffInSeconds,
diffInYears,
endOf,
format,
get: get$1,
isAfter,
isBefore,
isBetween,
isLeapYear,
isSame,
isSameOrAfter,
isSameOrBefore,
isValid,
parse: parse$1,
set: set$1,
startOf,
subDays,
subHours,
subMilliseconds,
subMinutes,
subMonths,
subSeconds,
subYears,
subtract,
units
}, Symbol.toStringTag, { value: "Module" }));
const { parse, get, set } = fns;
class DateChain {
constructor(input, format2) {
const _input = input instanceof DateChain ? input._d : input;
this._i = input;
this._f = format2;
this._d = parse(_input, format2);
}
clone() {
return new DateChain(this, this._f);
}
toArray() {
const date = this._d;
return [
get(date, "year"),
get(date, "month"),
get(date, "date"),
get(date, "hours"),
get(date, "minutes"),
get(date, "seconds"),
get(date, "milliseconds")
// -date.getTimezoneOffset()
];
}
toDate() {
return new Date(this._d);
}
toISOString() {
return this._d.toISOString();
}
toJSON() {
return this.toISOString();
}
toString() {
return this._d.toString();
}
valueOf() {
return this._d.valueOf();
}
}
const proto = DateChain.prototype;
Object.entries(units).forEach(([, method]) => {
const fn = function(val) {
if (val == null) {
return get(this._d, method);
}
set(this._d, method, val);
return this;
};
proto[method] = fn;
if (method !== "time") {
proto[`${method}s`] = fn;
}
});
const exclude = ["compile", "parse", "units"];
Object.entries(fns).forEach(([name, method]) => {
if (!exclude.includes(name)) {
proto[name] = function() {
const date = this._d;
const ret = method(date, ...arguments);
return ret === date ? this : ret;
};
}
DateChain[name] = method;
});
function chain(input, format2) {
return new DateChain(input, format2);
}
exports2.add = add;
exports2.addDays = addDays;
exports2.addHours = addHours;
exports2.addMilliseconds = addMilliseconds;
exports2.addMinutes = addMinutes;
exports2.addMonths = addMonths;
exports2.addSeconds = addSeconds;
exports2.addYears = addYears;
exports2.chain = chain;
exports2.compile = compile;
exports2.dayOfYear = dayOfYear;
exports2.daysInMonth = daysInMonth;
exports2.diff = diff;
exports2.diffInDays = diffInDays;
exports2.diffInHours = diffInHours;
exports2.diffInMilliseconds = diffInMilliseconds;
exports2.diffInMinutes = diffInMinutes;
exports2.diffInMonths = diffInMonths;
exports2.diffInSeconds = diffInSeconds;
exports2.diffInYears = diffInYears;
exports2.endOf = endOf;
exports2.format = format;
exports2.get = get$1;
exports2.isAfter = isAfter;
exports2.isBefore = isBefore;
exports2.isBetween = isBetween;
exports2.isLeapYear = isLeapYear;
exports2.isSame = isSame;
exports2.isSameOrAfter = isSameOrAfter;
exports2.isSameOrBefore = isSameOrBefore;
exports2.isValid = isValid;
exports2.parse = parse$1;
exports2.set = set$1;
exports2.startOf = startOf;
exports2.subDays = subDays;
exports2.subHours = subHours;
exports2.subMilliseconds = subMilliseconds;
exports2.subMinutes = subMinutes;
exports2.subMonths = subMonths;
exports2.subSeconds = subSeconds;
exports2.subYears = subYears;
exports2.subtract = subtract;
exports2.units = units;
Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
});