(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" });
});