uploaded

node_modules/@hapi/address/dist/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;

node_modules/@hapi/address/dist/decode.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uriDecode = void 0;
+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);
+}
+exports.uriDecode = uriDecode;
+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/
+//# sourceMappingURL=decode.js.map

node_modules/@hapi/address/dist/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 {};

node_modules/@hapi/address/dist/domain.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDomainOptions = exports.isDomainValid = exports.analyzeDomain = void 0;
+const Url = require("url");
+const errors_1 = require("./errors");
+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_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_1.errorCode)('DOMAIN_TOO_LONG');
+    }
+    const ascii = !NON_ASCII_RX.test(domain);
+    if (!ascii) {
+        if (options.allowUnicode === false) {
+            // Defaults to true
+            return (0, errors_1.errorCode)('DOMAIN_INVALID_UNICODE_CHARS');
+        }
+        domain = domain.normalize('NFC');
+    }
+    if (DOMAIN_CONTROL_RX.test(domain)) {
+        return (0, errors_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_1.errorCode)('DOMAIN_SEGMENTS_COUNT');
+    }
+    if (options.maxDomainSegments) {
+        if (segments.length > options.maxDomainSegments) {
+            return (0, errors_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_1.errorCode)('DOMAIN_FORBIDDEN_TLDS');
+            }
+        }
+        else if (tlds.deny.has(tld)) {
+            return (0, errors_1.errorCode)('DOMAIN_FORBIDDEN_TLDS');
+        }
+    }
+    for (let i = 0; i < segments.length; ++i) {
+        const segment = segments[i];
+        if (!segment.length) {
+            return (0, errors_1.errorCode)('DOMAIN_EMPTY_SEGMENT');
+        }
+        if (segment.length > 63) {
+            return (0, errors_1.errorCode)('DOMAIN_LONG_SEGMENT');
+        }
+        if (i < segments.length - 1) {
+            if (options.allowUnderscore) {
+                if (!DOMAIN_UNDERSCORE_SEGMENT_RX.test(segment)) {
+                    return (0, errors_1.errorCode)('DOMAIN_INVALID_CHARS');
+                }
+            }
+            else {
+                if (!DOMAIN_SEGMENT_RX.test(segment)) {
+                    return (0, errors_1.errorCode)('DOMAIN_INVALID_CHARS');
+                }
+            }
+        }
+        else {
+            if (!TLD_SEGMENT_RX.test(segment)) {
+                return (0, errors_1.errorCode)('DOMAIN_INVALID_TLDS_CHARS');
+            }
+        }
+    }
+    return null;
+}
+exports.analyzeDomain = analyzeDomain;
+/**
+ * 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);
+}
+exports.isDomainValid = isDomainValid;
+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');
+        }
+    }
+}
+exports.validateDomainOptions = validateDomainOptions;
+//# sourceMappingURL=domain.js.map

node_modules/@hapi/address/dist/domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.js","sourceRoot":"","sources":["../src/domain.ts"],"names":[],"mappings":"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"}

node_modules/@hapi/address/dist/email.d.ts

@@ -0,0 +1,27 @@
+import { Analysis, DomainOptions } from './domain';
+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;

node_modules/@hapi/address/dist/email.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmailValid = exports.analyzeEmail = void 0;
+const Util = require("util");
+const domain_1 = require("./domain");
+const errors_1 = require("./errors");
+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);
+}
+exports.analyzeEmail = analyzeEmail;
+/**
+ * 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);
+}
+exports.isEmailValid = isEmailValid;
+function validateEmail(email, options = {}) {
+    if (typeof email !== 'string') {
+        throw new Error('Invalid input: email must be a string');
+    }
+    if (!email) {
+        return (0, errors_1.errorCode)('EMPTY_STRING');
+    }
+    // Unicode
+    const ascii = !NON_ASCII_RX.test(email);
+    if (!ascii) {
+        if (options.allowUnicode === false) {
+            // Defaults to true
+            return (0, errors_1.errorCode)('FORBIDDEN_UNICODE');
+        }
+        email = email.normalize('NFC');
+    }
+    // Basic structure
+    const parts = email.split('@');
+    if (parts.length !== 2) {
+        return parts.length > 2 ? (0, errors_1.errorCode)('MULTIPLE_AT_CHAR') : (0, errors_1.errorCode)('MISSING_AT_CHAR');
+    }
+    const [local, domain] = parts;
+    if (!local) {
+        return (0, errors_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_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_1.errorCode)('LOCAL_TOO_LONG');
+        }
+    }
+    // Validate parts
+    return validateLocal(local, ascii) || (0, domain_1.analyzeDomain)(domain, options);
+}
+function validateLocal(local, ascii) {
+    const segments = local.split('.');
+    for (const segment of segments) {
+        if (!segment.length) {
+            return (0, errors_1.errorCode)('EMPTY_LOCAL_SEGMENT');
+        }
+        if (ascii) {
+            if (!ATEXT_RX.test(segment)) {
+                return (0, errors_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_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('|'));
+//# sourceMappingURL=email.js.map

node_modules/@hapi/address/dist/email.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.js","sourceRoot":"","sources":["../src/email.ts"],"names":[],"mappings":"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"}

node_modules/@hapi/address/dist/errors.d.ts

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

node_modules/@hapi/address/dist/errors.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorCode = exports.errorCodes = void 0;
+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] };
+}
+exports.errorCode = errorCode;
+//# sourceMappingURL=errors.js.map

node_modules/@hapi/address/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAAa,QAAA,UAAU,GAAG;IACtB,YAAY,EAAE,oCAAoC;IAClD,iBAAiB,EAAE,+CAA+C;IAClE,gBAAgB,EAAE,kDAAkD;IACpE,eAAe,EAAE,sCAAsC;IACvD,WAAW,EAAE,oCAAoC;IACjD,gBAAgB,EAAE,kBAAkB;IACpC,cAAc,EAAE,6BAA6B;IAC7C,mBAAmB,EAAE,yDAAyD;IAC9E,mBAAmB,EAAE,+CAA+C;IACpE,uBAAuB,EAAE,mCAAmC;IAC5D,eAAe,EAAE,iBAAiB;IAClC,4BAA4B,EAAE,8CAA8C;IAC5E,oBAAoB,EAAE,mCAAmC;IACzD,yBAAyB,EAAE,uCAAuC;IAClE,qBAAqB,EAAE,sDAAsD;IAC7E,yBAAyB,EAAE,mCAAmC;IAC9D,qBAAqB,EAAE,2BAA2B;IAClD,oBAAoB,EAAE,6CAA6C;IACnE,mBAAmB,EAAE,wDAAwD;CAChF,CAAC;AAEF,SAAgB,SAAS,CAAwC,IAAW;IACxE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,kBAAU,CAAC,IAAI,CAAC,EAAE,CAAC;AAC7C,CAAC;AAFD,8BAEC"}

node_modules/@hapi/address/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './domain';
+export * from './email';
+export { errorCodes } from './errors';
+export { ipRegex } from './ip';
+export { uriRegex } from './uri';
+export { uriDecode } from './decode';

node_modules/@hapi/address/dist/index.js

@@ -0,0 +1,28 @@
+"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;
+__exportStar(require("./domain"), exports);
+__exportStar(require("./email"), exports);
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "errorCodes", { enumerable: true, get: function () { return errors_1.errorCodes; } });
+var ip_1 = require("./ip");
+Object.defineProperty(exports, "ipRegex", { enumerable: true, get: function () { return ip_1.ipRegex; } });
+var uri_1 = require("./uri");
+Object.defineProperty(exports, "uriRegex", { enumerable: true, get: function () { return uri_1.uriRegex; } });
+var decode_1 = require("./decode");
+Object.defineProperty(exports, "uriDecode", { enumerable: true, get: function () { return decode_1.uriDecode; } });
+//# sourceMappingURL=index.js.map

node_modules/@hapi/address/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,0CAAwB;AACxB,mCAAsC;AAA7B,oGAAA,UAAU,OAAA;AACnB,2BAA+B;AAAtB,6FAAA,OAAO,OAAA;AAChB,6BAAiC;AAAxB,+FAAA,QAAQ,OAAA;AACjB,mCAAqC;AAA5B,mGAAA,SAAS,OAAA"}

node_modules/@hapi/address/dist/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 {};

node_modules/@hapi/address/dist/ip.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipRegex = void 0;
+const hoek_1 = require("@hapi/hoek");
+const uri_1 = require("./uri");
+/**
+ * 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, hoek_1.assert)(['required', 'optional', 'forbidden'].includes(cidr), 'options.cidr must be one of required, optional, forbidden');
+    // Versions
+    (0, hoek_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, hoek_1.assert)(versions.length >= 1, 'options.version must have at least 1 version specified');
+    for (const version of versions) {
+        (0, hoek_1.assert)(typeof version === 'string' && version === version.toLowerCase(), 'Invalid options.version value');
+        (0, hoek_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_1.ipVersions[version];
+        }
+        // Required
+        const cidrpart = `\\/${version === 'ipv4' ? uri_1.ipVersions.v4Cidr : uri_1.ipVersions.v6Cidr}`;
+        if (cidr === 'required') {
+            return `${uri_1.ipVersions[version]}${cidrpart}`;
+        }
+        // Optional
+        return `${uri_1.ipVersions[version]}(?:${cidrpart})?`;
+    });
+    const raw = `(?:${parts.join('|')})`;
+    const regex = new RegExp(`^${raw}$`);
+    return { cidr, versions, regex, raw };
+}
+exports.ipRegex = ipRegex;
+//# sourceMappingURL=ip.js.map

node_modules/@hapi/address/dist/ip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.js","sourceRoot":"","sources":["../src/ip.ts"],"names":[],"mappings":";;;AAAA,qCAAoC;AAEpC,+BAAmC;AAmCnC;;;;;;GAMG;AACH,SAAgB,OAAO,CAAC,UAAmB,EAAE;IACzC,OAAO;IAEP,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,UAAU,CAAC;IACxC,IAAA,aAAM,EACF,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EACpD,2DAA2D,CAC9D,CAAC;IAEF,WAAW;IAEX,IAAA,aAAM,EACF,OAAO,CAAC,OAAO,KAAK,SAAS,IAAI,OAAO,OAAO,CAAC,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EACtG,wDAAwD,CAC3D,CAAC;IAEF,IAAI,QAAQ,GAAG,OAAO,CAAC,OAAO,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IAChE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QAC1B,QAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC;KACzB;IAED,IAAA,aAAM,EAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,EAAE,wDAAwD,CAAC,CAAC;IAEvF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;QAC5B,IAAA,aAAM,EAAC,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,OAAO,CAAC,WAAW,EAAE,EAAE,+BAA+B,CAAC,CAAC;QAE1G,IAAA,aAAM,EACF,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAC/C,2CAA2C,GAAG,OAAO,GAAG,yCAAyC,CACpG,CAAC;KACL;IAED,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEzC,QAAQ;IAER,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;QACnC,YAAY;QAEZ,IAAI,IAAI,KAAK,WAAW,EAAE;YACtB,OAAO,gBAAU,CAAC,OAAO,CAAC,CAAC;SAC9B;QAED,WAAW;QAEX,MAAM,QAAQ,GAAG,MAAM,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,gBAAU,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAU,CAAC,MAAM,EAAE,CAAC;QAEpF,IAAI,IAAI,KAAK,UAAU,EAAE;YACrB,OAAO,GAAG,gBAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,EAAE,CAAC;SAC9C;QAED,WAAW;QAEX,OAAO,GAAG,gBAAU,CAAC,OAAO,CAAC,MAAM,QAAQ,IAAI,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IACrC,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC;IACrC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;AAC1C,CAAC;AA3DD,0BA2DC"}

node_modules/@hapi/address/dist/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 {};

node_modules/@hapi/address/dist/uri.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uriRegex = exports.ipVersions = void 0;
+const hoek_1 = require("@hapi/hoek");
+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, hoek_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, hoek_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, hoek_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, hoek_1.assert)(rfc.schemeRegex.test(scheme), 'scheme at position ' + i + ' must be a valid scheme');
+                selections.push((0, hoek_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;
+}
+exports.uriRegex = uriRegex;
+//# sourceMappingURL=uri.js.map