@formkit/tempo 0.0.18 → 0.1.0

package/dist/offset.mjs

@@ -0,0 +1,36 @@
+// src/offset.ts
+import { date } from "./date.mjs";
+import { normStr, minsToOffset } from "./common.mjs";
+import { deviceTZ } from "./deviceTZ.mjs";
+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 parts = {};
+  utcParts.forEach((part) => {
+    parts[part.type] = part.value;
+  });
+  return /* @__PURE__ */ new Date(
+    `${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}:${parts.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 timeDiffInMins = (timeB.getTime() - timeA.getTime()) / 1e3 / 60;
+  return minsToOffset(timeDiffInMins, timeZoneToken);
+}
+export {
+  offset
+};
+//# sourceMappingURL=offset.mjs.map

package/dist/offset.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/offset.ts"],"sourcesContent":["import { date } from \"./date\"\nimport { normStr, minsToOffset, TimezoneToken } from \"./common\"\nimport { deviceTZ } from \"./deviceTZ\"\nimport type { DateInput } from \"./types\"\n\n/**\n * Converts a date object from one timezone to that same time in UTC. This is\n * only for internal use.\n * @param d - A Date object\n * @param timeZone - A timezone string\n */\nfunction relativeTime(d: Date, timeZone: string): Date {\n  const utcParts = new Intl.DateTimeFormat(\"en-US\", {\n    year: \"numeric\",\n    month: \"2-digit\",\n    day: \"2-digit\",\n    hour: \"2-digit\",\n    minute: \"2-digit\",\n    second: \"2-digit\",\n    timeZone,\n    hourCycle: \"h23\",\n  })\n    .formatToParts(d)\n    .map(normStr)\n  const parts: {\n    year?: string\n    month?: string\n    day?: string\n    hour?: string\n    minute?: string\n    second?: string\n  } = {}\n  utcParts.forEach((part) => {\n    parts[part.type as keyof typeof parts] = part.value\n  })\n  return new Date(\n    `${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}:${parts.second}Z`\n  )\n}\n\n/**\n * Returns the offset between two timezones on a given date. The results are\n * ISO8601 compatible offsets like -0800 or +0530.\n *\n * @param dateInput - The date on which to determine the offset.\n * @param tzA - (default: UTC) The second timezone to compare determine the offset between.\n * @param tzB - (default: device) The first timezone to compare determine the offset between.\n */\nexport function offset(\n  utcTime: DateInput,\n  tzA = \"UTC\",\n  tzB = \"device\",\n  timeZoneToken: TimezoneToken = \"Z\" ,\n): string {\n  tzB = tzB === \"device\" ? deviceTZ() ?? \"utc\" : tzB\n  const d = date(utcTime)\n  const timeA = relativeTime(d, tzA)\n  const timeB = relativeTime(d, tzB)\n  const timeDiffInMins = (timeB.getTime() - timeA.getTime()) / 1000 / 60\n  return minsToOffset(timeDiffInMins, timeZoneToken)\n}\n"],"mappings":";AAAA,SAAS,YAAY;AACrB,SAAS,SAAS,oBAAmC;AACrD,SAAS,gBAAgB;AASzB,SAAS,aAAa,GAAS,UAAwB;AACrD,QAAM,WAAW,IAAI,KAAK,eAAe,SAAS;AAAA,IAChD,MAAM;AAAA,IACN,OAAO;AAAA,IACP,KAAK;AAAA,IACL,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR;AAAA,IACA,WAAW;AAAA,EACb,CAAC,EACE,cAAc,CAAC,EACf,IAAI,OAAO;AACd,QAAM,QAOF,CAAC;AACL,WAAS,QAAQ,CAAC,SAAS;AACzB,UAAM,KAAK,IAA0B,IAAI,KAAK;AAAA,EAChD,CAAC;AACD,SAAO,oBAAI;AAAA,IACT,GAAG,MAAM,IAAI,IAAI,MAAM,KAAK,IAAI,MAAM,GAAG,IAAI,MAAM,IAAI,IAAI,MAAM,MAAM,IAAI,MAAM,MAAM;AAAA,EACzF;AACF;AAUO,SAAS,OACd,SACA,MAAM,OACN,MAAM,UACN,gBAA+B,KACvB;AArDV;AAsDE,QAAM,QAAQ,YAAW,cAAS,MAAT,YAAc,QAAQ;AAC/C,QAAM,IAAI,KAAK,OAAO;AACtB,QAAM,QAAQ,aAAa,GAAG,GAAG;AACjC,QAAM,QAAQ,aAAa,GAAG,GAAG;AACjC,QAAM,kBAAkB,MAAM,QAAQ,IAAI,MAAM,QAAQ,KAAK,MAAO;AACpE,SAAO,aAAa,gBAAgB,aAAa;AACnD;","names":[]}

package/dist/parse.d.ts

@@ -0,0 +1,13 @@
+import { ParseOptions, Format, Part, FilledPart } from './types.js';
+
+declare function parse(options: ParseOptions): Date | never;
+declare function parse(dateStr: string, format?: Format, locale?: string): Date | never;
+/**
+ * Given a string date and corresponding format parts, fill the parts with the
+ * data from the string.
+ * @param dateStr - A string to parse.
+ * @param formatParts - The expected parts of the given string.
+ */
+declare function parseParts(dateStr: string, formatParts: Part[]): FilledPart[];
+
+export { parse, parseParts };

package/dist/parse.mjs

@@ -0,0 +1,163 @@
+// src/parse.ts
+import { date } from "./date.mjs";
+import { validate, styles, fixedLength, four, two, validOffset, fixedLengthByOffset } from "./common.mjs";
+import { formatStr } from "./formatStr.mjs";
+import { fourDigitYear } from "./fourDigitYear.mjs";
+import { ap } from "./ap.mjs";
+import { range } from "./range.mjs";
+import { monthDays } from "./monthDays.mjs";
+import { parts } from "./parts.mjs";
+function parse(dateStrOrOptions, format = "ISO8601", locale = "device") {
+  let partFilter = () => true;
+  let dateStr;
+  let dateOverflow = "backward";
+  if (typeof dateStrOrOptions === "object") {
+    ;
+    ({
+      date: dateStr,
+      format = "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(format, locale)})`
+    );
+  };
+  if (format === "ISO8601")
+    return date(dateStr);
+  const genitive = styles.includes(format) || typeof format === "object";
+  const formatParts = validate(parts(format, 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]
+  ]);
+  let a = null;
+  let offset = "";
+  parsedParts.forEach((part) => {
+    if (part.partName === "literal")
+      return;
+    if (part.token === part.value)
+      return invalid();
+    const v = Number(part.value);
+    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") {
+        offset = 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] = 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)}${offset}`;
+  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 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;
+}
+export {
+  parse,
+  parseParts
+};
+//# sourceMappingURL=parse.mjs.map

package/dist/parse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parse.ts"],"sourcesContent":["import { date } from \"./date\"\nimport { validate, styles, fixedLength, four, two, validOffset, fixedLengthByOffset } from \"./common\"\nimport { formatStr } from \"./formatStr\"\nimport { fourDigitYear } from \"./fourDigitYear\"\nimport { ap } from \"./ap\"\nimport { range } from \"./range\"\nimport { monthDays } from \"./monthDays\"\nimport { parts } from \"./parts\"\nimport type {\n  ParseOptions,\n  Format,\n  Part,\n  FormatStyle,\n  FilledPart,\n  FormatToken,\n} from \"./types\"\n\nexport function parse(options: ParseOptions): Date | never\nexport function parse(\n  dateStr: string,\n  format?: Format,\n  locale?: string\n): Date | never\n/**\n * Parses a date string into a Date object using the given format.\n * @param dateStr - A string representing a date.\n * @param format - The format the given string is in.\n * @param locale - The locale to parse the string from.\n */\nexport function parse(\n  dateStrOrOptions: string | ParseOptions,\n  format: Format = \"ISO8601\",\n  locale = \"device\"\n): Date | never {\n  let partFilter: (part: Part) => boolean = () => true\n  let dateStr: string\n  let dateOverflow = \"backward\"\n  if (typeof dateStrOrOptions === \"object\") {\n    ;({\n      date: dateStr,\n      format = \"ISO8601\",\n      locale = \"device\",\n      dateOverflow = \"backward\",\n      partFilter = () => true,\n    } = dateStrOrOptions)\n  } else {\n    dateStr = dateStrOrOptions\n  }\n  if (!dateStr) throw new Error(\"parse() requires a date string.\")\n  const invalid = (): never => {\n    throw new Error(\n      `Date (${dateStr}) does not match format (${formatStr(format, locale)})`\n    )\n  }\n  if (format === \"ISO8601\") return date(dateStr)\n  const genitive =\n    styles.includes(format as FormatStyle) || typeof format === \"object\"\n  const formatParts = validate(parts(format, locale).filter(partFilter))\n  if (!formatParts.length) throw new Error(\"parse() requires a pattern.\")\n  let parsedParts\n  try {\n    parsedParts = parseParts(dateStr, formatParts)\n  } catch {\n    return invalid()\n  }\n  const now = new Date()\n  const parsed = new Map([\n    [\"YYYY\", now.getFullYear()],\n    [\"MM\", now.getMonth() + 1],\n    [\"DD\", now.getDate()],\n    [\"HH\", 0],\n    [\"mm\", 0],\n    [\"ss\", 0],\n  ])\n  let a: null | boolean = null\n  let offset = \"\"\n  parsedParts.forEach((part): void | never => {\n    if (part.partName === \"literal\") return\n    if (part.token === part.value) return invalid()\n    const v = Number(part.value)\n    if (parsed.has(part.token)) {\n      // Parse for YYYY, MM, DD, HH, hh, mm, ss, Z\n      parsed.set(part.token, v)\n    } else if (part.token === \"YY\") {\n      // Parse for YY\n      parsed.set(\"YYYY\", fourDigitYear(part.value))\n    } else {\n      /* MMM - Short name Jan-Dec\n       * MMMM - Full name January - December\n       * h - Minimum hour digits, 12 hour clock, 1-12\n       * hh - 2 hour digits, 12 hour clock, 01-12\n       * m - The minute 0-59\n       * mm - The minute 00-12\n       * s - The second 0-59\n       * a - am/pm\n       * A - AM/PM\n       */\n      const t = part.token\n      if (t.startsWith(\"d\")) {\n        // d, ddd, dddd — we just ignore these because they are non specific\n        return\n      } else if (t === \"D\") {\n        parsed.set(\"DD\", v)\n      } else if (t === \"H\" || t.startsWith(\"h\")) {\n        parsed.set(\"HH\", v)\n      } else if (t === \"M\") {\n        parsed.set(\"MM\", v)\n      } else if (t === \"a\" || t === \"A\") {\n        a = part.value.toLowerCase() === ap(\"am\", locale).toLowerCase()\n      } else if (t === \"Z\" || t === \"ZZ\") {\n        offset = validOffset(part.value, t)\n      } else {\n        const values = range(t as FormatToken, locale, genitive)\n        const index = values.indexOf(part.value)\n        if (index !== -1) {\n          switch (t) {\n            case \"MMM\":\n            case \"MMMM\":\n              parsed.set(\"MM\", index + 1)\n              break\n          }\n        }\n      }\n    }\n  })\n  let hours = parsed.get(\"HH\") || 0\n  if (a === false) {\n    hours += hours === 12 ? 0 : 12\n    parsed.set(\"HH\", hours === 24 ? 0 : hours)\n  } else if (a === true && hours === 12) {\n    // 12am === 00 in 24 hour clock.\n    parsed.set(\"HH\", 0)\n  }\n  parsed.set(\"MM\", (parsed.get(\"MM\") || 1) - 1)\n  // eslint-disable-next-line prefer-const\n  let [Y, M, D, h, m, s] = Array.from(parsed.values())\n\n  // Determine if the date is valid for the month.\n  const maxDaysInMonth = monthDays(new Date(`${four(Y)}-${two(M + 1)}-10`))\n  if (maxDaysInMonth < D && dateOverflow === \"throw\")\n    throw new Error(`Invalid date ${four(Y)}-${two(M + 1)}-${two(D)}`)\n  D = dateOverflow === \"backward\" ? Math.min(D, maxDaysInMonth) : D\n\n  // Create the date.\n  const isoString = `${four(Y)}-${two(M + 1)}-${two(D)}T${two(h)}:${two(\n    m\n  )}:${two(s)}${offset}`\n  const d = new Date(isoString)\n  if (isFinite(+d)) return d\n  return invalid()\n}\n\n/**\n * Given a string date and corresponding format parts, fill the parts with the\n * data from the string.\n * @param dateStr - A string to parse.\n * @param formatParts - The expected parts of the given string.\n */\nexport function parseParts(dateStr: string, formatParts: Part[]): FilledPart[] {\n  let i = 0\n  const advance = (parts: Part[]): [Part, Part | undefined] => [\n    parts[i++],\n    parts[i],\n  ]\n  let pos = 0\n  const parsed: FilledPart[] = []\n  let n: undefined | Part = undefined\n  do {\n    const [current, next] = advance(formatParts)\n    n = next\n    let len = 1\n    if (current.partName === \"literal\") {\n      // Literals can be discarded\n      len = current.partValue.length\n    } else if (current.partName === \"timeZoneName\") {\n      len = fixedLengthByOffset(dateStr.substring(pos))\n    } else if (current.token in fixedLength) {\n      // Fixed length parse\n      len = fixedLength[current.token as keyof typeof fixedLength]\n    } else if (next) {\n      // Variable length parse.\n      if (next.partName === \"literal\") {\n        len = dateStr.indexOf(next.partValue, pos) - pos\n        if (len < 0) throw new Error()\n      } else if (next.partName === \"dayPeriod\") {\n        // Our validator is ensuring that the current item must be a variable\n        // length number. We need to extract it.\n        for (let i = 1; i <= 4; i++) {\n          if (isNaN(Number(dateStr.charAt(pos + i)))) {\n            len = i\n            break\n          }\n        }\n      } else {\n        // Our validator guarantees the next is either not a number or it\n        // will be the end of the string\n        const nextChar = dateStr.substring(pos).search(/\\d/)\n        if (nextChar !== -1) len = pos + nextChar\n      }\n    } else {\n      len = dateStr.length\n    }\n\n    parsed.push({ ...current, value: dateStr.substring(pos, pos + len) })\n    pos += len\n  } while (n)\n  return parsed\n}\n"],"mappings":"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","names":["parts","i"]}

package/dist/parts.d.ts

@@ -0,0 +1,12 @@
+import { Format, Part } from './types.js';
+
+/**
+ * Given a format string, produce an array of matching "parts", each part
+ * contains a regular expression and the corresponding
+ * Intl.DateTimeFormatPartTypesRegistry key/value.
+ * @param format - A format string like MM/DD/YYYY
+ * @param locale - The locale to parse for.
+ */
+declare function parts(format: Format, locale: string): Part[];
+
+export { parts };

package/dist/parts.mjs

@@ -0,0 +1,214 @@
+// src/parts.ts
+import {
+  styles,
+  normStr,
+  tokens,
+  memoParts,
+  clockAgnostic,
+  clock24,
+  specDate,
+  clock12
+} from "./common.mjs";
+function parts(format, locale) {
+  if (styles.includes(format) || typeof format === "object") {
+    return styleParts(format, locale);
+  }
+  let f = format;
+  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 validate(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)).map(createPart.bind(null, false));
+  const parts2 = validate(
+    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(format, locale) {
+  const options = {
+    timeZone: "UTC"
+  };
+  if (typeof format === "string") {
+    options.dateStyle = format;
+  } else {
+    if ("date" in format)
+      options.dateStyle = format.date;
+    if ("time" in format)
+      options.timeStyle = format.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 date = 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++) {
+      date.setMonth(0 + i);
+      if (i in weekdays)
+        date.setDate(weekdays[i]);
+      date.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(date).map(normStr);
+        if (style === "long" || style === "short") {
+          const genitiveFormattedParts = new Intl.DateTimeFormat(locale, {
+            dateStyle: style === "short" ? "medium" : "long",
+            timeZone: "UTC"
+          }).formatToParts(date).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;
+}
+export {
+  parts
+};
+//# sourceMappingURL=parts.mjs.map

package/dist/parts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parts.ts"],"sourcesContent":["import {\n  styles,\n  normStr,\n  tokens,\n  memoParts,\n  clockAgnostic,\n  clock24,\n  specDate,\n  clock12,\n} from \"./common\"\nimport type {\n  ParseOptions,\n  Format,\n  Part,\n  FormatStyle,\n  FormatStyleObj,\n  FormatPattern,\n  NamedFormats,\n  NamedFormatOption,\n} from \"./types\"\n/**\n * Given a format string, produce an array of matching \"parts\", each part\n * contains a regular expression and the corresponding\n * Intl.DateTimeFormatPartTypesRegistry key/value.\n * @param format - A format string like MM/DD/YYYY\n * @param locale - The locale to parse for.\n */\nexport function parts(format: Format, locale: string): Part[] {\n  if (styles.includes(format as FormatStyle) || typeof format === \"object\") {\n    return styleParts(format as FormatStyle | FormatStyleObj, locale)\n  }\n  let f = format\n  let match = 0\n  const testPattern = (pattern: FormatPattern) => {\n    if (!pattern[2]) pattern[2] = new RegExp(`(.)?(${pattern[0]})`, \"g\")\n    if (pattern[2].test(f)) {\n      let didAdd = 0\n      f = f.replace(pattern[2], (_, prefix, actualMatch) => {\n        if (prefix === \"\\\\\") return actualMatch\n        return `${typeof prefix === \"string\" ? prefix : \"\"}{!${\n          didAdd++ ? match : match++\n        }!}`\n      })\n      return !!didAdd\n    }\n    return false\n  }\n\n  function validate(patterns: Part[]): Part[] {\n    const parts = patterns.map((part) => part.partName)\n    const deduped = new Set(parts)\n    if (parts.length > deduped.size) {\n      throw new Error(`Cannot reuse format tokens.`)\n    }\n    return patterns\n  }\n\n  function createPart(\n    hour12: boolean,\n    [token, option, exp]: FormatPattern\n  ): Part {\n    const partName = Object.keys(option)[0] as Intl.DateTimeFormatPartTypes\n    const partValue = option[partName] as string\n    return {\n      option,\n      partName,\n      partValue,\n      token,\n      pattern: exp as RegExp,\n      hour12,\n    }\n  }\n\n  const found24Patterns = clockAgnostic\n    .filter(testPattern)\n    .concat(clock24.filter(testPattern))\n    .map(createPart.bind(null, false))\n\n  // Reset the format before re-checking\n  const parts = validate(\n    found24Patterns.concat(\n      clock12.filter(testPattern).map(createPart.bind(null, true))\n    )\n  )\n  const extractIndex = /^\\{!(\\d+)!\\}$/\n  return f\n    .split(/(\\{!\\d+!\\})/)\n    .map((match: string): Part => {\n      const hasIndex = match.match(extractIndex)\n      if (hasIndex) {\n        return parts[Number(hasIndex[1])]\n      }\n      return {\n        option: { literal: match },\n        partName: \"literal\",\n        partValue: match,\n        token: match,\n        pattern: new RegExp(\"\"),\n        hour12: false,\n      }\n    })\n    .filter((part) => !(part.partName === \"literal\" && part.partValue === \"\"))\n}\n\n/**\n * Determines the parts in a native date style, like \"full\".\n * @param format - A date style like \"full\" or \"short\"\n * @param locale - The locale string\n */\nfunction styleParts(\n  format: FormatStyle | FormatStyleObj,\n  locale: string\n): Part[] {\n  const options: Intl.DateTimeFormatOptions = {\n    timeZone: \"UTC\",\n  }\n  if (typeof format === \"string\") {\n    options.dateStyle = format\n  } else {\n    if (\"date\" in format) options.dateStyle = format.date\n    if (\"time\" in format) options.timeStyle = format.time\n  }\n\n  const formatter = new Intl.DateTimeFormat(locale, options)\n  const segments = formatter.formatToParts(new Date(specDate)).map(normStr)\n  const hourTypeSegments = formatter\n    .formatToParts(new Date(\"1999-04-05T23:05:01.000Z\"))\n    .map(normStr)\n  const hourPart = hourTypeSegments.find((segment) => segment.type === \"hour\")\n  const hourType = hourPart && hourPart.value === \"23\" ? 24 : 12\n  return segments\n    .map((part): Part | undefined => {\n      const partName = part.type\n      const formatPattern = guessPattern(\n        part.type,\n        part.value,\n        locale,\n        part.type === \"hour\" ? hourType : undefined,\n        options\n      )\n      if (formatPattern === undefined) return\n      const partValue = formatPattern[1][partName]\n      if (!partValue) return\n      if (!formatPattern[2])\n        formatPattern[2] = new RegExp(`${formatPattern[0]}`, \"g\")\n      return {\n        option: { [partName]: partValue },\n        partName,\n        partValue,\n        token: formatPattern[0],\n        pattern: formatPattern[2],\n        hour12: hourType === 12,\n      }\n    })\n    .filter((part): part is Part => !!part)\n}\n\n/**\n * Attempts to guess the correct part value type for a given dateStyle. For\n * example a month of 02 would be \"2-digit\".\n *\n * @param partName - The part name to guess for, like 'year' or 'month'\n * @param partValue - The current value, it is assumed this is the smallest denom.\n */\nfunction guessPattern<T extends Intl.DateTimeFormatPartTypes>(\n  partName: T,\n  partValue: string,\n  locale: string,\n  hour: T extends \"hour\" ? 12 | 24 : undefined,\n  options: Intl.DateTimeFormatOptions\n): FormatPattern | undefined {\n  const l = partValue.length\n  const n = !isNaN(Number(partValue))\n  let style: NamedFormatOption | undefined\n  /* eslint-disable @typescript-eslint/no-non-null-assertion */\n  switch (partName) {\n    case \"year\":\n      return l === 2 ? tokens.get(\"YY\") : tokens.get(\"YYYY\")\n    case \"month\":\n      if (n) return l === 1 ? tokens.get(\"M\") : tokens.get(\"MM\")\n      style = partStyle(locale, partName, partValue)\n      switch (style) {\n        case \"long\":\n          return tokens.get(\"MMMM\")\n        default:\n          return tokens.get(\"MMM\")\n      }\n    case \"day\":\n      return l === 1 ? tokens.get(\"D\") : tokens.get(\"DD\")\n    case \"weekday\":\n      style = partStyle(locale, partName, partValue)\n      switch (style) {\n        case \"narrow\":\n          return tokens.get(\"d\")\n        case \"short\":\n          return tokens.get(\"ddd\")\n        default:\n          return tokens.get(\"dddd\")\n      }\n    case \"hour\":\n      // Need to distinguish the locale’s default as 24 or 12 hour.\n      if (hour === 12) return l === 1 ? tokens.get(\"h\") : tokens.get(\"hh\")\n      return l === 1 ? tokens.get(\"H\") : tokens.get(\"HH\")\n    case \"minute\":\n      return l === 1 ? tokens.get(\"m\") : tokens.get(\"mm\")\n    case \"second\":\n      return l === 1 ? tokens.get(\"s\") : tokens.get(\"ss\")\n    case \"dayPeriod\":\n      return /^[A-Z]+$/u.test(partValue) ? tokens.get(\"A\") : tokens.get(\"a\")\n    case \"literal\":\n      return [partValue, { literal: partValue }, new RegExp(\"\")]\n    case \"timeZoneName\":\n      return options.timeStyle === \"full\" ? tokens.get(\"Z\") : tokens.get(\"ZZ\")\n    default:\n      return undefined\n  }\n  /* eslint-enable @typescript-eslint/no-non-null-assertion */\n}\n\n/**\n * Determines what \"style\" a given part is in. For example, if you provide:\n * ```js\n * partStyle('en', 'month', 'Jan')\n * // returns \"short\".\n * ```\n * Part styles are always expected to be \"genitive\" — for use in \"dateStyle\".\n * @param locale - Locale string\n * @param part - The part to attempt a lookup on\n * @param value - The value of a given part.\n */\nfunction partStyle(\n  locale: string,\n  part: keyof NamedFormats,\n  value: string\n): NamedFormatOption | undefined {\n  if (!memoParts.has(locale)) {\n    const date = new Date(specDate)\n    const weekdays = [3, 8, 9, 7, 6, 4, 3]\n    const parts = [\"weekday\", \"month\", \"dayPeriod\"]\n    const partStyles: NamedFormatOption[] = [\"long\", \"short\", \"narrow\"]\n    const formats: Partial<NamedFormats> = {}\n    for (let i = 0; i < 12; i++) {\n      date.setMonth(0 + i)\n      if (i in weekdays) date.setDate(weekdays[i])\n      date.setUTCHours(8 + i)\n      for (const style of partStyles) {\n        const segments = new Intl.DateTimeFormat(\n          locale,\n          parts.reduce(\n            (options, part) => Object.assign(options, { [part]: style }),\n            { hour12: true, timeZone: \"UTC\" }\n          )\n        )\n          .formatToParts(date)\n          .map(normStr)\n        if (style === \"long\" || style === \"short\") {\n          const genitiveFormattedParts = new Intl.DateTimeFormat(locale, {\n            dateStyle: style === \"short\" ? \"medium\" : \"long\",\n            timeZone: \"UTC\",\n          })\n            .formatToParts(date)\n            .map(normStr)\n          const genitiveMonth = genitiveFormattedParts.find(\n            (part) => part.type === \"month\"\n          )\n          const index = segments.findIndex((part) => part.type === \"month\")\n          if (index > -1 && genitiveMonth) segments[index] = genitiveMonth\n        }\n        segments.forEach((part) => {\n          if (part.type === \"literal\") return\n          const type = part.type as keyof NamedFormats\n          formats[type] = Object.assign(formats[type] || {}, {\n            [part.value]: style,\n          })\n        })\n      }\n    }\n    memoParts.set(locale, formats as NamedFormats)\n  }\n  const formats = memoParts.get(locale)\n  return formats ? formats[part][value] : undefined\n}\n"],"mappings":"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","names":["parts","match","formats","part"]}

package/dist/range.d.ts

@@ -0,0 +1,10 @@
+import { FormatToken } from './types.js';
+
+/**
+ * Returns an array of options for a given token in a given locale.
+ * @param token - Get the full range of options for a given token
+ * @param locale - The locale to fetch the options for.
+ */
+declare function range(token: FormatToken, locale?: string, genitive?: boolean): string[];
+
+export { range };

package/dist/range.mjs

@@ -0,0 +1,50 @@
+// src/range.ts
+import { format } from "./format.mjs";
+import { ap } from "./ap.mjs";
+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 [];
+}
+export {
+  range
+};
+//# sourceMappingURL=range.mjs.map

package/dist/range.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/range.ts"],"sourcesContent":["import { format } from \"./format\"\nimport { ap } from \"./ap\"\nimport type { FormatToken } from \"./types\"\n/**\n * Returns an array of options for a given token in a given locale.\n * @param token - Get the full range of options for a given token\n * @param locale - The locale to fetch the options for.\n */\nexport function range(\n  token: FormatToken,\n  locale = \"en\",\n  genitive = false\n): string[] {\n  const r: (n: number, c: (index: number) => string | number) => string[] = (\n    n,\n    c\n  ) =>\n    Array(n)\n      .fill(\"\")\n      .map((_, i) => `${c(i)}`)\n\n  if (token === \"M\") return r(12, (i) => i + 1)\n  if (token === \"MM\")\n    return r(12, (i) => {\n      const m = i + 1\n      return m < 10 ? `0${m}` : m\n    })\n  // MMM and MMMM\n  if (token.startsWith(\"M\"))\n    return range(\"MM\").map((m) =>\n      format(`2000-${m}-05`, token, locale, genitive)\n    )\n  if (token.startsWith(\"d\"))\n    return r(7, (i) => `0${i + 2}`).map((d) =>\n      format(`2022-10-${d}`, token, locale)\n    )\n  if (token === \"a\")\n    return [ap(\"am\", locale).toLowerCase(), ap(\"pm\", locale).toLowerCase()]\n  if (token === \"A\")\n    return [ap(\"am\", locale).toUpperCase(), ap(\"pm\", locale).toUpperCase()]\n  if (token.startsWith(\"Y\")) {\n    const year = new Date().getFullYear()\n    return r(120, (i) => i + 1).reduce(\n      (ranges, i) => {\n        if (i !== \"120\")\n          ranges.push(format(`${year + Number(i)}-06-06`, token, locale))\n        ranges.unshift(format(`${year - Number(i)}-06-06`, token, locale))\n        return ranges\n      },\n      [format(`${year}-06-06`, token, locale)]\n    )\n  }\n  if (token.startsWith(\"D\"))\n    return r(31, (i) => `${token === \"DD\" && i < 9 ? \"0\" : \"\"}${i + 1}`)\n  if (token.startsWith(\"H\"))\n    return r(24, (i) => `${token === \"HH\" && i < 10 ? \"0\" : \"\"}${i}`)\n  if (token.startsWith(\"h\"))\n    return r(12, (i) => `${token === \"hh\" && i < 9 ? \"0\" : \"\"}${i + 1}`)\n  if (token.startsWith(\"m\") || token.startsWith(\"s\"))\n    return r(60, (i) => `${token.length > 1 && i < 10 ? \"0\" : \"\"}${i}`)\n  return []\n}\n"],"mappings":";AAAA,SAAS,cAAc;AACvB,SAAS,UAAU;AAOZ,SAAS,MACd,OACA,SAAS,MACT,WAAW,OACD;AACV,QAAM,IAAoE,CACxE,GACA,MAEA,MAAM,CAAC,EACJ,KAAK,EAAE,EACP,IAAI,CAAC,GAAG,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE;AAE5B,MAAI,UAAU;AAAK,WAAO,EAAE,IAAI,CAAC,MAAM,IAAI,CAAC;AAC5C,MAAI,UAAU;AACZ,WAAO,EAAE,IAAI,CAAC,MAAM;AAClB,YAAM,IAAI,IAAI;AACd,aAAO,IAAI,KAAK,IAAI,CAAC,KAAK;AAAA,IAC5B,CAAC;AAEH,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,MAAM,IAAI,EAAE;AAAA,MAAI,CAAC,MACtB,OAAO,QAAQ,CAAC,OAAO,OAAO,QAAQ,QAAQ;AAAA,IAChD;AACF,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,EAAE,GAAG,CAAC,MAAM,IAAI,IAAI,CAAC,EAAE,EAAE;AAAA,MAAI,CAAC,MACnC,OAAO,WAAW,CAAC,IAAI,OAAO,MAAM;AAAA,IACtC;AACF,MAAI,UAAU;AACZ,WAAO,CAAC,GAAG,MAAM,MAAM,EAAE,YAAY,GAAG,GAAG,MAAM,MAAM,EAAE,YAAY,CAAC;AACxE,MAAI,UAAU;AACZ,WAAO,CAAC,GAAG,MAAM,MAAM,EAAE,YAAY,GAAG,GAAG,MAAM,MAAM,EAAE,YAAY,CAAC;AACxE,MAAI,MAAM,WAAW,GAAG,GAAG;AACzB,UAAM,QAAO,oBAAI,KAAK,GAAE,YAAY;AACpC,WAAO,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE;AAAA,MAC1B,CAAC,QAAQ,MAAM;AACb,YAAI,MAAM;AACR,iBAAO,KAAK,OAAO,GAAG,OAAO,OAAO,CAAC,CAAC,UAAU,OAAO,MAAM,CAAC;AAChE,eAAO,QAAQ,OAAO,GAAG,OAAO,OAAO,CAAC,CAAC,UAAU,OAAO,MAAM,CAAC;AACjE,eAAO;AAAA,MACT;AAAA,MACA,CAAC,OAAO,GAAG,IAAI,UAAU,OAAO,MAAM,CAAC;AAAA,IACzC;AAAA,EACF;AACA,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,EAAE,IAAI,CAAC,MAAM,GAAG,UAAU,QAAQ,IAAI,IAAI,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE;AACrE,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,EAAE,IAAI,CAAC,MAAM,GAAG,UAAU,QAAQ,IAAI,KAAK,MAAM,EAAE,GAAG,CAAC,EAAE;AAClE,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,EAAE,IAAI,CAAC,MAAM,GAAG,UAAU,QAAQ,IAAI,IAAI,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE;AACrE,MAAI,MAAM,WAAW,GAAG,KAAK,MAAM,WAAW,GAAG;AAC/C,WAAO,EAAE,IAAI,CAAC,MAAM,GAAG,MAAM,SAAS,KAAK,IAAI,KAAK,MAAM,EAAE,GAAG,CAAC,EAAE;AACpE,SAAO,CAAC;AACV;","names":[]}

package/dist/removeOffset.d.ts

@@ -0,0 +1,10 @@
+import { DateInput } from './types.js';
+
+/**
+ * Inverts the offset and applies it to the given date, returning a new date.
+ * @param dateInput - The date to remove the offset from.
+ * @param offset - The offset to remove in the +-HHmm or +-HH:mm format.
+ */
+declare function removeOffset(dateInput: DateInput, offset?: string): Date;
+
+export { removeOffset };

package/dist/removeOffset.mjs

@@ -0,0 +1,13 @@
+// src/removeOffset.ts
+import { applyOffset } from "./applyOffset.mjs";
+function removeOffset(dateInput, offset = "+00:00") {
+  const positive = offset.slice(0, 1) === "+";
+  return applyOffset(
+    dateInput,
+    offset.replace(positive ? "+" : "-", positive ? "-" : "+")
+  );
+}
+export {
+  removeOffset
+};
+//# sourceMappingURL=removeOffset.mjs.map

package/dist/removeOffset.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/removeOffset.ts"],"sourcesContent":["import { applyOffset } from \"./applyOffset\"\nimport type { DateInput } from \"./types\"\n\n/**\n * Inverts the offset and applies it to the given date, returning a new date.\n * @param dateInput - The date to remove the offset from.\n * @param offset - The offset to remove in the +-HHmm or +-HH:mm format.\n */\nexport function removeOffset(dateInput: DateInput, offset = \"+00:00\"): Date {\n  const positive = offset.slice(0, 1) === \"+\"\n  return applyOffset(\n    dateInput,\n    offset.replace(positive ? \"+\" : \"-\", positive ? \"-\" : \"+\")\n  )\n}\n"],"mappings":";AAAA,SAAS,mBAAmB;AAQrB,SAAS,aAAa,WAAsB,SAAS,UAAgB;AAC1E,QAAM,WAAW,OAAO,MAAM,GAAG,CAAC,MAAM;AACxC,SAAO;AAAA,IACL;AAAA,IACA,OAAO,QAAQ,WAAW,MAAM,KAAK,WAAW,MAAM,GAAG;AAAA,EAC3D;AACF;","names":[]}

package/dist/sameDay.d.ts

@@ -0,0 +1,10 @@
+import { DateInput } from './types.js';
+
+/**
+ * Checks if two date objects refer to the same date. Ignores time.
+ * @param inputDateA - First date to compare
+ * @param inputDateB - Second date to compare
+ */
+declare function sameDay(inputDateA: DateInput, inputDateB: DateInput): boolean;
+
+export { sameDay };

package/dist/sameDay.mjs

@@ -0,0 +1,11 @@
+// src/sameDay.ts
+import { date } from "./date.mjs";
+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();
+}
+export {
+  sameDay
+};
+//# sourceMappingURL=sameDay.mjs.map

package/dist/sameDay.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sameDay.ts"],"sourcesContent":["import { date } from \"./date\"\nimport type { DateInput } from \"./types\"\n\n/**\n * Checks if two date objects refer to the same date. Ignores time.\n * @param inputDateA - First date to compare\n * @param inputDateB - Second date to compare\n */\nexport function sameDay(inputDateA: DateInput, inputDateB: DateInput) {\n  const a = date(inputDateA)\n  const b = date(inputDateB)\n  return (\n    a.getDate() === b.getDate() &&\n    a.getMonth() === b.getMonth() &&\n    a.getFullYear() === b.getFullYear()\n  )\n}\n"],"mappings":";AAAA,SAAS,YAAY;AAQd,SAAS,QAAQ,YAAuB,YAAuB;AACpE,QAAM,IAAI,KAAK,UAAU;AACzB,QAAM,IAAI,KAAK,UAAU;AACzB,SACE,EAAE,QAAQ,MAAM,EAAE,QAAQ,KAC1B,EAAE,SAAS,MAAM,EAAE,SAAS,KAC5B,EAAE,YAAY,MAAM,EAAE,YAAY;AAEtC;","names":[]}

package/dist/sameHour.d.ts

@@ -0,0 +1,10 @@
+import { DateInput } from './types.js';
+
+/**
+ * Checks if two date objects refer to the same time hour. Ignores date.
+ * @param inputDateA - First date to compare
+ * @param inputDateB - Second date to compare
+ */
+declare function sameHour(inputDateA: DateInput, inputDateB: DateInput): boolean;
+
+export { sameHour };