wedux-ui 0.1.0

package/miniprogram_dist/libs/tempo_1_0_0.js

@@ -0,0 +1,1264 @@
+// src/iso8601.ts
+var iso8601Match =
+  /^([0-9]{4})-([0-1][0-9])(?:-([0-3][0-9]))?(?:[T ]?([0-2][0-9])(?::([0-5][0-9]))?(?::([0-5][0-9]))?)?(?:\.[0-9]+)?(Z|(?:\+|\-)[0-9]{2}:?[0-9]{2}(?::?[0-9]{2})?)?$/;
+function iso8601(date2) {
+  const matches = date2.match(iso8601Match);
+  if (matches) {
+    const month = Number(matches[2]);
+    if (month < 1 || month > 12) return false;
+    if (typeof matches[3] !== void 0) {
+      const date3 = Number(matches[3]);
+      if (date3 < 1 || date3 > 31) return false;
+    }
+    if (typeof matches[4] !== void 0) {
+      const hours = Number(matches[4]);
+      if (hours < 0 || hours > 23) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/date.ts
+function normalize(date2) {
+  const matches = date2.match(iso8601Match);
+  if (matches && typeof matches[4] === 'undefined') {
+    return (date2 += 'T00:00:00');
+  }
+  return date2;
+}
+function date(date2) {
+  if (!date2) {
+    date2 = /* @__PURE__ */ new Date();
+  }
+  if (date2 instanceof Date) {
+    return new Date(date2);
+  }
+  date2 = date2.trim();
+  if (iso8601(date2)) {
+    return new Date(normalize(date2));
+  }
+  throw new Error(`Non ISO 8601 compliant date (${date2}).`);
+}
+
+// src/addDay.ts
+function addDay(inputDate, count = 1) {
+  const d = date(inputDate);
+  d.setDate(d.getDate() + count);
+  return d;
+}
+
+// src/monthEnd.ts
+function monthEnd(inputDate) {
+  const d = date(inputDate);
+  d.setDate(1);
+  d.setMonth(d.getMonth() + 1);
+  d.setDate(0);
+  return d;
+}
+
+// src/monthDays.ts
+function monthDays(inputDate) {
+  const d = monthEnd(inputDate);
+  return d.getDate();
+}
+
+// src/addMonth.ts
+function addMonth(inputDate, count = 1, dateOverflow = false) {
+  const d = date(inputDate);
+  const dayOfMonth = d.getDate();
+  if (!dateOverflow) d.setDate(1);
+  d.setMonth(d.getMonth() + count);
+  if (!dateOverflow) {
+    const daysInMonth = monthDays(d);
+    d.setDate(daysInMonth < dayOfMonth ? daysInMonth : dayOfMonth);
+  }
+  return d;
+}
+
+// src/addYear.ts
+function addYear(inputDate, count = 1, dateOverflow = false) {
+  const d = date(inputDate);
+  const dayOfMonth = d.getDate();
+  if (!dateOverflow) d.setDate(1);
+  d.setFullYear(d.getFullYear() + count);
+  if (!dateOverflow) {
+    const daysInMonth = monthDays(d);
+    d.setDate(daysInMonth < dayOfMonth ? daysInMonth : dayOfMonth);
+  }
+  return d;
+}
+
+// src/addHour.ts
+function addHour(inputDate, count = 1) {
+  const d = date(inputDate);
+  d.setHours(d.getHours() + count);
+  return d;
+}
+
+// src/addMinute.ts
+function addMinute(inputDate, count = 1) {
+  const d = date(inputDate);
+  d.setMinutes(d.getMinutes() + count);
+  return d;
+}
+
+// src/addSecond.ts
+function addSecond(inputDate, count = 1) {
+  const d = date(inputDate);
+  d.setSeconds(d.getSeconds() + count);
+  return d;
+}
+
+// src/addMillisecond.ts
+function addMillisecond(inputDate, count = 1) {
+  const d = date(inputDate);
+  d.setMilliseconds(d.getMilliseconds() + count);
+  return d;
+}
+
+// src/common.ts
+var specDate = '1999-03-04T02:05:01.000Z';
+var memoParts = /* @__PURE__ */ new Map();
+var clockAgnostic = [
+  ['YYYY', { year: 'numeric' }],
+  ['YY', { year: '2-digit' }],
+  ['MMMM', { month: 'long' }],
+  ['MMM', { month: 'short' }],
+  ['MM', { month: '2-digit' }],
+  ['M', { month: 'numeric' }],
+  ['DD', { day: '2-digit' }],
+  ['D', { day: 'numeric' }],
+  ['dddd', { weekday: 'long' }],
+  ['ddd', { weekday: 'short' }],
+  ['d', { weekday: 'narrow' }],
+  ['mm', { minute: '2-digit' }],
+  ['m', { minute: 'numeric' }],
+  ['ss', { second: '2-digit' }],
+  ['s', { second: 'numeric' }],
+  ['ZZ', { timeZoneName: 'long' }],
+  ['Z', { timeZoneName: 'short' }],
+];
+var clock24 = [
+  ['HH', { hour: '2-digit' }],
+  ['H', { hour: 'numeric' }],
+];
+var clock12 = [
+  ['hh', { hour: '2-digit' }],
+  ['h', { hour: 'numeric' }],
+  ['a', { dayPeriod: 'narrow' }],
+  ['A', { dayPeriod: 'narrow' }],
+];
+var fractionalSeconds = [['SSS', { fractionalSecond: '3-digit' }]];
+var fixedLength = {
+  DD: 2,
+  HH: 2,
+  MM: 2,
+  YY: 2,
+  YYYY: 4,
+  hh: 2,
+  mm: 2,
+  ss: 2,
+};
+function fixedLengthByOffset(offsetString) {
+  if (/^[+-]\d{2}:\d{2}:\d{2}/.test(offsetString)) {
+    return 9;
+  }
+  if (/^[+-]\d{6}/.test(offsetString)) {
+    return 8;
+  }
+  if (/^[+-]\d{2}:\d{2}/.test(offsetString)) {
+    return 6;
+  }
+  if (/^[+-]\d{4}/.test(offsetString)) {
+    return 5;
+  }
+  throw new Error('Invalid offset format');
+}
+var genitiveTokens = ['MMMM', 'MMM', 'dddd', 'ddd'];
+var tokens = /* @__PURE__ */ new Map(
+  /* @__PURE__ */ [...clockAgnostic, ...clock24, ...clock12, ...fractionalSeconds].map(
+    (format2) => {
+      return [format2[0], format2];
+    },
+  ),
+);
+var dayPeriodMap = /* @__PURE__ */ new Map();
+var styles = ['full', 'long', 'medium', 'short'];
+var two = (n) => String(n).padStart(2, '0');
+var four = (n) => String(n).padStart(2, '0');
+function normStr(part) {
+  if (part.type === 'literal') {
+    part.value = part.value.normalize('NFKC');
+  }
+  return part;
+}
+function fill(inputDate, parts2, locale, genitive = false, offset2 = null) {
+  const partMap = createPartMap(inputDate, parts2, locale, genitive);
+  const d = date(inputDate);
+  function value({ partName, partValue, token }) {
+    if (partName === 'literal') return partValue;
+    const value2 = partMap[partName];
+    if (partName === 'hour' && token === 'H') {
+      return value2.replace(/^0/, '') || '0';
+    }
+    if (['mm', 'ss', 'MM'].includes(token) && value2.length === 1) {
+      return `0${value2}`;
+    }
+    if (partName === 'dayPeriod') {
+      const p = ap(d.getUTCHours() < 12 ? 'am' : 'pm', locale);
+      return token === 'A' ? p.toUpperCase() : p.toLowerCase();
+    }
+    if (partName === 'fractionalSecond') {
+      return String(d.getUTCMilliseconds()).padStart(3, '0');
+    }
+    if (partName === 'timeZoneName') {
+      return offset2 != null ? offset2 : minsToOffset(-1 * d.getTimezoneOffset(), token);
+    }
+    return value2;
+  }
+  return parts2.map((part) => {
+    return {
+      ...part,
+      value: value(part),
+    };
+  });
+}
+function createPartMap(inputDate, parts2, locale, genitive = false) {
+  const d = date(inputDate);
+  const hour12 = parts2.filter((part) => part.hour12);
+  const hour24 = parts2.filter((part) => !part.hour12);
+  const valueParts = [];
+  const genitiveParts = [];
+  function addValues(requestedParts, hour122 = false) {
+    const preciseLocale = `${locale}-u-hc-${hour122 ? 'h12' : 'h23'}`;
+    valueParts.push(
+      ...new Intl.DateTimeFormat(
+        preciseLocale,
+        requestedParts.reduce(
+          (options, part) => {
+            if (part.partName === 'literal') return options;
+            if (genitive && genitiveTokens.includes(part.token)) {
+              genitiveParts.push(part);
+            }
+            return Object.assign(options, part.option);
+          },
+          { timeZone: 'UTC' },
+        ),
+      )
+        .formatToParts(d)
+        .map(normStr),
+    );
+    if (genitive && genitiveParts.length) {
+      for (const part of genitiveParts) {
+        let formattedParts = [];
+        switch (part.token) {
+          case 'MMMM':
+            formattedParts = new Intl.DateTimeFormat(preciseLocale, {
+              dateStyle: 'long',
+              timeZone: 'UTC',
+            })
+              .formatToParts(d)
+              .map(normStr);
+            break;
+          case 'MMM':
+            formattedParts = new Intl.DateTimeFormat(preciseLocale, {
+              dateStyle: 'medium',
+              timeZone: 'UTC',
+            })
+              .formatToParts(d)
+              .map(normStr);
+            break;
+        }
+        const genitiveFormattedPart = formattedParts.find((p) => p.type === part.partName);
+        const index = valueParts.findIndex((p) => p.type === part.partName);
+        if (genitiveFormattedPart && index > -1) {
+          valueParts[index] = genitiveFormattedPart;
+        }
+      }
+    }
+  }
+  if (hour12.length) addValues(hour12, true);
+  if (hour24.length) addValues(hour24);
+  return valueParts.reduce((map, part) => {
+    map[part.type] = part.value;
+    return map;
+  }, {});
+}
+function secsToOffset(totalSecs, token = 'Z') {
+  const sign = totalSecs < 0 ? '-' : '+';
+  const absSecs = Math.abs(totalSecs);
+  const hours = String(Math.floor(absSecs / 3600)).padStart(2, '0');
+  const mins = String(Math.floor((absSecs % 3600) / 60)).padStart(2, '0');
+  const secs = Math.round(absSecs % 60);
+  if (token === 'ZZ') {
+    return secs === 0
+      ? `${sign}${hours}${mins}`
+      : `${sign}${hours}${mins}${String(secs).padStart(2, '0')}`;
+  }
+  return secs === 0
+    ? `${sign}${hours}:${mins}`
+    : `${sign}${hours}:${mins}:${String(secs).padStart(2, '0')}`;
+}
+function minsToOffset(timeDiffInMins, token = 'Z') {
+  return secsToOffset(timeDiffInMins * 60, token);
+}
+function offsetToSecs(offset2, token) {
+  validOffset(offset2, token);
+  const match = offset2.match(/([+-])([0-3][0-9]):?([0-5][0-9])(?::?([0-5][0-9]))?/);
+  const [_, sign, hours, mins, secs = '0'] = match;
+  const totalSecs = Number(hours) * 3600 + Number(mins) * 60 + Number(secs);
+  return sign === '+' ? totalSecs : -totalSecs;
+}
+function validOffset(offset2, token = 'Z') {
+  const valid = ((token2) => {
+    switch (token2) {
+      case 'Z':
+        return /^([+-])[0-3][0-9]:[0-5][0-9](?::[0-5][0-9])?$/.test(offset2);
+      case 'ZZ':
+        return /^([+-])[0-3][0-9][0-5][0-9](?:[0-5][0-9])?$/.test(offset2);
+    }
+  })(token);
+  if (!valid) throw new Error(`Invalid offset: ${offset2}`);
+  return offset2;
+}
+function escapeTokens(str) {
+  return clockAgnostic
+    .concat(clock24)
+    .concat(clock12)
+    .concat(fractionalSeconds)
+    .sort((a, b) => (a[0].length > b[0].length ? 1 : -1))
+    .reduce((target, part) => {
+      return target.replace(part[0], `\\${part[0]}`);
+    }, str);
+}
+function isNumeric(part) {
+  return ['numeric', '2-digit'].includes(part.partValue);
+}
+function validate(parts2) {
+  let lastPart = void 0;
+  for (const part of parts2) {
+    if (part.partName === 'literal' && !isNaN(parseFloat(part.partValue))) {
+      throw new Error(`Numbers in format (${part.partValue}).`);
+    }
+    if (lastPart && lastPart.partName !== 'literal' && part.partName !== 'literal') {
+      if (
+        !(lastPart.token in fixedLength) &&
+        !(part.token in fixedLength) &&
+        !(isNumeric(lastPart) && part.token.toLowerCase() === 'a') &&
+        lastPart.token !== 'SSS'
+      ) {
+        throw new Error(`Illegal adjacent tokens (${lastPart.token}, ${part.token})`);
+      }
+    }
+    lastPart = part;
+  }
+  return parts2;
+}
+function getOffsetFormat(format2) {
+  if (typeof format2 === 'string') {
+    return format2.includes('ZZ') ? 'ZZ' : 'Z';
+  }
+  return 'time' in format2 && format2.time === 'full' ? 'Z' : 'ZZ';
+}
+
+// src/ap.ts
+function ap(ampm, locale) {
+  const l = dayPeriodMap.get(locale);
+  if (l && l[ampm]) return l[ampm];
+  const specimen = new Date(specDate);
+  specimen.setUTCHours(ampm === 'am' ? 5 : 20);
+  const subparts = new Intl.DateTimeFormat(locale, {
+    timeStyle: 'full',
+    timeZone: 'UTC',
+    hour12: true,
+  })
+    .formatToParts(specimen)
+    .map(normStr);
+  const period = subparts.find((part) => part.type === 'dayPeriod');
+  if (period) {
+    const localePeriods = l || {};
+    dayPeriodMap.set(locale, Object.assign(localePeriods, { [ampm]: period.value }));
+    return period.value;
+  }
+  return ampm;
+}
+
+// src/applyOffset.ts
+function applyOffset(dateInput, offset2 = '+00:00') {
+  const d = date(dateInput);
+  const len = fixedLengthByOffset(offset2);
+  const token = len === 5 || len === 8 ? 'ZZ' : 'Z';
+  const timeDiffInSecs = offsetToSecs(offset2, token);
+  return new Date(d.getTime() + timeDiffInSecs * 1e3);
+}
+
+// src/deviceTZ.ts
+function deviceTZ() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+
+// src/offset.ts
+function relativeTime(d, timeZone) {
+  const utcParts = new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    timeZone,
+    hourCycle: 'h23',
+  })
+    .formatToParts(d)
+    .map(normStr);
+  const parts2 = {};
+  utcParts.forEach((part) => {
+    parts2[part.type] = part.value;
+  });
+  return /* @__PURE__ */ new Date(
+    `${parts2.year}-${parts2.month}-${parts2.day}T${parts2.hour}:${parts2.minute}:${parts2.second}Z`,
+  );
+}
+function offset(utcTime, tzA = 'UTC', tzB = 'device', timeZoneToken = 'Z') {
+  var _a;
+  tzB = tzB === 'device' ? ((_a = deviceTZ()) != null ? _a : 'utc') : tzB;
+  const d = date(utcTime);
+  const timeA = relativeTime(d, tzA);
+  const timeB = relativeTime(d, tzB);
+  const timeDiffInSecs = Math.round((timeB.getTime() - timeA.getTime()) / 1e3);
+  return secsToOffset(timeDiffInSecs, timeZoneToken);
+}
+
+// src/tzDate.ts
+function tzDate(inputDate, tz) {
+  const d = date(inputDate);
+  return applyOffset(d, offset(d, tz));
+}
+
+// src/dayOfYear.ts
+function dayOfYear(inputDate) {
+  const d = date(inputDate);
+  return Math.round(
+    (new Date(d.getFullYear(), d.getMonth(), d.getDate(), 0, 0).getTime() -
+      new Date(d.getFullYear(), 0, 0).getTime()) /
+      864e5,
+  );
+}
+
+// src/dayEnd.ts
+function dayEnd(inputDate) {
+  const d = date(inputDate);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+
+// src/dayStart.ts
+function dayStart(inputDate) {
+  const d = date(inputDate);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+// src/parts.ts
+function parts(format2, locale) {
+  if (styles.includes(format2) || typeof format2 === 'object') {
+    return styleParts(format2, locale);
+  }
+  let f = format2;
+  let match = 0;
+  const testPattern = (pattern) => {
+    if (!pattern[2]) pattern[2] = new RegExp(`(.)?(${pattern[0]})`, 'g');
+    if (pattern[2].test(f)) {
+      let didAdd = 0;
+      f = f.replace(pattern[2], (_, prefix, actualMatch) => {
+        if (prefix === '\\') return actualMatch;
+        return `${typeof prefix === 'string' ? prefix : ''}{!${didAdd++ ? match : match++}!}`;
+      });
+      return !!didAdd;
+    }
+    return false;
+  };
+  function validate2(patterns) {
+    const parts3 = patterns.map((part) => part.partName);
+    const deduped = new Set(parts3);
+    if (parts3.length > deduped.size) {
+      throw new Error(`Cannot reuse format tokens.`);
+    }
+    return patterns;
+  }
+  function createPart(hour12, [token, option, exp]) {
+    const partName = Object.keys(option)[0];
+    const partValue = option[partName];
+    return {
+      option,
+      partName,
+      partValue,
+      token,
+      pattern: exp,
+      hour12,
+    };
+  }
+  const found24Patterns = clockAgnostic
+    .filter(testPattern)
+    .concat(clock24.filter(testPattern))
+    .concat(fractionalSeconds.filter(testPattern))
+    .map(createPart.bind(null, false));
+  const parts2 = validate2(
+    found24Patterns.concat(clock12.filter(testPattern).map(createPart.bind(null, true))),
+  );
+  const extractIndex = /^\{!(\d+)!\}$/;
+  return f
+    .split(/(\{!\d+!\})/)
+    .map((match2) => {
+      const hasIndex = match2.match(extractIndex);
+      if (hasIndex) {
+        return parts2[Number(hasIndex[1])];
+      }
+      return {
+        option: { literal: match2 },
+        partName: 'literal',
+        partValue: match2,
+        token: match2,
+        pattern: new RegExp(''),
+        hour12: false,
+      };
+    })
+    .filter((part) => !(part.partName === 'literal' && part.partValue === ''));
+}
+function styleParts(format2, locale) {
+  const options = {
+    timeZone: 'UTC',
+  };
+  if (typeof format2 === 'string') {
+    options.dateStyle = format2;
+  } else {
+    if ('date' in format2) options.dateStyle = format2.date;
+    if ('time' in format2) options.timeStyle = format2.time;
+  }
+  const formatter = new Intl.DateTimeFormat(locale, options);
+  const segments = formatter.formatToParts(new Date(specDate)).map(normStr);
+  const hourTypeSegments = formatter
+    .formatToParts(/* @__PURE__ */ new Date('1999-04-05T23:05:01.000Z'))
+    .map(normStr);
+  const hourPart = hourTypeSegments.find((segment) => segment.type === 'hour');
+  const hourType = hourPart && hourPart.value === '23' ? 24 : 12;
+  return segments
+    .map((part) => {
+      const partName = part.type;
+      const formatPattern = guessPattern(
+        part.type,
+        part.value,
+        locale,
+        part.type === 'hour' ? hourType : void 0,
+        options,
+      );
+      if (formatPattern === void 0) return;
+      const partValue = formatPattern[1][partName];
+      if (!partValue) return;
+      if (!formatPattern[2]) formatPattern[2] = new RegExp(`${formatPattern[0]}`, 'g');
+      return {
+        option: { [partName]: partValue },
+        partName,
+        partValue,
+        token: formatPattern[0],
+        pattern: formatPattern[2],
+        hour12: hourType === 12,
+      };
+    })
+    .filter((part) => !!part);
+}
+function guessPattern(partName, partValue, locale, hour, options) {
+  const l = partValue.length;
+  const n = !isNaN(Number(partValue));
+  let style;
+  switch (partName) {
+    case 'year':
+      return l === 2 ? tokens.get('YY') : tokens.get('YYYY');
+    case 'month':
+      if (n) return l === 1 ? tokens.get('M') : tokens.get('MM');
+      style = partStyle(locale, partName, partValue);
+      switch (style) {
+        case 'long':
+          return tokens.get('MMMM');
+        default:
+          return tokens.get('MMM');
+      }
+    case 'day':
+      return l === 1 ? tokens.get('D') : tokens.get('DD');
+    case 'weekday':
+      style = partStyle(locale, partName, partValue);
+      switch (style) {
+        case 'narrow':
+          return tokens.get('d');
+        case 'short':
+          return tokens.get('ddd');
+        default:
+          return tokens.get('dddd');
+      }
+    case 'hour':
+      if (hour === 12) return l === 1 ? tokens.get('h') : tokens.get('hh');
+      return l === 1 ? tokens.get('H') : tokens.get('HH');
+    case 'minute':
+      return l === 1 ? tokens.get('m') : tokens.get('mm');
+    case 'second':
+      return l === 1 ? tokens.get('s') : tokens.get('ss');
+    case 'dayPeriod':
+      return /^[A-Z]+$/u.test(partValue) ? tokens.get('A') : tokens.get('a');
+    case 'literal':
+      return [partValue, { literal: partValue }, new RegExp('')];
+    case 'timeZoneName':
+      return options.timeStyle === 'full' ? tokens.get('Z') : tokens.get('ZZ');
+    default:
+      return void 0;
+  }
+}
+function partStyle(locale, part, value) {
+  if (!memoParts.has(locale)) {
+    const date2 = new Date(specDate);
+    const weekdays = [3, 8, 9, 7, 6, 4, 3];
+    const parts2 = ['weekday', 'month', 'dayPeriod'];
+    const partStyles = ['long', 'short', 'narrow'];
+    const formats2 = {};
+    for (let i = 0; i < 12; i++) {
+      date2.setMonth(0 + i);
+      if (i in weekdays) date2.setDate(weekdays[i]);
+      date2.setUTCHours(8 + i);
+      for (const style of partStyles) {
+        const segments = new Intl.DateTimeFormat(
+          locale,
+          parts2.reduce((options, part2) => Object.assign(options, { [part2]: style }), {
+            hour12: true,
+            timeZone: 'UTC',
+          }),
+        )
+          .formatToParts(date2)
+          .map(normStr);
+        if (style === 'long' || style === 'short') {
+          const genitiveFormattedParts = new Intl.DateTimeFormat(locale, {
+            dateStyle: style === 'short' ? 'medium' : 'long',
+            timeZone: 'UTC',
+          })
+            .formatToParts(date2)
+            .map(normStr);
+          const genitiveMonth = genitiveFormattedParts.find((part2) => part2.type === 'month');
+          const index = segments.findIndex((part2) => part2.type === 'month');
+          if (index > -1 && genitiveMonth) segments[index] = genitiveMonth;
+        }
+        segments.forEach((part2) => {
+          if (part2.type === 'literal') return;
+          const type = part2.type;
+          formats2[type] = Object.assign(formats2[type] || {}, {
+            [part2.value]: style,
+          });
+        });
+      }
+    }
+    memoParts.set(locale, formats2);
+  }
+  const formats = memoParts.get(locale);
+  return formats ? formats[part][value] : void 0;
+}
+
+// src/removeOffset.ts
+function removeOffset(dateInput, offset2 = '+00:00') {
+  const positive = offset2.slice(0, 1) === '+';
+  return applyOffset(dateInput, offset2.replace(positive ? '+' : '-', positive ? '-' : '+'));
+}
+
+// src/deviceLocale.ts
+function deviceLocale() {
+  return Intl.DateTimeFormat().resolvedOptions().locale;
+}
+
+// src/format.ts
+function format(
+  inputDateOrOptions,
+  format2 = 'long',
+  locale = 'device',
+  genitive = false,
+  partFilter,
+) {
+  let tz, forceOffset;
+  if (typeof inputDateOrOptions === 'object' && !(inputDateOrOptions instanceof Date)) {
+    ({
+      date: inputDateOrOptions,
+      format: format2,
+      locale,
+      genitive,
+      partFilter,
+      tz,
+    } = inputDateOrOptions);
+  }
+  if (format2 === 'ISO8601') return date(inputDateOrOptions).toISOString();
+  if (tz) {
+    forceOffset = offset(inputDateOrOptions, 'utc', tz, getOffsetFormat(format2));
+  }
+  tz != null ? tz : (tz = deviceTZ());
+  if ((tz == null ? void 0 : tz.toLowerCase()) !== 'utc') {
+    inputDateOrOptions = removeOffset(inputDateOrOptions, offset(inputDateOrOptions, tz, 'utc'));
+  }
+  if (!locale || locale === 'device') {
+    locale = deviceLocale();
+  }
+  return fill(
+    inputDateOrOptions,
+    parts(format2, locale).filter(partFilter != null ? partFilter : () => true),
+    locale,
+    genitive,
+    forceOffset,
+  )
+    .map((p) => p.value)
+    .join('');
+}
+
+// src/formatStr.ts
+function formatStr(format2, locale = 'en', escapeLiterals = false, filterParts = () => true) {
+  return parts(format2, locale)
+    .filter(filterParts)
+    .reduce(
+      (f, p) => (f += escapeLiterals && p.partName === 'literal' ? escapeTokens(p.token) : p.token),
+      '',
+    )
+    .normalize('NFKC');
+}
+
+// src/fourDigitYear.ts
+function fourDigitYear(value) {
+  const y = /* @__PURE__ */ new Date().getFullYear();
+  const currentYear = y % 100;
+  const century = Math.floor(y / 100);
+  const parsedYear = Number(value);
+  return (century + (parsedYear > currentYear + 20 ? -1 : 0)) * 100 + parsedYear;
+}
+
+// src/hourEnd.ts
+function hourEnd(inputDate) {
+  const d = date(inputDate);
+  d.setMinutes(59, 59, 999);
+  return d;
+}
+
+// src/hourStart.ts
+function hourStart(inputDate) {
+  const d = date(inputDate);
+  d.setMinutes(0, 0, 0);
+  return d;
+}
+
+// src/minuteEnd.ts
+function minuteEnd(inputDate) {
+  const d = date(inputDate);
+  d.setSeconds(59, 999);
+  return d;
+}
+
+// src/minuteStart.ts
+function minuteStart(inputDate) {
+  const d = date(inputDate);
+  d.setSeconds(0, 0);
+  return d;
+}
+
+// src/monthStart.ts
+function monthStart(inputDate) {
+  const d = date(inputDate);
+  d.setDate(1);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+// src/yearDays.ts
+function yearDays(inputDate) {
+  const d = date(inputDate);
+  return (
+    (new Date(d.getFullYear() + 1, 0, 0).getTime() - new Date(d.getFullYear(), 0, 0).getTime()) /
+    864e5
+  );
+}
+
+// src/nearestDay.ts
+function nearestDay(inputDate, search, constraint = 7) {
+  let increments;
+  let decrements;
+  const d = date(inputDate);
+  switch (constraint) {
+    case 'month':
+      decrements = d.getDate();
+      increments = monthDays(d) - d.getDate();
+      break;
+    case 'week':
+      decrements = d.getDay() + 1;
+      increments = 6 - d.getDay();
+      break;
+    case 'year':
+      const total = yearDays(d);
+      const day = dayOfYear(d);
+      decrements = day;
+      increments = total - day;
+      break;
+    default:
+      increments = decrements = constraint;
+  }
+  for (let i = 0; i <= increments || i < decrements; i++) {
+    if (i <= increments) {
+      const next = addDay(d, i);
+      if (search(next)) return next;
+    }
+    if (i && i <= decrements) {
+      const prev = addDay(d, -i);
+      if (search(prev)) return prev;
+    }
+  }
+  return null;
+}
+
+// src/range.ts
+function range(token, locale = 'en', genitive = false) {
+  const r = (n, c) =>
+    Array(n)
+      .fill('')
+      .map((_, i) => `${c(i)}`);
+  if (token === 'M') return r(12, (i) => i + 1);
+  if (token === 'MM')
+    return r(12, (i) => {
+      const m = i + 1;
+      return m < 10 ? `0${m}` : m;
+    });
+  if (token.startsWith('M'))
+    return range('MM').map((m) => format(`2000-${m}-05`, token, locale, genitive));
+  if (token.startsWith('d'))
+    return r(7, (i) => `0${i + 2}`).map((d) => format(`2022-10-${d}`, token, locale));
+  if (token === 'a') return [ap('am', locale).toLowerCase(), ap('pm', locale).toLowerCase()];
+  if (token === 'A') return [ap('am', locale).toUpperCase(), ap('pm', locale).toUpperCase()];
+  if (token.startsWith('Y')) {
+    const year = /* @__PURE__ */ new Date().getFullYear();
+    return r(120, (i) => i + 1).reduce(
+      (ranges, i) => {
+        if (i !== '120') ranges.push(format(`${year + Number(i)}-06-06`, token, locale));
+        ranges.unshift(format(`${year - Number(i)}-06-06`, token, locale));
+        return ranges;
+      },
+      [format(`${year}-06-06`, token, locale)],
+    );
+  }
+  if (token.startsWith('D')) return r(31, (i) => `${token === 'DD' && i < 9 ? '0' : ''}${i + 1}`);
+  if (token.startsWith('H')) return r(24, (i) => `${token === 'HH' && i < 10 ? '0' : ''}${i}`);
+  if (token.startsWith('h')) return r(12, (i) => `${token === 'hh' && i < 9 ? '0' : ''}${i + 1}`);
+  if (token.startsWith('m') || token.startsWith('s'))
+    return r(60, (i) => `${token.length > 1 && i < 10 ? '0' : ''}${i}`);
+  return [];
+}
+
+// src/parse.ts
+function parse(dateStrOrOptions, format2 = 'ISO8601', locale = 'device') {
+  let partFilter = () => true;
+  let dateStr;
+  let dateOverflow = 'backward';
+  if (typeof dateStrOrOptions === 'object') {
+    ({
+      date: dateStr,
+      format: format2 = 'ISO8601',
+      locale = 'device',
+      dateOverflow = 'backward',
+      partFilter = () => true,
+    } = dateStrOrOptions);
+  } else {
+    dateStr = dateStrOrOptions;
+  }
+  if (!dateStr) throw new Error('parse() requires a date string.');
+  const invalid = () => {
+    throw new Error(`Date (${dateStr}) does not match format (${formatStr(format2, locale)})`);
+  };
+  if (format2 === 'ISO8601') return date(dateStr);
+  const genitive = styles.includes(format2) || typeof format2 === 'object';
+  const formatParts = validate(parts(format2, locale).filter(partFilter));
+  if (!formatParts.length) throw new Error('parse() requires a pattern.');
+  let parsedParts;
+  try {
+    parsedParts = parseParts(dateStr, formatParts);
+  } catch {
+    return invalid();
+  }
+  const now = /* @__PURE__ */ new Date();
+  const parsed = /* @__PURE__ */ new Map([
+    ['YYYY', now.getFullYear()],
+    ['MM', now.getMonth() + 1],
+    ['DD', now.getDate()],
+    ['HH', 0],
+    ['mm', 0],
+    ['ss', 0],
+    ['SSS', 0],
+  ]);
+  let a = null;
+  let offset2 = '';
+  parsedParts.forEach((part) => {
+    if (part.partName === 'literal') return;
+    if (part.token === part.value) return invalid();
+    const v = Number(part.value);
+    if (part.token === 'SSS') {
+      const digits = part.value.padEnd(3, '0').slice(0, 3);
+      parsed.set('SSS', Number(digits));
+    } else if (parsed.has(part.token)) {
+      parsed.set(part.token, v);
+    } else if (part.token === 'YY') {
+      parsed.set('YYYY', fourDigitYear(part.value));
+    } else {
+      const t = part.token;
+      if (t.startsWith('d')) {
+        return;
+      } else if (t === 'D') {
+        parsed.set('DD', v);
+      } else if (t === 'H' || t.startsWith('h')) {
+        parsed.set('HH', v);
+      } else if (t === 'M') {
+        parsed.set('MM', v);
+      } else if (t === 'a' || t === 'A') {
+        a = part.value.toLowerCase() === ap('am', locale).toLowerCase();
+      } else if (t === 'Z' || t === 'ZZ') {
+        offset2 = validOffset(part.value, t);
+      } else {
+        const values = range(t, locale, genitive);
+        const index = values.indexOf(part.value);
+        if (index !== -1) {
+          switch (t) {
+            case 'MMM':
+            case 'MMMM':
+              parsed.set('MM', index + 1);
+              break;
+          }
+        }
+      }
+    }
+  });
+  let hours = parsed.get('HH') || 0;
+  if (a === false) {
+    hours += hours === 12 ? 0 : 12;
+    parsed.set('HH', hours === 24 ? 0 : hours);
+  } else if (a === true && hours === 12) {
+    parsed.set('HH', 0);
+  }
+  parsed.set('MM', (parsed.get('MM') || 1) - 1);
+  let [Y, M, D, h, m, s, ms] = Array.from(parsed.values());
+  const maxDaysInMonth = monthDays(/* @__PURE__ */ new Date(`${four(Y)}-${two(M + 1)}-10`));
+  if (maxDaysInMonth < D && dateOverflow === 'throw')
+    throw new Error(`Invalid date ${four(Y)}-${two(M + 1)}-${two(D)}`);
+  D = dateOverflow === 'backward' ? Math.min(D, maxDaysInMonth) : D;
+  const msStr = String(ms).padStart(3, '0');
+  if (offset2) {
+    const isoStringUtc = `${four(Y)}-${two(M + 1)}-${two(D)}T${two(h)}:${two(m)}:${two(s)}.${msStr}Z`;
+    const d2 = new Date(isoStringUtc);
+    if (!isFinite(+d2)) return invalid();
+    const len = fixedLengthByOffset(offset2);
+    const token = len === 5 || len === 8 ? 'ZZ' : 'Z';
+    const offsetSecs = offsetToSecs(offset2, token);
+    return new Date(d2.getTime() - offsetSecs * 1e3);
+  }
+  const isoString = `${four(Y)}-${two(M + 1)}-${two(D)}T${two(h)}:${two(m)}:${two(s)}.${msStr}`;
+  const d = new Date(isoString);
+  if (isFinite(+d)) return d;
+  return invalid();
+}
+function parseParts(dateStr, formatParts) {
+  let i = 0;
+  const advance = (parts2) => [parts2[i++], parts2[i]];
+  let pos = 0;
+  const parsed = [];
+  let n = void 0;
+  do {
+    const [current, next] = advance(formatParts);
+    n = next;
+    let len = 1;
+    if (current.partName === 'literal') {
+      len = current.partValue.length;
+    } else if (current.partName === 'timeZoneName') {
+      len = fixedLengthByOffset(dateStr.substring(pos));
+    } else if (current.token === 'SSS') {
+      let end = pos;
+      while (end < dateStr.length && /\d/.test(dateStr.charAt(end))) {
+        end++;
+      }
+      len = end - pos;
+    } else if (current.token in fixedLength) {
+      len = fixedLength[current.token];
+    } else if (next) {
+      if (next.partName === 'literal') {
+        len = dateStr.indexOf(next.partValue, pos) - pos;
+        if (len < 0) throw new Error();
+      } else if (next.partName === 'dayPeriod') {
+        for (let i2 = 1; i2 <= 4; i2++) {
+          if (isNaN(Number(dateStr.charAt(pos + i2)))) {
+            len = i2;
+            break;
+          }
+        }
+      } else {
+        const nextChar = dateStr.substring(pos).search(/\d/);
+        if (nextChar !== -1) len = pos + nextChar;
+      }
+    } else {
+      len = dateStr.length;
+    }
+    parsed.push({ ...current, value: dateStr.substring(pos, pos + len) });
+    pos += len;
+  } while (n);
+  return parsed;
+}
+
+// src/sameDay.ts
+function sameDay(inputDateA, inputDateB) {
+  const a = date(inputDateA);
+  const b = date(inputDateB);
+  return (
+    a.getDate() === b.getDate() &&
+    a.getMonth() === b.getMonth() &&
+    a.getFullYear() === b.getFullYear()
+  );
+}
+
+// src/sameSecond.ts
+function sameSecond(inputDateA, inputDateB) {
+  const a = date(inputDateA);
+  const b = date(inputDateB);
+  return a.getSeconds() === b.getSeconds();
+}
+
+// src/sameMillisecond.ts
+function sameMillisecond(inputDateA, inputDateB) {
+  const a = date(inputDateA);
+  const b = date(inputDateB);
+  return a.getMilliseconds() === b.getMilliseconds();
+}
+
+// src/sameMinute.ts
+function sameMinute(inputDateA, inputDateB) {
+  const a = date(inputDateA);
+  const b = date(inputDateB);
+  return a.getMinutes() === b.getMinutes();
+}
+
+// src/sameHour.ts
+function sameHour(inputDateA, inputDateB) {
+  const a = date(inputDateA);
+  const b = date(inputDateB);
+  return a.getHours() === b.getHours();
+}
+
+// src/sameYear.ts
+function sameYear(inputDateA, inputDateB) {
+  const a = date(inputDateA);
+  const b = date(inputDateB);
+  return a.getFullYear() === b.getFullYear();
+}
+
+// src/weekStart.ts
+function weekStart(inputDate, startOfWeekDay = 0) {
+  const d = date(inputDate);
+  let diff = startOfWeekDay - d.getDay();
+  if (diff > 0) diff = diff - 7;
+  d.setDate(d.getDate() + diff);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+// src/weekEnd.ts
+function weekEnd(inputDate, startOfWeekDay = 0) {
+  const d = weekStart(inputDate, startOfWeekDay);
+  d.setDate(d.getDate() + 6);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+
+// src/yearStart.ts
+function yearStart(inputDate) {
+  const d = date(inputDate);
+  d.setMonth(0, 1);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+// src/yearEnd.ts
+function yearEnd(inputDate) {
+  const d = date(inputDate);
+  d.setMonth(11, 31);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+
+// src/isBefore.ts
+function isBefore(inputDate, dateToCompare) {
+  const _date = date(inputDate);
+  const _dateToCompare = date(dateToCompare);
+  return +_date < +_dateToCompare;
+}
+
+// src/isAfter.ts
+function isAfter(inputDate, dateToCompare) {
+  const _date = date(inputDate);
+  const _dateToCompare = date(dateToCompare);
+  return +_date > +_dateToCompare;
+}
+
+// src/isEqual.ts
+function isEqual(dateLeft, dateRight) {
+  const _dateLeft = date(dateLeft);
+  const _dateRight = date(dateRight);
+  return +_dateLeft === +_dateRight;
+}
+
+// src/isPast.ts
+function isPast(inputDate) {
+  return isBefore(inputDate);
+}
+
+// src/isFuture.ts
+function isFuture(inputDate) {
+  return isAfter(inputDate);
+}
+
+// src/diffMilliseconds.ts
+function diffMilliseconds(dateA, dateB) {
+  const left = date(dateA);
+  const right = date(dateB);
+  return +left - +right;
+}
+
+// src/diffRound.ts
+function diffRound(value, method = 'trunc') {
+  const r = Math[method](value);
+  return r == 0 ? 0 : r;
+}
+
+// src/diffSeconds.ts
+function diffSeconds(dateA, dateB, roundingMethod) {
+  return diffRound(
+    // @ts-ignore
+    diffMilliseconds(dateA, dateB) / 1e3,
+    roundingMethod,
+  );
+}
+
+// src/diffMinutes.ts
+function diffMinutes(dateA, dateB, roundingMethod) {
+  return diffRound(
+    //@ts-ignore
+    diffMilliseconds(dateA, dateB) / 6e4,
+    roundingMethod,
+  );
+}
+
+// src/diffHours.ts
+function diffHours(dateA, dateB, roundingMethod) {
+  return diffRound(
+    //@ts-ignore
+    diffMilliseconds(dateA, dateB) / 36e5,
+    // 1000 * 60 * 60
+    roundingMethod,
+  );
+}
+
+// src/diffDays.ts
+function diffDays(dateA, dateB, roundingMethod) {
+  return diffRound(
+    // @ts-ignore
+    diffMilliseconds(dateA, dateB) / 864e5,
+    // hour * 24
+    roundingMethod,
+  );
+}
+
+// src/diffWeeks.ts
+function diffWeeks(dateA, dateB, roundingMethod) {
+  return diffRound(
+    diffMilliseconds(dateA, dateB) / 6048e5,
+    // day * 7
+    roundingMethod,
+  );
+}
+
+// src/diffMonths.ts
+function diffMonths(dateA, dateB) {
+  const l = date(dateA);
+  const r = date(dateB);
+  if (l < r) {
+    const rs = diffMonths(r, l);
+    return rs == 0 ? 0 : -rs;
+  }
+  let months = (l.getFullYear() - r.getFullYear()) * 12 + (l.getMonth() - r.getMonth());
+  const ld = l.getDate();
+  const rd = r.getDate();
+  if (ld < rd) {
+    const lm = monthDays(l);
+    if (!(lm == ld && lm < rd)) {
+      months--;
+    }
+  }
+  return months == 0 ? 0 : months;
+}
+
+// src/diffYears.ts
+function diffYears(dateA, dateB) {
+  const r = Math.trunc(
+    //@ts-ignore
+    diffMonths(dateA, dateB) / 12,
+  );
+  return r == 0 ? 0 : r;
+}
+export {
+  addDay,
+  addHour,
+  addMillisecond,
+  addMinute,
+  addMonth,
+  addSecond,
+  addYear,
+  ap,
+  applyOffset,
+  date,
+  dayEnd,
+  dayOfYear,
+  dayStart,
+  diffDays,
+  diffHours,
+  diffMilliseconds,
+  diffMinutes,
+  diffMonths,
+  diffSeconds,
+  diffWeeks,
+  diffYears,
+  format,
+  formatStr,
+  fourDigitYear,
+  hourEnd,
+  hourStart,
+  isAfter,
+  isBefore,
+  isEqual,
+  isFuture,
+  isPast,
+  iso8601,
+  minuteEnd,
+  minuteStart,
+  monthDays,
+  monthEnd,
+  monthStart,
+  nearestDay,
+  offset,
+  parse,
+  parseParts,
+  parts,
+  range,
+  removeOffset,
+  sameDay,
+  sameHour,
+  sameMillisecond,
+  sameMinute,
+  sameSecond,
+  sameYear,
+  tzDate,
+  weekEnd,
+  weekStart,
+  yearDays,
+  yearEnd,
+  yearStart,
+};