typebox 1.3.12 → 1.3.13

package/build/guard/string.mjs

@@ -67,7 +67,7 @@ function NextGraphemeClusterIndex(value, clusterStart) {
     // Consume combining marks & variation selectors
     clusterEnd = ConsumeModifiers(value, clusterEnd);
     // Handle multi-ZWJ sequences
-    while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
+    while (clusterEnd < value.length - 1 && IsZeroWidthJoiner(value.codePointAt(clusterEnd))) {
         const nextCP = value.codePointAt(clusterEnd + 1);
         clusterEnd += 1 + CodePointLength(nextCP);
         clusterEnd = ConsumeModifiers(value, clusterEnd);

package/build/system/memory/clone.mjs

@@ -24,7 +24,7 @@ function IsSchemaObject(value) {
 }
 function FromSchemaObject(value) {
     const result = {};
-    for (const key of Object.getOwnPropertyNames(value)) {
+    for (const key of Guard.Keys(value)) {
         if (Guard.IsUnsafePropertyKey(key))
             continue; // (ignore: prototype-pollution)
         const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!

package/build/system/memory/discard.mjs

@@ -1,12 +1,13 @@
 // deno-lint-ignore-file no-explicit-any
 // deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
 import { Clone } from './clone.mjs';
 /** Discards multiple property keys from the given object value */
 export function Discard(value, propertyKeys) {
     Metrics.discard += 1;
     const result = {};
-    for (const key of Object.getOwnPropertyNames(value)) {
+    for (const key of Guard.Keys(value)) {
         if (propertyKeys.includes(key))
             continue;
         const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!

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

@@ -2,13 +2,13 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TAny } from '../../types/any.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TCompare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
+import { type TUnknown } from '../../types/unknown.mjs';
+import { type TCompare, CompareResultLeftInside, CompareResultEqual, CompareResultDisjoint } from './compare.mjs';
 import { type TFlatten } from './flatten.mjs';
 import { type TEvaluateType } from './evaluate.mjs';
-type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultRightInside ? TBroadFilter<Type, Right, [...Result]> : TBroadFilter<Type, Right, [...Result, Left]> : Result);
-type TIsBroadestType<Type extends TSchema, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultLeftInside | typeof ResultEqual ? false : TIsBroadestType<Type, Right> : true);
-type TBroadenType<Type extends TSchema, Types extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>, Result extends TSchema[] = (Evaluated extends TAny ? [Evaluated] : TIsBroadestType<Evaluated, Types> extends true ? [...TBroadFilter<Evaluated, Types>, Evaluated] : Types)> = Result;
-type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : Left extends TNever ? TBroadenTypes<Right, Result> : TBroadenTypes<Right, TBroadenType<Left, Result>>) : Result);
+type TBroadenFilter<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = [], All extends TSchema[] = Types> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof CompareResultLeftInside | typeof CompareResultEqual ? All : TCompare<Type, Left> extends typeof CompareResultDisjoint ? TBroadenFilter<Type, Right, [...Result, Left], All> : TBroadenFilter<Type, Right, Result, All> : [...Result, Type]);
+type TBroadenType<Type extends TSchema, Types extends TSchema[], Result extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>> = (Evaluated extends TAny ? [Evaluated] : Evaluated extends TUnknown ? [Evaluated] : Evaluated extends TNever ? TBroadenTypes<Types, Result> : Evaluated extends TObject ? TBroadenTypes<Types, [...Result, Evaluated]> : TBroadenTypes<Types, TBroadenFilter<Evaluated, Result>>);
+type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TBroadenType<Left, Right, Result> : Result);
 export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>> = Flattened;
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export declare function Broaden<Types extends TSchema[]>(types: [...Types]): TBroaden<Types>;

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

@@ -3,37 +3,31 @@ import { Guard } from '../../../guard/index.mjs';
 import { IsAny } from '../../types/any.mjs';
 import { IsNever } from '../../types/never.mjs';
 import { IsObject } from '../../types/object.mjs';
-import { Compare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
+import { IsUnknown } from '../../types/unknown.mjs';
+import { Compare, CompareResultLeftInside, CompareResultEqual, CompareResultDisjoint } from './compare.mjs';
 import { Flatten } from './flatten.mjs';
 import { EvaluateType } from './evaluate.mjs';
-function BroadFilter(type, types) {
-    return types.filter(left => {
-        return Compare(type, left) === ResultRightInside
-            ? false
-            : true;
-    });
-}
-function IsBroadestType(type, types) {
-    const result = types.some(left => {
-        const result = Compare(type, left);
-        return Guard.IsEqual(result, ResultLeftInside) || Guard.IsEqual(result, ResultEqual);
-    });
-    return Guard.IsEqual(result, false);
+function BroadenFilter(type, types, result = [], all = types) {
+    return Guard.ShiftLeft(types, (left, right) => {
+        const compare = Compare(type, left);
+        return ((Guard.IsEqual(compare, CompareResultLeftInside) || Guard.IsEqual(compare, CompareResultEqual))
+            ? all // Left in set. Return original All set.
+            : Guard.IsEqual(compare, CompareResultDisjoint)
+                ? BroadenFilter(type, right, [...result, left], all) // Left is disjoint, keep it
+                : BroadenFilter(type, right, result, all) // Left in Type, drop it
+        );
+    }, () => [...result, type]); // Type broadest in set
 }
-function BroadenType(type, types) {
+function BroadenType(type, types, result) {
     const evaluated = EvaluateType(type);
-    return (IsAny(evaluated) ? [evaluated] :
-        IsBroadestType(evaluated, types)
-            ? [...BroadFilter(evaluated, types), evaluated]
-            : types);
+    return (IsAny(evaluated) ? [evaluated] : // terminate (always the most broad)
+        IsUnknown(evaluated) ? [evaluated] : // terminate (always the most broad)
+            IsNever(evaluated) ? BroadenTypes(types, result) : // ignored: never is dropped
+                IsObject(evaluated) ? BroadenTypes(types, [...result, evaluated]) : // objects are always considered (too expensive to compare)
+                    BroadenTypes(types, BroadenFilter(evaluated, result)));
 }
-function BroadenTypes(types) {
-    return types.reduce((result, left) => {
-        return (IsObject(left) ? [...result, left] : // push
-            IsNever(left) ? result : // ignore
-                BroadenType(left, result) // broaden
-        );
-    }, []);
+function BroadenTypes(types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => (BroadenType(left, right, result)), () => result);
 }
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export function Broaden(types) {

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

@@ -1,15 +1,11 @@
 import { type TSchema } from '../../types/index.mjs';
-import { type TUnknown } from '../../types/unknown.mjs';
 import { type TExtends, ExtendsResult } from "../../extends/index.mjs";
-export declare const ResultEqual = "equal";
-export declare const ResultDisjoint = "disjoint";
-export declare const ResultLeftInside = "left-inside";
-export declare const ResultRightInside = "right-inside";
-export type TCompareResult = typeof ResultEqual | typeof ResultDisjoint | typeof ResultLeftInside | typeof ResultRightInside;
+export declare const CompareResultEqual = 0;
+export declare const CompareResultDisjoint = 1;
+export declare const CompareResultLeftInside = 2;
+export declare const CompareResultRightInside = 3;
+export type TCompareResult = (typeof CompareResultEqual | typeof CompareResultDisjoint | typeof CompareResultLeftInside | typeof CompareResultRightInside);
 /** Compares left and right types and determines their set relationship */
-export type TCompare<Left extends TSchema, Right extends TSchema, Extends extends [ExtendsResult.TResult, ExtendsResult.TResult] = [
-    Left extends TUnknown ? ExtendsResult.TExtendsFalse : TExtends<{}, Left, Right>,
-    Left extends TUnknown ? ExtendsResult.TExtendsTrue : TExtends<{}, Right, Left>
-]> = (Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsTrueLike] ? typeof ResultEqual : Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsFalse] ? typeof ResultLeftInside : Extends extends [ExtendsResult.TExtendsFalse, ExtendsResult.TExtendsTrueLike] ? typeof ResultRightInside : typeof ResultDisjoint);
+export type TCompare<Left extends TSchema, Right extends TSchema, Extends extends [ExtendsResult.TResult, ExtendsResult.TResult] = [TExtends<{}, Left, Right>, TExtends<{}, Right, Left>]> = (Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsTrueLike] ? typeof CompareResultEqual : Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsFalse] ? typeof CompareResultLeftInside : Extends extends [ExtendsResult.TExtendsFalse, ExtendsResult.TExtendsTrueLike] ? typeof CompareResultRightInside : typeof CompareResultDisjoint);
 /** Compares left and right types and determines their set relationship. */
 export declare function Compare<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TCompare<Left, Right>;

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

@@ -1,22 +1,18 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
-import { IsUnknown } from '../../types/unknown.mjs';
 import { Extends, ExtendsResult } from "../../extends/index.mjs";
 // ------------------------------------------------------------------
 // TCompare
 // ------------------------------------------------------------------
-export const ResultEqual = 'equal';
-export const ResultDisjoint = 'disjoint';
-export const ResultLeftInside = 'left-inside';
-export const ResultRightInside = 'right-inside';
+export const CompareResultEqual = 0; // 'equal'
+export const CompareResultDisjoint = 1; // 'disjoint'
+export const CompareResultLeftInside = 2; // 'left-inside'
+export const CompareResultRightInside = 3; // 'right-inside'
 /** Compares left and right types and determines their set relationship. */
 export function Compare(left, right) {
-    const extendsCheck = [
-        IsUnknown(left) ? ExtendsResult.ExtendsFalse() : Extends({}, left, right),
-        IsUnknown(left) ? ExtendsResult.ExtendsTrue({}) : Extends({}, right, left),
-    ];
-    return (ExtendsResult.IsExtendsTrueLike(extendsCheck[0]) && ExtendsResult.IsExtendsTrueLike(extendsCheck[1]) ? ResultEqual :
-        ExtendsResult.IsExtendsTrueLike(extendsCheck[0]) && ExtendsResult.IsExtendsFalse(extendsCheck[1]) ? ResultLeftInside :
-            ExtendsResult.IsExtendsFalse(extendsCheck[0]) && ExtendsResult.IsExtendsTrueLike(extendsCheck[1]) ? ResultRightInside :
-                ResultDisjoint);
+    const extendsCheck = [Extends({}, left, right), Extends({}, right, left)];
+    return (ExtendsResult.IsExtendsTrueLike(extendsCheck[0]) && ExtendsResult.IsExtendsTrueLike(extendsCheck[1]) ? CompareResultEqual :
+        ExtendsResult.IsExtendsTrueLike(extendsCheck[0]) && ExtendsResult.IsExtendsFalse(extendsCheck[1]) ? CompareResultLeftInside :
+            ExtendsResult.IsExtendsFalse(extendsCheck[0]) && ExtendsResult.IsExtendsTrueLike(extendsCheck[1]) ? CompareResultRightInside :
+                CompareResultDisjoint);
 }

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

@@ -1,4 +1,3 @@
-import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TReadonly } from '../../types/_readonly.mjs';
 import { type TOptional } from '../../types/_optional.mjs';
 import { type TSchema } from '../../types/schema.mjs';
@@ -12,6 +11,10 @@ import { type TRemoveReadonly } from '../../action/_remove_readonly.mjs';
 import { type TRemoveOptional } from '../../action/_remove_optional.mjs';
 import { type TTupleElementsToProperties } from '../tuple/to_object.mjs';
 import { type TEvaluateIntersect } from './evaluate.mjs';
+/** Returns true if the type is a valid operand to Composite. */
+export type TCanComposite<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
+/** Returns true if the type is a valid operand to Composite. */
+export declare function CanComposite<Type extends TSchema>(type: Type): TCanComposite<Type>;
 type TIsReadonlyProperty<Left extends TSchema, Right extends TSchema> = (Left extends TReadonly<Left> ? Right extends TReadonly<Right> ? true : false : false);
 type TIsOptionalProperty<Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? true : false : false);
 type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TRemoveReadonly<TRemoveOptional<Evaluated>>> = ([
@@ -25,10 +28,10 @@ type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly
     IsOptional
 ] extends [false, true] ? TAddOptional<Property> : Property);
 type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TCompositeProperty<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
-type TCompositeProperties<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
-    [Key in keyof (Right & Left)]: TCompositePropertyKey<Left, Right, Key>;
+type TCompositeProperties<Left extends TProperties, Right extends TProperties, Keys extends PropertyKey = keyof (Left & Right), Result extends TProperties = {
+    [Key in Keys]: TCompositePropertyKey<Left, Right, Key>;
 }> = Result;
-type TGetProperties<Type extends TSchema, Result extends TProperties = (Type extends TObject<infer Properties extends TProperties> ? Properties : Type extends TTuple<infer Types extends TSchema[]> ? TTupleElementsToProperties<Types> : TUnreachable)> = Result;
+type TGetProperties<Type extends TSchema, Result extends TProperties = (Type extends TObject<infer Properties extends TProperties> ? Properties : Type extends TTuple<infer Types extends TSchema[]> ? TTupleElementsToProperties<Types> : {})> = Result;
 export type TComposite<Left extends TSchema, Right extends TSchema, LeftProperties extends TProperties = TGetProperties<Left>, RightProperties extends TProperties = TGetProperties<Right>, Properties extends TProperties = TCompositeProperties<LeftProperties, RightProperties>, Result extends TSchema = TObject<Properties>> = Result;
 export declare function Composite<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TComposite<Left, Right>;
 export {};

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

@@ -1,6 +1,5 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
-import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { IsReadonly } from '../../types/_readonly.mjs';
 import { IsOptional } from '../../types/_optional.mjs';
@@ -13,6 +12,10 @@ import { RemoveReadonly } from '../../action/_remove_readonly.mjs';
 import { RemoveOptional } from '../../action/_remove_optional.mjs';
 import { TupleElementsToProperties } from '../tuple/to_object.mjs';
 import { EvaluateIntersect } from './evaluate.mjs';
+/** Returns true if the type is a valid operand to Composite. */
+export function CanComposite(type) {
+    return (IsObject(type) || IsTuple(type));
+}
 function IsReadonlyProperty(left, right) {
     return (IsReadonly(left) ? IsReadonly(right) ? true : false : false);
 }
@@ -32,36 +35,26 @@ function CompositeProperty(left, right) {
 }
 function CompositePropertyKey(left, right, key) {
     return (key in left
-        ? key in right
-            ? CompositeProperty(left[key], right[key])
-            : left[key]
-        : key in right
-            ? right[key]
-            : Never());
+        ? key in right ? CompositeProperty(left[key], right[key]) : left[key]
+        : key in right ? right[key] : Never());
 }
 function CompositeProperties(left, right) {
-    const keys = new Set([...Guard.Keys(right), ...Guard.Keys(left)]);
-    return [...keys].reduce((result, key) => {
+    const keys = new Set([...Guard.Keys(left), ...Guard.Keys(right)]);
+    const result = [...keys].reduce((result, key) => {
         return { ...result, [key]: CompositePropertyKey(left, right, key) };
     }, {});
+    return result;
 }
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - symmetric unreachable | internal
-//
-// Composite is called by Distribute which provisions the type as
-// either TObject ot TTuple. Fall-through unreachable.
-//
-// ------------------------------------------------------------------
 function GetProperties(type) {
     const result = (IsObject(type) ? type.properties :
         IsTuple(type) ? TupleElementsToProperties(type.items) :
-            Unreachable() // {}
-    );
+            {});
     return result;
 }
 export function Composite(left, right) {
     const leftProperties = GetProperties(left);
     const rightProperties = GetProperties(right);
     const properties = CompositeProperties(leftProperties, rightProperties);
-    return Object(properties);
+    const result = Object(properties);
+    return result;
 }

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

@@ -1,27 +1,11 @@
 import { type TSchema } from '../../types/schema.mjs';
-import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TObject } from '../../types/object.mjs';
-import { type TTuple } from '../../types/tuple.mjs';
-import { type TComposite } from './composite.mjs';
 import { type TNarrow } from './narrow.mjs';
-import { type TEvaluateType } from './evaluate.mjs';
 import { type TEvaluateIntersect } from './evaluate.mjs';
-type TIsObjectLike<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
-type TIsUnionOperand<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false> = Result;
-type TDistributeOperation<Left extends TSchema, Right extends TSchema, EvaluatedLeft extends TSchema = TEvaluateType<Left>, EvaluatedRight extends TSchema = TEvaluateType<Right>, IsUnionOperand extends boolean = TIsUnionOperand<EvaluatedLeft, EvaluatedRight>, IsObjectLeft extends boolean = TIsObjectLike<EvaluatedLeft>, IsObjectRight extends boolean = TIsObjectLike<EvaluatedRight>, Result extends TSchema = ([
-    IsUnionOperand
-] extends [true] ? TEvaluateIntersect<[EvaluatedLeft, EvaluatedRight]> : [
-    IsObjectLeft,
-    IsObjectRight
-] extends [true, true] ? TComposite<EvaluatedLeft, EvaluatedRight> : [
-    IsObjectLeft,
-    IsObjectRight
-] extends [true, false] ? EvaluatedLeft : [
-    IsObjectLeft,
-    IsObjectRight
-] extends [false, true] ? EvaluatedRight : TNarrow<EvaluatedLeft, EvaluatedRight>)> = Result;
-type TDistributeType<Type extends TSchema, Distribution extends TSchema[], Result extends TSchema[] = []> = (Distribution extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeType<Type, Right, [...Result, TDistributeOperation<Type, Left>]> : Result extends [] ? [Type] : Result);
+import { type TEvaluateType } from './evaluate.mjs';
+type TShouldEvaluate<Left extends TSchema, Right extends TSchema, IsUnionLeft extends boolean = Left extends TUnion ? true : false, IsUnionRight extends boolean = Right extends TUnion ? true : false, Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false> = Result;
+type TDistributeOperation<Left extends TSchema, Right extends TSchema, EvaluatedLeft extends TSchema = TEvaluateType<Left>, EvaluatedRight extends TSchema = TEvaluateType<Right>, ShouldEvaluate extends boolean = TShouldEvaluate<EvaluatedLeft, EvaluatedRight>, Result extends TSchema = [ShouldEvaluate] extends [true] ? TEvaluateIntersect<[EvaluatedLeft, EvaluatedRight]> : TNarrow<EvaluatedLeft, EvaluatedRight>> = Result;
+type TDistributeType<Type extends TSchema, Distribution extends TSchema[], Result extends TSchema[] = []> = (Distribution extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeType<Type, Right, [...Result, TDistributeOperation<Left, Type>]> : Result extends [] ? [Type] : Result);
 type TDistributeUnion<Types extends TSchema[], Distribution extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeUnion<Right, Distribution, [...Result, ...TDistribute<[Left], Distribution>]> : Result);
 export type TDistribute<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TUnion<infer UnionTypes extends TSchema[]> ? TDistribute<Right, TDistributeUnion<UnionTypes, Result>> : TDistribute<Right, TDistributeType<Left, Result>> : Result);
 export declare function Distribute<Types extends TSchema[]>(types: [...Types], result?: TSchema[]): TDistribute<Types>;

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/package.json

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

package/readme.md

@@ -113,7 +113,7 @@ 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
 
@@ -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,7 +281,6 @@ 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.