@sinclair/typebox 0.32.4 → 0.32.6

package/build/import/type/pick/pick.d.mts

@@ -8,15 +8,13 @@ import type { TMappedKey, TMappedResult } from '../mapped/index.mjs';
 import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { type TPickFromMappedKey } from './pick-from-mapped-key.mjs';
 import { type TPickFromMappedResult } from './pick-from-mapped-result.mjs';
-type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromIntersect<R, K, [...Acc, PickResolve<L, K>]> : Acc;
+type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromIntersect<R, K, [...Acc, TPick<L, K>]> : Acc;
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K, []>;
-type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, PickResolve<L, K>]> : Acc;
+type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, TPick<L, K>]> : Acc;
 declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K, []>;
 type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
 declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): {};
-export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
-export declare function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
-export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
+export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */

package/build/import/type/pick/pick.mjs

@@ -24,8 +24,11 @@ function FromProperties(T, K) {
         return K in T ? { ...Acc, [K]: T[K] } : Acc;
     }, {});
 }
+// ------------------------------------------------------------------
+// PickResolve
+// ------------------------------------------------------------------
 // prettier-ignore
-export function PickResolve(T, K) {
+function PickResolve(T, K) {
     return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) :
         IsUnion(T) ? Union(FromUnion(T.anyOf, K)) :
             IsObject(T) ? Object(FromProperties(T.properties, K)) :

package/build/import/type/required/required-from-mapped-result.d.mts

@@ -1,11 +1,12 @@
 import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TRequired } from './required.mjs';
 type TFromProperties<P extends TProperties> = ({
     [K2 in keyof P]: TRequired<P[K2]>;
 });
-type TFromMappedResult<R extends TMappedResult> = (TFromProperties<R['properties']>);
-export type TRequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (TMappedResult<P>);
+type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
+export type TRequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
 export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/static/static.d.mts

@@ -19,13 +19,13 @@ import type { TUnion } from '../union/index.mjs';
 import type { TUnsafe } from '../unsafe/index.mjs';
 import type { TSchema } from '../schema/index.mjs';
 import type { TTransform } from '../transform/index.mjs';
-export type DecodeProperties<T extends TProperties> = {
-    [K in keyof T]: DecodeType<T[K]>;
+export type TDecodeProperties<T extends TProperties> = {
+    [K in keyof T]: TDecodeType<T[K]>;
 };
-export type DecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? DecodeRest<R, [...Acc, DecodeType<L>]> : Acc;
-export type DecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> : T);
+export type TDecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TDecodeRest<R, [...Acc, TDecodeType<L>]> : Acc;
+export type TDecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<TDecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<TDecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<TDecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<TDecodeRest<P>, TDecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<TDecodeRest<P>, TDecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TDecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<TDecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<TDecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<TDecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> : T);
 /** Creates an decoded static type from a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>;
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<TDecodeType<T>, P>;
 /** Creates an encoded static type from a TypeBox type */
 export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>;
 /** Creates a static type from a TypeBox type */

package/build/import/value/clean/clean.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index.mjs';
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T): unknown;
+export declare function Clean(schema: TSchema, value: unknown): unknown;

package/build/import/value/convert/convert.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index.mjs';
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
-export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Convert(schema: TSchema, value: unknown): unknown;

package/build/import/value/default/default.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index.mjs';
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Default(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Default(schema: TSchema, value: unknown): unknown;

package/build/import/value/value/value.d.mts

@@ -16,13 +16,13 @@ export declare function Check<T extends TSchema>(schema: T, references: TSchema[
 /** Returns true if the value matches the given type */
 export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Clean<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Clean(schema: TSchema, value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible */
-export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
-export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
 /** Decodes a value or throws if error */
@@ -30,9 +30,9 @@ export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T
 /** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Default(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
-export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+export declare function Default(schema: TSchema, value: unknown): unknown;
 /** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
 /** Encodes a value or throws if error */

package/build/require/index.d.ts

@@ -18,19 +18,19 @@ export { Date, type TDate, type DateOptions } from './type/date/index';
 export { Deref, type TDeref } from './type/deref/index';
 export { Enum, type TEnum } from './type/enum/index';
 export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index';
-export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index';
+export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index';
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index';
 export { Function, type TFunction } from './type/function/index';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
-export { Index, IndexPropertyKeys, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from './type/indexed/index';
+export { Index, IndexPropertyKeys, IndexFromPropertyKeys, IndexFromPropertyKey, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromPropertyKeys, type TIndexFromPropertyKey, type TIndexFromMappedKey, type TIndexFromMappedResult, } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
 export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index';
 export { Iterator, type TIterator } from './type/iterator/index';
 export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
-export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
+export { KeyOf, KeyOfPropertyKeys, KeyOfPropertyKeysToRest, KeyOfFromMappedResult, KeyOfPattern, type TKeyOf, type TKeyOfPropertyKeys, type TKeyOfPropertyKeysToRest, type TKeyOfFromMappedResult } from './type/keyof/index';
 export { Literal, type TLiteral, type TLiteralValue } from './type/literal/index';
-export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index';
+export { Mapped, MappedKey, MappedResult, MappedFunctionReturnType, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction, type TMappedFunctionReturnType } from './type/mapped/index';
 export { Never, type TNever } from './type/never/index';
 export { Not, type TNot } from './type/not/index';
 export { Null, type TNull } from './type/null/index';
@@ -44,7 +44,7 @@ export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult }
 export { Promise, type TPromise } from './type/promise/index';
 export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';
-export { Record, type TRecord } from './type/record/index';
+export { Record, type TRecord, type TRecordOrObject } from './type/record/index';
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index';
 export { Ref, type TRef } from './type/ref/index';
 export { RegExp, type TRegExp } from './type/regexp/index';
@@ -52,11 +52,11 @@ export { Required, type TRequired, type TRequiredFromMappedResult } from './type
 export { Rest, type TRest } from './type/rest/index';
 export { ReturnType, type TReturnType } from './type/return-type/index';
 export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index';
-export { type Static, type StaticDecode, type StaticEncode } from './type/static/index';
+export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, type TDecodeRest, type TDecodeProperties } from './type/static/index';
 export { Strict } from './type/strict/index';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index';
 export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index';
-export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, type TTemplateLiteral, type TIsTemplateLiteralFinite, type TTemplateLiteralGenerate, type TTemplateLiteralKind, } from './type/template-literal/index';
+export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, type TTemplateLiteral, type TTemplateLiteralSyntax, type TTemplateLiteralGenerate, type TTemplateLiteralKind, type TIsTemplateLiteralFinite, } from './type/template-literal/index';
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index';
 export { Tuple, type TTuple } from './type/tuple/index';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';

package/build/require/index.js

@@ -1,9 +1,9 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntrinsicFromMappedKey = exports.Intrinsic = exports.Iterator = exports.IntersectEvaluated = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedResult = exports.IndexFromMappedKey = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.TypeBoxError = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
-exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralExpressionGenerate = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralExpressionFinite = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.ReadonlyFromMappedResult = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.OptionalFromMappedResult = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = void 0;
-exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = void 0;
+exports.Iterator = exports.IntersectEvaluated = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedResult = exports.IndexFromMappedKey = exports.IndexFromPropertyKey = exports.IndexFromPropertyKeys = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.TypeBoxError = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
+exports.IsTemplateLiteralExpressionFinite = exports.TemplateLiteralExpressionGenerate = exports.IsTemplateLiteralFinite = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralGenerate = exports.TemplateLiteralSyntax = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.ReadonlyFromMappedResult = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.OptionalFromMappedResult = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedFunctionReturnType = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfFromMappedResult = exports.KeyOfPropertyKeysToRest = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.IntrinsicFromMappedKey = exports.Intrinsic = void 0;
+exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = void 0;
 // ------------------------------------------------------------------
 // Infrastructure
 // ------------------------------------------------------------------
@@ -76,6 +76,8 @@ Object.defineProperty(exports, "Increment", { enumerable: true, get: function ()
 var index_24 = require("./type/indexed/index");
 Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_24.Index; } });
 Object.defineProperty(exports, "IndexPropertyKeys", { enumerable: true, get: function () { return index_24.IndexPropertyKeys; } });
+Object.defineProperty(exports, "IndexFromPropertyKeys", { enumerable: true, get: function () { return index_24.IndexFromPropertyKeys; } });
+Object.defineProperty(exports, "IndexFromPropertyKey", { enumerable: true, get: function () { return index_24.IndexFromPropertyKey; } });
 Object.defineProperty(exports, "IndexFromMappedKey", { enumerable: true, get: function () { return index_24.IndexFromMappedKey; } });
 Object.defineProperty(exports, "IndexFromMappedResult", { enumerable: true, get: function () { return index_24.IndexFromMappedResult; } });
 var index_25 = require("./type/instance-type/index");
@@ -97,6 +99,8 @@ Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function ()
 var index_30 = require("./type/keyof/index");
 Object.defineProperty(exports, "KeyOf", { enumerable: true, get: function () { return index_30.KeyOf; } });
 Object.defineProperty(exports, "KeyOfPropertyKeys", { enumerable: true, get: function () { return index_30.KeyOfPropertyKeys; } });
+Object.defineProperty(exports, "KeyOfPropertyKeysToRest", { enumerable: true, get: function () { return index_30.KeyOfPropertyKeysToRest; } });
+Object.defineProperty(exports, "KeyOfFromMappedResult", { enumerable: true, get: function () { return index_30.KeyOfFromMappedResult; } });
 Object.defineProperty(exports, "KeyOfPattern", { enumerable: true, get: function () { return index_30.KeyOfPattern; } });
 var index_31 = require("./type/literal/index");
 Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return index_31.Literal; } });
@@ -104,6 +108,7 @@ var index_32 = require("./type/mapped/index");
 Object.defineProperty(exports, "Mapped", { enumerable: true, get: function () { return index_32.Mapped; } });
 Object.defineProperty(exports, "MappedKey", { enumerable: true, get: function () { return index_32.MappedKey; } });
 Object.defineProperty(exports, "MappedResult", { enumerable: true, get: function () { return index_32.MappedResult; } });
+Object.defineProperty(exports, "MappedFunctionReturnType", { enumerable: true, get: function () { return index_32.MappedFunctionReturnType; } });
 var index_33 = require("./type/never/index");
 Object.defineProperty(exports, "Never", { enumerable: true, get: function () { return index_33.Never; } });
 var index_34 = require("./type/not/index");
@@ -155,12 +160,13 @@ var index_55 = require("./type/symbol/index");
 Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return index_55.Symbol; } });
 var index_56 = require("./type/template-literal/index");
 Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_56.TemplateLiteral; } });
-Object.defineProperty(exports, "IsTemplateLiteralFinite", { enumerable: true, get: function () { return index_56.IsTemplateLiteralFinite; } });
-Object.defineProperty(exports, "IsTemplateLiteralExpressionFinite", { enumerable: true, get: function () { return index_56.IsTemplateLiteralExpressionFinite; } });
+Object.defineProperty(exports, "TemplateLiteralSyntax", { enumerable: true, get: function () { return index_56.TemplateLiteralSyntax; } });
+Object.defineProperty(exports, "TemplateLiteralGenerate", { enumerable: true, get: function () { return index_56.TemplateLiteralGenerate; } });
 Object.defineProperty(exports, "TemplateLiteralParse", { enumerable: true, get: function () { return index_56.TemplateLiteralParse; } });
 Object.defineProperty(exports, "TemplateLiteralParseExact", { enumerable: true, get: function () { return index_56.TemplateLiteralParseExact; } });
-Object.defineProperty(exports, "TemplateLiteralGenerate", { enumerable: true, get: function () { return index_56.TemplateLiteralGenerate; } });
+Object.defineProperty(exports, "IsTemplateLiteralFinite", { enumerable: true, get: function () { return index_56.IsTemplateLiteralFinite; } });
 Object.defineProperty(exports, "TemplateLiteralExpressionGenerate", { enumerable: true, get: function () { return index_56.TemplateLiteralExpressionGenerate; } });
+Object.defineProperty(exports, "IsTemplateLiteralExpressionFinite", { enumerable: true, get: function () { return index_56.IsTemplateLiteralExpressionFinite; } });
 var index_57 = require("./type/transform/index");
 Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_57.Transform; } });
 Object.defineProperty(exports, "TransformDecodeBuilder", { enumerable: true, get: function () { return index_57.TransformDecodeBuilder; } });

package/build/require/type/awaited/awaited.d.ts

@@ -2,9 +2,8 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TPromise } from '../promise/index';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TFromSchema<L>]> : Acc;
-type TFromSchema<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TPromise<infer S> ? TFromSchema<S> : T;
-export type TAwaited<T extends TSchema> = (TFromSchema<T>);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TAwaited<L>]> : Acc;
+export type TAwaited<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TPromise<infer S> ? TAwaited<S> : T;
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TFromSchema<T>;
+export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TAwaited<T>;
 export {};

package/build/require/type/awaited/awaited.js

@@ -11,7 +11,7 @@ const type_1 = require("../clone/type");
 const type_2 = require("../guard/type");
 // prettier-ignore
 function FromRest(T) {
-    return T.map(L => FromSchema(L));
+    return T.map(L => AwaitedResolve(L));
 }
 // prettier-ignore
 function FromIntersect(T) {
@@ -23,10 +23,13 @@ function FromUnion(T) {
 }
 // prettier-ignore
 function FromPromise(T) {
-    return FromSchema(T);
+    return AwaitedResolve(T);
 }
+// ----------------------------------------------------------------
+// AwaitedResolve
+// ----------------------------------------------------------------
 // prettier-ignore
-function FromSchema(T) {
+function AwaitedResolve(T) {
     return ((0, type_2.IsIntersect)(T) ? FromIntersect(T.allOf) :
         (0, type_2.IsUnion)(T) ? FromUnion(T.anyOf) :
             (0, type_2.IsPromise)(T) ? FromPromise(T.item) :
@@ -34,6 +37,6 @@ function FromSchema(T) {
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
 function Awaited(T, options = {}) {
-    return (0, type_1.CloneType)(FromSchema(T), options);
+    return (0, type_1.CloneType)(AwaitedResolve(T), options);
 }
 exports.Awaited = Awaited;

package/build/require/type/composite/composite.d.ts

@@ -1,4 +1,4 @@
-import type { UnionToTuple, Assert, Evaluate } from '../helpers/index';
+import type { UnionToTuple, Assert, Ensure, Evaluate } from '../helpers/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TIndex } from '../indexed/index';
@@ -7,8 +7,7 @@ type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc ex
     [_ in L]: TIndex<T, [L]>;
 }> : Acc;
 type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
-export type TComposite<T extends TObject[]> = TCompositeResolve<T>;
+export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect ? Ensure<TObject<TCompositeReduce<T>>> : Ensure<TObject<{}>>;
 /** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
 export {};

package/build/require/type/composite/composite.js

@@ -6,15 +6,11 @@ const index_1 = require("../object/index");
 const index_2 = require("../intersect/index");
 const index_3 = require("../indexed/index");
 const index_4 = require("../keyof/index");
-const type_1 = require("../clone/type");
-function CompositeResolve(T) {
+/** `[Json]` Creates a Composite object type */
+function Composite(T, options) {
     const intersect = (0, index_2.Intersect)(T, {});
     const keys = (0, index_4.KeyOfPropertyKeys)(intersect);
     const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, index_3.Index)(intersect, [key]) }), {});
-    return (0, index_1.Object)(properties);
-}
-/** `[Json]` Creates a Composite object type */
-function Composite(T, options) {
-    return (0, type_1.CloneType)(CompositeResolve(T), options);
+    return (0, index_1.Object)(properties, options);
 }
 exports.Composite = Composite;

package/build/require/type/deref/deref.d.ts

@@ -11,14 +11,12 @@ import type { TConstructor } from '../constructor/index';
 import type { TFunction } from '../function/index';
 import type { TRef } from '../ref/index';
 import type { TObject, TProperties } from '../object/index';
-export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, DerefResolve<L>]> : Acc);
+export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TDeref<L>]> : Acc);
 type FromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: DerefResolve<T[K]>;
+    [K in keyof T]: TDeref<T[K]>;
 }>;
 declare function FromProperties(properties: TProperties, references: TSchema[]): TProperties;
-export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
-export declare function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
-export type TDeref<T extends TSchema> = DerefResolve<T>;
+export type TDeref<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, TDeref<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, TDeref<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<TDeref<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDeref<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDeref<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDeref<S>> : T extends TRef<infer S extends TSchema> ? TDeref<S> : T;
 /** `[Json]` Creates a dereferenced type */
 export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
 export {};

package/build/require/type/deref/deref.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deref = exports.DerefResolve = void 0;
+exports.Deref = void 0;
 const type_1 = require("../clone/type");
 const index_1 = require("../discard/index");
 const value_1 = require("../guard/value");
@@ -95,7 +95,9 @@ function DerefResolve(schema, references) {
                                             (0, type_2.IsRef)(schema) ? FromRef(schema, references) :
                                                 schema);
 }
-exports.DerefResolve = DerefResolve;
+// ------------------------------------------------------------------
+// TDeref
+// ------------------------------------------------------------------
 /** `[Json]` Creates a dereferenced type */
 function Deref(schema, references) {
     return DerefResolve((0, type_1.CloneType)(schema), (0, type_1.CloneRest)(references));

package/build/require/type/exclude/exclude.d.ts

@@ -11,14 +11,11 @@ import { type TExcludeFromMappedResult } from './exclude-from-mapped-result';
 type TExcludeTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
-type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never);
-type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
-    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
+type TExcludeTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (Exclude<Static<L>, Static<R>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never);
+type TExcludeRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? never : L[K];
 }[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
-type TExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
-export type TExclude<T extends TSchema, U extends TSchema> = TExcludeResolve<T, U>;
+export type TExclude<L extends TSchema, R extends TSchema> = (L extends TMappedResult<L> ? TExcludeFromMappedResult<L, R> : L extends TTemplateLiteral ? TExcludeTemplateLiteral<L, R> : L extends TUnion<infer S> ? TExcludeRest<S, R> : L extends R ? TNever : L);
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
-/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+export declare function Exclude<L extends TSchema, R extends TSchema>(L: L, R: R, options?: SchemaOptions): TExclude<L, R>;
 export {};

package/build/require/type/exclude/exclude.js

@@ -12,25 +12,17 @@ const exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
 // TypeGuard
 // ------------------------------------------------------------------
 const type_2 = require("../guard/type");
-// prettier-ignore
-function ExcludeResolve(L, R) {
-    return ((0, type_2.IsTemplateLiteral)(L) ? ExcludeResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
-        (0, type_2.IsTemplateLiteral)(R) ? ExcludeResolve(L, (0, index_1.TemplateLiteralToUnion)(R)) :
-            (0, type_2.IsUnion)(L) ? (() => {
-                const narrowed = L.anyOf.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) === index_4.ExtendsResult.False);
-                return (narrowed.length === 1 ? narrowed[0] : (0, index_2.Union)(narrowed));
-            })() :
-                (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? (0, index_3.Never)() :
-                    L);
+function ExcludeRest(L, R) {
+    const excluded = L.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) === index_4.ExtendsResult.False);
+    return excluded.length === 1 ? excluded[0] : (0, index_2.Union)(excluded);
 }
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-function Exclude(unionType, excludedMembers, options = {}) {
-    if ((0, type_2.IsMappedResult)(unionType)) {
-        return (0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(unionType, excludedMembers, options);
-    }
-    else {
-        const E = ExcludeResolve(unionType, excludedMembers);
-        return (0, type_1.CloneType)(E, options);
-    }
+function Exclude(L, R, options = {}) {
+    // prettier-ignore
+    return (0, type_1.CloneType)(((0, type_2.IsMappedResult)(L) ? (0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(L, R, options) :
+        (0, type_2.IsTemplateLiteral)(L) ? Exclude((0, index_1.TemplateLiteralToUnion)(L), R) :
+            (0, type_2.IsTemplateLiteral)(R) ? Exclude(L, (0, index_1.TemplateLiteralToUnion)(R)) :
+                (0, type_2.IsUnion)(L) ? ExcludeRest(L.anyOf, R) :
+                    (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? (0, index_3.Never)() : L), options);
 }
 exports.Exclude = Exclude;

package/build/require/type/extract/extract.d.ts

@@ -5,19 +5,17 @@ import { type TTemplateLiteral } from '../template-literal/index';
 import { type TLiteral } from '../literal/index';
 import { type TUnion } from '../union/index';
 import { type Static } from '../static/index';
+import { type TNever } from '../never/index';
 import { type TUnionEvaluated } from '../union/index';
 import { type TExtractFromMappedResult } from './extract-from-mapped-result';
-type TFromTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
+type TExtractTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
-type TFromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TFromTemplateLiteralResult<Assert<S, string>> : never;
-type TFromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
-    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
+type TExtractTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = Extract<Static<L>, Static<R>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never;
+type TExtractRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? L[K] : never;
 }[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
-type TExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T, U> : T extends TUnion<infer S> ? TFromArray<S, U> : T);
-export type TExtract<T extends TSchema, U extends TSchema> = TExtractResolve<T, U>;
+export type TExtract<L extends TSchema, U extends TSchema> = (L extends TMappedResult ? TExtractFromMappedResult<L, U> : L extends TTemplateLiteral ? TExtractTemplateLiteral<L, U> : L extends TUnion<infer S> ? TExtractRest<S, U> : L extends U ? L : TNever);
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
-/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+export declare function Extract<L extends TSchema, R extends TSchema>(L: L, R: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

package/build/require/type/extract/extract.js

@@ -12,25 +12,17 @@ const extract_from_mapped_result_1 = require("./extract-from-mapped-result");
 // TypeGuard
 // ------------------------------------------------------------------
 const type_2 = require("../guard/type");
-// prettier-ignore
-function ExtractResolve(L, R) {
-    return ((0, type_2.IsTemplateLiteral)(L) ? ExtractResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
-        (0, type_2.IsTemplateLiteral)(R) ? ExtractResolve(L, (0, index_1.TemplateLiteralToUnion)(R)) :
-            (0, type_2.IsUnion)(L) ? (() => {
-                const narrowed = L.anyOf.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) !== index_4.ExtendsResult.False);
-                return (narrowed.length === 1 ? narrowed[0] : (0, index_2.Union)(narrowed));
-            })() :
-                (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? L :
-                    (0, index_3.Never)());
+function ExtractRest(L, R) {
+    const extracted = L.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) !== index_4.ExtendsResult.False);
+    return extracted.length === 1 ? extracted[0] : (0, index_2.Union)(extracted);
 }
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-function Extract(type, union, options = {}) {
-    if ((0, type_2.IsMappedResult)(type)) {
-        return (0, extract_from_mapped_result_1.ExtractFromMappedResult)(type, union, options);
-    }
-    else {
-        const E = ExtractResolve(type, union);
-        return (0, type_1.CloneType)(E, options);
-    }
+function Extract(L, R, options = {}) {
+    // prettier-ignore
+    return (0, type_1.CloneType)(((0, type_2.IsMappedResult)(L) ? (0, extract_from_mapped_result_1.ExtractFromMappedResult)(L, R, options) :
+        (0, type_2.IsTemplateLiteral)(L) ? Extract((0, index_1.TemplateLiteralToUnion)(L), R) :
+            (0, type_2.IsTemplateLiteral)(R) ? Extract(L, (0, index_1.TemplateLiteralToUnion)(R)) :
+                (0, type_2.IsUnion)(L) ? ExtractRest(L.anyOf, R) :
+                    (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? L : (0, index_3.Never)()), options);
 }
 exports.Extract = Extract;

package/build/require/type/indexed/indexed-from-mapped-key.d.ts

@@ -1,5 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Evaluate } from '../helpers/index';
+import type { Ensure, Evaluate } from '../helpers/index';
 import type { TProperties } from '../object/index';
 import { type TIndex } from './indexed';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
@@ -8,6 +8,6 @@ type TMappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
 };
 type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>> : Acc);
 type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<T, K['keys']>>;
-export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (TMappedResult<P>);
+export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (Ensure<TMappedResult<P>>);
 export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/indexed/indexed.d.ts

@@ -13,7 +13,7 @@ import { type TUnionEvaluated } from '../union/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
 import { type TIndexFromMappedResult } from './indexed-from-mapped-result';
-type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TFromKey<L, K>, TSchema>]> : Acc);
+type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Acc);
 type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
 type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
 type TFromUnionRest<T extends TSchema[]> = T;
@@ -22,9 +22,11 @@ type TFromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T
 type TFromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
 type AssertPropertyKey<T> = Assert<T, string | number>;
 type TFromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
-type TFromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? TFromKey<S, K> : T extends TIntersect<infer S> ? TFromIntersect<S, K> : T extends TUnion<infer S> ? TFromUnion<S, K> : T extends TTuple<infer S> ? TFromTuple<S, K> : T extends TArray<infer S> ? TFromArray<S, K> : T extends TObject<infer S> ? TFromProperty<S, K> : TNever);
-type TFromKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TFromKeys<T, R, [...Acc, Assert<TFromKey<T, L>, TSchema>]> : Acc);
-type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<TFromKeys<T, K>>);
+export type TIndexFromPropertyKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? TIndexFromPropertyKey<S, K> : T extends TIntersect<infer S> ? TFromIntersect<S, K> : T extends TUnion<infer S> ? TFromUnion<S, K> : T extends TTuple<infer S> ? TFromTuple<S, K> : T extends TArray<infer S> ? TFromArray<S, K> : T extends TObject<infer S> ? TFromProperty<S, K> : TNever);
+export declare function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TIndexFromPropertyKey<T, K>;
+export type TIndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TIndexFromPropertyKeys<T, R, [...Acc, Assert<TIndexFromPropertyKey<T, L>, TSchema>]> : Acc);
+export declare function IndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexFromPropertyKeys<T, K>;
+type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<T, K>>);
 declare function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K>;
 export type TIndex<T extends TSchema, K extends PropertyKey[]> = (FromSchema<T, K>);
 /** `[Json]` Returns an Indexed property type for the given keys */