@northguild/gmt 1.15.0 → 1.17.0

package/dist/plain/parse/parseUnitFromDate.js

@@ -1,16 +1,23 @@
 import { Temporal } from "@js-temporal/polyfill";
+import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
+import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { getWeekNumber } from "../calculate/getWeekNumber.js";
 import { isValidDate } from "../validate/index.js";
+import { isOptionsArgument } from "../../internal/isObject.js";
 /**
  * Return a specific date unit extracted from a PlainDate string.
  *
  * - Extracts "year", "month", "day", "week", or "dayOfWeek" from a PlainDate.
  * - Returns zero-padded string for month and day.
+ * - `unit` accepts the singular or plural name of a Temporal unit (`"hour"` or `"hours"`), as Temporal
+ *   does; `"dayOfWeek"` has no plural.
+ * - `weekStartsOn: "sunday"` numbers weeks by UTS #35 (week 1 holds 1 January, so late-December
+ *   days can be week 1); any value other than `"monday"` or `"sunday"` returns "".
  * - Returns "" for invalid input.
  *
  * @param value ISO PlainDate string
  * @param unit unit to extract from the date
- * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations; a non-object value (such as `null`) is invalid
  * @returns string representation of the requested unit or "" on invalid input
  *
  * @example parseUnitFromDate("2024-03-15", "year") // "2024"
@@ -18,32 +25,45 @@ import { isValidDate } from "../validate/index.js";
  * @example parseUnitFromDate("2024-03-15", "day") // "15"
  * @example parseUnitFromDate("2024-03-15", "week") // "11"
  * @example parseUnitFromDate("2024-03-15", "dayOfWeek") // "5"
+ * @example parseUnitFromDate("2024-03-15", "months") // "03"
+ * @example parseUnitFromDate("2024-12-31", "week", { weekStartsOn: "sunday" }) // "1"
  * @example parseUnitFromDate("invalid", "year") // ""
  * @example parseUnitFromDate("2024-01-01", "week", { weekStartsOn: "sunday" }) // "1"
  */
 export function parseUnitFromDate(value, unit, optionsArg) {
-    if (!isValidDate(value)) {
-        return "";
-    }
-    const weekStartsOn = optionsArg?.weekStartsOn ?? "monday";
     try {
-        const date = Temporal.PlainDate.from(value);
-        switch (unit) {
-            case "year":
-                return date.year.toString();
-            case "month":
-                return date.month.toString().padStart(2, "0");
-            case "day":
-                return date.day.toString().padStart(2, "0");
-            case "week":
-                return (getWeekNumber(value, weekStartsOn) ?? 0).toString();
-            case "dayOfWeek":
-                return date.dayOfWeek.toString();
-            default:
-                return "";
+        // Temporal GetOptionsObject: options are an object or omitted; null and primitives are invalid.
+        if (!isOptionsArgument(optionsArg)) {
+            return "";
+        }
+        const weekStartsOn = resolveWeekStartsOn(optionsArg?.weekStartsOn);
+        if (!isValidDate(value) || weekStartsOn === null) {
+            return "";
+        }
+        try {
+            const date = Temporal.PlainDate.from(value);
+            switch (resolveDateTimeUnit(unit)) {
+                case "year":
+                    return date.year.toString();
+                case "month":
+                    return date.month.toString().padStart(2, "0");
+                case "day":
+                    return date.day.toString().padStart(2, "0");
+                case "week":
+                    return (getWeekNumber(value, weekStartsOn) ?? 0).toString();
+                case "dayOfWeek":
+                    return date.dayOfWeek.toString();
+                default:
+                    return "";
+            }
+        }
+        catch {
+            return "";
         }
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return "";
     }
 }

package/dist/plain/parse/parseUnitFromDateTime.d.ts

@@ -1,22 +1,30 @@
+import { Temporal } from "@js-temporal/polyfill";
 /**
  * Return a specific unit extracted from a PlainDateTime string.
  *
- * - Extracts "year", "month", "day", "week", "dayOfWeek", "hour", "minute", "second", or "millisecond" from a PlainDateTime.
+ * - Extracts "year", "month", "day", "week", "dayOfWeek", "hour", "minute", "second",
+ *   "millisecond", "microsecond" or "nanosecond" from a PlainDateTime (the last three are
+ *   Temporal's 0-999 fields, zero-padded to 3 digits).
  * - Returns zero-padded string for most units.
+ * - `unit` accepts the singular or plural name of a Temporal unit (`"hour"` or `"hours"`), as Temporal
+ *   does; `"dayOfWeek"` has no plural.
+ * - `weekStartsOn: "sunday"` numbers weeks by UTS #35 (week 1 holds 1 January, so late-December
+ *   days can be week 1); any value other than `"monday"` or `"sunday"` returns "".
  * - Returns "" for invalid input.
  *
  * @param value ISO PlainDateTime string
  * @param unit unit to extract from the datetime
- * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations; a non-object value (such as `null`) is invalid
  * @returns string representation of the requested unit or "" on invalid input
  *
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "year") // "2024"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "week") // "11"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "hour") // "14"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "millisecond") // "123"
+ * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "hours") // "14"
  * @example parseUnitFromDateTime("invalid", "year") // ""
  * @example parseUnitFromDateTime("2024-01-01T00:00:00", "week", { weekStartsOn: "sunday" }) // "1"
  */
-export declare function parseUnitFromDateTime(value: string, unit: "year" | "month" | "day" | "week" | "dayOfWeek" | "hour" | "minute" | "second" | "millisecond", optionsArg?: {
+export declare function parseUnitFromDateTime(value: string, unit: Temporal.SmallestUnit<"year" | "month" | "day" | "week" | "hour" | "minute" | "second" | "millisecond" | "microsecond" | "nanosecond"> | "dayOfWeek", optionsArg?: {
     weekStartsOn?: "monday" | "sunday";
 }): string;

package/dist/plain/parse/parseUnitFromDateTime.js

@@ -1,56 +1,82 @@
+// fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
 import { Temporal } from "@js-temporal/polyfill";
+import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
+import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { getWeekNumber } from "../calculate/getWeekNumber.js";
 import { isValidDateTime } from "../validate/index.js";
+import { isOptionsArgument } from "../../internal/isObject.js";
 /**
  * Return a specific unit extracted from a PlainDateTime string.
  *
- * - Extracts "year", "month", "day", "week", "dayOfWeek", "hour", "minute", "second", or "millisecond" from a PlainDateTime.
+ * - Extracts "year", "month", "day", "week", "dayOfWeek", "hour", "minute", "second",
+ *   "millisecond", "microsecond" or "nanosecond" from a PlainDateTime (the last three are
+ *   Temporal's 0-999 fields, zero-padded to 3 digits).
  * - Returns zero-padded string for most units.
+ * - `unit` accepts the singular or plural name of a Temporal unit (`"hour"` or `"hours"`), as Temporal
+ *   does; `"dayOfWeek"` has no plural.
+ * - `weekStartsOn: "sunday"` numbers weeks by UTS #35 (week 1 holds 1 January, so late-December
+ *   days can be week 1); any value other than `"monday"` or `"sunday"` returns "".
  * - Returns "" for invalid input.
  *
  * @param value ISO PlainDateTime string
  * @param unit unit to extract from the datetime
- * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations; a non-object value (such as `null`) is invalid
  * @returns string representation of the requested unit or "" on invalid input
  *
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "year") // "2024"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "week") // "11"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "hour") // "14"
  * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "millisecond") // "123"
+ * @example parseUnitFromDateTime("2024-03-15T14:30:45.123", "hours") // "14"
  * @example parseUnitFromDateTime("invalid", "year") // ""
  * @example parseUnitFromDateTime("2024-01-01T00:00:00", "week", { weekStartsOn: "sunday" }) // "1"
  */
 export function parseUnitFromDateTime(value, unit, optionsArg) {
-    if (!isValidDateTime(value)) {
-        return "";
-    }
-    const weekStartsOn = optionsArg?.weekStartsOn ?? "monday";
     try {
-        const dateTime = Temporal.PlainDateTime.from(value);
-        switch (unit) {
-            case "year":
-                return dateTime.year.toString();
-            case "month":
-                return dateTime.month.toString().padStart(2, "0");
-            case "day":
-                return dateTime.day.toString().padStart(2, "0");
-            case "week":
-                return (getWeekNumber(value, weekStartsOn) ?? 0).toString();
-            case "dayOfWeek":
-                return dateTime.dayOfWeek.toString();
-            case "hour":
-                return dateTime.hour.toString().padStart(2, "0");
-            case "minute":
-                return dateTime.minute.toString().padStart(2, "0");
-            case "second":
-                return dateTime.second.toString().padStart(2, "0");
-            case "millisecond":
-                return dateTime.millisecond.toString().padStart(3, "0");
-            default:
-                return "";
+        // Temporal GetOptionsObject: options are an object or omitted; null and primitives are invalid.
+        if (!isOptionsArgument(optionsArg)) {
+            return "";
+        }
+        const weekStartsOn = resolveWeekStartsOn(optionsArg?.weekStartsOn);
+        if (!isValidDateTime(value) || weekStartsOn === null) {
+            return "";
+        }
+        try {
+            const dateTime = Temporal.PlainDateTime.from(value);
+            switch (resolveDateTimeUnit(unit)) {
+                case "year":
+                    return dateTime.year.toString();
+                case "month":
+                    return dateTime.month.toString().padStart(2, "0");
+                case "day":
+                    return dateTime.day.toString().padStart(2, "0");
+                case "week":
+                    return (getWeekNumber(dateTime.toPlainDate().toString(), weekStartsOn) ?? 0).toString();
+                case "dayOfWeek":
+                    return dateTime.dayOfWeek.toString();
+                case "hour":
+                    return dateTime.hour.toString().padStart(2, "0");
+                case "minute":
+                    return dateTime.minute.toString().padStart(2, "0");
+                case "second":
+                    return dateTime.second.toString().padStart(2, "0");
+                case "millisecond":
+                    return dateTime.millisecond.toString().padStart(3, "0");
+                case "microsecond":
+                    return dateTime.microsecond.toString().padStart(3, "0");
+                case "nanosecond":
+                    return dateTime.nanosecond.toString().padStart(3, "0");
+                default:
+                    return "";
+            }
+        }
+        catch {
+            return "";
         }
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return "";
     }
 }

package/dist/plain/parse/parseUnitFromTime.d.ts

@@ -1,8 +1,12 @@
+import { Temporal } from "@js-temporal/polyfill";
 /**
  * Return a specific time unit extracted from a PlainTime string.
  *
- * - Extracts "hour", "minute", "second", or "millisecond" from a PlainTime.
- * - Returns zero-padded string for hour, minute, second (2 digits) and millisecond (3 digits).
+ * - Extracts "hour", "minute", "second", "millisecond", "microsecond" or "nanosecond" from a
+ *   PlainTime.
+ * - Returns zero-padded string for hour, minute, second (2 digits) and millisecond, microsecond and
+ *   nanosecond (3 digits, each the 0-999 Temporal field).
+ * - `unit` accepts the singular or plural name (`"hour"` or `"hours"`), as Temporal does.
  * - Returns "" for invalid input.
  *
  * @param value ISO PlainTime string
@@ -13,6 +17,8 @@
  * @example parseUnitFromTime("14:30:45.123", "minute") // "30"
  * @example parseUnitFromTime("14:30:45.123", "second") // "45"
  * @example parseUnitFromTime("14:30:45.123", "millisecond") // "123"
+ * @example parseUnitFromTime("14:30:45.123", "milliseconds") // "123"
+ * @example parseUnitFromTime("14:30:45.123456789", "nanosecond") // "789"
  * @example parseUnitFromTime("invalid", "hour") // ""
  */
-export declare function parseUnitFromTime(value: string, unit: "hour" | "minute" | "second" | "millisecond"): string;
+export declare function parseUnitFromTime(value: string, unit: Temporal.SmallestUnit<"hour" | "minute" | "second" | "millisecond" | "microsecond" | "nanosecond">): string;

package/dist/plain/parse/parseUnitFromTime.js

@@ -1,10 +1,14 @@
 import { Temporal } from "@js-temporal/polyfill";
+import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
 import { isValidTime } from "../validate/index.js";
 /**
  * Return a specific time unit extracted from a PlainTime string.
  *
- * - Extracts "hour", "minute", "second", or "millisecond" from a PlainTime.
- * - Returns zero-padded string for hour, minute, second (2 digits) and millisecond (3 digits).
+ * - Extracts "hour", "minute", "second", "millisecond", "microsecond" or "nanosecond" from a
+ *   PlainTime.
+ * - Returns zero-padded string for hour, minute, second (2 digits) and millisecond, microsecond and
+ *   nanosecond (3 digits, each the 0-999 Temporal field).
+ * - `unit` accepts the singular or plural name (`"hour"` or `"hours"`), as Temporal does.
  * - Returns "" for invalid input.
  *
  * @param value ISO PlainTime string
@@ -15,6 +19,8 @@ import { isValidTime } from "../validate/index.js";
  * @example parseUnitFromTime("14:30:45.123", "minute") // "30"
  * @example parseUnitFromTime("14:30:45.123", "second") // "45"
  * @example parseUnitFromTime("14:30:45.123", "millisecond") // "123"
+ * @example parseUnitFromTime("14:30:45.123", "milliseconds") // "123"
+ * @example parseUnitFromTime("14:30:45.123456789", "nanosecond") // "789"
  * @example parseUnitFromTime("invalid", "hour") // ""
  */
 export function parseUnitFromTime(value, unit) {
@@ -23,7 +29,7 @@ export function parseUnitFromTime(value, unit) {
     }
     try {
         const time = Temporal.PlainTime.from(value);
-        switch (unit) {
+        switch (resolveDateTimeUnit(unit)) {
             case "hour":
                 return time.hour.toString().padStart(2, "0");
             case "minute":
@@ -32,6 +38,10 @@ export function parseUnitFromTime(value, unit) {
                 return time.second.toString().padStart(2, "0");
             case "millisecond":
                 return time.millisecond.toString().padStart(3, "0");
+            case "microsecond":
+                return time.microsecond.toString().padStart(3, "0");
+            case "nanosecond":
+                return time.nanosecond.toString().padStart(3, "0");
             default:
                 return "";
         }

package/dist/plain/parse/parseWeekFromDate.d.ts

@@ -2,6 +2,10 @@
  * Return the week number for a given ISO 8601 date string.
  *
  * - By default uses ISO weeks (Monday-based).
+ * - `weekStartsOn: "sunday"` is the UTS #35 week of the week-year with a Sunday first day and
+ *   minimal days 1 (week 1 holds 1 January, so late-December days can be week 1), while `"monday"`
+ *   is the ISO 8601 week of the week-year; both are 1–53 — see `getWeekNumber`.
+ * - `weekStartsOn` other than `"monday"` or `"sunday"` returns null.
  * - Returns null for invalid input.
  *
  * @param value ISO date string
@@ -13,6 +17,7 @@
  * @example parseWeekFromDate("2024-12-31") // 1
  * @example parseWeekFromDate("2024-01-01", { weekStartsOn: "sunday" }) // 1
  * @example parseWeekFromDate("invalid") // null
+ * @example parseWeekFromDate("2024-12-31", { weekStartsOn: "sunday" }) // 1 (its Sunday-first week holds 1 January 2025)
  */
 export declare function parseWeekFromDate(value: string, optionsArg?: {
     weekStartsOn?: "monday" | "sunday";

package/dist/plain/parse/parseWeekFromDate.js

@@ -1,9 +1,15 @@
+import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { getWeekNumber } from "../calculate/getWeekNumber.js";
 import { isValidDate } from "../validate/index.js";
+import { isOptionsArgument } from "../../internal/isObject.js";
 /**
  * Return the week number for a given ISO 8601 date string.
  *
  * - By default uses ISO weeks (Monday-based).
+ * - `weekStartsOn: "sunday"` is the UTS #35 week of the week-year with a Sunday first day and
+ *   minimal days 1 (week 1 holds 1 January, so late-December days can be week 1), while `"monday"`
+ *   is the ISO 8601 week of the week-year; both are 1–53 — see `getWeekNumber`.
+ * - `weekStartsOn` other than `"monday"` or `"sunday"` returns null.
  * - Returns null for invalid input.
  *
  * @param value ISO date string
@@ -15,16 +21,29 @@ import { isValidDate } from "../validate/index.js";
  * @example parseWeekFromDate("2024-12-31") // 1
  * @example parseWeekFromDate("2024-01-01", { weekStartsOn: "sunday" }) // 1
  * @example parseWeekFromDate("invalid") // null
+ * @example parseWeekFromDate("2024-12-31", { weekStartsOn: "sunday" }) // 1 (its Sunday-first week holds 1 January 2025)
  */
 export function parseWeekFromDate(value, optionsArg) {
-    if (!isValidDate(value)) {
-        return null;
-    }
-    const weekStartsOn = optionsArg?.weekStartsOn ?? "monday";
     try {
-        return getWeekNumber(value, weekStartsOn);
+        if (!isOptionsArgument(optionsArg)) {
+            return null;
+        }
+        if (!isValidDate(value)) {
+            return null;
+        }
+        const weekStartsOn = resolveWeekStartsOn(optionsArg?.weekStartsOn);
+        if (weekStartsOn === null)
+            return null;
+        try {
+            return getWeekNumber(value, weekStartsOn);
+        }
+        catch {
+            return null;
+        }
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return null;
     }
 }

package/dist/plain/parse/parseWeekFromDateTime.d.ts

@@ -2,6 +2,10 @@
  * Return the week number for a given ISO 8601 datetime string.
  *
  * - By default uses ISO weeks (Monday-based).
+ * - `weekStartsOn: "sunday"` is the UTS #35 week of the week-year with a Sunday first day and
+ *   minimal days 1 (week 1 holds 1 January, so late-December days can be week 1), while `"monday"`
+ *   is the ISO 8601 week of the week-year; both are 1–53 — see `getWeekNumber`.
+ * - `weekStartsOn` other than `"monday"` or `"sunday"` returns null.
  * - Returns null for invalid input.
  *
  * @param value ISO 8601 datetime string
@@ -12,6 +16,7 @@
  * @example parseWeekFromDateTime("2024-01-08T00:00:00") // 2
  * @example parseWeekFromDateTime("2024-01-01T00:00:00", { weekStartsOn: "sunday" }) // 1
  * @example parseWeekFromDateTime("invalid") // null
+ * @example parseWeekFromDateTime("2024-12-31T12:00:00", { weekStartsOn: "sunday" }) // 1 (its Sunday-first week holds 1 January 2025)
  */
 export declare function parseWeekFromDateTime(value: string, optionsArg?: {
     weekStartsOn?: "monday" | "sunday";

package/dist/plain/parse/parseWeekFromDateTime.js

@@ -1,9 +1,16 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { resolveWeekStartsOn } from "../../internal/resolveWeekStartsOn.js";
 import { getWeekNumber } from "../calculate/getWeekNumber.js";
 import { isValidDateTime } from "../validate/index.js";
+import { isOptionsArgument } from "../../internal/isObject.js";
 /**
  * Return the week number for a given ISO 8601 datetime string.
  *
  * - By default uses ISO weeks (Monday-based).
+ * - `weekStartsOn: "sunday"` is the UTS #35 week of the week-year with a Sunday first day and
+ *   minimal days 1 (week 1 holds 1 January, so late-December days can be week 1), while `"monday"`
+ *   is the ISO 8601 week of the week-year; both are 1–53 — see `getWeekNumber`.
+ * - `weekStartsOn` other than `"monday"` or `"sunday"` returns null.
  * - Returns null for invalid input.
  *
  * @param value ISO 8601 datetime string
@@ -14,16 +21,30 @@ import { isValidDateTime } from "../validate/index.js";
  * @example parseWeekFromDateTime("2024-01-08T00:00:00") // 2
  * @example parseWeekFromDateTime("2024-01-01T00:00:00", { weekStartsOn: "sunday" }) // 1
  * @example parseWeekFromDateTime("invalid") // null
+ * @example parseWeekFromDateTime("2024-12-31T12:00:00", { weekStartsOn: "sunday" }) // 1 (its Sunday-first week holds 1 January 2025)
  */
 export function parseWeekFromDateTime(value, optionsArg) {
-    if (!isValidDateTime(value)) {
-        return null;
-    }
-    const weekStartsOn = optionsArg?.weekStartsOn ?? "monday";
     try {
-        return getWeekNumber(value, weekStartsOn);
+        if (!isOptionsArgument(optionsArg)) {
+            return null;
+        }
+        if (!isValidDateTime(value)) {
+            return null;
+        }
+        const weekStartsOn = resolveWeekStartsOn(optionsArg?.weekStartsOn);
+        if (weekStartsOn === null)
+            return null;
+        try {
+            // getWeekNumber takes a PlainDate string only, so pass the date half.
+            return getWeekNumber(Temporal.PlainDateTime.from(value).toPlainDate().toString(), weekStartsOn);
+        }
+        catch {
+            return null;
+        }
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return null;
     }
 }

package/dist/plain/validate/isLeapSecond.d.ts

@@ -1,16 +1,34 @@
 /**
- * Return true if the provided string is a valid ISO 8601 leap second datetime.
+ * Return true if the provided ISO 8601 date-time or time string has a second-60 field.
  *
- * - Validates leap second format using regex: "YYYY-MM-DDT23:59:60Z" or "YYYY-MM-DDT23:59:60+00:00".
+ * - This is a syntactic test of the seconds field, the spelling Temporal would silently clamp to
+ *   `:59`. It does not check the IERS leap-second list: a real leap second exists only at
+ *   23:59:60 UTC at the end of a month in which one was inserted (RFC 3339 §5.7), so
+ *   `"2024-12-31T23:59:60Z"` (no leap second that day, IERS Bulletin C 68) and
+ *   `"2024-06-15T12:34:60Z"` both return true.
+ * - Matches a seconds field of `60` with any date, time of day or offset, or none, for example
+ *   "YYYY-MM-DDT23:59:60Z", "YYYY-MM-DDT23:59:60+00:00", "YYYY-MM-DDT23:59:60" or "23:59:60".
  * - Accepts optional fractional seconds.
+ * - Accepts every spelling Temporal's grammar parses: a `T`, `t` or space separator, and
+ *   extended or basic digits, a bare time with or without a `T` designator, and a designator,
+ *   annotation or nothing after the second. Temporal silently clamps each of them to `:59`, so
+ *   each is a leap second GMT has to catch. A `[key=value]` annotation value is never read as a time.
+ * - Compatibility: earlier releases recognised only an uppercase `T` with extended digits. To
+ *   keep that narrower test, match `/T\d{2}:\d{2}:60(?:[.,]\d+)?[-+Zz[]/` yourself.
  *
- * @param value ISO datetime string
- * @returns boolean indicating whether the input string is a valid leap second datetime
+ * @param value ISO date-time or time string
+ * @returns true when the string has a second-60 field, otherwise false
  *
- * @example isLeapSecond("2024-12-31T23:59:60Z") // true
- * @example isLeapSecond("2024-12-31T23:59:60.123Z") // true
- * @example isLeapSecond("2024-12-31T23:59:60+00:00") // true
- * @example isLeapSecond("2024-12-31T23:59:60.123+00:00") // true
- * @example isLeapSecond("2024-12-31T23:59:59Z") // false
+ * @example isLeapSecond("2016-12-31T23:59:60Z") // true
+ * @example isLeapSecond("2016-12-31T23:59:60.123Z") // true
+ * @example isLeapSecond("2016-12-31T23:59:60+00:00") // true
+ * @example isLeapSecond("2016-12-31T23:59:60.123+00:00") // true
+ * @example isLeapSecond("2016-12-31t23:59:60Z") // true (lowercase t)
+ * @example isLeapSecond("20161231 235960Z") // true (space separator, basic format)
+ * @example isLeapSecond("2016-12-31T23:59:60") // true (no designator; PlainDateTime clamps it)
+ * @example isLeapSecond("23:59:60") // true (a time; PlainTime clamps it)
+ * @example isLeapSecond("2016-12-31T23:59:59Z") // false
+ * @example isLeapSecond("2024-06-15T12:34:60Z") // true (syntactic: no leap second can occur here)
+ * @example /T\d{2}:\d{2}:60(?:[.,]\d+)?[-+Zz[]/.test("2016-12-31t23:59:60Z") // false (the earlier uppercase-T-only test)
  */
 export declare function isLeapSecond(value: string): boolean;

package/dist/plain/validate/isLeapSecond.js

@@ -1,19 +1,40 @@
 import { leapSecond } from "../../regex/leap-second.js";
 /**
- * Return true if the provided string is a valid ISO 8601 leap second datetime.
+ * Return true if the provided ISO 8601 date-time or time string has a second-60 field.
  *
- * - Validates leap second format using regex: "YYYY-MM-DDT23:59:60Z" or "YYYY-MM-DDT23:59:60+00:00".
+ * - This is a syntactic test of the seconds field, the spelling Temporal would silently clamp to
+ *   `:59`. It does not check the IERS leap-second list: a real leap second exists only at
+ *   23:59:60 UTC at the end of a month in which one was inserted (RFC 3339 §5.7), so
+ *   `"2024-12-31T23:59:60Z"` (no leap second that day, IERS Bulletin C 68) and
+ *   `"2024-06-15T12:34:60Z"` both return true.
+ * - Matches a seconds field of `60` with any date, time of day or offset, or none, for example
+ *   "YYYY-MM-DDT23:59:60Z", "YYYY-MM-DDT23:59:60+00:00", "YYYY-MM-DDT23:59:60" or "23:59:60".
  * - Accepts optional fractional seconds.
+ * - Accepts every spelling Temporal's grammar parses: a `T`, `t` or space separator, and
+ *   extended or basic digits, a bare time with or without a `T` designator, and a designator,
+ *   annotation or nothing after the second. Temporal silently clamps each of them to `:59`, so
+ *   each is a leap second GMT has to catch. A `[key=value]` annotation value is never read as a time.
+ * - Compatibility: earlier releases recognised only an uppercase `T` with extended digits. To
+ *   keep that narrower test, match `/T\d{2}:\d{2}:60(?:[.,]\d+)?[-+Zz[]/` yourself.
  *
- * @param value ISO datetime string
- * @returns boolean indicating whether the input string is a valid leap second datetime
+ * @param value ISO date-time or time string
+ * @returns true when the string has a second-60 field, otherwise false
  *
- * @example isLeapSecond("2024-12-31T23:59:60Z") // true
- * @example isLeapSecond("2024-12-31T23:59:60.123Z") // true
- * @example isLeapSecond("2024-12-31T23:59:60+00:00") // true
- * @example isLeapSecond("2024-12-31T23:59:60.123+00:00") // true
- * @example isLeapSecond("2024-12-31T23:59:59Z") // false
+ * @example isLeapSecond("2016-12-31T23:59:60Z") // true
+ * @example isLeapSecond("2016-12-31T23:59:60.123Z") // true
+ * @example isLeapSecond("2016-12-31T23:59:60+00:00") // true
+ * @example isLeapSecond("2016-12-31T23:59:60.123+00:00") // true
+ * @example isLeapSecond("2016-12-31t23:59:60Z") // true (lowercase t)
+ * @example isLeapSecond("20161231 235960Z") // true (space separator, basic format)
+ * @example isLeapSecond("2016-12-31T23:59:60") // true (no designator; PlainDateTime clamps it)
+ * @example isLeapSecond("23:59:60") // true (a time; PlainTime clamps it)
+ * @example isLeapSecond("2016-12-31T23:59:59Z") // false
+ * @example isLeapSecond("2024-06-15T12:34:60Z") // true (syntactic: no leap second can occur here)
+ * @example /T\d{2}:\d{2}:60(?:[.,]\d+)?[-+Zz[]/.test("2016-12-31t23:59:60Z") // false (the earlier uppercase-T-only test)
  */
 export function isLeapSecond(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
     return leapSecond.test(value);
 }

package/dist/plain/validate/isLeapYear.d.ts

@@ -2,7 +2,11 @@
  * Return true when the given PlainDate falls in a leap year.
  *
  * - A leap year is divisible by 4, except for century years which must be divisible by 400.
- * - Returns false for invalid input strings.
+ * - Returns false for invalid input strings, including every shape `isValidDate` rejects: a
+ *   date-time, zoned, basic-format or leap-second string, or a non-ISO calendar annotation. The
+ *   annotations Temporal ignores are accepted (`"2024-06-15[u-ca=iso8601]"` → true).
+ * - Compatibility: earlier releases read those shapes loosely (`"2024-03-15T10:00"` → `true`).
+ *   Pass the date part alone, or use `Temporal.PlainDate.from(value).inLeapYear`.
  *
  * @param value ISO PlainDate string
  * @returns boolean indicating whether the date is in a leap year
@@ -10,5 +14,7 @@
  * @example isLeapYear("2024-03-15") // true
  * @example isLeapYear("2023-03-15") // false
  * @example isLeapYear("invalid") // false
+ * @example isLeapYear("2024-03-15T10:00") // false (a date-time, not a PlainDate)
+ * @example isLeapYear("2024-03-15T10:00".slice(0, 10)) // true (the date part)
  */
 export declare function isLeapYear(value: string): boolean;

package/dist/plain/validate/isLeapYear.js

@@ -1,9 +1,14 @@
 import { Temporal } from "@js-temporal/polyfill";
+import { isValidDate } from "./isValidDate.js";
 /**
  * Return true when the given PlainDate falls in a leap year.
  *
  * - A leap year is divisible by 4, except for century years which must be divisible by 400.
- * - Returns false for invalid input strings.
+ * - Returns false for invalid input strings, including every shape `isValidDate` rejects: a
+ *   date-time, zoned, basic-format or leap-second string, or a non-ISO calendar annotation. The
+ *   annotations Temporal ignores are accepted (`"2024-06-15[u-ca=iso8601]"` → true).
+ * - Compatibility: earlier releases read those shapes loosely (`"2024-03-15T10:00"` → `true`).
+ *   Pass the date part alone, or use `Temporal.PlainDate.from(value).inLeapYear`.
  *
  * @param value ISO PlainDate string
  * @returns boolean indicating whether the date is in a leap year
@@ -11,8 +16,12 @@ import { Temporal } from "@js-temporal/polyfill";
  * @example isLeapYear("2024-03-15") // true
  * @example isLeapYear("2023-03-15") // false
  * @example isLeapYear("invalid") // false
+ * @example isLeapYear("2024-03-15T10:00") // false (a date-time, not a PlainDate)
+ * @example isLeapYear("2024-03-15T10:00".slice(0, 10)) // true (the date part)
  */
 export function isLeapYear(value) {
+    if (!isValidDate(value))
+        return false;
     try {
         const date = Temporal.PlainDate.from(value);
         return date.inLeapYear;