node-pluginsmanager-plugin 4.8.8 → 5.0.2

package/lib/cjs/checkers/RangeError/checkArrayLength.d.ts

@@ -0,0 +1,2 @@
+export declare function checkArrayLengthSync(dataName: string, data: any, length: number): ReferenceError | TypeError | RangeError | null;
+export declare function checkArrayLength(dataName: string, data: any, length: number): Promise<void>;

package/lib/cjs/checkers/RangeError/checkArrayLength.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkArrayLength = exports.checkArrayLengthSync = void 0;
+//  deps
+// locals
+const checkArray_1 = require("./../TypeError/checkArray");
+const checkInteger_1 = require("./../TypeError/checkInteger");
+// module
+function checkArrayLengthSync(dataName, data, length) {
+    let err = (0, checkArray_1.checkArraySync)(dataName, data);
+    if (!err) {
+        err = (0, checkInteger_1.checkIntegerSync)(dataName + "/length", length);
+    }
+    if (!err && length !== data.length) {
+        err = new RangeError("\"" + dataName + "\" length must be equal to " + length);
+    }
+    return err;
+}
+exports.checkArrayLengthSync = checkArrayLengthSync;
+;
+function checkArrayLength(dataName, data, length) {
+    const err = checkArrayLengthSync(dataName, data, length);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkArrayLength = checkArrayLength;
+;

package/lib/cjs/checkers/RangeError/checkArrayLengthBetween.d.ts

@@ -0,0 +1,2 @@
+export declare function checkArrayLengthBetweenSync(dataName: string, data: any, min: number, max: number): ReferenceError | TypeError | RangeError | null;
+export declare function checkArrayLengthBetween(dataName: string, data: any, min: number, max: number): Promise<void>;

package/lib/cjs/checkers/RangeError/checkArrayLengthBetween.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkArrayLengthBetween = exports.checkArrayLengthBetweenSync = void 0;
+//  deps
+// locals
+const checkArray_1 = require("./../TypeError/checkArray");
+const checkInteger_1 = require("./../TypeError/checkInteger");
+const checkNonEmptyInteger_1 = require("./checkNonEmptyInteger");
+// module
+function checkArrayLengthBetweenSync(dataName, data, min, max) {
+    let err = (0, checkArray_1.checkArraySync)(dataName, data);
+    if (!err) {
+        err = (0, checkInteger_1.checkIntegerSync)(dataName + "/min", min);
+    }
+    if (!err) {
+        err = (0, checkNonEmptyInteger_1.checkNonEmptyIntegerSync)(dataName + "/max", max);
+    }
+    if (!err && min > data.length) {
+        err = new RangeError("\"" + dataName + "\" length must be higher than " + min);
+    }
+    if (!err && max < data.length) {
+        err = new RangeError("\"" + dataName + "\" length must be lower than " + max);
+    }
+    return err;
+}
+exports.checkArrayLengthBetweenSync = checkArrayLengthBetweenSync;
+;
+function checkArrayLengthBetween(dataName, data, min, max) {
+    const err = checkArrayLengthBetweenSync(dataName, data, min, max);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkArrayLengthBetween = checkArrayLengthBetween;
+;

package/lib/cjs/checkers/RangeError/checkIntegerBetween.d.ts

@@ -0,0 +1,2 @@
+export declare function checkIntegerBetweenSync(dataName: string, data: any, min: number, max: number): ReferenceError | TypeError | RangeError | null;
+export declare function checkIntegerBetween(dataName: string, data: any, min: number, max: number): Promise<void>;

package/lib/cjs/checkers/RangeError/checkIntegerBetween.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIntegerBetween = exports.checkIntegerBetweenSync = void 0;
+//  deps
+// locals
+const checkInteger_1 = require("./../TypeError/checkInteger");
+const checkNonEmptyInteger_1 = require("./checkNonEmptyInteger");
+// module
+function checkIntegerBetweenSync(dataName, data, min, max) {
+    let err = (0, checkInteger_1.checkIntegerSync)(dataName, data);
+    if (!err) {
+        err = (0, checkInteger_1.checkIntegerSync)(dataName + "/min", min);
+    }
+    if (!err) {
+        err = (0, checkNonEmptyInteger_1.checkNonEmptyIntegerSync)(dataName + "/max", max);
+    }
+    if (!err && min > data) {
+        err = new RangeError("\"" + dataName + "\" must be higher than " + min);
+    }
+    if (!err && max < data) {
+        err = new RangeError("\"" + dataName + "\" must be lower than " + max);
+    }
+    return err;
+}
+exports.checkIntegerBetweenSync = checkIntegerBetweenSync;
+;
+function checkIntegerBetween(dataName, data, min, max) {
+    const err = checkIntegerBetweenSync(dataName, data, min, max);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkIntegerBetween = checkIntegerBetween;
+;

package/lib/cjs/checkers/RangeError/checkNonEmptyArray.d.ts

@@ -0,0 +1,2 @@
+export declare function checkNonEmptyArraySync(dataName: string, data: any): ReferenceError | TypeError | RangeError | null;
+export declare function checkNonEmptyArray(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/RangeError/checkNonEmptyArray.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNonEmptyArray = exports.checkNonEmptyArraySync = void 0;
+//  deps
+// locals
+const checkArray_1 = require("./../TypeError/checkArray");
+// module
+function checkNonEmptyArraySync(dataName, data) {
+    let err = (0, checkArray_1.checkArraySync)(dataName, data);
+    if (!err && 1 > data.length) {
+        err = new RangeError("\"" + dataName + "\" length must be higher than 0");
+    }
+    return err;
+}
+exports.checkNonEmptyArraySync = checkNonEmptyArraySync;
+;
+function checkNonEmptyArray(dataName, data) {
+    const err = checkNonEmptyArraySync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkNonEmptyArray = checkNonEmptyArray;
+;

package/lib/cjs/checkers/RangeError/checkNonEmptyInteger.d.ts

@@ -0,0 +1,2 @@
+export declare function checkNonEmptyIntegerSync(dataName: string, data: any): ReferenceError | TypeError | RangeError | null;
+export declare function checkNonEmptyInteger(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/RangeError/checkNonEmptyInteger.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNonEmptyInteger = exports.checkNonEmptyIntegerSync = void 0;
+//  deps
+// locals
+const checkInteger_1 = require("./../TypeError/checkInteger");
+// module
+function checkNonEmptyIntegerSync(dataName, data) {
+    let err = (0, checkInteger_1.checkIntegerSync)(dataName, data);
+    if (!err && 0 >= data) {
+        err = new RangeError("\"" + dataName + "\" must be higher than 0");
+    }
+    return err;
+}
+exports.checkNonEmptyIntegerSync = checkNonEmptyIntegerSync;
+;
+function checkNonEmptyInteger(dataName, data) {
+    const err = checkNonEmptyIntegerSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkNonEmptyInteger = checkNonEmptyInteger;
+;

package/lib/cjs/checkers/RangeError/checkNonEmptyNumber.d.ts

@@ -0,0 +1,2 @@
+export declare function checkNonEmptyNumberSync(dataName: string, data: any): ReferenceError | TypeError | RangeError | null;
+export declare function checkNonEmptyNumber(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/RangeError/checkNonEmptyNumber.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNonEmptyNumber = exports.checkNonEmptyNumberSync = void 0;
+//  deps
+// locals
+const checkNumber_1 = require("./../TypeError/checkNumber");
+// module
+function checkNonEmptyNumberSync(dataName, data) {
+    let err = (0, checkNumber_1.checkNumberSync)(dataName, data);
+    if (!err && 0 >= data) {
+        err = new RangeError("\"" + dataName + "\" must be higher than 0");
+    }
+    return err;
+}
+exports.checkNonEmptyNumberSync = checkNonEmptyNumberSync;
+;
+function checkNonEmptyNumber(dataName, data) {
+    const err = checkNonEmptyNumberSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkNonEmptyNumber = checkNonEmptyNumber;
+;

package/lib/cjs/checkers/RangeError/checkNonEmptyObject.d.ts

@@ -0,0 +1,2 @@
+export declare function checkNonEmptyObjectSync(dataName: string, data: any): ReferenceError | TypeError | RangeError | null;
+export declare function checkNonEmptyObject(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/RangeError/checkNonEmptyObject.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNonEmptyObject = exports.checkNonEmptyObjectSync = void 0;
+//  deps
+// locals
+const checkObject_1 = require("./../TypeError/checkObject");
+// module
+function checkNonEmptyObjectSync(dataName, data) {
+    let err = (0, checkObject_1.checkObjectSync)(dataName, data);
+    if (!err && 1 > Object.keys(data).length) {
+        err = new RangeError("\"" + dataName + "\" must have keys");
+    }
+    return err;
+}
+exports.checkNonEmptyObjectSync = checkNonEmptyObjectSync;
+;
+function checkNonEmptyObject(dataName, data) {
+    const err = checkNonEmptyObjectSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkNonEmptyObject = checkNonEmptyObject;
+;

package/lib/cjs/checkers/RangeError/checkNonEmptyString.d.ts

@@ -0,0 +1,2 @@
+export declare function checkNonEmptyStringSync(dataName: string, data: any): ReferenceError | TypeError | RangeError | null;
+export declare function checkNonEmptyString(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/RangeError/checkNonEmptyString.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNonEmptyString = exports.checkNonEmptyStringSync = void 0;
+//  deps
+// locals
+const checkString_1 = require("./../TypeError/checkString");
+// module
+function checkNonEmptyStringSync(dataName, data) {
+    let err = (0, checkString_1.checkStringSync)(dataName, data);
+    if (!err && "" === data.trim()) {
+        err = new RangeError("\"" + dataName + "\" length must be higher than 0");
+    }
+    return err;
+}
+exports.checkNonEmptyStringSync = checkNonEmptyStringSync;
+;
+function checkNonEmptyString(dataName, data) {
+    const err = checkNonEmptyStringSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkNonEmptyString = checkNonEmptyString;
+;

package/lib/cjs/checkers/RangeError/checkNumberBetween.d.ts

@@ -0,0 +1,2 @@
+export declare function checkNumberBetweenSync(dataName: string, data: any, min: number, max: number): ReferenceError | TypeError | RangeError | null;
+export declare function checkNumberBetween(dataName: string, data: any, min: number, max: number): Promise<void>;

package/lib/cjs/checkers/RangeError/checkNumberBetween.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNumberBetween = exports.checkNumberBetweenSync = void 0;
+//  deps
+// locals
+const checkNumber_1 = require("./../TypeError/checkNumber");
+const checkNonEmptyNumber_1 = require("./checkNonEmptyNumber");
+// module
+function checkNumberBetweenSync(dataName, data, min, max) {
+    let err = (0, checkNumber_1.checkNumberSync)(dataName, data);
+    if (!err) {
+        err = (0, checkNumber_1.checkNumberSync)(dataName + "/min", min);
+    }
+    if (!err) {
+        err = (0, checkNonEmptyNumber_1.checkNonEmptyNumberSync)(dataName + "/max", max);
+    }
+    if (!err && min > data) {
+        err = new RangeError("\"" + dataName + "\" must be higher than " + min);
+    }
+    if (!err && max < data) {
+        err = new RangeError("\"" + dataName + "\" must be lower than " + max);
+    }
+    return err;
+}
+exports.checkNumberBetweenSync = checkNumberBetweenSync;
+;
+function checkNumberBetween(dataName, data, min, max) {
+    const err = checkNumberBetweenSync(dataName, data, min, max);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkNumberBetween = checkNumberBetween;
+;

package/lib/cjs/checkers/RangeError/checkObjectLength.d.ts

@@ -0,0 +1,2 @@
+export declare function checkObjectLengthSync(dataName: string, data: any, _length: number): ReferenceError | TypeError | RangeError | null;
+export declare function checkObjectLength(dataName: string, data: any, length: number): Promise<void>;

package/lib/cjs/checkers/RangeError/checkObjectLength.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkObjectLength = exports.checkObjectLengthSync = void 0;
+//  deps
+// locals
+const checkObject_1 = require("./../TypeError/checkObject");
+const checkInteger_1 = require("./../TypeError/checkInteger");
+// private
+// methods
+// module
+function checkObjectLengthSync(dataName, data, _length) {
+    let err = (0, checkObject_1.checkObjectSync)(dataName, data);
+    if (!err) {
+        err = (0, checkInteger_1.checkIntegerSync)(dataName + "/length", _length);
+    }
+    if (!err) {
+        const { length } = Object.keys(data);
+        if (_length !== length) {
+            err = new RangeError("\"" + dataName + "\" keys count must be equal to " + _length);
+        }
+    }
+    return err;
+}
+exports.checkObjectLengthSync = checkObjectLengthSync;
+;
+function checkObjectLength(dataName, data, length) {
+    const err = checkObjectLengthSync(dataName, data, length);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkObjectLength = checkObjectLength;
+;

package/lib/cjs/checkers/RangeError/checkObjectLengthBetween.d.ts

@@ -0,0 +1,2 @@
+export declare function checkObjectLengthBetweenSync(dataName: string, data: any, min: number, max: number): ReferenceError | TypeError | RangeError | null;
+export declare function checkObjectLengthBetween(dataName: string, data: any, min: number, max: number): Promise<void>;

package/lib/cjs/checkers/RangeError/checkObjectLengthBetween.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkObjectLengthBetween = exports.checkObjectLengthBetweenSync = void 0;
+//  deps
+// locals
+const checkObject_1 = require("./../TypeError/checkObject");
+const checkInteger_1 = require("./../TypeError/checkInteger");
+const checkNonEmptyInteger_1 = require(".//checkNonEmptyInteger");
+// module
+function checkObjectLengthBetweenSync(dataName, data, min, max) {
+    let err = (0, checkObject_1.checkObjectSync)(dataName, data);
+    if (!err) {
+        err = (0, checkInteger_1.checkIntegerSync)(dataName + "/min", min);
+    }
+    if (!err) {
+        err = (0, checkNonEmptyInteger_1.checkNonEmptyIntegerSync)(dataName + "/max", max);
+    }
+    if (!err) {
+        const { length } = Object.keys(data);
+        if (min > length) {
+            err = new RangeError("\"" + dataName + "\" length must be higher than " + min);
+        }
+        if (!err && max < length) {
+            err = new RangeError("\"" + dataName + "\" length must be lower than " + max);
+        }
+    }
+    return err;
+}
+exports.checkObjectLengthBetweenSync = checkObjectLengthBetweenSync;
+;
+function checkObjectLengthBetween(dataName, data, min, max) {
+    const err = checkObjectLengthBetweenSync(dataName, data, min, max);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkObjectLengthBetween = checkObjectLengthBetween;
+;

package/lib/cjs/checkers/RangeError/checkStringLength.d.ts

@@ -0,0 +1,2 @@
+export declare function checkStringLengthSync(dataName: string, data: any, length: number): ReferenceError | TypeError | RangeError | null;
+export declare function checkStringLength(dataName: string, data: any, length: number): Promise<void>;

package/lib/cjs/checkers/RangeError/checkStringLength.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkStringLength = exports.checkStringLengthSync = void 0;
+//  deps
+// locals
+const checkString_1 = require("./../TypeError/checkString");
+const checkInteger_1 = require("./../TypeError/checkInteger");
+// module
+function checkStringLengthSync(dataName, data, length) {
+    let err = (0, checkString_1.checkStringSync)(dataName, data);
+    if (!err) {
+        err = (0, checkInteger_1.checkIntegerSync)(dataName + "/length", length);
+    }
+    if (!err && length !== data.length) {
+        err = new RangeError("\"" + dataName + "\" length must be equal to " + length);
+    }
+    return err;
+}
+exports.checkStringLengthSync = checkStringLengthSync;
+;
+function checkStringLength(dataName, data, length) {
+    const err = checkStringLengthSync(dataName, data, length);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkStringLength = checkStringLength;
+;

package/lib/cjs/checkers/RangeError/checkStringLengthBetween.d.ts

@@ -0,0 +1,2 @@
+export declare function checkStringLengthBetweenSync(dataName: string, data: any, min: number, max: number): ReferenceError | TypeError | RangeError | null;
+export declare function checkStringLengthBetween(dataName: string, data: any, min: number, max: number): Promise<void>;

package/lib/cjs/checkers/RangeError/checkStringLengthBetween.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkStringLengthBetween = exports.checkStringLengthBetweenSync = void 0;
+//  deps
+// locals
+const checkString_1 = require("./../TypeError/checkString");
+const checkInteger_1 = require("./../TypeError/checkInteger");
+const checkNonEmptyInteger_1 = require("./checkNonEmptyInteger");
+// module
+function checkStringLengthBetweenSync(dataName, data, min, max) {
+    let err = (0, checkString_1.checkStringSync)(dataName, data);
+    if (!err) {
+        err = (0, checkInteger_1.checkIntegerSync)(dataName + "/min", min);
+    }
+    if (!err) {
+        err = (0, checkNonEmptyInteger_1.checkNonEmptyIntegerSync)(dataName + "/max", max);
+    }
+    if (!err && min > data.length) {
+        err = new RangeError("\"" + dataName + "\" length must be higher than " + min);
+    }
+    if (!err && max < data.length) {
+        err = new RangeError("\"" + dataName + "\" length must be lower than " + max);
+    }
+    return err;
+}
+exports.checkStringLengthBetweenSync = checkStringLengthBetweenSync;
+;
+function checkStringLengthBetween(dataName, data, min, max) {
+    const err = checkStringLengthBetweenSync(dataName, data, min, max);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkStringLengthBetween = checkStringLengthBetween;
+;

package/lib/cjs/checkers/ReferenceError/checkExists.d.ts

@@ -0,0 +1,2 @@
+export declare function checkExistsSync(dataName: string, data: any): ReferenceError | null;
+export declare function checkExists(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/ReferenceError/checkExists.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExists = exports.checkExistsSync = void 0;
+// module
+function checkExistsSync(dataName, data) {
+    let err = null;
+    if ("undefined" === typeof data) {
+        err = new ReferenceError("\"" + dataName + "\" does not exist");
+    }
+    return err;
+}
+exports.checkExistsSync = checkExistsSync;
+;
+function checkExists(dataName, data) {
+    const err = checkExistsSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkExists = checkExists;
+;

package/lib/cjs/checkers/TypeError/checkArray.d.ts

@@ -0,0 +1,2 @@
+export declare function checkArraySync(dataName: string, data: any): ReferenceError | TypeError | null;
+export declare function checkArray(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/TypeError/checkArray.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkArray = exports.checkArraySync = void 0;
+//  deps
+// locals
+const checkObject_1 = require("../TypeError/checkObject");
+// module
+function checkArraySync(dataName, data) {
+    let err = (0, checkObject_1.checkObjectSync)(dataName, data);
+    if (!err && !(data instanceof Array)) {
+        err = new TypeError("\"" + dataName + "\" is not an Array");
+    }
+    return err;
+}
+exports.checkArraySync = checkArraySync;
+;
+function checkArray(dataName, data) {
+    const err = checkArraySync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkArray = checkArray;
+;

package/lib/cjs/checkers/TypeError/checkBoolean.d.ts

@@ -0,0 +1,2 @@
+export declare function checkBooleanSync(dataName: string, data: any): ReferenceError | TypeError | null;
+export declare function checkBoolean(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/TypeError/checkBoolean.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBoolean = exports.checkBooleanSync = void 0;
+//  deps
+// locals
+const checkExists_1 = require("../ReferenceError/checkExists");
+// module
+function checkBooleanSync(dataName, data) {
+    let err = (0, checkExists_1.checkExistsSync)(dataName, data);
+    if (!err && "boolean" !== typeof data) {
+        err = new TypeError("\"" + dataName + "\" is not a boolean");
+    }
+    return err;
+}
+exports.checkBooleanSync = checkBooleanSync;
+;
+function checkBoolean(dataName, data) {
+    const err = checkBooleanSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkBoolean = checkBoolean;
+;

package/lib/cjs/checkers/TypeError/checkFunction.d.ts

@@ -0,0 +1,2 @@
+export declare function checkFunctionSync(dataName: string, data: any): ReferenceError | TypeError | null;
+export declare function checkFunction(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/TypeError/checkFunction.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFunction = exports.checkFunctionSync = void 0;
+//  deps
+// locals
+const checkExists_1 = require("../ReferenceError/checkExists");
+// module
+function checkFunctionSync(dataName, data) {
+    let err = (0, checkExists_1.checkExistsSync)(dataName, data);
+    if (!err && "function" !== typeof data) {
+        err = new TypeError("\"" + dataName + "\" is not a function");
+    }
+    return err;
+}
+exports.checkFunctionSync = checkFunctionSync;
+;
+function checkFunction(dataName, data) {
+    const err = checkFunctionSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkFunction = checkFunction;
+;

package/lib/cjs/checkers/TypeError/checkInteger.d.ts

@@ -0,0 +1,2 @@
+export declare function checkIntegerSync(dataName: string, data: any): ReferenceError | TypeError | null;
+export declare function checkInteger(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/TypeError/checkInteger.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkInteger = exports.checkIntegerSync = void 0;
+//  deps
+// locals
+const checkExists_1 = require("../ReferenceError/checkExists");
+// module
+function checkIntegerSync(dataName, data) {
+    let err = (0, checkExists_1.checkExistsSync)(dataName, data);
+    if (!err && !Number.isInteger(data)) {
+        err = new TypeError("\"" + dataName + "\" is not an integer");
+    }
+    return err;
+}
+exports.checkIntegerSync = checkIntegerSync;
+;
+function checkInteger(dataName, data) {
+    const err = checkIntegerSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkInteger = checkInteger;
+;

package/lib/cjs/checkers/TypeError/checkNumber.d.ts

@@ -0,0 +1,2 @@
+export declare function checkNumberSync(dataName: string, data: any): ReferenceError | TypeError | null;
+export declare function checkNumber(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/TypeError/checkNumber.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNumber = exports.checkNumberSync = void 0;
+//  deps
+// locals
+const checkExists_1 = require("../ReferenceError/checkExists");
+// module
+function checkNumberSync(dataName, data) {
+    let err = (0, checkExists_1.checkExistsSync)(dataName, data);
+    if (!err && "number" !== typeof data) {
+        err = new TypeError("\"" + dataName + "\" is not a number");
+    }
+    return err;
+}
+exports.checkNumberSync = checkNumberSync;
+;
+function checkNumber(dataName, data) {
+    const err = checkNumberSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkNumber = checkNumber;
+;

package/lib/cjs/checkers/TypeError/checkObject.d.ts

@@ -0,0 +1,2 @@
+export declare function checkObjectSync(dataName: string, data: any): ReferenceError | TypeError | null;
+export declare function checkObject(dataName: string, data: any): Promise<void>;

package/lib/cjs/checkers/TypeError/checkObject.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkObject = exports.checkObjectSync = void 0;
+//  deps
+// locals
+const checkExists_1 = require("../ReferenceError/checkExists");
+// module
+function checkObjectSync(dataName, data) {
+    let err = (0, checkExists_1.checkExistsSync)(dataName, data);
+    if (!err && ("object" !== typeof data || null === data)) {
+        err = new TypeError("\"" + dataName + "\" is not an object");
+    }
+    return err;
+}
+exports.checkObjectSync = checkObjectSync;
+;
+function checkObject(dataName, data) {
+    const err = checkObjectSync(dataName, data);
+    return err ? Promise.reject(err) : Promise.resolve();
+}
+exports.checkObject = checkObject;
+;

package/lib/cjs/checkers/TypeError/checkString.d.ts

@@ -0,0 +1,2 @@
+export declare function checkStringSync(dataName: string, data: any): ReferenceError | TypeError | null;
+export declare function checkString(dataName: string, data: any): Promise<void>;