@depup/typebox 1.3.11-depup.0 → 1.3.14-depup.0

package/build/type/engine/evaluate/distribute.mjs

@@ -2,36 +2,24 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { IsObject } from '../../types/object.mjs';
-import { IsTuple } from '../../types/tuple.mjs';
-import { Composite } from './composite.mjs';
 import { Narrow } from './narrow.mjs';
-import { EvaluateType } from './evaluate.mjs';
 import { EvaluateIntersect } from './evaluate.mjs';
-function IsObjectLike(type) {
-    return IsObject(type) || IsTuple(type);
-}
-function IsUnionOperand(left, right) {
-    const isUnionLeft = IsUnion(left);
-    const isUnionRight = IsUnion(right);
-    const result = isUnionLeft || isUnionRight;
+import { EvaluateType } from './evaluate.mjs';
+function ShouldEvaluate(left, right) {
+    const result = IsUnion(left) || IsUnion(right);
     return result;
 }
 function DistributeOperation(left, right) {
     const evaluatedLeft = EvaluateType(left);
     const evaluatedRight = EvaluateType(right);
-    const isUnionOperand = IsUnionOperand(evaluatedLeft, evaluatedRight);
-    const isObjectLeft = IsObjectLike(evaluatedLeft);
-    const IsObjectRight = IsObjectLike(evaluatedRight);
-    const result = (isUnionOperand ? EvaluateIntersect([evaluatedLeft, evaluatedRight]) :
-        isObjectLeft && IsObjectRight ? Composite(evaluatedLeft, evaluatedRight) :
-            isObjectLeft && !IsObjectRight ? evaluatedLeft :
-                !isObjectLeft && IsObjectRight ? evaluatedRight :
-                    Narrow(evaluatedLeft, evaluatedRight));
+    const shouldEvaluate = ShouldEvaluate(evaluatedLeft, evaluatedRight);
+    const result = shouldEvaluate
+        ? EvaluateIntersect([evaluatedLeft, evaluatedRight])
+        : Narrow(evaluatedLeft, evaluatedRight);
     return result;
 }
 function DistributeType(type, types, result = []) {
-    return Guard.ShiftLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(type, left)]), () => Guard.IsEqual(result.length, 0)
+    return Guard.ShiftLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(left, type)]), () => Guard.IsEqual(result.length, 0)
         ? [type]
         : result);
 }

package/build/type/engine/evaluate/evaluate.d.mts

@@ -1,8 +1,8 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TDependent } from '../../types/dependent.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
-import { type TLiteral } from '../../types/literal.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
@@ -10,11 +10,11 @@ import { type TDistribute } from './distribute.mjs';
 import { type TBroaden } from './broaden.mjs';
 import { type TExcludeOperation } from '../exclude/operation.mjs';
 import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
-export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Intersect extends TSchema = TIntersect<[If, Then]>, Excluded extends TSchema = TExcludeOperation<Else, If>, Result extends TSchema = TEvaluateUnion<[Intersect, Excluded]>> = Result;
+export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Intersected extends TSchema = TEvaluateIntersect<[If, Then]>, Excluded extends TSchema = TExcludeOperation<Else, If>, Result extends TSchema = TEvaluateUnion<[Intersected, Excluded]>> = Result;
 export declare function EvaluateDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TEvaluateDependent<If, Then, Else>;
 export type TEvaluateEnum<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEvaluateEnum<Right, [...Result, TLiteral<Left>]> : TEvaluateUnion<Result>);
-export declare function EvaluateEnum<Values extends TEnumValue[]>(values: [...Values]): TEvaluateEnum<Values>;
-export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Broadend extends TSchema[] = TBroaden<Distribution>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = Result;
+export declare function EvaluateEnum<Values extends TEnumValue[]>(values: [...Values], result?: TSchema[]): TEvaluateEnum<Values>;
+export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Broadend extends TSchema[] = TBroaden<Distribution>, Result extends TSchema = TEvaluateUnion<Broadend>> = Result;
 export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
 export type TEvaluateTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TEvaluateType<Evaluated>> = Result;
 export declare function EvaluateTemplateLiteral<Pattern extends string>(pattern: Pattern): TEvaluateTemplateLiteral<Pattern>;

package/build/type/engine/evaluate/evaluate.mjs

@@ -2,29 +2,31 @@
 import { Guard } from '../../../guard/index.mjs';
 import { IsDependent } from '../../types/dependent.mjs';
 import { IsEnum } from '../../types/enum.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
 import { Literal } from '../../types/literal.mjs';
-import { IsIntersect, Intersect } from '../../types/intersect.mjs';
 import { Never } from '../../types/never.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 import { Distribute } from './distribute.mjs';
 import { Broaden } from './broaden.mjs';
 import { ExcludeOperation } from '../exclude/operation.mjs';
 import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
 export function EvaluateDependent(if_, then_, else_) {
-    const intersect = Intersect([if_, then_]);
+    const intersected = EvaluateIntersect([if_, then_]);
     const excluded = ExcludeOperation(else_, if_);
-    const result = EvaluateUnion([intersect, excluded]);
+    const result = EvaluateUnion([intersected, excluded]);
     return result;
 }
-export function EvaluateEnum(values) {
-    const result = values.map(value => Literal(value));
-    return EvaluateUnion(result);
+export function EvaluateEnum(values, result = []) {
+    return Guard.ShiftLeft(values, (left, right) => EvaluateEnum(right, [...result, Literal(left)]), () => EvaluateUnion(result));
 }
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
     const broadend = Broaden(distribution);
-    const result = EvaluateUnionFast(broadend);
+    const result = EvaluateUnion(broadend);
     return result;
 }
 export function EvaluateTemplateLiteral(pattern) {
@@ -38,12 +40,13 @@ export function EvaluateUnion(types) {
     return result;
 }
 export function EvaluateType(type) {
-    return (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
+    const result = (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
         IsEnum(type) ? EvaluateEnum(type.enum) :
             IsIntersect(type) ? EvaluateIntersect(type.allOf) :
                 IsTemplateLiteral(type) ? EvaluateTemplateLiteral(type.pattern) :
                     IsUnion(type) ? EvaluateUnion(type.anyOf) :
                         type);
+    return result;
 }
 export function EvaluateUnionFast(types) {
     const result = (Guard.IsEqual(types.length, 1) ? types[0] :

package/build/type/engine/evaluate/flatten.d.mts

@@ -2,5 +2,5 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TUnion } from '../../types/union.mjs';
 type TFlattenType<Type extends TSchema, Result extends TSchema[] = Type extends TUnion<infer Types extends TSchema[]> ? TFlatten<Types> : [Type]> = Result;
 export type TFlatten<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFlatten<Right, [...Result, ...TFlattenType<Left>]> : Result);
-export declare function Flatten<Types extends TSchema[]>(types: [...Types]): TFlatten<Types>;
+export declare function Flatten<Types extends TSchema[]>(types: [...Types], result?: TSchema[]): TFlatten<Types>;
 export {};

package/build/type/engine/evaluate/flatten.mjs

@@ -1,11 +1,10 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 function FlattenType(type) {
     const result = IsUnion(type) ? Flatten(type.anyOf) : [type];
     return result;
 }
-export function Flatten(types) {
-    return types.reduce((result, type) => {
-        return [...result, ...FlattenType(type)];
-    }, []);
+export function Flatten(types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Flatten(right, [...result, ...FlattenType(left)]), () => result);
 }

package/build/type/engine/evaluate/narrow.d.mts

@@ -1,5 +1,20 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
 import { type TNever } from '../../types/never.mjs';
-import { type TCompare, type TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
-export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
+import { type TUnknown } from '../../types/unknown.mjs';
+import { type TCompare, type TCompareResult, CompareResultLeftInside, CompareResultRightInside, CompareResultEqual } from './compare.mjs';
+import { type TComposite, type TCanComposite } from './composite.mjs';
+type TNarrowCompareRule<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof CompareResultLeftInside ? Left : Result extends typeof CompareResultRightInside ? Right : Result extends typeof CompareResultEqual ? Right : TNever);
+type TNarrowCompositeRule<Left extends TSchema, Right extends TSchema, CanCompositeLeft extends boolean = TCanComposite<Left>, CanCompositeRight extends boolean = TCanComposite<Right>> = ([
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [true, true] ? TComposite<Left, Right> : [
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [true, false] ? Left : [
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [false, true] ? Right : TNarrowCompareRule<Left, Right>);
+export type TNarrow<Left extends TSchema, Right extends TSchema> = (Left extends TNever ? TNever : Left extends TAny ? TAny : Left extends TUnknown ? Right : Right extends TNever ? TNever : Right extends TAny ? TAny : Right extends TUnknown ? Left : TNarrowCompositeRule<Left, Right>);
 export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;
+export {};

package/build/type/engine/evaluate/narrow.mjs

@@ -1,11 +1,31 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Never } from '../../types/never.mjs';
-import { Compare, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
-export function Narrow(left, right) {
+import { IsAny } from '../../types/any.mjs';
+import { Never, IsNever } from '../../types/never.mjs';
+import { IsUnknown } from '../../types/unknown.mjs';
+import { Compare, CompareResultLeftInside, CompareResultRightInside, CompareResultEqual } from './compare.mjs';
+import { Composite, CanComposite } from './composite.mjs';
+function NarrowCompareRule(left, right) {
     const result = Compare(left, right);
-    return (Guard.IsEqual(result, ResultLeftInside) ? left :
-        Guard.IsEqual(result, ResultRightInside) ? right :
-            Guard.IsEqual(result, ResultEqual) ? right :
+    return (Guard.IsEqual(result, CompareResultLeftInside) ? left :
+        Guard.IsEqual(result, CompareResultRightInside) ? right :
+            Guard.IsEqual(result, CompareResultEqual) ? right :
                 Never());
 }
+function NarrowCompositeRule(left, right) {
+    const canCompositeLeft = CanComposite(left);
+    const canCompositeRight = CanComposite(right);
+    return (canCompositeLeft && canCompositeRight ? Composite(left, right) :
+        canCompositeLeft && !canCompositeRight ? left :
+            !canCompositeLeft && canCompositeRight ? right :
+                NarrowCompareRule(left, right));
+}
+export function Narrow(left, right) {
+    return (IsNever(left) ? left :
+        IsAny(left) ? left :
+            IsUnknown(left) ? right :
+                IsNever(right) ? right :
+                    IsAny(right) ? right :
+                        IsUnknown(right) ? left :
+                            NarrowCompositeRule(left, right));
+}

package/build/type/engine/exclude/operation.mjs

@@ -1,5 +1,6 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { EvaluateType } from '../evaluate/evaluate.mjs';
@@ -9,10 +10,8 @@ function ExcludeType(left, right) {
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
     return result;
 }
-function ExcludeUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExcludeType(head, right)];
-    }, []);
+function ExcludeUnion(left, right, result = []) {
+    return Guard.ShiftLeft(left, (head, tail) => ExcludeUnion(tail, right, [...result, ...ExcludeType(head, right)]), () => result);
 }
 export function ExcludeOperation(left, right) {
     const evaluated = EvaluateType(left);

package/build/type/engine/extract/operation.d.mts

@@ -4,7 +4,7 @@ import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
 import { type TEvaluateType } from '../evaluate/evaluate.mjs';
 import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
 type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [Left] : []> = Result;
-type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+type TExtractUnion<Left extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
 export type TExtractOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExtractUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
 export declare function ExtractOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExtractOperation<Left, Right>;
 export {};

package/build/type/engine/extract/operation.mjs

@@ -1,5 +1,6 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { EvaluateType } from '../evaluate/evaluate.mjs';
@@ -9,10 +10,8 @@ function ExtractType(left, right) {
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
     return result;
 }
-function ExtractUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExtractType(head, right)];
-    }, []);
+function ExtractUnion(left, right, result = []) {
+    return Guard.ShiftLeft(left, (head, tail) => ExtractUnion(tail, right, [...result, ...ExtractType(head, right)]), () => result);
 }
 export function ExtractOperation(left, right) {
     const evaluated = EvaluateType(left);

package/build/type/engine/priority/priority.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
-import { type TCompare, type TCompareResult } from '../evaluate/compare.mjs';
-type TComparer<Left extends TSchema, Right extends TSchema, CompareResult extends TCompareResult = TCompare<Left, Right>, Result extends 0 | 1 = (CompareResult extends 'right-inside' ? 1 : CompareResult extends 'disjoint' ? 1 : 0)> = Result;
+import { type TCompare, type TCompareResult, CompareResultRightInside, CompareResultDisjoint } from '../evaluate/compare.mjs';
+type TComparer<Left extends TSchema, Right extends TSchema, CompareResult extends TCompareResult = TCompare<Left, Right>, Result extends 0 | 1 = (CompareResult extends typeof CompareResultRightInside ? 1 : CompareResult extends typeof CompareResultDisjoint ? 1 : 0)> = Result;
 type TInsert<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TComparer<Type, Left> extends 1 ? TInsert<Type, Right, [...Result, Left]> : [...Result, Type, ...Types] : [...Result, Type]);
 type TSort<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TSort<Right, TInsert<Left, Result>> : Result);
 /**

package/build/type/engine/priority/priority.mjs

@@ -1,12 +1,11 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Compare } from '../evaluate/compare.mjs';
+import { Compare, CompareResultRightInside, CompareResultDisjoint } from '../evaluate/compare.mjs';
 function Comparer(left, right) {
     const compareResult = Compare(left, right);
-    const result = (Guard.IsEqual(compareResult, 'right-inside') ? 1 :
-        Guard.IsEqual(compareResult, 'disjoint') ? 1 :
+    return (Guard.IsEqual(compareResult, CompareResultRightInside) ? 1 :
+        Guard.IsEqual(compareResult, CompareResultDisjoint) ? 1 :
             0);
-    return result;
 }
 function Insert(type, types, result = []) {
     return Guard.ShiftLeft(types, (left, right) => Guard.IsEqual(Comparer(type, left), 1)

package/build/type/script/parser.mjs

@@ -1,6 +1,13 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
-// auto-generated: design/syntax/syntax.ts
+// ------------------------------------------------------------------
+//
+// This module was auto-generated by TypeBox's parser compiler
+// infrastructure (ParseBox). The source grammar is located at:
+//
+// Source: ./design/syntax/syntax.ts
+//
+// ------------------------------------------------------------------
 import * as S from './mapping.mjs';
 import * as Token from './token/index.mjs';
 const If = (result, left, right = () => []) => result.length === 2 ? left(result) : right();

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-08-09T00:36:55.751Z",
+  "timestamp": "2026-08-16T00:27:32.093Z",
   "totalUpdated": 0
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@depup/typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript (with updated dependencies)",
-  "version": "1.3.11-depup.0",
+  "version": "1.3.14-depup.0",
   "keywords": [
     "typebox",
     "depup",
@@ -94,8 +94,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "typebox",
-    "originalVersion": "1.3.11",
-    "processedAt": "2026-08-09T00:36:56.456Z",
+    "originalVersion": "1.3.14",
+    "processedAt": "2026-08-16T00:27:33.089Z",
     "smokeTest": "passed"
   }
 }

package/readme.md

@@ -113,11 +113,11 @@ type User = Type.Static<typeof User>              // type User = {
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFkBDGAC0YgBMBXAG1WoBjCADsAzvGZs4AXkREAdAGVBUYGBgAKAAaU4cQmjgA1VIJjQALLLgBvOGQBccEdxDFUUADRwkz1+6ePgBe-m4e3nAA7mGBUHAAvnoGRCZmFlAAzDb2Ti7hQb6xESHFnonJhuim5tAATDkOZZF++XEV2gCU1HRwAOJQTGCswIJiHDz8QqIS-YPDo+NyyGjKqupaUqw+uvpVabCoZDnJ+pBiwDDAos41GZZepy7QIEy8t+nQmY-6+twAbh9alA6skkntUn1UDhUDAoEgTr84P9PFdBKgxB9DmQANoAXR+v2AIk4owxzXxYMqqSknmAb0RvyY7mAqBEMCB90J+lJGAw3DEqE5Vm5cDEaEEfCYUGFUEsVIhRgYGPYclsTwA5tCQLD4c4oTC4UhRa8YHS3s5aWo3lSutR9sqxKr5KslDAWKMADxVCAYOZDEZjHF4R2sPB4gB8+l6DpVjKRCcTSeTKZTvX0WsNerscAUecSotTReLJfTcFN5veObzCgqJfrDeTvQSQA) | [Example 2](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFkBDGAC0YgBMBXAG1WoBjCADsAzvABqqQTGgAWOAF5ERAHQB5YgCsZMABQBvOGQBcqtGoBy3EMVRR9ASgA0cJOeSWbdh87cAXp7qPvaOrnAA7sHetmHOcAC+TpTC4lJ60ADMyhaomjp6RiYx+aF+ER551nEVgaU1vuFJKWkScNKy0ABMuV75WrqyxWbV5eFuVf2N8U4t1HRwAOJQTGCswIJiHDz8QqLt0rCoZH3qg0WGlHBwkGLAMMCi5p1yUPIu13Ai0CBMvC9MlAsp8btwAG6ArpQbqUZKpA7wJaoHCoGBQJBnSwXYZXG7ghyPQSoMQNACCUFWSH0RxgJ1cX2AIk4mxJ5MpTGp03GzhS8La8GYdKgwH+WIGhVxXyYdmAqBEMChbw+XxZGAw3DEqCVClBcDEaEEfCYUB170+-MRjBJ7BU0xxBjxcAA5iiQGiMeZkaj0Ug9X9haKAYwWA4g3CUpRCGhrWJbdUAMowFibAA80ZRGFjrAAfDd8wXC4sM9nck7CxXK1XqzX84sbq6fZ64MY1G2knra13u1363AA2H-uZW+3El8exPJ3X6IkgA)
 
-TypeBox includes a runtime TypeScript engine that can transform TypeScript definitions to JSON Schema. The engine is fully type-safe and supports many programmable constructs including Conditional, Mapped, Indexed, Generics, Distributive Generics, and more.
+TypeBox includes a micro TypeScript engine that can transform TypeScript definitions to JSON Schema. The engine is fully type-safe and supports many programmable constructs including Conditional, Mapped, Indexed, Generics, Distributive Generics, and more.
 
 ### Example
 
-Syntax highlighting is available via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=sinclairzx81.typebox-script)
+Syntax highlighting is available via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=sinclairzx81.typebox-script).
 
 ```typescript
 import Type from 'typebox'
@@ -229,9 +229,9 @@ const result = Vector.Parse({ x: 1, y: 0, z: 0 })  // const result: {
 
 ### Coverage
 
-The following table shows specification coverage implemented by TypeBox.
+[JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) | [JSON Schema Compliance Suite](https://github.com/sinclairzx81/json-schema-compliance-suite)
 
-[JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) 
+TypeBox supports all major JSON Schema draft versions and tracks compliance against the official JSON Schema Test Suite. It also maintains a separate JavaScript compliance suite to track ecosystem adoption as JSON Schema moves toward the Version 1 candidate. The following table shows TypeBox specification coverage.
 
 | Spec | 3 | 4 | 6 | 7 | 2019-09 | 2020-12 | v1 |
 |:-----|:--|:--|:--|:--|:--|:--|:--|
@@ -281,10 +281,13 @@ The following table shows specification coverage implemented by TypeBox.
 | unevaluatedProperties | - | - | - | - | ✅ | ✅ | 128/129 |
 | uniqueItems | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 
-
 ### Performance
 
-The following table shows compile performance for various JSON Schema structures using AJV8 as a basis for comparison. 
+TypeBox tracks comparative performance against AJV8 as the de facto JSON Schema performance standard. For broader comparative benchmarks, refer to the community maintained projects below.
+
+[Runtime Benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/) | [Schema Benchmarks](https://schemabenchmarks.dev/)
+
+The following table shows compilation performance for various JSON Schema structures. These benchmarks measure the time required to JIT compile schematics, with faster compilation resulting in faster application startup.
 
 ```python
 ┌──────────────────────┬─────────────┬─────────────┐
@@ -316,8 +319,7 @@ The following table shows compile performance for various JSON Schema structures
 └──────────────────────┴─────────────┴─────────────┘
 ```
 
-
-The following tables shows validation performance for various JSON Schema structures using AJV8 as a basis for comparison.
+The following tables shows validation performance for various JSON Schema structures. These benchmarks measure overall validation throughput for JIT compiled schematics.
 
 ```python
 ┌──────────────────────┬──────────────┬──────────────┐

package/build/format/_idna.d.mts

@@ -1,2 +0,0 @@
-export declare function IsIdnLabel(value: string): boolean;
-export declare function IsLabel(value: string): boolean;

package/build/format/_idna.mjs

@@ -1,246 +0,0 @@
-import { Unreachable } from '../system/unreachable/index.mjs';
-import * as Puny from './_puny.mjs';
-// ------------------------------------------------------------------
-// Unicode General Category Helper (RFC 5892)
-// ------------------------------------------------------------------
-function IsNonspacingMark(cp) {
-    return /\p{Mn}/u.test(String.fromCodePoint(cp));
-}
-function IsSpacingCombiningMark(cp) {
-    return /\p{Mc}/u.test(String.fromCodePoint(cp));
-}
-function IsEnclosingMark(cp) {
-    return /\p{Me}/u.test(String.fromCodePoint(cp));
-}
-function IsCombiningMark(cp) {
-    return IsNonspacingMark(cp) || IsSpacingCombiningMark(cp) || IsEnclosingMark(cp);
-}
-// ------------------------------------------------------------------
-// RFC 5892 §2.6 DISALLOWED exceptions
-//
-// https://tools.ietf.org/html/rfc5892#section-2.6
-// ------------------------------------------------------------------
-const RFC5892_DISALLOWED = new Set([
-    0x0640, // ARABIC TATWEEL
-    0x07fa, // NKO LAJANYALAN
-    0x302e, // HANGUL SINGLE DOT TONE MARK
-    0x302f, // HANGUL DOUBLE DOT TONE MARK
-    0x3031, // VERTICAL KANA REPEAT MARK
-    0x3032, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK
-    0x3033, // VERTICAL KANA REPEAT MARK UPPER HALF
-    0x3034, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK UPPER HALF
-    0x3035, // VERTICAL KANA REPEAT MARK LOWER HALF
-    0x303b // VERTICAL IDEOGRAPHIC ITERATION MARK
-]);
-// ------------------------------------------------------------------
-// A set of Virama (halant) code points used to validate CONTEXTJ
-// rules (RFC 5892 Appendix A.1). These characters allow a subsequent
-// Zero Width Non-Joiner (U+200C) or Zero Width Joiner (U+200D) to
-// be valid in a label.
-// ------------------------------------------------------------------
-const VIRAMA_CPS = new Set([
-    0x094d,
-    0x09cd,
-    0x0a4d,
-    0x0acd,
-    0x0b4d,
-    0x0bcd,
-    0x0c4d,
-    0x0ccd,
-    0x0d3b,
-    0x0d3c,
-    0x0d4d,
-    0x0dca,
-    0x1b44,
-    0x1baa,
-    0x1bab,
-    0xa9c0,
-    0x11046,
-    0x1107f,
-    0x110b9,
-    0x11133,
-    0x11134,
-    0x111c0,
-    0x11235,
-    0x1134d,
-    0x11442,
-    0x114c2,
-    0x115bf,
-    0x1163f,
-    0x116b6,
-    0x11c3f,
-    0x11d44,
-    0x11d45
-]);
-// ------------------------------------------------------------------
-// Guards for CONTEXTO rules (RFC 5892 Appendix A)
-// ------------------------------------------------------------------
-function IsGreek(cp) {
-    return /\p{Script=Greek}/u.test(String.fromCodePoint(cp));
-}
-function IsHebrew(cp) {
-    return /\p{Script=Hebrew}/u.test(String.fromCodePoint(cp));
-}
-function IsHiragana(cp) {
-    return /\p{Script=Hiragana}/u.test(String.fromCodePoint(cp));
-}
-function IsKatakana(cp) {
-    return /\p{Script=Katakana}/u.test(String.fromCodePoint(cp));
-}
-function IsHan(cp) {
-    return /\p{Script=Han}/u.test(String.fromCodePoint(cp));
-}
-function IsArabicIndicDigit(cp) {
-    return cp >= 0x0660 && cp <= 0x0669;
-}
-function IsExtendedArabicIndicDigit(cp) {
-    return cp >= 0x06f0 && cp <= 0x06f9;
-}
-function IsVirama(cp) {
-    return VIRAMA_CPS.has(cp);
-}
-// ------------------------------------------------------------------
-// IsUnicodeLabel
-// ------------------------------------------------------------------
-function IsUnicodeLabel(value) {
-    // deno-coverage-ignore-start - unable to reach via format guards
-    if (value.length === 0)
-        return Unreachable(); // false
-    // deno-coverage-ignore-stop
-    // Use spread to handle surrogate pairs and provide O(1) neighbor access
-    const cps = [...value].map((c) => c.codePointAt(0));
-    const len = cps.length;
-    // RFC 5891 §4.2.3.2: Hyphen rules
-    if (cps[0] === 0x2d || cps[len - 1] === 0x2d)
-        return false;
-    if (len >= 4 && cps[2] === 0x2d && cps[3] === 0x2d)
-        return false;
-    // RFC 5891 §4.2.3.2 - Must not begin with a combining mark
-    if (IsCombiningMark(cps[0]))
-        return false;
-    let hasJapanese = false;
-    let hasArabicIndic = false;
-    let hasExtendedArabicIndic = false;
-    for (let i = 0; i < len; i++) {
-        const cp = cps[i];
-        // 1. DISALLOWED exceptions
-        if (RFC5892_DISALLOWED.has(cp))
-            return false;
-        // 2. Collect Flags
-        if (IsHiragana(cp) || IsKatakana(cp) || IsHan(cp))
-            hasJapanese = true;
-        if (IsArabicIndicDigit(cp))
-            hasArabicIndic = true;
-        if (IsExtendedArabicIndicDigit(cp))
-            hasExtendedArabicIndic = true;
-        // 3. CONTEXTO / CONTEXTJ Neighbor Rules
-        const prev = cps[i - 1], next = cps[i + 1];
-        switch (cp) {
-            case 0x00b7:
-                if (prev !== 0x006c || next !== 0x006c)
-                    return false;
-                break; // MIDDLE DOT (Catalan)
-            case 0x0375:
-                if (next === undefined || !IsGreek(next))
-                    return false;
-                break; // Greek KERAIA
-            case 0x05f3:
-            case 0x05f4:
-                if (prev === undefined || !IsHebrew(prev))
-                    return false;
-                break; // Hebrew GERESH
-            case 0x200c: // ZWNJ - RFC 5892 Appendix A.1
-                // Note: Full validation requires a Unicode joining type table. We reject
-                // only when preceded by ASCII (U+0000-U+007F), which can never satisfy
-                // the Virama or cursive-joining rules.
-                if (prev === undefined || (prev < 0x0080 && !IsVirama(prev)))
-                    return false;
-                break;
-            case 0x200d: // ZWJ  - RFC 5892 Appendix A.2
-                if (prev === undefined || !IsVirama(prev))
-                    return false;
-                break;
-            case 0x30fb: /* Checked at end via hasJapanese */
-                break; // KATAKANA MIDDLE DOT
-        }
-    }
-    // 4. Global Context Validations (Post-loop)
-    // RFC 5892 Appendix A.7 - Katakana Middle Dot requirement
-    if (value.includes('\u30fb') && !hasJapanese)
-        return false;
-    // RFC 5892 Appendix A.8/A.9 - Mixing Arabic Digits
-    if (hasArabicIndic && hasExtendedArabicIndic)
-        return false;
-    return true;
-}
-// ------------------------------------------------------------------
-// IsAsciiLabel
-// ------------------------------------------------------------------
-function IsAsciiLabel(value) {
-    // Must not start or end with a hyphen
-    if (value.charCodeAt(0) === 45 || value.charCodeAt(value.length - 1) === 45)
-        return false;
-    // RFC 5891 §4.2.3.1 : "--" at positions 3-4 is reserved for A-labels only
-    if (value.length >= 4 && value.charCodeAt(2) === 45 && value.charCodeAt(3) === 45)
-        return false;
-    // All characters must be alphanumeric or hyphen
-    for (let i = 0; i < value.length; i++) {
-        const ch = value.charCodeAt(i);
-        if (!((ch >= 97 && ch <= 122) || // a-z
-            (ch >= 65 && ch <= 90) || // A-Z
-            (ch >= 48 && ch <= 57) || // 0-9
-            ch === 45 // '-'
-        ))
-            return false;
-    }
-    return true;
-}
-// ------------------------------------------------------------------
-// IsPunyLabel
-// ------------------------------------------------------------------
-function IsPuny(value) {
-    return value.toLowerCase().startsWith('xn--');
-}
-function IsPunyLabel(value) {
-    try {
-        const payload = value.slice(4).toLowerCase();
-        // 1. Structural Validation (RFC 3492 syntax)
-        //
-        // If the payload contains a hyphen, it MUST be a delimiter separating basic
-        // ASCII characters from the variable-length integers. A payload consisting
-        // of ONLY a hyphen or starting with multiple hyphens without basic ASCII
-        // characters (like "-9uc") is fundamentally malformed.
-        //
-        const lastHyphen = payload.lastIndexOf('-');
-        if (lastHyphen === 0) {
-            // Catches "-9uc" right here because the delimiter is at index 0, meaning 0
-            // basic ASCII characters preceded it, which is non-canonical.
-            return false;
-        }
-        // 2. Decode the payload
-        const decoded = Puny.Decode(payload);
-        if (!decoded)
-            return false;
-        // 3. Validate the output rules against RFC 5892
-        return IsUnicodeLabel(decoded);
-    }
-    catch {
-        return false;
-    }
-}
-// ------------------------------------------------------------------
-// IsIdnLabel
-// ------------------------------------------------------------------
-export function IsIdnLabel(value) {
-    if (value.length === 0 || value.length > 63)
-        return false;
-    return IsPuny(value) ? IsPunyLabel(value) : IsUnicodeLabel(value);
-}
-// ------------------------------------------------------------------
-// IsLabel
-// ------------------------------------------------------------------
-export function IsLabel(value) {
-    if (value.length === 0 || value.length > 63)
-        return false;
-    return IsPuny(value) ? IsPunyLabel(value) : IsAsciiLabel(value);
-}