@zelgadis87/utils-core 5.2.9 → 5.2.10

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),
@@ -2283,6 +2130,8 @@ var TimeInstant = class _TimeInstant extends TimeBase {
   /**
    * 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 +2171,29 @@ 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 parse(dateString, pattern, base = _TimeInstant.now(), config = {}) {
+    return parseTimeInstant(dateString, pattern, base, config);
   }
   /**
   * @returns this instant, in ISO 8601 format (eg, 2024-11-01T15:49:22.024Z). The format is meant to always be realiable.
@@ -2406,13 +2277,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());
   }
@@ -2441,16 +2346,16 @@ var TimeInstant = class _TimeInstant extends TimeBase {
     return _TimeInstant.fromUnixTimestamp(timestamp2);
   }
   get dayOfMonth() {
-    return this.toDate().getDate();
+    return this.toDate().getUTCDate();
   }
   get dayOfWeek() {
-    return this.toDate().getDay() + 1;
+    return this.toDate().getUTCDay() + 1;
   }
   get month() {
-    return this.toDate().getMonth() + 1;
+    return this.toDate().getUTCMonth() + 1;
   }
   get year() {
-    return this.toDate().getFullYear();
+    return this.toDate().getUTCFullYear();
   }
   /**
    * Returns the week number represented by this instant, according to the ISO 8601 standard.
@@ -2483,6 +2388,293 @@ 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 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 formatType(instant, type, length, { locale, timeZone } = {}) {
+  if (type === "y") {
+    const year = instant.year;
+    if (length === 2) {
+      return String(year).slice(-2);
+    }
+    return String(year);
+  }
+  if (type === "M" && (length === 1 || length === 2)) {
+    const month = instant.month;
+    return length === 2 && month < 10 ? "0" + month : String(month);
+  }
+  if (type === "d" && (length === 1 || length === 2)) {
+    const day = instant.dayOfMonth;
+    return length === 2 && day < 10 ? "0" + day : String(day);
+  }
+  if (type === "H" && (length === 1 || length === 2)) {
+    const hours = instant.toDate().getUTCHours();
+    return length === 2 && hours < 10 ? "0" + hours : String(hours);
+  }
+  if (type === "h" && (length === 1 || length === 2)) {
+    let hours = instant.toDate().getUTCHours();
+    hours = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
+    return length === 2 && hours < 10 ? "0" + hours : String(hours);
+  }
+  if (type === "m" && (length === 1 || length === 2)) {
+    const minutes = instant.toDate().getUTCMinutes();
+    return length === 2 && minutes < 10 ? "0" + minutes : String(minutes);
+  }
+  if (type === "s" && (length === 1 || length === 2)) {
+    const seconds = instant.toDate().getUTCSeconds();
+    return length === 2 && seconds < 10 ? "0" + seconds : String(seconds);
+  }
+  if (type === "S") {
+    const ms = instant.toDate().getUTCMilliseconds();
+    if (length === 1) return String(Math.floor(ms / 100));
+    if (length === 2) return String(Math.floor(ms / 10)).padStart(2, "0");
+    if (length === 3) return String(ms).padStart(3, "0");
+    return String(ms);
+  }
+  const date = instant.toDate();
+  const option = optionNames[type];
+  const value = values[type][length - 1];
+  if (!value) {
+    return;
+  }
+  const options = {
+    [option]: value,
+    timeZone
+  };
+  if (type === "a") {
+    return Intl.DateTimeFormat(locale, {
+      ...options,
+      hour: "numeric"
+    }).formatToParts(date).pop()?.value;
+  }
+  if (type === "G" || type === "Z") {
+    return Intl.DateTimeFormat(locale, options).formatToParts(date).pop()?.value;
+  }
+  return Intl.DateTimeFormat(locale, options).format(date);
+}
+function formatTimeInstant(instant, pattern, config = {}) {
+  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);
+      return formatType(instant, type, match.length, config) || match;
+    });
+  }).join("");
+}
+function parseTimeInstant(dateString, pattern, base, 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]{3})";
+          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}"`);
+  }
+  let year = base.year;
+  let month = base.month;
+  let day = base.dayOfMonth;
+  let hour = base.toDate().getUTCHours();
+  let minute = base.toDate().getUTCMinutes();
+  let second = base.toDate().getUTCSeconds();
+  let millisecond = base.toDate().getUTCMilliseconds();
+  let isPM = false;
+  let is12Hour = false;
+  tokens.forEach((token, index) => {
+    const value = matches[index + 1];
+    switch (token.type) {
+      case "y":
+        if (token.length === 2) {
+          const shortYear = parseInt(value, 10);
+          year = shortYear < 50 ? 2e3 + shortYear : 1900 + shortYear;
+        } else {
+          year = parseInt(value, 10);
+        }
+        break;
+      case "M":
+        if (token.length <= 2) {
+          month = parseInt(value, 10);
+        } else {
+          const monthNames2 = [
+            "Jan",
+            "Feb",
+            "Mar",
+            "Apr",
+            "May",
+            "Jun",
+            "Jul",
+            "Aug",
+            "Sep",
+            "Oct",
+            "Nov",
+            "Dec"
+          ];
+          const longMonthNames = [
+            "January",
+            "February",
+            "March",
+            "April",
+            "May",
+            "June",
+            "July",
+            "August",
+            "September",
+            "October",
+            "November",
+            "December"
+          ];
+          let monthIndex = monthNames2.findIndex((name) => name.toLowerCase() === value.toLowerCase());
+          if (monthIndex === -1) {
+            monthIndex = longMonthNames.findIndex((name) => name.toLowerCase() === value.toLowerCase());
+          }
+          month = monthIndex !== -1 ? monthIndex + 1 : 1;
+        }
+        break;
+      case "d":
+        day = parseInt(value, 10);
+        break;
+      case "H":
+        hour = parseInt(value, 10);
+        break;
+      case "h":
+        hour = parseInt(value, 10);
+        is12Hour = true;
+        break;
+      case "m":
+        minute = parseInt(value, 10);
+        break;
+      case "s":
+        second = parseInt(value, 10);
+        break;
+      case "S":
+        let ms = parseInt(value, 10);
+        if (token.length === 1) ms *= 100;
+        else if (token.length === 2) ms *= 10;
+        millisecond = ms;
+        break;
+      case "a":
+        isPM = value.toLowerCase().includes("p");
+        break;
+    }
+  });
+  if (is12Hour && isPM && hour < 12) {
+    hour += 12;
+  } else if (is12Hour && !isPM && hour === 12) {
+    hour = 0;
+  }
+  if (!isValidYear(year)) throw new Error(`Invalid year in date string: ${dateString}`);
+  if (!isValidMonth(month)) throw new Error(`Invalid month in date string: ${dateString}`);
+  if (!isValidDayOfMonth(day)) throw new Error(`Invalid day in date string: ${dateString}`);
+  if (!isValidHour(hour)) throw new Error(`Invalid hour in date string: ${dateString}`);
+  if (!isValidMinute(minute)) throw new Error(`Invalid minute in date string: ${dateString}`);
+  if (!isValidSecond(second)) throw new Error(`Invalid second in date string: ${dateString}`);
+  if (!isValidMillisecond(millisecond)) throw new Error(`Invalid millisecond in date string: ${dateString}`);
+  return TimeInstant.fromParameters({
+    year,
+    month,
+    date: day,
+    hours: hour,
+    minutes: minute,
+    seconds: second,
+    milliseconds: millisecond
+  });
+}
 
 // src/Logger.ts
 var LEVELS = ["trace", "log", "debug", "info", "warn", "error"];