@everyonesoftware/common 5.0.0 → 6.0.0

package/outputs/{chunk-AY3YWKOM.js → chunk-5Z677JON.js}

@@ -4007,3590 +4007,1183 @@ var Condition = class _Condition {
   }
 };
 
-// sources/basicDisposable.ts
-var SyncDisposable = class _SyncDisposable {
-  disposedFunction;
-  disposed;
-  constructor(disposedFunction) {
-    PreCondition.assertNotUndefinedAndNotNull(disposedFunction, "disposedFunction");
-    this.disposedFunction = disposedFunction;
-    this.disposed = false;
-  }
-  /**
-   * Create a new {@link Disposable} that will invoke the provided {@link Function} when it is
-   * disposed.
-   * @param disposedFunction The function to invoke when the returned {@link Disposable} is
-   * disposed.
-   */
-  static create(disposedFunction) {
-    return new _SyncDisposable(disposedFunction);
-  }
-  dispose() {
-    return SyncResult.create(() => {
-      const result = !this.disposed;
-      if (result) {
-        try {
-          this.disposedFunction();
-        } finally {
-          this.disposed = true;
-        }
-      }
-      return result;
-    });
-  }
-  isDisposed() {
-    return this.disposed;
-  }
-};
-
-// sources/byteList.ts
-var ByteList = class _ByteList {
-  bytes;
-  count;
-  constructor() {
-    this.bytes = new Uint8Array(0);
-    this.count = 0;
-  }
-  static create(initialValues) {
-    const result = new _ByteList();
-    if (initialValues) {
-      result.addAll(initialValues);
-    }
-    return result;
-  }
-  add(value) {
-    return List.add(this, value);
-  }
-  addAll(values) {
-    return List.addAll(this, values);
-  }
-  insert(index, value) {
-    PreCondition.assertInsertIndex(index, this.getCount().await(), "index");
-    PreCondition.assertByte(value, "value");
-    if (this.count < this.bytes.length) {
-      if (index < this.count) {
-        this.bytes.copyWithin(index + 1, index, this.count);
-      }
-      this.bytes[index] = value;
-    } else {
-      const newCapacity = this.bytes.length * 2 + 1;
-      const newBytes = new Uint8Array(newCapacity);
-      if (index > 0) {
-        newBytes.set(this.bytes.subarray(0, index));
-      }
-      newBytes[index] = value;
-      if (index < this.count) {
-        newBytes.set(this.bytes.subarray(index), index + 1);
-      }
-      this.bytes = newBytes;
-    }
-    this.count++;
-    return this;
-  }
-  insertAll(index, values) {
-    return List.insertAll(this, index, values);
-  }
-  remove(value, equalFunctions) {
-    PreCondition.assertByte(value, "value");
-    return List.remove(this, value, equalFunctions);
-  }
-  removeAt(index) {
-    PreCondition.assertAccessIndex(index, this.count, "index");
-    const result = this.bytes[index];
-    this.bytes.copyWithin(index, index + 1, this.count);
-    this.count--;
-    return SyncResult.value(result);
-  }
-  removeFirst() {
-    return List.removeFirst(this);
-  }
-  removeLast() {
-    return List.removeLast(this);
-  }
-  set(index, value) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    PreCondition.assertByte(value, "value");
-    this.bytes[index] = value;
-    return this;
-  }
-  iterate() {
-    return Iterator.create(this.bytes[Symbol.iterator]().take(this.count));
-  }
-  get(index) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    return SyncResult.value(this.bytes.at(index));
-  }
-  toArray() {
-    return List.toArray(this);
-  }
-  any() {
-    return this.getCount().then((count) => count > 0);
-  }
-  getCount() {
-    return SyncResult.value(this.count);
-  }
-  equals(right, equalFunctions) {
-    return List.equals(this, right, equalFunctions);
-  }
-  toString(toStringFunctions) {
-    return List.toString(this, toStringFunctions);
-  }
-  concatenate(...toConcatenate) {
-    return List.concatenate(this, ...toConcatenate);
-  }
-  map(mapping) {
-    return List.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return List.flatMap(this, mapping);
-  }
-  where(condition) {
-    return List.where(this, condition);
-  }
-  instanceOf(typeOrTypeCheck) {
-    return List.instanceOf(this, typeOrTypeCheck);
-  }
-  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/byteListStream.ts
-var ByteListStream = class _ByteListStream {
-  list;
-  constructor() {
-    this.list = ByteList.create();
-  }
-  static create(initialValues) {
-    const result = new _ByteListStream();
-    if (initialValues) {
-      result.writeBytes(initialValues).await();
-    }
-    return result;
-  }
-  /**
-   * Get the number of bytes that are available to be read.
-   */
-  getAvailableByteCount() {
-    return this.list.getCount().await();
-  }
-  writeBytes(bytes, startIndex, length) {
-    PreCondition.assertNotUndefinedAndNotNull(bytes, "bytes");
-    if (isArray(bytes)) {
-      bytes = new Uint8Array(bytes);
-    }
-    if (isUndefinedOrNull(startIndex)) {
-      startIndex = 0;
-    }
-    if (isUndefinedOrNull(length)) {
-      length = bytes.length - startIndex;
-    }
-    PreCondition.assertInsertIndex(startIndex, bytes.length, "startIndex");
-    PreCondition.assertBetween(0, length, bytes.length - startIndex, "length");
-    this.list.addAll(bytes.subarray(startIndex, length + startIndex));
-    return SyncResult.value(length);
-  }
-  readBytes(countOrOutput, startIndex, count) {
-    let result;
-    if (isNumber(countOrOutput)) {
-      PreCondition.assertGreaterThanOrEqualTo(countOrOutput, 0, "count");
-      if (!this.list.any().await()) {
-        result = SyncResult.error(new EmptyError());
-      } else {
-        const bytesReadCount = Math.min(countOrOutput, this.list.getCount().await());
-        const output = new Uint8Array(bytesReadCount);
-        for (let i = 0; i < bytesReadCount; i++) {
-          output[i] = this.list.removeFirst().await();
-        }
-        result = SyncResult.value(output);
-      }
-    } else {
-      PreCondition.assertNotUndefinedAndNotNull(countOrOutput, "output");
-      if (isUndefinedOrNull(startIndex)) {
-        startIndex = 0;
-      }
-      if (isUndefinedOrNull(count)) {
-        count = countOrOutput.length - startIndex;
-      }
-      PreCondition.assertInsertIndex(startIndex, countOrOutput.length, "startIndex");
-      PreCondition.assertBetween(0, count, countOrOutput.length - startIndex, "count");
-      if (!this.list.any().await()) {
-        result = SyncResult.error(new EmptyError());
-      } else {
-        const bytesReadCount = Math.min(count, this.list.getCount().await());
-        for (let i = 0; i < bytesReadCount; i++) {
-          countOrOutput[startIndex + i] = this.list.removeFirst().await();
-        }
-        result = SyncResult.value(bytesReadCount);
-      }
-    }
-    return result;
-  }
-};
-
-// sources/stringIterator.ts
-var StringIterator = class _StringIterator {
-  value;
-  currentIndex;
-  started;
-  constructor(value) {
-    this.value = value;
-    this.currentIndex = 0;
-    this.started = false;
-  }
-  static create(value) {
-    PreCondition.assertNotUndefinedAndNotNull(value, "value");
-    return new _StringIterator(value);
-  }
-  getCurrentIndex() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.currentIndex;
-  }
-  next() {
-    return SyncResult.create(() => {
-      if (!this.hasStarted()) {
-        this.started = true;
-      } else if (this.hasCurrent()) {
-        this.currentIndex++;
-      }
-      return this.hasCurrent();
-    });
-  }
-  hasStarted() {
-    return this.started;
-  }
-  hasCurrent() {
-    return this.hasStarted() && this.currentIndex < this.value.length;
-  }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.value[this.currentIndex];
-  }
-  start() {
-    return Iterator.start(this);
-  }
-  takeCurrent() {
-    return Iterator.takeCurrent(this);
-  }
-  any() {
-    return Iterator.any(this);
-  }
-  getCount() {
-    return Iterator.getCount(this);
-  }
-  toArray() {
-    return Iterator.toArray(this);
-  }
-  concatenate(...toConcatenate) {
-    return Iterator.concatenate(this, ...toConcatenate);
-  }
-  map(mapping) {
-    return Iterator.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return Iterator.flatMap(this, mapping);
-  }
-  first() {
-    return Iterator.first(this);
-  }
-  last() {
-    return Iterator.last(this);
-  }
-  where(condition) {
-    return Iterator.where(this, condition);
-  }
-  whereInstanceOf(typeCheck) {
-    return Iterator.whereInstanceOf(this, typeCheck);
-  }
-  whereInstanceOfType(type) {
-    return Iterator.whereInstanceOfType(this, type);
-  }
-  take(maximumToTake) {
-    return Iterator.take(this, maximumToTake);
-  }
-  skip(maximumToSkip) {
-    return Iterator.skip(this, maximumToSkip);
-  }
-  [Symbol.iterator]() {
-    return Iterator[Symbol.iterator](this);
-  }
-};
-
-// sources/characterList.ts
-var CharacterList = class _CharacterList {
-  characters;
-  constructor(values) {
-    if (isString(values)) {
-      this.characters = values;
-    } else if (values) {
-      this.characters = join("", values);
-    } else {
-      this.characters = "";
-    }
-  }
-  static create(values) {
-    return new _CharacterList(values);
-  }
-  getCount() {
-    return SyncResult.value(this.characters.length);
-  }
-  insert(index, value) {
-    PreCondition.assertInsertIndex(index, this.getCount().await(), "index");
-    PreCondition.assertCharacter(value, "value");
-    if (index === 0) {
-      this.characters = value + this.characters;
-    } else if (index === this.getCount().await()) {
-      this.characters += value;
-    } else {
-      this.characters = this.characters.slice(0, index) + value + this.characters.slice(index);
-    }
-    return this;
-  }
-  removeAt(index) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    const result = this.get(index).await();
-    this.characters = (index === 0 ? "" : this.characters.slice(0, index)) + (index === this.getCount().await() - 1 ? "" : this.characters.slice(index + 1));
-    return SyncResult.value(result);
-  }
-  set(index, value) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    PreCondition.assertCharacter(value, "value");
-    this.characters = (index === 0 ? "" : this.characters.slice(0, index)) + value + (index === this.getCount().await() - 1 ? "" : this.characters.slice(index + 1));
-    return this;
-  }
-  iterate() {
-    return StringIterator.create(this.characters);
-  }
-  get(index) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    return SyncResult.value(this.characters.charAt(index));
-  }
-  add(value) {
-    return List.add(this, value);
-  }
-  addAll(values) {
-    return List.addAll(this, values);
-  }
-  insertAll(index, values) {
-    return List.insertAll(this, index, values);
-  }
-  remove(value, equalFunctions) {
-    return List.remove(this, value, equalFunctions);
-  }
-  removeFirst() {
-    return List.removeFirst(this);
-  }
-  removeLast() {
-    return List.removeLast(this);
-  }
-  toArray() {
-    return List.toArray(this);
-  }
-  any() {
-    return List.any(this);
-  }
-  equals(right, equalFunctions) {
-    return List.equals(this, right, equalFunctions);
-  }
-  toString(toStringFunctions) {
-    return List.toString(this, toStringFunctions);
-  }
-  concatenate(...toConcatenate) {
-    return List.concatenate(this, ...toConcatenate);
-  }
-  map(mapping) {
-    return List.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return List.flatMap(this, mapping);
-  }
-  where(condition) {
-    return List.where(this, condition);
-  }
-  instanceOf(typeOrTypeCheck) {
-    return List.instanceOf(this, typeOrTypeCheck);
-  }
-  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);
-  }
-  /**
-   * 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/characterListStream.ts
-var CharacterListStream = class _CharacterListStream {
-  list;
-  constructor() {
-    this.list = CharacterList.create();
-  }
-  static create(initialValues) {
-    const result = new _CharacterListStream();
-    if (initialValues) {
-      result.writeCharacters(initialValues).await();
-    }
-    return result;
-  }
-  writeCharacters(characters, startIndex, length) {
-    PreCondition.assertNotUndefinedAndNotNull(characters, "characters");
-    const characterString = isString(characters) ? characters : join("", characters);
-    if (isUndefinedOrNull(startIndex)) {
-      startIndex = 0;
-    }
-    if (isUndefinedOrNull(length)) {
-      length = characterString.length - startIndex;
-    }
-    PreCondition.assertInsertIndex(startIndex, characterString.length, "startIndex");
-    PreCondition.assertBetween(0, length, characterString.length - startIndex, "length");
-    this.list.addAll(characterString.slice(startIndex, length + startIndex));
-    return SyncResult.value(length);
-  }
-  writeString(text) {
-    this.list.addAll(text);
-    return SyncResult.value(text.length);
-  }
-  writeLine(text) {
-    return CharacterWriteStream.writeLine(this, text);
-  }
-  /**
-   * Get the number of characters that are available to be read.
-   */
-  getAvailableCharacterCount() {
-    return this.list.getCount().await();
-  }
-  readCharacter() {
-    return !this.list.any().await() ? SyncResult.error(new EmptyError()) : SyncResult.value(this.list.removeFirst().await());
-  }
-  readCharacters(countOrOutput, startIndex, count) {
-    let result;
-    if (isNumber(countOrOutput)) {
-      PreCondition.assertGreaterThanOrEqualTo(countOrOutput, 0, "count");
-      if (!this.list.any().await()) {
-        result = SyncResult.error(new EmptyError());
-      } else {
-        const bytesReadCount = Math.min(countOrOutput, this.list.getCount().await());
-        let output = "";
-        for (let i = 0; i < bytesReadCount; i++) {
-          output += this.list.removeFirst().await();
-        }
-        result = SyncResult.value(output);
-      }
-    } else {
-      PreCondition.assertNotUndefinedAndNotNull(countOrOutput, "output");
-      if (isUndefinedOrNull(startIndex)) {
-        startIndex = 0;
-      }
-      if (isUndefinedOrNull(count)) {
-        count = countOrOutput.length - startIndex;
-      }
-      PreCondition.assertInsertIndex(startIndex, countOrOutput.length, "startIndex");
-      PreCondition.assertBetween(0, count, countOrOutput.length - startIndex, "count");
-      if (!this.list.any().await()) {
-        result = SyncResult.error(new EmptyError());
-      } else {
-        const bytesReadCount = Math.min(count, this.list.getCount().await());
-        for (let i = 0; i < bytesReadCount; i++) {
-          countOrOutput[startIndex + i] = this.list.removeFirst().await();
-        }
-        result = SyncResult.value(bytesReadCount);
-      }
-    }
-    return result;
-  }
-  readUntil(searchString) {
-    return CharacterReadStream.readUntil(this, searchString);
-  }
-  readLine() {
-    return CharacterReadStream.readLine(this);
-  }
-};
-
-// sources/commandLineParameters.ts
-var CommandLineParameters = class _CommandLineParameters {
-  args;
-  constructor(argv) {
-    this.args = argv;
-  }
-  static create(args) {
-    return new _CommandLineParameters(args);
-  }
-};
-
-// sources/nodeJSCharacterWriteStream.ts
-var NodeJSCharacterWriteStream = class _NodeJSCharacterWriteStream extends CharacterWriteStream {
-  nodeJSWriteStream;
-  constructor(nodeJSWriteStream) {
-    PreCondition.assertNotUndefinedAndNotNull(nodeJSWriteStream, "nodeJSWriteStream");
-    super();
-    this.nodeJSWriteStream = nodeJSWriteStream;
-  }
-  static create(nodeJSWriteStream) {
-    return new _NodeJSCharacterWriteStream(nodeJSWriteStream);
-  }
-  writeString(text) {
-    PreCondition.assertNotUndefinedAndNotNull(text, "text");
-    return PromiseAsyncResult.create(new Promise((resolve, reject) => {
-      this.nodeJSWriteStream.write(text, (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(text.length);
-        }
-      });
-    }));
-  }
-};
-
-// sources/property.ts
-var Property = class _Property {
-  getter;
-  setter;
-  constructor(getter, setter) {
-    PreCondition.assertNotUndefinedAndNotNull(getter, "getter");
-    PreCondition.assertNotUndefinedAndNotNull(setter, "setter");
-    this.getter = getter;
-    this.setter = setter;
-  }
-  static create(getterOptionsOrInitialValue, setter) {
-    let getter;
-    if (isFunction(getterOptionsOrInitialValue)) {
-      getter = getterOptionsOrInitialValue;
-    } else if (isObject(getterOptionsOrInitialValue) && hasProperty(getterOptionsOrInitialValue, "getter") && hasProperty(getterOptionsOrInitialValue, "setter")) {
-      const options = getterOptionsOrInitialValue;
-      getter = options.getter;
-      setter = options.setter;
-    } else {
-      let initialValue = getterOptionsOrInitialValue;
-      getter = () => {
-        return initialValue;
-      };
-      setter = (value) => {
-        initialValue = value;
-      };
-    }
-    PreCondition.assertNotUndefinedAndNotNull(getter, "getter");
-    PreCondition.assertNotUndefinedAndNotNull(setter, "setter");
-    return new _Property(getter, setter);
-  }
-  getValue() {
-    return this.getter();
-  }
-  setValue(value) {
-    this.setter(value);
-    return this;
-  }
-  toString() {
-    return `${this.getValue()}`;
-  }
-};
-
-// sources/httpHeader.ts
-var HttpHeader = class _HttpHeader {
-  name;
-  value;
-  constructor(name, value) {
-    PreCondition.assertNotEmpty(name, "name");
-    PreCondition.assertNotUndefinedAndNotNull(value, "value");
-    this.name = name;
-    this.value = value;
-  }
-  static create(name, value) {
-    return new _HttpHeader(name, value);
-  }
-  getName() {
-    return this.name;
-  }
-  getValue() {
-    return this.value;
-  }
-  toString() {
-    return `${escapeAndQuote(this.name)}:${escapeAndQuote(this.value)}`;
-  }
-};
-
-// 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/mutableHttpHeaders.ts
-var MutableHttpHeaders = class _MutableHttpHeaders {
-  headers;
-  constructor(headers) {
-    this.headers = List.create();
-    if (headers) {
-      this.setAll(headers);
-    }
-  }
-  static create(headers) {
-    return new _MutableHttpHeaders(headers);
-  }
-  iterate() {
-    return this.headers.iterate();
-  }
-  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/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.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;
-    });
-  }
-  getHeaderValue(headerName) {
-    PreCondition.assertNotEmpty(headerName, "headerName");
-    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)}.`);
-      }
-      return result;
-    });
-  }
-  getBody() {
-    return PromiseAsyncResult.create(this.response.text());
-  }
-};
-
-// sources/httpMethod.ts
-var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
-  HttpMethod2[HttpMethod2["GET"] = 0] = "GET";
-  HttpMethod2[HttpMethod2["HEAD"] = 1] = "HEAD";
-  HttpMethod2[HttpMethod2["POST"] = 2] = "POST";
-  HttpMethod2[HttpMethod2["PUT"] = 3] = "PUT";
-  HttpMethod2[HttpMethod2["DELETE"] = 4] = "DELETE";
-  HttpMethod2[HttpMethod2["CONNECT"] = 5] = "CONNECT";
-  HttpMethod2[HttpMethod2["OPTIONS"] = 6] = "OPTIONS";
-  HttpMethod2[HttpMethod2["TRACE"] = 7] = "TRACE";
-  HttpMethod2[HttpMethod2["PATCH"] = 8] = "PATCH";
-  return HttpMethod2;
-})(HttpMethod || {});
-function parseHttpMethod(text) {
-  return SyncResult.create(() => {
-    let result;
-    switch (text.toUpperCase()) {
-      case "GET":
-        result = 0 /* GET */;
-        break;
-      case "HEAD":
-        result = 1 /* HEAD */;
-        break;
-      case "POST":
-        result = 2 /* POST */;
-        break;
-      case "PUT":
-        result = 3 /* PUT */;
-        break;
-      case "DELETE":
-        result = 4 /* DELETE */;
-        break;
-      case "CONNECT":
-        result = 5 /* CONNECT */;
-        break;
-      case "OPTIONS":
-        result = 6 /* OPTIONS */;
-        break;
-      case "TRACE":
-        result = 7 /* TRACE */;
-        break;
-      case "PATCH":
-        result = 8 /* PATCH */;
-        break;
-      default:
-        throw new NotFoundError(`No HttpMethod exists for the text "${text}".`);
-    }
-    return result;
-  });
-}
-function httpMethodToString(httpMethod) {
-  PreCondition.assertNotUndefinedAndNotNull(httpMethod, "httpMethod");
-  let result;
-  switch (httpMethod) {
-    case 0 /* GET */:
-      result = "GET";
-      break;
-    case 1 /* HEAD */:
-      result = "HEAD";
-      break;
-    case 2 /* POST */:
-      result = "POST";
-      break;
-    case 3 /* PUT */:
-      result = "PUT";
-      break;
-    case 4 /* DELETE */:
-      result = "DELETE";
-      break;
-    case 5 /* CONNECT */:
-      result = "CONNECT";
-      break;
-    case 6 /* OPTIONS */:
-      result = "OPTIONS";
-      break;
-    case 7 /* TRACE */:
-      result = "TRACE";
-      break;
-    case 8 /* PATCH */:
-      result = "PATCH";
-      break;
-    default:
-      throw new NotFoundError(`Unrecognized HttpMethod: ${httpMethod}`);
-  }
-  return result;
-}
-
-// 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 = "";
-  }
-  static create(method, url) {
-    return new _HttpOutgoingRequest(method, url);
-  }
-  /**
-   * 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);
-  }
-  /**
-   * Get the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
-   */
-  getMethod() {
-    return this.method;
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Get this {@link HttpOutgoingRequest}'s target URL.
-   */
-  getURL() {
-    return this.url;
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Get the {@link HttpHeaders} that will be sent.
-   */
-  getHeaders() {
-    return this.headers;
-  }
-  getHeader(headerName) {
-    return this.headers.get(headerName);
-  }
-  getHeaderValue(headerName) {
-    return this.headers.getValue(headerName);
-  }
-  /**
-   * Get the body that will be sent.
-   */
-  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;
+// sources/postConditionError.ts
+var PostConditionError = class extends Error {
+  constructor(...message) {
+    super(join("\n", message));
   }
 };
 
-// sources/network.ts
-var Network = class {
-};
-
-// 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();
+// 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;
   }
   /**
-   * Get the status code of this {@link HttpOutgoingResponse}.
+   * 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.
    */
-  getStatusCode() {
-    return this.statusCode;
+  static assertUndefined(value, expression, message) {
+    return _PostCondition.getCondition().assertUndefined(value, expression, message);
   }
   /**
-   * Set the status code of this {@link HttpOutgoingResponse}.
-   * @param statusCode The status code of this {@link HttpOutgoingResponse}.
+   * 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.
    */
-  setStatusCode(statusCode) {
-    PreCondition.assertBetween(100, statusCode, 599, "statusCode");
-    this.statusCode = statusCode;
-    return this;
+  static assertNotUndefined(value, expression, message) {
+    return _PostCondition.getCondition().assertNotUndefined(value, expression, message);
   }
-  getHeaders() {
-    return this.headers;
+  /**
+   * 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);
   }
   /**
-   * 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 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.
    */
-  getHeader(headerName) {
-    return this.headers.get(headerName);
+  static assertTrue(value, expression, message) {
+    return _PostCondition.getCondition().assertTrue(value, expression, message);
   }
   /**
-   * 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 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.
    */
-  getHeaderValue(headerName) {
-    return this.headers.getValue(headerName);
+  static assertFalse(value, expression, message) {
+    return _PostCondition.getCondition().assertFalse(value, expression, message);
   }
   /**
-   * 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 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.
    */
-  setHeader(headerName, headerValue) {
-    this.headers.set(headerName, headerValue);
-    return this;
+  static assertSame(expected, actual, expression, message) {
+    return _PostCondition.getCondition().assertSame(expected, actual, expression, message);
   }
-  setContentTypeHeader(contentType) {
-    this.headers.setContentType(contentType);
-    return this;
+  /**
+   * 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);
   }
   /**
-   * Get the body of this {@link HttpOutgoingResponse}.
+   * 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.
    */
-  getBody() {
-    return this.body;
+  static assertEqual(expected, actual, expression, message) {
+    return _PostCondition.getCondition().assertEqual(expected, actual, expression, message);
   }
   /**
-   * Set the body of this {@link HttpOutgoingResponse}.
-   * @param body The body for this {@link HttpOutgoingResponse}.
+   * 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.
    */
-  setBody(body) {
-    PreCondition.assertNotUndefinedAndNotNull(body, "body");
-    this.body = body;
-    return this;
+  static assertNotEqual(notExpected, actual, expression, message) {
+    return _PostCondition.getCondition().assertNotEqual(notExpected, actual, expression, message);
   }
-};
-
-// sources/nodeJSHttpServer.ts
-import * as http from "http";
-var NodeJSHttpServer = class _NodeJSHttpServer extends HttpServer {
-  httpServer;
-  disposed;
-  constructor() {
-    super();
-    this.disposed = false;
+  /**
+   * 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);
   }
-  static create() {
-    return new _NodeJSHttpServer();
+  /**
+   * 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);
   }
-  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);
-          }
-        });
-      }
-    }));
+  /**
+   * 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);
   }
-  isDisposed() {
-    return this.disposed;
+  /**
+   * 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);
   }
-  isStarted() {
-    return !!this.httpServer;
+  /**
+   * 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);
   }
-  addRequestHandler(requestPath, handler) {
-    throw new Error("Method not implemented.");
+  /**
+   * 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);
   }
-  setDefaultRequestHandler(handler) {
-    throw new Error("Method not implemented.");
+  /**
+   * 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);
   }
-  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);
-      }
-    }));
+  /**
+   * 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);
   }
-};
-
-// sources/realNetwork.ts
-var RealNetwork = class _RealNetwork extends Network {
-  constructor() {
-    super();
+  /**
+   * 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);
   }
-  static create() {
-    return new _RealNetwork();
+  /**
+   * 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);
   }
-  createHttpServer() {
-    return NodeJSHttpServer.create();
+  /**
+   * 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);
   }
-  createHttpClient() {
-    return FetchHttpClient.create();
+  /**
+   * 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/currentProcess.ts
-var CurrentProcess = class _CurrentProcess {
-  args;
-  parameters;
-  outputWriteStream;
-  exitCodeProperty;
-  network;
-  constructor() {
-  }
-  static create() {
-    return new _CurrentProcess();
+// 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 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 writeLine(writeStream, text) {
+    PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
+    return PromiseAsyncResult.create(async () => {
+      let result = 0;
+      if (text) {
+        result += await writeStream.writeString(text);
       }
-    }
-  }
-  getArguments() {
-    if (!this.args) {
-      this.args = process.argv;
-    }
-    return this.args;
-  }
-  setArguments(args) {
-    PreCondition.assertNotUndefinedAndNotNull(args, "args");
-    PreCondition.assertUndefined(this.parameters, "this.parameters");
-    this.args = args;
-    return this;
-  }
-  getParameters() {
-    if (!this.parameters) {
-      this.parameters = CommandLineParameters.create(this.getArguments());
-    }
-    return this.parameters;
+      result += await writeStream.writeString("\n");
+      PostCondition.assertGreaterThan(result, 0, "result");
+      return result;
+    });
   }
-  getOutputWriteStream() {
-    if (!this.outputWriteStream) {
-      this.outputWriteStream = NodeJSCharacterWriteStream.create(process.stdout);
-    }
-    return this.outputWriteStream;
+};
+
+// sources/commandLineParameters.ts
+var CommandLineParameters = class _CommandLineParameters {
+  args;
+  constructor(argv) {
+    this.args = argv;
   }
-  setOutputWriteStream(outputWriteStream) {
-    PreCondition.assertNotUndefinedAndNotNull(outputWriteStream, "outputWriteStream");
-    this.outputWriteStream = outputWriteStream;
-    return this;
+  static create(args) {
+    return new _CommandLineParameters(args);
   }
-  getExitCode() {
-    return this.getExitCodeProperty().getValue();
+};
+
+// sources/nodeJSCharacterWriteStream.ts
+var NodeJSCharacterWriteStream = class _NodeJSCharacterWriteStream extends CharacterWriteStream {
+  nodeJSWriteStream;
+  constructor(nodeJSWriteStream) {
+    PreCondition.assertNotUndefinedAndNotNull(nodeJSWriteStream, "nodeJSWriteStream");
+    super();
+    this.nodeJSWriteStream = nodeJSWriteStream;
   }
-  setExitCode(exitCode) {
-    PreCondition.assertNotUndefinedAndNotNull(exitCode, "exitCode");
-    this.getExitCodeProperty().setValue(exitCode);
-    return this;
+  static create(nodeJSWriteStream) {
+    return new _NodeJSCharacterWriteStream(nodeJSWriteStream);
   }
-  getExitCodeProperty() {
-    if (!this.exitCodeProperty) {
-      this.exitCodeProperty = Property.create({
-        getter: () => process.exitCode,
-        setter: (value) => {
-          process.exitCode = value;
+  writeString(text) {
+    PreCondition.assertNotUndefinedAndNotNull(text, "text");
+    return PromiseAsyncResult.create(new Promise((resolve, reject) => {
+      this.nodeJSWriteStream.write(text, (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(text.length);
         }
       });
-    }
-    return this.exitCodeProperty;
+    }));
   }
-  setExitCodeProperty(exitCodeProperty) {
-    PreCondition.assertNotUndefinedAndNotNull(exitCodeProperty, "exitCodeProperty");
-    this.exitCodeProperty = exitCodeProperty;
-    return this;
+};
+
+// sources/property.ts
+var Property = class _Property {
+  getter;
+  setter;
+  constructor(getter, setter) {
+    PreCondition.assertNotUndefinedAndNotNull(getter, "getter");
+    PreCondition.assertNotUndefinedAndNotNull(setter, "setter");
+    this.getter = getter;
+    this.setter = setter;
   }
-  getNetwork() {
-    if (!this.network) {
-      this.network = RealNetwork.create();
+  static create(getterOptionsOrInitialValue, setter) {
+    let getter;
+    if (isFunction(getterOptionsOrInitialValue)) {
+      getter = getterOptionsOrInitialValue;
+    } else if (isObject(getterOptionsOrInitialValue) && hasProperty(getterOptionsOrInitialValue, "getter") && hasProperty(getterOptionsOrInitialValue, "setter")) {
+      const options = getterOptionsOrInitialValue;
+      getter = options.getter;
+      setter = options.setter;
+    } else {
+      let initialValue = getterOptionsOrInitialValue;
+      getter = () => {
+        return initialValue;
+      };
+      setter = (value) => {
+        initialValue = value;
+      };
     }
-    return this.network;
+    PreCondition.assertNotUndefinedAndNotNull(getter, "getter");
+    PreCondition.assertNotUndefinedAndNotNull(setter, "setter");
+    return new _Property(getter, setter);
   }
-  setNetwork(network) {
-    PreCondition.assertUndefined(this.network, "this.network");
-    PreCondition.assertNotUndefinedAndNotNull(network, "network");
-    this.network = network;
+  getValue() {
+    return this.getter();
+  }
+  setValue(value) {
+    this.setter(value);
     return this;
   }
+  toString() {
+    return `${this.getValue()}`;
+  }
 };
 
-// sources/luxonDateTime.ts
-import * as luxon from "luxon";
-
-// sources/dateTime.ts
-var DateTime = class _DateTime {
-  static parse(text) {
-    return LuxonDateTime.parse(text);
-  }
-  static now() {
-    return LuxonDateTime.now();
-  }
-  /**
-   * Compare this {@link DateTime} to the provided {@link DateTime}. If this {@link DateTime} is
-   * less than the provided {@link DateTime}, then a negative number will be returned, 0 if
-   * they're equal, or a positive number if this {@link DateTime} is greater than the provided
-   * {@link DateTime}.
-   * @param dateTime The {@link DateTime} to compare to this {@link DateTime}.
-   */
-  compareTo(dateTime, compareTimes) {
-    return _DateTime.compareTo(this, dateTime, compareTimes);
-  }
-  static compareTo(left, right, compareTimes) {
-    let result = left.getYear() - right.getYear();
-    if (result === 0) {
-      result = left.getMonth() - right.getMonth();
-      if (result === 0) {
-        result = left.getDay() - right.getDay();
-        if (compareTimes && result === 0) {
-          result = left.getHour() - right.getHour();
-          if (result === 0) {
-            result = left.getMinute() - right.getMinute();
-            if (result === 0) {
-              result = left.getSecond();
-              -right.getSecond();
-            }
-          }
-        }
-      }
-    }
-    return result;
-  }
-  lessThan(dateTime, compareTimes) {
-    return _DateTime.lessThan(this, dateTime, compareTimes);
+// sources/httpHeader.ts
+var HttpHeader = class _HttpHeader {
+  name;
+  value;
+  constructor(name, value) {
+    PreCondition.assertNotEmpty(name, "name");
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
+    this.name = name;
+    this.value = value;
   }
-  static lessThan(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) < 0;
+  static create(name, value) {
+    return new _HttpHeader(name, value);
   }
-  lessThanOrEqualTo(dateTime, compareTimes) {
-    return _DateTime.lessThanOrEqualTo(this, dateTime, compareTimes);
+  getName() {
+    return this.name;
   }
-  static lessThanOrEqualTo(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) <= 0;
+  getValue() {
+    return this.value;
   }
-  equals(dateTime, compareTimes) {
-    return _DateTime.equals(this, dateTime, compareTimes);
+  toString() {
+    return `${escapeAndQuote(this.name)}:${escapeAndQuote(this.value)}`;
   }
-  static equals(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) === 0;
+};
+
+// sources/httpHeaders.ts
+var HttpHeaders = class _HttpHeaders {
+  static contentTypeHeaderName = "Content-Type";
+  static create(headers) {
+    return MutableHttpHeaders.create(headers);
   }
-  greaterThanOrEqualTo(dateTime, compareTimes) {
-    return _DateTime.greaterThanOrEqualTo(this, dateTime, compareTimes);
+  getContentType() {
+    return _HttpHeaders.getContentType(this);
   }
-  static greaterThanOrEqualTo(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) >= 0;
+  static getContentType(headers) {
+    return headers.get(_HttpHeaders.contentTypeHeaderName);
   }
-  greaterThan(dateTime, compareTimes) {
-    return _DateTime.greaterThan(this, dateTime, compareTimes);
+  getContentTypeValue() {
+    return _HttpHeaders.getContentTypeValue(this);
   }
-  static greaterThan(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) > 0;
+  static getContentTypeValue(headers) {
+    return headers.getValue(_HttpHeaders.contentTypeHeaderName);
   }
-  get debug() {
-    return _DateTime.debug(this);
+  /**
+   * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
+   */
+  toArray() {
+    return _HttpHeaders.toArray(this);
   }
-  static debug(dateTime) {
-    return dateTime.toString();
+  static toArray(headers) {
+    return Iterable.toArray(headers);
   }
-};
-
-// sources/luxonDateTime.ts
-var pctTimeZone = "America/Los_Angeles";
-var LuxonDateTime = class _LuxonDateTime {
-  dateTime;
-  constructor(dateTime) {
-    this.dateTime = dateTime;
+  any() {
+    return _HttpHeaders.any(this);
   }
-  static create(dateTime) {
-    return new _LuxonDateTime(dateTime);
+  static any(headers) {
+    return Iterable.any(headers);
   }
-  static parse(text) {
-    return _LuxonDateTime.create(luxon.DateTime.fromISO(text, { zone: pctTimeZone }));
+  getCount() {
+    return _HttpHeaders.getCount(this);
   }
-  static now() {
-    return _LuxonDateTime.create(luxon.DateTime.now().setZone(pctTimeZone));
+  static getCount(headers) {
+    return Iterable.getCount(headers);
   }
-  getYear() {
-    return this.dateTime.year;
+  equals(right, equalFunctions) {
+    return _HttpHeaders.equals(this, right, equalFunctions);
   }
-  getMonth() {
-    return this.dateTime.month;
+  static equals(headers, right, equalFunctions) {
+    return Iterable.equals(headers, right, equalFunctions);
   }
-  getDay() {
-    return this.dateTime.day;
+  toString(toStringFunctions) {
+    return _HttpHeaders.toString(this, toStringFunctions);
   }
-  getHour() {
-    return this.dateTime.hour;
+  static toString(headers, toStringFunctions) {
+    return Iterable.toString(headers, toStringFunctions);
   }
-  getMinute() {
-    return this.dateTime.minute;
+  concatenate(...toConcatenate) {
+    return _HttpHeaders.concatenate(this, ...toConcatenate);
   }
-  getSecond() {
-    return this.dateTime.second;
+  static concatenate(headers, ...toConcatenate) {
+    return Iterable.concatenate(headers, ...toConcatenate);
   }
-  addDays(days) {
-    return _LuxonDateTime.create(this.dateTime.plus({ days }));
+  map(mapping) {
+    return _HttpHeaders.map(this, mapping);
   }
-  toString() {
-    return this.dateTime.toISO();
+  static map(headers, mapping) {
+    return Iterable.map(headers, mapping);
   }
-  toDateString() {
-    return this.dateTime.toISODate();
+  flatMap(mapping) {
+    return _HttpHeaders.flatMap(this, mapping);
   }
-  compareTo(dateTime, compareTimes) {
-    return DateTime.compareTo(this, dateTime, compareTimes);
+  static flatMap(headers, mapping) {
+    return Iterable.flatMap(headers, mapping);
   }
-  lessThan(dateTime, compareTimes) {
-    return DateTime.lessThan(this, dateTime, compareTimes);
+  where(condition) {
+    return _HttpHeaders.where(this, condition);
   }
-  lessThanOrEqualTo(dateTime, compareTimes) {
-    return DateTime.lessThanOrEqualTo(this, dateTime, compareTimes);
+  static where(headers, condition) {
+    return Iterable.where(headers, condition);
   }
-  equals(dateTime, compareTimes) {
-    return DateTime.equals(this, dateTime, compareTimes);
+  instanceOf(typeOrTypeCheck) {
+    return _HttpHeaders.instanceOf(this, typeOrTypeCheck);
   }
-  greaterThanOrEqualTo(dateTime, compareTimes) {
-    return DateTime.greaterThanOrEqualTo(this, dateTime, compareTimes);
+  static instanceOf(headers, typeOrTypeCheck) {
+    return Iterable.instanceOf(headers, typeOrTypeCheck);
   }
-  greaterThan(dateTime, compareTimes) {
-    return DateTime.greaterThan(this, dateTime, compareTimes);
+  first(condition) {
+    return _HttpHeaders.first(this, condition);
   }
-  get debug() {
-    return DateTime.debug(this);
+  static first(headers, condition) {
+    return Iterable.first(headers, condition);
   }
-};
-
-// sources/listStack.ts
-var ListStack = class _ListStack {
-  list;
-  constructor(list2) {
-    this.list = list2 ?? List.create();
+  last(condition) {
+    return _HttpHeaders.last(this, condition);
   }
-  static create(list2) {
-    return new _ListStack(list2);
+  static last(headers, condition) {
+    return Iterable.last(headers, condition);
   }
-  any() {
-    return this.list.any();
+  [Symbol.iterator]() {
+    return _HttpHeaders[Symbol.iterator](this);
   }
-  add(value) {
-    return SyncResult.create(() => {
-      this.list.add(value);
-    });
+  static [Symbol.iterator](headers) {
+    return Iterable[Symbol.iterator](headers);
   }
-  addAll(values) {
-    PreCondition.assertNotUndefinedAndNotNull(values, "values");
-    return SyncResult.create(() => {
-      this.list.addAll(values);
-    });
+  contains(value, equalFunctions) {
+    return _HttpHeaders.contains(this, value, equalFunctions);
   }
-  remove() {
+  static contains(headers, value, equalFunctions) {
     return SyncResult.create(() => {
-      if (!this.any().await()) {
-        throw new EmptyError();
+      if (!equalFunctions) {
+        equalFunctions = EqualFunctions.create();
       }
-      return this.list.removeLast().await();
+      return headers.getValue(value.getName()).then((headerValue) => equalFunctions.areEqual(headerValue, value.getValue()).await()).catch(NotFoundError, () => false).await();
     });
   }
-  contains(value, equalFunctions) {
-    return this.list.contains(value, equalFunctions);
-  }
-};
-
-// 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();
-  }
 };
 
-// sources/depthFirstSearch.ts
-var SearchBreakError = class extends Error {
-};
-var DepthFirstSearch = class _DepthFirstSearch {
-  searchAction;
-  toVisit;
-  visited;
-  results;
-  started;
-  done;
-  constructor(initialToVisit, searchAction) {
-    PreCondition.assertNotEmpty(initialToVisit, "initialToVisit");
-    PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
-    this.searchAction = searchAction;
-    this.toVisit = Stack.create();
-    this.toVisit.addAll(initialToVisit).await();
-    this.visited = Set2.create();
-    this.results = List.create();
-    this.started = false;
-    this.done = false;
-  }
-  static create(initialToVisit, searchAction) {
-    return new _DepthFirstSearch(initialToVisit, searchAction);
-  }
-  addToVisit(toVisit) {
-    if (!this.hasVisited(toVisit)) {
-      this.toVisit.add(toVisit);
-    }
-  }
-  addAllToVisit(values) {
-    for (const value of values) {
-      this.addToVisit(value);
+// sources/mutableHttpHeaders.ts
+var MutableHttpHeaders = class _MutableHttpHeaders {
+  headers;
+  constructor(headers) {
+    this.headers = List.create();
+    if (headers) {
+      this.setAll(headers);
     }
   }
-  hasVisited(toVisit) {
-    return this.visited.contains(toVisit).await();
-  }
-  addResult(result) {
-    this.results.add(result);
-  }
-  addResults(results) {
-    this.results.addAll(results);
+  static create(headers) {
+    return new _MutableHttpHeaders(headers);
   }
-  break() {
-    throw new SearchBreakError();
+  iterate() {
+    return this.headers.iterate();
   }
-  next() {
+  get(headerName) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
     return SyncResult.create(() => {
-      let result = false;
-      if (!this.done) {
-        if (!this.started) {
-          this.started = true;
-        } else {
-          this.results.removeFirst().await();
-        }
-        while (!this.hasCurrent() && this.toVisit.any().await()) {
-          const current = this.toVisit.remove().await();
-          this.visited.add(current);
-          this.searchAction(this, current);
+      let result;
+      const lowerHeaderName = headerName.toLowerCase();
+      for (const header of this.headers) {
+        if (header.getName().toLowerCase() === lowerHeaderName) {
+          result = header;
+          break;
         }
-        result = this.hasCurrent();
-        this.done = !result;
+      }
+      if (result === void 0) {
+        throw new NotFoundError(`No HttpHeader found with the name ${escapeAndQuote(headerName)}.`);
       }
       return result;
     });
   }
-  hasStarted() {
-    return this.started;
+  getValue(headerName) {
+    return this.get(headerName).then((header) => header.getValue());
   }
-  hasCurrent() {
-    return this.results.any().await();
+  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;
   }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.results.first().await();
+  setAll(headers) {
+    PreCondition.assertNotUndefinedAndNotNull(headers, "headers");
+    for (const header of headers) {
+      this.set(header);
+    }
+    return this;
   }
-  start() {
-    return Iterator.start(this);
+  setContentType(contentType) {
+    return this.set(HttpHeaders.contentTypeHeaderName, contentType);
   }
-  takeCurrent() {
-    return Iterator.takeCurrent(this);
+  getContentType() {
+    return this.get(HttpHeaders.contentTypeHeaderName);
   }
-  any() {
-    return Iterator.any(this);
+  getContentTypeValue() {
+    return this.getValue(HttpHeaders.contentTypeHeaderName);
   }
   getCount() {
-    return Iterator.getCount(this);
+    return this.headers.getCount();
   }
   toArray() {
-    return Iterator.toArray(this);
-  }
-  concatenate(...toConcatenate) {
-    return Iterator.concatenate(this, ...toConcatenate);
-  }
-  where(condition) {
-    return Iterator.where(this, condition);
-  }
-  map(mapping) {
-    return Iterator.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return Iterator.flatMap(this, mapping);
-  }
-  whereInstanceOf(typeCheck) {
-    return Iterator.whereInstanceOf(this, typeCheck);
-  }
-  whereInstanceOfType(type) {
-    return Iterator.whereInstanceOfType(this, type);
-  }
-  first(condition) {
-    return Iterator.first(this, condition);
-  }
-  last(condition) {
-    return Iterator.last(this, condition);
-  }
-  take(maximumToTake) {
-    return Iterator.take(this, maximumToTake);
-  }
-  skip(maximumToSkip) {
-    return Iterator.skip(this, maximumToSkip);
-  }
-  [Symbol.iterator]() {
-    return Iterator[Symbol.iterator](this);
+    return HttpHeaders.toArray(this);
   }
-};
-function depthFirstSearch(parametersOrInitialToVisit, searchAction) {
-  let initialToVisit;
-  if (isJavascriptIterable(parametersOrInitialToVisit)) {
-    initialToVisit = parametersOrInitialToVisit;
-    searchAction = searchAction;
-  } else {
-    PreCondition.assertNotUndefinedAndNotNull(parametersOrInitialToVisit, "parameters");
-    initialToVisit = parametersOrInitialToVisit.initialToVisit;
-    searchAction = parametersOrInitialToVisit.searchAction;
+  any() {
+    return HttpHeaders.any(this);
   }
-  PreCondition.assertNotUndefinedAndNotNull(initialToVisit, "initialToVisit");
-  PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
-  return DepthFirstSearch.create(initialToVisit, searchAction);
-}
-
-// sources/disposable.ts
-var Disposable = class {
-  /**
-   * Create a new {@link Disposable} that will invoke the provided {@link Function} when it is
-   * disposed.
-   * @param disposedFunction The function to invoke when the returned {@link Disposable} is
-   * disposed.
-   */
-  static create(disposedFunction) {
-    return SyncDisposable.create(disposedFunction);
+  equals(right, equalFunctions) {
+    return HttpHeaders.equals(this, right, equalFunctions);
   }
-};
-
-// 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++;
+  toString(toStringFunctions) {
+    return HttpHeaders.toString(this, toStringFunctions);
   }
-  return result;
-}
-
-// sources/generator.ts
-var InnerGeneratorControl = class _InnerGeneratorControl {
-  returnValues;
-  done;
-  constructor() {
-    this.returnValues = List.create();
-    this.done = false;
+  concatenate(...toConcatenate) {
+    return HttpHeaders.concatenate(this, ...toConcatenate);
   }
-  static create() {
-    return new _InnerGeneratorControl();
+  map(mapping) {
+    return HttpHeaders.map(this, mapping);
   }
-  addValue(returnValue) {
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    this.returnValues.add(returnValue);
+  flatMap(mapping) {
+    return HttpHeaders.flatMap(this, mapping);
   }
-  addValues(returnValues) {
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    this.returnValues.addAll(returnValues);
+  where(condition) {
+    return HttpHeaders.where(this, condition);
   }
-  hasCurrent() {
-    return this.returnValues.any().await();
+  instanceOf(typeOrTypeCheck) {
+    return HttpHeaders.instanceOf(this, typeOrTypeCheck);
   }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    return this.returnValues.first().await();
+  first(condition) {
+    return HttpHeaders.first(this, condition);
   }
-  removeCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    this.returnValues.removeFirst().await();
+  last(condition) {
+    return HttpHeaders.last(this, condition);
   }
-  setDone() {
-    PreCondition.assertFalse(this.hasCurrent(), "this.hasCurrent()");
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    this.done = true;
+  [Symbol.iterator]() {
+    return HttpHeaders[Symbol.iterator](this);
   }
-  isDone() {
-    return this.done;
+  contains(value, equalFunctions) {
+    return HttpHeaders.contains(this, value, equalFunctions);
   }
 };
-var Generator = class _Generator {
-  control;
-  generatorAction;
-  started;
-  constructor(generatorAction) {
-    PreCondition.assertNotUndefinedAndNotNull(generatorAction, "generatorAction");
-    this.control = InnerGeneratorControl.create();
-    this.generatorAction = generatorAction;
-    this.started = false;
+
+// 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);
   }
-  static create(generatorAction) {
-    return new _Generator(generatorAction);
+  getStatusCode() {
+    return this.response.status;
   }
-  next() {
+  getHeaders() {
     return SyncResult.create(() => {
-      if (!this.control.isDone()) {
-        if (!this.hasStarted()) {
-          this.started = true;
-        } else {
-          this.control.removeCurrent();
-        }
-        if (!this.control.hasCurrent()) {
-          const actionResult = this.generatorAction(this.control);
-          if (actionResult !== void 0) {
-            this.control.addValue(actionResult);
-          }
-          if (!this.control.hasCurrent()) {
-            this.control.setDone();
-          }
-        }
+      const result = HttpHeaders.create();
+      for (const header of this.response.headers) {
+        result.set(header[0], header[1]);
       }
-      return this.hasCurrent();
+      return result;
     });
   }
-  hasStarted() {
-    return this.started;
-  }
-  hasCurrent() {
-    return this.control.hasCurrent();
-  }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.control.getCurrent();
-  }
-  start() {
-    return Iterator.start(this);
+  getHeader(headerName) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    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;
+    });
   }
-  takeCurrent() {
-    return Iterator.takeCurrent(this);
+  getHeaderValue(headerName) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    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)}.`);
+      }
+      return result;
+    });
   }
-  any() {
-    return Iterator.any(this);
+  getBody() {
+    return PromiseAsyncResult.create(this.response.text());
   }
-  getCount() {
-    return Iterator.getCount(this);
+};
+
+// sources/httpMethod.ts
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2[HttpMethod2["GET"] = 0] = "GET";
+  HttpMethod2[HttpMethod2["HEAD"] = 1] = "HEAD";
+  HttpMethod2[HttpMethod2["POST"] = 2] = "POST";
+  HttpMethod2[HttpMethod2["PUT"] = 3] = "PUT";
+  HttpMethod2[HttpMethod2["DELETE"] = 4] = "DELETE";
+  HttpMethod2[HttpMethod2["CONNECT"] = 5] = "CONNECT";
+  HttpMethod2[HttpMethod2["OPTIONS"] = 6] = "OPTIONS";
+  HttpMethod2[HttpMethod2["TRACE"] = 7] = "TRACE";
+  HttpMethod2[HttpMethod2["PATCH"] = 8] = "PATCH";
+  return HttpMethod2;
+})(HttpMethod || {});
+function parseHttpMethod(text) {
+  return SyncResult.create(() => {
+    let result;
+    switch (text.toUpperCase()) {
+      case "GET":
+        result = 0 /* GET */;
+        break;
+      case "HEAD":
+        result = 1 /* HEAD */;
+        break;
+      case "POST":
+        result = 2 /* POST */;
+        break;
+      case "PUT":
+        result = 3 /* PUT */;
+        break;
+      case "DELETE":
+        result = 4 /* DELETE */;
+        break;
+      case "CONNECT":
+        result = 5 /* CONNECT */;
+        break;
+      case "OPTIONS":
+        result = 6 /* OPTIONS */;
+        break;
+      case "TRACE":
+        result = 7 /* TRACE */;
+        break;
+      case "PATCH":
+        result = 8 /* PATCH */;
+        break;
+      default:
+        throw new NotFoundError(`No HttpMethod exists for the text "${text}".`);
+    }
+    return result;
+  });
+}
+function httpMethodToString(httpMethod) {
+  PreCondition.assertNotUndefinedAndNotNull(httpMethod, "httpMethod");
+  let result;
+  switch (httpMethod) {
+    case 0 /* GET */:
+      result = "GET";
+      break;
+    case 1 /* HEAD */:
+      result = "HEAD";
+      break;
+    case 2 /* POST */:
+      result = "POST";
+      break;
+    case 3 /* PUT */:
+      result = "PUT";
+      break;
+    case 4 /* DELETE */:
+      result = "DELETE";
+      break;
+    case 5 /* CONNECT */:
+      result = "CONNECT";
+      break;
+    case 6 /* OPTIONS */:
+      result = "OPTIONS";
+      break;
+    case 7 /* TRACE */:
+      result = "TRACE";
+      break;
+    case 8 /* PATCH */:
+      result = "PATCH";
+      break;
+    default:
+      throw new NotFoundError(`Unrecognized HttpMethod: ${httpMethod}`);
   }
-  toArray() {
-    return Iterator.toArray(this);
+  return result;
+}
+
+// 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 = "";
   }
-  concatenate(...toConcatenate) {
-    return Iterator.concatenate(this, ...toConcatenate);
+  static create(method, url) {
+    return new _HttpOutgoingRequest(method, url);
   }
-  where(condition) {
-    return Iterator.where(this, condition);
+  /**
+   * 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);
   }
-  map(mapping) {
-    return Iterator.map(this, mapping);
+  /**
+   * Get the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+   */
+  getMethod() {
+    return this.method;
   }
-  flatMap(mapping) {
-    return Iterator.flatMap(this, mapping);
+  /**
+   * 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;
   }
-  whereInstanceOf(typeCheck) {
-    return Iterator.whereInstanceOf(this, typeCheck);
+  /**
+   * Get this {@link HttpOutgoingRequest}'s target URL.
+   */
+  getURL() {
+    return this.url;
   }
-  whereInstanceOfType(type) {
-    return Iterator.whereInstanceOfType(this, type);
+  /**
+   * 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;
   }
-  first(condition) {
-    return Iterator.first(this, condition);
+  /**
+   * Get the {@link HttpHeaders} that will be sent.
+   */
+  getHeaders() {
+    return this.headers;
   }
-  last(condition) {
-    return Iterator.last(this, condition);
+  getHeader(headerName) {
+    return this.headers.get(headerName);
   }
-  take(maximumToTake) {
-    return Iterator.take(this, maximumToTake);
+  getHeaderValue(headerName) {
+    return this.headers.getValue(headerName);
   }
-  skip(maximumToSkip) {
-    return Iterator.skip(this, maximumToSkip);
+  /**
+   * Get the body that will be sent.
+   */
+  getBody() {
+    return this.body;
   }
-  [Symbol.iterator]() {
-    return Iterator[Symbol.iterator](this);
+  setBody(body) {
+    PreCondition.assertNotUndefinedAndNotNull(body, "body");
+    this.body = body;
+    return this;
   }
 };
 
-// sources/httpClient.ts
-var HttpClient = class _HttpClient {
+// sources/fetchHttpClient.ts
+var FetchHttpClient = class _FetchHttpClient {
+  constructor() {
+  }
   static create() {
-    return FetchHttpClient.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);
+    });
   }
-  /**
-   * Send a GET {@link HttpOutgoingRequest} to the provided URL.
-   * @param url The URL to send the GET {@link HttpOutgoingRequest} to.
-   */
   sendGetRequest(url) {
-    return _HttpClient.sendGetRequest(this, url);
+    return this.sendRequest(HttpOutgoingRequest.create(0 /* GET */, url));
   }
-  static sendGetRequest(httpClient, url) {
-    return httpClient.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;
   }
 };
 
-// sources/inMemoryCharacterWriteStream.ts
-var InMemoryCharacterWriteStream = class _InMemoryCharacterWriteStream extends CharacterWriteStream {
-  writtenText;
-  newlineSequence;
+// sources/network.ts
+var Network = class {
+};
+
+// sources/httpServer.ts
+var HttpServer = class {
+};
+
+// sources/httpOutgoingResponse.ts
+var HttpOutgoingResponse = class _HttpOutgoingResponse {
+  statusCode;
+  headers;
+  body;
   constructor() {
-    super();
-    this.writtenText = "";
-    this.newlineSequence = "\n";
+    this.statusCode = 200;
+    this.headers = MutableHttpHeaders.create();
+    this.body = "";
   }
   static create() {
-    return new _InMemoryCharacterWriteStream();
-  }
-  getNewlineSequence() {
-    return this.newlineSequence;
-  }
-  setNewlineSequence(newlineSequence) {
-    PreCondition.assertNotUndefinedAndNotNull(newlineSequence, "newlineSequence");
-    this.newlineSequence = newlineSequence;
-    return this;
+    return new _HttpOutgoingResponse();
   }
-  getWrittenText() {
-    return this.writtenText;
+  /**
+   * Get the status code of this {@link HttpOutgoingResponse}.
+   */
+  getStatusCode() {
+    return this.statusCode;
   }
-  clearWrittenText() {
-    this.writtenText = "";
+  /**
+   * 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;
   }
-  writeString(text) {
-    return SyncResult.create(() => {
-      if (text) {
-        this.writtenText += text;
-      }
-      return getLength(text);
-    });
-  }
-  writeLine(text) {
-    return SyncResult.create(() => {
-      let result = 0;
-      if (text) {
-        result += this.writeString(text).await();
-      }
-      if (this.newlineSequence) {
-        result += this.writeString(this.newlineSequence).await();
-      }
-      return result;
-    });
-  }
-};
-
-// sources/listQueue.ts
-var ListQueue = class _ListQueue {
-  list;
-  constructor(list2) {
-    this.list = list2 ?? List.create();
+  getHeaders() {
+    return this.headers;
   }
-  static create(list2) {
-    return new _ListQueue(list2);
+  /**
+   * 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);
   }
-  any() {
-    return this.list.any();
+  /**
+   * 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);
   }
-  add(value) {
-    return SyncResult.create(() => {
-      this.list.add(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.
+   */
+  setHeader(headerName, headerValue) {
+    this.headers.set(headerName, headerValue);
+    return this;
   }
-  addAll(values) {
-    PreCondition.assertNotUndefinedAndNotNull(values, "values");
-    return SyncResult.create(() => {
-      this.list.addAll(values);
-    });
+  setContentTypeHeader(contentType) {
+    this.headers.setContentType(contentType);
+    return this;
   }
-  remove() {
-    return SyncResult.create(() => {
-      if (!this.any().await()) {
-        throw new EmptyError();
-      }
-      return this.list.removeLast().await();
-    });
+  /**
+   * Get the body of this {@link HttpOutgoingResponse}.
+   */
+  getBody() {
+    return this.body;
   }
-  contains(value, equalFunctions) {
-    return this.list.contains(value, equalFunctions);
+  /**
+   * 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;
   }
 };
 
-// sources/node.ts
-var Node = class _Node {
-  value;
-  connectedNodes;
-  constructor(value) {
-    this.value = value;
-    this.connectedNodes = Set2.create();
+// sources/nodeJSHttpServer.ts
+import * as http from "http";
+var NodeJSHttpServer = class _NodeJSHttpServer extends HttpServer {
+  httpServer;
+  disposed;
+  constructor() {
+    super();
+    this.disposed = false;
+  }
+  static create() {
+    return new _NodeJSHttpServer();
   }
-  static create(value) {
-    return new _Node(value);
+  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);
+          }
+        });
+      }
+    }));
   }
-  getValue() {
-    return this.value;
+  isDisposed() {
+    return this.disposed;
   }
-  iterateConnectedNodes() {
-    return this.connectedNodes.iterate();
+  isStarted() {
+    return !!this.httpServer;
   }
-  addConnectedNode(node) {
-    PreCondition.assertNotUndefinedAndNotNull(node, "node");
-    this.connectedNodes.add(node);
+  addRequestHandler(requestPath, handler) {
+    throw new Error("Method not implemented.");
   }
-};
-
-// sources/queue.ts
-var Queue = class {
-  /**
-   * Create an instance of the default {@link Queue} implementation.
-   * @returns A new {@link Queue} object.
-   */
-  static create() {
-    return ListQueue.create();
+  setDefaultRequestHandler(handler) {
+    throw new Error("Method not implemented.");
   }
-};
-
-// sources/recreationDotGovClient.ts
-var RecreationDotGovDivisionAvailability = class _RecreationDotGovDivisionAvailability {
-  json;
-  minimumGroupSize;
-  maximumGroupSize;
-  dayAvailabilities;
-  constructor(json) {
-    PreCondition.assertNotUndefinedAndNotNull(json, "json");
-    this.json = json;
-    const minGroupSize = "MinGroupSize".toLowerCase();
-    const maxGroupSize = "MaxGroupSize".toLowerCase();
-    for (const rule of json.rules) {
-      switch (rule.name.toLowerCase()) {
-        case minGroupSize:
-          this.minimumGroupSize = rule.value;
-          break;
-        case maxGroupSize:
-          this.maximumGroupSize = rule.value;
-          break;
-      }
-    }
-    const dayAvailabilities = List.create();
-    const quotaUsageByMemberDaily = json.quota_type_maps?.QuotaUsageByMemberDaily;
-    if (quotaUsageByMemberDaily) {
-      for (const quotaUsage of Object.entries(quotaUsageByMemberDaily)) {
-        const dateString = quotaUsage[0];
-        const usageData = quotaUsage[1];
-        let walkup = false;
-        let reservationsRemaining = 0;
-        const boolsEntry = json.bools[dateString];
-        if (boolsEntry) {
-          walkup = usageData.show_walkup;
-          reservationsRemaining = usageData.remaining;
-        }
-        dayAvailabilities.add({
-          date: DateTime.parse(dateString),
-          totalSpots: usageData.total,
-          walkup,
-          reservationsRemaining
+  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);
       }
-    }
-    this.dayAvailabilities = dayAvailabilities;
-  }
-  static create(json) {
-    return new _RecreationDotGovDivisionAvailability(json);
-  }
-};
-var RecreationDotGovError = class extends Error {
-  constructor(message) {
-    super(message);
-  }
-};
-var RecreationDotGovClient = class _RecreationDotGovClient {
-  httpClient;
-  constructor(httpClient) {
-    PreCondition.assertNotUndefinedAndNotNull(httpClient, "httpClient");
-    this.httpClient = httpClient;
-  }
-  static create(httpClient) {
-    return new _RecreationDotGovClient(httpClient);
-  }
-  sendRequest(request) {
-    return this.httpClient.sendRequest(request);
-  }
-  sendGetRequest(url) {
-    return HttpClient.sendGetRequest(this, url);
-  }
-  getPermitItinerary(permitItineraryId) {
-    PreCondition.assertNotEmpty(permitItineraryId, "permitItineraryId");
-    return PromiseAsyncResult.create(async () => {
-      const response = await this.sendGetRequest(`https://www.recreation.gov/api/permitcontent/${permitItineraryId}`);
-      const responseBody = await response.getBody();
-      const statusCode = response.getStatusCode();
-      if (statusCode < 200 || 300 <= statusCode) {
-        const responseBodyJson2 = JSON.parse(responseBody);
-        const errorMessage = responseBodyJson2.error;
-        switch (errorMessage.toLowerCase()) {
-          case "permit not found":
-            throw new RecreationDotGovError(`No permit itinerary found for id: ${JSON.stringify(permitItineraryId)}`);
-          default:
-            throw new RecreationDotGovError(`Unrecognized error: ${JSON.stringify(errorMessage)}`);
-        }
-      }
-      const responseBodyJson = JSON.parse(responseBody);
-      return responseBodyJson.payload;
-    });
-  }
-  getDivisionAvailability(permitItineraryId, divisionId, month, year, earlyAccessPermitLotteryId) {
-    PreCondition.assertNotEmpty(permitItineraryId, "permitItineraryId");
-    PreCondition.assertNotEmpty(divisionId, "divisionId");
-    PreCondition.assertBetween(1, month, 12, "month");
-    return PromiseAsyncResult.create(async () => {
-      const url = earlyAccessPermitLotteryId ? `https://www.recreation.gov/api/permititinerary/${permitItineraryId}/division/${divisionId}/eapavailability/month/${earlyAccessPermitLotteryId}?month=${month}&year=${year}` : `https://www.recreation.gov/api/permititinerary/${permitItineraryId}/division/${divisionId}/availability/month?month=${month}&year=${year}`;
-      const response = await this.sendGetRequest(url);
-      let responseBody = await response.getBody();
-      const statusCode = response.getStatusCode();
-      if (statusCode < 200 || 300 <= statusCode) {
-        const responseBodyJson2 = JSON.parse(responseBody);
-        const errorMessage = responseBodyJson2.error;
-        switch (errorMessage.toLowerCase()) {
-          case "invalid permit id":
-            throw new RecreationDotGovError(`No permit itinerary found for id: ${JSON.stringify(permitItineraryId)}`);
-          case "request year is missing or invalid":
-            const emptyResponseBody = {
-              payload: {
-                bools: {},
-                rules: [],
-                quota_type_maps: {}
-              }
-            };
-            responseBody = JSON.stringify(emptyResponseBody);
-            break;
-          default:
-            throw new RecreationDotGovError(`Unrecognized error: ${JSON.stringify(errorMessage)}`);
-        }
-      }
-      const responseBodyJson = JSON.parse(responseBody);
-      return RecreationDotGovDivisionAvailability.create(responseBodyJson.payload);
-    });
+    }));
   }
 };
 
-// sources/stringComparer.ts
-var StringComparer = class _StringComparer extends Comparer {
+// sources/realNetwork.ts
+var RealNetwork = class _RealNetwork extends Network {
   constructor() {
     super();
   }
   static create() {
-    return new _StringComparer();
+    return new _RealNetwork();
   }
-  compare(left, right) {
-    return _StringComparer.compare(left, right);
+  createHttpServer() {
+    return NodeJSHttpServer.create();
   }
-  static compare(left, right) {
-    let result = Comparer.compareSameUndefinedNull(left, right);
-    if (result === void 0) {
-      result = left < right ? 0 /* LessThan */ : 2 /* GreaterThan */;
-    }
-    return result;
+  createHttpClient() {
+    return FetchHttpClient.create();
   }
 };
 
-// sources/wonderlandTrailClient.ts
-function isWonderlandTrailLocation(value) {
-  return isObject(value) && hasProperty(value, "name") && hasProperty(value, "trailhead") && hasProperty(value, "foodCacheStorage") && hasProperty(value, "divisionId") && hasProperty(value, "groupSiteDivisionId");
-}
-var WonderlandTrailLocations = class {
-  static graniteCreek = {
-    name: "Granite Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170009",
-    groupSiteDivisionId: "46753170010",
-    latitude: 46.92058,
-    longitude: -121.708,
-    elevationFeet: 5851
-  };
-  static sunriseCamp = {
-    name: "Sunrise Camp",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170058",
-    groupSiteDivisionId: "46753170059",
-    latitude: 46.91129,
-    longitude: -121.66002,
-    elevationFeet: 6258
-  };
-  static sunriseVisitorCenter = {
-    name: "Sunrise Visitor Center",
-    trailhead: true,
-    foodCacheStorage: true,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.91448,
-    longitude: -121.64337,
-    elevationFeet: 6410
-  };
-  static whiteRiver = {
-    name: "White River",
-    trailhead: true,
-    foodCacheStorage: true,
-    divisionId: "46753170066",
-    groupSiteDivisionId: "46753170067",
-    latitude: 46.90255,
-    longitude: -121.63869,
-    elevationFeet: 4229
-  };
-  static fryingPanCreek = {
-    name: "Fryingpan Creek",
-    trailhead: true,
-    foodCacheStorage: false,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.88809,
-    longitude: -121.61019,
-    elevationFeet: 3835
-  };
-  static summerland = {
-    name: "Summerland",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170056",
-    groupSiteDivisionId: "46753170057",
-    latitude: 46.86616,
-    longitude: -121.65843,
-    elevationFeet: 5988
-  };
-  static indianBar = {
-    name: "Indian Bar",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170046",
-    groupSiteDivisionId: "46753170047",
-    latitude: 46.82593,
-    longitude: -121.63942,
-    elevationFeet: 5101
-  };
-  static nickelCreek = {
-    name: "Nickel Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170051",
-    groupSiteDivisionId: "46753170052",
-    latitude: 46.77204,
-    longitude: -121.62402,
-    elevationFeet: 3383
-  };
-  static boxCanyon = {
-    name: "Box Canyon",
-    trailhead: true,
-    foodCacheStorage: false,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.7657,
-    longitude: -121.63517,
-    elevationFeet: 3025
-  };
-  static mapleCreek = {
-    name: "Maple Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170027",
-    groupSiteDivisionId: "46753170028",
-    latitude: 46.75745,
-    longitude: -121.65764,
-    elevationFeet: 2806
-  };
-  static reflectionLakes = {
-    name: "Reflection Lakes",
-    trailhead: true,
-    foodCacheStorage: false,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.76824,
-    longitude: -121.7289,
-    elevationFeet: 4862
-  };
-  static paradiseRiver = {
-    name: "Paradise River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170031",
-    groupSiteDivisionId: "46753170032",
-    latitude: 46.77076,
-    longitude: -121.75909,
-    elevationFeet: 3960
-  };
-  static longmire = {
-    name: "Longmire",
-    trailhead: true,
-    foodCacheStorage: true,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.75011,
-    longitude: -121.81253,
-    elevationFeet: 2750
-  };
-  static pyramidCreek = {
-    name: "Pyramid Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170033",
-    groupSiteDivisionId: "",
-    latitude: 46.77832,
-    longitude: -121.80963,
-    elevationFeet: 3721
-  };
-  static devilsDream = {
-    name: "Devil's Dream",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170040",
-    groupSiteDivisionId: "46753170041",
-    latitude: 46.78196,
-    longitude: -121.83297,
-    elevationFeet: 4929
-  };
-  static southPuyallupRiver = {
-    name: "South Puyallup River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170035",
-    groupSiteDivisionId: "46753170036",
-    latitude: 46.81331,
-    longitude: -121.86445,
-    elevationFeet: 4183
-  };
-  static klapatchePark = {
-    name: "Klapatche Park",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170024",
-    groupSiteDivisionId: "",
-    latitude: 46.83571,
-    longitude: -121.87752,
-    elevationFeet: 5496
-  };
-  static northPuyallupRiver = {
-    name: "North Puyallup River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170029",
-    groupSiteDivisionId: "46753170030",
-    latitude: 46.84751,
-    longitude: -121.87005,
-    elevationFeet: 3733
-  };
-  static goldenLakes = {
-    name: "Golden Lakes",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170022",
-    groupSiteDivisionId: "46753170023",
-    latitude: 46.88327,
-    longitude: -121.89919,
-    elevationFeet: 4927
-  };
-  static southMowichRiver = {
-    name: "South Mowich River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170019",
-    groupSiteDivisionId: "46753170020",
-    latitude: 46.91146,
-    longitude: -121.89314,
-    elevationFeet: 2686
-  };
-  static mowichLake = {
-    name: "Mowich Lake",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170015",
-    groupSiteDivisionId: "46753170016",
-    latitude: 46.93204,
-    longitude: -121.86351,
-    elevationFeet: 4868
-  };
-  static eaglesRoost = {
-    name: "Eagle's Roost",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170006",
-    groupSiteDivisionId: "",
-    latitude: 46.91529,
-    longitude: -121.84816,
-    elevationFeet: 4834
-  };
-  static cataractValley = {
-    name: "Cataract Valley",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170003",
-    groupSiteDivisionId: "46753170004",
-    latitude: 46.94049,
-    longitude: -121.80486,
-    elevationFeet: 4488
-  };
-  static ipsutCreek = {
-    name: "Ipsut Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170011",
-    groupSiteDivisionId: "46753170012",
-    latitude: 46.97615,
-    longitude: -121.83022,
-    elevationFeet: 2359
-  };
-  static carbonRiver = {
-    name: "Carbon River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170001",
-    groupSiteDivisionId: "46753170002",
-    latitude: 46.95063,
-    longitude: -121.79991,
-    elevationFeet: 3255
-  };
-  static dickCreek = {
-    name: "Dick Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170005",
-    groupSiteDivisionId: "",
-    latitude: 46.94071,
-    longitude: -121.78431,
-    elevationFeet: 4114
-  };
-  static mysticLake = {
-    name: "Mystic Lake",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170017",
-    groupSiteDivisionId: "46753170018",
-    latitude: 46.9157,
-    longitude: -121.75045,
-    elevationFeet: 5538
-  };
-  static getLocations() {
-    return Iterable.create([
-      this.graniteCreek,
-      this.sunriseCamp,
-      this.sunriseVisitorCenter,
-      this.whiteRiver,
-      this.fryingPanCreek,
-      this.summerland,
-      this.indianBar,
-      this.nickelCreek,
-      this.boxCanyon,
-      this.mapleCreek,
-      this.reflectionLakes,
-      this.paradiseRiver,
-      this.longmire,
-      this.pyramidCreek,
-      this.devilsDream,
-      this.southPuyallupRiver,
-      this.klapatchePark,
-      this.northPuyallupRiver,
-      this.goldenLakes,
-      this.southMowichRiver,
-      this.mowichLake,
-      this.eaglesRoost,
-      this.cataractValley,
-      this.ipsutCreek,
-      this.carbonRiver,
-      this.dickCreek,
-      this.mysticLake
-    ]);
-  }
-  static getTrailheads() {
-    return this.getLocations().where((location) => location.trailhead);
-  }
-};
-var WonderlandTrailReservationType = /* @__PURE__ */ ((WonderlandTrailReservationType2) => {
-  WonderlandTrailReservationType2[WonderlandTrailReservationType2["Reserved"] = 0] = "Reserved";
-  WonderlandTrailReservationType2[WonderlandTrailReservationType2["Walkup"] = 1] = "Walkup";
-  return WonderlandTrailReservationType2;
-})(WonderlandTrailReservationType || {});
-var WonderlandTrailAvailability = class _WonderlandTrailAvailability {
-  availabilityMap;
+// sources/currentProcess.ts
+var CurrentProcess = class _CurrentProcess {
+  args;
+  parameters;
+  outputWriteStream;
+  exitCodeProperty;
+  network;
   constructor() {
-    this.availabilityMap = Map2.create();
   }
   static create() {
-    return new _WonderlandTrailAvailability();
-  }
-  any() {
-    return this.availabilityMap.any().await();
-  }
-  addAvailability(location, date, individualSite, groupSite) {
-    PreCondition.assertNotUndefinedAndNotNull(location, "location");
-    PreCondition.assertNotUndefinedAndNotNull(date, "date");
-    const locationAvailability = this.getAvailability(location);
-    const dateString = date.toDateString();
-    const locationDayAvailability = locationAvailability.getOrSet(dateString, () => {
-      return {};
-    }).await();
-    locationAvailability.set(dateString, {
-      individualSite: individualSite ?? locationDayAvailability.individualSite,
-      groupSite: groupSite ?? locationDayAvailability.groupSite
-    });
-  }
-  getAvailability(location) {
-    PreCondition.assertNotUndefinedAndNotNull(location, "location");
-    return this.availabilityMap.getOrSet(location, () => MutableMap.create()).await();
-  }
-  getDayAvailability(location, date) {
-    PreCondition.assertNotUndefinedAndNotNull(location, "location");
-    PreCondition.assertNotUndefinedAndNotNull(date, "date");
-    return this.getAvailability(location).get(date.toDateString()).convertError(NotFoundError, () => new NotFoundError(`No availability was found for ${location.name} on ${date.toDateString()}.`));
-  }
-};
-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;
-  }
-};
-var WonderlandTrailConnection = class _WonderlandTrailConnection {
-  startLocation;
-  endLocation;
-  distanceMiles;
-  ascentFeet;
-  descentFeet;
-  direction;
-  intermediateLocations;
-  constructor(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations) {
-    PreCondition.assertNotUndefinedAndNotNull(startLocation, "startLocation");
-    PreCondition.assertNotUndefinedAndNotNull(endLocation, "endLocation");
-    PreCondition.assertGreaterThanOrEqualTo(distanceMiles, 0, "distanceMiles");
-    PreCondition.assertGreaterThanOrEqualTo(ascentFeet, 0, "ascentFeet");
-    PreCondition.assertGreaterThanOrEqualTo(descentFeet, 0, "descentFeet");
-    PreCondition.assertNotUndefinedAndNotNull(intermediateLocations, "intermediateLocations");
-    this.startLocation = startLocation;
-    this.endLocation = endLocation;
-    this.distanceMiles = distanceMiles;
-    this.ascentFeet = ascentFeet;
-    this.descentFeet = descentFeet;
-    this.direction = direction;
-    this.intermediateLocations = intermediateLocations;
-  }
-  static create(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations) {
-    return new _WonderlandTrailConnection(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations);
-  }
-  getLocations() {
-    const result = List.create();
-    _WonderlandTrailConnection.ensureExists(result, this.startLocation);
-    _WonderlandTrailConnection.ensureAllExist(result, this.intermediateLocations);
-    _WonderlandTrailConnection.ensureExists(result, this.endLocation);
-    return result;
-  }
-  static ensureExists(list2, location) {
-    if (!list2.contains(location).await()) {
-      list2.add(location);
-    }
+    return new _CurrentProcess();
   }
-  static ensureAllExist(list2, locations) {
-    for (const location of locations) {
-      _WonderlandTrailConnection.ensureExists(list2, location);
+  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}`);
+      }
     }
   }
-  reverseDirection() {
-    return _WonderlandTrailConnection.create(
-      this.endLocation,
-      this.startLocation,
-      this.distanceMiles,
-      this.descentFeet,
-      this.ascentFeet,
-      this.direction.reverse(),
-      this.intermediateLocations
-    );
-  }
-  join(connection) {
-    const intermediateLocations = List.create();
-    _WonderlandTrailConnection.ensureAllExist(intermediateLocations, this.intermediateLocations);
-    _WonderlandTrailConnection.ensureExists(intermediateLocations, this.endLocation);
-    _WonderlandTrailConnection.ensureExists(intermediateLocations, connection.startLocation);
-    _WonderlandTrailConnection.ensureAllExist(intermediateLocations, connection.intermediateLocations);
-    return _WonderlandTrailConnection.create(
-      this.startLocation,
-      connection.endLocation,
-      this.distanceMiles + connection.distanceMiles,
-      this.ascentFeet + connection.ascentFeet,
-      this.descentFeet + connection.descentFeet,
-      this.direction,
-      intermediateLocations
-    );
-  }
-  containsLocation(location) {
-    return this.getLocations().contains(location).await();
-  }
-  isLoop() {
-    return this.startLocation === this.endLocation;
-  }
-};
-var WonderlandTrailConnections = class _WonderlandTrailConnections {
-  connections;
-  addReverseConnectionDefault;
-  constructor(addReverseConnectionDefault) {
-    this.connections = Map2.create();
-    this.addReverseConnectionDefault = addReverseConnectionDefault;
-  }
-  static create(addReverseConnectionDefault) {
-    return new _WonderlandTrailConnections(!!addReverseConnectionDefault);
-  }
-  static createDefault() {
-    return _WonderlandTrailConnections.create(true).addConnection({
-      startLocation: WonderlandTrailLocations.whiteRiver,
-      endLocation: WonderlandTrailLocations.fryingPanCreek,
-      distanceMiles: 2.7,
-      ascentFeet: 100,
-      descentFeet: 600
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.fryingPanCreek,
-      endLocation: WonderlandTrailLocations.summerland,
-      distanceMiles: 4.3,
-      ascentFeet: 2200,
-      descentFeet: 100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.summerland,
-      endLocation: WonderlandTrailLocations.indianBar,
-      distanceMiles: 4.7,
-      ascentFeet: 1200,
-      descentFeet: 2100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.indianBar,
-      endLocation: WonderlandTrailLocations.nickelCreek,
-      distanceMiles: 6.8,
-      ascentFeet: 1400,
-      descentFeet: 3200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.nickelCreek,
-      endLocation: WonderlandTrailLocations.boxCanyon,
-      distanceMiles: 0.9,
-      ascentFeet: 100,
-      descentFeet: 400
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.boxCanyon,
-      endLocation: WonderlandTrailLocations.mapleCreek,
-      distanceMiles: 2.7,
-      ascentFeet: 500,
-      descentFeet: 700
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.mapleCreek,
-      endLocation: WonderlandTrailLocations.reflectionLakes,
-      distanceMiles: 4.7,
-      ascentFeet: 2300,
-      descentFeet: 200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.reflectionLakes,
-      endLocation: WonderlandTrailLocations.paradiseRiver,
-      distanceMiles: 2.6,
-      ascentFeet: 200,
-      descentFeet: 1200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.paradiseRiver,
-      endLocation: WonderlandTrailLocations.longmire,
-      distanceMiles: 3.6,
-      ascentFeet: 100,
-      descentFeet: 1200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.longmire,
-      endLocation: WonderlandTrailLocations.pyramidCreek,
-      distanceMiles: 3.3,
-      ascentFeet: 1400,
-      descentFeet: 400
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.pyramidCreek,
-      endLocation: WonderlandTrailLocations.devilsDream,
-      distanceMiles: 2.5,
-      ascentFeet: 1400,
-      descentFeet: 100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.devilsDream,
-      endLocation: WonderlandTrailLocations.southPuyallupRiver,
-      distanceMiles: 6.5,
-      ascentFeet: 1900,
-      descentFeet: 2700
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.southPuyallupRiver,
-      endLocation: WonderlandTrailLocations.klapatchePark,
-      distanceMiles: 4.1,
-      ascentFeet: 2100,
-      descentFeet: 800
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.klapatchePark,
-      endLocation: WonderlandTrailLocations.northPuyallupRiver,
-      distanceMiles: 2.6,
-      ascentFeet: 100,
-      descentFeet: 1900
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.northPuyallupRiver,
-      endLocation: WonderlandTrailLocations.goldenLakes,
-      distanceMiles: 5.1,
-      ascentFeet: 1900,
-      descentFeet: 600
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.goldenLakes,
-      endLocation: WonderlandTrailLocations.southMowichRiver,
-      distanceMiles: 5.8,
-      ascentFeet: 200,
-      descentFeet: 2400
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.southMowichRiver,
-      endLocation: WonderlandTrailLocations.mowichLake,
-      distanceMiles: 4.4,
-      ascentFeet: 2400,
-      descentFeet: 300
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.mowichLake,
-      endLocation: WonderlandTrailLocations.ipsutCreek,
-      distanceMiles: 5.6,
-      ascentFeet: 400,
-      descentFeet: 3e3
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.ipsutCreek,
-      endLocation: WonderlandTrailLocations.carbonRiver,
-      distanceMiles: 4,
-      ascentFeet: 1300,
-      descentFeet: 400
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.mowichLake,
-      endLocation: WonderlandTrailLocations.eaglesRoost,
-      distanceMiles: 2,
-      ascentFeet: 500,
-      descentFeet: 600
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.eaglesRoost,
-      endLocation: WonderlandTrailLocations.cataractValley,
-      distanceMiles: 12.4,
-      ascentFeet: 3300,
-      descentFeet: 3700
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.cataractValley,
-      endLocation: WonderlandTrailLocations.carbonRiver,
-      distanceMiles: 1.6,
-      ascentFeet: 100,
-      descentFeet: 1300
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.carbonRiver,
-      endLocation: WonderlandTrailLocations.dickCreek,
-      distanceMiles: 1.3,
-      ascentFeet: 1e3,
-      descentFeet: 100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.dickCreek,
-      endLocation: WonderlandTrailLocations.mysticLake,
-      distanceMiles: 3.7,
-      ascentFeet: 2100,
-      descentFeet: 600
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.mysticLake,
-      endLocation: WonderlandTrailLocations.graniteCreek,
-      distanceMiles: 4.1,
-      ascentFeet: 1500,
-      descentFeet: 1200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.graniteCreek,
-      endLocation: WonderlandTrailLocations.sunriseCamp,
-      distanceMiles: 4.6,
-      ascentFeet: 1400,
-      descentFeet: 1e3
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.sunriseCamp,
-      endLocation: WonderlandTrailLocations.whiteRiver,
-      distanceMiles: 3.5,
-      ascentFeet: 100,
-      descentFeet: 2100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.sunriseCamp,
-      endLocation: WonderlandTrailLocations.sunriseVisitorCenter,
-      distanceMiles: 1.4,
-      ascentFeet: 400,
-      descentFeet: 200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.sunriseVisitorCenter,
-      endLocation: WonderlandTrailLocations.whiteRiver,
-      distanceMiles: 3.1,
-      ascentFeet: 0,
-      descentFeet: 2200
-    });
-  }
-  iterateConnections(startLocationOrProperties, endLocation, direction) {
-    let startLocation;
-    if (isWonderlandTrailLocation(startLocationOrProperties)) {
-      startLocation = startLocationOrProperties;
-    } else if (startLocationOrProperties) {
-      startLocation = startLocationOrProperties.startLocation;
-      endLocation = startLocationOrProperties.endLocation;
-      direction = startLocationOrProperties.direction;
-    }
-    let result;
-    if (!startLocation) {
-      result = this.connections.iterateValues().flatMap((x) => x);
-    } else {
-      result = this.connections.get(startLocation).catch(NotFoundError, () => Iterable.create()).await().iterate();
-    }
-    if (endLocation) {
-      result = result.where((connection) => connection.endLocation == endLocation);
-    }
-    if (direction != null) {
-      result = result.where((connection) => connection.direction == direction);
+  getArguments() {
+    if (!this.args) {
+      this.args = process.argv;
     }
-    return result;
+    return this.args;
   }
-  addConnectionInner(connection) {
-    const startLocationConnections = this.connections.getOrSet(connection.startLocation, () => List.create()).await();
-    startLocationConnections.add(connection);
-  }
-  addConnection(connectionStartLocationOrProperties, addReverseConnectionOrEndLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations, addReverseConnection) {
-    let startLocation;
-    let endLocation;
-    if (isWonderlandTrailLocation(connectionStartLocationOrProperties)) {
-      startLocation = connectionStartLocationOrProperties;
-    } else if (connectionStartLocationOrProperties instanceof WonderlandTrailConnection) {
-      startLocation = connectionStartLocationOrProperties.startLocation;
-      endLocation = connectionStartLocationOrProperties.endLocation;
-      distanceMiles = connectionStartLocationOrProperties.distanceMiles;
-      ascentFeet = connectionStartLocationOrProperties.ascentFeet;
-      descentFeet = connectionStartLocationOrProperties.descentFeet;
-      direction = connectionStartLocationOrProperties.direction;
-      intermediateLocations = connectionStartLocationOrProperties.intermediateLocations;
-      addReverseConnection = !!addReverseConnectionOrEndLocation;
-    } else {
-      startLocation = connectionStartLocationOrProperties.startLocation;
-      endLocation = connectionStartLocationOrProperties.endLocation;
-      distanceMiles = connectionStartLocationOrProperties.distanceMiles;
-      ascentFeet = connectionStartLocationOrProperties.ascentFeet;
-      descentFeet = connectionStartLocationOrProperties.descentFeet;
-      direction = connectionStartLocationOrProperties.direction;
-      intermediateLocations = connectionStartLocationOrProperties.intermediateLocations;
-      addReverseConnection = connectionStartLocationOrProperties.addReverseConnection;
-    }
-    const connection = WonderlandTrailConnection.create(
-      startLocation,
-      endLocation,
-      distanceMiles,
-      ascentFeet,
-      descentFeet,
-      direction ?? WonderlandTrailDirection.clockwise,
-      intermediateLocations ?? Iterable.create()
-    );
-    this.addConnectionInner(connection);
-    if (addReverseConnection ?? this.addReverseConnectionDefault) {
-      this.addConnectionInner(connection.reverseDirection());
-    }
+  setArguments(args) {
+    PreCondition.assertNotUndefinedAndNotNull(args, "args");
+    PreCondition.assertUndefined(this.parameters, "this.parameters");
+    this.args = args;
     return this;
   }
-  containsConnection(connection) {
-    PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
-    const startLocationConnections = this.connections.get(connection.startLocation).catch(() => void 0).await();
-    return startLocationConnections?.contains(connection)?.await() === true;
-  }
-  reverseDirection() {
-    const result = _WonderlandTrailConnections.create(this.addReverseConnectionDefault);
-    for (const connection of this.iterateConnections()) {
-      result.addConnection(connection.reverseDirection());
-    }
-    return result;
-  }
-  expandConnections(startLocation, endLocation, direction) {
-    if (isUndefinedOrNull(direction)) {
-      direction = WonderlandTrailDirection.clockwise;
-    }
-    const result = _WonderlandTrailConnections.create(this.addReverseConnectionDefault);
-    const toVisit = Stack.create();
-    toVisit.addAll(this.iterateConnections(startLocation, void 0, direction));
-    while (toVisit.any().await()) {
-      const currentConnection = toVisit.remove().await();
-      result.addConnection(currentConnection, false);
-      if (!currentConnection.isLoop() && currentConnection.endLocation !== endLocation) {
-        for (const endLocationConnection of this.iterateConnections(currentConnection.endLocation, void 0, direction)) {
-          if (!result.containsConnection(endLocationConnection) && !toVisit.contains(endLocationConnection)) {
-            toVisit.add(endLocationConnection);
-          }
-          if (!currentConnection.intermediateLocations.contains(endLocationConnection.endLocation)) {
-            toVisit.add(currentConnection.join(endLocationConnection));
-          }
-        }
-      }
+  getParameters() {
+    if (!this.parameters) {
+      this.parameters = CommandLineParameters.create(this.getArguments());
     }
-    return result;
+    return this.parameters;
   }
-};
-var WonderlandTrailItinerary = class _WonderlandTrailItinerary {
-  startDay;
-  connections;
-  availabilityTypes;
-  constructor(startDay) {
-    PreCondition.assertNotUndefinedAndNotNull(startDay, "startDay");
-    this.startDay = startDay;
-    this.connections = List.create();
-    this.availabilityTypes = List.create();
-  }
-  static create(startDay) {
-    return new _WonderlandTrailItinerary(startDay);
-  }
-  clone() {
-    return _WonderlandTrailItinerary.create(this.startDay).addConnections(this.connections).addAvailabilityTypes(this.availabilityTypes);
-  }
-  getConnections() {
-    return this.connections;
-  }
-  getEndDay() {
-    return this.startDay.addDays(this.getDayCount() - 1);
-  }
-  getDayCount() {
-    return this.connections.getCount().await();
-  }
-  getStartLocation() {
-    return this.connections.first().then((firstConnection) => firstConnection.startLocation);
-  }
-  getIntermediateLocations() {
-    const result = List.create();
-    for (const connection of this.connections) {
-      if (result.any().await()) {
-        result.add(connection.startLocation);
-      }
-      result.addAll(connection.intermediateLocations);
+  getOutputWriteStream() {
+    if (!this.outputWriteStream) {
+      this.outputWriteStream = NodeJSCharacterWriteStream.create(process.stdout);
     }
-    return result;
-  }
-  getEndLocation() {
-    return this.connections.last().then((lastConnection) => lastConnection.endLocation);
+    return this.outputWriteStream;
   }
-  getPath() {
-    const result = List.create();
-    for (const connection of this.connections) {
-      if (!result.any().await()) {
-        result.add(connection.startLocation);
-      }
-      result.add(connection.endLocation);
-    }
-    return result;
+  setOutputWriteStream(outputWriteStream) {
+    PreCondition.assertNotUndefinedAndNotNull(outputWriteStream, "outputWriteStream");
+    this.outputWriteStream = outputWriteStream;
+    return this;
   }
-  getPathStrings(includeAvailabilityTypes) {
-    includeAvailabilityTypes = includeAvailabilityTypes ?? true;
-    const result = List.create();
-    let availabilityTypeIndex = 0;
-    const availabilityTypeCount = this.availabilityTypes.getCount().await();
-    for (const connection of this.connections) {
-      if (!result.any().await()) {
-        result.add(connection.startLocation.name);
-      }
-      let pathString = connection.endLocation.name;
-      if (includeAvailabilityTypes && availabilityTypeIndex < availabilityTypeCount) {
-        pathString += " ";
-        const availabilityType = this.availabilityTypes.get(availabilityTypeIndex).await();
-        availabilityTypeIndex++;
-        if (availabilityType.individualSite !== void 0) {
-          if (availabilityType.groupSite !== void 0) {
-            pathString += `(Individual ${availabilityType.individualSite}/Group ${availabilityType.groupSite})`;
-          } else {
-            pathString += `(Individual ${availabilityType.individualSite})`;
-          }
-        } else {
-          pathString += `(Group ${availabilityType.groupSite})`;
-        }
-      }
-      result.add(pathString);
-    }
-    return result;
+  getExitCode() {
+    return this.getExitCodeProperty().getValue();
   }
-  contains(parameters) {
-    PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
-    const location = parameters.location;
-    const checkItineraryStartLocation = parameters.checkItineraryStartLocation ?? true;
-    const checkItineraryIntermediateLocations = parameters.checkItineraryIntermediateLocations ?? true;
-    const checkItineraryEndLocation = parameters.checkItineraryEndLocation ?? true;
-    PreCondition.assertNotUndefinedAndNotNull(location, "location");
-    let result = false;
-    const connectionCount = this.connections.getCount().await();
-    for (let i = 0; i < connectionCount; i++) {
-      if (i !== 0 || checkItineraryStartLocation) {
-        result = this.connections.get(i).await().startLocation === location;
-        if (result) {
-          break;
-        }
-      }
-      if (checkItineraryIntermediateLocations) {
-        result = this.connections.get(i).await().intermediateLocations.contains(location).await();
-        if (result) {
-          break;
-        }
-      }
-      if (i === connectionCount - 1 && checkItineraryEndLocation) {
-        result = this.connections.get(i).await().endLocation === location;
-        if (result) {
-          break;
-        }
-      }
-    }
-    return result;
+  setExitCode(exitCode) {
+    PreCondition.assertNotUndefinedAndNotNull(exitCode, "exitCode");
+    this.getExitCodeProperty().setValue(exitCode);
+    return this;
   }
-  containsAny(parameters) {
-    PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
-    const connection = parameters.connection;
-    const checkConnectionStartLocation = parameters.checkConnectionStartLocation ?? true;
-    const checkConnectionIntermediateLocations = parameters.checkConnectionIntermediateLocations ?? true;
-    const checkConnectionEndLocation = parameters.checkConnectionEndLocation ?? true;
-    const checkItineraryStartLocation = parameters.checkItineraryStartLocation ?? true;
-    const checkItineraryIntermediateLocations = parameters.checkItineraryIntermediateLocations ?? true;
-    const checkItineraryEndLocation = parameters.checkItineraryEndLocation ?? true;
-    PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
-    let result = false;
-    if (!result && checkConnectionStartLocation) {
-      result = this.contains({
-        location: connection.startLocation,
-        checkItineraryStartLocation,
-        checkItineraryIntermediateLocations,
-        checkItineraryEndLocation
-      });
-    }
-    if (!result && checkConnectionIntermediateLocations) {
-      for (const connectionIntermediateLocation of connection.intermediateLocations) {
-        result = this.contains({
-          location: connectionIntermediateLocation,
-          checkItineraryStartLocation,
-          checkItineraryIntermediateLocations,
-          checkItineraryEndLocation
-        });
-        if (result) {
-          break;
+  getExitCodeProperty() {
+    if (!this.exitCodeProperty) {
+      this.exitCodeProperty = Property.create({
+        getter: () => process.exitCode,
+        setter: (value) => {
+          process.exitCode = value;
         }
-      }
-    }
-    if (!result && checkConnectionEndLocation) {
-      result = this.contains({
-        location: connection.endLocation,
-        checkItineraryStartLocation,
-        checkItineraryIntermediateLocations,
-        checkItineraryEndLocation
       });
     }
-    return result;
-  }
-  addConnection(connection) {
-    PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
-    this.connections.add(connection);
-    return this;
+    return this.exitCodeProperty;
   }
-  addConnections(connections) {
-    PreCondition.assertNotUndefinedAndNotNull(connections, "connections");
-    this.connections.addAll(connections);
+  setExitCodeProperty(exitCodeProperty) {
+    PreCondition.assertNotUndefinedAndNotNull(exitCodeProperty, "exitCodeProperty");
+    this.exitCodeProperty = exitCodeProperty;
     return this;
   }
-  addAvailabilityType(availabilityType) {
-    PreCondition.assertNotUndefinedAndNotNull(availabilityType, "availabilityType");
-    this.availabilityTypes.add(availabilityType);
-    return this;
+  getNetwork() {
+    if (!this.network) {
+      this.network = RealNetwork.create();
+    }
+    return this.network;
   }
-  addAvailabilityTypes(availabilityTypes) {
-    PreCondition.assertNotUndefinedAndNotNull(availabilityTypes, "availabilityTypes");
-    this.availabilityTypes.addAll(availabilityTypes);
+  setNetwork(network) {
+    PreCondition.assertUndefined(this.network, "this.network");
+    PreCondition.assertNotUndefinedAndNotNull(network, "network");
+    this.network = network;
     return this;
   }
-  toString(includeAvailabilityTypes) {
-    includeAvailabilityTypes = includeAvailabilityTypes ?? true;
-    return `startDay:${this.startDay.toDateString()},path:${this.getPathStrings(includeAvailabilityTypes)}`;
-  }
 };
-var WonderlandTrailClient = class _WonderlandTrailClient {
-  static permitItineraryId = "4675317";
-  httpClient;
-  recreationDotGovClient;
-  constructor(httpClient) {
-    PreCondition.assertNotUndefinedAndNotNull(httpClient, "httpClient");
-    this.httpClient = httpClient;
-    this.recreationDotGovClient = RecreationDotGovClient.create(httpClient);
-  }
-  static create(httpClient) {
-    return new _WonderlandTrailClient(httpClient);
-  }
-  sendRequest(request) {
-    return this.httpClient.sendRequest(request);
-  }
-  sendGetRequest(url) {
-    return HttpClient.sendGetRequest(this, url);
-  }
-  getAvailability(monthOrOptions, year, allowWalkupPermits, allowIndividualSites, allowGroupSites, earlyAccessPermitLotteryId) {
-    let month;
-    if (isNumber(monthOrOptions)) {
-      month = monthOrOptions;
-      year = year;
-      allowWalkupPermits = allowWalkupPermits;
-      allowIndividualSites = allowIndividualSites;
-      allowGroupSites = allowGroupSites;
-    } else {
-      month = monthOrOptions.month;
-      year = monthOrOptions.year;
-      allowWalkupPermits = monthOrOptions.allowWalkupPermits;
-      allowIndividualSites = monthOrOptions.allowIndividualSites;
-      allowGroupSites = monthOrOptions.allowGroupSites;
-      earlyAccessPermitLotteryId = monthOrOptions.earlyAccessPermitLotteryId;
-    }
-    return PromiseAsyncResult.create(async () => {
-      const result = WonderlandTrailAvailability.create();
-      for (const location of WonderlandTrailLocations.getLocations()) {
-        if (allowIndividualSites && location.divisionId) {
-          const divisionAvailability = await this.recreationDotGovClient.getDivisionAvailability(
-            _WonderlandTrailClient.permitItineraryId,
-            location.divisionId,
-            month,
-            year,
-            earlyAccessPermitLotteryId
-          );
-          const divisionDayAvailabilities = divisionAvailability.dayAvailabilities;
-          if (divisionDayAvailabilities) {
-            for (const divisionDayAvailability of divisionDayAvailabilities) {
-              const hasWalkupPermits = allowWalkupPermits && divisionDayAvailability.walkup;
-              const hasReservationPermits = divisionDayAvailability.reservationsRemaining > 0;
-              if (hasWalkupPermits || hasReservationPermits) {
-                result.addAvailability(
-                  location,
-                  divisionDayAvailability.date,
-                  hasWalkupPermits ? 1 /* Walkup */ : 0 /* Reserved */,
-                  void 0
-                );
-              }
-            }
-          }
-        }
-        if (allowGroupSites && location.groupSiteDivisionId) {
-          const groupSiteDivisionAvailability = await this.recreationDotGovClient.getDivisionAvailability(
-            _WonderlandTrailClient.permitItineraryId,
-            location.groupSiteDivisionId,
-            month,
-            year,
-            earlyAccessPermitLotteryId
-          );
-          const groupSiteDivisionDayAvailabilities = groupSiteDivisionAvailability.dayAvailabilities;
-          if (groupSiteDivisionDayAvailabilities) {
-            for (const groupSiteDayAvailability of groupSiteDivisionDayAvailabilities) {
-              const hasWalkupPermits = allowWalkupPermits && groupSiteDayAvailability.walkup;
-              const hasReservationPermits = groupSiteDayAvailability.reservationsRemaining > 0;
-              if (hasWalkupPermits || hasReservationPermits) {
-                result.addAvailability(
-                  location,
-                  groupSiteDayAvailability.date,
-                  void 0,
-                  hasWalkupPermits ? 1 /* Walkup */ : 0 /* Reserved */
-                );
-              }
-            }
-          }
-        }
-      }
-      return result;
-    });
-  }
-  findItineraries(parameters) {
-    PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
-    const availability = parameters.availability;
-    const startDate = parameters.startDate;
-    const startLocation = parameters.startLocation;
-    const endLocation = parameters.endLocation;
-    const direction = parameters.direction;
-    const maximumDayDistanceMiles = parameters.maximumDayDistanceMiles;
-    const maximumItineraryDays = parameters.maximumItineraryDays;
-    const campsitesToAvoid = Iterable.create(parameters.campsitesToAvoid ?? []);
-    const result = List.create();
-    const connections = WonderlandTrailConnections.createDefault().expandConnections(startLocation, endLocation, direction);
-    let startLocationConnections = connections.iterateConnections(startLocation, void 0, direction);
-    if (!isUndefinedOrNull(maximumDayDistanceMiles)) {
-      startLocationConnections = startLocationConnections.where((connection) => connection.distanceMiles <= maximumDayDistanceMiles);
-    }
-    const possibleItineraries = Stack.create();
-    possibleItineraries.addAll(startLocationConnections.map((c) => WonderlandTrailItinerary.create(startDate).addConnection(c)));
-    while (possibleItineraries.any().await()) {
-      const currentItinerary = possibleItineraries.remove().await();
-      const currentItineraryEndLocation = currentItinerary.getEndLocation().await();
-      if ((maximumItineraryDays === void 0 || currentItinerary.getDayCount() <= maximumItineraryDays) && (startLocation === currentItineraryEndLocation || endLocation === currentItineraryEndLocation || !campsitesToAvoid.contains(currentItineraryEndLocation).await())) {
-        if (currentItineraryEndLocation === endLocation) {
-          result.add(currentItinerary);
-        } else {
-          const dayAvailability = availability.getDayAvailability(currentItineraryEndLocation, currentItinerary.getEndDay()).catch(() => void 0).await();
-          if (dayAvailability) {
-            currentItinerary.addAvailabilityType(dayAvailability);
-            for (const nextDayConnection of connections.iterateConnections(currentItineraryEndLocation, void 0, direction)) {
-              if (!currentItinerary.containsAny({
-                connection: nextDayConnection,
-                checkConnectionStartLocation: false,
-                checkItineraryStartLocation: false,
-                checkItineraryEndLocation: false
-              })) {
-                if (maximumDayDistanceMiles === void 0 || nextDayConnection.distanceMiles <= maximumDayDistanceMiles) {
-                  possibleItineraries.add(currentItinerary.clone().addConnection(nextDayConnection));
-                }
-              }
-            }
-          }
+
+// 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} `;
       }
     }
-    return result;
-  }
-  findItinerariesAsync(parameters) {
-    PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
-    const startDay = parameters.startDay;
-    const startLocation = parameters.startLocation;
-    const endLocation = parameters.endLocation;
-    const direction = parameters.direction;
-    const maximumDayDistanceMiles = parameters.maximumDayDistanceMiles;
-    const maximumItineraryDays = parameters.maximumItineraryDays;
-    const allowWalkupPermits = parameters.allowWalkupPermits ?? true;
-    const allowIndividualSites = parameters.allowIndividualSites ?? true;
-    const allowGroupSites = parameters.allowGroupSites ?? false;
-    const campsitesToAvoid = parameters.campsitesToAvoid ?? [];
-    PreCondition.assertNotUndefinedAndNotNull(startDay, "startDay");
-    return PromiseAsyncResult.create(async () => {
-      const result = List.create();
-      const startLocationsToCheck = !isUndefinedOrNull(startLocation) ? Iterable.create([startLocation]) : WonderlandTrailLocations.getTrailheads();
-      const directionsToCheck = !isUndefinedOrNull(direction) ? Iterable.create([direction]) : Iterable.create([WonderlandTrailDirection.clockwise, WonderlandTrailDirection.counterClockwise]);
-      const availability = await this.getAvailability(
-        startDay.getMonth(),
-        startDay.getYear(),
-        allowWalkupPermits,
-        allowIndividualSites,
-        allowGroupSites
-      );
-      for (const startLocationToCheck of startLocationsToCheck) {
-        for (const directionToCheck of directionsToCheck) {
-          result.addAll(this.findItineraries({
-            availability,
-            startDate: startDay,
-            startLocation: startLocationToCheck,
-            endLocation: endLocation ?? startLocationToCheck,
-            direction: directionToCheck,
-            maximumDayDistanceMiles,
-            maximumItineraryDays,
-            campsitesToAvoid
-          }));
-        }
-      }
-      return result;
-    });
+    result += currentValue;
+    index++;
   }
-};
+  return result;
+}
 
 export {
   __export,
@@ -7681,16 +5274,9 @@ export {
   MutableCondition,
   PreConditionError,
   PreCondition,
-  SyncDisposable,
-  ByteList,
-  ByteListStream,
-  StringIterator,
-  CharacterList,
-  CharacterReadStream,
   PostConditionError,
   PostCondition,
   CharacterWriteStream,
-  CharacterListStream,
   CommandLineParameters,
   NodeJSCharacterWriteStream,
   Property,
@@ -7710,32 +5296,7 @@ export {
   NodeJSHttpServer,
   RealNetwork,
   CurrentProcess,
-  LuxonDateTime,
-  DateTime,
-  ListStack,
-  Stack,
-  depthFirstSearch,
-  Disposable,
   andList,
-  orList,
-  Generator,
-  HttpClient,
-  InMemoryCharacterWriteStream,
-  ListQueue,
-  Node,
-  Queue,
-  RecreationDotGovDivisionAvailability,
-  RecreationDotGovError,
-  RecreationDotGovClient,
-  StringComparer,
-  isWonderlandTrailLocation,
-  WonderlandTrailLocations,
-  WonderlandTrailReservationType,
-  WonderlandTrailAvailability,
-  WonderlandTrailDirection,
-  WonderlandTrailConnection,
-  WonderlandTrailConnections,
-  WonderlandTrailItinerary,
-  WonderlandTrailClient
+  orList
 };
-//# sourceMappingURL=chunk-AY3YWKOM.js.map
+//# sourceMappingURL=chunk-5Z677JON.js.map