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

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

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-08-02T00:59:01.706Z",
+  "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.9-depup.0",
+  "version": "1.3.14-depup.0",
   "keywords": [
     "typebox",
     "depup",
@@ -94,8 +94,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "typebox",
-    "originalVersion": "1.3.9",
-    "processedAt": "2026-08-02T00:59:02.398Z",
+    "originalVersion": "1.3.14",
+    "processedAt": "2026-08-16T00:27:33.089Z",
     "smokeTest": "passed"
   }
 }