@azure-net/node-kit 0.0.0-stage → 0.1.1

package/dist/validation/rules/StringRules.js

@@ -0,0 +1,481 @@
+import { isIP } from "node:net";
+import { sizeOption, testRule } from "./Factory.js";
+function checkOptions(options) {
+    if (!options || typeof options !== "object" || Array.isArray(options))
+        throw new TypeError("Options must be an object.");
+    for (const key of ["code", "messageKey", "label"]) {
+        if (options[key] !== undefined && typeof options[key] !== "string")
+            throw new TypeError(`${key} must be a string.`);
+    }
+    if (options.message !== undefined &&
+        typeof options.message !== "string" &&
+        typeof options.message !== "function") {
+        throw new TypeError("message must be a string or function.");
+    }
+}
+function format(code, predicate, options = {}, params = {}) {
+    checkOptions(options);
+    return testRule(code, (value) => typeof value === "string" && predicate(value), options, params);
+}
+// Full matches use an absolute end assertion: JavaScript's $ also accepts a final newline.
+function full(source, flags = "") {
+    return new RegExp(`^(?:${source})(?![\\s\\S])`, flags);
+}
+// Fixed, non-global patterns are shared; neither input data nor match results are cached.
+const fixed = {
+    hostnameLabel: full("[a-z0-9](?:[a-z0-9-]*[a-z0-9])?", "i"),
+    emailAtom: full("[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+"),
+    base64: full("[A-Za-z0-9+/]*={0,2}"),
+    base64url: full("[A-Za-z0-9_-]*"),
+    prefix: full("0|[1-9][0-9]{0,2}"),
+    date: full("[0-9]{4}-[0-9]{2}-[0-9]{2}"),
+    time: full("([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\\.([0-9]+))?)?"),
+    nanoid: full("[A-Za-z0-9_-]+"),
+    hashHex: full("[0-9a-f]+", "i"),
+    creditCard: full("[0-9](?:[ -]?[0-9]){11,18}"),
+    iban: full("[A-Z]{2}[0-9]{2}[A-Z0-9]{11,30}"),
+    weeks: full("P[0-9]+W"),
+    duration: full("P([0-9]+Y)?([0-9]+M)?([0-9]+D)?(?:T([0-9]+H)?([0-9]+M)?([0-9]+(?:[.,][0-9]+)?S)?)?"),
+};
+function pattern(code, source, options, flags = "") {
+    const regex = full(source, flags);
+    return format(code, (value) => regex.test(value), options);
+}
+function snapshotRegex(regex) {
+    if (!(regex instanceof RegExp))
+        throw new TypeError("Expected a RegExp.");
+    const copy = new RegExp(regex.source, regex.flags);
+    return (value) => {
+        copy.lastIndex = 0;
+        return copy.test(value);
+    };
+}
+function textArgument(value) {
+    if (typeof value !== "string")
+        throw new TypeError("Expected a string.");
+}
+function lengthRule(code, bound, options, compare) {
+    checkOptions(options);
+    sizeOption(bound, code);
+    const unit = options.unit === undefined ? "codePoints" : options.unit;
+    if (unit !== "codePoints" && unit !== "codeUnits")
+        throw new TypeError("Invalid length unit.");
+    return testRule(code, (value) => {
+        if (typeof value === "string")
+            return compare(unit === "codePoints" ? Array.from(value).length : value.length);
+        if (Array.isArray(value))
+            return compare(value.length);
+        if (value instanceof Map || value instanceof Set)
+            return compare(value.size);
+        return false;
+    }, options, { [code]: bound, unit });
+}
+function validHostname(value) {
+    const name = value.endsWith(".") ? value.slice(0, -1) : value;
+    return (name.length > 0 &&
+        name.length <= 253 &&
+        name
+            .split(".")
+            .every((label) => label.length <= 63 && fixed.hostnameLabel.test(label)));
+}
+function urlRule(code, options, httpOnly) {
+    checkOptions(options);
+    const protocol = options.protocol === undefined
+        ? undefined
+        : snapshotRegex(options.protocol);
+    const hostname = options.hostname === undefined
+        ? undefined
+        : snapshotRegex(options.hostname);
+    return format(code, (value) => {
+        // WHATWG URL silently removes whitespace and repairs backslashes; do not normalize input.
+        if (/[\s\u0000-\u001f\u007f\\]/u.test(value))
+            return false;
+        try {
+            const url = new URL(value);
+            if (httpOnly &&
+                (!/^https?:\/\/[^/?#]/i.test(value) ||
+                    !["http:", "https:"].includes(url.protocol) ||
+                    !url.hostname))
+                return false;
+            return ((!protocol || protocol(url.protocol.slice(0, -1))) &&
+                (!hostname || hostname(url.hostname)));
+        }
+        catch {
+            return false;
+        }
+    }, options, {
+        protocol: options.protocol?.toString(),
+        hostname: options.hostname?.toString(),
+    });
+}
+function canonicalBase64(value, url) {
+    if (!(url ? fixed.base64url : fixed.base64).test(value))
+        return false;
+    const encoding = url ? "base64url" : "base64";
+    return Buffer.from(value, encoding).toString(encoding) === value;
+}
+function ip(value, version) {
+    // Zone identifiers describe an interface, not the address itself.
+    if (value.includes("%"))
+        return false;
+    const actual = isIP(value);
+    return version === undefined ? actual !== 0 : actual === version;
+}
+function cidr(value, version) {
+    const parts = value.split("/");
+    if (parts.length !== 2)
+        return false;
+    const [address, prefix] = parts;
+    return (ip(address, version) &&
+        fixed.prefix.test(prefix) &&
+        Number(prefix) <= (isIP(address) === 4 ? 32 : 128));
+}
+function validDate(value) {
+    if (!fixed.date.test(value))
+        return false;
+    const year = Number(value.slice(0, 4)), month = Number(value.slice(5, 7)), day = Number(value.slice(8));
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return month >= 1 && month <= 12 && day >= 1 && day <= days[month - 1];
+}
+function precisionOption(options) {
+    checkOptions(options);
+    const precision = options.precision ?? null;
+    if (precision !== null &&
+        (!Number.isSafeInteger(precision) || precision < -1))
+        throw new RangeError("precision must be -1, null, or a non-negative safe integer.");
+    return precision;
+}
+function validTime(value, precision, requireSeconds) {
+    const match = fixed.time.exec(value);
+    if (!match ||
+        Number(match[1]) > 23 ||
+        Number(match[2]) > 59 ||
+        (match[3] !== undefined && Number(match[3]) > 59))
+        return false;
+    if (precision === -1)
+        return match[3] === undefined;
+    if (requireSeconds && match[3] === undefined)
+        return false;
+    if (precision === null)
+        return true;
+    return match[3] !== undefined && (match[4]?.length ?? 0) === precision;
+}
+const hashBytes = {
+    md5: 16,
+    sha1: 20,
+    sha256: 32,
+    sha384: 48,
+    sha512: 64,
+};
+let currencies;
+/**
+ * Noncoercive format checks. Format scope was reviewed against Zod 4.6.7's
+ * src/v4/core/{regexes,schemas}.ts (MIT, Colin McDonnell and contributors).
+ * Implementations below are independent; no Zod runtime dependency is required.
+ */
+export const stringRules = {
+    string(options = {}) {
+        checkOptions(options);
+        return testRule("string", (value) => typeof value === "string", options, {}, true);
+    },
+    /** Strings count Unicode code points by default, arrays count elements, maps/sets count entries. */
+    length(length, options = {}) {
+        return lengthRule("length", length, options, (size) => size === length);
+    },
+    minLength(minLength, options = {}) {
+        return lengthRule("minLength", minLength, options, (size) => size >= minLength);
+    },
+    maxLength(maxLength, options = {}) {
+        return lengthRule("maxLength", maxLength, options, (size) => size <= maxLength);
+    },
+    /** State-safe, not ReDoS-safe: callers are responsible for their pattern's complexity. */
+    matches(regex, options = {}) {
+        const test = snapshotRegex(regex);
+        return format("matches", test, options, {
+            pattern: regex.source,
+            flags: regex.flags,
+        });
+    },
+    includes(substring, options = {}) {
+        textArgument(substring);
+        return format("includes", (value) => value.includes(substring), options, {
+            substring,
+        });
+    },
+    startsWith(prefix, options = {}) {
+        textArgument(prefix);
+        return format("startsWith", (value) => value.startsWith(prefix), options, {
+            prefix,
+        });
+    },
+    endsWith(suffix, options = {}) {
+        textArgument(suffix);
+        return format("endsWith", (value) => value.endsWith(suffix), options, {
+            suffix,
+        });
+    },
+    lowercase(options = {}) {
+        return format("lowercase", (value) => value === value.toLowerCase(), options);
+    },
+    uppercase(options = {}) {
+        return format("uppercase", (value) => value === value.toUpperCase(), options);
+    },
+    /** ASCII dot-atom mailbox with a dotted DNS domain; not all RFC 5322 mailboxes. */
+    email(options = {}) {
+        return format("email", (value) => {
+            if (value.length > 254)
+                return false;
+            const parts = value.split("@");
+            if (parts.length !== 2)
+                return false;
+            const [local, domain] = parts;
+            return (local.length <= 64 &&
+                local.split(".").every((atom) => fixed.emailAtom.test(atom)) &&
+                domain.includes(".") &&
+                !domain.endsWith(".") &&
+                validHostname(domain) &&
+                !isIP(domain) &&
+                /[a-z]/i.test(domain.split(".").at(-1)));
+        }, options);
+    },
+    /** RFC 9562 versions 1-8 and, without a version filter, Nil/Max UUIDs. */
+    uuid(options = {}) {
+        checkOptions(options);
+        const version = options.version;
+        if (version !== undefined &&
+            (!Number.isInteger(version) || version < 1 || version > 8))
+            throw new RangeError("UUID version must be 1 through 8.");
+        const normal = full(`[0-9a-f]{8}-[0-9a-f]{4}-${version ?? "[1-8]"}[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}`, "i");
+        return format("uuid", (value) => normal.test(value) ||
+            (version === undefined &&
+                (value === "00000000-0000-0000-0000-000000000000" ||
+                    value.toLowerCase() === "ffffffff-ffff-ffff-ffff-ffffffffffff")), options, { version: version ?? "any" });
+    },
+    guid(options = {}) {
+        return pattern("guid", "[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}", options, "i");
+    },
+    /** Absolute WHATWG URLs, including non-HTTP schemes; not a safe-URL/security policy. */
+    url(options = {}) {
+        return urlRule("url", options, false);
+    },
+    httpUrl(options = {}) {
+        return urlRule("httpUrl", options, true);
+    },
+    /** ASCII DNS labels, optionally terminated by a root dot; use punycode for IDNs. */
+    hostname(options = {}) {
+        return format("hostname", validHostname, options);
+    },
+    /** International '+' notation with 2-15 digits; does not verify allocation or reachability. */
+    e164(options = {}) {
+        return pattern("e164", "\\+[1-9][0-9]{1,14}", options);
+    },
+    /** Common emoji sequences, not a versioned Unicode RGI membership check. */
+    emoji(options = {}) {
+        const base = "\\p{Extended_Pictographic}\\uFE0F?\\p{Emoji_Modifier}?";
+        return pattern("emoji", `(?:\\p{Regional_Indicator}{2}|[0-9#*]\\uFE0F?\\u20E3|${base}(?:\\u200D${base})*(?:[\\u{E0020}-\\u{E007E}]+\\u{E007F})?)+`, options, "u");
+    },
+    /** Canonical padded RFC 4648 encoding (empty input is valid). */
+    base64(options = {}) {
+        return format("base64", (value) => canonicalBase64(value, false), options);
+    },
+    /** Canonical unpadded RFC 4648 URL encoding (empty input is valid). */
+    base64url(options = {}) {
+        return format("base64url", (value) => canonicalBase64(value, true), options);
+    },
+    hex(options = {}) {
+        return pattern("hex", "[0-9a-f]*", options, "i");
+    },
+    /** Compact signed JWT syntax only: no signature, claim, expiry, or algorithm-security verification. */
+    jwt(options = {}) {
+        checkOptions(options);
+        const algorithm = options.algorithm;
+        if (algorithm !== undefined &&
+            (typeof algorithm !== "string" || !algorithm || algorithm === "none"))
+            throw new TypeError("algorithm must name a signing algorithm.");
+        return format("jwt", (value) => {
+            const parts = value.split(".");
+            if (parts.length !== 3 ||
+                !parts.every((part) => part.length > 0 && canonicalBase64(part, true)))
+                return false;
+            try {
+                const decoder = new TextDecoder("utf-8", { fatal: true });
+                const header = JSON.parse(decoder.decode(Buffer.from(parts[0], "base64url")));
+                const payload = JSON.parse(decoder.decode(Buffer.from(parts[1], "base64url")));
+                if (!header ||
+                    typeof header !== "object" ||
+                    Array.isArray(header) ||
+                    !payload ||
+                    typeof payload !== "object" ||
+                    Array.isArray(payload))
+                    return false;
+                const h = header;
+                return (typeof h.alg === "string" &&
+                    h.alg.length > 0 &&
+                    h.alg !== "none" &&
+                    (algorithm === undefined || h.alg === algorithm) &&
+                    (h.typ === undefined ||
+                        (typeof h.typ === "string" && h.typ.toUpperCase() === "JWT")) &&
+                    h.b64 !== false);
+            }
+            catch {
+                return false;
+            }
+        }, options, { algorithm: algorithm ?? "any" });
+    },
+    nanoid(options = {}) {
+        checkOptions(options);
+        const length = options.length === undefined ? 21 : options.length;
+        sizeOption(length, "length");
+        if (!length)
+            throw new RangeError("Nano ID length must be positive.");
+        return format("nanoid", (value) => value.length === length && fixed.nanoid.test(value), options, { length });
+    },
+    /** Canonical 25-character CUID v1 shape, not proof of provenance. */
+    cuid(options = {}) {
+        return pattern("cuid", "c[0-9a-z]{24}", options);
+    },
+    /** CUID2 allows custom lengths: lowercase leading letter followed by lowercase alphanumerics. */
+    cuid2(options = {}) {
+        return pattern("cuid2", "[a-z][a-z0-9]*", options);
+    },
+    ulid(options = {}) {
+        return pattern("ulid", "[0-7][0-9A-HJKMNP-TV-Z]{25}", options, "i");
+    },
+    /** Zod-compatible 20-character base32hex shape, case-insensitive; no padding-bit or provenance check. */
+    xid(options = {}) {
+        return pattern("xid", "[0-9a-v]{20}", options, "i");
+    },
+    /** Zod-compatible 27-character base62 shape; no decoded 160-bit range or timestamp check. */
+    ksuid(options = {}) {
+        return pattern("ksuid", "[A-Za-z0-9]{27}", options);
+    },
+    ip(options = {}) {
+        return format("ip", (value) => ip(value), options);
+    },
+    ipv4(options = {}) {
+        return format("ipv4", (value) => ip(value, 4), options);
+    },
+    ipv6(options = {}) {
+        return format("ipv6", (value) => ip(value, 6), options);
+    },
+    /** CIDR address/prefix notation; host bits need not be zero. */
+    cidr(options = {}) {
+        return format("cidr", (value) => cidr(value), options);
+    },
+    cidrv4(options = {}) {
+        return format("cidrv4", (value) => cidr(value, 4), options);
+    },
+    cidrv6(options = {}) {
+        return format("cidrv6", (value) => cidr(value, 6), options);
+    },
+    mac(options = {}) {
+        checkOptions(options);
+        const delimiter = options.delimiter === undefined ? ":" : options.delimiter;
+        if (![":", "-", ""].includes(delimiter))
+            throw new TypeError("Invalid MAC delimiter.");
+        const regex = full(Array(6).fill("[0-9a-f]{2}").join(delimiter), "i");
+        return format("mac", (value) => regex.test(value), options, { delimiter });
+    },
+    /** 12-19 digit PAN with optional single space/hyphen separators and Luhn checksum, not issuer verification. */
+    creditCard(options = {}) {
+        return format("creditCard", (value) => {
+            if (!fixed.creditCard.test(value))
+                return false;
+            const digits = value.replace(/[ -]/g, "");
+            if (/^0+$/.test(digits))
+                return false;
+            let sum = 0;
+            for (let index = digits.length - 1, double = false; index >= 0; index--, double = !double) {
+                let digit = Number(digits[index]);
+                if (double) {
+                    digit *= 2;
+                    if (digit > 9)
+                        digit -= 9;
+                }
+                sum += digit;
+            }
+            return sum % 10 === 0;
+        }, options);
+    },
+    /** Electronic IBAN shape and MOD-97 checksum; no country-specific BBAN or bank registry validation. */
+    iban(options = {}) {
+        return format("iban", (value) => {
+            if (!fixed.iban.test(value))
+                return false;
+            const check = Number(value.slice(2, 4));
+            if (check < 2 || check > 98)
+                return false;
+            let remainder = 0;
+            for (const char of value.slice(4) + value.slice(0, 4)) {
+                const numeric = char >= "A" ? char.charCodeAt(0) - 55 : Number(char);
+                remainder = (remainder * (numeric >= 10 ? 100 : 10) + numeric) % 97;
+            }
+            return remainder === 1;
+        }, options);
+    },
+    /** Uppercase currencies supported by the host's ICU data, not a live ISO 4217 registry. */
+    currencyCode(options = {}) {
+        currencies ??= new Set(Intl.supportedValuesOf("currency"));
+        return format("currencyCode", (value) => currencies.has(value), options);
+    },
+    hash(algorithm, options = {}) {
+        checkOptions(options);
+        if (!Object.hasOwn(hashBytes, algorithm))
+            throw new TypeError("Unsupported hash algorithm.");
+        const bytes = hashBytes[algorithm], encoding = options.encoding === undefined ? "hex" : options.encoding;
+        if (!["hex", "base64", "base64url"].includes(encoding))
+            throw new TypeError("Unsupported hash encoding.");
+        return format("hash", (value) => encoding === "hex"
+            ? value.length === bytes * 2 && fixed.hashHex.test(value)
+            : canonicalBase64(value, encoding === "base64url") &&
+                Buffer.from(value, encoding).length === bytes, options, { algorithm, encoding });
+    },
+    /** Gregorian calendar YYYY-MM-DD, including astronomical year 0000. */
+    isoDate(options = {}) {
+        return format("isoDate", validDate, options);
+    },
+    /** Local HH:mm[:ss[.fraction]]; no leap seconds or 24:00. precision -1 means minutes. */
+    isoTime(options = {}) {
+        const precision = precisionOption(options);
+        return format("isoTime", (value) => validTime(value, precision, false), options, { precision });
+    },
+    /** UTC by default; explicit opt-ins for offsets and local time. Zoned forms require seconds unless precision=-1. */
+    isoDateTime(options = {}) {
+        const precision = precisionOption(options);
+        for (const key of ["offset", "local"]) {
+            if (options[key] !== undefined && typeof options[key] !== "boolean")
+                throw new TypeError(`${key} must be boolean.`);
+        }
+        const offset = options.offset ?? false, local = options.local ?? false;
+        return format("isoDateTime", (value) => {
+            if (value[10] !== "T" || !validDate(value.slice(0, 10)))
+                return false;
+            let time = value.slice(11), zoned = false;
+            if (time.endsWith("Z")) {
+                time = time.slice(0, -1);
+                zoned = true;
+            }
+            else if (/[+-]/.test(time)) {
+                if (!offset ||
+                    !/[+-](?:[01][0-9]|2[0-3]):[0-5][0-9]$(?![\s\S])/.test(time))
+                    return false;
+                time = time.slice(0, -6);
+                zoned = true;
+            }
+            return (zoned || local) && validTime(time, precision, zoned);
+        }, options, { precision, offset, local });
+    },
+    /** ISO 8601-1 subset: weeks alone, or ordered Y/M/D and H/M/S; fractions only on seconds. */
+    isoDuration(options = {}) {
+        return format("isoDuration", (value) => {
+            if (fixed.weeks.test(value))
+                return true;
+            const match = fixed.duration.exec(value);
+            return (!!match &&
+                match.slice(1).some((part) => part !== undefined) &&
+                (!value.includes("T") ||
+                    match.slice(4).some((part) => part !== undefined)));
+        }, options);
+    },
+};

package/dist/validation/rules/StructureRules.d.ts

@@ -0,0 +1,30 @@
+import type { AnyRule, BuiltinRule, FieldRule, RuleOptions, ValidationRules } from "../Types.js";
+import { validatorDefinition } from "../Symbols.js";
+import type { Validator } from "../Validator.js";
+export declare const structureRules: {
+    optional: () => BuiltinRule<undefined>;
+    nullable: () => BuiltinRule<null>;
+    nullish: () => BuiltinRule<null | undefined>;
+    object<T extends object, TRoot = unknown, C = unknown>(shape: ValidationRules<T, TRoot, C>, options?: RuleOptions & {
+        unknownKeys?: "reject" | "allow";
+    }): BuiltinRule<T, C, TRoot>;
+    array<T, TRoot = unknown, C = unknown>(items: readonly FieldRule<T, T[], TRoot, C>[], options?: RuleOptions): BuiltinRule<T[], C, TRoot>;
+    tuple<T extends readonly unknown[], TRoot = unknown, C = unknown>(items: { readonly [K in keyof T]: readonly FieldRule<T[K], T, TRoot, C>[]; }, options?: RuleOptions): BuiltinRule<T, C, TRoot>;
+    record<T, TRoot = unknown, C = unknown>(items: readonly FieldRule<T, Record<string, T>, TRoot, C>[], options?: RuleOptions, keys?: readonly FieldRule<string, Record<string, T>, TRoot, C>[]): BuiltinRule<Record<string, T>, C, TRoot>;
+    map<K, V, TRoot = unknown, C = unknown>(keys: readonly FieldRule<K, Map<K, V>, TRoot, C>[], items: readonly FieldRule<V, Map<K, V>, TRoot, C>[], options?: RuleOptions): BuiltinRule<Map<K, V>, C, TRoot>;
+    set<T, TRoot = unknown, C = unknown>(items: readonly FieldRule<T, Set<T>, TRoot, C>[], options?: RuleOptions): BuiltinRule<Set<T>, C, TRoot>;
+    union<T, D = unknown, TRoot = unknown, C = unknown>(alternatives: readonly (readonly FieldRule<T, D, TRoot, C>[])[], options?: RuleOptions): BuiltinRule<T, C, TRoot>;
+    discriminatedUnion<T, D = unknown, TRoot = unknown, C = unknown>(key: string, variants: Readonly<Record<string, readonly FieldRule<T, D, TRoot, C>[]>>, options?: RuleOptions): BuiltinRule<T, C, TRoot>;
+    intersection<A extends object, B extends object, TRoot = unknown, C = unknown>(left: ValidationRules<A, TRoot, C>, right: ValidationRules<B, TRoot, C>, options?: RuleOptions): BuiltinRule<A & B, C, TRoot>;
+    validator<T extends object, C>(validator: (new () => Validator<T, C>) & {
+        [validatorDefinition](): Readonly<Record<string, readonly AnyRule[]>>;
+        readonly configuration: {
+            readonly unknownKeys?: "reject" | "allow";
+        };
+    }, options?: RuleOptions): BuiltinRule<T, C>;
+    lazy<T, D = unknown, TRoot = unknown, C = unknown>(resolve: () => readonly FieldRule<T, D, TRoot, C>[], options?: RuleOptions): BuiltinRule<T, C, TRoot>;
+    unique(options?: RuleOptions): BuiltinRule<never>;
+    uniqueBy<T>(key: keyof T, options?: RuleOptions): BuiltinRule<never>;
+    sameAs(key: string, options?: RuleOptions): BuiltinRule<never>;
+    notSameAs(key: string, options?: RuleOptions): BuiltinRule<never>;
+};

package/dist/validation/rules/StructureRules.js

@@ -0,0 +1,145 @@
+import { descriptor, testRule } from "./Factory.js";
+import { validatorDefinition } from "../Symbols.js";
+const list = (items) => Object.freeze([...items]);
+function checkKeys(shape) {
+    if (Object.getOwnPropertySymbols(shape).length)
+        throw new TypeError("Validation schemas support string and numeric keys, not symbols.");
+}
+function structure(kind, options = {}, extra = {}) {
+    return descriptor({
+        kind,
+        code: `type.${kind}`,
+        structural: true,
+        options,
+        params: {},
+        ...extra,
+    });
+}
+export const structureRules = {
+    optional: () => structure("optional"),
+    nullable: () => structure("nullable"),
+    nullish: () => structure("optional", {}, { params: { nullable: true } }),
+    object(shape, options = {}) {
+        checkKeys(shape);
+        const snapshot = Object.fromEntries(Object.entries(shape).map(([key, rules]) => [
+            key,
+            list(rules),
+        ]));
+        return structure("object", options, {
+            shape: Object.freeze(snapshot),
+            unknownKeys: options.unknownKeys,
+        });
+    },
+    array(items, options = {}) {
+        return structure("array", options, { items: list(items) });
+    },
+    tuple(items, options = {}) {
+        return structure("tuple", options, {
+            tuple: Object.freeze(items.map(list)),
+        });
+    },
+    record(items, options = {}, keys) {
+        return structure("record", options, {
+            items: list(items),
+            keys: keys && list(keys),
+        });
+    },
+    map(keys, items, options = {}) {
+        return structure("map", options, { keys: list(keys), items: list(items) });
+    },
+    set(items, options = {}) {
+        return structure("set", options, { items: list(items) });
+    },
+    union(alternatives, options = {}) {
+        if (alternatives.length < 2)
+            throw new TypeError("A union requires at least two alternatives.");
+        return structure("union", options, {
+            alternatives: Object.freeze(alternatives.map(list)),
+        });
+    },
+    discriminatedUnion(key, variants, options = {}) {
+        if (!Object.keys(variants).length)
+            throw new TypeError("A discriminated union requires variants.");
+        return structure("union", options, {
+            discriminator: key,
+            variants: Object.freeze(Object.fromEntries(Object.entries(variants).map(([key, value]) => [key, list(value)]))),
+        });
+    },
+    intersection(left, right, options = {}) {
+        checkKeys(left);
+        checkKeys(right);
+        const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+        const a = left;
+        const b = right;
+        return structure("object", options, {
+            shape: Object.freeze(Object.fromEntries([...keys].map((key) => {
+                const first = Object.hasOwn(a, key) ? a[key] : undefined;
+                const second = Object.hasOwn(b, key) ? b[key] : undefined;
+                return [
+                    key,
+                    first && second
+                        ? list([
+                            structure("intersection", options, {
+                                alternatives: [list(first), list(second)],
+                            }),
+                        ])
+                        : list(first ?? second),
+                ];
+            }))),
+        });
+    },
+    validator(validator, options = {}) {
+        let cached;
+        return structure("validator", options, {
+            unknownKeys: validator.configuration.unknownKeys ?? "reject",
+            resolve: () => (cached ??= [
+                structure("object", options, {
+                    shape: validator[validatorDefinition](),
+                }),
+            ]),
+        });
+    },
+    lazy(resolve, options = {}) {
+        let cached;
+        return structure("lazy", options, {
+            resolve: () => (cached ??= list(resolve())),
+        });
+    },
+    unique(options = {}) {
+        return testRule("array.unique", (value) => Array.isArray(value) && new Set(value).size === value.length, options);
+    },
+    uniqueBy(key, options = {}) {
+        return testRule("array.unique", (value) => {
+            if (!Array.isArray(value))
+                return false;
+            const seen = new Set();
+            for (const item of value) {
+                const selected = item != null && Object.hasOwn(item, key) ? item[key] : undefined;
+                if (seen.has(selected))
+                    return false;
+                seen.add(selected);
+            }
+            return true;
+        }, options, { key: String(key) });
+    },
+    sameAs(key, options = {}) {
+        return testRule("comparison.sameAs", (value, { data }) => {
+            const property = data !== null && typeof data === "object"
+                ? Object.getOwnPropertyDescriptor(data, key)
+                : undefined;
+            return (!!property &&
+                Object.hasOwn(property, "value") &&
+                Object.is(value, property.value));
+        }, options, { field: key });
+    },
+    notSameAs(key, options = {}) {
+        return testRule("comparison.notSameAs", (value, { data }) => {
+            const property = data !== null && typeof data === "object"
+                ? Object.getOwnPropertyDescriptor(data, key)
+                : undefined;
+            return (!!property &&
+                Object.hasOwn(property, "value") &&
+                !Object.is(value, property.value));
+        }, options, { field: key });
+    },
+};