hein 0.0.1

package/.eslintrc

@@ -0,0 +1,167 @@
+{
+    "parser": "@typescript-eslint/parser",
+    "extends": [
+        "airbnb-typescript/base",
+        "plugin:@typescript-eslint/eslint-recommended",
+        "plugin:@typescript-eslint/recommended",
+        "plugin:mocha/recommended",
+        "plugin:unicorn/recommended"
+    ],
+    "plugins": [
+        "import",
+        "mocha",
+        "unicorn"
+    ],
+    "parserOptions": {
+        "ecmaVersion": 2018,
+        "sourceType": "module",
+        "project": "./tsconfig.json"
+    },
+    "rules": {
+        "no-multi-spaces": "error",
+        "spaced-comment": [
+            "error",
+            "always",
+            {
+                "markers": [
+                    "/"
+                ]
+            }
+        ],
+        "template-curly-spacing": [
+            "error",
+            "always"
+        ],
+        "no-irregular-whitespace": [
+            "error",
+            {
+                "skipStrings": false
+            }
+        ],
+        "no-trailing-spaces": "error",
+        "eol-last": "error",
+        "@typescript-eslint/indent": [
+            "error",
+            4,
+            {
+                "ignoredNodes": [
+                    "TSUnionType",
+                    "TSTypeLiteral"
+                ],
+                "SwitchCase": 1
+            }
+        ],
+        "@typescript-eslint/comma-dangle": "off",
+        "@typescript-eslint/no-use-before-define": [
+            "error",
+            {
+                "variables": false
+            }
+        ],
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/space-before-function-paren": [
+            "error",
+            {
+                "named": "never"
+            }
+        ],
+        "@typescript-eslint/space-before-blocks": "error",
+        "@typescript-eslint/type-annotation-spacing": "error",
+        "arrow-spacing": "error",
+        "@typescript-eslint/quotes": [
+            "error",
+            "single",
+            {
+                "avoidEscape": true,
+                "allowTemplateLiterals": true
+            }
+        ],
+        "@typescript-eslint/no-floating-promises": "error",
+        "mocha/no-mocha-arrows": "off",
+        "unicorn/no-null": "off",
+        "unicorn/prevent-abbreviations": [
+            "error",
+            {
+                "replacements": {
+                    "args": false
+                }
+            }
+        ],
+        "unicorn/consistent-function-scoping": "off",
+        "unicorn/empty-brace-spaces": "off",
+        "unicorn/error-message": "off",
+        "@typescript-eslint/no-extra-parens": "error",
+        "@typescript-eslint/no-extra-semi": "error",
+        "@typescript-eslint/naming-convention": [
+            "error",
+            {
+                "selector": "variable",
+                "format": [
+                    "camelCase",
+                    "PascalCase"
+                ]
+            },
+            {
+                "selector": "function",
+                "format": [
+                    "camelCase",
+                    "PascalCase"
+                ]
+            },
+            {
+                "selector": "typeLike",
+                "format": [
+                    "PascalCase"
+                ]
+            },
+            {
+                "selector": "variable",
+                "format": [
+                    "camelCase",
+                    "PascalCase",
+                    "UPPER_CASE",
+                    "snake_case"
+                ],
+                "modifiers": [
+                    "destructured"
+                ]
+            },
+            {
+                "selector": "variable",
+                "format": [
+                    "camelCase",
+                    "PascalCase",
+                    "UPPER_CASE"
+                ],
+                "modifiers": [
+                    "const"
+                ]
+            },
+            {
+                "selector": "typeParameter",
+                "format": [
+                    "UPPER_CASE"
+                ]
+            }
+        ],
+        "curly": [
+            "error",
+            "all"
+        ],
+        "@typescript-eslint/semi": "error",
+        "comma-dangle": [
+            "error",
+            "never"
+        ]
+    },
+    "overrides": [
+        {
+            "files": [
+                "./src/test/**/*.ts"
+            ],
+            "rules": {
+                "import/no-extraneous-dependencies": "off"
+            }
+        }
+    ]
+}

package/.mocharc.json

@@ -0,0 +1,4 @@
+{
+    "require": "ts-node/register/transpile-only",
+    "extension": ["ts"]
+}

package/.nycrc

@@ -0,0 +1,16 @@
+{
+    "extension": [
+        ".ts"
+    ],
+    "require": [
+        "ts-node/register/transpile-only"
+    ],
+    "reporter": [
+        "lcov",
+        "text",
+        "text-summary",
+        "html"
+    ],
+    "sourceMap": true,
+    "instrument": true
+}

package/DIFFERENCES_WITH_CHAI.md

@@ -0,0 +1,49 @@
+# Differences with Chai
+
+## TypeScript
+
+While Chai does have typescript definitions from DefinitelyTyped, the types it provides are a lot looser than I would like.
+
+### Value typechecking
+
+For example, the following is not a typescript violation and the properties of the expectation object are not auto-completed:
+
+```typescript
+// Chai:
+expect({ a: 1 }).to.eql({ b: 1 }); // No typescript error
+
+// Hein:
+expect({ a: 1 }).to.eql({ b: 1 });
+/*
+Argument of type '{ b: number; }' is not assignable to parameter of type '{ a: number; }'.
+  Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.ts(2345)
+*/
+expect<any>({ a: 1 }).to.eql({ b: 1 }); // OK in case you really want to do this
+```
+
+### Method typechecking
+
+```typescript
+// Chai:
+expect('test').to.be.above(5); // No typescript error
+
+// Hein:
+expect('test').to.be.above(5);
+/*
+Property 'above' does not exist on type 'StringExpect<string>'.ts(2339)
+*/
+```
+
+## Always call methods, getters are not assertions
+
+With chai there are special properties that act as assertions. In Hein you have to call the method to assert.
+
+```typescript
+// Chai:
+expect(true).to.be.true;
+
+// Hein:
+expect(true).to.be.true();
+```
+
+I recommend using [no-unused-expressions eslint rule](https://typescript-eslint.io/rules/no-unused-expressions/) to avoid this.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Kristjan Tammekivi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,293 @@
+# Hein
+
+Assertion library with focus on TypeScript
+
+## Features?
+
+* Full TypeScript support
+* Fuzzy matching for eql with any()
+
+* [Differences between Chai and Hein](DIFFERENCES_WITH_CHAI.md)
+
+## Usage
+
+### Assert
+```typescript
+import { assert } from 'hein';
+import {equal} from 'hein/assert';
+
+equal(1, 1);
+assert.equal(1, 1);
+```
+
+### Expect
+```typescript
+import { expect } from 'hein';
+expect(1).to.equal(1);
+```
+
+#### Chainable properties
+
+* a
+* an
+* and - used to chain multiple assertions, clears the state (so .not will be reset)
+* be
+* have
+* not - inverts the expectation (ie `expect(5).to.not.equal(5)` will throw)
+* to
+
+#### Assertions
+
+##### above
+
+Alias for [greaterThan](#greaterThan)
+
+##### array
+
+Assert that value is an array
+
+```typescript
+expect([]).to.be.an.array();
+```
+
+##### atLeast
+
+Alias for [greaterThanOrEqual](#greaterThanOrEqual)
+
+##### atMost
+
+Alias for [lessThanOrEqual](#lessThanOrEqual)
+
+##### below
+
+Alias for [lessThan](#lessThan)
+
+##### bigint
+
+Assert that value is a BigInt
+
+```typescript
+expect(BigInt(5)).to.be.a.bigint();
+```
+
+##### boolean
+
+Assert that value is a boolean
+
+```typescript
+expect(true).to.be.a.boolean();
+```
+
+##### Date
+
+Assert that value is an instance of Date
+
+```typescript
+expect(new Date).to.be.a.date();
+```
+
+##### empty
+
+Assert that array / object / Map / Set is empty
+```typescript
+expect([]).to.be.empty();
+expect({}).to.be.empty();
+expect(new Map()).to.be.empty();
+expect(new Set()).to.be.empty();
+```
+
+##### eql
+
+Assert that value deep equals the expectation
+```typescript
+expect({ a: 1 }).to.eql({ a: 1 });
+```
+
+##### eq
+
+Alias for [equal](#equal)
+
+##### equal
+
+Assert that value strictly equals expectation. NaN is treated as a non-unique value
+```typescript
+expect('hein').to.equal('hein');
+expect(NaN).to.equal(NaN);
+```
+
+##### false
+
+Assert that value is false
+```typescript
+expect(false).to.be.false();
+```
+
+##### function
+
+Assert that value is a function
+```typescript
+expect(() => {}).to.be.a.function();
+```
+
+##### greaterThan
+
+Assert that value is greater than expectation
+```typescript
+expect(5).to.be.greaterThan(4);
+```
+
+##### gt
+
+Alias for [greaterThan](#greaterThan)
+
+##### greaterThanOrEqual
+
+Assert that value is greater than or equal to argument
+```typescript
+expect(5).to.be.greaterThanOrEqual(5);
+expect(5).to.be.greaterThanOrEqual(4);
+```
+
+##### gte
+
+Alias for [greaterThanOrEqual](#greaterThanOrEqual)
+
+##### instanceOf
+
+Assert that value is an instance of provided constructor
+```typescript
+expect(new Error()).to.be.an.instanceOf(Error);
+```
+
+##### lengthOf
+
+Assert that value has a length equal to argument
+```typescript
+expect([1]).to.have.a.lengthOf(1);
+expect({ a: 1 }).to.have.a.lengthOf(1);
+expect(new Map([['a', 1]])).to.have.a.lengthOf(1);
+expect(new Set([1])).to.have.a.lengthOf(1);
+expect('hein').to.have.a.lengthOf(4);
+```
+
+##### lessThan
+
+Assert that value is less than expectation
+```typescript
+expect(5).to.be.lessThan(6);
+```
+##### lt
+
+Alias for [lessThan](#lessThan)
+
+##### lessThanOrEqual
+
+Assert that value is less than or equal to expectation
+```typescript
+expect(5).to.be.lessThanOrEqual(5);
+expect(4).to.be.lessThanOrEqual(5);
+```
+
+##### lte
+
+Alias for [lessThanOrEqual](#lessThanOrEqual)
+
+##### Map
+
+Assert that value is an instance of Map
+```typescript
+expect(new Map()).to.be.a.Map();
+```
+
+##### NaN
+
+Assert that value is NaN
+```typescript
+expect(NaN).to.be.NaN();
+```
+
+##### null
+
+Assert that value is null
+```typescript
+expect(null).to.be.null();
+```
+
+##### number
+
+Assert that value is a number
+```typescript
+expect(5).to.be.a.number();
+```
+
+##### object
+
+Assert that value is an object. Null and instances of Array don't count
+expect({}).to.be.an.object();
+
+
+##### reject
+
+Assert that provided Promise rejects. At the moment this is the only assertion that can't be chained, returns a promise
+```typescript
+await expect(Promise.reject()).to.reject();
+```
+
+##### Set
+
+Assert that value is an instance of Set
+```typescript
+expect(new Set()).to.be.a.Set();
+```
+##### sizeOf
+
+Alias of [lengthOf](#lengthOf)
+
+##### string
+
+Assert that value is a string
+```typescript
+expect('hein').to.be.a.string();
+```
+
+##### symbol
+
+Assert that value is a symbol
+```typescript
+expect(Symbol()).to.be.a.symbol();
+```
+
+##### throw
+
+Assert that provided function throws
+```typescript
+expect(() => { throw new Error() }).to.throw();
+```
+##### true
+
+Assert that value is true
+```typescript
+expect(true).to.be.true;
+```
+
+##### undefined
+
+Assert that value is undefined
+```typescript
+expect(undefined).to.be.undefined();
+```
+
+##### WeakMap
+
+Assert that value is an instance of WeakMap
+```typescript
+expect(new WeakMap()).to.be.a.WeakMap();
+```
+
+##### WeakSet
+
+Assert that value is an instance of WeakSet
+```typescript
+expect(new WeakSet()).to.be.a.WeakSet();
+```
+

package/dist/assert/eql.d.ts

@@ -0,0 +1,2 @@
+export declare const eql: <T>(actual: T, expected: T, message?: string) => true | void, notEql: <T>(actual: T, expected: T, message?: string) => true | void;
+//# sourceMappingURL=eql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eql.d.ts","sourceRoot":"","sources":["../../src/assert/eql.ts"],"names":[],"mappings":"AAIA,eAAO,MAAO,GAAG,wCAK2C,MAAM,kBAL/C,MAAM,wCAKmC,MAAM,gBAUhE,CAAC"}

package/dist/assert/eql.js

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

package/dist/assert/eql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eql.js","sourceRoot":"","sources":["../../src/assert/eql.ts"],"names":[],"mappings":";;;;AAAA,mCAAmC;AACnC,kDAAqD;AACrD,0CAAuC;AAE1B,KAAgB,IAAA,2BAAe,EAAC;IACzC,QAAQ,EAAE;QACN,MAAM,EAAE,gDAAgD;QACxD,GAAG,EAAE,oDAAoD;KAC5D;IACD,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAI,MAAS,EAAE,QAAW,EAAE,OAAgB,EAAE,EAAE;QAC9D,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,CAAC,EAAE;YAC3C,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;CACJ,CAAC,EAfY,WAAG,UAAE,cAAM,SAetB"}

package/dist/assert/equal.d.ts

@@ -0,0 +1,9 @@
+interface Equal {
+    /**
+     * check for === equality, 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

@@ -0,0 +1 @@
+{"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,OAc3B,CAAC"}

package/dist/assert/equal.js

@@ -0,0 +1,21 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEqual = exports.equal = void 0;
+const assertion_1 = require("../utils/assertion");
+_a = (0, assertion_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

@@ -0,0 +1 @@
+{"version":3,"file":"equal.js","sourceRoot":"","sources":["../../src/assert/equal.ts"],"names":[],"mappings":";;;;AAAA,kDAAqD;AASxC,KAAoB,IAAA,2BAAe,EAAC;IAC7C,QAAQ,EAAE;QACN,KAAK,EAAE,2CAA2C;QAClD,GAAG,EAAE,+CAA+C;KACvD;IACD,IAAI,EAAE,CAAC,MAAM,EAAS,EAAE,CAAC,CAAI,CAAI,EAAE,CAAI,EAAE,OAAgB,EAAE,EAAE;QACzD,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;CACJ,CAAC,EAdY,aAAK,UAAE,gBAAQ,SAc1B"}

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1 @@
+{"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,kBAYjD,CAAC"}

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

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notGreaterThanEqual = exports.greaterThanEqual = void 0;
+const assertion_1 = require("../utils/assertion");
+const validate_numeric_and_dates_1 = require("../utils/validate-numeric-and-dates");
+_a = (0, assertion_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

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than-equal.js","sourceRoot":"","sources":["../../src/assert/greater-than-equal.ts"],"names":[],"mappings":";;;;AAAA,kDAAqD;AACrD,oFAA+E;AASlE,KAA0C,IAAA,2BAAe,EAAC;IACnE,QAAQ,EAAE;QACN,mBAAmB,EAAE,qEAAqE;QAC1F,GAAG,EAAE,qEAAqE;KAC7E;IACD,IAAI,EAAE,CAAC,MAAM,EAAoB,EAAE,CAAC,CAAC,CAAM,EAAE,CAAM,EAAE,OAAgB,EAAE,EAAE;QACrE,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;CACJ,CAAC,EAZY,wBAAgB,UAAE,2BAAmB,SAYhD"}

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1 @@
+{"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,aAYvC,CAAC"}