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

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

@@ -1,7 +1,8 @@
 import { Never } from '../never/index.mjs';
-import { IntersectResolve } from '../intersect/index.mjs';
-import { UnionResolve } from '../union/index.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TNever as IsNeverType } from '../guard/type.mjs';
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { TArray as IsArrayType, TIntersect as IsIntersectType, TObject as IsObjectType, TNever as IsNeverType, TTuple as IsTupleType, TUnion as IsUnionType } from '../guard/type.mjs';
 function FromRest(T, K) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -17,7 +18,7 @@ function FromIntersectRest(T) {
         : []);
 }
 function FromIntersect(T, K) {
-    return (IntersectResolve(FromIntersectRest(FromRest(T, K))));
+    return (IntersectEvaluated(FromIntersectRest(FromRest(T, K))));
 }
 function FromUnionRest(T, S = T) {
     const [L, ...R] = T;
@@ -28,11 +29,11 @@ function FromUnionRest(T, S = T) {
         : S);
 }
 function FromUnion(T, K) {
-    return (UnionResolve(FromUnionRest(FromRest(T, K))));
+    return (UnionEvaluated(FromUnionRest(FromRest(T, K))));
 }
 function FromTuple(T, K) {
     return (K in T ? T[K] :
-        K === '[number]' ? UnionResolve(T) :
+        K === '[number]' ? UnionEvaluated(T) :
             Never());
 }
 function FromArray(T, K) {
@@ -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(UnionEvaluated(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';
+import { TMappedKey as IsMappedKey, TSchema as IsSchemaType } from '../guard/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/intersect/index.d.mts

@@ -1 +1,3 @@
+export * from './intersect-evaluated.mjs';
+export * from './intersect-type.mjs';
 export * from './intersect.mjs';

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

@@ -1 +1,3 @@
+export * from './intersect-evaluated.mjs';
+export * from './intersect-type.mjs';
 export * from './intersect.mjs';

package/build/import/type/intersect/intersect-create.d.mts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TIntersect, IntersectOptions } from './intersect-type.mjs';
+export declare function IntersectCreate<T extends TSchema[]>(T: [...T], options: IntersectOptions): TIntersect<T>;

package/build/import/type/intersect/intersect-create.mjs

@@ -0,0 +1,12 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType, CloneRest } from '../clone/type.mjs';
+import { TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+export function IntersectCreate(T, options) {
+    const allObjects = T.every((schema) => IsObjectType(schema));
+    const clonedUnevaluatedProperties = IsSchemaType(options.unevaluatedProperties)
+        ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) }
+        : {};
+    return ((options.unevaluatedProperties === false || IsSchemaType(options.unevaluatedProperties) || allObjects
+        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
+        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) }));
+}

package/build/import/type/intersect/intersect-evaluated.d.mts

@@ -0,0 +1,16 @@
+import type { SchemaOptions, TSchema } from '../schema/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import { TIntersect, IntersectOptions } from './intersect-type.mjs';
+type IsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? IsIntersectOptional<R> : false : true);
+declare function IsIntersectOptional<T extends TSchema[]>(T: T): IsIntersectOptional<T>;
+type RemoveOptionalFromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? [RemoveOptionalFromType<S>, ...RemoveOptionalFromRest<R>] : [L, ...RemoveOptionalFromRest<R>] : []);
+declare function RemoveOptionalFromRest<T extends TSchema[]>(T: T): RemoveOptionalFromRest<T>;
+type RemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? RemoveOptionalFromType<S> : T);
+declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptionalFromType<T>;
+type ResolveIntersect<T extends TSchema[]> = (IsIntersectOptional<T> extends true ? TOptional<TIntersect<RemoveOptionalFromRest<T>>> : TIntersect<RemoveOptionalFromRest<T>>);
+declare function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): ResolveIntersect<T>;
+export type IntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveIntersect<T>);
+export declare function IntersectEvaluated<T extends TSchema[], R = IntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
+export {};

package/build/import/type/intersect/intersect-evaluated.mjs

@@ -0,0 +1,35 @@
+import { OptionalKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { Discard } from '../discard/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { IntersectCreate } from './intersect-create.mjs';
+import { TOptional as IsOptionalType, TTransform as IsTransformType, } from '../guard/type.mjs';
+function IsIntersectOptional(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsOptionalType(L)
+            ? IsIntersectOptional(R)
+            : false
+        : true);
+}
+function RemoveOptionalFromRest(T) {
+    return (T.map(T => RemoveOptionalFromType(T)));
+}
+function RemoveOptionalFromType(T) {
+    return (Discard(T, [OptionalKind]));
+}
+function ResolveIntersect(T, options) {
+    return (IsIntersectOptional(T)
+        ? Optional(IntersectCreate(RemoveOptionalFromRest(T), options))
+        : IntersectCreate(RemoveOptionalFromRest(T), options));
+}
+export function IntersectEvaluated(T, options = {}) {
+    if (T.length === 0)
+        return Never(options);
+    if (T.length === 1)
+        return CloneType(T[0], options);
+    if (T.some((schema) => IsTransformType(schema)))
+        throw new Error('Cannot intersect transform types');
+    return ResolveIntersect(T, options);
+}

package/build/import/type/intersect/intersect-type.d.mts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type IntersectStatic<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? Static<L, P> & IntersectStatic<R, P> : unknown;
+export type TUnevaluatedProperties = undefined | TSchema | boolean;
+export interface IntersectOptions extends SchemaOptions {
+    unevaluatedProperties?: TUnevaluatedProperties;
+}
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+    [Kind]: 'Intersect';
+    static: IntersectStatic<T, this['params']>;
+    type?: 'object';
+    allOf: [...T];
+}
+export {};

package/build/import/type/intersect/intersect-type.mjs

@@ -0,0 +1 @@
+import { Kind } from '../symbols/index.mjs';

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

@@ -1,21 +1,5 @@
-import type { TupleToIntersect, AssertType } from '../helpers/index.mjs';
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { OptionalFromIntersect } from '../modifiers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-export type IntersectResolve<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : OptionalFromIntersect<T>);
-export declare function IntersectResolve<T extends TSchema[]>(T: T): IntersectResolve<T>;
-export type TUnevaluatedProperties = undefined | TSchema | boolean;
-export interface IntersectOptions extends SchemaOptions {
-    unevaluatedProperties?: TUnevaluatedProperties;
-}
-export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
-    [Kind]: 'Intersect';
-    static: TupleToIntersect<{
-        [K in keyof T]: Static<AssertType<T[K]>, this['params']>;
-    }>;
-    type?: 'object';
-    allOf: [...T];
-}
-export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
+import { TIntersect, IntersectOptions } from './intersect-type.mjs';
+export type Intersect<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TIntersect<T>);
+export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;

package/build/import/type/intersect/intersect.mjs

@@ -1,25 +1,13 @@
+import { CloneType } from '../clone/type.mjs';
 import { Never } from '../never/index.mjs';
-import { OptionalFromIntersect } from '../modifiers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-import { CloneType, CloneRest } from '../clone/type.mjs';
-import { TTransform as IsTransformType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
-export function IntersectResolve(T) {
-    return (T.length === 0
-        ? Never()
-        : T.length === 1
-            ? T[0]
-            : OptionalFromIntersect(T));
-}
+import { IntersectCreate } from './intersect-create.mjs';
+import { TTransform as IsTransformType, } from '../guard/type.mjs';
 export function Intersect(T, options = {}) {
     if (T.length === 0)
-        return Never();
+        return Never(options);
     if (T.length === 1)
         return CloneType(T[0], options);
     if (T.some((schema) => IsTransformType(schema)))
         throw new Error('Cannot intersect transform types');
-    const allObjects = T.every((schema) => IsObjectType(schema));
-    const clonedUnevaluatedProperties = IsSchemaType(options.unevaluatedProperties) ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) } : {};
-    return (options.unevaluatedProperties === false || IsSchemaType(options.unevaluatedProperties) || allObjects
-        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
-        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) });
+    return IntersectCreate(T, 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 {};

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

@@ -1,5 +1,5 @@
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
-import { IntrinsicMappedResult } from './intrinsic-mapped-result.mjs';
+import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
 import { TMappedKey as IsMappedKeyType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
@@ -17,7 +17,7 @@ function ApplyUppercase(value) {
 function ApplyLowercase(value) {
     return value.toLowerCase();
 }
-function FromTemplateLiteral(schema, mode) {
+function FromTemplateLiteral(schema, mode, options) {
     const expression = TemplateLiteralParseExact(schema.pattern);
     const finite = IsTemplateLiteralFinite(expression);
     if (!finite)
@@ -26,7 +26,7 @@ function FromTemplateLiteral(schema, mode) {
     const literals = strings.map((value) => Literal(value));
     const mapped = FromRest(literals, mode);
     const union = Union(mapped);
-    return TemplateLiteral([union]);
+    return TemplateLiteral([union], options);
 }
 function FromLiteralValue(value, mode) {
     return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
@@ -39,10 +39,10 @@ function FromRest(T, mode) {
     const [L, ...R] = T;
     return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
 }
-export function Intrinsic(schema, mode) {
-    return (IsMappedKeyType(schema) ? IntrinsicMappedResult(schema, mode) :
-        IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode) :
-            IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode)) :
-                IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode)) :
+export function Intrinsic(schema, mode, options = {}) {
+    return (IsMappedKeyType(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+        IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode, schema) :
+            IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode), options) :
+                IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
                     schema);
 }

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

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

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

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

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

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

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

@@ -1,2 +1,3 @@
+export * from './keyof-from-mapped-result.mjs';
 export * from './keyof-property-keys.mjs';
 export * from './keyof.mjs';

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

@@ -1,2 +1,3 @@
+export * from './keyof-from-mapped-result.mjs';
 export * from './keyof-property-keys.mjs';
 export * from './keyof.mjs';

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

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

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

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

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

@@ -1,12 +1,15 @@
 import type { TSchema } from '../schema/index.mjs';
 import type { Ensure } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
 import { type TLiteral, TLiteralValue } from '../literal/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type SchemaOptions } from '../schema/index.mjs';
 import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
-import { UnionResolve } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
+import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
 declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
-export type TKeyOf<T extends TSchema> = (Ensure<UnionResolve<FromLiterals<KeyOfPropertyKeys<T>>>>);
+export type TKeyOf<T extends TSchema> = (Ensure<UnionEvaluated<FromLiterals<KeyOfPropertyKeys<T>>>>);
+export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
 export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
 export {};

package/build/import/type/keyof/keyof.mjs

@@ -1,8 +1,10 @@
 import { Literal } from '../literal/index.mjs';
 import { Number } from '../number/index.mjs';
 import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
-import { UnionResolve } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
+import { TMappedResult as IsMappedResultType } from '../guard/type.mjs';
 function FromLiterals(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -12,6 +14,11 @@ function FromLiterals(T) {
         : []);
 }
 export function KeyOf(T, options = {}) {
-    const K = UnionResolve(FromLiterals(KeyOfPropertyKeys(T)));
-    return CloneType(K, options);
+    if (IsMappedResultType(T)) {
+        return KeyOfFromMappedResult(T, options);
+    }
+    else {
+        const K = UnionEvaluated(FromLiterals(KeyOfPropertyKeys(T)));
+        return CloneType(K, options);
+    }
 }

package/build/import/type/mapped/mapped.mjs

@@ -1,4 +1,3 @@
-import { TSchema as IsSchemaType } from '../guard/type.mjs';
 import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
@@ -17,7 +16,7 @@ import { Readonly } from '../readonly/index.mjs';
 import { Tuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
 import { MappedResult } from './mapped-result.mjs';
-import { TArray as IsArrayType, TAsyncIterator as IsAsyncIteratorType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TIterator as IsIteratorType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TObject as IsObjectType, TOptional as IsOptionalType, TPromise as IsPromiseType, TTuple as IsTupleType, TUnion as IsUnionType, } from '../guard/type.mjs';
+import { TArray as IsArrayType, TAsyncIterator as IsAsyncIteratorType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TIterator as IsIteratorType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TObject as IsObjectType, TOptional as IsOptionalType, TPromise as IsPromiseType, TSchema as IsSchemaType, TTuple as IsTupleType, TUnion as IsUnionType, } from '../guard/type.mjs';
 function FromMappedResult(K, P) {
     return (K in P
         ? FromSchemaType(K, P[K])

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

@@ -4,8 +4,6 @@ import type { Evaluate } from '../helpers/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import type { TOptional } from '../optional/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-export type TPropertyKey = string | number;
-export type TProperties = Record<TPropertyKey, TSchema>;
 type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
 }[keyof T];
@@ -16,10 +14,12 @@ type OptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
 }[keyof T];
 type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-type PropertiesResolve<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-export type ObjectResolve<T extends TProperties, P extends unknown[]> = PropertiesResolve<T, {
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+export type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
     [K in keyof T]: Static<T[K], P>;
 }>;
+export type TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, TSchema>;
 export type TAdditionalProperties = undefined | TSchema | boolean;
 export interface ObjectOptions extends SchemaOptions {
     additionalProperties?: TAdditionalProperties;
@@ -28,7 +28,7 @@ export interface ObjectOptions extends SchemaOptions {
 }
 export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
     [Kind]: 'Object';
-    static: ObjectResolve<T, this['params']>;
+    static: ObjectStatic<T, this['params']>;
     additionalProperties?: TAdditionalProperties;
     type: 'object';
     properties: T;

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TOmit } from './omit.mjs';
+type FromPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TOmit<T, [K]>;
+};
+declare function FromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): FromPropertyKey<T, K>;
+type FromPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<T, LK> & FromPropertyKeys<T, RK> : {});
+declare function FromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): FromPropertyKeys<T, K>;
+type FromMappedKey<T extends TSchema, K extends TMappedKey> = (FromPropertyKeys<T, K['keys']>);
+declare function FromMappedKey<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): FromMappedKey<T, K>;
+export type TOmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>> = (TMappedResult<P>);
+export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,20 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Omit } from './omit.mjs';
+function FromPropertyKey(T, K, options) {
+    return {
+        [K]: Omit(T, [K], options)
+    };
+}
+function FromPropertyKeys(T, K, options) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...FromPropertyKey(T, LK, options), ...FromPropertyKeys(T, RK, options) }
+        : {});
+}
+function FromMappedKey(T, K, options) {
+    return FromPropertyKeys(T, K.keys, options);
+}
+export function OmitFromMappedKey(T, K, options) {
+    const P = FromMappedKey(T, K, options);
+    return MappedResult(P);
+}

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

@@ -6,7 +6,7 @@ import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { TMappedKey } from '../mapped/index.mjs';
-import { type TOmitMappedResult } from './omit-mapped-result.mjs';
+import { type TOmitFromMappedKey } from './omit-from-mapped-key.mjs';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromIntersect<R, K>] : [];
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromUnion<R, K>] : [];
@@ -16,7 +16,7 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type OmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<OmitResolve<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 OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): OmitResolve<T, K>;
 export type TOmit<T extends TSchema, K extends PropertyKey[]> = OmitResolve<T, K>;
-export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitMappedResult<T, K>;
+export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
 export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
 export declare function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
 export {};