@zelgadis87/utils-core 5.2.9 → 5.2.11

package/esbuild/index.cjs

@@ -1,13 +1,8 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,154 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/format.js
-var require_format = __commonJS({
-  "../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/format.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2["default"] = format2;
-    function ownKeys(object, enumerableOnly) {
-      var keys = Object.keys(object);
-      if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) {
-          symbols = symbols.filter(function(sym) {
-            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-          });
-        }
-        keys.push.apply(keys, symbols);
-      }
-      return keys;
-    }
-    function _objectSpread(target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i] != null ? arguments[i] : {};
-        if (i % 2) {
-          ownKeys(Object(source), true).forEach(function(key) {
-            _defineProperty(target, key, source[key]);
-          });
-        } else if (Object.getOwnPropertyDescriptors) {
-          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-        } else {
-          ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-          });
-        }
-      }
-      return target;
-    }
-    function _defineProperty(obj, key, value) {
-      if (key in obj) {
-        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
-      } else {
-        obj[key] = value;
-      }
-      return obj;
-    }
-    var PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
-    var ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"|(\+)/g;
-    var optionNames = {
-      y: "year",
-      M: "month",
-      d: "day",
-      D: "weekday",
-      S: "fractionalSecondDigits",
-      G: "era",
-      Z: "timeZoneName",
-      P: "dayPeriod",
-      a: "hour12",
-      h: "hour",
-      H: "hour",
-      m: "minute",
-      s: "second"
-    };
-    var values = {
-      y: ["numeric", "2-digit", void 0, "numeric"],
-      M: ["narrow", "2-digit", "short", "long"],
-      d: ["numeric", "2-digit"],
-      D: ["narrow", "short", "long"],
-      S: [1, 2, 3],
-      G: ["narrow", "short", "long"],
-      Z: ["short", "long"],
-      P: ["narrow", "short", "long"],
-      a: [true],
-      h: ["numeric", "2-digit"],
-      H: ["numeric", "2-digit"],
-      m: ["numeric", "2-digit"],
-      s: ["numeric", "2-digit"]
-    };
-    function padIf(condition, value, length) {
-      return condition && length === 2 && value / 10 < 1 ? "0" + value : value;
-    }
-    function formatType(date, type, length) {
-      var _options;
-      var _ref = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}, locale = _ref.locale, timeZone = _ref.timeZone;
-      var option = optionNames[type];
-      var value = values[type][length - 1];
-      if (!value) {
-        return;
-      }
-      var options = (_options = {}, _defineProperty(_options, option, value), _defineProperty(_options, "timeZone", timeZone), _options);
-      if (type === "a") {
-        return Intl.DateTimeFormat(locale, _objectSpread(_objectSpread({}, options), {}, {
-          hour: "numeric"
-        })).formatToParts(date).pop().value;
-      }
-      if (type === "G" || type === "Z") {
-        return Intl.DateTimeFormat(locale, options).formatToParts(date).pop().value;
-      }
-      if (type === "H" || type === "h") {
-        return Intl.DateTimeFormat("en-GB", _objectSpread(_objectSpread({}, options), {}, {
-          hourCycle: type === "H" ? "h23" : "h11"
-        })).format(date).toLocaleLowerCase().replace(" am", "").replace(" pm", "");
-      }
-      return padIf(["m", "s"].includes(type) && value === "2-digit", Intl.DateTimeFormat(locale, options).format(date), 2);
-    }
-    function format2(date, pattern, config) {
-      return pattern.split(ESCAPE_REGEX).filter(function(sub) {
-        return sub !== void 0;
-      }).map(function(sub, index) {
-        if (index % 2 !== 0) {
-          return sub;
-        }
-        return sub.replace(PATTERN_REGEX, function(match) {
-          var type = match.charAt(0);
-          return formatType(date, type, match.length, config) || match;
-        });
-      }).join("");
-    }
-  }
-});
-
-// ../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/index.js
-var require_lib = __commonJS({
-  "../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/index.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", {
-      value: true
-    });
-    exports2.format = void 0;
-    var _format = require_format();
-    var _format2 = _interopRequireDefault(_format);
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    exports2.format = _format2["default"];
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -1720,9 +1569,6 @@ var LazyDictionary = class _LazyDictionary {
   }
 };
 
-// src/time/TimeInstant.ts
-var import_small_date = __toESM(require_lib());
-
 // src/time/TimeUnit.ts
 var TimeUnit = class _TimeUnit {
   constructor(multiplier) {
@@ -1889,13 +1735,13 @@ var TimeDuration = class _TimeDuration extends TimeBase {
   	* @returns the duration, with only the most significant units displayed as a human readable string, eg: 1d 20h, 10m 30s.
   */
   get formatted() {
-    const format2 = (x, u1, y, u2) => `${x}${u1} ${pad(y.toString(), 2, "0")}${u2}`;
+    const format = (x, u1, y, u2) => `${x}${u1} ${pad(y.toString(), 2, "0")}${u2}`;
     const units = this.toUnits();
-    if (units.days >= 1) return format2(units.days, "d", units.hours, "h");
+    if (units.days >= 1) return format(units.days, "d", units.hours, "h");
     else if (units.hours >= 1)
-      return format2(units.hours, "h", units.minutes, "m");
+      return format(units.hours, "h", units.minutes, "m");
     else if (units.minutes >= 1)
-      return format2(units.minutes, "m", units.seconds, "s");
+      return format(units.minutes, "m", units.seconds, "s");
     else if (units.seconds >= 0)
       return units.seconds.toString() + "s";
     else if (units.seconds > -60)
@@ -2141,7 +1987,7 @@ var timeInstantResolveValue = (getFromDate2, referenceDate, x) => {
 };
 var getFromDate = {
   year: (d) => d.getFullYear(),
-  month: (d) => d.getMonth(),
+  month: (d) => d.getMonth() + 1,
   date: (d) => d.getDate(),
   hours: (d) => d.getHours(),
   minutes: (d) => d.getMinutes(),
@@ -2158,7 +2004,8 @@ function createTimeInstantFromParameters(aParameters, aReferenceDate = TimeInsta
   const referenceDate = toReferenceDate(aReferenceDate);
   const timestamp2 = Date.UTC(
     timeInstantResolveValue(getFromDate.year, referenceDate, year),
-    timeInstantResolveValue(getFromDate.month, referenceDate, month),
+    timeInstantResolveValue(getFromDate.month, referenceDate, month) - 1,
+    // Convert from 1-based to 0-based for Date.UTC()
     timeInstantResolveValue(getFromDate.date, referenceDate, date),
     timeInstantResolveValue(getFromDate.hours, referenceDate, hours),
     timeInstantResolveValue(getFromDate.minutes, referenceDate, minutes),
@@ -2246,13 +2093,18 @@ var TimeInstant = class _TimeInstant extends TimeBase {
     return TimeDuration_default.fromMs(Math.max(distance, 0));
   }
   distanceFromStartOfDay() {
-    return this.distanceFrom(this.atStartOfDay());
+    const params = this.toParameters();
+    const msInDay = params.hours * 36e5 + params.minutes * 6e4 + params.seconds * 1e3 + params.milliseconds;
+    return TimeDuration_default.fromMs(msInDay);
   }
   atStartOfDay() {
     return this.atTime({ hours: 0, minutes: 0, seconds: 0, milliseconds: 0 });
   }
   distanceFromEndOfDay() {
-    return this.distanceFrom(this.atEndOfDay());
+    const params = this.toParameters();
+    const msInDay = params.hours * 36e5 + params.minutes * 6e4 + params.seconds * 1e3 + params.milliseconds;
+    const msUntilEndOfDay = 86399999 - msInDay;
+    return TimeDuration_default.fromMs(msUntilEndOfDay);
   }
   atEndOfDay() {
     return this.atTime({ hours: 23, minutes: 59, seconds: 59, milliseconds: 999 });
@@ -2278,11 +2130,13 @@ var TimeInstant = class _TimeInstant extends TimeBase {
       throw new Error("Instant is not in the past");
   }
   isToday() {
-    return Math.floor(this.days) === Math.floor(_TimeInstant.now().days);
+    return Math.floor(this.ms / 864e5) === Math.floor(Date.now() / 864e5);
   }
   /**
    * Formats this instant using the given pattern. The pattern can contain the following tokens:
    * 
+   * Note: Implementation inspired by the small-date library (https://github.com/robinweser/small-date).
+   * 
    * | Token | Description                     | Example                       |
    * |:------|:--------------------------------|:------------------------------|
    * | D     | Weekday, 1 letter               | W                             |
@@ -2322,7 +2176,32 @@ var TimeInstant = class _TimeInstant extends TimeBase {
    * @returns a string, formatted using the given pattern, at the given timeZone with the given locale.
    */
   format(pattern, config = {}) {
-    return (0, import_small_date.format)(this.toDate(), pattern, config);
+    return formatTimeInstant(this, pattern, config);
+  }
+  /**
+   * Parses a date string using the given pattern and creates a TimeInstant.
+   * This method is the inverse of format() - parsing a formatted string should recreate the original instant.
+   * 
+   * For partial patterns (e.g., time-only or date-only), the missing components are taken from the base instant.
+   * For example, parsing "14:30" with base set to yesterday at midnight will result in yesterday at 14:30.
+   * 
+   * Note: Currently performs basic validation (e.g., month 1-12, day 1-31) but does not validate
+   * calendar-specific constraints (e.g., February 30th, April 31st). Invalid dates may be
+   * normalized by the underlying Date constructor.
+   * 
+   * @param dateString The date string to parse
+   * @param pattern The pattern used to parse the string (same tokens as format())
+   * @param base The base TimeInstant to use for partial patterns (defaults to now)
+   * @param config An optional locale and timeZone definition to use during parsing
+   * @returns A TimeInstant parsed from the string
+   * @throws Error if the string doesn't match the pattern or contains invalid basic values
+   * @todo Add calendar-aware validation to reject dates like February 30th, April 31st
+   */
+  static fromString(dateString, pattern, base = _TimeInstant.now(), config = {}) {
+    return parseTimeInstant(dateString, pattern, base, config);
+  }
+  static parse(dateString, pattern, config = {}) {
+    return parseTimeInstantComponents(dateString, pattern, config);
   }
   /**
   * @returns this instant, in ISO 8601 format (eg, 2024-11-01T15:49:22.024Z). The format is meant to always be realiable.
@@ -2342,8 +2221,17 @@ var TimeInstant = class _TimeInstant extends TimeBase {
   toDate() {
     return new Date(this.ms);
   }
-  toDateUTC() {
-    return new Date(this.ms + (/* @__PURE__ */ new Date()).getTimezoneOffset() * 60 * 1e3);
+  toParameters() {
+    const d = this.toDate();
+    return {
+      year: d.getUTCFullYear(),
+      month: d.getUTCMonth() + 1,
+      date: d.getUTCDate(),
+      hours: d.getUTCHours(),
+      minutes: d.getUTCMinutes(),
+      seconds: d.getUTCSeconds(),
+      milliseconds: d.getUTCMilliseconds()
+    };
   }
   /**
    * @returns true if the instant is in the past, false otherwise
@@ -2406,13 +2294,47 @@ var TimeInstant = class _TimeInstant extends TimeBase {
     return timeInstantBuilder();
   }
   static fromIso8601(str) {
-    return _TimeInstant.fromUnixTimestamp(new Date(str).getTime());
-  }
-  static tryFromIso8601(str) {
-    if (!str.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:.\d{3}|)(?:Z|[+-]\d{2}:\d{2})?$/))
-      throw new Error("Invalid date given: " + str);
-    return _TimeInstant.fromUnixTimestamp(new Date(str).getTime());
+    const iso8601Regex = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})(Z|[+-]\d{2}:\d{2})?$/;
+    const match = str.match(iso8601Regex);
+    if (!match) {
+      throw new Error("Invalid ISO 8601 date format: " + str);
+    }
+    const [, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr, millisecondStr] = match;
+    const year = parseInt(yearStr, 10);
+    const month = parseInt(monthStr, 10);
+    const date = parseInt(dayStr, 10);
+    const hours = parseInt(hourStr, 10);
+    const minutes = parseInt(minuteStr, 10);
+    const seconds = parseInt(secondStr, 10);
+    const milliseconds = parseInt(millisecondStr, 10);
+    if (!isValidYear(year))
+      throw new Error("Invalid year in: " + str);
+    if (!isValidMonth(month))
+      throw new Error("Invalid month in: " + str);
+    if (!isValidDayOfMonth(date))
+      throw new Error("Invalid day in: " + str);
+    if (!isValidHour(hours))
+      throw new Error("Invalid hour in: " + str);
+    if (!isValidMinute(minutes))
+      throw new Error("Invalid minute in: " + str);
+    if (!isValidSecond(seconds))
+      throw new Error("Invalid second in: " + str);
+    if (!isValidMillisecond(milliseconds))
+      throw new Error("Invalid millisecond in: " + str);
+    return _TimeInstant.fromParameters({
+      year,
+      month,
+      date,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    });
   }
+  /**
+   * @deprecated [2025.10.19]: Use fromIso8601 instead.
+   */
+  static tryFromIso8601 = this.fromIso8601;
   static now() {
     return _TimeInstant.fromUnixTimestamp(Date.now());
   }
@@ -2440,30 +2362,21 @@ var TimeInstant = class _TimeInstant extends TimeBase {
     const timestamp2 = Math.round(this.ms / unitMs) * unitMs;
     return _TimeInstant.fromUnixTimestamp(timestamp2);
   }
-  get dayOfMonth() {
-    return this.toDate().getDate();
-  }
-  get dayOfWeek() {
-    return this.toDate().getDay() + 1;
-  }
-  get month() {
-    return this.toDate().getMonth() + 1;
-  }
-  get year() {
-    return this.toDate().getFullYear();
-  }
   /**
    * Returns the week number represented by this instant, according to the ISO 8601 standard.
-  	* Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
+   * Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
    */
   get weekNumber() {
     const date = this.toDate();
     const oneDay = 1e3 * 60 * 60 * 24;
-    const thursdayOfThisWeek = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 4 - (date.getDay() || 7), 14, 0, 0);
-    const firstOfJanuary = new Date(thursdayOfThisWeek.getFullYear(), 0, 1, 14, 0, 0);
-    const dayOfTheYear = Math.round((thursdayOfThisWeek.getTime() - firstOfJanuary.getTime()) / oneDay);
+    const dayOfWeek = date.getUTCDay() || 7;
+    const thursdayMs = this.ms + (4 - dayOfWeek) * oneDay;
+    const thursdayDate = new Date(thursdayMs);
+    const thursdayYear = thursdayDate.getUTCFullYear();
+    const firstOfJanMs = Date.UTC(thursdayYear, 0, 1, 12, 0, 0);
+    const dayOfTheYear = Math.round((thursdayMs - firstOfJanMs) / oneDay);
     const weekNumber = Math.floor(dayOfTheYear / 7) + 1;
-    return { weekNumber, year: thursdayOfThisWeek.getFullYear() };
+    return { weekNumber, year: thursdayYear };
   }
   /**
    * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
@@ -2483,6 +2396,297 @@ function isTimeInstant(x) {
   return x !== null && x !== void 0 && x instanceof TimeInstant;
 }
 var TimeInstant_default = TimeInstant;
+function isValidYear(num) {
+  return num >= 0 && num <= 9999;
+}
+function isValidMonth(num) {
+  return num >= 1 && num <= 12;
+}
+function isValidDayOfMonth(num) {
+  return num >= 1 && num <= 31;
+}
+function isValidHour(num) {
+  return num >= 0 && num <= 23;
+}
+function isValidMinute(num) {
+  return num >= 0 && num <= 59;
+}
+function isValidSecond(num) {
+  return num >= 0 && num <= 59;
+}
+function isValidMillisecond(num) {
+  return num >= 0 && num <= 999;
+}
+var monthNamesCache = /* @__PURE__ */ new Map();
+function getMonthNames(locale = "en") {
+  const cached = monthNamesCache.get(locale);
+  if (cached) {
+    return cached;
+  }
+  const shortFormatter = new Intl.DateTimeFormat(locale, { month: "short" });
+  const longFormatter = new Intl.DateTimeFormat(locale, { month: "long" });
+  const short = [];
+  const long = [];
+  for (let month = 0; month < 12; month++) {
+    const date = new Date(2e3, month, 1);
+    short.push(normalizeMonthName(shortFormatter.format(date)));
+    long.push(normalizeMonthName(longFormatter.format(date)));
+  }
+  const result = { short, long };
+  monthNamesCache.set(locale, result);
+  return result;
+}
+function normalizeMonthName(name) {
+  return name.replace(/[.,;:!?]/g, "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim();
+}
+var PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
+var ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"/g;
+var formatterConfigs = {
+  // Year
+  "y": { options: { year: "numeric" } },
+  "yy": { options: { year: "2-digit" } },
+  "yyyy": { options: { year: "numeric" } },
+  // Month
+  "M": { options: { month: "numeric" } },
+  "MM": { options: { month: "2-digit" } },
+  "MMM": { options: { month: "short" } },
+  "MMMM": { options: { month: "long" } },
+  // Day
+  "d": { options: { day: "numeric" } },
+  "dd": { options: { day: "2-digit" } },
+  // Hours (24-hour) - extract and pad manually due to Intl quirk
+  "H": { options: { hour: "numeric", hour12: false }, extract: { partType: "hour" } },
+  "HH": { options: { hour: "2-digit", hour12: false }, extract: { partType: "hour", transform: (v) => v.padStart(2, "0") } },
+  // Hours (12-hour) - extract and pad manually due to Intl quirk
+  "h": { options: { hour: "numeric", hour12: true }, extract: { partType: "hour" } },
+  "hh": { options: { hour: "2-digit", hour12: true }, extract: { partType: "hour", transform: (v) => v.padStart(2, "0") } },
+  // Minutes - extract and pad manually due to Intl quirk
+  "m": { options: { minute: "numeric" }, extract: { partType: "minute" } },
+  "mm": { options: { minute: "2-digit" }, extract: { partType: "minute", transform: (v) => v.padStart(2, "0") } },
+  // Seconds - extract and pad manually due to Intl quirk
+  "s": { options: { second: "numeric" }, extract: { partType: "second" } },
+  "ss": { options: { second: "2-digit" }, extract: { partType: "second", transform: (v) => v.padStart(2, "0") } },
+  // Milliseconds - extract manually
+  "S": { options: { fractionalSecondDigits: 1 }, extract: { partType: "fractionalSecond" } },
+  "SS": { options: { fractionalSecondDigits: 2 }, extract: { partType: "fractionalSecond" } },
+  "SSS": { options: { fractionalSecondDigits: 3 }, extract: { partType: "fractionalSecond" } },
+  // Weekday
+  "D": { options: { weekday: "narrow" } },
+  "DD": { options: { weekday: "short" } },
+  "DDD": { options: { weekday: "long" } },
+  // Era
+  "G": { options: { era: "narrow" } },
+  "GG": { options: { era: "short" } },
+  "GGG": { options: { era: "long" } },
+  // Timezone
+  "Z": { options: { timeZoneName: "short" } },
+  "ZZ": { options: { timeZoneName: "long" } },
+  // Day period
+  "P": { options: { dayPeriod: "narrow" } },
+  "PP": { options: { dayPeriod: "short" } },
+  "PPP": { options: { dayPeriod: "long" } },
+  // Meridiem - extract dayPeriod and lowercase it
+  "a": { options: { hour: "numeric", hour12: true }, extract: { partType: "dayPeriod", transform: (v) => v.toLowerCase() } }
+};
+function formatType(type, length, date, locale = "en", timeZone = "UTC") {
+  const tokenKey = type.repeat(length);
+  const config = formatterConfigs[tokenKey];
+  if (!config) {
+    return void 0;
+  }
+  const formatter = new Intl.DateTimeFormat(locale, { ...config.options, timeZone });
+  if (config.extract) {
+    const part = formatter.formatToParts(date).find((p) => p.type === config.extract.partType);
+    const value = part?.value;
+    if (!value) {
+      return void 0;
+    }
+    return config.extract.transform ? config.extract.transform(value) : value;
+  }
+  return formatter.format(date);
+}
+function formatTimeInstant(instant, pattern, config = {}) {
+  const date = instant.toDate();
+  const locale = config.locale || "en";
+  const timeZone = config.timeZone || "UTC";
+  return pattern.split(ESCAPE_REGEX).filter((sub) => sub !== void 0).map((sub, index) => {
+    if (index % 2 !== 0) {
+      return sub;
+    }
+    return sub.replace(PATTERN_REGEX, (match) => {
+      const type = match.charAt(0);
+      const length = match.length;
+      return formatType(type, length, date, locale, timeZone) || match;
+    });
+  }).join("");
+}
+function parseTimeInstant(dateString, pattern, base, config = {}) {
+  const parsed = parseTimeInstantComponents(dateString, pattern, config);
+  const params = {
+    ...base.toParameters(),
+    ...parsed
+  };
+  return TimeInstant.fromParameters(params);
+}
+function parseTimeInstantComponents(dateString, pattern, config = {}) {
+  let regexPattern = pattern;
+  const tokens = [];
+  let position = 0;
+  const parts = pattern.split(ESCAPE_REGEX).filter((sub) => sub !== void 0);
+  regexPattern = parts.map((sub, index) => {
+    if (index % 2 !== 0) {
+      return sub.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    return sub.replace(PATTERN_REGEX, (match) => {
+      const type = match.charAt(0);
+      tokens.push({ type, length: match.length, position: position++ });
+      switch (type) {
+        case "y":
+          return match.length === 2 ? "(\\d{2})" : "(\\d{4})";
+        case "M":
+          if (match.length === 1) return "(\\d{1,2})";
+          if (match.length === 2) return "(\\d{2})";
+          if (match.length === 3) return "([A-Za-z.]{1,7})";
+          return "([A-Za-z]+)";
+        case "d":
+          return match.length === 1 ? "(\\d{1,2})" : "(\\d{2})";
+        case "H":
+        case "h":
+          return match.length === 1 ? "(\\d{1,2})" : "(\\d{2})";
+        case "m":
+        case "s":
+          return match.length === 1 ? "(\\d{1,2})" : "(\\d{2})";
+        case "S":
+          return `(\\d{${match.length}})`;
+        case "a":
+          return "([aApP][mM])";
+        case "D":
+          if (match.length === 1) return "([A-Za-z])";
+          if (match.length === 2) return "([A-Za-z]{3})";
+          return "([A-Za-z]+)";
+        case "G":
+          if (match.length === 1) return "([A-Za-z])";
+          if (match.length === 2) return "([A-Za-z]{2})";
+          return "([A-Za-z\\s]+)";
+        case "Z":
+          return match.length === 1 ? "([A-Za-z0-9+\\-:]+)" : "([A-Za-z\\s]+)";
+        case "P":
+          return "([A-Za-z\\s]+)";
+        default:
+          return match;
+      }
+    });
+  }).join("");
+  const regex = new RegExp("^" + regexPattern + "$");
+  const matches = dateString.match(regex);
+  if (!matches) {
+    throw new Error(`Date string "${dateString}" does not match pattern "${pattern}"`);
+  }
+  const result = {};
+  const locale = config.locale || "en";
+  let isPM = false;
+  let is12Hour = false;
+  let hourValue;
+  tokens.forEach((token, index) => {
+    const value = matches[index + 1];
+    switch (token.type) {
+      case "y":
+        if (token.length === 2) {
+          const shortYear = parseInt(value, 10);
+          result.year = shortYear < 50 ? 2e3 + shortYear : 1900 + shortYear;
+        } else {
+          result.year = parseInt(value, 10);
+        }
+        break;
+      case "M":
+        switch (token.length) {
+          case 1:
+          case 2:
+            result.month = parseInt(value, 10);
+            break;
+          case 3: {
+            const normalizedValue = normalizeMonthName(value);
+            const monthIndex = getMonthNames(locale).short.findIndex(
+              (name) => name.toLowerCase() === normalizedValue.toLowerCase()
+            );
+            if (monthIndex === -1)
+              throw new Error(`Invalid short month name in date string: ${dateString}`);
+            result.month = monthIndex + 1;
+            break;
+          }
+          case 4: {
+            const normalizedValue = normalizeMonthName(value);
+            const monthIndex = getMonthNames(locale).long.findIndex(
+              (name) => name.toLowerCase() === normalizedValue.toLowerCase()
+            );
+            if (monthIndex === -1)
+              throw new Error(`Invalid full month name in date string: ${dateString}`);
+            result.month = monthIndex + 1;
+            break;
+          }
+          default:
+            throw new Error(`Invalid month pattern: ${token}`);
+        }
+        break;
+      case "d":
+        result.date = parseInt(value, 10);
+        break;
+      case "H":
+        result.hours = parseInt(value, 10);
+        break;
+      case "h":
+        hourValue = parseInt(value, 10);
+        is12Hour = true;
+        break;
+      case "m":
+        result.minutes = parseInt(value, 10);
+        break;
+      case "s":
+        result.seconds = parseInt(value, 10);
+        break;
+      case "S":
+        let ms = parseInt(value, 10);
+        if (token.length === 1) ms *= 100;
+        else if (token.length === 2) ms *= 10;
+        result.milliseconds = ms;
+        break;
+      case "a":
+        isPM = value.toLowerCase().includes("p");
+        break;
+    }
+  });
+  if (is12Hour && hourValue !== void 0) {
+    if (isPM && hourValue < 12) {
+      result.hours = hourValue + 12;
+    } else if (!isPM && hourValue === 12) {
+      result.hours = 0;
+    } else {
+      result.hours = hourValue;
+    }
+  }
+  if (typeof result.year === "number" && !isValidYear(result.year)) {
+    throw new Error(`Invalid year in date string: ${dateString}`);
+  }
+  if (typeof result.month === "number" && !isValidMonth(result.month)) {
+    throw new Error(`Invalid month in date string: ${dateString}`);
+  }
+  if (typeof result.date === "number" && !isValidDayOfMonth(result.date)) {
+    throw new Error(`Invalid day in date string: ${dateString}`);
+  }
+  if (typeof result.hours === "number" && !isValidHour(result.hours)) {
+    throw new Error(`Invalid hour in date string: ${dateString}`);
+  }
+  if (typeof result.minutes === "number" && !isValidMinute(result.minutes)) {
+    throw new Error(`Invalid minute in date string: ${dateString}`);
+  }
+  if (typeof result.seconds === "number" && !isValidSecond(result.seconds)) {
+    throw new Error(`Invalid second in date string: ${dateString}`);
+  }
+  if (typeof result.milliseconds === "number" && !isValidMillisecond(result.milliseconds)) {
+    throw new Error(`Invalid millisecond in date string: ${dateString}`);
+  }
+  return result;
+}
 
 // src/Logger.ts
 var LEVELS = ["trace", "log", "debug", "info", "warn", "error"];