@sinclair/typebox 0.32.14 → 0.32.16

package/build/import/value/transform/decode.mjs

@@ -7,7 +7,7 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -16,168 +16,174 @@ import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
 // Errors
 // ------------------------------------------------------------------
 // thrown externally
+// prettier-ignore
 export class TransformDecodeCheckError extends TypeBoxError {
     schema;
     value;
     error;
     constructor(schema, value, error) {
-        super(`Unable to decode due to invalid value`);
+        super(`Unable to decode value as it does not match the expected schema`);
         this.schema = schema;
         this.value = value;
         this.error = error;
     }
 }
+// prettier-ignore
 export class TransformDecodeError extends TypeBoxError {
     schema;
+    path;
     value;
-    constructor(schema, value, error) {
-        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
+    error;
+    constructor(schema, path, value, error) {
+        super(error instanceof Error ? error.message : 'Unknown error');
         this.schema = schema;
+        this.path = path;
         this.value = value;
+        this.error = error;
     }
 }
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 // prettier-ignore
-function Default(schema, value) {
+function Default(schema, path, value) {
     try {
         return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
     }
     catch (error) {
-        throw new TransformDecodeError(schema, value, error);
+        throw new TransformDecodeError(schema, path, value, error);
     }
 }
 // prettier-ignore
-function FromArray(schema, references, value) {
+function FromArray(schema, references, path, value) {
     return (IsArray(value))
-        ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
-        : Default(schema, value);
+        ? Default(schema, path, value.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value)))
+        : Default(schema, path, value);
 }
 // prettier-ignore
-function FromIntersect(schema, references, value) {
-    if (!IsPlainObject(value) || IsValueType(value))
-        return Default(schema, value);
+function FromIntersect(schema, references, path, value) {
+    if (!IsStandardObject(value) || IsValueType(value))
+        return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!IsTransform(schema.unevaluatedProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
-function FromNot(schema, references, value) {
-    return Default(schema, Visit(schema.not, references, value));
+function FromNot(schema, references, path, value) {
+    return Default(schema, path, Visit(schema.not, references, path, value));
 }
 // prettier-ignore
-function FromObject(schema, references, value) {
-    if (!IsPlainObject(value))
-        return Default(schema, value);
+function FromObject(schema, references, path, value) {
+    if (!IsStandardObject(value))
+        return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!IsSchema(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
 // prettier-ignore
-function FromRecord(schema, references, value) {
-    if (!IsPlainObject(value))
-        return Default(schema, value);
+function FromRecord(schema, references, path, value) {
+    if (!IsStandardObject(value))
+        return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
     const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
         return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!IsSchema(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
 // prettier-ignore
-function FromRef(schema, references, value) {
+function FromRef(schema, references, path, value) {
     const target = Deref(schema, references);
-    return Default(schema, Visit(target, references, value));
+    return Default(schema, path, Visit(target, references, path, value));
 }
 // prettier-ignore
-function FromThis(schema, references, value) {
+function FromThis(schema, references, path, value) {
     const target = Deref(schema, references);
-    return Default(schema, Visit(target, references, value));
+    return Default(schema, path, Visit(target, references, path, value));
 }
 // prettier-ignore
-function FromTuple(schema, references, value) {
+function FromTuple(schema, references, path, value) {
     return (IsArray(value) && IsArray(schema.items))
-        ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
-        : Default(schema, value);
+        ? Default(schema, path, schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value[index])))
+        : Default(schema, path, value);
 }
 // prettier-ignore
-function FromUnion(schema, references, value) {
+function FromUnion(schema, references, path, value) {
     for (const subschema of schema.anyOf) {
         if (!Check(subschema, references, value))
             continue;
         // note: ensure interior is decoded first
-        const decoded = Visit(subschema, references, value);
-        return Default(schema, decoded);
+        const decoded = Visit(subschema, references, path, value);
+        return Default(schema, path, decoded);
     }
-    return Default(schema, value);
+    return Default(schema, path, value);
 }
 // prettier-ignore
-function Visit(schema, references, value) {
+function Visit(schema, references, path, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         case 'Array':
-            return FromArray(schema_, references_, value);
+            return FromArray(schema_, references_, path, value);
         case 'Intersect':
-            return FromIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, path, value);
         case 'Not':
-            return FromNot(schema_, references_, value);
+            return FromNot(schema_, references_, path, value);
         case 'Object':
-            return FromObject(schema_, references_, value);
+            return FromObject(schema_, references_, path, value);
         case 'Record':
-            return FromRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return FromRef(schema_, references_, value);
+            return FromRef(schema_, references_, path, value);
         case 'Symbol':
-            return Default(schema_, value);
+            return Default(schema_, path, value);
         case 'This':
-            return FromThis(schema_, references_, value);
+            return FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return FromTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, path, value);
         case 'Union':
-            return FromUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, path, value);
         default:
-            return Default(schema_, value);
+            return Default(schema_, path, value);
     }
 }
 /**
@@ -186,5 +192,5 @@ function Visit(schema, references, value) {
  * undefined behavior. Refer to the `Value.Decode()` for implementation details.
  */
 export function TransformDecode(schema, references, value) {
-    return Visit(schema, references, value);
+    return Visit(schema, references, '', value);
 }

package/build/import/value/transform/encode.d.mts

@@ -9,8 +9,10 @@ export declare class TransformEncodeCheckError extends TypeBoxError {
 }
 export declare class TransformEncodeError extends TypeBoxError {
     readonly schema: TSchema;
+    readonly path: string;
     readonly value: unknown;
-    constructor(schema: TSchema, value: unknown, error: any);
+    readonly error: Error;
+    constructor(schema: TSchema, path: string, value: unknown, error: Error);
 }
 /**
  * `[Internal]` Encodes the value and returns the result. This function expects the

package/build/import/value/transform/encode.mjs

@@ -7,7 +7,7 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -15,80 +15,86 @@ import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
+// prettier-ignore
 export class TransformEncodeCheckError extends TypeBoxError {
     schema;
     value;
     error;
     constructor(schema, value, error) {
-        super(`Unable to encode due to invalid value`);
+        super(`The encoded value does not match the expected schema`);
         this.schema = schema;
         this.value = value;
         this.error = error;
     }
 }
+// prettier-ignore
 export class TransformEncodeError extends TypeBoxError {
     schema;
+    path;
     value;
-    constructor(schema, value, error) {
+    error;
+    constructor(schema, path, value, error) {
         super(`${error instanceof Error ? error.message : 'Unknown error'}`);
         this.schema = schema;
+        this.path = path;
         this.value = value;
+        this.error = error;
     }
 }
 // ------------------------------------------------------------------
 // Encode
 // ------------------------------------------------------------------
 // prettier-ignore
-function Default(schema, value) {
+function Default(schema, path, value) {
     try {
         return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
     }
     catch (error) {
-        throw new TransformEncodeError(schema, value, error);
+        throw new TransformEncodeError(schema, path, value, error);
     }
 }
 // prettier-ignore
-function FromArray(schema, references, value) {
-    const defaulted = Default(schema, value);
+function FromArray(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
     return IsArray(defaulted)
-        ? defaulted.map((value) => Visit(schema.items, references, value))
+        ? defaulted.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value))
         : defaulted;
 }
 // prettier-ignore
-function FromIntersect(schema, references, value) {
-    const defaulted = Default(schema, value);
-    if (!IsPlainObject(value) || IsValueType(value))
+function FromIntersect(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
+    if (!IsStandardObject(value) || IsValueType(value))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in defaulted
-            ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) }
             : value;
     }, defaulted);
     if (!IsTransform(schema.unevaluatedProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
     return unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
 }
 // prettier-ignore
-function FromNot(schema, references, value) {
-    return Default(schema.not, Default(schema, value));
+function FromNot(schema, references, path, value) {
+    return Default(schema.not, path, Default(schema, path, value));
 }
 // prettier-ignore
-function FromObject(schema, references, value) {
-    const defaulted = Default(schema, value);
-    if (!IsPlainObject(value))
+function FromObject(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
+    if (!IsStandardObject(value))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in value
-            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
             : value;
     }, defaulted);
     if (!IsSchema(schema.additionalProperties)) {
@@ -98,93 +104,93 @@ function FromObject(schema, references, value) {
     const additionalProperties = schema.additionalProperties;
     return unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
 }
 // prettier-ignore
-function FromRecord(schema, references, value) {
-    const defaulted = Default(schema, value);
-    if (!IsPlainObject(value))
+function FromRecord(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
+    if (!IsStandardObject(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
     const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
         return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
             : value;
     }, defaulted);
     if (!IsSchema(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
     return unknownKeys.reduce((value, key) => {
         return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
 }
 // prettier-ignore
-function FromRef(schema, references, value) {
+function FromRef(schema, references, path, value) {
     const target = Deref(schema, references);
-    const resolved = Visit(target, references, value);
-    return Default(schema, resolved);
+    const resolved = Visit(target, references, path, value);
+    return Default(schema, path, resolved);
 }
 // prettier-ignore
-function FromThis(schema, references, value) {
+function FromThis(schema, references, path, value) {
     const target = Deref(schema, references);
-    const resolved = Visit(target, references, value);
-    return Default(schema, resolved);
+    const resolved = Visit(target, references, path, value);
+    return Default(schema, path, resolved);
 }
 // prettier-ignore
-function FromTuple(schema, references, value) {
-    const value1 = Default(schema, value);
-    return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : [];
+function FromTuple(schema, references, path, value) {
+    const value1 = Default(schema, path, value);
+    return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value1[index])) : [];
 }
 // prettier-ignore
-function FromUnion(schema, references, value) {
+function FromUnion(schema, references, path, value) {
     // test value against union variants
     for (const subschema of schema.anyOf) {
         if (!Check(subschema, references, value))
             continue;
-        const value1 = Visit(subschema, references, value);
-        return Default(schema, value1);
+        const value1 = Visit(subschema, references, path, value);
+        return Default(schema, path, value1);
     }
     // test transformed value against union variants
     for (const subschema of schema.anyOf) {
-        const value1 = Visit(subschema, references, value);
+        const value1 = Visit(subschema, references, path, value);
         if (!Check(schema, references, value1))
             continue;
-        return Default(schema, value1);
+        return Default(schema, path, value1);
     }
-    return Default(schema, value);
+    return Default(schema, path, value);
 }
 // prettier-ignore
-function Visit(schema, references, value) {
+function Visit(schema, references, path, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         case 'Array':
-            return FromArray(schema_, references_, value);
+            return FromArray(schema_, references_, path, value);
         case 'Intersect':
-            return FromIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, path, value);
         case 'Not':
-            return FromNot(schema_, references_, value);
+            return FromNot(schema_, references_, path, value);
         case 'Object':
-            return FromObject(schema_, references_, value);
+            return FromObject(schema_, references_, path, value);
         case 'Record':
-            return FromRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return FromRef(schema_, references_, value);
+            return FromRef(schema_, references_, path, value);
         case 'This':
-            return FromThis(schema_, references_, value);
+            return FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return FromTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, path, value);
         case 'Union':
-            return FromUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, path, value);
         default:
-            return Default(schema_, value);
+            return Default(schema_, path, value);
     }
 }
 /**
@@ -194,5 +200,5 @@ function Visit(schema, references, value) {
  * `Value.Encode()` function for implementation details.
  */
 export function TransformEncode(schema, references, value) {
-    return Visit(schema, references, value);
+    return Visit(schema, references, '', value);
 }

package/build/import/value/value/value.mjs

@@ -51,7 +51,7 @@ export function Encode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     const encoded = TransformEncode(schema, references, value);
     if (!Check(schema, references, encoded))
-        throw new TransformEncodeCheckError(schema, value, Errors(schema, references, value).First());
+        throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
     return encoded;
 }
 /** Returns an iterator for each error in this value. */

package/build/require/compiler/index.d.ts

@@ -1,2 +1,2 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { TypeCompiler, TypeCheck, type TypeCompilerCodegenOptions, type TypeCompilerLanguageOption, TypeCompilerTypeGuardError, TypeCompilerUnknownTypeError } from './compiler';
+export * from './compiler';

package/build/require/compiler/index.js

@@ -1,12 +1,22 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompilerUnknownTypeError = exports.TypeCompilerTypeGuardError = exports.TypeCheck = exports.TypeCompiler = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
 Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
-var compiler_1 = require("./compiler");
-Object.defineProperty(exports, "TypeCompiler", { enumerable: true, get: function () { return compiler_1.TypeCompiler; } });
-Object.defineProperty(exports, "TypeCheck", { enumerable: true, get: function () { return compiler_1.TypeCheck; } });
-Object.defineProperty(exports, "TypeCompilerTypeGuardError", { enumerable: true, get: function () { return compiler_1.TypeCompilerTypeGuardError; } });
-Object.defineProperty(exports, "TypeCompilerUnknownTypeError", { enumerable: true, get: function () { return compiler_1.TypeCompilerUnknownTypeError; } });
+__exportStar(require("./compiler"), exports);

package/build/require/errors/index.d.ts

@@ -1,2 +1,2 @@
-export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors';
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction, type ErrorFunctionParameter } from './function';
+export * from './errors';
+export * from './function';

package/build/require/errors/index.js

@@ -1,13 +1,19 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetErrorFunction = exports.GetErrorFunction = exports.DefaultErrorFunction = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = exports.ValueErrorIterator = exports.Errors = void 0;
-var errors_1 = require("./errors");
-Object.defineProperty(exports, "Errors", { enumerable: true, get: function () { return errors_1.Errors; } });
-Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return errors_1.ValueErrorIterator; } });
-Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
-Object.defineProperty(exports, "ValueErrorsUnknownTypeError", { enumerable: true, get: function () { return errors_1.ValueErrorsUnknownTypeError; } });
-var function_1 = require("./function");
-Object.defineProperty(exports, "DefaultErrorFunction", { enumerable: true, get: function () { return function_1.DefaultErrorFunction; } });
-Object.defineProperty(exports, "GetErrorFunction", { enumerable: true, get: function () { return function_1.GetErrorFunction; } });
-Object.defineProperty(exports, "SetErrorFunction", { enumerable: true, get: function () { return function_1.SetErrorFunction; } });
+__exportStar(require("./errors"), exports);
+__exportStar(require("./function"), exports);

package/build/require/system/index.d.ts

@@ -1,2 +1,2 @@
-export { TypeSystemPolicy } from './policy';
-export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system';
+export * from './policy';
+export * from './system';

package/build/require/system/index.js

@@ -1,10 +1,19 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeSystemDuplicateTypeKind = exports.TypeSystemDuplicateFormat = exports.TypeSystem = exports.TypeSystemPolicy = void 0;
-var policy_1 = require("./policy");
-Object.defineProperty(exports, "TypeSystemPolicy", { enumerable: true, get: function () { return policy_1.TypeSystemPolicy; } });
-var system_1 = require("./system");
-Object.defineProperty(exports, "TypeSystem", { enumerable: true, get: function () { return system_1.TypeSystem; } });
-Object.defineProperty(exports, "TypeSystemDuplicateFormat", { enumerable: true, get: function () { return system_1.TypeSystemDuplicateFormat; } });
-Object.defineProperty(exports, "TypeSystemDuplicateTypeKind", { enumerable: true, get: function () { return system_1.TypeSystemDuplicateTypeKind; } });
+__exportStar(require("./policy"), exports);
+__exportStar(require("./system"), exports);

package/build/require/system/system.d.ts

@@ -8,7 +8,7 @@ export declare class TypeSystemDuplicateFormat extends TypeBoxError {
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export declare namespace TypeSystem {
     /** Creates a new type */
-    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("../type/unsafe/unsafe").TUnsafe<Type>;
+    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("src/type/unsafe/unsafe").TUnsafe<Type>;
     /** Creates a new string format */
     function Format<F extends string>(format: F, check: (value: string) => boolean): F;
 }

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

@@ -16,7 +16,7 @@ import { type TIndexFromMappedResult } from './indexed-from-mapped-result';
 type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Acc);
 type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
 type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
-type TFromUnionRest<T extends TSchema[]> = T;
+type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : TFromUnionRest<R, [L, ...Acc]> : Acc;
 type TFromUnion<T extends TSchema[], K extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>);
 type TFromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? TUnionEvaluated<T> : TNever);
 type TFromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);