@stacksjs/datetime 0.58.73 → 0.59.2

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { useDateFormat, useNow } from '@stacksjs/utils';
+declare const now: typeof useNow;
+declare const dateFormat: typeof useDateFormat;
+export { now, dateFormat };
+export { format, parse } from '@formkit/tempo';

package/dist/index.js

@@ -1,9 +1,704 @@
 // @bun
 // src/index.ts
 import {useDateFormat, useNow} from "@stacksjs/utils";
+
+// ../../../../node_modules/@formkit/tempo/dist/index.mjs
+var iso8601 = function(date2) {
+  const matches = date2.match(iso8601Match);
+  if (matches) {
+    const month = Number(matches[2]);
+    if (month < 1 || month > 12)
+      return false;
+    if (typeof matches[3] !== undefined) {
+      const date3 = Number(matches[3]);
+      if (date3 < 1 || date3 > 31)
+        return false;
+    }
+    if (typeof matches[4] !== undefined) {
+      const hours = Number(matches[4]);
+      if (hours < 0 || hours > 23)
+        return false;
+    }
+    return true;
+  }
+  return false;
+};
+var normalize = function(date2) {
+  const matches = date2.match(iso8601Match);
+  if (matches && typeof matches[4] === "undefined") {
+    return date2 += "T00:00:00";
+  }
+  return date2;
+};
+var date = function(date2) {
+  if (!date2) {
+    date2 = new Date;
+  }
+  if (date2 instanceof Date) {
+    const d = new Date(date2);
+    d.setMilliseconds(0);
+    return d;
+  }
+  date2 = date2.trim();
+  if (iso8601(date2)) {
+    return new Date(normalize(date2));
+  }
+  throw new Error(`Non ISO 8601 compliant date (${date2}).`);
+};
+var monthEnd = function(inputDate) {
+  const d = date(inputDate);
+  d.setDate(1);
+  d.setMonth(d.getMonth() + 1);
+  d.setDate(0);
+  return d;
+};
+var monthDays = function(inputDate) {
+  const d = monthEnd(inputDate);
+  return d.getDate();
+};
+var normStr = function(part) {
+  if (part.type === "literal") {
+    part.value = part.value.normalize("NFKC");
+  }
+  return part;
+};
+var fill = function(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/, "");
+    }
+    if ((partName === "minute" || partName === "second") && (token === "mm" || token === "ss") && 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 === "timeZoneName") {
+      return offset2 != null ? offset2 : minsToOffset(-1 * d.getTimezoneOffset());
+    }
+    return value2;
+  }
+  return parts2.map((part) => {
+    return {
+      ...part,
+      value: value(part)
+    };
+  });
+};
+var createPartMap = function(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;
+  }, {});
+};
+var minsToOffset = function(timeDiffInMins) {
+  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 ? "-" : "+";
+  return `${sign}${hours}${mins}`;
+};
+var offsetToMins = function(offset2) {
+  validOffset(offset2);
+  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;
+};
+var validOffset = function(offset2) {
+  const valid = /^([+-])[0-3][0-9][0-6][0-9]$/.test(offset2);
+  if (!valid)
+    throw new Error(`Invalid offset: ${offset2}`);
+  return offset2;
+};
+var escapeTokens = function(str) {
+  return clockAgnostic.concat(clock24).concat(clock12).sort((a, b) => a[0].length > b[0].length ? 1 : -1).reduce((target, part) => {
+    return target.replace(part[0], `\\${part[0]}`);
+  }, str);
+};
+var isNumeric = function(part) {
+  return ["numeric", "2-digit"].includes(part.partValue);
+};
+var validate = function(parts2) {
+  let lastPart = undefined;
+  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")) {
+        throw new Error(`Illegal adjacent tokens (${lastPart.token}, ${part.token})`);
+      }
+    }
+    lastPart = part;
+  }
+  return parts2;
+};
+var ap = function(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;
+};
+var applyOffset = function(dateInput, offset2 = "+0000") {
+  const d = date(dateInput);
+  const timeDiffInMins = offsetToMins(offset2);
+  return new Date(d.getTime() + timeDiffInMins * 1000 * 60);
+};
+var deviceTZ = function() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+};
+var relativeTime = function(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 new Date(`${parts2.year}-${parts2.month}-${parts2.day}T${parts2.hour}:${parts2.minute}:${parts2.second}Z`);
+};
+var offset = function(utcTime, tzA = "UTC", tzB = "device") {
+  tzB = tzB === "device" ? deviceTZ() : tzB;
+  const d = date(utcTime);
+  const timeA = relativeTime(d, tzA);
+  const timeB = relativeTime(d, tzB);
+  const timeDiffInMins = (timeB.getTime() - timeA.getTime()) / 1000 / 60;
+  return minsToOffset(timeDiffInMins);
+};
+var parts = function(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)).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 === ""));
+};
+var styleParts = function(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(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 : undefined);
+    if (formatPattern === undefined)
+      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);
+};
+var guessPattern = function(partName, partValue, locale, hour) {
+  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":
+      const offset2 = partValue.split("-");
+      return offset2.length === 2 && offset2[1].length === 4 ? tokens.get("ZZ") : tokens.get("Z");
+    default:
+      return;
+  }
+};
+var partStyle = function(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] : undefined;
+};
+var removeOffset = function(dateInput, offset2 = "+0000") {
+  const positive = offset2.slice(0, 1) === "+";
+  return applyOffset(dateInput, offset2.replace(positive ? "+" : "-", positive ? "-" : "+"));
+};
+var deviceLocale = function() {
+  return Intl.DateTimeFormat().resolvedOptions().locale;
+};
+var format = function(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);
+  }
+  tz != null || (tz = deviceTZ());
+  if (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("");
+};
+var formatStr = function(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");
+};
+var fourDigitYear = function(value) {
+  const y = (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;
+};
+var range = function(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 = (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 [];
+};
+var parse = function(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 = new Date;
+  const parsed = new Map([
+    ["YYYY", now.getFullYear()],
+    ["MM", now.getMonth() + 1],
+    ["DD", now.getDate()],
+    ["HH", 0],
+    ["mm", 0],
+    ["ss", 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 (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") {
+        offset2 = validOffset(part.value);
+      } 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(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 d = new Date(isoString);
+  if (isFinite(+d))
+    return d;
+  return invalid();
+};
+var parseParts = function(dateStr, formatParts) {
+  let i = 0;
+  const advance = (parts2) => [
+    parts2[i++],
+    parts2[i]
+  ];
+  let pos = 0;
+  const parsed = [];
+  let n = undefined;
+  do {
+    const [current, next] = advance(formatParts);
+    n = next;
+    let len = 1;
+    if (current.partName === "literal") {
+      len = current.partValue.length;
+    } 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;
+};
+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]{4})?$/;
+var specDate = "1999-03-04T02:05:01.000Z";
+var memoParts = 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" }],
+  ["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 fixedLength = {
+  DD: 2,
+  HH: 2,
+  MM: 2,
+  YY: 2,
+  YYYY: 4,
+  hh: 2,
+  mm: 2,
+  ss: 2,
+  Z: 5
+};
+var genitiveTokens = ["MMMM", "MMM", "dddd", "ddd"];
+var tokens = new Map([...clockAgnostic, ...clock24, ...clock12].map((format2) => {
+  return [format2[0], format2];
+}));
+var dayPeriodMap = new Map;
+var styles = [
+  "full",
+  "long",
+  "medium",
+  "short"
+];
+var two = (n) => String(n).padStart(2, "0");
+var four = (n) => String(n).padStart(2, "0");
+
+// src/index.ts
 var now = useNow;
 var dateFormat = useDateFormat;
 export {
+  parse,
   now,
+  format,
   dateFormat
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/datetime",
   "type": "module",
-  "version": "0.58.73",
+  "version": "0.59.2",
   "description": "The Stacks datetime helpers.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -49,6 +49,7 @@
     "prepublishOnly": "bun --bun run build"
   },
   "dependencies": {
+    "@formkit/tempo": "^0.0.14",
     "@stacksjs/utils": "latest"
   },
   "devDependencies": {

package/src/index.ts

@@ -5,3 +5,5 @@ const dateFormat = useDateFormat
 
 // useNow and useDateFormat are exported from @stacksjs/utils
 export { now, dateFormat }
+
+export { format, parse } from '@formkit/tempo'