typebox 1.1.20 → 1.1.22

package/build/type/engine/mapped/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';

package/build/type/engine/module/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Memory } from '../../../system/memory/index.mjs';

package/build/type/engine/non-nullable/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Null } from '../../types/null.mjs';

package/build/type/engine/object/from-intersect.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Guard } from '../../../guard/index.mjs';

package/build/type/engine/object/from-type.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';

package/build/type/engine/parameters/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsFunction } from '../../types/function.mjs';

package/build/type/engine/partial/from-type.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';

package/build/type/engine/pick/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Guard } from '../../../guard/index.mjs';

package/build/type/engine/record/from-key-integer.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TInteger } from '../../types/integer.mjs';
 import { type TRecord, IntegerKey } from '../../types/record.mjs';
-export type TFromIntegerKey<Key extends TInteger, Value extends TSchema, Result extends TSchema = TRecord<typeof IntegerKey, Value>> = Result;
-export declare function FromIntegerKey<Key extends TInteger, Value extends TSchema>(key: Key, value: Value): TFromIntegerKey<Key, Value>;
+export type TFromIntegerKey<_Key extends TInteger, Value extends TSchema, Result extends TSchema = TRecord<typeof IntegerKey, Value>> = Result;
+export declare function FromIntegerKey<Key extends TInteger, Value extends TSchema>(_key: Key, value: Value): TFromIntegerKey<Key, Value>;

package/build/type/engine/record/from-key-integer.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { IntegerKey } from '../../types/record.mjs';
 import { CreateRecord } from './record-create.mjs';
-export function FromIntegerKey(key, value) {
+export function FromIntegerKey(_key, value) {
     const result = CreateRecord(IntegerKey, value);
     return result;
 }

package/build/type/engine/record/from-key-number.d.mts

@@ -2,4 +2,4 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TNumber } from '../../types/number.mjs';
 import { type TRecord, NumberKey } from '../../types/record.mjs';
 export type TFromNumberKey<Key extends TNumber, Value extends TSchema, Result extends TSchema = TRecord<typeof NumberKey, Value>> = Result;
-export declare function FromNumberKey<Key extends TNumber, Value extends TSchema>(key: Key, value: Value): TFromNumberKey<Key, Value>;
+export declare function FromNumberKey<Key extends TNumber, Value extends TSchema>(_key: Key, value: Value): TFromNumberKey<Key, Value>;

package/build/type/engine/record/from-key-number.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { NumberKey } from '../../types/record.mjs';
 import { CreateRecord } from './record-create.mjs';
-export function FromNumberKey(key, value) {
+export function FromNumberKey(_key, value) {
     const result = CreateRecord(NumberKey, value);
     return result;
 }

package/build/type/engine/required/from-type.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';

package/build/type/engine/template-literal/encode.mjs

@@ -39,7 +39,7 @@ function EncodeString(right, pattern) {
 function EncodeTemplateLiteral(templatePattern, right, pattern) {
     return EncodeTypes(right, `${pattern}${UnwrapTemplateLiteralPattern(templatePattern)}`);
 }
-function EncodeEnum(types, right, pattern, result = []) {
+function EncodeEnum(types, right, pattern) {
     const variants = EnumValuesToVariants(types);
     return EncodeUnion(variants, right, pattern);
 }

package/build/type/engine/template-literal/is-finite.mjs

@@ -3,7 +3,7 @@ import { Guard } from '../../../guard/index.mjs';
 import { IsSchema } from '../../types/schema.mjs';
 import { IsLiteral } from '../../types/literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
-function FromLiteral(value) {
+function FromLiteral(_value) {
     return true;
 }
 function FromTypesReduce(types) {

package/build/type/engine/tuple/to-object.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Object } from '../../types/object.mjs';
 export function TupleElementsToProperties(types) {

package/build/type/extends/extends-right.d.mts

@@ -15,7 +15,7 @@ import { type TEnumValuesToUnion } from '../engine/enum/index.mjs';
 type TExtendsRightInfer<Inferred extends TProperties, Name extends string, Left extends TSchema, Right extends TSchema, Result extends Result.TResult = (TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer CheckInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Memory.TAssign<Inferred, CheckInferred>, {
     [_ in Name]: Left;
 }>> : Result.TExtendsFalse)> = Result;
-type TExtendsRightAny<Inferred extends TProperties, Left extends TSchema, Result extends Result.TResult = Result.TExtendsTrue<Inferred>> = Result;
+type TExtendsRightAny<Inferred extends TProperties, _Left extends TSchema, Result extends Result.TResult = Result.TExtendsTrue<Inferred>> = Result;
 type TExtendsRightEnum<Inferred extends TProperties, Left extends TSchema, Right extends TEnumValue[], Union extends TSchema = TEnumValuesToUnion<Right>> = TExtendsLeft<Inferred, Left, Union>;
 type TExtendsRightIntersect<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsRightIntersect<Inferred, Left, Tail> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
 type TExtendsRightTemplateLiteral<Inferred extends TProperties, Left extends TSchema, Right extends string, Decoded extends TSchema = TTemplateLiteralDecode<Right>> = TExtendsLeft<Inferred, Left, Decoded>;

package/build/type/extends/extends-right.mjs

@@ -14,7 +14,7 @@ import { EnumValuesToUnion } from '../engine/enum/index.mjs';
 function ExtendsRightInfer(inferred, name, left, right) {
     return Result.Match(ExtendsLeft(inferred, left, right), checkInferred => Result.ExtendsTrue(Memory.Assign(Memory.Assign(inferred, checkInferred), { [name]: left })), () => Result.ExtendsFalse());
 }
-function ExtendsRightAny(inferred, left) {
+function ExtendsRightAny(inferred, _left) {
     return Result.ExtendsTrue(inferred);
 }
 function ExtendsRightEnum(inferred, left, right) {

package/build/type/extends/inference.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';

package/build/type/extends/object.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';

package/build/type/types/_codec.d.mts

@@ -13,7 +13,7 @@ export type TCodec<Type extends TSchema = TSchema, Decoded extends unknown = unk
 export declare class EncodeBuilder<Type extends TSchema, Decoded extends unknown> {
     private readonly type;
     private readonly decode;
-    constructor(type: Type, decode: Function);
+    constructor(type: Type, decode: globalThis.Function);
     Encode<Callback extends TEncodeCallback<Type, Decoded>>(callback: Callback): TCodec<Type, Decoded>;
 }
 export declare class DecodeBuilder<Type extends TSchema> {

package/build/type/types/_codec.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../system/index.mjs';
 import { Guard } from '../../guard/index.mjs';

package/build/type/types/base.d.mts

@@ -32,9 +32,9 @@ export declare class Base<Value extends unknown = unknown> implements TSchema, X
     readonly '~guard': XGuardInterface<Value>;
     constructor();
     /** Checks a value or returns false if invalid */
-    Check(value: unknown): value is Value;
+    Check(_value: unknown): _value is Value;
     /** Returns errors for a value. Return an empty array if valid.  */
-    Errors(value: unknown): object[];
+    Errors(_value: unknown): object[];
     /** Converts a value into this type */
     Convert(value: unknown): unknown;
     /** Cleans a value according to this type */

package/build/type/types/base.mjs

@@ -47,11 +47,11 @@ export class Base {
         }));
     }
     /** Checks a value or returns false if invalid */
-    Check(value) {
+    Check(_value) {
         return true;
     }
     /** Returns errors for a value. Return an empty array if valid.  */
-    Errors(value) {
+    Errors(_value) {
         return [];
     }
     /** Converts a value into this type */

package/build/type/types/call.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { IsKind } from './schema.mjs';

package/build/type/types/never.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { IsKind } from './schema.mjs';

package/build/type/types/properties.mjs

@@ -1,4 +1,3 @@
-// deno-lint-ignore-file no-array-constructor
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { IsOptional } from './_optional.mjs';

package/build/type/types/record.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';

package/build/type/types/ref.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file no-explicit-any
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { IsKind } from './schema.mjs';

package/build/value/clean/from-base.d.mts

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

package/build/value/clean/from-base.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromBase(context, type, value) {
+export function FromBase(_context, type, value) {
     return type.Clean(value);
 }

package/build/value/codec/callback.mjs

@@ -4,13 +4,13 @@ import { IsCodec } from '../../type/index.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
-function Decode(context, type, value) {
+function Decode(_context, type, value) {
     return type['~codec'].decode(value);
 }
 // ------------------------------------------------------------------
 // Encode
 // ------------------------------------------------------------------
-function Encode(context, type, value) {
+function Encode(_context, type, value) {
     return type['~codec'].encode(value);
 }
 // ------------------------------------------------------------------

package/build/value/codec/from-union.mjs

@@ -21,7 +21,7 @@ function Decode(direction, context, type, value) {
 // Encode
 // ------------------------------------------------------------------
 function Encode(direction, context, type, value) {
-    let exterior = Callback(direction, context, type, value);
+    const exterior = Callback(direction, context, type, value);
     for (const schema of UnionPrioritySort(type.anyOf, -1)) {
         const variant = FromType(direction, context, schema, Clone(exterior));
         if (!Check(context, schema, variant))

package/build/value/convert/from-array.mjs

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

package/build/value/convert/from-base.d.mts

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

package/build/value/convert/from-base.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromBase(context, type, value) {
+export function FromBase(_context, type, value) {
     return type.Convert(value);
 }

package/build/value/convert/from-bigint.d.mts

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

package/build/value/convert/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;
+export function FromBigInt(_context, _type, value) {
     const result = Try.TryBigInt(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/from-boolean.d.mts

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

package/build/value/convert/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;
+export function FromBoolean(_context, _type, value) {
     const result = Try.TryBoolean(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/from-integer.d.mts

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

package/build/value/convert/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;
+export function FromInteger(_context, _type, value) {
     const result = Try.TryNumber(value);
     return Try.IsOk(result) ? Math.trunc(result.value) : value;
 }

package/build/value/convert/from-literal.mjs

@@ -6,28 +6,28 @@ import { Try } from './try/index.mjs';
 // ------------------------------------------------------------------
 // BigInt
 // ------------------------------------------------------------------
-function FromLiteralBigInt(context, type, value) {
+function FromLiteralBigInt(_context, type, value) {
     const result = Try.TryBigInt(value);
     return Try.IsOk(result) && Guard.IsEqual(type.const, result.value) ? result.value : value;
 }
 // ------------------------------------------------------------------
 // Boolean
 // ------------------------------------------------------------------
-function FromLiteralBoolean(context, type, value) {
+function FromLiteralBoolean(_context, type, value) {
     const result = Try.TryBoolean(value);
     return Try.IsOk(result) && Guard.IsEqual(type.const, result.value) ? result.value : value;
 }
 // ------------------------------------------------------------------
 // Number
 // ------------------------------------------------------------------
-function FromLiteralNumber(context, type, value) {
+function FromLiteralNumber(_context, type, value) {
     const result = Try.TryNumber(value);
     return Try.IsOk(result) && Guard.IsEqual(type.const, result.value) ? result.value : value;
 }
 // ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
-function FromLiteralString(context, type, value) {
+function FromLiteralString(_context, type, value) {
     const result = Try.TryString(value);
     return Try.IsOk(result) && Guard.IsEqual(type.const, result.value) ? result.value : value;
 }

package/build/value/convert/from-null.d.mts

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

package/build/value/convert/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;
+export function FromNull(_context, _type, value) {
     const result = Try.TryNull(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/from-number.d.mts

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

package/build/value/convert/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;
+export function FromNumber(_context, _type, value) {
     const result = Try.TryNumber(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/from-string.d.mts

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

package/build/value/convert/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;
+export function FromString(_context, _type, value) {
     const result = Try.TryString(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/from-type.d.mts

@@ -1,2 +1,2 @@
-import * as T from '../../type/index.mjs';
-export declare function FromType(context: T.TProperties, type: T.TSchema, value: unknown): unknown;
+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

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import * as T from '../../type/index.mjs';
+import * as Type from '../../type/index.mjs';
 import { FromArray } from './from-array.mjs';
 import { FromBase } from './from-base.mjs';
 import { FromBigInt } from './from-bigint.mjs';
@@ -21,25 +21,25 @@ 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 (T.IsArray(type) ? FromArray(context, type, value) :
-        T.IsBase(type) ? FromBase(context, type, value) :
-            T.IsBigInt(type) ? FromBigInt(context, type, value) :
-                T.IsBoolean(type) ? FromBoolean(context, type, value) :
-                    T.IsCyclic(type) ? FromCyclic(context, type, value) :
-                        T.IsEnum(type) ? FromEnum(context, type, value) :
-                            T.IsInteger(type) ? FromInteger(context, type, value) :
-                                T.IsIntersect(type) ? FromIntersect(context, type, value) :
-                                    T.IsLiteral(type) ? FromLiteral(context, type, value) :
-                                        T.IsNull(type) ? FromNull(context, type, value) :
-                                            T.IsNumber(type) ? FromNumber(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.IsString(type) ? FromString(context, type, value) :
-                                                                T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
-                                                                    T.IsTuple(type) ? FromTuple(context, type, value) :
-                                                                        T.IsUndefined(type) ? FromUndefined(context, type, value) :
-                                                                            T.IsUnion(type) ? FromUnion(context, type, value) :
-                                                                                T.IsVoid(type) ? FromVoid(context, type, value) :
+    return (Type.IsArray(type) ? FromArray(context, type, value) :
+        Type.IsBase(type) ? FromBase(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.d.mts

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

package/build/value/convert/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;
+export function FromUndefined(_context, _type, value) {
     const result = Try.TryUndefined(value);
     return Try.IsOk(result) ? result.value : value;
 }

package/build/value/convert/from-void.d.mts

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

package/build/value/convert/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;
+export function FromVoid(_context, _type, value) {
     const result = Try.TryUndefined(value);
     return Try.IsOk(result) ? (void 0) : value;
 }

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.mjs

@@ -1,34 +1,13 @@
 // 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
-// ------------------------------------------------------------------
 // Boolean
 // ------------------------------------------------------------------
 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