z-schema 10.0.0 → 12.0.0

package/dist/types/z-schema.d.ts

@@ -6,17 +6,60 @@ import type { SchemaReader } from './z-schema-reader.js';
 import './z-schema-versions.js';
 import { ZSchemaBase } from './z-schema-base.js';
 export declare class ZSchema extends ZSchemaBase {
-    /** @deprecated Use ZSchema.create() instead. */
-    private constructor();
+    /** @internal Use ZSchema.create() instead. */
+    constructor(options: ZSchemaOptions | undefined, token: symbol);
+    /**
+     * Register a global format validator available to all instances.
+     * @param name - The format name (e.g. `'email'`, `'date'`).
+     * @param validatorFunction - A sync or async function `(value: unknown) => boolean | Promise<boolean>`.
+     */
     static registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
+    /**
+     * Remove a globally registered format validator.
+     * @param name - The format name to unregister.
+     */
     static unregisterFormat(name: string): void;
+    /** Returns the names of all globally registered format validators. */
     static getRegisteredFormats(): string[];
+    /** Returns a deep clone of the default options. */
     static getDefaultOptions(): ZSchemaOptions;
+    /**
+     * Register a remote schema in the global cache so any instance can resolve `$ref` to it.
+     * @param uri - The URI the schema will be known by.
+     * @param schema - The schema object or JSON string.
+     * @param validationOptions - Optional options used for schema preparation.
+     */
     static setRemoteReference(uri: string, schema: string | JsonSchema, validationOptions?: ZSchemaOptions): void;
+    /** Returns the current global schema reader, or `undefined` if none is set. */
     static getSchemaReader(): SchemaReader | undefined;
+    /**
+     * Set a global schema reader function used to resolve remote `$ref` URIs.
+     * @param schemaReader - A function `(uri: string) => JsonSchema | undefined`, or `undefined` to clear.
+     */
     static setSchemaReader(schemaReader: SchemaReader | undefined): void;
     static schemaSymbol: symbol;
     static jsonSymbol: symbol;
+    /**
+     * Create a validator instance.
+     *
+     * The returned type depends on the `async` and `safe` options:
+     * - `{}` → `ZSchema` — `validate()` returns `true` or throws.
+     * - `{ safe: true }` → `ZSchemaSafe` — `validate()` returns `{ valid, err? }`.
+     * - `{ async: true }` → `ZSchemaAsync` — `validate()` returns `Promise<true>` or rejects.
+     * - `{ async: true, safe: true }` → `ZSchemaAsyncSafe` — `validate()` returns `Promise<{ valid, err? }>`.
+     *
+     * @param options - Validator configuration. See `ZSchemaOptions` for all available settings.
+     * @returns A validator instance of the appropriate variant.
+     *
+     * @example
+     * ```ts
+     * const validator = ZSchema.create();
+     * validator.validate(data, schema); // throws on error
+     *
+     * const safe = ZSchema.create({ safe: true });
+     * const result = safe.validate(data, schema); // { valid, err? }
+     * ```
+     */
     static create(options: ZSchemaOptions & {
         async: true;
         safe: true;
@@ -28,28 +71,121 @@ export declare class ZSchema extends ZSchemaBase {
         safe: true;
     }): ZSchemaSafe;
     static create(options?: ZSchemaOptions): ZSchema;
+    /**
+     * Validate JSON data against a schema.
+     * @param json - The data to validate.
+     * @param schema - A JSON Schema object or a schema id string (previously registered via `validateSchema`).
+     * @param options - Per-call options (`schemaPath`, `includeErrors`, `excludeErrors`).
+     * @returns `true` if valid.
+     * @throws {@link ValidateError} if validation fails, with a `details` array of structured errors.
+     */
     validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): true;
+    /**
+     * Validate JSON data against a schema, returning a result object instead of throwing.
+     * @param json - The data to validate.
+     * @param schema - A JSON Schema object or a schema id string.
+     * @param options - Per-call options.
+     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
+     */
     validateSafe(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): ValidateResponse;
+    /**
+     * Validate JSON data against a schema asynchronously (supports async format validators).
+     * @param json - The data to validate.
+     * @param schema - A JSON Schema object or a schema id string.
+     * @param options - Per-call options.
+     * @returns A promise that resolves to `true` if valid.
+     * @throws {@link ValidateError} if validation fails (the promise rejects).
+     */
     validateAsync(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<true>;
+    /**
+     * Validate JSON data against a schema asynchronously, returning a result object.
+     * The promise always resolves (never rejects).
+     * @param json - The data to validate.
+     * @param schema - A JSON Schema object or a schema id string.
+     * @param options - Per-call options.
+     * @returns A promise resolving to `{ valid: true }` or `{ valid: false, err: ValidateError }`.
+     */
     validateAsyncSafe(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<ValidateResponse>;
+    /**
+     * Validate one or more JSON Schemas, compiling and caching them for later use with `validate()`.
+     * @param schemaOrArr - A single schema or an array of schemas (for cross-referencing).
+     * @returns `true` if all schemas are valid.
+     * @throws {@link ValidateError} if any schema is invalid.
+     */
     validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): true;
+    /**
+     * Validate one or more JSON Schemas, returning a result object instead of throwing.
+     * @param schemaOrArr - A single schema or an array of schemas.
+     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
+     */
     validateSchemaSafe(schemaOrArr: JsonSchema | JsonSchema[]): ValidateResponse;
 }
+/**
+ * Synchronous safe validator — `validate()` returns `{ valid, err? }` instead of throwing.
+ * Created via `ZSchema.create({ safe: true })`.
+ */
 export declare class ZSchemaSafe extends ZSchemaBase {
-    /** @deprecated Use ZSchema.create() instead. */
-    private constructor();
+    /** @internal Use ZSchema.create() instead. */
+    constructor(options: ZSchemaOptions | undefined, token: symbol);
+    /**
+     * Validate JSON data against a schema.
+     * @param json - The data to validate.
+     * @param schema - A JSON Schema object or a schema id string.
+     * @param options - Per-call options.
+     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
+     */
     validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): ValidateResponse;
+    /**
+     * Validate one or more JSON Schemas.
+     * @param schemaOrArr - A single schema or an array of schemas.
+     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
+     */
     validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): ValidateResponse;
 }
+/**
+ * Asynchronous throw validator — `validate()` returns `Promise<true>` or rejects.
+ * Created via `ZSchema.create({ async: true })`.
+ */
 export declare class ZSchemaAsync extends ZSchemaBase {
-    /** @deprecated Use ZSchema.create() instead. */
-    private constructor();
+    /** @internal Use ZSchema.create() instead. */
+    constructor(options: ZSchemaOptions | undefined, token: symbol);
+    /**
+     * Validate JSON data against a schema asynchronously.
+     * @param json - The data to validate.
+     * @param schema - A JSON Schema object or a schema id string.
+     * @param options - Per-call options.
+     * @returns A promise that resolves to `true` if valid.
+     * @throws {@link ValidateError} if validation fails (the promise rejects).
+     */
     validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<true>;
+    /**
+     * Validate one or more JSON Schemas (synchronous, throws on error).
+     * @param schemaOrArr - A single schema or an array of schemas.
+     * @returns `true` if all schemas are valid.
+     * @throws {@link ValidateError} if any schema is invalid.
+     */
     validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): true;
 }
+/**
+ * Asynchronous safe validator — `validate()` returns `Promise<{ valid, err? }>` (never rejects).
+ * Created via `ZSchema.create({ async: true, safe: true })`.
+ */
 export declare class ZSchemaAsyncSafe extends ZSchemaBase {
-    /** @deprecated Use ZSchema.create() instead. */
-    private constructor();
+    /** @internal Use ZSchema.create() instead. */
+    constructor(options: ZSchemaOptions | undefined, token: symbol);
+    /**
+     * Validate JSON data against a schema asynchronously.
+     * The promise always resolves (never rejects).
+     * @param json - The data to validate.
+     * @param schema - A JSON Schema object or a schema id string.
+     * @param options - Per-call options.
+     * @returns A promise resolving to `{ valid: true }` or `{ valid: false, err: ValidateError }`.
+     */
     validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<ValidateResponse>;
+    /**
+     * Validate one or more JSON Schemas.
+     * @param schemaOrArr - A single schema or an array of schemas.
+     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
+     */
     validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): ValidateResponse;
 }

package/dist/utils/array.js

@@ -1,11 +1,52 @@
 import { areEqual } from './json.js';
-export const isUniqueArray = (arr, indexes) => {
-    let i;
-    let j;
+/**
+ * Check if all elements in an array are unique.
+ *
+ * Uses a Set-based fast path for arrays of pure primitives (O(n)).
+ * Falls back to pairwise deep comparison (O(n²)) when the array contains
+ * objects or arrays that need structural equality checks.
+ */
+export const isUniqueArray = (arr, indexes, maxDepth) => {
     const l = arr.length;
-    for (i = 0; i < l; i++) {
-        for (j = i + 1; j < l; j++) {
-            if (areEqual(arr[i], arr[j])) {
+    if (l <= 1)
+        return true;
+    // Fast path: if every element is a primitive, use a Set.
+    // We distinguish types so that e.g. 1 !== '1' and 0 !== false.
+    let allPrimitive = true;
+    for (let i = 0; i < l; i++) {
+        const v = arr[i];
+        if (v !== null && typeof v === 'object') {
+            allPrimitive = false;
+            break;
+        }
+    }
+    if (allPrimitive) {
+        // Prefix each value with its type so "1" (number) !== "1" (string).
+        const seen = new Set();
+        for (let i = 0; i < l; i++) {
+            const v = arr[i];
+            const key = typeof v + ':' + String(v);
+            if (seen.has(key)) {
+                // Find the first occurrence for the indexes report.
+                if (indexes) {
+                    for (let j = 0; j < i; j++) {
+                        const prev = arr[j];
+                        if (typeof prev === typeof v && prev === v) {
+                            indexes.push(j, i);
+                            break;
+                        }
+                    }
+                }
+                return false;
+            }
+            seen.add(key);
+        }
+        return true;
+    }
+    // Slow path: at least one element is an object/array — need deep comparison.
+    for (let i = 0; i < l; i++) {
+        for (let j = i + 1; j < l; j++) {
+            if (areEqual(arr[i], arr[j], { maxDepth })) {
                 if (indexes) {
                     indexes.push(i, j);
                 }
@@ -16,10 +57,11 @@ export const isUniqueArray = (arr, indexes) => {
     return true;
 };
 export const difference = (bigSet, subSet) => {
+    const exclusions = new Set(subSet);
     const arr = [];
     let idx = bigSet.length;
     while (idx--) {
-        if (subSet.indexOf(bigSet[idx]) === -1) {
+        if (!exclusions.has(bigSet[idx])) {
             arr.push(bigSet[idx]);
         }
     }

package/dist/utils/base64.js

@@ -0,0 +1,29 @@
+const base64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+export const isValidBase64 = (value) => {
+    if (value.length % 4 !== 0) {
+        return false;
+    }
+    return base64Pattern.test(value);
+};
+export const decodeBase64 = (value) => {
+    if (!isValidBase64(value)) {
+        return undefined;
+    }
+    if (typeof atob === 'function') {
+        try {
+            return atob(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (typeof Buffer !== 'undefined') {
+        try {
+            return Buffer.from(value, 'base64').toString('utf8');
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+};

package/dist/utils/clone.js

@@ -1,15 +1,14 @@
+import { DEFAULT_MAX_RECURSION_DEPTH } from '../z-schema-options.js';
 import { copyProp } from './properties.js';
 export const shallowClone = (src) => {
     if (src == null || typeof src !== 'object') {
         return src;
     }
     let res;
-    let idx;
     if (Array.isArray(src)) {
         res = [];
-        idx = src.length;
-        while (idx--) {
-            res[idx] = src[idx];
+        for (let i = 0; i < src.length; i++) {
+            res[i] = src[i];
         }
     }
     else {
@@ -21,16 +20,19 @@ export const shallowClone = (src) => {
     }
     return res;
 };
-export const deepClone = (src) => {
+export const deepClone = (src, maxDepth = DEFAULT_MAX_RECURSION_DEPTH) => {
     let vidx = 0;
     const visited = new Map();
     const cloned = [];
-    const cloneDeepInner = (src) => {
+    const cloneDeepInner = (src, _depth) => {
         if (typeof src !== 'object' || src === null) {
             return src;
         }
+        if (_depth >= maxDepth) {
+            throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in deepClone. ` +
+                'If your schema or data is deeply nested and valid, increase the maxRecursionDepth option.');
+        }
         let res;
-        let idx;
         const cidx = visited.get(src);
         if (cidx !== undefined) {
             return cloned[cidx];
@@ -39,9 +41,8 @@ export const deepClone = (src) => {
         if (Array.isArray(src)) {
             res = [];
             cloned.push(res);
-            idx = src.length;
-            while (idx--) {
-                res[idx] = cloneDeepInner(src[idx]);
+            for (let i = 0; i < src.length; i++) {
+                res[i] = cloneDeepInner(src[i], _depth + 1);
             }
         }
         else {
@@ -49,10 +50,10 @@ export const deepClone = (src) => {
             cloned.push(res);
             const keys = Object.keys(src).sort();
             for (const key of keys) {
-                copyProp(src, res, key, cloneDeepInner);
+                copyProp(src, res, key, (v) => cloneDeepInner(v, _depth + 1));
             }
         }
         return res;
     };
-    return cloneDeepInner(src);
+    return cloneDeepInner(src, 0);
 };

package/dist/utils/date.js

@@ -0,0 +1,21 @@
+const isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+const getDaysInMonth = (year, month) => {
+    switch (month) {
+        case 2:
+            return isLeapYear(year) ? 29 : 28;
+        case 4:
+        case 6:
+        case 9:
+        case 11:
+            return 30;
+        default:
+            return 31;
+    }
+};
+export const isValidRfc3339Date = (year, month, day) => {
+    if (month < 1 || month > 12) {
+        return false;
+    }
+    const maxDay = getDaysInMonth(year, month);
+    return day >= 1 && day <= maxDay;
+};

package/dist/utils/hostname.js

@@ -0,0 +1,146 @@
+import punycode from 'punycode/punycode.js';
+import isIPModule from 'validator/lib/isIP.js';
+const IDN_SEPARATOR_REGEX = /[\u3002\uff0e\uff61]/g;
+const IDN_SEPARATOR_TEST_REGEX = /[\u3002\uff0e\uff61]/;
+const splitHostnameLabels = (hostname) => {
+    if (hostname.length === 0 || hostname.length > 255) {
+        return null;
+    }
+    if (hostname.startsWith('.') || hostname.endsWith('.')) {
+        return null;
+    }
+    const labels = hostname.split('.');
+    if (labels.some((label) => label.length === 0 || label.length > 63)) {
+        return null;
+    }
+    return labels;
+};
+const isAsciiHostnameLabel = (label) => /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label);
+const isGreek = (char) => /\p{Script=Greek}/u.test(char);
+const isHebrew = (char) => /\p{Script=Hebrew}/u.test(char);
+const hasCjkKanaOrHan = (input) => /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/u.test(input);
+const toUnicodeLabel = (label) => {
+    if (!/^xn--/i.test(label)) {
+        return label;
+    }
+    try {
+        return punycode.toUnicode(label.toLowerCase());
+    }
+    catch (_e) {
+        return null;
+    }
+};
+const isValidIdnUnicodeLabel = (label) => {
+    if (label.startsWith('-') || label.endsWith('-')) {
+        return false;
+    }
+    if (label.length >= 4 && label[2] === '-' && label[3] === '-' && !/^xn--/i.test(label)) {
+        return false;
+    }
+    if (/^\p{M}/u.test(label)) {
+        return false;
+    }
+    if (/[\u302e\u302f\u0640\u07fa]/u.test(label)) {
+        return false;
+    }
+    for (let idx = 0; idx < label.length; idx++) {
+        const char = label[idx];
+        if (char === '\u00b7') {
+            if (idx === 0 || idx === label.length - 1 || label[idx - 1] !== 'l' || label[idx + 1] !== 'l') {
+                return false;
+            }
+        }
+        if (char === '\u0375') {
+            if (idx === label.length - 1 || !isGreek(label[idx + 1])) {
+                return false;
+            }
+        }
+        if (char === '\u05f3' || char === '\u05f4') {
+            if (idx === 0 || !isHebrew(label[idx - 1])) {
+                return false;
+            }
+        }
+        if (char === '\u200d') {
+            if (idx === 0 || label[idx - 1] !== '\u094d') {
+                return false;
+            }
+        }
+    }
+    if (label.includes('\u30fb') && !hasCjkKanaOrHan(label.replace(/\u30fb/g, ''))) {
+        return false;
+    }
+    const hasArabicIndic = /[\u0660-\u0669]/.test(label);
+    const hasExtendedArabicIndic = /[\u06f0-\u06f9]/.test(label);
+    if (hasArabicIndic && hasExtendedArabicIndic) {
+        return false;
+    }
+    return true;
+};
+/*
+  http://json-schema.org/latest/json-schema-validation.html#anchor114
+  A string instance is valid against this attribute if it is a valid
+  representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
+
+  http://tools.ietf.org/html/rfc1034#section-3.5
+
+  <digit> ::= any one of the ten digits 0 through 9
+  var digit = /[0-9]/;
+
+  <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
+  var letter = /[a-zA-Z]/;
+
+  <let-dig> ::= <letter> | <digit>
+  var letDig = /[0-9a-zA-Z]/;
+
+  <let-dig-hyp> ::= <let-dig> | "-"
+  var letDigHyp = /[-0-9a-zA-Z]/;
+
+  <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+  var ldhStr = /[-0-9a-zA-Z]+/;
+
+  <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
+  var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
+
+  <subdomain> ::= <label> | <subdomain> "." <label>
+  var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
+
+  <domain> ::= <subdomain> | " "
+  var domain = null;
+*/
+export const isValidHostname = (hostname) => {
+    // eslint-disable-next-line no-control-regex
+    if (IDN_SEPARATOR_TEST_REGEX.test(hostname) || /[^\x00-\x7F]/.test(hostname)) {
+        return false;
+    }
+    if (isIPModule.default(hostname, 4)) {
+        return false;
+    }
+    const labels = splitHostnameLabels(hostname);
+    if (labels === null) {
+        return false;
+    }
+    for (const label of labels) {
+        if (!isAsciiHostnameLabel(label)) {
+            return false;
+        }
+        const unicodeLabel = toUnicodeLabel(label);
+        if (unicodeLabel === null || !isValidIdnUnicodeLabel(unicodeLabel)) {
+            return false;
+        }
+    }
+    return true;
+};
+export const isValidIdnHostname = (hostname) => {
+    const normalizedHostname = hostname.replace(IDN_SEPARATOR_REGEX, '.');
+    const labels = splitHostnameLabels(normalizedHostname);
+    if (labels === null) {
+        return false;
+    }
+    for (const label of labels) {
+        const unicodeLabel = toUnicodeLabel(label);
+        if (unicodeLabel === null || !isValidIdnUnicodeLabel(unicodeLabel)) {
+            return false;
+        }
+    }
+    return true;
+};

package/dist/utils/json.js

@@ -1,7 +1,8 @@
+import { DEFAULT_MAX_RECURSION_DEPTH } from '../z-schema-options.js';
 import { isObject } from './what-is.js';
-export const areEqual = (json1, json2, options) => {
-    options = options || {};
-    const caseInsensitiveComparison = options.caseInsensitiveComparison || false;
+export const areEqual = (json1, json2, options, _depth = 0) => {
+    const caseInsensitiveComparison = options?.caseInsensitiveComparison || false;
+    const maxDepth = options?.maxDepth ?? DEFAULT_MAX_RECURSION_DEPTH;
     // http://json-schema.org/latest/json-schema-core.html#rfc.section.3.6
     // Two JSON values are said to be equal if and only if:
     // both are nulls; or
@@ -17,6 +18,10 @@ export const areEqual = (json1, json2, options) => {
         json1.toUpperCase() === json2.toUpperCase()) {
         return true;
     }
+    if (_depth >= maxDepth) {
+        throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in areEqual. ` +
+            'If your data is deeply nested and valid, increase the maxRecursionDepth option.');
+    }
     let i, len;
     // both are arrays, and:
     if (Array.isArray(json1) && Array.isArray(json2)) {
@@ -27,7 +32,7 @@ export const areEqual = (json1, json2, options) => {
         // items at the same index are equal according to this definition; or
         len = json1.length;
         for (i = 0; i < len; i++) {
-            if (!areEqual(json1[i], json2[i], { caseInsensitiveComparison: caseInsensitiveComparison })) {
+            if (!areEqual(json1[i], json2[i], options, _depth + 1)) {
                 return false;
             }
         }
@@ -38,13 +43,13 @@ export const areEqual = (json1, json2, options) => {
         // have the same set of property names; and
         const keys1 = sortedKeys(json1);
         const keys2 = sortedKeys(json2);
-        if (!areEqual(keys1, keys2, { caseInsensitiveComparison: caseInsensitiveComparison })) {
+        if (!areEqual(keys1, keys2, options, _depth + 1)) {
             return false;
         }
         // values for a same property name are equal according to this definition.
         len = keys1.length;
         for (i = 0; i < len; i++) {
-            if (!areEqual(json1[keys1[i]], json2[keys1[i]], { caseInsensitiveComparison: caseInsensitiveComparison })) {
+            if (!areEqual(json1[keys1[i]], json2[keys1[i]], options, _depth + 1)) {
                 return false;
             }
         }

package/dist/utils/properties.js

@@ -1,10 +1,5 @@
-// Safe own-property check utility
-// Returns true if the object has the property as its own (not inherited)
-export function hasOwn(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
 export function copyProp(from, to, key, fn) {
-    if (hasOwn(from, key)) {
+    if (Object.hasOwn(from, key)) {
         Object.defineProperty(to, key, {
             value: fn ? fn(from[key]) : from[key],
             enumerable: true,

package/dist/utils/time.js

@@ -0,0 +1,50 @@
+export const toUtcTime = (hour, minute, offsetSign, offsetHour, offsetMinute) => {
+    const localTotalMinutes = hour * 60 + minute;
+    const offsetTotalMinutes = offsetHour * 60 + offsetMinute;
+    const utcTotalMinutes = offsetSign === '+' ? localTotalMinutes - offsetTotalMinutes : localTotalMinutes + offsetTotalMinutes;
+    const normalizedUtcTotalMinutes = ((utcTotalMinutes % 1440) + 1440) % 1440;
+    return {
+        hour: Math.floor(normalizedUtcTotalMinutes / 60),
+        minute: normalizedUtcTotalMinutes % 60,
+    };
+};
+const RFC3339_TIME_REGEX = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(\.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/i;
+export const parseRfc3339Time = (time) => {
+    const matches = RFC3339_TIME_REGEX.exec(time);
+    if (matches === null) {
+        return null;
+    }
+    const hour = parseInt(matches[1], 10);
+    const minute = parseInt(matches[2], 10);
+    const second = parseInt(matches[3], 10);
+    if (hour > 23 || minute > 59 || second > 60) {
+        return null;
+    }
+    let utcHour = hour;
+    let utcMinute = minute;
+    if (matches[5].toLowerCase() !== 'z') {
+        const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(matches[5]);
+        if (offsetMatches === null) {
+            return null;
+        }
+        const offsetSign = offsetMatches[1];
+        const offsetHour = parseInt(offsetMatches[2], 10);
+        const offsetMinute = parseInt(offsetMatches[3], 10);
+        if (offsetHour > 23 || offsetMinute > 59) {
+            return null;
+        }
+        const utc = toUtcTime(hour, minute, offsetSign, offsetHour, offsetMinute);
+        utcHour = utc.hour;
+        utcMinute = utc.minute;
+    }
+    if (second === 60 && (utcHour !== 23 || utcMinute !== 59)) {
+        return null;
+    }
+    return {
+        hour,
+        minute,
+        second,
+        utcHour,
+        utcMinute,
+    };
+};