typebox 0.0.1 → 1.0.0

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

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

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

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

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

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

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

@@ -0,0 +1,9 @@
+// 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.d.mts

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

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

@@ -0,0 +1,9 @@
+// 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.d.mts

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

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

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Ref } from '../../type/index.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.d.mts

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

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

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { EnumToUnion } from '../../type/engine/enum/index.mjs';
+import { FromUnion } from './from-union.mjs';
+export function FromEnum(context, type, value) {
+    const union = EnumToUnion(type);
+    return FromUnion(context, union, value);
+}

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

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

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

@@ -0,0 +1,9 @@
+// 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.d.mts

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

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

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Evaluate } from '../../type/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromIntersect(context, type, value) {
+    const evaluatedType = Evaluate(type);
+    return FromType(context, evaluatedType, value);
+}

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

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

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

@@ -0,0 +1,44 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsLiteralBigInt, IsLiteralBoolean, IsLiteralNumber, IsLiteralString } from '../../type/index.mjs';
+import { Try } from './try/index.mjs';
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+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) {
+    const result = Try.TryBoolean(value);
+    return Try.IsOk(result) && Guard.IsEqual(type.const, result.value) ? result.value : value;
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+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) {
+    const result = Try.TryString(value);
+    return Try.IsOk(result) && Guard.IsEqual(type.const, result.value) ? result.value : value;
+}
+// deno-coverage-ignore-start - unreachable | guarded
+export function FromLiteral(context, type, value) {
+    if (Guard.IsEqual(type.const, value))
+        return value;
+    return (IsLiteralBigInt(type) ? FromLiteralBigInt(context, type, value) :
+        IsLiteralBoolean(type) ? FromLiteralBoolean(context, type, value) :
+            IsLiteralNumber(type) ? FromLiteralNumber(context, type, value) :
+                IsLiteralString(type) ? FromLiteralString(context, type, value) :
+                    Unreachable());
+}
+// deno-coverage-ignore-stop

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

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

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

@@ -0,0 +1,9 @@
+// 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.d.mts

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

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

@@ -0,0 +1,9 @@
+// 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;
+}

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

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

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

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+import { FromAdditionalProperties } from './from-additional.mjs';
+function FromProperties(context, type, value) {
+    const entries = Guard.EntriesRegExp(type.properties);
+    const keys = Guard.Keys(value);
+    for (const [regexp, schema] of entries) {
+        for (const key of keys) {
+            if (regexp.test(key)) {
+                value[key] = FromType(context, schema, value[key]);
+            }
+        }
+    }
+    return (Guard.HasPropertyKey(type, 'additionalProperties') && Guard.IsObject(type.additionalProperties)
+        ? FromAdditionalProperties(context, entries, type.additionalProperties, value)
+        : value);
+}
+export function FromObject(context, type, value) {
+    return Guard.IsObjectNotArray(value)
+        ? FromProperties(context, type, value)
+        : value;
+}

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

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

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

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.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);
+    for (const [regexp, schema] of entries) {
+        for (const key of keys) {
+            if (regexp.test(key)) {
+                value[key] = FromType(context, schema, value[key]);
+            }
+        }
+    }
+    return (Guard.HasPropertyKey(type, 'additionalProperties') && Guard.IsObject(type.additionalProperties)
+        ? FromAdditionalProperties(context, entries, type.additionalProperties, value)
+        : value);
+}
+export function FromRecord(context, type, value) {
+    return Guard.IsObjectNotArray(value)
+        ? FromPatternProperties(context, type, value)
+        : value;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,9 @@
+// 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

@@ -0,0 +1,2 @@
+import type { TTemplateLiteral, 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,7 @@
+// deno-fmt-ignore-file
+import { TemplateLiteralDecode } from '../../type/engine/template-literal/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromTemplateLiteral(context, type, value) {
+    const decoded = TemplateLiteralDecode(type.pattern);
+    return FromType(context, decoded, value);
+}

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

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

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

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromTuple(context, type, value) {
+    if (!Guard.IsArray(value))
+        return value;
+    for (let index = 0; index < Math.min(type.items.length, value.length); index++) {
+        value[index] = FromType(context, type.items[index], value[index]);
+    }
+    return value;
+}

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

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

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

@@ -0,0 +1,45 @@
+// deno-fmt-ignore-file
+import * as T from '../../type/index.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromBase } from './from-base.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 (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) :
+                                                                                    value);
+}

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

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

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

@@ -0,0 +1,9 @@
+// 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.d.mts

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

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

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Clone } from '../clone/index.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)
+        return value;
+    const candidates = type.anyOf.map(type => FromType(context, type, Clone(value)));
+    const selected = candidates.find(value => Check(context, type, value));
+    return Guard.IsUndefined(selected) ? value : selected;
+}

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

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

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

@@ -0,0 +1,9 @@
+// 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/index.d.mts

@@ -0,0 +1 @@
+export * from './convert.mjs';

package/build/value/convert/index.mjs

@@ -0,0 +1 @@
+export * from './convert.mjs';

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

@@ -0,0 +1 @@
+export * as Try from './try.mjs';

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

@@ -0,0 +1 @@
+export * as Try from './try.mjs';

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

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

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

@@ -0,0 +1,74 @@
+// 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$/;
+const decimalPattern = /^-?(0|[1-9]\d*)\.\d+$/;
+const integerPattern = /^-?(0|[1-9]\d*)$/;
+function IsStringBigIntLike(value) {
+    return bigintPattern.test(value);
+}
+function IsStringDecimalLike(value) {
+    return decimalPattern.test(value);
+}
+function IsStringIntegerLike(value) {
+    return integerPattern.test(value);
+}
+function FromString(value) {
+    const lowercase = value.toLowerCase();
+    return (IsStringBigIntLike(value) ? Ok(BigInt(value.slice(0, value.length - 1))) :
+        IsStringDecimalLike(value) ? Ok(BigInt(value.split('.')[0])) :
+            IsStringIntegerLike(value) ? Ok(BigInt(value)) :
+                Guard.IsEqual(lowercase, 'false') ? Ok(BigInt(0)) :
+                    Guard.IsEqual(lowercase, 'true') ? Ok(BigInt(1)) :
+                        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) :
+        Guard.IsBoolean(value) ? FromBoolean(value) :
+            Guard.IsNumber(value) ? FromNumber(value) :
+                Guard.IsNull(value) ? FromNull(value) :
+                    Guard.IsString(value) ? FromString(value) :
+                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                            Fail());
+}
+// deno-coverage-ignore-stop

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

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

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

@@ -0,0 +1,64 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Ok, Fail } from './try-result.mjs';
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    return (Guard.IsEqual(value, BigInt(0)) ? Ok(false) :
+        Guard.IsEqual(value, BigInt(1)) ? Ok(true) :
+            Fail());
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function FromBoolean(value) {
+    return Ok(value);
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    return (Guard.IsEqual(value, 0) ? Ok(false) :
+        Guard.IsEqual(value, 1) ? Ok(true) :
+            Fail());
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(value) {
+    return Ok(false);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+function FromString(value) {
+    return (Guard.IsEqual(value.toLowerCase(), 'false') ? Ok(false) :
+        Guard.IsEqual(value.toLowerCase(), 'true') ? Ok(true) :
+            Guard.IsEqual(value, '0') ? Ok(false) :
+                Guard.IsEqual(value, '1') ? Ok(true) :
+                    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.IsNumber(value) ? FromNumber(value) :
+                Guard.IsNull(value) ? FromNull(value) :
+                    Guard.IsString(value) ? FromString(value) :
+                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                            Fail());
+}
+// deno-coverage-ignore-stop

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

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

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

@@ -0,0 +1,61 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Ok, Fail } from './try-result.mjs';
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    return Guard.IsEqual(value, BigInt(0)) ? Ok(null) : Fail();
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    return Guard.IsEqual(value, false) ? Ok(null) : Fail();
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+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) {
+    const lowercase = value.toLowerCase();
+    const predicate = Guard.IsEqual(lowercase, 'undefined')
+        || Guard.IsEqual(lowercase, 'null')
+        || Guard.IsEqual(value, '')
+        || Guard.IsEqual(value, '0');
+    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.IsString(value) ? FromString(value) :
+                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                            Fail());
+}
+// deno-coverage-ignore-stop

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

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