hein 1.4.2 → 2.0.0-alpha.0

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,qCAAmC;AACnC,uCAAsD;AAA7C,yGAAA,gBAAgB,OAAA;AAAE,4FAAA,GAAG,OAAA;AAC9B,mCAA+D;AAAtD,6FAAA,GAAG,OAAA;AACZ,6DAAsD;AAA7C,sHAAA,cAAc,OAAA;AAGvB,qCAAoC;AAA3B,4FAAA,IAAI,OAAA"}
+{"version":3,"file":"index.js","names":["mixins: Record<string, Property | Method | Alias>","AssertionError"],"sources":["../src/mixins.ts","../src/utils/chain.ts","../src/utils/get-size.ts","../src/expect/after.ts","../src/expect/ballpark.ts","../src/expect/before.ts","../src/expect/between.ts","../src/expect/empty.ts","../src/expect/end-with.ts","../src/expect/eql.ts","../src/expect/equal-shorthand.ts","../src/expect/equal.ts","../src/expect/excluding.ts","../src/expect/greater-than-equal.ts","../src/expect/greater-than.ts","../src/expect/has-property.ts","../src/expect/include.ts","../src/expect/instance-of-shorthand.ts","../src/expect/instance-of.ts","../src/expect/keys.ts","../src/expect/length.ts","../src/expect/less-than-equal.ts","../src/expect/less-than.ts","../src/expect/match.ts","../src/expect/members.ts","../src/expect/reject.ts","../src/expect/round-to.ts","../src/expect/start-with.ts","../src/expect/throw.ts","../src/expect/type-shorthand.ts","../src/expect/type.ts","../src/utils/fail.ts","../src/expect.ts"],"sourcesContent":["export interface State<T> {\n    inverted?: boolean;\n    value?: T;\n    getProperty?: (value: T) => any;\n    deep?: boolean;\n    same?: boolean;\n    ordered?: boolean;\n    partial?: boolean;\n\n    every?: boolean;\n}\n\nexport interface Property {\n    type: 'property';\n    value: (state: State<any>) => Partial<State<any>> | null;\n}\n\ntype MethodCallback = (state: State<any>) => (...args: any[]) => void;\n\nexport interface Method {\n    type: 'method';\n    value: MethodCallback;\n}\n\nexport interface Alias {\n    type: 'alias';\n    value: string;\n}\n\nexport const mixins: Record<string, Property | Method | Alias> = {};\n\nexport const use = (plugins: Record<string, Property | Method | Alias>) => {\n    Object.assign(mixins, plugins);\n};\n","export const registerProperty = <T, U extends string, V extends () => any>(object: T, name: U, value: V) => {\n    Object.defineProperty(object, name, {\n        enumerable: true,\n        get() {\n            return value();\n        }\n    });\n    return object as T & Record<U, V>;\n};\n\nexport const registerMethod = <T, U extends string, V>(object: T, name: U, value: V) => {\n    Object.defineProperty(object, name, {\n        value\n    });\n    return object as T & Record<U, V>;\n};\n","import isPlainObject from 'lodash/isPlainObject.js';\n\nexport const getSize = (value: any) => {\n    if (Array.isArray(value)) {\n        return value.length;\n    }\n    if (isPlainObject(value)) {\n        return Object.keys(value).length;\n    }\n    if (value instanceof Map) {\n        return value.size;\n    }\n    if (value instanceof Set) {\n        return value.size;\n    }\n    if (typeof value === 'string') {\n        return value.length;\n    }\n    return 0;\n};\n","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","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","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","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","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","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","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","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","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","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","import { greaterThanEqual, notGreaterThanEqual } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface NumberExpect<T> {\n        /**\n         * check if actual is greater than or equal to expected\n         */\n        greaterThanOrEqual(value: T): this;\n        /**\n         * check if actual is greater than or equal to expected\n         */\n        gte(value: T): this;\n        /**\n         * check if actual is greater than or equal to expected\n         */\n        atLeast(value: T): this;\n    }\n    interface DateExpect<T> {\n        /**\n         * check if actual is greater than or equal to expected\n         */\n        greaterThanOrEqual(value: T): this;\n        /**\n         * check if actual is greater than or equal to expected\n         */\n        gte(value: T): this;\n        /**\n         * check if actual is greater than or equal to expected\n         */\n        atLeast(value: T): this;\n    }\n}\n\nuse({\n    greaterThanOrEqual: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (other: any) => {\n                if (inverted) {\n                    notGreaterThanEqual(value, other);\n                } else {\n                    greaterThanEqual(value, other);\n                }\n            }\n    },\n    gte: { type: 'alias', value: 'greaterThanOrEqual' },\n    atLeast: { type: 'alias', value: 'greaterThanOrEqual' }\n});\n","import { greaterThan, notGreaterThan } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface NumberExpect<T> {\n        /**\n         * check if actual is greater than expected\n         */\n        greaterThan(value: T): this;\n        /**\n         * check if actual is greater than expected\n         */\n        gt(value: T): this;\n        /**\n         * check if actual is greater than expected\n         */\n        above(value: T): this;\n    }\n    interface DateExpect<T> {\n        /**\n         * check if actual is greater than expected\n         */\n        greaterThan(value: T): this;\n        /**\n         * check if actual is greater than expected\n         */\n        gt(value: T): this;\n        /**\n         * check if actual is greater than expected\n         */\n        above(value: T): this;\n    }\n}\n\nuse({\n    greaterThan: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (other: any) => {\n                if (inverted) {\n                    notGreaterThan(value, other);\n                } else {\n                    greaterThan(value, other);\n                }\n            }\n    },\n    gt: { type: 'alias', value: 'greaterThan' },\n    above: { type: 'alias', value: 'greaterThan' }\n});\n","import { deepHasProperty, deepNotHasProperty, hasProperty, notHasProperty } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface ValueExpect<T> {\n        /**\n         * check if value has a property\n         * @param property a property in the object. When combined with .deep. can be a path like 'a.b.c'\n         * @example expect({a: {b: {c: 1}}}).to.have.property('a.b.c');\n         * @example expect({a: {b: {c: 1}}}).to.have.deep.property('[0].a.b.c');\n         */\n        property<K extends keyof T>(property: K): this;\n        /**\n         * check if value has a property\n         * @param property a property in the object. When combined with .deep. can be a path like 'a.b.c'\n         * @example expect({a: {b: {c: 1}}}).to.have.property('a.b.c');\n         * @example expect({a: {b: {c: 1}}}).to.have.deep.property('[0].a.b.c');\n         */\n        property(property: string): this;\n        /**\n         * check if value has a property\n         * @param property a property in the object. When combined with .deep. can be a path like 'a.b.c'\n         * @param value\n         * @example expect({a: {b: {c: 1}}}).to.have.property('a.b.c');\n         * @example expect({a: {b: {c: 1}}}).to.have.deep.property('[0].a.b.c');\n         */\n        property<K extends keyof T>(property: K, value?: any): this;\n        /**\n         * check if value has a property\n         * @param property a property in the object. When combined with .deep. can be a path like 'a.b.c'\n         * @param value\n         * @example expect({a: {b: {c: 1}}}).to.have.property('a.b.c');\n         * @example expect({a: {b: {c: 1}}}).to.have.deep.property('[0].a.b.c');\n         */\n        property(property: string, value?: any): this;\n    }\n}\n\nuse({\n    property: {\n        type: 'method',\n        value:\n            ({ value, inverted, deep }) =>\n            (...args: [any, any]) => {\n                if (deep) {\n                    if (inverted) {\n                        return deepNotHasProperty(value, ...args);\n                    }\n                    return deepHasProperty(value, ...args);\n                }\n                if (inverted) {\n                    return notHasProperty(value, ...args);\n                }\n                return hasProperty(value, ...args);\n            }\n    }\n});\n","import { includes, notIncludes } from '../assert.js';\nimport { use } from '../mixins.js';\n\ntype ArrayType<T> = T extends (infer U)[] ? U : T;\n\ndeclare module '../expect.types' {\n    interface ArrayExpect<T> {\n        /**\n         * check if array includes element(s)\n         */\n        include(...elements: ArrayType<T>[]): this;\n        /**\n         * check if array includes element(s)\n         */\n        contain(...elements: ArrayType<T>[]): this;\n    }\n    interface StringExpect {\n        /**\n         * check if string includes substring(s)\n         */\n        include(...substrings: string[]): this;\n        /**\n         * check if string includes substring(s)\n         */\n        contain(...substrings: string[]): this;\n    }\n}\n\nuse({\n    include: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (...elements: any[]) => {\n                if (inverted) {\n                    notIncludes(value, ...elements);\n                } else {\n                    includes(value, ...elements);\n                }\n            }\n    },\n    contain: {\n        type: 'alias',\n        value: 'include'\n    }\n});\n","import { instanceOf, notInstanceOf } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface DateExpect {\n        /**\n         * check if value is an instance of Date\n         */\n        Date(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ObjectExpect<T> {\n        /**\n         * check if value is an instance of Map\n         */\n        Map(): this;\n        /**\n         * check if value is an instance of Set\n         */\n        Set(): this;\n        /**\n         * check if value is an instance of WeakMap\n         */\n        WeakMap(): this;\n        /**\n         * check if value is an instance of WeakSet\n         */\n        WeakSet(): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface MapExpect<T> {\n        /**\n         * check if value is an instance of Map\n         */\n        Map(): this;\n    }\n}\n\nconst constructors = [Date, Map, Set, WeakMap, WeakSet];\n\nuse(\n    Object.fromEntries(\n        constructors.map((constructor) => {\n            return [\n                constructor.name,\n                {\n                    type: 'method',\n                    value:\n                        ({ inverted, value }) =>\n                        () => {\n                            if (inverted) {\n                                notInstanceOf(value, constructor);\n                            } else {\n                                instanceOf(value, constructor);\n                            }\n                        }\n                }\n            ];\n        })\n    )\n);\n","import { notInstanceOf, instanceOf } from '../assert.js';\nimport { use } from '../mixins.js';\nimport { type Constructor } from '../utils/process-error.js';\n\ndeclare module '../expect.types' {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ValueExpect<T> {\n        /**\n         * check if instance of value\n         * @param constructor - The constructor function to check against\n         */\n        instanceOf(constructor: Constructor): this;\n    }\n}\n\nuse({\n    instanceOf: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (constructor: Constructor) => {\n                if (inverted) {\n                    notInstanceOf(value, constructor);\n                } else {\n                    instanceOf(value, constructor);\n                }\n            }\n    }\n});\n","import { hasKeys, notHasKeys } from '../assert.js';\nimport { use } from '../mixins.js';\n\ntype InferMapKeys<T> = T extends Map<infer K, any> ? K : never;\n\ndeclare module '../expect.types' {\n    interface ObjectExpect<T> {\n        /**\n         * Check if value has keys\n         */\n        keys<K extends keyof T>(keys: K[] | K): this;\n    }\n    interface MapExpect<T> {\n        /**\n         * Check if value has keys\n         */\n        keys<K extends InferMapKeys<T>>(keys: K[] | K): this;\n    }\n}\n\nuse({\n    keys: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (keys) => {\n                if (inverted) {\n                    notHasKeys(value, keys);\n                } else {\n                    hasKeys(value, keys);\n                }\n            }\n    }\n});\n","import { hasSize, notHasSize } 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 for object/array/Map/Set/string to have a certain size\n         */\n        sizeOf(size: number, message?: string): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface MapExpect<T> {\n        /**\n         * check for Map to have a certain size\n         */\n        sizeOf(size: number, message?: string): this;\n    }\n    interface StringExpect {\n        /**\n         * check for string to have a certain size\n         */\n        lengthOf(length: number, message?: string): this;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface ArrayExpect<T> {\n        /**\n         * check for array length\n         */\n        lengthOf(length: number, message?: string): this;\n    }\n}\n\nuse({\n    sizeOf: { type: 'alias', value: 'lengthOf' },\n    lengthOf: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (length: number, message?: string) => {\n                if (inverted) {\n                    notHasSize(value, length, message);\n                } else {\n                    hasSize(value, length, message);\n                }\n            }\n    }\n});\n","import { lessThanEqual, notLessThanEqual } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface NumberExpect<T> {\n        /**\n         * check if actual is less than or equal to expected\n         */\n        lessThanOrEqual(value: T): this;\n        /**\n         * check if actual is less than or equal to expected\n         */\n        lte(value: T): this;\n        /**\n         * check if actual is less than or equal to expected\n         */\n        atMost(value: T): this;\n    }\n    interface DateExpect<T> {\n        /**\n         * check if actual is less than or equal to expected\n         */\n        lessThanOrEqual(value: T): this;\n        /**\n         * check if actual is less than or equal to expected\n         */\n        lte(value: T): this;\n        /**\n         * check if actual is less than or equal to expected\n         */\n        atMost(value: T): this;\n    }\n}\n\nuse({\n    lessThanOrEqual: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (other: any) => {\n                if (inverted) {\n                    notLessThanEqual(value, other);\n                } else {\n                    lessThanEqual(value, other);\n                }\n            }\n    },\n    lte: { type: 'alias', value: 'lessThanOrEqual' },\n    atMost: { type: 'alias', value: 'lessThanOrEqual' }\n});\n","import { lessThan, notLessThan } from '../assert.js';\nimport { use } from '../mixins.js';\n\ndeclare module '../expect.types' {\n    interface NumberExpect<T> {\n        /**\n         * check if actual is less than expected\n         */\n        lessThan(value: T): this;\n        /**\n         * check if actual is less than expected\n         */\n        lt(value: T): this;\n        /**\n         * check if actual is less than expected\n         */\n        below(value: T): this;\n    }\n    interface DateExpect<T> {\n        /**\n         * check if actual is less than expected\n         */\n        lessThan(value: T): this;\n        /**\n         * check if actual is less than expected\n         */\n        lt(value: T): this;\n        /**\n         * check if actual is less than expected\n         */\n        below(value: T): this;\n    }\n}\n\nuse({\n    lessThan: {\n        type: 'method',\n        value:\n            ({ value, inverted }) =>\n            (other: any) => {\n                if (inverted) {\n                    notLessThan(value, other);\n                } else {\n                    lessThan(value, other);\n                }\n            }\n    },\n    lt: { type: 'alias', value: 'lessThan' },\n    below: { type: 'alias', value: 'lessThan' }\n});\n","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","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","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","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","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","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","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","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","import { AssertionError } from 'hein-assertion-utils';\n\n/**\n * Throw an AssertionError\n * @param {string} message - The message to pass to the AssertionError\n */\nexport const fail = (message: string = 'Fail') => {\n    throw new AssertionError(undefined, undefined, message);\n};\n","import { mixins, State, use } from './mixins.js';\nimport { registerMethod, registerProperty } from './utils/chain.js';\nimport { getSize } from './utils/get-size.js';\nimport { Expect } from './expect.types.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';\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":"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"}

package/dist/throws-BrCCeBBl.d.ts

@@ -0,0 +1,42 @@
+import "hein-assertion-utils";
+
+//#region src/utils/process-error.d.ts
+interface Constructor<T = any> {
+  new (...args: any[]): T;
+}
+type ErrorPredicate = (error: Error) => boolean;
+//#endregion
+//#region src/assert/throws.d.ts
+type ThrowsCallback = () => unknown;
+interface Throw {
+  /**
+   * check if function throws an error
+   * @param callback
+   * @example throws(() => { throw new Error('foo'); });
+   * @example throws(() => { throw new TypeError('foo'); }, TypeError);
+   */
+  (callback: ThrowsCallback, message?: string): void;
+  /**
+   * check if function throws an error matching the constructor
+   * @param callback
+   * @example throws(() => { throw new TypeError('foo'); }, TypeError);
+   */
+  (callback: ThrowsCallback, expectedError: Constructor, message?: string): void;
+  /**
+   * check if function throws an error matching the regex
+   * @param callback
+   * @example throws(() => { throw new Error('foo'); });
+   * @example throws(() => { throw new TypeError('foo'); }, /foo/);
+   */
+  (callback: ThrowsCallback, expectedError: RegExp, message?: string): void;
+  /**
+   * check if function throws an error matching the predicate function
+   * @param callback
+   * @example throws(() => { throw new TypeError('foo'); }, (error) => error.message === 'foo');
+   */
+  (callback: ThrowsCallback, expectedError: ErrorPredicate, message?: string): void;
+}
+declare const throws: Throw, notThrows: Throw;
+//#endregion
+export { Constructor, ErrorPredicate, ThrowsCallback, notThrows, throws };
+//# sourceMappingURL=throws-BrCCeBBl.d.ts.map

package/dist/throws-BrCCeBBl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throws-BrCCeBBl.d.ts","names":[],"sources":["../src/utils/process-error.ts","../src/assert/throws.ts"],"sourcesContent":[],"mappings":";;;UAEiB;wBACS;AAD1B;AAIY,KAAA,cAAA,GAAc,CAAA,KAAW,EAAA,KAAK,EAAA,GAAA,OAAA;;;KCF9B,cAAA;UAEF,KAAA;EDJO;AAIjB;;;;ACFA;EAEU,CAAA,QAAK,EAOA,cAPA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;EAAA;;;;;WAoB+B,EAP/B,cAO+B,EAAA,aAAA,EAPA,WAOA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;AAqB9C;;;WAA+B,EArBhB,cAqBgB,EAAA,aAAA,EArBe,MAqBf,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;EAoB7B;;;;;aAnCa,+BAA+B;;cAehC,QAAM,kBAAW"}

package/dist/throws-D7JsW4NM.d.cts

@@ -0,0 +1,40 @@
+//#region src/utils/process-error.d.ts
+interface Constructor<T = any> {
+  new (...args: any[]): T;
+}
+type ErrorPredicate = (error: Error) => boolean;
+//#endregion
+//#region src/assert/throws.d.ts
+type ThrowsCallback = () => unknown;
+interface Throw {
+  /**
+   * check if function throws an error
+   * @param callback
+   * @example throws(() => { throw new Error('foo'); });
+   * @example throws(() => { throw new TypeError('foo'); }, TypeError);
+   */
+  (callback: ThrowsCallback, message?: string): void;
+  /**
+   * check if function throws an error matching the constructor
+   * @param callback
+   * @example throws(() => { throw new TypeError('foo'); }, TypeError);
+   */
+  (callback: ThrowsCallback, expectedError: Constructor, message?: string): void;
+  /**
+   * check if function throws an error matching the regex
+   * @param callback
+   * @example throws(() => { throw new Error('foo'); });
+   * @example throws(() => { throw new TypeError('foo'); }, /foo/);
+   */
+  (callback: ThrowsCallback, expectedError: RegExp, message?: string): void;
+  /**
+   * check if function throws an error matching the predicate function
+   * @param callback
+   * @example throws(() => { throw new TypeError('foo'); }, (error) => error.message === 'foo');
+   */
+  (callback: ThrowsCallback, expectedError: ErrorPredicate, message?: string): void;
+}
+declare const throws: Throw, notThrows: Throw;
+//#endregion
+export { Constructor, ErrorPredicate, ThrowsCallback, notThrows, throws };
+//# sourceMappingURL=throws-D7JsW4NM.d.cts.map

package/dist/throws-D7JsW4NM.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throws-D7JsW4NM.d.cts","names":[],"sources":["../src/utils/process-error.ts","../src/assert/throws.ts"],"sourcesContent":[],"mappings":";AAEiB,UAAA,WAAW,CACF,IAAC,GAAA,CAAA,CAAA;EAGf,KAAA,GAAA,IAAA,EAAA,GAAc,EAAA,CAAA,EAHA,CAGA;;KAAd,cAAA,WAAyB;;;AAJpB,KCEL,cAAA,GDDc,GAAC,GAAA,OAAA;AAG3B,UCAU,KAAA,CDAE;;;;ACFZ;AAA2C;;WAS5B,EAAA,cAAA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;;WAmB+B,EAb/B,cAa+B,EAAA,aAAA,EAbA,WAaA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;EAAc;AAe5D;;;;;EAAsB,CAAA,QAAA,EArBP,cAqBO,EAAA,aAAA,EArBwB,MAqBxB,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;;aAfP,+BAA+B;;cAehC,QAAM,kBAAW"}

package/eslint.config.mjs

@@ -0,0 +1,13 @@
+import eslintConfigHein from 'eslint-config-hein';
+import { globalIgnores } from 'eslint/config';
+
+export default [
+    globalIgnores(['tsdown.config.ts']),
+    ...eslintConfigHein,
+    {
+        files: ['src/expect.types.ts'],
+        rules: {
+            '@typescript-eslint/no-empty-object-type': 'off'
+        }
+    }
+];

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "hein",
-  "version": "1.4.2",
+  "description": "Assertion library written in TypeScript",
+  "version": "2.0.0-alpha.0",
+  "type": "module",
   "engines": {
     "node": ">=14.0.0"
   },
@@ -9,7 +11,6 @@
     "url": "https://github.com/KristjanTammekivi/hein"
   },
   "homepage": "https://heinjs.com",
-  "description": "Assertion library written in TypeScript",
   "keywords": [
     "typescript",
     "assertion",
@@ -17,11 +18,23 @@
     "test",
     "testing"
   ],
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.cts",
   "exports": {
-    ".": "./dist/index.js",
-    "./assert": "./dist/assert.js",
-    "./expect.types": "./dist/expect.types.js"
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./assert": {
+      "import": "./dist/assert.js",
+      "require": "./dist/assert.cjs"
+    },
+    "./expect.types": {
+      "import": "./dist/expect.types.js",
+      "require": "./dist/expect.types.cjs"
+    },
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
@@ -34,7 +47,7 @@
     }
   },
   "scripts": {
-    "build": "rimraf dist && tsc -b .",
+    "build": "tsdown",
     "lint": "eslint src/**/*.ts",
     "lint:fix": "npm run lint -- --fix",
     "test": "node --trace-warnings node_modules/.bin/mocha 'src/**/*.test.ts'",
@@ -45,22 +58,22 @@
   "author": "Kristjan Tammekivi",
   "license": "MIT",
   "dependencies": {
-    "hein-assertion-utils": "^1.0.4",
+    "hein-assertion-utils": "^2.0.0-alpha.3",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@types/lodash": "^4.14.184",
-    "@types/mocha": "^10.0.0",
-    "@types/mustache": "^4.2.1",
-    "@types/node": "^20.10.0",
-    "eslint": "^8.55.0",
-    "eslint-config-hein": "^1.0.4",
-    "mocha": "^10.1.0",
-    "nyc": "^15.1.0",
+    "@types/lodash": "^4.17.0",
+    "@types/mocha": "^10.0.9",
+    "@types/node": "^24.5.0",
+    "eslint": "^9.35.0",
+    "eslint-config-hein": "^2.0.0-alpha.0",
+    "mocha": "^11.7.1",
+    "nyc": "^17.1.0",
     "rimraf": "^5.0.1",
     "source-map-support": "^0.5.21",
     "ts-node": "^10.9.1",
-    "typedoc": "^0.25.0",
-    "typescript": "^5.2.2"
+    "tsdown": "^0.15.2",
+    "typedoc": "^0.28.9",
+    "typescript": "^5.9.2"
   }
 }

package/tsdown.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig([{
+    entry: ['src/index.ts', 'src/expect.types.ts', 'src/assert.ts'],
+    platform: 'node',
+    format: ['esm', 'cjs'],
+    sourcemap: true,
+    dts: true
+}]);

package/dist/assert/deep-equal.d.ts

@@ -1,2 +0,0 @@
-export 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;
-//# sourceMappingURL=deep-equal.d.ts.map

package/dist/assert/deep-equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-equal.d.ts","sourceRoot":"","sources":["../../src/assert/deep-equal.ts"],"names":[],"mappings":"AAIA,eAAO,MAAO,SAAS,iDAO+B,MAAM,GAAG,OAAO,YAAoB,MAAM,kBAPvE,YAAY,iDAOiB,MAAM,GAAG,OAAO,YAAoB,MAAM,gBAY9F,CAAC"}

package/dist/assert/deep-equal.js

@@ -1,26 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notDeepEqual = exports.deepEqual = void 0;
-const lodash_1 = require("lodash");
-const hein_assertion_utils_1 = require("hein-assertion-utils");
-const match_1 = require("../utils/match");
-_a = (0, hein_assertion_utils_1.createAssertion)({
-    messages: {
-        notEql: 'Expected {{actual}} to deep equal {{expected}}',
-        not: 'Expected {{actual}} to not deep equal {{expected}}'
-    },
-    test: (report) => (actual, expected, partialOrMessage = false, message) => {
-        const partial = typeof partialOrMessage === 'boolean' ? partialOrMessage : false;
-        message = typeof partialOrMessage === 'string' ? partialOrMessage : message;
-        if (typeof expected !== 'function') {
-            // TODO: evaluations
-            expected = (0, lodash_1.cloneDeep)(expected);
-        }
-        if ((0, match_1.match)(actual, expected, { mutate: true, partial })) {
-            return report({ message, status: 'ok', expected, actual });
-        }
-        return report({ message, status: 'notok', messageId: 'notEql', expected, actual });
-    }
-}), exports.deepEqual = _a[0], exports.notDeepEqual = _a[1];
-//# sourceMappingURL=deep-equal.js.map

package/dist/assert/deep-equal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-equal.js","sourceRoot":"","sources":["../../src/assert/deep-equal.ts"],"names":[],"mappings":";;;;AAAA,mCAAmC;AACnC,+DAAuD;AACvD,0CAAuC;AAE1B,KAA4B,IAAA,sCAAe,EAAC;IACrD,QAAQ,EAAE;QACN,MAAM,EAAE,gDAAgD;QACxD,GAAG,EAAE,oDAAoD;KAC5D;IACD,IAAI,EACA,CAAC,MAAM,EAAE,EAAE,CACX,CAAI,MAAS,EAAE,QAAW,EAAE,mBAAqC,KAAK,EAAE,OAAgB,EAAE,EAAE;QACxF,MAAM,OAAO,GAAG,OAAO,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC;QACjF,OAAO,GAAG,OAAO,gBAAgB,KAAK,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC;QAC5E,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE;YAChC,oBAAoB;YACpB,QAAQ,GAAG,IAAA,kBAAS,EAAC,QAAQ,CAAC,CAAC;SAClC;QACD,IAAI,IAAA,aAAK,EAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE;YACpD,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;SAC9D;QACD,OAAO,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IACvF,CAAC;CACR,CAAC,EAnBY,iBAAS,UAAE,oBAAY,SAmBlC"}

package/dist/assert/deep-has-property.d.ts

@@ -1,20 +0,0 @@
-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;
-}
-export declare const deepHasProperty: DeepHasProperty, deepNotHasProperty: DeepHasProperty;
-export {};
-//# sourceMappingURL=deep-has-property.d.ts.map

package/dist/assert/deep-has-property.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-has-property.d.ts","sourceRoot":"","sources":["../../src/assert/deep-has-property.ts"],"names":[],"mappings":"AAGA,UAAU,eAAe;IACrB;;;;;OAKG;IACH,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC;;;;;;OAMG;IACH,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAAC;CACrD;AAED,eAAO,MAAO,eAAe,mBAAE,kBAAkB,iBA4C/C,CAAC"}

package/dist/assert/deep-has-property.js

@@ -1,50 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepNotHasProperty = exports.deepHasProperty = void 0;
-const hein_assertion_utils_1 = require("hein-assertion-utils");
-const lodash_1 = require("lodash");
-_a = (0, hein_assertion_utils_1.createAssertion)({
-    messages: {
-        noProperty: 'Expected {{actual}} to have property {{expected}}',
-        wrongValue: 'Expected {{obj}} to have property {{expected}} with value {{value}}',
-        not: 'Expected {{actual}} to not have property {{expected}}',
-        notWrongValue: 'Expected {{obj}} to not have property {{expected}} with value {{value}}'
-    },
-    test: (report) => (...args) => {
-        const [actual, expected, value] = args;
-        const actualStringified = (0, hein_assertion_utils_1.stringify)(actual);
-        if ((0, lodash_1.has)(actual, expected)) {
-            if (args.length === 3) {
-                const actualValue = (0, lodash_1.get)(actual, expected);
-                if (actualValue === value) {
-                    return report({
-                        status: 'ok',
-                        messageId: 'notWrongValue',
-                        expected: value,
-                        actual: actualValue,
-                        data: { value, expected, obj: actualStringified },
-                        noStringify: true
-                    });
-                }
-                return report({
-                    status: 'notok',
-                    messageId: 'wrongValue',
-                    expected: value,
-                    actual: actualValue,
-                    data: { value, expected, obj: actualStringified },
-                    noStringify: true
-                });
-            }
-            return report({ status: 'ok', noStringify: true, expected, actual: actualStringified });
-        }
-        return report({
-            status: 'notok',
-            messageId: 'noProperty',
-            expected,
-            actual: actualStringified,
-            noStringify: true
-        });
-    }
-}), exports.deepHasProperty = _a[0], exports.deepNotHasProperty = _a[1];
-//# sourceMappingURL=deep-has-property.js.map

package/dist/assert/deep-has-property.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-has-property.js","sourceRoot":"","sources":["../../src/assert/deep-has-property.ts"],"names":[],"mappings":";;;;AAAA,+DAAkE;AAClE,mCAAkC;AAoBrB,KAAwC,IAAA,sCAAe,EAAC;IACjE,QAAQ,EAAE;QACN,UAAU,EAAE,mDAAmD;QAC/D,UAAU,EAAE,qEAAqE;QACjF,GAAG,EAAE,uDAAuD;QAC5D,aAAa,EAAE,yEAAyE;KAC3F;IACD,IAAI,EACA,CAAC,MAAM,EAAmB,EAAE,CAC5B,CAAC,GAAG,IAAkD,EAAE,EAAE;QACtD,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;QACvC,MAAM,iBAAiB,GAAG,IAAA,gCAAS,EAAC,MAAM,CAAC,CAAC;QAC5C,IAAI,IAAA,YAAG,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAE;YACvB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;gBACnB,MAAM,WAAW,GAAG,IAAA,YAAG,EAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBAC1C,IAAI,WAAW,KAAK,KAAK,EAAE;oBACvB,OAAO,MAAM,CAAC;wBACV,MAAM,EAAE,IAAI;wBACZ,SAAS,EAAE,eAAe;wBAC1B,QAAQ,EAAE,KAAK;wBACf,MAAM,EAAE,WAAW;wBACnB,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,iBAAiB,EAAE;wBACjD,WAAW,EAAE,IAAI;qBACpB,CAAC,CAAC;iBACN;gBACD,OAAO,MAAM,CAAC;oBACV,MAAM,EAAE,OAAO;oBACf,SAAS,EAAE,YAAY;oBACvB,QAAQ,EAAE,KAAK;oBACf,MAAM,EAAE,WAAW;oBACnB,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,iBAAiB,EAAE;oBACjD,WAAW,EAAE,IAAI;iBACpB,CAAC,CAAC;aACN;YACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;SAC3F;QACD,OAAO,MAAM,CAAC;YACV,MAAM,EAAE,OAAO;YACf,SAAS,EAAE,YAAY;YACvB,QAAQ;YACR,MAAM,EAAE,iBAAiB;YACzB,WAAW,EAAE,IAAI;SACpB,CAAC,CAAC;IACP,CAAC;CACR,CAAC,EA5CY,uBAAe,UAAE,0BAAkB,SA4C9C"}

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

@@ -1,11 +0,0 @@
-interface EndsWith {
-    /**
-     * check if string ends with a specific string
-     * @param string
-     * @param end
-     */
-    (string: string, end: string): void;
-}
-export declare const endsWith: EndsWith, notEndsWith: EndsWith;
-export {};
-//# sourceMappingURL=ends-with.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ends-with.d.ts","sourceRoot":"","sources":["../../src/assert/ends-with.ts"],"names":[],"mappings":"AAIA,UAAU,QAAQ;IACd;;;;OAIG;IACH,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED,eAAO,MAAO,QAAQ,YAAE,WAAW,UAwBjC,CAAC"}

package/dist/assert/ends-with.js

@@ -1,30 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notEndsWith = exports.endsWith = void 0;
-const hein_assertion_utils_1 = require("hein-assertion-utils");
-_a = (0, hein_assertion_utils_1.createAssertion)({
-    messages: {
-        wrongEnd: 'Expected {{ actual }} to end with {{ expected }}',
-        not: 'Expected {{ actual }} to not end with {{ expected }}'
-    },
-    test: (report) => (actual, end) => {
-        if (actual.endsWith(end)) {
-            report({
-                messageId: 'not',
-                status: 'ok',
-                actual,
-                expected: end
-            });
-        }
-        else {
-            report({
-                messageId: 'wrongEnd',
-                status: 'notok',
-                actual,
-                expected: end
-            });
-        }
-    }
-}), exports.endsWith = _a[0], exports.notEndsWith = _a[1];
-//# sourceMappingURL=ends-with.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ends-with.js","sourceRoot":"","sources":["../../src/assert/ends-with.ts"],"names":[],"mappings":";;;;AAAA,+DAAuD;AAa1C,KAA0B,IAAA,sCAAe,EAAC;IACnD,QAAQ,EAAE;QACN,QAAQ,EAAE,kDAAkD;QAC5D,GAAG,EAAE,sDAAsD;KAC9D;IACD,IAAI,EACA,CAAC,MAAM,EAAY,EAAE,CACrB,CAAC,MAAc,EAAE,GAAW,EAAE,EAAE;QAC5B,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACtB,MAAM,CAAC;gBACH,SAAS,EAAE,KAAK;gBAChB,MAAM,EAAE,IAAI;gBACZ,MAAM;gBACN,QAAQ,EAAE,GAAG;aAChB,CAAC,CAAC;SACN;aAAM;YACH,MAAM,CAAC;gBACH,SAAS,EAAE,UAAU;gBACrB,MAAM,EAAE,OAAO;gBACf,MAAM;gBACN,QAAQ,EAAE,GAAG;aAChB,CAAC,CAAC;SACN;IACL,CAAC;CACR,CAAC,EAxBY,gBAAQ,UAAE,mBAAW,SAwBhC"}

package/dist/assert/equal.d.ts

@@ -1,9 +0,0 @@
-interface Equal {
-    /**
-     * check for === equality except here NaN is equal to NaN
-     */
-    <T>(actual: T, expected: T, message?: string): void;
-}
-export declare const equal: Equal, notEqual: Equal;
-export {};
-//# sourceMappingURL=equal.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../src/assert/equal.ts"],"names":[],"mappings":"AAEA,UAAU,KAAK;IACX;;OAEG;IACH,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvD;AAED,eAAO,MAAO,KAAK,SAAE,QAAQ,OAgB3B,CAAC"}

package/dist/assert/equal.js

@@ -1,21 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notEqual = exports.equal = void 0;
-const hein_assertion_utils_1 = require("hein-assertion-utils");
-_a = (0, hein_assertion_utils_1.createAssertion)({
-    messages: {
-        equal: 'Expected {{actual}} to equal {{expected}}',
-        not: 'Expected {{actual}} to not equal {{expected}}'
-    },
-    test: (report) => (a, b, message) => {
-        if (Number.isNaN(a) && Number.isNaN(b)) {
-            return report({ status: 'ok', expected: b, actual: a, message });
-        }
-        if (a !== b) {
-            return report({ status: 'notok', messageId: 'equal', actual: a, expected: b, message });
-        }
-        return report({ status: 'ok', expected: a, actual: b, message });
-    }
-}), exports.equal = _a[0], exports.notEqual = _a[1];
-//# sourceMappingURL=equal.js.map

package/dist/assert/equal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"equal.js","sourceRoot":"","sources":["../../src/assert/equal.ts"],"names":[],"mappings":";;;;AAAA,+DAAuD;AAS1C,KAAoB,IAAA,sCAAe,EAAC;IAC7C,QAAQ,EAAE;QACN,KAAK,EAAE,2CAA2C;QAClD,GAAG,EAAE,+CAA+C;KACvD;IACD,IAAI,EACA,CAAC,MAAM,EAAS,EAAE,CAClB,CAAI,CAAI,EAAE,CAAI,EAAE,OAAgB,EAAE,EAAE;QAChC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACpC,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;SACpE;QACD,IAAI,CAAC,KAAK,CAAC,EAAE;YACT,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;SAC3F;QACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IACrE,CAAC;CACR,CAAC,EAhBY,aAAK,UAAE,gBAAQ,SAgB1B"}

package/dist/assert/greater-than-equal.d.ts

@@ -1,9 +0,0 @@
-interface GreaterThanEqual {
-    /**
-     * check for >=
-     */
-    <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
-}
-export declare const greaterThanEqual: GreaterThanEqual, notGreaterThanEqual: GreaterThanEqual;
-export {};
-//# sourceMappingURL=greater-than-equal.d.ts.map

package/dist/assert/greater-than-equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"greater-than-equal.d.ts","sourceRoot":"","sources":["../../src/assert/greater-than-equal.ts"],"names":[],"mappings":"AAGA,UAAU,gBAAgB;IACtB;;OAEG;IACH,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtF;AAED,eAAO,MAAO,gBAAgB,oBAAE,mBAAmB,kBAcjD,CAAC"}

package/dist/assert/greater-than-equal.js

@@ -1,20 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notGreaterThanEqual = exports.greaterThanEqual = void 0;
-const hein_assertion_utils_1 = require("hein-assertion-utils");
-const validate_numeric_and_dates_1 = require("../utils/validate-numeric-and-dates");
-_a = (0, hein_assertion_utils_1.createAssertion)({
-    messages: {
-        notGreaterThanEqual: 'Expected {{actual}} to not be greater than or equal to {{expected}}',
-        not: 'Expected {{actual}} to not be greater than or equal to {{expected}}'
-    },
-    test: (report) => (a, b, message) => {
-        (0, validate_numeric_and_dates_1.validateNumericsAndDates)(a, b);
-        if (a < b) {
-            return report({ status: 'notok', messageId: 'notGreaterThanEqual', actual: a, expected: b, message });
-        }
-        return report({ status: 'ok', expected: a, actual: b });
-    }
-}), exports.greaterThanEqual = _a[0], exports.notGreaterThanEqual = _a[1];
-//# sourceMappingURL=greater-than-equal.js.map

package/dist/assert/greater-than-equal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"greater-than-equal.js","sourceRoot":"","sources":["../../src/assert/greater-than-equal.ts"],"names":[],"mappings":";;;;AAAA,+DAAuD;AACvD,oFAA+E;AASlE,KAA0C,IAAA,sCAAe,EAAC;IACnE,QAAQ,EAAE;QACN,mBAAmB,EAAE,qEAAqE;QAC1F,GAAG,EAAE,qEAAqE;KAC7E;IACD,IAAI,EACA,CAAC,MAAM,EAAoB,EAAE,CAC7B,CAAC,CAAM,EAAE,CAAM,EAAE,OAAgB,EAAE,EAAE;QACjC,IAAA,qDAAwB,EAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC/B,IAAI,CAAC,GAAG,CAAC,EAAE;YACP,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;SACzG;QACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IAC5D,CAAC;CACR,CAAC,EAdY,wBAAgB,UAAE,2BAAmB,SAchD"}

package/dist/assert/greater-than.d.ts

@@ -1,9 +0,0 @@
-interface GreaterThan {
-    /**
-     * check for >
-     */
-    <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
-}
-export declare const greaterThan: GreaterThan, notGreaterThan: GreaterThan;
-export {};
-//# sourceMappingURL=greater-than.d.ts.map

package/dist/assert/greater-than.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"greater-than.d.ts","sourceRoot":"","sources":["../../src/assert/greater-than.ts"],"names":[],"mappings":"AAGA,UAAU,WAAW;IACjB;;OAEG;IACH,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtF;AAED,eAAO,MAAO,WAAW,eAAE,cAAc,aAcvC,CAAC"}

package/dist/assert/greater-than.js

@@ -1,20 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notGreaterThan = exports.greaterThan = void 0;
-const hein_assertion_utils_1 = require("hein-assertion-utils");
-const validate_numeric_and_dates_1 = require("../utils/validate-numeric-and-dates");
-_a = (0, hein_assertion_utils_1.createAssertion)({
-    messages: {
-        smaller: 'Expected {{actual}} to be greater than {{expected}}',
-        not: 'Expected {{actual}} to not be greater than {{expected}}'
-    },
-    test: (report) => (actual, expected) => {
-        (0, validate_numeric_and_dates_1.validateNumericsAndDates)(actual, expected);
-        if (actual > expected) {
-            return report({ status: 'ok', messageId: 'not', expected, actual });
-        }
-        return report({ status: 'notok', messageId: 'smaller', actual, expected, noStringify: true });
-    }
-}), exports.greaterThan = _a[0], exports.notGreaterThan = _a[1];
-//# sourceMappingURL=greater-than.js.map

package/dist/assert/greater-than.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"greater-than.js","sourceRoot":"","sources":["../../src/assert/greater-than.ts"],"names":[],"mappings":";;;;AAAA,+DAAuD;AACvD,oFAA+E;AASlE,KAAgC,IAAA,sCAAe,EAAC;IACzD,QAAQ,EAAE;QACN,OAAO,EAAE,qDAAqD;QAC9D,GAAG,EAAE,yDAAyD;KACjE;IACD,IAAI,EACA,CAAC,MAAM,EAAe,EAAE,CACxB,CAAC,MAAW,EAAE,QAAa,EAAE,EAAE;QAC3B,IAAA,qDAAwB,EAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAC3C,IAAI,MAAM,GAAG,QAAQ,EAAE;YACnB,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;SACvE;QACD,OAAO,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;IAClG,CAAC;CACR,CAAC,EAdY,mBAAW,UAAE,sBAAc,SActC"}