@sinclair/typebox 0.33.22 → 0.34.1

package/build/cjs/type/indexed/indexed-from-mapped-result.d.ts

@@ -3,10 +3,10 @@ import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndex } from './index';
-type TFromProperties<T extends TSchema, P extends TProperties> = ({
-    [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>>;
+type TFromProperties<Type extends TSchema, Properties extends TProperties> = ({
+    [K2 in keyof Properties]: TIndex<Type, TIndexPropertyKeys<Properties[K2]>>;
 });
-type TFromMappedResult<T extends TSchema, R extends TMappedResult> = (TFromProperties<T, R['properties']>);
-export type TIndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>> = (TMappedResult<P>);
-export declare function IndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>>(T: T, R: R, options?: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult> = (TFromProperties<Type, MappedResult['properties']>);
+export type TIndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<Type, MappedResult>> = (TMappedResult<Properties>);
+export declare function IndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<Type, MappedResult>>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TMappedResult<Properties>;
 export {};

package/build/cjs/type/indexed/indexed-from-mapped-result.js

@@ -6,19 +6,20 @@ const index_1 = require("../mapped/index");
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const index_2 = require("./index");
 // prettier-ignore
-function FromProperties(T, P, options) {
-    const Acc = {};
-    for (const K2 of Object.getOwnPropertyNames(P)) {
-        Acc[K2] = (0, index_2.Index)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(P[K2]), options);
+function FromProperties(type, properties, options) {
+    const result = {};
+    for (const K2 of Object.getOwnPropertyNames(properties)) {
+        const keys = (0, indexed_property_keys_1.IndexPropertyKeys)(properties[K2]);
+        result[K2] = (0, index_2.Index)(type, keys, options);
     }
-    return Acc;
+    return result;
 }
 // prettier-ignore
-function FromMappedResult(T, R, options) {
-    return FromProperties(T, R.properties, options);
+function FromMappedResult(type, mappedResult, options) {
+    return FromProperties(type, mappedResult.properties, options);
 }
 // prettier-ignore
-function IndexFromMappedResult(T, R, options) {
-    const P = FromMappedResult(T, R, options);
-    return (0, index_1.MappedResult)(P);
+function IndexFromMappedResult(type, mappedResult, options) {
+    const properties = FromMappedResult(type, mappedResult, options);
+    return (0, index_1.MappedResult)(properties);
 }

package/build/cjs/type/indexed/indexed-property-keys.d.ts

@@ -4,11 +4,11 @@ import type { TInteger } from '../integer/index';
 import type { TNumber } from '../number/index';
 import type { TSchema } from '../schema/index';
 import type { TUnion } from '../union/index';
-type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
-type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...Acc, ...TIndexPropertyKeys<L>]> : Acc);
-type TFromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
-export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TLiteral<infer S> ? TFromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
-]);
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Result extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = Result;
+type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TIndexPropertyKeys<Left>]> : Result);
+type TFromLiteral<LiteralValue extends TLiteralValue> = (LiteralValue extends PropertyKey ? [`${LiteralValue}`] : []);
+export type TIndexPropertyKeys<Type extends TSchema, Result extends PropertyKey[] = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteral<LiteralValue> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
+])> = Result;
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
-export declare function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T>;
+export declare function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type>;
 export {};

package/build/cjs/type/indexed/indexed-property-keys.js

@@ -8,16 +8,16 @@ const index_1 = require("../template-literal/index");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function FromTemplateLiteral(T) {
-    const R = (0, index_1.TemplateLiteralGenerate)(T);
-    return R.map(S => S.toString());
+function FromTemplateLiteral(templateLiteral) {
+    const result = (0, index_1.TemplateLiteralGenerate)(templateLiteral);
+    return result.map(S => S.toString());
 }
 // prettier-ignore
-function FromUnion(T) {
-    const Acc = [];
-    for (const L of T)
-        Acc.push(...IndexPropertyKeys(L));
-    return Acc;
+function FromUnion(type) {
+    const result = [];
+    for (const left of type)
+        result.push(...IndexPropertyKeys(left));
+    return result;
 }
 // prettier-ignore
 function FromLiteral(T) {
@@ -26,11 +26,11 @@ function FromLiteral(T) {
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore
-function IndexPropertyKeys(T) {
-    return [...new Set(((0, kind_1.IsTemplateLiteral)(T) ? FromTemplateLiteral(T) :
-            (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
-                (0, kind_1.IsLiteral)(T) ? FromLiteral(T.const) :
-                    (0, kind_1.IsNumber)(T) ? ['[number]'] :
-                        (0, kind_1.IsInteger)(T) ? ['[number]'] :
+function IndexPropertyKeys(type) {
+    return [...new Set(((0, kind_1.IsTemplateLiteral)(type) ? FromTemplateLiteral(type) :
+            (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf) :
+                (0, kind_1.IsLiteral)(type) ? FromLiteral(type.const) :
+                    (0, kind_1.IsNumber)(type) ? ['[number]'] :
+                        (0, kind_1.IsInteger)(type) ? ['[number]'] :
                             []))];
 }

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

@@ -1,4 +1,6 @@
 import { type TSchema, SchemaOptions } from '../schema/index';
+import { type TComputed } from '../computed/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type Assert } from '../helpers/index';
 import { type TNever } from '../never/index';
@@ -8,33 +10,45 @@ import { TMappedResult, type TMappedKey } from '../mapped/index';
 import { type TUnion } from '../union/index';
 import { type TTuple } from '../tuple/index';
 import { type TArray } from '../array/index';
+import { type TRef } from '../ref/index';
 import { type TIntersectEvaluated } from '../intersect/index';
 import { type TUnionEvaluated } from '../union/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
 import { type TIndexFromMappedResult } from './indexed-from-mapped-result';
-type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Acc);
-type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
-type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
-type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : TFromUnionRest<R, [L, ...Acc]> : Acc;
-type TFromUnion<T extends TSchema[], K extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>);
-type TFromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? TUnionEvaluated<T> : TNever);
-type TFromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
-type AssertPropertyKey<T> = Assert<T, string | number>;
-type TFromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
-export type TIndexFromPropertyKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? TIndexFromPropertyKey<S, K> : T extends TIntersect<infer S> ? TFromIntersect<S, K> : T extends TUnion<infer S> ? TFromUnion<S, K> : T extends TTuple<infer S> ? TFromTuple<S, K> : T extends TArray<infer S> ? TFromArray<S, K> : T extends TObject<infer S> ? TFromProperty<S, K> : TNever);
-export declare function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TIndexFromPropertyKey<T, K>;
-export type TIndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TIndexFromPropertyKeys<T, R, [...Acc, Assert<TIndexFromPropertyKey<T, L>, TSchema>]> : Acc);
-export declare function IndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexFromPropertyKeys<T, K>;
-type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<T, K>>);
-declare function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K>;
-export type TIndex<T extends TSchema, K extends PropertyKey[]> = (FromSchema<T, K>);
+type TFromRest<T extends TSchema[], K extends PropertyKey, Result extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Result, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Result);
+type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? TFromIntersectRest<Right, [...Result]> : TFromIntersectRest<Right, [...Result, Left]> : Result);
+type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>);
+type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? [] : TFromUnionRest<Right, [Left, ...Result]> : Result;
+type TFromUnion<Types extends TSchema[], Key extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>);
+type TFromTuple<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema = (Key extends '[number]' ? TUnionEvaluated<Types> : Key extends keyof Types ? Types[Key] extends infer Type extends TSchema ? Type : TNever : TNever)> = Result;
+type TFromArray<Type extends TSchema, Key extends PropertyKey> = (Key extends '[number]' ? Type : TNever);
+type AssertPropertyKey<T extends unknown> = Assert<T, string | number>;
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever)> = Result;
+export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer S extends TSchema> ? TIndexFromPropertyKey<S, Key> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<S, Key> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<S, Key> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<S, Key> : Type extends TArray<infer S extends TSchema> ? TFromArray<S, Key> : Type extends TObject<infer S extends TProperties> ? TFromProperty<S, Key> : TNever);
+export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TIndexFromPropertyKey<Type, Key>;
+export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TIndexFromPropertyKeys<Type, Right, [...Result, Assert<TIndexFromPropertyKey<Type, Left>, TSchema>]> : Result);
+export declare function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys>;
+type TFromType<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = TIndexFromPropertyKeys<Type, PropertyKeys>> = TUnionEvaluated<Result>;
+type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]> : TUnionFromPropertyKeys<Rest, [...Result]> : TUnionEvaluated<Result>);
+type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
+type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
+export type TIndex<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Key extends TMappedResult ? TIndexFromMappedResult<Type, Key> : Key extends TMappedKey ? TIndexFromMappedKey<Type, Key> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [false, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, false] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : TFromType<Type, TResolvePropertyKeys<Key>>);
 /** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;
+export declare function Index<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TIndex<Type, Key>;
 /** `[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>;
+export declare function Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
 /** `[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>;
+export declare function Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
 /** `[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 declare function Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
 export {};

package/build/cjs/type/indexed/indexed.js

@@ -5,80 +5,93 @@ exports.IndexFromPropertyKey = IndexFromPropertyKey;
 exports.IndexFromPropertyKeys = IndexFromPropertyKeys;
 exports.Index = Index;
 const type_1 = require("../create/type");
-const index_1 = require("../never/index");
-const index_2 = require("../intersect/index");
-const index_3 = require("../union/index");
+const index_1 = require("../computed/index");
+const index_2 = require("../literal/index");
+const index_3 = require("../never/index");
+const index_4 = require("../intersect/index");
+const index_5 = require("../union/index");
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
 const indexed_from_mapped_result_1 = require("./indexed-from-mapped-result");
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
+const value_1 = require("../guard/value");
 // prettier-ignore
-function FromRest(T, K) {
-    return T.map(L => IndexFromPropertyKey(L, K));
+function FromRest(types, key) {
+    return types.map(left => IndexFromPropertyKey(left, key));
 }
 // prettier-ignore
-function FromIntersectRest(T) {
-    return T.filter(L => !(0, kind_1.IsNever)(L));
+function FromIntersectRest(types) {
+    return types.filter(left => !(0, kind_1.IsNever)(left));
 }
 // prettier-ignore
-function FromIntersect(T, K) {
-    return ((0, index_2.IntersectEvaluated)(FromIntersectRest(FromRest(T, K))));
+function FromIntersect(types, key) {
+    return ((0, index_4.IntersectEvaluated)(FromIntersectRest(FromRest(types, key))));
 }
 // prettier-ignore
-function FromUnionRest(T) {
-    return (T.some(L => (0, kind_1.IsNever)(L))
+function FromUnionRest(types) {
+    return (types.some(L => (0, kind_1.IsNever)(L))
         ? []
-        : T);
+        : types);
 }
 // prettier-ignore
-function FromUnion(T, K) {
-    return ((0, index_3.UnionEvaluated)(FromUnionRest(FromRest(T, K))));
+function FromUnion(types, key) {
+    return ((0, index_5.UnionEvaluated)(FromUnionRest(FromRest(types, key))));
 }
 // prettier-ignore
-function FromTuple(T, K) {
-    return (K in T ? T[K] :
-        K === '[number]' ? (0, index_3.UnionEvaluated)(T) :
-            (0, index_1.Never)());
+function FromTuple(types, key) {
+    return (key === '[number]' ? (0, index_5.UnionEvaluated)(types) :
+        key in types ? types[key] :
+            (0, index_3.Never)());
 }
 // prettier-ignore
-function FromArray(T, K) {
-    return (K === '[number]'
-        ? T
-        : (0, index_1.Never)());
+function FromArray(type, key) {
+    // ... ?
+    return (key === '[number]' ? type : (0, index_3.Never)());
 }
 // prettier-ignore
-function FromProperty(T, K) {
-    return (K in T ? T[K] : (0, index_1.Never)());
+function FromProperty(properties, key) {
+    return (key in properties ? properties[key] : (0, index_3.Never)());
 }
 // prettier-ignore
-function IndexFromPropertyKey(T, K) {
-    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf, K) :
-        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf, K) :
-            (0, kind_1.IsTuple)(T) ? FromTuple(T.items ?? [], K) :
-                (0, kind_1.IsArray)(T) ? FromArray(T.items, K) :
-                    (0, kind_1.IsObject)(T) ? FromProperty(T.properties, K) :
-                        (0, index_1.Never)());
+function IndexFromPropertyKey(type, key) {
+    return ((0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf, key) :
+        (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf, key) :
+            (0, kind_1.IsTuple)(type) ? FromTuple(type.items ?? [], key) :
+                (0, kind_1.IsArray)(type) ? FromArray(type.items, key) :
+                    (0, kind_1.IsObject)(type) ? FromProperty(type.properties, key) :
+                        (0, index_3.Never)());
 }
 // prettier-ignore
-function IndexFromPropertyKeys(T, K) {
-    return K.map(L => IndexFromPropertyKey(T, L));
+function IndexFromPropertyKeys(type, propertyKeys) {
+    return propertyKeys.map(left => IndexFromPropertyKey(type, left));
 }
 // prettier-ignore
-function FromSchema(T, K) {
-    return ((0, index_3.UnionEvaluated)(IndexFromPropertyKeys(T, K)));
+function FromType(type, propertyKeys) {
+    const result = IndexFromPropertyKeys(type, propertyKeys);
+    return (0, index_5.UnionEvaluated)(result);
+}
+// prettier-ignore
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => (0, kind_1.IsLiteralValue)(key) ? [...result, (0, index_2.Literal)(key)] : result, []);
+    return (0, index_5.UnionEvaluated)(result);
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-function Index(T, K, options) {
-    // mapped-types
-    if ((0, kind_1.IsMappedResult)(K))
-        return (0, indexed_from_mapped_result_1.IndexFromMappedResult)(T, K, options);
-    if ((0, kind_1.IsMappedKey)(K))
-        return (0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options);
-    // prettier-ignore
-    return (0, type_1.CreateType)((0, kind_1.IsSchema)(K)
-        ? FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K))
-        : FromSchema(T, K), options);
+// prettier-ignore
+function Index(type, key, options) {
+    const typeKey = (0, value_1.IsArray)(key) ? UnionFromPropertyKeys(key) : key;
+    const propertyKeys = (0, kind_1.IsSchema)(key) ? (0, indexed_property_keys_1.IndexPropertyKeys)(key) : key;
+    const isTypeRef = (0, kind_1.IsRef)(type);
+    const isKeyRef = (0, kind_1.IsRef)(key);
+    return ((0, kind_1.IsMappedResult)(key) ? (0, indexed_from_mapped_result_1.IndexFromMappedResult)(type, key, options) :
+        (0, kind_1.IsMappedKey)(key) ? (0, indexed_from_mapped_key_1.IndexFromMappedKey)(type, key, options) :
+            (isTypeRef && isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
+                        (0, type_1.CreateType)(FromType(type, propertyKeys), options));
 }

package/build/cjs/type/intersect/intersect-evaluated.d.ts

@@ -3,11 +3,11 @@ import { type TNever } from '../never/index';
 import { type TOptional } from '../optional/index';
 import type { TReadonly } from '../readonly/index';
 import { TIntersect, IntersectOptions } from './intersect-type';
-type TIsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? TIsIntersectOptional<R> : false : true);
-type TRemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> : T);
-type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<R, [...Acc, L]> : Acc);
-type TResolveIntersect<T extends TSchema[]> = (TIsIntersectOptional<T> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<T>>> : TIntersect<TRemoveOptionalFromRest<T>>);
-export type TIntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveIntersect<T>);
+type TIsIntersectOptional<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<TSchema> ? TIsIntersectOptional<Right> : false : true);
+type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<Type>]> : TRemoveOptionalFromRest<Right, [...Result, Left]> : Result);
+type TResolveIntersect<Types extends TSchema[]> = (TIsIntersectOptional<Types> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<Types>>> : TIntersect<TRemoveOptionalFromRest<Types>>);
+export type TIntersectEvaluated<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TResolveIntersect<Types>);
 /** `[Json]` Creates an evaluated Intersect type */
-export declare function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
+export declare function IntersectEvaluated<Types extends TSchema[], Result extends TSchema = TIntersectEvaluated<Types>>(types: [...Types], options?: IntersectOptions): Result;
 export {};

package/build/cjs/type/intersect/intersect-evaluated.js

@@ -13,30 +13,30 @@ const intersect_create_1 = require("./intersect-create");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function IsIntersectOptional(T) {
-    return T.every(L => (0, kind_1.IsOptional)(L));
+function IsIntersectOptional(types) {
+    return types.every(left => (0, kind_1.IsOptional)(left));
 }
 // prettier-ignore
-function RemoveOptionalFromType(T) {
-    return ((0, index_2.Discard)(T, [index_1.OptionalKind]));
+function RemoveOptionalFromType(type) {
+    return ((0, index_2.Discard)(type, [index_1.OptionalKind]));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return T.map(L => (0, kind_1.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
+function RemoveOptionalFromRest(types) {
+    return types.map(left => (0, kind_1.IsOptional)(left) ? RemoveOptionalFromType(left) : left);
 }
 // prettier-ignore
-function ResolveIntersect(T, options) {
-    return (IsIntersectOptional(T)
-        ? (0, index_4.Optional)((0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(T), options))
-        : (0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(T), options));
+function ResolveIntersect(types, options) {
+    return (IsIntersectOptional(types)
+        ? (0, index_4.Optional)((0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(types), options))
+        : (0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(types), options));
 }
 /** `[Json]` Creates an evaluated Intersect type */
-function IntersectEvaluated(T, options = {}) {
-    if (T.length === 0)
+function IntersectEvaluated(types, options = {}) {
+    if (types.length === 1)
+        return (0, type_1.CreateType)(types[0], options);
+    if (types.length === 0)
         return (0, index_3.Never)(options);
-    if (T.length === 1)
-        return (0, type_1.CreateType)(T[0], options);
-    if (T.some((schema) => (0, kind_1.IsTransform)(schema)))
+    if (types.some((schema) => (0, kind_1.IsTransform)(schema)))
         throw new Error('Cannot intersect transform types');
-    return ResolveIntersect(T, options);
+    return ResolveIntersect(types, options);
 }

package/build/cjs/type/intersect/intersect.d.ts

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

package/build/cjs/type/intersect/intersect.js

@@ -10,12 +10,12 @@ const intersect_create_1 = require("./intersect-create");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 /** `[Json]` Creates an evaluated Intersect type */
-function Intersect(T, options) {
-    if (T.length === 0)
+function Intersect(types, options) {
+    if (types.length === 1)
+        return (0, type_1.CreateType)(types[0], options);
+    if (types.length === 0)
         return (0, index_1.Never)(options);
-    if (T.length === 1)
-        return (0, type_1.CreateType)(T[0], options);
-    if (T.some((schema) => (0, kind_1.IsTransform)(schema)))
+    if (types.some((schema) => (0, kind_1.IsTransform)(schema)))
         throw new Error('Cannot intersect transform types');
-    return (0, intersect_create_1.IntersectCreate)(T, options);
+    return (0, intersect_create_1.IntersectCreate)(types, options);
 }

package/build/cjs/type/keyof/keyof-from-mapped-result.d.ts

@@ -2,11 +2,11 @@ import type { SchemaOptions } from '../schema/index';
 import type { Ensure, Evaluate } from '../helpers/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
-import { type TKeyOf } from './keyof';
-type TFromProperties<K extends TProperties> = ({
-    [K2 in keyof K]: TKeyOf<K[K2]>;
+import { type TKeyOfFromType } from './keyof';
+type TFromProperties<Properties extends TProperties> = ({
+    [K2 in keyof Properties]: TKeyOfFromType<Properties[K2]>;
 });
-type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
-export type TKeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function KeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<MappedResult extends TMappedResult> = (Evaluate<TFromProperties<MappedResult['properties']>>);
+export type TKeyOfFromMappedResult<MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<MappedResult>> = (Ensure<TMappedResult<Properties>>);
+export declare function KeyOfFromMappedResult<MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<MappedResult>>(mappedResult: MappedResult, options?: SchemaOptions): TMappedResult<Properties>;
 export {};

package/build/cjs/type/keyof/keyof-from-mapped-result.js

@@ -6,18 +6,18 @@ const index_1 = require("../mapped/index");
 const keyof_1 = require("./keyof");
 const value_1 = require("../clone/value");
 // prettier-ignore
-function FromProperties(K, options) {
-    const Acc = {};
-    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-        Acc[K2] = (0, keyof_1.KeyOf)(K[K2], (0, value_1.Clone)(options));
-    return Acc;
+function FromProperties(properties, options) {
+    const result = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+        result[K2] = (0, keyof_1.KeyOf)(properties[K2], (0, value_1.Clone)(options));
+    return result;
 }
 // prettier-ignore
-function FromMappedResult(R, options) {
-    return FromProperties(R.properties, options);
+function FromMappedResult(mappedResult, options) {
+    return FromProperties(mappedResult.properties, options);
 }
 // prettier-ignore
-function KeyOfFromMappedResult(R, options) {
-    const P = FromMappedResult(R, options);
-    return (0, index_1.MappedResult)(P);
+function KeyOfFromMappedResult(mappedResult, options) {
+    const properties = FromMappedResult(mappedResult, options);
+    return (0, index_1.MappedResult)(properties);
 }

package/build/cjs/type/keyof/keyof-property-keys.d.ts

@@ -7,18 +7,18 @@ import type { TTuple } from '../tuple/index';
 import type { TArray } from '../array/index';
 import type { TObject, TProperties } from '../object/index';
 import { type TSetUnionMany, type TSetIntersectMany } from '../sets/index';
-type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TKeyOfPropertyKeys<L>]> : Acc);
-type TFromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetUnionMany<C>> = R;
-type TFromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetIntersectMany<C>> = R;
-type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, TIncrement<I>, [...Acc, I]> : Acc;
+type TFromRest<Types extends TSchema[], Result extends PropertyKey[][] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TKeyOfPropertyKeys<L>]> : Result);
+type TFromIntersect<Types extends TSchema[], PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>, PropertyKeys extends PropertyKey[] = TSetUnionMany<PropertyKeysArray>> = PropertyKeys;
+type TFromUnion<Types extends TSchema[], PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>, PropertyKeys extends PropertyKey[] = TSetIntersectMany<PropertyKeysArray>> = PropertyKeys;
+type TFromTuple<Types extends TSchema[], Indexer extends string = ZeroString, Acc extends PropertyKey[] = []> = Types extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, TIncrement<Indexer>, [...Acc, Indexer]> : Acc;
 type TFromArray<_ extends TSchema> = ([
     '[number]'
 ]);
-type TFromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
-export type TKeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? TFromIntersect<S> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TTuple<infer S> ? TFromTuple<S> : T extends TArray<infer S> ? TFromArray<S> : T extends TObject<infer S> ? TFromProperties<S> : [
+type TFromProperties<Properties extends TProperties> = (UnionToTuple<keyof Properties>);
+export type TKeyOfPropertyKeys<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TKeyOfPropertyKeys<Type> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Properties> : [
 ]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
-export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T>;
+export declare function KeyOfPropertyKeys<Type extends TSchema>(type: Type): TKeyOfPropertyKeys<Type>;
 /** Returns a regular expression pattern derived from the given TSchema */
 export declare function KeyOfPattern(schema: TSchema): string;
 export {};

package/build/cjs/type/keyof/keyof-property-keys.js

@@ -9,27 +9,27 @@ const index_1 = require("../sets/index");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function FromRest(T) {
-    const Acc = [];
-    for (const L of T)
-        Acc.push(KeyOfPropertyKeys(L));
-    return Acc;
+function FromRest(types) {
+    const result = [];
+    for (const L of types)
+        result.push(KeyOfPropertyKeys(L));
+    return result;
 }
 // prettier-ignore
-function FromIntersect(T) {
-    const C = FromRest(T);
-    const R = (0, index_1.SetUnionMany)(C);
-    return R;
+function FromIntersect(types) {
+    const propertyKeysArray = FromRest(types);
+    const propertyKeys = (0, index_1.SetUnionMany)(propertyKeysArray);
+    return propertyKeys;
 }
 // prettier-ignore
-function FromUnion(T) {
-    const C = FromRest(T);
-    const R = (0, index_1.SetIntersectMany)(C);
-    return R;
+function FromUnion(types) {
+    const propertyKeysArray = FromRest(types);
+    const propertyKeys = (0, index_1.SetIntersectMany)(propertyKeysArray);
+    return propertyKeys;
 }
 // prettier-ignore
-function FromTuple(T) {
-    return T.map((_, I) => I.toString());
+function FromTuple(types) {
+    return types.map((_, indexer) => indexer.toString());
 }
 // prettier-ignore
 function FromArray(_) {
@@ -55,13 +55,13 @@ function FromPatternProperties(patternProperties) {
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
 // prettier-ignore
-function KeyOfPropertyKeys(T) {
-    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf) :
-        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
-            (0, kind_1.IsTuple)(T) ? FromTuple(T.items ?? []) :
-                (0, kind_1.IsArray)(T) ? FromArray(T.items) :
-                    (0, kind_1.IsObject)(T) ? FromProperties(T.properties) :
-                        (0, kind_1.IsRecord)(T) ? FromPatternProperties(T.patternProperties) :
+function KeyOfPropertyKeys(type) {
+    return ((0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf) :
+        (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf) :
+            (0, kind_1.IsTuple)(type) ? FromTuple(type.items ?? []) :
+                (0, kind_1.IsArray)(type) ? FromArray(type.items) :
+                    (0, kind_1.IsObject)(type) ? FromProperties(type.properties) :
+                        (0, kind_1.IsRecord)(type) ? FromPatternProperties(type.patternProperties) :
                             []);
 }
 // ----------------------------------------------------------------