kizu 0.0.0-autorel

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Marc H. Weiner
+
+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,124 @@
+<picture>
+    <source srcset="docs/kitest-logo-light.svg" media="(prefers-color-scheme: light)">
+    <source srcset="docs/kitest-logo-dark.svg" media="(prefers-color-scheme: dark)">
+    <img src="docs/kitest-logo-light.svg" alt="Logo" style="margin: 0 0 10px" size="250">
+</picture>
+
+[![build status](https://github.com/mhweiner/kitest/actions/workflows/release.yml/badge.svg)](https://github.com/mhweiner/kitest/actions)
+[![SemVer](https://img.shields.io/badge/SemVer-2.0.0-blue)]()
+[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org)
+[![AutoRel](https://img.shields.io/badge/v2-AutoRel?label=AutoRel&labelColor=0ab5fc&color=grey&link=https%3A%2F%2Fgithub.com%2Fmhweiner%2Fautorel)](https://github.com/mhweiner/autorel)
+
+**kitest** is a fast, minimalist test runner for TypeScript and JavaScript, with a small, easy-to-learn API that lets you focus on your tests — not your tooling.
+
+Fast, minimal, precise, safe, atomic, and easy to use.
+
+## Features
+
+**🚀 Fast & Reliable**
+- Multi-process parallel test runner. Each test file is run in its own process/runtime for performance and isolation benefits. _Use on a multicore machine for best results._
+- Optimized for speed and simplicity.
+- Minimal dependencies.
+
+**😀 Easy to Use**
+- Very simple functional [assertion API](docs/api.md). No need to learn a DSL or framework.
+- Built-in [powerful diff visualization tool](#visual-diff-tool) and clean, organized output.
+- Failed tests are easy to find, grouped at the end of the output.
+- Errors or unhandled promise rejections are buffered and grouped under the test file in the output. This helps you know where they came from.
+- Clean stack traces with no extra noise.
+
+**🛡 Defensive**
+- Uncaught errors and unhandled promise rejections will cause the test to fail.
+- Any spec files without tests, or tests without assertions, result in a failed test.
+- Strict and deep equality comparison by default.
+
+**🔒 Out-of-the-box Typescript support**
+- No special configuration needed, and no plugins to install. 
+- Works great with [c8](https://github.com/bcoe/c8) for code coverage.
+- Handles compilation errors gracefully.
+
+# Quick Examples
+
+```typescript
+import {test} from '@kitest/kitest';
+
+// Basic test
+
+function greet(name: string): string {
+  return `hello, ${name}`;
+}
+
+test('greet()', (assert) => {
+  assert.equal(hello('world'), 'hello, world');
+});
+
+// Error handling
+
+function throwError(): never {
+  throw new Error('oops');
+}
+
+test('throwError()', (assert) => {
+  assert.throws(() => throwError(), /oops/);
+});
+
+// Async test
+
+async function fetchData(): Promise<string> {
+  return Promise.resolve('data');
+}
+
+test('fetchData()', async (assert) => {
+  const data = await fetchData();
+  assert.equal(data, 'data');
+});
+```
+
+# Table of Contents
+
+- [Getting Started](docs/gettingStarted.md)
+- [Examples](#examples)
+- [API](docs/api.md)
+- [Visual Diff Tool](docs/visualDiff.md)
+- [Best Practices](docs/bestPractices.md)
+- [Inspiration, Philosophy & Attribution](docs/inspiration.md)
+- [FAQ](docs/faq.md)
+- [Support, Feedback, and Contributions](#support-feedback-and-contributions)
+- [Sponsorship](#sponsorship)
+- [License](LICENSE)
+
+# Getting Started
+
+To install and get started with `kitest`, see our [Getting Started](docs/gettingStarted.md) guide.
+
+# Examples
+
+See the [examples](examples) and [src](src) folders for more examples.
+
+# Support, feedback, and contributions
+
+- Star this repo if you like it!
+- Submit an [issue](https://github.com/mhweiner/kitest/issues) with your problem, feature request or bug report
+- Issue a PR against `main` and request review. Make sure all tests pass and coverage is good.
+- Write about this project in your blog, tweet about it, or share it with your friends!
+
+# Sponsorship
+<br>
+<picture>
+    <source srcset="docs/aeroview-white.svg" media="(prefers-color-scheme: dark)">
+    <source srcset="docs/aeroview-black.svg" media="(prefers-color-scheme: light)">
+    <img src="docs/aeroview-black.svg" alt="Logo" height="20">
+</picture>
+<br>
+
+Aeroview is a lightning-fast, developer-friendly, AI-powered logging IDE. Get started for free at [https://aeroview.io](https://aeroview.io).
+
+Want to sponsor this project? [Reach out](mailto:mhweiner234@gmail.com?subject=I%20want%20to%20sponsor%20kitest).
+
+# Other useful libraries
+
+- [autorel](https://github.com/mhweiner/autorel): Automate semantic releases based on conventional commits. Similar to semantic-release but much simpler.
+- [brek](https://github.com/mhweiner/brek): A powerful yet simple configuration library for Node.js. It’s structured, typed, and designed for dynamic configuration loading, making it perfect for securely managing secrets (e.g., AWS Secrets Manager).
+- [jsout](https://github.com/mhweiner/jsout): A Syslog-compatible, small, and simple logger for Typescript/Javascript projects.
+- [cjs-mock](https://github.com/mhweiner/cjs-mock): NodeJS module mocking for CJS (CommonJS) modules for unit testing purposes.
+- [typura](https://github.com/aeroview/typura): Simple and extensible runtime input validation for TS/JS, written in TS.

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env ts-node
+
+require('../dist/run');

package/dist/assertions/AssertionError.d.ts

@@ -0,0 +1,3 @@
+export declare class AssertionError extends Error {
+    constructor(message: string);
+}

package/dist/assertions/AssertionError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionError = void 0;
+class AssertionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+exports.AssertionError = AssertionError;
+//# sourceMappingURL=AssertionError.js.map

package/dist/assertions/equal.d.ts

@@ -0,0 +1,2 @@
+import { Assertion } from '../test';
+export declare function equal(assertions: Assertion[], actual: any, expected: any, description?: string): void;

package/dist/assertions/equal.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equal = equal;
+const deepStrictEqual_1 = require("../lib/deepStrictEqual");
+const util = __importStar(require("util"));
+const kleur_1 = __importDefault(require("kleur"));
+const AssertionError_1 = require("./AssertionError");
+const diff_1 = require("../lib/diff");
+function equal(assertions, actual, expected, description) {
+    const descWithDefault = description || 'equal()';
+    if ((0, deepStrictEqual_1.deepStrictEqual)(actual, expected)) {
+        assertions.push({ pass: true, description: descWithDefault });
+    }
+    else {
+        const diagnostic = createDiagnostic(actual, expected);
+        const stack = new AssertionError_1.AssertionError('not deeply and strictly equivalent').stack;
+        assertions.push({ pass: false, description: descWithDefault, diagnostic, stack });
+    }
+}
+function createDiagnostic(actual, expected) {
+    const diff = (0, diff_1.getDiff)(actual, expected);
+    const actualStr = util.inspect(actual, { colors: true, depth: null });
+    const expectedStr = util.inspect(expected, { colors: true, depth: null });
+    const sectionActual = `${kleur_1.default.grey().bold('Actual:')}\n\n${actualStr}`;
+    const sectionExpected = `\n\n${kleur_1.default.grey().bold('Expected:')}\n\n${expectedStr}`;
+    const sectionDiff = diff && `\n\n${kleur_1.default.grey().bold('Diff:')}\n\n${diff}`;
+    return `${sectionActual}${sectionExpected}${sectionDiff}\n`;
+}
+//# sourceMappingURL=equal.js.map

package/dist/assertions/errorsEquivalent.d.ts

@@ -0,0 +1,3 @@
+import { Assertion } from '../test';
+export declare function errorsEquivalent(assertions: Assertion[], actualErr: Error, expectedErr: Error | RegExp, description?: string): void;
+export declare function createDiagnosticRegexMismatch(actualErrMsg: string, expectedRegEx: RegExp): string;

package/dist/assertions/errorsEquivalent.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorsEquivalent = errorsEquivalent;
+exports.createDiagnosticRegexMismatch = createDiagnosticRegexMismatch;
+const serialize_error_1 = require("serialize-error");
+const equal_1 = require("./equal");
+const pass_1 = require("./pass");
+const AssertionError_1 = require("./AssertionError");
+const kleur_1 = __importDefault(require("kleur"));
+function errorsEquivalent(assertions, actualErr, expectedErr, description) {
+    if (!(actualErr instanceof Error))
+        throw new Error('actualErr is not an instance of Error');
+    if (!(expectedErr instanceof Error) && !(expectedErr instanceof RegExp))
+        throw new Error('expectedErr is not an instance of Error or a RegExp');
+    if (expectedErr instanceof RegExp) {
+        if (!expectedErr.test(actualErr.message)) {
+            const diagnostic = createDiagnosticRegexMismatch(actualErr.message, expectedErr);
+            const stack = new AssertionError_1.AssertionError('Expected error message does not match').stack;
+            assertions.push({ pass: false, description: description !== null && description !== void 0 ? description : 'errorsEquivalent()', diagnostic, stack });
+        }
+        else {
+            (0, pass_1.pass)(assertions, description !== null && description !== void 0 ? description : 'errorsEquivalent()');
+        }
+    }
+    else {
+        compareErrorObjects(assertions, actualErr, expectedErr, description);
+    }
+}
+function compareErrorObjects(assertions, actualErr, expectedErr, description) {
+    if (!(actualErr instanceof Error))
+        throw new Error('actualErr is not an instance of Error');
+    if (!(expectedErr instanceof Error) && !(expectedErr instanceof RegExp))
+        throw new Error('expectedErr is not an instance of Error or a RegExp');
+    const actualErrSerialized = (0, serialize_error_1.serializeError)(actualErr);
+    const expectedErrSerialized = (0, serialize_error_1.serializeError)(expectedErr);
+    // ignore stack traces
+    actualErrSerialized === null || actualErrSerialized === void 0 ? true : delete actualErrSerialized.stack;
+    expectedErrSerialized === null || expectedErrSerialized === void 0 ? true : delete expectedErrSerialized.stack;
+    (0, equal_1.equal)(assertions, actualErrSerialized, expectedErrSerialized, description || 'errorsEquivalent()');
+}
+function createDiagnosticRegexMismatch(actualErrMsg, expectedRegEx) {
+    const actual = `${kleur_1.default.grey().bold('Actual Error Message:')}\n\n${actualErrMsg}`;
+    const expected = `\n\n${kleur_1.default.grey().bold('Expected RegEx:')}\n\n${expectedRegEx}`;
+    return `${actual}${expected}\n\n`;
+}
+//# sourceMappingURL=errorsEquivalent.js.map

package/dist/assertions/fail.d.ts

@@ -0,0 +1,2 @@
+import { Assertion } from '../test';
+export declare function fail(assertions: Assertion[], description?: string): void;

package/dist/assertions/fail.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fail = fail;
+function fail(assertions, description) {
+    assertions.push({ pass: false, description: description !== null && description !== void 0 ? description : 'fail()' });
+}
+//# sourceMappingURL=fail.js.map

package/dist/assertions/index.d.ts

@@ -0,0 +1,10 @@
+import { Assertion } from '../test';
+export declare function createAssertionPredicates(assertions: Assertion[]): {
+    pass: (description?: string) => void;
+    fail: (description?: string) => void;
+    isTrue: (condition: boolean, description?: string) => void;
+    isFalse: (condition: boolean, description?: string) => void;
+    equal: (actual: any, expected: any, description?: string) => void;
+    errorsEquivalent: (actual: any, expected: any, description?: string) => void;
+    throws: (experiment: () => any, expectedErr: Error | RegExp, description?: string) => void;
+};

package/dist/assertions/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAssertionPredicates = createAssertionPredicates;
+const errorsEquivalent_1 = require("./errorsEquivalent");
+const equal_1 = require("./equal");
+const throws_1 = require("./throws");
+const isTrue_1 = require("./isTrue");
+const isFalse_1 = require("./isFalse");
+const fail_1 = require("./fail");
+const pass_1 = require("./pass");
+function createAssertionPredicates(assertions) {
+    return {
+        pass: (description) => ((0, pass_1.pass)(assertions, description)),
+        fail: (description) => ((0, fail_1.fail)(assertions, description)),
+        isTrue: (condition, description) => ((0, isTrue_1.isTrue)(assertions, condition, description)),
+        isFalse: (condition, description) => ((0, isFalse_1.isFalse)(assertions, condition, description)),
+        equal: (actual, expected, description) => ((0, equal_1.equal)(assertions, actual, expected, description)),
+        errorsEquivalent: (actual, expected, description) => ((0, errorsEquivalent_1.errorsEquivalent)(assertions, actual, expected, description)),
+        throws: (experiment, expectedErr, description) => ((0, throws_1.throws)(assertions, experiment, expectedErr, description)),
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/assertions/isFalse.d.ts

@@ -0,0 +1,2 @@
+import { Assertion } from '../test';
+export declare function isFalse(assertions: Assertion[], condition: boolean, description?: string): void;

package/dist/assertions/isFalse.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFalse = isFalse;
+const util = __importStar(require("util"));
+const kleur_1 = __importDefault(require("kleur"));
+const AssertionError_1 = require("./AssertionError");
+function isFalse(assertions, condition, description) {
+    const descWithDefault = description || 'isFalse()';
+    if (!condition) {
+        assertions.push({ pass: true, description: descWithDefault });
+    }
+    else {
+        const diagnostic = createDiagnostic(condition);
+        const stack = new AssertionError_1.AssertionError('is not false').stack;
+        assertions.push({ pass: false, description: descWithDefault, diagnostic, stack });
+    }
+}
+function createDiagnostic(actual) {
+    const actualStr = util.inspect(actual, { colors: true, depth: null });
+    const sectionActual = `${kleur_1.default.grey().bold('Actual:')}\n\n${actualStr}`;
+    return `${sectionActual}\n`;
+}
+//# sourceMappingURL=isFalse.js.map

package/dist/assertions/isTrue.d.ts

@@ -0,0 +1,2 @@
+import { Assertion } from '../test';
+export declare function isTrue(assertions: Assertion[], condition: boolean, description?: string): void;

package/dist/assertions/isTrue.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTrue = isTrue;
+const util = __importStar(require("util"));
+const kleur_1 = __importDefault(require("kleur"));
+const AssertionError_1 = require("./AssertionError");
+function isTrue(assertions, condition, description) {
+    const descWithDefault = description || 'isTrue()';
+    if (condition) {
+        assertions.push({ pass: true, description: descWithDefault });
+    }
+    else {
+        const diagnostic = createDiagnostic(condition);
+        const stack = new AssertionError_1.AssertionError('is not true').stack;
+        assertions.push({ pass: false, description: descWithDefault, diagnostic, stack });
+    }
+}
+function createDiagnostic(actual) {
+    const actualStr = util.inspect(actual, { colors: true, depth: null });
+    const sectionActual = `${kleur_1.default.grey().bold('Actual:')}\n\n${actualStr}`;
+    return `${sectionActual}\n`;
+}
+//# sourceMappingURL=isTrue.js.map

package/dist/assertions/pass.d.ts

@@ -0,0 +1,2 @@
+import { Assertion } from '../test';
+export declare function pass(assertions: Assertion[], description?: string): void;

package/dist/assertions/pass.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pass = pass;
+function pass(assertions, description) {
+    assertions.push({ pass: true, description: description !== null && description !== void 0 ? description : 'pass()' });
+}
+//# sourceMappingURL=pass.js.map

package/dist/assertions/throws.d.ts

@@ -0,0 +1,2 @@
+import { Assertion } from '../test';
+export declare function throws(assertions: Assertion[], experiment: () => any, expectedErr: Error | RegExp, description?: string): void;

package/dist/assertions/throws.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throws = throws;
+const toResult_1 = require("../lib/toResult");
+const errorsEquivalent_1 = require("./errorsEquivalent");
+function throws(assertions, experiment, expectedErr, description) {
+    if (typeof experiment !== 'function')
+        throw new Error('experiment must be a function');
+    if (!(expectedErr instanceof Error) && !(expectedErr instanceof RegExp))
+        throw new Error('expectedErr is not an instance of Error or a RegExp');
+    const [actualErr] = (0, toResult_1.toResult)(experiment);
+    if (!actualErr)
+        throw new Error('experiment did not throw an error');
+    (0, errorsEquivalent_1.errorsEquivalent)(assertions, actualErr, expectedErr, description || 'throws()');
+}
+//# sourceMappingURL=throws.js.map

package/dist/calculateFinalResults.d.ts

@@ -0,0 +1,9 @@
+import { TestResultsByFile } from './run';
+export declare function calculateFinalResults(specFiles: string[], testResults: TestResultsByFile): {
+    numFiles: number;
+    numTests: number;
+    numSuccessfulTests: number;
+    filesWithNoTests: string[];
+    numAssertions: number;
+    numSuccessfulAssertions: number;
+};

package/dist/calculateFinalResults.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFinalResults = calculateFinalResults;
+const isTestPassing_1 = require("./isTestPassing");
+function calculateFinalResults(specFiles, testResults) {
+    const numFiles = Object.keys(testResults).length;
+    const filesWithNoTests = specFiles.reduce((files, filename) => (testResults[filename] ? files : files.concat([filename])), []);
+    const numTests = Object.values(testResults).reduce((acc, results) => acc + results.length, 0);
+    const numSuccessfulTests = Object.values(testResults).reduce((acc, results) => (acc + results.reduce((acc, test) => (acc + ((0, isTestPassing_1.isTestPassing)(test) ? 1 : 0)), 0)), 0);
+    const numAssertions = Object.values(testResults).reduce((acc, results) => (acc + results.reduce((acc, test) => acc + test.assertions.length, 0)), 0);
+    const numSuccessfulAssertions = Object.values(testResults).reduce((acc, results) => (acc + results.reduce((acc, test) => (acc + test.assertions.reduce((acc, assertion) => acc + (assertion.pass ? 1 : 0), 0)), 0)), 0);
+    return {
+        numFiles,
+        numTests,
+        numSuccessfulTests,
+        filesWithNoTests,
+        numAssertions,
+        numSuccessfulAssertions,
+    };
+}
+//# sourceMappingURL=calculateFinalResults.js.map

package/dist/getSpecFiles.d.ts

@@ -0,0 +1 @@
+export declare function getSpecFiles(): Promise<string[]>;

package/dist/getSpecFiles.js

@@ -0,0 +1,22 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecFiles = getSpecFiles;
+const tiny_glob_1 = __importDefault(require("tiny-glob"));
+function getSpecFiles() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (0, tiny_glob_1.default)(process.argv[2]);
+    });
+}
+//# sourceMappingURL=getSpecFiles.js.map

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './test';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./test"), exports);
+//# sourceMappingURL=index.js.map

package/dist/isTestPassing.d.ts

@@ -0,0 +1,6 @@
+import { TestResults } from './test';
+/**
+ * All assertions must pass, with no errors, and at least one assertion.
+ * @param test
+ */
+export declare function isTestPassing(test: TestResults): boolean;

package/dist/isTestPassing.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTestPassing = isTestPassing;
+/**
+ * All assertions must pass, with no errors, and at least one assertion.
+ * @param test
+ */
+function isTestPassing(test) {
+    if (!test.assertions.length)
+        return false;
+    if (test.error)
+        return false;
+    return test.assertions.reduce((pass, assertion) => pass && assertion.pass, true);
+}
+//# sourceMappingURL=isTestPassing.js.map

package/dist/lib/deepStrictEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepStrictEqual(obj1: any, obj2: any): boolean;

package/dist/lib/deepStrictEqual.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepStrictEqual = deepStrictEqual;
+/* eslint-disable max-lines-per-function */
+function deepStrictEqual(obj1, obj2) {
+    if (obj1 === obj2)
+        return true;
+    if (isPrimitive(obj1) && isPrimitive(obj2))
+        return obj1 === obj2;
+    if (Array.isArray(obj1) !== Array.isArray(obj2))
+        return false;
+    if (typeof obj1 !== typeof obj2)
+        return false;
+    if (obj1 === null || obj2 === null)
+        return false;
+    // Handle Map objects
+    if (obj1 instanceof Map && obj2 instanceof Map) {
+        if (obj1.size !== obj2.size)
+            return false;
+        for (const [key, value] of obj1) {
+            if (!obj2.has(key) || !deepStrictEqual(value, obj2.get(key)))
+                return false;
+        }
+        return true;
+    }
+    // Handle Set objects
+    if (obj1 instanceof Set && obj2 instanceof Set) {
+        if (obj1.size !== obj2.size)
+            return false;
+        for (const item of obj1) {
+            let matchFound = false;
+            for (const item2 of obj2) {
+                if (deepStrictEqual(item, item2)) {
+                    matchFound = true;
+                    break;
+                }
+            }
+            if (!matchFound)
+                return false;
+        }
+        return true;
+    }
+    // Handle object comparison
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    for (const key of keys1) {
+        if (!Object.prototype.hasOwnProperty.call(obj2, key))
+            return false;
+        if (!deepStrictEqual(obj1[key], obj2[key]))
+            return false;
+    }
+    return true;
+}
+// Helper function to check if a value is a primitive
+function isPrimitive(value) {
+    return value !== Object(value);
+}
+//# sourceMappingURL=deepStrictEqual.js.map

package/dist/lib/diff.d.ts

@@ -0,0 +1,2 @@
+export declare function getDiff(actual: any, expected: any): string;
+export declare function stringVisualDiff(actual: string, expected: string): string;

package/dist/lib/diff.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiff = getDiff;
+exports.stringVisualDiff = stringVisualDiff;
+const deep_object_diff_1 = require("deep-object-diff");
+const diff_1 = require("diff");
+const kleur_1 = __importDefault(require("kleur"));
+const node_util_1 = require("node:util");
+function getDiff(actual, expected) {
+    if (actual === expected)
+        return '';
+    if (typeof actual === 'string' && typeof expected === 'string') {
+        return stringVisualDiff(actual, expected);
+    }
+    else if (typeof actual === 'object' && typeof expected === 'object') {
+        return (0, node_util_1.inspect)((0, deep_object_diff_1.diff)(actual, expected), {
+            colors: true,
+            depth: null,
+        });
+    }
+    else {
+        return '';
+    }
+}
+function stringVisualDiff(actual, expected) {
+    return (0, diff_1.diffChars)(actual, expected).reduce((str, part) => str + (part.added ? kleur_1.default.bgGreen().black(part.value) : part.removed
+        ? kleur_1.default.bgRed().white(part.value) : kleur_1.default.white(part.value)), '');
+}
+//# sourceMappingURL=diff.js.map

package/dist/lib/toResult.d.ts

@@ -0,0 +1,4 @@
+export type Result<E, T> = [E] | [undefined, T];
+export type PromiseResult<E, T> = Promise<Result<E, T>>;
+export declare function toResult<E extends Error, T>(executable: () => T): Result<E, T>;
+export declare function toResultAsync<E extends Error, T>(p: Promise<T>): PromiseResult<E, T>;

package/dist/lib/toResult.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toResult = toResult;
+exports.toResultAsync = toResultAsync;
+function toResult(executable) {
+    try {
+        const result = executable();
+        return [undefined, result];
+    }
+    catch (e) {
+        return [e];
+    }
+}
+function toResultAsync(p) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const result = yield p;
+            return [undefined, result];
+        }
+        catch (e) {
+            return [e];
+        }
+    });
+}
+//# sourceMappingURL=toResult.js.map

package/dist/output.d.ts

@@ -0,0 +1,5 @@
+import { TestResultsByFile, FinalResults } from './run';
+import { TestResults } from './test';
+export declare function printResultsByFile(resultsByFile: TestResultsByFile): void;
+export declare function printFileResults(filename: string, tests: TestResults[]): void;
+export declare function printSummary(finalResults: FinalResults): void;

package/dist/output.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printResultsByFile = printResultsByFile;
+exports.printFileResults = printFileResults;
+exports.printSummary = printSummary;
+const kleur_1 = __importDefault(require("kleur"));
+const isTestPassing_1 = require("./isTestPassing");
+const serialize_error_1 = require("serialize-error");
+const sortTestResults_1 = require("./sortTestResults");
+const log = console.log;
+const successSymbol = kleur_1.default.green('✔');
+const failureSymbol = kleur_1.default.red('✖');
+const hr = kleur_1.default.gray('\n────────────────────────────────\n');
+const noTestErrorTpl = (files) => kleur_1.default.red().bold(`
+Error: ${files.length} spec file(s) have no tests. This could indicate a compilation error 
+(ie. Typescript), or an early runtime error. All spec files must have at least one test. 
+The following spec files do not have any attempted or completed tests:
+
+${files.join(', ')}
+`);
+function printResultsByFile(resultsByFile) {
+    const sortedResults = (0, sortTestResults_1.sortTestResults)(resultsByFile);
+    for (const [filename, tests] of sortedResults) {
+        printFileResults(filename, tests);
+    }
+}
+function printFileResults(filename, tests) {
+    const doesFileHaveFailures = tests.some((test) => !(0, isTestPassing_1.isTestPassing)(test));
+    const header = `${kleur_1.default.underline().blue(filename)} ${doesFileHaveFailures ? failureSymbol : successSymbol}\n`;
+    log(header);
+    tests.forEach(((test) => {
+        log(`${test.description} ${(0, isTestPassing_1.isTestPassing)(test) ? successSymbol : failureSymbol}`);
+        test.assertions.forEach((assertion) => {
+            log(kleur_1.default.gray(`  ${assertion.description} ${assertion.pass ? successSymbol : failureSymbol}`));
+            !assertion.pass && printFailedAssertionDiag(assertion);
+        });
+        test.error && printError(test.error);
+        log('');
+    }));
+}
+function printError(serializedError) {
+    log(hr);
+    log((0, serialize_error_1.deserializeError)(serializedError));
+    log(hr);
+}
+function printFailedAssertionDiag(assertion) {
+    if (!assertion.diagnostic && !assertion.stack)
+        return;
+    log(hr);
+    assertion.diagnostic && log(assertion.diagnostic);
+    assertion.stack && log(kleur_1.default.grey(filterStackTrace(assertion.stack)));
+    log(hr);
+}
+function printSummary(finalResults) {
+    const successRate = finalResults.numSuccessfulTests / finalResults.numTests;
+    const assertionSuccessRate = finalResults.numSuccessfulAssertions / finalResults.numAssertions;
+    const numFilesWithNoTests = finalResults.filesWithNoTests.length;
+    if (assertionSuccessRate === 1) {
+        log(kleur_1.default.bold().green(`${successSymbol} ${finalResults.numSuccessfulAssertions}/${finalResults.numAssertions} assertions passed`));
+    }
+    else {
+        log(kleur_1.default.bold().red(`${failureSymbol} ${finalResults.numSuccessfulAssertions}/${finalResults.numAssertions} assertions passed`));
+    }
+    if (successRate === 1) {
+        log(kleur_1.default.bold().green(`${successSymbol} ${finalResults.numSuccessfulTests}/${finalResults.numTests} tests passed`));
+    }
+    else {
+        log(kleur_1.default.bold().red(`${failureSymbol} ${finalResults.numSuccessfulTests}/${finalResults.numTests} tests passed`));
+    }
+    numFilesWithNoTests && log(noTestErrorTpl(finalResults.filesWithNoTests));
+}
+function filterStackTrace(stack) {
+    const ignoreRegex = [
+        /at Generator.next \(<anonymous>\)/,
+        /at new Promise \(<anonymous>\)/,
+        /assertions\/index.[ts|js]{2}/,
+        /\/kitest\/[src|dist]{3,4}\/test.[ts|js]{2}/,
+    ].reduce((combined, exp) => (new RegExp(`${combined.source}|${exp.source}`)), new RegExp('a^'));
+    return stack.split('\n').reduce((acc, line) => (!ignoreRegex.test(line) ? acc.concat([line]) : acc), []).join('\n');
+}
+//# sourceMappingURL=output.js.map

package/dist/run.d.ts

@@ -0,0 +1,12 @@
+import { TestResults } from './test';
+export type TestResultsByFile = {
+    [file: string]: TestResults[];
+};
+export type FinalResults = {
+    numFiles: number;
+    numTests: number;
+    numSuccessfulTests: number;
+    filesWithNoTests: string[];
+    numAssertions: number;
+    numSuccessfulAssertions: number;
+};

package/dist/run.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ora_1 = __importDefault(require("ora"));
+const output_1 = require("./output");
+const calculateFinalResults_1 = require("./calculateFinalResults");
+const workerPool_1 = require("./workerPool");
+const shouldExitWithError_1 = require("./shouldExitWithError");
+const getSpecFiles_1 = require("./getSpecFiles");
+const testResultsByFile = {};
+let numCompletedTests = 0;
+const status = (0, ora_1.default)();
+function start() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const specFiles = yield (0, getSpecFiles_1.getSpecFiles)();
+        console.log(`Found ${specFiles.length} spec files.\n`);
+        status.start('Running tests...');
+        yield (0, workerPool_1.workerPool)(specFiles, addTestResults);
+        finish(specFiles);
+    });
+}
+/**
+ * Add TestResults and update status.
+ * @param file
+ * @param results
+ */
+function addTestResults(file, results) {
+    numCompletedTests = numCompletedTests + 1;
+    testResultsByFile[file] = (testResultsByFile[file] || []).concat([results]);
+    status.text = `${numCompletedTests} tests completed.`;
+}
+function finish(specFiles) {
+    status.stop();
+    const finalResults = (0, calculateFinalResults_1.calculateFinalResults)(specFiles, testResultsByFile);
+    (0, output_1.printResultsByFile)(testResultsByFile);
+    (0, output_1.printSummary)(finalResults);
+    if ((0, shouldExitWithError_1.shouldExitWithError)(finalResults))
+        process.exit(1);
+}
+start().catch(console.log.bind(console));
+//# sourceMappingURL=run.js.map

package/dist/shouldExitWithError.d.ts

@@ -0,0 +1,2 @@
+import { FinalResults } from './run';
+export declare function shouldExitWithError(finalResults: FinalResults): boolean;

package/dist/shouldExitWithError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldExitWithError = shouldExitWithError;
+function shouldExitWithError(finalResults) {
+    return !!finalResults.filesWithNoTests.length || finalResults.numSuccessfulTests / finalResults.numTests !== 1;
+}
+//# sourceMappingURL=shouldExitWithError.js.map

package/dist/sortTestResults.d.ts

@@ -0,0 +1,3 @@
+import { TestResultsByFile } from './run';
+import { TestResults } from './test';
+export declare function sortTestResults(resultsByFile: TestResultsByFile): Map<string, TestResults[]>;

package/dist/sortTestResults.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortTestResults = sortTestResults;
+const isTestPassing_1 = require("./isTestPassing");
+function sortTestResults(resultsByFile) {
+    const sortedResults = new Map();
+    const passingFiles = [];
+    const failingFiles = [];
+    // Separate passing and failing files
+    for (const [file, tests] of Object.entries(resultsByFile)) {
+        const hasFailingTests = tests.some((test) => !(0, isTestPassing_1.isTestPassing)(test));
+        if (hasFailingTests) {
+            failingFiles.push([file, tests]);
+        }
+        else {
+            passingFiles.push([file, tests]);
+        }
+    }
+    // Sort passing files first, failing files last
+    const sortedFiles = [...passingFiles, ...failingFiles];
+    for (const [file, tests] of sortedFiles) {
+        // Sort tests: passing tests first, failing tests last
+        const sortedTests = [...tests].sort((a, b) => Number((0, isTestPassing_1.isTestPassing)(b)) - Number((0, isTestPassing_1.isTestPassing)(a)));
+        // Sort assertions inside each test: passing assertions first
+        for (const test of sortedTests) {
+            test.assertions.sort((a, b) => Number(b.pass) - Number(a.pass));
+        }
+        sortedResults.set(file, sortedTests);
+    }
+    return sortedResults;
+}
+//# sourceMappingURL=sortTestResults.js.map

package/dist/test.d.ts

@@ -0,0 +1,16 @@
+import { createAssertionPredicates } from './assertions';
+import { ErrorObject } from 'serialize-error';
+export type TestResults = {
+    description: string;
+    assertions: Assertion[];
+    error?: ErrorObject;
+};
+export type Assertion = {
+    pass: boolean;
+    description: string;
+    diagnostic?: string;
+    stack?: string;
+};
+type AssertionAPI = ReturnType<typeof createAssertionPredicates>;
+export declare function test(description: string, experiment: (assert: AssertionAPI) => void): Promise<void>;
+export {};

package/dist/test.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = test;
+const assertions_1 = require("./assertions");
+const serialize_error_1 = require("serialize-error");
+const toResult_1 = require("./lib/toResult");
+process.on('unhandledRejection', (err) => {
+    sendTestResults({
+        description: 'Unhandled Promise Rejection',
+        assertions: [],
+        error: (0, serialize_error_1.serializeError)(err),
+    });
+});
+function test(description, experiment) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const assertions = [];
+        const expAsync = () => __awaiter(this, void 0, void 0, function* () { return experiment((0, assertions_1.createAssertionPredicates)(assertions)); });
+        const [err] = yield (0, toResult_1.toResultAsync)(expAsync());
+        if (err) {
+            sendTestResults({
+                description,
+                assertions: [],
+                error: (0, serialize_error_1.serializeError)(err),
+            });
+        }
+        else {
+            sendTestResults({ description, assertions });
+        }
+    });
+}
+function sendTestResults(results) {
+    // @ts-ignore
+    process.send(results);
+}
+//# sourceMappingURL=test.js.map

package/dist/workerPool.d.ts

@@ -0,0 +1,2 @@
+import { TestResults } from './test';
+export declare function workerPool(specFiles: string[], addTestResults: (file: string, testResults: TestResults) => void): Promise<void>;

package/dist/workerPool.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workerPool = workerPool;
+const os_1 = require("os");
+const child_process_1 = require("child_process");
+const toResult_1 = require("./lib/toResult");
+const numCores = (0, os_1.cpus)().length; // will be the size of our worker pool
+let numWorkers = 0;
+let currentSpecFileIndex = 0;
+function workerPool(specFiles, addTestResults) {
+    return new Promise((resolve, reject) => {
+        function next() {
+            if (currentSpecFileIndex >= specFiles.length && numWorkers === 0)
+                resolve();
+            if (currentSpecFileIndex >= specFiles.length)
+                return;
+            if (numWorkers >= numCores)
+                return;
+            const file = specFiles[currentSpecFileIndex];
+            const [err, worker] = (0, toResult_1.toResult)(() => (0, child_process_1.fork)(file));
+            if (err) {
+                return reject(new Error(`failed to create worker for ${file}`));
+            }
+            numWorkers++;
+            currentSpecFileIndex++;
+            worker.on('close', () => {
+                numWorkers--;
+                next();
+            });
+            worker.on('message', (msg) => addTestResults(file, msg));
+            next();
+        }
+        next();
+    });
+}
+//# sourceMappingURL=workerPool.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "kizu",
+  "version": "0.0.0-autorel",
+  "description": "An easy-to-use, fast, and defensive Typescript/Javascript test runner designed to help you to write simple, readable, and maintainable tests.",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "bin": {
+    "kitest": "bin/cli.js"
+  },
+  "types": "dist/index.d.ts",
+  "files": [
+    "bin",
+    "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.spec.*",
+    "package.json",
+    "package-lock.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mhweiner/hoare.git"
+  },
+  "scripts": {
+    "prepare": "npm run build",
+    "test": "npm run build && c8 ./bin/cli.js '@(examples|src)/**/*.spec.@(ts|js)' && c8 report -r text -r html",
+    "lint": "eslint ./ --ext .js,.ts",
+    "build": "rm -rf ./dist && tsc"
+  },
+  "homepage": "https://github.com/mhweiner/hoare",
+  "keywords": [
+    "unit test",
+    "ts unit test",
+    "typescript unit test",
+    "unit-test",
+    "mocha",
+    "jasmine",
+    "jest",
+    "tape",
+    "ava",
+    "node-tap"
+  ],
+  "dependencies": {
+    "deep-object-diff": "^1.1.0",
+    "diff": "^5.0.0",
+    "kleur": "^4.1.4",
+    "ora": "^5.4.1",
+    "serialize-error": "^8.1.0",
+    "tiny-glob": "^0.2.9"
+  },
+  "devDependencies": {
+    "@types/diff": "^5.0.1",
+    "@types/node": "^16.11.6",
+    "@typescript-eslint/eslint-plugin": "^5.2.0",
+    "@typescript-eslint/parser": "^5.2.0",
+    "c8": "^7.10.0",
+    "cjs-mock": "^0.1.0",
+    "eslint": "^8.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.2"
+  }
+}