@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/esm/lib/validation/VLD.js

@@ -0,0 +1,210 @@
+import Engine from './engine/schema/index.js';
+import { extendBigInt } from './engine/schema/extensions/bigint.js';
+import { currentValidationLanguage } from './ValidationLanguage.js';
+import { InvalidValueException } from '../../exceptions/dto/InvalidValueException.js';
+import { As } from '@lakutata/utils/As';
+import { withCause } from '../helpers/internal/WithCause.js';
+export const DefaultValidationOptions = Object.freeze({
+    abortEarly: true,
+    cache: false,
+    allowUnknown: true,
+    stripUnknown: true,
+    convert: true
+});
+let mergedOptionsRoot = { next: new Map() };
+let mergedOptionsCount = 0;
+const maxMergedOptions = 1000;
+/**
+ * The default options merged with the options. For options of primitive values, the merged options are frozen and
+ * reused (the validation engine then reuses its settings and the schema preferences merged with them).
+ * @param options
+ */
+function mergeOptions(options) {
+    if (Object.getOwnPropertySymbols(options).length)
+        return { ...DefaultValidationOptions, ...options };
+    let node = mergedOptionsRoot;
+    for (const name of Object.keys(options)) {
+        const value = options[name];
+        //-0 is not kept apart from 0 by the maps
+        if ((value !== null && typeof value === 'object') || typeof value === 'function' || Object.is(value, -0))
+            return { ...DefaultValidationOptions, ...options };
+        let byValue = node.next.get(name);
+        if (!byValue) {
+            byValue = new Map();
+            node.next.set(name, byValue);
+        }
+        let child = byValue.get(value);
+        if (!child) {
+            child = { next: new Map() };
+            byValue.set(value, child);
+        }
+        node = child;
+    }
+    if (!node.merged) {
+        if (mergedOptionsCount >= maxMergedOptions) {
+            mergedOptionsRoot = { next: new Map() };
+            mergedOptionsCount = 0;
+        }
+        node.merged = Object.freeze({ ...DefaultValidationOptions, ...options });
+        mergedOptionsCount++;
+    }
+    return node.merged;
+}
+/**
+ * The object schemas wrapping a schema under a target name, by schema then by name (schemas are immutable)
+ */
+const targetSchemas = new WeakMap();
+/**
+ * An object schema with the schema under the target name, reused for schema objects
+ * @param schema
+ * @param targetName
+ */
+function targetSchema(schema, targetName) {
+    if (!Engine.isSchema(schema))
+        return Engine.object({ [targetName]: schema });
+    let byName = targetSchemas.get(schema);
+    if (!byName) {
+        byName = new Map();
+        targetSchemas.set(schema, byName);
+    }
+    let wrapper = byName.get(targetName);
+    if (!wrapper) {
+        wrapper = Engine.object({ [targetName]: schema });
+        byName.set(targetName, wrapper);
+    }
+    return wrapper;
+}
+class ValidateMethods {
+    /**
+     * Whether input is schema or not
+     * @param schema
+     */
+    isSchema(schema) {
+        return Engine.isSchema(schema);
+    }
+    /**
+     * Is data matched with given schema
+     * @param data
+     * @param schema
+     * @param options
+     */
+    isValid(data, schema, options = {}) {
+        try {
+            this.validate(data, schema, options);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Is data matched with given schema
+     * @param data
+     * @param schema
+     * @param options
+     */
+    async isValidAsync(data, schema, options = {}) {
+        try {
+            await this.validateAsync(data, schema, options);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Validates a value using the schema and options.
+     * @param data
+     * @param schema
+     * @param options
+     */
+    validate(data, schema, options = {}) {
+        try {
+            return this.validateIn(data, schema, options);
+        }
+        catch (error) {
+            //An invalid value of the code running in a language: validated again in it, for its errors
+            const language = inLanguage(options);
+            if (!language)
+                throw error;
+            return this.validateIn(data, schema, { ...options, errors: { ...As(options).errors, language: language } });
+        }
+    }
+    /**
+     * Validates a value using the schema and options (in the language of the options)
+     * @param data
+     * @param schema
+     * @param options
+     */
+    validateIn(data, schema, options) {
+        options = mergeOptions(options);
+        let error;
+        let value;
+        if (options.targetName) {
+            const result = targetSchema(schema, options.targetName).validate({ [options.targetName]: data }, As(options));
+            error = result.error;
+            value = As(result.value)[options.targetName];
+        }
+        else {
+            const result = As(schema).validate(data, As(options));
+            error = result.error;
+            value = As(result.value);
+        }
+        if (error)
+            throw withCause(new InvalidValueException(error.message), error);
+        return value;
+    }
+    /**
+     * Validates a value using the schema and options.
+     * @param data
+     * @param schema
+     * @param options
+     */
+    async validateAsync(data, schema, options = {}) {
+        try {
+            return await this.validateAsyncIn(data, schema, options);
+        }
+        catch (error) {
+            //An invalid value of the code running in a language: validated again in it, for its errors
+            const language = inLanguage(options);
+            if (!language)
+                throw error;
+            return await this.validateAsyncIn(data, schema, { ...options, errors: { ...As(options).errors, language: language } });
+        }
+    }
+    /**
+     * Validates a value using the schema and options (in the language of the options)
+     * @param data
+     * @param schema
+     * @param options
+     */
+    async validateAsyncIn(data, schema, options) {
+        options = mergeOptions(options);
+        try {
+            if (options.targetName) {
+                const result = As(await targetSchema(schema, options.targetName).validateAsync({ [options.targetName]: data }, As(mergeOptions({
+                    ...options,
+                    artifacts: false
+                }))));
+                return result[options.targetName];
+            }
+            else {
+                return As(await As(schema).validateAsync(data, As(options)));
+            }
+        }
+        catch (e) {
+            throw withCause(new InvalidValueException(e.message), e);
+        }
+    }
+}
+/**
+ * The language a validation is validated again in when its value is invalid: the one of the code running, unless the
+ * validation gives its own
+ * @param options
+ */
+function inLanguage(options) {
+    const language = currentValidationLanguage();
+    return language && !(As(options).errors?.language) ? language : undefined;
+}
+export const VLD = As(extendBigInt(Engine));
+export const VLDMethods = new ValidateMethods();

package/dist/esm/lib/validation/ValidationLanguage.js

@@ -0,0 +1,51 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * The language of the validations of the code running (the language of a request)
+ */
+const LANGUAGE = new AsyncLocalStorage();
+/**
+ * Run a function with a validation language: the validation errors raised in it, its asynchronous continuations
+ * included, have their messages in that language (the messages registered by `registerValidationMessages()`), except
+ * for the validations giving their own `errors.language` option. The codes without a message in the language keep the
+ * default (English) one, and so does every code of a language with no registered messages.
+ * @param language The language tag the messages are registered under, like `fr` or `zh-CN`.
+ * @param fn The function to run; it may be asynchronous.
+ * @returns What the function returns (its promise, for an asynchronous function).
+ * @remarks A valid value is validated as without a language: only an invalid value is validated a second time, in the
+ * language, for its messages.
+ * @example
+ * ```typescript
+ * import {DTO, loadValidationMessages, registerValidationMessages, runInValidationLanguage} from 'lakutata'
+ *
+ * const messages: Record<string, string> | undefined = await loadValidationMessages('fr')
+ * if (messages) registerValidationMessages('fr', messages)
+ *
+ * await runInValidationLanguage('fr', async (): Promise<void> => {
+ *     try {
+ *         DTO.validate('', DTO.String().required())
+ *     } catch (error) {
+ *         //The message is in French
+ *         console.log((error as Error).message)
+ *     }
+ * })
+ * ```
+ */
+export function runInValidationLanguage(language, fn) {
+    return LANGUAGE.run(language, fn);
+}
+/**
+ * The validation language of the code running, set by `runInValidationLanguage()`.
+ * @returns The language tag, or undefined outside of `runInValidationLanguage()`.
+ * @example
+ * ```typescript
+ * import {currentValidationLanguage, runInValidationLanguage} from 'lakutata'
+ *
+ * console.log(currentValidationLanguage()) //undefined
+ * runInValidationLanguage('ja', (): void => {
+ *     console.log(currentValidationLanguage()) //ja
+ * })
+ * ```
+ */
+export function currentValidationLanguage() {
+    return LANGUAGE.getStore();
+}

package/dist/esm/lib/validation/ValidationMessages.js

@@ -0,0 +1,151 @@
+import { As } from '@lakutata/utils/As';
+import { defaults } from './engine/schema/common.js';
+import { compile } from './engine/schema/messages.js';
+import { VLD } from './VLD.js';
+/**
+ * Register the validation error messages of a language, by error code (`any.required`, `string.min`). The messages are
+ * merged into the ones already registered for the language, replacing those with the same code. A validation in the
+ * language (run in `runInValidationLanguage()`, or given the `errors.language` option) uses them; the codes without a
+ * message in the language keep the default (English) one.
+ * @param language The language tag, like `fr` or `zh-CN`, matched exactly (case-sensitive) by the validations.
+ * @param messages The message templates by error code, like `{'any.required': '{{#label}} est requis'}`: `{{#label}}`,
+ * `{{#limit}}`… are replaced by the context of the error (see `defaultValidationMessages()` for the codes and their
+ * variables).
+ * @throws {SchemaDefinitionException} When a message is not a string, or its template is invalid.
+ * @remarks The templates are compiled once, when registered: register the languages when the application starts.
+ * @example
+ * ```typescript
+ * import {DTO, registerValidationMessages, runInValidationLanguage} from 'lakutata'
+ *
+ * registerValidationMessages('fr', {
+ *     'any.required': '{{#label}} est requis',
+ *     'string.min': '{{#label}} doit contenir au moins {{#limit}} caractères'
+ * })
+ *
+ * runInValidationLanguage('fr', (): void => {
+ *     //Throws: "name" est requis
+ *     DTO.validate({}, DTO.Object({name: DTO.String().min(2).required()}))
+ * })
+ * ```
+ */
+export function registerValidationMessages(language, messages) {
+    const compiled = As(compile({ [language]: messages }));
+    //In place: the settings of the validations reuse the messages of the defaults
+    const registered = As(defaults.messages);
+    registered[language] = { ...registered[language], ...As(compiled[language]) };
+}
+/**
+ * The languages with validation error messages registered by `registerValidationMessages()`.
+ * @returns The language tags, in registration order; empty until a language is registered (the default English
+ * messages are not listed).
+ * @example
+ * ```typescript
+ * import {registerValidationMessages, validationLanguages} from 'lakutata'
+ *
+ * registerValidationMessages('de', {'any.required': '{{#label}} ist erforderlich'})
+ * console.log(validationLanguages()) //['de']
+ * ```
+ */
+export function validationLanguages() {
+    return Object.keys(As(defaults.messages));
+}
+/**
+ * The language tags with built-in validation error messages, which `loadValidationMessages()` loads (`en`: the
+ * default messages).
+ */
+export const BUILT_IN_VALIDATION_LANGUAGES = Object.freeze([
+    'en', 'zh-CN', 'zh-TW', 'ja', 'ko', 'fr', 'de', 'es', 'pt-BR', 'it', 'nl', 'pl', 'ru', 'uk', 'tr', 'vi', 'th', 'id', 'hi', 'ar'
+]);
+/**
+ * The loaders of the built-in messages, by language: static imports, bundled with the applications
+ */
+const LOADERS = {
+    'en': async () => ({ default: defaultValidationMessages() }),
+    'zh-CN': () => import('./messages/zh-CN.js'),
+    'zh-TW': () => import('./messages/zh-TW.js'),
+    'ja': () => import('./messages/ja.js'),
+    'ko': () => import('./messages/ko.js'),
+    'fr': () => import('./messages/fr.js'),
+    'de': () => import('./messages/de.js'),
+    'es': () => import('./messages/es.js'),
+    'pt-BR': () => import('./messages/pt-BR.js'),
+    'it': () => import('./messages/it.js'),
+    'nl': () => import('./messages/nl.js'),
+    'pl': () => import('./messages/pl.js'),
+    'ru': () => import('./messages/ru.js'),
+    'uk': () => import('./messages/uk.js'),
+    'tr': () => import('./messages/tr.js'),
+    'vi': () => import('./messages/vi.js'),
+    'th': () => import('./messages/th.js'),
+    'id': () => import('./messages/id.js'),
+    'hi': () => import('./messages/hi.js'),
+    'ar': () => import('./messages/ar.js')
+};
+/**
+ * The built-in messages language closest to a language tag: the same tag (compared case-insensitively, `_` read as
+ * `-`); for Chinese, the one of its script or region (`zh-Hant`, `zh-HK`, `zh-MO`: `zh-TW`; `zh`, `zh-Hans`, `zh-SG`:
+ * `zh-CN`); otherwise the built-in one of the same primary language (`pt-PT`: `pt-BR`, `en-GB`: `en`).
+ * @param language A language tag, like `pt_PT` or the `Accept-Language` value of a request.
+ * @returns One of `BUILT_IN_VALIDATION_LANGUAGES`, or undefined for a language without built-in messages.
+ * @example
+ * ```typescript
+ * import {builtInValidationLanguage} from 'lakutata'
+ *
+ * console.log(builtInValidationLanguage('zh-HK')) //zh-TW
+ * console.log(builtInValidationLanguage('pt_PT')) //pt-BR
+ * console.log(builtInValidationLanguage('sv')) //undefined
+ * ```
+ */
+export function builtInValidationLanguage(language) {
+    const tag = language.replace(/_/g, '-').toLowerCase();
+    const exact = Object.keys(LOADERS).find((candidate) => candidate.toLowerCase() === tag);
+    if (exact)
+        return exact;
+    const parts = tag.split('-');
+    if (parts[0] === 'zh')
+        return parts.some((part) => ['hant', 'tw', 'hk', 'mo'].includes(part)) ? 'zh-TW' : 'zh-CN';
+    return Object.keys(LOADERS).find((candidate) => candidate.toLowerCase().split('-')[0] === parts[0]);
+}
+/**
+ * Load the built-in validation error messages of a language, the ones of its closest built-in language
+ * (`builtInValidationLanguage()`). They are loaded on demand, so an application only loads the languages it uses; they
+ * are not registered: pass them to `registerValidationMessages()`.
+ * @param language A language tag, like `fr` or `zh-Hant`.
+ * @returns A copy of the message templates by error code (for `en`, the default messages), or undefined for a language
+ * without built-in messages.
+ * @example
+ * ```typescript
+ * import {loadValidationMessages, registerValidationMessages} from 'lakutata'
+ *
+ * for (const language of ['fr', 'zh-CN']) {
+ *     const messages: Record<string, string> | undefined = await loadValidationMessages(language)
+ *     if (messages) registerValidationMessages(language, messages)
+ * }
+ * ```
+ */
+export async function loadValidationMessages(language) {
+    const builtIn = builtInValidationLanguage(language);
+    return builtIn ? { ...(await LOADERS[builtIn]()).default } : undefined;
+}
+/**
+ * The default (English) validation error messages: the starting point of the messages of a new language.
+ * @returns A new object of the message templates by error code, the bigint ones included, like
+ * `{'any.required': '{{#label}} is required', …}`.
+ * @example
+ * ```typescript
+ * import {defaultValidationMessages} from 'lakutata'
+ *
+ * const messages: Record<string, string> = defaultValidationMessages()
+ * console.log(messages['string.min']) //{{#label}} length must be at least {{#limit}} characters long
+ * ```
+ */
+export function defaultValidationMessages() {
+    const messages = {};
+    //The types of the validation, its extensions (bigint) too
+    const types = As(VLD).types();
+    for (const schema of Object.values(types)) {
+        for (const [code, template] of Object.entries(schema._definition.messages ?? {}))
+            messages[code] = template.source;
+    }
+    return messages;
+}

package/dist/esm/lib/validation/engine/address/decode.js

@@ -0,0 +1,101 @@
+/**
+ * Derived from the upstream src/decode.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const HEX = {
+    '0': 0,
+    '1': 1,
+    '2': 2,
+    '3': 3,
+    '4': 4,
+    '5': 5,
+    '6': 6,
+    '7': 7,
+    '8': 8,
+    '9': 9,
+    a: 10,
+    A: 10,
+    b: 11,
+    B: 11,
+    c: 12,
+    C: 12,
+    d: 13,
+    D: 13,
+    e: 14,
+    E: 14,
+    f: 15,
+    F: 15
+};
+const UTF8 = {
+    accept: 12,
+    reject: 0,
+    data: [
+        // Maps bytes to character to a transition
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+        3, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 7, 10, 9, 9, 9, 11, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+        // Maps a state to a new state when adding a transition
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 24, 36, 48, 60, 72, 84, 96, 0, 12, 12, 12, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 48, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0,
+        // Maps the current transition to a mask that needs to apply to the byte
+        0x7f, 0x3f, 0x3f, 0x3f, 0x00, 0x1f, 0x0f, 0x0f, 0x0f, 0x07, 0x07, 0x07
+    ]
+};
+/**
+ * Faster version of decodeURIComponent() that does not throw.
+ *
+ * @param string - the URL string to decode.
+ *
+ * @returns the decoded string or null if invalid.
+ */
+export function uriDecode(string) {
+    let percentPos = string.indexOf('%');
+    if (percentPos === -1) {
+        return string;
+    }
+    let decoded = '';
+    let last = 0;
+    let codepoint = 0;
+    let startOfOctets = percentPos;
+    let state = UTF8.accept;
+    while (percentPos > -1 && percentPos < string.length) {
+        const high = resolveHex(string[percentPos + 1], 4);
+        const low = resolveHex(string[percentPos + 2], 0);
+        const byte = high | low;
+        const type = UTF8.data[byte];
+        state = UTF8.data[256 + state + type];
+        codepoint = (codepoint << 6) | (byte & UTF8.data[364 + type]);
+        if (state === UTF8.accept) {
+            decoded += string.slice(last, startOfOctets);
+            decoded +=
+                codepoint <= 0xffff
+                    ? String.fromCharCode(codepoint)
+                    : String.fromCharCode(0xd7c0 + (codepoint >> 10), 0xdc00 + (codepoint & 0x3ff));
+            codepoint = 0;
+            last = percentPos + 3;
+            percentPos = string.indexOf('%', last);
+            startOfOctets = percentPos;
+            continue;
+        }
+        if (state === UTF8.reject) {
+            return null;
+        }
+        percentPos += 3;
+        if (percentPos >= string.length || string[percentPos] !== '%') {
+            return null;
+        }
+    }
+    return decoded + string.slice(last);
+}
+function resolveHex(char, shift) {
+    const i = HEX[char];
+    return i === undefined ? 255 : i << shift;
+}
+// Adapted from:
+// Copyright (c) 2017-2019 Justin Ridgewell, MIT Licensed, https://github.com/jridgewell/safe-decode-string-component
+// Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>, MIT Licensed, http://bjoern.hoehrmann.de/utf-8/decoder/dfa/

package/dist/esm/lib/validation/engine/address/domain.js

@@ -0,0 +1,143 @@
+/**
+ * Derived from the upstream src/domain.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import * as Url from 'node:url';
+import { errorCode } from './errors.js';
+const MIN_DOMAIN_SEGMENTS = 2;
+const NON_ASCII_RX = /[^\x00-\x7f]/;
+const DOMAIN_CONTROL_RX = /[\x00-\x20@\:\/\\#!\$&\'\(\)\*\+,;=\?]/; // Control + space + separators
+const TLD_SEGMENT_RX = /^[a-zA-Z](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?$/;
+const DOMAIN_SEGMENT_RX = /^[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?$/;
+const DOMAIN_UNDERSCORE_SEGMENT_RX = /^[a-zA-Z0-9_](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?$/;
+const URL_IMPL = Url.URL || URL; // $lab:coverage:ignore$
+function isTldsAllow(tlds) {
+    return !!tlds.allow;
+}
+/**
+ * Analyzes a string to verify it is a valid domain name.
+ *
+ * @param domain - the domain name to validate.
+ * @param options - optional settings.
+ *
+ * @return - undefined when valid, otherwise an object with single error key with a string message value.
+ */
+export function analyzeDomain(domain, options = {}) {
+    if (!domain) {
+        // Catch null / undefined
+        return errorCode('DOMAIN_NON_EMPTY_STRING');
+    }
+    if (typeof domain !== 'string') {
+        throw new Error('Invalid input: domain must be a string');
+    }
+    if (domain.length > 256) {
+        return errorCode('DOMAIN_TOO_LONG');
+    }
+    const ascii = !NON_ASCII_RX.test(domain);
+    if (!ascii) {
+        if (options.allowUnicode === false) {
+            // Defaults to true
+            return errorCode('DOMAIN_INVALID_UNICODE_CHARS');
+        }
+        domain = domain.normalize('NFC');
+    }
+    if (DOMAIN_CONTROL_RX.test(domain)) {
+        return errorCode('DOMAIN_INVALID_CHARS');
+    }
+    domain = punycode(domain);
+    // https://tools.ietf.org/html/rfc1035 section 2.3.1
+    if (options.allowFullyQualified && domain[domain.length - 1] === '.') {
+        domain = domain.slice(0, -1);
+    }
+    const minDomainSegments = options.minDomainSegments || MIN_DOMAIN_SEGMENTS;
+    const segments = domain.split('.');
+    if (segments.length < minDomainSegments) {
+        return errorCode('DOMAIN_SEGMENTS_COUNT');
+    }
+    if (options.maxDomainSegments) {
+        if (segments.length > options.maxDomainSegments) {
+            return errorCode('DOMAIN_SEGMENTS_COUNT_MAX');
+        }
+    }
+    const tlds = options.tlds;
+    if (tlds) {
+        const tld = segments[segments.length - 1].toLowerCase();
+        if (isTldsAllow(tlds)) {
+            if (!tlds.allow.has(tld)) {
+                return errorCode('DOMAIN_FORBIDDEN_TLDS');
+            }
+        }
+        else if (tlds.deny.has(tld)) {
+            return errorCode('DOMAIN_FORBIDDEN_TLDS');
+        }
+    }
+    for (let i = 0; i < segments.length; ++i) {
+        const segment = segments[i];
+        if (!segment.length) {
+            return errorCode('DOMAIN_EMPTY_SEGMENT');
+        }
+        if (segment.length > 63) {
+            return errorCode('DOMAIN_LONG_SEGMENT');
+        }
+        if (i < segments.length - 1) {
+            if (options.allowUnderscore) {
+                if (!DOMAIN_UNDERSCORE_SEGMENT_RX.test(segment)) {
+                    return errorCode('DOMAIN_INVALID_CHARS');
+                }
+            }
+            else {
+                if (!DOMAIN_SEGMENT_RX.test(segment)) {
+                    return errorCode('DOMAIN_INVALID_CHARS');
+                }
+            }
+        }
+        else {
+            if (!TLD_SEGMENT_RX.test(segment)) {
+                return errorCode('DOMAIN_INVALID_TLDS_CHARS');
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Analyzes a string to verify it is a valid domain name.
+ *
+ * @param domain - the domain name to validate.
+ * @param options - optional settings.
+ *
+ * @return - true when valid, otherwise false.
+ */
+export function isDomainValid(domain, options) {
+    return !analyzeDomain(domain, options);
+}
+function punycode(domain) {
+    if (domain.includes('%')) {
+        domain = domain.replace(/%/g, '%25');
+    }
+    try {
+        return new URL_IMPL(`http://${domain}`).host;
+    }
+    catch (err) {
+        return domain;
+    }
+}
+export function validateDomainOptions(options) {
+    if (!options) {
+        return;
+    }
+    if (typeof options.tlds !== 'object') {
+        throw new Error('Invalid options: tlds must be a boolean or an object');
+    }
+    if (isTldsAllow(options.tlds)) {
+        if (options.tlds.allow instanceof Set === false) {
+            throw new Error('Invalid options: tlds.allow must be a Set object or true');
+        }
+        if (options.tlds.deny) {
+            throw new Error('Invalid options: cannot specify both tlds.allow and tlds.deny lists');
+        }
+    }
+    else {
+        if (options.tlds.deny instanceof Set === false) {
+            throw new Error('Invalid options: tlds.deny must be a Set object');
+        }
+    }
+}