typebox 1.2.10 → 1.2.12

package/build/guard/guard.d.mts

@@ -47,8 +47,8 @@ export declare function IsMinLength(value: string, length: number): boolean;
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Returns true if all elements from offset satisfy the callback, visiting every element regardless of failure */
 export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
-/** Takes the left-most element from an array and dispatches to the true arm, or the false arm if empty */
-export declare function TakeLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
+/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
+export declare function ShiftLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
 /** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
 export declare function IsUnsafePropertyKey(key: PropertyKey): boolean;
 /** Returns true if this value has this property key */

package/build/guard/guard.mjs

@@ -162,8 +162,8 @@ export function EveryAll(value, offset, callback) {
     }
     return result;
 }
-/** Takes the left-most element from an array and dispatches to the true arm, or the false arm if empty */
-export function TakeLeft(array, true_, false_) {
+/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
+export function ShiftLeft(array, true_, false_) {
     return (IsEqual(array.length, 0) ? false_() : true_(array[0], array.slice(1)));
 }
 // --------------------------------------------------------------------------

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

@@ -19,7 +19,7 @@ function BuildDistributionArray(parameters, names) {
     return parameters.reduce((result, left) => [...result, names.includes(left.name)], []);
 }
 function ZipDistributionArray(arguments_, distributionArray, result = []) {
-    return Guard.TakeLeft(arguments_, (argumentLeft, argumentRight) => Guard.TakeLeft(distributionArray, (booleanLeft, booleanRight) => ZipDistributionArray(argumentRight, booleanRight, [...result, [booleanLeft, argumentLeft]]), () => result), () => result);
+    return Guard.ShiftLeft(arguments_, (argumentLeft, argumentRight) => Guard.ShiftLeft(distributionArray, (booleanLeft, booleanRight) => ZipDistributionArray(argumentRight, booleanRight, [...result, [booleanLeft, argumentLeft]]), () => result), () => result);
 }
 function Expand(type) {
     return (IsUnion(type)

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

@@ -23,10 +23,10 @@ function BindArgument(context, state, name, extends_, type) {
 function BindArguments(context, state, parameterLeft, parameterRight, arguments_) {
     const instantiatedExtends = InstantiateType(context, state, parameterLeft.extends);
     const instantiatedEquals = InstantiateType(context, state, parameterLeft.equals);
-    return Guard.TakeLeft(arguments_, (left, right) => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right), () => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
+    return Guard.ShiftLeft(arguments_, (left, right) => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right), () => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
 }
 function BindParameters(context, state, parameters, arguments_) {
-    return Guard.TakeLeft(parameters, (left, right) => BindArguments(context, state, left, right, arguments_), () => context);
+    return Guard.ShiftLeft(parameters, (left, right) => BindArguments(context, state, left, right, arguments_), () => context);
 }
 export function ResolveArgumentsContext(context, state, parameters, arguments_) {
     return BindParameters(context, state, parameters, arguments_);

package/build/type/engine/cyclic/check.mjs

@@ -24,7 +24,7 @@ function FromProperties(stack, context, properties) {
     return FromTypes(stack, context, types);
 }
 function FromTypes(stack, context, types) {
-    return Guard.TakeLeft(types, (left, right) => FromType(stack, context, left)
+    return Guard.ShiftLeft(types, (left, right) => FromType(stack, context, left)
         ? true
         : FromTypes(stack, context, right), () => false);
 }

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

@@ -31,15 +31,15 @@ function DistributeOperation(left, right) {
     return result;
 }
 function DistributeType(type, types, result = []) {
-    return Guard.TakeLeft(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(type, left)]), () => Guard.IsEqual(result.length, 0)
         ? [type]
         : result);
 }
 function DistributeUnion(types, distribution, result = []) {
-    return Guard.TakeLeft(types, (left, right) => DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)]), () => result);
+    return Guard.ShiftLeft(types, (left, right) => DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)]), () => result);
 }
 export function Distribute(types, result = []) {
-    return Guard.TakeLeft(types, (left, right) => IsUnion(left)
+    return Guard.ShiftLeft(types, (left, right) => IsUnion(left)
         ? Distribute(right, DistributeUnion(left.anyOf, result))
         : Distribute(right, DistributeType(left, result)), () => result);
 }

package/build/type/engine/instantiate.mjs

@@ -70,7 +70,7 @@ export function State(callstack, visited) {
     return { callstack, visited };
 }
 export function CanInstantiate(types) {
-    return Guard.TakeLeft(types, (left, right) => IsRef(left)
+    return Guard.ShiftLeft(types, (left, right) => IsRef(left)
         ? false
         : CanInstantiate(right), () => true);
 }

package/build/type/engine/object/from_union.mjs

@@ -11,9 +11,9 @@ function CollapseUnionProperties(left, right) {
     return result;
 }
 function ReduceVariants(types, result) {
-    return Guard.TakeLeft(types, (left, right) => ReduceVariants(right, CollapseUnionProperties(result, FromType(left))), () => result);
+    return Guard.ShiftLeft(types, (left, right) => ReduceVariants(right, CollapseUnionProperties(result, FromType(left))), () => result);
 }
 export function FromUnion(types) {
-    return Guard.TakeLeft(types, (left, right) => ReduceVariants(right, FromType(left)), () => Unreachable());
+    return Guard.ShiftLeft(types, (left, right) => ReduceVariants(right, FromType(left)), () => Unreachable());
 }
 // deno-coverage-ignore-stop

package/build/type/engine/template_literal/decode.mjs

@@ -9,13 +9,13 @@ import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
 import { IsTemplateLiteralFinite } from './is_finite.mjs';
 import { TemplateLiteralCreate } from './create.mjs';
 function FromLiteralPush(variants, value, result = []) {
-    return Guard.TakeLeft(variants, (left, right) => FromLiteralPush(right, value, [...result, `${left}${value}`]), () => result);
+    return Guard.ShiftLeft(variants, (left, right) => FromLiteralPush(right, value, [...result, `${left}${value}`]), () => result);
 }
 function FromLiteral(variants, value) {
     return (Guard.IsEqual(variants.length, 0) ? [`${value}`] : FromLiteralPush(variants, value));
 }
 function FromUnion(variants, types, result = []) {
-    return Guard.TakeLeft(types, (left, right) => FromUnion(variants, right, [...result, ...FromType(variants, left)]), () => result);
+    return Guard.ShiftLeft(types, (left, right) => FromUnion(variants, right, [...result, ...FromType(variants, left)]), () => result);
 }
 // ------------------------------------------------------------------
 // deno-coverage-ignore-start - symmetric unreachable | internal
@@ -33,7 +33,7 @@ function FromType(variants, type) {
     return result;
 }
 function DecodeFromSpan(variants, types) {
-    return Guard.TakeLeft(types, (left, right) => DecodeFromSpan(FromType(variants, left), right), () => variants);
+    return Guard.ShiftLeft(types, (left, right) => DecodeFromSpan(FromType(variants, left), right), () => variants);
 }
 function VariantsToLiterals(variants) {
     return variants.map(variant => Literal(variant));

package/build/type/engine/template_literal/encode.mjs

@@ -50,7 +50,7 @@ function EncodeEnum(values, right, pattern) {
     return EncodeType(evaluated, right, pattern);
 }
 function EncodeUnion(types, right, pattern, result = []) {
-    return Guard.TakeLeft(types, (head, tail) => EncodeUnion(tail, right, pattern, [...result, EncodeType(head, [], '')]), () => EncodeTypes(right, `${pattern}(${JoinString(result)})`));
+    return Guard.ShiftLeft(types, (head, tail) => EncodeUnion(tail, right, pattern, [...result, EncodeType(head, [], '')]), () => EncodeTypes(right, `${pattern}(${JoinString(result)})`));
 }
 function EncodeType(type, right, pattern) {
     return (IsEnum(type) ? EncodeEnum(type.enum, right, pattern) :
@@ -66,7 +66,7 @@ function EncodeType(type, right, pattern) {
                                             NeverPattern);
 }
 function EncodeTypes(types, pattern) {
-    return Guard.TakeLeft(types, (left, right) => EncodeType(left, right, pattern), () => pattern);
+    return Guard.ShiftLeft(types, (left, right) => EncodeType(left, right, pattern), () => pattern);
 }
 function EncodePattern(types) {
     const encoded = EncodeTypes(types, '');

package/build/type/engine/template_literal/is_finite.mjs

@@ -6,7 +6,7 @@ function FromLiteral(_value) {
     return true;
 }
 function FromTypesReduce(types) {
-    return Guard.TakeLeft(types, (left, right) => FromType(left)
+    return Guard.ShiftLeft(types, (left, right) => FromType(left)
         ? FromTypesReduce(right)
         : false, () => true);
 }

package/build/type/extends/extends_left.d.mts

@@ -16,6 +16,7 @@ import { type TExtendsNull } from './null.mjs';
 import { type TExtendsNumber } from './number.mjs';
 import { type TExtendsObject } from './object.mjs';
 import { type TExtendsPromise } from './promise.mjs';
+import { type TExtendsRecord } from './record.mjs';
 import { type TExtendsString } from './string.mjs';
 import { type TExtendsSymbol } from './symbol.mjs';
 import { type TExtendsTemplateLiteral } from './template_literal.mjs';
@@ -42,6 +43,7 @@ import { type TNull } from '../types/null.mjs';
 import { type TNumber } from '../types/number.mjs';
 import { type TObject } from '../types/object.mjs';
 import { type TPromise } from '../types/promise.mjs';
+import { type TRecord } from '../types/record.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TString } from '../types/string.mjs';
 import { type TSymbol } from '../types/symbol.mjs';
@@ -53,5 +55,5 @@ import { type TProperties } from '../types/properties.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TVoid } from '../types/void.mjs';
 import * as Result from './result.mjs';
-export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsDependent<Inferred, If, Then, Else, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, Values, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
+export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsDependent<Inferred, If, Then, Else, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, Values, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TExtendsRecord<Inferred, Pattern, Value, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
 export declare function ExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsLeft<Inferred, Left, Right>;

package/build/type/extends/extends_left.mjs

@@ -17,6 +17,7 @@ import { ExtendsNull } from './null.mjs';
 import { ExtendsNumber } from './number.mjs';
 import { ExtendsObject } from './object.mjs';
 import { ExtendsPromise } from './promise.mjs';
+import { ExtendsRecord } from './record.mjs';
 import { ExtendsString } from './string.mjs';
 import { ExtendsSymbol } from './symbol.mjs';
 import { ExtendsTemplateLiteral } from './template_literal.mjs';
@@ -46,6 +47,7 @@ import { IsNull } from '../types/null.mjs';
 import { IsNumber } from '../types/number.mjs';
 import { IsObject } from '../types/object.mjs';
 import { IsPromise } from '../types/promise.mjs';
+import { IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
 import { IsString } from '../types/string.mjs';
 import { IsSymbol } from '../types/symbol.mjs';
 import { IsTemplateLiteral } from '../types/template_literal.mjs';
@@ -74,13 +76,14 @@ export function ExtendsLeft(inferred, left, right) {
                                                                 IsNumber(left) ? ExtendsNumber(inferred, left, right) :
                                                                     IsObject(left) ? ExtendsObject(inferred, left.properties, right) :
                                                                         IsPromise(left) ? ExtendsPromise(inferred, left.item, right) :
-                                                                            IsString(left) ? ExtendsString(inferred, left, right) :
-                                                                                IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
-                                                                                    IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
-                                                                                        IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
-                                                                                            IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
-                                                                                                IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
-                                                                                                    IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
-                                                                                                        IsVoid(left) ? ExtendsVoid(inferred, left, right) :
-                                                                                                            Result.ExtendsFalse());
+                                                                            IsRecord(left) ? ExtendsRecord(inferred, RecordPattern(left), RecordValue(left), right) :
+                                                                                IsString(left) ? ExtendsString(inferred, left, right) :
+                                                                                    IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
+                                                                                        IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
+                                                                                            IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
+                                                                                                IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
+                                                                                                    IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
+                                                                                                        IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
+                                                                                                            IsVoid(left) ? ExtendsVoid(inferred, left, right) :
+                                                                                                                Result.ExtendsFalse());
 }

package/build/type/extends/extends_right.mjs

@@ -27,14 +27,14 @@ function ExtendsRightEnum(inferred, left, right) {
     return ExtendsLeft(inferred, left, evaluated);
 }
 function ExtendsRightIntersect(inferred, left, right) {
-    return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
+    return Guard.ShiftLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 function ExtendsRightTemplateLiteral(inferred, left, right) {
     const evaluated = EvaluateTemplateLiteral(right);
     return ExtendsLeft(inferred, left, evaluated);
 }
 function ExtendsRightUnion(inferred, left, right) {
-    return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
+    return Guard.ShiftLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
 }
 export function ExtendsRight(inferred, left, right) {
     return (IsAny(right) ? ExtendsRightAny(inferred, left) :

package/build/type/extends/inference.mjs

@@ -46,7 +46,7 @@ export function TryInferable(type) {
         undefined);
 }
 function TryInferResults(rest, right, result = []) {
-    return Guard.TakeLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
+    return Guard.ShiftLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/build/type/extends/object.d.mts

@@ -6,6 +6,8 @@ import { type TOptional } from '../types/_optional.mjs';
 import { type TInfer } from '../types/infer.mjs';
 import { type TNever } from '../types/never.mjs';
 import { type TObject } from '../types/object.mjs';
+import { type TRecord } from '../types/record.mjs';
+import { type TUnion } from '../types/union.mjs';
 import { type TExtendsLeft } from './extends_left.mjs';
 import { type TExtendsRight } from './extends_right.mjs';
 import { type TUnionToTuple } from '../engine/helpers/union.mjs';
@@ -20,6 +22,11 @@ type TExtendsPropertiesComparer<Inferred extends TProperties, Left extends TProp
 }, Checked extends boolean = Properties[keyof Right] extends Result.TExtendsTrueLike ? true : false, Extracted extends TProperties = Checked extends true ? TExtractInferredProperties<TUnionToTuple<keyof Properties>, Properties> : {}> = (Checked extends true ? Result.TExtendsTrue<Extracted> : Result.TExtendsFalse);
 type TExtendsProperties<Inferred extends TProperties, Left extends TProperties, Right extends TProperties, Compared extends Result.TResult = TExtendsPropertiesComparer<Inferred, Left, Right>> = (Compared extends Result.TExtendsTrueLike<infer ComparedInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Inferred, ComparedInferred>> : Result.TExtendsFalse);
 type TExtendsObjectToObject<Inferred extends TProperties, Left extends TProperties, Right extends TProperties> = (TExtendsProperties<Inferred, Left, Right>);
-export type TExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema> = (Right extends TObject<infer Properties extends TProperties> ? TExtendsObjectToObject<Inferred, Left, Properties> : TExtendsRight<Inferred, TObject<Left>, Right>);
+type TRecordMergeInferred<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
+    [Key in keyof Right]: Key extends keyof Left ? Left[Key] extends TUnion<infer Types extends TSchema[]> ? TUnion<[...Types, Right[Key]]> : TUnion<[Left[Key], Right[Key]]> : Right[Key];
+}> = Result;
+type TExtendsRecordComparer<Properties extends TProperties, Keys extends (keyof Properties)[], Type extends TSchema, Result extends TProperties> = (Keys extends [infer Left extends (keyof Properties), ...infer Right extends (keyof Properties)[]] ? TExtendsLeft<{}, Properties[Left], Type> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsRecordComparer<Properties, Right, Type, TRecordMergeInferred<Result, Inferred>> : Result.TExtendsFalse : Result.TExtendsTrue<Result>);
+type TExtendsObjectToRecord<Inferred extends TProperties, Properties extends TProperties, _Pattern extends string, Value extends TSchema, Keys extends (keyof Properties)[] = TUnionToTuple<keyof Properties>, Result extends Result.TResult = TExtendsRecordComparer<Properties, Keys, Value, Inferred>> = Result;
+export type TExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema> = (Right extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TExtendsObjectToRecord<Inferred, Left, Pattern, Value> : Right extends TObject<infer Properties extends TProperties> ? TExtendsObjectToObject<Inferred, Left, Properties> : TExtendsRight<Inferred, TObject<Left>, Right>);
 export declare function ExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsObject<Inferred, Left, Right>;
 export {};

package/build/type/extends/object.mjs

@@ -7,6 +7,8 @@ import { IsOptional } from '../types/_optional.mjs';
 import { IsInfer } from '../types/infer.mjs';
 import { IsNever } from '../types/never.mjs';
 import { IsObject, Object } from '../types/object.mjs';
+import { IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
+import { Union, IsUnion } from '../types/union.mjs';
 import { ExtendsLeft } from './extends_left.mjs';
 import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
@@ -80,8 +82,28 @@ function ExtendsProperties(inferred, left, right) {
 function ExtendsObjectToObject(inferred, left, right) {
     return ExtendsProperties(inferred, left, right);
 }
+function RecordMergeInferred(left, right) {
+    return Guard.Keys(right).reduce((result, key) => {
+        return {
+            ...result, [key]: Guard.HasPropertyKey(left, key)
+                ? IsUnion(result[key])
+                    // @ts-ignore 5.0.4 cannot see `.anyOf`
+                    ? Union([...result[key].anyOf, right[key]])
+                    : Union([left[key], right[key]])
+                : right[key]
+        };
+    }, left);
+}
+function ExtendsRecordComparer(properties, keys, type, result) {
+    return Guard.ShiftLeft(keys, (left, right) => Result.Match(ExtendsLeft({}, properties[left], type), inferred => ExtendsRecordComparer(properties, right, type, RecordMergeInferred(result, inferred)), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(result));
+}
+function ExtendsObjectToRecord(inferred, properties, _pattern, value) {
+    const keys = Guard.Keys(properties);
+    const result = ExtendsRecordComparer(properties, keys, value, inferred);
+    return result;
+}
 export function ExtendsObject(inferred, left, right) {
-    return (IsObject(right)
-        ? ExtendsObjectToObject(inferred, left, right.properties)
-        : ExtendsRight(inferred, Object(left), right));
+    return (IsRecord(right) ? ExtendsObjectToRecord(inferred, left, RecordPattern(right), RecordValue(right)) :
+        IsObject(right) ? ExtendsObjectToObject(inferred, left, right.properties) :
+            ExtendsRight(inferred, Object(left), right));
 }

package/build/type/extends/parameters.mjs

@@ -16,12 +16,12 @@ function ParameterCompare(inferred, left, leftRest, right, rightRest) {
     );
 }
 function ParameterRight(inferred, left, leftRest, rightRest) {
-    return Guard.TakeLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
+    return Guard.ShiftLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
         ? Result.ExtendsTrue(inferred) // 'ok: left was optional'
         : Result.ExtendsFalse()); // 'fail: left was required'
 }
 function ParametersLeft(inferred, left, rightRest) {
-    return Guard.TakeLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
+    return Guard.ShiftLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
 }
 export function ExtendsParameters(inferred, left, right) {
     return ParametersLeft(inferred, left, right);

package/build/type/extends/record.d.mts

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TObject } from '../types/object.mjs';
+import { type TRecordPatternToType, type TRecord } from '../types/record.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+export type TFromObject<Inferred extends TProperties, Properties extends TProperties> = keyof Properties extends never ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse;
+type TFromRecord<Inferred extends TProperties, _LeftKey extends TSchema, LeftValue extends TSchema, _RightKey extends TSchema, RightValue extends TSchema> = (TExtendsLeft<Inferred, LeftValue, RightValue>);
+export type TExtendsRecord<Inferred extends TProperties, LeftPattern extends string, LeftValue extends TSchema, Right extends TSchema> = (Right extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TFromRecord<Inferred, TRecordPatternToType<LeftPattern>, LeftValue, TRecordPatternToType<Pattern>, Value> : Right extends TObject<infer Properties extends TProperties> ? TFromObject<Inferred, Properties> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+export declare function ExtendsRecord<Inferred extends TProperties, Pattern extends string, Value extends TSchema, Right extends TSchema>(inferred: Inferred, leftPattern: Pattern, leftValue: Value, right: Right): TExtendsRecord<Inferred, Pattern, Value, Right>;
+export {};

package/build/type/extends/record.mjs

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsAny } from '../types/any.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import { IsObject } from '../types/object.mjs';
+import { IsRecord, RecordPatternToType, RecordPattern, RecordValue } from '../types/record.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+function FromObject(inferred, properties) {
+    return (Guard.IsEqual(Guard.Keys(properties).length, 0)
+        ? Result.ExtendsTrue(inferred)
+        : Result.ExtendsFalse());
+}
+function FromRecord(inferred, _leftKey, leftValue, _rightKey, rightValue) {
+    return ExtendsLeft(inferred, leftValue, rightValue);
+}
+export function ExtendsRecord(inferred, leftPattern, leftValue, right) {
+    return (IsRecord(right) ? FromRecord(inferred, RecordPatternToType(leftPattern), leftValue, RecordPatternToType(RecordPattern(right)), RecordValue(right)) :
+        IsObject(right) ? FromObject(inferred, right.properties) :
+            IsAny(right) ? Result.ExtendsTrue(inferred) :
+                IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+                    Result.ExtendsFalse());
+}

package/build/type/extends/tuple.mjs

@@ -32,10 +32,10 @@ function ElementsLeft(inferred, reversed, leftRest, right, rightRest) {
     // Rest Inferrable Right Means we delegate to TInferTupleResult to Generate a Result
     IsInferable(inferable)
         ? InferTupleResult(inferred, inferable['name'], ApplyReverse(leftRest, reversed), inferable['type'])
-        : Guard.TakeLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
+        : Guard.ShiftLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
 }
 function ElementsRight(inferred, reversed, leftRest, rightRest) {
-    return Guard.TakeLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
+    return Guard.ShiftLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
         ? Result.ExtendsTrue(inferred) // 'Ok: right-empty-and-left-empty'
         : Result.ExtendsFalse()); // 'Fail: right-empty-and-left-not-empty'
 }
@@ -51,7 +51,7 @@ function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+        : Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
 }
 export function ExtendsTuple(inferred, left, right) {
     const instantiatedLeft = InstantiateElements(inferred, State([], []), left);

package/build/type/extends/union.mjs

@@ -8,10 +8,10 @@ import * as Result from './result.mjs';
 // ----------------------------------------------------------------------------
 import { IsInferable, TryInferable, InferUnionResult } from './inference.mjs';
 function ExtendsUnionSome(inferred, type, unionTypes) {
-    return Guard.TakeLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
+    return Guard.ShiftLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
 }
 function ExtendsUnionLeft(inferred, left, right) {
-    return Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
+    return Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 export function ExtendsUnion(inferred, left, right) {
     const inferrable = TryInferable(right);

package/build/type/script/token/internal/guard.d.mts

@@ -1 +1 @@
-export { IsArray, IsEqual, IsString, TakeLeft } from '../../../../guard/guard.mjs';
+export { IsArray, IsEqual, IsString, ShiftLeft } from '../../../../guard/guard.mjs';

package/build/type/script/token/internal/guard.mjs

@@ -1,5 +1,5 @@
 // deno-coverage-ignore-start - parsebox tested
-export { IsArray, IsEqual, IsString, TakeLeft } from '../../../../guard/guard.mjs';
+export { IsArray, IsEqual, IsString, ShiftLeft } from '../../../../guard/guard.mjs';
 // ------------------------------------------------------------------
 // Internal Guards to ensure Token is portable.
 // ------------------------------------------------------------------

package/build/type/script/token/internal/take.mjs

@@ -12,7 +12,7 @@ export function Take(variants, input) {
     // ----------------------------------------------------------------
     // Symmetric
     // ----------------------------------------------------------------
-    // return Guard.TakeLeft(variants, (valueLeft, valueRight) => 
+    // return Guard.ShiftLeft(variants, (valueLeft, valueRight) => 
     //   Match(TakeVariant(valueLeft, input), (take, rest) => 
     //     [take, rest],
     //     () => Take(valueRight, input)),

package/build/type/script/token/until.mjs

@@ -1,13 +1,13 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
 import { Match } from './internal/match.mjs';
-import { IsEqual, TakeLeft } from './internal/guard.mjs';
+import { IsEqual, ShiftLeft } from './internal/guard.mjs';
 function TakeOne(input) {
     const result = IsEqual(input, '') ? [] : [input.slice(0, 1), input.slice(1)];
     return result;
 }
 function IsInputMatchSentinal(end, input) {
-    return TakeLeft(end, (left, right) => input.startsWith(left)
+    return ShiftLeft(end, (left, right) => input.startsWith(left)
         ? true
         : IsInputMatchSentinal(right, input), () => false);
 }

package/build/type/types/record.d.mts

@@ -31,15 +31,21 @@ export declare function RecordDeferred<Key extends TSchema, Value extends TSchem
 export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordAction<Key, Value>;
 /** Creates a Record type from regular expression pattern. */
 export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(key: Pattern, value: Value): TRecord<Pattern, Value>;
-/** Returns the raw string pattern used for the Record key  */
+/** Transforms a Record Pattern to a Type */
+export type TRecordPatternToType<Pattern extends string, Result extends TSchema = (Pattern extends typeof StringKey ? TString : Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TTemplateLiteralDecodeUnsafe<Pattern>)> = Result;
+/** Transforms a Record Pattern to a Type */
+export declare function RecordPatternToType<Pattern extends string>(pattern: Pattern): TRecordPatternToType<Pattern>;
+/** Extracts the Pattern from a Record type */
 export type TRecordPattern<Type extends TRecord, Result extends string = Extract<keyof Type['patternProperties'], string>> = Result;
-/** Returns the raw string pattern used for the Record key  */
+/** Extracts the Pattern from a Record type */
 export declare function RecordPattern<Type extends TRecord>(type: Type): TRecordPattern<Type>;
-/** Returns the Record key as a TypeBox type  */
-export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = (Pattern extends typeof StringKey ? TString : Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TTemplateLiteralDecodeUnsafe<Pattern>)> = Result;
-/** Returns the Record key as a TypeBox type  */
+/** Extracts the Key from a Record type */
+export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = TRecordPatternToType<Pattern>> = Result;
+/** Extracts the Key from a Record type */
 export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
+/** Extracts the Value from a Record type */
 export type TRecordValue<Type extends TRecord, Result extends TSchema = Type['patternProperties'][TRecordPattern<Type>]> = Result;
+/** Extracts the Value from a Record type */
 export declare function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type>;
 export declare function IsRecord(value: unknown): value is TRecord;
 export declare function RecordOptions(type: TRecord): TObjectOptions;

package/build/type/types/record.mjs

@@ -30,19 +30,25 @@ export function Record(key, value, options = {}) {
 export function RecordFromPattern(key, value) {
     return CreateRecord(key, value);
 }
-/** Returns the raw string pattern used for the Record key  */
+/** Transforms a Record Pattern to a Type */
+export function RecordPatternToType(pattern) {
+    const result = (Guard.IsEqual(pattern, StringKey) ? String() :
+        Guard.IsEqual(pattern, IntegerKey) ? Integer() :
+            Guard.IsEqual(pattern, NumberKey) ? Number() :
+                TemplateLiteralDecodeUnsafe(pattern));
+    return result;
+}
+/** Extracts the Pattern from a Record type */
 export function RecordPattern(type) {
     return Guard.Keys(type.patternProperties)[0];
 }
-/** Returns the Record key as a TypeBox type  */
+/** Extracts the Key from a Record type */
 export function RecordKey(type) {
     const pattern = RecordPattern(type);
-    const result = (Guard.IsEqual(pattern, StringKey) ? String() :
-        Guard.IsEqual(pattern, IntegerKey) ? Integer() :
-            Guard.IsEqual(pattern, NumberKey) ? Number() :
-                TemplateLiteralDecodeUnsafe(pattern));
+    const result = RecordPatternToType(pattern);
     return result;
 }
+/** Extracts the Value from a Record type */
 export function RecordValue(type) {
     return type.patternProperties[RecordPattern(type)];
 }

package/build/value/shared/union_priority_sort.mjs

@@ -26,7 +26,7 @@ function DeterministicCompare(left, right) {
 // ------------------------------------------------------------------
 /** Deterministically sorts schemas by structural relationship (narrow to broad) */
 export function UnionPrioritySort(types, order = 1) {
-    return types.sort((left, right) => {
+    return [...types].sort((left, right) => {
         const result = Compare(left, right);
         return (Guard.IsEqual(result, 'disjoint') ? DeterministicCompare(left, right) :
             Guard.IsEqual(result, 'right-inside') ? 1 :

package/package.json

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