@sinclair/typebox 0.32.0-dev-20 → 0.32.0-dev-22

package/build/require/type/template-literal/template-literal.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteral = void 0;
-const pattern_1 = require("./pattern");
 const syntax_1 = require("./syntax");
+const pattern_1 = require("./pattern");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a TemplateLiteral type */

package/build/require/type/template-literal/union.d.ts

@@ -3,5 +3,5 @@ import { type TUnion } from '../union/index';
 import { type TLiteral } from '../literal/index';
 import { type TString } from '../string/index';
 import { type TNever } from '../never/index';
-/** Resolves a template literal as a TUnion */
-export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;
+/** Returns a Union from the given TemplateLiteral */
+export declare function TemplateLiteralToUnion(schema: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

package/build/require/type/template-literal/union.js

@@ -4,19 +4,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralToUnion = void 0;
 const index_1 = require("../union/index");
 const index_2 = require("../literal/index");
-const index_3 = require("../string/index");
 const generate_1 = require("./generate");
-const parser_1 = require("./parser");
-const finite_1 = require("./finite");
 // ------------------------------------------------------------------
 // TemplateLiteralToUnion
 // ------------------------------------------------------------------
-/** Resolves a template literal as a TUnion */
-function TemplateLiteralToUnion(template) {
-    const expression = (0, parser_1.TemplateLiteralParseExact)(template.pattern);
-    if (!(0, finite_1.IsTemplateLiteralFinite)(expression))
-        return (0, index_3.String)();
-    const literals = [...(0, generate_1.TemplateLiteralGenerate)(expression)].map((value) => (0, index_2.Literal)(value));
-    return (0, index_1.Union)(literals);
+/** Returns a Union from the given TemplateLiteral */
+function TemplateLiteralToUnion(schema) {
+    const R = (0, generate_1.TemplateLiteralGenerate)(schema);
+    const L = R.map((S) => (0, index_2.Literal)(S));
+    return (0, index_1.Union)(L);
 }
 exports.TemplateLiteralToUnion = TemplateLiteralToUnion;

package/build/require/type/transform/transform.js

@@ -7,7 +7,6 @@ const index_1 = require("../symbols/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // ------------------------------------------------------------------
 // TransformBuilders

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

@@ -1,8 +1,7 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import { Kind } from '../symbols/index';
-type TupleStaticRest<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleStaticRest<R, P>] : [];
-type TupleStatic<T extends TSchema[], P extends unknown[], R extends unknown[] = TupleStaticRest<T, P>> = R;
+type TupleStatic<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TupleStatic<R, P, [...Acc, Static<L, P>]> : Acc;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
     static: TupleStatic<T, this['params']>;

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

@@ -34,7 +34,7 @@ import { type TRequired, type TRequiredFromMappedResult } from '../required/inde
 import { type TRest } from '../rest/index';
 import { type TSchema, type SchemaOptions } from '../schema/index';
 import { type TString, type StringOptions } from '../string/index';
-import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index';
+import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index';
 import { TransformDecodeBuilder } from '../transform/index';
 import { type TTuple } from '../tuple/index';
 import { Union } from '../union/index';
@@ -157,7 +157,7 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates a String type */
     String(options?: StringOptions): TString;
     /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
     /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Json]` Creates a Transform type */

package/build/require/type/union/union-evaluated.d.ts

@@ -3,15 +3,11 @@ import { type TNever } from '../never/index';
 import { type TOptional } from '../optional/index';
 import type { TReadonly } from '../readonly/index';
 import type { TUnion } from './union-type';
-type IsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : IsUnionOptional<R> : false);
-declare function IsUnionOptional<T extends TSchema[]>(T: T): IsUnionOptional<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 ResolveUnion<T extends TSchema[], R extends TSchema[] = RemoveOptionalFromRest<T>> = (IsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
-declare function ResolveUnion<T extends TSchema[]>(T: T, options: SchemaOptions): ResolveUnion<T>;
-export type UnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveUnion<T>);
+type TIsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : TIsUnionOptional<R> : false);
+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 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 TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFromRest<T>> = (TIsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
+export type TUnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveUnion<T>);
 /** `[Json]` Creates an evaluated Union type */
-export declare function UnionEvaluated<T extends TSchema[], R = UnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
+export declare function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
 export {};

package/build/require/type/union/union-evaluated.js

@@ -23,8 +23,13 @@ function IsUnionOptional(T) {
         : false);
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return (T.map(T => RemoveOptionalFromType(T)));
+function RemoveOptionalFromRest(T, Acc = []) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? (0, type_2.IsOptional)(L)
+            ? RemoveOptionalFromRest(R, [...Acc, RemoveOptionalFromType(L)])
+            : RemoveOptionalFromRest(R, [...Acc, L])
+        : Acc);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {

package/build/require/value/cast/cast.js

@@ -97,7 +97,7 @@ function Default(schema, references, value) {
 // ------------------------------------------------------------------
 // Cast
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return (0, index_5.Clone)(value);
     const created = (0, index_1.IsArray)(value) ? (0, index_5.Clone)(value) : (0, index_3.Create)(schema, references);
@@ -111,7 +111,7 @@ function TArray(schema, references, value) {
         throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
     return unique;
 }
-function TConstructor(schema, references, value) {
+function FromConstructor(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return (0, index_3.Create)(schema, references);
     const required = new Set(schema.returns.required || []);
@@ -123,15 +123,15 @@ function TConstructor(schema, references, value) {
     }
     return result;
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const created = (0, index_3.Create)(schema, references);
     const mapped = (0, index_1.IsPlainObject)(created) && (0, index_1.IsPlainObject)(value) ? { ...created, ...value } : value;
     return (0, index_4.Check)(schema, references, mapped) ? mapped : (0, index_3.Create)(schema, references);
 }
-function TNever(schema, references, value) {
+function FromNever(schema, references, value) {
     throw new ValueCastNeverTypeError(schema);
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return value;
     if (value === null || typeof value !== 'object')
@@ -154,7 +154,7 @@ function TObject(schema, references, value) {
     }
     return result;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return (0, index_5.Clone)(value);
     if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
@@ -167,13 +167,13 @@ function TRecord(schema, references, value) {
     }
     return result;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit((0, index_6.Deref)(schema, references), references, value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit((0, index_6.Deref)(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if ((0, index_4.Check)(schema, references, value))
         return (0, index_5.Clone)(value);
     if (!(0, index_1.IsArray)(value))
@@ -182,7 +182,7 @@ function TTuple(schema, references, value) {
         return [];
     return schema.items.map((schema, index) => Visit(schema, references, value[index]));
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     return (0, index_4.Check)(schema, references, value) ? (0, index_5.Clone)(value) : CastUnion(schema, references, value);
 }
 function Visit(schema, references, value) {
@@ -193,25 +193,25 @@ function Visit(schema, references, value) {
         // Structural
         // --------------------------------------------------------------
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'Constructor':
-            return TConstructor(schema_, references_, value);
+            return FromConstructor(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Never':
-            return TNever(schema_, references_, value);
+            return FromNever(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         // --------------------------------------------------------------
         // DefaultClone
         // --------------------------------------------------------------

package/build/require/value/check/check.js

@@ -44,10 +44,10 @@ function IsDefined(value) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TAny(schema, references, value) {
+function FromAny(schema, references, value) {
     return true;
 }
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (!(0, index_9.IsArray)(value))
         return false;
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -88,10 +88,10 @@ function TArray(schema, references, value) {
     }
     return true;
 }
-function TAsyncIterator(schema, references, value) {
+function FromAsyncIterator(schema, references, value) {
     return (0, index_9.IsAsyncIterator)(value);
 }
-function TBigInt(schema, references, value) {
+function FromBigInt(schema, references, value) {
     if (!(0, index_9.IsBigInt)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -111,13 +111,13 @@ function TBigInt(schema, references, value) {
     }
     return true;
 }
-function TBoolean(schema, references, value) {
+function FromBoolean(schema, references, value) {
     return (0, index_9.IsBoolean)(value);
 }
-function TConstructor(schema, references, value) {
+function FromConstructor(schema, references, value) {
     return Visit(schema.returns, references, value.prototype);
 }
-function TDate(schema, references, value) {
+function FromDate(schema, references, value) {
     if (!(0, index_9.IsDate)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
@@ -137,10 +137,10 @@ function TDate(schema, references, value) {
     }
     return true;
 }
-function TFunction(schema, references, value) {
+function FromFunction(schema, references, value) {
     return (0, index_9.IsFunction)(value);
 }
-function TInteger(schema, references, value) {
+function FromInteger(schema, references, value) {
     if (!(0, index_9.IsInteger)(value)) {
         return false;
     }
@@ -161,7 +161,7 @@ function TInteger(schema, references, value) {
     }
     return true;
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const check1 = schema.allOf.every((schema) => Visit(schema, references, value));
     if (schema.unevaluatedProperties === false) {
         const keyPattern = new RegExp((0, index_5.KeyOfPattern)(schema));
@@ -177,22 +177,22 @@ function TIntersect(schema, references, value) {
         return check1;
     }
 }
-function TIterator(schema, references, value) {
+function FromIterator(schema, references, value) {
     return (0, index_9.IsIterator)(value);
 }
-function TLiteral(schema, references, value) {
+function FromLiteral(schema, references, value) {
     return value === schema.const;
 }
-function TNever(schema, references, value) {
+function FromNever(schema, references, value) {
     return false;
 }
-function TNot(schema, references, value) {
+function FromNot(schema, references, value) {
     return !Visit(schema.not, references, value);
 }
-function TNull(schema, references, value) {
+function FromNull(schema, references, value) {
     return (0, index_9.IsNull)(value);
 }
-function TNumber(schema, references, value) {
+function FromNumber(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsNumberLike(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -212,7 +212,7 @@ function TNumber(schema, references, value) {
     }
     return true;
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsObjectLike(value))
         return false;
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -256,10 +256,10 @@ function TObject(schema, references, value) {
         return true;
     }
 }
-function TPromise(schema, references, value) {
+function FromPromise(schema, references, value) {
     return (0, index_9.IsPromise)(value);
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsRecordLike(value)) {
         return false;
     }
@@ -286,10 +286,10 @@ function TRecord(schema, references, value) {
         : true;
     return check1 && check2 && check3;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
-function TString(schema, references, value) {
+function FromString(schema, references, value) {
     if (!(0, index_9.IsString)(value)) {
         return false;
     }
@@ -314,16 +314,16 @@ function TString(schema, references, value) {
     }
     return true;
 }
-function TSymbol(schema, references, value) {
+function FromSymbol(schema, references, value) {
     return (0, index_9.IsSymbol)(value);
 }
-function TTemplateLiteral(schema, references, value) {
+function FromTemplateLiteral(schema, references, value) {
     return (0, index_9.IsString)(value) && new RegExp(schema.pattern).test(value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (!(0, index_9.IsArray)(value)) {
         return false;
     }
@@ -342,13 +342,13 @@ function TTuple(schema, references, value) {
     }
     return true;
 }
-function TUndefined(schema, references, value) {
+function FromUndefined(schema, references, value) {
     return (0, index_9.IsUndefined)(value);
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     return schema.anyOf.some((inner) => Visit(inner, references, value));
 }
-function TUint8Array(schema, references, value) {
+function FromUint8Array(schema, references, value) {
     if (!(0, index_9.IsUint8Array)(value)) {
         return false;
     }
@@ -360,13 +360,13 @@ function TUint8Array(schema, references, value) {
     }
     return true;
 }
-function TUnknown(schema, references, value) {
+function FromUnknown(schema, references, value) {
     return true;
 }
-function TVoid(schema, references, value) {
+function FromVoid(schema, references, value) {
     return index_1.TypeSystemPolicy.IsVoidLike(value);
 }
-function TKind(schema, references, value) {
+function FromKind(schema, references, value) {
     if (!index_7.TypeRegistry.Has(schema[index_4.Kind]))
         return false;
     const func = index_7.TypeRegistry.Get(schema[index_4.Kind]);
@@ -377,69 +377,69 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[index_4.Kind]) {
         case 'Any':
-            return TAny(schema_, references_, value);
+            return FromAny(schema_, references_, value);
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'AsyncIterator':
-            return TAsyncIterator(schema_, references_, value);
+            return FromAsyncIterator(schema_, references_, value);
         case 'BigInt':
-            return TBigInt(schema_, references_, value);
+            return FromBigInt(schema_, references_, value);
         case 'Boolean':
-            return TBoolean(schema_, references_, value);
+            return FromBoolean(schema_, references_, value);
         case 'Constructor':
-            return TConstructor(schema_, references_, value);
+            return FromConstructor(schema_, references_, value);
         case 'Date':
-            return TDate(schema_, references_, value);
+            return FromDate(schema_, references_, value);
         case 'Function':
-            return TFunction(schema_, references_, value);
+            return FromFunction(schema_, references_, value);
         case 'Integer':
-            return TInteger(schema_, references_, value);
+            return FromInteger(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Iterator':
-            return TIterator(schema_, references_, value);
+            return FromIterator(schema_, references_, value);
         case 'Literal':
-            return TLiteral(schema_, references_, value);
+            return FromLiteral(schema_, references_, value);
         case 'Never':
-            return TNever(schema_, references_, value);
+            return FromNever(schema_, references_, value);
         case 'Not':
-            return TNot(schema_, references_, value);
+            return FromNot(schema_, references_, value);
         case 'Null':
-            return TNull(schema_, references_, value);
+            return FromNull(schema_, references_, value);
         case 'Number':
-            return TNumber(schema_, references_, value);
+            return FromNumber(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Promise':
-            return TPromise(schema_, references_, value);
+            return FromPromise(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'String':
-            return TString(schema_, references_, value);
+            return FromString(schema_, references_, value);
         case 'Symbol':
-            return TSymbol(schema_, references_, value);
+            return FromSymbol(schema_, references_, value);
         case 'TemplateLiteral':
-            return TTemplateLiteral(schema_, references_, value);
+            return FromTemplateLiteral(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Undefined':
-            return TUndefined(schema_, references_, value);
+            return FromUndefined(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         case 'Uint8Array':
-            return TUint8Array(schema_, references_, value);
+            return FromUint8Array(schema_, references_, value);
         case 'Unknown':
-            return TUnknown(schema_, references_, value);
+            return FromUnknown(schema_, references_, value);
         case 'Void':
-            return TVoid(schema_, references_, value);
+            return FromVoid(schema_, references_, value);
         default:
             if (!index_7.TypeRegistry.Has(schema_[index_4.Kind]))
                 throw new ValueCheckUnknownTypeError(schema_);
-            return TKind(schema_, references_, value);
+            return FromKind(schema_, references_, value);
     }
 }
 /** Returns true if the value matches the given type. */

package/build/require/value/clean/clean.js

@@ -26,12 +26,12 @@ function IsCheckable(schema) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (!(0, index_6.IsArray)(value))
         return value;
     return value.map((value) => Visit(schema.items, references, value));
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
     const intersections = schema.allOf.map((schema) => Visit(schema, references, (0, index_3.Clone)(value)));
     const composite = intersections.reduce((acc, value) => ((0, index_6.IsObject)(value) ? { ...acc, ...value } : value), {});
@@ -47,7 +47,7 @@ function TIntersect(schema, references, value) {
     }
     return composite;
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!(0, index_6.IsObject)(value) || (0, index_6.IsArray)(value))
         return value; // Check IsArray for AllowArrayObject configuration
     const additionalProperties = schema.additionalProperties;
@@ -64,7 +64,7 @@ function TObject(schema, references, value) {
     }
     return value;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!(0, index_6.IsObject)(value))
         return value;
     const additionalProperties = schema.additionalProperties;
@@ -84,13 +84,13 @@ function TRecord(schema, references, value) {
     }
     return value;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit((0, index_4.Deref)(schema, references), references, value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit((0, index_4.Deref)(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (!(0, index_6.IsArray)(value))
         return value;
     if ((0, index_6.IsUndefined)(schema.items))
@@ -104,7 +104,7 @@ function TTuple(schema, references, value) {
         ? value.slice(0, length)
         : value;
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     for (const inner of schema.anyOf) {
         if (IsCheckable(inner) && (0, index_2.Check)(inner, value)) {
             return Visit(inner, references, value);
@@ -117,21 +117,21 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[index_5.Kind]) {
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         default:
             return value;
     }