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

package/dist/assert.js

@@ -1,3 +1,88 @@
-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, notThrows, rejects, roundTo, startsWith, throws } from "./assert-kFXp7i_B.js";
+import { __export } from "./_virtual/rolldown_runtime.js";
+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";
 
-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 };
+//#region src/assert.ts
+var assert_exports = /* @__PURE__ */ __export({
+	assert: () => assert,
+	deepEqual: () => deepEqual,
+	deepHasProperty: () => deepHasProperty,
+	deepNotHasProperty: () => deepNotHasProperty,
+	endsWith: () => endsWith,
+	equal: () => equal,
+	greaterThan: () => greaterThan,
+	greaterThanEqual: () => greaterThanEqual,
+	hasKeys: () => hasKeys,
+	hasMembers: () => hasMembers,
+	hasProperty: () => hasProperty,
+	hasSize: () => hasSize,
+	inBallpark: () => inBallpark,
+	includes: () => includes,
+	instanceOf: () => instanceOf,
+	isAfter: () => isAfter,
+	isBefore: () => isBefore,
+	isBetween: () => isBetween,
+	isEmpty: () => isEmpty,
+	isType: () => isType,
+	lessThan: () => lessThan,
+	lessThanEqual: () => lessThanEqual,
+	match: () => match,
+	notAfter: () => notAfter,
+	notBefore: () => notBefore,
+	notBetween: () => notBetween,
+	notDeepEqual: () => notDeepEqual,
+	notEndsWith: () => notEndsWith,
+	notEqual: () => notEqual,
+	notGreaterThan: () => notGreaterThan,
+	notGreaterThanEqual: () => notGreaterThanEqual,
+	notHasKeys: () => notHasKeys,
+	notHasMembers: () => notHasMembers,
+	notHasProperty: () => notHasProperty,
+	notHasSize: () => notHasSize,
+	notInBallpark: () => notInBallpark,
+	notIncludes: () => notIncludes,
+	notInstanceOf: () => notInstanceOf,
+	notIsEmpty: () => notIsEmpty,
+	notIsType: () => notIsType,
+	notLessThan: () => notLessThan,
+	notLessThanEqual: () => notLessThanEqual,
+	notMatch: () => notMatch,
+	notRejects: () => notRejects,
+	notRoundTo: () => notRoundTo,
+	notStartsWith: () => notStartsWith,
+	notThrows: () => notThrows,
+	rejects: () => rejects,
+	roundTo: () => roundTo,
+	startsWith: () => startsWith,
+	throws: () => throws
+});
+const assert = () => {
+	throw new Error("Not implemented");
+};
+
+//#endregion
+export { assert, assert_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.js.map

package/dist/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","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/expect/after.cjs

@@ -0,0 +1,15 @@
+const require_is_after = require('../assert/is-after.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/after.ts
+require_mixins.use({ after: {
+	type: "method",
+	value: ({ value, inverted }) => (date) => {
+		if (inverted) require_is_after.notAfter(value, date);
+		else require_is_after.isAfter(value, date);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=after.cjs.map

package/dist/expect/after.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"after.cjs","names":["use"],"sources":["../../src/expect/after.ts"],"sourcesContent":["import { isAfter, notAfter } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface DateExpect {\n        /**\n         * check if date is after other date\n         * @param date\n         */\n        after(date: Date): this;\n    }\n}\n\nuse({\n    after: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (date: Date) => {\n                if (inverted) {\n                    notAfter(value, date);\n                } else {\n                    isAfter(value, date);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAaAA,mBAAI,EACA,OAAO;CACH,MAAM;CACN,QACK,EAAE,OAAO,gBACT,SAAe;AACZ,MAAI,SACA,2BAAS,OAAO,KAAK;MAErB,0BAAQ,OAAO,KAAK;;CAGnC,EACJ,CAAC"}

package/dist/expect/after.js

@@ -0,0 +1,16 @@
+import { isAfter, notAfter } from "../assert/is-after.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/after.ts
+use({ after: {
+	type: "method",
+	value: ({ value, inverted }) => (date) => {
+		if (inverted) notAfter(value, date);
+		else isAfter(value, date);
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=after.js.map

package/dist/expect/after.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"after.js","names":[],"sources":["../../src/expect/after.ts"],"sourcesContent":["import { isAfter, notAfter } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface DateExpect {\n        /**\n         * check if date is after other date\n         * @param date\n         */\n        after(date: Date): this;\n    }\n}\n\nuse({\n    after: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (date: Date) => {\n                if (inverted) {\n                    notAfter(value, date);\n                } else {\n                    isAfter(value, date);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAaA,IAAI,EACA,OAAO;CACH,MAAM;CACN,QACK,EAAE,OAAO,gBACT,SAAe;AACZ,MAAI,SACA,UAAS,OAAO,KAAK;MAErB,SAAQ,OAAO,KAAK;;CAGnC,EACJ,CAAC"}

package/dist/expect/ballpark.cjs

@@ -0,0 +1,15 @@
+const require_in_ballpark = require('../assert/in-ballpark.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/ballpark.ts
+require_mixins.use({ ballpark: {
+	type: "method",
+	value: ({ value, inverted }) => (ballpark, multiplier = .1) => {
+		if (inverted) require_in_ballpark.notInBallpark(value, ballpark, multiplier);
+		else require_in_ballpark.inBallpark(value, ballpark, multiplier);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=ballpark.cjs.map

package/dist/expect/ballpark.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballpark.cjs","names":["use"],"sources":["../../src/expect/ballpark.ts"],"sourcesContent":["import { inBallpark, notInBallpark } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface NumberExpect {\n        /**\n         * check if number close enough (default 10%)\n         * @param ballpark\n         * @param [multiplier=10] - a number between 0 and 1 (exclusive). 0.1 (default) means 10% difference is allowed.\n         */\n        ballpark(ballpark: number, multiplier?: number): this;\n    }\n}\n\nuse({\n    ballpark: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (ballpark, multiplier = 0.1) => {\n                if (inverted) {\n                    notInBallpark(value, ballpark, multiplier);\n                } else {\n                    inBallpark(value, ballpark, multiplier);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcAA,mBAAI,EACA,UAAU;CACN,MAAM;CACN,QACK,EAAE,OAAO,gBACT,UAAU,aAAa,OAAQ;AAC5B,MAAI,SACA,mCAAc,OAAO,UAAU,WAAW;MAE1C,gCAAW,OAAO,UAAU,WAAW;;CAGtD,EACJ,CAAC"}

package/dist/expect/ballpark.js

@@ -0,0 +1,16 @@
+import { inBallpark, notInBallpark } from "../assert/in-ballpark.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/ballpark.ts
+use({ ballpark: {
+	type: "method",
+	value: ({ value, inverted }) => (ballpark, multiplier = .1) => {
+		if (inverted) notInBallpark(value, ballpark, multiplier);
+		else inBallpark(value, ballpark, multiplier);
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=ballpark.js.map

package/dist/expect/ballpark.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ballpark.js","names":[],"sources":["../../src/expect/ballpark.ts"],"sourcesContent":["import { inBallpark, notInBallpark } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface NumberExpect {\n        /**\n         * check if number close enough (default 10%)\n         * @param ballpark\n         * @param [multiplier=10] - a number between 0 and 1 (exclusive). 0.1 (default) means 10% difference is allowed.\n         */\n        ballpark(ballpark: number, multiplier?: number): this;\n    }\n}\n\nuse({\n    ballpark: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (ballpark, multiplier = 0.1) => {\n                if (inverted) {\n                    notInBallpark(value, ballpark, multiplier);\n                } else {\n                    inBallpark(value, ballpark, multiplier);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcA,IAAI,EACA,UAAU;CACN,MAAM;CACN,QACK,EAAE,OAAO,gBACT,UAAU,aAAa,OAAQ;AAC5B,MAAI,SACA,eAAc,OAAO,UAAU,WAAW;MAE1C,YAAW,OAAO,UAAU,WAAW;;CAGtD,EACJ,CAAC"}

package/dist/expect/before.cjs

@@ -0,0 +1,15 @@
+const require_is_before = require('../assert/is-before.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/before.ts
+require_mixins.use({ before: {
+	type: "method",
+	value: ({ value, inverted }) => (date) => {
+		if (inverted) require_is_before.notBefore(value, date);
+		else require_is_before.isBefore(value, date);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=before.cjs.map

package/dist/expect/before.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"before.cjs","names":["use"],"sources":["../../src/expect/before.ts"],"sourcesContent":["import { isBefore, notBefore } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface DateExpect {\n        /**\n         * check if date is before other date\n         * @param date\n         */\n        before(date: Date): this;\n    }\n}\n\nuse({\n    before: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (date: Date) => {\n                if (inverted) {\n                    notBefore(value, date);\n                } else {\n                    isBefore(value, date);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAaAA,mBAAI,EACA,QAAQ;CACJ,MAAM;CACN,QACK,EAAE,OAAO,gBACT,SAAe;AACZ,MAAI,SACA,6BAAU,OAAO,KAAK;MAEtB,4BAAS,OAAO,KAAK;;CAGpC,EACJ,CAAC"}

package/dist/expect/before.js

@@ -0,0 +1,16 @@
+import { isBefore, notBefore } from "../assert/is-before.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/before.ts
+use({ before: {
+	type: "method",
+	value: ({ value, inverted }) => (date) => {
+		if (inverted) notBefore(value, date);
+		else isBefore(value, date);
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=before.js.map

package/dist/expect/before.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"before.js","names":[],"sources":["../../src/expect/before.ts"],"sourcesContent":["import { isBefore, notBefore } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface DateExpect {\n        /**\n         * check if date is before other date\n         * @param date\n         */\n        before(date: Date): this;\n    }\n}\n\nuse({\n    before: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (date: Date) => {\n                if (inverted) {\n                    notBefore(value, date);\n                } else {\n                    isBefore(value, date);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAaA,IAAI,EACA,QAAQ;CACJ,MAAM;CACN,QACK,EAAE,OAAO,gBACT,SAAe;AACZ,MAAI,SACA,WAAU,OAAO,KAAK;MAEtB,UAAS,OAAO,KAAK;;CAGpC,EACJ,CAAC"}

package/dist/expect/between.cjs

@@ -0,0 +1,15 @@
+const require_is_between = require('../assert/is-between.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/between.ts
+require_mixins.use({ between: {
+	type: "method",
+	value: ({ value, inverted }) => (start, end, inclusive = true) => {
+		if (inverted) require_is_between.notBetween(value, start, end, { inclusive });
+		else require_is_between.isBetween(value, start, end, { inclusive });
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=between.cjs.map

package/dist/expect/between.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"between.cjs","names":["use"],"sources":["../../src/expect/between.ts"],"sourcesContent":["import { isBetween, notBetween } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface DateExpect {\n        /**\n         * check if date is between other dates\n         * @param start\n         * @param end\n         */\n        between(start: Date, end: Date, inclusive?: boolean): this;\n    }\n    interface NumberExpect {\n        /**\n         * check if number is between other numbers\n         * @param start\n         * @param end\n         * @param inclusive\n         */\n        between(start: number, end: number, inclusive?: boolean): this;\n    }\n}\n\nuse({\n    between: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (start: Date, end: Date, inclusive = true) => {\n                if (inverted) {\n                    notBetween(value, start, end, { inclusive });\n                } else {\n                    isBetween(value, start, end, { inclusive });\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAuBAA,mBAAI,EACA,SAAS;CACL,MAAM;CACN,QACK,EAAE,OAAO,gBACT,OAAa,KAAW,YAAY,SAAS;AAC1C,MAAI,SACA,+BAAW,OAAO,OAAO,KAAK,EAAE,WAAW,CAAC;MAE5C,8BAAU,OAAO,OAAO,KAAK,EAAE,WAAW,CAAC;;CAG1D,EACJ,CAAC"}

package/dist/expect/between.js

@@ -0,0 +1,16 @@
+import { isBetween, notBetween } from "../assert/is-between.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/between.ts
+use({ between: {
+	type: "method",
+	value: ({ value, inverted }) => (start, end, inclusive = true) => {
+		if (inverted) notBetween(value, start, end, { inclusive });
+		else isBetween(value, start, end, { inclusive });
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=between.js.map

package/dist/expect/between.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"between.js","names":[],"sources":["../../src/expect/between.ts"],"sourcesContent":["import { isBetween, notBetween } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface DateExpect {\n        /**\n         * check if date is between other dates\n         * @param start\n         * @param end\n         */\n        between(start: Date, end: Date, inclusive?: boolean): this;\n    }\n    interface NumberExpect {\n        /**\n         * check if number is between other numbers\n         * @param start\n         * @param end\n         * @param inclusive\n         */\n        between(start: number, end: number, inclusive?: boolean): this;\n    }\n}\n\nuse({\n    between: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (start: Date, end: Date, inclusive = true) => {\n                if (inverted) {\n                    notBetween(value, start, end, { inclusive });\n                } else {\n                    isBetween(value, start, end, { inclusive });\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAuBA,IAAI,EACA,SAAS;CACL,MAAM;CACN,QACK,EAAE,OAAO,gBACT,OAAa,KAAW,YAAY,SAAS;AAC1C,MAAI,SACA,YAAW,OAAO,OAAO,KAAK,EAAE,WAAW,CAAC;MAE5C,WAAU,OAAO,OAAO,KAAK,EAAE,WAAW,CAAC;;CAG1D,EACJ,CAAC"}

package/dist/expect/empty.cjs

@@ -0,0 +1,15 @@
+const require_is_empty = require('../assert/is-empty.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/empty.ts
+require_mixins.use({ empty: {
+	type: "method",
+	value: ({ value, inverted }) => (message) => {
+		if (inverted) require_is_empty.notIsEmpty(value, message);
+		else require_is_empty.isEmpty(value, message);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=empty.cjs.map

package/dist/expect/empty.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.cjs","names":["use"],"sources":["../../src/expect/empty.ts"],"sourcesContent":["import { isEmpty, notIsEmpty } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ObjectExpect<T> {\n        /**\n         * check if object/array/Map/Set is empty\n         */\n        empty(message?: string): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface MapExpect<T> {\n        /**\n         * check if Map is empty\n         */\n        empty(message?: string): this;\n    }\n}\n\nuse({\n    empty: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (message?: string) => {\n                if (inverted) {\n                    notIsEmpty(value, message);\n                } else {\n                    isEmpty(value, message);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAoBAA,mBAAI,EACA,OAAO;CACH,MAAM;CACN,QACK,EAAE,OAAO,gBACT,YAAqB;AAClB,MAAI,SACA,6BAAW,OAAO,QAAQ;MAE1B,0BAAQ,OAAO,QAAQ;;CAGtC,EACJ,CAAC"}

package/dist/expect/empty.js

@@ -0,0 +1,16 @@
+import { isEmpty, notIsEmpty } from "../assert/is-empty.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/empty.ts
+use({ empty: {
+	type: "method",
+	value: ({ value, inverted }) => (message) => {
+		if (inverted) notIsEmpty(value, message);
+		else isEmpty(value, message);
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=empty.js.map

package/dist/expect/empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.js","names":[],"sources":["../../src/expect/empty.ts"],"sourcesContent":["import { isEmpty, notIsEmpty } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ObjectExpect<T> {\n        /**\n         * check if object/array/Map/Set is empty\n         */\n        empty(message?: string): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface MapExpect<T> {\n        /**\n         * check if Map is empty\n         */\n        empty(message?: string): this;\n    }\n}\n\nuse({\n    empty: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (message?: string) => {\n                if (inverted) {\n                    notIsEmpty(value, message);\n                } else {\n                    isEmpty(value, message);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAoBA,IAAI,EACA,OAAO;CACH,MAAM;CACN,QACK,EAAE,OAAO,gBACT,YAAqB;AAClB,MAAI,SACA,YAAW,OAAO,QAAQ;MAE1B,SAAQ,OAAO,QAAQ;;CAGtC,EACJ,CAAC"}

package/dist/expect/end-with.cjs

@@ -0,0 +1,15 @@
+const require_ends_with = require('../assert/ends-with.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/end-with.ts
+require_mixins.use({ endWith: {
+	type: "method",
+	value: ({ value, inverted }) => (end) => {
+		if (inverted) require_ends_with.notEndsWith(value, end);
+		else require_ends_with.endsWith(value, end);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=end-with.cjs.map

package/dist/expect/end-with.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"end-with.cjs","names":["use"],"sources":["../../src/expect/end-with.ts"],"sourcesContent":["import { endsWith, notEndsWith } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface StringExpect {\n        /**\n         * check if string ends with other string\n         * @param start\n         * @example endsWith('foo', 'o');\n         */\n        endWith(end: string): this;\n    }\n}\n\nuse({\n    endWith: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (end: string) => {\n                if (inverted) {\n                    notEndsWith(value, end);\n                } else {\n                    endsWith(value, end);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcAA,mBAAI,EACA,SAAS;CACL,MAAM;CACN,QACK,EAAE,OAAO,gBACT,QAAgB;AACb,MAAI,SACA,+BAAY,OAAO,IAAI;MAEvB,4BAAS,OAAO,IAAI;;CAGnC,EACJ,CAAC"}

package/dist/expect/end-with.js

@@ -0,0 +1,16 @@
+import { endsWith, notEndsWith } from "../assert/ends-with.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/end-with.ts
+use({ endWith: {
+	type: "method",
+	value: ({ value, inverted }) => (end) => {
+		if (inverted) notEndsWith(value, end);
+		else endsWith(value, end);
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=end-with.js.map

package/dist/expect/end-with.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"end-with.js","names":[],"sources":["../../src/expect/end-with.ts"],"sourcesContent":["import { endsWith, notEndsWith } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface StringExpect {\n        /**\n         * check if string ends with other string\n         * @param start\n         * @example endsWith('foo', 'o');\n         */\n        endWith(end: string): this;\n    }\n}\n\nuse({\n    endWith: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (end: string) => {\n                if (inverted) {\n                    notEndsWith(value, end);\n                } else {\n                    endsWith(value, end);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcA,IAAI,EACA,SAAS;CACL,MAAM;CACN,QACK,EAAE,OAAO,gBACT,QAAgB;AACb,MAAI,SACA,aAAY,OAAO,IAAI;MAEvB,UAAS,OAAO,IAAI;;CAGnC,EACJ,CAAC"}

package/dist/expect/eql.cjs

@@ -0,0 +1,21 @@
+const require_deep_equal = require('../assert/deep-equal.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/eql.ts
+require_mixins.use({
+	partially: {
+		type: "property",
+		value: () => ({ partial: true })
+	},
+	eql: {
+		type: "method",
+		value: ({ value, inverted, partial }) => (other, message) => {
+			if (inverted) require_deep_equal.notDeepEqual(value, other, partial, message);
+			else require_deep_equal.deepEqual(value, other, partial, message);
+		}
+	}
+});
+
+//#endregion
+//# sourceMappingURL=eql.cjs.map

package/dist/expect/eql.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"eql.cjs","names":["use"],"sources":["../../src/expect/eql.ts"],"sourcesContent":["import { deepEqual, notDeepEqual } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type DeepPartial } from '../utils/types.js';\n\ndeclare module '../expect.types' {\n    interface ValueExpect<T> {\n        /**\n         * check for deep equality\n         */\n        eql(value: T, message?: string): this;\n        partially: ValueExpect<DeepPartial<T>>;\n    }\n}\n\nuse({\n    partially: {\n        type: 'property',\n        value: () => ({ partial: true })\n    },\n    eql: {\n        type: 'method',\n        value:\n            ({ value, inverted, partial }) =>\n            (other: any, message) => {\n                if (inverted) {\n                    notDeepEqual(value, other, partial, message);\n                } else {\n                    deepEqual(value, other, partial, message);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcAA,mBAAI;CACA,WAAW;EACP,MAAM;EACN,cAAc,EAAE,SAAS,MAAM;EAClC;CACD,KAAK;EACD,MAAM;EACN,QACK,EAAE,OAAO,UAAU,eACnB,OAAY,YAAY;AACrB,OAAI,SACA,iCAAa,OAAO,OAAO,SAAS,QAAQ;OAE5C,8BAAU,OAAO,OAAO,SAAS,QAAQ;;EAGxD;CACJ,CAAC"}

package/dist/expect/eql.js

@@ -0,0 +1,22 @@
+import { deepEqual, notDeepEqual } from "../assert/deep-equal.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/eql.ts
+use({
+	partially: {
+		type: "property",
+		value: () => ({ partial: true })
+	},
+	eql: {
+		type: "method",
+		value: ({ value, inverted, partial }) => (other, message) => {
+			if (inverted) notDeepEqual(value, other, partial, message);
+			else deepEqual(value, other, partial, message);
+		}
+	}
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=eql.js.map

package/dist/expect/eql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eql.js","names":[],"sources":["../../src/expect/eql.ts"],"sourcesContent":["import { deepEqual, notDeepEqual } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type DeepPartial } from '../utils/types.js';\n\ndeclare module '../expect.types' {\n    interface ValueExpect<T> {\n        /**\n         * check for deep equality\n         */\n        eql(value: T, message?: string): this;\n        partially: ValueExpect<DeepPartial<T>>;\n    }\n}\n\nuse({\n    partially: {\n        type: 'property',\n        value: () => ({ partial: true })\n    },\n    eql: {\n        type: 'method',\n        value:\n            ({ value, inverted, partial }) =>\n            (other: any, message) => {\n                if (inverted) {\n                    notDeepEqual(value, other, partial, message);\n                } else {\n                    deepEqual(value, other, partial, message);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcA,IAAI;CACA,WAAW;EACP,MAAM;EACN,cAAc,EAAE,SAAS,MAAM;EAClC;CACD,KAAK;EACD,MAAM;EACN,QACK,EAAE,OAAO,UAAU,eACnB,OAAY,YAAY;AACrB,OAAI,SACA,cAAa,OAAO,OAAO,SAAS,QAAQ;OAE5C,WAAU,OAAO,OAAO,SAAS,QAAQ;;EAGxD;CACJ,CAAC"}

package/dist/expect/equal-shorthand.cjs

@@ -0,0 +1,34 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_equal = require('../assert/equal.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/expect/equal-shorthand.ts
+require_mixins.use(Object.fromEntries(Object.entries({
+	false: false,
+	true: true
+}).map(([key, expectValue]) => {
+	return [key, {
+		type: "method",
+		value: ({ inverted, value }) => () => {
+			if (inverted) {
+				const message = (0, hein_assertion_utils.format)("Expected {{= it.value }} to not be {{= it.key }}", {
+					key,
+					value
+				}, true);
+				require_equal.notEqual(value, expectValue, message);
+			} else {
+				const message = (0, hein_assertion_utils.format)("Expected {{= it.value }} to be {{= it.key }}", {
+					key,
+					value
+				}, true);
+				require_equal.equal(value, expectValue, message);
+			}
+		}
+	}];
+})));
+
+//#endregion
+//# sourceMappingURL=equal-shorthand.cjs.map

package/dist/expect/equal-shorthand.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal-shorthand.cjs","names":["use"],"sources":["../../src/expect/equal-shorthand.ts"],"sourcesContent":["import { equal, notEqual } from '../assert.js';\nimport { type State, use } from '../mixins.js';\nimport { format } from 'hein-assertion-utils';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface BooleanExpect<T> {\n        /**\n         * check if value is true\n         */\n        true(): this;\n        /**\n         * check if value is false\n         */\n        false(): this;\n    }\n}\n\nconst values = {\n    false: false,\n    true: true\n};\n\nuse(\n    Object.fromEntries(\n        Object.entries(values).map(([key, expectValue]) => {\n            return [\n                key,\n                {\n                    type: 'method',\n                    value:\n                        ({ inverted, value }: State<any>) =>\n                        () => {\n                            if (inverted) {\n                                const message = format(\n                                    'Expected {{= it.value }} to not be {{= it.key }}',\n                                    {\n                                        key,\n                                        value\n                                    },\n                                    true\n                                );\n                                notEqual(value, expectValue, message);\n                            } else {\n                                const message = format(\n                                    'Expected {{= it.value }} to be {{= it.key }}',\n                                    {\n                                        key,\n                                        value\n                                    },\n                                    true\n                                );\n                                equal(value, expectValue, message);\n                            }\n                        }\n                }\n            ];\n        })\n    )\n);\n"],"mappings":";;;;;;;;AAuBAA,mBACI,OAAO,YACH,OAAO,QAPA;CACX,OAAO;CACP,MAAM;CACT,CAI6B,CAAC,KAAK,CAAC,KAAK,iBAAiB;AAC/C,QAAO,CACH,KACA;EACI,MAAM;EACN,QACK,EAAE,UAAU,kBACP;AACF,OAAI,UAAU;IACV,MAAM,2CACF,oDACA;KACI;KACA;KACH,EACD,KACH;AACD,2BAAS,OAAO,aAAa,QAAQ;UAClC;IACH,MAAM,2CACF,gDACA;KACI;KACA;KACH,EACD,KACH;AACD,wBAAM,OAAO,aAAa,QAAQ;;;EAGjD,CACJ;EACH,CACL,CACJ"}

package/dist/expect/equal-shorthand.js

@@ -0,0 +1,33 @@
+import { equal, notEqual } from "../assert/equal.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+import { format } from "hein-assertion-utils";
+
+//#region src/expect/equal-shorthand.ts
+use(Object.fromEntries(Object.entries({
+	false: false,
+	true: true
+}).map(([key, expectValue]) => {
+	return [key, {
+		type: "method",
+		value: ({ inverted, value }) => () => {
+			if (inverted) {
+				const message = format("Expected {{= it.value }} to not be {{= it.key }}", {
+					key,
+					value
+				}, true);
+				notEqual(value, expectValue, message);
+			} else {
+				const message = format("Expected {{= it.value }} to be {{= it.key }}", {
+					key,
+					value
+				}, true);
+				equal(value, expectValue, message);
+			}
+		}
+	}];
+})));
+
+//#endregion
+export {  };
+//# sourceMappingURL=equal-shorthand.js.map

package/dist/expect/equal-shorthand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal-shorthand.js","names":[],"sources":["../../src/expect/equal-shorthand.ts"],"sourcesContent":["import { equal, notEqual } from '../assert.js';\nimport { type State, use } from '../mixins.js';\nimport { format } from 'hein-assertion-utils';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface BooleanExpect<T> {\n        /**\n         * check if value is true\n         */\n        true(): this;\n        /**\n         * check if value is false\n         */\n        false(): this;\n    }\n}\n\nconst values = {\n    false: false,\n    true: true\n};\n\nuse(\n    Object.fromEntries(\n        Object.entries(values).map(([key, expectValue]) => {\n            return [\n                key,\n                {\n                    type: 'method',\n                    value:\n                        ({ inverted, value }: State<any>) =>\n                        () => {\n                            if (inverted) {\n                                const message = format(\n                                    'Expected {{= it.value }} to not be {{= it.key }}',\n                                    {\n                                        key,\n                                        value\n                                    },\n                                    true\n                                );\n                                notEqual(value, expectValue, message);\n                            } else {\n                                const message = format(\n                                    'Expected {{= it.value }} to be {{= it.key }}',\n                                    {\n                                        key,\n                                        value\n                                    },\n                                    true\n                                );\n                                equal(value, expectValue, message);\n                            }\n                        }\n                }\n            ];\n        })\n    )\n);\n"],"mappings":";;;;;;AAuBA,IACI,OAAO,YACH,OAAO,QAPA;CACX,OAAO;CACP,MAAM;CACT,CAI6B,CAAC,KAAK,CAAC,KAAK,iBAAiB;AAC/C,QAAO,CACH,KACA;EACI,MAAM;EACN,QACK,EAAE,UAAU,kBACP;AACF,OAAI,UAAU;IACV,MAAM,UAAU,OACZ,oDACA;KACI;KACA;KACH,EACD,KACH;AACD,aAAS,OAAO,aAAa,QAAQ;UAClC;IACH,MAAM,UAAU,OACZ,gDACA;KACI;KACA;KACH,EACD,KACH;AACD,UAAM,OAAO,aAAa,QAAQ;;;EAGjD,CACJ;EACH,CACL,CACJ"}

package/dist/expect/equal.cjs

@@ -0,0 +1,27 @@
+const require_deep_equal = require('../assert/deep-equal.cjs');
+const require_equal = require('../assert/equal.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/equal.ts
+require_mixins.use({
+	equal: {
+		type: "method",
+		value: ({ value, inverted, deep }) => (other, message) => {
+			if (deep) {
+				if (inverted) require_deep_equal.notDeepEqual(value, other, message);
+				else require_deep_equal.deepEqual(value, other, message);
+				return;
+			}
+			if (inverted) require_equal.notEqual(value, other, message);
+			else require_equal.equal(value, other, message);
+		}
+	},
+	eq: {
+		type: "alias",
+		value: "equal"
+	}
+});
+
+//#endregion
+//# sourceMappingURL=equal.cjs.map

package/dist/expect/equal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.cjs","names":["use"],"sources":["../../src/expect/equal.ts"],"sourcesContent":["import { deepEqual, equal, notDeepEqual, notEqual } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface ValueExpect<T> {\n        /**\n         * check for === equality, NaN is considered equal to NaN\n         */\n        equal(value: T, message?: string): this;\n        /**\n         * check for === equality, NaN is considered equal to NaN\n         */\n        eq(value: T, message?: string): this;\n    }\n}\n\nuse({\n    equal: {\n        type: 'method',\n        value:\n            ({ value, inverted, deep }) =>\n            (other: any, message?: string) => {\n                if (deep) {\n                    if (inverted) {\n                        notDeepEqual(value, other, message);\n                    } else {\n                        deepEqual(value, other, message);\n                    }\n                    return;\n                }\n                if (inverted) {\n                    notEqual(value, other, message);\n                } else {\n                    equal(value, other, message);\n                }\n            }\n    },\n    eq: { type: 'alias', value: 'equal' }\n});\n"],"mappings":";;;;;;AAgBAA,mBAAI;CACA,OAAO;EACH,MAAM;EACN,QACK,EAAE,OAAO,UAAU,YACnB,OAAY,YAAqB;AAC9B,OAAI,MAAM;AACN,QAAI,SACA,iCAAa,OAAO,OAAO,QAAQ;QAEnC,8BAAU,OAAO,OAAO,QAAQ;AAEpC;;AAEJ,OAAI,SACA,wBAAS,OAAO,OAAO,QAAQ;OAE/B,qBAAM,OAAO,OAAO,QAAQ;;EAG3C;CACD,IAAI;EAAE,MAAM;EAAS,OAAO;EAAS;CACxC,CAAC"}

package/dist/expect/equal.js

@@ -0,0 +1,28 @@
+import { deepEqual, notDeepEqual } from "../assert/deep-equal.js";
+import { equal, notEqual } from "../assert/equal.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/equal.ts
+use({
+	equal: {
+		type: "method",
+		value: ({ value, inverted, deep }) => (other, message) => {
+			if (deep) {
+				if (inverted) notDeepEqual(value, other, message);
+				else deepEqual(value, other, message);
+				return;
+			}
+			if (inverted) notEqual(value, other, message);
+			else equal(value, other, message);
+		}
+	},
+	eq: {
+		type: "alias",
+		value: "equal"
+	}
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=equal.js.map

package/dist/expect/equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.js","names":[],"sources":["../../src/expect/equal.ts"],"sourcesContent":["import { deepEqual, equal, notDeepEqual, notEqual } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface ValueExpect<T> {\n        /**\n         * check for === equality, NaN is considered equal to NaN\n         */\n        equal(value: T, message?: string): this;\n        /**\n         * check for === equality, NaN is considered equal to NaN\n         */\n        eq(value: T, message?: string): this;\n    }\n}\n\nuse({\n    equal: {\n        type: 'method',\n        value:\n            ({ value, inverted, deep }) =>\n            (other: any, message?: string) => {\n                if (deep) {\n                    if (inverted) {\n                        notDeepEqual(value, other, message);\n                    } else {\n                        deepEqual(value, other, message);\n                    }\n                    return;\n                }\n                if (inverted) {\n                    notEqual(value, other, message);\n                } else {\n                    equal(value, other, message);\n                }\n            }\n    },\n    eq: { type: 'alias', value: 'equal' }\n});\n"],"mappings":";;;;;;AAgBA,IAAI;CACA,OAAO;EACH,MAAM;EACN,QACK,EAAE,OAAO,UAAU,YACnB,OAAY,YAAqB;AAC9B,OAAI,MAAM;AACN,QAAI,SACA,cAAa,OAAO,OAAO,QAAQ;QAEnC,WAAU,OAAO,OAAO,QAAQ;AAEpC;;AAEJ,OAAI,SACA,UAAS,OAAO,OAAO,QAAQ;OAE/B,OAAM,OAAO,OAAO,QAAQ;;EAG3C;CACD,IAAI;EAAE,MAAM;EAAS,OAAO;EAAS;CACxC,CAAC"}

package/dist/expect/excluding.cjs

@@ -0,0 +1,19 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_mixins = require('../mixins.cjs');
+const require_expect = require('../expect.cjs');
+let lodash_omit_js = require("lodash/omit.js");
+lodash_omit_js = require_rolldown_runtime.__toESM(lodash_omit_js);
+
+//#region src/expect/excluding.ts
+require_mixins.use({ excluding: {
+	type: "method",
+	value: (state) => (...keys) => {
+		return require_expect.expectChain({
+			...state,
+			value: (0, lodash_omit_js.default)(state.value, keys)
+		});
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=excluding.cjs.map

package/dist/expect/excluding.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"excluding.cjs","names":["use","expectChain"],"sources":["../../src/expect/excluding.ts"],"sourcesContent":["import omit from 'lodash/omit.js';\nimport { use } from '../mixins.js';\nimport { expectChain } from '../expect.js';\n\ndeclare module '../expect.types' {\n    interface ObjectExpect<T> {\n        /**\n         * exclude keys from object to be compared further down the chain\n         * @param keys\n         */\n        excluding<K extends keyof T>(...keys: K[]): ObjectExpect<Omit<T, K>>;\n    }\n}\n\nuse({\n    excluding: {\n        type: 'method',\n        value:\n            (state) =>\n            (...keys: string[]) => {\n                return expectChain({ ...state, value: omit(state.value, keys) });\n            }\n    }\n});\n"],"mappings":";;;;;;;AAcAA,mBAAI,EACA,WAAW;CACP,MAAM;CACN,QACK,WACA,GAAG,SAAmB;AACnB,SAAOC,2BAAY;GAAE,GAAG;GAAO,mCAAY,MAAM,OAAO,KAAK;GAAE,CAAC;;CAE3E,EACJ,CAAC"}

package/dist/expect/excluding.js

@@ -0,0 +1,18 @@
+import { use } from "../mixins.js";
+import { expectChain } from "../expect.js";
+import omit from "lodash/omit.js";
+
+//#region src/expect/excluding.ts
+use({ excluding: {
+	type: "method",
+	value: (state) => (...keys) => {
+		return expectChain({
+			...state,
+			value: omit(state.value, keys)
+		});
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=excluding.js.map

package/dist/expect/excluding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"excluding.js","names":[],"sources":["../../src/expect/excluding.ts"],"sourcesContent":["import omit from 'lodash/omit.js';\nimport { use } from '../mixins.js';\nimport { expectChain } from '../expect.js';\n\ndeclare module '../expect.types' {\n    interface ObjectExpect<T> {\n        /**\n         * exclude keys from object to be compared further down the chain\n         * @param keys\n         */\n        excluding<K extends keyof T>(...keys: K[]): ObjectExpect<Omit<T, K>>;\n    }\n}\n\nuse({\n    excluding: {\n        type: 'method',\n        value:\n            (state) =>\n            (...keys: string[]) => {\n                return expectChain({ ...state, value: omit(state.value, keys) });\n            }\n    }\n});\n"],"mappings":";;;;;AAcA,IAAI,EACA,WAAW;CACP,MAAM;CACN,QACK,WACA,GAAG,SAAmB;AACnB,SAAO,YAAY;GAAE,GAAG;GAAO,OAAO,KAAK,MAAM,OAAO,KAAK;GAAE,CAAC;;CAE3E,EACJ,CAAC"}