@lakutata/core 1.0.60 → 3.0.0-beta.0

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

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILT_IN_VALIDATION_LANGUAGES = void 0;
+exports.registerValidationMessages = registerValidationMessages;
+exports.validationLanguages = validationLanguages;
+exports.builtInValidationLanguage = builtInValidationLanguage;
+exports.loadValidationMessages = loadValidationMessages;
+exports.defaultValidationMessages = defaultValidationMessages;
+const As_1 = require("@lakutata/utils/As");
+const common_js_1 = require("./engine/schema/common.js");
+const messages_js_1 = require("./engine/schema/messages.js");
+const VLD_js_1 = require("./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()}))
+ * })
+ * ```
+ */
+function registerValidationMessages(language, messages) {
+    const compiled = (0, As_1.As)((0, messages_js_1.compile)({ [language]: messages }));
+    //In place: the settings of the validations reuse the messages of the defaults
+    const registered = (0, As_1.As)(common_js_1.defaults.messages);
+    registered[language] = { ...registered[language], ...(0, As_1.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']
+ * ```
+ */
+function validationLanguages() {
+    return Object.keys((0, As_1.As)(common_js_1.defaults.messages));
+}
+/**
+ * The language tags with built-in validation error messages, which `loadValidationMessages()` loads (`en`: the
+ * default messages).
+ */
+exports.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': () => Promise.resolve().then(() => __importStar(require('./messages/zh-CN.js'))),
+    'zh-TW': () => Promise.resolve().then(() => __importStar(require('./messages/zh-TW.js'))),
+    'ja': () => Promise.resolve().then(() => __importStar(require('./messages/ja.js'))),
+    'ko': () => Promise.resolve().then(() => __importStar(require('./messages/ko.js'))),
+    'fr': () => Promise.resolve().then(() => __importStar(require('./messages/fr.js'))),
+    'de': () => Promise.resolve().then(() => __importStar(require('./messages/de.js'))),
+    'es': () => Promise.resolve().then(() => __importStar(require('./messages/es.js'))),
+    'pt-BR': () => Promise.resolve().then(() => __importStar(require('./messages/pt-BR.js'))),
+    'it': () => Promise.resolve().then(() => __importStar(require('./messages/it.js'))),
+    'nl': () => Promise.resolve().then(() => __importStar(require('./messages/nl.js'))),
+    'pl': () => Promise.resolve().then(() => __importStar(require('./messages/pl.js'))),
+    'ru': () => Promise.resolve().then(() => __importStar(require('./messages/ru.js'))),
+    'uk': () => Promise.resolve().then(() => __importStar(require('./messages/uk.js'))),
+    'tr': () => Promise.resolve().then(() => __importStar(require('./messages/tr.js'))),
+    'vi': () => Promise.resolve().then(() => __importStar(require('./messages/vi.js'))),
+    'th': () => Promise.resolve().then(() => __importStar(require('./messages/th.js'))),
+    'id': () => Promise.resolve().then(() => __importStar(require('./messages/id.js'))),
+    'hi': () => Promise.resolve().then(() => __importStar(require('./messages/hi.js'))),
+    'ar': () => Promise.resolve().then(() => __importStar(require('./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
+ * ```
+ */
+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)
+ * }
+ * ```
+ */
+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
+ * ```
+ */
+function defaultValidationMessages() {
+    const messages = {};
+    //The types of the validation, its extensions (bigint) too
+    const types = (0, As_1.As)(VLD_js_1.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/cjs/lib/validation/engine/address/decode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Faster version of decodeURIComponent() that does not throw.
+ *
+ * @param string - the URL string to decode.
+ *
+ * @returns the decoded string or null if invalid.
+ */
+export declare function uriDecode(string: string): string | null;

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uriDecode = uriDecode;
+/**
+ * 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.
+ */
+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/cjs/lib/validation/engine/address/domain.d.ts

@@ -0,0 +1,74 @@
+interface TldsAllow {
+    readonly allow: Set<string>;
+}
+interface TldsDeny {
+    readonly deny: Set<string>;
+}
+export interface DomainOptions {
+    /**
+     * Determines whether Unicode characters are allowed.
+     *
+     * @default true
+     */
+    readonly allowUnicode?: boolean;
+    /**
+     * Determines whether underscore (_) characters are allowed.
+     *
+     * @default false
+     */
+    readonly allowUnderscore?: boolean;
+    /**
+     * The maximum number of domain segments (e.g. `x.y.z` has 3 segments) allowed.
+     *
+     * @default Infinity
+     */
+    readonly maxDomainSegments?: number;
+    /**
+     * The minimum number of domain segments (e.g. `x.y.z` has 3 segments) required.
+     *
+     * @default 2
+     */
+    readonly minDomainSegments?: number;
+    /**
+     * Top-level-domain options
+     *
+     * @default true
+     */
+    readonly tlds?: TldsAllow | TldsDeny;
+    /**
+     * Allows passing fully qualified domain (ends with a period)
+     *
+     * @default false
+     */
+    readonly allowFullyQualified?: boolean;
+}
+export interface Analysis {
+    /**
+     * The reason validation failed.
+     */
+    error: string;
+    /**
+     * The error code.
+     */
+    code: string;
+}
+/**
+ * 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 declare function analyzeDomain(domain: string, options?: DomainOptions): Analysis | 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 declare function isDomainValid(domain: string, options?: DomainOptions): boolean;
+export declare function validateDomainOptions(options: DomainOptions): void;
+export {};

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

@@ -0,0 +1,181 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDomain = analyzeDomain;
+exports.isDomainValid = isDomainValid;
+exports.validateDomainOptions = validateDomainOptions;
+/**
+ * Derived from the upstream src/domain.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const Url = __importStar(require("node:url"));
+const errors_js_1 = require("./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.
+ */
+function analyzeDomain(domain, options = {}) {
+    if (!domain) {
+        // Catch null / undefined
+        return (0, errors_js_1.errorCode)('DOMAIN_NON_EMPTY_STRING');
+    }
+    if (typeof domain !== 'string') {
+        throw new Error('Invalid input: domain must be a string');
+    }
+    if (domain.length > 256) {
+        return (0, errors_js_1.errorCode)('DOMAIN_TOO_LONG');
+    }
+    const ascii = !NON_ASCII_RX.test(domain);
+    if (!ascii) {
+        if (options.allowUnicode === false) {
+            // Defaults to true
+            return (0, errors_js_1.errorCode)('DOMAIN_INVALID_UNICODE_CHARS');
+        }
+        domain = domain.normalize('NFC');
+    }
+    if (DOMAIN_CONTROL_RX.test(domain)) {
+        return (0, errors_js_1.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 (0, errors_js_1.errorCode)('DOMAIN_SEGMENTS_COUNT');
+    }
+    if (options.maxDomainSegments) {
+        if (segments.length > options.maxDomainSegments) {
+            return (0, errors_js_1.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 (0, errors_js_1.errorCode)('DOMAIN_FORBIDDEN_TLDS');
+            }
+        }
+        else if (tlds.deny.has(tld)) {
+            return (0, errors_js_1.errorCode)('DOMAIN_FORBIDDEN_TLDS');
+        }
+    }
+    for (let i = 0; i < segments.length; ++i) {
+        const segment = segments[i];
+        if (!segment.length) {
+            return (0, errors_js_1.errorCode)('DOMAIN_EMPTY_SEGMENT');
+        }
+        if (segment.length > 63) {
+            return (0, errors_js_1.errorCode)('DOMAIN_LONG_SEGMENT');
+        }
+        if (i < segments.length - 1) {
+            if (options.allowUnderscore) {
+                if (!DOMAIN_UNDERSCORE_SEGMENT_RX.test(segment)) {
+                    return (0, errors_js_1.errorCode)('DOMAIN_INVALID_CHARS');
+                }
+            }
+            else {
+                if (!DOMAIN_SEGMENT_RX.test(segment)) {
+                    return (0, errors_js_1.errorCode)('DOMAIN_INVALID_CHARS');
+                }
+            }
+        }
+        else {
+            if (!TLD_SEGMENT_RX.test(segment)) {
+                return (0, errors_js_1.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.
+ */
+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;
+    }
+}
+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');
+        }
+    }
+}

package/dist/cjs/lib/validation/engine/address/email.d.ts

@@ -0,0 +1,27 @@
+import { Analysis, DomainOptions } from './domain.js';
+export interface EmailOptions extends DomainOptions {
+    /**
+     * Determines whether to ignore the standards maximum email length limit.
+     *
+     * @default false
+     */
+    readonly ignoreLength?: boolean;
+}
+/**
+ * Analyzes a string to verify it is a valid email address.
+ *
+ * @param email - the email address to validate.
+ * @param options - optional settings.
+ *
+ * @return - undefined when valid, otherwise an object with single error key with a string message value.
+ */
+export declare function analyzeEmail(email: string, options?: EmailOptions): Analysis | null;
+/**
+ * Analyzes a string to verify it is a valid email address.
+ *
+ * @param email - the email address to validate.
+ * @param options - optional settings.
+ *
+ * @return - true when valid, otherwise false.
+ */
+export declare function isEmailValid(email: string, options?: EmailOptions): boolean;