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

package/dist/utils/process-error.js

@@ -0,0 +1,85 @@
+//#region src/utils/process-error.ts
+const isConstructor = (value) => {
+	return typeof value === "function" && value.prototype && value.prototype.isPrototypeOf;
+};
+const processError = (report, error, narrowerOrMessage, message) => {
+	message = (typeof narrowerOrMessage === "string" ? narrowerOrMessage : message) ?? null;
+	if (!(error instanceof Error)) return report({
+		noStringify: true,
+		status: "notok",
+		messageId: "nonError",
+		actual: typeof error,
+		expected: "Error"
+	});
+	if (narrowerOrMessage) {
+		if (isConstructor(narrowerOrMessage)) {
+			if (!(error instanceof narrowerOrMessage)) return report({
+				noStringify: true,
+				status: "notok",
+				messageId: "invalidConstructor",
+				actual: error.name,
+				expected: narrowerOrMessage.name,
+				message
+			});
+			return report({
+				noStringify: true,
+				status: "ok",
+				messageId: "notConstructor",
+				actual: error.name,
+				expected: narrowerOrMessage.name,
+				message
+			});
+		} else if (typeof narrowerOrMessage === "function") {
+			if (!narrowerOrMessage(error)) return report({
+				noStringify: true,
+				status: "notok",
+				messageId: "predicate",
+				actual: error,
+				expected: null,
+				message
+			});
+			return report({
+				noStringify: true,
+				status: "ok",
+				messageId: "notPredicate",
+				actual: error,
+				expected: null,
+				message
+			});
+		} else if (typeof narrowerOrMessage === "string") return report({
+			noStringify: true,
+			status: "ok",
+			messageId: "throws",
+			actual: error,
+			message: narrowerOrMessage
+		});
+		else if (narrowerOrMessage instanceof RegExp) {
+			if (!narrowerOrMessage.test(error.message)) return report({
+				noStringify: true,
+				status: "notok",
+				messageId: "regex",
+				actual: error.message,
+				expected: narrowerOrMessage.toString(),
+				message
+			});
+			return report({
+				noStringify: true,
+				status: "ok",
+				messageId: "notRegex",
+				actual: error.message,
+				expected: narrowerOrMessage.toString(),
+				message
+			});
+		}
+	}
+	return report({
+		noStringify: true,
+		status: "ok",
+		actual: error,
+		message
+	});
+};
+
+//#endregion
+export { processError };
+//# sourceMappingURL=process-error.js.map

package/dist/utils/process-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-error.js","names":[],"sources":["../../src/utils/process-error.ts"],"sourcesContent":["import { type Report } from 'hein-assertion-utils';\n\nexport interface Constructor<T = any> {\n    new (...args: any[]): T;\n}\n\nexport type ErrorPredicate = (error: Error) => boolean;\n\nexport const isConstructor = (value: any): value is Constructor => {\n    return typeof value === 'function' && value.prototype && value.prototype.isPrototypeOf;\n};\n\nexport const isErrorConstructor = (value: any): value is Constructor<Error> => {\n    return isConstructor(value) && value.prototype instanceof Error;\n};\n\ntype ThrowsMessages =\n    | 'invalidArgument'\n    | 'nonError'\n    | 'throws'\n    | 'invalidConstructor'\n    | 'predicate'\n    | 'regex'\n    | 'not'\n    | 'notConstructor'\n    | 'notPredicate'\n    | 'notRegex';\n\nexport const processError = (report: Report<ThrowsMessages>, error: Error, narrowerOrMessage, message) => {\n    message = (typeof narrowerOrMessage === 'string' ? narrowerOrMessage : message) ?? null;\n\n    if (!(error instanceof Error)) {\n        return report({\n            noStringify: true,\n            status: 'notok',\n            messageId: 'nonError',\n            actual: typeof error,\n            expected: 'Error'\n        });\n    }\n    if (narrowerOrMessage) {\n        if (isConstructor(narrowerOrMessage)) {\n            if (!(error instanceof narrowerOrMessage)) {\n                return report({\n                    noStringify: true,\n                    status: 'notok',\n                    messageId: 'invalidConstructor',\n                    actual: error.name,\n                    expected: narrowerOrMessage.name,\n                    message\n                });\n            }\n            return report({\n                noStringify: true,\n                status: 'ok',\n                messageId: 'notConstructor',\n                actual: error.name,\n                expected: narrowerOrMessage.name,\n                message\n            });\n        } else if (typeof narrowerOrMessage === 'function') {\n            if (!(narrowerOrMessage as ErrorPredicate)(error)) {\n                return report({\n                    noStringify: true,\n                    status: 'notok',\n                    messageId: 'predicate',\n                    actual: error,\n                    expected: null,\n                    message\n                });\n            }\n            return report({\n                noStringify: true,\n                status: 'ok',\n                messageId: 'notPredicate',\n                actual: error,\n                expected: null,\n                message\n            });\n        } else if (typeof narrowerOrMessage === 'string') {\n            return report({\n                noStringify: true,\n                status: 'ok',\n                messageId: 'throws',\n                actual: error,\n                message: narrowerOrMessage\n            });\n        } else if (narrowerOrMessage instanceof RegExp) {\n            if (!narrowerOrMessage.test(error.message)) {\n                return report({\n                    noStringify: true,\n                    status: 'notok',\n                    messageId: 'regex',\n                    actual: error.message,\n                    expected: narrowerOrMessage.toString(),\n                    message\n                });\n            }\n            return report({\n                noStringify: true,\n                status: 'ok',\n                messageId: 'notRegex',\n                actual: error.message,\n                expected: narrowerOrMessage.toString(),\n                message\n            });\n        }\n    }\n    return report({ noStringify: true, status: 'ok', actual: error, message });\n};\n"],"mappings":";AAQA,MAAa,iBAAiB,UAAqC;AAC/D,QAAO,OAAO,UAAU,cAAc,MAAM,aAAa,MAAM,UAAU;;AAmB7E,MAAa,gBAAgB,QAAgC,OAAc,mBAAmB,YAAY;AACtG,YAAW,OAAO,sBAAsB,WAAW,oBAAoB,YAAY;AAEnF,KAAI,EAAE,iBAAiB,OACnB,QAAO,OAAO;EACV,aAAa;EACb,QAAQ;EACR,WAAW;EACX,QAAQ,OAAO;EACf,UAAU;EACb,CAAC;AAEN,KAAI,mBACA;MAAI,cAAc,kBAAkB,EAAE;AAClC,OAAI,EAAE,iBAAiB,mBACnB,QAAO,OAAO;IACV,aAAa;IACb,QAAQ;IACR,WAAW;IACX,QAAQ,MAAM;IACd,UAAU,kBAAkB;IAC5B;IACH,CAAC;AAEN,UAAO,OAAO;IACV,aAAa;IACb,QAAQ;IACR,WAAW;IACX,QAAQ,MAAM;IACd,UAAU,kBAAkB;IAC5B;IACH,CAAC;aACK,OAAO,sBAAsB,YAAY;AAChD,OAAI,CAAE,kBAAqC,MAAM,CAC7C,QAAO,OAAO;IACV,aAAa;IACb,QAAQ;IACR,WAAW;IACX,QAAQ;IACR,UAAU;IACV;IACH,CAAC;AAEN,UAAO,OAAO;IACV,aAAa;IACb,QAAQ;IACR,WAAW;IACX,QAAQ;IACR,UAAU;IACV;IACH,CAAC;aACK,OAAO,sBAAsB,SACpC,QAAO,OAAO;GACV,aAAa;GACb,QAAQ;GACR,WAAW;GACX,QAAQ;GACR,SAAS;GACZ,CAAC;WACK,6BAA6B,QAAQ;AAC5C,OAAI,CAAC,kBAAkB,KAAK,MAAM,QAAQ,CACtC,QAAO,OAAO;IACV,aAAa;IACb,QAAQ;IACR,WAAW;IACX,QAAQ,MAAM;IACd,UAAU,kBAAkB,UAAU;IACtC;IACH,CAAC;AAEN,UAAO,OAAO;IACV,aAAa;IACb,QAAQ;IACR,WAAW;IACX,QAAQ,MAAM;IACd,UAAU,kBAAkB,UAAU;IACtC;IACH,CAAC;;;AAGV,QAAO,OAAO;EAAE,aAAa;EAAM,QAAQ;EAAM,QAAQ;EAAO;EAAS,CAAC"}

package/dist/utils/validate-numeric-and-dates.cjs

@@ -0,0 +1,20 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_get_type = require('./get-type.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/utils/validate-numeric-and-dates.ts
+const allowedTypes = [
+	"number",
+	"bigint",
+	"date"
+];
+const validateNumericsAndDates = (actual, expected) => {
+	const actualType = actual instanceof Date ? "date" : require_get_type.getType(actual);
+	const expectedType = expected instanceof Date ? "date" : require_get_type.getType(expected);
+	if (!allowedTypes.includes(actualType) || !allowedTypes.includes(expectedType)) throw new hein_assertion_utils.AssertionError(actualType, expectedType, `Expected arguments to be ${allowedTypes.join("/")}, received ${actualType}/${expectedType}`);
+};
+
+//#endregion
+exports.validateNumericsAndDates = validateNumericsAndDates;
+//# sourceMappingURL=validate-numeric-and-dates.cjs.map

package/dist/utils/validate-numeric-and-dates.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-numeric-and-dates.cjs","names":["allowedTypes: (ValueType | 'date')[]","getType","AssertionError"],"sources":["../../src/utils/validate-numeric-and-dates.ts"],"sourcesContent":["import { AssertionError } from 'hein-assertion-utils';\nimport { type ValueType, getType } from './get-type.js';\n\nconst allowedTypes: (ValueType | 'date')[] = ['number', 'bigint', 'date'];\n\nexport const validateNumericsAndDates = (actual: any, expected: any) => {\n    const actualType = actual instanceof Date ? 'date' : getType(actual);\n    const expectedType = expected instanceof Date ? 'date' : getType(expected);\n    if (!allowedTypes.includes(actualType) || !allowedTypes.includes(expectedType)) {\n        throw new AssertionError(\n            actualType,\n            expectedType,\n            `Expected arguments to be ${ allowedTypes.join('/') }, received ${ actualType }/${ expectedType }`\n        );\n    }\n};\n"],"mappings":";;;;;;AAGA,MAAMA,eAAuC;CAAC;CAAU;CAAU;CAAO;AAEzE,MAAa,4BAA4B,QAAa,aAAkB;CACpE,MAAM,aAAa,kBAAkB,OAAO,SAASC,yBAAQ,OAAO;CACpE,MAAM,eAAe,oBAAoB,OAAO,SAASA,yBAAQ,SAAS;AAC1E,KAAI,CAAC,aAAa,SAAS,WAAW,IAAI,CAAC,aAAa,SAAS,aAAa,CAC1E,OAAM,IAAIC,oCACN,YACA,cACA,4BAA6B,aAAa,KAAK,IAAI,CAAE,aAAc,WAAY,GAAI,eACtF"}

package/dist/utils/validate-numeric-and-dates.js

@@ -0,0 +1,18 @@
+import { getType } from "./get-type.js";
+import { AssertionError } from "hein-assertion-utils";
+
+//#region src/utils/validate-numeric-and-dates.ts
+const allowedTypes = [
+	"number",
+	"bigint",
+	"date"
+];
+const validateNumericsAndDates = (actual, expected) => {
+	const actualType = actual instanceof Date ? "date" : getType(actual);
+	const expectedType = expected instanceof Date ? "date" : getType(expected);
+	if (!allowedTypes.includes(actualType) || !allowedTypes.includes(expectedType)) throw new AssertionError(actualType, expectedType, `Expected arguments to be ${allowedTypes.join("/")}, received ${actualType}/${expectedType}`);
+};
+
+//#endregion
+export { validateNumericsAndDates };
+//# sourceMappingURL=validate-numeric-and-dates.js.map

package/dist/utils/validate-numeric-and-dates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-numeric-and-dates.js","names":["allowedTypes: (ValueType | 'date')[]"],"sources":["../../src/utils/validate-numeric-and-dates.ts"],"sourcesContent":["import { AssertionError } from 'hein-assertion-utils';\nimport { type ValueType, getType } from './get-type.js';\n\nconst allowedTypes: (ValueType | 'date')[] = ['number', 'bigint', 'date'];\n\nexport const validateNumericsAndDates = (actual: any, expected: any) => {\n    const actualType = actual instanceof Date ? 'date' : getType(actual);\n    const expectedType = expected instanceof Date ? 'date' : getType(expected);\n    if (!allowedTypes.includes(actualType) || !allowedTypes.includes(expectedType)) {\n        throw new AssertionError(\n            actualType,\n            expectedType,\n            `Expected arguments to be ${ allowedTypes.join('/') }, received ${ actualType }/${ expectedType }`\n        );\n    }\n};\n"],"mappings":";;;;AAGA,MAAMA,eAAuC;CAAC;CAAU;CAAU;CAAO;AAEzE,MAAa,4BAA4B,QAAa,aAAkB;CACpE,MAAM,aAAa,kBAAkB,OAAO,SAAS,QAAQ,OAAO;CACpE,MAAM,eAAe,oBAAoB,OAAO,SAAS,QAAQ,SAAS;AAC1E,KAAI,CAAC,aAAa,SAAS,WAAW,IAAI,CAAC,aAAa,SAAS,aAAa,CAC1E,OAAM,IAAI,eACN,YACA,cACA,4BAA6B,aAAa,KAAK,IAAI,CAAE,aAAc,WAAY,GAAI,eACtF"}

package/dist/utils/xor.cjs

@@ -0,0 +1,9 @@
+
+//#region src/utils/xor.ts
+const xor = (a, b) => {
+	return a && !b || !a && b;
+};
+
+//#endregion
+exports.xor = xor;
+//# sourceMappingURL=xor.cjs.map

package/dist/utils/xor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"xor.cjs","names":[],"sources":["../../src/utils/xor.ts"],"sourcesContent":["export const xor = (a: boolean, b: boolean) => {\n    return (a && !b) || (!a && b);\n};\n"],"mappings":";;AAAA,MAAa,OAAO,GAAY,MAAe;AAC3C,QAAQ,KAAK,CAAC,KAAO,CAAC,KAAK"}

package/dist/utils/xor.js

@@ -0,0 +1,8 @@
+//#region src/utils/xor.ts
+const xor = (a, b) => {
+	return a && !b || !a && b;
+};
+
+//#endregion
+export { xor };
+//# sourceMappingURL=xor.js.map

package/dist/utils/xor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xor.js","names":[],"sources":["../../src/utils/xor.ts"],"sourcesContent":["export const xor = (a: boolean, b: boolean) => {\n    return (a && !b) || (!a && b);\n};\n"],"mappings":";AAAA,MAAa,OAAO,GAAY,MAAe;AAC3C,QAAQ,KAAK,CAAC,KAAO,CAAC,KAAK"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hein",
   "description": "Assertion library written in TypeScript",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "type": "module",
   "engines": {
     "node": ">=14.0.0"

package/dist/assert-ChQPKP5C.d.cts

@@ -1,480 +0,0 @@
-import { Constructor, ErrorPredicate, ValueType, notThrows, throws } from "./throws-CYLYG7gu.cjs";
-
-//#region rolldown:runtime
-//#endregion
-//#region src/assert/deep-equal.d.ts
-declare const deepEqual: <T>(actual: T, expected: T, partialOrMessage?: string | boolean, message?: string) => true | void, notDeepEqual: <T>(actual: T, expected: T, partialOrMessage?: string | boolean, message?: string) => true | void;
-//#endregion
-//#region src/assert/equal.d.ts
-interface Equal {
-  /**
-   * check for === equality except here NaN is equal to NaN
-   */
-  <T>(actual: T, expected: T, message?: string): void;
-}
-declare const equal: Equal, notEqual: Equal;
-//#endregion
-//#region src/assert/greater-than.d.ts
-interface GreaterThan {
-  /**
-   * check for >
-   */
-  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
-}
-declare const greaterThan: GreaterThan, notGreaterThan: GreaterThan;
-//#endregion
-//#region src/assert/greater-than-equal.d.ts
-interface GreaterThanEqual {
-  /**
-   * check for >=
-   */
-  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
-}
-declare const greaterThanEqual: GreaterThanEqual, notGreaterThanEqual: GreaterThanEqual;
-//#endregion
-//#region src/assert/has-property.d.ts
-interface HasProperty {
-  /**
-   * check if object has a property
-   * @param object
-   * @param property a property in the object.
-   * @example hasProperty({a: 1}, 'a');
-   */
-  <T, K extends keyof T>(object: T, property: K): void;
-  /**
-   * check if object has a property with a specific value
-   * @param object
-   * @param property a property in the object.
-   * @param value
-   * @example hasProperty({a: 1}, 'a', 1);
-   */
-  <T, K extends keyof T>(object: T, property: K, value: T[K]): void;
-}
-declare const hasProperty: HasProperty, notHasProperty: HasProperty;
-//#endregion
-//#region src/assert/has-size.d.ts
-interface HasSize {
-  /**
-   * check if array has a specific length
-   * @param array
-   * @param length
-   * @example hasSize([1, 2, 3], 3);
-   */
-  (array: any[], length: number, message?: string): void;
-  /**
-   * check if object has a specific amount of keys
-   * @param object
-   * @param length
-   * @example hasSize({a: 1, b: 2}, 2);
-   */
-  (object: Record<string, unknown>, length: number, message?: string): void;
-  /**
-   * check if Map has a specific amount of keys
-   * @param map
-   * @param length
-   * @example hasSize(new Map([['a', 1], ['b', 2]]), 2);
-   */
-  (map: Map<unknown, unknown>, length: number, message?: string): void;
-  /**
-   * check if Set has a specific amount of members
-   * @param set
-   * @param length
-   * @example hasSize(new Set([1, 2, 3]), 3);
-   */
-  (set: Set<unknown>, length: number, message?: string): void;
-  /**
-   * check if string has a specific length
-   * @param string
-   * @param length
-   * @example hasSize('abc', 3);
-   */
-  (string: string, length: number, message?: string): void;
-}
-declare const hasSize: HasSize, notHasSize: HasSize;
-//#endregion
-//#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
-//#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
-//#region src/assert/is-empty.d.ts
-interface IsEmpty {
-  /**
-   * check if array is empty
-   * @param array
-   * @example isEmpty([]);
-   */
-  <T>(array: T[], message?: string): void;
-  /**
-   * check if object is empty
-   * @param object
-   * @example isEmpty({});
-   */
-  (object: Record<string, unknown>, message?: string): void;
-  /**
-   * check if Map is empty
-   * @param map
-   * @example isEmpty(new Map());
-   */
-  <K, V>(map: Map<K, V>, message?: string): void;
-  /**
-   * check if Set is empty
-   * @param set
-   * @example isEmpty(new Set());
-   */
-  <T>(set: Set<T>, message?: string): void;
-}
-declare const isEmpty: IsEmpty, notIsEmpty: IsEmpty;
-//#endregion
-//#region src/assert/is-type.d.ts
-interface IsType {
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType('foo', 'string');
-   * @example isType(1, 'number');
-   * @example isType(1n, 'bigint');
-   * @example isType(true, 'boolean');
-   * @example isType(Symbol('foo'), 'symbol');
-   * @example isType(undefined, 'undefined');
-   * @example isType({}, 'object');
-   * @example isType(() => {}, 'function');
-   * @example isType(null, 'null');
-   * @example isType(NaN, 'NaN');
-   * @example isType([], 'array');
-   */
-  (value: unknown, expectedType: ValueType): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType('foo', 'string');
-   */
-  (value: string, expectedType: 'string'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType(1, 'number');
-   * @example isType(NaN, 'NaN');
-   */
-  (value: number, expectedType: 'number' | 'NaN'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType(1n, 'bigint');
-   */
-  (value: bigint, expectedType: 'bigint'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType(true, 'boolean');
-   */
-  (value: boolean, expectedType: 'boolean'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType(Symbol('foo'), 'symbol');
-   */
-  (value: symbol, expectedType: 'symbol'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType(Symbol('foo'), 'symbol');
-   */
-  (value: undefined, expectedType: 'undefined'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType({}, 'object');
-   */
-  (value: object, expectedType: 'object'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType(() => {}, 'function');
-   */
-  (value: Function, expectedType: 'function'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType(null, 'null');
-   */
-  (value: null, expectedType: 'null'): void;
-  /**
-   * check if value is of a specific type, nulls, NaN and arrays are specially handled
-   * @param value
-   * @param expectedType
-   * @example isType([], 'array');
-   */
-  (value: any[], expectedType: 'array'): void;
-}
-declare const isType: IsType, notIsType: IsType;
-//#endregion
-//#region src/assert/less-than.d.ts
-interface LesserThan {
-  /**
-   * check for <
-   */
-  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
-}
-declare const lessThan: LesserThan, notLessThan: LesserThan;
-//#endregion
-//#region src/assert/less-than-equal.d.ts
-interface LessThanEqual {
-  /**
-   * check for <=
-   */
-  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
-}
-declare const lessThanEqual: LessThanEqual, notLessThanEqual: LessThanEqual;
-//#endregion
-//#region src/assert/match.d.ts
-interface IsMatch {
-  /**
-   * check if string matches regex
-   * @param actual
-   * @param regex
-   * @example match('foo', /foo/);
-   * @example notMatch('foo', /bar/);
-   */
-  (actual: string, regex: RegExp): void;
-}
-declare const match: IsMatch, notMatch: IsMatch;
-//#endregion
-//#region src/assert/rejects.d.ts
-interface Rejects {
-  /**
-   * check if promise rejects
-   * @param promise
-   * @example rejects(Promise.reject());
-   */
-  (promise: Promise<any>, message?: string): Promise<void>;
-  /**
-   * check if promise rejects with an instance of constructor
-   * @param promise
-   * @param constructor - expected error constructor
-   * @example rejects(Promise.reject(new Error()), Error);
-   */
-  (promise: Promise<any>, constructor: Constructor, message?: string): Promise<void>;
-  /**
-   * check if promise rejects with a specific error message
-   * @param promise
-   * @param regex - expected error message regex
-   * @example rejects(Promise.reject(new Error('This is worrying)), /worrying/);
-   */
-  (promise: Promise<any>, constructor: RegExp, message?: string): Promise<void>;
-  /**
-   * check if promise rejects with and matches the predicate function
-   * @param promise
-   * @param predicate - predicate function that receives the error and returns boolean
-   * @example rejects(Promise.reject(new Error('This is worrying')), (error) => error.message === 'This is worrying');));
-   */
-  (promise: Promise<any>, constructor: ErrorPredicate, message?: string): Promise<void>;
-}
-declare const rejects: Rejects, notRejects: Rejects;
-//#endregion
-//#region src/assert/deep-has-property.d.ts
-interface DeepHasProperty {
-  /**
-   * check if object has a property
-   * @param object
-   * @param property a property in the object. Can be a path like 'a.b.c'
-   * @example deepHasProperty([{a: {b: {c: 1}}}], '[0].a.b.c');
-   */
-  (object: any, property: string): void;
-  /**
-   * check if object has a property with a specific value
-   * @param object
-   * @param property a property in the object. Can be a path like 'a.b.c'
-   * @param value
-   * @example deepHasProperty([{a: {b: {c: 1}}}], '[0].a.b.c', 1);
-   */
-  (object: any, property: string, value: any): void;
-}
-declare const deepHasProperty: DeepHasProperty, deepNotHasProperty: DeepHasProperty;
-//#endregion
-//#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
-//#region src/assert/ends-with.d.ts
-interface EndsWith {
-  /**
-   * check if string ends with a specific string
-   * @param string
-   * @param end
-   */
-  (string: string, end: string): void;
-}
-declare const endsWith: EndsWith, notEndsWith: EndsWith;
-//#endregion
-//#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
-//#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
-//#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
-//#region src/assert/in-ballpark.d.ts
-interface InBallpark {
-  /**
-   * check if a number is in ballpark of another number. See also roundTo
-   * @param actual
-   * @param expected
-   * @param [allowedDifferenceMultiplier=0.1] - a number between 0 and 1 (exclusive). 0.1 (default) means 10% difference is allowed.
-   * @example inBallpark(1, 1.1);
-   * @example inBallpark(1, 1.1, 0.1);
-   */
-  (actual: number, expected: number, allowedDifferenceMultiplier?: number): void;
-}
-declare const inBallpark: InBallpark, notInBallpark: InBallpark;
-//#endregion
-//#region src/assert/round-to.d.ts
-interface RoundTo {
-  /**
-   * check if value rounds to target
-   * @param actual
-   * @param expected
-   * @param [decimals=0] - number of decimals to round to, defaults to 0
-   * @example roundTo(1.234, 1.23, 2);
-   */
-  (actual: number, expected: number, decimals?: number): void;
-}
-declare const roundTo: RoundTo, notRoundTo: RoundTo;
-//#endregion
-//#region src/assert/has-members.d.ts
-interface HasMembersOptions {
-  /**
-   * check for deep equality (ie {a: 1} === {a: 1})
-   * @default false
-   * @example
-   * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });
-   */
-  deep?: boolean;
-  /**
-   * use partial matching (ie {a: 1, b: 2} === {a: 1})
-   * implies deep
-   * @default false
-   * @example
-   * hasMembers([{ a: 1, b: 2 }], [{ a: 1 }], { partial: true });
-   */
-  partial?: boolean;
-  /**
-   * check that all the members in the first array are present in the second one
-   * @default false
-   * @example
-   * hasMembers([1, 2], [2, 1], { same: true });
-   * notHasMembers([1, 2], [1], { same: true});
-   */
-  same?: boolean;
-  /**
-   * check that the members in the first array are in the same order as the second one
-   * @default false
-   * @example
-   * hasMembers([1, 2], [1, 2], { ordered: true });
-   * notHasMembers([1, 2], [2, 1], { ordered: true });
-   */
-  ordered?: boolean;
-}
-interface HasMembers {
-  /**
-   * check that the members in second array are present in the first one
-   * @example
-   * hasMembers([1], [1]);
-   * hasMembers([1, 2], [2, 1]);
-   * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });
-   */
-  <T>(actual: T[], expected: T[], options?: HasMembersOptions, message?: string): void;
-}
-declare const hasMembers: HasMembers, notHasMembers: HasMembers;
-//#endregion
-//#region src/assert/has-keys.d.ts
-interface HasKeys {
-  /**
-   * check if object has keys
-   * @param object
-   * @param keys a key or array of keys in the object.
-   * @example hasKeys({a: 1}, 'a');
-   * @example hasKeys({a: 1, b: 2}, ['a', 'b']);
-   */
-  <T extends Record<string, any>, K extends keyof T>(object: T, keys: K[] | K, message?: string): void;
-  <K, T extends Map<K, any>>(object: T, keys: K[] | K, message?: string): void;
-}
-declare const hasKeys: HasKeys, notHasKeys: HasKeys;
-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, rejects, roundTo, startsWith };
-//# sourceMappingURL=assert-ChQPKP5C.d.cts.map

package/dist/assert-ChQPKP5C.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert-ChQPKP5C.d.cts","names":[],"sources":["../src/assert/deep-equal.ts","../src/assert/equal.ts","../src/assert/greater-than.ts","../src/assert/greater-than-equal.ts","../src/assert/has-property.ts","../src/assert/has-size.ts","../src/assert/includes.ts","../src/assert/instance-of.ts","../src/assert/is-empty.ts","../src/assert/is-type.ts","../src/assert/less-than.ts","../src/assert/less-than-equal.ts","../src/assert/match.ts","../src/assert/rejects.ts","../src/assert/deep-has-property.ts","../src/assert/starts-with.ts","../src/assert/ends-with.ts","../src/assert/is-before.ts","../src/assert/is-after.ts","../src/assert/is-between.ts","../src/assert/in-ballpark.ts","../src/assert/round-to.ts","../src/assert/has-members.ts","../src/assert/has-keys.ts","../src/assert.ts"],"sourcesContent":[],"mappings":"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"}