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

package/dist/expect/match.js

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

package/dist/expect/match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.js","names":[],"sources":["../../src/expect/match.ts"],"sourcesContent":["import { match, notMatch } 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 StringExpect<T> {\n        /**\n         * check if string matches regex\n         */\n        match(regex: RegExp): this;\n    }\n}\n\nuse({\n    match: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (regex: RegExp) => {\n                if (inverted) {\n                    notMatch(value, regex);\n                } else {\n                    match(value, regex);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAaA,IAAI,EACA,OAAO;CACH,MAAM;CACN,QACK,EAAE,OAAO,gBACT,UAAkB;AACf,MAAI,SACA,UAAS,OAAO,MAAM;MAEtB,OAAM,OAAO,MAAM;;CAGlC,EACJ,CAAC"}

package/dist/expect/members.cjs

@@ -0,0 +1,41 @@
+const require_has_members = require('../assert/has-members.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/members.ts
+require_mixins.use({
+	members: {
+		type: "method",
+		value: ({ value, inverted, same, deep, ordered, partial }) => (other, message) => {
+			if (inverted) require_has_members.notHasMembers(value, other, {
+				deep,
+				same,
+				ordered,
+				partial
+			}, message);
+			else require_has_members.hasMembers(value, other, {
+				deep,
+				same,
+				ordered,
+				partial
+			}, message);
+		}
+	},
+	same: {
+		type: "property",
+		value: (state) => {
+			state.same = true;
+			return state;
+		}
+	},
+	ordered: {
+		type: "property",
+		value: (state) => {
+			state.ordered = true;
+			return state;
+		}
+	}
+});
+
+//#endregion
+//# sourceMappingURL=members.cjs.map

package/dist/expect/members.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"members.cjs","names":["use"],"sources":["../../src/expect/members.ts"],"sourcesContent":["import { hasMembers, notHasMembers } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type DeepPartial } from '../utils/types.js';\n\ntype InferArray<T> = T extends Array<infer U> ? U : any;\n\ndeclare module '../expect.types' {\n    interface ArrayExpect<T> {\n        /**\n         * check that the members in second array are present in the first one\n         */\n        members(value: InferArray<T>[], message?: string): this;\n        same: ArrayExpect<T>;\n        ordered: ArrayExpect<T>;\n        /**\n         * Use partial matching for objects\n         * @example\n         * expect({ a: 1, b: 2 }).to.partially.eql({ a: 1 });\n         */\n        partially: ArrayExpect<DeepPartial<T>>;\n    }\n}\n\nuse({\n    members: {\n        type: 'method',\n        value:\n            ({ value, inverted, same, deep, ordered, partial }) =>\n            (other: any, message?: string) => {\n                if (inverted) {\n                    notHasMembers(value, other, { deep, same, ordered, partial }, message);\n                } else {\n                    hasMembers(value, other, { deep, same, ordered, partial }, message);\n                }\n            }\n    },\n    same: {\n        type: 'property',\n        value: (state) => {\n            state.same = true;\n            return state;\n        }\n    },\n    ordered: {\n        type: 'property',\n        value: (state) => {\n            state.ordered = true;\n            return state;\n        }\n    }\n});\n"],"mappings":";;;;;AAuBAA,mBAAI;CACA,SAAS;EACL,MAAM;EACN,QACK,EAAE,OAAO,UAAU,MAAM,MAAM,SAAS,eACxC,OAAY,YAAqB;AAC9B,OAAI,SACA,mCAAc,OAAO,OAAO;IAAE;IAAM;IAAM;IAAS;IAAS,EAAE,QAAQ;OAEtE,gCAAW,OAAO,OAAO;IAAE;IAAM;IAAM;IAAS;IAAS,EAAE,QAAQ;;EAGlF;CACD,MAAM;EACF,MAAM;EACN,QAAQ,UAAU;AACd,SAAM,OAAO;AACb,UAAO;;EAEd;CACD,SAAS;EACL,MAAM;EACN,QAAQ,UAAU;AACd,SAAM,UAAU;AAChB,UAAO;;EAEd;CACJ,CAAC"}

package/dist/expect/members.js

@@ -0,0 +1,42 @@
+import { hasMembers, notHasMembers } from "../assert/has-members.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/members.ts
+use({
+	members: {
+		type: "method",
+		value: ({ value, inverted, same, deep, ordered, partial }) => (other, message) => {
+			if (inverted) notHasMembers(value, other, {
+				deep,
+				same,
+				ordered,
+				partial
+			}, message);
+			else hasMembers(value, other, {
+				deep,
+				same,
+				ordered,
+				partial
+			}, message);
+		}
+	},
+	same: {
+		type: "property",
+		value: (state) => {
+			state.same = true;
+			return state;
+		}
+	},
+	ordered: {
+		type: "property",
+		value: (state) => {
+			state.ordered = true;
+			return state;
+		}
+	}
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=members.js.map

package/dist/expect/members.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"members.js","names":[],"sources":["../../src/expect/members.ts"],"sourcesContent":["import { hasMembers, notHasMembers } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type DeepPartial } from '../utils/types.js';\n\ntype InferArray<T> = T extends Array<infer U> ? U : any;\n\ndeclare module '../expect.types' {\n    interface ArrayExpect<T> {\n        /**\n         * check that the members in second array are present in the first one\n         */\n        members(value: InferArray<T>[], message?: string): this;\n        same: ArrayExpect<T>;\n        ordered: ArrayExpect<T>;\n        /**\n         * Use partial matching for objects\n         * @example\n         * expect({ a: 1, b: 2 }).to.partially.eql({ a: 1 });\n         */\n        partially: ArrayExpect<DeepPartial<T>>;\n    }\n}\n\nuse({\n    members: {\n        type: 'method',\n        value:\n            ({ value, inverted, same, deep, ordered, partial }) =>\n            (other: any, message?: string) => {\n                if (inverted) {\n                    notHasMembers(value, other, { deep, same, ordered, partial }, message);\n                } else {\n                    hasMembers(value, other, { deep, same, ordered, partial }, message);\n                }\n            }\n    },\n    same: {\n        type: 'property',\n        value: (state) => {\n            state.same = true;\n            return state;\n        }\n    },\n    ordered: {\n        type: 'property',\n        value: (state) => {\n            state.ordered = true;\n            return state;\n        }\n    }\n});\n"],"mappings":";;;;;AAuBA,IAAI;CACA,SAAS;EACL,MAAM;EACN,QACK,EAAE,OAAO,UAAU,MAAM,MAAM,SAAS,eACxC,OAAY,YAAqB;AAC9B,OAAI,SACA,eAAc,OAAO,OAAO;IAAE;IAAM;IAAM;IAAS;IAAS,EAAE,QAAQ;OAEtE,YAAW,OAAO,OAAO;IAAE;IAAM;IAAM;IAAS;IAAS,EAAE,QAAQ;;EAGlF;CACD,MAAM;EACF,MAAM;EACN,QAAQ,UAAU;AACd,SAAM,OAAO;AACb,UAAO;;EAEd;CACD,SAAS;EACL,MAAM;EACN,QAAQ,UAAU;AACd,SAAM,UAAU;AAChB,UAAO;;EAEd;CACJ,CAAC"}

package/dist/expect/reject.cjs

@@ -0,0 +1,14 @@
+const require_rejects = require('../assert/rejects.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/reject.ts
+require_mixins.use({ reject: {
+	type: "method",
+	value: ({ value, inverted }) => (...args) => {
+		return inverted ? require_rejects.notRejects(value, ...args) : require_rejects.rejects(value, ...args);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=reject.cjs.map

package/dist/expect/reject.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reject.cjs","names":["use","notRejects","rejects"],"sources":["../../src/expect/reject.ts"],"sourcesContent":["import { notRejects, rejects } from '../assert.js';\nimport { type State, use } from '../mixins.js';\nimport { type Constructor, type ErrorPredicate } from '../utils/process-error.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface PromiseExpect<T> {\n        /**\n         * check if promise rejects\n         * @param message\n         */\n        reject(message?: string): Promise<void>;\n        reject(matcher: RegExp | Constructor<Error> | ErrorPredicate): Promise<void>;\n    }\n}\n\nuse({\n    reject: {\n        type: 'method',\n        value:\n            ({ value, inverted }: State<any>) =>\n            (...args: any[]) => {\n                return inverted ? notRejects(value, ...args) : rejects(value, ...args);\n            }\n    }\n});\n"],"mappings":";;;;;AAgBAA,mBAAI,EACA,QAAQ;CACJ,MAAM;CACN,QACK,EAAE,OAAO,gBACT,GAAG,SAAgB;AAChB,SAAO,WAAWC,2BAAW,OAAO,GAAG,KAAK,GAAGC,wBAAQ,OAAO,GAAG,KAAK;;CAEjF,EACJ,CAAC"}

package/dist/expect/reject.js

@@ -0,0 +1,15 @@
+import { notRejects, rejects } from "../assert/rejects.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/reject.ts
+use({ reject: {
+	type: "method",
+	value: ({ value, inverted }) => (...args) => {
+		return inverted ? notRejects(value, ...args) : rejects(value, ...args);
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=reject.js.map

package/dist/expect/reject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reject.js","names":[],"sources":["../../src/expect/reject.ts"],"sourcesContent":["import { notRejects, rejects } from '../assert.js';\nimport { type State, use } from '../mixins.js';\nimport { type Constructor, type ErrorPredicate } from '../utils/process-error.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface PromiseExpect<T> {\n        /**\n         * check if promise rejects\n         * @param message\n         */\n        reject(message?: string): Promise<void>;\n        reject(matcher: RegExp | Constructor<Error> | ErrorPredicate): Promise<void>;\n    }\n}\n\nuse({\n    reject: {\n        type: 'method',\n        value:\n            ({ value, inverted }: State<any>) =>\n            (...args: any[]) => {\n                return inverted ? notRejects(value, ...args) : rejects(value, ...args);\n            }\n    }\n});\n"],"mappings":";;;;;AAgBA,IAAI,EACA,QAAQ;CACJ,MAAM;CACN,QACK,EAAE,OAAO,gBACT,GAAG,SAAgB;AAChB,SAAO,WAAW,WAAW,OAAO,GAAG,KAAK,GAAG,QAAQ,OAAO,GAAG,KAAK;;CAEjF,EACJ,CAAC"}

package/dist/expect/round-to.cjs

@@ -0,0 +1,15 @@
+const require_round_to = require('../assert/round-to.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/round-to.ts
+require_mixins.use({ roundTo: {
+	type: "method",
+	value: ({ value, inverted }) => (target, decimal = 0) => {
+		if (inverted) require_round_to.notRoundTo(value, target, decimal);
+		else require_round_to.roundTo(value, target, decimal);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=round-to.cjs.map

package/dist/expect/round-to.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"round-to.cjs","names":["use"],"sources":["../../src/expect/round-to.ts"],"sourcesContent":["import { notRoundTo, roundTo } 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 target\n         * @param decimal defaults to 0, can be negative if trying to round down to nearest 10, 100, etc\n         */\n        roundTo(target: number, decimal?: number): this;\n    }\n}\n\nuse({\n    roundTo: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (target, decimal = 0) => {\n                if (inverted) {\n                    notRoundTo(value, target, decimal);\n                } else {\n                    roundTo(value, target, decimal);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcAA,mBAAI,EACA,SAAS;CACL,MAAM;CACN,QACK,EAAE,OAAO,gBACT,QAAQ,UAAU,MAAM;AACrB,MAAI,SACA,6BAAW,OAAO,QAAQ,QAAQ;MAElC,0BAAQ,OAAO,QAAQ,QAAQ;;CAG9C,EACJ,CAAC"}

package/dist/expect/round-to.js

@@ -0,0 +1,16 @@
+import { notRoundTo, roundTo } from "../assert/round-to.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/round-to.ts
+use({ roundTo: {
+	type: "method",
+	value: ({ value, inverted }) => (target, decimal = 0) => {
+		if (inverted) notRoundTo(value, target, decimal);
+		else roundTo(value, target, decimal);
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=round-to.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"round-to.js","names":[],"sources":["../../src/expect/round-to.ts"],"sourcesContent":["import { notRoundTo, roundTo } 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 target\n         * @param decimal defaults to 0, can be negative if trying to round down to nearest 10, 100, etc\n         */\n        roundTo(target: number, decimal?: number): this;\n    }\n}\n\nuse({\n    roundTo: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (target, decimal = 0) => {\n                if (inverted) {\n                    notRoundTo(value, target, decimal);\n                } else {\n                    roundTo(value, target, decimal);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcA,IAAI,EACA,SAAS;CACL,MAAM;CACN,QACK,EAAE,OAAO,gBACT,QAAQ,UAAU,MAAM;AACrB,MAAI,SACA,YAAW,OAAO,QAAQ,QAAQ;MAElC,SAAQ,OAAO,QAAQ,QAAQ;;CAG9C,EACJ,CAAC"}

package/dist/expect/start-with.cjs

@@ -0,0 +1,15 @@
+const require_starts_with = require('../assert/starts-with.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/start-with.ts
+require_mixins.use({ startWith: {
+	type: "method",
+	value: ({ value, inverted }) => (start) => {
+		if (inverted) require_starts_with.notStartsWith(value, start);
+		else require_starts_with.startsWith(value, start);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=start-with.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"start-with.cjs","names":["use"],"sources":["../../src/expect/start-with.ts"],"sourcesContent":["import { startsWith, notStartsWith } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface StringExpect {\n        /**\n         * check if string starts with other string\n         * @param start\n         * @example startsWith('foo', 'f');\n         */\n        startWith(start: string): this;\n    }\n}\n\nuse({\n    startWith: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (start: string) => {\n                if (inverted) {\n                    notStartsWith(value, start);\n                } else {\n                    startsWith(value, start);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcAA,mBAAI,EACA,WAAW;CACP,MAAM;CACN,QACK,EAAE,OAAO,gBACT,UAAkB;AACf,MAAI,SACA,mCAAc,OAAO,MAAM;MAE3B,gCAAW,OAAO,MAAM;;CAGvC,EACJ,CAAC"}

package/dist/expect/start-with.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"start-with.js","names":[],"sources":["../../src/expect/start-with.ts"],"sourcesContent":["import { startsWith, notStartsWith } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface StringExpect {\n        /**\n         * check if string starts with other string\n         * @param start\n         * @example startsWith('foo', 'f');\n         */\n        startWith(start: string): this;\n    }\n}\n\nuse({\n    startWith: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (start: string) => {\n                if (inverted) {\n                    notStartsWith(value, start);\n                } else {\n                    startsWith(value, start);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcA,IAAI,EACA,WAAW;CACP,MAAM;CACN,QACK,EAAE,OAAO,gBACT,UAAkB;AACf,MAAI,SACA,eAAc,OAAO,MAAM;MAE3B,YAAW,OAAO,MAAM;;CAGvC,EACJ,CAAC"}

package/dist/expect/throw.cjs

@@ -0,0 +1,14 @@
+const require_throws = require('../assert/throws.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/throw.ts
+require_mixins.use({ throw: {
+	type: "method",
+	value: ({ value, inverted }) => (...args) => {
+		return inverted ? require_throws.notThrows(value, ...args) : require_throws.throws(value, ...args);
+	}
+} });
+
+//#endregion
+//# sourceMappingURL=throw.cjs.map

package/dist/expect/throw.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw.cjs","names":["use","notThrows","throws"],"sources":["../../src/expect/throw.ts"],"sourcesContent":["import { notThrows, throws } from '../assert.js';\nimport { type State, use } from '../mixins.js';\nimport { type Constructor, type ErrorPredicate } from '../utils/process-error.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface FunctionExpect<T> {\n        /**\n         * check if function throws\n         * @param message\n         */\n        throw(message?: string): this;\n        throw(matcher: RegExp | Constructor<Error> | ErrorPredicate, message?: string): this;\n    }\n}\n\nuse({\n    throw: {\n        type: 'method',\n        value:\n            ({ value, inverted }: State<any>) =>\n            (...args: any[]) => {\n                return inverted ? notThrows(value, ...args) : throws(value, ...args);\n            }\n    }\n});\n"],"mappings":";;;;;AAgBAA,mBAAI,EACA,OAAO;CACH,MAAM;CACN,QACK,EAAE,OAAO,gBACT,GAAG,SAAgB;AAChB,SAAO,WAAWC,yBAAU,OAAO,GAAG,KAAK,GAAGC,sBAAO,OAAO,GAAG,KAAK;;CAE/E,EACJ,CAAC"}

package/dist/expect/throw.js

@@ -0,0 +1,15 @@
+import { notThrows, throws } from "../assert/throws.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/throw.ts
+use({ throw: {
+	type: "method",
+	value: ({ value, inverted }) => (...args) => {
+		return inverted ? notThrows(value, ...args) : throws(value, ...args);
+	}
+} });
+
+//#endregion
+export {  };
+//# sourceMappingURL=throw.js.map

package/dist/expect/throw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw.js","names":[],"sources":["../../src/expect/throw.ts"],"sourcesContent":["import { notThrows, throws } from '../assert.js';\nimport { type State, use } from '../mixins.js';\nimport { type Constructor, type ErrorPredicate } from '../utils/process-error.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface FunctionExpect<T> {\n        /**\n         * check if function throws\n         * @param message\n         */\n        throw(message?: string): this;\n        throw(matcher: RegExp | Constructor<Error> | ErrorPredicate, message?: string): this;\n    }\n}\n\nuse({\n    throw: {\n        type: 'method',\n        value:\n            ({ value, inverted }: State<any>) =>\n            (...args: any[]) => {\n                return inverted ? notThrows(value, ...args) : throws(value, ...args);\n            }\n    }\n});\n"],"mappings":";;;;;AAgBA,IAAI,EACA,OAAO;CACH,MAAM;CACN,QACK,EAAE,OAAO,gBACT,GAAG,SAAgB;AAChB,SAAO,WAAW,UAAU,OAAO,GAAG,KAAK,GAAG,OAAO,OAAO,GAAG,KAAK;;CAE/E,EACJ,CAAC"}

package/dist/expect/type-shorthand.cjs

@@ -0,0 +1,29 @@
+const require_is_type = require('../assert/is-type.cjs');
+require('../assert.cjs');
+const require_mixins = require('../mixins.cjs');
+
+//#region src/expect/type-shorthand.ts
+require_mixins.use(Object.fromEntries([
+	"NaN",
+	"array",
+	"bigint",
+	"boolean",
+	"function",
+	"null",
+	"number",
+	"object",
+	"string",
+	"symbol",
+	"undefined"
+].map((type) => {
+	return [type, {
+		type: "method",
+		value: ({ value, inverted }) => () => {
+			if (inverted) require_is_type.notIsType(value, type);
+			else require_is_type.isType(value, type);
+		}
+	}];
+})));
+
+//#endregion
+//# sourceMappingURL=type-shorthand.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-shorthand.cjs","names":["use"],"sources":["../../src/expect/type-shorthand.ts"],"sourcesContent":["import { isType, notIsType } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type ValueType } from '../utils/get-type.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface NumberExpect<T> {\n        /**\n         * check if value is a number\n         */\n        number(): this;\n        /**\n         * check if value is a NaN\n         */\n        NaN(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ArrayExpect<T> {\n        /**\n         * check if value is an array\n         */\n        array(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface BigIntExpect<T> {\n        /**\n         * check if value is a bigint\n         */\n        bigint(): this;\n    }\n    interface BooleanExpect {\n        /**\n         * check if value is a boolean\n         */\n        boolean(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface FunctionExpect<T> {\n        /**\n         * check if value is a function\n         */\n        function(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ValueExpect<T> {\n        /**\n         * check if value is null\n         */\n        null(): this;\n        /**\n         * check if value is undefined\n         */\n        undefined(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ObjectExpect<T> {\n        /**\n         * check if value is a plain object\n         */\n        object(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface StringExpect<T> {\n        /**\n         * check if value is a string\n         */\n        string(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface SymbolExpect<T> {\n        /**\n         * check if value is a symbol\n         */\n        symbol(): this;\n    }\n}\n\nconst types: ValueType[] = [\n    'NaN',\n    'array',\n    'bigint',\n    'boolean',\n    'function',\n    'null',\n    'number',\n    'object',\n    'string',\n    'symbol',\n    'undefined'\n];\n\nuse(\n    Object.fromEntries(\n        types.map((type) => {\n            return [\n                type,\n                {\n                    type: 'method',\n                    value:\n                        ({ value, inverted }) =>\n                        () => {\n                            if (inverted) {\n                                notIsType(value, type);\n                            } else {\n                                isType(value, type);\n                            }\n                        }\n                }\n            ];\n        })\n    )\n);\n"],"mappings":";;;;;AA2FAA,mBACI,OAAO,YAfgB;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACH,CAIa,KAAK,SAAS;AAChB,QAAO,CACH,MACA;EACI,MAAM;EACN,QACK,EAAE,OAAO,qBACJ;AACF,OAAI,SACA,2BAAU,OAAO,KAAK;OAEtB,wBAAO,OAAO,KAAK;;EAGlC,CACJ;EACH,CACL,CACJ"}

package/dist/expect/type-shorthand.js

@@ -0,0 +1,30 @@
+import { isType, notIsType } from "../assert/is-type.js";
+import "../assert.js";
+import { use } from "../mixins.js";
+
+//#region src/expect/type-shorthand.ts
+use(Object.fromEntries([
+	"NaN",
+	"array",
+	"bigint",
+	"boolean",
+	"function",
+	"null",
+	"number",
+	"object",
+	"string",
+	"symbol",
+	"undefined"
+].map((type) => {
+	return [type, {
+		type: "method",
+		value: ({ value, inverted }) => () => {
+			if (inverted) notIsType(value, type);
+			else isType(value, type);
+		}
+	}];
+})));
+
+//#endregion
+export {  };
+//# sourceMappingURL=type-shorthand.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-shorthand.js","names":[],"sources":["../../src/expect/type-shorthand.ts"],"sourcesContent":["import { isType, notIsType } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type ValueType } from '../utils/get-type.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface NumberExpect<T> {\n        /**\n         * check if value is a number\n         */\n        number(): this;\n        /**\n         * check if value is a NaN\n         */\n        NaN(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ArrayExpect<T> {\n        /**\n         * check if value is an array\n         */\n        array(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface BigIntExpect<T> {\n        /**\n         * check if value is a bigint\n         */\n        bigint(): this;\n    }\n    interface BooleanExpect {\n        /**\n         * check if value is a boolean\n         */\n        boolean(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface FunctionExpect<T> {\n        /**\n         * check if value is a function\n         */\n        function(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ValueExpect<T> {\n        /**\n         * check if value is null\n         */\n        null(): this;\n        /**\n         * check if value is undefined\n         */\n        undefined(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ObjectExpect<T> {\n        /**\n         * check if value is a plain object\n         */\n        object(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface StringExpect<T> {\n        /**\n         * check if value is a string\n         */\n        string(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface SymbolExpect<T> {\n        /**\n         * check if value is a symbol\n         */\n        symbol(): this;\n    }\n}\n\nconst types: ValueType[] = [\n    'NaN',\n    'array',\n    'bigint',\n    'boolean',\n    'function',\n    'null',\n    'number',\n    'object',\n    'string',\n    'symbol',\n    'undefined'\n];\n\nuse(\n    Object.fromEntries(\n        types.map((type) => {\n            return [\n                type,\n                {\n                    type: 'method',\n                    value:\n                        ({ value, inverted }) =>\n                        () => {\n                            if (inverted) {\n                                notIsType(value, type);\n                            } else {\n                                isType(value, type);\n                            }\n                        }\n                }\n            ];\n        })\n    )\n);\n"],"mappings":";;;;;AA2FA,IACI,OAAO,YAfgB;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACH,CAIa,KAAK,SAAS;AAChB,QAAO,CACH,MACA;EACI,MAAM;EACN,QACK,EAAE,OAAO,qBACJ;AACF,OAAI,SACA,WAAU,OAAO,KAAK;OAEtB,QAAO,OAAO,KAAK;;EAGlC,CACJ;EACH,CACL,CACJ"}

package/dist/expect/type.cjs

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

package/dist/expect/type.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.cjs","names":["use"],"sources":["../../src/expect/type.ts"],"sourcesContent":["import { notIsType, isType } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type ValueType } from '../utils/get-type.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ValueExpect<T> {\n        /**\n         * check if value is of certain type\n         */\n        type(type: ValueType): this;\n    }\n}\n\nuse({\n    type: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (type: ValueType) => {\n                if (inverted) {\n                    notIsType(value, type);\n                } else {\n                    isType(value, type);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcAA,mBAAI,EACA,MAAM;CACF,MAAM;CACN,QACK,EAAE,OAAO,gBACT,SAAoB;AACjB,MAAI,SACA,2BAAU,OAAO,KAAK;MAEtB,wBAAO,OAAO,KAAK;;CAGlC,EACJ,CAAC"}

package/dist/expect/type.js

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

package/dist/expect/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","names":[],"sources":["../../src/expect/type.ts"],"sourcesContent":["import { notIsType, isType } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type ValueType } from '../utils/get-type.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ValueExpect<T> {\n        /**\n         * check if value is of certain type\n         */\n        type(type: ValueType): this;\n    }\n}\n\nuse({\n    type: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (type: ValueType) => {\n                if (inverted) {\n                    notIsType(value, type);\n                } else {\n                    isType(value, type);\n                }\n            }\n    }\n});\n"],"mappings":";;;;;AAcA,IAAI,EACA,MAAM;CACF,MAAM;CACN,QACK,EAAE,OAAO,gBACT,SAAoB;AACjB,MAAI,SACA,WAAU,OAAO,KAAK;MAEtB,QAAO,OAAO,KAAK;;CAGlC,EACJ,CAAC"}

package/dist/expect.cjs

@@ -0,0 +1,144 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_mixins = require('./mixins.cjs');
+const require_chain = require('./utils/chain.cjs');
+const require_get_size = require('./utils/get-size.cjs');
+require('./expect/after.cjs');
+require('./expect/ballpark.cjs');
+require('./expect/before.cjs');
+require('./expect/between.cjs');
+require('./expect/empty.cjs');
+require('./expect/end-with.cjs');
+require('./expect/eql.cjs');
+require('./expect/equal-shorthand.cjs');
+require('./expect/equal.cjs');
+require('./expect/excluding.cjs');
+require('./expect/greater-than-equal.cjs');
+require('./expect/greater-than.cjs');
+require('./expect/has-property.cjs');
+require('./expect/include.cjs');
+require('./expect/instance-of-shorthand.cjs');
+require('./expect/instance-of.cjs');
+require('./expect/keys.cjs');
+require('./expect/length.cjs');
+require('./expect/less-than-equal.cjs');
+require('./expect/less-than.cjs');
+require('./expect/match.cjs');
+require('./expect/members.cjs');
+require('./expect/reject.cjs');
+require('./expect/round-to.cjs');
+require('./expect/start-with.cjs');
+require('./expect/throw.cjs');
+require('./expect/type-shorthand.cjs');
+require('./expect/type.cjs');
+const require_fail = require('./utils/fail.cjs');
+let lodash_mapValues_js = require("lodash/mapValues.js");
+lodash_mapValues_js = require_rolldown_runtime.__toESM(lodash_mapValues_js);
+
+//#region src/expect.ts
+require_mixins.use({
+	to: {
+		type: "property",
+		value: () => null
+	},
+	be: {
+		type: "property",
+		value: () => null
+	},
+	a: {
+		type: "property",
+		value: () => null
+	},
+	an: {
+		type: "property",
+		value: () => null
+	},
+	and: {
+		type: "property",
+		value: ({ value, every,...rest }) => {
+			const values = (0, lodash_mapValues_js.default)(rest, () => {});
+			return {
+				value,
+				every,
+				...values
+			};
+		}
+	},
+	have: {
+		type: "property",
+		value: () => null
+	},
+	in: {
+		type: "property",
+		value: () => null
+	},
+	not: {
+		type: "property",
+		value: (state) => ({
+			...state,
+			inverted: !state.inverted
+		})
+	},
+	of: {
+		type: "property",
+		value: () => null
+	},
+	length: {
+		type: "property",
+		value: (state) => ({
+			...state,
+			getProperty: require_get_size.getSize
+		})
+	},
+	deep: {
+		type: "property",
+		value: (state) => ({
+			...state,
+			deep: true
+		})
+	},
+	every: {
+		type: "property",
+		value: (state) => ({
+			...state,
+			every: true
+		})
+	}
+});
+const expectChain = (state) => {
+	const chain = {};
+	for (const [key, v] of Object.entries(require_mixins.mixins)) {
+		const definition = v.type === "alias" ? require_mixins.mixins[v.value] : v;
+		if (definition.type === "property") require_chain.registerProperty(chain, key, () => {
+			const newState = definition.value(state);
+			return expectChain({
+				...state,
+				...newState
+			});
+		});
+		else if (definition.type === "method") require_chain.registerMethod(chain, key, (...args) => {
+			if (state.getProperty) definition.value({
+				value: state.getProperty(state.value),
+				inverted: state.inverted
+			})(...args);
+			else if (state.every) for (const value of state.value) definition.value({
+				...state,
+				value
+			})(...args);
+			else {
+				const result = definition.value({ ...state })(...args);
+				if (result) return result;
+			}
+			return expectChain(state);
+		});
+	}
+	return chain;
+};
+const expect = ((actual) => {
+	return expectChain({ value: actual });
+});
+expect.fail = require_fail.fail;
+
+//#endregion
+exports.expect = expect;
+exports.expectChain = expectChain;
+//# sourceMappingURL=expect.cjs.map

package/dist/expect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.cjs","names":["use","getSize","mixins","fail"],"sources":["../src/expect.ts"],"sourcesContent":["import { mixins, type State, use } from './mixins.js';\nimport { registerMethod, registerProperty } from './utils/chain.js';\nimport { getSize } from './utils/get-size.js';\nimport './expect/after.js';\nimport './expect/ballpark.js';\nimport './expect/before.js';\nimport './expect/between.js';\nimport './expect/empty.js';\nimport './expect/end-with.js';\nimport './expect/eql.js';\nimport './expect/equal-shorthand.js';\nimport './expect/equal.js';\nimport './expect/excluding.js';\nimport './expect/greater-than-equal.js';\nimport './expect/greater-than.js';\nimport './expect/has-property.js';\nimport './expect/include.js';\nimport './expect/instance-of-shorthand.js';\nimport './expect/instance-of.js';\nimport './expect/keys.js';\nimport './expect/length.js';\nimport './expect/less-than-equal.js';\nimport './expect/less-than.js';\nimport './expect/match.js';\nimport './expect/members.js';\nimport './expect/reject.js';\nimport './expect/round-to.js';\nimport './expect/start-with.js';\nimport './expect/throw.js';\nimport './expect/type-shorthand.js';\nimport './expect/type.js';\nimport mapValues from 'lodash/mapValues.js';\nimport { fail } from './utils/fail.js';\nimport { type Expect } from './expect.types.js';\n\nuse({\n    to: { type: 'property', value: () => null },\n    be: { type: 'property', value: () => null },\n    a: { type: 'property', value: () => null },\n    an: { type: 'property', value: () => null },\n    and: {\n        type: 'property',\n        value: ({ value, every, ...rest }) => {\n            const values = mapValues(rest, () => {}) as any;\n            return { value, every, ...values };\n        }\n    },\n    have: { type: 'property', value: () => null },\n    in: { type: 'property', value: () => null },\n    not: { type: 'property', value: (state) => ({ ...state, inverted: !state.inverted }) },\n    of: { type: 'property', value: () => null },\n\n    length: { type: 'property', value: (state) => ({ ...state, getProperty: getSize }) },\n    deep: { type: 'property', value: (state) => ({ ...state, deep: true }) },\n\n    every: { type: 'property', value: (state) => ({ ...state, every: true }) }\n});\n\nexport const expectChain = <T>(state: State<T>) => {\n    const chain = {} as any;\n    for (const [key, v] of Object.entries(mixins)) {\n        const definition = v.type === 'alias' ? mixins[v.value] : v;\n        if (definition.type === 'property') {\n            registerProperty(chain, key, () => {\n                const newState = definition.value(state);\n                return expectChain({ ...state, ...newState });\n            });\n        } else if (definition.type === 'method') {\n            registerMethod(chain, key, (...args: any[]) => {\n                if (state.getProperty) {\n                    definition.value({ value: state.getProperty(state.value), inverted: state.inverted })(...args);\n                } else if (state.every) {\n                    for (const value of state.value as any) {\n                        definition.value({ ...state, value })(...args);\n                    }\n                } else {\n                    const result = definition.value({ ...state })(...args);\n                    if (result as any) {\n                        return result;\n                    }\n                }\n                return expectChain(state);\n            });\n        }\n    }\n    return chain;\n};\n\nexport const expect = (<T>(actual: T) => {\n    return expectChain({ value: actual });\n}) as Expect;\n\nexpect.fail = fail;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCAA,mBAAI;CACA,IAAI;EAAE,MAAM;EAAY,aAAa;EAAM;CAC3C,IAAI;EAAE,MAAM;EAAY,aAAa;EAAM;CAC3C,GAAG;EAAE,MAAM;EAAY,aAAa;EAAM;CAC1C,IAAI;EAAE,MAAM;EAAY,aAAa;EAAM;CAC3C,KAAK;EACD,MAAM;EACN,QAAQ,EAAE,OAAO,MAAO,GAAG,WAAW;GAClC,MAAM,0CAAmB,YAAY,GAAG;AACxC,UAAO;IAAE;IAAO;IAAO,GAAG;IAAQ;;EAEzC;CACD,MAAM;EAAE,MAAM;EAAY,aAAa;EAAM;CAC7C,IAAI;EAAE,MAAM;EAAY,aAAa;EAAM;CAC3C,KAAK;EAAE,MAAM;EAAY,QAAQ,WAAW;GAAE,GAAG;GAAO,UAAU,CAAC,MAAM;GAAU;EAAG;CACtF,IAAI;EAAE,MAAM;EAAY,aAAa;EAAM;CAE3C,QAAQ;EAAE,MAAM;EAAY,QAAQ,WAAW;GAAE,GAAG;GAAO,aAAaC;GAAS;EAAG;CACpF,MAAM;EAAE,MAAM;EAAY,QAAQ,WAAW;GAAE,GAAG;GAAO,MAAM;GAAM;EAAG;CAExE,OAAO;EAAE,MAAM;EAAY,QAAQ,WAAW;GAAE,GAAG;GAAO,OAAO;GAAM;EAAG;CAC7E,CAAC;AAEF,MAAa,eAAkB,UAAoB;CAC/C,MAAM,QAAQ,EAAE;AAChB,MAAK,MAAM,CAAC,KAAK,MAAM,OAAO,QAAQC,sBAAO,EAAE;EAC3C,MAAM,aAAa,EAAE,SAAS,UAAUA,sBAAO,EAAE,SAAS;AAC1D,MAAI,WAAW,SAAS,WACpB,gCAAiB,OAAO,WAAW;GAC/B,MAAM,WAAW,WAAW,MAAM,MAAM;AACxC,UAAO,YAAY;IAAE,GAAG;IAAO,GAAG;IAAU,CAAC;IAC/C;WACK,WAAW,SAAS,SAC3B,8BAAe,OAAO,MAAM,GAAG,SAAgB;AAC3C,OAAI,MAAM,YACN,YAAW,MAAM;IAAE,OAAO,MAAM,YAAY,MAAM,MAAM;IAAE,UAAU,MAAM;IAAU,CAAC,CAAC,GAAG,KAAK;YACvF,MAAM,MACb,MAAK,MAAM,SAAS,MAAM,MACtB,YAAW,MAAM;IAAE,GAAG;IAAO;IAAO,CAAC,CAAC,GAAG,KAAK;QAE/C;IACH,MAAM,SAAS,WAAW,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,KAAK;AACtD,QAAI,OACA,QAAO;;AAGf,UAAO,YAAY,MAAM;IAC3B;;AAGV,QAAO;;AAGX,MAAa,WAAc,WAAc;AACrC,QAAO,YAAY,EAAE,OAAO,QAAQ,CAAC;;AAGzC,OAAO,OAAOC"}

package/dist/expect.d.cts

@@ -0,0 +1,10 @@
+import { State } from "./mixins.cjs";
+import { Expect } from "./expect.types.cjs";
+
+//#region src/expect.d.ts
+
+declare const expectChain: <T>(state: State<T>) => any;
+declare const expect: Expect;
+//#endregion
+export { expect, expectChain };
+//# sourceMappingURL=expect.d.cts.map

package/dist/expect.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.d.cts","names":[],"sources":["../src/expect.ts"],"sourcesContent":[],"mappings":";;;;;cA0Da,wBAAyB,MAAM;cA8B/B,QAEP"}

package/dist/expect.d.ts

@@ -0,0 +1,10 @@
+import { State } from "./mixins.js";
+import { Expect } from "./expect.types.js";
+
+//#region src/expect.d.ts
+
+declare const expectChain: <T>(state: State<T>) => any;
+declare const expect: Expect;
+//#endregion
+export { expect, expectChain };
+//# sourceMappingURL=expect.d.ts.map

package/dist/expect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.d.ts","names":[],"sources":["../src/expect.ts"],"sourcesContent":[],"mappings":";;;;;cA0Da,wBAAyB,MAAM;cA8B/B,QAEP"}