@sinclair/typebox 0.32.15 → 0.32.17

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

@@ -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);
+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);
+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);
+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/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);

package/build/require/type/indexed/indexed.js

@@ -27,7 +27,9 @@ function FromIntersect(T, K) {
 }
 // prettier-ignore
 function FromUnionRest(T) {
-    return T; // review this
+    return (T.some(L => (0, type_2.IsNever)(L))
+        ? []
+        : T);
 }
 // prettier-ignore
 function FromUnion(T, K) {

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

@@ -24,8 +24,9 @@ export type TDecodeProperties<T extends TProperties> = {
 };
 export type TDecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TDecodeRest<R, [...Acc, TDecodeType<L>]> : Acc;
 export type TDecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<TDecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<TDecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<TDecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<TDecodeRest<P>, TDecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<TDecodeRest<P>, TDecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TDecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<TDecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<TDecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<TDecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> : T);
+export type StaticDecodeIsAny<T> = boolean extends (T extends TSchema ? true : false) ? true : false;
 /** Creates an decoded static type from a TypeBox type */
-export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<TDecodeType<T>, P>;
+export type StaticDecode<T extends TSchema, P extends unknown[] = []> = StaticDecodeIsAny<T> extends true ? unknown : Static<TDecodeType<T>, P>;
 /** Creates an encoded static type from a TypeBox type */
 export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>;
 /** Creates a static type from a TypeBox type */

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

@@ -9,23 +9,42 @@ const index_1 = require("../error/index");
 class TemplateLiteralParserError extends index_1.TypeBoxError {
 }
 exports.TemplateLiteralParserError = TemplateLiteralParserError;
+// -------------------------------------------------------------------
+// Unescape
+//
+// Unescape for these control characters specifically. Note that this
+// function is only called on non union group content, and where we
+// still want to allow the user to embed control characters in that
+// content. For review.
+// -------------------------------------------------------------------
 // prettier-ignore
+function Unescape(pattern) {
+    return pattern
+        .replace(/\\\$/g, '$')
+        .replace(/\\\*/g, '*')
+        .replace(/\\\^/g, '^')
+        .replace(/\\\|/g, '|')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')');
+}
+// -------------------------------------------------------------------
+// Control Characters
+// -------------------------------------------------------------------
 function IsNonEscaped(pattern, index, char) {
     return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
 }
-// prettier-ignore
 function IsOpenParen(pattern, index) {
     return IsNonEscaped(pattern, index, '(');
 }
-// prettier-ignore
 function IsCloseParen(pattern, index) {
     return IsNonEscaped(pattern, index, ')');
 }
-// prettier-ignore
 function IsSeparator(pattern, index) {
     return IsNonEscaped(pattern, index, '|');
 }
-// prettier-ignore
+// -------------------------------------------------------------------
+// Control Groups
+// -------------------------------------------------------------------
 function IsGroup(pattern) {
     if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
         return false;
@@ -142,7 +161,7 @@ function TemplateLiteralParse(pattern) {
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
-                { type: 'const', const: pattern });
+                { type: 'const', const: Unescape(pattern) });
 }
 exports.TemplateLiteralParse = TemplateLiteralParse;
 // ------------------------------------------------------------------

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

@@ -12,7 +12,7 @@ type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [T
 ];
 type FromUnion<T extends string> = TUnionEvaluated<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>] : [
+type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$\{${infer R1}\}${infer R2}` ? [TLiteral<L>, ...FromString<`{${R1}}`>, ...FromString<R2>] : T extends `${infer L}$\{${infer R1}\}` ? [TLiteral<L>, ...FromString<`{${R1}}`>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
 export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */

package/build/require/value/convert/convert.js

@@ -3,44 +3,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Convert = void 0;
 const index_1 = require("../clone/index");
-const index_2 = require("../check/index");
-const index_3 = require("../deref/index");
-const type_1 = require("../../type/guard/type");
-const index_4 = require("../../type/symbols/index");
-const index_5 = require("../../type/composite/index");
+const index_2 = require("../deref/index");
+const index_3 = require("../../type/symbols/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_6 = require("../guard/index");
+const index_4 = require("../guard/index");
 // ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
 function IsStringNumeric(value) {
-    return (0, index_6.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
+    return (0, index_4.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
 }
 function IsValueToString(value) {
-    return (0, index_6.IsBigInt)(value) || (0, index_6.IsBoolean)(value) || (0, index_6.IsNumber)(value);
+    return (0, index_4.IsBigInt)(value) || (0, index_4.IsBoolean)(value) || (0, index_4.IsNumber)(value);
 }
 function IsValueTrue(value) {
-    return value === true || ((0, index_6.IsNumber)(value) && value === 1) || ((0, index_6.IsBigInt)(value) && value === BigInt('1')) || ((0, index_6.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
+    return value === true || ((0, index_4.IsNumber)(value) && value === 1) || ((0, index_4.IsBigInt)(value) && value === BigInt('1')) || ((0, index_4.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
 }
 function IsValueFalse(value) {
-    return value === false || ((0, index_6.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_6.IsBigInt)(value) && value === BigInt('0')) || ((0, index_6.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
+    return value === false || ((0, index_4.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_4.IsBigInt)(value) && value === BigInt('0')) || ((0, index_4.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
 }
 function IsTimeStringWithTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, index_4.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
 }
 function IsTimeStringWithoutTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_4.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateTimeStringWithTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, index_4.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
 }
 function IsDateTimeStringWithoutTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_4.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateString(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+    return (0, index_4.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
 }
 // ------------------------------------------------------------------
 // Convert
@@ -59,31 +56,31 @@ function TryConvertLiteralBoolean(value, target) {
 }
 // prettier-ignore
 function TryConvertLiteral(schema, value) {
-    return ((0, index_6.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
-        (0, index_6.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
-            (0, index_6.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
+    return ((0, index_4.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
+        (0, index_4.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
+            (0, index_4.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
                 (0, index_1.Clone)(value));
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
 }
 function TryConvertBigInt(value) {
-    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_6.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
+    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_4.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
 }
 function TryConvertString(value) {
-    return IsValueToString(value) ? value.toString() : (0, index_6.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
+    return IsValueToString(value) ? value.toString() : (0, index_4.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
 }
 function TryConvertNumber(value) {
     return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertInteger(value) {
-    return IsStringNumeric(value) ? parseInt(value) : (0, index_6.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+    return IsStringNumeric(value) ? parseInt(value) : (0, index_4.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertNull(value) {
-    return (0, index_6.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
+    return (0, index_4.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
 }
 function TryConvertUndefined(value) {
-    return (0, index_6.IsString)(value) && value === 'undefined' ? undefined : value;
+    return (0, index_4.IsString)(value) && value === 'undefined' ? undefined : value;
 }
 // ------------------------------------------------------------------
 // note: this function may return an invalid dates for the regex
@@ -94,8 +91,8 @@ function TryConvertUndefined(value) {
 // ------------------------------------------------------------------
 // prettier-ignore
 function TryConvertDate(value) {
-    return ((0, index_6.IsDate)(value) ? value :
-        (0, index_6.IsNumber)(value) ? new Date(value) :
+    return ((0, index_4.IsDate)(value) ? value :
+        (0, index_4.IsNumber)(value) ? new Date(value) :
             IsValueTrue(value) ? new Date(1) :
                 IsValueFalse(value) ? new Date(0) :
                     IsStringNumeric(value) ? new Date(parseInt(value)) :
@@ -116,7 +113,7 @@ function Default(value) {
 // Convert
 // ------------------------------------------------------------------
 function FromArray(schema, references, value) {
-    if ((0, index_6.IsArray)(value)) {
+    if ((0, index_4.IsArray)(value)) {
         return value.map((value) => Visit(schema.items, references, value));
     }
     return value;
@@ -133,12 +130,8 @@ function FromDate(schema, references, value) {
 function FromInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
-// prettier-ignore
 function FromIntersect(schema, references, value) {
-    const allObjects = schema.allOf.every(schema => (0, type_1.IsObject)(schema));
-    if (allObjects)
-        return Visit((0, index_5.Composite)(schema.allOf), references, value);
-    return Visit(schema.allOf[0], references, value); // todo: fix this
+    return schema.allOf.reduce((value, schema) => Visit(schema, references, value), value);
 }
 function FromLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
@@ -151,11 +144,11 @@ function FromNumber(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    const isConvertable = (0, index_6.IsObject)(value);
+    const isConvertable = (0, index_4.IsObject)(value);
     if (!isConvertable)
         return value;
     return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
-        return !(0, index_6.IsUndefined)(value[key])
+        return !(0, index_4.IsUndefined)(value[key])
             ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
             : ({ ...value });
     }, value);
@@ -170,20 +163,20 @@ function FromRecord(schema, references, value) {
     return result;
 }
 function FromRef(schema, references, value) {
-    return Visit((0, index_3.Deref)(schema, references), references, value);
+    return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 function FromString(schema, references, value) {
     return TryConvertString(value);
 }
 function FromSymbol(schema, references, value) {
-    return (0, index_6.IsString)(value) || (0, index_6.IsNumber)(value) ? Symbol(value) : value;
+    return (0, index_4.IsString)(value) || (0, index_4.IsNumber)(value) ? Symbol(value) : value;
 }
 function FromThis(schema, references, value) {
-    return Visit((0, index_3.Deref)(schema, references), references, value);
+    return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 // prettier-ignore
 function FromTuple(schema, references, value) {
-    const isConvertable = (0, index_6.IsArray)(value) && !(0, index_6.IsUndefined)(schema.items);
+    const isConvertable = (0, index_4.IsArray)(value) && !(0, index_4.IsUndefined)(schema.items);
     if (!isConvertable)
         return value;
     return value.map((value, index) => {
@@ -196,18 +189,12 @@ function FromUndefined(schema, references, value) {
     return TryConvertUndefined(value);
 }
 function FromUnion(schema, references, value) {
-    for (const subschema of schema.anyOf) {
-        const converted = Visit(subschema, references, value);
-        if ((0, index_2.Check)(subschema, references, converted)) {
-            return converted;
-        }
-    }
-    return value;
+    return schema.anyOf.reduce((value, schema) => Visit(schema, references, value), value);
 }
 function Visit(schema, references, value) {
-    const references_ = (0, index_6.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_4.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema[index_4.Kind]) {
+    switch (schema[index_3.Kind]) {
         case 'Array':
             return FromArray(schema_, references_, value);
         case 'BigInt':

package/build/require/value/delta/delta.d.ts

@@ -1,34 +1,34 @@
 import type { Static } from '../../type/static/index';
 import { TypeBoxError } from '../../type/error/index';
 export type Insert = Static<typeof Insert>;
-export declare const Insert: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"insert">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
+export declare const Insert: import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"insert">;
+    path: import("src/type/string/string").TString;
+    value: import("src/type/unknown/unknown").TUnknown;
 }>;
 export type Update = Static<typeof Update>;
-export declare const Update: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"update">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
+export declare const Update: import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"update">;
+    path: import("src/type/string/string").TString;
+    value: import("src/type/unknown/unknown").TUnknown;
 }>;
 export type Delete = Static<typeof Delete>;
-export declare const Delete: import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"delete">;
-    path: import("../../type/string/string").TString;
+export declare const Delete: import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"delete">;
+    path: import("src/type/string/string").TString;
 }>;
 export type Edit = Static<typeof Edit>;
-export declare const Edit: import("../../type/union/union-type").TUnion<[import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"insert">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
-}>, import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"update">;
-    path: import("../../type/string/string").TString;
-    value: import("../../type/unknown/unknown").TUnknown;
-}>, import("../../type/object/object").TObject<{
-    type: import("../../type/literal/literal").TLiteral<"delete">;
-    path: import("../../type/string/string").TString;
+export declare const Edit: import("src/type/union/union-type").TUnion<[import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"insert">;
+    path: import("src/type/string/string").TString;
+    value: import("src/type/unknown/unknown").TUnknown;
+}>, import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"update">;
+    path: import("src/type/string/string").TString;
+    value: import("src/type/unknown/unknown").TUnknown;
+}>, import("src/type/object/object").TObject<{
+    type: import("src/type/literal/literal").TLiteral<"delete">;
+    path: import("src/type/string/string").TString;
 }>]>;
 export declare class ValueDeltaError extends TypeBoxError {
     readonly value: unknown;

package/build/require/value/transform/decode.d.ts

@@ -9,8 +9,10 @@ export declare class TransformDecodeCheckError extends TypeBoxError {
 }
 export declare class TransformDecodeError 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]` Decodes the value and returns the result. This function requires that