hein 0.0.1

package/dist/assert/greater-than.js

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notGreaterThan = exports.greaterThan = void 0;
+const assertion_1 = require("../utils/assertion");
+const validate_numeric_and_dates_1 = require("../utils/validate-numeric-and-dates");
+_a = (0, assertion_1.createAssertion)({
+    messages: {
+        smaller: 'Expected {{actual}} to be greater than {{expected}}',
+        not: 'Expected {{actual}} to not be greater than {{expected}}'
+    },
+    test: (report) => (actual, expected) => {
+        (0, validate_numeric_and_dates_1.validateNumericsAndDates)(actual, expected);
+        if (actual < expected) {
+            return report({ status: 'notok', messageId: 'smaller', actual, expected, noStringify: true });
+        }
+        return report({ status: 'ok', messageId: 'not', expected, actual });
+    }
+}), exports.greaterThan = _a[0], exports.notGreaterThan = _a[1];
+//# sourceMappingURL=greater-than.js.map

package/dist/assert/greater-than.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than.js","sourceRoot":"","sources":["../../src/assert/greater-than.ts"],"names":[],"mappings":";;;;AAAA,kDAAqD;AACrD,oFAA+E;AASlE,KAAgC,IAAA,2BAAe,EAAC;IACzD,QAAQ,EAAE;QACN,OAAO,EAAE,qDAAqD;QAC9D,GAAG,EAAE,yDAAyD;KACjE;IACD,IAAI,EAAE,CAAC,MAAM,EAAe,EAAE,CAAC,CAAC,MAAW,EAAE,QAAa,EAAE,EAAE;QAC1D,IAAA,qDAAwB,EAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAC3C,IAAI,MAAM,GAAG,QAAQ,EAAE;YACnB,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;SACjG;QACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IACxE,CAAC;CACJ,CAAC,EAZY,mBAAW,UAAE,sBAAc,SAYtC"}

package/dist/assert/has-size.d.ts

@@ -0,0 +1,2 @@
+export declare const hasSize: <T>(actual: T, expected: number, message?: string) => true | void, notHasSize: <T>(actual: T, expected: number, message?: string) => true | void;
+//# sourceMappingURL=has-size.d.ts.map

package/dist/assert/has-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-size.d.ts","sourceRoot":"","sources":["../../src/assert/has-size.ts"],"names":[],"mappings":"AAGA,eAAO,MAAO,OAAO,2BAa0B,MAAM,YAAY,MAAM,kBAbhD,UAAU,2BAac,MAAM,YAAY,MAAM,gBAgCrE,CAAC"}

package/dist/assert/has-size.js

@@ -0,0 +1,53 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notHasSize = exports.hasSize = void 0;
+const lodash_1 = require("lodash");
+const assertion_1 = require("../utils/assertion");
+_a = (0, assertion_1.createAssertion)({
+    messages: {
+        array: 'Expected array to have length of {{expected}}',
+        object: 'Expected object to have size of {{expected}}',
+        map: 'Expected Map to have size of {{expected}}',
+        set: 'Expected Set to have size of {{expected}}',
+        string: 'Expected string to have length of {{expected}}',
+        not: 'Expected array to not have length of {{expected}}',
+        notObject: 'Expected object to not have size of {{expected}}',
+        notMap: 'Expected Map to not have size of {{expected}}',
+        notSet: 'Expected Set to not have size of {{expected}}',
+        notString: 'Expected string to not have length of {{expected}}'
+    },
+    test: (report) => (actual, expected, message) => {
+        if (Array.isArray(actual)) {
+            if (actual.length === expected) {
+                return report({ message, status: 'ok', expected, actual: actual.length });
+            }
+            return report({ message, status: 'notok', messageId: 'array', expected, actual: actual.length });
+        }
+        if ((0, lodash_1.isPlainObject)(actual)) {
+            if (Object.keys(actual).length === expected) {
+                return report({ message, status: 'ok', messageId: 'notObject', expected, actual: Object.keys(actual).length });
+            }
+            return report({ message, status: 'notok', messageId: 'object', expected, actual: Object.keys(actual).length });
+        }
+        if (actual instanceof Map) {
+            if (actual.size === expected) {
+                return report({ message, status: 'ok', messageId: 'notMap', expected, actual: actual.size });
+            }
+            return report({ message, status: 'notok', messageId: 'map', expected, actual: actual.size });
+        }
+        if (actual instanceof Set) {
+            if (actual.size === expected) {
+                return report({ message, status: 'ok', messageId: 'notSet', expected, actual: actual.size });
+            }
+            return report({ message, status: 'notok', messageId: 'set', expected, actual: actual.size });
+        }
+        if (typeof actual === 'string') {
+            if (actual.length === expected) {
+                return report({ message, status: 'ok', messageId: 'notString', expected, actual: actual.length });
+            }
+            return report({ message, status: 'notok', messageId: 'string', expected, actual: actual.length });
+        }
+    }
+}), exports.hasSize = _a[0], exports.notHasSize = _a[1];
+//# sourceMappingURL=has-size.js.map

package/dist/assert/has-size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-size.js","sourceRoot":"","sources":["../../src/assert/has-size.ts"],"names":[],"mappings":"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"}

package/dist/assert/instance-of.d.ts

@@ -0,0 +1,11 @@
+import { Constructor } from '../utils/process-error';
+declare module '../expect.types' {
+    interface ValueExpect<T> {
+        /**
+         * check if instance of value
+         */
+        instanceOf(constructor: Constructor): this;
+    }
+}
+export declare const instanceOf: (actual: any, expected: Constructor) => true | void, notInstanceOf: (actual: any, expected: Constructor) => true | void;
+//# sourceMappingURL=instance-of.d.ts.map

package/dist/assert/instance-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-of.d.ts","sourceRoot":"","sources":["../../src/assert/instance-of.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,QAAQ,iBAAiB,CAAC;IAC7B,UAAU,WAAW,CAAC,CAAC;QACnB;;WAEG;QACH,UAAU,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;KAC9C;CACJ;AAED,eAAO,MAAO,UAAU,WAKO,GAAG,YAAY,WAAW,kBAL/B,aAAa,WAKR,GAAG,YAAY,WAAW,gBASvD,CAAC"}

package/dist/assert/instance-of.js

@@ -0,0 +1,23 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notInstanceOf = exports.instanceOf = void 0;
+const lodash_1 = require("lodash");
+const assertion_1 = require("../utils/assertion");
+const get_type_1 = require("../utils/get-type");
+_a = (0, assertion_1.createAssertion)({
+    messages: {
+        notInstanceOf: 'Expected {{actual}} to be an instance of {{expected}}',
+        not: 'Expected {{actual}} to not be an instance of {{expected}}'
+    },
+    test: (report) => (actual, expected) => {
+        if (!(0, lodash_1.isObjectLike)(actual)) {
+            throw new assertion_1.AssertionError((0, get_type_1.getType)(actual), 'object', 'Expected value to be an object');
+        }
+        if (!(actual instanceof expected)) {
+            return report({ status: 'notok', messageId: 'notInstanceOf', expected: expected.name, actual: actual.constructor.name, noStringify: true });
+        }
+        return report({ status: 'ok', expected: expected.name, actual: actual.constructor.name, messageId: 'not', noStringify: true });
+    }
+}), exports.instanceOf = _a[0], exports.notInstanceOf = _a[1];
+//# sourceMappingURL=instance-of.js.map

package/dist/assert/instance-of.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-of.js","sourceRoot":"","sources":["../../src/assert/instance-of.ts"],"names":[],"mappings":";;;;AAAA,mCAAsC;AACtC,kDAAqE;AACrE,gDAA4C;AAY/B,KAA8B,IAAA,2BAAe,EAAC;IACvD,QAAQ,EAAE;QACN,aAAa,EAAE,uDAAuD;QACtE,GAAG,EAAE,2DAA2D;KACnE;IACD,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAW,EAAE,QAAqB,EAAE,EAAE;QACrD,IAAI,CAAC,IAAA,qBAAY,EAAC,MAAM,CAAC,EAAE;YACvB,MAAM,IAAI,0BAAc,CAAC,IAAA,kBAAO,EAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,gCAAgC,CAAC,CAAC;SACzF;QACD,IAAI,CAAC,CAAC,MAAM,YAAY,QAAQ,CAAC,EAAE;YAC/B,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;SAC/I;QACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;IACnI,CAAC;CACJ,CAAC,EAdY,kBAAU,UAAE,qBAAa,SAcpC"}

package/dist/assert/is-empty.d.ts

@@ -0,0 +1,2 @@
+export declare const isEmpty: <T>(actual: T, message?: string) => true | void, notIsEmpty: <T>(actual: T, message?: string) => true | void;
+//# sourceMappingURL=is-empty.d.ts.map

package/dist/assert/is-empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty.d.ts","sourceRoot":"","sources":["../../src/assert/is-empty.ts"],"names":[],"mappings":"AAGA,eAAO,MAAO,OAAO,2BAW0B,MAAM,kBAX9B,UAAU,2BAWc,MAAM,gBA0BnD,CAAC"}

package/dist/assert/is-empty.js

@@ -0,0 +1,45 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notIsEmpty = exports.isEmpty = void 0;
+const lodash_1 = require("lodash");
+const assertion_1 = require("../utils/assertion");
+_a = (0, assertion_1.createAssertion)({
+    messages: {
+        array: 'Expected array to be empty',
+        object: 'Expected object to be empty',
+        map: 'Expected Map to be empty',
+        set: 'Expected Set to be empty',
+        not: 'Expected array to not be empty',
+        notObject: 'Expected object to not be empty',
+        notMap: 'Expected Map to not be empty',
+        notSet: 'Expected Set to not be empty'
+    },
+    test: (report) => (actual, message) => {
+        if (Array.isArray(actual)) {
+            if (actual.length === 0) {
+                return report({ message, status: 'ok', actual });
+            }
+            return report({ message, status: 'notok', messageId: 'array', actual });
+        }
+        if ((0, lodash_1.isPlainObject)(actual)) {
+            if (Object.keys(actual).length === 0) {
+                return report({ message, status: 'ok', messageId: 'notObject', actual });
+            }
+            return report({ message, status: 'notok', messageId: 'object', actual });
+        }
+        if (actual instanceof Map) {
+            if (actual.size === 0) {
+                return report({ message, status: 'ok', messageId: 'notMap', actual });
+            }
+            return report({ message, status: 'notok', messageId: 'map', actual });
+        }
+        if (actual instanceof Set) {
+            if (actual.size === 0) {
+                return report({ message, status: 'ok', messageId: 'notSet', actual });
+            }
+            return report({ message, status: 'notok', messageId: 'set', actual });
+        }
+    }
+}), exports.isEmpty = _a[0], exports.notIsEmpty = _a[1];
+//# sourceMappingURL=is-empty.js.map

package/dist/assert/is-empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty.js","sourceRoot":"","sources":["../../src/assert/is-empty.ts"],"names":[],"mappings":";;;;AAAA,mCAAuC;AACvC,kDAAqD;AAExC,KAAwB,IAAA,2BAAe,EAAC;IACjD,QAAQ,EAAE;QACN,KAAK,EAAE,4BAA4B;QACnC,MAAM,EAAE,6BAA6B;QACrC,GAAG,EAAE,0BAA0B;QAC/B,GAAG,EAAE,0BAA0B;QAC/B,GAAG,EAAE,gCAAgC;QACrC,SAAS,EAAE,iCAAiC;QAC5C,MAAM,EAAE,8BAA8B;QACtC,MAAM,EAAE,8BAA8B;KACzC;IACD,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAI,MAAS,EAAE,OAAgB,EAAE,EAAE;QACjD,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACvB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;gBACrB,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;aACpD;YACD,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;SAC3E;QACD,IAAI,IAAA,sBAAa,EAAC,MAAM,CAAC,EAAE;YACvB,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;gBAClC,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC;aAC5E;YACD,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;SAC5E;QACD,IAAI,MAAM,YAAY,GAAG,EAAE;YACvB,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC,EAAE;gBACnB,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;aACzE;YACD,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;SACzE;QACD,IAAI,MAAM,YAAY,GAAG,EAAE;YACvB,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC,EAAE;gBACnB,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;aACzE;YACD,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;SACzE;IACL,CAAC;CACJ,CAAC,EArCY,eAAO,UAAE,kBAAU,SAqC9B"}

package/dist/assert/is-type.d.ts

@@ -0,0 +1,3 @@
+import { ValueType } from '../utils/get-type';
+export declare const isType: (value: any, expectedType: ValueType) => true | void, notIsType: (value: any, expectedType: ValueType) => true | void;
+//# sourceMappingURL=is-type.d.ts.map

package/dist/assert/is-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.d.ts","sourceRoot":"","sources":["../../src/assert/is-type.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAW,MAAM,mBAAmB,CAAC;AAEvD,eAAO,MAAO,MAAM,UAKU,GAAG,gBAAgB,SAAS,kBALpC,SAAS,UAKD,GAAG,gBAAgB,SAAS,gBAOxD,CAAC"}

package/dist/assert/is-type.js

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notIsType = exports.isType = void 0;
+const assertion_1 = require("../utils/assertion");
+const get_type_1 = require("../utils/get-type");
+_a = (0, assertion_1.createAssertion)({
+    messages: {
+        wrongType: 'Expected {{ actual }} to be a(n) {{ expected }}',
+        not: `Expected {{ actual }} to not be a(n) {{ expected }}`
+    },
+    test: (report) => (value, expectedType) => {
+        const actualType = (0, get_type_1.getType)(value);
+        if (actualType !== expectedType) {
+            return report({ status: 'notok', messageId: 'wrongType', actual: actualType, expected: expectedType, noStringify: true });
+        }
+        return report({ status: 'ok', messageId: 'not', actual: actualType, expected: expectedType, noStringify: true });
+    }
+}), exports.isType = _a[0], exports.notIsType = _a[1];
+//# sourceMappingURL=is-type.js.map

package/dist/assert/is-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.js","sourceRoot":"","sources":["../../src/assert/is-type.ts"],"names":[],"mappings":";;;;AAAA,kDAAqD;AACrD,gDAAuD;AAE1C,KAAsB,IAAA,2BAAe,EAAC;IAC/C,QAAQ,EAAE;QACN,SAAS,EAAE,iDAAiD;QAC5D,GAAG,EAAE,qDAAqD;KAC7D;IACD,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAU,EAAE,YAAuB,EAAE,EAAE;QACtD,MAAM,UAAU,GAAG,IAAA,kBAAO,EAAC,KAAK,CAAC,CAAC;QAClC,IAAI,UAAU,KAAK,YAAY,EAAE;YAC7B,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;SAC7H;QACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;IACrH,CAAC;CACJ,CAAC,EAZY,cAAM,UAAE,iBAAS,SAY5B"}

package/dist/assert/less-than-equal.d.ts

@@ -0,0 +1,9 @@
+interface LessThanEqual {
+    /**
+     * check for <=
+     */
+    <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+export declare const lessThanEqual: LessThanEqual, notLessThanEqual: LessThanEqual;
+export {};
+//# sourceMappingURL=less-than-equal.d.ts.map

package/dist/assert/less-than-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-than-equal.d.ts","sourceRoot":"","sources":["../../src/assert/less-than-equal.ts"],"names":[],"mappings":"AAGA,UAAU,aAAa;IACnB;;OAEG;IACH,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtF;AAED,eAAO,MAAO,aAAa,iBAAE,gBAAgB,eAY3C,CAAC"}

package/dist/assert/less-than-equal.js

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notLessThanEqual = exports.lessThanEqual = void 0;
+const assertion_1 = require("../utils/assertion");
+const validate_numeric_and_dates_1 = require("../utils/validate-numeric-and-dates");
+_a = (0, assertion_1.createAssertion)({
+    messages: {
+        lesserThanEqual: 'Expected {{actual}} to be less than or equal to {{expected}}',
+        not: 'Expected {{actual}} to not be less than or equal to {{expected}}'
+    },
+    test: (report) => (actual, expected, message) => {
+        (0, validate_numeric_and_dates_1.validateNumericsAndDates)(actual, expected);
+        if (actual > expected) {
+            return report({ status: 'notok', messageId: 'lesserThanEqual', actual, expected, message, noStringify: true });
+        }
+        return report({ status: 'ok', actual, expected, message, messageId: 'not', noStringify: true });
+    }
+}), exports.lessThanEqual = _a[0], exports.notLessThanEqual = _a[1];
+//# sourceMappingURL=less-than-equal.js.map

package/dist/assert/less-than-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-than-equal.js","sourceRoot":"","sources":["../../src/assert/less-than-equal.ts"],"names":[],"mappings":";;;;AAAA,kDAAqD;AACrD,oFAA+E;AASlE,KAAoC,IAAA,2BAAe,EAAC;IAC7D,QAAQ,EAAE;QACN,eAAe,EAAE,8DAA8D;QAC/E,GAAG,EAAE,kEAAkE;KAC1E;IACD,IAAI,EAAE,CAAC,MAAM,EAAiB,EAAE,CAAC,CAAC,MAAW,EAAE,QAAa,EAAE,OAAgB,EAAE,EAAE;QAC9E,IAAA,qDAAwB,EAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAC3C,IAAI,MAAM,GAAG,QAAQ,EAAE;YACnB,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;SAClH;QACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;IACpG,CAAC;CACJ,CAAC,EAZY,qBAAa,UAAE,wBAAgB,SAY1C"}

package/dist/assert/less-than.d.ts

@@ -0,0 +1,9 @@
+interface LesserThan {
+    /**
+     * check for <
+     */
+    <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+export declare const lessThan: LesserThan, notLessThan: LesserThan;
+export {};
+//# sourceMappingURL=less-than.d.ts.map

package/dist/assert/less-than.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-than.d.ts","sourceRoot":"","sources":["../../src/assert/less-than.ts"],"names":[],"mappings":"AAGA,UAAU,UAAU;IAChB;;OAEG;IACH,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtF;AAED,eAAO,MAAO,QAAQ,cAAE,WAAW,YAYjC,CAAC"}

package/dist/assert/less-than.js

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notLessThan = exports.lessThan = void 0;
+const assertion_1 = require("../utils/assertion");
+const validate_numeric_and_dates_1 = require("../utils/validate-numeric-and-dates");
+_a = (0, assertion_1.createAssertion)({
+    messages: {
+        lesserThan: 'Expected {{actual}} to be less than {{expected}}',
+        not: 'Expected {{actual}} to not be less than {{expected}}'
+    },
+    test: (report) => (actual, expected, message) => {
+        (0, validate_numeric_and_dates_1.validateNumericsAndDates)(actual, expected);
+        if (actual >= expected) {
+            return report({ status: 'notok', messageId: 'lesserThan', actual, expected, message });
+        }
+        return report({ status: 'ok', actual, expected, message, messageId: 'not' });
+    }
+}), exports.lessThan = _a[0], exports.notLessThan = _a[1];
+//# sourceMappingURL=less-than.js.map

package/dist/assert/less-than.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-than.js","sourceRoot":"","sources":["../../src/assert/less-than.ts"],"names":[],"mappings":";;;;AAAA,kDAAqD;AACrD,oFAA+E;AASlE,KAA0B,IAAA,2BAAe,EAAC;IACnD,QAAQ,EAAE;QACN,UAAU,EAAE,kDAAkD;QAC9D,GAAG,EAAE,sDAAsD;KAC9D;IACD,IAAI,EAAE,CAAC,MAAM,EAAc,EAAE,CAAC,CAAC,MAAW,EAAE,QAAa,EAAE,OAAgB,EAAE,EAAE;QAC3E,IAAA,qDAAwB,EAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAC3C,IAAI,MAAM,IAAI,QAAQ,EAAE;YACpB,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;SAC1F;QACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;IACjF,CAAC;CACJ,CAAC,EAZY,gBAAQ,UAAE,mBAAW,SAYhC"}

package/dist/assert/rejects.d.ts

@@ -0,0 +1,2 @@
+export declare const rejects: (promise: Promise<any>, narrowerOrMessage?: any, message?: any) => Promise<true | void>, notRejects: (promise: Promise<any>, narrowerOrMessage?: any, message?: any) => Promise<true | void>;
+//# sourceMappingURL=rejects.d.ts.map

package/dist/assert/rejects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rejects.d.ts","sourceRoot":"","sources":["../../src/assert/rejects.ts"],"names":[],"mappings":"AAGA,eAAO,MAAO,OAAO,YAaiB,QAAQ,GAAG,CAAC,mEAb3B,UAAU,YAaK,QAAQ,GAAG,CAAC,iEAYhD,CAAC"}

package/dist/assert/rejects.js

@@ -0,0 +1,34 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notRejects = exports.rejects = void 0;
+const assertion_1 = require("../utils/assertion");
+const process_error_1 = require("../utils/process-error");
+_a = (0, assertion_1.createAssertion)({
+    messages: {
+        invalidArgument: 'Expected {{actual}} to be a Promise',
+        nonError: 'Expected Promise to reject with an instance of Error',
+        throws: 'Expected Promise to reject',
+        invalidConstructor: 'Expected Promise to reject with {{expected}}',
+        predicate: 'Expected {{actual}} to match predicate function',
+        regex: 'Expected Promise to reject with an error matching {{expected}}',
+        not: 'Expected Promise to not reject',
+        notConstructor: 'Expected Promise to not reject with a {{expected}}',
+        notPredicate: 'Expected {{actual}} to not match predicate function',
+        notRegex: 'Expected Promise to not reject with an error matching {{expected}}'
+    },
+    test: (report) => async (promise, narrowerOrMessage, message) => {
+        // TODO: invalid argument in not case
+        if (!promise || typeof promise.then !== 'function') {
+            return report({ noStringify: true, status: 'notok', messageId: 'invalidArgument', actual: typeof promise, expected: 'Promise' });
+        }
+        try {
+            await promise;
+        }
+        catch (error) {
+            return (0, process_error_1.processError)(report, error, narrowerOrMessage, message);
+        }
+        return report({ noStringify: true, status: 'notok', messageId: 'throws', message: typeof narrowerOrMessage === 'string' ? narrowerOrMessage : message });
+    }
+}), exports.rejects = _a[0], exports.notRejects = _a[1];
+//# sourceMappingURL=rejects.js.map

package/dist/assert/rejects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rejects.js","sourceRoot":"","sources":["../../src/assert/rejects.ts"],"names":[],"mappings":";;;;AAAA,kDAAqD;AACrD,0DAAsD;AAEzC,KAAwB,IAAA,2BAAe,EAAC;IACjD,QAAQ,EAAE;QACN,eAAe,EAAE,qCAAqC;QACtD,QAAQ,EAAE,sDAAsD;QAChE,MAAM,EAAE,4BAA4B;QACpC,kBAAkB,EAAE,8CAA8C;QAClE,SAAS,EAAE,iDAAiD;QAC5D,KAAK,EAAE,gEAAgE;QACvE,GAAG,EAAE,gCAAgC;QACrC,cAAc,EAAE,oDAAoD;QACpE,YAAY,EAAE,qDAAqD;QACnE,QAAQ,EAAE,oEAAoE;KACjF;IACD,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,KAAK,EAAE,OAAqB,EAAE,iBAAkB,EAAE,OAAQ,EAAE,EAAE;QAC5E,qCAAqC;QACrC,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE;YAChD,OAAO,MAAM,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,EAAE,OAAO,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;SACpI;QACD,IAAI;YACA,MAAM,OAAO,CAAC;SACjB;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,IAAA,4BAAY,EAAC,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;SAClE;QACD,OAAO,MAAM,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,iBAAiB,KAAK,QAAQ,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAC7J,CAAC;CACJ,CAAC,EAzBY,eAAO,UAAE,kBAAU,SAyB9B"}

package/dist/assert/throws.d.ts

@@ -0,0 +1,9 @@
+import { Constructor, ErrorPredicate } from '../utils/process-error';
+export declare type ThrowsCallback = () => unknown;
+interface Throw {
+    (callback: ThrowsCallback, message?: string): void;
+    (callback: ThrowsCallback, expectedError: Constructor | RegExp | ErrorPredicate, message?: string): void;
+}
+export declare const throws: Throw, notThrows: Throw;
+export {};
+//# sourceMappingURL=throws.d.ts.map

package/dist/assert/throws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throws.d.ts","sourceRoot":"","sources":["../../src/assert/throws.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAgB,MAAM,wBAAwB,CAAC;AAEnF,oBAAY,cAAc,GAAG,MAAM,OAAO,CAAC;AAE3C,UAAU,KAAK;IACX,CAAC,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,CAAC,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,GAAG,MAAM,GAAG,cAAc,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5G;AAeD,eAAO,MAAO,MAAM,SAAE,SAAS,OAc7B,CAAC"}

package/dist/assert/throws.js

@@ -0,0 +1,35 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notThrows = exports.throws = void 0;
+const assertion_1 = require("../utils/assertion");
+const get_type_1 = require("../utils/get-type");
+const process_error_1 = require("../utils/process-error");
+const messages = {
+    nonError: 'Expected function to throw an instance of Error',
+    throws: 'Expected function to throw',
+    invalidConstructor: 'Expected function to throw {{expected}}',
+    predicate: 'Expected {{actual}} to match predicate function',
+    regex: 'Expected function to throw an error matching {{expected}}',
+    not: 'Expected function to not throw',
+    notConstructor: 'Expected function to not throw a {{expected}}',
+    notPredicate: 'Expected function to not throw an error matching the predicate',
+    notRegex: 'Expected function to not throw an error matching {{expected}}'
+};
+_a = (0, assertion_1.createAssertion)({
+    messages: messages,
+    test: (report) => ((callback, narrowerOrMessage, message) => {
+        const argumentType = (0, get_type_1.getType)(callback);
+        if (argumentType !== 'function') {
+            throw new assertion_1.AssertionError(argumentType, 'function', `Expected ${argumentType} to be a function`);
+        }
+        try {
+            callback();
+        }
+        catch (error) {
+            return (0, process_error_1.processError)(report, error, narrowerOrMessage, message);
+        }
+        return report({ noStringify: true, status: 'notok', messageId: 'throws', message: typeof narrowerOrMessage === 'string' ? narrowerOrMessage : message });
+    })
+}), exports.throws = _a[0], exports.notThrows = _a[1];
+//# sourceMappingURL=throws.js.map

package/dist/assert/throws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throws.js","sourceRoot":"","sources":["../../src/assert/throws.ts"],"names":[],"mappings":";;;;AAAA,kDAAqE;AACrE,gDAA4C;AAC5C,0DAAmF;AAUnF,MAAM,QAAQ,GAAG;IACb,QAAQ,EAAE,iDAAiD;IAC3D,MAAM,EAAE,4BAA4B;IACpC,kBAAkB,EAAE,yCAAyC;IAC7D,SAAS,EAAE,iDAAiD;IAC5D,KAAK,EAAE,2DAA2D;IAClE,GAAG,EAAE,gCAAgC;IACrC,cAAc,EAAE,+CAA+C;IAC/D,YAAY,EAAE,gEAAgE;IAC9E,QAAQ,EAAE,+DAA+D;CAC5E,CAAC;AAEW,KAAsB,IAAA,2BAAe,EAAC;IAC/C,QAAQ,EAAE,QAAQ;IAClB,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,EAAE;QACxD,MAAM,YAAY,GAAG,IAAA,kBAAO,EAAC,QAAQ,CAAC,CAAC;QACvC,IAAI,YAAY,KAAK,UAAU,EAAE;YAC7B,MAAM,IAAI,0BAAc,CAAC,YAAY,EAAE,UAAU,EAAE,YAAa,YAAa,mBAAmB,CAAC,CAAC;SACrG;QACD,IAAI;YACA,QAAQ,EAAE,CAAC;SACd;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,IAAA,4BAAY,EAAC,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;SAClE;QACD,OAAO,MAAM,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,iBAAiB,KAAK,QAAQ,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAC7J,CAAC,CAAU;CACd,CAAC,EAdY,cAAM,UAAE,iBAAS,SAc5B"}

package/dist/assert.d.ts

@@ -0,0 +1,14 @@
+export { eql, notEql } from './assert/eql';
+export { equal, notEqual } from './assert/equal';
+export { greaterThan, notGreaterThan } from './assert/greater-than';
+export { greaterThanEqual, notGreaterThanEqual } from './assert/greater-than-equal';
+export { hasSize, notHasSize } from './assert/has-size';
+export { instanceOf, notInstanceOf } from './assert/instance-of';
+export { isEmpty, notIsEmpty } from './assert/is-empty';
+export { isType, notIsType } from './assert/is-type';
+export { lessThan, notLessThan } from './assert/less-than';
+export { lessThanEqual, notLessThanEqual } from './assert/less-than-equal';
+export { notRejects, rejects } from './assert/rejects';
+export { notThrows, throws } from './assert/throws';
+export declare const assert: () => never;
+//# sourceMappingURL=assert.d.ts.map

package/dist/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../src/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEpD,eAAO,MAAM,MAAM,aAElB,CAAC"}

package/dist/assert.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = exports.throws = exports.notThrows = exports.rejects = exports.notRejects = exports.notLessThanEqual = exports.lessThanEqual = exports.notLessThan = exports.lessThan = exports.notIsType = exports.isType = exports.notIsEmpty = exports.isEmpty = exports.notInstanceOf = exports.instanceOf = exports.notHasSize = exports.hasSize = exports.notGreaterThanEqual = exports.greaterThanEqual = exports.notGreaterThan = exports.greaterThan = exports.notEqual = exports.equal = exports.notEql = exports.eql = void 0;
+var eql_1 = require("./assert/eql");
+Object.defineProperty(exports, "eql", { enumerable: true, get: function () { return eql_1.eql; } });
+Object.defineProperty(exports, "notEql", { enumerable: true, get: function () { return eql_1.notEql; } });
+var equal_1 = require("./assert/equal");
+Object.defineProperty(exports, "equal", { enumerable: true, get: function () { return equal_1.equal; } });
+Object.defineProperty(exports, "notEqual", { enumerable: true, get: function () { return equal_1.notEqual; } });
+var greater_than_1 = require("./assert/greater-than");
+Object.defineProperty(exports, "greaterThan", { enumerable: true, get: function () { return greater_than_1.greaterThan; } });
+Object.defineProperty(exports, "notGreaterThan", { enumerable: true, get: function () { return greater_than_1.notGreaterThan; } });
+var greater_than_equal_1 = require("./assert/greater-than-equal");
+Object.defineProperty(exports, "greaterThanEqual", { enumerable: true, get: function () { return greater_than_equal_1.greaterThanEqual; } });
+Object.defineProperty(exports, "notGreaterThanEqual", { enumerable: true, get: function () { return greater_than_equal_1.notGreaterThanEqual; } });
+var has_size_1 = require("./assert/has-size");
+Object.defineProperty(exports, "hasSize", { enumerable: true, get: function () { return has_size_1.hasSize; } });
+Object.defineProperty(exports, "notHasSize", { enumerable: true, get: function () { return has_size_1.notHasSize; } });
+var instance_of_1 = require("./assert/instance-of");
+Object.defineProperty(exports, "instanceOf", { enumerable: true, get: function () { return instance_of_1.instanceOf; } });
+Object.defineProperty(exports, "notInstanceOf", { enumerable: true, get: function () { return instance_of_1.notInstanceOf; } });
+var is_empty_1 = require("./assert/is-empty");
+Object.defineProperty(exports, "isEmpty", { enumerable: true, get: function () { return is_empty_1.isEmpty; } });
+Object.defineProperty(exports, "notIsEmpty", { enumerable: true, get: function () { return is_empty_1.notIsEmpty; } });
+var is_type_1 = require("./assert/is-type");
+Object.defineProperty(exports, "isType", { enumerable: true, get: function () { return is_type_1.isType; } });
+Object.defineProperty(exports, "notIsType", { enumerable: true, get: function () { return is_type_1.notIsType; } });
+var less_than_1 = require("./assert/less-than");
+Object.defineProperty(exports, "lessThan", { enumerable: true, get: function () { return less_than_1.lessThan; } });
+Object.defineProperty(exports, "notLessThan", { enumerable: true, get: function () { return less_than_1.notLessThan; } });
+var less_than_equal_1 = require("./assert/less-than-equal");
+Object.defineProperty(exports, "lessThanEqual", { enumerable: true, get: function () { return less_than_equal_1.lessThanEqual; } });
+Object.defineProperty(exports, "notLessThanEqual", { enumerable: true, get: function () { return less_than_equal_1.notLessThanEqual; } });
+var rejects_1 = require("./assert/rejects");
+Object.defineProperty(exports, "notRejects", { enumerable: true, get: function () { return rejects_1.notRejects; } });
+Object.defineProperty(exports, "rejects", { enumerable: true, get: function () { return rejects_1.rejects; } });
+var throws_1 = require("./assert/throws");
+Object.defineProperty(exports, "notThrows", { enumerable: true, get: function () { return throws_1.notThrows; } });
+Object.defineProperty(exports, "throws", { enumerable: true, get: function () { return throws_1.throws; } });
+const assert = () => {
+    throw new Error('Not implemented');
+};
+exports.assert = assert;
+//# sourceMappingURL=assert.js.map

package/dist/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","sourceRoot":"","sources":["../src/assert.ts"],"names":[],"mappings":";;;AAAA,oCAA2C;AAAlC,0FAAA,GAAG,OAAA;AAAE,6FAAA,MAAM,OAAA;AACpB,wCAAiD;AAAxC,8FAAA,KAAK,OAAA;AAAE,iGAAA,QAAQ,OAAA;AACxB,sDAAoE;AAA3D,2GAAA,WAAW,OAAA;AAAE,8GAAA,cAAc,OAAA;AACpC,kEAAoF;AAA3E,sHAAA,gBAAgB,OAAA;AAAE,yHAAA,mBAAmB,OAAA;AAC9C,8CAAwD;AAA/C,mGAAA,OAAO,OAAA;AAAE,sGAAA,UAAU,OAAA;AAC5B,oDAAiE;AAAxD,yGAAA,UAAU,OAAA;AAAE,4GAAA,aAAa,OAAA;AAClC,8CAAwD;AAA/C,mGAAA,OAAO,OAAA;AAAE,sGAAA,UAAU,OAAA;AAC5B,4CAAqD;AAA5C,iGAAA,MAAM,OAAA;AAAE,oGAAA,SAAS,OAAA;AAC1B,gDAA2D;AAAlD,qGAAA,QAAQ,OAAA;AAAE,wGAAA,WAAW,OAAA;AAC9B,4DAA2E;AAAlE,gHAAA,aAAa,OAAA;AAAE,mHAAA,gBAAgB,OAAA;AACxC,4CAAuD;AAA9C,qGAAA,UAAU,OAAA;AAAE,kGAAA,OAAO,OAAA;AAC5B,0CAAoD;AAA3C,mGAAA,SAAS,OAAA;AAAE,gGAAA,MAAM,OAAA;AAEnB,MAAM,MAAM,GAAG,GAAG,EAAE;IACvB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;AACvC,CAAC,CAAC;AAFW,QAAA,MAAM,UAEjB"}

package/dist/expect/empty.d.ts

@@ -0,0 +1,10 @@
+declare module '../expect.types' {
+    interface ObjectExpect<T> {
+        /**
+         * check if object/array/Map/Set is empty
+         */
+        empty(message?: string): this;
+    }
+}
+export {};
+//# sourceMappingURL=empty.d.ts.map

package/dist/expect/empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.d.ts","sourceRoot":"","sources":["../../src/expect/empty.ts"],"names":[],"mappings":"AAGA,OAAO,QAAQ,iBAAiB,CAAC;IAC7B,UAAU,YAAY,CAAC,CAAC;QACpB;;WAEG;QACH,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACjC;CACJ"}

package/dist/expect/empty.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("../assert");
+const mixins_1 = require("../mixins");
+(0, mixins_1.use)({
+    empty: {
+        type: 'method',
+        value: ({ value, inverted }) => (message) => {
+            if (inverted) {
+                (0, assert_1.notIsEmpty)(value, message);
+            }
+            else {
+                (0, assert_1.isEmpty)(value, message);
+            }
+        }
+    }
+});
+//# sourceMappingURL=empty.js.map

package/dist/expect/empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.js","sourceRoot":"","sources":["../../src/expect/empty.ts"],"names":[],"mappings":";;AAAA,sCAAgD;AAChD,sCAAgC;AAWhC,IAAA,YAAG,EAAC;IACA,KAAK,EAAE;QACH,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC,OAAgB,EAAE,EAAE;YACjD,IAAI,QAAQ,EAAE;gBACV,IAAA,mBAAU,EAAC,KAAK,EAAE,OAAO,CAAC,CAAC;aAC9B;iBAAM;gBACH,IAAA,gBAAO,EAAC,KAAK,EAAE,OAAO,CAAC,CAAC;aAC3B;QACL,CAAC;KACJ;CACJ,CAAC,CAAC"}

package/dist/expect/eql.d.ts

@@ -0,0 +1,10 @@
+declare module '../expect.types' {
+    interface ValueExpect<T> {
+        /**
+         * check for deep equality
+         */
+        eql(value: T): this;
+    }
+}
+export {};
+//# sourceMappingURL=eql.d.ts.map

package/dist/expect/eql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eql.d.ts","sourceRoot":"","sources":["../../src/expect/eql.ts"],"names":[],"mappings":"AAGA,OAAO,QAAQ,iBAAiB,CAAC;IAC7B,UAAU,WAAW,CAAC,CAAC;QACnB;;WAEG;QACH,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;KACvB;CACJ"}

package/dist/expect/eql.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("../assert");
+const mixins_1 = require("../mixins");
+(0, mixins_1.use)({
+    eql: {
+        type: 'method',
+        value: ({ value, inverted }) => (other) => {
+            if (inverted) {
+                (0, assert_1.notEql)(value, other);
+            }
+            else {
+                (0, assert_1.eql)(value, other);
+            }
+        }
+    }
+});
+//# sourceMappingURL=eql.js.map

package/dist/expect/eql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eql.js","sourceRoot":"","sources":["../../src/expect/eql.ts"],"names":[],"mappings":";;AAAA,sCAAwC;AACxC,sCAAgC;AAWhC,IAAA,YAAG,EAAC;IACA,GAAG,EAAE;QACD,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC,KAAU,EAAE,EAAE;YAC3C,IAAI,QAAQ,EAAE;gBACV,IAAA,eAAM,EAAC,KAAK,EAAE,KAAK,CAAC,CAAC;aACxB;iBAAM;gBACH,IAAA,YAAG,EAAC,KAAK,EAAE,KAAK,CAAC,CAAC;aACrB;QACL,CAAC;KACJ;CACJ,CAAC,CAAC"}

package/dist/expect/equal-shorthand.d.ts

@@ -0,0 +1,14 @@
+declare module '../expect.types' {
+    interface BooleanExpect<T> {
+        /**
+         * check if value is true
+         */
+        true(): this;
+        /**
+         * check if value is false
+         */
+        false(): this;
+    }
+}
+export {};
+//# sourceMappingURL=equal-shorthand.d.ts.map

package/dist/expect/equal-shorthand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal-shorthand.d.ts","sourceRoot":"","sources":["../../src/expect/equal-shorthand.ts"],"names":[],"mappings":"AAIA,OAAO,QAAQ,iBAAiB,CAAC;IAE7B,UAAU,aAAa,CAAC,CAAC;QACrB;;WAEG;QACH,IAAI,IAAI,IAAI,CAAC;QACb;;WAEG;QACH,KAAK,IAAI,IAAI,CAAC;KACjB;CACJ"}