@formkit/tempo 0.1.2 → 1.1.0

package/dist/index.cjs

@@ -18,10 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
+  add: () => add,
   addDay: () => addDay,
   addHour: () => addHour,
+  addMillisecond: () => addMillisecond,
   addMinute: () => addMinute,
   addMonth: () => addMonth,
   addSecond: () => addSecond,
@@ -32,6 +34,7 @@ __export(src_exports, {
   dayEnd: () => dayEnd,
   dayOfYear: () => dayOfYear,
   dayStart: () => dayStart,
+  diff: () => diff,
   diffDays: () => diffDays,
   diffHours: () => diffHours,
   diffMilliseconds: () => diffMilliseconds,
@@ -48,6 +51,8 @@ __export(src_exports, {
   isAfter: () => isAfter,
   isBefore: () => isBefore,
   isEqual: () => isEqual,
+  isFuture: () => isFuture,
+  isPast: () => isPast,
   iso8601: () => iso8601,
   minuteEnd: () => minuteEnd,
   minuteStart: () => minuteStart,
@@ -63,9 +68,17 @@ __export(src_exports, {
   removeOffset: () => removeOffset,
   sameDay: () => sameDay,
   sameHour: () => sameHour,
+  sameMillisecond: () => sameMillisecond,
   sameMinute: () => sameMinute,
   sameSecond: () => sameSecond,
   sameYear: () => sameYear,
+  setDayOfMonth: () => setDayOfMonth,
+  setHour: () => setHour,
+  setMilliseconds: () => setMilliseconds,
+  setMinutes: () => setMinutes,
+  setMonth: () => setMonth,
+  setSeconds: () => setSeconds,
+  setYear: () => setYear,
   tzDate: () => tzDate,
   weekEnd: () => weekEnd,
   weekStart: () => weekStart,
@@ -73,25 +86,22 @@ __export(src_exports, {
   yearEnd: () => yearEnd,
   yearStart: () => yearStart
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // 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})?$/;
+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 (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 (date3 < 1 || date3 > 31) return false;
     }
     if (typeof matches[4] !== void 0) {
       const hours = Number(matches[4]);
-      if (hours < 0 || hours > 23)
-        return false;
+      if (hours < 0 || hours > 23) return false;
     }
     return true;
   }
@@ -111,9 +121,7 @@ function date(date2) {
     date2 = /* @__PURE__ */ new Date();
   }
   if (date2 instanceof Date) {
-    const d = new Date(date2);
-    d.setMilliseconds(0);
-    return d;
+    return new Date(date2);
   }
   date2 = date2.trim();
   if (iso8601(date2)) {
@@ -129,6 +137,27 @@ function addDay(inputDate, count = 1) {
   return d;
 }
 
+// src/addHour.ts
+function addHour(inputDate, count = 1) {
+  const d = date(inputDate);
+  d.setHours(d.getHours() + count);
+  return d;
+}
+
+// src/addMillisecond.ts
+function addMillisecond(inputDate, count = 1) {
+  const d = date(inputDate);
+  d.setMilliseconds(d.getMilliseconds() + count);
+  return d;
+}
+
+// src/addMinute.ts
+function addMinute(inputDate, count = 1) {
+  const d = date(inputDate);
+  d.setMinutes(d.getMinutes() + count);
+  return d;
+}
+
 // src/monthEnd.ts
 function monthEnd(inputDate) {
   const d = date(inputDate);
@@ -144,13 +173,12 @@ function monthDays(inputDate) {
   return d.getDate();
 }
 
-// src/addMonth.ts
-function addMonth(inputDate, count = 1, dateOverflow = false) {
+// src/handleDateOverflow.ts
+function handleOverflow(inputDate, action, dateOverflow = false) {
   const d = date(inputDate);
   const dayOfMonth = d.getDate();
-  if (!dateOverflow)
-    d.setDate(1);
-  d.setMonth(d.getMonth() + count);
+  if (!dateOverflow) d.setDate(1);
+  action(d);
   if (!dateOverflow) {
     const daysInMonth = monthDays(d);
     d.setDate(daysInMonth < dayOfMonth ? daysInMonth : dayOfMonth);
@@ -158,38 +186,63 @@ function addMonth(inputDate, count = 1, dateOverflow = false) {
   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/addMonth.ts
+function addMonth(inputDate, count = 1, dateOverflow = false) {
+  return handleOverflow(inputDate, (d) => d.setMonth(d.getMonth() + count), dateOverflow);
 }
 
-// src/addHour.ts
-function addHour(inputDate, count = 1) {
+// src/addSecond.ts
+function addSecond(inputDate, count = 1) {
   const d = date(inputDate);
-  d.setHours(d.getHours() + count);
+  d.setSeconds(d.getSeconds() + count);
   return d;
 }
 
-// src/addMinute.ts
-function addMinute(inputDate, count = 1) {
-  const d = date(inputDate);
-  d.setMinutes(d.getMinutes() + count);
-  return d;
+// src/addYear.ts
+function addYear(inputDate, count = 1, dateOverflow = false) {
+  return handleOverflow(
+    inputDate,
+    (d) => d.setFullYear(d.getFullYear() + count),
+    dateOverflow
+  );
 }
 
-// src/addSecond.ts
-function addSecond(inputDate, count = 1) {
-  const d = date(inputDate);
-  d.setSeconds(d.getSeconds() + count);
+// src/add.ts
+function add(inputDate, duration, dateOverflow = false) {
+  var _a, _b;
+  let d = date(inputDate);
+  const applyFixedUnits = () => {
+    if (duration.weeks) {
+      d = addDay(d, duration.weeks * 7);
+    }
+    if (duration.days) {
+      d = addDay(d, duration.days);
+    }
+    if (duration.hours) {
+      d = addHour(d, duration.hours);
+    }
+    if (duration.minutes) {
+      d = addMinute(d, duration.minutes);
+    }
+    if (duration.seconds) {
+      d = addSecond(d, duration.seconds);
+    }
+    if (duration.milliseconds) {
+      d = addMillisecond(d, duration.milliseconds);
+    }
+  };
+  const applyCalendarUnits = () => {
+    if (duration.months) {
+      d = addMonth(d, duration.months, dateOverflow);
+    }
+    if (duration.years) {
+      d = addYear(d, duration.years, dateOverflow);
+    }
+  };
+  const calendarFirst = ((_a = duration.months) != null ? _a : 0) < 0 || ((_b = duration.years) != null ? _b : 0) < 0;
+  if (calendarFirst) applyCalendarUnits();
+  applyFixedUnits();
+  if (!calendarFirst) applyCalendarUnits();
   return d;
 }
 
@@ -225,6 +278,9 @@ var clock12 = [
   ["a", { dayPeriod: "narrow" }],
   ["A", { dayPeriod: "narrow" }]
 ];
+var fractionalSeconds = [
+  ["SSS", { fractionalSecond: "3-digit" }]
+];
 var fixedLength = {
   DD: 2,
   HH: 2,
@@ -236,6 +292,12 @@ var fixedLength = {
   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;
   }
@@ -246,17 +308,12 @@ function fixedLengthByOffset(offsetString) {
 }
 var genitiveTokens = ["MMMM", "MMM", "dddd", "ddd"];
 var tokens = /* @__PURE__ */ new Map(
-  /* @__PURE__ */ [...clockAgnostic, ...clock24, ...clock12].map((format2) => {
+  /* @__PURE__ */ [...clockAgnostic, ...clock24, ...clock12, ...fractionalSeconds].map((format2) => {
     return [format2[0], format2];
   })
 );
 var dayPeriodMap = /* @__PURE__ */ new Map();
-var styles = [
-  "full",
-  "long",
-  "medium",
-  "short"
-];
+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) {
@@ -269,8 +326,7 @@ 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;
+    if (partName === "literal") return partValue;
     const value2 = partMap[partName];
     if (partName === "hour" && token === "H") {
       return value2.replace(/^0/, "") || "0";
@@ -282,6 +338,9 @@ function fill(inputDate, parts2, locale, genitive = false, offset2 = null) {
       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);
     }
@@ -307,8 +366,7 @@ function createPartMap(inputDate, parts2, locale, genitive = false) {
         preciseLocale,
         requestedParts.reduce(
           (options, part) => {
-            if (part.partName === "literal")
-              return options;
+            if (part.partName === "literal") return options;
             if (genitive && genitiveTokens.includes(part.token)) {
               genitiveParts.push(part);
             }
@@ -335,9 +393,7 @@ function createPartMap(inputDate, parts2, locale, genitive = false) {
             }).formatToParts(d).map(normStr);
             break;
         }
-        const genitiveFormattedPart = formattedParts.find(
-          (p) => p.type === part.partName
-        );
+        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;
@@ -345,50 +401,48 @@ function createPartMap(inputDate, parts2, locale, genitive = false) {
       }
     }
   }
-  if (hour12.length)
-    addValues(hour12, true);
-  if (hour24.length)
-    addValues(hour24);
+  if (hour12.length) addValues(hour12, true);
+  if (hour24.length) addValues(hour24);
   return valueParts.reduce((map, part) => {
     map[part.type] = part.value;
     return map;
   }, {});
 }
-function minsToOffset(timeDiffInMins, token = "Z") {
-  const hours = String(Math.floor(Math.abs(timeDiffInMins / 60))).padStart(
-    2,
-    "0"
-  );
-  const mins = String(Math.abs(timeDiffInMins % 60)).padStart(2, "0");
-  const sign = timeDiffInMins < 0 ? "-" : "+";
+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 `${sign}${hours}${mins}`;
+    return secs === 0 ? `${sign}${hours}${mins}` : `${sign}${hours}${mins}${String(secs).padStart(2, "0")}`;
   }
-  return `${sign}${hours}:${mins}`;
+  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 offsetToMins(offset2, token) {
+function offsetToSecs(offset2, token) {
   validOffset(offset2, token);
-  const [_, sign, hours, mins] = offset2.match(
-    /([+-])([0-3][0-9]):?([0-6][0-9])/
-  );
-  const offsetInMins = Number(hours) * 60 + Number(mins);
-  return sign === "+" ? offsetInMins : -offsetInMins;
+  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-6][0-9]$/.test(offset2);
+        return /^([+-])[0-3][0-9]:[0-5][0-9](?::[0-5][0-9])?$/.test(offset2);
       case "ZZ":
-        return /^([+-])[0-3][0-9][0-6][0-9]$/.test(offset2);
+        return /^([+-])[0-3][0-9][0-5][0-9](?:[0-5][0-9])?$/.test(offset2);
     }
   })(token);
-  if (!valid)
-    throw new Error(`Invalid offset: ${offset2}`);
+  if (!valid) throw new Error(`Invalid offset: ${offset2}`);
   return offset2;
 }
 function escapeTokens(str) {
-  return clockAgnostic.concat(clock24).concat(clock12).sort((a, b) => a[0].length > b[0].length ? 1 : -1).reduce((target, part) => {
+  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);
 }
@@ -402,10 +456,8 @@ function validate(parts2) {
       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")) {
-        throw new Error(
-          `Illegal adjacent tokens (${lastPart.token}, ${part.token})`
-        );
+      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;
@@ -422,8 +474,7 @@ function getOffsetFormat(format2) {
 // src/ap.ts
 function ap(ampm, locale) {
   const l = dayPeriodMap.get(locale);
-  if (l && l[ampm])
-    return l[ampm];
+  if (l && l[ampm]) return l[ampm];
   const specimen = new Date(specDate);
   specimen.setUTCHours(ampm === "am" ? 5 : 20);
   const subparts = new Intl.DateTimeFormat(locale, {
@@ -446,16 +497,10 @@ function ap(ampm, locale) {
 // src/applyOffset.ts
 function applyOffset(dateInput, offset2 = "+00:00") {
   const d = date(dateInput);
-  const token = (() => {
-    switch (fixedLengthByOffset(offset2)) {
-      case 5:
-        return "ZZ";
-      case 6:
-        return "Z";
-    }
-  })();
-  const timeDiffInMins = offsetToMins(offset2, token);
-  return new Date(d.getTime() + timeDiffInMins * 1e3 * 60);
+  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
@@ -466,22 +511,24 @@ function deviceTZ() {
 // src/offset.ts
 function relativeTime(d, timeZone) {
   const utcParts = new Intl.DateTimeFormat("en-US", {
+    era: "short",
     year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric",
     timeZone,
     hourCycle: "h23"
-  }).formatToParts(d).map(normStr);
-  const parts2 = {};
+  }).formatToParts(d);
+  const p = {};
   utcParts.forEach((part) => {
-    parts2[part.type] = part.value;
+    if (part.type !== "literal") p[part.type] = part.value;
   });
-  return /* @__PURE__ */ new Date(
-    `${parts2.year}-${parts2.month}-${parts2.day}T${parts2.hour}:${parts2.minute}:${parts2.second}Z`
-  );
+  const year = p.era === "BC" ? 1 - Number(p.year) : Number(p.year);
+  const result = new Date(Date.UTC(0, 0, 1, Number(p.hour), Number(p.minute), Number(p.second)));
+  result.setUTCFullYear(year, Number(p.month) - 1, Number(p.day));
+  return result;
 }
 function offset(utcTime, tzA = "UTC", tzB = "device", timeZoneToken = "Z") {
   var _a;
@@ -489,10 +536,8 @@ function offset(utcTime, tzA = "UTC", tzB = "device", timeZoneToken = "Z") {
   const d = date(utcTime);
   const timeA = relativeTime(d, tzA);
   const timeB = relativeTime(d, tzB);
-  const timeDiffInMins = Math.round(
-    (timeB.getTime() - timeA.getTime()) / 1e3 / 60
-  );
-  return minsToOffset(timeDiffInMins, timeZoneToken);
+  const timeDiffInSecs = Math.round((timeB.getTime() - timeA.getTime()) / 1e3);
+  return secsToOffset(timeDiffInSecs, timeZoneToken);
 }
 
 // src/tzDate.ts
@@ -519,7 +564,7 @@ function dayEnd(inputDate) {
 // src/dayStart.ts
 function dayStart(inputDate) {
   const d = date(inputDate);
-  d.setHours(0, 0, 0);
+  d.setHours(0, 0, 0, 0);
   return d;
 }
 
@@ -531,13 +576,11 @@ function parts(format2, locale) {
   let f = format2;
   let match = 0;
   const testPattern = (pattern) => {
-    if (!pattern[2])
-      pattern[2] = new RegExp(`(.)?(${pattern[0]})`, "g");
+    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;
+        if (prefix === "\\") return actualMatch;
         return `${typeof prefix === "string" ? prefix : ""}{!${didAdd++ ? match : match++}!}`;
       });
       return !!didAdd;
@@ -564,7 +607,7 @@ function parts(format2, locale) {
       hour12
     };
   }
-  const found24Patterns = clockAgnostic.filter(testPattern).concat(clock24.filter(testPattern)).map(createPart.bind(null, false));
+  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))
@@ -593,10 +636,8 @@ function styleParts(format2, locale) {
   if (typeof format2 === "string") {
     options.dateStyle = format2;
   } else {
-    if ("date" in format2)
-      options.dateStyle = format2.date;
-    if ("time" in format2)
-      options.timeStyle = format2.time;
+    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);
@@ -612,11 +653,9 @@ function styleParts(format2, locale) {
       part.type === "hour" ? hourType : void 0,
       options
     );
-    if (formatPattern === void 0)
-      return;
+    if (formatPattern === void 0) return;
     const partValue = formatPattern[1][partName];
-    if (!partValue)
-      return;
+    if (!partValue) return;
     if (!formatPattern[2])
       formatPattern[2] = new RegExp(`${formatPattern[0]}`, "g");
     return {
@@ -637,8 +676,7 @@ function guessPattern(partName, partValue, locale, hour, options) {
     case "year":
       return l === 2 ? tokens.get("YY") : tokens.get("YYYY");
     case "month":
-      if (n)
-        return l === 1 ? tokens.get("M") : tokens.get("MM");
+      if (n) return l === 1 ? tokens.get("M") : tokens.get("MM");
       style = partStyle(locale, partName, partValue);
       switch (style) {
         case "long":
@@ -659,8 +697,7 @@ function guessPattern(partName, partValue, locale, hour, options) {
           return tokens.get("dddd");
       }
     case "hour":
-      if (hour === 12)
-        return l === 1 ? tokens.get("h") : tokens.get("hh");
+      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");
@@ -685,8 +722,7 @@ function partStyle(locale, part, value) {
     const formats2 = {};
     for (let i = 0; i < 12; i++) {
       date2.setMonth(0 + i);
-      if (i in weekdays)
-        date2.setDate(weekdays[i]);
+      if (i in weekdays) date2.setDate(weekdays[i]);
       date2.setUTCHours(8 + i);
       for (const style of partStyles) {
         const segments = new Intl.DateTimeFormat(
@@ -705,12 +741,10 @@ function partStyle(locale, part, value) {
             (part2) => part2.type === "month"
           );
           const index = segments.findIndex((part2) => part2.type === "month");
-          if (index > -1 && genitiveMonth)
-            segments[index] = genitiveMonth;
+          if (index > -1 && genitiveMonth) segments[index] = genitiveMonth;
         }
         segments.forEach((part2) => {
-          if (part2.type === "literal")
-            return;
+          if (part2.type === "literal") return;
           const type = part2.type;
           formats2[type] = Object.assign(formats2[type] || {}, {
             [part2.value]: style
@@ -752,8 +786,7 @@ function format(inputDateOrOptions, format2 = "long", locale = "device", genitiv
       tz
     } = inputDateOrOptions);
   }
-  if (format2 === "ISO8601")
-    return date(inputDateOrOptions).toISOString();
+  if (format2 === "ISO8601") return date(inputDateOrOptions).toISOString();
   if (tz) {
     forceOffset = offset(inputDateOrOptions, "utc", tz, getOffsetFormat(format2));
   }
@@ -769,7 +802,7 @@ function format(inputDateOrOptions, format2 = "long", locale = "device", genitiv
   }
   return fill(
     inputDateOrOptions,
-    parts(format2, locale).filter(partFilter != null ? partFilter : () => true),
+    parts(format2, locale).filter(partFilter != null ? partFilter : (() => true)),
     locale,
     genitive,
     forceOffset
@@ -803,7 +836,7 @@ function hourEnd(inputDate) {
 // src/hourStart.ts
 function hourStart(inputDate) {
   const d = date(inputDate);
-  d.setMinutes(0, 0);
+  d.setMinutes(0, 0, 0);
   return d;
 }
 
@@ -817,7 +850,7 @@ function minuteEnd(inputDate) {
 // src/minuteStart.ts
 function minuteStart(inputDate) {
   const d = date(inputDate);
-  d.setSeconds(0);
+  d.setSeconds(0, 0);
   return d;
 }
 
@@ -825,7 +858,7 @@ function minuteStart(inputDate) {
 function monthStart(inputDate) {
   const d = date(inputDate);
   d.setDate(1);
-  d.setHours(0, 0, 0);
+  d.setHours(0, 0, 0, 0);
   return d;
 }
 
@@ -861,13 +894,11 @@ function nearestDay(inputDate, search, constraint = 7) {
   for (let i = 0; i <= increments || i < decrements; i++) {
     if (i <= increments) {
       const next = addDay(d, i);
-      if (search(next))
-        return next;
+      if (search(next)) return next;
     }
     if (i && i <= decrements) {
       const prev = addDay(d, -i);
-      if (search(prev))
-        return prev;
+      if (search(prev)) return prev;
     }
   }
   return null;
@@ -876,8 +907,7 @@ function nearestDay(inputDate, search, constraint = 7) {
 // 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 === "M") return r(12, (i) => i + 1);
   if (token === "MM")
     return r(12, (i) => {
       const m = i + 1;
@@ -935,19 +965,16 @@ function parse(dateStrOrOptions, format2 = "ISO8601", locale = "device") {
   } else {
     dateStr = dateStrOrOptions;
   }
-  if (!dateStr)
-    throw new Error("parse() requires a date string.");
+  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);
+  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.");
+  if (!formatParts.length) throw new Error("parse() requires a pattern.");
   let parsedParts;
   try {
     parsedParts = parseParts(dateStr, formatParts);
@@ -961,17 +988,19 @@ function parse(dateStrOrOptions, format2 = "ISO8601", locale = "device") {
     ["DD", now.getDate()],
     ["HH", 0],
     ["mm", 0],
-    ["ss", 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();
+    if (part.partName === "literal") return;
+    if (part.token === part.value) return invalid();
     const v = Number(part.value);
-    if (parsed.has(part.token)) {
+    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));
@@ -1011,17 +1040,24 @@ function parse(dateStrOrOptions, format2 = "ISO8601", locale = "device") {
     parsed.set("HH", 0);
   }
   parsed.set("MM", (parsed.get("MM") || 1) - 1);
-  let [Y, M, D, h, m, s] = Array.from(parsed.values());
+  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 isoString = `${four(Y)}-${two(M + 1)}-${two(D)}T${two(h)}:${two(
-    m
-  )}:${two(s)}${offset2}`;
+  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;
+  if (isFinite(+d)) return d;
   return invalid();
 }
 function parseParts(dateStr, formatParts) {
@@ -1041,13 +1077,18 @@ function parseParts(dateStr, formatParts) {
       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();
+        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)))) {
@@ -1057,8 +1098,7 @@ function parseParts(dateStr, formatParts) {
         }
       } else {
         const nextChar = dateStr.substring(pos).search(/\d/);
-        if (nextChar !== -1)
-          len = pos + nextChar;
+        if (nextChar !== -1) len = pos + nextChar;
       }
     } else {
       len = dateStr.length;
@@ -1083,6 +1123,13 @@ function sameSecond(inputDateA, 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);
@@ -1104,14 +1151,62 @@ function sameYear(inputDateA, inputDateB) {
   return a.getFullYear() === b.getFullYear();
 }
 
+// src/setMilliseconds.ts
+function setMilliseconds(inputDate, ms) {
+  const d = date(inputDate);
+  d.setMilliseconds(ms);
+  return d;
+}
+
+// src/setSeconds.ts
+function setSeconds(inputDate, second) {
+  const d = date(inputDate);
+  d.setSeconds(second);
+  return d;
+}
+
+// src/setMinutes.ts
+function setMinutes(inputDate, minute) {
+  const d = date(inputDate);
+  d.setMinutes(minute);
+  return d;
+}
+
+// src/setHour.ts
+function setHour(inputDate, hour) {
+  const d = date(inputDate);
+  d.setHours(hour);
+  return d;
+}
+
+// src/setDayOfMonth.ts
+function setDayOfMonth(inputDate, day, dateOverflow = false) {
+  const d = date(inputDate);
+  const daysInMonth = monthDays(d);
+  if (!dateOverflow) {
+    day = day > daysInMonth ? daysInMonth : day;
+  }
+  d.setDate(day);
+  return d;
+}
+
+// src/setMonth.ts
+function setMonth(inputDate, month, dateOverflow = false) {
+  return handleOverflow(inputDate, (d) => d.setMonth(month), dateOverflow);
+}
+
+// src/setYear.ts
+function setYear(inputDate, year, dateOverflow = false) {
+  return handleOverflow(inputDate, (d) => d.setFullYear(year), dateOverflow);
+}
+
 // 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);
+  let diff2 = startOfWeekDay - d.getDay();
+  if (diff2 > 0) diff2 = diff2 - 7;
+  d.setDate(d.getDate() + diff2);
+  d.setHours(0, 0, 0, 0);
   return d;
 }
 
@@ -1119,24 +1214,22 @@ function weekStart(inputDate, startOfWeekDay = 0) {
 function weekEnd(inputDate, startOfWeekDay = 0) {
   const d = weekStart(inputDate, startOfWeekDay);
   d.setDate(d.getDate() + 6);
-  d.setHours(23, 59, 59);
+  d.setHours(23, 59, 59, 999);
   return d;
 }
 
 // src/yearStart.ts
 function yearStart(inputDate) {
   const d = date(inputDate);
-  d.setMonth(0);
-  d.setDate(1);
-  d.setHours(0, 0, 0);
+  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);
-  d.setDate(31);
+  d.setMonth(11, 31);
   d.setHours(23, 59, 59, 999);
   return d;
 }
@@ -1162,6 +1255,16 @@ function isEqual(dateLeft, 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);
@@ -1177,17 +1280,26 @@ function diffRound(value, method = "trunc") {
 
 // src/diffSeconds.ts
 function diffSeconds(dateA, dateB, roundingMethod) {
-  return diffRound(diffMilliseconds(dateA, dateB) / 1e3, roundingMethod);
+  return diffRound(
+    // @ts-ignore
+    diffMilliseconds(dateA, dateB) / 1e3,
+    roundingMethod
+  );
 }
 
 // src/diffMinutes.ts
 function diffMinutes(dateA, dateB, roundingMethod) {
-  return diffRound(diffMilliseconds(dateA, dateB) / 6e4, 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
@@ -1197,6 +1309,7 @@ function diffHours(dateA, dateB, roundingMethod) {
 // src/diffDays.ts
 function diffDays(dateA, dateB, roundingMethod) {
   return diffRound(
+    // @ts-ignore
     diffMilliseconds(dateA, dateB) / 864e5,
     // hour * 24
     roundingMethod
@@ -1234,13 +1347,86 @@ function diffMonths(dateA, dateB) {
 
 // src/diffYears.ts
 function diffYears(dateA, dateB) {
-  const r = Math.trunc(diffMonths(dateA, dateB) / 12);
+  const r = Math.trunc(
+    //@ts-ignore
+    diffMonths(dateA, dateB) / 12
+  );
   return r == 0 ? 0 : r;
 }
+
+// src/diff.ts
+function negateDuration(duration) {
+  const negated = {};
+  for (const unit of Object.keys(duration)) {
+    negated[unit] = -duration[unit];
+  }
+  return negated;
+}
+function calendarDiff(current, target, diffUnit, addUnit) {
+  let amount = diffUnit(current, target);
+  let next = addUnit(current, -amount);
+  while (amount > 0 && next < target) {
+    amount--;
+    next = addUnit(current, -amount);
+  }
+  return [amount, next];
+}
+function diff(dateA, dateB, options) {
+  let a = date(dateA);
+  let b = date(dateB);
+  if (a < b) {
+    const duration2 = diff(b, a, options);
+    return (options == null ? void 0 : options.abs) ? duration2 : negateDuration(duration2);
+  }
+  const skip = new Set(options == null ? void 0 : options.skip);
+  const duration = {};
+  if (!skip.has("years")) {
+    const [years, next] = calendarDiff(a, b, diffYears, addYear);
+    a = next;
+    if (years) duration.years = years;
+  }
+  if (!skip.has("months")) {
+    const [months, next] = calendarDiff(a, b, diffMonths, addMonth);
+    a = next;
+    if (months) duration.months = months;
+  }
+  if (!skip.has("weeks")) {
+    const weeks = diffWeeks(a, b);
+    a = addDay(a, -(weeks * 7));
+    if (weeks) duration.weeks = weeks;
+  }
+  if (!skip.has("days")) {
+    const days = diffDays(a, b);
+    a = addDay(a, -days);
+    if (days) duration.days = days;
+  }
+  if (!skip.has("hours")) {
+    const hours = diffHours(a, b);
+    a = addHour(a, -hours);
+    if (hours) duration.hours = hours;
+  }
+  if (!skip.has("minutes")) {
+    const minutes = diffMinutes(a, b);
+    a = addMinute(a, -minutes);
+    if (minutes) duration.minutes = minutes;
+  }
+  if (!skip.has("seconds")) {
+    const seconds = diffSeconds(a, b);
+    a = addSecond(a, -seconds);
+    if (seconds) duration.seconds = seconds;
+  }
+  if (!skip.has("milliseconds")) {
+    const ms = diffMilliseconds(a, b);
+    if (ms) duration.milliseconds = ms;
+  }
+  return duration;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  add,
   addDay,
   addHour,
+  addMillisecond,
   addMinute,
   addMonth,
   addSecond,
@@ -1251,6 +1437,7 @@ function diffYears(dateA, dateB) {
   dayEnd,
   dayOfYear,
   dayStart,
+  diff,
   diffDays,
   diffHours,
   diffMilliseconds,
@@ -1267,6 +1454,8 @@ function diffYears(dateA, dateB) {
   isAfter,
   isBefore,
   isEqual,
+  isFuture,
+  isPast,
   iso8601,
   minuteEnd,
   minuteStart,
@@ -1282,9 +1471,17 @@ function diffYears(dateA, dateB) {
   removeOffset,
   sameDay,
   sameHour,
+  sameMillisecond,
   sameMinute,
   sameSecond,
   sameYear,
+  setDayOfMonth,
+  setHour,
+  setMilliseconds,
+  setMinutes,
+  setMonth,
+  setSeconds,
+  setYear,
   tzDate,
   weekEnd,
   weekStart,