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

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

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
-import { FromAdditionalProperties } from './from-additional.mjs';
-import { IsOptionalUndefined } from '../shared/optional-undefined.mjs';
+import { FromType } from './from_type.mjs';
+import { FromAdditionalProperties } from './from_additional.mjs';
+import { IsOptionalUndefined } from '../shared/optional_undefined.mjs';
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------

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

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
-import { FromAdditionalProperties } from './from-additional.mjs';
+import { FromType } from './from_type.mjs';
+import { FromAdditionalProperties } from './from_additional.mjs';
 function FromPatternProperties(context, type, value) {
     const entries = Guard.EntriesRegExp(type.patternProperties);
     const keys = Guard.Keys(value);

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

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

package/build/value/convert/{from-string.mjs → from_string.mjs}

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

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

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

package/build/value/convert/from_template_literal.mjs

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

package/build/value/convert/{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, type, value) {
     if (!Guard.IsArray(value))
         return value;

package/build/value/convert/from_type.d.mts

@@ -0,0 +1,2 @@
+import * as Type from '../../type/index.mjs';
+export declare function FromType(context: Type.TProperties, type: Type.TSchema, value: unknown): unknown;

package/build/value/convert/from_type.mjs

@@ -0,0 +1,43 @@
+// deno-fmt-ignore-file
+import * as Type from '../../type/index.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromBigInt } from './from_bigint.mjs';
+import { FromBoolean } from './from_boolean.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromEnum } from './from_enum.mjs';
+import { FromInteger } from './from_integer.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromLiteral } from './from_literal.mjs';
+import { FromNull } from './from_null.mjs';
+import { FromNumber } from './from_number.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromRecord } from './from_record.mjs';
+import { FromRef } from './from_ref.mjs';
+import { FromString } from './from_string.mjs';
+import { FromTemplateLiteral } from './from_template_literal.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUndefined } from './from_undefined.mjs';
+import { FromUnion } from './from_union.mjs';
+import { FromVoid } from './from_void.mjs';
+export function FromType(context, type, value) {
+    return (Type.IsArray(type) ? FromArray(context, type, value) :
+        Type.IsBigInt(type) ? FromBigInt(context, type, value) :
+            Type.IsBoolean(type) ? FromBoolean(context, type, value) :
+                Type.IsCyclic(type) ? FromCyclic(context, type, value) :
+                    Type.IsEnum(type) ? FromEnum(context, type, value) :
+                        Type.IsInteger(type) ? FromInteger(context, type, value) :
+                            Type.IsIntersect(type) ? FromIntersect(context, type, value) :
+                                Type.IsLiteral(type) ? FromLiteral(context, type, value) :
+                                    Type.IsNull(type) ? FromNull(context, type, value) :
+                                        Type.IsNumber(type) ? FromNumber(context, type, value) :
+                                            Type.IsObject(type) ? FromObject(context, type, value) :
+                                                Type.IsRecord(type) ? FromRecord(context, type, value) :
+                                                    Type.IsRef(type) ? FromRef(context, type, value) :
+                                                        Type.IsString(type) ? FromString(context, type, value) :
+                                                            Type.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
+                                                                Type.IsTuple(type) ? FromTuple(context, type, value) :
+                                                                    Type.IsUndefined(type) ? FromUndefined(context, type, value) :
+                                                                        Type.IsUnion(type) ? FromUnion(context, type, value) :
+                                                                            Type.IsVoid(type) ? FromVoid(context, type, value) :
+                                                                                value);
+}

package/build/value/convert/{from-undefined.mjs → from_undefined.mjs}

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

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

@@ -2,7 +2,7 @@
 import { Guard } from '../../guard/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromUnion(context, type, value) {
     const matched = type.anyOf.some(type => Check(context, type, value));
     if (matched)

package/build/value/convert/{from-void.mjs → from_void.mjs}

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

package/build/value/convert/try/try.d.mts

@@ -1,7 +1,8 @@
-export * from './try-bigint.mjs';
-export * from './try-boolean.mjs';
-export * from './try-null.mjs';
-export * from './try-number.mjs';
-export * from './try-result.mjs';
-export * from './try-string.mjs';
-export * from './try-undefined.mjs';
+export * from './try_array.mjs';
+export * from './try_bigint.mjs';
+export * from './try_boolean.mjs';
+export * from './try_null.mjs';
+export * from './try_number.mjs';
+export * from './try_result.mjs';
+export * from './try_string.mjs';
+export * from './try_undefined.mjs';

package/build/value/convert/try/try.mjs

@@ -1,7 +1,8 @@
-export * from './try-bigint.mjs';
-export * from './try-boolean.mjs';
-export * from './try-null.mjs';
-export * from './try-number.mjs';
-export * from './try-result.mjs';
-export * from './try-string.mjs';
-export * from './try-undefined.mjs';
+export * from './try_array.mjs';
+export * from './try_bigint.mjs';
+export * from './try_boolean.mjs';
+export * from './try_null.mjs';
+export * from './try_number.mjs';
+export * from './try_result.mjs';
+export * from './try_string.mjs';
+export * from './try_undefined.mjs';

package/build/value/convert/try/try_array.d.mts

@@ -0,0 +1,2 @@
+import { type TOk } from './try_result.mjs';
+export declare function TryArray(value: unknown): TOk<unknown[]>;

package/build/value/convert/try/try_array.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Ok } from './try_result.mjs';
+export function TryArray(value) {
+    return Guard.IsArray(value) ? Ok(value) : Ok([value]);
+}

package/build/value/convert/try/{try-bigint.d.mts → try_bigint.d.mts}

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try_result.mjs';
 export declare function TryBigInt(value: unknown): TResult<bigint>;

package/build/value/convert/try/{try-bigint.mjs → try_bigint.mjs}

@@ -1,15 +1,6 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Ok, Fail } from './try-result.mjs';
-// ------------------------------------------------------------------
-// BigInt
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-function FromBigInt(value) {
-    return Ok(value);
-}
-// deno-coverage-ignore-stop
+import { Ok, Fail } from './try_result.mjs';
 // ------------------------------------------------------------------
 // Boolean
 // ------------------------------------------------------------------
@@ -17,18 +8,6 @@ function FromBoolean(value) {
     return Guard.IsEqual(value, true) ? Ok(BigInt(1)) : Ok(BigInt(0));
 }
 // ------------------------------------------------------------------
-// Number
-// ------------------------------------------------------------------
-function FromNumber(value) {
-    return Ok(BigInt(Math.trunc(value)));
-}
-// ------------------------------------------------------------------
-// Null
-// ------------------------------------------------------------------
-function FromNull(value) {
-    return Ok(BigInt(0));
-}
-// ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
 const bigintPattern = /^-?(0|[1-9]\d*)n$/;
@@ -53,22 +32,14 @@ function FromString(value) {
                         Fail());
 }
 // ------------------------------------------------------------------
-// Undefined
-// ------------------------------------------------------------------
-function FromUndefined(value) {
-    return Ok(BigInt(0));
-}
-// ------------------------------------------------------------------
 // Try
 // ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
 export function TryBigInt(value) {
-    return (Guard.IsBigInt(value) ? FromBigInt(value) :
+    return (Guard.IsBigInt(value) ? Ok(value) :
         Guard.IsBoolean(value) ? FromBoolean(value) :
-            Guard.IsNumber(value) ? FromNumber(value) :
-                Guard.IsNull(value) ? FromNull(value) :
+            Guard.IsNumber(value) ? Ok(BigInt(Math.trunc(value))) :
+                Guard.IsNull(value) ? Ok(BigInt(0)) :
                     Guard.IsString(value) ? FromString(value) :
-                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                        Guard.IsUndefined(value) ? Ok(BigInt(0)) :
                             Fail());
 }
-// deno-coverage-ignore-stop

package/build/value/convert/try/{try-boolean.d.mts → try_boolean.d.mts}

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try_result.mjs';
 export declare function TryBoolean(value: unknown): TResult<boolean>;

package/build/value/convert/try/{try-boolean.mjs → try_boolean.mjs}

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Ok, Fail } from './try-result.mjs';
+import { Ok, Fail } from './try_result.mjs';
 // ------------------------------------------------------------------
 // BigInt
 // ------------------------------------------------------------------
@@ -11,14 +10,6 @@ function FromBigInt(value) {
             Fail());
 }
 // ------------------------------------------------------------------
-// Boolean
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-function FromBoolean(value) {
-    return Ok(value);
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
 // Number
 // ------------------------------------------------------------------
 function FromNumber(value) {
@@ -27,12 +18,6 @@ function FromNumber(value) {
             Fail());
 }
 // ------------------------------------------------------------------
-// Null
-// ------------------------------------------------------------------
-function FromNull(value) {
-    return Ok(false);
-}
-// ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
 function FromString(value) {
@@ -43,22 +28,14 @@ function FromString(value) {
                     Fail());
 }
 // ------------------------------------------------------------------
-// Undefined
-// ------------------------------------------------------------------
-function FromUndefined(value) {
-    return Ok(false);
-}
-// ------------------------------------------------------------------
 // Try
 // ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
 export function TryBoolean(value) {
     return (Guard.IsBigInt(value) ? FromBigInt(value) :
-        Guard.IsBoolean(value) ? FromBoolean(value) :
+        Guard.IsBoolean(value) ? Ok(value) :
             Guard.IsNumber(value) ? FromNumber(value) :
-                Guard.IsNull(value) ? FromNull(value) :
+                Guard.IsNull(value) ? Ok(false) :
                     Guard.IsString(value) ? FromString(value) :
-                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                        Guard.IsUndefined(value) ? Ok(false) :
                             Fail());
 }
-// deno-coverage-ignore-stop

package/build/value/convert/try/{try-null.d.mts → try_null.d.mts}

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try_result.mjs';
 export declare function TryNull(value: unknown): TResult<null>;

package/build/value/convert/try/{try-null.mjs → try_null.mjs}

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Ok, Fail } from './try-result.mjs';
+import { Ok, Fail } from './try_result.mjs';
 // ------------------------------------------------------------------
 // BigInt
 // ------------------------------------------------------------------
@@ -21,14 +20,6 @@ function FromNumber(value) {
     return Guard.IsEqual(value, 0) ? Ok(null) : Fail();
 }
 // ------------------------------------------------------------------
-// Null
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-function FromNull(value) {
-    return Ok(null);
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
 function FromString(value) {
@@ -40,22 +31,14 @@ function FromString(value) {
     return predicate ? Ok(null) : Fail();
 }
 // ------------------------------------------------------------------
-// Undefined
-// ------------------------------------------------------------------
-function FromUndefined(value) {
-    return Ok(null);
-}
-// ------------------------------------------------------------------
 // Try
 // ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
 export function TryNull(value) {
     return (Guard.IsBigInt(value) ? FromBigInt(value) :
         Guard.IsBoolean(value) ? FromBoolean(value) :
             Guard.IsNumber(value) ? FromNumber(value) :
-                Guard.IsNull(value) ? FromNull(value) :
+                Guard.IsNull(value) ? Ok(null) :
                     Guard.IsString(value) ? FromString(value) :
-                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                        Guard.IsUndefined(value) ? Ok(null) :
                             Fail());
 }
-// deno-coverage-ignore-stop

package/build/value/convert/try/{try-number.d.mts → try_number.d.mts}

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try_result.mjs';
 export declare function TryNumber(value: unknown): TResult<number>;

package/build/value/convert/try/try_number.mjs

@@ -0,0 +1,44 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Ok, Fail, IsOk } from './try_result.mjs';
+import { TryBigInt } from './try_bigint.mjs';
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+const maxBigInt = BigInt(Number.MAX_SAFE_INTEGER);
+const minBigInt = BigInt(Number.MIN_SAFE_INTEGER);
+function FromBigInt(value) {
+    return (value <= maxBigInt && value >= minBigInt) ? Ok(Number(value)) : Fail();
+}
+function FromBoolean(value) {
+    return Ok(value ? 1 : 0);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+function FromString(value) {
+    const coerced = +value;
+    if (Guard.IsNumber(coerced))
+        return Ok(coerced);
+    const lowercase = value.toLowerCase();
+    if (Guard.IsEqual(lowercase, 'false'))
+        return Ok(0);
+    if (Guard.IsEqual(lowercase, 'true'))
+        return Ok(1);
+    const result = TryBigInt(value);
+    if (IsOk(result))
+        return (result.value <= maxBigInt && result.value >= minBigInt) ? Ok(Number(result.value)) : Fail();
+    return Fail();
+}
+// ------------------------------------------------------------------
+// Try
+// ------------------------------------------------------------------
+export function TryNumber(value) {
+    return (Guard.IsBigInt(value) ? FromBigInt(value) :
+        Guard.IsBoolean(value) ? FromBoolean(value) :
+            Guard.IsNumber(value) ? Ok(value) :
+                Guard.IsNull(value) ? Ok(0) :
+                    Guard.IsString(value) ? FromString(value) :
+                        Guard.IsUndefined(value) ? Ok(0) :
+                            Fail());
+}

package/build/value/convert/try/{try-result.mjs → try_result.mjs}

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Guard

package/build/value/convert/try/{try-string.d.mts → try_string.d.mts}

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try_result.mjs';
 export declare function TryString(value: unknown): TResult;

package/build/value/convert/try/try_string.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Ok, Fail } from './try_result.mjs';
+export function TryString(value) {
+    return (Guard.IsBigInt(value) ? Ok(value.toString()) :
+        Guard.IsBoolean(value) ? Ok(value.toString()) :
+            Guard.IsNumber(value) ? Ok(value.toString()) :
+                Guard.IsNull(value) ? Ok('null') :
+                    Guard.IsString(value) ? Ok(value) :
+                        Guard.IsUndefined(value) ? Ok('') :
+                            Fail());
+}

package/build/value/convert/try/{try-undefined.d.mts → try_undefined.d.mts}

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try_result.mjs';
 export declare function TryUndefined(value: unknown): TResult<undefined>;

package/build/value/convert/try/{try-undefined.mjs → try_undefined.mjs}

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Ok, Fail } from './try-result.mjs';
+import { Ok, Fail } from './try_result.mjs';
 // ------------------------------------------------------------------
 // BigInt
 // ------------------------------------------------------------------
@@ -21,12 +20,6 @@ function FromNumber(value) {
     return Guard.IsEqual(value, 0) ? Ok(undefined) : Fail();
 }
 // ------------------------------------------------------------------
-// Null
-// ------------------------------------------------------------------
-function FromNull(value) {
-    return Ok(undefined);
-}
-// ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
 function FromString(value) {
@@ -38,24 +31,14 @@ function FromString(value) {
     return predicate ? Ok(undefined) : Fail();
 }
 // ------------------------------------------------------------------
-// Undefined
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-function FromUndefined(value) {
-    return Ok(undefined);
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
 // Try
 // ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
 export function TryUndefined(value) {
     return (Guard.IsBigInt(value) ? FromBigInt(value) :
         Guard.IsBoolean(value) ? FromBoolean(value) :
             Guard.IsNumber(value) ? FromNumber(value) :
-                Guard.IsNull(value) ? FromNull(value) :
+                Guard.IsNull(value) ? Ok(undefined) :
                     Guard.IsString(value) ? FromString(value) :
-                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                        Guard.IsUndefined(value) ? Ok(value) :
                             Fail());
 }
-// deno-coverage-ignore-stop

package/build/value/create/create.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';
 /** Creates a value from the provided type. This function will use `default` annotations if present. */
 export function Create(...args) {
     const [context, type] = Arguments.Match(args, {

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsUniqueItems, IsDefault, IsMinItems } from '../../schema/types/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { CreateError } from './error.mjs';
 export function FromArray(context, type) {
     if (IsUniqueItems(type) && !IsDefault(type))

package/build/value/create/{from-constructor.mjs → from_constructor.mjs}

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromConstructor(context, type) {
     const instanceType = FromType(context, type.instanceType);
     return class {

package/build/value/create/{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) {
     return FromType({ ...context, ...type.$defs }, Ref(type.$ref));
 }

package/build/value/create/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) {
+    return FromType(context, Evaluate(type));
+}

package/build/value/create/{from-function.mjs → from_function.mjs}

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromFunction(context, type) {
     const returnType = FromType(context, type.returnType);
     return () => returnType;

package/build/value/create/{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) {
     const instantiated = Instantiate(context, type);
     const evaluated = Evaluate(instantiated);

package/build/value/create/{from-object.mjs → from_object.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 FromObject(context, type) {
     const required = Guard.IsUndefined(type.required) ? [] : type.required;
     return required.reduce((result, key) => {

package/build/value/create/{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 { CreateError } from './error.mjs';
 export function FromRef(context, type) {
     return Guard.HasPropertyKey(context, type.$ref)

package/build/value/create/{from-template-literal.mjs → from_template_literal.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { IsString } from '../../type/index.mjs';
-import { TemplateLiteralDecode } from '../../type/engine/template-literal/index.mjs';
-import { FromType } from './from-type.mjs';
+import { TemplateLiteralDecode } from '../../type/engine/template_literal/index.mjs';
+import { FromType } from './from_type.mjs';
 import { CreateError } from './error.mjs';
 export function FromTemplateLiteral(context, type) {
     const decoded = TemplateLiteralDecode(type.pattern);

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

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromTuple(context, type) {
     return Array.from({ length: type.minItems }, (_, i) => FromType(context, type.items[i]));
 }