hein 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/assert/in-ballpark.js

@@ -0,0 +1,41 @@
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/in-ballpark.ts
+const [inBallpark, notInBallpark] = createAssertion({
+	messages: {
+		miss: "Expected {{= it.actual }} to be in ballpark of {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be in ballpark of {{= it.expected }}",
+		invalidMultiplier: "Expected multiplier to be between 0 and 1"
+	},
+	test: (report) => (actual, expected, allowedDifference = .1) => {
+		const absActual = Math.abs(actual);
+		const absExpected = Math.abs(expected);
+		if (allowedDifference <= 0 || allowedDifference >= 1) {
+			report({
+				status: "ok",
+				messageId: "invalidMultiplier",
+				actual: allowedDifference
+			});
+			return report({
+				status: "notok",
+				messageId: "invalidMultiplier",
+				actual: allowedDifference
+			});
+		}
+		if (absActual <= absExpected * (1 + allowedDifference) && absActual >= absExpected * (1 - allowedDifference)) return report({
+			status: "ok",
+			expected,
+			actual
+		});
+		return report({
+			status: "notok",
+			messageId: "miss",
+			expected,
+			actual
+		});
+	}
+});
+
+//#endregion
+export { inBallpark, notInBallpark };
+//# sourceMappingURL=in-ballpark.js.map

package/dist/assert/in-ballpark.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-ballpark.js","names":[],"sources":["../../src/assert/in-ballpark.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface InBallpark {\n    /**\n     * check if a number is in ballpark of another number. See also roundTo\n     * @param actual\n     * @param expected\n     * @param [allowedDifferenceMultiplier=0.1] - a number between 0 and 1 (exclusive). 0.1 (default) means 10% difference is allowed.\n     * @example inBallpark(1, 1.1);\n     * @example inBallpark(1, 1.1, 0.1);\n     */\n    (actual: number, expected: number, allowedDifferenceMultiplier?: number): void;\n}\n\nexport const [inBallpark, notInBallpark] = createAssertion({\n    messages: {\n        miss: 'Expected {{= it.actual }} to be in ballpark of {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be in ballpark of {{= it.expected }}',\n        invalidMultiplier: 'Expected multiplier to be between 0 and 1'\n    },\n    test:\n        (report): InBallpark =>\n        (actual: number, expected: number, allowedDifference = 0.1) => {\n            const absActual = Math.abs(actual);\n            const absExpected = Math.abs(expected);\n            if (allowedDifference <= 0 || allowedDifference >= 1) {\n                report({ status: 'ok', messageId: 'invalidMultiplier', actual: allowedDifference });\n                return report({ status: 'notok', messageId: 'invalidMultiplier', actual: allowedDifference });\n            }\n            if (\n                absActual <= absExpected * (1 + allowedDifference) &&\n                absActual >= absExpected * (1 - allowedDifference)\n            ) {\n                return report({ status: 'ok', expected, actual });\n            }\n            return report({ status: 'notok', messageId: 'miss', expected, actual });\n        }\n});\n"],"mappings":";;;AAcA,MAAa,CAAC,YAAY,iBAAiB,gBAAgB;CACvD,UAAU;EACN,MAAM;EACN,KAAK;EACL,mBAAmB;EACtB;CACD,OACK,YACA,QAAgB,UAAkB,oBAAoB,OAAQ;EAC3D,MAAM,YAAY,KAAK,IAAI,OAAO;EAClC,MAAM,cAAc,KAAK,IAAI,SAAS;AACtC,MAAI,qBAAqB,KAAK,qBAAqB,GAAG;AAClD,UAAO;IAAE,QAAQ;IAAM,WAAW;IAAqB,QAAQ;IAAmB,CAAC;AACnF,UAAO,OAAO;IAAE,QAAQ;IAAS,WAAW;IAAqB,QAAQ;IAAmB,CAAC;;AAEjG,MACI,aAAa,eAAe,IAAI,sBAChC,aAAa,eAAe,IAAI,mBAEhC,QAAO,OAAO;GAAE,QAAQ;GAAM;GAAU;GAAQ,CAAC;AAErD,SAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAQ;GAAU;GAAQ,CAAC;;CAElF,CAAC"}

package/dist/assert/includes.cjs

@@ -0,0 +1,30 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/assert/includes.ts
+const [includes, notIncludes] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		arrayMisses: "Expected {{= it.actual }} to include {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not include {{= it.expected }}"
+	},
+	test: (report) => (actual, ...elements) => {
+		for (const element of elements) if (actual.includes(element)) report({
+			messageId: "not",
+			status: "ok",
+			actual,
+			expected: element
+		});
+		else report({
+			messageId: "arrayMisses",
+			status: "notok",
+			actual,
+			expected: element
+		});
+	}
+});
+
+//#endregion
+exports.includes = includes;
+exports.notIncludes = notIncludes;
+//# sourceMappingURL=includes.cjs.map

package/dist/assert/includes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.cjs","names":[],"sources":["../../src/assert/includes.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface Includes {\n    /**\n     * check if array includes a specific element\n     * @param array\n     * @param element\n     * @example includes([1, 2, 3], 2);\n     * @example includes([1, 2, 3], 2, 3);\n     */\n    <T>(array: T[], ...elements: T[]): void;\n    /**\n     * check if string includes a specific string\n     * @param string\n     * @param element\n     * @example includes('abc', 'b');\n     * @example includes('abc', 'b', 'c');\n     * @example includes('abc', 'bc');\n     */\n    (string: string, ...elements: string[]): void;\n}\n\nexport const [includes, notIncludes] = createAssertion({\n    messages: {\n        arrayMisses: 'Expected {{= it.actual }} to include {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not include {{= it.expected }}'\n    },\n    test:\n        (report): Includes =>\n        (actual: string | any[], ...elements) => {\n            for (const element of elements) {\n                if (actual.includes(element)) {\n                    report({\n                        messageId: 'not',\n                        status: 'ok',\n                        actual,\n                        expected: element\n                    });\n                } else {\n                    report({\n                        messageId: 'arrayMisses',\n                        status: 'notok',\n                        actual,\n                        expected: element\n                    });\n                }\n            }\n        }\n});\n"],"mappings":";;;;;AAsBA,MAAa,CAAC,UAAU,yDAA+B;CACnD,UAAU;EACN,aAAa;EACb,KAAK;EACR;CACD,OACK,YACA,QAAwB,GAAG,aAAa;AACrC,OAAK,MAAM,WAAW,SAClB,KAAI,OAAO,SAAS,QAAQ,CACxB,QAAO;GACH,WAAW;GACX,QAAQ;GACR;GACA,UAAU;GACb,CAAC;MAEF,QAAO;GACH,WAAW;GACX,QAAQ;GACR;GACA,UAAU;GACb,CAAC;;CAIrB,CAAC"}

package/dist/assert/includes.d.cts

@@ -0,0 +1,24 @@
+//#region src/assert/includes.d.ts
+interface Includes {
+  /**
+   * check if array includes a specific element
+   * @param array
+   * @param element
+   * @example includes([1, 2, 3], 2);
+   * @example includes([1, 2, 3], 2, 3);
+   */
+  <T>(array: T[], ...elements: T[]): void;
+  /**
+   * check if string includes a specific string
+   * @param string
+   * @param element
+   * @example includes('abc', 'b');
+   * @example includes('abc', 'b', 'c');
+   * @example includes('abc', 'bc');
+   */
+  (string: string, ...elements: string[]): void;
+}
+declare const includes: Includes, notIncludes: Includes;
+//#endregion
+export { includes, notIncludes };
+//# sourceMappingURL=includes.d.cts.map

package/dist/assert/includes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.d.cts","names":[],"sources":["../../src/assert/includes.ts"],"sourcesContent":[],"mappings":";UAEU,QAAA;EAAA;;;;;AAoBV;;KAAsB,CAAA,KAAA,EAZP,CAYO,EAAA,EAAA,GAAA,QAAA,EAZW,CAYX,EAAA,CAAA,EAAA,IAAA;;;;;;;;;;;cAAR,UAAQ,uBAAa"}

package/dist/assert/includes.d.ts

@@ -0,0 +1,24 @@
+//#region src/assert/includes.d.ts
+interface Includes {
+  /**
+   * check if array includes a specific element
+   * @param array
+   * @param element
+   * @example includes([1, 2, 3], 2);
+   * @example includes([1, 2, 3], 2, 3);
+   */
+  <T>(array: T[], ...elements: T[]): void;
+  /**
+   * check if string includes a specific string
+   * @param string
+   * @param element
+   * @example includes('abc', 'b');
+   * @example includes('abc', 'b', 'c');
+   * @example includes('abc', 'bc');
+   */
+  (string: string, ...elements: string[]): void;
+}
+declare const includes: Includes, notIncludes: Includes;
+//#endregion
+export { includes, notIncludes };
+//# sourceMappingURL=includes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"includes.d.ts","names":[],"sources":["../../src/assert/includes.ts"],"sourcesContent":[],"mappings":";UAEU,QAAA;EAAA;;;;;AAoBV;;KAAsB,CAAA,KAAA,EAZP,CAYO,EAAA,EAAA,GAAA,QAAA,EAZW,CAYX,EAAA,CAAA,EAAA,IAAA;;;;;;;;;;;cAAR,UAAQ,uBAAa"}

package/dist/assert/includes.js

@@ -0,0 +1,27 @@
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/includes.ts
+const [includes, notIncludes] = createAssertion({
+	messages: {
+		arrayMisses: "Expected {{= it.actual }} to include {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not include {{= it.expected }}"
+	},
+	test: (report) => (actual, ...elements) => {
+		for (const element of elements) if (actual.includes(element)) report({
+			messageId: "not",
+			status: "ok",
+			actual,
+			expected: element
+		});
+		else report({
+			messageId: "arrayMisses",
+			status: "notok",
+			actual,
+			expected: element
+		});
+	}
+});
+
+//#endregion
+export { includes, notIncludes };
+//# sourceMappingURL=includes.js.map

package/dist/assert/includes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.js","names":[],"sources":["../../src/assert/includes.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface Includes {\n    /**\n     * check if array includes a specific element\n     * @param array\n     * @param element\n     * @example includes([1, 2, 3], 2);\n     * @example includes([1, 2, 3], 2, 3);\n     */\n    <T>(array: T[], ...elements: T[]): void;\n    /**\n     * check if string includes a specific string\n     * @param string\n     * @param element\n     * @example includes('abc', 'b');\n     * @example includes('abc', 'b', 'c');\n     * @example includes('abc', 'bc');\n     */\n    (string: string, ...elements: string[]): void;\n}\n\nexport const [includes, notIncludes] = createAssertion({\n    messages: {\n        arrayMisses: 'Expected {{= it.actual }} to include {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not include {{= it.expected }}'\n    },\n    test:\n        (report): Includes =>\n        (actual: string | any[], ...elements) => {\n            for (const element of elements) {\n                if (actual.includes(element)) {\n                    report({\n                        messageId: 'not',\n                        status: 'ok',\n                        actual,\n                        expected: element\n                    });\n                } else {\n                    report({\n                        messageId: 'arrayMisses',\n                        status: 'notok',\n                        actual,\n                        expected: element\n                    });\n                }\n            }\n        }\n});\n"],"mappings":";;;AAsBA,MAAa,CAAC,UAAU,eAAe,gBAAgB;CACnD,UAAU;EACN,aAAa;EACb,KAAK;EACR;CACD,OACK,YACA,QAAwB,GAAG,aAAa;AACrC,OAAK,MAAM,WAAW,SAClB,KAAI,OAAO,SAAS,QAAQ,CACxB,QAAO;GACH,WAAW;GACX,QAAQ;GACR;GACA,UAAU;GACb,CAAC;MAEF,QAAO;GACH,WAAW;GACX,QAAQ;GACR;GACA,UAAU;GACb,CAAC;;CAIrB,CAAC"}

package/dist/assert/instance-of.cjs

@@ -0,0 +1,36 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_get_type = require('../utils/get-type.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+let lodash_isObjectLike_js = require("lodash/isObjectLike.js");
+lodash_isObjectLike_js = require_rolldown_runtime.__toESM(lodash_isObjectLike_js);
+
+//#region src/assert/instance-of.ts
+const [instanceOf, notInstanceOf] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		notInstanceOf: "Expected {{= it.actual }} to be an instance of {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be an instance of {{= it.expected }}"
+	},
+	test: (report) => (actual, expected) => {
+		if (!(0, lodash_isObjectLike_js.default)(actual)) throw new hein_assertion_utils.AssertionError(require_get_type.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
+		});
+	}
+});
+
+//#endregion
+exports.instanceOf = instanceOf;
+exports.notInstanceOf = notInstanceOf;
+//# sourceMappingURL=instance-of.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instance-of.cjs","names":["AssertionError","getType"],"sources":["../../src/assert/instance-of.ts"],"sourcesContent":["import isObjectLike from 'lodash/isObjectLike.js';\nimport { AssertionError, createAssertion } from 'hein-assertion-utils';\nimport { getType } from '../utils/get-type.js';\nimport { type Constructor } from '../utils/process-error.js';\n\ninterface InstanceOf {\n    /**\n     * check if value is an instance of a constructor\n     * @param value\n     * @param constructor\n     * @example instanceOf(new Error(), Error);\n     */\n    <T extends Constructor>(value: InstanceType<T>, constructor: T): void;\n}\n\nexport const [instanceOf, notInstanceOf] = createAssertion({\n    messages: {\n        notInstanceOf: 'Expected {{= it.actual }} to be an instance of {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be an instance of {{= it.expected }}'\n    },\n    test:\n        (report): InstanceOf =>\n        (actual: any, expected: Constructor) => {\n            if (!isObjectLike(actual)) {\n                throw new AssertionError(getType(actual), 'object', 'Expected value to be an object');\n            }\n            if (!(actual instanceof expected)) {\n                return report({\n                    status: 'notok',\n                    messageId: 'notInstanceOf',\n                    expected: expected.name,\n                    actual: actual.constructor.name,\n                    noStringify: true\n                });\n            }\n            return report({\n                status: 'ok',\n                expected: expected.name,\n                actual: actual.constructor.name,\n                messageId: 'not',\n                noStringify: true\n            });\n        }\n});\n"],"mappings":";;;;;;;;AAeA,MAAa,CAAC,YAAY,2DAAiC;CACvD,UAAU;EACN,eAAe;EACf,KAAK;EACR;CACD,OACK,YACA,QAAa,aAA0B;AACpC,MAAI,qCAAc,OAAO,CACrB,OAAM,IAAIA,oCAAeC,yBAAQ,OAAO,EAAE,UAAU,iCAAiC;AAEzF,MAAI,EAAE,kBAAkB,UACpB,QAAO,OAAO;GACV,QAAQ;GACR,WAAW;GACX,UAAU,SAAS;GACnB,QAAQ,OAAO,YAAY;GAC3B,aAAa;GAChB,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR,UAAU,SAAS;GACnB,QAAQ,OAAO,YAAY;GAC3B,WAAW;GACX,aAAa;GAChB,CAAC;;CAEb,CAAC"}

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

@@ -0,0 +1,16 @@
+import { Constructor } from "../utils/process-error.cjs";
+
+//#region src/assert/instance-of.d.ts
+interface InstanceOf {
+  /**
+   * check if value is an instance of a constructor
+   * @param value
+   * @param constructor
+   * @example instanceOf(new Error(), Error);
+   */
+  <T extends Constructor>(value: InstanceType<T>, constructor: T): void;
+}
+declare const instanceOf: InstanceOf, notInstanceOf: InstanceOf;
+//#endregion
+export { instanceOf, notInstanceOf };
+//# sourceMappingURL=instance-of.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instance-of.d.cts","names":[],"sources":["../../src/assert/instance-of.ts"],"sourcesContent":[],"mappings":";;;UAKU,UAAA;;AAFmD;;;;;aAS9C,WAAkD,CAAA,CAAA,KAAA,EAA9B,YAA8B,CAAjB,CAAiB,CAAA,EAAA,WAAA,EAAA,CAAA,CAAA,EAAA,IAAA;;AAGnD,cAAA,UAAU,EAAA,UAAA,EAAA,aAAA,EAAe,UAAf"}

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

@@ -0,0 +1,16 @@
+import { Constructor } from "../utils/process-error.js";
+
+//#region src/assert/instance-of.d.ts
+interface InstanceOf {
+  /**
+   * check if value is an instance of a constructor
+   * @param value
+   * @param constructor
+   * @example instanceOf(new Error(), Error);
+   */
+  <T extends Constructor>(value: InstanceType<T>, constructor: T): void;
+}
+declare const instanceOf: InstanceOf, notInstanceOf: InstanceOf;
+//#endregion
+export { instanceOf, notInstanceOf };
+//# sourceMappingURL=instance-of.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instance-of.d.ts","names":[],"sources":["../../src/assert/instance-of.ts"],"sourcesContent":[],"mappings":";;;UAKU,UAAA;;AAFmD;;;;;aAS9C,WAAkD,CAAA,CAAA,KAAA,EAA9B,YAA8B,CAAjB,CAAiB,CAAA,EAAA,WAAA,EAAA,CAAA,CAAA,EAAA,IAAA;;AAGnD,cAAA,UAAU,EAAA,UAAA,EAAA,aAAA,EAAe,UAAf"}

package/dist/assert/instance-of.js

@@ -0,0 +1,32 @@
+import { getType } from "../utils/get-type.js";
+import { AssertionError, createAssertion } from "hein-assertion-utils";
+import isObjectLike from "lodash/isObjectLike.js";
+
+//#region src/assert/instance-of.ts
+const [instanceOf, notInstanceOf] = createAssertion({
+	messages: {
+		notInstanceOf: "Expected {{= it.actual }} to be an instance of {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be an instance of {{= it.expected }}"
+	},
+	test: (report) => (actual, expected) => {
+		if (!isObjectLike(actual)) throw new AssertionError(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
+		});
+	}
+});
+
+//#endregion
+export { instanceOf, notInstanceOf };
+//# sourceMappingURL=instance-of.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instance-of.js","names":[],"sources":["../../src/assert/instance-of.ts"],"sourcesContent":["import isObjectLike from 'lodash/isObjectLike.js';\nimport { AssertionError, createAssertion } from 'hein-assertion-utils';\nimport { getType } from '../utils/get-type.js';\nimport { type Constructor } from '../utils/process-error.js';\n\ninterface InstanceOf {\n    /**\n     * check if value is an instance of a constructor\n     * @param value\n     * @param constructor\n     * @example instanceOf(new Error(), Error);\n     */\n    <T extends Constructor>(value: InstanceType<T>, constructor: T): void;\n}\n\nexport const [instanceOf, notInstanceOf] = createAssertion({\n    messages: {\n        notInstanceOf: 'Expected {{= it.actual }} to be an instance of {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be an instance of {{= it.expected }}'\n    },\n    test:\n        (report): InstanceOf =>\n        (actual: any, expected: Constructor) => {\n            if (!isObjectLike(actual)) {\n                throw new AssertionError(getType(actual), 'object', 'Expected value to be an object');\n            }\n            if (!(actual instanceof expected)) {\n                return report({\n                    status: 'notok',\n                    messageId: 'notInstanceOf',\n                    expected: expected.name,\n                    actual: actual.constructor.name,\n                    noStringify: true\n                });\n            }\n            return report({\n                status: 'ok',\n                expected: expected.name,\n                actual: actual.constructor.name,\n                messageId: 'not',\n                noStringify: true\n            });\n        }\n});\n"],"mappings":";;;;;AAeA,MAAa,CAAC,YAAY,iBAAiB,gBAAgB;CACvD,UAAU;EACN,eAAe;EACf,KAAK;EACR;CACD,OACK,YACA,QAAa,aAA0B;AACpC,MAAI,CAAC,aAAa,OAAO,CACrB,OAAM,IAAI,eAAe,QAAQ,OAAO,EAAE,UAAU,iCAAiC;AAEzF,MAAI,EAAE,kBAAkB,UACpB,QAAO,OAAO;GACV,QAAQ;GACR,WAAW;GACX,UAAU,SAAS;GACnB,QAAQ,OAAO,YAAY;GAC3B,aAAa;GAChB,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR,UAAU,SAAS;GACnB,QAAQ,OAAO,YAAY;GAC3B,WAAW;GACX,aAAa;GAChB,CAAC;;CAEb,CAAC"}

package/dist/assert/is-after.cjs

@@ -0,0 +1,29 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/assert/is-after.ts
+const [isAfter, notAfter] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		before: "Expected {{= it.actual }} to be after {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be after {{= it.expected }}"
+	},
+	test: (report) => (actual, expected) => {
+		if (actual <= expected) return report({
+			messageId: "before",
+			status: "notok",
+			actual,
+			expected
+		});
+		return report({
+			status: "ok",
+			actual,
+			expected
+		});
+	}
+});
+
+//#endregion
+exports.isAfter = isAfter;
+exports.notAfter = notAfter;
+//# sourceMappingURL=is-after.cjs.map

package/dist/assert/is-after.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-after.cjs","names":[],"sources":["../../src/assert/is-after.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface IsAfter {\n    /**\n     * check that date is after another date\n     */\n    <T extends Date>(actual: T, expected: T): void;\n}\n\nexport const [isAfter, notAfter] = createAssertion({\n    messages: {\n        before: 'Expected {{= it.actual }} to be after {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be after {{= it.expected }}'\n    },\n    test:\n        (report): IsAfter =>\n        (actual: Date, expected: Date) => {\n            if (actual <= expected) {\n                return report({\n                    messageId: 'before',\n                    status: 'notok',\n                    actual,\n                    expected\n                });\n            }\n            return report({\n                status: 'ok',\n                actual,\n                expected\n            });\n        }\n});\n"],"mappings":";;;;;AASA,MAAa,CAAC,SAAS,sDAA4B;CAC/C,UAAU;EACN,QAAQ;EACR,KAAK;EACR;CACD,OACK,YACA,QAAc,aAAmB;AAC9B,MAAI,UAAU,SACV,QAAO,OAAO;GACV,WAAW;GACX,QAAQ;GACR;GACA;GACH,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR;GACA;GACH,CAAC;;CAEb,CAAC"}

package/dist/assert/is-after.d.cts

@@ -0,0 +1,11 @@
+//#region src/assert/is-after.d.ts
+interface IsAfter {
+  /**
+   * check that date is after another date
+   */
+  <T extends Date>(actual: T, expected: T): void;
+}
+declare const isAfter: IsAfter, notAfter: IsAfter;
+//#endregion
+export { isAfter, notAfter };
+//# sourceMappingURL=is-after.d.cts.map

package/dist/assert/is-after.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-after.d.cts","names":[],"sources":["../../src/assert/is-after.ts"],"sourcesContent":[],"mappings":";UAEU,OAAA;EAAA;;;aAIK,IAAc,CAAA,CAAA,MAAA,EAAA,CAAA,EAAA,QAAA,EAAa,CAAb,CAAA,EAAA,IAAA;;AAAc,cAG7B,OAH6B,EAGtB,OAHsB,EAAA,QAAA,EAGZ,OAHY"}

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

@@ -0,0 +1,11 @@
+//#region src/assert/is-after.d.ts
+interface IsAfter {
+  /**
+   * check that date is after another date
+   */
+  <T extends Date>(actual: T, expected: T): void;
+}
+declare const isAfter: IsAfter, notAfter: IsAfter;
+//#endregion
+export { isAfter, notAfter };
+//# sourceMappingURL=is-after.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-after.d.ts","names":[],"sources":["../../src/assert/is-after.ts"],"sourcesContent":[],"mappings":";UAEU,OAAA;EAAA;;;aAIK,IAAc,CAAA,CAAA,MAAA,EAAA,CAAA,EAAA,QAAA,EAAa,CAAb,CAAA,EAAA,IAAA;;AAAc,cAG7B,OAH6B,EAGtB,OAHsB,EAAA,QAAA,EAGZ,OAHY"}

package/dist/assert/is-after.js

@@ -0,0 +1,26 @@
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/is-after.ts
+const [isAfter, notAfter] = createAssertion({
+	messages: {
+		before: "Expected {{= it.actual }} to be after {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be after {{= it.expected }}"
+	},
+	test: (report) => (actual, expected) => {
+		if (actual <= expected) return report({
+			messageId: "before",
+			status: "notok",
+			actual,
+			expected
+		});
+		return report({
+			status: "ok",
+			actual,
+			expected
+		});
+	}
+});
+
+//#endregion
+export { isAfter, notAfter };
+//# sourceMappingURL=is-after.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-after.js","names":[],"sources":["../../src/assert/is-after.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface IsAfter {\n    /**\n     * check that date is after another date\n     */\n    <T extends Date>(actual: T, expected: T): void;\n}\n\nexport const [isAfter, notAfter] = createAssertion({\n    messages: {\n        before: 'Expected {{= it.actual }} to be after {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be after {{= it.expected }}'\n    },\n    test:\n        (report): IsAfter =>\n        (actual: Date, expected: Date) => {\n            if (actual <= expected) {\n                return report({\n                    messageId: 'before',\n                    status: 'notok',\n                    actual,\n                    expected\n                });\n            }\n            return report({\n                status: 'ok',\n                actual,\n                expected\n            });\n        }\n});\n"],"mappings":";;;AASA,MAAa,CAAC,SAAS,YAAY,gBAAgB;CAC/C,UAAU;EACN,QAAQ;EACR,KAAK;EACR;CACD,OACK,YACA,QAAc,aAAmB;AAC9B,MAAI,UAAU,SACV,QAAO,OAAO;GACV,WAAW;GACX,QAAQ;GACR;GACA;GACH,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR;GACA;GACH,CAAC;;CAEb,CAAC"}

package/dist/assert/is-before.cjs

@@ -0,0 +1,29 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/assert/is-before.ts
+const [isBefore, notBefore] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		after: "Expected {{= it.actual }} to be before {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be before {{= it.expected }}"
+	},
+	test: (report) => (actual, expected) => {
+		if (actual >= expected) return report({
+			messageId: "after",
+			status: "notok",
+			actual,
+			expected
+		});
+		return report({
+			status: "ok",
+			actual,
+			expected
+		});
+	}
+});
+
+//#endregion
+exports.isBefore = isBefore;
+exports.notBefore = notBefore;
+//# sourceMappingURL=is-before.cjs.map

package/dist/assert/is-before.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-before.cjs","names":[],"sources":["../../src/assert/is-before.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface IsBefore {\n    /**\n     * check that date is before another date\n     */\n    <T extends Date>(actual: T, expected: T, message?: string): void;\n}\n\nexport const [isBefore, notBefore] = createAssertion({\n    messages: {\n        after: 'Expected {{= it.actual }} to be before {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be before {{= it.expected }}'\n    },\n    test:\n        (report): IsBefore =>\n        (actual: Date, expected: Date) => {\n            if (actual >= expected) {\n                return report({\n                    messageId: 'after',\n                    status: 'notok',\n                    actual,\n                    expected\n                });\n            }\n            return report({\n                status: 'ok',\n                actual,\n                expected\n            });\n        }\n});\n"],"mappings":";;;;;AASA,MAAa,CAAC,UAAU,uDAA6B;CACjD,UAAU;EACN,OAAO;EACP,KAAK;EACR;CACD,OACK,YACA,QAAc,aAAmB;AAC9B,MAAI,UAAU,SACV,QAAO,OAAO;GACV,WAAW;GACX,QAAQ;GACR;GACA;GACH,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR;GACA;GACH,CAAC;;CAEb,CAAC"}

package/dist/assert/is-before.d.cts

@@ -0,0 +1,11 @@
+//#region src/assert/is-before.d.ts
+interface IsBefore {
+  /**
+   * check that date is before another date
+   */
+  <T extends Date>(actual: T, expected: T, message?: string): void;
+}
+declare const isBefore: IsBefore, notBefore: IsBefore;
+//#endregion
+export { isBefore, notBefore };
+//# sourceMappingURL=is-before.d.cts.map

package/dist/assert/is-before.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-before.d.cts","names":[],"sources":["../../src/assert/is-before.ts"],"sourcesContent":[],"mappings":";UAEU,QAAA;EAAA;;;aAIK,IAAc,CAAA,CAAA,MAAA,EAAA,CAAA,EAAA,QAAA,EAAa,CAAb,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;AAAc,cAG7B,QAH6B,EAGrB,QAHqB,EAAA,SAAA,EAGV,QAHU"}

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

@@ -0,0 +1,11 @@
+//#region src/assert/is-before.d.ts
+interface IsBefore {
+  /**
+   * check that date is before another date
+   */
+  <T extends Date>(actual: T, expected: T, message?: string): void;
+}
+declare const isBefore: IsBefore, notBefore: IsBefore;
+//#endregion
+export { isBefore, notBefore };
+//# sourceMappingURL=is-before.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-before.d.ts","names":[],"sources":["../../src/assert/is-before.ts"],"sourcesContent":[],"mappings":";UAEU,QAAA;EAAA;;;aAIK,IAAc,CAAA,CAAA,MAAA,EAAA,CAAA,EAAA,QAAA,EAAa,CAAb,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;AAAc,cAG7B,QAH6B,EAGrB,QAHqB,EAAA,SAAA,EAGV,QAHU"}

package/dist/assert/is-before.js

@@ -0,0 +1,26 @@
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/is-before.ts
+const [isBefore, notBefore] = createAssertion({
+	messages: {
+		after: "Expected {{= it.actual }} to be before {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be before {{= it.expected }}"
+	},
+	test: (report) => (actual, expected) => {
+		if (actual >= expected) return report({
+			messageId: "after",
+			status: "notok",
+			actual,
+			expected
+		});
+		return report({
+			status: "ok",
+			actual,
+			expected
+		});
+	}
+});
+
+//#endregion
+export { isBefore, notBefore };
+//# sourceMappingURL=is-before.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-before.js","names":[],"sources":["../../src/assert/is-before.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface IsBefore {\n    /**\n     * check that date is before another date\n     */\n    <T extends Date>(actual: T, expected: T, message?: string): void;\n}\n\nexport const [isBefore, notBefore] = createAssertion({\n    messages: {\n        after: 'Expected {{= it.actual }} to be before {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be before {{= it.expected }}'\n    },\n    test:\n        (report): IsBefore =>\n        (actual: Date, expected: Date) => {\n            if (actual >= expected) {\n                return report({\n                    messageId: 'after',\n                    status: 'notok',\n                    actual,\n                    expected\n                });\n            }\n            return report({\n                status: 'ok',\n                actual,\n                expected\n            });\n        }\n});\n"],"mappings":";;;AASA,MAAa,CAAC,UAAU,aAAa,gBAAgB;CACjD,UAAU;EACN,OAAO;EACP,KAAK;EACR;CACD,OACK,YACA,QAAc,aAAmB;AAC9B,MAAI,UAAU,SACV,QAAO,OAAO;GACV,WAAW;GACX,QAAQ;GACR;GACA;GACH,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR;GACA;GACH,CAAC;;CAEb,CAAC"}

package/dist/assert/is-between.cjs

@@ -0,0 +1,47 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/assert/is-between.ts
+const [isBetween, notBetween] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		notBetween: "Expected {{= it.actual }} to be between {{= it.lesser }} and {{= it.greater }}",
+		not: "Expected {{= it.actual }} to not be between {{= it.lesser }} and {{= it.greater }}"
+	},
+	test: (report) => (actual, start, end, { inclusive = true } = {}) => {
+		const [greater, lesser] = end > start ? [end, start] : [start, end];
+		const inclusivelyBetween = actual <= greater && actual >= lesser;
+		const exclusivelyBetween = actual < greater && actual > lesser;
+		if (inclusive && !inclusivelyBetween) return report({
+			messageId: "notBetween",
+			status: "notok",
+			actual,
+			data: {
+				lesser,
+				greater
+			}
+		});
+		if (!inclusive && !exclusivelyBetween) return report({
+			messageId: "notBetween",
+			status: "notok",
+			actual,
+			data: {
+				lesser,
+				greater
+			}
+		});
+		return report({
+			status: "ok",
+			actual,
+			data: {
+				lesser,
+				greater
+			}
+		});
+	}
+});
+
+//#endregion
+exports.isBetween = isBetween;
+exports.notBetween = notBetween;
+//# sourceMappingURL=is-between.cjs.map

package/dist/assert/is-between.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-between.cjs","names":[],"sources":["../../src/assert/is-between.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface IsBetweenOptions {\n    inclusive?: boolean;\n}\n\ninterface IsBetween {\n    /**\n     * check that date is Between another date\n     */\n    <T extends Date>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;\n    <T extends number>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;\n}\n\nexport const [isBetween, notBetween] = createAssertion({\n    messages: {\n        notBetween: 'Expected {{= it.actual }} to be between {{= it.lesser }} and {{= it.greater }}',\n        not: 'Expected {{= it.actual }} to not be between {{= it.lesser }} and {{= it.greater }}'\n    },\n    test:\n        (report): IsBetween =>\n        <T extends Date | number>(actual: T, start: T, end: T, { inclusive = true }: IsBetweenOptions = {}) => {\n            const [greater, lesser] = end > start ? [end, start] : [start, end];\n            const inclusivelyBetween = actual <= greater && actual >= lesser;\n            const exclusivelyBetween = actual < greater && actual > lesser;\n            if (inclusive && !inclusivelyBetween) {\n                return report({\n                    messageId: 'notBetween',\n                    status: 'notok',\n                    actual,\n                    data: { lesser, greater }\n                });\n            }\n            if (!inclusive && !exclusivelyBetween) {\n                return report({\n                    messageId: 'notBetween',\n                    status: 'notok',\n                    actual,\n                    data: { lesser, greater }\n                });\n            }\n            return report({\n                status: 'ok',\n                actual,\n                data: { lesser, greater }\n            });\n        }\n});\n"],"mappings":";;;;;AAcA,MAAa,CAAC,WAAW,wDAA8B;CACnD,UAAU;EACN,YAAY;EACZ,KAAK;EACR;CACD,OACK,YACyB,QAAW,OAAU,KAAQ,EAAE,YAAY,SAA2B,EAAE,KAAK;EACnG,MAAM,CAAC,SAAS,UAAU,MAAM,QAAQ,CAAC,KAAK,MAAM,GAAG,CAAC,OAAO,IAAI;EACnE,MAAM,qBAAqB,UAAU,WAAW,UAAU;EAC1D,MAAM,qBAAqB,SAAS,WAAW,SAAS;AACxD,MAAI,aAAa,CAAC,mBACd,QAAO,OAAO;GACV,WAAW;GACX,QAAQ;GACR;GACA,MAAM;IAAE;IAAQ;IAAS;GAC5B,CAAC;AAEN,MAAI,CAAC,aAAa,CAAC,mBACf,QAAO,OAAO;GACV,WAAW;GACX,QAAQ;GACR;GACA,MAAM;IAAE;IAAQ;IAAS;GAC5B,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR;GACA,MAAM;IAAE;IAAQ;IAAS;GAC5B,CAAC;;CAEb,CAAC"}

package/dist/assert/is-between.d.cts

@@ -0,0 +1,15 @@
+//#region src/assert/is-between.d.ts
+interface IsBetweenOptions {
+  inclusive?: boolean;
+}
+interface IsBetween {
+  /**
+   * check that date is Between another date
+   */
+  <T extends Date>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;
+  <T extends number>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;
+}
+declare const isBetween: IsBetween, notBetween: IsBetween;
+//#endregion
+export { isBetween, notBetween };
+//# sourceMappingURL=is-between.d.cts.map

package/dist/assert/is-between.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-between.d.cts","names":[],"sources":["../../src/assert/is-between.ts"],"sourcesContent":[],"mappings":";UAEU,gBAAA;EAAA,SAAA,CAAA,EAAA,OAAgB;AAAA;UAIhB,SAAA,CAAS;;;;aAIJ,IAAgC,CAAA,CAAA,MAAA,EAAlB,CAAkB,EAAA,KAAA,EAAR,CAAQ,EAAA,GAAA,EAAA,CAAA,EAAA,OAAA,CAAA,EAAa,gBAAb,CAAA,EAAA,IAAA;aAAa,MAAA,CAAA,CAAA,MAAA,EAC7B,CAD6B,EAAA,KAAA,EACnB,CADmB,EAAA,GAAA,EACX,CADW,EAAA,OAAA,CAAA,EACE,gBADF,CAAA,EAAA,IAAA;;AACnB,cAG3B,SAH2B,EAGlB,SAHkB,EAAA,UAAA,EAGN,SAHM"}

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

@@ -0,0 +1,15 @@
+//#region src/assert/is-between.d.ts
+interface IsBetweenOptions {
+  inclusive?: boolean;
+}
+interface IsBetween {
+  /**
+   * check that date is Between another date
+   */
+  <T extends Date>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;
+  <T extends number>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;
+}
+declare const isBetween: IsBetween, notBetween: IsBetween;
+//#endregion
+export { isBetween, notBetween };
+//# sourceMappingURL=is-between.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-between.d.ts","names":[],"sources":["../../src/assert/is-between.ts"],"sourcesContent":[],"mappings":";UAEU,gBAAA;EAAA,SAAA,CAAA,EAAA,OAAgB;AAAA;UAIhB,SAAA,CAAS;;;;aAIJ,IAAgC,CAAA,CAAA,MAAA,EAAlB,CAAkB,EAAA,KAAA,EAAR,CAAQ,EAAA,GAAA,EAAA,CAAA,EAAA,OAAA,CAAA,EAAa,gBAAb,CAAA,EAAA,IAAA;aAAa,MAAA,CAAA,CAAA,MAAA,EAC7B,CAD6B,EAAA,KAAA,EACnB,CADmB,EAAA,GAAA,EACX,CADW,EAAA,OAAA,CAAA,EACE,gBADF,CAAA,EAAA,IAAA;;AACnB,cAG3B,SAH2B,EAGlB,SAHkB,EAAA,UAAA,EAGN,SAHM"}