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

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

@@ -1,9 +1,45 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import { type TIndexResult } from './indexed-result.mjs';
+import { type TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type Assert } from '../helpers/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TMappedKey } from '../mapped/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TArray } from '../array/index.mjs';
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { type TIndexPropertyKeys } from './indexed-property-keys.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>;
+type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
+declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
+type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
+declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
+type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectEvaluated<FromIntersectRest<FromRest<T, K>>>);
+declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
+type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
+declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
+type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionEvaluated<FromUnionRest<FromRest<T, K>>>);
+declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
+type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionEvaluated<T> : TNever);
+declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
+type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
+declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
+type AssertPropertyKey<T> = Assert<T, string | number>;
+type FromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
+declare function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): FromProperty<T, K>;
+type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? FromKey<S, K> : T extends TIntersect<infer S> ? FromIntersect<S, K> : T extends TUnion<infer S> ? FromUnion<S, K> : T extends TTuple<infer S> ? FromTuple<S, K> : T extends TArray<infer S> ? FromArray<S, K> : T extends TObject<infer S> ? FromProperty<S, K> : TNever);
+declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, 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>;
+type FromSchema<T extends TSchema, K extends PropertyKey[]> = (UnionEvaluated<FromKeys<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 */
 export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
+export {};

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

@@ -1,10 +1,89 @@
-import { IndexResult } from './indexed-result.mjs';
+import { Never } from '../never/index.mjs';
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
+import { CloneType } from '../clone/type.mjs';
 import { IndexPropertyKeys } from './indexed-property-keys.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';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { TArray as IsArrayType, TIntersect as IsIntersectType, TObject as IsObjectType, TMappedKey as IsMappedKey, TNever as IsNeverType, TSchema as IsSchemaType, TTuple as IsTupleType, TUnion as IsUnionType } from '../guard/type.mjs';
+// prettier-ignore
+function FromRest(T, K) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [FromKey(L, K), ...FromRest(R, K)]
+        : []);
+}
+// prettier-ignore
+function FromIntersectRest(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsNeverType(L)
+            ? [...FromIntersectRest(R)]
+            : [L, ...FromIntersectRest(R)]
+        : []);
+}
+// prettier-ignore
+function FromIntersect(T, K) {
+    return (IntersectEvaluated(FromIntersectRest(FromRest(T, K))));
+}
+// prettier-ignore
+function FromUnionRest(T, S = T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsNeverType(L)
+            ? []
+            : FromUnionRest(R, S)
+        : S);
+}
+// prettier-ignore
+function FromUnion(T, K) {
+    return (UnionEvaluated(FromUnionRest(FromRest(T, K))));
+}
+// prettier-ignore
+function FromTuple(T, K) {
+    return (K in T ? T[K] :
+        K === '[number]' ? UnionEvaluated(T) :
+            Never());
+}
+// prettier-ignore
+function FromArray(T, K) {
+    return (K === '[number]'
+        ? T
+        : Never());
+}
+// prettier-ignore
+function FromProperty(T, K) {
+    return (K in T
+        ? T[K]
+        : Never());
+}
+// prettier-ignore
+function FromKey(T, K) {
+    return (IsIntersectType(T) ? FromIntersect(T.allOf, K) :
+        IsUnionType(T) ? FromUnion(T.anyOf, K) :
+            IsTupleType(T) ? FromTuple(T.items ?? [], K) :
+                IsArrayType(T) ? FromArray(T.items, K) :
+                    IsObjectType(T) ? FromProperty(T.properties, K) :
+                        Never());
+}
+// prettier-ignore
+function FromKeys(T, K) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? [FromKey(T, L), ...FromKeys(T, R)]
+        : []);
+}
+// prettier-ignore
+function FromSchema(T, K) {
+    return (UnionEvaluated(FromKeys(T, K)));
+}
+/** `[Json]` Returns an Indexed property type for the given keys */
 export function Index(T, K, options = {}) {
+    // prettier-ignore
     return (IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
-        IsSchemaType(K) ? IndexResult(T, IndexPropertyKeys(K), options) :
-            IndexResult(T, K, options));
+        IsSchemaType(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
+            CloneType(FromSchema(T, K), options));
 }

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

@@ -1,4 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TConstructor } from '../constructor/index.mjs';
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
 export declare function InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;

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

@@ -1,4 +1,5 @@
 import { CloneType } from '../clone/type.mjs';
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
 export function InstanceType(schema, options = {}) {
     return CloneType(schema.returns, options);
 }

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

@@ -12,4 +12,5 @@ export interface TInteger extends TSchema, IntegerOptions {
     static: number;
     type: 'integer';
 }
+/** `[Json]` Creates an Integer type */
 export declare function Integer(options?: IntegerOptions): TInteger;

package/build/import/type/integer/integer.mjs

@@ -1,4 +1,5 @@
 import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates an Integer type */
 export function Integer(options = {}) {
     return {
         ...options,

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

@@ -1,6 +1,14 @@
 import { Kind } from '../symbols/index.mjs';
 import { CloneType, CloneRest } from '../clone/type.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+// ------------------------------------------------------------------
+// IntersectCreate
+// ------------------------------------------------------------------
+// prettier-ignore
 export function IntersectCreate(T, options) {
     const allObjects = T.every((schema) => IsObjectType(schema));
     const clonedUnevaluatedProperties = IsSchemaType(options.unevaluatedProperties)

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

@@ -12,5 +12,6 @@ declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptional
 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>);
+/** `[Json]` Creates an evaluated Intersect type */
 export declare function IntersectEvaluated<T extends TSchema[], R = IntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
 export {};

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

@@ -4,7 +4,12 @@ import { Discard } from '../discard/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Optional } from '../optional/index.mjs';
 import { IntersectCreate } from './intersect-create.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TOptional as IsOptionalType, TTransform as IsTransformType, } from '../guard/type.mjs';
+// prettier-ignore
 function IsIntersectOptional(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -13,17 +18,21 @@ function IsIntersectOptional(T) {
             : false
         : true);
 }
+// prettier-ignore
 function RemoveOptionalFromRest(T) {
     return (T.map(T => RemoveOptionalFromType(T)));
 }
+// prettier-ignore
 function RemoveOptionalFromType(T) {
     return (Discard(T, [OptionalKind]));
 }
+// prettier-ignore
 function ResolveIntersect(T, options) {
     return (IsIntersectOptional(T)
         ? Optional(IntersectCreate(RemoveOptionalFromRest(T), options))
         : IntersectCreate(RemoveOptionalFromRest(T), options));
 }
+/** `[Json]` Creates an evaluated Intersect type */
 export function IntersectEvaluated(T, options = {}) {
     if (T.length === 0)
         return Never(options);

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

@@ -2,4 +2,5 @@ import type { TSchema } from '../schema/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { TIntersect, IntersectOptions } from './intersect-type.mjs';
 export type Intersect<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TIntersect<T>);
+/** `[Json]` Creates an evaluated Intersect type */
 export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;

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

@@ -1,7 +1,12 @@
 import { CloneType } from '../clone/type.mjs';
 import { Never } from '../never/index.mjs';
 import { IntersectCreate } from './intersect-create.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TTransform as IsTransformType, } from '../guard/type.mjs';
+/** `[Json]` Creates an evaluated Intersect type */
 export function Intersect(T, options = {}) {
     if (T.length === 0)
         return Never(options);

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

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TIntrinsic } from './intrinsic.mjs';
 export type TCapitalize<T extends TSchema> = TIntrinsic<T, 'Capitalize'>;
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
 export declare function Capitalize<T extends TSchema>(T: T, options?: SchemaOptions): TCapitalize<T>;

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

@@ -1,4 +1,5 @@
 import { Intrinsic } from './intrinsic.mjs';
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
 export function Capitalize(T, options = {}) {
     return Intrinsic(T, 'Capitalize', options);
 }

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

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

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

@@ -12,6 +12,8 @@ declare function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode): st
 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 ? 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;
+/** Applies an intrinsic string manipulation to the given type. */
 export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
+/** Applies an intrinsic string manipulation to the given type. */
 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

@@ -2,7 +2,14 @@ import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, Te
 import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TMappedKey as IsMappedKeyType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
+// ------------------------------------------------------------------
+// Apply
+// ------------------------------------------------------------------
 function ApplyUncapitalize(value) {
     const [first, rest] = [value.slice(0, 1), value.slice(1)];
     return [first.toLowerCase(), rest].join('');
@@ -18,6 +25,8 @@ function ApplyLowercase(value) {
     return value.toLowerCase();
 }
 function FromTemplateLiteral(schema, mode, options) {
+    // note: template literals require special runtime handling as they are encoded in string patterns.
+    // This diverges from the mapped type which would otherwise map on the template literal kind.
     const expression = TemplateLiteralParseExact(schema.pattern);
     const finite = IsTemplateLiteralFinite(expression);
     if (!finite)
@@ -28,6 +37,7 @@ function FromTemplateLiteral(schema, mode, options) {
     const union = Union(mapped);
     return TemplateLiteral([union], options);
 }
+// prettier-ignore
 function FromLiteralValue(value, mode) {
     return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
         mode === 'Capitalize' ? ApplyCapitalize(value) :
@@ -39,8 +49,13 @@ function FromRest(T, mode) {
     const [L, ...R] = T;
     return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
 }
+/** Applies an intrinsic string manipulation to the given type. */
 export function Intrinsic(schema, mode, options = {}) {
-    return (IsMappedKeyType(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+    // prettier-ignore
+    return (
+    // Intrinsic-Mapped-Inference
+    IsMappedKeyType(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+        // Standard-Inference
         IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode, schema) :
             IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode), options) :
                 IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :

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

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TIntrinsic } from './intrinsic.mjs';
 export type TLowercase<T extends TSchema> = TIntrinsic<T, 'Lowercase'>;
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
 export declare function Lowercase<T extends TSchema>(T: T, options?: SchemaOptions): TLowercase<T>;

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

@@ -1,4 +1,5 @@
 import { Intrinsic } from './intrinsic.mjs';
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
 export function Lowercase(T, options = {}) {
     return Intrinsic(T, 'Lowercase', options);
 }

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

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TIntrinsic } from './intrinsic.mjs';
 export type TUncapitalize<T extends TSchema> = TIntrinsic<T, 'Uncapitalize'>;
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
 export declare function Uncapitalize<T extends TSchema>(T: T, options?: SchemaOptions): TUncapitalize<T>;

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

@@ -1,4 +1,5 @@
 import { Intrinsic } from './intrinsic.mjs';
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
 export function Uncapitalize(T, options = {}) {
     return Intrinsic(T, 'Uncapitalize', options);
 }

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

@@ -1,4 +1,5 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TIntrinsic } from './intrinsic.mjs';
 export type TUppercase<T extends TSchema> = TIntrinsic<T, 'Uppercase'>;
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
 export declare function Uppercase<T extends TSchema>(T: T, options?: SchemaOptions): TUppercase<T>;

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

@@ -1,4 +1,5 @@
 import { Intrinsic } from './intrinsic.mjs';
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
 export function Uppercase(T, options = {}) {
     return Intrinsic(T, 'Uppercase', options);
 }

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

@@ -7,4 +7,5 @@ export interface TIterator<T extends TSchema = TSchema> extends TSchema {
     type: 'Iterator';
     items: T;
 }
+/** `[JavaScript]` Creates an Iterator type */
 export declare function Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;

package/build/import/type/iterator/iterator.mjs

@@ -1,5 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+/** `[JavaScript]` Creates an Iterator type */
 export function Iterator(items, options = {}) {
     return {
         ...options,

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

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

package/build/import/type/keyof/keyof-property-keys.d.mts

@@ -23,6 +23,8 @@ type FromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
 declare function FromProperties<T extends TProperties>(T: T): FromProperties<T>;
 export type KeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
 ]);
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
 export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): KeyOfPropertyKeys<T>;
+/** Returns a regular expression pattern derived from the given TSchema */
 export declare function KeyOfPattern(schema: TSchema): string;
 export {};

package/build/import/type/keyof/keyof-property-keys.mjs

@@ -1,31 +1,45 @@
 import { Increment } from '../helpers/index.mjs';
 import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TRecord as IsRecordType } from '../guard/type.mjs';
+// prettier-ignore
 function FromRest(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [KeyOfPropertyKeys(L), ...FromRest(R)]
         : []);
 }
+// prettier-ignore
 function FromIntersect(T, C = FromRest(T)) {
     return OperatorUnionMany(C);
 }
+// prettier-ignore
 function FromUnion(T) {
     const C = FromRest(T);
     return OperatorIntersectMany(C);
 }
+// prettier-ignore
 function FromTuple(T, I = '0') {
     const [_, ...R] = T;
     return (T.length > 0
         ? [I, ...FromTuple(R, Increment(I))]
         : []);
 }
+// prettier-ignore
 function FromArray(_) {
     return (['[number]']);
 }
+// prettier-ignore
 function FromProperties(T) {
     return (globalThis.Object.getOwnPropertyNames(T));
 }
+// ------------------------------------------------------------------
+// FromPatternProperties
+// ------------------------------------------------------------------
+// prettier-ignore
 function FromPatternProperties(patternProperties) {
     if (!includePatternProperties)
         return [];
@@ -36,6 +50,8 @@ function FromPatternProperties(patternProperties) {
             : key;
     });
 }
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
+// prettier-ignore
 export function KeyOfPropertyKeys(T) {
     return (IsIntersectType(T) ? FromIntersect(T.allOf) :
         IsUnionType(T) ? FromUnion(T.anyOf) :
@@ -45,7 +61,11 @@ export function KeyOfPropertyKeys(T) {
                         IsRecordType(T) ? FromPatternProperties(T.patternProperties) :
                             []);
 }
+// ----------------------------------------------------------------
+// KeyOfPattern
+// ----------------------------------------------------------------
 let includePatternProperties = false;
+/** Returns a regular expression pattern derived from the given TSchema */
 export function KeyOfPattern(schema) {
     includePatternProperties = true;
     const keys = KeyOfPropertyKeys(schema);

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

@@ -10,6 +10,8 @@ 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<UnionEvaluated<FromLiterals<KeyOfPropertyKeys<T>>>>);
+/** `[Json]` Creates a KeyOf type */
 export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
+/** `[Json]` Creates a KeyOf type */
 export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
 export {};

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

@@ -4,7 +4,12 @@ import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
 import { UnionEvaluated } from '../union/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TMappedResult as IsMappedResultType } from '../guard/type.mjs';
+// prettier-ignore
 function FromLiterals(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -13,6 +18,7 @@ function FromLiterals(T) {
             : [Literal(L), ...FromLiterals(R)]
         : []);
 }
+/** `[Json]` Creates a KeyOf type */
 export function KeyOf(T, options = {}) {
     if (IsMappedResultType(T)) {
         return KeyOfFromMappedResult(T, options);

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

@@ -6,4 +6,5 @@ export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSche
     static: T;
     const: T;
 }
+/** `[Json]` Creates a Literal type */
 export declare function Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;

package/build/import/type/literal/literal.mjs

@@ -1,4 +1,5 @@
 import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Literal type */
 export function Literal(value, options = {}) {
     return {
         ...options,

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

@@ -1,4 +1,5 @@
 import { Kind } from '../symbols/index.mjs';
+// prettier-ignore
 export function MappedKey(T) {
     return {
         [Kind]: 'MappedKey',

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

@@ -1,4 +1,5 @@
 import { Kind } from '../symbols/index.mjs';
+// prettier-ignore
 export function MappedResult(properties) {
     return {
         [Kind]: 'MappedResult',

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

@@ -38,6 +38,8 @@ type FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema> =
 declare function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): FromMappedFunctionReturnType<K, T>;
 export type TMappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
 export type TMapped<K extends PropertyKey[], F extends TMappedFunction<K>, R extends TProperties = Evaluate<FromMappedFunctionReturnType<K, ReturnType<F>>>> = Ensure<TObject<R>>;
+/** `[Json]` Creates a Mapped object type */
 export declare function Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+/** `[Json]` Creates a Mapped object type */
 export declare function Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
 export {};