assert-logic 1.0.0

package/README.md

@@ -0,0 +1,166 @@
+# assert-logic
+
+![Downloads](https://img.shields.io/npm/dw/assert-logic?style=flat-square) ![Version@npm](https://img.shields.io/npm/v/assert-logic?label=version%40npm&style=flat-square) ![Version@git](https://img.shields.io/github/package-json/v/szikszail/assert-logic/main?label=version%40git&style=flat-square) ![CI](https://img.shields.io/github/actions/workflow/status/szikszail/assert-logic/ci.yml?branch=main&label=ci&style=flat-square) ![Docs](https://img.shields.io/github/actions/workflow/status/szikszail/assert-logic/docs.yml?branch=main&label=docs&style=flat-square)
+
+This handy tool can be used to implement additional logic into your assertions, either using Chai, Jest, Assert, or
+plain JavaScript.
+
+## Usage
+
+Install the package:
+
+```shell
+npm install assert-logic --save-dev
+```
+
+Use it in your tests:
+
+```javascript
+const {and, or} = require('assert-logic');
+const {expect} = require('chai');
+
+test("Test if a number is even and greater than 10 or less than 7", () => {
+    const number = 12;
+    and(
+        () => expect(number).to.be.an('number'),
+        () => expect(number % 2).to.equal(0),
+        or(
+            () => expect(number).to.be.lessThan(7),
+            () => expect(number).to.be.greaterThan(10),
+        ),
+    ).evaluate();
+});
+```
+
+## API
+
+### Pass/Fail
+
+In the context of this package, a value is considered failed if it is:
+
+1. a (sync) function that throws an error
+2. a (sync) function that returns a falsy value (except for `undefined`)
+3. a (async) function that returns a Promise that rejects
+4. a (async) function that returns a Promise that resolves to a falsy value (except for `undefined`)
+5. a Promise that rejects
+6. a Promise that resolves to a falsy value (except for `undefined`)
+7. value that is falsy (except for `undefined`)
+
+In all other cases, the value is considered passed.
+
+### Operations
+
+The API contains the following functions: `and`, `or`, `not`, `xor`, `nand`, `nor`, `xnor`, and also the `evaluate`
+function. All accept any number of sync/async functions, Promises, or values as arguments.
+
+| Operation | Description                                             |
+|-----------|---------------------------------------------------------|
+| and       | Passes if all of its arguments pass                     |
+| or        | Passes if any of its arguments pass                     |
+| not       | Negates the result of its argument                      |
+| xor       | Passes if odd number of its arguments passes            |
+| nand      | Passes if any of its arguments fails                    |
+| nor       | Passes if all of its arguments fail                     |
+| xnor      | Passes if all of its arguments pass or all of them fail |
+
+#### Append
+
+The `append` function can be used to append additional logic to an existing variadic logic (all except `pass`).
+
+```javascript
+const {and} = require('assert-logic');
+
+const logic = and(
+    () => true,
+    () => false,
+);
+logic.append(() => true).evaluate(); // will throw an error
+```
+
+### Evaluation
+
+The `evaluate` function will evaluate the logic and throw an error if it fails.
+
+The `evaluate` function does not need to be called if the logic is used as an argument to an assertion, as the assertion
+will call it automatically.
+
+The evaluate function will return a Promise if any of the arguments are async.
+
+### AssertionError
+
+Given the following expression what is expected to fail:
+```javascript
+and(
+    xor(true, false, true),
+    true,
+).evaluate()
+```
+
+The error message will look like this:
+
+```
+AssertionError (AND): Expected all expression to pass, but not all did.
+Results:
+  - AssertionError (XOR): Expected odd number of expressions to pass, but even number did.
+    Results:
+      - Pass
+      - AssertionError (PASS): Expected expression to pass.
+        Results:
+          - Error: "Failed expression: (boolean false)"
+        Expression: (boolean false)
+      - Pass
+    Expression: |-
+      XOR(
+        (boolean true)
+        (boolean false)
+        (boolean true)
+      )
+  - Pass
+Expression: |-
+  AND(
+    XOR(
+      (boolean true)
+      (boolean false)
+      (boolean true)
+    )
+    (boolean true)
+  )
+```
+
+## How NOT to use it
+
+### As a replacement for assertions
+
+This package is not meant to be used as a replacement for assertions, but rather as a tool to implement additional logic
+into your assertions.
+
+### With passing the assertions directly
+
+```javascript
+const {and} = require('assert-logic');
+const {expect} = require('chai');
+
+test("Test if a number is even and greater than 10 or less than 7", () => {
+    const number = 12;
+    and(
+        expect(number).to.be.an('number'),
+        expect(number % 2).to.equal(0),
+        or(
+            expect(number).to.be.lessThan(7),
+            expect(number).to.be.greaterThan(10),
+        ),
+    ).evaluate();
+});
+```
+
+This will not work as expected, as the assertions will be evaluated before the logic is evaluated.
+
+## Other
+
+For detailed documentation see the [TypeDocs documentation](https://szikszail.github.io/assert-logic/).
+
+This package uses [debug](https://www.npmjs.com/package/debug) for logging, use `assert-logic` to see debug logs:
+
+```shell
+DEBUG=assert-logic node my-script.js
+```

package/assertion/and.d.ts

@@ -0,0 +1,7 @@
+import { Assertion } from "./assertion";
+import type { AssertionValue, EvaluationResult } from "../types";
+import { VariadicAssertion } from "./variadic";
+export declare class ANDAssertion extends VariadicAssertion {
+    constructor(...values: (AssertionValue | Assertion)[]);
+    onEvaluation(results: EvaluationResult[]): void | Promise<void>;
+}

package/assertion/and.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANDAssertion = void 0;
+const variadic_1 = require("./variadic");
+class ANDAssertion extends variadic_1.VariadicAssertion {
+    constructor(...values) {
+        super("AND", "Expected all expression to pass, but not all did.", ...values);
+    }
+    onEvaluation(results) {
+        const failed = results.filter((result) => result instanceof Error);
+        if (failed.length > 0) {
+            this.fail(results);
+        }
+    }
+}
+exports.ANDAssertion = ANDAssertion;
+//# sourceMappingURL=and.js.map

package/assertion/and.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"and.js","sourceRoot":"","sources":["../../src/assertion/and.ts"],"names":[],"mappings":";;;AAEA,yCAA6C;AAE7C,MAAa,YAAa,SAAQ,4BAAiB;IACjD,YAAY,GAAG,MAAsC;QACnD,KAAK,CAAC,KAAK,EAAE,mDAAmD,EAAE,GAAG,MAAM,CAAC,CAAC;IAC/E,CAAC;IAED,YAAY,CAAC,OAA2B;QACtC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC;QACnE,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AAXD,oCAWC"}

package/assertion/assertion.d.ts

@@ -0,0 +1,9 @@
+import { EvaluationResult } from "../types";
+export declare class Assertion {
+    protected readonly operator: string;
+    protected readonly expectation: string;
+    constructor(operator: string, expectation: string);
+    evaluate(): void | Promise<void>;
+    onEvaluation(results: EvaluationResult[]): void | Promise<void>;
+    protected fail(results: EvaluationResult[]): void;
+}

package/assertion/assertion.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assertion = void 0;
+const error_1 = require("../error");
+class Assertion {
+    constructor(operator, expectation) {
+        this.operator = operator;
+        this.expectation = expectation;
+    }
+    evaluate() {
+        // pass
+    }
+    // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onEvaluation(results) {
+        // pass
+    }
+    fail(results) {
+        throw new error_1.AssertionError(this.operator, this.expectation, this, results);
+    }
+}
+exports.Assertion = Assertion;
+//# sourceMappingURL=assertion.js.map

package/assertion/assertion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion.js","sourceRoot":"","sources":["../../src/assertion/assertion.ts"],"names":[],"mappings":";;;AAAA,oCAAwC;AAGxC,MAAa,SAAS;IACpB,YACqB,QAAgB,EAChB,WAAmB;QADnB,aAAQ,GAAR,QAAQ,CAAQ;QAChB,gBAAW,GAAX,WAAW,CAAQ;IAExC,CAAC;IAED,QAAQ;QACN,OAAO;IACT,CAAC;IAED,aAAa;IACb,6DAA6D;IAC7D,YAAY,CAAC,OAA2B;QACtC,OAAO;IACT,CAAC;IAES,IAAI,CAAC,OAA2B;QACxC,MAAM,IAAI,sBAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAC3E,CAAC;CACF;AApBD,8BAoBC"}

package/assertion/nand.d.ts

@@ -0,0 +1,7 @@
+import { Assertion } from "./assertion";
+import type { AssertionValue, EvaluationResult } from "../types";
+import { VariadicAssertion } from "./variadic";
+export declare class NANDAssertion extends VariadicAssertion {
+    constructor(...values: (AssertionValue | Assertion)[]);
+    onEvaluation(results: EvaluationResult[]): void | Promise<void>;
+}

package/assertion/nand.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NANDAssertion = void 0;
+const variadic_1 = require("./variadic");
+class NANDAssertion extends variadic_1.VariadicAssertion {
+    constructor(...values) {
+        super("NAND", "Expected any expressions to fail, but non did.", ...values);
+    }
+    onEvaluation(results) {
+        const failed = results.filter((result) => result instanceof Error);
+        if (failed.length === 0) {
+            this.fail(results);
+        }
+    }
+}
+exports.NANDAssertion = NANDAssertion;
+//# sourceMappingURL=nand.js.map

package/assertion/nand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nand.js","sourceRoot":"","sources":["../../src/assertion/nand.ts"],"names":[],"mappings":";;;AAEA,yCAA6C;AAE7C,MAAa,aAAc,SAAQ,4BAAiB;IAClD,YAAY,GAAG,MAAsC;QACnD,KAAK,CAAC,MAAM,EAAE,gDAAgD,EAAE,GAAG,MAAM,CAAC,CAAC;IAC7E,CAAC;IAED,YAAY,CAAC,OAA2B;QACtC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC;QACnE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AAXD,sCAWC"}

package/assertion/nor.d.ts

@@ -0,0 +1,7 @@
+import { Assertion } from "./assertion";
+import type { AssertionValue, EvaluationResult } from "../types";
+import { VariadicAssertion } from "./variadic";
+export declare class NORAssertion extends VariadicAssertion {
+    constructor(...values: (AssertionValue | Assertion)[]);
+    onEvaluation(results: EvaluationResult[]): void | Promise<void>;
+}

package/assertion/nor.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NORAssertion = void 0;
+const variadic_1 = require("./variadic");
+class NORAssertion extends variadic_1.VariadicAssertion {
+    constructor(...values) {
+        super("NOR", "Expected all expressions to fail, but some passed.", ...values);
+    }
+    onEvaluation(results) {
+        const failed = results.filter((result) => result instanceof Error);
+        if (failed.length !== results.length) {
+            this.fail(results);
+        }
+    }
+}
+exports.NORAssertion = NORAssertion;
+//# sourceMappingURL=nor.js.map

package/assertion/nor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nor.js","sourceRoot":"","sources":["../../src/assertion/nor.ts"],"names":[],"mappings":";;;AAEA,yCAA6C;AAE7C,MAAa,YAAa,SAAQ,4BAAiB;IACjD,YAAY,GAAG,MAAsC;QACnD,KAAK,CAAC,KAAK,EAAE,oDAAoD,EAAE,GAAG,MAAM,CAAC,CAAC;IAChF,CAAC;IAED,YAAY,CAAC,OAA2B;QACtC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC;QACnE,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AAXD,oCAWC"}

package/assertion/not.d.ts

@@ -0,0 +1,7 @@
+import { Assertion } from "./assertion";
+import { AssertionValue, EvaluationResult } from "../types";
+import { UnaryAssertion } from "./unary";
+export declare class NOTAssertion extends UnaryAssertion {
+    constructor(value: AssertionValue | Assertion);
+    onEvaluation(results: EvaluationResult[]): void | Promise<void>;
+}

package/assertion/not.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOTAssertion = void 0;
+const unary_1 = require("./unary");
+class NOTAssertion extends unary_1.UnaryAssertion {
+    constructor(value) {
+        super("NOT", "Expected the expression to fail, but it passed.", value);
+    }
+    onEvaluation(results) {
+        if (results[0] === true) {
+            this.fail(results);
+        }
+    }
+}
+exports.NOTAssertion = NOTAssertion;
+//# sourceMappingURL=not.js.map

package/assertion/not.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not.js","sourceRoot":"","sources":["../../src/assertion/not.ts"],"names":[],"mappings":";;;AAEA,mCAAuC;AAEvC,MAAa,YAAa,SAAQ,sBAAc;IAC9C,YAAY,KAAiC;QAC3C,KAAK,CAAC,KAAK,EAAE,iDAAiD,EAAE,KAAK,CAAC,CAAC;IACzE,CAAC;IAED,YAAY,CAAC,OAA2B;QACtC,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AAVD,oCAUC"}

package/assertion/or.d.ts

@@ -0,0 +1,7 @@
+import { Assertion } from "./assertion";
+import type { AssertionValue, EvaluationResult } from "../types";
+import { VariadicAssertion } from "./variadic";
+export declare class ORAssertion extends VariadicAssertion {
+    constructor(...values: (AssertionValue | Assertion)[]);
+    onEvaluation(results: EvaluationResult[]): void | Promise<void>;
+}

package/assertion/or.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORAssertion = void 0;
+const variadic_1 = require("./variadic");
+class ORAssertion extends variadic_1.VariadicAssertion {
+    constructor(...values) {
+        super("OR", "Expected any expression to pass, but non did.", ...values);
+    }
+    onEvaluation(results) {
+        const failed = results.filter((result) => result instanceof Error);
+        if (failed.length === results.length) {
+            this.fail(results);
+        }
+    }
+}
+exports.ORAssertion = ORAssertion;
+//# sourceMappingURL=or.js.map

package/assertion/or.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"or.js","sourceRoot":"","sources":["../../src/assertion/or.ts"],"names":[],"mappings":";;;AAEA,yCAA6C;AAE7C,MAAa,WAAY,SAAQ,4BAAiB;IAChD,YAAY,GAAG,MAAsC;QACnD,KAAK,CAAC,IAAI,EAAE,+CAA+C,EAAE,GAAG,MAAM,CAAC,CAAC;IAC1E,CAAC;IAED,YAAY,CAAC,OAA2B;QACtC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC;QACnE,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AAXD,kCAWC"}

package/assertion/pass.d.ts

@@ -0,0 +1,9 @@
+import { Assertion } from "./assertion";
+import type { AssertionValue } from "../types";
+export declare function valueToString(value: AssertionValue): string;
+export declare class PASSAssertion extends Assertion {
+    private value;
+    constructor(value: AssertionValue);
+    evaluate(): void | Promise<void>;
+    toString(): string;
+}

package/assertion/pass.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PASSAssertion = exports.valueToString = void 0;
+const assertion_1 = require("./assertion");
+const error_1 = require("../error");
+function valueToString(value) {
+    if (value instanceof Function) {
+        let name = value === null || value === void 0 ? void 0 : value.name;
+        if (!name) {
+            return '(function)';
+        }
+        if (name.length > 20) {
+            name = name.slice(0, 17) + "...";
+        }
+        return `(function ${name})`;
+    }
+    if (value instanceof Promise) {
+        return '(promise)';
+    }
+    return `(${typeof value} ${String(value)})`;
+}
+exports.valueToString = valueToString;
+class PASSAssertion extends assertion_1.Assertion {
+    constructor(value) {
+        super("PASS", "Expected expression to pass.");
+        this.value = value;
+        if (value instanceof assertion_1.Assertion) {
+            return value;
+        }
+    }
+    evaluate() {
+        let result = this.value;
+        if (result instanceof Function) {
+            try {
+                result = result();
+            }
+            catch (e) {
+                this.fail([e]);
+            }
+        }
+        if (result instanceof Promise) {
+            return result.then((value) => {
+                if (value !== undefined && !value) {
+                    this.fail([new error_1.FailedAssertionError(value)]);
+                }
+            }, (error) => {
+                this.fail([error]);
+            });
+        }
+        if (result !== undefined && !result) {
+            this.fail([new error_1.FailedAssertionError(result)]);
+        }
+    }
+    toString() {
+        return valueToString(this.value);
+    }
+}
+exports.PASSAssertion = PASSAssertion;
+//# sourceMappingURL=pass.js.map

package/assertion/pass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pass.js","sourceRoot":"","sources":["../../src/assertion/pass.ts"],"names":[],"mappings":";;;AAAA,2CAAsC;AAEtC,oCAA8C;AAE9C,SAAgB,aAAa,CAAC,KAAqB;IACjD,IAAI,KAAK,YAAY,QAAQ,EAAE,CAAC;QAC9B,IAAI,IAAI,GAAG,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,IAAI,CAAC;QACvB,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,YAAY,CAAC;QACtB,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;YACrB,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC;QACnC,CAAC;QACD,OAAO,aAAa,IAAI,GAAG,CAAC;IAC9B,CAAC;IACD,IAAI,KAAK,YAAY,OAAO,EAAE,CAAC;QAC7B,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,OAAO,IAAI,OAAO,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAA;AAC7C,CAAC;AAfD,sCAeC;AAED,MAAa,aAAc,SAAQ,qBAAS;IAC1C,YAAoB,KAAqB;QACvC,KAAK,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAC;QAD5B,UAAK,GAAL,KAAK,CAAgB;QAGvC,IAAI,KAAK,YAAY,qBAAS,EAAE,CAAC;YAC/B,OAAO,KAAsB,CAAC;QAChC,CAAC;IACH,CAAC;IAED,QAAQ;QACN,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC;QACxB,IAAI,MAAM,YAAY,QAAQ,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,MAAM,GAAG,MAAM,EAAE,CAAC;YACpB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACjB,CAAC;QACH,CAAC;QACD,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;YAC9B,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC3B,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,KAAK,EAAE,CAAC;oBAClC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,4BAAoB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC/C,CAAC;YACH,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;gBACX,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YACrB,CAAC,CAAC,CAAC;QACL,CAAC;QACD,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,CAAC;YACpC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,4BAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED,QAAQ;QACN,OAAO,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;CACF;AAnCD,sCAmCC"}

package/assertion/unary.d.ts

@@ -0,0 +1,8 @@
+import { AssertionValue } from "../types";
+import { Assertion } from "./assertion";
+export declare class UnaryAssertion extends Assertion {
+    protected readonly value: Assertion;
+    constructor(operator: string, expectation: string, value: AssertionValue | Assertion);
+    toString(): string;
+    evaluate(): void | Promise<void>;
+}

package/assertion/unary.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnaryAssertion = void 0;
+const pass_1 = require("./pass");
+const assertion_1 = require("./assertion");
+class UnaryAssertion extends assertion_1.Assertion {
+    constructor(operator, expectation, value) {
+        super(operator, expectation);
+        if (value instanceof assertion_1.Assertion) {
+            this.value = value;
+        }
+        else {
+            this.value = new pass_1.PASSAssertion(value);
+        }
+    }
+    toString() {
+        return `${this.operator}(${this.value.toString()})`;
+    }
+    evaluate() {
+        let result;
+        let handled = false;
+        try {
+            result = this.value.evaluate();
+        }
+        catch (e) {
+            this.onEvaluation(e);
+            handled = true;
+        }
+        if (!handled) {
+            if (result instanceof Promise) {
+                return result.then(() => {
+                    this.onEvaluation([true]);
+                }, (e) => {
+                    this.onEvaluation([e]);
+                });
+            }
+            this.onEvaluation([true]);
+        }
+    }
+}
+exports.UnaryAssertion = UnaryAssertion;
+//# sourceMappingURL=unary.js.map

package/assertion/unary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unary.js","sourceRoot":"","sources":["../../src/assertion/unary.ts"],"names":[],"mappings":";;;AACA,iCAAqC;AACrC,2CAAsC;AAEtC,MAAa,cAAe,SAAQ,qBAAS;IAG3C,YAAY,QAAgB,EAAE,WAAmB,EAAE,KAAiC;QAClF,KAAK,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAE7B,IAAI,KAAK,YAAY,qBAAS,EAAE,CAAC;YAC/B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACrB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,KAAK,GAAG,IAAI,oBAAa,CAAC,KAAK,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC;IACtD,CAAC;IAED,QAAQ;QACN,IAAI,MAA4B,CAAC;QACjC,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACrB,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;gBAC9B,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;oBACtB,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;gBAC5B,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;oBACP,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACzB,CAAC,CAAC,CAAC;YACL,CAAC;YACD,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;CACF;AArCD,wCAqCC"}

package/assertion/variadic.d.ts

@@ -0,0 +1,9 @@
+import { AssertionValue } from "../types";
+import { Assertion } from "./assertion";
+export declare class VariadicAssertion extends Assertion {
+    protected readonly values: Assertion[];
+    constructor(operator: string, expectation: string, ...values: (AssertionValue | Assertion)[]);
+    append(...values: (AssertionValue | Assertion)[]): void;
+    evaluate(): void | Promise<void>;
+    toString(): string;
+}

package/assertion/variadic.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariadicAssertion = void 0;
+const pass_1 = require("./pass");
+const lines_builder_1 = require("lines-builder");
+const assertion_1 = require("./assertion");
+class VariadicAssertion extends assertion_1.Assertion {
+    constructor(operator, expectation, ...values) {
+        if (values.length < 1) {
+            throw new Error(`At least one value is required for ${operator} assertion.`);
+        }
+        super(operator, expectation);
+        this.values = [];
+        this.append(...values);
+    }
+    append(...values) {
+        this.values.push(...values.map((value) => {
+            if (value instanceof assertion_1.Assertion) {
+                return value;
+            }
+            return new pass_1.PASSAssertion(value);
+        }));
+    }
+    evaluate() {
+        const results = this.values.map((value) => {
+            try {
+                return value.evaluate();
+            }
+            catch (e) {
+                return e;
+            }
+        });
+        if (results.some((result) => result instanceof Promise)) {
+            return Promise.allSettled(results).then((settledResults) => {
+                this.onEvaluation(settledResults.map((settledResult) => {
+                    if (settledResult.status === "fulfilled") {
+                        return true;
+                    }
+                    return settledResult.reason;
+                }));
+            });
+        }
+        this.onEvaluation(results);
+    }
+    toString() {
+        return (0, lines_builder_1.lines)(this.operator + "(", (0, lines_builder_1.lines)(...this.values.map((value) => value.toString())), ")").toString();
+    }
+}
+exports.VariadicAssertion = VariadicAssertion;
+//# sourceMappingURL=variadic.js.map

package/assertion/variadic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variadic.js","sourceRoot":"","sources":["../../src/assertion/variadic.ts"],"names":[],"mappings":";;;AACA,iCAAqC;AACrC,iDAAoC;AACpC,2CAAsC;AAEtC,MAAa,iBAAkB,SAAQ,qBAAS;IAG9C,YAAY,QAAgB,EAAE,WAAmB,EAAE,GAAG,MAAsC;QAC1F,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,sCAAsC,QAAQ,aAAa,CAAC,CAAC;QAC/E,CAAC;QACD,KAAK,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QANZ,WAAM,GAAgB,EAAE,CAAC;QAO1C,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;IACzB,CAAC;IAED,MAAM,CAAC,GAAG,MAAsC;QAC9C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACvC,IAAI,KAAK,YAAY,qBAAS,EAAE,CAAC;gBAC/B,OAAO,KAAK,CAAC;YACf,CAAC;YACD,OAAO,IAAI,oBAAa,CAAC,KAAK,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAED,QAAQ;QACN,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACxC,IAAI,CAAC;gBACH,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC1B,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,CAAC,CAAC;YACX,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,YAAY,OAAO,CAAC,EAAE,CAAC;YACxD,OAAO,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,EAAE;gBACzD,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE;oBACrD,IAAI,aAAa,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;wBACzC,OAAO,IAAI,CAAC;oBACd,CAAC;oBACD,OAAO,aAAa,CAAC,MAAM,CAAC;gBAC9B,CAAC,CAAC,CAAC,CAAC;YACN,CAAC,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAED,QAAQ;QACN,OAAO,IAAA,qBAAK,EACV,IAAI,CAAC,QAAQ,GAAG,GAAG,EACnB,IAAA,qBAAK,EACH,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAChD,EACD,GAAG,CACJ,CAAC,QAAQ,EAAE,CAAC;IACf,CAAC;CACF;AAlDD,8CAkDC"}

package/assertion/xnor.d.ts

@@ -0,0 +1,7 @@
+import { Assertion } from "./assertion";
+import type { AssertionValue, EvaluationResult } from "../types";
+import { VariadicAssertion } from "./variadic";
+export declare class XNORAssertion extends VariadicAssertion {
+    constructor(...values: (AssertionValue | Assertion)[]);
+    onEvaluation(results: EvaluationResult[]): void | Promise<void>;
+}

package/assertion/xnor.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XNORAssertion = void 0;
+const variadic_1 = require("./variadic");
+class XNORAssertion extends variadic_1.VariadicAssertion {
+    constructor(...values) {
+        super("XNOR", "Expected all expressions to have the same state (pass or fail), but there are few outliers.", ...values);
+    }
+    onEvaluation(results) {
+        const failed = results.filter((result) => result instanceof Error);
+        if (failed.length !== 0 && failed.length !== results.length) {
+            this.fail(results);
+        }
+    }
+}
+exports.XNORAssertion = XNORAssertion;
+//# sourceMappingURL=xnor.js.map

package/assertion/xnor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xnor.js","sourceRoot":"","sources":["../../src/assertion/xnor.ts"],"names":[],"mappings":";;;AAEA,yCAA6C;AAE7C,MAAa,aAAc,SAAQ,4BAAiB;IAClD,YAAY,GAAG,MAAsC;QACnD,KAAK,CAAC,MAAM,EAAE,6FAA6F,EAAE,GAAG,MAAM,CAAC,CAAC;IAC1H,CAAC;IAED,YAAY,CAAC,OAA2B;QACtC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC;QACnE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC;YAC5D,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AAXD,sCAWC"}

package/assertion/xor.d.ts

@@ -0,0 +1,7 @@
+import { Assertion } from "./assertion";
+import type { AssertionValue, EvaluationResult } from "../types";
+import { VariadicAssertion } from "./variadic";
+export declare class XORAssertion extends VariadicAssertion {
+    constructor(...values: (AssertionValue | Assertion)[]);
+    onEvaluation(results: EvaluationResult[]): void | Promise<void>;
+}

package/assertion/xor.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XORAssertion = void 0;
+const variadic_1 = require("./variadic");
+class XORAssertion extends variadic_1.VariadicAssertion {
+    constructor(...values) {
+        super("XOR", "Expected odd number of expressions to pass, but even number did.", ...values);
+    }
+    onEvaluation(results) {
+        const failed = results.filter((result) => result instanceof Error);
+        const nPassed = results.length - failed.length;
+        if (nPassed % 2 === 0) {
+            this.fail(results);
+        }
+    }
+}
+exports.XORAssertion = XORAssertion;
+//# sourceMappingURL=xor.js.map

package/assertion/xor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xor.js","sourceRoot":"","sources":["../../src/assertion/xor.ts"],"names":[],"mappings":";;;AAEA,yCAA6C;AAE7C,MAAa,YAAa,SAAQ,4BAAiB;IACjD,YAAY,GAAG,MAAsC;QACnD,KAAK,CAAC,KAAK,EAAE,kEAAkE,EAAE,GAAG,MAAM,CAAC,CAAC;IAC9F,CAAC;IAED,YAAY,CAAC,OAA2B;QACtC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC;QACnE,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC/C,IAAI,OAAO,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AAZD,oCAYC"}

package/error.d.ts

@@ -0,0 +1,12 @@
+import { Assertion } from "./assertion/assertion";
+import { AnyValue, EvaluationResult } from "./types";
+export declare class AssertionError extends Error {
+    readonly operator: string;
+    readonly expectation: string;
+    readonly assertion: Assertion;
+    readonly results?: EvaluationResult[];
+    constructor(operator: string, expectation: string, assertion: Assertion, results?: EvaluationResult[]);
+}
+export declare class FailedAssertionError extends Error {
+    constructor(value: AnyValue);
+}

package/error.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailedAssertionError = exports.AssertionError = void 0;
+const yaml_1 = require("yaml");
+const pass_1 = require("./assertion/pass");
+function getErrorRepresentation(operator, expectation, assertion, results) {
+    const repr = {
+        [`AssertionError (${operator})`]: expectation,
+    };
+    if ((results === null || results === void 0 ? void 0 : results.length) > 0) {
+        repr.Results = results.map((result) => {
+            if (result instanceof AssertionError) {
+                return getErrorRepresentation(result.operator, result.expectation, result.assertion, result.results);
+            }
+            if (result instanceof Error) {
+                return {
+                    // eslint-disable-next-line no-control-regex
+                    Error: result.message.replace(/\u001b\[\d+m/g, ''),
+                };
+            }
+            return "Pass";
+        });
+    }
+    repr.Expression = assertion.toString();
+    return repr;
+}
+class AssertionError extends Error {
+    constructor(operator, expectation, assertion, results) {
+        super((0, yaml_1.stringify)(getErrorRepresentation(operator, expectation, assertion, results), {
+            indent: 2,
+            // defaultStringType: "PLAIN",
+            // defaultKeyType: "PLAIN",
+            collectionStyle: 'block',
+            // lineWidth: 0,
+            // blockQuote: true,
+            doubleQuotedMinMultiLineLength: Infinity,
+        }));
+        this.operator = operator;
+        this.expectation = expectation;
+        this.assertion = assertion;
+        this.results = results;
+        this.name = "AssertionError";
+    }
+}
+exports.AssertionError = AssertionError;
+class FailedAssertionError extends Error {
+    constructor(value) {
+        super(`Failed expression: ${(0, pass_1.valueToString)(value)}`);
+        this.name = "FailedAssertionError";
+    }
+}
+exports.FailedAssertionError = FailedAssertionError;
+//# sourceMappingURL=error.js.map

package/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":";;;AACA,+BAA+B;AAE/B,2CAA+C;AAI/C,SAAS,sBAAsB,CAAC,QAAgB,EAAE,WAAmB,EAAE,SAAoB,EAAE,OAA4B;IACvH,MAAM,IAAI,GAAc;QACtB,CAAC,mBAAmB,QAAQ,GAAG,CAAC,EAAE,WAAW;KAC9C,CAAC;IACF,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,MAAM,IAAG,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YACpC,IAAI,MAAM,YAAY,cAAc,EAAE,CAAC;gBACrC,OAAO,sBAAsB,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;YACvG,CAAC;YACD,IAAI,MAAM,YAAY,KAAK,EAAE,CAAC;gBAC5B,OAAO;oBACL,4CAA4C;oBAC5C,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC;iBACnD,CAAC;YACJ,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;IACD,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAC;IACvC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAa,cAAe,SAAQ,KAAK;IACvC,YACkB,QAAgB,EAChB,WAAmB,EACnB,SAAoB,EACpB,OAA4B;QAE5C,KAAK,CAAC,IAAA,gBAAS,EACb,sBAAsB,CAAC,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,CAAC,EACjE;YACE,MAAM,EAAE,CAAC;YACT,8BAA8B;YAC9B,2BAA2B;YAC3B,eAAe,EAAE,OAAO;YACxB,gBAAgB;YAChB,oBAAoB;YACpB,8BAA8B,EAAE,QAAQ;SACzC,CACF,CAAC,CAAC;QAhBa,aAAQ,GAAR,QAAQ,CAAQ;QAChB,gBAAW,GAAX,WAAW,CAAQ;QACnB,cAAS,GAAT,SAAS,CAAW;QACpB,YAAO,GAAP,OAAO,CAAqB;QAc5C,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAAC;IAC/B,CAAC;CACF;AArBD,wCAqBC;AAED,MAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,KAAe;QACzB,KAAK,CAAC,sBAAsB,IAAA,oBAAa,EAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AALD,oDAKC"}

package/index.d.ts

@@ -0,0 +1,17 @@
+import type { AssertionValue } from "./types";
+import { PASSAssertion } from "./assertion/pass";
+import { NOTAssertion } from "./assertion/not";
+import { ORAssertion } from "./assertion/or";
+import { ANDAssertion } from "./assertion/and";
+import { XORAssertion } from "./assertion/xor";
+import { NORAssertion } from "./assertion/nor";
+import { NANDAssertion } from "./assertion/nand";
+import { XNORAssertion } from "./assertion/xnor";
+export declare const pass: (value: AssertionValue) => PASSAssertion;
+export declare const not: (value: AssertionValue) => NOTAssertion;
+export declare const or: (...values: AssertionValue[]) => ORAssertion;
+export declare const and: (...values: AssertionValue[]) => ANDAssertion;
+export declare const nor: (...values: AssertionValue[]) => NORAssertion;
+export declare const nand: (...values: AssertionValue[]) => NANDAssertion;
+export declare const xor: (...values: AssertionValue[]) => XORAssertion;
+export declare const xnor: (...values: AssertionValue[]) => XNORAssertion;

package/index.js

@@ -0,0 +1,37 @@
+"use strict";
+// import debug = require("debug");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xnor = exports.xor = exports.nand = exports.nor = exports.and = exports.or = exports.not = exports.pass = void 0;
+const pass_1 = require("./assertion/pass");
+const not_1 = require("./assertion/not");
+const or_1 = require("./assertion/or");
+const and_1 = require("./assertion/and");
+const xor_1 = require("./assertion/xor");
+const nor_1 = require("./assertion/nor");
+const nand_1 = require("./assertion/nand");
+const xnor_1 = require("./assertion/xnor");
+const lines_builder_1 = require("lines-builder");
+(0, lines_builder_1.setDefaultOptions)({
+    // Need to force EOL to be Unix style, because Windows style is not supported by YAML
+    eol: "\n",
+    trimLeft: false,
+    skipFirstLevelIndent: true,
+    indent: 2
+});
+const pass = (value) => new pass_1.PASSAssertion(value);
+exports.pass = pass;
+const not = (value) => new not_1.NOTAssertion(value);
+exports.not = not;
+const or = (...values) => new or_1.ORAssertion(...values);
+exports.or = or;
+const and = (...values) => new and_1.ANDAssertion(...values);
+exports.and = and;
+const nor = (...values) => new nor_1.NORAssertion(...values);
+exports.nor = nor;
+const nand = (...values) => new nand_1.NANDAssertion(...values);
+exports.nand = nand;
+const xor = (...values) => new xor_1.XORAssertion(...values);
+exports.xor = xor;
+const xnor = (...values) => new xnor_1.XNORAssertion(...values);
+exports.xnor = xnor;
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,mCAAmC;;;AAKnC,2CAA+C;AAC/C,yCAA6C;AAC7C,uCAA2C;AAC3C,yCAA6C;AAC7C,yCAA6C;AAC7C,yCAA6C;AAC7C,2CAA+C;AAC/C,2CAA+C;AAE/C,iDAAgD;AAEhD,IAAA,iCAAiB,EAAC;IAChB,qFAAqF;IACrF,GAAG,EAAE,IAAI;IACT,QAAQ,EAAE,KAAK;IACf,oBAAoB,EAAE,IAAI;IAC1B,MAAM,EAAE,CAAC;CACV,CAAC,CAAC;AAEI,MAAM,IAAI,GAAG,CAAC,KAAqB,EAAE,EAAE,CAAC,IAAI,oBAAa,CAAC,KAAK,CAAC,CAAC;AAA3D,QAAA,IAAI,QAAuD;AACjE,MAAM,GAAG,GAAG,CAAC,KAAqB,EAAE,EAAE,CAAC,IAAI,kBAAY,CAAC,KAAK,CAAC,CAAC;AAAzD,QAAA,GAAG,OAAsD;AAC/D,MAAM,EAAE,GAAG,CAAC,GAAG,MAAwB,EAAE,EAAE,CAAC,IAAI,gBAAW,CAAC,GAAG,MAAM,CAAC,CAAC;AAAjE,QAAA,EAAE,MAA+D;AACvE,MAAM,GAAG,GAAG,CAAC,GAAG,MAAwB,EAAE,EAAE,CAAC,IAAI,kBAAY,CAAC,GAAG,MAAM,CAAC,CAAC;AAAnE,QAAA,GAAG,OAAgE;AACzE,MAAM,GAAG,GAAG,CAAC,GAAG,MAAwB,EAAE,EAAE,CAAC,IAAI,kBAAY,CAAC,GAAG,MAAM,CAAC,CAAC;AAAnE,QAAA,GAAG,OAAgE;AACzE,MAAM,IAAI,GAAG,CAAC,GAAG,MAAwB,EAAE,EAAE,CAAC,IAAI,oBAAa,CAAC,GAAG,MAAM,CAAC,CAAC;AAArE,QAAA,IAAI,QAAiE;AAC3E,MAAM,GAAG,GAAG,CAAC,GAAG,MAAwB,EAAE,EAAE,CAAC,IAAI,kBAAY,CAAC,GAAG,MAAM,CAAC,CAAC;AAAnE,QAAA,GAAG,OAAgE;AACzE,MAAM,IAAI,GAAG,CAAC,GAAG,MAAwB,EAAE,EAAE,CAAC,IAAI,oBAAa,CAAC,GAAG,MAAM,CAAC,CAAC;AAArE,QAAA,IAAI,QAAiE"}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "assert-logic",
+  "version": "1.0.0",
+  "description": "This repository/project is a template/placeholder for new NPM packages.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "npm run buildUpdate && npm test && npm run typedoc",
+    "buildUpdate": "npm run clean && npm run compile && npm run copyToDist",
+    "copyToDist": "copyfiles -f *.txt *.md package.json dist",
+    "typedoc": "typedoc --out ./docs ./src && touch ./docs/.nojekyll",
+    "clean": "rimraf ./dist ./docs ./reports ./coverage",
+    "test": "dotenv-ng --var JEST_JUNIT_OUTPUT_DIR=./reports -- jest --coverage -u",
+    "lint": "eslint . --ext .ts --fix",
+    "compile": "tsc && npm run lint"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/szikszail/assert-logic.git"
+  },
+  "keywords": [],
+  "author": "Laszlo Szikszai <sziklaszlo@gmail.com>",
+  "license": "MIT",
+  "files": [
+    "**/*.js",
+    "**/*.d.ts",
+    "**/*.js.map"
+  ],
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/szikszail/assert-logic/issues"
+  },
+  "homepage": "https://github.com/szikszail/assert-logic#readme",
+  "devDependencies": {
+    "@types/chai": "^4.2.21",
+    "@types/debug": "^4.1.12",
+    "@types/jest": "^29.5.12",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.11.20",
+    "@typescript-eslint/eslint-plugin": "^7.0.2",
+    "@typescript-eslint/parser": "^7.0.2",
+    "chai": "^4.3.4",
+    "copyfiles": "^2.4.1",
+    "dotenv-ng": "^1.3.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.2",
+    "typedoc": "^0.25.9",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "debug": "^4.3.4",
+    "lines-builder": "^1.5.1",
+    "yaml": "^2.4.0"
+  },
+  "jest": {
+    "reporters": [
+      "default",
+      "jest-junit"
+    ],
+    "transform": {
+      "^.+\\.ts?$": "ts-jest"
+    },
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/tests/**/*.test.ts"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "dist"
+    ],
+    "setupFilesAfterEnv": [
+      "./tests/setup/areStringsMatch.ts"
+    ],
+    "coverageDirectory": "./coverage",
+    "collectCoverageFrom": [
+      "./src/**/*.ts"
+    ],
+    "moduleFileExtensions": [
+      "ts",
+      "js"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 85,
+        "functions": 85,
+        "lines": 85,
+        "statements": 85
+      }
+    }
+  }
+}