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

package/build/import/compiler/compiler.mjs

@@ -196,10 +196,10 @@ export var TypeCompiler;
     // ----------------------------------------------------------------
     // Types
     // ----------------------------------------------------------------
-    function* TAny(schema, references, value) {
+    function* FromAny(schema, references, value) {
         yield 'true';
     }
-    function* TArray(schema, references, value) {
+    function* FromArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
         if (IsNumber(schema.maxItems))
@@ -223,10 +223,10 @@ export var TypeCompiler;
             yield `((${parameter}) => { ${block} )(${value})`;
         }
     }
-    function* TAsyncIterator(schema, references, value) {
+    function* FromAsyncIterator(schema, references, value) {
         yield `(typeof value === 'object' && Symbol.asyncIterator in ${value})`;
     }
-    function* TBigInt(schema, references, value) {
+    function* FromBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
         if (IsBigInt(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
@@ -239,13 +239,13 @@ export var TypeCompiler;
         if (IsBigInt(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
     }
-    function* TBoolean(schema, references, value) {
+    function* FromBoolean(schema, references, value) {
         yield `(typeof ${value} === 'boolean')`;
     }
-    function* TConstructor(schema, references, value) {
+    function* FromConstructor(schema, references, value) {
         yield* Visit(schema.returns, references, `${value}.prototype`);
     }
-    function* TDate(schema, references, value) {
+    function* FromDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
         if (IsNumber(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
@@ -258,10 +258,10 @@ export var TypeCompiler;
         if (IsNumber(schema.multipleOfTimestamp))
             yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
     }
-    function* TFunction(schema, references, value) {
+    function* FromFunction(schema, references, value) {
         yield `(typeof ${value} === 'function')`;
     }
-    function* TInteger(schema, references, value) {
+    function* FromInteger(schema, references, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
         if (IsNumber(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
@@ -274,7 +274,7 @@ export var TypeCompiler;
         if (IsNumber(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
-    function* TIntersect(schema, references, value) {
+    function* FromIntersect(schema, references, value) {
         const check1 = schema.allOf.map((schema) => CreateExpression(schema, references, value)).join(' && ');
         if (schema.unevaluatedProperties === false) {
             const keyCheck = CreateVariable(`${new RegExp(KeyOfPattern(schema))};`);
@@ -290,10 +290,10 @@ export var TypeCompiler;
             yield `(${check1})`;
         }
     }
-    function* TIterator(schema, references, value) {
+    function* FromIterator(schema, references, value) {
         yield `(typeof value === 'object' && Symbol.iterator in ${value})`;
     }
-    function* TLiteral(schema, references, value) {
+    function* FromLiteral(schema, references, value) {
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
             yield `(${value} === ${schema.const})`;
         }
@@ -301,17 +301,17 @@ export var TypeCompiler;
             yield `(${value} === '${LiteralString.Escape(schema.const)}')`;
         }
     }
-    function* TNever(schema, references, value) {
+    function* FromNever(schema, references, value) {
         yield `false`;
     }
-    function* TNot(schema, references, value) {
+    function* FromNot(schema, references, value) {
         const expression = CreateExpression(schema.not, references, value);
         yield `(!${expression})`;
     }
-    function* TNull(schema, references, value) {
+    function* FromNull(schema, references, value) {
         yield `(${value} === null)`;
     }
-    function* TNumber(schema, references, value) {
+    function* FromNumber(schema, references, value) {
         yield Policy.IsNumberLike(value);
         if (IsNumber(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
@@ -324,7 +324,7 @@ export var TypeCompiler;
         if (IsNumber(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
-    function* TObject(schema, references, value) {
+    function* FromObject(schema, references, value) {
         yield Policy.IsObjectLike(value);
         if (IsNumber(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
@@ -359,10 +359,10 @@ export var TypeCompiler;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
     }
-    function* TPromise(schema, references, value) {
+    function* FromPromise(schema, references, value) {
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
-    function* TRecord(schema, references, value) {
+    function* FromRecord(schema, references, value) {
         yield Policy.IsRecordLike(value);
         if (IsNumber(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
@@ -375,7 +375,7 @@ export var TypeCompiler;
         const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;
         yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
     }
-    function* TRef(schema, references, value) {
+    function* FromRef(schema, references, value) {
         const target = Deref(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
         // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
@@ -383,7 +383,7 @@ export var TypeCompiler;
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
     }
-    function* TString(schema, references, value) {
+    function* FromString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
         if (IsNumber(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
@@ -397,19 +397,19 @@ export var TypeCompiler;
             yield `format('${schema.format}', ${value})`;
         }
     }
-    function* TSymbol(schema, references, value) {
+    function* FromSymbol(schema, references, value) {
         yield `(typeof ${value} === 'symbol')`;
     }
-    function* TTemplateLiteral(schema, references, value) {
+    function* FromTemplateLiteral(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
         const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
         yield `${variable}.test(${value})`;
     }
-    function* TThis(schema, references, value) {
+    function* FromThis(schema, references, value) {
         // Note: This types are assured to be hoisted prior to this call. Just yield the function.
         yield `${CreateFunctionName(schema.$ref)}(${value})`;
     }
-    function* TTuple(schema, references, value) {
+    function* FromTuple(schema, references, value) {
         yield `Array.isArray(${value})`;
         if (schema.items === undefined)
             return yield `${value}.length === 0`;
@@ -419,27 +419,27 @@ export var TypeCompiler;
             yield `${expression}`;
         }
     }
-    function* TUndefined(schema, references, value) {
+    function* FromUndefined(schema, references, value) {
         yield `${value} === undefined`;
     }
-    function* TUnion(schema, references, value) {
+    function* FromUnion(schema, references, value) {
         const expressions = schema.anyOf.map((schema) => CreateExpression(schema, references, value));
         yield `(${expressions.join(' || ')})`;
     }
-    function* TUint8Array(schema, references, value) {
+    function* FromUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
         if (IsNumber(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
         if (IsNumber(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
-    function* TUnknown(schema, references, value) {
+    function* FromUnknown(schema, references, value) {
         yield 'true';
     }
-    function* TVoid(schema, references, value) {
+    function* FromVoid(schema, references, value) {
         yield Policy.IsVoidLike(value);
     }
-    function* TKind(schema, references, value) {
+    function* FromKind(schema, references, value) {
         const instance = state.instances.size;
         state.instances.set(instance, schema);
         yield `kind('${schema[Kind]}', ${instance}, ${value})`;
@@ -463,69 +463,69 @@ export var TypeCompiler;
         }
         switch (schema_[Kind]) {
             case 'Any':
-                return yield* TAny(schema_, references_, value);
+                return yield* FromAny(schema_, references_, value);
             case 'Array':
-                return yield* TArray(schema_, references_, value);
+                return yield* FromArray(schema_, references_, value);
             case 'AsyncIterator':
-                return yield* TAsyncIterator(schema_, references_, value);
+                return yield* FromAsyncIterator(schema_, references_, value);
             case 'BigInt':
-                return yield* TBigInt(schema_, references_, value);
+                return yield* FromBigInt(schema_, references_, value);
             case 'Boolean':
-                return yield* TBoolean(schema_, references_, value);
+                return yield* FromBoolean(schema_, references_, value);
             case 'Constructor':
-                return yield* TConstructor(schema_, references_, value);
+                return yield* FromConstructor(schema_, references_, value);
             case 'Date':
-                return yield* TDate(schema_, references_, value);
+                return yield* FromDate(schema_, references_, value);
             case 'Function':
-                return yield* TFunction(schema_, references_, value);
+                return yield* FromFunction(schema_, references_, value);
             case 'Integer':
-                return yield* TInteger(schema_, references_, value);
+                return yield* FromInteger(schema_, references_, value);
             case 'Intersect':
-                return yield* TIntersect(schema_, references_, value);
+                return yield* FromIntersect(schema_, references_, value);
             case 'Iterator':
-                return yield* TIterator(schema_, references_, value);
+                return yield* FromIterator(schema_, references_, value);
             case 'Literal':
-                return yield* TLiteral(schema_, references_, value);
+                return yield* FromLiteral(schema_, references_, value);
             case 'Never':
-                return yield* TNever(schema_, references_, value);
+                return yield* FromNever(schema_, references_, value);
             case 'Not':
-                return yield* TNot(schema_, references_, value);
+                return yield* FromNot(schema_, references_, value);
             case 'Null':
-                return yield* TNull(schema_, references_, value);
+                return yield* FromNull(schema_, references_, value);
             case 'Number':
-                return yield* TNumber(schema_, references_, value);
+                return yield* FromNumber(schema_, references_, value);
             case 'Object':
-                return yield* TObject(schema_, references_, value);
+                return yield* FromObject(schema_, references_, value);
             case 'Promise':
-                return yield* TPromise(schema_, references_, value);
+                return yield* FromPromise(schema_, references_, value);
             case 'Record':
-                return yield* TRecord(schema_, references_, value);
+                return yield* FromRecord(schema_, references_, value);
             case 'Ref':
-                return yield* TRef(schema_, references_, value);
+                return yield* FromRef(schema_, references_, value);
             case 'String':
-                return yield* TString(schema_, references_, value);
+                return yield* FromString(schema_, references_, value);
             case 'Symbol':
-                return yield* TSymbol(schema_, references_, value);
+                return yield* FromSymbol(schema_, references_, value);
             case 'TemplateLiteral':
-                return yield* TTemplateLiteral(schema_, references_, value);
+                return yield* FromTemplateLiteral(schema_, references_, value);
             case 'This':
-                return yield* TThis(schema_, references_, value);
+                return yield* FromThis(schema_, references_, value);
             case 'Tuple':
-                return yield* TTuple(schema_, references_, value);
+                return yield* FromTuple(schema_, references_, value);
             case 'Undefined':
-                return yield* TUndefined(schema_, references_, value);
+                return yield* FromUndefined(schema_, references_, value);
             case 'Union':
-                return yield* TUnion(schema_, references_, value);
+                return yield* FromUnion(schema_, references_, value);
             case 'Uint8Array':
-                return yield* TUint8Array(schema_, references_, value);
+                return yield* FromUint8Array(schema_, references_, value);
             case 'Unknown':
-                return yield* TUnknown(schema_, references_, value);
+                return yield* FromUnknown(schema_, references_, value);
             case 'Void':
-                return yield* TVoid(schema_, references_, value);
+                return yield* FromVoid(schema_, references_, value);
             default:
                 if (!TypeRegistry.Has(schema_[Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
-                return yield* TKind(schema_, references_, value);
+                return yield* FromKind(schema_, references_, value);
         }
     }
     // ----------------------------------------------------------------

package/build/import/errors/errors.mjs

@@ -129,8 +129,8 @@ function Create(type, schema, path, value) {
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
-function* TAny(schema, references, path, value) { }
-function* TArray(schema, references, path, value) {
+function* FromAny(schema, references, path, value) { }
+function* FromArray(schema, references, path, value) {
     if (!IsArray(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
     }
@@ -171,11 +171,11 @@ function* TArray(schema, references, path, value) {
         yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
     }
 }
-function* TAsyncIterator(schema, references, path, value) {
+function* FromAsyncIterator(schema, references, path, value) {
     if (!IsAsyncIterator(value))
         yield Create(ValueErrorType.AsyncIterator, schema, path, value);
 }
-function* TBigInt(schema, references, path, value) {
+function* FromBigInt(schema, references, path, value) {
     if (!IsBigInt(value))
         return yield Create(ValueErrorType.BigInt, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -194,14 +194,14 @@ function* TBigInt(schema, references, path, value) {
         yield Create(ValueErrorType.BigIntMultipleOf, schema, path, value);
     }
 }
-function* TBoolean(schema, references, path, value) {
+function* FromBoolean(schema, references, path, value) {
     if (!IsBoolean(value))
         yield Create(ValueErrorType.Boolean, schema, path, value);
 }
-function* TConstructor(schema, references, path, value) {
+function* FromConstructor(schema, references, path, value) {
     yield* Visit(schema.returns, references, path, value.prototype);
 }
-function* TDate(schema, references, path, value) {
+function* FromDate(schema, references, path, value) {
     if (!IsDate(value))
         return yield Create(ValueErrorType.Date, schema, path, value);
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
@@ -220,11 +220,11 @@ function* TDate(schema, references, path, value) {
         yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path, value);
     }
 }
-function* TFunction(schema, references, path, value) {
+function* FromFunction(schema, references, path, value) {
     if (!IsFunction(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
-function* TInteger(schema, references, path, value) {
+function* FromInteger(schema, references, path, value) {
     if (!IsInteger(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -243,7 +243,7 @@ function* TInteger(schema, references, path, value) {
         yield Create(ValueErrorType.IntegerMultipleOf, schema, path, value);
     }
 }
-function* TIntersect(schema, references, path, value) {
+function* FromIntersect(schema, references, path, value) {
     for (const inner of schema.allOf) {
         const next = Visit(inner, references, path, value).next();
         if (!next.done) {
@@ -270,26 +270,26 @@ function* TIntersect(schema, references, path, value) {
         }
     }
 }
-function* TIterator(schema, references, path, value) {
+function* FromIterator(schema, references, path, value) {
     if (!IsIterator(value))
         yield Create(ValueErrorType.Iterator, schema, path, value);
 }
-function* TLiteral(schema, references, path, value) {
+function* FromLiteral(schema, references, path, value) {
     if (!(value === schema.const))
         yield Create(ValueErrorType.Literal, schema, path, value);
 }
-function* TNever(schema, references, path, value) {
+function* FromNever(schema, references, path, value) {
     yield Create(ValueErrorType.Never, schema, path, value);
 }
-function* TNot(schema, references, path, value) {
+function* FromNot(schema, references, path, value) {
     if (Visit(schema.not, references, path, value).next().done === true)
         yield Create(ValueErrorType.Not, schema, path, value);
 }
-function* TNull(schema, references, path, value) {
+function* FromNull(schema, references, path, value) {
     if (!IsNull(value))
         yield Create(ValueErrorType.Null, schema, path, value);
 }
-function* TNumber(schema, references, path, value) {
+function* FromNumber(schema, references, path, value) {
     if (!TypeSystemPolicy.IsNumberLike(value))
         return yield Create(ValueErrorType.Number, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -308,7 +308,7 @@ function* TNumber(schema, references, path, value) {
         yield Create(ValueErrorType.NumberMultipleOf, schema, path, value);
     }
 }
-function* TObject(schema, references, path, value) {
+function* FromObject(schema, references, path, value) {
     if (!TypeSystemPolicy.IsObjectLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -354,11 +354,11 @@ function* TObject(schema, references, path, value) {
         }
     }
 }
-function* TPromise(schema, references, path, value) {
+function* FromPromise(schema, references, path, value) {
     if (!IsPromise(value))
         yield Create(ValueErrorType.Promise, schema, path, value);
 }
-function* TRecord(schema, references, path, value) {
+function* FromRecord(schema, references, path, value) {
     if (!TypeSystemPolicy.IsRecordLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -387,10 +387,10 @@ function* TRecord(schema, references, path, value) {
         }
     }
 }
-function* TRef(schema, references, path, value) {
+function* FromRef(schema, references, path, value) {
     yield* Visit(Deref(schema, references), references, path, value);
 }
-function* TString(schema, references, path, value) {
+function* FromString(schema, references, path, value) {
     if (!IsString(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
@@ -417,11 +417,11 @@ function* TString(schema, references, path, value) {
         }
     }
 }
-function* TSymbol(schema, references, path, value) {
+function* FromSymbol(schema, references, path, value) {
     if (!IsSymbol(value))
         yield Create(ValueErrorType.Symbol, schema, path, value);
 }
-function* TTemplateLiteral(schema, references, path, value) {
+function* FromTemplateLiteral(schema, references, path, value) {
     if (!IsString(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     const regex = new RegExp(schema.pattern);
@@ -429,10 +429,10 @@ function* TTemplateLiteral(schema, references, path, value) {
         yield Create(ValueErrorType.StringPattern, schema, path, value);
     }
 }
-function* TThis(schema, references, path, value) {
+function* FromThis(schema, references, path, value) {
     yield* Visit(Deref(schema, references), references, path, value);
 }
-function* TTuple(schema, references, path, value) {
+function* FromTuple(schema, references, path, value) {
     if (!IsArray(value))
         return yield Create(ValueErrorType.Tuple, schema, path, value);
     if (schema.items === undefined && !(value.length === 0)) {
@@ -448,11 +448,11 @@ function* TTuple(schema, references, path, value) {
         yield* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
     }
 }
-function* TUndefined(schema, references, path, value) {
+function* FromUndefined(schema, references, path, value) {
     if (!IsUndefined(value))
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
-function* TUnion(schema, references, path, value) {
+function* FromUnion(schema, references, path, value) {
     let count = 0;
     for (const subschema of schema.anyOf) {
         const errors = [...Visit(subschema, references, path, value)];
@@ -464,7 +464,7 @@ function* TUnion(schema, references, path, value) {
         yield Create(ValueErrorType.Union, schema, path, value);
     }
 }
-function* TUint8Array(schema, references, path, value) {
+function* FromUint8Array(schema, references, path, value) {
     if (!IsUint8Array(value))
         return yield Create(ValueErrorType.Uint8Array, schema, path, value);
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
@@ -474,12 +474,12 @@ function* TUint8Array(schema, references, path, value) {
         yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path, value);
     }
 }
-function* TUnknown(schema, references, path, value) { }
-function* TVoid(schema, references, path, value) {
+function* FromUnknown(schema, references, path, value) { }
+function* FromVoid(schema, references, path, value) {
     if (!TypeSystemPolicy.IsVoidLike(value))
         yield Create(ValueErrorType.Void, schema, path, value);
 }
-function* TKind(schema, references, path, value) {
+function* FromKind(schema, references, path, value) {
     const check = TypeRegistry.Get(schema[Kind]);
     if (!check(schema, value))
         yield Create(ValueErrorType.Kind, schema, path, value);
@@ -489,69 +489,69 @@ function* Visit(schema, references, path, value) {
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Any':
-            return yield* TAny(schema_, references_, path, value);
+            return yield* FromAny(schema_, references_, path, value);
         case 'Array':
-            return yield* TArray(schema_, references_, path, value);
+            return yield* FromArray(schema_, references_, path, value);
         case 'AsyncIterator':
-            return yield* TAsyncIterator(schema_, references_, path, value);
+            return yield* FromAsyncIterator(schema_, references_, path, value);
         case 'BigInt':
-            return yield* TBigInt(schema_, references_, path, value);
+            return yield* FromBigInt(schema_, references_, path, value);
         case 'Boolean':
-            return yield* TBoolean(schema_, references_, path, value);
+            return yield* FromBoolean(schema_, references_, path, value);
         case 'Constructor':
-            return yield* TConstructor(schema_, references_, path, value);
+            return yield* FromConstructor(schema_, references_, path, value);
         case 'Date':
-            return yield* TDate(schema_, references_, path, value);
+            return yield* FromDate(schema_, references_, path, value);
         case 'Function':
-            return yield* TFunction(schema_, references_, path, value);
+            return yield* FromFunction(schema_, references_, path, value);
         case 'Integer':
-            return yield* TInteger(schema_, references_, path, value);
+            return yield* FromInteger(schema_, references_, path, value);
         case 'Intersect':
-            return yield* TIntersect(schema_, references_, path, value);
+            return yield* FromIntersect(schema_, references_, path, value);
         case 'Iterator':
-            return yield* TIterator(schema_, references_, path, value);
+            return yield* FromIterator(schema_, references_, path, value);
         case 'Literal':
-            return yield* TLiteral(schema_, references_, path, value);
+            return yield* FromLiteral(schema_, references_, path, value);
         case 'Never':
-            return yield* TNever(schema_, references_, path, value);
+            return yield* FromNever(schema_, references_, path, value);
         case 'Not':
-            return yield* TNot(schema_, references_, path, value);
+            return yield* FromNot(schema_, references_, path, value);
         case 'Null':
-            return yield* TNull(schema_, references_, path, value);
+            return yield* FromNull(schema_, references_, path, value);
         case 'Number':
-            return yield* TNumber(schema_, references_, path, value);
+            return yield* FromNumber(schema_, references_, path, value);
         case 'Object':
-            return yield* TObject(schema_, references_, path, value);
+            return yield* FromObject(schema_, references_, path, value);
         case 'Promise':
-            return yield* TPromise(schema_, references_, path, value);
+            return yield* FromPromise(schema_, references_, path, value);
         case 'Record':
-            return yield* TRecord(schema_, references_, path, value);
+            return yield* FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return yield* TRef(schema_, references_, path, value);
+            return yield* FromRef(schema_, references_, path, value);
         case 'String':
-            return yield* TString(schema_, references_, path, value);
+            return yield* FromString(schema_, references_, path, value);
         case 'Symbol':
-            return yield* TSymbol(schema_, references_, path, value);
+            return yield* FromSymbol(schema_, references_, path, value);
         case 'TemplateLiteral':
-            return yield* TTemplateLiteral(schema_, references_, path, value);
+            return yield* FromTemplateLiteral(schema_, references_, path, value);
         case 'This':
-            return yield* TThis(schema_, references_, path, value);
+            return yield* FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return yield* TTuple(schema_, references_, path, value);
+            return yield* FromTuple(schema_, references_, path, value);
         case 'Undefined':
-            return yield* TUndefined(schema_, references_, path, value);
+            return yield* FromUndefined(schema_, references_, path, value);
         case 'Union':
-            return yield* TUnion(schema_, references_, path, value);
+            return yield* FromUnion(schema_, references_, path, value);
         case 'Uint8Array':
-            return yield* TUint8Array(schema_, references_, path, value);
+            return yield* FromUint8Array(schema_, references_, path, value);
         case 'Unknown':
-            return yield* TUnknown(schema_, references_, path, value);
+            return yield* FromUnknown(schema_, references_, path, value);
         case 'Void':
-            return yield* TVoid(schema_, references_, path, value);
+            return yield* FromVoid(schema_, references_, path, value);
         default:
             if (!TypeRegistry.Has(schema_[Kind]))
                 throw new ValueErrorsUnknownTypeError(schema);
-            return yield* TKind(schema_, references_, path, value);
+            return yield* FromKind(schema_, references_, path, value);
     }
 }
 /** Returns an iterator for each error in this value. */

package/build/import/index.d.mts

@@ -7,7 +7,7 @@ export { Any, type TAny } from './type/any/index.mjs';
 export { Array, type TArray, type ArrayOptions } from './type/array/index.mjs';
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index.mjs';
 export { Awaited, type TAwaited } from './type/awaited/index.mjs';
-export { BigInt, type TBigInt, BigIntOptions } from './type/bigint/index.mjs';
+export { BigInt, type TBigInt, type BigIntOptions } from './type/bigint/index.mjs';
 export { Boolean, type TBoolean } from './type/boolean/index.mjs';
 export { Composite, type TComposite } from './type/composite/index.mjs';
 export { Const, type TConst } from './type/const/index.mjs';
@@ -54,9 +54,9 @@ export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from '.
 export { type Static, type StaticDecode, type StaticEncode } from './type/static/index.mjs';
 export { Strict } from './type/strict/index.mjs';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index.mjs';
-export { Symbol, type TSymbol, type SymbolValue } from './type/symbol/index.mjs';
-export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from './type/template-literal/index.mjs';
-export { Transform, type TTransform, type TransformOptions, type TransformFunction, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index.mjs';
+export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index.mjs';
+export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, type TTemplateLiteral, type TIsTemplateLiteralFinite, type TTemplateLiteralGenerate, type TTemplateLiteralKind, } from './type/template-literal/index.mjs';
+export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index.mjs';
 export { Tuple, type TTuple } from './type/tuple/index.mjs';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index.mjs';
 export { Undefined, type TUndefined } from './type/undefined/index.mjs';

package/build/import/index.mjs

@@ -59,7 +59,7 @@ export { ReturnType } from './type/return-type/index.mjs';
 export { Strict } from './type/strict/index.mjs';
 export { String } from './type/string/index.mjs';
 export { Symbol } from './type/symbol/index.mjs';
-export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate } from './type/template-literal/index.mjs';
+export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, } from './type/template-literal/index.mjs';
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index.mjs';
 export { Tuple } from './type/tuple/index.mjs';
 export { Uint8Array } from './type/uint8array/index.mjs';

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

@@ -1,10 +1,10 @@
-import { type TTemplateLiteral, TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../template-literal/index.mjs';
+import { type TTemplateLiteral, TTemplateLiteralGenerate } from '../template-literal/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TInteger } from '../integer/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type TSchema } from '../schema/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-type FromTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFinite<T>> = (F extends true ? TemplateLiteralGenerate<T> extends infer R extends string[] ? R : [] : []);
+type FromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
 declare function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): FromTemplateLiteral<T>;
 type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TIndexPropertyKeys<L>, ...FromUnion<R>] : []);
 declare function FromUnion<T extends TSchema[]>(T: T): FromUnion<T>;