@sinclair/typebox 0.32.0-dev-14 → 0.32.0-dev-15

package/build/import/index.d.mts

@@ -16,18 +16,18 @@ export { ConstructorParameters, type TConstructorParameters } from './type/const
 export { Date, type TDate, type DateOptions } from './type/date/index.mjs';
 export { Deref, type TDeref } from './type/deref/index.mjs';
 export { Enum, type TEnum } from './type/enum/index.mjs';
-export { Exclude, type TExclude } from './type/exclude/index.mjs';
-export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index.mjs';
-export { Extract, type TExtract } from './type/extract/index.mjs';
+export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index.mjs';
+export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index.mjs';
+export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index.mjs';
 export { Function, type TFunction } from './type/function/index.mjs';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index.mjs';
-export { Index, IndexPropertyKeys, IndexMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index.mjs';
 export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
 export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index.mjs';
 export { Iterator, type TIterator } from './type/iterator/index.mjs';
-export { Intrinsic, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index.mjs';
-export { KeyOf, type TKeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
+export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index.mjs';
+export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
 export { Literal, type TLiteral } from './type/literal/index.mjs';
 export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index.mjs';
 export { Never, type TNever } from './type/never/index.mjs';
@@ -35,11 +35,11 @@ export { Not, type TNot } from './type/not/index.mjs';
 export { Null, type TNull } from './type/null/index.mjs';
 export { Number, type TNumber, type NumberOptions } from './type/number/index.mjs';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index.mjs';
-export { Omit, type TOmit, type TOmitMappedResult } from './type/omit/index.mjs';
+export { Omit, type TOmit, type TOmitFromMappedKey } from './type/omit/index.mjs';
 export { Optional, type TOptional } from './type/optional/index.mjs';
 export { Parameters, type TParameters } from './type/parameters/index.mjs';
-export { Partial, type TPartial } from './type/partial/index.mjs';
-export { Pick, type TPick, type TPickMappedResult } from './type/pick/index.mjs';
+export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index.mjs';
+export { Pick, type TPick, type TPickFromMappedKey } from './type/pick/index.mjs';
 export { Promise, type TPromise } from './type/promise/index.mjs';
 export { Readonly, type TReadonly } from './type/readonly/index.mjs';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index.mjs';
@@ -47,7 +47,7 @@ export { Record, type TRecord } from './type/record/index.mjs';
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index.mjs';
 export { Ref, type TRef } from './type/ref/index.mjs';
 export { RegExp, type TRegExp } from './type/regexp/index.mjs';
-export { Required, type TRequired } from './type/required/index.mjs';
+export { Required, type TRequired, type TRequiredFromMappedResult } from './type/required/index.mjs';
 export { Rest, type TRest } from './type/rest/index.mjs';
 export { ReturnType, type TReturnType } from './type/return-type/index.mjs';
 export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index.mjs';

package/build/import/index.mjs

@@ -21,12 +21,12 @@ export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './t
 export { Extract } from './type/extract/index.mjs';
 export { Function } from './type/function/index.mjs';
 export { Increment } from './type/helpers/index.mjs';
-export { Index, IndexPropertyKeys, IndexMappedResult } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexFromMappedKey } from './type/indexed/index.mjs';
 export { InstanceType } from './type/instance-type/index.mjs';
 export { Integer } from './type/integer/index.mjs';
 export { Intersect } from './type/intersect/index.mjs';
 export { Iterator } from './type/iterator/index.mjs';
-export { Intrinsic, Capitalize, Lowercase, Uncapitalize, Uppercase } from './type/intrinsic/index.mjs';
+export { Intrinsic, IntrinsicFromMappedKey, Capitalize, Lowercase, Uncapitalize, Uppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
 export { Literal } from './type/literal/index.mjs';
 export { Mapped, MappedKey, MappedResult } from './type/mapped/index.mjs';
@@ -38,7 +38,7 @@ export { Object } from './type/object/index.mjs';
 export { Omit } from './type/omit/index.mjs';
 export { Optional } from './type/optional/index.mjs';
 export { Parameters } from './type/parameters/index.mjs';
-export { Partial } from './type/partial/index.mjs';
+export { Partial, PartialFromMappedResult } from './type/partial/index.mjs';
 export { Pick } from './type/pick/index.mjs';
 export { Promise } from './type/promise/index.mjs';
 export { Readonly } from './type/readonly/index.mjs';

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

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TExclude } from './exclude.mjs';
+type FromProperties<K extends TProperties, U extends TSchema> = ({
+    [K2 in keyof K]: TExclude<K[K2], U>;
+});
+declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
+type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
+declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
+export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
+export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/import/type/exclude/exclude-from-mapped-result.mjs

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Exclude } from './exclude.mjs';
+function FromProperties(K, U, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Exclude(K[K2], U, options) };
+    }, {});
+}
+function FromMappedResult(K, U, options) {
+    return FromProperties(K.properties, U, options);
+}
+export function ExcludeFromMappedResult(T, U, options) {
+    const P = FromMappedResult(T, U, options);
+    return MappedResult(P);
+}

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

@@ -1,11 +1,13 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
 import { type TTemplateLiteral } from '../template-literal/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TLiteral } from '../literal/index.mjs';
 import { type Static } from '../static/index.mjs';
 import { UnionResolve } from '../union/index.mjs';
+import { type TExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
 type ExcludeTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
@@ -14,7 +16,8 @@ type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTu
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
 }[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
 type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
-export declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
+declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
 export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
+export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
 export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
 export {};

package/build/import/type/exclude/exclude.mjs

@@ -3,8 +3,9 @@ import { Union } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType } from '../guard/type.mjs';
-export function ExcludeResolve(L, R) {
+import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
+import { TMappedResult as IsMappedResultType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType } from '../guard/type.mjs';
+function ExcludeResolve(L, R) {
     return (IsTemplateLiteralType(L) ? ExcludeResolve(TemplateLiteralToUnion(L), R) :
         IsTemplateLiteralType(R) ? ExcludeResolve(L, TemplateLiteralToUnion(R)) :
             IsUnionType(L) ? (() => {
@@ -15,6 +16,11 @@ export function ExcludeResolve(L, R) {
                     L);
 }
 export function Exclude(unionType, excludedMembers, options = {}) {
-    const E = ExcludeResolve(unionType, excludedMembers);
-    return CloneType(E, options);
+    if (IsMappedResultType(unionType)) {
+        return ExcludeFromMappedResult(unionType, excludedMembers, options);
+    }
+    else {
+        const E = ExcludeResolve(unionType, excludedMembers);
+        return CloneType(E, options);
+    }
 }

package/build/import/type/exclude/index.d.mts

@@ -1 +1,2 @@
+export * from './exclude-from-mapped-result.mjs';
 export * from './exclude.mjs';

package/build/import/type/exclude/index.mjs

@@ -1 +1,2 @@
+export * from './exclude-from-mapped-result.mjs';
 export * from './exclude.mjs';

package/build/import/type/extends/extends-from-mapped-key.d.mts

@@ -0,0 +1,17 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import type { Assert } from '../helpers/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import { type TExtends } from './extends.mjs';
+type FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
+    [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
+};
+declare function FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromPropertyKey<K, U, L, R>;
+type FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<LK, U, L, R> & FromPropertyKeys<RK, U, L, R> : {});
+declare function FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R, options: SchemaOptions): FromPropertyKeys<K, U, L, R>;
+type FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (FromPropertyKeys<K['keys'], U, L, R>);
+declare function FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromMappedKey<K, U, L, R>;
+export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/import/type/extends/extends-from-mapped-key.mjs

@@ -0,0 +1,21 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Extends } from './extends.mjs';
+function FromPropertyKey(K, U, L, R, options) {
+    return {
+        [K]: Extends(Literal(K), U, L, R, options)
+    };
+}
+function FromPropertyKeys(K, U, L, R, options) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...FromPropertyKey(LK, U, L, R, options), ...FromPropertyKeys(RK, U, L, R, options) }
+        : {});
+}
+function FromMappedKey(K, U, L, R, options) {
+    return FromPropertyKeys(K.keys, U, L, R, options);
+}
+export function ExtendsFromMappedKey(T, U, L, R, options) {
+    const P = FromMappedKey(T, U, L, R, options);
+    return MappedResult(P);
+}

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

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TExtends } from './extends.mjs';
+type FromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
+    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
+});
+declare function FromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromProperties<K, U, L, R>;
+type FromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (FromProperties<K['properties'], U, L, R>);
+declare function FromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromMappedResult<K, U, L, R>;
+export type TExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedResult<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedResult<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/import/type/extends/extends-from-mapped-result.mjs

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Extends } from './extends.mjs';
+function FromProperties(K, U, L, R, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Extends(K[K2], U, L, R, options) };
+    }, {});
+}
+function FromMappedResult(K, U, L, R, options) {
+    return FromProperties(K.properties, U, L, R, options);
+}
+export function ExtendsFromMappedResult(T, U, L, R, options) {
+    const P = FromMappedResult(T, U, L, R, options);
+    return MappedResult(P);
+}

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

@@ -3,12 +3,12 @@ import type { Static } from '../static/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { TMappedKey, TMappedResult } from '../mapped/index.mjs';
 import { UnionToTuple } from '../helpers/index.mjs';
-import { type TExtendsMappedResult } from './extends-mapped-result.mjs';
-import { type TExtendsMappedResultFromResult } from './extends-mapped-result-from-result.mjs';
+import { type TExtendsFromMappedKey } from './extends-from-mapped-key.mjs';
+import { type TExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
 type ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
 declare function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): ExtendsResolve<L, R, T, U>;
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = ExtendsResolve<L, R, T, F>;
-export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResultFromResult<L, R, T, F>;
-export declare function Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResult<L, R, T, F>;
+export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+export declare function Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
 export declare function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
 export {};

package/build/import/type/extends/extends.mjs

@@ -2,8 +2,8 @@ import { TMappedKey as IsMappedKeyType, TMappedResult as IsMappedResultType } fr
 import { Union } from '../union/index.mjs';
 import { ExtendsCheck, ExtendsResult } from './extends-check.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { ExtendsMappedResult } from './extends-mapped-result.mjs';
-import { ExtendsMappedResultFromResult } from './extends-mapped-result-from-result.mjs';
+import { ExtendsFromMappedKey } from './extends-from-mapped-key.mjs';
+import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = ExtendsCheck(left, right);
     return (R === ExtendsResult.Union ? Union([trueType, falseType]) :
@@ -11,7 +11,7 @@ function ExtendsResolve(left, right, trueType, falseType) {
             falseType);
 }
 export function Extends(L, R, T, F, options = {}) {
-    return (IsMappedResultType(L) ? CloneType(ExtendsMappedResultFromResult(L, R, T, F), options) :
-        IsMappedKeyType(L) ? CloneType(ExtendsMappedResult(L, R, T, F), options) :
+    return (IsMappedResultType(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
+        IsMappedKeyType(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) :
             CloneType(ExtendsResolve(L, R, T, F), options));
 }

package/build/import/type/extends/index.d.mts

@@ -1,5 +1,5 @@
 export * from './extends-check.mjs';
-export * from './extends-mapped-result-from-result.mjs';
-export * from './extends-mapped-result.mjs';
+export * from './extends-from-mapped-key.mjs';
+export * from './extends-from-mapped-result.mjs';
 export * from './extends-undefined.mjs';
 export * from './extends.mjs';

package/build/import/type/extends/index.mjs

@@ -1,5 +1,5 @@
 export * from './extends-check.mjs';
-export * from './extends-mapped-result-from-result.mjs';
-export * from './extends-mapped-result.mjs';
+export * from './extends-from-mapped-key.mjs';
+export * from './extends-from-mapped-result.mjs';
 export * from './extends-undefined.mjs';
 export * from './extends.mjs';

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

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TExtract } from './extract.mjs';
+type FromProperties<K extends TProperties, U extends TSchema> = ({
+    [K2 in keyof K]: TExtract<K[K2], U>;
+});
+declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
+type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
+declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
+export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
+export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/import/type/extract/extract-from-mapped-result.mjs

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Extract } from './extract.mjs';
+function FromProperties(K, U, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Extract(K[K2], U, options) };
+    }, {});
+}
+function FromMappedResult(K, U, options) {
+    return FromProperties(K.properties, U, options);
+}
+export function ExtractFromMappedResult(T, U, options) {
+    const P = FromMappedResult(T, U, options);
+    return MappedResult(P);
+}

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

@@ -1,10 +1,12 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
 import { type TTemplateLiteral } from '../template-literal/index.mjs';
 import { type TLiteral } from '../literal/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type Static } from '../static/index.mjs';
 import { UnionResolve } from '../union/index.mjs';
+import { type TExtractFromMappedResult } from './extract-from-mapped-result.mjs';
 type FromTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
@@ -15,5 +17,6 @@ type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple
 export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
 export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
 export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;
+export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
 export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

package/build/import/type/extract/extract.mjs

@@ -3,7 +3,8 @@ import { Union } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType } from '../guard/type.mjs';
+import { ExtractFromMappedResult } from './extract-from-mapped-result.mjs';
+import { TMappedResult as IsMappedResultType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType } from '../guard/type.mjs';
 export function ExtractResolve(L, R) {
     return (IsTemplateLiteralType(L) ? ExtractResolve(TemplateLiteralToUnion(L), R) :
         IsTemplateLiteralType(R) ? ExtractResolve(L, TemplateLiteralToUnion(R)) :
@@ -15,6 +16,11 @@ export function ExtractResolve(L, R) {
                     Never());
 }
 export function Extract(type, union, options = {}) {
-    const E = ExtractResolve(type, union);
-    return CloneType(E, options);
+    if (IsMappedResultType(type)) {
+        return ExtractFromMappedResult(type, union, options);
+    }
+    else {
+        const E = ExtractResolve(type, union);
+        return CloneType(E, options);
+    }
 }

package/build/import/type/extract/index.d.mts

@@ -1 +1,2 @@
+export * from './extract-from-mapped-result.mjs';
 export * from './extract.mjs';

package/build/import/type/extract/index.mjs

@@ -1 +1,2 @@
+export * from './extract-from-mapped-result.mjs';
 export * from './extract.mjs';

package/build/import/type/indexed/index.d.mts

@@ -1,4 +1,4 @@
-export * from './indexed-mapped-result.mjs';
+export * from './indexed-from-mapped-key.mjs';
 export * from './indexed-property-keys.mjs';
 export * from './indexed-result.mjs';
 export * from './indexed.mjs';

package/build/import/type/indexed/index.mjs

@@ -1,4 +1,4 @@
-export * from './indexed-mapped-result.mjs';
+export * from './indexed-from-mapped-key.mjs';
 export * from './indexed-property-keys.mjs';
 export * from './indexed-result.mjs';
 export * from './indexed.mjs';

package/build/import/type/indexed/{indexed-mapped-result.d.mts → indexed-from-mapped-key.d.mts}

@@ -1,4 +1,4 @@
-import { type TSchema } from '../schema/index.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TProperties } from '../object/index.mjs';
 import { type TIndexResult } from './indexed-result.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
@@ -6,11 +6,11 @@ import { Evaluate } from '../helpers/index.mjs';
 type MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
     [_ in K]: TIndexResult<T, [K]>;
 };
-declare function MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedIndexPropertyKey<T, K>;
+declare function MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): MappedIndexPropertyKey<T, K>;
 type MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIndexPropertyKey<T, L> & MappedIndexPropertyKeys<T, R> : {});
-declare function MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): MappedIndexPropertyKeys<T, K>;
+declare function MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): MappedIndexPropertyKeys<T, K>;
 type MappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<MappedIndexPropertyKeys<T, K['keys']>>;
-declare function MappedIndexProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K): MappedIndexProperties<T, K>;
-export type TIndexMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>> = (TMappedResult<P>);
-export declare function IndexMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>>(T: T, K: K): TMappedResult<P>;
+declare function MappedIndexProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): MappedIndexProperties<T, K>;
+export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>> = (TMappedResult<P>);
+export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/indexed/indexed-from-mapped-key.mjs

@@ -0,0 +1,18 @@
+import { IndexResult } from './indexed-result.mjs';
+import { MappedResult } from '../mapped/index.mjs';
+function MappedIndexPropertyKey(T, K, options) {
+    return { [K]: IndexResult(T, [K], options) };
+}
+function MappedIndexPropertyKeys(T, K, options) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? { ...MappedIndexPropertyKey(T, L, options), ...MappedIndexPropertyKeys(T, R, options) }
+        : {});
+}
+function MappedIndexProperties(T, K, options) {
+    return MappedIndexPropertyKeys(T, K.keys, options);
+}
+export function IndexFromMappedKey(T, K, options) {
+    const P = MappedIndexProperties(T, K, options);
+    return MappedResult(P);
+}

package/build/import/type/indexed/indexed-result.d.mts

@@ -1,4 +1,4 @@
-import { type TSchema } from '../schema/index.mjs';
+import { type TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TRecursive } from '../recursive/index.mjs';
@@ -29,5 +29,5 @@ declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K):
 type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
 declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
 export type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
-export declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexResult<T, K>;
+export declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): TIndexResult<T, K>;
 export {};

package/build/import/type/indexed/indexed-result.mjs

@@ -1,6 +1,7 @@
 import { Never } from '../never/index.mjs';
 import { IntersectResolve } from '../intersect/index.mjs';
 import { UnionResolve } from '../union/index.mjs';
+import { CloneType } from '../clone/type.mjs';
 import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TNever as IsNeverType } from '../guard/type.mjs';
 function FromRest(T, K) {
     const [L, ...R] = T;
@@ -59,6 +60,6 @@ function FromKeys(T, K) {
         ? [FromKey(T, L), ...FromKeys(T, R)]
         : []);
 }
-export function IndexResult(T, K) {
-    return (UnionResolve(FromKeys(T, K)));
+export function IndexResult(T, K, options) {
+    return (CloneType(UnionResolve(FromKeys(T, K)), options));
 }

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

@@ -1,9 +1,9 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TIndexResult } from './indexed-result.mjs';
 import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
-import { type TIndexMappedResult } from './indexed-mapped-result.mjs';
+import { type TIndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { TMappedKey } from '../mapped/index.mjs';
 export type TIndex<T extends TSchema, K extends PropertyKey[]> = TIndexResult<T, K>;
-export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K): TIndexMappedResult<T, K>;
+export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
 export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
 export declare function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;

package/build/import/type/indexed/indexed.mjs

@@ -1,10 +1,10 @@
 import { TSchema as IsSchemaType, TMappedKey as IsMappedKey } from '../guard/type.mjs';
 import { IndexResult } from './indexed-result.mjs';
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
-import { IndexMappedResult } from './indexed-mapped-result.mjs';
+import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { CloneType } from '../clone/type.mjs';
 export function Index(T, K, options = {}) {
-    return (IsMappedKey(K) ? CloneType(IndexMappedResult(T, K), options) :
-        IsSchemaType(K) ? CloneType(IndexResult(T, IndexPropertyKeys(K)), options) :
-            CloneType(IndexResult(T, K), options));
+    return (IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
+        IsSchemaType(K) ? IndexResult(T, IndexPropertyKeys(K), options) :
+            IndexResult(T, K, options));
 }

package/build/import/type/intrinsic/capitalize.mjs

@@ -1,5 +1,4 @@
 import { Intrinsic } from './intrinsic.mjs';
-import { CloneType } from '../clone/type.mjs';
 export function Capitalize(T, options = {}) {
-    return CloneType(Intrinsic(T, 'Capitalize'), options);
+    return Intrinsic(T, 'Capitalize', options);
 }

package/build/import/type/intrinsic/index.d.mts

@@ -1,5 +1,5 @@
 export * from './capitalize.mjs';
-export * from './intrinsic-mapped-result.mjs';
+export * from './intrinsic-from-mapped-key.mjs';
 export * from './intrinsic.mjs';
 export * from './lowercase.mjs';
 export * from './uncapitalize.mjs';

package/build/import/type/intrinsic/index.mjs

@@ -1,5 +1,5 @@
 export * from './capitalize.mjs';
-export * from './intrinsic-mapped-result.mjs';
+export * from './intrinsic-from-mapped-key.mjs';
 export * from './intrinsic.mjs';
 export * from './lowercase.mjs';
 export * from './uncapitalize.mjs';

package/build/import/type/intrinsic/{intrinsic-mapped-result.d.mts → intrinsic-from-mapped-key.d.mts}

@@ -1,3 +1,4 @@
+import type { SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
 import { type TIntrinsic, type IntrinsicMode } from './intrinsic.mjs';
@@ -5,11 +6,11 @@ import { TLiteral, TLiteralValue } from '../literal/index.mjs';
 type MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode, P extends TLiteralValue = K extends TLiteralValue ? K : never> = {
     [_ in K]: TIntrinsic<TLiteral<P>, M>;
 };
-declare function MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode>(K: K, M: M): MappedIntrinsicPropertyKey<K, M>;
+declare function MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode>(K: K, M: M, options: SchemaOptions): MappedIntrinsicPropertyKey<K, M>;
 type MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIntrinsicPropertyKey<L, M> & MappedIntrinsicPropertyKeys<R, M> : {});
-declare function MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode>(K: [...K], M: M): MappedIntrinsicPropertyKeys<K, M>;
+declare function MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode>(K: [...K], M: M, options: SchemaOptions): MappedIntrinsicPropertyKeys<K, M>;
 type MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode> = (MappedIntrinsicPropertyKeys<K['keys'], M>);
-declare function MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode>(T: K, M: M): MappedIntrinsicProperties<K, M>;
-export type TIntrinsicMappedResult<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
-export declare function IntrinsicMappedResult<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>>(T: K, M: M): TMappedResult<P>;
+declare function MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode>(T: K, M: M, options: SchemaOptions): MappedIntrinsicProperties<K, M>;
+export type TIntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
+export declare function IntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>>(T: K, M: M, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/intrinsic/intrinsic-from-mapped-key.mjs

@@ -0,0 +1,21 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Intrinsic } from './intrinsic.mjs';
+import { Literal } from '../literal/index.mjs';
+function MappedIntrinsicPropertyKey(K, M, options) {
+    return {
+        [K]: Intrinsic(Literal(K), M, options)
+    };
+}
+function MappedIntrinsicPropertyKeys(K, M, options) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? { ...MappedIntrinsicPropertyKey(L, M, options), ...MappedIntrinsicPropertyKeys(R, M, options) }
+        : {});
+}
+function MappedIntrinsicProperties(T, M, options) {
+    return MappedIntrinsicPropertyKeys(T['keys'], M, options);
+}
+export function IntrinsicFromMappedKey(T, M, options) {
+    const P = MappedIntrinsicProperties(T, M, options);
+    return MappedResult(P);
+}

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

@@ -1,17 +1,17 @@
-import type { TSchema } from '../schema/index.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index.mjs';
-import { type TIntrinsicMappedResult } from './intrinsic-mapped-result.mjs';
+import { type TIntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TMappedKey } from '../mapped/index.mjs';
 export type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
 type FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [TIntrinsic<L, M>, ...FromTemplateLiteral<R, M>] : T : T;
-declare function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode>(schema: TTemplateLiteral, mode: IntrinsicMode): FromTemplateLiteral<T, M>;
+declare function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode>(schema: TTemplateLiteral, mode: IntrinsicMode, options: SchemaOptions): FromTemplateLiteral<T, M>;
 type FromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
 declare function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode): string;
 type FromRest<T extends TSchema[], M extends IntrinsicMode> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [TIntrinsic<L, M>, ...FromRest<R, M>] : [];
 declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], mode: M): FromRest<T, M>;
-export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicMappedResult<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
-export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M): TIntrinsicMappedResult<T, M>;
-export declare function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M): TIntrinsic<T, M>;
+export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
+export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
+export declare function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsic<T, M>;
 export {};