z-schema 12.0.4 → 12.1.0

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

@@ -1,87 +0,0 @@
-import type { ValidateError } from './errors.js';
-import type { FormatValidatorFn } from './format-validators.js';
-import type { JsonSchema, JsonSchemaInternal } from './json-schema-versions.js';
-import type { ZSchemaOptions } from './z-schema-options.js';
-import { type Errors } from './errors.js';
-import { Report } from './report.js';
-import { SchemaCache } from './schema-cache.js';
-import { SchemaCompiler } from './schema-compiler.js';
-import { SchemaValidator } from './schema-validator.js';
-export interface ValidateOptions {
-    schemaPath?: string;
-    includeErrors?: Array<keyof typeof Errors>;
-    excludeErrors?: Array<keyof typeof Errors>;
-}
-export type ValidateResponse = {
-    valid: boolean;
-    err?: ValidateError;
-};
-export type ValidateCallback = (err: ValidateResponse['err'], valid: ValidateResponse['valid']) => void;
-/**
- * Module-private symbol used by `ZSchema.create()` to authorise construction.
- * Not exported — external code cannot instantiate ZSchema variants directly.
- */
-export declare const FACTORY_TOKEN: unique symbol;
-export declare class ZSchemaBase {
-    scache: SchemaCache;
-    sc: SchemaCompiler;
-    sv: SchemaValidator;
-    validateOptions: ValidateOptions;
-    options: ZSchemaOptions;
-    constructor(options: ZSchemaOptions | undefined, token: symbol);
-    /**
-     * Internal recursive JSON validation — delegates to the `validate` function
-     * in `json-validation.ts`. Exposed as a method so that per-keyword validator
-     * modules (array, combinators, object) can call back into the core validator
-     * via `this` without importing `json-validation.ts` directly (which would
-     * create a circular dependency).
-     */
-    _jsonValidate(report: Report, schema: boolean | JsonSchemaInternal, json: unknown): boolean;
-    getDefaultSchemaId(): string;
-    _validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions, callback: ValidateCallback): void;
-    _validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
-    _validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): true;
-    _validate(json: unknown, schema: JsonSchema | string): true;
-    _validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): true;
-    /**
-     * Register a format validator on this instance only (does not affect other instances or the global registry).
-     * @param name - The format name.
-     * @param validatorFunction - A sync or async function `(value: unknown) => boolean | Promise<boolean>`.
-     */
-    registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
-    /**
-     * Unregister an instance-scoped format validator.
-     * @param name - The format name to unregister.
-     */
-    unregisterFormat(name: string): void;
-    /** Returns the names of format validators registered on this instance. */
-    getRegisteredFormats(): string[];
-    /** Returns all supported format names (global + instance-registered). */
-    getSupportedFormats(): string[];
-    /**
-     * Register a remote schema in this instance's cache so `$ref` can resolve 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.
-     */
-    setRemoteReference(uri: string, schema: string | JsonSchema, validationOptions?: ZSchemaOptions): void;
-    /**
-     * Extract unresolvable `$ref` URIs from a validation error.
-     * @param err - A `ValidateError` from a failed validation.
-     * @returns An array of unresolvable reference URIs.
-     */
-    getMissingReferences(err: ValidateError): string[];
-    /**
-     * Extract unresolvable **remote** `$ref` URIs from a validation error (local fragment-only refs are excluded).
-     * @param err - A `ValidateError` from a failed validation.
-     * @returns An array of remote reference base URIs.
-     */
-    getMissingRemoteReferences(err: ValidateError): string[];
-    /**
-     * Resolve a previously compiled schema by its `$id` / `id`, cleaning up internal bookkeeping properties
-     * and inlining resolved `$ref` targets.
-     * @param schemaId - The schema identifier to look up.
-     * @returns A clean, resolved copy of the schema, or `undefined` if not found.
-     */
-    getResolvedSchema(schemaId: string): JsonSchema | undefined;
-}

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

@@ -1,35 +0,0 @@
-import type { FormatValidatorFn } from './format-validators.js';
-import type { Report } from './report.js';
-import { type JsonSchemaVersion } from './json-schema-versions.js';
-import { DEFAULT_MAX_RECURSION_DEPTH, MAX_ASYNC_TIMEOUT } from './utils/constants.js';
-export { DEFAULT_MAX_RECURSION_DEPTH, MAX_ASYNC_TIMEOUT };
-export interface ZSchemaOptions {
-    version?: JsonSchemaVersion | 'none';
-    asyncTimeout?: number;
-    forceAdditional?: boolean;
-    assumeAdditional?: boolean | string[];
-    enumCaseInsensitiveComparison?: boolean;
-    forceItems?: boolean;
-    forceMinItems?: boolean;
-    forceMaxItems?: boolean;
-    forceMinLength?: boolean;
-    forceMaxLength?: boolean;
-    forceProperties?: boolean;
-    ignoreUnresolvableReferences?: boolean;
-    noExtraKeywords?: boolean;
-    noTypeless?: boolean;
-    noEmptyStrings?: boolean;
-    noEmptyArrays?: boolean;
-    strictUris?: boolean;
-    strictMode?: boolean;
-    reportPathAsArray?: boolean;
-    breakOnFirstError?: boolean;
-    pedanticCheck?: boolean;
-    ignoreUnknownFormats?: boolean;
-    formatAssertions?: boolean | null;
-    customValidator?: (report: Report, schema: unknown, json: unknown) => void;
-    customFormats?: Record<string, FormatValidatorFn | null>;
-    maxRecursionDepth?: number;
-}
-export declare const defaultOptions: ZSchemaOptions;
-export declare const normalizeOptions: (options?: ZSchemaOptions) => ZSchemaOptions;

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

@@ -1,4 +0,0 @@
-import type { JsonSchema } from './json-schema-versions.js';
-export type SchemaReader = (uri: string) => JsonSchema;
-export declare function getSchemaReader(): SchemaReader | undefined;
-export declare function setSchemaReader(schemaReader: SchemaReader | undefined): void;

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,191 +0,0 @@
-import type { FormatValidatorFn } from './format-validators.js';
-import type { JsonSchema } from './json-schema-versions.js';
-import type { ValidateOptions, ValidateResponse } from './z-schema-base.js';
-import type { ZSchemaOptions } from './z-schema-options.js';
-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 {
-    /** @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;
-    }): ZSchemaAsyncSafe;
-    static create(options: ZSchemaOptions & {
-        async: true;
-    }): ZSchemaAsync;
-    static create(options: ZSchemaOptions & {
-        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 {
-    /** @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 {
-    /** @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 {
-    /** @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,69 +0,0 @@
-import { areEqual } from './json.js';
-/**
- * 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;
-    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);
-                }
-                return false;
-            }
-        }
-    }
-    return true;
-};
-export const difference = (bigSet, subSet) => {
-    const exclusions = new Set(subSet);
-    const arr = [];
-    let idx = bigSet.length;
-    while (idx--) {
-        if (!exclusions.has(bigSet[idx])) {
-            arr.push(bigSet[idx]);
-        }
-    }
-    return arr;
-};

package/dist/utils/base64.js

@@ -1,29 +0,0 @@
-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,59 +0,0 @@
-import { DEFAULT_MAX_RECURSION_DEPTH } from './constants.js';
-import { copyProp } from './properties.js';
-export const shallowClone = (src) => {
-    if (src == null || typeof src !== 'object') {
-        return src;
-    }
-    let res;
-    if (Array.isArray(src)) {
-        res = [];
-        for (let i = 0; i < src.length; i++) {
-            res[i] = src[i];
-        }
-    }
-    else {
-        res = {};
-        const keys = Object.keys(src).sort();
-        for (const key of keys) {
-            copyProp(src, res, key);
-        }
-    }
-    return res;
-};
-export const deepClone = (src, maxDepth = DEFAULT_MAX_RECURSION_DEPTH) => {
-    let vidx = 0;
-    const visited = new Map();
-    const cloned = [];
-    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;
-        const cidx = visited.get(src);
-        if (cidx !== undefined) {
-            return cloned[cidx];
-        }
-        visited.set(src, vidx++);
-        if (Array.isArray(src)) {
-            res = [];
-            cloned.push(res);
-            for (let i = 0; i < src.length; i++) {
-                res[i] = cloneDeepInner(src[i], _depth + 1);
-            }
-        }
-        else {
-            res = {};
-            cloned.push(res);
-            const keys = Object.keys(src).sort();
-            for (const key of keys) {
-                copyProp(src, res, key, (v) => cloneDeepInner(v, _depth + 1));
-            }
-        }
-        return res;
-    };
-    return cloneDeepInner(src, 0);
-};

package/dist/utils/constants.js

@@ -1,19 +0,0 @@
-/**
- * Default maximum recursion depth for deeply nested schema/data traversal.
- * Used as the default for {@link ZSchemaOptions.maxRecursionDepth} and
- * internal helpers like `deepClone` and `collectIds`.
- */
-export const DEFAULT_MAX_RECURSION_DEPTH = 100;
-/**
- * Maximum allowed value for {@link ZSchemaOptions.asyncTimeout} in milliseconds.
- * Values exceeding this limit are clamped during option normalization to
- * prevent resource exhaustion (CWE-400).
- */
-export const MAX_ASYNC_TIMEOUT = 60_000;
-/**
- * Maximum allowed length for a JSON Schema `pattern` regular expression string.
- * Patterns exceeding this limit are rejected by {@link compileSchemaRegex} to
- * mitigate Regular Expression Denial-of-Service (CWE-1333) and regex injection
- * (CWE-95).
- */
-export const MAX_SCHEMA_REGEX_LENGTH = 10_000;

package/dist/utils/date.js

@@ -1,21 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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;
-};