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

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

@@ -18,7 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./finite"), exports);
 __exportStar(require("./generate"), exports);
 __exportStar(require("./syntax"), exports);
-__exportStar(require("./parser"), exports);
+__exportStar(require("./parse"), exports);
 __exportStar(require("./pattern"), exports);
 __exportStar(require("./union"), exports);
 __exportStar(require("./template-literal"), exports);

package/build/require/type/template-literal/{parser.js → parse.js}

@@ -132,17 +132,22 @@ function And(pattern) {
         (expressions.length === 1) ? expressions[0] :
             { type: 'and', expr: expressions });
 }
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
 /** Parses a pattern and returns an expression tree */
-// prettier-ignore
 function TemplateLiteralParse(pattern) {
+    // prettier-ignore
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
                 { type: 'const', const: pattern });
 }
 exports.TemplateLiteralParse = TemplateLiteralParse;
+// ------------------------------------------------------------------
+// TemplateLiteralParseExact
+// ------------------------------------------------------------------
 /** Parses a pattern and strips forward and trailing ^ and $ */
-// prettier-ignore
 function TemplateLiteralParseExact(pattern) {
     return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
 }

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

@@ -14,7 +14,7 @@ type FromUnion<T extends string> = UnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
 type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
-export type TemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
+export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
 export {};

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

@@ -53,7 +53,6 @@ function* FromSyntax(syntax) {
     }
     yield (0, index_1.Literal)(syntax);
 }
-// prettier-ignore
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 function TemplateLiteralSyntax(syntax) {
     return [...FromSyntax(syntax)];

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

@@ -9,7 +9,7 @@ import type { TString } from '../string/index';
 import type { TBoolean } from '../boolean/index';
 import type { TNever } from '../never/index';
 import type { Static } from '../static/index';
-import { TemplateLiteralSyntax } from './syntax';
+import { TTemplateLiteralSyntax } from './syntax';
 import { EmptyString } from '../helpers/index';
 import { Kind } from '../symbols/index';
 type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {
@@ -24,7 +24,7 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     pattern: string;
 }
 /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
 /** `[Json]` Creates a TemplateLiteral type */
 export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
 export {};

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/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/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;
     }