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

package/dist/assert/round-to.js

@@ -0,0 +1,51 @@
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/round-to.ts
+const [roundTo, notRoundTo] = createAssertion({
+	messages: {
+		miss: "Expected {{= it.actual }} to round to {{= it.expected }}",
+		tooManyDecimals: "Invalid argument for target, decimals for target ({{= it.expected }}) cannot be less than rounding decimals ({{= it.decimals }})",
+		not: "Expected {{= it.actual }} to not round to {{= it.expected }}"
+	},
+	test: (report) => (actual, expected, decimals = 0) => {
+		var _expected$toString$sp;
+		if (((_expected$toString$sp = expected.toString().split(".")[1]) === null || _expected$toString$sp === void 0 ? void 0 : _expected$toString$sp.length) > decimals) {
+			report({
+				status: "notok",
+				messageId: "tooManyDecimals",
+				expected,
+				actual,
+				data: { decimals },
+				noStringify: true
+			});
+			report({
+				status: "ok",
+				messageId: "tooManyDecimals",
+				expected,
+				actual,
+				data: { decimals },
+				noStringify: true
+			});
+			return true;
+		}
+		if (round(actual, decimals) === expected) return report({
+			status: "ok",
+			expected,
+			actual
+		});
+		return report({
+			status: "notok",
+			messageId: "miss",
+			expected,
+			actual
+		});
+	}
+});
+const round = (value, decimals) => {
+	const factor = 10 ** decimals;
+	return Math.round(value * factor) / factor;
+};
+
+//#endregion
+export { notRoundTo, roundTo };
+//# sourceMappingURL=round-to.js.map

package/dist/assert/round-to.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-to.js","names":[],"sources":["../../src/assert/round-to.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface RoundTo {\n    /**\n     * check if value rounds to target\n     * @param actual\n     * @param expected\n     * @param [decimals=0] - number of decimals to round to, defaults to 0\n     * @example roundTo(1.234, 1.23, 2);\n     */\n    (actual: number, expected: number, decimals?: number): void;\n}\n\nexport const [roundTo, notRoundTo] = createAssertion({\n    messages: {\n        miss: 'Expected {{= it.actual }} to round to {{= it.expected }}',\n        tooManyDecimals:\n            'Invalid argument for target, decimals for target ({{= it.expected }}) cannot be less than rounding decimals ({{= it.decimals }})',\n        not: 'Expected {{= it.actual }} to not round to {{= it.expected }}'\n    },\n    test:\n        (report): RoundTo =>\n        (actual: number, expected: number, decimals = 0) => {\n            if (expected.toString().split('.')[1]?.length > decimals) {\n                report({\n                    status: 'notok',\n                    messageId: 'tooManyDecimals',\n                    expected,\n                    actual,\n                    data: { decimals },\n                    noStringify: true\n                });\n                report({\n                    status: 'ok',\n                    messageId: 'tooManyDecimals',\n                    expected,\n                    actual,\n                    data: { decimals },\n                    noStringify: true\n                });\n                return true;\n            }\n            if (round(actual, decimals) === expected) {\n                return report({ status: 'ok', expected, actual });\n            }\n            return report({ status: 'notok', messageId: 'miss', expected, actual });\n        }\n});\n\nconst round = (value: number, decimals: number) => {\n    const factor = 10 ** decimals;\n    return Math.round(value * factor) / factor;\n};\n"],"mappings":";;;AAaA,MAAa,CAAC,SAAS,cAAc,gBAAgB;CACjD,UAAU;EACN,MAAM;EACN,iBACI;EACJ,KAAK;EACR;CACD,OACK,YACA,QAAgB,UAAkB,WAAW,MAAM;;AAChD,gCAAI,SAAS,UAAU,CAAC,MAAM,IAAI,CAAC,kFAAI,UAAS,UAAU;AACtD,UAAO;IACH,QAAQ;IACR,WAAW;IACX;IACA;IACA,MAAM,EAAE,UAAU;IAClB,aAAa;IAChB,CAAC;AACF,UAAO;IACH,QAAQ;IACR,WAAW;IACX;IACA;IACA,MAAM,EAAE,UAAU;IAClB,aAAa;IAChB,CAAC;AACF,UAAO;;AAEX,MAAI,MAAM,QAAQ,SAAS,KAAK,SAC5B,QAAO,OAAO;GAAE,QAAQ;GAAM;GAAU;GAAQ,CAAC;AAErD,SAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAQ;GAAU;GAAQ,CAAC;;CAElF,CAAC;AAEF,MAAM,SAAS,OAAe,aAAqB;CAC/C,MAAM,SAAS,MAAM;AACrB,QAAO,KAAK,MAAM,QAAQ,OAAO,GAAG"}

package/dist/assert/starts-with.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/starts-with.ts
+const [startsWith, notStartsWith] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		wrongStart: "Expected {{= it.actual }} to start with {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not start with {{= it.expected }}"
+	},
+	test: (report) => (actual, start) => {
+		if (actual.startsWith(start)) report({
+			messageId: "not",
+			status: "ok",
+			actual,
+			expected: start
+		});
+		else report({
+			messageId: "wrongStart",
+			status: "notok",
+			actual,
+			expected: start
+		});
+	}
+});
+
+//#endregion
+exports.notStartsWith = notStartsWith;
+exports.startsWith = startsWith;
+//# sourceMappingURL=starts-with.cjs.map

package/dist/assert/starts-with.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"starts-with.cjs","names":[],"sources":["../../src/assert/starts-with.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface StartsWith {\n    /**\n     * check if string starts with start\n     * @param string\n     * @param start\n     * @example startsWith('foo', 'f');\n     */\n    (string: string, start: string): void;\n}\n\nexport const [startsWith, notStartsWith] = createAssertion({\n    messages: {\n        wrongStart: 'Expected {{= it.actual }} to start with {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not start with {{= it.expected }}'\n    },\n    test:\n        (report): StartsWith =>\n        (actual: string, start: string) => {\n            if (actual.startsWith(start)) {\n                report({\n                    messageId: 'not',\n                    status: 'ok',\n                    actual,\n                    expected: start\n                });\n            } else {\n                report({\n                    messageId: 'wrongStart',\n                    status: 'notok',\n                    actual,\n                    expected: start\n                });\n            }\n        }\n});\n"],"mappings":";;;;;AAYA,MAAa,CAAC,YAAY,2DAAiC;CACvD,UAAU;EACN,YAAY;EACZ,KAAK;EACR;CACD,OACK,YACA,QAAgB,UAAkB;AAC/B,MAAI,OAAO,WAAW,MAAM,CACxB,QAAO;GACH,WAAW;GACX,QAAQ;GACR;GACA,UAAU;GACb,CAAC;MAEF,QAAO;GACH,WAAW;GACX,QAAQ;GACR;GACA,UAAU;GACb,CAAC;;CAGjB,CAAC"}

package/dist/assert/starts-with.d.cts

@@ -0,0 +1,14 @@
+//#region src/assert/starts-with.d.ts
+interface StartsWith {
+  /**
+   * check if string starts with start
+   * @param string
+   * @param start
+   * @example startsWith('foo', 'f');
+   */
+  (string: string, start: string): void;
+}
+declare const startsWith: StartsWith, notStartsWith: StartsWith;
+//#endregion
+export { notStartsWith, startsWith };
+//# sourceMappingURL=starts-with.d.cts.map

package/dist/assert/starts-with.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starts-with.d.cts","names":[],"sources":["../../src/assert/starts-with.ts"],"sourcesContent":[],"mappings":";UAEU,UAAA;EAAA;AAUV;;;;;EAA0B,CAAA,MAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;cAAZ,YAAU,2BAAe"}

package/dist/assert/starts-with.d.ts

@@ -0,0 +1,14 @@
+//#region src/assert/starts-with.d.ts
+interface StartsWith {
+  /**
+   * check if string starts with start
+   * @param string
+   * @param start
+   * @example startsWith('foo', 'f');
+   */
+  (string: string, start: string): void;
+}
+declare const startsWith: StartsWith, notStartsWith: StartsWith;
+//#endregion
+export { notStartsWith, startsWith };
+//# sourceMappingURL=starts-with.d.ts.map

package/dist/assert/starts-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starts-with.d.ts","names":[],"sources":["../../src/assert/starts-with.ts"],"sourcesContent":[],"mappings":";UAEU,UAAA;EAAA;AAUV;;;;;EAA0B,CAAA,MAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;cAAZ,YAAU,2BAAe"}

package/dist/assert/starts-with.js

@@ -0,0 +1,27 @@
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/starts-with.ts
+const [startsWith, notStartsWith] = createAssertion({
+	messages: {
+		wrongStart: "Expected {{= it.actual }} to start with {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not start with {{= it.expected }}"
+	},
+	test: (report) => (actual, start) => {
+		if (actual.startsWith(start)) report({
+			messageId: "not",
+			status: "ok",
+			actual,
+			expected: start
+		});
+		else report({
+			messageId: "wrongStart",
+			status: "notok",
+			actual,
+			expected: start
+		});
+	}
+});
+
+//#endregion
+export { notStartsWith, startsWith };
+//# sourceMappingURL=starts-with.js.map

package/dist/assert/starts-with.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"starts-with.js","names":[],"sources":["../../src/assert/starts-with.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface StartsWith {\n    /**\n     * check if string starts with start\n     * @param string\n     * @param start\n     * @example startsWith('foo', 'f');\n     */\n    (string: string, start: string): void;\n}\n\nexport const [startsWith, notStartsWith] = createAssertion({\n    messages: {\n        wrongStart: 'Expected {{= it.actual }} to start with {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not start with {{= it.expected }}'\n    },\n    test:\n        (report): StartsWith =>\n        (actual: string, start: string) => {\n            if (actual.startsWith(start)) {\n                report({\n                    messageId: 'not',\n                    status: 'ok',\n                    actual,\n                    expected: start\n                });\n            } else {\n                report({\n                    messageId: 'wrongStart',\n                    status: 'notok',\n                    actual,\n                    expected: start\n                });\n            }\n        }\n});\n"],"mappings":";;;AAYA,MAAa,CAAC,YAAY,iBAAiB,gBAAgB;CACvD,UAAU;EACN,YAAY;EACZ,KAAK;EACR;CACD,OACK,YACA,QAAgB,UAAkB;AAC/B,MAAI,OAAO,WAAW,MAAM,CACxB,QAAO;GACH,WAAW;GACX,QAAQ;GACR;GACA,UAAU;GACb,CAAC;MAEF,QAAO;GACH,WAAW;GACX,QAAQ;GACR;GACA,UAAU;GACb,CAAC;;CAGjB,CAAC"}

package/dist/assert/throws.cjs

@@ -0,0 +1,41 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_get_type = require('../utils/get-type.cjs');
+const require_process_error = require('../utils/process-error.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/assert/throws.ts
+const messages = {
+	nonError: "Expected function to throw an instance of Error",
+	throws: "Expected function to throw",
+	invalidConstructor: "Expected function to throw {{= it.expected }}",
+	predicate: "Expected {{= it.actual }} to match predicate function",
+	regex: "Expected function to throw an error matching {{= it.expected }}",
+	not: "Expected function to not throw",
+	notConstructor: "Expected function to not throw a {{= it.expected }}",
+	notPredicate: "Expected function to not throw an error matching the predicate",
+	notRegex: "Expected function to not throw an error matching {{= it.expected }}"
+};
+const [throws, notThrows] = (0, hein_assertion_utils.createAssertion)({
+	messages,
+	test: (report) => ((callback, narrowerOrMessage, message) => {
+		const argumentType = require_get_type.getType(callback);
+		if (argumentType !== "function") throw new hein_assertion_utils.AssertionError(argumentType, "function", `Expected ${argumentType} to be a function`);
+		try {
+			callback();
+		} catch (error) {
+			return require_process_error.processError(report, error, narrowerOrMessage, message);
+		}
+		return report({
+			noStringify: true,
+			status: "notok",
+			messageId: "throws",
+			message: typeof narrowerOrMessage === "string" ? narrowerOrMessage : message
+		});
+	})
+});
+
+//#endregion
+exports.notThrows = notThrows;
+exports.throws = throws;
+//# sourceMappingURL=throws.cjs.map

package/dist/assert/throws.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"throws.cjs","names":["getType","AssertionError","processError"],"sources":["../../src/assert/throws.ts"],"sourcesContent":["import { AssertionError, createAssertion } from 'hein-assertion-utils';\nimport { getType } from '../utils/get-type.js';\nimport { type Constructor, type ErrorPredicate, processError } from '../utils/process-error.js';\n\nexport type ThrowsCallback = () => unknown;\n\ninterface Throw {\n    /**\n     * check if function throws an error\n     * @param callback\n     * @example throws(() => { throw new Error('foo'); });\n     * @example throws(() => { throw new TypeError('foo'); }, TypeError);\n     */\n    (callback: ThrowsCallback, message?: string): void;\n    /**\n     * check if function throws an error matching the constructor\n     * @param callback\n     * @example throws(() => { throw new TypeError('foo'); }, TypeError);\n     */\n    (callback: ThrowsCallback, expectedError: Constructor, message?: string): void;\n    /**\n     * check if function throws an error matching the regex\n     * @param callback\n     * @example throws(() => { throw new Error('foo'); });\n     * @example throws(() => { throw new TypeError('foo'); }, /foo/);\n     */\n    (callback: ThrowsCallback, expectedError: RegExp, message?: string): void;\n    /**\n     * check if function throws an error matching the predicate function\n     * @param callback\n     * @example throws(() => { throw new TypeError('foo'); }, (error) => error.message === 'foo');\n     */\n    (callback: ThrowsCallback, expectedError: ErrorPredicate, message?: string): void;\n}\n\nconst messages = {\n    nonError: 'Expected function to throw an instance of Error',\n    throws: 'Expected function to throw',\n    invalidConstructor: 'Expected function to throw {{= it.expected }}',\n    predicate: 'Expected {{= it.actual }} to match predicate function',\n    regex: 'Expected function to throw an error matching {{= it.expected }}',\n    not: 'Expected function to not throw',\n    notConstructor: 'Expected function to not throw a {{= it.expected }}',\n    notPredicate: 'Expected function to not throw an error matching the predicate',\n    notRegex: 'Expected function to not throw an error matching {{= it.expected }}'\n};\n\nexport const [throws, notThrows] = createAssertion({\n    messages: messages,\n    test: (report) =>\n        ((callback, narrowerOrMessage, message) => {\n            const argumentType = getType(callback);\n            if (argumentType !== 'function') {\n                throw new AssertionError(argumentType, 'function', `Expected ${ argumentType } to be a function`);\n            }\n            try {\n                callback();\n            } catch (error) {\n                return processError(report, error, narrowerOrMessage, message);\n            }\n            return report({\n                noStringify: true,\n                status: 'notok',\n                messageId: 'throws',\n                message: typeof narrowerOrMessage === 'string' ? narrowerOrMessage : message\n            });\n        }) as Throw\n});\n"],"mappings":";;;;;;;AAmCA,MAAM,WAAW;CACb,UAAU;CACV,QAAQ;CACR,oBAAoB;CACpB,WAAW;CACX,OAAO;CACP,KAAK;CACL,gBAAgB;CAChB,cAAc;CACd,UAAU;CACb;AAED,MAAa,CAAC,QAAQ,uDAA6B;CACrC;CACV,OAAO,aACD,UAAU,mBAAmB,YAAY;EACvC,MAAM,eAAeA,yBAAQ,SAAS;AACtC,MAAI,iBAAiB,WACjB,OAAM,IAAIC,oCAAe,cAAc,YAAY,YAAa,aAAc,mBAAmB;AAErG,MAAI;AACA,aAAU;WACL,OAAO;AACZ,UAAOC,mCAAa,QAAQ,OAAO,mBAAmB,QAAQ;;AAElE,SAAO,OAAO;GACV,aAAa;GACb,QAAQ;GACR,WAAW;GACX,SAAS,OAAO,sBAAsB,WAAW,oBAAoB;GACxE,CAAC;;CAEb,CAAC"}

package/dist/{throws-CYLYG7gu.d.cts → assert/throws.d.cts}

@@ -1,12 +1,5 @@
-//#region src/utils/process-error.d.ts
-interface Constructor<T = any> {
-  new (...args: any[]): T;
-}
-type ErrorPredicate = (error: Error) => boolean;
-//#endregion
-//#region src/utils/get-type.d.ts
-type ValueType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'null' | 'NaN' | 'array';
-//#endregion
+import { Constructor, ErrorPredicate } from "../utils/process-error.cjs";
+
 //#region src/assert/throws.d.ts
 type ThrowsCallback = () => unknown;
 interface Throw {
@@ -39,5 +32,5 @@ interface Throw {
 }
 declare const throws: Throw, notThrows: Throw;
 //#endregion
-export { Constructor, ErrorPredicate, ThrowsCallback, ValueType, notThrows, throws };
-//# sourceMappingURL=throws-CYLYG7gu.d.cts.map
+export { ThrowsCallback, notThrows, throws };
+//# sourceMappingURL=throws.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"throws.d.cts","names":[],"sources":["../../src/assert/throws.ts"],"sourcesContent":[],"mappings":";;;KAIY,cAAA;UAEF,KAAA;EAFE;AAA+B;;;;;WAsB5B,EAbA,cAaA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;AAqBf;EAAoB,CAAA,QAAA,EA5BL,cA4BK,EAAA,aAAA,EA5B0B,WA4B1B,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;;;aArBL,+BAA+B;;;;;;aAM/B,+BAA+B;;cAehC,QAAM,kBAAW"}

package/dist/{throws-BlzO4xvg.d.ts → assert/throws.d.ts}

@@ -1,14 +1,5 @@
-import "hein-assertion-utils";
+import { Constructor, ErrorPredicate } from "../utils/process-error.js";
 
-//#region src/utils/process-error.d.ts
-interface Constructor<T = any> {
-  new (...args: any[]): T;
-}
-type ErrorPredicate = (error: Error) => boolean;
-//#endregion
-//#region src/utils/get-type.d.ts
-type ValueType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'null' | 'NaN' | 'array';
-//#endregion
 //#region src/assert/throws.d.ts
 type ThrowsCallback = () => unknown;
 interface Throw {
@@ -41,5 +32,5 @@ interface Throw {
 }
 declare const throws: Throw, notThrows: Throw;
 //#endregion
-export { Constructor, ErrorPredicate, ThrowsCallback, ValueType, notThrows, throws };
-//# sourceMappingURL=throws-BlzO4xvg.d.ts.map
+export { ThrowsCallback, notThrows, throws };
+//# sourceMappingURL=throws.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"throws.d.ts","names":[],"sources":["../../src/assert/throws.ts"],"sourcesContent":[],"mappings":";;;KAIY,cAAA;UAEF,KAAA;EAFE;AAA+B;;;;;WAsB5B,EAbA,cAaA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;AAqBf;EAAoB,CAAA,QAAA,EA5BL,cA4BK,EAAA,aAAA,EA5B0B,WA4B1B,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;;;aArBL,+BAA+B;;;;;;aAM/B,+BAA+B;;cAehC,QAAM,kBAAW"}

package/dist/assert/throws.js

@@ -0,0 +1,38 @@
+import { getType } from "../utils/get-type.js";
+import { processError } from "../utils/process-error.js";
+import { AssertionError, createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/throws.ts
+const messages = {
+	nonError: "Expected function to throw an instance of Error",
+	throws: "Expected function to throw",
+	invalidConstructor: "Expected function to throw {{= it.expected }}",
+	predicate: "Expected {{= it.actual }} to match predicate function",
+	regex: "Expected function to throw an error matching {{= it.expected }}",
+	not: "Expected function to not throw",
+	notConstructor: "Expected function to not throw a {{= it.expected }}",
+	notPredicate: "Expected function to not throw an error matching the predicate",
+	notRegex: "Expected function to not throw an error matching {{= it.expected }}"
+};
+const [throws, notThrows] = createAssertion({
+	messages,
+	test: (report) => ((callback, narrowerOrMessage, message) => {
+		const argumentType = getType(callback);
+		if (argumentType !== "function") throw new AssertionError(argumentType, "function", `Expected ${argumentType} to be a function`);
+		try {
+			callback();
+		} catch (error) {
+			return processError(report, error, narrowerOrMessage, message);
+		}
+		return report({
+			noStringify: true,
+			status: "notok",
+			messageId: "throws",
+			message: typeof narrowerOrMessage === "string" ? narrowerOrMessage : message
+		});
+	})
+});
+
+//#endregion
+export { notThrows, throws };
+//# sourceMappingURL=throws.js.map

package/dist/assert/throws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throws.js","names":[],"sources":["../../src/assert/throws.ts"],"sourcesContent":["import { AssertionError, createAssertion } from 'hein-assertion-utils';\nimport { getType } from '../utils/get-type.js';\nimport { type Constructor, type ErrorPredicate, processError } from '../utils/process-error.js';\n\nexport type ThrowsCallback = () => unknown;\n\ninterface Throw {\n    /**\n     * check if function throws an error\n     * @param callback\n     * @example throws(() => { throw new Error('foo'); });\n     * @example throws(() => { throw new TypeError('foo'); }, TypeError);\n     */\n    (callback: ThrowsCallback, message?: string): void;\n    /**\n     * check if function throws an error matching the constructor\n     * @param callback\n     * @example throws(() => { throw new TypeError('foo'); }, TypeError);\n     */\n    (callback: ThrowsCallback, expectedError: Constructor, message?: string): void;\n    /**\n     * check if function throws an error matching the regex\n     * @param callback\n     * @example throws(() => { throw new Error('foo'); });\n     * @example throws(() => { throw new TypeError('foo'); }, /foo/);\n     */\n    (callback: ThrowsCallback, expectedError: RegExp, message?: string): void;\n    /**\n     * check if function throws an error matching the predicate function\n     * @param callback\n     * @example throws(() => { throw new TypeError('foo'); }, (error) => error.message === 'foo');\n     */\n    (callback: ThrowsCallback, expectedError: ErrorPredicate, message?: string): void;\n}\n\nconst messages = {\n    nonError: 'Expected function to throw an instance of Error',\n    throws: 'Expected function to throw',\n    invalidConstructor: 'Expected function to throw {{= it.expected }}',\n    predicate: 'Expected {{= it.actual }} to match predicate function',\n    regex: 'Expected function to throw an error matching {{= it.expected }}',\n    not: 'Expected function to not throw',\n    notConstructor: 'Expected function to not throw a {{= it.expected }}',\n    notPredicate: 'Expected function to not throw an error matching the predicate',\n    notRegex: 'Expected function to not throw an error matching {{= it.expected }}'\n};\n\nexport const [throws, notThrows] = createAssertion({\n    messages: messages,\n    test: (report) =>\n        ((callback, narrowerOrMessage, message) => {\n            const argumentType = getType(callback);\n            if (argumentType !== 'function') {\n                throw new AssertionError(argumentType, 'function', `Expected ${ argumentType } to be a function`);\n            }\n            try {\n                callback();\n            } catch (error) {\n                return processError(report, error, narrowerOrMessage, message);\n            }\n            return report({\n                noStringify: true,\n                status: 'notok',\n                messageId: 'throws',\n                message: typeof narrowerOrMessage === 'string' ? narrowerOrMessage : message\n            });\n        }) as Throw\n});\n"],"mappings":";;;;;AAmCA,MAAM,WAAW;CACb,UAAU;CACV,QAAQ;CACR,oBAAoB;CACpB,WAAW;CACX,OAAO;CACP,KAAK;CACL,gBAAgB;CAChB,cAAc;CACd,UAAU;CACb;AAED,MAAa,CAAC,QAAQ,aAAa,gBAAgB;CACrC;CACV,OAAO,aACD,UAAU,mBAAmB,YAAY;EACvC,MAAM,eAAe,QAAQ,SAAS;AACtC,MAAI,iBAAiB,WACjB,OAAM,IAAI,eAAe,cAAc,YAAY,YAAa,aAAc,mBAAmB;AAErG,MAAI;AACA,aAAU;WACL,OAAO;AACZ,UAAO,aAAa,QAAQ,OAAO,mBAAmB,QAAQ;;AAElE,SAAO,OAAO;GACV,aAAa;GACb,QAAQ;GACR,WAAW;GACX,SAAS,OAAO,sBAAsB,WAAW,oBAAoB;GACxE,CAAC;;CAEb,CAAC"}

package/dist/assert.cjs

@@ -1,53 +1,144 @@
-const require_assert = require('./assert-DZjgWjOw.cjs');
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_deep_equal = require('./assert/deep-equal.cjs');
+const require_equal = require('./assert/equal.cjs');
+const require_greater_than = require('./assert/greater-than.cjs');
+const require_greater_than_equal = require('./assert/greater-than-equal.cjs');
+const require_has_property = require('./assert/has-property.cjs');
+const require_has_size = require('./assert/has-size.cjs');
+const require_includes = require('./assert/includes.cjs');
+const require_instance_of = require('./assert/instance-of.cjs');
+const require_is_empty = require('./assert/is-empty.cjs');
+const require_is_type = require('./assert/is-type.cjs');
+const require_less_than = require('./assert/less-than.cjs');
+const require_less_than_equal = require('./assert/less-than-equal.cjs');
+const require_match = require('./assert/match.cjs');
+const require_rejects = require('./assert/rejects.cjs');
+const require_throws = require('./assert/throws.cjs');
+const require_deep_has_property = require('./assert/deep-has-property.cjs');
+const require_starts_with = require('./assert/starts-with.cjs');
+const require_ends_with = require('./assert/ends-with.cjs');
+const require_is_before = require('./assert/is-before.cjs');
+const require_is_after = require('./assert/is-after.cjs');
+const require_is_between = require('./assert/is-between.cjs');
+const require_in_ballpark = require('./assert/in-ballpark.cjs');
+const require_round_to = require('./assert/round-to.cjs');
+const require_has_members = require('./assert/has-members.cjs');
+const require_has_keys = require('./assert/has-keys.cjs');
 
-exports.assert = require_assert.assert;
-exports.deepEqual = require_assert.deepEqual;
-exports.deepHasProperty = require_assert.deepHasProperty;
-exports.deepNotHasProperty = require_assert.deepNotHasProperty;
-exports.endsWith = require_assert.endsWith;
-exports.equal = require_assert.equal;
-exports.greaterThan = require_assert.greaterThan;
-exports.greaterThanEqual = require_assert.greaterThanEqual;
-exports.hasKeys = require_assert.hasKeys;
-exports.hasMembers = require_assert.hasMembers;
-exports.hasProperty = require_assert.hasProperty;
-exports.hasSize = require_assert.hasSize;
-exports.inBallpark = require_assert.inBallpark;
-exports.includes = require_assert.includes;
-exports.instanceOf = require_assert.instanceOf;
-exports.isAfter = require_assert.isAfter;
-exports.isBefore = require_assert.isBefore;
-exports.isBetween = require_assert.isBetween;
-exports.isEmpty = require_assert.isEmpty;
-exports.isType = require_assert.isType;
-exports.lessThan = require_assert.lessThan;
-exports.lessThanEqual = require_assert.lessThanEqual;
-exports.match = require_assert.match;
-exports.notAfter = require_assert.notAfter;
-exports.notBefore = require_assert.notBefore;
-exports.notBetween = require_assert.notBetween;
-exports.notDeepEqual = require_assert.notDeepEqual;
-exports.notEndsWith = require_assert.notEndsWith;
-exports.notEqual = require_assert.notEqual;
-exports.notGreaterThan = require_assert.notGreaterThan;
-exports.notGreaterThanEqual = require_assert.notGreaterThanEqual;
-exports.notHasKeys = require_assert.notHasKeys;
-exports.notHasMembers = require_assert.notHasMembers;
-exports.notHasProperty = require_assert.notHasProperty;
-exports.notHasSize = require_assert.notHasSize;
-exports.notInBallpark = require_assert.notInBallpark;
-exports.notIncludes = require_assert.notIncludes;
-exports.notInstanceOf = require_assert.notInstanceOf;
-exports.notIsEmpty = require_assert.notIsEmpty;
-exports.notIsType = require_assert.notIsType;
-exports.notLessThan = require_assert.notLessThan;
-exports.notLessThanEqual = require_assert.notLessThanEqual;
-exports.notMatch = require_assert.notMatch;
-exports.notRejects = require_assert.notRejects;
-exports.notRoundTo = require_assert.notRoundTo;
-exports.notStartsWith = require_assert.notStartsWith;
-exports.notThrows = require_assert.notThrows;
-exports.rejects = require_assert.rejects;
-exports.roundTo = require_assert.roundTo;
-exports.startsWith = require_assert.startsWith;
-exports.throws = require_assert.throws;
+//#region src/assert.ts
+var assert_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	assert: () => assert,
+	deepEqual: () => require_deep_equal.deepEqual,
+	deepHasProperty: () => require_deep_has_property.deepHasProperty,
+	deepNotHasProperty: () => require_deep_has_property.deepNotHasProperty,
+	endsWith: () => require_ends_with.endsWith,
+	equal: () => require_equal.equal,
+	greaterThan: () => require_greater_than.greaterThan,
+	greaterThanEqual: () => require_greater_than_equal.greaterThanEqual,
+	hasKeys: () => require_has_keys.hasKeys,
+	hasMembers: () => require_has_members.hasMembers,
+	hasProperty: () => require_has_property.hasProperty,
+	hasSize: () => require_has_size.hasSize,
+	inBallpark: () => require_in_ballpark.inBallpark,
+	includes: () => require_includes.includes,
+	instanceOf: () => require_instance_of.instanceOf,
+	isAfter: () => require_is_after.isAfter,
+	isBefore: () => require_is_before.isBefore,
+	isBetween: () => require_is_between.isBetween,
+	isEmpty: () => require_is_empty.isEmpty,
+	isType: () => require_is_type.isType,
+	lessThan: () => require_less_than.lessThan,
+	lessThanEqual: () => require_less_than_equal.lessThanEqual,
+	match: () => require_match.match,
+	notAfter: () => require_is_after.notAfter,
+	notBefore: () => require_is_before.notBefore,
+	notBetween: () => require_is_between.notBetween,
+	notDeepEqual: () => require_deep_equal.notDeepEqual,
+	notEndsWith: () => require_ends_with.notEndsWith,
+	notEqual: () => require_equal.notEqual,
+	notGreaterThan: () => require_greater_than.notGreaterThan,
+	notGreaterThanEqual: () => require_greater_than_equal.notGreaterThanEqual,
+	notHasKeys: () => require_has_keys.notHasKeys,
+	notHasMembers: () => require_has_members.notHasMembers,
+	notHasProperty: () => require_has_property.notHasProperty,
+	notHasSize: () => require_has_size.notHasSize,
+	notInBallpark: () => require_in_ballpark.notInBallpark,
+	notIncludes: () => require_includes.notIncludes,
+	notInstanceOf: () => require_instance_of.notInstanceOf,
+	notIsEmpty: () => require_is_empty.notIsEmpty,
+	notIsType: () => require_is_type.notIsType,
+	notLessThan: () => require_less_than.notLessThan,
+	notLessThanEqual: () => require_less_than_equal.notLessThanEqual,
+	notMatch: () => require_match.notMatch,
+	notRejects: () => require_rejects.notRejects,
+	notRoundTo: () => require_round_to.notRoundTo,
+	notStartsWith: () => require_starts_with.notStartsWith,
+	notThrows: () => require_throws.notThrows,
+	rejects: () => require_rejects.rejects,
+	roundTo: () => require_round_to.roundTo,
+	startsWith: () => require_starts_with.startsWith,
+	throws: () => require_throws.throws
+});
+const assert = () => {
+	throw new Error("Not implemented");
+};
+
+//#endregion
+exports.assert = assert;
+Object.defineProperty(exports, 'assert_exports', {
+  enumerable: true,
+  get: function () {
+    return assert_exports;
+  }
+});
+exports.deepEqual = require_deep_equal.deepEqual;
+exports.deepHasProperty = require_deep_has_property.deepHasProperty;
+exports.deepNotHasProperty = require_deep_has_property.deepNotHasProperty;
+exports.endsWith = require_ends_with.endsWith;
+exports.equal = require_equal.equal;
+exports.greaterThan = require_greater_than.greaterThan;
+exports.greaterThanEqual = require_greater_than_equal.greaterThanEqual;
+exports.hasKeys = require_has_keys.hasKeys;
+exports.hasMembers = require_has_members.hasMembers;
+exports.hasProperty = require_has_property.hasProperty;
+exports.hasSize = require_has_size.hasSize;
+exports.inBallpark = require_in_ballpark.inBallpark;
+exports.includes = require_includes.includes;
+exports.instanceOf = require_instance_of.instanceOf;
+exports.isAfter = require_is_after.isAfter;
+exports.isBefore = require_is_before.isBefore;
+exports.isBetween = require_is_between.isBetween;
+exports.isEmpty = require_is_empty.isEmpty;
+exports.isType = require_is_type.isType;
+exports.lessThan = require_less_than.lessThan;
+exports.lessThanEqual = require_less_than_equal.lessThanEqual;
+exports.match = require_match.match;
+exports.notAfter = require_is_after.notAfter;
+exports.notBefore = require_is_before.notBefore;
+exports.notBetween = require_is_between.notBetween;
+exports.notDeepEqual = require_deep_equal.notDeepEqual;
+exports.notEndsWith = require_ends_with.notEndsWith;
+exports.notEqual = require_equal.notEqual;
+exports.notGreaterThan = require_greater_than.notGreaterThan;
+exports.notGreaterThanEqual = require_greater_than_equal.notGreaterThanEqual;
+exports.notHasKeys = require_has_keys.notHasKeys;
+exports.notHasMembers = require_has_members.notHasMembers;
+exports.notHasProperty = require_has_property.notHasProperty;
+exports.notHasSize = require_has_size.notHasSize;
+exports.notInBallpark = require_in_ballpark.notInBallpark;
+exports.notIncludes = require_includes.notIncludes;
+exports.notInstanceOf = require_instance_of.notInstanceOf;
+exports.notIsEmpty = require_is_empty.notIsEmpty;
+exports.notIsType = require_is_type.notIsType;
+exports.notLessThan = require_less_than.notLessThan;
+exports.notLessThanEqual = require_less_than_equal.notLessThanEqual;
+exports.notMatch = require_match.notMatch;
+exports.notRejects = require_rejects.notRejects;
+exports.notRoundTo = require_round_to.notRoundTo;
+exports.notStartsWith = require_starts_with.notStartsWith;
+exports.notThrows = require_throws.notThrows;
+exports.rejects = require_rejects.rejects;
+exports.roundTo = require_round_to.roundTo;
+exports.startsWith = require_starts_with.startsWith;
+exports.throws = require_throws.throws;
+//# sourceMappingURL=assert.cjs.map

package/dist/assert.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.cjs","names":[],"sources":["../src/assert.ts"],"sourcesContent":["export { deepEqual, notDeepEqual } from './assert/deep-equal.js';\nexport { equal, notEqual } from './assert/equal.js';\nexport { greaterThan, notGreaterThan } from './assert/greater-than.js';\nexport { greaterThanEqual, notGreaterThanEqual } from './assert/greater-than-equal.js';\nexport { hasProperty, notHasProperty } from './assert/has-property.js';\nexport { hasSize, notHasSize } from './assert/has-size.js';\nexport { includes, notIncludes } from './assert/includes.js';\nexport { instanceOf, notInstanceOf } from './assert/instance-of.js';\nexport { isEmpty, notIsEmpty } from './assert/is-empty.js';\nexport { isType, notIsType } from './assert/is-type.js';\nexport { lessThan, notLessThan } from './assert/less-than.js';\nexport { lessThanEqual, notLessThanEqual } from './assert/less-than-equal.js';\nexport { match, notMatch } from './assert/match.js';\nexport { notRejects, rejects } from './assert/rejects.js';\nexport { notThrows, throws } from './assert/throws.js';\nexport { deepHasProperty, deepNotHasProperty } from './assert/deep-has-property.js';\nexport { startsWith, notStartsWith } from './assert/starts-with.js';\nexport { endsWith, notEndsWith } from './assert/ends-with.js';\nexport { isBefore, notBefore } from './assert/is-before.js';\nexport { isAfter, notAfter } from './assert/is-after.js';\nexport { isBetween, notBetween } from './assert/is-between.js';\nexport { inBallpark, notInBallpark } from './assert/in-ballpark.js';\nexport { roundTo, notRoundTo } from './assert/round-to.js';\nexport { hasMembers, notHasMembers } from './assert/has-members.js';\nexport { hasKeys, notHasKeys } from './assert/has-keys.js';\n\nexport const assert = () => {\n    throw new Error('Not implemented');\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,eAAe;AACxB,OAAM,IAAI,MAAM,kBAAkB"}

package/dist/assert.d.cts

@@ -1,3 +1,34 @@
-import { assert, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, rejects, roundTo, startsWith } from "./assert-ChQPKP5C.cjs";
-import { notThrows, throws } from "./throws-CYLYG7gu.cjs";
-export { assert, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws };
+import { deepEqual, notDeepEqual } from "./assert/deep-equal.cjs";
+import { equal, notEqual } from "./assert/equal.cjs";
+import { greaterThan, notGreaterThan } from "./assert/greater-than.cjs";
+import { greaterThanEqual, notGreaterThanEqual } from "./assert/greater-than-equal.cjs";
+import { hasProperty, notHasProperty } from "./assert/has-property.cjs";
+import { hasSize, notHasSize } from "./assert/has-size.cjs";
+import { includes, notIncludes } from "./assert/includes.cjs";
+import { instanceOf, notInstanceOf } from "./assert/instance-of.cjs";
+import { isEmpty, notIsEmpty } from "./assert/is-empty.cjs";
+import { isType, notIsType } from "./assert/is-type.cjs";
+import { lessThan, notLessThan } from "./assert/less-than.cjs";
+import { lessThanEqual, notLessThanEqual } from "./assert/less-than-equal.cjs";
+import { match, notMatch } from "./assert/match.cjs";
+import { notRejects, rejects } from "./assert/rejects.cjs";
+import { notThrows, throws } from "./assert/throws.cjs";
+import { deepHasProperty, deepNotHasProperty } from "./assert/deep-has-property.cjs";
+import { notStartsWith, startsWith } from "./assert/starts-with.cjs";
+import { endsWith, notEndsWith } from "./assert/ends-with.cjs";
+import { isBefore, notBefore } from "./assert/is-before.cjs";
+import { isAfter, notAfter } from "./assert/is-after.cjs";
+import { isBetween, notBetween } from "./assert/is-between.cjs";
+import { inBallpark, notInBallpark } from "./assert/in-ballpark.cjs";
+import { notRoundTo, roundTo } from "./assert/round-to.cjs";
+import { hasMembers, notHasMembers } from "./assert/has-members.cjs";
+import { hasKeys, notHasKeys } from "./assert/has-keys.cjs";
+
+//#region src/assert.d.ts
+declare namespace assert_d_exports {
+  export { assert, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws };
+}
+declare const assert: () => never;
+//#endregion
+export { assert, assert_d_exports, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws };
+//# sourceMappingURL=assert.d.cts.map

package/dist/assert.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.cts","names":[],"sources":["../src/assert.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Ba"}

package/dist/assert.d.ts

@@ -1,3 +1,34 @@
-import { assert, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, rejects, roundTo, startsWith } from "./assert-CsN7srt-.js";
-import { notThrows, throws } from "./throws-BlzO4xvg.js";
-export { assert, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws };
+import { deepEqual, notDeepEqual } from "./assert/deep-equal.js";
+import { equal, notEqual } from "./assert/equal.js";
+import { greaterThan, notGreaterThan } from "./assert/greater-than.js";
+import { greaterThanEqual, notGreaterThanEqual } from "./assert/greater-than-equal.js";
+import { hasProperty, notHasProperty } from "./assert/has-property.js";
+import { hasSize, notHasSize } from "./assert/has-size.js";
+import { includes, notIncludes } from "./assert/includes.js";
+import { instanceOf, notInstanceOf } from "./assert/instance-of.js";
+import { isEmpty, notIsEmpty } from "./assert/is-empty.js";
+import { isType, notIsType } from "./assert/is-type.js";
+import { lessThan, notLessThan } from "./assert/less-than.js";
+import { lessThanEqual, notLessThanEqual } from "./assert/less-than-equal.js";
+import { match, notMatch } from "./assert/match.js";
+import { notRejects, rejects } from "./assert/rejects.js";
+import { notThrows, throws } from "./assert/throws.js";
+import { deepHasProperty, deepNotHasProperty } from "./assert/deep-has-property.js";
+import { notStartsWith, startsWith } from "./assert/starts-with.js";
+import { endsWith, notEndsWith } from "./assert/ends-with.js";
+import { isBefore, notBefore } from "./assert/is-before.js";
+import { isAfter, notAfter } from "./assert/is-after.js";
+import { isBetween, notBetween } from "./assert/is-between.js";
+import { inBallpark, notInBallpark } from "./assert/in-ballpark.js";
+import { notRoundTo, roundTo } from "./assert/round-to.js";
+import { hasMembers, notHasMembers } from "./assert/has-members.js";
+import { hasKeys, notHasKeys } from "./assert/has-keys.js";
+
+//#region src/assert.d.ts
+declare namespace assert_d_exports {
+  export { assert, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws };
+}
+declare const assert: () => never;
+//#endregion
+export { assert, assert_d_exports, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws };
+//# sourceMappingURL=assert.d.ts.map

package/dist/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","names":[],"sources":["../src/assert.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Ba"}