typebox 1.1.20 → 1.1.22

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

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Ok, Fail } from './try-result.mjs';
 // ------------------------------------------------------------------
@@ -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.mjs

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Ok, Fail } from './try-result.mjs';
 // ------------------------------------------------------------------
@@ -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.mjs

@@ -1,41 +1,17 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Ok, Fail, IsOk } from './try-result.mjs';
-// ------------------------------------------------------------------
-// Two-Phase
-// ------------------------------------------------------------------
 import { TryBigInt } from './try-bigint.mjs';
 // ------------------------------------------------------------------
 // BigInt
 // ------------------------------------------------------------------
 const maxBigInt = BigInt(Number.MAX_SAFE_INTEGER);
 const minBigInt = BigInt(Number.MIN_SAFE_INTEGER);
-function CanBigIntDowncast(value) {
-    return (value <= maxBigInt && value >= minBigInt);
-}
 function FromBigInt(value) {
-    return CanBigIntDowncast(value) ? Ok(Number(value)) : Fail();
+    return (value <= maxBigInt && value >= minBigInt) ? Ok(Number(value)) : Fail();
 }
-// ------------------------------------------------------------------
-// Boolean
-// ------------------------------------------------------------------
 function FromBoolean(value) {
-    return value ? Ok(1) : Ok(0);
-}
-// ------------------------------------------------------------------
-// Number
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-function FromNumber(value) {
-    return Ok(value);
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
-// Null
-// ------------------------------------------------------------------
-function FromNull(value) {
-    return Ok(0);
+    return Ok(value ? 1 : 0);
 }
 // ------------------------------------------------------------------
 // String
@@ -51,26 +27,18 @@ function FromString(value) {
         return Ok(1);
     const result = TryBigInt(value);
     if (IsOk(result))
-        return FromBigInt(result.value);
+        return (result.value <= maxBigInt && result.value >= minBigInt) ? Ok(Number(result.value)) : Fail();
     return Fail();
 }
 // ------------------------------------------------------------------
-// Undefined
-// ------------------------------------------------------------------
-function FromUndefined(value) {
-    return Ok(0);
-}
-// ------------------------------------------------------------------
 // Try
 // ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
 export function TryNumber(value) {
     return (Guard.IsBigInt(value) ? FromBigInt(value) :
         Guard.IsBoolean(value) ? FromBoolean(value) :
-            Guard.IsNumber(value) ? FromNumber(value) :
-                Guard.IsNull(value) ? FromNull(value) :
+            Guard.IsNumber(value) ? Ok(value) :
+                Guard.IsNull(value) ? Ok(0) :
                     Guard.IsString(value) ? FromString(value) :
-                        Guard.IsUndefined(value) ? FromUndefined(value) :
+                        Guard.IsUndefined(value) ? Ok(0) :
                             Fail());
 }
-// deno-coverage-ignore-stop

package/build/value/convert/try/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.mjs

@@ -1,56 +1,12 @@
 // 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 Ok(value.toString());
-}
-// ------------------------------------------------------------------
-// Boolean
-// ------------------------------------------------------------------
-function FromBoolean(value) {
-    return Ok(value.toString());
-}
-// ------------------------------------------------------------------
-// Number
-// ------------------------------------------------------------------
-function FromNumber(value) {
-    return Ok(value.toString());
-}
-// ------------------------------------------------------------------
-// Null
-// ------------------------------------------------------------------
-function FromNull(value) {
-    return Ok('null');
-}
-// ------------------------------------------------------------------
-// String
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-function FromString(value) {
-    return Ok(value);
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
-// Undefined
-// ------------------------------------------------------------------
-function FromUndefined(value) {
-    return Ok('');
-}
-// ------------------------------------------------------------------
-// Try
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
 export function TryString(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) :
+    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());
 }
-// deno-coverage-ignore-stop

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

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Ok, Fail } from './try-result.mjs';
 // ------------------------------------------------------------------
@@ -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/convert/try/try.d.mts

@@ -1,3 +1,4 @@
+export * from './try-array.mjs';
 export * from './try-bigint.mjs';
 export * from './try-boolean.mjs';
 export * from './try-null.mjs';

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

@@ -1,3 +1,4 @@
+export * from './try-array.mjs';
 export * from './try-bigint.mjs';
 export * from './try-boolean.mjs';
 export * from './try-null.mjs';

package/build/value/create/from-async-iterator.d.mts

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

package/build/value/create/from-async-iterator.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
 async function* CreateAsyncIterator() { }
-export function FromAsyncIterator(context, type) {
+export function FromAsyncIterator(_context, _type) {
     return CreateAsyncIterator();
 }

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsExclusiveMinimum, IsMinimum } from '../../schema/types/index.mjs';
-export function FromBigInt(context, type) {
+export function FromBigInt(_context, type) {
     return (IsExclusiveMinimum(type) ? BigInt(type.exclusiveMinimum) + BigInt(1) :
         IsMinimum(type) ? BigInt(type.minimum) :
             BigInt(0));

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

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

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

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromBoolean(context, type) {
+export function FromBoolean(_context, _type) {
     return false;
 }

package/build/value/create/from-default.d.mts

@@ -1,3 +1,3 @@
 import { type TProperties } from '../../type/index.mjs';
 import { type XDefault } from '../../schema/types/index.mjs';
-export declare function FromDefault(context: TProperties, schema: XDefault): unknown;
+export declare function FromDefault(_context: TProperties, schema: XDefault): unknown;

package/build/value/create/from-default.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Clone } from '../clone/index.mjs';
-export function FromDefault(context, schema) {
+export function FromDefault(_context, schema) {
     return Guard.IsFunction(schema.default)
         ? schema.default(schema)
         : Guard.IsObject(schema.default)

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

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

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

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { IsExclusiveMinimum, IsMinimum } from '../../schema/types/index.mjs';
-export function FromInteger(context, type) {
+export function FromInteger(_context, type) {
     return ((IsExclusiveMinimum(type) && Guard.IsNumber(type.exclusiveMinimum)) ? type.exclusiveMinimum + 1 :
         IsMinimum(type) ? type.minimum :
             0);

package/build/value/create/from-iterator.d.mts

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

package/build/value/create/from-iterator.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
 function* CreateIterator() { }
-export function FromIterator(context, type) {
+export function FromIterator(_context, _type) {
     return CreateIterator();
 }

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

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

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

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

package/build/value/create/from-never.d.mts

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

package/build/value/create/from-never.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
 import { CreateError } from './error.mjs';
-export function FromNever(context, type) {
+export function FromNever(_context, type) {
     throw new CreateError(type, 'Cannot create TNever types');
 }

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

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

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

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromNull(context, type) {
+export function FromNull(_context, _type) {
     return null;
 }

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

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

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

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { IsExclusiveMinimum, IsMinimum } from '../../schema/types/index.mjs';
-export function FromNumber(context, type) {
+export function FromNumber(_context, type) {
     return (IsExclusiveMinimum(type) && Guard.IsNumber(type.exclusiveMinimum) ? type.exclusiveMinimum + 1 :
         IsMinimum(type) ? type.minimum :
             0);

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

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

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

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { IsMinProperties, IsDefault } from '../../schema/types/index.mjs';
 import { CreateError } from './error.mjs';
-export function FromRecord(context, type) {
+export function FromRecord(_context, type) {
     if (IsMinProperties(type) && !IsDefault(type))
         throw new CreateError(type, 'Record with the minProperties constraint must have a default annotation');
     return {};

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

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

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsPattern, IsFormat, IsDefault, IsMinLength } from '../../schema/types/index.mjs';
-export function FromString(context, type) {
+export function FromString(_context, type) {
     const needsDefault = (IsPattern(type) || IsFormat(type)) && !IsDefault(type);
     if (needsDefault)
         throw Error('Strings with format or pattern constraints must specify default');

package/build/value/create/from-symbol.d.mts

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

package/build/value/create/from-symbol.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromSymbol(context, type) {
+export function FromSymbol(_context, _type) {
     return Symbol();
 }

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

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

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

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromUndefined(context, type) {
+export function FromUndefined(_context, _type) {
     return undefined;
 }

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

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

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

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export function FromVoid(context, type) {
+export function FromVoid(_context, _type) {
     return void 0;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.20",
+  "version": "1.1.22",
   "keywords": [
     "typescript",
     "jsonschema"

package/build/system/environment/can-evaluate.d.mts

@@ -1,2 +0,0 @@
-/** Returns true if the environment supports dynamic JavaScript evaluation */
-export declare function CanAccelerate(): boolean;

package/build/system/environment/can-evaluate.mjs

@@ -1,26 +0,0 @@
-import { Settings } from '../settings/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-let supported = undefined;
-// ------------------------------------------------------------------
-// TryEval
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - catch is environment dependent
-function TryEval() {
-    try {
-        new globalThis.Function('null')();
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
-// CanEvaluate
-// ------------------------------------------------------------------
-/** Returns true if the environment supports dynamic JavaScript evaluation */
-export function CanAccelerate() {
-    if (Guard.IsUndefined(supported))
-        supported = TryEval();
-    return supported && Settings.Get().useAcceleration;
-}