@autometa/datetime 0.1.15 → 1.0.0-rc.0

package/dist/index.js

@@ -1,605 +1,473 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  DateFactory: () => DateFactory,
-  Dates: () => Dates,
-  FmtDateFactory: () => FmtDateFactory,
-  IsoDateFactory: () => IsoDateFactory,
-  Time: () => Time,
-  TimeDiff: () => TimeDiff,
-  TimeObject: () => TimeObject
-});
-module.exports = __toCommonJS(src_exports);
+import { AutomationError } from '@autometa/errors';
+import { isValidDate, isValidISODateString, isValidTime, isValidYearMonth } from 'iso-datestring-validator';
+import { assertKey } from '@autometa/asserters';
 
 // src/dates/date-factory.ts
-var import_phrases = require("@autometa/phrases");
 
-// src/dates/midnight.ts
-function midnight() {
-  const date = /* @__PURE__ */ new Date();
-  date.setDate(date.getDate() + 1);
-  date.setHours(0, 0, 0, 0);
-  return date;
+// src/dates/clock.ts
+var systemClock = {
+  now: () => /* @__PURE__ */ new Date()
+};
+function cloneDate(date) {
+  return new Date(date.getTime());
+}
+var UNIT_ALIASES = {
+  millisecond: { unit: "milliseconds", scale: 1 },
+  milliseconds: { unit: "milliseconds", scale: 1 },
+  ms: { unit: "milliseconds", scale: 1 },
+  second: { unit: "seconds", scale: 1 },
+  seconds: { unit: "seconds", scale: 1 },
+  sec: { unit: "seconds", scale: 1 },
+  secs: { unit: "seconds", scale: 1 },
+  minute: { unit: "minutes", scale: 1 },
+  minutes: { unit: "minutes", scale: 1 },
+  min: { unit: "minutes", scale: 1 },
+  mins: { unit: "minutes", scale: 1 },
+  hour: { unit: "hours", scale: 1 },
+  hours: { unit: "hours", scale: 1 },
+  hr: { unit: "hours", scale: 1 },
+  hrs: { unit: "hours", scale: 1 },
+  day: { unit: "days", scale: 1 },
+  days: { unit: "days", scale: 1 },
+  week: { unit: "weeks", scale: 1 },
+  weeks: { unit: "weeks", scale: 1 },
+  fortnight: { unit: "days", scale: 14 },
+  fortnights: { unit: "days", scale: 14 },
+  month: { unit: "months", scale: 1 },
+  months: { unit: "months", scale: 1 },
+  year: { unit: "years", scale: 1 },
+  years: { unit: "years", scale: 1 }
+};
+function resolveTimeUnit(input) {
+  const key = input.trim().toLowerCase();
+  const resolved = UNIT_ALIASES[key];
+  if (!resolved) {
+    throw new AutomationError(
+      `Unsupported time unit '${input}'. Expected one of ${Object.keys(UNIT_ALIASES).sort().join(", ")}.`
+    );
+  }
+  return resolved;
+}
+
+// src/shared/phrases.ts
+var SEPARATORS = /[\s_-]+/g;
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+function splitWords(phrase) {
+  return phrase.trim().split(SEPARATORS).filter(Boolean).map((word) => word.toLowerCase());
+}
+function toCamelKey(phrase) {
+  const words = splitWords(phrase);
+  if (words.length === 0) {
+    return "";
+  }
+  const [first, ...rest] = words;
+  return first + rest.map(capitalize).join("");
+}
+function normalizeToken(phrase) {
+  return splitWords(phrase).join("");
 }
 
 // src/dates/date-factory.ts
-var import_errors = require("@autometa/errors");
-var import_asserters = require("@autometa/asserters");
-var import_iso_datestring_validator = require("iso-datestring-validator");
-function isTimeShortcut(text) {
-  const converted = (0, import_phrases.convertPhrase)(text, import_phrases.camel);
-  const includes = [
-    "now",
-    "beforeYesterday",
-    "yesterday",
-    "today",
-    "tomorrow",
-    "afterTomorrow",
-    "midnight",
-    "lastWeek",
-    "nextWeek",
-    "lastFortnight",
-    "nextFortnight"
-  ].includes(converted);
-  if (!includes) {
-    return false;
-  }
-  return true;
+var SHORTCUT_LOOKUP = /* @__PURE__ */ new Set([
+  "now",
+  "beforeYesterday",
+  "yesterday",
+  "today",
+  "tomorrow",
+  "afterTomorrow",
+  "midnight",
+  "lastWeek",
+  "nextWeek",
+  "lastFortnight",
+  "nextFortnight"
+]);
+var FUTURE_PATTERN = /^(\d+)\s+([A-Za-z\s]+?)\s+from\s+now$/i;
+var PAST_PATTERN = /^(\d+)\s+([A-Za-z\s]+?)\s+ago$/i;
+function invalidDate() {
+  return new Date(Number.NaN);
+}
+function isDateShortcut(value) {
+  return SHORTCUT_LOOKUP.has(value);
 }
-var _extractTimeFromPhrase, extractTimeFromPhrase_fn, _extractFutureFromPhrase, extractFutureFromPhrase_fn, _extractPastFromPhrase, extractPastFromPhrase_fn, _addYears, addYears_fn, _addMonths, addMonths_fn, _addWeeks, addWeeks_fn, _addDays, addDays_fn, _addSeconds, addSeconds_fn, _addMilliseconds, addMilliseconds_fn, _addHours, addHours_fn, _addMinutes, addMinutes_fn;
 var DateFactory = class {
-  constructor() {
-    __privateAdd(this, _extractTimeFromPhrase);
-    __privateAdd(this, _extractFutureFromPhrase);
-    __privateAdd(this, _extractPastFromPhrase);
-    __privateAdd(this, _addYears);
-    __privateAdd(this, _addMonths);
-    __privateAdd(this, _addWeeks);
-    __privateAdd(this, _addDays);
-    __privateAdd(this, _addSeconds);
-    __privateAdd(this, _addMilliseconds);
-    __privateAdd(this, _addHours);
-    __privateAdd(this, _addMinutes);
-    this.phraseMap = /* @__PURE__ */ new Map([
-      ["now", () => this.make(0, "days")],
-      ["beforeYesterday", () => this.make(-2, "days")],
-      ["yesterday", () => this.make(-1, "days")],
-      ["today", () => this.make(0, "days")],
-      ["tomorrow", () => this.make(1, "days")],
-      ["afterTomorrow", () => this.make(2, "days")],
-      ["nextWeek", () => this.make(7, "days")],
-      ["lastWeek", () => this.make(-7, "days")],
-      ["nextFortnight", () => this.make(14, "days")],
-      ["lastFortnight", () => this.make(-14, "days")],
-      ["midnight", midnight]
-    ]);
-  }
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  find(name) {
-    const result = this.phraseMap.get(name);
-    if (result) {
-      return result();
+  constructor(options = {}) {
+    this.clock = options.clock ?? systemClock;
+  }
+  find(shortcut) {
+    switch (shortcut) {
+      case "now":
+        return this.currentDate();
+      case "beforeYesterday":
+        return this.make(-2, "days");
+      case "yesterday":
+        return this.make(-1, "days");
+      case "today":
+        return this.make(0, "days");
+      case "tomorrow":
+        return this.make(1, "days");
+      case "afterTomorrow":
+        return this.make(2, "days");
+      case "midnight":
+        return this.midnight();
+      case "lastWeek":
+        return this.make(-1, "weeks");
+      case "nextWeek":
+        return this.make(1, "weeks");
+      case "lastFortnight":
+        return this.make(-14, "days");
+      case "nextFortnight":
+        return this.make(14, "days");
+      default:
+        throw new AutomationError(
+          `Unsupported date shortcut '${shortcut}'.`
+        );
     }
-    (0, import_errors.raise)(
-      `Could not find date shortcut ${name}. Please use a valid date shortcut from the following list: ${Array.from(
-        this.phraseMap.keys()
-      ).join(", ")}`
-    );
   }
   fromPhraseSafe(phrase) {
-    const name = (0, import_phrases.convertPhrase)(phrase, import_phrases.camel);
-    if (isTimeShortcut(name)) {
-      if (this.phraseMap.has(name)) {
-        return this.phraseMap.get(name)?.call(this);
-      }
+    if (typeof phrase !== "string") {
+      return invalidDate();
+    }
+    const trimmed = phrase.trim();
+    if (trimmed.length === 0) {
+      return invalidDate();
     }
-    const matchDay = __privateMethod(this, _extractTimeFromPhrase, extractTimeFromPhrase_fn).call(this, phrase);
-    if (matchDay) {
-      return matchDay;
+    const shortcutCandidate = toCamelKey(trimmed);
+    if (isDateShortcut(shortcutCandidate)) {
+      return this.find(shortcutCandidate);
     }
-    const first = (0, import_iso_datestring_validator.isValidDate)(phrase);
-    const second = (0, import_iso_datestring_validator.isValidISODateString)(phrase);
-    const third = (0, import_iso_datestring_validator.isValidTime)(phrase);
-    const fourth = (0, import_iso_datestring_validator.isValidYearMonth)(phrase);
-    if (!first && !second && !third && !fourth) {
-      return /* @__PURE__ */ new Date("null");
+    const relative = this.extractRelative(trimmed);
+    if (relative) {
+      return this.make(relative.offset, relative.unit);
     }
-    const parsed = new Date(phrase);
-    if (isNaN(parsed.getTime())) {
-      return new Date(Date.parse(phrase));
+    if (this.isDateLike(trimmed)) {
+      return this.parseDate(trimmed);
     }
-    return parsed;
+    return invalidDate();
   }
   fromPhrase(phrase) {
     const result = this.fromPhraseSafe(phrase);
-    if (result) {
-      return result;
+    if (Number.isNaN(result.getTime())) {
+      throw new AutomationError(
+        `Could not parse date from phrase '${String(phrase)}'. Valid shortcuts are: ${[...SHORTCUT_LOOKUP].join(", ")}.`
+      );
     }
-    (0, import_errors.raise)(
-      `Could not parse date from phrase ${phrase}. Please use a valid date string or a phrase from the following list: ${Array.from(
-        this.phraseMap.keys()
-      ).join(", ")}`
-    );
+    return result;
   }
-  make(timeOffset, timeunit) {
-    const unit = timeunit.endsWith("s") ? timeunit : `${timeunit}s`;
+  make(timeOffset, timeUnit) {
+    if (!Number.isFinite(timeOffset)) {
+      throw new AutomationError(
+        `Time offset must be finite. Received '${timeOffset}'.`
+      );
+    }
+    const { unit, scale } = resolveTimeUnit(String(timeUnit));
+    const offset = timeOffset * scale;
+    const date = this.currentDate();
     switch (unit) {
       case "years":
-        return __privateMethod(this, _addYears, addYears_fn).call(this, timeOffset);
+        date.setFullYear(date.getFullYear() + offset);
+        break;
       case "months":
-        return __privateMethod(this, _addMonths, addMonths_fn).call(this, timeOffset);
+        date.setMonth(date.getMonth() + offset);
+        break;
       case "weeks":
-        return __privateMethod(this, _addWeeks, addWeeks_fn).call(this, timeOffset);
+        date.setDate(date.getDate() + offset * 7);
+        break;
       case "days":
-        return __privateMethod(this, _addDays, addDays_fn).call(this, timeOffset);
-      case "seconds":
-        return __privateMethod(this, _addSeconds, addSeconds_fn).call(this, timeOffset);
-      case "milliseconds":
-        return __privateMethod(this, _addMilliseconds, addMilliseconds_fn).call(this, timeOffset);
+        date.setDate(date.getDate() + offset);
+        break;
       case "hours":
-        return __privateMethod(this, _addHours, addHours_fn).call(this, timeOffset);
+        date.setHours(date.getHours() + offset);
+        break;
       case "minutes":
-        return __privateMethod(this, _addMinutes, addMinutes_fn).call(this, timeOffset);
+        date.setMinutes(date.getMinutes() + offset);
+        break;
+      case "seconds":
+        date.setSeconds(date.getSeconds() + offset);
+        break;
+      case "milliseconds":
+        date.setMilliseconds(date.getMilliseconds() + offset);
+        break;
       default:
-        throw new import_errors.AutomationError(
-          `Invalid timeunit ${timeunit}, options are 'days', 'seconds', 'milliseconds', 'hours', 'minutes'. Non plural equivalents such as 'day' or 'week' are also accepted.`
-        );
+        throw new AutomationError(`Unsupported time unit '${unit}'.`);
     }
+    return date;
   }
-};
-_extractTimeFromPhrase = new WeakSet();
-extractTimeFromPhrase_fn = function(phrase) {
-  return __privateMethod(this, _extractFutureFromPhrase, extractFutureFromPhrase_fn).call(this, phrase) ?? __privateMethod(this, _extractPastFromPhrase, extractPastFromPhrase_fn).call(this, phrase);
-};
-_extractFutureFromPhrase = new WeakSet();
-extractFutureFromPhrase_fn = function(phrase) {
-  const pastPattern = /^(\d+) (.*)s? from now?/;
-  const pastMatch = pastPattern.exec(phrase);
-  if ((0, import_asserters.ConfirmDefined)(pastMatch) && (0, import_asserters.ConfirmLengthAtLeast)(pastMatch, 3)) {
-    const [_, value, unit] = pastMatch;
-    const timeunit = (0, import_phrases.convertPhrase)(unit, import_phrases.collapse);
-    return this.make(Number(value), timeunit);
+  currentDate() {
+    return cloneDate(this.clock.now());
   }
-};
-_extractPastFromPhrase = new WeakSet();
-extractPastFromPhrase_fn = function(phrase) {
-  const pastPattern = /^(\d+) (.*)(s)? ago?/gm;
-  const pastMatch = pastPattern.exec(phrase);
-  if ((0, import_asserters.ConfirmDefined)(pastMatch) && (0, import_asserters.ConfirmLengthAtLeast)(pastMatch, 3)) {
-    const [_, value, unit] = pastMatch;
-    const timeunit = (0, import_phrases.convertPhrase)(unit, import_phrases.camel);
-    return this.make(-Number(value), timeunit);
+  midnight() {
+    const date = this.currentDate();
+    date.setUTCDate(date.getUTCDate() + 1);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+  parseDate(value) {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+    return new Date(Date.parse(value));
+  }
+  isDateLike(value) {
+    if (!Number.isNaN(new Date(value).getTime())) {
+      return true;
+    }
+    return isValidDate(value) || isValidISODateString(value) || isValidTime(value) || isValidYearMonth(value);
+  }
+  extractRelative(phrase) {
+    const futureMatch = FUTURE_PATTERN.exec(phrase);
+    if (futureMatch) {
+      return this.buildRelativeMatch(futureMatch, 1);
+    }
+    const pastMatch = PAST_PATTERN.exec(phrase);
+    if (pastMatch) {
+      return this.buildRelativeMatch(pastMatch, -1);
+    }
+    return void 0;
+  }
+  buildRelativeMatch(match, direction) {
+    const value = match[1];
+    const unit = match[2];
+    if (!value || !unit) {
+      return void 0;
+    }
+    const magnitude = Number.parseInt(value, 10);
+    if (!Number.isFinite(magnitude)) {
+      return void 0;
+    }
+    const convertedUnit = normalizeToken(unit);
+    const { unit: normalisedUnit, scale } = resolveTimeUnit(convertedUnit);
+    const offset = magnitude * scale * direction;
+    return {
+      offset,
+      unit: normalisedUnit
+    };
   }
-};
-_addYears = new WeakSet();
-addYears_fn = function(yearsOffset) {
-  const date = /* @__PURE__ */ new Date();
-  date.setFullYear(date.getFullYear() + yearsOffset);
-  return date;
-};
-_addMonths = new WeakSet();
-addMonths_fn = function(monthOffset) {
-  const date = /* @__PURE__ */ new Date();
-  date.setMonth(date.getMonth() + monthOffset);
-  return date;
-};
-_addWeeks = new WeakSet();
-addWeeks_fn = function(weekOffset) {
-  const date = /* @__PURE__ */ new Date();
-  date.setMonth(date.getMonth() + weekOffset / 4);
-  return date;
-};
-_addDays = new WeakSet();
-addDays_fn = function(daysOffset) {
-  const date = /* @__PURE__ */ new Date();
-  date.setDate(date.getDate() + daysOffset);
-  return date;
-};
-_addSeconds = new WeakSet();
-addSeconds_fn = function(secondsOffset) {
-  const date = /* @__PURE__ */ new Date();
-  date.setSeconds(date.getSeconds() + secondsOffset);
-  return date;
-};
-_addMilliseconds = new WeakSet();
-addMilliseconds_fn = function(millisecondsOffset) {
-  const date = /* @__PURE__ */ new Date();
-  date.setMilliseconds(date.getMilliseconds() + millisecondsOffset);
-  return date;
-};
-_addHours = new WeakSet();
-addHours_fn = function(hoursOffset) {
-  const date = /* @__PURE__ */ new Date();
-  date.setHours(date.getHours() + hoursOffset);
-  return date;
-};
-_addMinutes = new WeakSet();
-addMinutes_fn = function(minutesOffset) {
-  const date = /* @__PURE__ */ new Date();
-  date.setMinutes(date.getMinutes() + minutesOffset);
-  return date;
 };
 
-// src/dates/iso-date-factory.ts
-var IsoDateFactory = class {
-  constructor(dateFactory) {
+// src/dates/formatted-date-factory.ts
+var FormattedDateFactory = class {
+  constructor(dateFactory, options = {}) {
     this.dateFactory = dateFactory;
-    this.phraseMap = /* @__PURE__ */ new Map([
-      ["beforeYesterday", this.make(-2, "days")],
-      ["yesterday", this.make(-1, "days")],
-      ["today", this.make(0, "days")],
-      ["tomorrow", this.make(1, "days")],
-      ["afterTomorrow", this.make(2, "days")],
-      ["nextWeek", this.make(7, "days")],
-      ["lastWeek", this.make(-7, "days")],
-      ["nextFortnight", this.make(14, "days")],
-      ["lastFortnight", this.make(-14, "days")],
-      ["midnight", midnight().toISOString()]
-    ]);
-  }
-  make(daysOffset, timeunit) {
-    return this.dateFactory.make(daysOffset, timeunit).toISOString();
-  }
-  /**
-   * Attempts to parse a phrase into a date.
-   * @param phrase
-   * @returns
-   */
+    this.format = options.formatter ?? ((date) => date.toISOString().substring(0, 10));
+  }
+  make(offset, unit) {
+    return this.format(this.dateFactory.make(offset, unit));
+  }
   fromPhrase(phrase) {
-    return this.dateFactory.fromPhrase(phrase)?.toISOString();
+    return this.format(this.dateFactory.fromPhrase(phrase));
   }
-  /**
-   * Returns the date and time of the day before yesterday
-   */
   get beforeYesterday() {
-    return this.phraseMap.get("beforeYesterday");
+    return this.fromShortcut("beforeYesterday");
   }
-  /**
-   * Returns the date and time of yesterday
-   */
   get yesterday() {
-    return this.phraseMap.get("yesterday");
+    return this.fromShortcut("yesterday");
   }
-  /**
-   * Returns the date and time of today
-   */
   get today() {
-    return this.phraseMap.get("today");
+    return this.fromShortcut("today");
   }
-  /**
-   * Returns the date and time of tomorrow
-   */
   get tomorrow() {
-    return this.phraseMap.get("tomorrow");
+    return this.fromShortcut("tomorrow");
   }
-  /**
-   * Returns the date and time of the day after tomorrow
-   */
   get afterTomorrow() {
-    return this.phraseMap.get("afterTomorrow");
+    return this.fromShortcut("afterTomorrow");
   }
-  /**
-   * Returns the date and time of midnight today
-   */
   get midnight() {
-    return this.phraseMap.get("midnight");
+    return this.fromShortcut("midnight");
   }
-  /**
-   * Returns the date and time of today 1 week ago
-   */
   get lastWeek() {
-    return this.phraseMap.get("lastWeek");
+    return this.fromShortcut("lastWeek");
   }
-  /**
-   * Returns the date and time of today 1 week from now
-   */
   get nextWeek() {
-    return this.phraseMap.get("nextWeek");
+    return this.fromShortcut("nextWeek");
   }
   get lastFortnight() {
-    return this.phraseMap.get("lastFortnight");
+    return this.fromShortcut("lastFortnight");
   }
-  /**
-   * Returns the date and time of today 1 fortnight from now
-   */
   get nextFortnight() {
-    return this.phraseMap.get("nextFortnight");
+    return this.fromShortcut("nextFortnight");
+  }
+  fromShortcut(shortcut) {
+    return this.format(this.dateFactory.find(shortcut));
   }
 };
 
-// src/dates/formatted-date-factory.ts
-var FmtDateFactory = class {
-  constructor(dateFactory) {
+// src/dates/iso-date-factory.ts
+var IsoDateFactory = class {
+  constructor(dateFactory, options = {}) {
     this.dateFactory = dateFactory;
-    this.phraseMap = /* @__PURE__ */ new Map([
-      ["beforeYesterday", this.make(-2, "days")],
-      ["yesterday", this.make(-1, "days")],
-      ["today", this.make(0, "days")],
-      ["tomorrow", this.make(1, "days")],
-      ["afterTomorrow", this.make(2, "days")],
-      ["nextWeek", this.make(7, "days")],
-      ["lastWeek", this.make(-7, "days")],
-      ["nextFortnight", this.make(14, "days")],
-      ["lastFortnight", this.make(-14, "days")],
-      ["midnight", midnight().toISOString()]
-    ]);
-  }
-  make(daysOffset, timeunit) {
-    return this.dateFactory.make(daysOffset, timeunit).toISOString().split("T")[0];
-  }
-  /**
-   * Attempts to parse a phrase into a date.
-   * @param phrase
-   * @returns
-   */
+    this.serialise = options.serializer ?? ((date) => date.toISOString());
+  }
+  make(offset, unit) {
+    return this.serialise(this.dateFactory.make(offset, unit));
+  }
   fromPhrase(phrase) {
-    return this.dateFactory.fromPhrase(phrase)?.toISOString().split("T")[0];
+    return this.serialise(this.dateFactory.fromPhrase(phrase));
   }
-  /**
-   * Returns the date and time of the day before yesterday
-   */
   get beforeYesterday() {
-    return this.phraseMap.get("beforeYesterday");
+    return this.fromShortcut("beforeYesterday");
   }
-  /**
-   * Returns the date and time of yesterday
-   */
   get yesterday() {
-    return this.phraseMap.get("yesterday");
+    return this.fromShortcut("yesterday");
   }
-  /**
-   * Returns the date and time of today
-   */
   get today() {
-    return this.phraseMap.get("today");
+    return this.fromShortcut("today");
   }
-  /**
-   * Returns the date and time of tomorrow
-   */
   get tomorrow() {
-    return this.phraseMap.get("tomorrow");
+    return this.fromShortcut("tomorrow");
   }
-  /**
-   * Returns the date and time of the day after tomorrow
-   */
   get afterTomorrow() {
-    return this.phraseMap.get("afterTomorrow");
+    return this.fromShortcut("afterTomorrow");
   }
-  /**
-   * Returns the date and time of midnight today
-   */
   get midnight() {
-    return this.phraseMap.get("midnight");
+    return this.fromShortcut("midnight");
   }
-  /**
-   * Returns the date and time of today 1 week ago
-   */
   get lastWeek() {
-    return this.phraseMap.get("lastWeek");
+    return this.fromShortcut("lastWeek");
   }
-  /**
-   * Returns the date and time of today 1 week from now
-   */
   get nextWeek() {
-    return this.phraseMap.get("nextWeek");
+    return this.fromShortcut("nextWeek");
   }
-  /**
-   * Returns the date and time of today 1 fortnight ago
-   */
   get lastFortnight() {
-    return this.phraseMap.get("lastFortnight");
+    return this.fromShortcut("lastFortnight");
   }
-  /**
-   * Returns the date and time of today 1 fortnight from now
-   */
   get nextFortnight() {
-    return this.phraseMap.get("nextFortnight");
+    return this.fromShortcut("nextFortnight");
+  }
+  fromShortcut(shortcut) {
+    return this.serialise(this.dateFactory.find(shortcut));
   }
 };
 
-// src/dates/dates.ts
-var _factory, _iso, _fmt;
-var DatesObject = class {
-  constructor() {
-    __privateAdd(this, _factory, new DateFactory());
-    __privateAdd(this, _iso, new IsoDateFactory(__privateGet(this, _factory)));
-    __privateAdd(this, _fmt, new FmtDateFactory(__privateGet(this, _factory)));
-  }
-  /**
-   * Switches to the ISO factory, which offers an identical interface
-   * but returns ISO strings instead of Date objects.
-   * 
-   * Example: `2020-01-01T00:00:00.000Z`
-   */
-  get iso() {
-    return __privateGet(this, _iso);
-  }
-  /**
-   * Switches to the formatted factory, which offers an identical interface
-   * but returns formatted strings instead of Date objects.
-   * 
-   * Example: `2020-01-01`
-   */
-  get fmt() {
-    return __privateGet(this, _fmt);
-  }
-  /**
-   * Returns the current date and time.
-   */
+// src/dates/object.ts
+var DatesFacade = class {
+  constructor(factory) {
+    this.factory = factory;
+    this.iso = new IsoDateFactory(factory);
+    this.fmt = new FormattedDateFactory(factory);
+  }
   get now() {
-    return __privateGet(this, _factory).find("now");
+    return this.fromShortcut("now");
   }
-  /**
-   * Returns the date and time of the day before yesterday
-   */
   get beforeYesterday() {
-    return __privateGet(this, _factory).find("beforeYesterday");
+    return this.fromShortcut("beforeYesterday");
   }
-  /**
-   * Returns the date and time of yesterday
-   */
   get yesterday() {
-    return __privateGet(this, _factory).find("yesterday");
+    return this.fromShortcut("yesterday");
   }
-  /**
-   * Returns the date and time of today
-   */
   get today() {
-    return __privateGet(this, _factory).find("today");
+    return this.fromShortcut("today");
   }
-  /**
-   * Returns the date and time of tomorrow
-   */
   get tomorrow() {
-    return __privateGet(this, _factory).find("tomorrow");
+    return this.fromShortcut("tomorrow");
   }
-  /**
-   * Returns the date and time of the day after tomorrow
-   */
   get afterTomorrow() {
-    return __privateGet(this, _factory).find("afterTomorrow");
+    return this.fromShortcut("afterTomorrow");
   }
-  /**
-   * Returns the date and time of midnight today
-   */
   get midnight() {
-    return __privateGet(this, _factory).find("midnight");
+    return this.fromShortcut("midnight");
   }
-  /**
-   * Returns the date and time of today 1 week ago
-   */
   get lastWeek() {
-    return __privateGet(this, _factory).find("lastWeek");
+    return this.fromShortcut("lastWeek");
   }
-  /**
-   * Returns the date and time of today 1 week from now
-   */
   get nextWeek() {
-    return __privateGet(this, _factory).find("nextWeek");
+    return this.fromShortcut("nextWeek");
   }
-  /**
-   * Returns the date and time of today 2 weeks ago
-   */
   get lastFortnight() {
-    return __privateGet(this, _factory).find("lastFortnight");
+    return this.fromShortcut("lastFortnight");
   }
-  /**
-   * Returns the date and time of today 2 weeks from now
-   */
   get nextFortnight() {
-    return __privateGet(this, _factory).find("nextFortnight");
+    return this.fromShortcut("nextFortnight");
   }
-  /**
-   * Attempts to parse a phrase into a date.
-   * @param phrase 
-   * @returns 
-   */
   fromPhrase(phrase) {
-    return __privateGet(this, _factory).fromPhrase(phrase);
-  }
-  /**
-   * Attempts to parse a phrase into a date.
-   * If the phrase is invalid, it will return an invalid date instead of throwing.
-   * @param phrase 
-   * @returns 
-   */
+    return this.factory.fromPhrase(phrase);
+  }
   fromPhraseSafe(phrase) {
-    return __privateGet(this, _factory).fromPhraseSafe(phrase);
+    return this.factory.fromPhraseSafe(phrase);
   }
-  make(timeOffset, timeUnit) {
-    return __privateGet(this, _factory).make(timeOffset, timeUnit);
+  make(offset, unit) {
+    return this.factory.make(offset, unit);
+  }
+  fromShortcut(shortcut) {
+    return this.factory.find(shortcut);
   }
 };
-_factory = new WeakMap();
-_iso = new WeakMap();
-_fmt = new WeakMap();
-var Dates = new DatesObject();
-
-// src/time/time.ts
-var import_asserters2 = require("@autometa/asserters");
-var import_phrases2 = require("@autometa/phrases");
+function createDates(options = {}) {
+  const factory = options.factory ?? new DateFactory(options);
+  return new DatesFacade(factory);
+}
+var Dates = createDates();
+var SUPPORTED_METHODS = [
+  "minutes",
+  "seconds",
+  "millis",
+  "days",
+  "hours",
+  "weeks"
+];
+function toTime(date) {
+  return new Date(date).getTime();
+}
 var TimeDiff = class {
-  minutes(date1, date2) {
-    return this.millis(date1, date2) / 6e4;
+  minutes(start, end) {
+    return this.millis(start, end) / 6e4;
   }
-  seconds(date1, date2) {
-    return this.millis(date1, date2) / 1e3;
+  seconds(start, end) {
+    return this.millis(start, end) / 1e3;
   }
-  millis(date1, date2) {
-    const d1 = new Date(date1).getTime();
-    const d2 = new Date(date2).getTime();
-    return Math.abs(Math.round(d2 - d1));
+  millis(start, end) {
+    const distance = Math.abs(toTime(end) - toTime(start));
+    return Math.round(distance);
   }
-  days(date1, date2) {
-    return this.millis(date1, date2) / 864e5;
+  days(start, end) {
+    return this.millis(start, end) / 864e5;
   }
-  hours(date1, date2) {
-    return this.millis(date1, date2) / 36e5;
+  hours(start, end) {
+    return this.millis(start, end) / 36e5;
   }
-  weeks(date1, date2) {
-    return this.millis(date1, date2) / 6048e5;
+  weeks(start, end) {
+    return this.millis(start, end) / 6048e5;
   }
   fromPhrase(phrase) {
-    const propertyKey = (0, import_phrases2.convertPhrase)(phrase, import_phrases2.lower);
-    (0, import_asserters2.AssertKey)(this, propertyKey);
-    return this[propertyKey].bind(this);
+    if (typeof phrase !== "string") {
+      throw new AutomationError(
+        `TimeDiff.fromPhrase expects a string, received '${typeof phrase}'.`
+      );
+    }
+    const key = normalizeToken(phrase);
+    if (!this.hasMethod(key)) {
+      throw new AutomationError(
+        `Unsupported diff unit '${phrase}'. Expected one of ${this.supportedMethods().join(", ")}.`
+      );
+    }
+    assertKey(this, key, "TimeDiff.fromPhrase");
+    const method = this[key];
+    if (typeof method !== "function") {
+      throw new AutomationError(`Diff method '${key}' is not callable.`);
+    }
+    return method.bind(this);
   }
-};
-var _diff;
-var TimeObject = class {
-  constructor() {
-    __privateAdd(this, _diff, new TimeDiff());
+  hasMethod(name) {
+    return SUPPORTED_METHODS.includes(name);
+  }
+  supportedMethods() {
+    return [...SUPPORTED_METHODS];
   }
-  get diff() {
-    return __privateGet(this, _diff);
+};
+
+// src/time/time.ts
+var TimeFacade = class {
+  constructor(diff) {
+    this.diff = diff;
   }
 };
-_diff = new WeakMap();
-var Time = new TimeObject();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DateFactory,
-  Dates,
-  FmtDateFactory,
-  IsoDateFactory,
-  Time,
-  TimeDiff,
-  TimeObject
-});
+function createTime() {
+  return new TimeFacade(new TimeDiff());
+}
+var Time = createTime();
+
+export { DateFactory, Dates, FormattedDateFactory, IsoDateFactory, Time, TimeDiff, createDates, createTime };
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map