@everyonesoftware/common 6.0.0 → 8.0.0

package/outputs/sourceIndex.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // sources/index.ts
 var sources_exports = {};
 __export(sources_exports, {
+  ANSIStyles: () => ANSIStyles,
   AsyncIterator: () => AsyncIterator,
   AsyncIteratorToJavascriptAsyncIteratorAdapter: () => AsyncIteratorToJavascriptAsyncIteratorAdapter,
   AsyncResult: () => AsyncResult,
@@ -42,6 +43,7 @@ __export(sources_exports, {
   CharacterListStream: () => CharacterListStream,
   CharacterReadStream: () => CharacterReadStream,
   CharacterReadStreamAsyncIterator: () => CharacterReadStreamAsyncIterator,
+  CharacterTable: () => CharacterTable,
   CharacterWriteStream: () => CharacterWriteStream,
   CommandLineParameter: () => CommandLineParameter,
   CommandLineParameters: () => CommandLineParameters,
@@ -71,6 +73,8 @@ __export(sources_exports, {
   HttpOutgoingResponse: () => HttpOutgoingResponse,
   HttpServer: () => HttpServer,
   InMemoryCharacterWriteStream: () => InMemoryCharacterWriteStream,
+  IndentedCharacterWriteStream: () => IndentedCharacterWriteStream,
+  Indexable: () => Indexable,
   Iterable: () => Iterable,
   Iterator: () => Iterator,
   IteratorToJavascriptIteratorAdapter: () => IteratorToJavascriptIteratorAdapter,
@@ -91,6 +95,7 @@ __export(sources_exports, {
   MapIterator: () => MapIterator,
   MutableCondition: () => MutableCondition,
   MutableHttpHeaders: () => MutableHttpHeaders,
+  MutableIndexable: () => MutableIndexable,
   MutableMap: () => MutableMap,
   Network: () => Network,
   Node: () => Node,
@@ -192,6 +197,40 @@ __export(sources_exports, {
 });
 module.exports = __toCommonJS(sources_exports);
 
+// sources/ANSIStyles.ts
+var ANSIStyles = class {
+  constructor() {
+  }
+  static color(colorCode, text) {
+    return `\x1B[${colorCode}m${text}\x1B[0m`;
+  }
+  static black(text) {
+    return this.color(30, text);
+  }
+  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/CharacterTable.ts
+var CharacterTable = class _CharacterTable {
+  constructor() {
+  }
+  static create() {
+    return new _CharacterTable();
+  }
+  // public getRows()
+};
+
 // sources/bytes.ts
 var Bytes = class _Bytes {
   /**
@@ -609,109 +648,6 @@ function isPromise(value) {
   return isPromiseLike(value) && hasFunction(value, "catch", 1) && hasFunction(value, "finally", 1);
 }
 
-// sources/promiseAsyncResult.ts
-var PromiseAsyncResult = class _PromiseAsyncResult {
-  promise;
-  constructor(promise) {
-    PreCondition.assertNotUndefinedAndNotNull(promise, "promise");
-    this.promise = promise;
-  }
-  static create(actionOrPromise) {
-    PreCondition.assertNotUndefinedAndNotNull(actionOrPromise, "action or promise");
-    return new _PromiseAsyncResult(Promise.resolve(isPromise(actionOrPromise) ? actionOrPromise : actionOrPromise()));
-  }
-  static value(value) {
-    return _PromiseAsyncResult.create(Promise.resolve(value));
-  }
-  static error(error) {
-    return _PromiseAsyncResult.create(Promise.reject(error));
-  }
-  static yield() {
-    return _PromiseAsyncResult.create(Promise.resolve());
-  }
-  then(onfulfilled, onrejected) {
-    return _PromiseAsyncResult.create(this.promise.then(onfulfilled, onrejected));
-  }
-  onValue(onValueFunction) {
-    return this.then(async (value) => {
-      let result;
-      try {
-        await onValueFunction(value);
-        result = this;
-      } catch (error) {
-        result = _PromiseAsyncResult.error(error);
-      }
-      return result;
-    });
-  }
-  catch(errorTypeOrOnRejected, onrejected) {
-    let errorType;
-    if (!isUndefinedOrNull(onrejected)) {
-      errorType = errorTypeOrOnRejected;
-      PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-    } else {
-      onrejected = errorTypeOrOnRejected;
-    }
-    return _PromiseAsyncResult.create(this.promise.catch((reason) => {
-      let value;
-      if (errorType && !instanceOfType(reason, errorType)) {
-        throw reason;
-      } else if (!isUndefinedOrNull(onrejected)) {
-        value = onrejected(reason);
-      }
-      return value;
-    }));
-  }
-  onError(errorTypeOrOnErrorFunction, onErrorFunction) {
-    let errorType;
-    if (!isUndefinedOrNull(onErrorFunction)) {
-      errorType = errorTypeOrOnErrorFunction;
-      PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-    } else {
-      onErrorFunction = errorTypeOrOnErrorFunction;
-    }
-    PreCondition.assertNotUndefinedAndNotNull(onErrorFunction, "onErrorFunction");
-    let result;
-    if (errorType) {
-      result = this.catch(errorType, async (reason) => {
-        await onErrorFunction(reason);
-        throw reason;
-      });
-    } else {
-      result = this.catch(async (reason) => {
-        await onErrorFunction(reason);
-        throw reason;
-      });
-    }
-    return result;
-  }
-  convertError(errorTypeOrConvertErrorFunction, convertErrorFunction) {
-    let errorType;
-    if (!isUndefinedOrNull(convertErrorFunction)) {
-      errorType = errorTypeOrConvertErrorFunction;
-      PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-    } else {
-      convertErrorFunction = errorTypeOrConvertErrorFunction;
-    }
-    PreCondition.assertNotUndefinedAndNotNull(convertErrorFunction, "convertErrorFunction");
-    let result;
-    if (errorType) {
-      result = this.catch(errorType, async (reason) => {
-        throw await convertErrorFunction(reason);
-      });
-    } else {
-      result = this.catch(async (reason) => {
-        throw await convertErrorFunction(reason);
-      });
-    }
-    return result;
-  }
-  finally(onfinally) {
-    return _PromiseAsyncResult.create(this.promise.finally(onfinally));
-  }
-  [Symbol.toStringTag] = "AsyncResult";
-};
-
 // sources/syncResult.ts
 var SyncResult = class _SyncResult {
   value;
@@ -1956,6 +1892,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;
@@ -2057,6 +2105,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;
@@ -2907,85 +3046,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);
   }
 };
 
@@ -3342,7 +3481,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);
@@ -3829,7 +3968,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),
@@ -4195,25 +4334,528 @@ var PreCondition = class _PreCondition {
   }
 };
 
-// sources/asyncIteratorToJavascriptAsyncIteratorAdapter.ts
-var AsyncIteratorToJavascriptAsyncIteratorAdapter = class _AsyncIteratorToJavascriptAsyncIteratorAdapter {
-  iterator;
-  hasStarted;
-  constructor(iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    this.iterator = iterator;
-    this.hasStarted = false;
-  }
-  static create(iterator) {
-    return new _AsyncIteratorToJavascriptAsyncIteratorAdapter(iterator);
+// sources/promiseAsyncResult.ts
+var PromiseAsyncResult = class _PromiseAsyncResult {
+  promise;
+  constructor(promise) {
+    PreCondition.assertNotUndefinedAndNotNull(promise, "promise");
+    this.promise = promise;
   }
-  async next() {
-    if (!this.hasStarted) {
-      this.hasStarted = true;
-      await this.iterator.start();
+  static create(actionOrPromise) {
+    PreCondition.assertNotUndefinedAndNotNull(actionOrPromise, "action or promise");
+    let promise;
+    if (isPromise(actionOrPromise)) {
+      promise = actionOrPromise;
     } else {
-      await this.iterator.next();
-    }
+      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));
+  }
+  static error(error) {
+    return _PromiseAsyncResult.create(Promise.reject(error));
+  }
+  static yield() {
+    return _PromiseAsyncResult.create(Promise.resolve());
+  }
+  then(onfulfilled, onrejected) {
+    return _PromiseAsyncResult.create(this.promise.then(onfulfilled, onrejected));
+  }
+  onValue(onValueFunction) {
+    return this.then(async (value) => {
+      let result;
+      try {
+        await onValueFunction(value);
+        result = this;
+      } catch (error) {
+        result = _PromiseAsyncResult.error(error);
+      }
+      return result;
+    });
+  }
+  catch(errorTypeOrOnRejected, onrejected) {
+    let errorType;
+    if (!isUndefinedOrNull(onrejected)) {
+      errorType = errorTypeOrOnRejected;
+      PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+    } else {
+      onrejected = errorTypeOrOnRejected;
+    }
+    return _PromiseAsyncResult.create(this.promise.catch((reason) => {
+      let value;
+      if (errorType && !instanceOfType(reason, errorType)) {
+        throw reason;
+      } else if (!isUndefinedOrNull(onrejected)) {
+        value = onrejected(reason);
+      }
+      return value;
+    }));
+  }
+  onError(errorTypeOrOnErrorFunction, onErrorFunction) {
+    let errorType;
+    if (!isUndefinedOrNull(onErrorFunction)) {
+      errorType = errorTypeOrOnErrorFunction;
+      PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+    } else {
+      onErrorFunction = errorTypeOrOnErrorFunction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(onErrorFunction, "onErrorFunction");
+    let result;
+    if (errorType) {
+      result = this.catch(errorType, async (reason) => {
+        await onErrorFunction(reason);
+        throw reason;
+      });
+    } else {
+      result = this.catch(async (reason) => {
+        await onErrorFunction(reason);
+        throw reason;
+      });
+    }
+    return result;
+  }
+  convertError(errorTypeOrConvertErrorFunction, convertErrorFunction) {
+    let errorType;
+    if (!isUndefinedOrNull(convertErrorFunction)) {
+      errorType = errorTypeOrConvertErrorFunction;
+      PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+    } else {
+      convertErrorFunction = errorTypeOrConvertErrorFunction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(convertErrorFunction, "convertErrorFunction");
+    let result;
+    if (errorType) {
+      result = this.catch(errorType, async (reason) => {
+        throw await convertErrorFunction(reason);
+      });
+    } else {
+      result = this.catch(async (reason) => {
+        throw await convertErrorFunction(reason);
+      });
+    }
+    return result;
+  }
+  finally(onfinally) {
+    return _PromiseAsyncResult.create(this.promise.finally(onfinally));
+  }
+  [Symbol.toStringTag] = "AsyncResult";
+};
+
+// sources/asyncResult.ts
+var AsyncResult = class {
+  static create(actionOrPromise) {
+    return PromiseAsyncResult.create(actionOrPromise);
+  }
+  /**
+   * Get an {@link AsyncResult} that is already completed and doesn't do anything.
+   */
+  static empty() {
+    return PromiseAsyncResult.empty();
+  }
+  /**
+   * Create a new {@link AsyncResult} that contains the provided value.
+   * @param value The value to wrap in a {@link AsyncResult}.
+   */
+  static value(value) {
+    return PromiseAsyncResult.value(value);
+  }
+  /**
+   * Create a new {@link AsyncResult} that contains the provided error.
+   * @param error The error to wrap in a {@link AsyncResult}.
+   */
+  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 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);
+  }
+  /**
+   * Assert that the provided actual value is equal to 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 assertEqual(expected, actual, expression, message) {
+    return _PostCondition.getCondition().assertEqual(expected, actual, expression, message);
+  }
+  /**
+   * Assert that the provided actual value is not equal to the provided expected value.
+   * @param notExpected The not 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 assertNotEqual(notExpected, actual, expression, message) {
+    return _PostCondition.getCondition().assertNotEqual(notExpected, actual, expression, message);
+  }
+  /**
+   * Assert that the provided value is not empty.
+   * @param value The value to check.
+   * @param expression  The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
+   */
+  static assertNotEmpty(value, expression, message) {
+    return _PostCondition.getCondition().assertNotEmpty(value, expression, message);
+  }
+  /**
+   * Assert that the provided value is less than the provided upperBound.
+   * @param value The value to check.
+   * @param upperBound The upperBound that the value must be less than.
+   * @param expression  The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
+   */
+  static assertLessThan(value, upperBound, expression, message) {
+    return _PostCondition.getCondition().assertLessThan(value, upperBound, expression, message);
+  }
+  /**
+   * Assert that the provided value is less than or equal to the provided upperBound.
+   * @param value The value to check.
+   * @param upperBound The upperBound that the value must be less than.
+   * @param expression  The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
+   */
+  static assertLessThanOrEqualTo(value, upperBound, expression, message) {
+    return _PostCondition.getCondition().assertLessThanOrEqualTo(value, upperBound, expression, message);
+  }
+  /**
+   * Assert that the provided value is greater than or equal to the provided lowerBound.
+   * @param value The value to check.
+   * @param lowerBound The lowerBound that the value must be greater than or equal to.
+   * @param expression  The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
+   */
+  static assertGreaterThanOrEqualTo(value, lowerBound, expression, message) {
+    return _PostCondition.getCondition().assertGreaterThanOrEqualTo(value, lowerBound, expression, message);
+  }
+  /**
+   * Assert that the provided value is greater than the provided lowerBound.
+   * @param value The value to check.
+   * @param lowerBound The lowerBound that the value must be greater than.
+   * @param expression  The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
+   */
+  static assertGreaterThan(value, lowerBound, expression, message) {
+    return _PostCondition.getCondition().assertGreaterThan(value, lowerBound, expression, message);
+  }
+  /**
+   * Assert that the value is greater than or equal to the lowerBound and less than or equal to
+   * the upperBound.
+   * @param lowerBound The lowerBound that the value must be greater than or equal to.
+   * @param value The value to check.
+   * @param upperBound The upperBound that the value must be less than or equal to.
+   * @param expression  The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
+   */
+  static assertBetween(lowerBound, value, upperBound, expression, message) {
+    return _PostCondition.getCondition().assertBetween(lowerBound, value, upperBound, expression, message);
+  }
+  /**
+   * Assert that the index is within the access bounds of an indexable with the provided count.
+   * @param index The index to check.
+   * @param count The number of elements in the indexable.
+   * @param expression  The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
+   */
+  static assertAccessIndex(index, count, expression, message) {
+    return _PostCondition.getCondition().assertAccessIndex(index, count, expression, message);
+  }
+  /**
+   * Assert that the index is within the insertion bounds of a {@link List} with the provided count.
+   * @param index The index to check.
+   * @param count The number of elements in the indexable.
+   * @param expression  The expression that produced the actual value.
+   * @param message An optional message that describes the scenario.
+   */
+  static assertInsertIndex(index, count, expression, message) {
+    return _PostCondition.getCondition().assertInsertIndex(index, count, expression, message);
+  }
+  /**
+   * Assert that the value is one of the possibilities.
+   * @param possibilities The possible values that the value can be.
+   * @param value The value to check.
+   * @param expression The expression that produced the value.
+   * @param message An optional error message.
+   */
+  static assertOneOf(possibilities, value, expression, message) {
+    return _PostCondition.getCondition().assertOneOf(possibilities, value, expression, message);
+  }
+  /**
+   * Assert that the value is within the bounds of a byte.
+   * @param value The value to check.
+   * @param expression The expression that produced the value.
+   * @param message An optional error message.
+   */
+  static assertByte(value, expression, message) {
+    return _PostCondition.getCondition().assertByte(value, expression, message);
+  }
+  /**
+   * Assert that the value is an integer.
+   * @param value The value to check.
+   * @param expression The expression that produced the value.
+   * @param message An optional error message.
+   */
+  static assertInteger(value, expression, message) {
+    return _PostCondition.getCondition().assertInteger(value, expression, message);
+  }
+  /**
+   * Assert that the value is a characer (single character string).
+   * @param value The value to check.
+   * @param expression The expression that produced the value.
+   * @param message An optional error message.
+   */
+  static assertCharacter(value, expression, message) {
+    return _PostCondition.getCondition().assertCharacter(value, expression, message);
+  }
+  assertInstanceOf(parametersOrValue, type, typeCheck, expression, message) {
+    return _PostCondition.getCondition().assertInstanceOf(parametersOrValue, type, typeCheck, expression, message);
+  }
+};
+
+// sources/characterWriteStream.ts
+var CharacterWriteStream = class _CharacterWriteStream {
+  /**
+   * Write the provided text (if provided) and then write a newline character sequence to this
+   * {@link CharacterWriteStream}.
+   * @param text The optional text to write before the newline character sequence.
+   * @returns The number of characters that were written.
+   */
+  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;
+    });
+  }
+};
+
+// 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/asyncIteratorToJavascriptAsyncIteratorAdapter.ts
+var AsyncIteratorToJavascriptAsyncIteratorAdapter = class _AsyncIteratorToJavascriptAsyncIteratorAdapter {
+  iterator;
+  hasStarted;
+  constructor(iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    this.iterator = iterator;
+    this.hasStarted = false;
+  }
+  static create(iterator) {
+    return new _AsyncIteratorToJavascriptAsyncIteratorAdapter(iterator);
+  }
+  async next() {
+    if (!this.hasStarted) {
+      this.hasStarted = true;
+      await this.iterator.start();
+    } else {
+      await this.iterator.next();
+    }
     const result = {
       done: !this.iterator.hasCurrent(),
       value: void 0
@@ -4925,30 +5567,6 @@ var AsyncIterator = class _AsyncIterator {
   }
 };
 
-// sources/asyncResult.ts
-var AsyncResult = class {
-  static create(actionOrPromise) {
-    return PromiseAsyncResult.create(isPromise(actionOrPromise) ? actionOrPromise : new Promise(actionOrPromise));
-  }
-  /**
-   * Create a new {@link AsyncResult} that contains the provided value.
-   * @param value The value to wrap in a {@link AsyncResult}.
-   */
-  static value(value) {
-    return PromiseAsyncResult.value(value);
-  }
-  /**
-   * Create a new {@link AsyncResult} that contains the provided error.
-   * @param error The error to wrap in a {@link AsyncResult}.
-   */
-  static error(error) {
-    return PromiseAsyncResult.error(error);
-  }
-  static yield() {
-    return PromiseAsyncResult.yield();
-  }
-};
-
 // sources/basicDisposable.ts
 var SyncDisposable = class _SyncDisposable {
   disposedFunction;
@@ -5372,315 +5990,64 @@ var CharacterList = class _CharacterList {
   first(condition) {
     return List.first(this, condition);
   }
-  last(condition) {
-    return List.last(this, condition);
-  }
-  contains(value, equalFunctions) {
-    return List.contains(this, value, equalFunctions);
-  }
-  [Symbol.iterator]() {
-    return List[Symbol.iterator](this);
-  }
-};
-
-// sources/characterReadStream.ts
-var CharacterReadStream = class _CharacterReadStream {
-  readCharacters(count) {
-    return _CharacterReadStream.readCharacters(this, count);
-  }
-  static readCharacters(readStream, count) {
-    let characters = "";
-    function readUntilCount(countRemaining) {
-      return readStream.readCharacter().then((character) => {
-        characters += character;
-        return countRemaining === 0 ? SyncResult.value(characters) : readUntilCount(countRemaining - 1);
-      });
-    }
-    return readUntilCount(count);
-  }
-  /**
-   * Read characters from this stream until the provided {@link searchString} is found or the end
-   * of the stream is reached. The {@link searchString} will be included in the returned string if
-   * it is found..
-   * @param searchString The string to search for.
-   */
-  readUntil(searchString) {
-    return _CharacterReadStream.readUntil(this, searchString);
-  }
-  static readUntil(readStream, searchString) {
-    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-    PreCondition.assertNotEmpty(searchString, "searchString");
-    let characters = "";
-    function readUntilSearchString() {
-      return readStream.readCharacter().then((character) => {
-        characters += character;
-        return characters.endsWith(searchString) ? SyncResult.value(characters) : readUntilSearchString();
-      });
-    }
-    return readUntilSearchString();
-  }
-  /**
-   * Read a sequence of characters from this stream until either a newline character ('\\n') or
-   * the end of the stream is reached. Terminating newline characters will be included in the
-   * returned string.
-   */
-  readLine() {
-    return _CharacterReadStream.readLine(this);
-  }
-  static readLine(readStream) {
-    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-    return readStream.readUntil("\n");
-  }
-};
-
-// 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);
-  }
-  /**
-   * Assert that the provided actual value is equal to 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 assertEqual(expected, actual, expression, message) {
-    return _PostCondition.getCondition().assertEqual(expected, actual, expression, message);
-  }
-  /**
-   * Assert that the provided actual value is not equal to the provided expected value.
-   * @param notExpected The not 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 assertNotEqual(notExpected, actual, expression, message) {
-    return _PostCondition.getCondition().assertNotEqual(notExpected, actual, expression, message);
-  }
-  /**
-   * Assert that the provided value is not empty.
-   * @param value The value to check.
-   * @param expression  The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertNotEmpty(value, expression, message) {
-    return _PostCondition.getCondition().assertNotEmpty(value, expression, message);
-  }
-  /**
-   * Assert that the provided value is less than the provided upperBound.
-   * @param value The value to check.
-   * @param upperBound The upperBound that the value must be less than.
-   * @param expression  The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertLessThan(value, upperBound, expression, message) {
-    return _PostCondition.getCondition().assertLessThan(value, upperBound, expression, message);
-  }
-  /**
-   * Assert that the provided value is less than or equal to the provided upperBound.
-   * @param value The value to check.
-   * @param upperBound The upperBound that the value must be less than.
-   * @param expression  The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertLessThanOrEqualTo(value, upperBound, expression, message) {
-    return _PostCondition.getCondition().assertLessThanOrEqualTo(value, upperBound, expression, message);
-  }
-  /**
-   * Assert that the provided value is greater than or equal to the provided lowerBound.
-   * @param value The value to check.
-   * @param lowerBound The lowerBound that the value must be greater than or equal to.
-   * @param expression  The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertGreaterThanOrEqualTo(value, lowerBound, expression, message) {
-    return _PostCondition.getCondition().assertGreaterThanOrEqualTo(value, lowerBound, expression, message);
-  }
-  /**
-   * Assert that the provided value is greater than the provided lowerBound.
-   * @param value The value to check.
-   * @param lowerBound The lowerBound that the value must be greater than.
-   * @param expression  The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertGreaterThan(value, lowerBound, expression, message) {
-    return _PostCondition.getCondition().assertGreaterThan(value, lowerBound, expression, message);
-  }
-  /**
-   * Assert that the value is greater than or equal to the lowerBound and less than or equal to
-   * the upperBound.
-   * @param lowerBound The lowerBound that the value must be greater than or equal to.
-   * @param value The value to check.
-   * @param upperBound The upperBound that the value must be less than or equal to.
-   * @param expression  The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertBetween(lowerBound, value, upperBound, expression, message) {
-    return _PostCondition.getCondition().assertBetween(lowerBound, value, upperBound, expression, message);
-  }
-  /**
-   * Assert that the index is within the access bounds of an indexable with the provided count.
-   * @param index The index to check.
-   * @param count The number of elements in the indexable.
-   * @param expression  The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertAccessIndex(index, count, expression, message) {
-    return _PostCondition.getCondition().assertAccessIndex(index, count, expression, message);
+  last(condition) {
+    return List.last(this, condition);
   }
-  /**
-   * Assert that the index is within the insertion bounds of a {@link List} with the provided count.
-   * @param index The index to check.
-   * @param count The number of elements in the indexable.
-   * @param expression  The expression that produced the actual value.
-   * @param message An optional message that describes the scenario.
-   */
-  static assertInsertIndex(index, count, expression, message) {
-    return _PostCondition.getCondition().assertInsertIndex(index, count, expression, message);
+  contains(value, equalFunctions) {
+    return List.contains(this, value, equalFunctions);
   }
-  /**
-   * Assert that the value is one of the possibilities.
-   * @param possibilities The possible values that the value can be.
-   * @param value The value to check.
-   * @param expression The expression that produced the value.
-   * @param message An optional error message.
-   */
-  static assertOneOf(possibilities, value, expression, message) {
-    return _PostCondition.getCondition().assertOneOf(possibilities, value, expression, message);
+  [Symbol.iterator]() {
+    return List[Symbol.iterator](this);
   }
-  /**
-   * Assert that the value is within the bounds of a byte.
-   * @param value The value to check.
-   * @param expression The expression that produced the value.
-   * @param message An optional error message.
-   */
-  static assertByte(value, expression, message) {
-    return _PostCondition.getCondition().assertByte(value, expression, message);
+};
+
+// sources/characterReadStream.ts
+var CharacterReadStream = class _CharacterReadStream {
+  readCharacters(count) {
+    return _CharacterReadStream.readCharacters(this, count);
   }
-  /**
-   * Assert that the value is an integer.
-   * @param value The value to check.
-   * @param expression The expression that produced the value.
-   * @param message An optional error message.
-   */
-  static assertInteger(value, expression, message) {
-    return _PostCondition.getCondition().assertInteger(value, expression, message);
+  static readCharacters(readStream, count) {
+    let characters = "";
+    function readUntilCount(countRemaining) {
+      return readStream.readCharacter().then((character) => {
+        characters += character;
+        return countRemaining === 0 ? SyncResult.value(characters) : readUntilCount(countRemaining - 1);
+      });
+    }
+    return readUntilCount(count);
   }
   /**
-   * Assert that the value is a characer (single character string).
-   * @param value The value to check.
-   * @param expression The expression that produced the value.
-   * @param message An optional error message.
+   * Read characters from this stream until the provided {@link searchString} is found or the end
+   * of the stream is reached. The {@link searchString} will be included in the returned string if
+   * it is found..
+   * @param searchString The string to search for.
    */
-  static assertCharacter(value, expression, message) {
-    return _PostCondition.getCondition().assertCharacter(value, expression, message);
+  readUntil(searchString) {
+    return _CharacterReadStream.readUntil(this, searchString);
   }
-  assertInstanceOf(parametersOrValue, type, typeCheck, expression, message) {
-    return _PostCondition.getCondition().assertInstanceOf(parametersOrValue, type, typeCheck, expression, message);
+  static readUntil(readStream, searchString) {
+    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
+    PreCondition.assertNotEmpty(searchString, "searchString");
+    let characters = "";
+    function readUntilSearchString() {
+      return readStream.readCharacter().then((character) => {
+        characters += character;
+        return characters.endsWith(searchString) ? SyncResult.value(characters) : readUntilSearchString();
+      });
+    }
+    return readUntilSearchString();
   }
-};
-
-// sources/characterWriteStream.ts
-var CharacterWriteStream = class _CharacterWriteStream {
   /**
-   * Write the provided text (if provided) and then write a newline character sequence to this
-   * {@link CharacterWriteStream}.
-   * @param text The optional text to write before the newline character sequence.
-   * @returns The number of characters that were written.
+   * Read a sequence of characters from this stream until either a newline character ('\\n') or
+   * the end of the stream is reached. Terminating newline characters will be included in the
+   * returned string.
    */
-  writeLine(text) {
-    return _CharacterWriteStream.writeLine(this, text);
+  readLine() {
+    return _CharacterReadStream.readLine(this);
   }
-  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 readLine(readStream) {
+    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
+    return readStream.readUntil("\n");
   }
 };
 
@@ -5846,51 +6213,166 @@ var CharacterReadStreamAsyncIterator = class _CharacterReadStreamAsyncIterator {
   }
 };
 
-// sources/commandLineParameter.ts
-var CommandLineParameter = class _CommandLineParameter {
+// 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;
+  }
   /**
-   * The full name of this {@link CommandLineParameter}.
+   * 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;
-  /**
-   * The description for this {@link CommandLineParameter}.
-   */
+  aliases;
   description;
-  /**
-   * The function that can be invoked to get this {@link CommandLineParameter}'s value.
-   */
-  valueGetter;
-  constructor(name, description, valueGetter) {
+  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;
-    this.description = description;
-    this.valueGetter = valueGetter;
   }
-  /**
-   * Create a new {@link CommandLineParameter}.
-   * @param name The full name of the {@link CommandLineParameter}.
-   * @param description The description for the {@link CommandLineParameter}.
-   * @param valueGetter The function that will be used to get the returned
-   * {@link CommandLineParameter}'s value.
-   */
-  static create(name, description, valueGetter) {
-    return new _CommandLineParameter(name, description, valueGetter);
+  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 value for this {@link CommandLineParameter}.
+   * Get the name of this {@link CommandLineParameter}.
    */
-  getValue() {
-    return this.valueGetter();
+  getName() {
+    return this.name;
   }
-};
-
-// sources/commandLineParameters.ts
-var CommandLineParameters = class _CommandLineParameters {
-  args;
-  constructor(argv) {
-    this.args = argv;
+  getAliases() {
+    return this.aliases ?? Iterable.create();
   }
-  static create(args) {
-    return new _CommandLineParameters(args);
+  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;
   }
 };
 
@@ -6818,14 +7300,14 @@ var CurrentProcess = class _CurrentProcess {
   }
   getArguments() {
     if (!this.args) {
-      this.args = process.argv;
+      this.args = Iterable.create(process.argv);
     }
     return this.args;
   }
   setArguments(args) {
     PreCondition.assertNotUndefinedAndNotNull(args, "args");
     PreCondition.assertUndefined(this.parameters, "this.parameters");
-    this.args = args;
+    this.args = isIterable(args) ? args : Iterable.create(args);
     return this;
   }
   getParameters() {
@@ -7038,6 +7520,9 @@ var ListStack = class _ListStack {
   any() {
     return this.list.any();
   }
+  getCount() {
+    return this.list.getCount();
+  }
   add(value) {
     return SyncResult.create(() => {
       this.list.add(value);
@@ -7084,7 +7569,7 @@ var DepthFirstSearch = class _DepthFirstSearch {
   started;
   done;
   constructor(initialToVisit, searchAction) {
-    PreCondition.assertNotEmpty(initialToVisit, "initialToVisit");
+    PreCondition.assertNotUndefinedAndNotNull(initialToVisit, "initialToVisit");
     PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
     this.searchAction = searchAction;
     this.toVisit = Stack.create();
@@ -7226,37 +7711,6 @@ var Disposable = class {
   }
 };
 
-// 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/generator.ts
 var InnerGeneratorControl = class _InnerGeneratorControl {
   returnValues;
@@ -8844,6 +9298,7 @@ var WonderlandTrailClient = class _WonderlandTrailClient {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ANSIStyles,
   AsyncIterator,
   AsyncIteratorToJavascriptAsyncIteratorAdapter,
   AsyncResult,
@@ -8856,6 +9311,7 @@ var WonderlandTrailClient = class _WonderlandTrailClient {
   CharacterListStream,
   CharacterReadStream,
   CharacterReadStreamAsyncIterator,
+  CharacterTable,
   CharacterWriteStream,
   CommandLineParameter,
   CommandLineParameters,
@@ -8885,6 +9341,8 @@ var WonderlandTrailClient = class _WonderlandTrailClient {
   HttpOutgoingResponse,
   HttpServer,
   InMemoryCharacterWriteStream,
+  IndentedCharacterWriteStream,
+  Indexable,
   Iterable,
   Iterator,
   IteratorToJavascriptIteratorAdapter,
@@ -8905,6 +9363,7 @@ var WonderlandTrailClient = class _WonderlandTrailClient {
   MapIterator,
   MutableCondition,
   MutableHttpHeaders,
+  MutableIndexable,
   MutableMap,
   Network,
   Node,