typebox 1.1.9 → 1.1.11

package/build/format/email.d.mts

@@ -1,2 +1,5 @@
-/** Returns true if the value is an Email */
+/**
+ * Returns true if the value is an Email
+ * @specification Json Schema 2020-12
+ */
 export declare function IsEmail(value: string): boolean;

package/build/format/email.mjs

@@ -1,5 +1,29 @@
-const Email = /^(?!.*\.\.)[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i;
-/** Returns true if the value is an Email */
+import { IsIPv4Internal } from './ipv4.mjs';
+/**
+ * Returns true if the value is an Email
+ * @specification Json Schema 2020-12
+ */
 export function IsEmail(value) {
-    return Email.test(value);
+    const dot = value.indexOf('.');
+    const at = value.indexOf('@');
+    const quoted = value[0] === '"' && value[at - 1] === '"';
+    const ipLiteral = value[at + 1] === '[' && value[value.length - 1] === ']';
+    const ipv6 = ipLiteral && value.indexOf(':', at) !== -1;
+    const ipv4 = ipLiteral && !ipv6 && IsIPv4Internal(value, at + 2, value.length - 1);
+    return (at > 0 && at < value.length - 1) &&
+        !(
+        // .test@example.com
+        (!quoted && dot === 0) ||
+            // te..st@example.com
+            (!quoted && dot !== -1 && value.indexOf('.', dot + 1) === dot + 1) ||
+            // test.@example.com
+            (dot !== -1 && value.indexOf('@', dot) === dot + 1) ||
+            // joe bloggs@example.com
+            (!quoted && value.indexOf(' ') !== -1) ||
+            // user1@oceania.org, user2@oceania.org
+            (value.indexOf(',') !== -1) ||
+            // joe.bloggs@[127.0.0.300]
+            (ipLiteral && !ipv4 && !ipv6) ||
+            // joe.bloggs@invalid=domain.com
+            (value.indexOf('=', at) !== -1));
 }

package/build/format/format.d.mts

@@ -1,22 +1,22 @@
 export * from './_registry.mjs';
-export * from './date-time.mjs';
-export * from './date.mjs';
-export * from './duration.mjs';
-export * from './email.mjs';
-export * from './hostname.mjs';
-export * from './idn-email.mjs';
-export * from './idn-hostname.mjs';
-export * from './ipv4.mjs';
-export * from './ipv6.mjs';
-export * from './iri-reference.mjs';
-export * from './iri.mjs';
-export * from './json-pointer-uri-fragment.mjs';
-export * from './json-pointer.mjs';
-export * from './regex.mjs';
-export * from './relative-json-pointer.mjs';
-export * from './time.mjs';
-export * from './uri-reference.mjs';
-export * from './uri-template.mjs';
-export * from './uri.mjs';
-export * from './url.mjs';
-export * from './uuid.mjs';
+export { IsDateTime } from './date-time.mjs';
+export { IsDate } from './date.mjs';
+export { IsDuration } from './duration.mjs';
+export { IsEmail } from './email.mjs';
+export { IsHostname } from './hostname.mjs';
+export { IsIdnEmail } from './idn-email.mjs';
+export { IsIdnHostname } from './idn-hostname.mjs';
+export { IsIPv4 } from './ipv4.mjs';
+export { IsIPv6 } from './ipv6.mjs';
+export { IsIriReference } from './iri-reference.mjs';
+export { IsIri } from './iri.mjs';
+export { IsJsonPointerUriFragment } from './json-pointer-uri-fragment.mjs';
+export { IsJsonPointer } from './json-pointer.mjs';
+export { IsRegex } from './regex.mjs';
+export { IsRelativeJsonPointer } from './relative-json-pointer.mjs';
+export { IsTime } from './time.mjs';
+export { IsUriReference } from './uri-reference.mjs';
+export { IsUriTemplate } from './uri-template.mjs';
+export { IsUri } from './uri.mjs';
+export { IsUrl } from './url.mjs';
+export { IsUuid } from './uuid.mjs';

package/build/format/format.mjs

@@ -1,22 +1,22 @@
 export * from './_registry.mjs';
-export * from './date-time.mjs';
-export * from './date.mjs';
-export * from './duration.mjs';
-export * from './email.mjs';
-export * from './hostname.mjs';
-export * from './idn-email.mjs';
-export * from './idn-hostname.mjs';
-export * from './ipv4.mjs';
-export * from './ipv6.mjs';
-export * from './iri-reference.mjs';
-export * from './iri.mjs';
-export * from './json-pointer-uri-fragment.mjs';
-export * from './json-pointer.mjs';
-export * from './regex.mjs';
-export * from './relative-json-pointer.mjs';
-export * from './time.mjs';
-export * from './uri-reference.mjs';
-export * from './uri-template.mjs';
-export * from './uri.mjs';
-export * from './url.mjs';
-export * from './uuid.mjs';
+export { IsDateTime } from './date-time.mjs';
+export { IsDate } from './date.mjs';
+export { IsDuration } from './duration.mjs';
+export { IsEmail } from './email.mjs';
+export { IsHostname } from './hostname.mjs';
+export { IsIdnEmail } from './idn-email.mjs';
+export { IsIdnHostname } from './idn-hostname.mjs';
+export { IsIPv4 } from './ipv4.mjs';
+export { IsIPv6 } from './ipv6.mjs';
+export { IsIriReference } from './iri-reference.mjs';
+export { IsIri } from './iri.mjs';
+export { IsJsonPointerUriFragment } from './json-pointer-uri-fragment.mjs';
+export { IsJsonPointer } from './json-pointer.mjs';
+export { IsRegex } from './regex.mjs';
+export { IsRelativeJsonPointer } from './relative-json-pointer.mjs';
+export { IsTime } from './time.mjs';
+export { IsUriReference } from './uri-reference.mjs';
+export { IsUriTemplate } from './uri-template.mjs';
+export { IsUri } from './uri.mjs';
+export { IsUrl } from './url.mjs';
+export { IsUuid } from './uuid.mjs';

package/build/format/hostname.d.mts

@@ -1,2 +1,5 @@
-/** Returns true if the value is a Hostname */
+/**
+ * Returns true if the value matches RFC 1123 hostname syntax.
+ * @specification https://tools.ietf.org/html/rfc1123
+ */
 export declare function IsHostname(value: string): boolean;

package/build/format/hostname.mjs

@@ -1,5 +1,34 @@
-const Hostname = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
-/** Returns true if the value is a Hostname */
+/**
+ * Returns true if the value matches RFC 1123 hostname syntax.
+ * @specification https://tools.ietf.org/html/rfc1123
+ */
 export function IsHostname(value) {
-    return Hostname.test(value);
+    if (value.length > 253 || value.length === 0)
+        return false;
+    let start = 0;
+    let prev = 0;
+    for (let i = 0; i < value.length; i++) {
+        const ch = value.charCodeAt(i);
+        if (ch === 46) { // '.'
+            // trailing dot is valid e.g. "example.com." but not "."
+            if (i === value.length - 1 && start < i)
+                break;
+            const len = i - start;
+            if (len === 0 || len > 63 || value.charCodeAt(start) === 45 || prev === 45)
+                return false;
+            start = i + 1;
+        }
+        else if (!((ch >= 97 && ch <= 122) || // a-z
+            (ch >= 65 && ch <= 90) || // A-Z
+            (ch >= 48 && ch <= 57) || // 0-9
+            ch === 45 // '-'
+        )) {
+            return false;
+        }
+        prev = ch;
+    }
+    const length = value.length - start;
+    const first = value.charCodeAt(start);
+    const last = value.charCodeAt(value.length - 1);
+    return length > 0 && length <= 63 && first !== 45 && last !== 45;
 }

package/build/format/idn-email.d.mts

@@ -1,2 +1,5 @@
-/** Returns true if the value is a Idn Email */
+/**
+ * Returns true if the value is an IdnEmail
+ * @specification Json Schema 2020-12
+ */
 export declare function IsIdnEmail(value: string): boolean;

package/build/format/idn-email.mjs

@@ -1,5 +1,8 @@
-const IdnEmail = /^(?!.*\.\.)[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+(?:\.[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+)*@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?)*$/iu;
-/** Returns true if the value is a Idn Email */
+import { IsEmail } from './email.mjs';
+/**
+ * Returns true if the value is an IdnEmail
+ * @specification Json Schema 2020-12
+ */
 export function IsIdnEmail(value) {
-    return IdnEmail.test(value);
+    return IsEmail(value);
 }

package/build/format/idn-hostname.d.mts

@@ -1,5 +1,5 @@
 /**
- * Returns true if the value is a Hostname
- * @specification
+ * Returns true if the value is an IDN Hostname
+ * @specification Json Schema 2020-12
  */
 export declare function IsIdnHostname(value: string): boolean;

package/build/format/idn-hostname.mjs

@@ -1,124 +1,115 @@
-function IsValidAdjacentForKatakanaMiddleDot(char) {
-    const codePoint = char.codePointAt(0);
-    // deno-coverage-ignore - internal condition never reached
-    if (codePoint === undefined)
-        return false;
-    return ((codePoint >= 0x3040 && codePoint <= 0x309F) || // Hiragana
-        (codePoint >= 0x30A0 && codePoint <= 0x30FF && codePoint !== 0x30FB) || // Katakana (excluding U+30FB)
-        (codePoint >= 0x4E00 && codePoint <= 0x9FFF) // Han (CJK Unified Ideographs)
+function IsValidAdjacentForKatakanaMiddleDot(cp) {
+    return ((cp >= 0x3040 && cp <= 0x309F) || // Hiragana
+        (cp >= 0x30A0 && cp <= 0x30FF && cp !== 0x30FB) || // Katakana (excluding U+30FB)
+        (cp >= 0x4E00 && cp <= 0x9FFF) // Han (CJK Unified Ideographs)
     );
 }
 /**
- * Returns true if the value is a Hostname
- * @specification
+ * Returns true if the value is an IDN Hostname
+ * @specification Json Schema 2020-12
  */
 export function IsIdnHostname(value) {
-    if (value.length === 0)
-        return false;
-    if (value.includes(' '))
+    if (value.length === 0 || value.includes(' '))
         return false;
-    // Allowed label separators per RFC3490: U+002E, U+3002, U+FF0E, U+FF61.
-    const separators = /[\u002E\u3002\uFF0E\uFF61]/g;
-    // Normalize (NFC) and replace allowed separators with a dot.
-    const normalized = value.normalize('NFC').replace(separators, '.');
+    // Normalize (NFC) and replace allowed separators with a dot
+    // Allowed label separators per RFC3490: U+002E, U+3002, U+FF0E, U+FF61
+    const normalized = value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
     if (normalized.length > 253)
         return false;
-    // Split into labels; disallow empty labels.
     const labels = normalized.split('.');
-    if (labels.some((label) => label.length === 0))
-        return false;
     for (const label of labels) {
-        // Each label must be ≤ 63 characters.
-        if (label.length > 63)
+        if (label.length === 0 || label.length > 63)
             return false;
-        // Labels must not begin or end with a hyphen.
-        if (label.startsWith('-') || label.endsWith('-'))
+        // Labels must not begin or end with a hyphen
+        if (label.charCodeAt(0) === 45 || label.charCodeAt(label.length - 1) === 45)
             return false;
-        // A-label (punycode) checks.
-        if (/^xn--/i.test(label)) {
+        // A-label (punycode) checks
+        if ((label.charCodeAt(0) === 120 || label.charCodeAt(0) === 88) && // 'x' or 'X'
+            (label.charCodeAt(1) === 110 || label.charCodeAt(1) === 78) && // 'n' or 'N'
+            label.charCodeAt(2) === 45 && // '-'
+            label.charCodeAt(3) === 45 // '-'
+        ) {
             const punycodePart = label.slice(4);
-            if (punycodePart.length < 2)
-                return false;
-            if (punycodePart.includes('---'))
+            if (punycodePart.length < 2 || punycodePart.includes('---'))
                 return false;
             continue;
         }
-        // U-label: Reject if any disallowed code points occur.
-        // Disallowed: U+302E, U+302F, U+3031, U+3032, U+3033, U+3034, U+3035, U+303B, U+0640, U+07FA.
-        if (/[\u302E\u302F\u3031\u3032\u3033\u3034\u3035\u303B\u0640\u07FA]/.test(label)) {
-            return false;
-        }
-        // Disallow labels starting with certain combining marks.
-        const firstChar = label.charAt(0);
-        if (/[\u0903\u0300\u0488]/.test(firstChar))
-            return false;
-        // Check each character within the label.
+        // U-label checks
+        let hasArabicIndic = false;
+        let hasExtendedArabicIndic = false;
         for (let i = 0; i < label.length; i++) {
-            const char = label.charAt(i);
-            // --- MIDDLE DOT (U+00B7) ---
-            // Must be flanked on both sides by "l" or "L".
-            if (char === '\u00B7') {
+            // deno-coverage-ignore
+            const cp = label.codePointAt(i) ?? 0;
+            // Disallowed code points
+            if (cp === 0x302E || cp === 0x302F ||
+                cp === 0x3031 || cp === 0x3032 || cp === 0x3033 || cp === 0x3034 || cp === 0x3035 ||
+                cp === 0x303B || cp === 0x0640 || cp === 0x07FA)
+                return false;
+            // Disallow labels starting with certain combining marks
+            if (i === 0 && (cp === 0x0903 || cp === 0x0300 || cp === 0x0488))
+                return false;
+            // MIDDLE DOT (U+00B7) must be flanked by 'l' or 'L'
+            if (cp === 0x00B7) {
                 if (i === 0 || i === label.length - 1)
                     return false;
-                const prev = label.charAt(i - 1);
-                const next = label.charAt(i + 1);
-                if (!/^[lL]$/.test(prev) || !/^[lL]$/.test(next))
+                // deno-coverage-ignore
+                const prev = label.codePointAt(i - 1) ?? 0;
+                // deno-coverage-ignore
+                const next = label.codePointAt(i + 1) ?? 0;
+                if ((prev !== 108 && prev !== 76) || (next !== 108 && next !== 76))
                     return false;
             }
-            // --- KATAKANA MIDDLE DOT (U+30FB) ---
-            if (char === '\u30FB') {
-                // If label is a single character, it's invalid.
+            // KATAKANA MIDDLE DOT (U+30FB) | U+30FB is below U+FFFF so stride is always 1
+            if (cp === 0x30FB) {
                 if (label.length === 1)
                     return false;
                 if (i === 0) {
-                    // At beginning: check following character.
-                    const next = label.charAt(i + 1);
+                    // deno-coverage-ignore
+                    const next = label.codePointAt(i + 1) ?? 0;
                     if (!IsValidAdjacentForKatakanaMiddleDot(next))
                         return false;
                 }
                 else {
-                    // In the middle: check both adjacent characters.
-                    const prev = label.charAt(i - 1);
-                    const next = label.charAt(i + 1);
-                    if (!IsValidAdjacentForKatakanaMiddleDot(prev) || !IsValidAdjacentForKatakanaMiddleDot(next)) {
+                    // deno-coverage-ignore
+                    const prev = label.codePointAt(i - 1) ?? 0;
+                    // deno-coverage-ignore
+                    const next = label.codePointAt(i + 1) ?? 0;
+                    if (!IsValidAdjacentForKatakanaMiddleDot(prev) || !IsValidAdjacentForKatakanaMiddleDot(next))
                         return false;
-                    }
                 }
             }
-            // --- Greek Keraia (U+0375) ---
-            if (char === '\u0375') {
+            // Greek KERAIA (U+0375) | U+0375 is below U+FFFF so stride is always 1
+            if (cp === 0x0375) {
                 if (i === label.length - 1)
                     return false;
-                const next = label.charAt(i + 1);
-                if (!/[\u0370-\u03FF]/.test(next))
+                // deno-coverage-ignore
+                const next = label.codePointAt(i + 1) ?? 0;
+                if (next < 0x0370 || next > 0x03FF)
                     return false;
             }
-            // --- Hebrew GERESH (U+05F3) and GERSHAYIM (U+05F4) ---
-            if (char === '\u05F3' || char === '\u05F4') {
+            // Hebrew GERESH (U+05F3) and GERSHAYIM (U+05F4)
+            if (cp === 0x05F3 || cp === 0x05F4) {
                 if (i === 0)
                     return false;
-                const prev = label.charAt(i - 1);
-                if (!/[\u05D0-\u05EA]/.test(prev))
+                // deno-coverage-ignore
+                const prev = label.codePointAt(i - 1) ?? 0;
+                if (prev < 0x05D0 || prev > 0x05EA)
                     return false;
             }
-            // --- ZERO WIDTH JOINER (U+200D) ---
-            if (char === '\u200D') {
+            // ZERO WIDTH JOINER (U+200D)
+            if (cp === 0x200D) {
                 if (i === 0)
                     return false;
-                const prev = label.charAt(i - 1);
-                if (prev !== '\u094D')
+                // deno-coverage-ignore
+                const prev = label.codePointAt(i - 1) ?? 0;
+                if (prev !== 0x094D)
                     return false;
             }
-            // ZERO WIDTH NON-JOINER (U+200C) is allowed.
-        }
-        // --- Arabic-Indic digits vs. Extended Arabic-Indic digits ---
-        let hasArabicIndic = false;
-        let hasExtendedArabicIndic = false;
-        for (let i = 0; i < label.length; i++) {
-            const char = label.charAt(i);
-            if (/[\u0660-\u0669]/.test(char))
+            // Arabic-Indic digits
+            if (cp >= 0x0660 && cp <= 0x0669)
                 hasArabicIndic = true;
-            if (/[\u06F0-\u06F9]/.test(char))
+            // Extended Arabic-Indic digits
+            if (cp >= 0x06F0 && cp <= 0x06F9)
                 hasExtendedArabicIndic = true;
         }
         if (hasArabicIndic && hasExtendedArabicIndic)

package/build/format/ipv4.d.mts

@@ -1,6 +1,6 @@
+export declare function IsIPv4Internal(value: string, start: number, end: number): boolean;
 /**
  * Returns true if the value is a IPV4 address
- * @source ajv-formats
  * @specification http://tools.ietf.org/html/rfc2673#section-3.2
  */
 export declare function IsIPv4(value: string): boolean;

package/build/format/ipv4.mjs

@@ -1,9 +1,38 @@
-const IPv4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+// ------------------------------------------------------------------
+// Ranged Fast Path
+// ------------------------------------------------------------------
+/* Returns true if the value is a IPV4 address from index range offsets */
+export function IsIPv4Internal(value, start, end) {
+    let dots = 0;
+    let num = 0;
+    let digits = 0;
+    let leading = 0;
+    for (let i = start; i < end; i++) {
+        const ch = value.charCodeAt(i);
+        if (ch === 46) { // '.'
+            if (digits === 0 || num > 255 || (leading === 48 && digits > 1))
+                return false;
+            dots++;
+            num = 0;
+            digits = 0;
+            leading = 0;
+        }
+        else if (ch >= 48 && ch <= 57) { // '0'-'9'
+            if (digits === 0)
+                leading = ch;
+            num = num * 10 + (ch - 48);
+            digits++;
+        }
+        else {
+            return false;
+        }
+    }
+    return dots === 3 && digits > 0 && num <= 255 && !(leading === 48 && digits > 1);
+}
 /**
  * Returns true if the value is a IPV4 address
- * @source ajv-formats
  * @specification http://tools.ietf.org/html/rfc2673#section-3.2
  */
 export function IsIPv4(value) {
-    return IPv4.test(value);
+    return IsIPv4Internal(value, 0, value.length);
 }

package/build/format/ipv6.d.mts

@@ -1,6 +1,5 @@
 /**
- * Returns true if the value is a IPV6 address
- * @source ajv-formats
+ * Returns true if the value is an IPv6 address
  * @specification http://tools.ietf.org/html/rfc2373#section-2.2
  */
 export declare function IsIPv6(value: string): boolean;

package/build/format/ipv6.mjs

@@ -1,9 +1,67 @@
-const IPv6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
+import { IsIPv4Internal } from './ipv4.mjs';
+function InRange(ch) {
+    return (ch >= 48 && ch <= 57) || // 0-9
+        (ch >= 65 && ch <= 70) || // A-F
+        (ch >= 97 && ch <= 102); // a-f
+}
 /**
- * Returns true if the value is a IPV6 address
- * @source ajv-formats
+ * Returns true if the value is an IPv6 address
  * @specification http://tools.ietf.org/html/rfc2373#section-2.2
  */
 export function IsIPv6(value) {
-    return IPv6.test(value);
+    const length = value.length;
+    if (length === 0)
+        return false;
+    let groups = 0;
+    let compressed = false;
+    let i = 0;
+    // handle leading '::'
+    if (value.charCodeAt(0) === 58 && value.charCodeAt(1) === 58) {
+        if (length === 2)
+            return true; // '::' is valid
+        compressed = true;
+        i = 2;
+    }
+    while (i < length) {
+        // read hex digits
+        let digits = 0;
+        const start = i;
+        while (i < length && InRange(value.charCodeAt(i))) {
+            i++;
+            digits++;
+        }
+        if (digits === 0)
+            return false;
+        const next = value.charCodeAt(i);
+        // check for embedded IPv4 at the end
+        if (next === 46) { // '.'
+            if (!IsIPv4Internal(value, start, length))
+                return false;
+            groups += 2;
+            i = length;
+            break;
+        }
+        if (digits > 4)
+            return false;
+        groups++;
+        if (i === length)
+            break;
+        // expect ':' separator
+        if (next !== 58)
+            return false;
+        i++;
+        // check for '::' compression
+        if (value.charCodeAt(i) === 58) {
+            if (compressed)
+                return false; // only one '::' allowed
+            // check for ':::'
+            if (value.charCodeAt(i + 1) === 58)
+                return false;
+            compressed = true;
+            i++;
+            if (i === length)
+                break; // trailing '::'
+        }
+    }
+    return compressed ? groups <= 7 : groups === 8;
 }

package/build/format/uri.d.mts

@@ -1,6 +1,5 @@
 /**
- * Returns true if the value is a uri
- * @specification
- * @source ajv-formats
+ * Returns true if the value matches RFC 3986 URI syntax.
+ * @specification https://tools.ietf.org/html/rfc3986
  */
 export declare function IsUri(value: string): boolean;

package/build/format/uri.mjs

@@ -1,9 +1,135 @@
-const Uri = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i;
+function IsAlpha(ch) {
+    return (ch >= 97 && ch <= 122) || (ch >= 65 && ch <= 90); // a-z, A-Z
+}
+function IsAlphaNumeric(ch) {
+    return IsAlpha(ch) || (ch >= 48 && ch <= 57); // a-z, A-Z, 0-9
+}
+function IsHex(ch) {
+    return (ch >= 48 && ch <= 57) || // 0-9
+        (ch >= 65 && ch <= 70) || // A-F
+        (ch >= 97 && ch <= 102); // a-f
+}
+function IsSchemeChar(ch) {
+    return IsAlphaNumeric(ch) ||
+        ch === 43 || ch === 45 || ch === 46; // '+', '-', '.'
+}
+function IsUnreserved(ch) {
+    return IsAlphaNumeric(ch) ||
+        ch === 45 || ch === 46 || // '-', '.'
+        ch === 95 || ch === 126; // '_', '~'
+}
+function IsSubDelim(ch) {
+    return ch === 33 || ch === 36 || ch === 38 || ch === 39 ||
+        ch === 40 || ch === 41 || ch === 42 || ch === 43 ||
+        ch === 44 || ch === 59 || ch === 61; // ! $ & ' ( ) * + , ; =
+}
+function IsPchar(ch) {
+    return IsUnreserved(ch) || IsSubDelim(ch) || ch === 58 || ch === 64; // ':', '@'
+}
 /**
- * Returns true if the value is a uri
- * @specification
- * @source ajv-formats
+ * Returns true if the value matches RFC 3986 URI syntax.
+ * @specification https://tools.ietf.org/html/rfc3986
  */
 export function IsUri(value) {
-    return Uri.test(value);
+    const length = value.length;
+    if (length === 0)
+        return false;
+    // Scheme: must start with a letter
+    if (!IsAlpha(value.charCodeAt(0)))
+        return false;
+    // Scheme: continues until ':'
+    let i = 1;
+    while (i < length) {
+        const ch = value.charCodeAt(i);
+        if (ch === 58)
+            break; // ':'
+        if (!IsSchemeChar(ch))
+            return false;
+        i++;
+    }
+    // Ensure scheme is terminated by ':'
+    if (value.charCodeAt(i) !== 58)
+        return false;
+    i++;
+    // Authority: optional '//'
+    if (value.charCodeAt(i) === 47 && value.charCodeAt(i + 1) === 47) {
+        i += 2;
+        // Userinfo: check for '@' before path/query/fragment delimiters
+        const authorityStart = i;
+        let atPos = -1;
+        for (let j = i; j < length; j++) {
+            const ch = value.charCodeAt(j);
+            if (ch === 64) {
+                atPos = j;
+                break;
+            } // '@'
+            if (ch === 47 || ch === 63 || ch === 35)
+                break; // '/', '?', '#'
+        }
+        if (atPos !== -1) {
+            // Userinfo: validate allowed chars and percent-encoding
+            for (let j = authorityStart; j < atPos; j++) {
+                const ch = value.charCodeAt(j);
+                if (ch === 91 || ch === 93)
+                    return false; // No '[' or ']' in userinfo
+                if (ch === 37) { // '%' percent-encoding
+                    if (j + 2 >= atPos || !IsHex(value.charCodeAt(j + 1)) || !IsHex(value.charCodeAt(j + 2)))
+                        return false;
+                    j += 2;
+                }
+                else if (!IsUnreserved(ch) && !IsSubDelim(ch) && ch !== 58)
+                    return false;
+            }
+            i = atPos + 1;
+        }
+        // Host: IP-literal [addr] or reg-name
+        if (value.charCodeAt(i) === 91) { // '['
+            i++;
+            while (i < length && value.charCodeAt(i) !== 93)
+                i++;
+            if (value.charCodeAt(i) !== 93)
+                return false; // ']'
+            i++;
+        }
+        else {
+            // Host: validate ASCII; skip validation for non-ASCII (Unicode hosts)
+            while (i < length) {
+                const ch = value.charCodeAt(i);
+                if (ch === 47 || ch === 63 || ch === 35 || ch === 58)
+                    break;
+                if (ch < 128 && !IsUnreserved(ch) && !IsSubDelim(ch))
+                    return false;
+                i++;
+            }
+        }
+        // Port: optional digits after ':'
+        if (value.charCodeAt(i) === 58) { // ':'
+            i++;
+            while (i < length) {
+                const ch = value.charCodeAt(i);
+                if (ch === 47 || ch === 63 || ch === 35)
+                    break;
+                if (ch < 48 || ch > 57)
+                    return false; // 0-9
+                i++;
+            }
+        }
+    }
+    // Path, Query, and Fragment
+    while (i < length) {
+        const ch = value.charCodeAt(i);
+        if (ch === 37) { // '%' percent-encoding
+            if (i + 2 >= length || !IsHex(value.charCodeAt(i + 1)) || !IsHex(value.charCodeAt(i + 2)))
+                return false;
+            i += 2;
+        }
+        else if (ch > 127) {
+            return false; // URI is ASCII-only
+        }
+        else if (!(IsPchar(ch) || ch === 47 || ch === 63 || ch === 35)) {
+            return false; // '/', '?', '#'
+        }
+        i++;
+    }
+    return true;
 }

package/build/type/action/mapped.d.mts

@@ -3,10 +3,10 @@ import { type TIdentifier } from '../types/identifier.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TInstantiate } from '../engine/instantiate.mjs';
 /** Creates a deferred Mapped action. */
-export type TMappedDeferred<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = (TDeferred<'Mapped', [Identifier, Key, As, Property]>);
+export type TMappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TDeferred<'Mapped', [Identifier, Type, As, Property]>);
 /** Creates a deferred Mapped action. */
-export declare function MappedDeferred<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, key: Key, as: As, property: Property, options?: TSchemaOptions): TMappedDeferred<Identifier, Key, As, Property>;
+export declare function MappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMappedDeferred<Identifier, Type, As, Property>;
 /** Applies a Mapped action using the given types. */
-export type TMapped<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = (TInstantiate<{}, TMappedDeferred<Identifier, Key, As, Property>>);
+export type TMapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TInstantiate<{}, TMappedDeferred<Identifier, Type, As, Property>>);
 /** Applies a Mapped action using the given types. */
-export declare function Mapped<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, key: Key, as: As, property: Property, options?: TSchemaOptions): TMapped<Identifier, Key, As, Property>;
+export declare function Mapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMapped<Identifier, Type, As, Property>;

package/build/type/action/mapped.mjs

@@ -2,10 +2,10 @@
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';
 /** Creates a deferred Mapped action. */
-export function MappedDeferred(identifier, key, as, property, options = {}) {
-    return Deferred('Mapped', [identifier, key, as, property], options);
+export function MappedDeferred(identifier, type, as, property, options = {}) {
+    return Deferred('Mapped', [identifier, type, as, property], options);
 }
 /** Applies a Mapped action using the given types. */
-export function Mapped(identifier, key, as, property, options = {}) {
-    return Instantiate({}, MappedDeferred(identifier, key, as, property, options));
+export function Mapped(identifier, type, as, property, options = {}) {
+    return Instantiate({}, MappedDeferred(identifier, type, as, property, options));
 }

package/build/type/engine/call/distribute-arguments.d.mts

@@ -3,13 +3,13 @@ import { type TUnion } from '../../types/union.mjs';
 import { type TDeferred } from '../../types/deferred.mjs';
 import { type TRef } from '../../types/ref.mjs';
 import { type TParameter } from '../../types/parameter.mjs';
-type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef<infer Name extends string> ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Name]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Result);
+type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef<infer Name extends string> ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Name]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Expression extends TDeferred<'Mapped', [infer _Identifier extends TSchema, infer Type extends TSchema, infer _As extends TSchema, infer _Property extends TSchema]> ? (Type extends TDeferred<'KeyOf', [infer Ref extends TRef]> ? [...Result, Ref['$ref']] : Result) : Result);
 type TBuildDistributionArray<Parameters extends TParameter[], Names extends string[], Result extends boolean[] = []> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? Left['name'] extends Names[number] ? TBuildDistributionArray<Right, Names, [...Result, true]> : TBuildDistributionArray<Right, Names, [...Result, false]> : Result);
 type TZipDistributionArray<Arguments extends TSchema[], DistributionArray extends boolean[], Result extends [boolean, TSchema][] = []> = (Arguments extends [infer ArgumentLeft extends TSchema, ...infer ArgumentRight extends TSchema[]] ? DistributionArray extends [infer BooleanLeft extends boolean, ...infer BooleanRight extends boolean[]] ? TZipDistributionArray<ArgumentRight, BooleanRight, [...Result, [BooleanLeft, ArgumentLeft]]> : Result : Result);
 type TExpand<Type extends TSchema> = (Type extends TUnion<infer Types extends TSchema[]> ? [...Types] : [Type]);
 type TAppend<Current extends TSchema[][], Type extends TSchema, Result extends TSchema[][] = []> = (Current extends [infer Left extends TSchema[], ...infer Right extends TSchema[][]] ? TAppend<Right, Type, [...Result, [...Left, Type]]> : Result);
 type TCross<Current extends TSchema[][], Variants extends TSchema[], Result extends TSchema[][] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCross<Current, Right, [...Result, ...TAppend<Current, Left>]> : Result);
 type TDistribute<ZippedArguments extends [boolean, TSchema][], Result extends TSchema[][] = [[]]> = (ZippedArguments extends [infer Left extends [boolean, TSchema], ...infer Right extends [boolean, TSchema][]] ? Left[0] extends true ? TDistribute<Right, TCross<Result, TExpand<Left[1]>>> : TDistribute<Right, TCross<Result, [Left[1]]>> : Result);
-export type TDistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema, DistributionNames extends string[] = TCollectDistributionNames<Expression>, DistributionArray extends boolean[] = TBuildDistributionArray<Parameters, DistributionNames>, ZippedArguments extends [boolean, TSchema][] = TZipDistributionArray<Arguments, DistributionArray>, Result extends TSchema[][] = Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<ZippedArguments> : [Arguments]> = Result;
+export type TDistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema, DistributionNames extends string[] = TCollectDistributionNames<Expression>, DistributionArray extends boolean[] = TBuildDistributionArray<Parameters, DistributionNames>, ZippedArguments extends [boolean, TSchema][] = TZipDistributionArray<Arguments, DistributionArray>, Result extends TSchema[][] = (Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<ZippedArguments> : Expression extends TDeferred<'Mapped', TSchema[]> ? TDistribute<ZippedArguments> : [Arguments])> = Result;
 export declare function DistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema>(parameters: [...Parameters], arguments_: [...Arguments], expression: Expression): TDistributeArguments<Parameters, Arguments, Expression>;
 export {};

package/build/type/engine/call/distribute-arguments.mjs

@@ -4,11 +4,16 @@ import { IsUnion } from '../../types/union.mjs';
 import { IsDeferred } from '../../types/deferred.mjs';
 import { IsRef } from '../../types/ref.mjs';
 function CollectDistributionNames(expression, result = []) {
-    return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+    return (
+    // Conditional
+    IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
         ? IsRef(expression.parameters[0])
             ? CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], [...result, expression.parameters[0].$ref]))
             : CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], result))
-        : result);
+        // Mapped
+        : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')
+            ? (IsDeferred(expression.parameters[1]) && Guard.IsEqual(expression.parameters[1].action, 'KeyOf') && IsRef(expression.parameters[1].parameters[0]) ? [...result, expression.parameters[1].parameters[0]['$ref']] :
+                result) : result);
 }
 function BuildDistributionArray(parameters, names) {
     return parameters.reduce((result, left) => [...result, names.includes(left.name)], []);
@@ -48,5 +53,7 @@ export function DistributeArguments(parameters, arguments_, expression) {
     const zippedArguments = ZipDistributionArray(arguments_, distributionArray);
     return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
         ? Distribute(zippedArguments)
-        : [arguments_]);
+        : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')
+            ? Distribute(zippedArguments)
+            : [arguments_]);
 }

package/build/type/engine/call/instantiate.mjs

@@ -31,7 +31,7 @@ function CallDistributed(context, state, target, parameters, expression, distrib
 function CallImmediate(context, state, target, parameters, expression, arguments_) {
     const distributedArguments = DistributeArguments(parameters, arguments_, expression);
     const returnTypes = CallDistributed(context, state, target, parameters, expression, distributedArguments);
-    const result = returnTypes.length === 1 ? returnTypes[0] : EvaluateUnion(returnTypes);
+    const result = Guard.IsEqual(returnTypes.length, 1) ? returnTypes[0] : EvaluateUnion(returnTypes);
     return result;
 }
 export function CallInstantiate(context, state, target, arguments_) {

package/build/type/engine/mapped/instantiate.d.mts

@@ -4,25 +4,22 @@ import { type TLiteral } from '../../types/literal.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TIdentifier } from '../../types/identifier.mjs';
-import { type TMappedKeys } from './mapped-keys.mjs';
 import { type TTemplateLiteral } from '../../types/template-literal.mjs';
 import { type TMappedDeferred } from '../../action/mapped.mjs';
 import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TInstantiateKeyAs<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, ContextWithKey extends TProperties = Memory.TAssign<Context, {
-    [_ in Identifier['name']]: Key;
-}>, InstantiatedKeyAs extends TSchema = TInstantiateType<ContextWithKey, State, As>, Result extends TSchema = InstantiatedKeyAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedKeyAs> = Result;
-type TInstantiateProperty<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, Property extends TSchema, ContextWithKey extends TProperties = Memory.TAssign<Context, {
-    [_ in Identifier['name']]: Key;
-}>, InstantiatedProperty extends TSchema = TInstantiateType<ContextWithKey, State, Property>> = InstantiatedProperty;
-type TMappedProperty<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedProperty extends TSchema = TInstantiateProperty<Context, State, Identifier, Key, Property>, InstantiatedKeyAs extends TSchema = TInstantiateKeyAs<Context, State, Identifier, Key, As>, Result extends TProperties = (InstantiatedKeyAs extends TLiteral<string | number> ? {
-    [_ in InstantiatedKeyAs['const']]: InstantiatedProperty;
-} : {})> = Result;
-type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Keys extends TSchema[], As extends TSchema, Type extends TSchema, Result extends TProperties = {}> = (Keys extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Type, Result & TMappedProperty<Context, State, Identifier, Left, As, Type>> : Result);
-type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, Keys extends TSchema[] = TMappedKeys<Key>, Mapped extends TProperties = TMappedProperties<Context, State, Identifier, Keys, As, Property>, Result extends TSchema = TObject<{
-    [Key in keyof Mapped]: Mapped[Key];
-}>> = Result;
-type TMappedImmediate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedKey extends TSchema = TInstantiateType<Context, State, Key>> = TMappedAction<Context, State, Identifier, InstantiatedKey, As, Property>;
-export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = TCanInstantiate<Context, [Key]> extends true ? TMappedImmediate<Context, State, Identifier, Key, As, Property> : TMappedDeferred<Identifier, Key, As, Property>;
-export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, key: Key, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Key, As, Property>;
+import { type TMappedVariants } from './mapped-variants.mjs';
+import { type TEvaluateIntersect } from '../evaluate/index.mjs';
+type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedAs> = Result;
+type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
+    [_ in Identifier['name']]: Variant;
+}>, InstantiatedAs extends TSchema = TInstantiateType<VariantContext, State, As>, CanonicalAs extends TSchema = TCanonicalAs<InstantiatedAs>, InstantiatedProperty extends TSchema = TInstantiateType<VariantContext, State, Property>, Result extends TProperties = CanonicalAs extends TLiteral<string | number> ? {
+    [_ in CanonicalAs['const']]: InstantiatedProperty;
+} : {}> = Result;
+type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variants extends TSchema[], As extends TSchema, Property extends TSchema, Result extends TProperties[] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Property, [...Result, TMappedVariant<Context, State, Identifier, Left, As, Property>]> : Result);
+type TReduceProperties<Properties extends TProperties[], Result extends TSchema[] = []> = (Properties extends [infer Left extends TProperties, ...infer Right extends TProperties[]] ? TReduceProperties<Right, [...Result, TObject<Left>]> : Result);
+type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Variants extends TSchema[] = TMappedVariants<Type>, MappedProperties extends TProperties[] = TMappedProperties<Context, State, Identifier, Variants, As, Property>, MappedObjects extends TSchema[] = TReduceProperties<MappedProperties>, Result extends TSchema = TEvaluateIntersect<MappedObjects>> = Result;
+type TMappedImmediate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstantiatedType, As, Property>;
+export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TMappedImmediate<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>;
+export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Type, As, Property>;
 export {};

package/build/type/engine/mapped/instantiate.mjs

@@ -2,46 +2,48 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
 import { Object } from '../../types/object.mjs';
-import { MappedKeys } from './mapped-keys.mjs';
 import { IsTemplateLiteral } from '../../types/template-literal.mjs';
 import { MappedDeferred } from '../../action/mapped.mjs';
 import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function InstantiateKeyAs(context, state, identifier, key, as) {
-    const contextWithKey = Memory.Assign(context, { [identifier['name']]: key });
-    const instantiatedKeyAs = InstantiateType(contextWithKey, state, as);
-    const result = IsTemplateLiteral(instantiatedKeyAs) ? TemplateLiteralDecode(instantiatedKeyAs.pattern) : instantiatedKeyAs;
+import { MappedVariants } from './mapped-variants.mjs';
+import { EvaluateIntersect } from '../evaluate/index.mjs';
+function CanonicalAs(instantiatedAs) {
+    const result = IsTemplateLiteral(instantiatedAs) ? TemplateLiteralDecode(instantiatedAs.pattern) : instantiatedAs;
     return result;
 }
-function InstantiateProperty(context, state, identifier, key, property) {
-    const contextWithKey = Memory.Assign(context, { [identifier['name']]: key });
-    const instantiatedProperty = InstantiateType(contextWithKey, state, property);
-    return instantiatedProperty;
-}
-function MappedProperty(context, state, identifier, key, as, property) {
-    const instantiatedProperty = InstantiateProperty(context, state, identifier, key, property);
-    const instantiatedKeyAs = InstantiateKeyAs(context, state, identifier, key, as);
-    return (IsLiteralString(instantiatedKeyAs) || IsLiteralNumber(instantiatedKeyAs)
-        ? { [instantiatedKeyAs.const]: instantiatedProperty }
+function MappedVariant(context, state, identifier, variant, as, property) {
+    const variantContext = Memory.Assign(context, { [identifier['name']]: variant });
+    const instantiatedAs = InstantiateType(variantContext, state, as);
+    const canonicalAs = CanonicalAs(instantiatedAs);
+    const instantiatedProperty = InstantiateType(variantContext, state, property);
+    return (IsLiteralNumber(canonicalAs) || IsLiteralString(canonicalAs)
+        ? { [canonicalAs.const]: instantiatedProperty }
         : {});
 }
-function MappedProperties(context, state, identifier, keys, as, type) {
-    return keys.reduce((result, left) => {
-        return { ...result, ...MappedProperty(context, state, identifier, left, as, type) };
-    }, {});
+function MappedProperties(context, state, identifier, variants, as, property) {
+    return variants.reduce((result, left) => {
+        return [...result, MappedVariant(context, state, identifier, left, as, property)];
+    }, []);
+}
+function MappedObjects(properties) {
+    return properties.reduce((result, left) => {
+        return [...result, Object(left)];
+    }, []);
 }
-function MappedAction(context, state, identifier, key, as, type) {
-    const keys = MappedKeys(key);
-    const mapped = MappedProperties(context, state, identifier, keys, as, type);
-    const result = Object(mapped);
+function MappedAction(context, state, identifier, type, as, property) {
+    const variants = MappedVariants(type);
+    const mappedProperties = MappedProperties(context, state, identifier, variants, as, property);
+    const mappedObjects = MappedObjects(mappedProperties);
+    const result = EvaluateIntersect(mappedObjects);
     return result;
 }
-function MappedImmediate(context, state, identifier, key, as, property, options) {
-    const instantiatedKey = InstantiateType(context, state, key);
-    return Memory.Update(MappedAction(context, state, identifier, instantiatedKey, as, property), {}, options);
+function MappedImmediate(context, state, identifier, type, as, property, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(MappedAction(context, state, identifier, instantiatedType, as, property), {}, options);
 }
-export function MappedInstantiate(context, state, identifier, key, as, property, options) {
-    return (CanInstantiate(context, [key])
-        ? MappedImmediate(context, state, identifier, key, as, property, options)
-        : MappedDeferred(identifier, key, as, property, options));
+export function MappedInstantiate(context, state, identifier, type, as, property, options) {
+    return (CanInstantiate(context, [type])
+        ? MappedImmediate(context, state, identifier, type, as, property, options)
+        : MappedDeferred(identifier, type, as, property, options));
 }

package/build/type/engine/mapped/{mapped-keys.d.mts → mapped-variants.d.mts}

@@ -5,10 +5,11 @@ import { type TTemplateLiteral } from '../../types/template-literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TEnumValuesToVariants } from '../enum/index.mjs';
 import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
-type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TFromType<Decoded>> = Result;
+type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema[] = TFromType<Decoded>> = Result;
 type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
 type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromUnion<TEnumValuesToVariants<Values>> : Type extends TLiteral<string | number> ? [Type] : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+    Type
 ])> = Result;
-export type TMappedKeys<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;
-export declare function MappedKeys<Type extends TSchema>(type: Type): TMappedKeys<Type>;
+export type TMappedVariants<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;
+export declare function MappedVariants<Type extends TSchema>(type: Type): TMappedVariants<Type>;
 export {};

package/build/type/engine/mapped/{mapped-keys.mjs → mapped-variants.mjs}

@@ -20,10 +20,10 @@ function FromType(type) {
         IsLiteralString(type) || IsLiteralNumber(type) ? [type] :
             IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
                 IsUnion(type) ? FromUnion(type.anyOf) :
-                    []);
+                    [type]);
     return result;
 }
-export function MappedKeys(type) {
+export function MappedVariants(type) {
     const result = FromType(type);
     return result;
 }

package/build/type/script/mapping.d.mts

@@ -274,7 +274,7 @@ export type TMappedOptionalMapping<Input extends [unknown, unknown] | [unknown]
 export declare function MappedOptionalMapping(input: [unknown, unknown] | [unknown] | []): unknown;
 export type TMappedAsMapping<Input extends [unknown, unknown] | []> = (Input extends ['as', infer Type extends T.TSchema] ? [Type] : []);
 export declare function MappedAsMapping(input: [unknown, unknown] | []): unknown;
-export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Union extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Type extends T.TSchema, null, '}'] ? (As extends [infer As extends T.TSchema] ? C.TMappedDeferred<T.TIdentifier<Key>, Union, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Type>>> : C.TMappedDeferred<T.TIdentifier<Key>, Union, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Type>>>) : never);
+export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Type extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Property extends T.TSchema, null, '}'] ? (As extends [infer As extends T.TSchema] ? C.TMappedDeferred<T.TIdentifier<Key>, Type, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>> : C.TMappedDeferred<T.TIdentifier<Key>, Type, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>>) : never);
 export declare function MappedMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TReferenceMapping<Input extends string, Result extends T.TSchema = T.TRef<Input>> = Result;
 export declare function ReferenceMapping(input: string): unknown;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "keywords": [
     "typescript",
     "jsonschema"