@depup/typebox 1.1.21-depup.0 → 1.3.8-depup.0

package/build/typebox.mjs

@@ -13,31 +13,30 @@ export { Script } from './type/script/index.mjs';
 // ------------------------------------------------------------------
 // Actions
 // ------------------------------------------------------------------
-export { Awaited } from './type/action/awaited.mjs';
 export { Capitalize } from './type/action/capitalize.mjs';
 export { Conditional } from './type/action/conditional.mjs';
-export { ConstructorParameters } from './type/action/constructor-parameters.mjs';
+export { ConstructorParameters } from './type/action/constructor_parameters.mjs';
 export { Evaluate } from './type/action/evaluate.mjs';
 export { Exclude } from './type/action/exclude.mjs';
 export { Extract } from './type/action/extract.mjs';
 export { Index } from './type/action/index.mjs';
-export { InstanceType } from './type/action/instance-type.mjs';
+export { InstanceType } from './type/action/instance_type.mjs';
 export { Interface } from './type/action/interface.mjs';
 export { KeyOf } from './type/action/keyof.mjs';
 export { Lowercase } from './type/action/lowercase.mjs';
 export { Mapped } from './type/action/mapped.mjs';
 export { Module } from './type/action/module.mjs';
-export { NonNullable } from './type/action/non-nullable.mjs';
+export { NonNullable } from './type/action/non_nullable.mjs';
 export { Omit } from './type/action/omit.mjs';
-export { Options } from './type/action/options.mjs';
 export { Parameters } from './type/action/parameters.mjs';
 export { Partial } from './type/action/partial.mjs';
 export { Pick } from './type/action/pick.mjs';
-export { ReadonlyType } from './type/action/readonly-type.mjs';
+export { ReadonlyObject, ReadonlyType } from './type/action/readonly_object.mjs';
 export { Required } from './type/action/required.mjs';
-export { ReturnType } from './type/action/return-type.mjs';
+export { ReturnType } from './type/action/return_type.mjs';
 export { Uncapitalize } from './type/action/uncapitalize.mjs';
 export { Uppercase } from './type/action/uppercase.mjs';
+export { With } from './type/action/with.mjs';
 // ------------------------------------------------------------------
 // Extension
 // ------------------------------------------------------------------
@@ -51,35 +50,32 @@ export { IsRefine, Refine } from './type/types/_refine.mjs';
 // ------------------------------------------------------------------
 export { Any, IsAny } from './type/types/any.mjs';
 export { Array, IsArray } from './type/types/array.mjs';
-export { AsyncIterator, IsAsyncIterator } from './type/types/async-iterator.mjs';
-export { Base, IsBase } from './type/types/base.mjs';
 export { BigInt, IsBigInt } from './type/types/bigint.mjs';
 export { Boolean, IsBoolean } from './type/types/boolean.mjs';
 export { Call, IsCall } from './type/types/call.mjs';
 export { Constructor, IsConstructor } from './type/types/constructor.mjs';
 export { Cyclic, IsCyclic } from './type/types/cyclic.mjs';
-export { Enum, IsEnum } from './type/types/enum.mjs';
+export { Enum, IsEnum, IsEnumValue } from './type/types/enum.mjs';
 export { Function, IsFunction } from './type/types/function.mjs';
 export { Generic, IsGeneric } from './type/types/generic.mjs';
 export { Identifier, IsIdentifier } from './type/types/identifier.mjs';
+export { Dependent, IsDependent } from './type/types/dependent.mjs';
 export { Infer, IsInfer } from './type/types/infer.mjs';
 export { Integer, IsInteger } from './type/types/integer.mjs';
 export { Intersect, IsIntersect } from './type/types/intersect.mjs';
-export { IsIterator, Iterator } from './type/types/iterator.mjs';
 export { IsLiteral, Literal } from './type/types/literal.mjs';
 export { IsNever, Never } from './type/types/never.mjs';
 export { IsNull, Null } from './type/types/null.mjs';
 export { IsNumber, Number } from './type/types/number.mjs';
 export { IsObject, Object } from './type/types/object.mjs';
 export { IsParameter, Parameter } from './type/types/parameter.mjs';
-export { IsPromise, Promise } from './type/types/promise.mjs';
-export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue } from './type/types/record.mjs';
+export { IsRecord, Record, RecordKey, RecordPattern, RecordValue } from './type/types/record.mjs';
 export { IsRef, Ref } from './type/types/ref.mjs';
 export { IsRest, Rest } from './type/types/rest.mjs';
 export { IsKind, IsSchema } from './type/types/schema.mjs';
 export { IsString, String } from './type/types/string.mjs';
 export { IsSymbol, Symbol } from './type/types/symbol.mjs';
-export { IsTemplateLiteral, TemplateLiteral } from './type/types/template-literal.mjs';
+export { IsTemplateLiteral, TemplateLiteral } from './type/types/template_literal.mjs';
 export { IsThis, This } from './type/types/this.mjs';
 export { IsTuple, Tuple } from './type/types/tuple.mjs';
 export { IsUndefined, Undefined } from './type/types/undefined.mjs';

package/build/value/clean/clean.mjs

@@ -1,5 +1,6 @@
-import { Arguments } from '../../system/arguments/index.mjs';
-import { FromType } from './from-type.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
+import { FromType } from './from_type.mjs';
+import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 /**
  * Cleans a value by removing non-evaluated properties and elements as derived from the provided type.
  * This function returns unknown so callers should Check the return value before use. This function
@@ -11,5 +12,6 @@ export function Clean(...args) {
         3: (context, type, value) => [context, type, value],
         2: (type, value) => [{}, type, value]
     });
-    return FromType(context, type, value);
+    const sorted = Settings.Get().unionPrioritySort ? UnionPrioritySort(type) : type;
+    return FromType(context, sorted, value);
 }

package/build/value/clean/{from-array.mjs → from_array.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromArray(context, type, value) {
     if (!Guard.IsArray(value))
         return value;

package/build/value/clean/{from-cyclic.mjs → from_cyclic.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Ref } from '../../type/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromCyclic(context, type, value) {
     return FromType({ ...context, ...type.$defs }, Ref(type.$ref), value);
 }

package/build/value/clean/{from-intersect.mjs → from_intersect.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
-import { Evaluate, Instantiate, IsObject, Options } from '../../type/index.mjs';
+import { Evaluate, Instantiate, IsObject, With } from '../../type/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 // ------------------------------------------------------------------
 // EvaluateIntersection
 // ------------------------------------------------------------------
@@ -13,7 +13,7 @@ function EvaluateIntersection(context, type) {
     const instantiated = Instantiate(context, type);
     const evaluated = Evaluate(instantiated);
     return IsObject(evaluated)
-        ? Options(evaluated, additionalProperties)
+        ? With(evaluated, additionalProperties)
         : evaluated;
 }
 // ------------------------------------------------------------------

package/build/value/clean/{from-object.mjs → from_object.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { IsSchema } from '../../type/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Check } from '../check/index.mjs';
 import { GetAdditionalProperties } from './additional.mjs';
 // ------------------------------------------------------------------

package/build/value/clean/{from-record.mjs → from_record.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { IsSchema, RecordPattern, RecordValue } from '../../type/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Check } from '../check/index.mjs';
 import { GetAdditionalProperties } from './additional.mjs';
 // ------------------------------------------------------------------

package/build/value/clean/{from-ref.mjs → from_ref.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromRef(context, type, value) {
     return Guard.HasPropertyKey(context, type.$ref)
         ? FromType(context, context[type.$ref], value)

package/build/value/clean/{from-tuple.mjs → from_tuple.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromTuple(context, schema, value) {
     if (!Guard.IsArray(value))
         return value;

package/build/value/clean/from_type.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import * as T from '../../type/index.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromRecord } from './from_record.mjs';
+import { FromRef } from './from_ref.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.mjs';
+export function FromType(context, type, value) {
+    return (T.IsArray(type) ? FromArray(context, type, value) :
+        T.IsCyclic(type) ? FromCyclic(context, type, value) :
+            T.IsIntersect(type) ? FromIntersect(context, type, value) :
+                T.IsObject(type) ? FromObject(context, type, value) :
+                    T.IsRecord(type) ? FromRecord(context, type, value) :
+                        T.IsRef(type) ? FromRef(context, type, value) :
+                            T.IsTuple(type) ? FromTuple(context, type, value) :
+                                T.IsUnion(type) ? FromUnion(context, type, value) :
+                                    value);
+}

package/build/value/clean/{from-union.mjs → from_union.mjs}

@@ -1,10 +1,9 @@
 // deno-fmt-ignore-file
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
-import { FromType } from './from-type.mjs';
-import { UnionPrioritySort } from '../shared/union-priority-sort.mjs';
+import { FromType } from './from_type.mjs';
 export function FromUnion(context, type, value) {
-    for (const schema of UnionPrioritySort(type.anyOf)) {
+    for (const schema of type.anyOf) {
         const clean = FromType(context, schema, Clone(value));
         if (Check(context, schema, clean))
             return clean;

package/build/value/clone/clone.mjs

@@ -1,70 +1,5 @@
 // deno-fmt-ignore-file
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// ClassInstance
-//
-// TypeBox does not support cloning arbitrary class instances. It treats
-// class instances as atomic values, similar to number, boolean, and
-// string. In the future, an implementation could detect the presence of
-// a .clone() method, but no formal specification for this behavior
-// exists, so we don't.
-//
-// ------------------------------------------------------------------
-function FromClassInstance(value) {
-    return value; // atomic
-}
-// ------------------------------------------------------------------
-// ObjectInstance
-// ------------------------------------------------------------------
-function FromObjectInstance(value) {
-    const result = {};
-    for (const key of Object.getOwnPropertyNames(value)) {
-        result[key] = Clone(value[key]);
-    }
-    for (const key of Object.getOwnPropertySymbols(value)) {
-        result[key] = Clone(value[key]);
-    }
-    return result;
-}
-Object.create({});
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-function FromObject(value) {
-    return (Guard.IsClassInstance(value)
-        ? FromClassInstance(value)
-        : FromObjectInstance(value));
-}
-// ------------------------------------------------------------------
-// Array
-// ------------------------------------------------------------------
-function FromArray(value) {
-    return value.map((element) => Clone(element));
-}
-// ------------------------------------------------------------------
-// TypeArray
-// ------------------------------------------------------------------
-function FromTypedArray(value) {
-    return value.slice();
-}
-// ------------------------------------------------------------------
-// Map
-// ------------------------------------------------------------------
-function FromMap(value) {
-    return new Map(Clone([...value.entries()]));
-}
-// ------------------------------------------------------------------
-// Set
-// ------------------------------------------------------------------
-function FromSet(value) {
-    return new Set(Clone([...value.values()]));
-}
-// ------------------------------------------------------------------
-// Value
-// ------------------------------------------------------------------
-function FromValue(value) {
-    return value;
-}
+import { Clone as SystemClone } from '../../system/memory/clone.mjs';
 // ------------------------------------------------------------------
 // Clone
 // ------------------------------------------------------------------
@@ -73,10 +8,5 @@ function FromValue(value) {
  * but also supports deep cloning instances of Map, Set and TypeArray.
  */
 export function Clone(value) {
-    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
-        GlobalsGuard.IsMap(value) ? FromMap(value) :
-            GlobalsGuard.IsSet(value) ? FromSet(value) :
-                Guard.IsArray(value) ? FromArray(value) :
-                    Guard.IsObject(value) ? FromObject(value) :
-                        FromValue(value));
+    return SystemClone(value);
 }

package/build/value/codec/decode.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -8,7 +8,8 @@ import { Clone } from '../clone/index.mjs';
 import { Convert } from '../convert/index.mjs';
 import { Default } from '../default/index.mjs';
 import { Pipeline } from '../pipeline/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
+import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 // ------------------------------------------------------------------
 // Assert
 // ------------------------------------------------------------------
@@ -27,7 +28,8 @@ function Assert(context, type, value) {
 // ------------------------------------------------------------------
 /** Executes Decode callbacks only */
 export function DecodeUnsafe(context, type, value) {
-    return FromType('Decode', context, type, value);
+    const sorted = Settings.Get().unionPrioritySort ? UnionPrioritySort(type) : type;
+    return FromType('Decode', context, sorted, value);
 }
 // ------------------------------------------------------------------
 // Decoder

package/build/value/codec/encode.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -8,7 +8,8 @@ import { Clone } from '../clone/index.mjs';
 import { Convert } from '../convert/index.mjs';
 import { Default } from '../default/index.mjs';
 import { Pipeline } from '../pipeline/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
+import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 // ------------------------------------------------------------------
 // Assert
 // ------------------------------------------------------------------
@@ -27,7 +28,8 @@ function Assert(context, type, value) {
 // ------------------------------------------------------------------
 /** Executes Encode callbacks only */
 export function EncodeUnsafe(context, type, value) {
-    return FromType('Encode', context, type, value);
+    const sorted = Settings.Get().unionPrioritySort ? UnionPrioritySort(type) : type;
+    return FromType('Encode', context, sorted, value);
 }
 // ------------------------------------------------------------------
 // Encoder

package/build/value/codec/{from-array.mjs → from_array.mjs}

@@ -1,16 +1,13 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    // deno-coverage-ignore-start - unreachable | checked
     if (!Guard.IsArray(value))
-        return Unreachable();
-    // deno-coverage-ignore-stop
+        return value;
     for (let i = 0; i < value.length; i++) {
         value[i] = FromType(direction, context, type.items, value[i]);
     }

package/build/value/codec/{from-cyclic.mjs → from_cyclic.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Ref } from '../../type/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
 export function FromCyclic(direction, context, type, value) {
     value = FromType(direction, { ...context, ...type.$defs }, Ref(type.$ref), value);

package/build/value/codec/{from-intersect.mjs → from_intersect.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Clean } from '../clean/index.mjs';

package/build/value/codec/{from-object.mjs → from_object.mjs}

@@ -1,17 +1,14 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
-import { IsOptionalUndefined } from '../shared/optional-undefined.mjs';
+import { IsOptionalUndefined } from '../shared/optional_undefined.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    // deno-coverage-ignore-start - unreachable | checked
     if (!Guard.IsObjectNotArray(value))
-        return Unreachable();
-    // deno-coverage-ignore-stop
+        return value;
     for (const key of Guard.Keys(type.properties)) {
         // Ignore for non-present or optional-undefined
         if (!Guard.HasPropertyKey(value, key) || IsOptionalUndefined(type.properties[key], key, value))

package/build/value/codec/{from-record.mjs → from_record.mjs}

@@ -1,23 +1,18 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { RecordPattern, RecordValue } from '../../type/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    // deno-coverage-ignore-start - unreachable | checked
     if (!Guard.IsObjectNotArray(value))
-        return Unreachable();
-    // deno-coverage-ignore-stop
+        return value;
     const regexp = new RegExp(RecordPattern(type));
     for (const key of Guard.Keys(value)) {
-        // deno-coverage-ignore-start - unreachable | checked
         if (!regexp.test(key))
-            Unreachable();
-        // deno-coverage-ignore-stop
+            continue;
         value[key] = FromType(direction, context, RecordValue(type), value[key]);
     }
     return Callback(direction, context, type, value);

package/build/value/codec/{from-ref.mjs → from_ref.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
 // ------------------------------------------------------------------
 // ResolveRef

package/build/value/codec/{from-tuple.mjs → from_tuple.mjs}

@@ -1,16 +1,13 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    // deno-coverage-ignore-start - unreachable | checked
     if (!Guard.IsArray(value))
-        return Unreachable();
-    // deno-coverage-ignore-stop
+        return value;
     for (let i = 0; i < Math.min(type.items.length, value.length); i++) {
         value[i] = FromType(direction, context, type.items[i], value[i]);
     }

package/build/value/codec/{from-type.mjs → from_type.mjs}

@@ -1,13 +1,13 @@
 // deno-fmt-ignore-file
 import * as Type from '../../type/index.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromCyclic } from './from-cyclic.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromRecord } from './from-record.mjs';
-import { FromRef } from './from-ref.mjs';
-import { FromTuple } from './from-tuple.mjs';
-import { FromUnion } from './from-union.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromRecord } from './from_record.mjs';
+import { FromRef } from './from_ref.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.mjs';
 import { Callback } from './callback.mjs';
 export function FromType(direction, context, type, value) {
     return (Type.IsArray(type) ? FromArray(direction, context, type, value) :

package/build/value/codec/{from-union.mjs → from_union.mjs}

@@ -1,15 +1,14 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Callback } from './callback.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Check } from '../check/index.mjs';
-import { UnionPrioritySort } from '../shared/union-priority-sort.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    for (const schema of UnionPrioritySort(type.anyOf, 1)) {
+    for (const schema of type.anyOf) {
         if (!Check(context, schema, value))
             continue;
         const variant = FromType(direction, context, schema, value);
@@ -22,7 +21,7 @@ function Decode(direction, context, type, value) {
 // ------------------------------------------------------------------
 function Encode(direction, context, type, value) {
     const exterior = Callback(direction, context, type, value);
-    for (const schema of UnionPrioritySort(type.anyOf, -1)) {
+    for (const schema of type.anyOf) {
         const variant = FromType(direction, context, schema, Clone(exterior));
         if (!Check(context, schema, variant))
             continue;

package/build/value/convert/convert.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Arguments } from '../../system/arguments/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 /**
  * Converts a value to the given type, coercing interior values if a reasonable conversion is possible. This
  * function returns unknown so callers should Check the return value before use. This function mutates the

package/build/value/convert/{from-additional.mjs → from_additional.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 /**
  * Used by Object and Record Types. The entries are derived from the known
  * properties obtained from 'properties' and 'patternProperties' respectively.

package/build/value/convert/from_array.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { Try } from './try/index.mjs';
+export function FromArray(context, type, value) {
+    const result = Try.TryArray(value);
+    return result.value.map(value => FromType(context, type.items, value));
+}

package/build/value/convert/{from-bigint.mjs → from_bigint.mjs}

@@ -1,9 +1,6 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
 import { Try } from './try/index.mjs';
 export function FromBigInt(_context, _type, value) {
-    if (Guard.IsBigInt(value))
-        return value;
     const result = Try.TryBigInt(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/{from-boolean.mjs → from_boolean.mjs}

@@ -1,9 +1,6 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
 import { Try } from './try/index.mjs';
 export function FromBoolean(_context, _type, value) {
-    if (Guard.IsBoolean(value))
-        return value;
     const result = Try.TryBoolean(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/{from-cyclic.mjs → from_cyclic.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Ref } from '../../type/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromCyclic(context, type, value) {
     return FromType({ ...context, ...type.$defs }, Ref(type.$ref), value);
 }

package/build/value/convert/from_enum.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Evaluate } from '../../type/index.mjs';
+import { FromType } from './from_type.mjs';
+export function FromEnum(context, type, value) {
+    return FromType(context, Evaluate(type), value);
+}

package/build/value/convert/{from-integer.mjs → from_integer.mjs}

@@ -1,9 +1,6 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
 import { Try } from './try/index.mjs';
 export function FromInteger(_context, _type, value) {
-    if (Guard.IsInteger(value))
-        return value;
     const result = Try.TryNumber(value);
     return Try.IsOk(result) ? Math.trunc(result.value) : value;
 }

package/build/value/convert/{from-intersect.mjs → from_intersect.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Evaluate, Instantiate } from '../../type/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromIntersect(context, type, value) {
     const instantiated = Instantiate(context, type);
     const evaluated = Evaluate(instantiated);

package/build/value/convert/{from-literal.d.mts → from_literal.d.mts}

@@ -1,2 +1,2 @@
-import { TLiteral, TProperties } from '../../type/index.mjs';
+import { type TLiteral, type TProperties } from '../../type/index.mjs';
 export declare function FromLiteral(context: TProperties, type: TLiteral, value: unknown): unknown;

package/build/value/convert/{from-null.mjs → from_null.mjs}

@@ -1,9 +1,6 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
 import { Try } from './try/index.mjs';
 export function FromNull(_context, _type, value) {
-    if (Guard.IsNull(value))
-        return value;
     const result = Try.TryNull(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/{from-number.mjs → from_number.mjs}

@@ -1,9 +1,6 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
 import { Try } from './try/index.mjs';
 export function FromNumber(_context, _type, value) {
-    if (Guard.IsNumber(value))
-        return value;
     const result = Try.TryNumber(value);
     return Try.IsOk(result) ? result.value : value;
 }