import { Checker } from '@pro-script/as-is';
import { NumbersValidator } from '@pro-script/as-is-plugins/numbers';
import { StringsValidator } from '@pro-script/as-is-plugins/strings';

const { as, is } = new Checker({ integrate: Object.assign(NumbersValidator, StringsValidator) });

const { Checker } = require('@pro-script/as-is');
const { NumbersValidator } = require('@pro-script/as-is-plugins/numbers');
const { StringsValidator } = require('@pro-script/as-is-plugins/strings');

const { as, is } = new Checker({ integrate: Object.assign(NumbersValidator, StringsValidator) });

const checker = new Checker({ 
    'IF/ELSE/END': true, 
    strict: true, 
    Enum: true, 
    utility: true,
    integrate: Object.assign(NumbersValidator, StringsValidator) });
const { multi, Interface, as, is, IF, ELSE, END, optional, get, macro, strict, Enum }  = checker;
const { START, STOP, FINISH, METHOD, PROPERTY, IS, CHECK, passed, failed } = new MicroTest({ is, as });

Object.assign(global, { multi, Interface, as, is, Enum });

Object.assign(window, { multi, Interface, as, is, Enum });

const { IUser } = Interface({
            IUser: {
                name: as.string,
                age: as.number,
                birthDate: as.date
            }
});
as.IUser = { name: 'Jesus', age: 2022, birthDate: 'Sat Apr 7 0:0:0 GMT+0200 (Central European Summer Time)'};

function example(name, age,  _ = as.IUser = { name, age }) {
            console.log(name, age);
            return 'returned string';
        }

as.StringNumber(example({ name: 'text', age: 12, pages:['page'] }));

const { multi, Interface, Type, as, is, IF, ELSE, END, optional, get, macro, strict, Enum }  = checker;

const { TUser } = Type({
            IUser: {
                name: as.string,
                birthDate: as.date,
                age: (value)=> {
                    // any code here to check the value 
                }
            }
});
as.TUser({ name: 'Jesus', age: 2022, birthDate: 'Sat Apr 7 0:0:0 GMT+0200 (Central European Summer Time)'});

import { Checker, BaseInterface, MicroTest, Utility } from '@pro-script/as-is';
import axios from "axios";

const integrate = {
    up: async function (url) {
        const result = await axios.get(url);
        if(result.status === 200) return 'Ok';
        else throw new TypeError('url is down');
    }
};

const { multi, strict, as, is } = new Checker({ integrate });
const isUrl = as;

async function example(arg, arg2, arg3,
                       type = [as.string(arg), as.number(arg2), as.boolean(arg3)]) {
    await isUrl.up('https://google.com');
    console.log(type);
};

await example('text', 2, true)
// [ 'text', 2, true ]

await isUrl?.up('https://not-google.com');
// TypeError: url is down

const { as, is } = new Checker;

const checker = new Checker({ 'IF/ELSE/END': true, strict: true, Enum: true, utility: true });
const { multi, Interface, as, is, IF, ELSE, END, optional, get, macro, strict, Enum }  = checker;
const { START, STOP, FINISH, METHOD, PROPERTY, IS, CHECK, passed, failed } = new MicroTest({ is, as });

const checker = new Checker({ 
    'IF/ELSE/END': true, 
    strict: true, 
    Enum: true, 
    utility: true, 
    integrate: Object.assign(NumbersValidator, StringsValidator) 
});
const { multi, Interface, as, is, IF, ELSE, END, optional, get, macro, strict, Enum }  = checker;
const { START, STOP, FINISH, METHOD, PROPERTY, IS, CHECK, passed, failed } = new MicroTest({ is, as });

is.string(value) -> true | false
as.string(value) -> value | TypeError: [get.type(value)] is not a(an) string

is.string('hello');   // Returns true
is.string(123);       // Returns false

as.string('hello');   // Returns 'hello'
as.string(123);       // Throws TypeError: Number is not a(an) string

is.number(value) -> true | false
as.number(value) -> value | TypeError: [get.type(value)] is not is not a(an) number

is.number(123);   // Returns true
is.number('123'); // Returns false

as.number(123);   // Returns 123
as.number('123'); // Throws TypeError: Number is not a(an) number

is.boolean(value) -> true | false
as.boolean(value) -> value | TypeError: [get.type(value)] is not a(an) boolean

is.boolean(true);  // Returns true
is.boolean(1);     // Returns false

as.boolean(true);  // Returns true
as.boolean(1);     // Throws TypeError: Number is not a(an) boolean

is.symbol(value) -> true | false
as.symbol(value) -> value | TypeError: [get.type(value)] is not a(an) symbol

const sym = Symbol('test');
is.symbol(sym);        // Returns true
is.symbol('symbol');   // Returns false

as.symbol(sym);        // Returns sym
as.symbol('symbol');   // Throws TypeError: String is not a(an) symbol

is.function(value) -> true | false
as.function(value) -> value | TypeError: [get.type(value)] is not a(an) function

const func = () => {};
is.function(func);    // Returns true
is.function(123);     // Returns false

as.function(func);    // Returns func
as.function(123);     // Throws TypeError: Number is not a(an) function

is.bigInt(value) -> true | false
as.bigInt(value) -> value | TypeError: [get.type(value)] is not a(an) bigInt

const bigIntExample = BigInt('1234567890123456789012345678901234567890');
is.bigInt(bigIntExample);     // Returns true
is.bigInt(1234567890);        // Returns false

as.bigInt(bigIntExample);     // Returns bigIntExample
as.bigInt(1234567890);        // Throws TypeError: Number is not a(an) bigInt

is.array(value) -> true | false
as.array(value) -> value | TypeError: [get.type(value)] is not a(an) bigInt

const arrayExample = [];
is.array(arrayExample);    // Returns true
is.array('not an array');  // Returns false

as.array(arrayExample);    // Returns arrayExample
as.array('not an array');  // Throws TypeError: String is not a(an) array

is.date(value) -> true | false
as.date(value) -> value | TypeError: [get.type(value)] is not a(an) date

const dateExample = new Date();
is.date(dateExample);    // Returns true
is.date('not a date');   // Returns false

as.date(dateExample);    // Returns dateExample
as.date('not a date');   // Throws TypeError: String is not a(an) date

is.object(value) -> true | false
as.object(value) -> value | TypeError: [get.type(value)] is not a(an) object

const objectExample = {};
is.object(objectExample);    // Returns true
is.object('not an object');  // Returns false

as.object(objectExample);    // Returns objectExample
as.object('not an object');  // Throws TypeError: String is not a(an) object

is.set(value) -> true | false
as.set(value) -> value | TypeError: [get.type(value)] is not a(an) set

const setExample = new Set();
is.set(setExample);      // Returns true
is.set('not a set');     // Returns false

as.set(setExample);      // Returns setExample
as.set('not a set');     // Throws TypeError: String is not a(an) set

is.map(value) -> true | false
as.map(value) -> value | TypeError: [get.type(value)] is not a(an) map

const mapExample = new Map();
is.map(mapExample);      // Returns true
is.map('not a map');     // Returns false

as.map(mapExample);      // Returns mapExample
as.map('not a map');     // Throws TypeError: String is not a(an) map

is.weakSet(value) -> true | false
as.weakSet(value) -> value | TypeError: [get.type(value)] is not a(an) weakSet

const weakSetExample = new WeakSet();
is.weakSet(weakSet

Example);      // Returns true
is.weakSet('not a weakSet');     // Returns false

as.weakSet(weakSetExample);      // Returns weakSetExample
as.weakSet('not a weakSet');     // Throws TypeError: String is not a(an) weakSet

is.weakMap(value) -> true | false
as.weakMap(value) -> value | TypeError: [get.type(value)] is not a(an) weakMap

const weakMapExample = new WeakMap();
is.weakMap(weakMapExample);      // Returns true
is.weakMap('not a weakMap');     // Returns false

as.weakMap(weakMapExample);      // Returns weakMapExample
as.weakMap('not a weakMap');     // Throws TypeError: String is not a(an) weakMap

is.regExp(value) -> true | false
as.regExp(value) -> value | TypeError: [get.type(value)] is not a(an) regExp

const regExpExample = /./g;
is.regExp(regExpExample);      // Returns true
is.regExp('not a regExp');     // Returns false

as.regExp(regExpExample);      // Returns regExpExample
as.regExp('not a regExp');     // Throws TypeError: String is not a(an) regExp

is.promise(value) -> true | false
as.promise(value) -> value | TypeError: [get.type(value)] is not a(an) promise

const promiseExample = new Promise((resolve) => resolve());
is.promise(promiseExample);      // Returns true
is.promise('not a promise');     // Returns false

as.promise(promiseExample);      // Returns promiseExample
as.promise('not a promise');     // Throws TypeError: String is not a(an) promise

is.generator(value) -> true | false
as.generator(value) -> value | TypeError: [get.type(value)] is not a(an) generator

function* generatorExample() {
    yield 1;
    yield 2;
}
is.generator(generatorExample());     // Returns true
is.generator('not a generator');      // Returns false

as.generator(generatorExample());     // Returns generatorExample
as.generator('not a generator');      // Throws TypeError: String is not a(an) generator

is.typedArray(value) -> true | false
as.typedArray(value) -> value | TypeError: TypedArray is not a value that passed validation

is.typedArray(new Int8Array());   // Returns true
is.typedArray([]);                // Returns false

as.typedArray(new Int8Array());   // Returns Int8Array
as.typedArray([]);                // Throws TypeError: Array is not a(an) typedArray

is.buffer(value) -> true | false
as.buffer(value) -> value | TypeError: [get.type(value)] is not a(an) buffer

is.buffer(Buffer.from('hello'));  // Returns true
is.buffer('hello');               // Returns false

as.buffer(Buffer.from('hello'));  // Returns Buffer
as.buffer('hello');               // Throws TypeError: String is not a(an) buffer

is.sharedArrayBuffer(value) -> true | false
as.sharedArrayBuffer(value) -> value | TypeError: [get.type(value)] is not a(an) sharedArrayBuffer

is.sharedArrayBuffer(new SharedArrayBuffer());  // Returns true
is.sharedArrayBuffer([]);                       // Returns false

as.sharedArrayBuffer(new SharedArrayBuffer());  // Returns SharedArrayBuffer
as.sharedArrayBuffer([]);                       // Throws TypeError: Array is not a(an) sharedArrayBuffer

is.date(value) -> true | false
as.date(value) -> value | TypeError: [get.type(value)] is not a(an) date

is.date(new Date());      // Returns true
is.date('2021-01-01');    // Returns false

as.date(new Date());      // Returns Date
as.date('2021-01-01');    // Throws TypeError: String is not a(an) date

is.object(value) -> true | false
as.object(value) -> value | TypeError: [get.type(value)] is not a(an) object

is.object({});            // Returns true
is.object('hello');       // Returns false

as.object({});            // Returns {}
as.object('hello');       // Throws TypeError: String is not a(an) object

is.class(value) -> true | false
as.class(value) -> value | TypeError: [get.type(value)] is not a(an) class

class MyClass {}
is.class(MyClass);        // Returns true
is.class(() => {});       // Returns false

as.class(MyClass);        // Returns MyClass
as.class(() => {});       // Throws TypeError: Function is not a(an) class

is.instance(value, constructor) -> true | false
as.instance(value, constructor) -> value | TypeError: [get.type(value)] is not a(an) instance

class MyClass {}
const instance = new MyClass();
is.instance(instance, MyClass);   // Returns true
is.instance({}, MyClass);         // Returns false

as.instance(instance, MyClass);   // Returns instance
as.instance({}, MyClass);         // Throws TypeError: Object is not a(an) instance

is.iterator(value) -> true | false
as.iterator(value) -> value | TypeError: [get.type(value)] is not a(an) iterator

const iterator = [][Symbol.iterator]();
is.iterator(iterator);    // Returns true
is.iterator([]);          // Returns false

as.iterator(iterator);    // Returns iterator
as.iterator([]);          // Throws TypeError: Array is not a(an) iterator

is.nullish(value) -> true | false
as.nullish(value) -> value | TypeError: [get.type(value)] is not a(an) nullish

is.nullish(null);         // Returns true
is.nullish(undefined);    // Returns true
is.nullish('hello');      // Returns false

as.nullish(null);         // Returns null
as.nullish(undefined);    // Returns undefined
as.nullish('hello');      // Throws TypeError: String is not a(an) nullish

is.error(value) -> true | false
as.error(value) -> value | TypeError: [get.type(value)] is not a(an) error

is.error(new Error());    // Returns true
is.error('error');        // Returns false

as.error(new Error());    // Returns Error
as.error('error');        // Throws TypeError: String is not a(an) error

is.rangeError(value) -> true | false
as.rangeError(value) -> value | TypeError: [get.type(value)] is not a(an) rangeError

is.rangeError(new RangeError());    // Returns true
is.rangeError('error');             // Returns false

as.rangeError(new RangeError());    // Returns RangeError
as.rangeError('error');             // Throws TypeError: String is not a(an) rangeError

is.referenceError(value) -> true | false
as.referenceError(value) -> value | TypeError: [get.type(value)] is not a(an) referenceError

is.referenceError(new ReferenceError());    // Returns true
is.referenceError('error');                 // Returns false

as.referenceError(new ReferenceError());    // Returns ReferenceError
as.referenceError('error');                 // Throws TypeError: String is not a(an) referenceError

is.syntaxError(value) -> true | false
as.syntaxError(value) -> value | TypeError: [get.type(value)] is not a(an) syntaxError

is.syntaxError(new SyntaxError());    // Returns true
is.syntaxError('error');              // Returns false

as.syntaxError(new SyntaxError());    // Returns SyntaxError
as.syntaxError('error');              // Throws TypeError: String is not a(an) syntaxError

is.typeError(value) -> true | false
as.typeError(value) -> value | TypeError: [get.type(value)] is not a(an) typeError

is.typeError(new TypeError());    // Returns true
is.typeError('error');            // Returns false

as.typeError(new TypeError());    // Returns TypeError
as.typeError('error');            // Throws TypeError: String is not a(an) typeError

is.any(value) -> true
as.any(value) -> value

is.any('hello');    // Returns true
is.any(123);        // Returns true

as.any('hello');    // Returns 'hello'
as.any(123);        // Returns 123

Enum.init('enum object here')

Enum.init({
    RED: 0,
    GREEN: Enum.inc,
    BLUE: Enum.inc,
});

// Enum {
//   '0': 'RED',
//   '1': 'GREEN',
//   '2': 'BLUE',
//   RED: 0,
//   GREEN: 1,
//   BLUE: 2
// }

Enum.init({
    ROOF: 2,
    FLOOR: Enum.dec,
    BASEMENT: Enum.dec,
});
// Enum {
//   '0': 'BASEMENT',
//   '1': 'FLOOR',
//   '2': 'ROOF',
//   ROOF: 2,
//   FLOOR: 1,
//   BASEMENT: 0
// }

Enum.init({
    RED: 0,
    GREEN: Enum.inc,
    BLUE: Enum.inc,
    ROOF: 6,
    FLOOR: Enum.dec,
    BASEMENT: Enum.dec,
});
// Enum {
//   '0': 'RED',
//   '1': 'GREEN',
//   '2': 'BLUE',
//   '4': 'BASEMENT',
//   '5': 'FLOOR',
//   '6': 'ROOF',
//   RED: 0,
//   GREEN: 1,
//   BLUE: 2,
//   ROOF: 6,
//   FLOOR: 5,
//   BASEMENT: 4
// }

Enum.init({
    [Enum.step]: 10, // ['Enum.step'] the same but with a quotes
    RED: Enum.inc,
    GREEN: Enum.inc,
    BLUE: Enum.inc,
});

// Enum {
//   '10': 'RED',
//   '20': 'GREEN',
//   '30': 'BLUE',
//   RED: 10,
//   GREEN: 20,
//   BLUE: 30
// }
const enumExample = Enum.init({
    [Enum.step]: 10,
    ROOF: Enum.dec,
    FLOOR: 30,
    BASEMENT: Enum.dec,
});
// Enum {
//   '10': 'ROOF',
//   '20': 'BASEMENT',
//   '30': 'FLOOR',
//   ROOF: 10,
//   FLOOR: 30,
//   BASEMENT: 20
// }

as.Enum(enumExample) && as.enum(enumExample);

is.empty(value) -> true | false
as.empty(value) -> value | TypeError: Value is not empty

const emptyArray = [];
is.empty(emptyArray);    // Returns true
is.empty([1, 2, 3]);     // Returns false

as.empty(emptyArray);    // Returns emptyArray
as.empty([1, 2, 3]);     // Throws TypeError: Value is not empty

is.notEmpty(value) -> true | false
as.notEmpty(value) -> value | TypeError: Value is empty

const notEmptyArray = [1, 2, 3];
is.notEmpty(notEmptyArray);    // Returns true
is.notEmpty([]);               // Returns false

as.notEmpty(notEmptyArray);    // Returns notEmptyArray
as.notEmpty([]);               // Throws TypeError: Value is empty

is.json(value) -> true | false
as.json(value) -> value | TypeError: Value is not JSON

const jsonExample = JSON.stringify({ test: 'test' });
is.json(jsonExample);    // Returns true
is.json('not json');     // Returns false

as.json(jsonExample);    // Returns jsonExample
as.json('not json');     // Throws TypeError: Value is not JSON

is.json5(value) -> true | false
as.json5(value) -> value | TypeError: Value is not JSON5

const json5Example = '{property: "value"}';
is.json5(json5Example);    // Returns true
is.json5('not json5');     // Returns false

as.json5(json5Example);    // Returns json5Example
as.json5('not json5');     // Throws TypeError: Value is not JSON5

is.null(value) -> true | false
as.null(value) -> value | TypeError: Value is not null

const nullExample = null;
is.null(nullExample);    // Returns true
is.null('not null');     // Returns false

as.null(nullExample);    // Returns nullExample
as.null('not null');     // Throws TypeError: Value is not null

is.zero(value) -> true | false
as.zero(value) -> value | TypeError: Number is not a value that passed validation

is.zero(0);      // Returns true
is.zero(5);      // Returns false

as.zero(0);      // Returns 0
as.zero(5);      // Throws TypeError: Number is not a value that passed validation

is.even(value) -> true | false
as.even(value) -> value | TypeError: Number is not a value that passed validation

is.even(2);      // Returns true
is.even(3);      // Returns false

as.even(2);      // Returns 2
as.even(3);      // Throws TypeError: Number is not a value that passed validation

is.odd(value) -> true | false
as.odd(value) -> value | TypeError: Number is not a value that passed validation

is.odd(1);      // Returns true
is.odd(4);      // Returns false

as.odd(1);      // Returns 1
as.odd(4);      // Throws TypeError: Number is not a value that passed validation

is.positive(value) -> true | false
as.positive(value) -> value | TypeError: Number is not a value that passed validation

is.positive(1.1);      // Returns true
is.positive(-1.1);     // Returns false

as.positive(1.1);      // Returns 1.1
as.positive(-1.1);     // Throws TypeError: Number is not a value that passed validation

is.negative(value) -> true | false
as.negative(value) -> value | TypeError: Number is not a value that passed validation

is.negative(-1.1);      // Returns true
is.negative(1.1);       // Returns false

as.negative(-1.1);      // Returns -1.1
as.negative(1.1);       // Throws TypeError: Number is not a value that passed validation

is.positiveInteger(value) -> true | false
as.positiveInteger(value) -> value | TypeError: Number is not a value that passed validation

is.positiveInteger(1);      // Returns true
is.positiveInteger(-1);     // Returns false

as.positiveInteger(1);      // Returns 1
as.positiveInteger(-1);     // Throws TypeError: Number is not a value that passed validation

is.negativeInteger(value) -> true | false
as.negativeInteger(value) -> value | TypeError: Number is not a value that passed validation

is.negativeInteger(-1);      // Returns true
is.negativeInteger(1);       // Returns false

as.negativeInteger(-1);      // Returns -1
as.negativeInteger(1);       // Throws TypeError: Number is not a value that passed validation

is.isFinite(value) -> true | false
as.isFinite(value) -> value | TypeError: Number is not a value that passed validation

is.isFinite(0);      // Returns true
is.isFinite(Infinity); // Returns false

as.isFinite(0);      // Returns 0
as.isFinite(Infinity); // Throws TypeError: Number is not a value that passed validation

is.NaN(value) -> true | false
as.NaN(value) -> value | TypeError: Number is not a value that passed validation

is.NaN(NaN);      // Returns true
is.NaN(0);        // Returns false

as.NaN(NaN);      // Returns NaN
as.NaN(0);        // Throws TypeError: Number is not a value that passed validation

is.between({ arg, min, max }) -> true | false
as.between({ arg, min, max }) -> value | TypeError: Number is not a value that passed validation

is.between({ arg: 5, min: 0, max: 10 });  // Returns true
is.between({ arg: 15, min: 0, max: 10 }); // Returns false

as.between({ arg: 5, min: 0, max: 10 });  // Returns 5
as.between({ arg: 15, min: 0, max: 10 }); // Throws TypeError: Number is not a value that passed validation

is.greater({ arg, value }) -> true | false
as.greater({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.greater({ arg: 15, value: 5 });  // Returns true
is.greater({ arg: 5, value: 15 });  // Returns false

as.greater({ arg: 15, value: 5 });  // Returns 15
as.greater({ arg: 5, value: 15 });  // Throws TypeError: Number is not a value that passed validation

is.less({ arg, value }) -> true | false
as.less({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.less({ arg: 5, value: 15 });  // Returns true
is.less({ arg: 15, value: 5 });  // Returns false

as.less({ arg: 5, value: 15 });  // Returns 5
as.less({ arg: 15, value: 5 });  // Throws TypeError: Number is not a value that passed validation

is.equalGreater({ arg, value }) -> true | false
as.equalGreater({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.equalGreater({ arg: 5, value: 5 });  // Returns true
is.equalGreater({ arg: 4, value: 5 });  // Returns false

as.equalGreater({ arg: 5, value: 5 });  // Returns 5
as.equalGreater({ arg: 4, value: 5 });  // Throws TypeError: Number is not a value that passed validation

is.equalLess({ arg, value }) -> true | false
as.equalLess({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.equalLess({ arg: 5, value: 5 });  // Returns true
is.equalLess({ arg: 6, value: 5 });  // Returns false

as.equalLess({ arg: 5, value: 5 });  // Returns 5
as.equalLess({ arg: 6, value: 5 });  // Throws TypeError: Number is not a value that passed validation

is.max({ arg, value }) -> true | false
as.max({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.max({ arg: 5, value: 5 });  // Returns true
is.max({ arg: 4, value: 5 });  // Returns false

as.max({ arg: 5, value: 5 });  // Returns 5
as.max({ arg: 4, value: 5 });  // Throws TypeError: Number is not a value that passed validation

is.min({ arg, value }) -> true | false
as.min({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.min({ arg: 5, value: 5 });  // Returns true
is.min({ arg: 6, value: 5 });  // Returns false

as.min({ arg: 5, value: 5 });  // Returns 5
as.min({ arg: 6, value: 5 });  // Throws TypeError: Number is not a value that passed validation

is.multiple({ arg, value }) -> true | false
as.multiple({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.multiple({ arg: 15, value: 5 });  // Returns true
is.multiple({ arg: 14, value: 5 });  // Returns false

as.multiple({ arg: 15, value: 5 });  // Returns 15
as.multiple({ arg: 14, value: 5 });  // Throws TypeError: Number is not a value that passed validation

is.port(value) -> true | false
as.port(value) -> value | TypeError: Number is not a value that passed validation

is.port(80);      // Returns true
is.port(70000);   // Returns false

as.port(80);      // Returns 80
as.port(70000);   // Throws TypeError: Number is not a value that passed validation

is.safe(value) -> true | false
as.safe(value) -> value | TypeError: Number is not a value that passed validation

is.safe(Number.MAX_SAFE_INTEGER);      // Returns true
is.safe(Number.MAX_SAFE_INTEGER + 1);  // Returns false

as.safe(Number.MAX_SAFE_INTEGER);      // Returns Number.MAX_SAFE_INTEGER
as.safe(Number.MAX_SAFE_INTEGER + 1);  // Throws TypeError: Number is not a value that passed validation

is.precision({ arg, value }) -> true | false
as.precision({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.precision({ arg: 5.22, value: 2 });  // Returns true
is.precision({ arg: 5.2, value: 2 });   // Returns false

as.precision({ arg: 5.22, value: 2 });  // Returns 5.22
as.precision({ arg: 5.2, value: 2 });   // Throws TypeError: Number is not a value that passed validation

is.digits({ arg, value }) -> true | false
as.digits({ arg, value }) -> value | TypeError: Number is not a value that passed validation

is.digits({ arg: 12345, value: 5 });  // Returns true
is.digits({ arg: 1234, value: 5 });   // Returns false

as.digits({ arg: 12345, value: 5 });  // Returns 12345
as.digits({ arg: 1234, value: 5 });   // Throws TypeError: Number is not a value that passed validation

is.ISBN10(value) -> true | false
as.ISBN10(value) -> value | TypeError: Number is not a value that passed validation

is.ISBN10(1234567890);  // Returns true
is.ISBN10(123456789);   // Returns false

as.ISBN10(1234567890);  // Returns 1234567890
as.ISBN10(123456789);   // Throws TypeError: Number is not a value that passed validation

is.ISBN13(value) -> true | false
as.ISBN13(value) -> value | TypeError: Number is not a value that passed validation

is.ISBN13(1234567890123);  // Returns true
is.ISBN13(123456789012);   // Returns false

as.ISBN13(1234567890123);  // Returns 1234567890123
as.ISBN13(123456789012);   // Throws TypeError: Number is not a value that passed validation