@everyonesoftware/common 6.0.0 → 8.0.0

package/outputs/testIndex.cjs

@@ -425,7 +425,26 @@ var PromiseAsyncResult = class _PromiseAsyncResult {
   }
   static create(actionOrPromise) {
     PreCondition.assertNotUndefinedAndNotNull(actionOrPromise, "action or promise");
-    return new _PromiseAsyncResult(Promise.resolve(isPromise(actionOrPromise) ? actionOrPromise : actionOrPromise()));
+    let promise;
+    if (isPromise(actionOrPromise)) {
+      promise = actionOrPromise;
+    } else {
+      let actionExecutor2 = function(resolve, reject) {
+        try {
+          resolve(action());
+        } catch (error) {
+          reject(error);
+        }
+      };
+      var actionExecutor = actionExecutor2;
+      const action = actionOrPromise;
+      ;
+      promise = new Promise(actionExecutor2);
+    }
+    return new _PromiseAsyncResult(promise);
+  }
+  static empty() {
+    return _PromiseAsyncResult.create(Promise.resolve());
   }
   static value(value) {
     return _PromiseAsyncResult.create(Promise.resolve(value));
@@ -1685,6 +1704,118 @@ var Iterator = class _Iterator {
   }
 };
 
+// sources/Indexable.ts
+var Indexable = class _Indexable {
+  static create(values) {
+    return List.create(values);
+  }
+  toArray() {
+    return _Indexable.toArray(this);
+  }
+  static toArray(indexable) {
+    return Iterable.toArray(indexable);
+  }
+  any() {
+    return _Indexable.any(this);
+  }
+  static any(indexable) {
+    return Iterable.any(indexable);
+  }
+  getCount() {
+    return _Indexable.getCount(this);
+  }
+  static getCount(indexable) {
+    return Iterable.getCount(indexable);
+  }
+  equals(right, equalFunctions) {
+    return _Indexable.equals(this, right, equalFunctions);
+  }
+  static equals(left, right, equalFunctions) {
+    return Iterable.equals(left, right, equalFunctions);
+  }
+  toString(toStringFunctions) {
+    return _Indexable.toString(this, toStringFunctions);
+  }
+  static toString(indexable, toStringFunctions) {
+    return Iterable.toString(indexable, toStringFunctions);
+  }
+  concatenate(...toConcatenate) {
+    return _Indexable.concatenate(this, ...toConcatenate);
+  }
+  static concatenate(indexable, ...toConcatenate) {
+    return Iterable.concatenate(indexable, ...toConcatenate);
+  }
+  map(mapping) {
+    return _Indexable.map(this, mapping);
+  }
+  static map(indexable, mapping) {
+    return Iterable.map(indexable, mapping);
+  }
+  flatMap(mapping) {
+    return _Indexable.flatMap(this, mapping);
+  }
+  static flatMap(indexable, mapping) {
+    return Iterable.flatMap(indexable, mapping);
+  }
+  where(condition) {
+    return _Indexable.where(this, condition);
+  }
+  static where(indexable, condition) {
+    return Iterable.where(indexable, condition);
+  }
+  instanceOf(typeOrTypeCheck) {
+    return _Indexable.instanceOf(this, typeOrTypeCheck);
+  }
+  static instanceOf(indexable, typeOrTypeCheck) {
+    return Iterable.instanceOf(indexable, typeOrTypeCheck);
+  }
+  first(condition) {
+    return _Indexable.first(this, condition);
+  }
+  static first(indexable, condition) {
+    let result;
+    if (condition) {
+      result = Iterable.first(indexable, condition);
+    } else {
+      if (indexable.any().await()) {
+        result = indexable.get(0);
+      } else {
+        result = SyncResult.error(new EmptyError());
+      }
+    }
+    return result;
+  }
+  last(condition) {
+    return _Indexable.last(this, condition);
+  }
+  static last(indexable, condition) {
+    let result;
+    if (condition) {
+      result = Iterable.last(indexable, condition);
+    } else {
+      const count = indexable.getCount().await();
+      if (count > 0) {
+        result = indexable.get(count - 1);
+      } else {
+        result = SyncResult.error(new EmptyError());
+      }
+    }
+    return result;
+  }
+  [Symbol.iterator]() {
+    return _Indexable[Symbol.iterator](this);
+  }
+  static [Symbol.iterator](indexable) {
+    return Iterable[Symbol.iterator](indexable);
+  }
+  contains(value, equalFunctions) {
+    return _Indexable.contains(this, value, equalFunctions);
+  }
+  static contains(indexable, value, equalFunctions) {
+    return Iterable.contains(indexable, value, equalFunctions);
+  }
+};
+
 // sources/javascriptArrayList.ts
 var JavascriptArrayList = class _JavascriptArrayList {
   array;
@@ -1786,6 +1917,97 @@ var JavascriptArrayList = class _JavascriptArrayList {
   }
 };
 
+// sources/MutableIndexable.ts
+var MutableIndexable = class _MutableIndexable {
+  static create(values) {
+    return List.create(values);
+  }
+  toArray() {
+    return _MutableIndexable.toArray(this);
+  }
+  static toArray(indexable) {
+    return Indexable.toArray(indexable);
+  }
+  any() {
+    return _MutableIndexable.any(this);
+  }
+  static any(indexable) {
+    return Indexable.any(indexable);
+  }
+  getCount() {
+    return _MutableIndexable.getCount(this);
+  }
+  static getCount(indexable) {
+    return Indexable.getCount(indexable);
+  }
+  equals(right, equalFunctions) {
+    return _MutableIndexable.equals(this, right, equalFunctions);
+  }
+  static equals(left, right, equalFunctions) {
+    return Indexable.equals(left, right, equalFunctions);
+  }
+  toString(toStringFunctions) {
+    return _MutableIndexable.toString(this, toStringFunctions);
+  }
+  static toString(indexable, toStringFunctions) {
+    return Indexable.toString(indexable, toStringFunctions);
+  }
+  concatenate(...toConcatenate) {
+    return _MutableIndexable.concatenate(this, ...toConcatenate);
+  }
+  static concatenate(indexable, ...toConcatenate) {
+    return Indexable.concatenate(indexable, ...toConcatenate);
+  }
+  map(mapping) {
+    return _MutableIndexable.map(this, mapping);
+  }
+  static map(indexable, mapping) {
+    return Indexable.map(indexable, mapping);
+  }
+  flatMap(mapping) {
+    return _MutableIndexable.flatMap(this, mapping);
+  }
+  static flatMap(indexable, mapping) {
+    return Indexable.flatMap(indexable, mapping);
+  }
+  where(condition) {
+    return _MutableIndexable.where(this, condition);
+  }
+  static where(indexable, condition) {
+    return Indexable.where(indexable, condition);
+  }
+  instanceOf(typeOrTypeCheck) {
+    return _MutableIndexable.instanceOf(this, typeOrTypeCheck);
+  }
+  static instanceOf(indexable, typeOrTypeCheck) {
+    return Indexable.instanceOf(indexable, typeOrTypeCheck);
+  }
+  first(condition) {
+    return _MutableIndexable.first(this, condition);
+  }
+  static first(indexable, condition) {
+    return Indexable.first(indexable, condition);
+  }
+  last(condition) {
+    return _MutableIndexable.last(this, condition);
+  }
+  static last(indexable, condition) {
+    return Indexable.last(indexable, condition);
+  }
+  [Symbol.iterator]() {
+    return Indexable[Symbol.iterator](this);
+  }
+  static [Symbol.iterator](indexable) {
+    return Iterable[Symbol.iterator](indexable);
+  }
+  contains(value, equalFunctions) {
+    return _MutableIndexable.contains(this, value, equalFunctions);
+  }
+  static contains(indexable, value, equalFunctions) {
+    return Indexable.contains(indexable, value, equalFunctions);
+  }
+};
+
 // sources/javascript.ts
 var JavascriptMap = Map;
 var JavascriptSet = Set;
@@ -2633,85 +2855,85 @@ var List = class _List {
     return _List.toArray(this);
   }
   static toArray(list2) {
-    return Iterable.toArray(list2);
+    return MutableIndexable.toArray(list2);
   }
   any() {
     return _List.any(this);
   }
   static any(list2) {
-    return Iterable.any(list2);
+    return MutableIndexable.any(list2);
   }
   getCount() {
     return _List.getCount(this);
   }
   static getCount(list2) {
-    return Iterable.getCount(list2);
+    return MutableIndexable.getCount(list2);
   }
   equals(right, equalFunctions) {
     return _List.equals(this, right, equalFunctions);
   }
   static equals(left, right, equalFunctions) {
-    return Iterable.equals(left, right, equalFunctions);
+    return MutableIndexable.equals(left, right, equalFunctions);
   }
   toString(toStringFunctions) {
     return _List.toString(this, toStringFunctions);
   }
   static toString(list2, toStringFunctions) {
-    return Iterable.toString(list2, toStringFunctions);
+    return MutableIndexable.toString(list2, toStringFunctions);
   }
   concatenate(...toConcatenate) {
     return _List.concatenate(this, ...toConcatenate);
   }
   static concatenate(list2, ...toConcatenate) {
-    return Iterable.concatenate(list2, ...toConcatenate);
+    return MutableIndexable.concatenate(list2, ...toConcatenate);
   }
   map(mapping) {
     return _List.map(this, mapping);
   }
   static map(list2, mapping) {
-    return Iterable.map(list2, mapping);
+    return MutableIndexable.map(list2, mapping);
   }
   flatMap(mapping) {
     return _List.flatMap(this, mapping);
   }
   static flatMap(list2, mapping) {
-    return Iterable.flatMap(list2, mapping);
+    return MutableIndexable.flatMap(list2, mapping);
   }
   where(condition) {
     return _List.where(this, condition);
   }
   static where(list2, condition) {
-    return Iterable.where(list2, condition);
+    return MutableIndexable.where(list2, condition);
   }
   instanceOf(typeOrTypeCheck) {
     return _List.instanceOf(this, typeOrTypeCheck);
   }
   static instanceOf(list2, typeOrTypeCheck) {
-    return Iterable.instanceOf(list2, typeOrTypeCheck);
+    return MutableIndexable.instanceOf(list2, typeOrTypeCheck);
   }
   first(condition) {
     return _List.first(this, condition);
   }
   static first(list2, condition) {
-    return condition ? Iterable.first(list2, condition) : list2.get(0);
+    return MutableIndexable.first(list2, condition);
   }
   last(condition) {
     return _List.last(this, condition);
   }
   static last(list2, condition) {
-    return condition ? Iterable.last(list2, condition) : list2.get(list2.getCount().await() - 1);
+    return MutableIndexable.last(list2, condition);
   }
   [Symbol.iterator]() {
     return _List[Symbol.iterator](this);
   }
   static [Symbol.iterator](list2) {
-    return Iterable[Symbol.iterator](list2);
+    return Indexable[Symbol.iterator](list2);
   }
   contains(value, equalFunctions) {
     return _List.contains(this, value, equalFunctions);
   }
   static contains(list2, value, equalFunctions) {
-    return Iterable.contains(list2, value, equalFunctions);
+    return MutableIndexable.contains(list2, value, equalFunctions);
   }
 };
 
@@ -3068,7 +3290,7 @@ var WhereIterable = class _WhereIterable {
 // sources/iterable.ts
 var Iterable = class _Iterable {
   static create(values) {
-    return List.create(values);
+    return Indexable.create(values);
   }
   [Symbol.iterator]() {
     return _Iterable[Symbol.iterator](this);
@@ -3555,7 +3777,7 @@ var MutableCondition = class _MutableCondition {
   }
   assertNotEmpty(value, expression, message) {
     this.assertNotUndefinedAndNotNull(value, expression, message);
-    if (isString(value) && value.length === 0 || isJavascriptIterable(value) && !Iterable.create(value).any()) {
+    if (isString(value) && value.length === 0 || isJavascriptIterable(value) && !Iterable.create(value).any().await()) {
       throw this.createError({
         expected: "not empty",
         actual: this.toValueString(value),
@@ -3921,395 +4143,142 @@ var PreCondition = class _PreCondition {
   }
 };
 
-// tests/test.ts
-var Test = class _Test {
-  /**
-   * Assert that the provided value is undefined;
-   * @param value The value to check.
-   */
-  assertUndefined(value) {
-    _Test.assertUndefined(this, value);
+// sources/ANSIStyles.ts
+var ANSIStyles = class {
+  constructor() {
   }
-  /**
-   * Assert that the provided value is undefined.
-   * @param test The current {@link Test}.
-   * @param value The value to check.
-   */
-  static assertUndefined(test2, value) {
-    test2.assertSame(value, void 0);
+  static color(colorCode, text) {
+    return `\x1B[${colorCode}m${text}\x1B[0m`;
   }
-  /**
-   * Assert that the provided value is not undefined;
-   * @param value The value to check.
-   */
-  assertNotUndefined(value) {
-    _Test.assertNotUndefined(this, value);
+  static black(text) {
+    return this.color(30, text);
   }
-  /**
-   * Assert that the provided value is not undefined.
-   * @param test The current {@link Test}.
-   * @param value The value to check.
-   */
-  static assertNotUndefined(test2, value) {
-    test2.assertNotSame(value, void 0);
+  static red(text) {
+    return this.color(31, text);
+  }
+  static green(text) {
+    return this.color(32, text);
+  }
+  static yellow(text) {
+    return this.color(33, text);
+  }
+  static blue(text) {
+    return this.color(34, text);
+  }
+};
+
+// sources/asyncResult.ts
+var AsyncResult = class {
+  static create(actionOrPromise) {
+    return PromiseAsyncResult.create(actionOrPromise);
   }
   /**
-   * Assert that the provided value is null.
-   * @param value The value to check.
+   * Get an {@link AsyncResult} that is already completed and doesn't do anything.
    */
-  assertNull(value) {
-    _Test.assertNull(this, value);
+  static empty() {
+    return PromiseAsyncResult.empty();
   }
   /**
-   * Assert that the provided value is null.
-   * @param value The value to check.
+   * Create a new {@link AsyncResult} that contains the provided value.
+   * @param value The value to wrap in a {@link AsyncResult}.
    */
-  static assertNull(test2, value) {
-    test2.assertSame(value, null);
+  static value(value) {
+    return PromiseAsyncResult.value(value);
   }
   /**
-   * Assert that the provided value is not null.
-   * @param value The value to check.
+   * Create a new {@link AsyncResult} that contains the provided error.
+   * @param error The error to wrap in a {@link AsyncResult}.
    */
-  assertNotNull(value) {
-    _Test.assertNull(this, value);
+  static error(error) {
+    return PromiseAsyncResult.error(error);
+  }
+  static yield() {
+    return PromiseAsyncResult.yield();
+  }
+};
+
+// sources/postConditionError.ts
+var PostConditionError = class extends Error {
+  constructor(...message) {
+    super(join("\n", message));
+  }
+};
+
+// sources/postCondition.ts
+var PostCondition = class _PostCondition {
+  static condition;
+  static getCondition() {
+    if (_PostCondition.condition === void 0) {
+      _PostCondition.condition = MutableCondition.create().setCreateErrorFunction((message) => {
+        return new PostConditionError(message);
+      });
+    }
+    return _PostCondition.condition;
   }
   /**
-   * Assert that the provided value is not null.
+   * Assert that the provided value is undefined.
    * @param value The value to check.
+   * @param expression The name of the expression that produced the value.
+   * @param message An additional message that will be included with the error.
    */
-  static assertNotNull(test2, value) {
-    test2.assertNotSame(value, null);
+  static assertUndefined(value, expression, message) {
+    return _PostCondition.getCondition().assertUndefined(value, expression, message);
   }
   /**
    * Assert that the provided value is not undefined and not null.
    * @param value The value to check.
+   * @param expression The name of the expression that produced the value.
+   * @param message An additional message that will be included with the error.
    */
-  assertNotUndefinedAndNotNull(value) {
-    _Test.assertNotUndefinedAndNotNull(this, value);
+  static assertNotUndefined(value, expression, message) {
+    return _PostCondition.getCondition().assertNotUndefined(value, expression, message);
   }
   /**
    * Assert that the provided value is not undefined and not null.
    * @param value The value to check.
+   * @param expression The name of the expression that produced the value.
+   * @param message An additional message that will be included with the error.
    */
-  static assertNotUndefinedAndNotNull(test2, value) {
-    test2.assertNotSame(value, null);
-    test2.assertNotSame(value, void 0);
+  static assertNotUndefinedAndNotNull(value, expression, message) {
+    return _PostCondition.getCondition().assertNotUndefinedAndNotNull(value, expression, message);
   }
   /**
-   * Assert that the provided value is false.
+   * Assert that the provided value is true.
    * @param value The value to check.
+   * @param expression The name of the expression that produced the value.
+   * @param message An additional message that will be included with the error.
    */
-  assertFalse(value) {
-    _Test.assertFalse(this, value);
+  static assertTrue(value, expression, message) {
+    return _PostCondition.getCondition().assertTrue(value, expression, message);
   }
   /**
    * Assert that the provided value is false.
    * @param value The value to check.
+   * @param expression The name of the expression that produced the value.
+   * @param message An additional message that will be included with the error.
    */
-  static assertFalse(test2, value) {
-    PreCondition.assertNotUndefinedAndNotNull(test2, "test");
-    test2.assertSame(value, false);
+  static assertFalse(value, expression, message) {
+    return _PostCondition.getCondition().assertFalse(value, expression, message);
   }
   /**
-   * Assert that the provided value is true.
-   * @param value The value to check.
+   * Assert that the provided actual value is the same as the provided expected value.
+   * @param expected The expected value.
+   * @param actual The actual value.
+   * @param expression The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
    */
-  assertTrue(value) {
-    _Test.assertTrue(this, value);
+  static assertSame(expected, actual, expression, message) {
+    return _PostCondition.getCondition().assertSame(expected, actual, expression, message);
   }
   /**
-   * Assert that the provided value is true.
-   * @param value The value to check.
+   * Assert that the provided actual value is not the same as the provided expected value.
+   * @param expected The expected value.
+   * @param actual The actual value.
+   * @param expression The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
    */
-  static assertTrue(test2, value) {
-    PreCondition.assertNotUndefinedAndNotNull(test2, "test");
-    test2.assertSame(value, true);
-  }
-  /**
-   * Assert that the provided value is an instance of the provided {@link Type}.
-   * @param value The value to check.
-   * @param type The {@link Type} to check.
-   * @param expression The expression that produced the value.
-   * @param message An optional error message.
-   */
-  assertInstanceOf(value, type, typeCheck) {
-    return _Test.assertInstanceOf(this, value, type, typeCheck);
-  }
-  /**
-   * Assert that the provided value is an instance of the provided {@link Type}.
-   * @param value The value to check.
-   * @param type The {@link Type} to check.
-   * @param expression The expression that produced the value.
-   * @param message An optional error message.
-   */
-  static assertInstanceOf(test2, value, type, typeCheck) {
-    PreCondition.assertNotUndefinedAndNotNull(type, "type");
-    if (isUndefinedOrNull(typeCheck)) {
-      typeCheck = ((value2) => value2 instanceof type);
-    }
-    if (!typeCheck(value)) {
-      test2.fail(`Expected value to be of type ${type.name} but found ${value} instead.`);
-    }
-  }
-};
-
-// tests/assertTest.ts
-var AssertTest = class _AssertTest {
-  name;
-  constructor(name) {
-    this.name = name;
-  }
-  /**
-   * Create a new {@link AssertTest} object.
-   */
-  static create(name) {
-    return new _AssertTest(name);
-  }
-  fail(message) {
-    PreCondition.assertNotEmpty(message, "message");
-    assert.fail(message);
-  }
-  assertUndefined(value) {
-    Test.assertUndefined(this, value);
-  }
-  assertNotUndefined(value) {
-    Test.assertNotUndefined(this, value);
-  }
-  assertNull(value) {
-    Test.assertNull(this, value);
-  }
-  assertNotNull(value) {
-    Test.assertNotNull(this, value);
-  }
-  assertNotUndefinedAndNotNull(value) {
-    Test.assertNotUndefinedAndNotNull(this, value);
-  }
-  assertSame(left, right) {
-    assert.strictEqual(left, right);
-  }
-  assertNotSame(left, right) {
-    assert.notStrictEqual(left, right);
-  }
-  assertEqual(left, right, message) {
-    assert.deepStrictEqual(left, right, message);
-  }
-  assertNotEqual(left, right) {
-    assert.notDeepStrictEqual(left, right);
-  }
-  assertFalse(value) {
-    Test.assertFalse(this, value);
-  }
-  assertTrue(value) {
-    Test.assertTrue(this, value);
-  }
-  assertThrows(action, expectedError) {
-    if (!isFunction(action)) {
-      const syncResult = action;
-      action = () => {
-        syncResult.await();
-      };
-    }
-    assert.throws(action, expectedError);
-  }
-  assertThrowsAsync(action, expectedError) {
-    const promiseOrAsyncAction = isFunction(action) ? async () => await action() : action;
-    return PromiseAsyncResult.create(assert.rejects(promiseOrAsyncAction, expectedError));
-  }
-  assertInstanceOf(value, type, typeCheck) {
-    Test.assertInstanceOf(this, value, type, typeCheck);
-  }
-};
-
-// tests/assertTestTests.ts
-var import_assert = require("assert");
-function test(runner) {
-  runner.testFile("assertTest.ts", () => {
-    runner.testType("AssertTest", () => {
-      runner.testFunction("assertThrows()", () => {
-        runner.test("with throwing action", (test2) => {
-          const at = AssertTest.create("fake-test-name");
-          at.assertThrows(() => {
-            throw new Error("abc");
-          }, new Error("abc"));
-        });
-        runner.test("with non-throwing action", (test2) => {
-          const at = AssertTest.create("fake-test-name");
-          test2.assertThrows(
-            () => at.assertThrows(() => {
-            }, new Error("oops")),
-            new import_assert.AssertionError({
-              message: "Missing expected exception (Error).",
-              operator: "throws",
-              expected: new Error("oops")
-            })
-          );
-        });
-      });
-      runner.testFunction("assertThrowsAsync()", () => {
-        runner.test("with throwing sync action", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
-          await at.assertThrowsAsync(() => {
-            throw new Error("abc");
-          }, new Error("abc"));
-        });
-        runner.test("with throwing async action", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
-          await at.assertThrowsAsync(async () => {
-            throw new Error("abc");
-          }, new Error("abc"));
-        });
-        runner.test("with rejected Promise", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
-          await at.assertThrowsAsync(Promise.reject(new Error("abc")), new Error("abc"));
-        });
-        runner.test("with throwing action that returns a rejected Promise", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
-          await at.assertThrowsAsync(() => Promise.reject(new Error("abc")), new Error("abc"));
-        });
-        runner.test("with non-throwing async action", async (test2) => {
-          const at = AssertTest.create("fake-test-name");
-          await test2.assertThrowsAsync(
-            async () => await at.assertThrowsAsync(async () => {
-            }, new Error("oops")),
-            new import_assert.AssertionError({
-              message: "Missing expected rejection (Error).",
-              operator: "rejects",
-              expected: new Error("oops")
-            })
-          );
-        });
-      });
-    });
-  });
-}
-
-// tests/basicTestSkip.ts
-var BasicTestSkip = class _BasicTestSkip {
-  shouldSkip;
-  message;
-  constructor(shouldSkip, message) {
-    PreCondition.assertNotUndefinedAndNotNull(message, "message");
-    this.shouldSkip = shouldSkip;
-    this.message = message;
-  }
-  /**
-   * Create a new {@link TestSkip} with the provided properties.
-   * @param shouldSkip Whether the tests associated with the new {@link TestSkip}
-   * should be skipped.
-   * @param message The message that explains why the tests associated with this {@link TestSkip}
-   * should be skipped.
-   */
-  static create(shouldSkip, message) {
-    if (shouldSkip === void 0 || shouldSkip === null) {
-      shouldSkip = true;
-    }
-    if (message === void 0 || message === null) {
-      message = "";
-    }
-    return new _BasicTestSkip(shouldSkip, message);
-  }
-  getShouldSkip() {
-    return this.shouldSkip;
-  }
-  getMessage() {
-    return this.message;
-  }
-};
-
-// sources/commandLineParameters.ts
-var CommandLineParameters = class _CommandLineParameters {
-  args;
-  constructor(argv) {
-    this.args = argv;
-  }
-  static create(args) {
-    return new _CommandLineParameters(args);
-  }
-};
-
-// sources/postConditionError.ts
-var PostConditionError = class extends Error {
-  constructor(...message) {
-    super(join("\n", message));
-  }
-};
-
-// sources/postCondition.ts
-var PostCondition = class _PostCondition {
-  static condition;
-  static getCondition() {
-    if (_PostCondition.condition === void 0) {
-      _PostCondition.condition = MutableCondition.create().setCreateErrorFunction((message) => {
-        return new PostConditionError(message);
-      });
-    }
-    return _PostCondition.condition;
-  }
-  /**
-   * Assert that the provided value is undefined.
-   * @param value The value to check.
-   * @param expression The name of the expression that produced the value.
-   * @param message An additional message that will be included with the error.
-   */
-  static assertUndefined(value, expression, message) {
-    return _PostCondition.getCondition().assertUndefined(value, expression, message);
-  }
-  /**
-   * Assert that the provided value is not undefined and not null.
-   * @param value The value to check.
-   * @param expression The name of the expression that produced the value.
-   * @param message An additional message that will be included with the error.
-   */
-  static assertNotUndefined(value, expression, message) {
-    return _PostCondition.getCondition().assertNotUndefined(value, expression, message);
-  }
-  /**
-   * Assert that the provided value is not undefined and not null.
-   * @param value The value to check.
-   * @param expression The name of the expression that produced the value.
-   * @param message An additional message that will be included with the error.
-   */
-  static assertNotUndefinedAndNotNull(value, expression, message) {
-    return _PostCondition.getCondition().assertNotUndefinedAndNotNull(value, expression, message);
-  }
-  /**
-   * Assert that the provided value is true.
-   * @param value The value to check.
-   * @param expression The name of the expression that produced the value.
-   * @param message An additional message that will be included with the error.
-   */
-  static assertTrue(value, expression, message) {
-    return _PostCondition.getCondition().assertTrue(value, expression, message);
-  }
-  /**
-   * Assert that the provided value is false.
-   * @param value The value to check.
-   * @param expression The name of the expression that produced the value.
-   * @param message An additional message that will be included with the error.
-   */
-  static assertFalse(value, expression, message) {
-    return _PostCondition.getCondition().assertFalse(value, expression, message);
-  }
-  /**
-   * Assert that the provided actual value is the same as the provided expected value.
-   * @param expected The expected value.
-   * @param actual The actual value.
-   * @param expression The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertSame(expected, actual, expression, message) {
-    return _PostCondition.getCondition().assertSame(expected, actual, expression, message);
-  }
-  /**
-   * Assert that the provided actual value is not the same as the provided expected value.
-   * @param expected The expected value.
-   * @param actual The actual value.
-   * @param expression The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertNotSame(expected, actual, expression, message) {
-    return _PostCondition.getCondition().assertNotSame(expected, actual, expression, message);
+  static assertNotSame(expected, actual, expression, message) {
+    return _PostCondition.getCondition().assertNotSame(expected, actual, expression, message);
   }
   /**
    * Assert that the provided actual value is equal to the provided expected value.
@@ -4465,17 +4434,280 @@ var CharacterWriteStream = class _CharacterWriteStream {
   writeLine(text) {
     return _CharacterWriteStream.writeLine(this, text);
   }
-  static writeLine(writeStream, text) {
-    PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
-    return PromiseAsyncResult.create(async () => {
-      let result = 0;
-      if (text) {
-        result += await writeStream.writeString(text);
-      }
-      result += await writeStream.writeString("\n");
-      PostCondition.assertGreaterThan(result, 0, "result");
-      return result;
-    });
+  static writeLine(writeStream, text) {
+    PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
+    return PromiseAsyncResult.create(async () => {
+      let result = 0;
+      if (text) {
+        result += await writeStream.writeString(text);
+      }
+      result += await writeStream.writeString("\n");
+      PostCondition.assertGreaterThan(result, 0, "result");
+      return result;
+    });
+  }
+};
+
+// sources/IndentedCharacterWriteStream.ts
+var IndentedCharacterWriteStream = class _IndentedCharacterWriteStream extends CharacterWriteStream {
+  innerStream;
+  currentIndentationList;
+  currentIndentation;
+  singleIndent;
+  atLineStart;
+  constructor(innerStream) {
+    PreCondition.assertNotUndefinedAndNotNull(innerStream, "innerStream");
+    super();
+    this.innerStream = innerStream;
+    this.currentIndentationList = List.create();
+    this.currentIndentation = "";
+    this.singleIndent = "  ";
+    this.atLineStart = true;
+  }
+  static create(innerStream) {
+    return new _IndentedCharacterWriteStream(innerStream);
+  }
+  getSingleIndent() {
+    return this.singleIndent;
+  }
+  setSingleIndent(singleIndent) {
+    PreCondition.assertNotUndefinedAndNotNull(singleIndent, "singleIndent");
+    this.singleIndent = singleIndent;
+    return this;
+  }
+  getCurrentIndentationCount() {
+    return this.currentIndentationList.getCount().await();
+  }
+  getCurrentIndentation() {
+    return this.currentIndentation;
+  }
+  addIndentation(singleIndent) {
+    if (isUndefinedOrNull(singleIndent)) {
+      singleIndent = this.singleIndent;
+    }
+    this.currentIndentationList.add(singleIndent);
+    if (singleIndent) {
+      this.currentIndentation = this.currentIndentation + singleIndent;
+    }
+    return this;
+  }
+  removeIndentation() {
+    PreCondition.assertGreaterThanOrEqualTo(this.getCurrentIndentationCount(), 1, "this.getCurrentIndentationCount()");
+    const result = this.currentIndentationList.removeLast().await();
+    if (result) {
+      this.currentIndentation = this.currentIndentation.substring(0, this.currentIndentation.length - result.length);
+    }
+    return result;
+  }
+  indent(actionOrSingleIndent, action) {
+    let singleIndent;
+    if (isString(actionOrSingleIndent)) {
+      singleIndent = actionOrSingleIndent;
+      action = action;
+    } else {
+      action = actionOrSingleIndent;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(action, "action");
+    return AsyncResult.create(async () => {
+      let result;
+      this.addIndentation(singleIndent);
+      try {
+        result = await action();
+        if (!isNumber(result)) {
+          result = 0;
+        }
+      } finally {
+        this.removeIndentation();
+      }
+      return result;
+    });
+  }
+  writeString(text) {
+    return AsyncResult.create(async () => {
+      let result = 0;
+      const textLength = text.length;
+      let startIndex = 0;
+      while (startIndex < textLength) {
+        const newLineCharacterIndex = text.indexOf("\n", startIndex);
+        const atLineStartAfterWrite = newLineCharacterIndex !== -1;
+        const nextLineStartIndex = atLineStartAfterWrite ? newLineCharacterIndex + 1 : textLength;
+        if (newLineCharacterIndex === startIndex || newLineCharacterIndex === startIndex + 1 && text[startIndex] === "\r") {
+          result += await this.innerStream.writeString(text.substring(startIndex, nextLineStartIndex));
+          startIndex = nextLineStartIndex;
+        } else {
+          if (this.atLineStart && this.currentIndentation) {
+            result += await this.innerStream.writeString(this.currentIndentation);
+          }
+          result += await this.innerStream.writeString(text.substring(startIndex, nextLineStartIndex));
+          startIndex = nextLineStartIndex;
+        }
+        this.atLineStart = atLineStartAfterWrite;
+      }
+      return result;
+    });
+  }
+};
+
+// sources/english.ts
+function andList(values) {
+  return list("and", values);
+}
+function orList(values) {
+  return list("or", values);
+}
+function list(conjunction, values) {
+  PreCondition.assertNotEmpty(conjunction, "conjunction");
+  PreCondition.assertNotUndefinedAndNotNull(values, "values");
+  let result = "";
+  let index = 0;
+  const iterator = Iterator.create(values).start().await();
+  while (iterator.hasCurrent()) {
+    const currentValue = iterator.takeCurrent().await();
+    if (index >= 1) {
+      if (iterator.hasCurrent()) {
+        result += `, `;
+      } else {
+        if (index >= 2) {
+          result += `,`;
+        }
+        result += ` ${conjunction} `;
+      }
+    }
+    result += currentValue;
+    index++;
+  }
+  return result;
+}
+
+// sources/commandLineParameters.ts
+var CommandLineParameters = class _CommandLineParameters {
+  args;
+  parameters;
+  constructor(argv) {
+    PreCondition.assertNotUndefinedAndNotNull(argv, "argv");
+    this.args = isIterable(argv) ? argv : Iterable.create(argv);
+    this.parameters = List.create();
+  }
+  static create(args) {
+    return new _CommandLineParameters(args);
+  }
+  static getArgumentName(arg) {
+    return arg[0] === "-" ? arg.substring(arg[1] === "-" ? 2 : 1) : void 0;
+  }
+  getArguments() {
+    return this.args;
+  }
+  /**
+   * Get the value of the first argument that matches one of the provided names. 
+   * @param names The possible names to look for.
+   */
+  getNamedArgumentStringValue(nameOrNames) {
+    PreCondition.assertNotEmpty(nameOrNames, "nameOrNames");
+    return SyncResult.create(() => {
+      let foundArgName = false;
+      let result;
+      if (isString(nameOrNames)) {
+        nameOrNames = [nameOrNames];
+      }
+      const searchNames = Iterable.create(nameOrNames);
+      for (const arg of this.args) {
+        if (!foundArgName) {
+          const argName = _CommandLineParameters.getArgumentName(arg);
+          foundArgName = !!(argName && searchNames.contains(argName));
+        } else {
+          result = arg;
+          break;
+        }
+      }
+      if (result === void 0) {
+        const toStringFunctions = ToStringFunctions.create();
+        throw new NotFoundError(`No argument found that matches ${orList(searchNames.map((n) => toStringFunctions.toString(n)))}.`);
+      }
+      return result;
+    });
+  }
+  nameOrAliasExists(nameOrAlias) {
+    PreCondition.assertNotEmpty(nameOrAlias, "nameOrAlias");
+    let result = false;
+    for (const parameter of this.parameters) {
+      if (parameter.getNameAndAliases().contains(nameOrAlias).await()) {
+        result = true;
+        break;
+      }
+    }
+    return result;
+  }
+  add(name) {
+    const result = CommandLineParameter.create({
+      owner: this,
+      name
+    });
+    this.parameters.add(result);
+    return result;
+  }
+};
+
+// sources/commandLineParameter.ts
+var CommandLineParameter = class _CommandLineParameter {
+  owner;
+  name;
+  aliases;
+  description;
+  constructor(owner, name) {
+    PreCondition.assertNotUndefinedAndNotNull(owner, "owner");
+    PreCondition.assertNotEmpty(name, "name");
+    PreCondition.assertFalse(owner.nameOrAliasExists(name), "owner.nameOrAliasExists(name)");
+    this.owner = owner;
+    this.name = name;
+  }
+  static create(ownerOrProperties, name) {
+    let owner;
+    if (ownerOrProperties instanceof CommandLineParameters) {
+      owner = ownerOrProperties;
+      name = name;
+    } else {
+      owner = ownerOrProperties.owner;
+      name = ownerOrProperties.name;
+    }
+    return new _CommandLineParameter(owner, name);
+  }
+  /**
+   * Get the name of this {@link CommandLineParameter}.
+   */
+  getName() {
+    return this.name;
+  }
+  getAliases() {
+    return this.aliases ?? Iterable.create();
+  }
+  nameOrAliasExists(nameOrAlias) {
+    return this.owner.nameOrAliasExists(nameOrAlias);
+  }
+  addAlias(alias) {
+    PreCondition.assertNotEmpty(alias, "alias");
+    PreCondition.assertFalse(this.nameOrAliasExists(alias), "this.nameOrAliasExists(alias)");
+    if (this.aliases === void 0) {
+      this.aliases = List.create();
+    }
+    this.aliases.add(alias);
+    return this;
+  }
+  addAliases(aliases) {
+    for (const alias of aliases) {
+      this.addAlias(alias);
+    }
+    return this;
+  }
+  getNameAndAliases() {
+    return List.create().add(this.getName()).addAll(this.getAliases());
+  }
+  getDescription() {
+    return this.description ?? "";
+  }
+  setDescription(description) {
+    PreCondition.assertNotUndefinedAndNotNull(description, "description");
+    this.description = description;
+    return this;
   }
 };
 
@@ -4586,747 +4818,1112 @@ var MutableHttpHeaders = class _MutableHttpHeaders {
   iterate() {
     return this.headers.iterate();
   }
-  get(headerName) {
+  get(headerName) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    return SyncResult.create(() => {
+      let result;
+      const lowerHeaderName = headerName.toLowerCase();
+      for (const header of this.headers) {
+        if (header.getName().toLowerCase() === lowerHeaderName) {
+          result = header;
+          break;
+        }
+      }
+      if (result === void 0) {
+        throw new NotFoundError(`No HttpHeader found with the name ${escapeAndQuote(headerName)}.`);
+      }
+      return result;
+    });
+  }
+  getValue(headerName) {
+    return this.get(headerName).then((header) => header.getValue());
+  }
+  set(headerOrHeaderName, headerValue) {
+    let headerName;
+    if (isString(headerOrHeaderName)) {
+      headerName = headerOrHeaderName;
+    } else {
+      headerName = headerOrHeaderName.getName();
+      headerValue = headerOrHeaderName.getValue();
+    }
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
+    let insertIndex = 0;
+    for (let insertIndex2 = 0; insertIndex2 < this.headers.getCount().await(); insertIndex2++) {
+      const header = this.headers.get(insertIndex2).await();
+      if (header.getName() === headerName) {
+        this.headers.removeAt(insertIndex2);
+        break;
+      }
+    }
+    this.headers.insert(insertIndex, HttpHeader.create(headerName, headerValue));
+    return this;
+  }
+  setAll(headers) {
+    PreCondition.assertNotUndefinedAndNotNull(headers, "headers");
+    for (const header of headers) {
+      this.set(header);
+    }
+    return this;
+  }
+  setContentType(contentType) {
+    return this.set(HttpHeaders.contentTypeHeaderName, contentType);
+  }
+  getContentType() {
+    return this.get(HttpHeaders.contentTypeHeaderName);
+  }
+  getContentTypeValue() {
+    return this.getValue(HttpHeaders.contentTypeHeaderName);
+  }
+  getCount() {
+    return this.headers.getCount();
+  }
+  toArray() {
+    return HttpHeaders.toArray(this);
+  }
+  any() {
+    return HttpHeaders.any(this);
+  }
+  equals(right, equalFunctions) {
+    return HttpHeaders.equals(this, right, equalFunctions);
+  }
+  toString(toStringFunctions) {
+    return HttpHeaders.toString(this, toStringFunctions);
+  }
+  concatenate(...toConcatenate) {
+    return HttpHeaders.concatenate(this, ...toConcatenate);
+  }
+  map(mapping) {
+    return HttpHeaders.map(this, mapping);
+  }
+  flatMap(mapping) {
+    return HttpHeaders.flatMap(this, mapping);
+  }
+  where(condition) {
+    return HttpHeaders.where(this, condition);
+  }
+  instanceOf(typeOrTypeCheck) {
+    return HttpHeaders.instanceOf(this, typeOrTypeCheck);
+  }
+  first(condition) {
+    return HttpHeaders.first(this, condition);
+  }
+  last(condition) {
+    return HttpHeaders.last(this, condition);
+  }
+  [Symbol.iterator]() {
+    return HttpHeaders[Symbol.iterator](this);
+  }
+  contains(value, equalFunctions) {
+    return HttpHeaders.contains(this, value, equalFunctions);
+  }
+};
+
+// sources/httpHeaders.ts
+var HttpHeaders = class _HttpHeaders {
+  static contentTypeHeaderName = "Content-Type";
+  static create(headers) {
+    return MutableHttpHeaders.create(headers);
+  }
+  getContentType() {
+    return _HttpHeaders.getContentType(this);
+  }
+  static getContentType(headers) {
+    return headers.get(_HttpHeaders.contentTypeHeaderName);
+  }
+  getContentTypeValue() {
+    return _HttpHeaders.getContentTypeValue(this);
+  }
+  static getContentTypeValue(headers) {
+    return headers.getValue(_HttpHeaders.contentTypeHeaderName);
+  }
+  /**
+   * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
+   */
+  toArray() {
+    return _HttpHeaders.toArray(this);
+  }
+  static toArray(headers) {
+    return Iterable.toArray(headers);
+  }
+  any() {
+    return _HttpHeaders.any(this);
+  }
+  static any(headers) {
+    return Iterable.any(headers);
+  }
+  getCount() {
+    return _HttpHeaders.getCount(this);
+  }
+  static getCount(headers) {
+    return Iterable.getCount(headers);
+  }
+  equals(right, equalFunctions) {
+    return _HttpHeaders.equals(this, right, equalFunctions);
+  }
+  static equals(headers, right, equalFunctions) {
+    return Iterable.equals(headers, right, equalFunctions);
+  }
+  toString(toStringFunctions) {
+    return _HttpHeaders.toString(this, toStringFunctions);
+  }
+  static toString(headers, toStringFunctions) {
+    return Iterable.toString(headers, toStringFunctions);
+  }
+  concatenate(...toConcatenate) {
+    return _HttpHeaders.concatenate(this, ...toConcatenate);
+  }
+  static concatenate(headers, ...toConcatenate) {
+    return Iterable.concatenate(headers, ...toConcatenate);
+  }
+  map(mapping) {
+    return _HttpHeaders.map(this, mapping);
+  }
+  static map(headers, mapping) {
+    return Iterable.map(headers, mapping);
+  }
+  flatMap(mapping) {
+    return _HttpHeaders.flatMap(this, mapping);
+  }
+  static flatMap(headers, mapping) {
+    return Iterable.flatMap(headers, mapping);
+  }
+  where(condition) {
+    return _HttpHeaders.where(this, condition);
+  }
+  static where(headers, condition) {
+    return Iterable.where(headers, condition);
+  }
+  instanceOf(typeOrTypeCheck) {
+    return _HttpHeaders.instanceOf(this, typeOrTypeCheck);
+  }
+  static instanceOf(headers, typeOrTypeCheck) {
+    return Iterable.instanceOf(headers, typeOrTypeCheck);
+  }
+  first(condition) {
+    return _HttpHeaders.first(this, condition);
+  }
+  static first(headers, condition) {
+    return Iterable.first(headers, condition);
+  }
+  last(condition) {
+    return _HttpHeaders.last(this, condition);
+  }
+  static last(headers, condition) {
+    return Iterable.last(headers, condition);
+  }
+  [Symbol.iterator]() {
+    return _HttpHeaders[Symbol.iterator](this);
+  }
+  static [Symbol.iterator](headers) {
+    return Iterable[Symbol.iterator](headers);
+  }
+  contains(value, equalFunctions) {
+    return _HttpHeaders.contains(this, value, equalFunctions);
+  }
+  static contains(headers, value, equalFunctions) {
+    return SyncResult.create(() => {
+      if (!equalFunctions) {
+        equalFunctions = EqualFunctions.create();
+      }
+      return headers.getValue(value.getName()).then((headerValue) => equalFunctions.areEqual(headerValue, value.getValue()).await()).catch(NotFoundError, () => false).await();
+    });
+  }
+};
+
+// sources/httpIncomingResponse.ts
+var HttpIncomingResponse = class {
+};
+
+// sources/fetchHttpResponse.ts
+var FetchHttpIncomingResponse = class _FetchHttpIncomingResponse extends HttpIncomingResponse {
+  response;
+  constructor(response) {
+    PreCondition.assertNotUndefinedAndNotNull(response, "response");
+    super();
+    this.response = response;
+  }
+  static create(response) {
+    return new _FetchHttpIncomingResponse(response);
+  }
+  getStatusCode() {
+    return this.response.status;
+  }
+  getHeaders() {
+    return SyncResult.create(() => {
+      const result = HttpHeaders.create();
+      for (const header of this.response.headers) {
+        result.set(header[0], header[1]);
+      }
+      return result;
+    });
+  }
+  getHeader(headerName) {
     PreCondition.assertNotEmpty(headerName, "headerName");
     return SyncResult.create(() => {
       let result;
       const lowerHeaderName = headerName.toLowerCase();
-      for (const header of this.headers) {
-        if (header.getName().toLowerCase() === lowerHeaderName) {
-          result = header;
+      for (const header of this.response.headers) {
+        if (lowerHeaderName === header[0].toLowerCase()) {
+          result = HttpHeader.create(header[0], header[1]);
           break;
         }
       }
       if (result === void 0) {
-        throw new NotFoundError(`No HttpHeader found with the name ${escapeAndQuote(headerName)}.`);
+        throw new NotFoundError(`Could not find a header with the name ${escapeAndQuote(headerName)}.`);
       }
       return result;
     });
   }
-  getValue(headerName) {
-    return this.get(headerName).then((header) => header.getValue());
-  }
-  set(headerOrHeaderName, headerValue) {
-    let headerName;
-    if (isString(headerOrHeaderName)) {
-      headerName = headerOrHeaderName;
-    } else {
-      headerName = headerOrHeaderName.getName();
-      headerValue = headerOrHeaderName.getValue();
-    }
+  getHeaderValue(headerName) {
     PreCondition.assertNotEmpty(headerName, "headerName");
-    PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
-    let insertIndex = 0;
-    for (let insertIndex2 = 0; insertIndex2 < this.headers.getCount().await(); insertIndex2++) {
-      const header = this.headers.get(insertIndex2).await();
-      if (header.getName() === headerName) {
-        this.headers.removeAt(insertIndex2);
-        break;
+    return SyncResult.create(() => {
+      let result;
+      const lowerHeaderName = headerName.toLowerCase();
+      for (const header of this.response.headers) {
+        if (lowerHeaderName === header[0].toLowerCase()) {
+          result = header[1];
+          break;
+        }
       }
-    }
-    this.headers.insert(insertIndex, HttpHeader.create(headerName, headerValue));
-    return this;
+      if (result === void 0) {
+        throw new NotFoundError(`Could not find a header with the name ${escapeAndQuote(headerName)}.`);
+      }
+      return result;
+    });
   }
-  setAll(headers) {
-    PreCondition.assertNotUndefinedAndNotNull(headers, "headers");
-    for (const header of headers) {
-      this.set(header);
-    }
-    return this;
+  getBody() {
+    return PromiseAsyncResult.create(this.response.text());
   }
-  setContentType(contentType) {
-    return this.set(HttpHeaders.contentTypeHeaderName, contentType);
+};
+
+// sources/httpOutgoingRequest.ts
+var HttpOutgoingRequest = class _HttpOutgoingRequest {
+  method;
+  url;
+  headers;
+  body;
+  constructor(method, url) {
+    PreCondition.assertNotUndefinedAndNotNull(method, "method");
+    PreCondition.assertNotEmpty(url, "url");
+    this.method = method;
+    this.url = url;
+    this.headers = HttpHeaders.create();
+    this.body = "";
   }
-  getContentType() {
-    return this.get(HttpHeaders.contentTypeHeaderName);
+  static create(method, url) {
+    return new _HttpOutgoingRequest(method, url);
   }
-  getContentTypeValue() {
-    return this.getValue(HttpHeaders.contentTypeHeaderName);
+  /**
+   * Create a new {@link HttpOutgoingRequest} with a GET {@link HttpMethod}.
+   * @param url The target URL for the {@link HttpOutgoingRequest}.
+   */
+  static get(url) {
+    return _HttpOutgoingRequest.create(0 /* GET */, url);
   }
-  getCount() {
-    return this.headers.getCount();
+  /**
+   * Get the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+   */
+  getMethod() {
+    return this.method;
   }
-  toArray() {
-    return HttpHeaders.toArray(this);
+  /**
+   * Set the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+   * @param method The {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+   */
+  setMethod(method) {
+    PreCondition.assertNotUndefinedAndNotNull(method, "method");
+    this.method = method;
+    return this;
   }
-  any() {
-    return HttpHeaders.any(this);
+  /**
+   * Get this {@link HttpOutgoingRequest}'s target URL.
+   */
+  getURL() {
+    return this.url;
   }
-  equals(right, equalFunctions) {
-    return HttpHeaders.equals(this, right, equalFunctions);
+  /**
+   * Set the URL that this request will be sent to.
+   * @param url The URL to send this request to.
+   */
+  setURL(url) {
+    PreCondition.assertNotEmpty(url, "url");
+    this.url = url;
+    return this;
   }
-  toString(toStringFunctions) {
-    return HttpHeaders.toString(this, toStringFunctions);
+  /**
+   * Get the {@link HttpHeaders} that will be sent.
+   */
+  getHeaders() {
+    return this.headers;
   }
-  concatenate(...toConcatenate) {
-    return HttpHeaders.concatenate(this, ...toConcatenate);
+  getHeader(headerName) {
+    return this.headers.get(headerName);
   }
-  map(mapping) {
-    return HttpHeaders.map(this, mapping);
+  getHeaderValue(headerName) {
+    return this.headers.getValue(headerName);
   }
-  flatMap(mapping) {
-    return HttpHeaders.flatMap(this, mapping);
+  /**
+   * Get the body that will be sent.
+   */
+  getBody() {
+    return this.body;
   }
-  where(condition) {
-    return HttpHeaders.where(this, condition);
+  setBody(body) {
+    PreCondition.assertNotUndefinedAndNotNull(body, "body");
+    this.body = body;
+    return this;
   }
-  instanceOf(typeOrTypeCheck) {
-    return HttpHeaders.instanceOf(this, typeOrTypeCheck);
+};
+
+// sources/fetchHttpClient.ts
+var FetchHttpClient = class _FetchHttpClient {
+  constructor() {
   }
-  first(condition) {
-    return HttpHeaders.first(this, condition);
+  static create() {
+    return new _FetchHttpClient();
   }
-  last(condition) {
-    return HttpHeaders.last(this, condition);
+  sendRequest(request) {
+    PreCondition.assertNotUndefinedAndNotNull(request, "request");
+    return PromiseAsyncResult.create(async () => {
+      const requestInit = {
+        method: _FetchHttpClient.convertMethod(request.getMethod()),
+        headers: request.getHeaders().map((header) => [header.getName(), header.getValue()]).toArray().await(),
+        body: request.getBody() || void 0
+      };
+      const fetchResponse = await fetch(request.getURL(), requestInit);
+      return FetchHttpIncomingResponse.create(fetchResponse);
+    });
   }
-  [Symbol.iterator]() {
-    return HttpHeaders[Symbol.iterator](this);
+  sendGetRequest(url) {
+    return this.sendRequest(HttpOutgoingRequest.create(0 /* GET */, url));
   }
-  contains(value, equalFunctions) {
-    return HttpHeaders.contains(this, value, equalFunctions);
+  static convertMethod(method) {
+    PreCondition.assertNotUndefinedAndNotNull(method, "method");
+    let result;
+    switch (method) {
+      case 5 /* CONNECT */:
+        result = "CONNECT";
+        break;
+      case 4 /* DELETE */:
+        result = "DELETE";
+        break;
+      case 0 /* GET */:
+        result = "GET";
+        break;
+      case 1 /* HEAD */:
+        result = "HEAD";
+        break;
+      case 6 /* OPTIONS */:
+        result = "OPTIONS";
+        break;
+      case 8 /* PATCH */:
+        result = "PATCH";
+        break;
+      case 2 /* POST */:
+        result = "POST";
+        break;
+      case 3 /* PUT */:
+        result = "PUT";
+        break;
+      case 7 /* TRACE */:
+        result = "TRACE";
+        break;
+    }
+    PostCondition.assertNotEmpty(result, "result");
+    return result;
   }
 };
 
-// sources/httpHeaders.ts
-var HttpHeaders = class _HttpHeaders {
-  static contentTypeHeaderName = "Content-Type";
-  static create(headers) {
-    return MutableHttpHeaders.create(headers);
+// sources/network.ts
+var Network = class {
+};
+
+// sources/nodeJSHttpServer.ts
+var http = __toESM(require("http"), 1);
+
+// sources/httpServer.ts
+var HttpServer = class {
+};
+
+// sources/httpOutgoingResponse.ts
+var HttpOutgoingResponse = class _HttpOutgoingResponse {
+  statusCode;
+  headers;
+  body;
+  constructor() {
+    this.statusCode = 200;
+    this.headers = MutableHttpHeaders.create();
+    this.body = "";
+  }
+  static create() {
+    return new _HttpOutgoingResponse();
+  }
+  /**
+   * Get the status code of this {@link HttpOutgoingResponse}.
+   */
+  getStatusCode() {
+    return this.statusCode;
+  }
+  /**
+   * Set the status code of this {@link HttpOutgoingResponse}.
+   * @param statusCode The status code of this {@link HttpOutgoingResponse}.
+   */
+  setStatusCode(statusCode) {
+    PreCondition.assertBetween(100, statusCode, 599, "statusCode");
+    this.statusCode = statusCode;
+    return this;
   }
-  getContentType() {
-    return _HttpHeaders.getContentType(this);
+  getHeaders() {
+    return this.headers;
   }
-  static getContentType(headers) {
-    return headers.get(_HttpHeaders.contentTypeHeaderName);
+  /**
+   * Get the HTTP header with the provided name or return a {@link NotFoundError} if the header
+   * doesn't exist.
+   * @param headerName The name of the header to get.
+   */
+  getHeader(headerName) {
+    return this.headers.get(headerName);
   }
-  getContentTypeValue() {
-    return _HttpHeaders.getContentTypeValue(this);
+  /**
+   * Get the value of the header with the provided name or return a {@link NotFoundError} if the
+   * header doesn't exist.
+   * @param headerName The name of the header value to get.
+   */
+  getHeaderValue(headerName) {
+    return this.headers.getValue(headerName);
   }
-  static getContentTypeValue(headers) {
-    return headers.getValue(_HttpHeaders.contentTypeHeaderName);
+  /**
+   * Set the HTTP header in this {@link HttpOutgoingResponse}.
+   * @param headerName The name of the HTTP header.
+   * @param headerValue The value of the HTTP header.
+   */
+  setHeader(headerName, headerValue) {
+    this.headers.set(headerName, headerValue);
+    return this;
+  }
+  setContentTypeHeader(contentType) {
+    this.headers.setContentType(contentType);
+    return this;
   }
   /**
-   * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
+   * Get the body of this {@link HttpOutgoingResponse}.
    */
-  toArray() {
-    return _HttpHeaders.toArray(this);
+  getBody() {
+    return this.body;
   }
-  static toArray(headers) {
-    return Iterable.toArray(headers);
+  /**
+   * Set the body of this {@link HttpOutgoingResponse}.
+   * @param body The body for this {@link HttpOutgoingResponse}.
+   */
+  setBody(body) {
+    PreCondition.assertNotUndefinedAndNotNull(body, "body");
+    this.body = body;
+    return this;
   }
-  any() {
-    return _HttpHeaders.any(this);
+};
+
+// sources/nodeJSHttpServer.ts
+var NodeJSHttpServer = class _NodeJSHttpServer extends HttpServer {
+  httpServer;
+  disposed;
+  constructor() {
+    super();
+    this.disposed = false;
   }
-  static any(headers) {
-    return Iterable.any(headers);
+  static create() {
+    return new _NodeJSHttpServer();
   }
-  getCount() {
-    return _HttpHeaders.getCount(this);
+  dispose() {
+    return PromiseAsyncResult.create(new Promise((resolve, reject) => {
+      if (this.disposed) {
+        resolve(false);
+      } else if (!this.httpServer) {
+        this.disposed = true;
+        resolve(true);
+      } else {
+        this.httpServer.close((error) => {
+          if (error) {
+            reject(error);
+          } else {
+            this.disposed = true;
+            this.httpServer = void 0;
+            resolve(true);
+          }
+        });
+      }
+    }));
   }
-  static getCount(headers) {
-    return Iterable.getCount(headers);
+  isDisposed() {
+    return this.disposed;
   }
-  equals(right, equalFunctions) {
-    return _HttpHeaders.equals(this, right, equalFunctions);
+  isStarted() {
+    return !!this.httpServer;
   }
-  static equals(headers, right, equalFunctions) {
-    return Iterable.equals(headers, right, equalFunctions);
+  addRequestHandler(requestPath, handler) {
+    throw new Error("Method not implemented.");
   }
-  toString(toStringFunctions) {
-    return _HttpHeaders.toString(this, toStringFunctions);
+  setDefaultRequestHandler(handler) {
+    throw new Error("Method not implemented.");
   }
-  static toString(headers, toStringFunctions) {
-    return Iterable.toString(headers, toStringFunctions);
+  start(portNumber) {
+    PreCondition.assertGreaterThanOrEqualTo(portNumber, 1, "portNumber");
+    PreCondition.assertFalse(this.isDisposed(), "this.isDisposed()");
+    PreCondition.assertUndefined(this.httpServer, "this.httpServer");
+    return PromiseAsyncResult.create(new Promise((resolve, reject) => {
+      if (this.httpServer) {
+        reject(new Error("Can't run a HttpServer multiple times."));
+      } else {
+        this.httpServer = http.createServer();
+        this.httpServer.on("request", (request, response) => {
+          const httpResponse = HttpOutgoingResponse.create().setStatusCode(200).setHeader("Content-Type", "text/plain").setBody("Hello world!");
+          const statusCode = httpResponse.getStatusCode();
+          const headers = httpResponse.getHeaders();
+          const responseHeaders = {};
+          for (const header of headers) {
+            responseHeaders[header.getName()] = header.getValue();
+          }
+          response.writeHead(statusCode, responseHeaders);
+          response.end(httpResponse.getBody());
+        });
+        this.httpServer.on("close", () => {
+          resolve();
+        });
+        this.httpServer.on("error", (error) => {
+          reject(error);
+        });
+        this.httpServer.listen(portNumber);
+      }
+    }));
   }
-  concatenate(...toConcatenate) {
-    return _HttpHeaders.concatenate(this, ...toConcatenate);
+};
+
+// sources/realNetwork.ts
+var RealNetwork = class _RealNetwork extends Network {
+  constructor() {
+    super();
   }
-  static concatenate(headers, ...toConcatenate) {
-    return Iterable.concatenate(headers, ...toConcatenate);
+  static create() {
+    return new _RealNetwork();
   }
-  map(mapping) {
-    return _HttpHeaders.map(this, mapping);
+  createHttpServer() {
+    return NodeJSHttpServer.create();
   }
-  static map(headers, mapping) {
-    return Iterable.map(headers, mapping);
+  createHttpClient() {
+    return FetchHttpClient.create();
   }
-  flatMap(mapping) {
-    return _HttpHeaders.flatMap(this, mapping);
+};
+
+// sources/currentProcess.ts
+var CurrentProcess = class _CurrentProcess {
+  args;
+  parameters;
+  outputWriteStream;
+  exitCodeProperty;
+  network;
+  constructor() {
   }
-  static flatMap(headers, mapping) {
-    return Iterable.flatMap(headers, mapping);
+  static create() {
+    return new _CurrentProcess();
   }
-  where(condition) {
-    return _HttpHeaders.where(this, condition);
+  static async run(action) {
+    PreCondition.assertNotUndefinedAndNotNull(action, "action");
+    const currentProcess = _CurrentProcess.create();
+    try {
+      const result = await action(currentProcess);
+      if (isNumber(result)) {
+        currentProcess.setExitCode(result);
+      }
+    } catch (error) {
+      currentProcess.setExitCode(-1);
+      const writeStream = currentProcess.getOutputWriteStream();
+      if (error instanceof Error && error.stack) {
+        writeStream.writeLine(error.stack);
+      } else {
+        writeStream.writeLine(`${error}`);
+      }
+    }
   }
-  static where(headers, condition) {
-    return Iterable.where(headers, condition);
+  getArguments() {
+    if (!this.args) {
+      this.args = Iterable.create(process.argv);
+    }
+    return this.args;
   }
-  instanceOf(typeOrTypeCheck) {
-    return _HttpHeaders.instanceOf(this, typeOrTypeCheck);
+  setArguments(args) {
+    PreCondition.assertNotUndefinedAndNotNull(args, "args");
+    PreCondition.assertUndefined(this.parameters, "this.parameters");
+    this.args = isIterable(args) ? args : Iterable.create(args);
+    return this;
   }
-  static instanceOf(headers, typeOrTypeCheck) {
-    return Iterable.instanceOf(headers, typeOrTypeCheck);
+  getParameters() {
+    if (!this.parameters) {
+      this.parameters = CommandLineParameters.create(this.getArguments());
+    }
+    return this.parameters;
   }
-  first(condition) {
-    return _HttpHeaders.first(this, condition);
+  getOutputWriteStream() {
+    if (!this.outputWriteStream) {
+      this.outputWriteStream = NodeJSCharacterWriteStream.create(process.stdout);
+    }
+    return this.outputWriteStream;
   }
-  static first(headers, condition) {
-    return Iterable.first(headers, condition);
+  setOutputWriteStream(outputWriteStream) {
+    PreCondition.assertNotUndefinedAndNotNull(outputWriteStream, "outputWriteStream");
+    this.outputWriteStream = outputWriteStream;
+    return this;
   }
-  last(condition) {
-    return _HttpHeaders.last(this, condition);
+  getExitCode() {
+    return this.getExitCodeProperty().getValue();
   }
-  static last(headers, condition) {
-    return Iterable.last(headers, condition);
+  setExitCode(exitCode) {
+    PreCondition.assertNotUndefinedAndNotNull(exitCode, "exitCode");
+    this.getExitCodeProperty().setValue(exitCode);
+    return this;
   }
-  [Symbol.iterator]() {
-    return _HttpHeaders[Symbol.iterator](this);
+  getExitCodeProperty() {
+    if (!this.exitCodeProperty) {
+      this.exitCodeProperty = Property.create({
+        getter: () => process.exitCode,
+        setter: (value) => {
+          process.exitCode = value;
+        }
+      });
+    }
+    return this.exitCodeProperty;
   }
-  static [Symbol.iterator](headers) {
-    return Iterable[Symbol.iterator](headers);
+  setExitCodeProperty(exitCodeProperty) {
+    PreCondition.assertNotUndefinedAndNotNull(exitCodeProperty, "exitCodeProperty");
+    this.exitCodeProperty = exitCodeProperty;
+    return this;
   }
-  contains(value, equalFunctions) {
-    return _HttpHeaders.contains(this, value, equalFunctions);
+  getNetwork() {
+    if (!this.network) {
+      this.network = RealNetwork.create();
+    }
+    return this.network;
   }
-  static contains(headers, value, equalFunctions) {
-    return SyncResult.create(() => {
-      if (!equalFunctions) {
-        equalFunctions = EqualFunctions.create();
-      }
-      return headers.getValue(value.getName()).then((headerValue) => equalFunctions.areEqual(headerValue, value.getValue()).await()).catch(NotFoundError, () => false).await();
-    });
+  setNetwork(network) {
+    PreCondition.assertUndefined(this.network, "this.network");
+    PreCondition.assertNotUndefinedAndNotNull(network, "network");
+    this.network = network;
+    return this;
   }
 };
 
-// sources/httpIncomingResponse.ts
-var HttpIncomingResponse = class {
-};
+// sources/luxonDateTime.ts
+var luxon = __toESM(require("luxon"), 1);
 
-// sources/fetchHttpResponse.ts
-var FetchHttpIncomingResponse = class _FetchHttpIncomingResponse extends HttpIncomingResponse {
-  response;
-  constructor(response) {
-    PreCondition.assertNotUndefinedAndNotNull(response, "response");
-    super();
-    this.response = response;
+// sources/listStack.ts
+var ListStack = class _ListStack {
+  list;
+  constructor(list2) {
+    this.list = list2 ?? List.create();
   }
-  static create(response) {
-    return new _FetchHttpIncomingResponse(response);
+  static create(list2) {
+    return new _ListStack(list2);
   }
-  getStatusCode() {
-    return this.response.status;
+  any() {
+    return this.list.any();
   }
-  getHeaders() {
+  getCount() {
+    return this.list.getCount();
+  }
+  add(value) {
     return SyncResult.create(() => {
-      const result = HttpHeaders.create();
-      for (const header of this.response.headers) {
-        result.set(header[0], header[1]);
-      }
-      return result;
+      this.list.add(value);
     });
   }
-  getHeader(headerName) {
-    PreCondition.assertNotEmpty(headerName, "headerName");
+  addAll(values) {
+    PreCondition.assertNotUndefinedAndNotNull(values, "values");
     return SyncResult.create(() => {
-      let result;
-      const lowerHeaderName = headerName.toLowerCase();
-      for (const header of this.response.headers) {
-        if (lowerHeaderName === header[0].toLowerCase()) {
-          result = HttpHeader.create(header[0], header[1]);
-          break;
-        }
-      }
-      if (result === void 0) {
-        throw new NotFoundError(`Could not find a header with the name ${escapeAndQuote(headerName)}.`);
-      }
-      return result;
+      this.list.addAll(values);
     });
   }
-  getHeaderValue(headerName) {
-    PreCondition.assertNotEmpty(headerName, "headerName");
+  remove() {
     return SyncResult.create(() => {
-      let result;
-      const lowerHeaderName = headerName.toLowerCase();
-      for (const header of this.response.headers) {
-        if (lowerHeaderName === header[0].toLowerCase()) {
-          result = header[1];
-          break;
-        }
-      }
-      if (result === void 0) {
-        throw new NotFoundError(`Could not find a header with the name ${escapeAndQuote(headerName)}.`);
+      if (!this.any().await()) {
+        throw new EmptyError();
       }
-      return result;
+      return this.list.removeLast().await();
     });
   }
-  getBody() {
-    return PromiseAsyncResult.create(this.response.text());
+  contains(value, equalFunctions) {
+    return this.list.contains(value, equalFunctions);
   }
 };
 
-// sources/httpOutgoingRequest.ts
-var HttpOutgoingRequest = class _HttpOutgoingRequest {
-  method;
-  url;
-  headers;
-  body;
-  constructor(method, url) {
-    PreCondition.assertNotUndefinedAndNotNull(method, "method");
-    PreCondition.assertNotEmpty(url, "url");
-    this.method = method;
-    this.url = url;
-    this.headers = HttpHeaders.create();
-    this.body = "";
+// sources/stack.ts
+var Stack = class {
+  /**
+   * Create an instance of the default {@link Stack} implementation.
+   * @returns A new {@link Stack} object.
+   */
+  static create() {
+    return ListStack.create();
   }
-  static create(method, url) {
-    return new _HttpOutgoingRequest(method, url);
+};
+
+// sources/wonderlandTrailClient.ts
+var WonderlandTrailDirection = class _WonderlandTrailDirection {
+  value;
+  constructor(value) {
+    PreCondition.assertNotEmpty(value, "value");
+    this.value = value;
+  }
+  static clockwise = new _WonderlandTrailDirection("Clockwise");
+  static counterClockwise = new _WonderlandTrailDirection("CounterClockwise");
+  toString() {
+    return this.value;
   }
+  reverse() {
+    return this === _WonderlandTrailDirection.clockwise ? _WonderlandTrailDirection.counterClockwise : _WonderlandTrailDirection.clockwise;
+  }
+};
+
+// tests/test.ts
+var Test = class _Test {
   /**
-   * Create a new {@link HttpOutgoingRequest} with a GET {@link HttpMethod}.
-   * @param url The target URL for the {@link HttpOutgoingRequest}.
+   * Assert that the provided value is undefined;
+   * @param value The value to check.
    */
-  static get(url) {
-    return _HttpOutgoingRequest.create(0 /* GET */, url);
+  assertUndefined(value) {
+    _Test.assertUndefined(this, value);
   }
   /**
-   * Get the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+   * Assert that the provided value is undefined.
+   * @param test The current {@link Test}.
+   * @param value The value to check.
    */
-  getMethod() {
-    return this.method;
+  static assertUndefined(test2, value) {
+    test2.assertSame(value, void 0);
   }
   /**
-   * Set the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
-   * @param method The {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+   * Assert that the provided value is not undefined;
+   * @param value The value to check.
    */
-  setMethod(method) {
-    PreCondition.assertNotUndefinedAndNotNull(method, "method");
-    this.method = method;
-    return this;
+  assertNotUndefined(value) {
+    _Test.assertNotUndefined(this, value);
   }
   /**
-   * Get this {@link HttpOutgoingRequest}'s target URL.
+   * Assert that the provided value is not undefined.
+   * @param test The current {@link Test}.
+   * @param value The value to check.
    */
-  getURL() {
-    return this.url;
+  static assertNotUndefined(test2, value) {
+    test2.assertNotSame(value, void 0);
   }
   /**
-   * Set the URL that this request will be sent to.
-   * @param url The URL to send this request to.
+   * Assert that the provided value is null.
+   * @param value The value to check.
    */
-  setURL(url) {
-    PreCondition.assertNotEmpty(url, "url");
-    this.url = url;
-    return this;
+  assertNull(value) {
+    _Test.assertNull(this, value);
   }
   /**
-   * Get the {@link HttpHeaders} that will be sent.
+   * Assert that the provided value is null.
+   * @param value The value to check.
    */
-  getHeaders() {
-    return this.headers;
-  }
-  getHeader(headerName) {
-    return this.headers.get(headerName);
-  }
-  getHeaderValue(headerName) {
-    return this.headers.getValue(headerName);
+  static assertNull(test2, value) {
+    test2.assertSame(value, null);
   }
   /**
-   * Get the body that will be sent.
+   * Assert that the provided value is not null.
+   * @param value The value to check.
    */
-  getBody() {
-    return this.body;
-  }
-  setBody(body) {
-    PreCondition.assertNotUndefinedAndNotNull(body, "body");
-    this.body = body;
-    return this;
-  }
-};
-
-// sources/fetchHttpClient.ts
-var FetchHttpClient = class _FetchHttpClient {
-  constructor() {
-  }
-  static create() {
-    return new _FetchHttpClient();
-  }
-  sendRequest(request) {
-    PreCondition.assertNotUndefinedAndNotNull(request, "request");
-    return PromiseAsyncResult.create(async () => {
-      const requestInit = {
-        method: _FetchHttpClient.convertMethod(request.getMethod()),
-        headers: request.getHeaders().map((header) => [header.getName(), header.getValue()]).toArray().await(),
-        body: request.getBody() || void 0
-      };
-      const fetchResponse = await fetch(request.getURL(), requestInit);
-      return FetchHttpIncomingResponse.create(fetchResponse);
-    });
-  }
-  sendGetRequest(url) {
-    return this.sendRequest(HttpOutgoingRequest.create(0 /* GET */, url));
-  }
-  static convertMethod(method) {
-    PreCondition.assertNotUndefinedAndNotNull(method, "method");
-    let result;
-    switch (method) {
-      case 5 /* CONNECT */:
-        result = "CONNECT";
-        break;
-      case 4 /* DELETE */:
-        result = "DELETE";
-        break;
-      case 0 /* GET */:
-        result = "GET";
-        break;
-      case 1 /* HEAD */:
-        result = "HEAD";
-        break;
-      case 6 /* OPTIONS */:
-        result = "OPTIONS";
-        break;
-      case 8 /* PATCH */:
-        result = "PATCH";
-        break;
-      case 2 /* POST */:
-        result = "POST";
-        break;
-      case 3 /* PUT */:
-        result = "PUT";
-        break;
-      case 7 /* TRACE */:
-        result = "TRACE";
-        break;
-    }
-    PostCondition.assertNotEmpty(result, "result");
-    return result;
+  assertNotNull(value) {
+    _Test.assertNull(this, value);
   }
-};
-
-// sources/network.ts
-var Network = class {
-};
-
-// sources/nodeJSHttpServer.ts
-var http = __toESM(require("http"), 1);
-
-// sources/httpServer.ts
-var HttpServer = class {
-};
-
-// sources/httpOutgoingResponse.ts
-var HttpOutgoingResponse = class _HttpOutgoingResponse {
-  statusCode;
-  headers;
-  body;
-  constructor() {
-    this.statusCode = 200;
-    this.headers = MutableHttpHeaders.create();
-    this.body = "";
+  /**
+   * Assert that the provided value is not null.
+   * @param value The value to check.
+   */
+  static assertNotNull(test2, value) {
+    test2.assertNotSame(value, null);
   }
-  static create() {
-    return new _HttpOutgoingResponse();
+  /**
+   * Assert that the provided value is not undefined and not null.
+   * @param value The value to check.
+   */
+  assertNotUndefinedAndNotNull(value) {
+    _Test.assertNotUndefinedAndNotNull(this, value);
   }
   /**
-   * Get the status code of this {@link HttpOutgoingResponse}.
+   * Assert that the provided value is not undefined and not null.
+   * @param value The value to check.
    */
-  getStatusCode() {
-    return this.statusCode;
+  static assertNotUndefinedAndNotNull(test2, value) {
+    test2.assertNotSame(value, null);
+    test2.assertNotSame(value, void 0);
   }
   /**
-   * Set the status code of this {@link HttpOutgoingResponse}.
-   * @param statusCode The status code of this {@link HttpOutgoingResponse}.
+   * Assert that the provided collection is not undefined, not null, and not empty.
+   * @param value The value to check.
    */
-  setStatusCode(statusCode) {
-    PreCondition.assertBetween(100, statusCode, 599, "statusCode");
-    this.statusCode = statusCode;
-    return this;
+  assertNotEmpty(value) {
+    _Test.assertNotEmpty(this, value);
   }
-  getHeaders() {
-    return this.headers;
+  static assertNotEmpty(test2, value) {
+    test2.assertNotUndefinedAndNotNull(value);
+    test2.assertTrue(Iterable.any(value).await());
   }
   /**
-   * Get the HTTP header with the provided name or return a {@link NotFoundError} if the header
-   * doesn't exist.
-   * @param headerName The name of the header to get.
+   * Assert that the provided value is false.
+   * @param value The value to check.
    */
-  getHeader(headerName) {
-    return this.headers.get(headerName);
+  assertFalse(value) {
+    _Test.assertFalse(this, value);
+  }
+  static assertFalse(test2, value) {
+    PreCondition.assertNotUndefinedAndNotNull(test2, "test");
+    test2.assertSame(value, false);
   }
   /**
-   * Get the value of the header with the provided name or return a {@link NotFoundError} if the
-   * header doesn't exist.
-   * @param headerName The name of the header value to get.
+   * Assert that the provided value is true.
+   * @param value The value to check.
    */
-  getHeaderValue(headerName) {
-    return this.headers.getValue(headerName);
+  assertTrue(value) {
+    _Test.assertTrue(this, value);
   }
   /**
-   * Set the HTTP header in this {@link HttpOutgoingResponse}.
-   * @param headerName The name of the HTTP header.
-   * @param headerValue The value of the HTTP header.
+   * Assert that the provided value is true.
+   * @param value The value to check.
    */
-  setHeader(headerName, headerValue) {
-    this.headers.set(headerName, headerValue);
-    return this;
-  }
-  setContentTypeHeader(contentType) {
-    this.headers.setContentType(contentType);
-    return this;
+  static assertTrue(test2, value) {
+    PreCondition.assertNotUndefinedAndNotNull(test2, "test");
+    test2.assertSame(value, true);
   }
   /**
-   * Get the body of this {@link HttpOutgoingResponse}.
+   * Assert that the provided value is an instance of the provided {@link Type}.
+   * @param value The value to check.
+   * @param type The {@link Type} to check.
+   * @param expression The expression that produced the value.
+   * @param message An optional error message.
    */
-  getBody() {
-    return this.body;
+  assertInstanceOf(value, type, typeCheck) {
+    return _Test.assertInstanceOf(this, value, type, typeCheck);
   }
   /**
-   * Set the body of this {@link HttpOutgoingResponse}.
-   * @param body The body for this {@link HttpOutgoingResponse}.
+   * Assert that the provided value is an instance of the provided {@link Type}.
+   * @param value The value to check.
+   * @param type The {@link Type} to check.
+   * @param expression The expression that produced the value.
+   * @param message An optional error message.
    */
-  setBody(body) {
-    PreCondition.assertNotUndefinedAndNotNull(body, "body");
-    this.body = body;
-    return this;
+  static assertInstanceOf(test2, value, type, typeCheck) {
+    PreCondition.assertNotUndefinedAndNotNull(type, "type");
+    if (isUndefinedOrNull(typeCheck)) {
+      typeCheck = ((value2) => value2 instanceof type);
+    }
+    if (!typeCheck(value)) {
+      test2.fail(`Expected value to be of type ${type.name} but found ${value} instead.`);
+    }
   }
 };
 
-// sources/nodeJSHttpServer.ts
-var NodeJSHttpServer = class _NodeJSHttpServer extends HttpServer {
-  httpServer;
-  disposed;
+// tests/assertTest.ts
+var AssertTest = class _AssertTest {
   constructor() {
-    super();
-    this.disposed = false;
   }
+  /**
+   * Create a new {@link AssertTest} object.
+   */
   static create() {
-    return new _NodeJSHttpServer();
-  }
-  dispose() {
-    return PromiseAsyncResult.create(new Promise((resolve, reject) => {
-      if (this.disposed) {
-        resolve(false);
-      } else if (!this.httpServer) {
-        this.disposed = true;
-        resolve(true);
-      } else {
-        this.httpServer.close((error) => {
-          if (error) {
-            reject(error);
-          } else {
-            this.disposed = true;
-            this.httpServer = void 0;
-            resolve(true);
-          }
-        });
-      }
-    }));
-  }
-  isDisposed() {
-    return this.disposed;
-  }
-  isStarted() {
-    return !!this.httpServer;
-  }
-  addRequestHandler(requestPath, handler) {
-    throw new Error("Method not implemented.");
+    return new _AssertTest();
   }
-  setDefaultRequestHandler(handler) {
-    throw new Error("Method not implemented.");
+  fail(message) {
+    PreCondition.assertNotEmpty(message, "message");
+    assert.fail(message);
   }
-  start(portNumber) {
-    PreCondition.assertGreaterThanOrEqualTo(portNumber, 1, "portNumber");
-    PreCondition.assertFalse(this.isDisposed(), "this.isDisposed()");
-    PreCondition.assertUndefined(this.httpServer, "this.httpServer");
-    return PromiseAsyncResult.create(new Promise((resolve, reject) => {
-      if (this.httpServer) {
-        reject(new Error("Can't run a HttpServer multiple times."));
-      } else {
-        this.httpServer = http.createServer();
-        this.httpServer.on("request", (request, response) => {
-          const httpResponse = HttpOutgoingResponse.create().setStatusCode(200).setHeader("Content-Type", "text/plain").setBody("Hello world!");
-          const statusCode = httpResponse.getStatusCode();
-          const headers = httpResponse.getHeaders();
-          const responseHeaders = {};
-          for (const header of headers) {
-            responseHeaders[header.getName()] = header.getValue();
-          }
-          response.writeHead(statusCode, responseHeaders);
-          response.end(httpResponse.getBody());
-        });
-        this.httpServer.on("close", () => {
-          resolve();
-        });
-        this.httpServer.on("error", (error) => {
-          reject(error);
-        });
-        this.httpServer.listen(portNumber);
-      }
-    }));
+  assertUndefined(value) {
+    Test.assertUndefined(this, value);
   }
-};
-
-// sources/realNetwork.ts
-var RealNetwork = class _RealNetwork extends Network {
-  constructor() {
-    super();
+  assertNotUndefined(value) {
+    Test.assertNotUndefined(this, value);
   }
-  static create() {
-    return new _RealNetwork();
+  assertNull(value) {
+    Test.assertNull(this, value);
   }
-  createHttpServer() {
-    return NodeJSHttpServer.create();
+  assertNotNull(value) {
+    Test.assertNotNull(this, value);
   }
-  createHttpClient() {
-    return FetchHttpClient.create();
+  assertNotUndefinedAndNotNull(value) {
+    Test.assertNotUndefinedAndNotNull(this, value);
   }
-};
-
-// sources/currentProcess.ts
-var CurrentProcess = class _CurrentProcess {
-  args;
-  parameters;
-  outputWriteStream;
-  exitCodeProperty;
-  network;
-  constructor() {
+  assertNotEmpty(value) {
+    Test.assertNotEmpty(this, value);
   }
-  static create() {
-    return new _CurrentProcess();
+  assertSame(left, right) {
+    assert.strictEqual(left, right);
   }
-  static async run(action) {
-    PreCondition.assertNotUndefinedAndNotNull(action, "action");
-    const currentProcess = _CurrentProcess.create();
-    try {
-      const result = await action(currentProcess);
-      if (isNumber(result)) {
-        currentProcess.setExitCode(result);
-      }
-    } catch (error) {
-      currentProcess.setExitCode(-1);
-      const writeStream = currentProcess.getOutputWriteStream();
-      if (error instanceof Error && error.stack) {
-        writeStream.writeLine(error.stack);
-      } else {
-        writeStream.writeLine(`${error}`);
-      }
-    }
+  assertNotSame(left, right) {
+    assert.notStrictEqual(left, right);
   }
-  getArguments() {
-    if (!this.args) {
-      this.args = process.argv;
-    }
-    return this.args;
+  assertEqual(left, right, message) {
+    assert.deepStrictEqual(left, right, message);
   }
-  setArguments(args) {
-    PreCondition.assertNotUndefinedAndNotNull(args, "args");
-    PreCondition.assertUndefined(this.parameters, "this.parameters");
-    this.args = args;
-    return this;
+  assertNotEqual(left, right) {
+    assert.notDeepStrictEqual(left, right);
   }
-  getParameters() {
-    if (!this.parameters) {
-      this.parameters = CommandLineParameters.create(this.getArguments());
-    }
-    return this.parameters;
+  assertFalse(value) {
+    Test.assertFalse(this, value);
   }
-  getOutputWriteStream() {
-    if (!this.outputWriteStream) {
-      this.outputWriteStream = NodeJSCharacterWriteStream.create(process.stdout);
-    }
-    return this.outputWriteStream;
+  assertTrue(value) {
+    Test.assertTrue(this, value);
   }
-  setOutputWriteStream(outputWriteStream) {
-    PreCondition.assertNotUndefinedAndNotNull(outputWriteStream, "outputWriteStream");
-    this.outputWriteStream = outputWriteStream;
-    return this;
+  assertThrows(action, expectedError) {
+    if (!isFunction(action)) {
+      const syncResult = action;
+      action = () => {
+        syncResult.await();
+      };
+    }
+    assert.throws(action, expectedError);
   }
-  getExitCode() {
-    return this.getExitCodeProperty().getValue();
+  assertThrowsAsync(action, expectedError) {
+    const promiseOrAsyncAction = isFunction(action) ? async () => await action() : action;
+    return PromiseAsyncResult.create(assert.rejects(promiseOrAsyncAction, expectedError));
   }
-  setExitCode(exitCode) {
-    PreCondition.assertNotUndefinedAndNotNull(exitCode, "exitCode");
-    this.getExitCodeProperty().setValue(exitCode);
-    return this;
+  assertInstanceOf(value, type, typeCheck) {
+    Test.assertInstanceOf(this, value, type, typeCheck);
   }
-  getExitCodeProperty() {
-    if (!this.exitCodeProperty) {
-      this.exitCodeProperty = Property.create({
-        getter: () => process.exitCode,
-        setter: (value) => {
-          process.exitCode = value;
-        }
+};
+
+// tests/assertTestTests.ts
+var import_assert = require("assert");
+function test(runner) {
+  runner.testFile("assertTest.ts", () => {
+    runner.testType("AssertTest", () => {
+      runner.testFunction("assertThrows()", () => {
+        runner.test("with throwing action", (test2) => {
+          const at = AssertTest.create();
+          at.assertThrows(() => {
+            throw new Error("abc");
+          }, new Error("abc"));
+        });
+        runner.test("with non-throwing action", (test2) => {
+          const at = AssertTest.create();
+          test2.assertThrows(
+            () => at.assertThrows(() => {
+            }, new Error("oops")),
+            new import_assert.AssertionError({
+              message: "Missing expected exception (Error).",
+              operator: "throws",
+              expected: new Error("oops")
+            })
+          );
+        });
       });
-    }
-    return this.exitCodeProperty;
-  }
-  setExitCodeProperty(exitCodeProperty) {
-    PreCondition.assertNotUndefinedAndNotNull(exitCodeProperty, "exitCodeProperty");
-    this.exitCodeProperty = exitCodeProperty;
-    return this;
+      runner.testFunction("assertThrowsAsync()", () => {
+        runner.test("with throwing sync action", async (test2) => {
+          const at = AssertTest.create();
+          await at.assertThrowsAsync(() => {
+            throw new Error("abc");
+          }, new Error("abc"));
+        });
+        runner.test("with throwing async action", async (test2) => {
+          const at = AssertTest.create();
+          await at.assertThrowsAsync(async () => {
+            throw new Error("abc");
+          }, new Error("abc"));
+        });
+        runner.test("with rejected Promise", async (test2) => {
+          const at = AssertTest.create();
+          await at.assertThrowsAsync(Promise.reject(new Error("abc")), new Error("abc"));
+        });
+        runner.test("with throwing action that returns a rejected Promise", async (test2) => {
+          const at = AssertTest.create();
+          await at.assertThrowsAsync(() => Promise.reject(new Error("abc")), new Error("abc"));
+        });
+        runner.test("with non-throwing async action", async (test2) => {
+          const at = AssertTest.create();
+          await test2.assertThrowsAsync(
+            async () => await at.assertThrowsAsync(async () => {
+            }, new Error("oops")),
+            new import_assert.AssertionError({
+              message: "Missing expected rejection (Error).",
+              operator: "rejects",
+              expected: new Error("oops")
+            })
+          );
+        });
+      });
+    });
+  });
+}
+
+// tests/basicTestSkip.ts
+var BasicTestSkip = class _BasicTestSkip {
+  shouldSkip;
+  message;
+  constructor(shouldSkip, message) {
+    PreCondition.assertNotUndefinedAndNotNull(message, "message");
+    this.shouldSkip = shouldSkip;
+    this.message = message;
   }
-  getNetwork() {
-    if (!this.network) {
-      this.network = RealNetwork.create();
+  /**
+   * Create a new {@link TestSkip} with the provided properties.
+   * @param shouldSkip Whether the tests associated with the new {@link TestSkip}
+   * should be skipped.
+   * @param message The message that explains why the tests associated with this {@link TestSkip}
+   * should be skipped.
+   */
+  static create(shouldSkip, message) {
+    if (shouldSkip === void 0 || shouldSkip === null) {
+      shouldSkip = true;
     }
-    return this.network;
+    if (message === void 0 || message === null) {
+      message = "";
+    }
+    return new _BasicTestSkip(shouldSkip, message);
   }
-  setNetwork(network) {
-    PreCondition.assertUndefined(this.network, "this.network");
-    PreCondition.assertNotUndefinedAndNotNull(network, "network");
-    this.network = network;
-    return this;
+  getShouldSkip() {
+    return this.shouldSkip;
+  }
+  getMessage() {
+    return this.message;
   }
 };
 
 // tests/failedTest.ts
 var FailedTest = class _FailedTest {
-  fullTestNameParts;
+  testAction;
   error;
-  constructor(fullTestNameParts, error) {
-    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestName");
+  constructor(testAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
     PreCondition.assertNotUndefinedAndNotNull(error, "error");
-    this.fullTestNameParts = fullTestNameParts;
+    this.testAction = testAction;
     this.error = error;
   }
-  static create(fullTestNameParts, error) {
-    return new _FailedTest(fullTestNameParts, error);
-  }
-  getFullTestNameParts() {
-    return this.fullTestNameParts;
+  static create(testAction, error) {
+    return new _FailedTest(testAction, error);
   }
-  getFullTestName() {
-    return join(" ", this.fullTestNameParts);
+  getTestAction() {
+    return this.testAction;
   }
-  getError() {
+  getTestError() {
     return this.error;
   }
-  getErrorMessage() {
-    return this.error instanceof Error && this.error.stack ? this.error.stack : `${this.error}`;
-  }
 };
 
 // tests/skippedTest.ts
 var SkippedTest = class _SkippedTest {
   skip;
-  fullTestNameParts;
-  constructor(skip, fullTestNameParts) {
+  testAction;
+  constructor(skip, testAction) {
     PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
-    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
     this.skip = skip;
-    this.fullTestNameParts = fullTestNameParts;
+    this.testAction = testAction;
   }
-  static create(skip, fullTestNameParts) {
-    return new _SkippedTest(skip, fullTestNameParts);
+  static create(skip, testAction) {
+    return new _SkippedTest(skip, testAction);
   }
   getSkipMessage() {
     return this.skip.getMessage();
   }
-  getFullTestNameParts() {
-    return this.fullTestNameParts;
-  }
-  getFullTestName() {
-    return join(" ", this.fullTestNameParts);
+  getTestAction() {
+    return this.testAction;
   }
 };
 
@@ -5334,18 +5931,21 @@ var SkippedTest = class _SkippedTest {
 var TestAction = class _TestAction {
   parent;
   name;
+  type;
   skip;
   action;
-  constructor(parent, name, skip, action) {
+  constructor(parent, name, type, skip, action) {
     PreCondition.assertNotUndefinedAndNotNull(name, "name");
+    PreCondition.assertNotEmpty(type, "type");
     PreCondition.assertNotUndefinedAndNotNull(action, "action");
     this.parent = parent;
     this.name = name;
+    this.type = type;
     this.skip = skip;
     this.action = action;
   }
-  static create(parent, name, skip, action) {
-    return new _TestAction(parent, name, skip, action);
+  static create(parent, name, type, skip, action) {
+    return new _TestAction(parent, name, type, skip, action);
   }
   getParent() {
     return this.parent;
@@ -5364,6 +5964,9 @@ var TestAction = class _TestAction {
   getFullName() {
     return join(" ", this.getFullNameParts());
   }
+  getType() {
+    return this.type;
+  }
   getSkip() {
     return this.skip || this.parent?.getSkip();
   }
@@ -5378,34 +5981,6 @@ var TestAction = class _TestAction {
   }
 };
 
-// sources/english.ts
-function andList(values) {
-  return list("and", values);
-}
-function list(conjunction, values) {
-  PreCondition.assertNotEmpty(conjunction, "conjunction");
-  PreCondition.assertNotUndefinedAndNotNull(values, "values");
-  let result = "";
-  let index = 0;
-  const iterator = Iterator.create(values).start().await();
-  while (iterator.hasCurrent()) {
-    const currentValue = iterator.takeCurrent().await();
-    if (index >= 1) {
-      if (iterator.hasCurrent()) {
-        result += `, `;
-      } else {
-        if (index >= 2) {
-          result += `,`;
-        }
-        result += ` ${conjunction} `;
-      }
-    }
-    result += currentValue;
-    index++;
-  }
-  return result;
-}
-
 // tests/testSkip.ts
 var TestSkip = class {
   constructor() {
@@ -5449,139 +6024,404 @@ var TestRunner = class _TestRunner {
   toString(value) {
     return _TestRunner.toString(this, value);
   }
-  /**
-   * Get the {@link string} representation of the provided value.
-   * @param value The value to get the {@link string} representation of.
-   */
-  static toString(_runner, value) {
-    const toStringFunctions = ToStringFunctions.create();
-    return toStringFunctions.toString(value);
+  /**
+   * Get the {@link string} representation of the provided value.
+   * @param value The value to get the {@link string} representation of.
+   */
+  static toString(_runner, value) {
+    const toStringFunctions = ToStringFunctions.create();
+    return toStringFunctions.toString(value);
+  }
+  skip(messageOrShouldSkip, message) {
+    let shouldSkip;
+    if (!isBoolean(messageOrShouldSkip)) {
+      shouldSkip = true;
+      message = messageOrShouldSkip;
+    } else {
+      shouldSkip = messageOrShouldSkip;
+    }
+    return _TestRunner.skip(this, shouldSkip, message);
+  }
+  /**
+   * Create a {@link TestSkip} object that will prevent tests from being run.
+   * @param shouldSkip Whether these tests should be skipped.
+   * @param message The message that explains why the tests are being skipped.
+   */
+  static skip(_runner, shouldSkip, message) {
+    return TestSkip.create(shouldSkip, message);
+  }
+};
+
+// tests/ConsoleTestRunnerUI.ts
+var ConsoleTestRunnerUI = class {
+  writeStream;
+  styles;
+  getErrorStringOptions;
+  constructor() {
+    this.styles = Map2.create();
+  }
+  static flat() {
+    return FlatConsoleTestRunnerUI.create();
+  }
+  static tree() {
+    return TreeConsoleTestRunnerUI.create();
+  }
+  setWriteStream(writeStream) {
+    PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
+    this.writeStream = IndentedCharacterWriteStream.create(writeStream);
+    return this;
+  }
+  setStyle(style, styleFunction) {
+    PreCondition.assertNotEmpty(style, "style");
+    PreCondition.assertNotUndefinedAndNotNull(styleFunction, "styleFunction");
+    this.styles.set(style, styleFunction);
+    return this;
+  }
+  setStyles(styles) {
+    PreCondition.assertNotUndefinedAndNotNull(styles, "styles");
+    for (const entry of Object.entries(styles)) {
+      this.setStyle(entry[0], entry[1]);
+    }
+    return this;
+  }
+  applyStyle(style, text) {
+    PreCondition.assertNotEmpty(style, "style");
+    PreCondition.assertNotUndefinedAndNotNull(text, "text");
+    const styleFunction = this.styles.get(style).catch(NotFoundError, () => {
+      return (text2) => text2;
+    }).await();
+    return styleFunction(text);
+  }
+  addIndentation() {
+    this.writeStream?.addIndentation();
+  }
+  removeIndentation() {
+    this.writeStream?.removeIndentation();
+  }
+  indent(action) {
+    return this.writeStream?.indent(action) ?? AsyncResult.value(0);
+  }
+  writeString(text) {
+    return this.writeStream?.writeString(text) ?? AsyncResult.value(0);
+  }
+  writeLine(text) {
+    return this.writeStream?.writeLine(text) ?? AsyncResult.value(0);
+  }
+  writeTestActionName(testAction) {
+    return this.writeString(this.applyStyle(testAction.getType(), testAction.getName()));
+  }
+  writeFullTestActionName(testAction) {
+    return AsyncResult.create(async () => {
+      let result = 0;
+      const testActionStack = Stack.create();
+      let currentTestAction = testAction;
+      while (currentTestAction) {
+        testActionStack.add(currentTestAction);
+        currentTestAction = currentTestAction.getParent();
+      }
+      while (await testActionStack.any()) {
+        currentTestAction = await testActionStack.remove();
+        if (currentTestAction.getParent()) {
+          result += await this.writeString(" ");
+        }
+        result += await this.writeTestActionName(currentTestAction);
+      }
+      return result;
+    });
+  }
+  setGetErrorStringOptions(options) {
+    this.getErrorStringOptions = options;
+    return this;
+  }
+  beforeTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    return AsyncResult.empty();
+  }
+  afterTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    return AsyncResult.empty();
+  }
+  beforeTest(testAction) {
+    return AsyncResult.empty();
+  }
+  afterPassedTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("passed", "Passed")}`);
+    });
+  }
+  afterSkippedTest(testAction, skip) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("skipped", "Skipped")}`);
+    });
+  }
+  afterFailedTest(currentTestAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(currentTestAction, "currentTestAction");
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("failed", "Failed")}`);
+    });
+  }
+  writeSummary(passedTestCount, skippedTests, failedTests) {
+    PreCondition.assertGreaterThanOrEqualTo(passedTestCount, 0, "passedTestCount");
+    PreCondition.assertNotUndefinedAndNotNull(skippedTests, "skippedTests");
+    PreCondition.assertNotUndefinedAndNotNull(failedTests, "failedTests");
+    return AsyncResult.create(async () => {
+      await this.writeLine();
+      if (await skippedTests.any()) {
+        await this.writeLine(`${this.applyStyle("skipped", "Skipped Tests")}:`);
+        let counter = 0;
+        for (const skippedTest of skippedTests) {
+          await this.writeString(`${++counter}) `);
+          await this.writeFullTestActionName(skippedTest.getTestAction());
+          await this.writeLine();
+          const skipMessage = skippedTest.getSkipMessage();
+          if (skipMessage) {
+            await this.indent(() => this.writeLine(skipMessage));
+          }
+        }
+        await this.writeLine();
+      }
+      if (await failedTests.any()) {
+        await this.writeLine(`${this.applyStyle("failed", "Failed Tests")}:`);
+        let counter = 0;
+        for (const failedTest of failedTests) {
+          await this.writeString(`${++counter}) `);
+          await this.writeFullTestActionName(failedTest.getTestAction());
+          await this.writeLine();
+          const testError = failedTest.getTestError();
+          await this.indent(() => this.writeLine(testError.getErrorString(this.getErrorStringOptions)));
+          await this.writeLine();
+        }
+      }
+      if (passedTestCount > 0) {
+        await this.writeLine(`${this.applyStyle("passed", "Passed")}:  ${passedTestCount}`);
+      }
+      if (await skippedTests.any()) {
+        await this.writeLine(`${this.applyStyle("skipped", "Skipped")}: ${skippedTests.getCount().await()}`);
+      }
+      if (await failedTests.any()) {
+        await this.writeLine(`${this.applyStyle("failed", "Failed")}:  ${failedTests.getCount().await()}`);
+      }
+    });
+  }
+};
+var FlatConsoleTestRunnerUI = class _FlatConsoleTestRunnerUI extends ConsoleTestRunnerUI {
+  constructor() {
+    super();
+  }
+  static create() {
+    return new _FlatConsoleTestRunnerUI();
+  }
+  beforeTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.writeFullTestActionName(testAction);
+    });
   }
-  skip(messageOrShouldSkip, message) {
-    let shouldSkip;
-    if (!isBoolean(messageOrShouldSkip)) {
-      shouldSkip = true;
-      message = messageOrShouldSkip;
-    } else {
-      shouldSkip = messageOrShouldSkip;
-    }
-    return _TestRunner.skip(this, shouldSkip, message);
+};
+var TreeConsoleTestRunnerUI = class _TreeConsoleTestRunnerUI extends ConsoleTestRunnerUI {
+  testActions;
+  testActionWrittenDepth;
+  constructor() {
+    super();
+    this.testActions = List.create();
+    this.testActionWrittenDepth = 0;
   }
-  /**
-   * Create a {@link TestSkip} object that will prevent tests from being run.
-   * @param shouldSkip Whether these tests should be skipped.
-   * @param message The message that explains why the tests are being skipped.
-   */
-  static skip(_runner, shouldSkip, message) {
-    return TestSkip.create(shouldSkip, message);
+  static create() {
+    return new _TreeConsoleTestRunnerUI();
   }
-  static runTestAction(runner, name, skip, testAction) {
-    if (getParameterCount(testAction) === 0) {
-      runner.testGroup(name, skip, testAction);
-    } else {
-      runner.test(name, skip, testAction);
-    }
+  beforeTestGroup(testGroup) {
+    return AsyncResult.create(() => {
+      this.testActions.add(testGroup);
+    });
   }
-  testFile(fileName, skipOrTestAction, testAction) {
-    _TestRunner.testFile(this, fileName, skipOrTestAction, testAction);
+  afterTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    PreCondition.assertTrue(this.testActions.any().await(), "this.testActions.any().await()");
+    return AsyncResult.create(() => {
+      this.testActions.removeLast().await();
+      const testActionCount = this.testActions.getCount().await();
+      if (this.testActionWrittenDepth > testActionCount) {
+        this.testActionWrittenDepth--;
+        this.removeIndentation();
+      }
+    });
   }
-  /**
-   * Create a test group that will test the provided file.
-   * @param runner The {@link TestRunner} that will run the tests.
-   * @param fileName The name of the file that is being tested.
-   * @param testAction The action that will run the tests.
-   */
-  static testFile(runner, fileName, skipOrTestAction, testAction) {
-    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
-    PreCondition.assertNotUndefinedAndNotNull(fileName, "fileName");
-    PreCondition.assertNotEmpty(fileName, "fileName");
-    let skip;
-    if (isFunction(skipOrTestAction)) {
-      PreCondition.assertUndefined(testAction, "testAction");
-      skip = void 0;
-      testAction = skipOrTestAction;
-    } else {
-      skip = skipOrTestAction;
-    }
+  beforeTest(testAction) {
     PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
-    _TestRunner.runTestAction(runner, fileName, skip, testAction);
+    return AsyncResult.create(async () => {
+      const testActionCount = this.testActions.getCount().await();
+      while (this.testActionWrittenDepth < testActionCount) {
+        const testGroup = this.testActions.get(this.testActionWrittenDepth).await();
+        await this.writeTestActionName(testGroup);
+        await this.writeLine();
+        this.addIndentation();
+        this.testActionWrittenDepth++;
+      }
+      await this.writeTestActionName(testAction);
+    });
   }
-  testType(typeNameOrType, skipOrTestAction, testAction) {
-    _TestRunner.testType(this, typeNameOrType, skipOrTestAction, testAction);
+};
+
+// tests/AssertTestCreator.ts
+var AssertTestCreator = class _AssertTestCreator {
+  constructor() {
+  }
+  static create() {
+    return new _AssertTestCreator();
+  }
+  createTest() {
+    return AssertTest.create();
   }
+};
+
+// tests/TestCreator.ts
+var TestCreator = class {
   /**
-   * Create a test group that will test the provided type.
-   * @param runner The {@link TestRunner} that will run the tests.
-   * @param type The {@link Type} or name of the type that is being tested.
-   * @param testAction The action that will run the tests.
+   * Create the default {@link TestCreator}.
    */
-  static testType(runner, typeNameOrType, skipOrTestAction, testAction) {
-    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
-    PreCondition.assertNotUndefinedAndNotNull(typeNameOrType, "typeNameOrType");
-    let typeName;
-    if (isString(typeNameOrType)) {
-      typeName = typeNameOrType;
-    } else {
-      typeName = getName(typeNameOrType);
+  static create() {
+    return AssertTestCreator.create();
+  }
+};
+
+// tests/BasicTestError.ts
+var import_url = require("url");
+var import_path = __toESM(require("path"), 1);
+var BasicTestError = class _BasicTestError {
+  error;
+  constructor(error) {
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    this.error = error;
+  }
+  static create(error) {
+    return new _BasicTestError(error);
+  }
+  getError() {
+    return this.error;
+  }
+  getErrorString(options) {
+    let result = this.error instanceof Error && this.error.stack ? this.error.stack : `${this.error}`;
+    const currentFolderPath = process.cwd();
+    if (options?.removeNonProjectPaths ?? false) {
+      result = _BasicTestError.removeNonProjectPaths(result, currentFolderPath);
     }
-    PreCondition.assertNotEmpty(typeName, "typeName");
-    let skip;
-    if (isFunction(skipOrTestAction)) {
-      PreCondition.assertUndefined(testAction, "testAction");
-      skip = void 0;
-      testAction = skipOrTestAction;
-    } else {
-      skip = skipOrTestAction;
+    if (options?.relativeFilePaths ?? false) {
+      result = _BasicTestError.makeFilePathsRelative(result, currentFolderPath);
     }
-    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
-    _TestRunner.runTestAction(runner, typeName, skip, testAction);
+    return result;
   }
-  testFunction(functionSignature, skipOrTestAction, testAction) {
-    _TestRunner.testFunction(this, functionSignature, skipOrTestAction, testAction);
+  static removeNonProjectPaths(errorString, currentFolderPath) {
+    currentFolderPath = currentFolderPath.replaceAll("\\", "/");
+    return errorString.split("\n").filter((line) => {
+      let keepLine = false;
+      const trimmedLine = line.trim();
+      const match = trimmedLine.match(/^at .* \((.+)\)$/) ?? trimmedLine.match(/^at (.+)$/);
+      if (!match) {
+        keepLine = true;
+      } else {
+        const location = match[1];
+        try {
+          const filePath = import_path.default.resolve((0, import_url.fileURLToPath)(location)).replaceAll("\\", "/");
+          keepLine = filePath.startsWith(currentFolderPath);
+        } catch {
+        }
+      }
+      return keepLine;
+    }).join("\n");
+  }
+  static makeFilePathsRelative(errorString, currentFolderPath) {
+    return errorString.split("\n").map((line) => {
+      const match = line.match(/^(\s*)at (.+?) \((.+)\)$/) ?? line.match(/^(\s*)at (.+)$/);
+      if (match) {
+        const hasFunctionName = match.length === 4;
+        const indentation = match[1];
+        const functionName = hasFunctionName ? match[2] : void 0;
+        const location = hasFunctionName ? match[3] : match[2];
+        let relativeLocation = location;
+        try {
+          const pathMatch = location.match(/^(.*?):(\d+):(\d+)$/);
+          if (pathMatch) {
+            const fullPath = pathMatch[1];
+            const lineNumber = pathMatch[2];
+            const columnNumber = pathMatch[3];
+            let absolutePath;
+            if (fullPath.startsWith("file:///")) {
+              absolutePath = (0, import_url.fileURLToPath)(fullPath);
+            } else if (/^[A-Za-z]:[\\/]/.test(fullPath) || fullPath.startsWith("/")) {
+              absolutePath = fullPath;
+            }
+            if (absolutePath) {
+              let relativePath = import_path.default.relative(
+                currentFolderPath,
+                absolutePath
+              );
+              relativePath = relativePath.replace(/\\/g, "/");
+              relativeLocation = `${relativePath}:${lineNumber}:${columnNumber}`;
+            }
+          }
+        } catch {
+        }
+        if (relativeLocation !== location) {
+          if (functionName) {
+            line = `${indentation}at ${functionName} (${relativeLocation})`;
+          } else {
+            line = `${indentation}at ${relativeLocation}`;
+          }
+        }
+      }
+      return line;
+    }).join("\n");
   }
-  /**
-   * Create a test group that will test the provided function.
-   * @param runner The {@link TestRunner} that will run the tests.
-   * @param functionSignature The signature of the function that is being tested.
-   * @param testAction The action that will run the tests.
-   */
-  static testFunction(runner, functionSignature, skipOrTestAction, testAction) {
-    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
-    PreCondition.assertNotEmpty(functionSignature, "functionSignature");
-    let skip;
-    if (isFunction(skipOrTestAction)) {
-      PreCondition.assertUndefined(testAction, "testAction");
-      skip = void 0;
-      testAction = skipOrTestAction;
-    } else {
-      skip = skipOrTestAction;
-    }
-    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
-    _TestRunner.runTestAction(runner, functionSignature, skip, testAction);
+};
+
+// tests/BasicTestErrorCreator.ts
+var BasicTestErrorCreator = class _BasicTestErrorCreator {
+  constructor() {
+  }
+  static create() {
+    return new _BasicTestErrorCreator();
+  }
+  createTestError(error) {
+    return BasicTestError.create(error);
+  }
+};
+
+// tests/TestErrorCreator.ts
+var TestErrorCreator = class {
+  static create() {
+    return BasicTestErrorCreator.create();
   }
 };
 
 // tests/consoleTestRunner.ts
-var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
+var ConsoleTestRunner = class _ConsoleTestRunner {
   writeStream;
-  pendingActions;
-  pendingActionsInsertIndex;
+  testActions;
+  testActionInsertIndex;
   currentTestAction;
   currentTest;
   passedTestCount;
   skippedTests;
   testFailures;
-  constructor() {
-    super();
-    this.writeStream = NodeJSCharacterWriteStream.create(process.stdout);
-    this.pendingActions = List.create();
-    this.pendingActionsInsertIndex = 0;
+  testCreator;
+  testErrorCreator;
+  ui;
+  constructor(testCreator, testErrorCreator, ui) {
+    this.writeStream = IndentedCharacterWriteStream.create(NodeJSCharacterWriteStream.create(process.stdout));
+    this.testActions = List.create();
+    this.testActionInsertIndex = 0;
     this.passedTestCount = 0;
     this.skippedTests = List.create();
     this.testFailures = List.create();
+    this.testCreator = testCreator || TestCreator.create();
+    this.testErrorCreator = testErrorCreator || TestErrorCreator.create();
+    this.ui = ui || ConsoleTestRunnerUI.tree();
+    this.ui.setWriteStream(this.writeStream);
   }
-  static create() {
-    return new _ConsoleTestRunner();
+  static create(testCreator, testErrorCreator, ui) {
+    return new _ConsoleTestRunner(testCreator, testErrorCreator, ui);
   }
   static run(testFunctionOrTestFunctions) {
     let testFunction;
@@ -5602,7 +6442,15 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
       };
     }
     return CurrentProcess.run(async (currentProcess) => {
-      const runner = _ConsoleTestRunner.create().setWriteStream(currentProcess.getOutputWriteStream());
+      const runner = _ConsoleTestRunner.create().setWriteStream(currentProcess.getOutputWriteStream()).setStyles({
+        file: (t) => ANSIStyles.blue(t),
+        function: (t) => ANSIStyles.blue(t),
+        type: (t) => ANSIStyles.blue(t),
+        group: (t) => ANSIStyles.blue(t),
+        passed: (t) => ANSIStyles.green(`\u2713 ${t}`),
+        skipped: (t) => ANSIStyles.yellow(`\u25CC ${t}`),
+        failed: (t) => ANSIStyles.red(`\u2717 ${t}`)
+      });
       await testFunction(runner);
       await runner.runAsync();
       await runner.printSummary();
@@ -5610,21 +6458,50 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
   }
   setWriteStream(writeStream) {
     PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
-    this.writeStream = writeStream;
+    this.writeStream = IndentedCharacterWriteStream.create(writeStream);
+    this.ui.setWriteStream(this.writeStream);
+    return this;
+  }
+  setStyle(style, styleFunction) {
+    this.ui.setStyle(style, styleFunction);
+    return this;
+  }
+  setStyles(styles) {
+    this.ui.setStyles(styles);
+    return this;
+  }
+  setGetErrorStringOptions(options) {
+    this.ui.setGetErrorStringOptions(options);
     return this;
   }
   /**
    * Get the number of {@link TestAction}s that have yet to be executed.
    */
-  getPendingTestActionsCount() {
-    return this.pendingActions.getCount().await();
+  getTestActionCount() {
+    return this.testActions.getCount().await();
   }
   /**
-   * Get the index in the pending-{@link TestAction} stack that new {@link TestAction}s will be
+   * Get the index in the {@link TestAction} list that new {@link TestAction}s will be
    * inserted at.
    */
-  getPendingTestActionsInsertIndex() {
-    return this.pendingActionsInsertIndex;
+  getTestActionInsertIndex() {
+    return this.testActionInsertIndex;
+  }
+  resetTestActionInsertIndex() {
+    this.testActionInsertIndex = 0;
+  }
+  insertTestAction(testActionName, testActionType, skip, action) {
+    const parentTestAction = this.getCurrentTestAction();
+    const testAction = TestAction.create(parentTestAction, testActionName, testActionType, skip, async () => {
+      try {
+        await action();
+      } catch (error) {
+        const testError = this.testErrorCreator.createTestError(error);
+        await this.afterFailedTest(testAction, testError);
+      }
+    });
+    this.testActions.insert(this.testActionInsertIndex, testAction);
+    this.testActionInsertIndex++;
   }
   /**
    * Get the number of tests that have been skipped.
@@ -5658,37 +6535,103 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
     return this.currentTest;
   }
   assertNoCurrentTest() {
-    if (this.currentTest !== void 0) {
+    if (this.currentTest) {
       this.currentTest.fail("Can't start a new test group or a new test while running a test.");
     }
   }
-  beforeTest(fullTestNameParts) {
-    return PromiseAsyncResult.create(async () => {
-      await this.writeStream.writeString(join(" ", fullTestNameParts));
-    });
+  beforeTestGroup(testAction) {
+    return this.ui.beforeTestGroup(testAction);
   }
-  afterPassedTest() {
-    return PromiseAsyncResult.create(async () => {
-      await this.writeStream.writeLine(" - Passed");
+  afterTestGroup(testAction) {
+    return this.ui.afterTestGroup(testAction);
+  }
+  beforeTest(testAction) {
+    return this.ui.beforeTest(testAction);
+  }
+  afterPassedTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.ui.afterPassedTest(testAction);
       this.passedTestCount++;
     });
   }
-  afterSkippedTest(fullTestNameParts, skip) {
-    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
-    PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
-    return PromiseAsyncResult.create(async () => {
-      this.skippedTests.add(SkippedTest.create(skip, fullTestNameParts));
-      await this.writeStream.writeLine(" - Skipped");
+  afterSkippedTest(testAction, skip) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    return AsyncResult.create(async () => {
+      await this.ui.afterSkippedTest(testAction, skip);
+      this.skippedTests.add(SkippedTest.create(skip, testAction));
     });
   }
-  afterFailedTest(fullTestNameParts, error) {
-    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
+  afterFailedTest(testAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
     PreCondition.assertNotUndefinedAndNotNull(error, "error");
-    return PromiseAsyncResult.create(async () => {
-      this.testFailures.add(FailedTest.create(fullTestNameParts, error));
-      await this.writeStream.writeLine(" - Failed");
+    return AsyncResult.create(async () => {
+      await this.ui.afterFailedTest(testAction, error);
+      this.testFailures.add(FailedTest.create(testAction, error));
     });
   }
+  andList(values) {
+    return TestRunner.andList(this, values);
+  }
+  toString(value) {
+    return TestRunner.toString(this, value);
+  }
+  skip(messageOrShouldSkip, message) {
+    let shouldSkip;
+    if (!isBoolean(messageOrShouldSkip)) {
+      shouldSkip = true;
+      message = messageOrShouldSkip;
+    } else {
+      shouldSkip = messageOrShouldSkip;
+    }
+    return TestRunner.skip(this, shouldSkip, message);
+  }
+  testFile(fileName, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(fileName, "fileName");
+    PreCondition.assertNotEmpty(fileName, "fileName");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.testGroupOrTest(fileName, "file", skip, testAction);
+  }
+  testType(typeNameOrType, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(typeNameOrType, "typeNameOrType");
+    let typeName;
+    if (isString(typeNameOrType)) {
+      typeName = typeNameOrType;
+    } else {
+      typeName = getName(typeNameOrType);
+    }
+    PreCondition.assertNotEmpty(typeName, "typeName");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.testGroupOrTest(typeName, "type", skip, testAction);
+  }
+  testFunction(functionSignature, skipOrTestAction, testAction) {
+    PreCondition.assertNotEmpty(functionSignature, "functionSignature");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.testGroupOrTest(functionSignature, "function", skip, testAction);
+  }
   testGroup(testGroupName, skipOrTestAction, testAction) {
     PreCondition.assertNotUndefinedAndNotNull(testGroupName, "testGroupName");
     PreCondition.assertNotEmpty(testGroupName, "testGroupName");
@@ -5701,27 +6644,7 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
       skip = skipOrTestAction;
     }
     PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
-    this.assertNoCurrentTest();
-    this.pendingActions.insert(
-      this.pendingActionsInsertIndex,
-      TestAction.create(
-        this.getCurrentTestAction(),
-        testGroupName,
-        skip,
-        async () => {
-          const previousTestActionInsertIndex = this.pendingActionsInsertIndex;
-          this.pendingActionsInsertIndex = this.pendingActions.getCount().await();
-          const currentTestAction = this.getCurrentTestAction();
-          try {
-            await testAction();
-          } catch (error) {
-            await this.afterFailedTest(currentTestAction.getFullNameParts(), error);
-          } finally {
-            this.pendingActionsInsertIndex = previousTestActionInsertIndex;
-          }
-        }
-      )
-    );
+    this.innerTestGroup(testGroupName, "group", skip, testAction);
   }
   test(testName, skipOrTestAction, testAction) {
     PreCondition.assertNotUndefinedAndNotNull(testName, "testName");
@@ -5735,85 +6658,81 @@ var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
       skip = skipOrTestAction;
     }
     PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.innerTest(testName, "test", skip, testAction);
+  }
+  innerTestGroup(testGroupName, type, skip, testGroupAction) {
+    PreCondition.assertNotEmpty(testGroupName, "testGroupName");
+    PreCondition.assertNotUndefinedAndNotNull(testGroupAction, "testGroupAction");
+    this.assertNoCurrentTest();
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      () => this.beforeTestGroup(this.getCurrentTestAction())
+    );
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      async () => {
+        this.resetTestActionInsertIndex();
+        await testGroupAction();
+      }
+    );
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      () => this.afterTestGroup(this.getCurrentTestAction())
+    );
+  }
+  innerTest(testName, testType, skip, testAction) {
+    PreCondition.assertNotEmpty(testName, "testName");
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
     this.assertNoCurrentTest();
-    this.pendingActions.insert(
-      this.pendingActionsInsertIndex,
-      TestAction.create(
-        this.getCurrentTestAction(),
-        testName,
-        skip,
-        async () => {
-          const currentTestAction = this.getCurrentTestAction();
+    this.insertTestAction(
+      testName,
+      testType,
+      skip,
+      async () => {
+        const currentTestAction = this.getCurrentTestAction();
+        await this.beforeTest(currentTestAction);
+        const skip2 = currentTestAction.getSkip();
+        if (skip2?.getShouldSkip()) {
+          await this.afterSkippedTest(currentTestAction, skip2);
+        } else {
+          this.currentTest = this.testCreator.createTest();
           try {
-            await this.beforeTest(currentTestAction.getFullNameParts());
-            if (currentTestAction.shouldSkip()) {
-              await this.afterSkippedTest(currentTestAction.getFullNameParts(), currentTestAction.getSkip());
-            } else {
-              this.currentTest = AssertTest.create(testName);
-              try {
-                await testAction(this.currentTest);
-                await this.afterPassedTest();
-              } finally {
-                this.currentTest = void 0;
-              }
-            }
-          } catch (error) {
-            await this.afterFailedTest(currentTestAction.getFullNameParts(), error);
+            await testAction(this.currentTest);
+          } finally {
+            this.currentTest = void 0;
           }
+          await this.afterPassedTest(currentTestAction);
         }
-      )
+      }
     );
   }
+  testGroupOrTest(name, type, skip, testAction) {
+    if (getParameterCount(testAction) === 0) {
+      this.innerTestGroup(name, type, skip, testAction);
+    } else {
+      this.innerTest(name, type, skip, testAction);
+    }
+  }
   async runAsync() {
-    while (this.pendingActions.any().await()) {
-      this.currentTestAction = this.pendingActions.removeLast().await();
+    while (this.testActions.any().await()) {
+      this.resetTestActionInsertIndex();
+      this.currentTestAction = this.testActions.removeFirst().await();
       try {
-        const result = this.currentTestAction.runAsync();
-        if (isPromise(result)) {
-          await result;
-        }
+        await this.currentTestAction.runAsync();
       } finally {
         this.currentTestAction = void 0;
       }
     }
+    this.resetTestActionInsertIndex();
   }
   printSummary() {
-    return PromiseAsyncResult.create(async () => {
-      await this.writeStream.writeLine();
-      const skippedTests = this.getSkippedTests();
-      if (await skippedTests.any()) {
-        await this.writeStream.writeLine(`Skipped Tests:`);
-        let counter = 0;
-        for (const skippedTest of skippedTests) {
-          await this.writeStream.writeLine(`${++counter}) ${skippedTest.getFullTestName()}`);
-          const skipMessage = skippedTest.getSkipMessage();
-          if (skipMessage) {
-            await this.writeStream.writeLine(`  ${skipMessage}`);
-          }
-        }
-        await this.writeStream.writeLine();
-      }
-      const failedTests = this.getFailedTests();
-      if (await failedTests.any()) {
-        await this.writeStream.writeLine("Failed Tests:");
-        let counter = 0;
-        for (const failedTest of failedTests) {
-          await this.writeStream.writeLine(`${++counter}) ${failedTest.getFullTestName()}`);
-          await this.writeStream.writeLine(`  ${failedTest.getErrorMessage()}`);
-          await this.writeStream.writeLine();
-        }
-      }
-      const passedTestCount = this.getPassedTestCount();
-      if (passedTestCount > 0) {
-        await this.writeStream.writeLine(`Passed:  ${passedTestCount}`);
-      }
-      if (await skippedTests.any()) {
-        await this.writeStream.writeLine(`Skipped: ${skippedTests.getCount().await()}`);
-      }
-      if (await failedTests.any()) {
-        await this.writeStream.writeLine(`Failed:  ${failedTests.getCount().await()}`);
-      }
-    });
+    return this.ui.writeSummary(this.passedTestCount, this.getSkippedTests(), this.getFailedTests());
   }
 };
 // Annotate the CommonJS export names for ESM import in node: