@lakutata/core 1.0.59 → 3.0.0-beta.0

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

@@ -0,0 +1,182 @@
+"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.analyzeEmail = analyzeEmail;
+exports.isEmailValid = isEmailValid;
+/**
+ * Derived from the upstream src/email.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const Util = __importStar(require("node:util"));
+const domain_js_1 = require("./domain.js");
+const errors_js_1 = require("./errors.js");
+const NON_ASCII_RX = /[^\x00-\x7f]/;
+const ENCODER_IMPL = new (Util.TextEncoder || TextEncoder)(); // $lab:coverage:ignore$
+/**
+ * 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.
+ */
+function analyzeEmail(email, options) {
+    return validateEmail(email, options);
+}
+/**
+ * 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.
+ */
+function isEmailValid(email, options) {
+    return !validateEmail(email, options);
+}
+function validateEmail(email, options = {}) {
+    if (typeof email !== 'string') {
+        throw new Error('Invalid input: email must be a string');
+    }
+    if (!email) {
+        return (0, errors_js_1.errorCode)('EMPTY_STRING');
+    }
+    // Unicode
+    const ascii = !NON_ASCII_RX.test(email);
+    if (!ascii) {
+        if (options.allowUnicode === false) {
+            // Defaults to true
+            return (0, errors_js_1.errorCode)('FORBIDDEN_UNICODE');
+        }
+        email = email.normalize('NFC');
+    }
+    // Basic structure
+    const parts = email.split('@');
+    if (parts.length !== 2) {
+        return parts.length > 2 ? (0, errors_js_1.errorCode)('MULTIPLE_AT_CHAR') : (0, errors_js_1.errorCode)('MISSING_AT_CHAR');
+    }
+    const [local, domain] = parts;
+    if (!local) {
+        return (0, errors_js_1.errorCode)('EMPTY_LOCAL');
+    }
+    if (!options.ignoreLength) {
+        if (email.length > 254) {
+            // http://tools.ietf.org/html/rfc5321#section-4.5.3.1.3
+            return (0, errors_js_1.errorCode)('ADDRESS_TOO_LONG');
+        }
+        if (ENCODER_IMPL.encode(local).length > 64) {
+            // http://tools.ietf.org/html/rfc5321#section-4.5.3.1.1
+            return (0, errors_js_1.errorCode)('LOCAL_TOO_LONG');
+        }
+    }
+    // Validate parts
+    return validateLocal(local, ascii) || (0, domain_js_1.analyzeDomain)(domain, options);
+}
+function validateLocal(local, ascii) {
+    const segments = local.split('.');
+    for (const segment of segments) {
+        if (!segment.length) {
+            return (0, errors_js_1.errorCode)('EMPTY_LOCAL_SEGMENT');
+        }
+        if (ascii) {
+            if (!ATEXT_RX.test(segment)) {
+                return (0, errors_js_1.errorCode)('INVALID_LOCAL_CHARS');
+            }
+            continue;
+        }
+        for (const char of segment) {
+            if (ATEXT_RX.test(char)) {
+                continue;
+            }
+            const binary = toBinary(char);
+            if (!ATOM_RX.test(binary)) {
+                return (0, errors_js_1.errorCode)('INVALID_LOCAL_CHARS');
+            }
+        }
+    }
+    return null;
+}
+function toBinary(char) {
+    return Array.from(ENCODER_IMPL.encode(char), (v) => String.fromCharCode(v)).join('');
+}
+/*
+    From RFC 5321:
+
+        Mailbox         =   Local-part "@" ( Domain / address-literal )
+
+        Local-part      =   Dot-string / Quoted-string
+        Dot-string      =   Atom *("."  Atom)
+        Atom            =   1*atext
+        atext           =   ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~"
+
+        Domain          =   sub-domain *("." sub-domain)
+        sub-domain      =   Let-dig [Ldh-str]
+        Let-dig         =   ALPHA / DIGIT
+        Ldh-str         =   *( ALPHA / DIGIT / "-" ) Let-dig
+
+        ALPHA           =   %x41-5A / %x61-7A        ; a-z, A-Z
+        DIGIT           =   %x30-39                  ; 0-9
+
+    From RFC 6531:
+
+        sub-domain      =/  U-label
+        atext           =/  UTF8-non-ascii
+
+        UTF8-non-ascii  =   UTF8-2 / UTF8-3 / UTF8-4
+
+        UTF8-2          =   %xC2-DF UTF8-tail
+        UTF8-3          =   %xE0 %xA0-BF UTF8-tail /
+                            %xE1-EC 2( UTF8-tail ) /
+                            %xED %x80-9F UTF8-tail /
+                            %xEE-EF 2( UTF8-tail )
+        UTF8-4          =   %xF0 %x90-BF 2( UTF8-tail ) /
+                            %xF1-F3 3( UTF8-tail ) /
+                            %xF4 %x80-8F 2( UTF8-tail )
+
+        UTF8-tail       =   %x80-BF
+
+    Note: The following are not supported:
+
+        RFC 5321: address-literal, Quoted-string
+        RFC 5322: obs-*, CFWS
+*/
+const ATEXT_RX = /^[\w!#\$%&'\*\+\-/=\?\^`\{\|\}~]+$/; // _ included in \w
+const ATOM_RX = new RegExp([
+    //  %xC2-DF UTF8-tail
+    '(?:[\\xc2-\\xdf][\\x80-\\xbf])',
+    //  %xE0 %xA0-BF UTF8-tail              %xE1-EC 2( UTF8-tail )            %xED %x80-9F UTF8-tail              %xEE-EF 2( UTF8-tail )
+    '(?:\\xe0[\\xa0-\\xbf][\\x80-\\xbf])|(?:[\\xe1-\\xec][\\x80-\\xbf]{2})|(?:\\xed[\\x80-\\x9f][\\x80-\\xbf])|(?:[\\xee-\\xef][\\x80-\\xbf]{2})',
+    //  %xF0 %x90-BF 2( UTF8-tail )            %xF1-F3 3( UTF8-tail )            %xF4 %x80-8F 2( UTF8-tail )
+    '(?:\\xf0[\\x90-\\xbf][\\x80-\\xbf]{2})|(?:[\\xf1-\\xf3][\\x80-\\xbf]{3})|(?:\\xf4[\\x80-\\x8f][\\x80-\\xbf]{2})'
+].join('|'));

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

@@ -0,0 +1,48 @@
+/**
+ * Derived from the upstream src/errors.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+export declare const errorCodes: {
+    EMPTY_STRING: string;
+    FORBIDDEN_UNICODE: string;
+    MULTIPLE_AT_CHAR: string;
+    MISSING_AT_CHAR: string;
+    EMPTY_LOCAL: string;
+    ADDRESS_TOO_LONG: string;
+    LOCAL_TOO_LONG: string;
+    EMPTY_LOCAL_SEGMENT: string;
+    INVALID_LOCAL_CHARS: string;
+    DOMAIN_NON_EMPTY_STRING: string;
+    DOMAIN_TOO_LONG: string;
+    DOMAIN_INVALID_UNICODE_CHARS: string;
+    DOMAIN_INVALID_CHARS: string;
+    DOMAIN_INVALID_TLDS_CHARS: string;
+    DOMAIN_SEGMENTS_COUNT: string;
+    DOMAIN_SEGMENTS_COUNT_MAX: string;
+    DOMAIN_FORBIDDEN_TLDS: string;
+    DOMAIN_EMPTY_SEGMENT: string;
+    DOMAIN_LONG_SEGMENT: string;
+};
+export declare function errorCode<TCode extends keyof typeof errorCodes>(code: TCode): {
+    code: TCode;
+    error: {
+        EMPTY_STRING: string;
+        FORBIDDEN_UNICODE: string;
+        MULTIPLE_AT_CHAR: string;
+        MISSING_AT_CHAR: string;
+        EMPTY_LOCAL: string;
+        ADDRESS_TOO_LONG: string;
+        LOCAL_TOO_LONG: string;
+        EMPTY_LOCAL_SEGMENT: string;
+        INVALID_LOCAL_CHARS: string;
+        DOMAIN_NON_EMPTY_STRING: string;
+        DOMAIN_TOO_LONG: string;
+        DOMAIN_INVALID_UNICODE_CHARS: string;
+        DOMAIN_INVALID_CHARS: string;
+        DOMAIN_INVALID_TLDS_CHARS: string;
+        DOMAIN_SEGMENTS_COUNT: string;
+        DOMAIN_SEGMENTS_COUNT_MAX: string;
+        DOMAIN_FORBIDDEN_TLDS: string;
+        DOMAIN_EMPTY_SEGMENT: string;
+        DOMAIN_LONG_SEGMENT: string;
+    }[TCode];
+};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorCodes = void 0;
+exports.errorCode = errorCode;
+/**
+ * Derived from the upstream src/errors.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+exports.errorCodes = {
+    EMPTY_STRING: 'Address must be a non-empty string',
+    FORBIDDEN_UNICODE: 'Address contains forbidden Unicode characters',
+    MULTIPLE_AT_CHAR: 'Address cannot contain more than one @ character',
+    MISSING_AT_CHAR: 'Address must contain one @ character',
+    EMPTY_LOCAL: 'Address local part cannot be empty',
+    ADDRESS_TOO_LONG: 'Address too long',
+    LOCAL_TOO_LONG: 'Address local part too long',
+    EMPTY_LOCAL_SEGMENT: 'Address local part contains empty dot-separated segment',
+    INVALID_LOCAL_CHARS: 'Address local part contains invalid character',
+    DOMAIN_NON_EMPTY_STRING: 'Domain must be a non-empty string',
+    DOMAIN_TOO_LONG: 'Domain too long',
+    DOMAIN_INVALID_UNICODE_CHARS: 'Domain contains forbidden Unicode characters',
+    DOMAIN_INVALID_CHARS: 'Domain contains invalid character',
+    DOMAIN_INVALID_TLDS_CHARS: 'Domain contains invalid tld character',
+    DOMAIN_SEGMENTS_COUNT: 'Domain lacks the minimum required number of segments',
+    DOMAIN_SEGMENTS_COUNT_MAX: 'Domain contains too many segments',
+    DOMAIN_FORBIDDEN_TLDS: 'Domain uses forbidden TLD',
+    DOMAIN_EMPTY_SEGMENT: 'Domain contains empty dot-separated segment',
+    DOMAIN_LONG_SEGMENT: 'Domain contains dot-separated segment that is too long'
+};
+function errorCode(code) {
+    return { code, error: exports.errorCodes[code] };
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Derived from the upstream src/index.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+export * from './domain.js';
+export * from './email.js';
+export { errorCodes } from './errors.js';
+export { ipRegex } from './ip.js';
+export { uriRegex } from './uri.js';
+export { uriDecode } from './decode.js';

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

@@ -0,0 +1,30 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uriDecode = exports.uriRegex = exports.ipRegex = exports.errorCodes = void 0;
+/**
+ * Derived from the upstream src/index.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+__exportStar(require("./domain.js"), exports);
+__exportStar(require("./email.js"), exports);
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "errorCodes", { enumerable: true, get: function () { return errors_js_1.errorCodes; } });
+var ip_js_1 = require("./ip.js");
+Object.defineProperty(exports, "ipRegex", { enumerable: true, get: function () { return ip_js_1.ipRegex; } });
+var uri_js_1 = require("./uri.js");
+Object.defineProperty(exports, "uriRegex", { enumerable: true, get: function () { return uri_js_1.uriRegex; } });
+var decode_js_1 = require("./decode.js");
+Object.defineProperty(exports, "uriDecode", { enumerable: true, get: function () { return decode_js_1.uriDecode; } });

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

@@ -0,0 +1,35 @@
+interface Options {
+    /**
+     * The required CIDR mode.
+     *
+     * @default 'optional'
+     */
+    readonly cidr?: Cidr;
+    /**
+     * The allowed versions.
+     *
+     * @default ['ipv4', 'ipv6', 'ipvfuture']
+     */
+    readonly version?: Version | Version[];
+}
+type Cidr = 'optional' | 'required' | 'forbidden';
+type Version = 'ipv4' | 'ipv6' | 'ipvfuture';
+interface Expression {
+    /** The CIDR mode. */
+    cidr: Cidr;
+    /** The raw regular expression string. */
+    raw: string;
+    /** The regular expression. */
+    regex: RegExp;
+    /** The array of versions allowed. */
+    versions: Version[];
+}
+/**
+ * Generates a regular expression used to validate IP addresses.
+ *
+ * @param options - optional settings.
+ *
+ * @returns an object with the regular expression and meta data.
+ */
+export declare function ipRegex(options?: Options): Expression;
+export {};

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipRegex = ipRegex;
+/**
+ * Derived from the upstream src/ip.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const index_js_1 = require("../utils/index.js");
+const uri_js_1 = require("./uri.js");
+/**
+ * Generates a regular expression used to validate IP addresses.
+ *
+ * @param options - optional settings.
+ *
+ * @returns an object with the regular expression and meta data.
+ */
+function ipRegex(options = {}) {
+    // CIDR
+    const cidr = options.cidr || 'optional';
+    (0, index_js_1.assert)(['required', 'optional', 'forbidden'].includes(cidr), 'options.cidr must be one of required, optional, forbidden');
+    // Versions
+    (0, index_js_1.assert)(options.version === undefined || typeof options.version === 'string' || Array.isArray(options.version), 'options.version must be a string or an array of string');
+    let versions = options.version || ['ipv4', 'ipv6', 'ipvfuture'];
+    if (!Array.isArray(versions)) {
+        versions = [versions];
+    }
+    (0, index_js_1.assert)(versions.length >= 1, 'options.version must have at least 1 version specified');
+    for (const version of versions) {
+        (0, index_js_1.assert)(typeof version === 'string' && version === version.toLowerCase(), 'Invalid options.version value');
+        (0, index_js_1.assert)(['ipv4', 'ipv6', 'ipvfuture'].includes(version), 'options.version contains unknown version ' + version + ' - must be one of ipv4, ipv6, ipvfuture');
+    }
+    versions = Array.from(new Set(versions));
+    // Regex
+    const parts = versions.map((version) => {
+        // Forbidden
+        if (cidr === 'forbidden') {
+            return uri_js_1.ipVersions[version];
+        }
+        // Required
+        const cidrpart = `\\/${version === 'ipv4' ? uri_js_1.ipVersions.v4Cidr : uri_js_1.ipVersions.v6Cidr}`;
+        if (cidr === 'required') {
+            return `${uri_js_1.ipVersions[version]}${cidrpart}`;
+        }
+        // Optional
+        return `${uri_js_1.ipVersions[version]}(?:${cidrpart})?`;
+    });
+    const raw = `(?:${parts.join('|')})`;
+    const regex = new RegExp(`^${raw}$`);
+    return { cidr, versions, regex, raw };
+}

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

@@ -0,0 +1,55 @@
+export declare const ipVersions: {
+    v4Cidr: string;
+    v6Cidr: string;
+    ipv4: string;
+    ipv6: string;
+    ipvfuture: string;
+};
+interface Expression {
+    /** The raw regular expression string. */
+    raw: string;
+    /** The regular expression. */
+    regex: RegExp;
+    /** The specified URI scheme */
+    scheme: string | null;
+}
+/**
+ * Generates a regular expression used to validate URI addresses.
+ *
+ * @param options - optional settings.
+ *
+ * @returns an object with the regular expression and meta data.
+ */
+export declare function uriRegex(options?: Options): Expression;
+type Scheme = string | RegExp;
+interface Options {
+    /**
+     * Allow the use of [] in query parameters.
+     *
+     * @default false
+     */
+    readonly allowQuerySquareBrackets?: boolean;
+    /**
+     * Allow relative URIs.
+     *
+     * @default false
+     */
+    readonly allowRelative?: boolean;
+    /**
+     * Requires the URI to be relative.
+     *
+     * @default false
+     */
+    readonly relativeOnly?: boolean;
+    /**
+     * Capture domain segment ($1).
+     *
+     * @default false
+     */
+    readonly domain?: boolean;
+    /**
+     * The allowed URI schemes.
+     */
+    readonly scheme?: Scheme | Scheme[];
+}
+export {};

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

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipVersions = void 0;
+exports.uriRegex = uriRegex;
+/**
+ * Derived from the upstream src/uri.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const index_js_1 = require("../utils/index.js");
+function generate() {
+    const rfc3986 = {};
+    const hexDigit = '\\dA-Fa-f'; // HEXDIG = DIGIT / "A" / "B" / "C" / "D" / "E" / "F"
+    const hexDigitOnly = '[' + hexDigit + ']';
+    const unreserved = '\\w-\\.~'; // unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+    const subDelims = "!\\$&'\\(\\)\\*\\+,;="; // sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+    const pctEncoded = '%' + hexDigit; // pct-encoded = "%" HEXDIG HEXDIG
+    const pchar = unreserved + pctEncoded + subDelims + ':@'; // pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
+    const pcharOnly = '[' + pchar + ']';
+    const decOctect = '(?:0{0,2}\\d|0?[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])'; // dec-octet = DIGIT / %x31-39 DIGIT / "1" 2DIGIT / "2" %x30-34 DIGIT / "25" %x30-35  ; 0-9 / 10-99 / 100-199 / 200-249 / 250-255
+    rfc3986.ipv4address = '(?:' + decOctect + '\\.){3}' + decOctect; // IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+    /*
+        h16 = 1*4HEXDIG ; 16 bits of address represented in hexadecimal
+        ls32 = ( h16 ":" h16 ) / IPv4address ; least-significant 32 bits of address
+        IPv6address =                            6( h16 ":" ) ls32
+                    /                       "::" 5( h16 ":" ) ls32
+                    / [               h16 ] "::" 4( h16 ":" ) ls32
+                    / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+                    / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+                    / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
+                    / [ *4( h16 ":" ) h16 ] "::"              ls32
+                    / [ *5( h16 ":" ) h16 ] "::"              h16
+                    / [ *6( h16 ":" ) h16 ] "::"
+    */
+    const h16 = hexDigitOnly + '{1,4}';
+    const ls32 = '(?:' + h16 + ':' + h16 + '|' + rfc3986.ipv4address + ')';
+    const IPv6SixHex = '(?:' + h16 + ':){6}' + ls32;
+    const IPv6FiveHex = '::(?:' + h16 + ':){5}' + ls32;
+    const IPv6FourHex = '(?:' + h16 + ')?::(?:' + h16 + ':){4}' + ls32;
+    const IPv6ThreeHex = '(?:(?:' + h16 + ':){0,1}' + h16 + ')?::(?:' + h16 + ':){3}' + ls32;
+    const IPv6TwoHex = '(?:(?:' + h16 + ':){0,2}' + h16 + ')?::(?:' + h16 + ':){2}' + ls32;
+    const IPv6OneHex = '(?:(?:' + h16 + ':){0,3}' + h16 + ')?::' + h16 + ':' + ls32;
+    const IPv6NoneHex = '(?:(?:' + h16 + ':){0,4}' + h16 + ')?::' + ls32;
+    const IPv6NoneHex2 = '(?:(?:' + h16 + ':){0,5}' + h16 + ')?::' + h16;
+    const IPv6NoneHex3 = '(?:(?:' + h16 + ':){0,6}' + h16 + ')?::';
+    rfc3986.ipv4Cidr = '(?:\\d|[1-2]\\d|3[0-2])'; // IPv4 cidr = DIGIT / %x31-32 DIGIT / "3" %x30-32  ; 0-9 / 10-29 / 30-32
+    rfc3986.ipv6Cidr = '(?:0{0,2}\\d|0?[1-9]\\d|1[01]\\d|12[0-8])'; // IPv6 cidr = DIGIT / %x31-39 DIGIT / "1" %x0-1 DIGIT / "12" %x0-8;   0-9 / 10-99 / 100-119 / 120-128
+    rfc3986.ipv6address =
+        '(?:' +
+            IPv6SixHex +
+            '|' +
+            IPv6FiveHex +
+            '|' +
+            IPv6FourHex +
+            '|' +
+            IPv6ThreeHex +
+            '|' +
+            IPv6TwoHex +
+            '|' +
+            IPv6OneHex +
+            '|' +
+            IPv6NoneHex +
+            '|' +
+            IPv6NoneHex2 +
+            '|' +
+            IPv6NoneHex3 +
+            ')';
+    rfc3986.ipvFuture = 'v' + hexDigitOnly + '+\\.[' + unreserved + subDelims + ':]+'; // IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
+    rfc3986.scheme = '[a-zA-Z][a-zA-Z\\d+-\\.]*'; // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+    rfc3986.schemeRegex = new RegExp(rfc3986.scheme);
+    const userinfo = '[' + unreserved + pctEncoded + subDelims + ':]*'; // userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
+    const IPLiteral = '\\[(?:' + rfc3986.ipv6address + '|' + rfc3986.ipvFuture + ')\\]'; // IP-literal = "[" ( IPv6address / IPvFuture  ) "]"
+    const regName = '[' + unreserved + pctEncoded + subDelims + ']{1,255}'; // reg-name = *( unreserved / pct-encoded / sub-delims )
+    const host = '(?:' + IPLiteral + '|' + rfc3986.ipv4address + '|' + regName + ')'; // host = IP-literal / IPv4address / reg-name
+    const port = '\\d*'; // port = *DIGIT
+    const authority = '(?:' + userinfo + '@)?' + host + '(?::' + port + ')?'; // authority   = [ userinfo "@" ] host [ ":" port ]
+    const authorityCapture = '(?:' + userinfo + '@)?(' + host + ')(?::' + port + ')?';
+    /*
+        segment       = *pchar
+        segment-nz    = 1*pchar
+        path          = path-abempty    ; begins with "/" '|' is empty
+                    / path-absolute   ; begins with "/" but not "//"
+                    / path-noscheme   ; begins with a non-colon segment
+                    / path-rootless   ; begins with a segment
+                    / path-empty      ; zero characters
+        path-abempty  = *( "/" segment )
+        path-absolute = "/" [ segment-nz *( "/" segment ) ]
+        path-rootless = segment-nz *( "/" segment )
+    */
+    const segment = pcharOnly + '*';
+    const segmentNz = pcharOnly + '+';
+    const segmentNzNc = '[' + unreserved + pctEncoded + subDelims + '@' + ']+';
+    const pathEmpty = '';
+    const pathAbEmpty = '(?:\\/' + segment + ')*';
+    const pathAbsolute = '\\/(?:' + segmentNz + pathAbEmpty + ')?';
+    const pathRootless = segmentNz + pathAbEmpty;
+    const pathNoScheme = segmentNzNc + pathAbEmpty;
+    const pathAbNoAuthority = '(?:\\/\\/\\/' + segment + pathAbEmpty + ')'; // Used by file:///
+    // hier-part = "//" authority path
+    rfc3986.hierPart =
+        '(?:' +
+            '(?:\\/\\/' +
+            authority +
+            pathAbEmpty +
+            ')' +
+            '|' +
+            pathAbsolute +
+            '|' +
+            pathRootless +
+            '|' +
+            pathAbNoAuthority +
+            ')';
+    rfc3986.hierPartCapture =
+        '(?:' + '(?:\\/\\/' + authorityCapture + pathAbEmpty + ')' + '|' + pathAbsolute + '|' + pathRootless + ')';
+    // relative-part = "//" authority path-abempty / path-absolute / path-noscheme / path-empty
+    rfc3986.relativeRef =
+        '(?:' +
+            '(?:\\/\\/' +
+            authority +
+            pathAbEmpty +
+            ')' +
+            '|' +
+            pathAbsolute +
+            '|' +
+            pathNoScheme +
+            '|' +
+            pathEmpty +
+            ')';
+    rfc3986.relativeRefCapture =
+        '(?:' +
+            '(?:\\/\\/' +
+            authorityCapture +
+            pathAbEmpty +
+            ')' +
+            '|' +
+            pathAbsolute +
+            '|' +
+            pathNoScheme +
+            '|' +
+            pathEmpty +
+            ')';
+    // query = *( pchar / "/" / "?" )
+    // query = *( pchar / "[" / "]" / "/" / "?" )
+    rfc3986.query = '[' + pchar + '\\/\\?]*(?=#|$)'; //Finish matching either at the fragment part '|' end of the line.
+    rfc3986.queryWithSquareBrackets = '[' + pchar + '\\[\\]\\/\\?]*(?=#|$)';
+    // fragment = *( pchar / "/" / "?" )
+    rfc3986.fragment = '[' + pchar + '\\/\\?]*';
+    return rfc3986;
+}
+const rfc3986 = generate();
+exports.ipVersions = {
+    v4Cidr: rfc3986.ipv4Cidr,
+    v6Cidr: rfc3986.ipv6Cidr,
+    ipv4: rfc3986.ipv4address,
+    ipv6: rfc3986.ipv6address,
+    ipvfuture: rfc3986.ipvFuture
+};
+function createRegex(options) {
+    const rfc = rfc3986;
+    // Construct expression
+    const query = options.allowQuerySquareBrackets ? rfc.queryWithSquareBrackets : rfc.query;
+    const suffix = '(?:\\?' + query + ')?' + '(?:#' + rfc.fragment + ')?';
+    // relative-ref = relative-part [ "?" query ] [ "#" fragment ]
+    const relative = options.domain ? rfc.relativeRefCapture : rfc.relativeRef;
+    if (options.relativeOnly) {
+        return wrap(relative + suffix);
+    }
+    // Custom schemes
+    let customScheme = '';
+    if (options.scheme) {
+        (0, index_js_1.assert)(options.scheme instanceof RegExp || typeof options.scheme === 'string' || Array.isArray(options.scheme), 'scheme must be a RegExp, String, or Array');
+        const schemes = [].concat(options.scheme);
+        (0, index_js_1.assert)(schemes.length >= 1, 'scheme must have at least 1 scheme specified');
+        // Flatten the array into a string to be used to match the schemes
+        const selections = [];
+        for (let i = 0; i < schemes.length; ++i) {
+            const scheme = schemes[i];
+            (0, index_js_1.assert)(scheme instanceof RegExp || typeof scheme === 'string', 'scheme at position ' + i + ' must be a RegExp or String');
+            if (scheme instanceof RegExp) {
+                selections.push(scheme.source.toString());
+            }
+            else {
+                (0, index_js_1.assert)(rfc.schemeRegex.test(scheme), 'scheme at position ' + i + ' must be a valid scheme');
+                selections.push((0, index_js_1.escapeRegex)(scheme));
+            }
+        }
+        customScheme = selections.join('|');
+    }
+    // URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+    const scheme = customScheme ? '(?:' + customScheme + ')' : rfc.scheme;
+    const absolute = '(?:' + scheme + ':' + (options.domain ? rfc.hierPartCapture : rfc.hierPart) + ')';
+    const prefix = options.allowRelative ? '(?:' + absolute + '|' + relative + ')' : absolute;
+    return wrap(prefix + suffix, customScheme);
+}
+function wrap(raw, scheme = null) {
+    raw = `(?=.)(?!https?\:/(?:$|[^/]))(?!https?\:///)(?!https?\:[^/])${raw}`; // Require at least one character and explicitly forbid 'http:/' or HTTP with empty domain
+    return {
+        raw,
+        regex: new RegExp(`^${raw}$`),
+        scheme
+    };
+}
+const genericUriRegex = createRegex({});
+/**
+ * Generates a regular expression used to validate URI addresses.
+ *
+ * @param options - optional settings.
+ *
+ * @returns an object with the regular expression and meta data.
+ */
+function uriRegex(options = {}) {
+    if (options.scheme ||
+        options.allowRelative ||
+        options.relativeOnly ||
+        options.allowQuerySquareBrackets ||
+        options.domain) {
+        return createRegex(options);
+    }
+    return genericUriRegex;
+}