@everyonesoftware/common 11.0.0 → 13.0.0

package/outputs/sourceIndex.cjs

@@ -45,6 +45,7 @@ __export(sources_exports, {
   CharacterReadStreamAsyncIterator: () => CharacterReadStreamAsyncIterator,
   CharacterTable: () => CharacterTable,
   CharacterWriteStream: () => CharacterWriteStream,
+  Clock: () => Clock,
   CommandLineParameter: () => CommandLineParameter,
   CommandLineParameters: () => CommandLineParameters,
   Comparable: () => Comparable,
@@ -58,6 +59,7 @@ __export(sources_exports, {
   Disposable: () => Disposable,
   EmptyError: () => EmptyError,
   EqualFunctions: () => EqualFunctions,
+  FetchError: () => FetchError,
   FetchHttpClient: () => FetchHttpClient,
   FetchHttpIncomingResponse: () => FetchHttpIncomingResponse,
   FlatMapIterable: () => FlatMapIterable,
@@ -101,6 +103,7 @@ __export(sources_exports, {
   Node: () => Node,
   NodeJSCharacterWriteStream: () => NodeJSCharacterWriteStream,
   NodeJSHttpIncomingRequest: () => NodeJSHttpIncomingRequest,
+  NodeJSHttpOutgoingResponse: () => NodeJSHttpOutgoingResponse,
   NodeJSHttpServer: () => NodeJSHttpServer,
   NotFoundError: () => NotFoundError,
   PostCondition: () => PostCondition,
@@ -110,6 +113,7 @@ __export(sources_exports, {
   PromiseAsyncResult: () => PromiseAsyncResult,
   Property: () => Property,
   Queue: () => Queue,
+  RealClock: () => RealClock,
   RealNetwork: () => RealNetwork,
   RecreationDotGovClient: () => RecreationDotGovClient,
   RecreationDotGovDivisionAvailability: () => RecreationDotGovDivisionAvailability,
@@ -4477,6 +4481,187 @@ var CharacterTable = class _CharacterTable {
   }
 };
 
+// sources/luxonDateTime.ts
+var luxon = __toESM(require("luxon"), 1);
+var pctTimeZone = "America/Los_Angeles";
+var LuxonDateTime = class _LuxonDateTime {
+  dateTime;
+  constructor(dateTime) {
+    this.dateTime = dateTime;
+  }
+  static create(dateTime) {
+    return new _LuxonDateTime(dateTime);
+  }
+  static parse(text) {
+    return _LuxonDateTime.create(luxon.DateTime.fromISO(text, { zone: pctTimeZone }));
+  }
+  static now() {
+    return _LuxonDateTime.create(luxon.DateTime.now().setZone(pctTimeZone));
+  }
+  getYear() {
+    return this.dateTime.year;
+  }
+  getMonth() {
+    return this.dateTime.month;
+  }
+  getDay() {
+    return this.dateTime.day;
+  }
+  getHour() {
+    return this.dateTime.hour;
+  }
+  getMinute() {
+    return this.dateTime.minute;
+  }
+  getSecond() {
+    return this.dateTime.second;
+  }
+  addDays(days) {
+    return _LuxonDateTime.create(this.dateTime.plus({ days }));
+  }
+  toString() {
+    return this.dateTime.toISO();
+  }
+  toDateString() {
+    return this.dateTime.toISODate();
+  }
+  toShortDateString() {
+    return `${this.dateTime.monthShort} ${this.dateTime.day}`;
+  }
+  compareTo(dateTime, compareTimes) {
+    return DateTime2.compareTo(this, dateTime, compareTimes);
+  }
+  lessThan(dateTime, compareTimes) {
+    return DateTime2.lessThan(this, dateTime, compareTimes);
+  }
+  lessThanOrEqualTo(dateTime, compareTimes) {
+    return DateTime2.lessThanOrEqualTo(this, dateTime, compareTimes);
+  }
+  equals(dateTime, compareTimes) {
+    return DateTime2.equals(this, dateTime, compareTimes);
+  }
+  greaterThanOrEqualTo(dateTime, compareTimes) {
+    return DateTime2.greaterThanOrEqualTo(this, dateTime, compareTimes);
+  }
+  greaterThan(dateTime, compareTimes) {
+    return DateTime2.greaterThan(this, dateTime, compareTimes);
+  }
+  get debug() {
+    return DateTime2.debug(this);
+  }
+};
+
+// sources/dateTime.ts
+var DateTime2 = 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);
+  }
+  static lessThan(left, right, compareTimes) {
+    return left.compareTo(right, compareTimes) < 0;
+  }
+  lessThanOrEqualTo(dateTime, compareTimes) {
+    return _DateTime.lessThanOrEqualTo(this, dateTime, compareTimes);
+  }
+  static lessThanOrEqualTo(left, right, compareTimes) {
+    return left.compareTo(right, compareTimes) <= 0;
+  }
+  equals(dateTime, compareTimes) {
+    return _DateTime.equals(this, dateTime, compareTimes);
+  }
+  static equals(left, right, compareTimes) {
+    return left.compareTo(right, compareTimes) === 0;
+  }
+  greaterThanOrEqualTo(dateTime, compareTimes) {
+    return _DateTime.greaterThanOrEqualTo(this, dateTime, compareTimes);
+  }
+  static greaterThanOrEqualTo(left, right, compareTimes) {
+    return left.compareTo(right, compareTimes) >= 0;
+  }
+  greaterThan(dateTime, compareTimes) {
+    return _DateTime.greaterThan(this, dateTime, compareTimes);
+  }
+  static greaterThan(left, right, compareTimes) {
+    return left.compareTo(right, compareTimes) > 0;
+  }
+  get debug() {
+    return _DateTime.debug(this);
+  }
+  static debug(dateTime) {
+    return dateTime.toString();
+  }
+};
+
+// sources/RealClock.ts
+var RealClock = class _RealClock {
+  constructor() {
+  }
+  static create() {
+    return new _RealClock();
+  }
+  now() {
+    return DateTime2.now();
+  }
+};
+
+// sources/Clock.ts
+var Clock = class {
+  static create() {
+    return RealClock.create();
+  }
+};
+
+// sources/FetchError.ts
+var FetchError = class extends Error {
+  innerError;
+  constructor(innerError) {
+    PreCondition.assertNotUndefinedAndNotNull(innerError, "innerError");
+    super(innerError.message, { cause: innerError });
+    this.innerError = innerError;
+  }
+  get code() {
+    return "code" in this.innerError ? this.innerError.code : void 0;
+  }
+  get hostname() {
+    return "hostname" in this.innerError ? this.innerError.hostname : void 0;
+  }
+};
+
 // sources/asyncResult.ts
 var AsyncResult = class {
   static create(actionOrPromise) {
@@ -4858,663 +5043,641 @@ var IndentedCharacterWriteStream = class _IndentedCharacterWriteStream extends C
   }
 };
 
-// sources/TokenType.ts
-var TokenType = class _TokenType {
+// sources/httpHeader.ts
+var HttpHeader = class _HttpHeader {
   name;
-  constructor(name) {
+  value;
+  constructor(name, value) {
     PreCondition.assertNotEmpty(name, "name");
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
     this.name = name;
+    this.value = value;
   }
-  static create(name) {
-    return new _TokenType(name);
+  static create(name, value) {
+    return new _HttpHeader(name, value);
   }
-  static Whitespace = _TokenType.create("Whitespace");
-  static NewLine = _TokenType.create("NewLine");
-  static Letters = _TokenType.create("Letters");
-  static Digits = _TokenType.create("Digits");
-  static LeftParenthesis = _TokenType.create("LeftParenthesis");
-  static RightParenthesis = _TokenType.create("RightParenthesis");
-  static Backslash = _TokenType.create("Backslash");
-  static ForwardSlash = _TokenType.create("ForwardSlash");
-  static Unknown = _TokenType.create("Unknown");
-  static Period = _TokenType.create("Period");
-  static Underscore = _TokenType.create("Underscore");
-  static Colon = _TokenType.create("Colon");
-  toString() {
+  getName() {
     return this.name;
   }
-};
-
-// sources/Token.ts
-var Token = class _Token {
-  static newLineToken = _Token.create("\n", TokenType.NewLine);
-  static carriageReturnNewLineToken = _Token.create("\r\n", TokenType.NewLine);
-  static leftParenthesisToken = _Token.create("(", TokenType.LeftParenthesis);
-  static rightParenthesisToken = _Token.create(")", TokenType.RightParenthesis);
-  static backslashToken = _Token.create("\\", TokenType.Backslash);
-  static forwardSlashToken = _Token.create("/", TokenType.ForwardSlash);
-  static periodToken = _Token.create(".", TokenType.Period);
-  static underscoreToken = _Token.create("_", TokenType.Underscore);
-  static colonToken = _Token.create(":", TokenType.Colon);
-  text;
-  type;
-  constructor(text, type) {
-    PreCondition.assertNotEmpty(text, "text");
-    PreCondition.assertNotUndefinedAndNotNull(type, "type");
-    this.text = text;
-    this.type = type;
-  }
-  static create(text, type) {
-    return new _Token(text, type);
+  getValue() {
+    return this.value;
   }
-  static whitespace(text) {
-    return _Token.create(text, TokenType.Whitespace);
+  toString() {
+    return `${escapeAndQuote(this.name)}:${escapeAndQuote(this.value)}`;
   }
-  static newLine(text) {
-    text ??= "\n";
-    let result;
-    switch (text) {
-      case "\n":
-        result = _Token.newLineToken;
-        break;
-      case "\r\n":
-        result = _Token.carriageReturnNewLineToken;
-        break;
-      default:
-        result = _Token.create(text, TokenType.NewLine);
-        break;
+};
+
+// sources/mutableHttpHeaders.ts
+var MutableHttpHeaders = class _MutableHttpHeaders {
+  headers;
+  constructor(headers) {
+    this.headers = List.create();
+    if (headers) {
+      this.setAll(headers);
     }
-    return result;
-  }
-  static leftParenthesis() {
-    return _Token.leftParenthesisToken;
-  }
-  static rightParenthesis() {
-    return _Token.rightParenthesisToken;
-  }
-  static backslash() {
-    return _Token.backslashToken;
   }
-  static forwardSlash() {
-    return _Token.forwardSlashToken;
+  static create(headers) {
+    return new _MutableHttpHeaders(headers);
   }
-  static period() {
-    return _Token.periodToken;
+  iterate() {
+    return this.headers.iterate();
   }
-  static underscore() {
-    return _Token.underscoreToken;
-  }
-  static colon() {
-    return _Token.colonToken;
-  }
-  static letters(text) {
-    return _Token.create(text, TokenType.Letters);
-  }
-  static digits(text) {
-    return _Token.create(text, TokenType.Digits);
-  }
-  static unknown(text) {
-    return _Token.create(text, TokenType.Unknown);
-  }
-  getText() {
-    return this.text;
-  }
-  getType() {
-    return this.type;
-  }
-};
-
-// sources/Tokenizer.ts
-var Tokenizer = class _Tokenizer {
-  characters;
-  currentToken;
-  started;
-  constructor(characters) {
-    this.characters = characters;
-    this.started = false;
-  }
-  static create(characters) {
-    PreCondition.assertNotUndefinedAndNotNull(characters, "characters");
-    return new _Tokenizer(isIterator(characters) ? characters : Iterator.create(characters));
-  }
-  hasStarted() {
-    return this.started;
-  }
-  hasCurrent() {
-    return this.currentToken !== void 0;
-  }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.currentToken;
-  }
-  next() {
+  get(headerName) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
     return SyncResult.create(() => {
-      if (!this.hasStarted()) {
-        this.characters.start().await();
-        this.started = true;
-      }
-      if (!this.characters.hasCurrent()) {
-        this.currentToken = void 0;
-      } else {
-        switch (this.characters.getCurrent()) {
-          case " ":
-          case "	":
-            this.currentToken = Token.whitespace(this.readWhile((c) => c === " " || c === "	"));
-            break;
-          case "\n":
-            this.characters.next().await();
-            this.currentToken = Token.newLine();
-            break;
-          case "\r":
-            if (this.characters.next().await() && this.characters.getCurrent() === "\n") {
-              this.characters.next().await();
-              this.currentToken = Token.newLine("\r\n");
-            } else {
-              this.currentToken = Token.whitespace("\r");
-            }
-            break;
-          case "(":
-            this.characters.next().await();
-            this.currentToken = Token.leftParenthesis();
-            break;
-          case ")":
-            this.characters.next().await();
-            this.currentToken = Token.rightParenthesis();
-            break;
-          case ".":
-            this.characters.next().await();
-            this.currentToken = Token.period();
-            break;
-          case "_":
-            this.characters.next().await();
-            this.currentToken = Token.underscore();
-            break;
-          case "/":
-            this.characters.next().await();
-            this.currentToken = Token.forwardSlash();
-            break;
-          case "\\":
-            this.characters.next().await();
-            this.currentToken = Token.backslash();
-            break;
-          case ":":
-            this.characters.next().await();
-            this.currentToken = Token.colon();
-            break;
-          default:
-            if (isLetter(this.characters.getCurrent())) {
-              this.currentToken = Token.letters(this.readWhile(isLetter));
-            } else if (isDigit(this.characters.getCurrent())) {
-              this.currentToken = Token.digits(this.readWhile(isDigit));
-            } else {
-              this.currentToken = Token.unknown(this.characters.takeCurrent().await());
-            }
-            break;
+      let result;
+      const lowerHeaderName = headerName.toLowerCase();
+      for (const header of this.headers) {
+        if (header.getName().toLowerCase() === lowerHeaderName) {
+          result = header;
+          break;
         }
       }
-      return this.hasCurrent();
+      if (result === void 0) {
+        throw new NotFoundError(`No HttpHeader found with the name ${escapeAndQuote(headerName)}.`);
+      }
+      return result;
     });
   }
-  readWhile(condition) {
-    PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
-    PreCondition.assertTrue(this.characters.hasCurrent(), "this.characters.hasCurrent()");
-    PreCondition.assertTrue(condition(this.characters.getCurrent()), "condition(this.characters.getCurrent())");
-    let result = "";
-    do {
-      result += this.characters.takeCurrent().await();
-    } while (this.characters.hasCurrent() && condition(this.characters.getCurrent()));
-    return result;
+  getValue(headerName) {
+    return this.get(headerName).then((header) => header.getValue());
   }
-  start() {
-    return Iterator.start(this);
+  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;
   }
-  takeCurrent() {
-    return Iterator.takeCurrent(this);
+  setAll(headers) {
+    PreCondition.assertNotUndefinedAndNotNull(headers, "headers");
+    for (const header of headers) {
+      this.set(header);
+    }
+    return this;
   }
-  any() {
-    return Iterator.any(this);
+  setContentType(contentType) {
+    return this.set(HttpHeaders.contentTypeHeaderName, contentType);
+  }
+  getContentType() {
+    return this.get(HttpHeaders.contentTypeHeaderName);
+  }
+  getContentTypeValue() {
+    return this.getValue(HttpHeaders.contentTypeHeaderName);
   }
   getCount() {
-    return Iterator.getCount(this);
+    return this.headers.getCount();
   }
   toArray() {
-    return Iterator.toArray(this);
+    return HttpHeaders.toArray(this);
   }
-  concatenate(...toConcatenate) {
-    return Iterator.concatenate(this, ...toConcatenate);
+  any() {
+    return HttpHeaders.any(this);
   }
-  where(condition) {
-    return Iterator.where(this, condition);
+  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 Iterator.map(this, mapping);
+    return HttpHeaders.map(this, mapping);
   }
   flatMap(mapping) {
-    return Iterator.flatMap(this, mapping);
+    return HttpHeaders.flatMap(this, mapping);
   }
-  whereInstanceOf(typeCheck) {
-    return Iterator.whereInstanceOf(this, typeCheck);
+  where(condition) {
+    return HttpHeaders.where(this, condition);
   }
-  whereInstanceOfType(type) {
-    return Iterator.whereInstanceOfType(this, type);
+  instanceOf(typeOrTypeCheck) {
+    return HttpHeaders.instanceOf(this, typeOrTypeCheck);
   }
   first(condition) {
-    return Iterator.first(this, condition);
+    return HttpHeaders.first(this, condition);
   }
   last(condition) {
-    return Iterator.last(this, condition);
-  }
-  take(maximumToTake) {
-    return Iterator.take(this, maximumToTake);
-  }
-  skip(maximumToSkip) {
-    return Iterator.skip(this, maximumToSkip);
+    return HttpHeaders.last(this, condition);
   }
   [Symbol.iterator]() {
-    return Iterator[Symbol.iterator](this);
+    return HttpHeaders[Symbol.iterator](this);
+  }
+  contains(value, equalFunctions) {
+    return HttpHeaders.contains(this, value, equalFunctions);
   }
 };
 
-// sources/asyncIteratorToJavascriptAsyncIteratorAdapter.ts
-var AsyncIteratorToJavascriptAsyncIteratorAdapter = class _AsyncIteratorToJavascriptAsyncIteratorAdapter {
-  iterator;
-  hasStarted;
-  constructor(iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    this.iterator = iterator;
-    this.hasStarted = false;
+// sources/httpHeaders.ts
+var HttpHeaders = class _HttpHeaders {
+  static contentTypeHeaderName = "Content-Type";
+  static create(headers) {
+    return MutableHttpHeaders.create(headers);
   }
-  static create(iterator) {
-    return new _AsyncIteratorToJavascriptAsyncIteratorAdapter(iterator);
+  getContentType() {
+    return _HttpHeaders.getContentType(this);
   }
-  async next() {
-    if (!this.hasStarted) {
-      this.hasStarted = true;
-      await this.iterator.start();
-    } else {
-      await this.iterator.next();
-    }
-    const result = {
-      done: !this.iterator.hasCurrent(),
-      value: void 0
-    };
-    if (!result.done) {
-      result.value = this.iterator.getCurrent();
-    }
-    return result;
+  static getContentType(headers) {
+    return headers.get(_HttpHeaders.contentTypeHeaderName);
   }
-};
-
-// sources/javascriptAsyncIteratorToAsyncIteratorAdapter.ts
-var JavascriptAsyncIteratorToAsyncIteratorAdapter = class _JavascriptAsyncIteratorToAsyncIteratorAdapter {
-  javascriptIterator;
-  javascriptIteratorResult;
-  constructor(javascriptIterator) {
-    PreCondition.assertNotUndefinedAndNotNull(javascriptIterator, "javascriptIterator");
-    this.javascriptIterator = javascriptIterator;
+  getContentTypeValue() {
+    return _HttpHeaders.getContentTypeValue(this);
   }
-  static create(javascriptIterator) {
-    if (isJavascriptAsyncIterable(javascriptIterator)) {
-      javascriptIterator = javascriptIterator[Symbol.asyncIterator]();
-    }
-    return new _JavascriptAsyncIteratorToAsyncIteratorAdapter(javascriptIterator);
+  static getContentTypeValue(headers) {
+    return headers.getValue(_HttpHeaders.contentTypeHeaderName);
   }
-  next() {
-    return PromiseAsyncResult.create(async () => {
-      this.javascriptIteratorResult = await this.javascriptIterator.next();
-      return this.hasCurrent();
-    });
+  /**
+   * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
+   */
+  toArray() {
+    return _HttpHeaders.toArray(this);
   }
-  hasStarted() {
-    return this.javascriptIteratorResult !== void 0;
+  static toArray(headers) {
+    return Iterable.toArray(headers);
   }
-  hasCurrent() {
-    return this.javascriptIteratorResult?.done === false;
+  any() {
+    return _HttpHeaders.any(this);
   }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.javascriptIteratorResult.value;
+  static any(headers) {
+    return Iterable.any(headers);
   }
-  start() {
-    return AsyncIterator.start(this);
+  getCount() {
+    return _HttpHeaders.getCount(this);
   }
-  takeCurrent() {
-    return AsyncIterator.takeCurrent(this);
+  static getCount(headers) {
+    return Iterable.getCount(headers);
   }
-  any() {
-    return AsyncIterator.any(this);
+  equals(right, equalFunctions) {
+    return _HttpHeaders.equals(this, right, equalFunctions);
   }
-  getCount() {
-    return AsyncIterator.getCount(this);
+  static equals(headers, right, equalFunctions) {
+    return Iterable.equals(headers, right, equalFunctions);
   }
-  toArray() {
-    return AsyncIterator.toArray(this);
+  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 AsyncIterator.map(this, mapping);
+    return _HttpHeaders.map(this, mapping);
   }
-  [Symbol.asyncIterator]() {
-    return AsyncIterator[Symbol.asyncIterator](this);
+  static map(headers, mapping) {
+    return Iterable.map(headers, mapping);
   }
-  first(condition) {
-    return AsyncIterator.first(this, condition);
+  flatMap(mapping) {
+    return _HttpHeaders.flatMap(this, mapping);
   }
-  last(condition) {
-    return AsyncIterator.last(this, condition);
+  static flatMap(headers, mapping) {
+    return Iterable.flatMap(headers, mapping);
   }
   where(condition) {
-    return AsyncIterator.where(this, condition);
-  }
-  whereInstanceOf(typeCheck) {
-    return AsyncIterator.whereInstanceOf(this, typeCheck);
+    return _HttpHeaders.where(this, condition);
   }
-  whereInstanceOfType(type) {
-    return AsyncIterator.whereInstanceOfType(this, type);
+  static where(headers, condition) {
+    return Iterable.where(headers, condition);
   }
-  take(maximumToTake) {
-    return AsyncIterator.take(this, maximumToTake);
+  instanceOf(typeOrTypeCheck) {
+    return _HttpHeaders.instanceOf(this, typeOrTypeCheck);
   }
-  skip(maximumToSkip) {
-    return AsyncIterator.skip(this, maximumToSkip);
+  static instanceOf(headers, typeOrTypeCheck) {
+    return Iterable.instanceOf(headers, typeOrTypeCheck);
   }
-};
-
-// sources/mapAsyncIterator.ts
-var MapAsyncIterator = class _MapAsyncIterator {
-  inputIterator;
-  mapping;
-  current;
-  started;
-  constructor(inputIterator, mapping) {
-    PreCondition.assertNotUndefinedAndNotNull(inputIterator, "inputIterator");
-    PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
-    this.inputIterator = inputIterator;
-    this.mapping = mapping;
-    this.started = false;
+  first(condition) {
+    return _HttpHeaders.first(this, condition);
   }
-  static create(inputIterator, mapping) {
-    return new _MapAsyncIterator(inputIterator, mapping);
+  static first(headers, condition) {
+    return Iterable.first(headers, condition);
   }
-  next() {
-    return PromiseAsyncResult.create(async () => {
-      if (!this.hasStarted()) {
-        this.started = true;
-        await this.inputIterator.start();
-      } else {
-        await this.inputIterator.next();
-      }
-      const result = this.inputIterator.hasCurrent();
-      this.current = result ? await this.mapping(this.inputIterator.getCurrent()) : void 0;
-      return result;
-    });
+  last(condition) {
+    return _HttpHeaders.last(this, condition);
   }
-  hasStarted() {
-    return this.started;
+  static last(headers, condition) {
+    return Iterable.last(headers, condition);
   }
-  hasCurrent() {
-    return this.hasStarted() && this.inputIterator.hasCurrent();
+  [Symbol.iterator]() {
+    return _HttpHeaders[Symbol.iterator](this);
   }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.current;
+  static [Symbol.iterator](headers) {
+    return Iterable[Symbol.iterator](headers);
   }
-  start() {
-    return AsyncIterator.start(this);
+  contains(value, equalFunctions) {
+    return _HttpHeaders.contains(this, value, equalFunctions);
   }
-  takeCurrent() {
-    return AsyncIterator.takeCurrent(this);
+  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();
+    });
   }
-  any() {
-    return AsyncIterator.any(this);
+};
+
+// sources/NodeJSHttpOutgoingResponse.ts
+var NodeJSHttpOutgoingResponse = class _NodeJSHttpOutgoingResponse {
+  innerResponse;
+  bodyString;
+  constructor(innerResponse) {
+    PreCondition.assertNotUndefinedAndNotNull(innerResponse, "innerResponse");
+    this.innerResponse = innerResponse;
   }
-  getCount() {
-    return AsyncIterator.getCount(this);
+  static create(innerResponse) {
+    return new _NodeJSHttpOutgoingResponse(innerResponse);
   }
-  toArray() {
-    return AsyncIterator.toArray(this);
+  setStatusCode(statusCode) {
+    this.innerResponse.statusCode = statusCode;
+    return this;
   }
-  map(mapping) {
-    return AsyncIterator.map(this, mapping);
+  getStatusCode() {
+    return SyncResult.value(this.innerResponse.statusCode);
   }
-  [Symbol.asyncIterator]() {
-    return AsyncIterator[Symbol.asyncIterator](this);
+  static headerValueToString(headerValue) {
+    PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
+    return isArray(headerValue) ? join(",", headerValue) : headerValue.toString();
   }
-  first(condition) {
-    return AsyncIterator.first(this, condition);
+  getHeaders() {
+    const result = HttpHeaders.create();
+    for (const rawHeader of Object.entries(this.innerResponse.getHeaders())) {
+      const headerName = rawHeader[0];
+      const headerValue = rawHeader[1];
+      if (headerValue !== void 0) {
+        result.set(headerName, _NodeJSHttpOutgoingResponse.headerValueToString(headerValue));
+      }
+    }
+    return result;
   }
-  last() {
-    return AsyncIterator.last(this);
+  getHeader(headerName) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    const headerValue = this.innerResponse.getHeader(headerName);
+    return headerValue === void 0 ? SyncResult.error(new NotFoundError(`No HTTP header value exists with the name ${escapeAndQuote(headerName)}.`)) : SyncResult.value(HttpHeader.create(headerName, _NodeJSHttpOutgoingResponse.headerValueToString(headerValue)));
   }
-  where(condition) {
-    return AsyncIterator.where(this, condition);
+  getHeaderValue(headerName) {
+    const headerValue = this.innerResponse.getHeader(headerName);
+    return headerValue === void 0 ? SyncResult.error(new NotFoundError(`No HTTP header value exists with the name ${escapeAndQuote(headerName)}.`)) : SyncResult.value(_NodeJSHttpOutgoingResponse.headerValueToString(headerValue));
   }
-  whereInstanceOf(typeCheck) {
-    return AsyncIterator.whereInstanceOf(this, typeCheck);
+  setHeader(headerName, headerValue) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
+    this.innerResponse.setHeader(headerName, headerValue);
+    return this;
   }
-  whereInstanceOfType(type) {
-    return AsyncIterator.whereInstanceOfType(this, type);
+  setBodyString(body) {
+    PreCondition.assertNotUndefinedAndNotNull(body, "body");
+    this.bodyString = body;
+    return this;
   }
-  take(maximumToTake) {
-    return AsyncIterator.take(this, maximumToTake);
+  setBodyJSON(body) {
+    PreCondition.assertNotUndefinedAndNotNull(body, "body");
+    return this.setBodyString(JSON.stringify(body));
   }
-  skip(maximumToSkip) {
-    return AsyncIterator.skip(this, maximumToSkip);
+  end() {
+    return AsyncResult.create(new Promise((resolve, reject) => {
+      this.innerResponse.end(this.bodyString, () => {
+        resolve();
+      });
+    }));
   }
 };
 
-// sources/skipAsyncIterator.ts
-var SkipAsyncIterator = class _SkipAsyncIterator {
-  innerIterator;
-  started;
-  maximumToSkip;
-  constructor(innerIterator, maximumToSkip) {
-    PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
-    PreCondition.assertNotUndefinedAndNotNull(maximumToSkip, "maximumToSkip");
-    PreCondition.assertInteger(maximumToSkip, "maximumToSkip");
-    PreCondition.assertGreaterThanOrEqualTo(maximumToSkip, 0, "maximumToSkip");
-    this.innerIterator = innerIterator;
-    this.started = false;
-    this.maximumToSkip = maximumToSkip;
+// sources/TokenType.ts
+var TokenType = class _TokenType {
+  name;
+  constructor(name) {
+    PreCondition.assertNotEmpty(name, "name");
+    this.name = name;
   }
-  static create(innerIterator, maximumToSkip) {
-    return new _SkipAsyncIterator(innerIterator, maximumToSkip);
+  static create(name) {
+    return new _TokenType(name);
   }
-  next() {
-    return PromiseAsyncResult.create(async () => {
-      if (!this.hasStarted()) {
-        this.started = true;
-        await this.innerIterator.start();
-        for (let i = 0; i < this.maximumToSkip; i++) {
-          if (!await this.innerIterator.next()) {
-            break;
-          }
-        }
-      } else {
-        await this.innerIterator.next();
-      }
-      return this.hasCurrent();
-    });
+  static Whitespace = _TokenType.create("Whitespace");
+  static NewLine = _TokenType.create("NewLine");
+  static Letters = _TokenType.create("Letters");
+  static Digits = _TokenType.create("Digits");
+  static LeftParenthesis = _TokenType.create("LeftParenthesis");
+  static RightParenthesis = _TokenType.create("RightParenthesis");
+  static Backslash = _TokenType.create("Backslash");
+  static ForwardSlash = _TokenType.create("ForwardSlash");
+  static Unknown = _TokenType.create("Unknown");
+  static Period = _TokenType.create("Period");
+  static Underscore = _TokenType.create("Underscore");
+  static Colon = _TokenType.create("Colon");
+  toString() {
+    return this.name;
   }
-  hasStarted() {
-    return this.started;
-  }
-  hasCurrent() {
-    return this.hasStarted() && this.innerIterator.hasCurrent();
+};
+
+// sources/Token.ts
+var Token = class _Token {
+  static newLineToken = _Token.create("\n", TokenType.NewLine);
+  static carriageReturnNewLineToken = _Token.create("\r\n", TokenType.NewLine);
+  static leftParenthesisToken = _Token.create("(", TokenType.LeftParenthesis);
+  static rightParenthesisToken = _Token.create(")", TokenType.RightParenthesis);
+  static backslashToken = _Token.create("\\", TokenType.Backslash);
+  static forwardSlashToken = _Token.create("/", TokenType.ForwardSlash);
+  static periodToken = _Token.create(".", TokenType.Period);
+  static underscoreToken = _Token.create("_", TokenType.Underscore);
+  static colonToken = _Token.create(":", TokenType.Colon);
+  text;
+  type;
+  constructor(text, type) {
+    PreCondition.assertNotEmpty(text, "text");
+    PreCondition.assertNotUndefinedAndNotNull(type, "type");
+    this.text = text;
+    this.type = type;
   }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.innerIterator.getCurrent();
+  static create(text, type) {
+    return new _Token(text, type);
   }
-  start() {
-    return AsyncIterator.start(this);
+  static whitespace(text) {
+    return _Token.create(text, TokenType.Whitespace);
   }
-  takeCurrent() {
-    return AsyncIterator.takeCurrent(this);
+  static newLine(text) {
+    text ??= "\n";
+    let result;
+    switch (text) {
+      case "\n":
+        result = _Token.newLineToken;
+        break;
+      case "\r\n":
+        result = _Token.carriageReturnNewLineToken;
+        break;
+      default:
+        result = _Token.create(text, TokenType.NewLine);
+        break;
+    }
+    return result;
   }
-  any() {
-    return AsyncIterator.any(this);
+  static leftParenthesis() {
+    return _Token.leftParenthesisToken;
   }
-  getCount() {
-    return AsyncIterator.getCount(this);
+  static rightParenthesis() {
+    return _Token.rightParenthesisToken;
   }
-  toArray() {
-    return AsyncIterator.toArray(this);
+  static backslash() {
+    return _Token.backslashToken;
   }
-  where(condition) {
-    return AsyncIterator.where(this, condition);
+  static forwardSlash() {
+    return _Token.forwardSlashToken;
   }
-  whereInstanceOf(typeCheck) {
-    return AsyncIterator.whereInstanceOf(this, typeCheck);
+  static period() {
+    return _Token.periodToken;
   }
-  whereInstanceOfType(type) {
-    return AsyncIterator.whereInstanceOfType(this, type);
+  static underscore() {
+    return _Token.underscoreToken;
   }
-  map(mapping) {
-    return AsyncIterator.map(this, mapping);
+  static colon() {
+    return _Token.colonToken;
   }
-  first(condition) {
-    return AsyncIterator.first(this, condition);
+  static letters(text) {
+    return _Token.create(text, TokenType.Letters);
   }
-  last(condition) {
-    return AsyncIterator.last(this, condition);
+  static digits(text) {
+    return _Token.create(text, TokenType.Digits);
   }
-  [Symbol.asyncIterator]() {
-    return AsyncIterator[Symbol.asyncIterator](this);
+  static unknown(text) {
+    return _Token.create(text, TokenType.Unknown);
   }
-  take(maximumToTake) {
-    return AsyncIterator.take(this, maximumToTake);
+  getText() {
+    return this.text;
   }
-  skip(maximumToSkip) {
-    return AsyncIterator.skip(this, maximumToSkip);
+  getType() {
+    return this.type;
   }
 };
 
-// sources/takeAsyncIterator.ts
-var TakeAsyncIterator = class _TakeAsyncIterator {
-  innerIterator;
+// sources/Tokenizer.ts
+var Tokenizer = class _Tokenizer {
+  characters;
+  currentToken;
   started;
-  maximumToTake;
-  taken;
-  constructor(innerIterator, maximumToTake) {
-    PreCondition.assertGreaterThanOrEqualTo(maximumToTake, 0, "maximumToTake");
-    this.innerIterator = innerIterator;
+  constructor(characters) {
+    this.characters = characters;
     this.started = false;
-    this.maximumToTake = maximumToTake;
-    this.taken = 0;
   }
-  static create(innerIterator, maximumToTake) {
-    return new _TakeAsyncIterator(innerIterator, maximumToTake);
+  static create(characters) {
+    PreCondition.assertNotUndefinedAndNotNull(characters, "characters");
+    return new _Tokenizer(isIterator(characters) ? characters : Iterator.create(characters));
+  }
+  hasStarted() {
+    return this.started;
   }
   hasCurrent() {
-    return this.hasStarted() && this.taken <= this.maximumToTake && this.innerIterator.hasCurrent();
+    return this.currentToken !== void 0;
+  }
+  getCurrent() {
+    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+    return this.currentToken;
   }
   next() {
-    return PromiseAsyncResult.create(async () => {
-      if (this.maximumToTake <= 0) {
-        return false;
-      } else if (!this.hasStarted()) {
+    return SyncResult.create(() => {
+      if (!this.hasStarted()) {
+        this.characters.start().await();
         this.started = true;
-        await this.innerIterator.start();
-        this.taken++;
-      } else if (this.taken <= this.maximumToTake) {
-        await this.innerIterator.next();
-        this.taken++;
+      }
+      if (!this.characters.hasCurrent()) {
+        this.currentToken = void 0;
+      } else {
+        switch (this.characters.getCurrent()) {
+          case " ":
+          case "	":
+            this.currentToken = Token.whitespace(this.readWhile((c) => c === " " || c === "	"));
+            break;
+          case "\n":
+            this.characters.next().await();
+            this.currentToken = Token.newLine();
+            break;
+          case "\r":
+            if (this.characters.next().await() && this.characters.getCurrent() === "\n") {
+              this.characters.next().await();
+              this.currentToken = Token.newLine("\r\n");
+            } else {
+              this.currentToken = Token.whitespace("\r");
+            }
+            break;
+          case "(":
+            this.characters.next().await();
+            this.currentToken = Token.leftParenthesis();
+            break;
+          case ")":
+            this.characters.next().await();
+            this.currentToken = Token.rightParenthesis();
+            break;
+          case ".":
+            this.characters.next().await();
+            this.currentToken = Token.period();
+            break;
+          case "_":
+            this.characters.next().await();
+            this.currentToken = Token.underscore();
+            break;
+          case "/":
+            this.characters.next().await();
+            this.currentToken = Token.forwardSlash();
+            break;
+          case "\\":
+            this.characters.next().await();
+            this.currentToken = Token.backslash();
+            break;
+          case ":":
+            this.characters.next().await();
+            this.currentToken = Token.colon();
+            break;
+          default:
+            if (isLetter(this.characters.getCurrent())) {
+              this.currentToken = Token.letters(this.readWhile(isLetter));
+            } else if (isDigit(this.characters.getCurrent())) {
+              this.currentToken = Token.digits(this.readWhile(isDigit));
+            } else {
+              this.currentToken = Token.unknown(this.characters.takeCurrent().await());
+            }
+            break;
+        }
       }
       return this.hasCurrent();
     });
   }
-  hasStarted() {
-    return this.started;
-  }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.innerIterator.getCurrent();
+  readWhile(condition) {
+    PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
+    PreCondition.assertTrue(this.characters.hasCurrent(), "this.characters.hasCurrent()");
+    PreCondition.assertTrue(condition(this.characters.getCurrent()), "condition(this.characters.getCurrent())");
+    let result = "";
+    do {
+      result += this.characters.takeCurrent().await();
+    } while (this.characters.hasCurrent() && condition(this.characters.getCurrent()));
+    return result;
   }
   start() {
-    return AsyncIterator.start(this);
+    return Iterator.start(this);
   }
   takeCurrent() {
-    return AsyncIterator.takeCurrent(this);
+    return Iterator.takeCurrent(this);
   }
   any() {
-    return AsyncIterator.any(this);
+    return Iterator.any(this);
   }
   getCount() {
-    return AsyncIterator.getCount(this);
+    return Iterator.getCount(this);
   }
   toArray() {
-    return AsyncIterator.toArray(this);
+    return Iterator.toArray(this);
+  }
+  concatenate(...toConcatenate) {
+    return Iterator.concatenate(this, ...toConcatenate);
   }
   where(condition) {
-    return AsyncIterator.where(this, condition);
+    return Iterator.where(this, condition);
+  }
+  map(mapping) {
+    return Iterator.map(this, mapping);
+  }
+  flatMap(mapping) {
+    return Iterator.flatMap(this, mapping);
   }
   whereInstanceOf(typeCheck) {
-    return AsyncIterator.whereInstanceOf(this, typeCheck);
+    return Iterator.whereInstanceOf(this, typeCheck);
   }
   whereInstanceOfType(type) {
-    return AsyncIterator.whereInstanceOfType(this, type);
-  }
-  map(mapping) {
-    return AsyncIterator.map(this, mapping);
+    return Iterator.whereInstanceOfType(this, type);
   }
   first(condition) {
-    return AsyncIterator.first(this, condition);
+    return Iterator.first(this, condition);
   }
   last(condition) {
-    return AsyncIterator.last(this, condition);
-  }
-  [Symbol.asyncIterator]() {
-    return AsyncIterator[Symbol.asyncIterator](this);
+    return Iterator.last(this, condition);
   }
   take(maximumToTake) {
-    return AsyncIterator.take(this, maximumToTake);
+    return Iterator.take(this, maximumToTake);
   }
   skip(maximumToSkip) {
-    return AsyncIterator.skip(this, maximumToSkip);
+    return Iterator.skip(this, maximumToSkip);
+  }
+  [Symbol.iterator]() {
+    return Iterator[Symbol.iterator](this);
   }
 };
 
-// sources/whereAsyncIterator.ts
-var WhereAsyncIterator = class _WhereAsyncIterator {
-  innerIterator;
-  started;
-  condition;
-  constructor(innerIterator, condition) {
-    PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
-    PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
-    this.innerIterator = innerIterator;
-    this.started = false;
-    this.condition = condition;
+// sources/asyncIteratorToJavascriptAsyncIteratorAdapter.ts
+var AsyncIteratorToJavascriptAsyncIteratorAdapter = class _AsyncIteratorToJavascriptAsyncIteratorAdapter {
+  iterator;
+  hasStarted;
+  constructor(iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    this.iterator = iterator;
+    this.hasStarted = false;
   }
-  hasStarted() {
-    return this.started;
+  static create(iterator) {
+    return new _AsyncIteratorToJavascriptAsyncIteratorAdapter(iterator);
   }
-  hasCurrent() {
-    return this.hasStarted() && this.innerIterator.hasCurrent();
+  async next() {
+    if (!this.hasStarted) {
+      this.hasStarted = true;
+      await this.iterator.start();
+    } else {
+      await this.iterator.next();
+    }
+    const result = {
+      done: !this.iterator.hasCurrent(),
+      value: void 0
+    };
+    if (!result.done) {
+      result.value = this.iterator.getCurrent();
+    }
+    return result;
   }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.innerIterator.getCurrent();
+};
+
+// sources/javascriptAsyncIteratorToAsyncIteratorAdapter.ts
+var JavascriptAsyncIteratorToAsyncIteratorAdapter = class _JavascriptAsyncIteratorToAsyncIteratorAdapter {
+  javascriptIterator;
+  javascriptIteratorResult;
+  constructor(javascriptIterator) {
+    PreCondition.assertNotUndefinedAndNotNull(javascriptIterator, "javascriptIterator");
+    this.javascriptIterator = javascriptIterator;
   }
-  static create(innerIterator, condition) {
-    return new _WhereAsyncIterator(innerIterator, condition);
+  static create(javascriptIterator) {
+    if (isJavascriptAsyncIterable(javascriptIterator)) {
+      javascriptIterator = javascriptIterator[Symbol.asyncIterator]();
+    }
+    return new _JavascriptAsyncIteratorToAsyncIteratorAdapter(javascriptIterator);
   }
   next() {
     return PromiseAsyncResult.create(async () => {
-      if (!this.hasStarted()) {
-        await this.innerIterator.start();
-        this.started = true;
-        while (this.hasCurrent() && !await this.condition(this.getCurrent())) {
-          await this.innerIterator.next();
-        }
-      } else {
-        do {
-          await this.innerIterator.next();
-        } while (this.hasCurrent() && !await this.condition(this.getCurrent()));
-      }
+      this.javascriptIteratorResult = await this.javascriptIterator.next();
       return this.hasCurrent();
     });
   }
+  hasStarted() {
+    return this.javascriptIteratorResult !== void 0;
+  }
+  hasCurrent() {
+    return this.javascriptIteratorResult?.done === false;
+  }
+  getCurrent() {
+    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+    return this.javascriptIteratorResult.value;
+  }
   start() {
     return AsyncIterator.start(this);
   }
@@ -5530,17 +5693,11 @@ var WhereAsyncIterator = class _WhereAsyncIterator {
   toArray() {
     return AsyncIterator.toArray(this);
   }
-  where(condition) {
-    return AsyncIterator.where(this, condition);
-  }
   map(mapping) {
     return AsyncIterator.map(this, mapping);
   }
-  whereInstanceOf(typeCheck) {
-    return AsyncIterator.whereInstanceOf(this, typeCheck);
-  }
-  whereInstanceOfType(type) {
-    return AsyncIterator.whereInstanceOfType(this, type);
+  [Symbol.asyncIterator]() {
+    return AsyncIterator[Symbol.asyncIterator](this);
   }
   first(condition) {
     return AsyncIterator.first(this, condition);
@@ -5548,565 +5705,223 @@ var WhereAsyncIterator = class _WhereAsyncIterator {
   last(condition) {
     return AsyncIterator.last(this, condition);
   }
+  where(condition) {
+    return AsyncIterator.where(this, condition);
+  }
+  whereInstanceOf(typeCheck) {
+    return AsyncIterator.whereInstanceOf(this, typeCheck);
+  }
+  whereInstanceOfType(type) {
+    return AsyncIterator.whereInstanceOfType(this, type);
+  }
   take(maximumToTake) {
     return AsyncIterator.take(this, maximumToTake);
   }
   skip(maximumToSkip) {
     return AsyncIterator.skip(this, maximumToSkip);
   }
-  [Symbol.asyncIterator]() {
-    return AsyncIterator[Symbol.asyncIterator](this);
-  }
 };
 
-// sources/asyncIterator.ts
-var AsyncIterator = class _AsyncIterator {
-  static create(iterator) {
-    return JavascriptAsyncIteratorToAsyncIteratorAdapter.create(iterator);
+// sources/mapAsyncIterator.ts
+var MapAsyncIterator = class _MapAsyncIterator {
+  inputIterator;
+  mapping;
+  current;
+  started;
+  constructor(inputIterator, mapping) {
+    PreCondition.assertNotUndefinedAndNotNull(inputIterator, "inputIterator");
+    PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
+    this.inputIterator = inputIterator;
+    this.mapping = mapping;
+    this.started = false;
   }
-  /**
-   * Move to the first value if this {@link AsyncIterator} hasn't started yet.
-   * @returns This object for method chaining.
-   */
-  start() {
-    return _AsyncIterator.start(this);
+  static create(inputIterator, mapping) {
+    return new _MapAsyncIterator(inputIterator, mapping);
   }
-  /**
-   * Move the provided {@link AsyncIterator} to its first value if it hasn't started yet.
-   */
-  static start(iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+  next() {
     return PromiseAsyncResult.create(async () => {
-      if (!iterator.hasStarted()) {
-        await iterator.next();
+      if (!this.hasStarted()) {
+        this.started = true;
+        await this.inputIterator.start();
+      } else {
+        await this.inputIterator.next();
       }
-      return iterator;
+      const result = this.inputIterator.hasCurrent();
+      this.current = result ? await this.mapping(this.inputIterator.getCurrent()) : void 0;
+      return result;
     });
   }
-  /**
-   * Get the current value from this {@link AsyncIterator} and advance this {@link AsyncIterator} to the
-   * next value.
-   */
-  takeCurrent() {
-    return _AsyncIterator.takeCurrent(this);
+  hasStarted() {
+    return this.started;
   }
-  static takeCurrent(iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    PreCondition.assertTrue(iterator.hasCurrent(), "iterator.hasCurrent()");
-    return PromiseAsyncResult.create(async () => {
-      const result = iterator.getCurrent();
-      await iterator.next();
-      return result;
-    });
+  hasCurrent() {
+    return this.hasStarted() && this.inputIterator.hasCurrent();
   }
-  [Symbol.asyncIterator]() {
-    return _AsyncIterator[Symbol.asyncIterator](this);
+  getCurrent() {
+    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+    return this.current;
   }
-  /**
-   * Convert the provided {@link AsyncIterator} to a {@link IteratorToJavascriptIteratorAdapter}.
-   * @param iterator The {@link AsyncIterator} to convert.
-   */
-  static [Symbol.asyncIterator](iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    return AsyncIteratorToJavascriptAsyncIteratorAdapter.create(iterator);
+  start() {
+    return AsyncIterator.start(this);
   }
-  /**
-   * Get whether this {@link AsyncIterator} contains any values.
-   * Note: This may advance the {@link AsyncIterator} to the first value if it hasn't been
-   * started yet.
-   */
-  any() {
-    return _AsyncIterator.any(this);
+  takeCurrent() {
+    return AsyncIterator.takeCurrent(this);
   }
-  /**
-   * Get whether this {@link AsyncIterator} contains any values.
-   * Note: This may advance the {@link AsyncIterator} to the first value if it hasn't been
-   * started yet.
-   */
-  static any(iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    return PromiseAsyncResult.create(async () => {
-      await iterator.start();
-      return iterator.hasCurrent();
-    });
+  any() {
+    return AsyncIterator.any(this);
   }
-  /**
-   * Get the number of values in this {@link AsyncIterator}.
-   * Note: This will consume all of the values in this {@link AsyncIterator}.
-   */
   getCount() {
-    return _AsyncIterator.getCount(this);
-  }
-  /**
-   * Get the number of values in the provided {@link AsyncIterator}.
-   * Note: This will consume all of the values in the provided {@link AsyncIterator}.
-   */
-  static getCount(iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    return PromiseAsyncResult.create(async () => {
-      let result = 0;
-      if (iterator.hasCurrent()) {
-        result++;
-      }
-      while (await iterator.next()) {
-        result++;
-      }
-      return result;
-    });
+    return AsyncIterator.getCount(this);
   }
-  /**
-   * Get all of the remaining values in this {@link AsyncIterator} in a {@link T} {@link Array}.
-   */
   toArray() {
-    return _AsyncIterator.toArray(this);
-  }
-  /**
-   * Get all of the remaining values in the provided {@link AsyncIterator} in a {@link T}
-   * {@link Array}.
-   */
-  static toArray(iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    return PromiseAsyncResult.create(async () => {
-      const result = [];
-      if (iterator.hasCurrent()) {
-        result.push(iterator.getCurrent());
-      }
-      while (await iterator.next()) {
-        result.push(iterator.getCurrent());
-      }
-      return result;
-    });
+    return AsyncIterator.toArray(this);
   }
-  /**
-   * Get an {@link AsyncIterator} that will only return values that match the provided condition.
-   * @param condition The condition to run against each of the values in this {@link AsyncIterator}.
-   */
-  where(condition) {
-    return _AsyncIterator.where(this, condition);
+  map(mapping) {
+    return AsyncIterator.map(this, mapping);
   }
-  static where(iterator, condition) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
-    return WhereAsyncIterator.create(iterator, condition);
+  [Symbol.asyncIterator]() {
+    return AsyncIterator[Symbol.asyncIterator](this);
   }
-  /**
-   * Get a {@link MapIterator} that will map all {@link T} values from this {@link AsyncIterator} to
-   * {@link TOutput} values.
-   * @param mapping The mapping that maps {@link T} values to {@link TOutput} values.
-   */
-  map(mapping) {
-    return _AsyncIterator.map(this, mapping);
+  first(condition) {
+    return AsyncIterator.first(this, condition);
   }
-  static map(iterator, mapping) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
-    return MapAsyncIterator.create(iterator, mapping);
+  last() {
+    return AsyncIterator.last(this);
   }
-  /**
-   * Get an {@link AsyncIterator} that will filter this {@link AsyncIterator} to only the values that are
-   * instances of {@link U} based on the provided type check {@link Function}.
-   * @param typeCheck The {@link Function} that will be used to determine if values are of type
-   * {@link U}.
-   */
-  whereInstanceOf(typeCheck) {
-    return _AsyncIterator.whereInstanceOf(this, typeCheck);
+  where(condition) {
+    return AsyncIterator.where(this, condition);
   }
-  static whereInstanceOf(iterator, typeCheck) {
-    PreCondition.assertNotUndefinedAndNotNull(typeCheck, "typeCheck");
-    return iterator.where(typeCheck).map((value) => value);
+  whereInstanceOf(typeCheck) {
+    return AsyncIterator.whereInstanceOf(this, typeCheck);
   }
-  /**
-   * Get an {@link AsyncIterator} that will filter this {@link AsyncIterator} to only the values that are
-   * instances of the provided {@link Type}.
-   * @param type The type of values to return from the new {@link AsyncIterator}.
-   */
   whereInstanceOfType(type) {
-    return _AsyncIterator.whereInstanceOfType(this, type);
+    return AsyncIterator.whereInstanceOfType(this, type);
   }
-  static whereInstanceOfType(iterator, type) {
-    PreCondition.assertNotUndefinedAndNotNull(type, "type");
-    return iterator.whereInstanceOf((value) => instanceOfType(value, type));
+  take(maximumToTake) {
+    return AsyncIterator.take(this, maximumToTake);
   }
-  /**
-   * If the condition function is undefined, then this function will return the first value in
-   * this {@link AsyncIterator}. If this condition function is provided, then this function will return
-   * the first value that matches the provided condition.
-   * @param condition The condition that the returned value must satisfy.
-   */
-  first(condition) {
-    return _AsyncIterator.first(this, condition);
+  skip(maximumToSkip) {
+    return AsyncIterator.skip(this, maximumToSkip);
   }
-  /**
-   * If the condition function is undefined, then this function will return the first value in
-   * the {@link AsyncIterator}. If this condition function is provided, then this function will return
-   * the first value that matches the provided condition.
-   * @param iterator The {@link AsyncIterator} to get the first value from.
-   */
-  static first(iterator, condition) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
-    return PromiseAsyncResult.create(async () => {
-      await iterator.start();
-      if (isUndefinedOrNull(condition)) {
-        if (!iterator.hasCurrent()) {
-          throw new EmptyError();
-        }
-      } else {
-        while (iterator.hasCurrent() && !await condition(iterator.getCurrent())) {
-          await iterator.next();
-        }
-        if (!iterator.hasCurrent()) {
-          throw new NotFoundError("No value was found in the AsyncIterator that matched the provided condition.");
-        }
-      }
-      return iterator.getCurrent();
-    });
+};
+
+// sources/skipAsyncIterator.ts
+var SkipAsyncIterator = class _SkipAsyncIterator {
+  innerIterator;
+  started;
+  maximumToSkip;
+  constructor(innerIterator, maximumToSkip) {
+    PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
+    PreCondition.assertNotUndefinedAndNotNull(maximumToSkip, "maximumToSkip");
+    PreCondition.assertInteger(maximumToSkip, "maximumToSkip");
+    PreCondition.assertGreaterThanOrEqualTo(maximumToSkip, 0, "maximumToSkip");
+    this.innerIterator = innerIterator;
+    this.started = false;
+    this.maximumToSkip = maximumToSkip;
   }
-  /**
-   * If the condition function is undefined, then this function will return the last value in this
-   * {@link AsyncIterator}. If this condition function is provided, then this function will return the
-   * last value that matches the provided condition.
-   * @param condition The condition that the returned value must satisfy.
-   */
-  last(condition) {
-    return _AsyncIterator.last(this, condition);
+  static create(innerIterator, maximumToSkip) {
+    return new _SkipAsyncIterator(innerIterator, maximumToSkip);
   }
-  /**
-   * If the condition function is undefined, then this function will return the last value in the
-   * {@link AsyncIterator}. If this condition function is provided, then this function will return the
-   * last value that matches the provided condition.
-   * @param iterator The {@link AsyncIterator} to get the last value from.
-   */
-  static last(iterator, condition) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+  next() {
     return PromiseAsyncResult.create(async () => {
-      await iterator.start();
-      if (!iterator.hasCurrent()) {
-        throw new EmptyError();
-      }
-      let result;
-      let found = false;
-      do {
-        if (!condition || await condition(iterator.getCurrent())) {
-          result = iterator.getCurrent();
-          found = true;
-        }
-      } while (await iterator.next());
-      if (!found) {
-        if (!condition) {
-          throw new EmptyError();
-        } else {
-          throw new NotFoundError("No value was found in the AsyncIterator that matched the provided condition.");
+      if (!this.hasStarted()) {
+        this.started = true;
+        await this.innerIterator.start();
+        for (let i = 0; i < this.maximumToSkip; i++) {
+          if (!await this.innerIterator.next()) {
+            break;
+          }
         }
+      } else {
+        await this.innerIterator.next();
       }
-      return result;
+      return this.hasCurrent();
     });
   }
-  /**
-   * Find the maximum value in the provided {@link AsyncIterator}.
-   * @param iterator The values to find the maximum of.
-   */
-  static findMaximum(iterator) {
-    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterable");
-    return PromiseAsyncResult.create(async () => {
-      if (isJavascriptAsyncIterator(iterator)) {
-        iterator = _AsyncIterator.create(iterator);
-      }
-      let result = await iterator.first().convertError(EmptyError, () => new EmptyError("Can't find the maximum of an empty Iterator."));
-      while (await iterator.next()) {
-        const currentValue = iterator.getCurrent();
-        if (result.lessThan(currentValue)) {
-          result = currentValue;
-        }
-      }
-      return result;
-    });
+  hasStarted() {
+    return this.started;
   }
-  /**
-   * Get a new {@link AsyncIterator} that wraps around this {@link AsyncIterator} and only
-   * returns a maximum number of values from this {@link AsyncIterator}.
-   * @param maximumToTake The maximum number of values to take from this {@link AsyncIterator}.
-   */
-  take(maximumToTake) {
-    return _AsyncIterator.take(this, maximumToTake);
+  hasCurrent() {
+    return this.hasStarted() && this.innerIterator.hasCurrent();
   }
-  static take(iterator, maximumToTake) {
-    return TakeAsyncIterator.create(iterator, maximumToTake);
+  getCurrent() {
+    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+    return this.innerIterator.getCurrent();
   }
-  /**
-   * Get a new {@link AsyncIterator} that wraps around this {@link AsyncIterator} and will skip the initial
-   * provided number of values before beginning to return values.
-   * @param maximumToSkip The maximum number of values to skip from this {@link AsyncIterator}.
-   */
-  skip(maximumToSkip) {
-    return _AsyncIterator.skip(this, maximumToSkip);
+  start() {
+    return AsyncIterator.start(this);
   }
-  static skip(iterator, maximumToSkip) {
-    return SkipAsyncIterator.create(iterator, maximumToSkip);
+  takeCurrent() {
+    return AsyncIterator.takeCurrent(this);
   }
-};
-
-// sources/basicDisposable.ts
-var SyncDisposable = class _SyncDisposable {
-  disposedFunction;
-  disposed;
-  constructor(disposedFunction) {
-    PreCondition.assertNotUndefinedAndNotNull(disposedFunction, "disposedFunction");
-    this.disposedFunction = disposedFunction;
-    this.disposed = false;
+  any() {
+    return AsyncIterator.any(this);
   }
-  /**
-   * 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);
+  getCount() {
+    return AsyncIterator.getCount(this);
   }
-  dispose() {
-    return SyncResult.create(() => {
-      const result = !this.disposed;
-      if (result) {
-        try {
-          this.disposedFunction();
-        } finally {
-          this.disposed = true;
-        }
-      }
-      return result;
-    });
+  toArray() {
+    return AsyncIterator.toArray(this);
   }
-  isDisposed() {
-    return this.disposed;
+  where(condition) {
+    return AsyncIterator.where(this, condition);
   }
-};
-
-// sources/byteList.ts
-var ByteList = class _ByteList {
-  bytes;
-  count;
-  constructor() {
-    this.bytes = new Uint8Array(0);
-    this.count = 0;
+  whereInstanceOf(typeCheck) {
+    return AsyncIterator.whereInstanceOf(this, typeCheck);
   }
-  static create(initialValues) {
-    const result = new _ByteList();
-    if (initialValues) {
-      result.addAll(initialValues);
-    }
-    return result;
+  whereInstanceOfType(type) {
+    return AsyncIterator.whereInstanceOfType(this, type);
   }
-  add(value) {
-    return List.add(this, value);
+  map(mapping) {
+    return AsyncIterator.map(this, mapping);
   }
-  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);
+  first(condition) {
+    return AsyncIterator.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;
+    return AsyncIterator.last(this, condition);
   }
-  /**
-   * Get the number of bytes that are available to be read.
-   */
-  getAvailableByteCount() {
-    return this.list.getCount().await();
+  [Symbol.asyncIterator]() {
+    return AsyncIterator[Symbol.asyncIterator](this);
   }
-  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);
+  take(maximumToTake) {
+    return AsyncIterator.take(this, maximumToTake);
   }
-  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;
+  skip(maximumToSkip) {
+    return AsyncIterator.skip(this, maximumToSkip);
   }
 };
 
-// sources/byteReadStream.ts
-var ByteReadStream = class {
-};
-
-// sources/byteWriteStream.ts
-var ByteWriteStream = class {
-};
-
-// sources/stringIterator.ts
-var StringIterator = class _StringIterator {
-  value;
-  currentIndex;
+// sources/takeAsyncIterator.ts
+var TakeAsyncIterator = class _TakeAsyncIterator {
+  innerIterator;
   started;
-  constructor(value) {
-    this.value = value;
-    this.currentIndex = 0;
+  maximumToTake;
+  taken;
+  constructor(innerIterator, maximumToTake) {
+    PreCondition.assertGreaterThanOrEqualTo(maximumToTake, 0, "maximumToTake");
+    this.innerIterator = innerIterator;
     this.started = false;
+    this.maximumToTake = maximumToTake;
+    this.taken = 0;
   }
-  static create(value) {
-    PreCondition.assertNotUndefinedAndNotNull(value, "value");
-    return new _StringIterator(value);
+  static create(innerIterator, maximumToTake) {
+    return new _TakeAsyncIterator(innerIterator, maximumToTake);
   }
-  getCurrentIndex() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.currentIndex;
+  hasCurrent() {
+    return this.hasStarted() && this.taken <= this.maximumToTake && this.innerIterator.hasCurrent();
   }
   next() {
-    return SyncResult.create(() => {
-      if (!this.hasStarted()) {
+    return PromiseAsyncResult.create(async () => {
+      if (this.maximumToTake <= 0) {
+        return false;
+      } else if (!this.hasStarted()) {
         this.started = true;
-      } else if (this.hasCurrent()) {
-        this.currentIndex++;
+        await this.innerIterator.start();
+        this.taken++;
+      } else if (this.taken <= this.maximumToTake) {
+        await this.innerIterator.next();
+        this.taken++;
       }
       return this.hasCurrent();
     });
@@ -6114,135 +5929,546 @@ var StringIterator = class _StringIterator {
   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];
+    return this.innerIterator.getCurrent();
   }
   start() {
-    return Iterator.start(this);
+    return AsyncIterator.start(this);
   }
   takeCurrent() {
-    return Iterator.takeCurrent(this);
+    return AsyncIterator.takeCurrent(this);
   }
   any() {
-    return Iterator.any(this);
+    return AsyncIterator.any(this);
   }
   getCount() {
-    return Iterator.getCount(this);
+    return AsyncIterator.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);
+    return AsyncIterator.toArray(this);
   }
   where(condition) {
-    return Iterator.where(this, condition);
+    return AsyncIterator.where(this, condition);
   }
   whereInstanceOf(typeCheck) {
-    return Iterator.whereInstanceOf(this, typeCheck);
+    return AsyncIterator.whereInstanceOf(this, typeCheck);
   }
   whereInstanceOfType(type) {
-    return Iterator.whereInstanceOfType(this, type);
+    return AsyncIterator.whereInstanceOfType(this, type);
   }
-  take(maximumToTake) {
-    return Iterator.take(this, maximumToTake);
+  map(mapping) {
+    return AsyncIterator.map(this, mapping);
+  }
+  first(condition) {
+    return AsyncIterator.first(this, condition);
+  }
+  last(condition) {
+    return AsyncIterator.last(this, condition);
+  }
+  [Symbol.asyncIterator]() {
+    return AsyncIterator[Symbol.asyncIterator](this);
+  }
+  take(maximumToTake) {
+    return AsyncIterator.take(this, maximumToTake);
   }
   skip(maximumToSkip) {
-    return Iterator.skip(this, maximumToSkip);
+    return AsyncIterator.skip(this, maximumToSkip);
+  }
+};
+
+// sources/whereAsyncIterator.ts
+var WhereAsyncIterator = class _WhereAsyncIterator {
+  innerIterator;
+  started;
+  condition;
+  constructor(innerIterator, condition) {
+    PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
+    PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
+    this.innerIterator = innerIterator;
+    this.started = false;
+    this.condition = condition;
+  }
+  hasStarted() {
+    return this.started;
+  }
+  hasCurrent() {
+    return this.hasStarted() && this.innerIterator.hasCurrent();
+  }
+  getCurrent() {
+    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+    return this.innerIterator.getCurrent();
+  }
+  static create(innerIterator, condition) {
+    return new _WhereAsyncIterator(innerIterator, condition);
+  }
+  next() {
+    return PromiseAsyncResult.create(async () => {
+      if (!this.hasStarted()) {
+        await this.innerIterator.start();
+        this.started = true;
+        while (this.hasCurrent() && !await this.condition(this.getCurrent())) {
+          await this.innerIterator.next();
+        }
+      } else {
+        do {
+          await this.innerIterator.next();
+        } while (this.hasCurrent() && !await this.condition(this.getCurrent()));
+      }
+      return this.hasCurrent();
+    });
+  }
+  start() {
+    return AsyncIterator.start(this);
+  }
+  takeCurrent() {
+    return AsyncIterator.takeCurrent(this);
+  }
+  any() {
+    return AsyncIterator.any(this);
+  }
+  getCount() {
+    return AsyncIterator.getCount(this);
+  }
+  toArray() {
+    return AsyncIterator.toArray(this);
+  }
+  where(condition) {
+    return AsyncIterator.where(this, condition);
+  }
+  map(mapping) {
+    return AsyncIterator.map(this, mapping);
+  }
+  whereInstanceOf(typeCheck) {
+    return AsyncIterator.whereInstanceOf(this, typeCheck);
+  }
+  whereInstanceOfType(type) {
+    return AsyncIterator.whereInstanceOfType(this, type);
+  }
+  first(condition) {
+    return AsyncIterator.first(this, condition);
+  }
+  last(condition) {
+    return AsyncIterator.last(this, condition);
+  }
+  take(maximumToTake) {
+    return AsyncIterator.take(this, maximumToTake);
+  }
+  skip(maximumToSkip) {
+    return AsyncIterator.skip(this, maximumToSkip);
+  }
+  [Symbol.asyncIterator]() {
+    return AsyncIterator[Symbol.asyncIterator](this);
+  }
+};
+
+// sources/asyncIterator.ts
+var AsyncIterator = class _AsyncIterator {
+  static create(iterator) {
+    return JavascriptAsyncIteratorToAsyncIteratorAdapter.create(iterator);
+  }
+  /**
+   * Move to the first value if this {@link AsyncIterator} hasn't started yet.
+   * @returns This object for method chaining.
+   */
+  start() {
+    return _AsyncIterator.start(this);
+  }
+  /**
+   * Move the provided {@link AsyncIterator} to its first value if it hasn't started yet.
+   */
+  static start(iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    return PromiseAsyncResult.create(async () => {
+      if (!iterator.hasStarted()) {
+        await iterator.next();
+      }
+      return iterator;
+    });
+  }
+  /**
+   * Get the current value from this {@link AsyncIterator} and advance this {@link AsyncIterator} to the
+   * next value.
+   */
+  takeCurrent() {
+    return _AsyncIterator.takeCurrent(this);
+  }
+  static takeCurrent(iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    PreCondition.assertTrue(iterator.hasCurrent(), "iterator.hasCurrent()");
+    return PromiseAsyncResult.create(async () => {
+      const result = iterator.getCurrent();
+      await iterator.next();
+      return result;
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return _AsyncIterator[Symbol.asyncIterator](this);
+  }
+  /**
+   * Convert the provided {@link AsyncIterator} to a {@link IteratorToJavascriptIteratorAdapter}.
+   * @param iterator The {@link AsyncIterator} to convert.
+   */
+  static [Symbol.asyncIterator](iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    return AsyncIteratorToJavascriptAsyncIteratorAdapter.create(iterator);
+  }
+  /**
+   * Get whether this {@link AsyncIterator} contains any values.
+   * Note: This may advance the {@link AsyncIterator} to the first value if it hasn't been
+   * started yet.
+   */
+  any() {
+    return _AsyncIterator.any(this);
+  }
+  /**
+   * Get whether this {@link AsyncIterator} contains any values.
+   * Note: This may advance the {@link AsyncIterator} to the first value if it hasn't been
+   * started yet.
+   */
+  static any(iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    return PromiseAsyncResult.create(async () => {
+      await iterator.start();
+      return iterator.hasCurrent();
+    });
+  }
+  /**
+   * Get the number of values in this {@link AsyncIterator}.
+   * Note: This will consume all of the values in this {@link AsyncIterator}.
+   */
+  getCount() {
+    return _AsyncIterator.getCount(this);
+  }
+  /**
+   * Get the number of values in the provided {@link AsyncIterator}.
+   * Note: This will consume all of the values in the provided {@link AsyncIterator}.
+   */
+  static getCount(iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    return PromiseAsyncResult.create(async () => {
+      let result = 0;
+      if (iterator.hasCurrent()) {
+        result++;
+      }
+      while (await iterator.next()) {
+        result++;
+      }
+      return result;
+    });
+  }
+  /**
+   * Get all of the remaining values in this {@link AsyncIterator} in a {@link T} {@link Array}.
+   */
+  toArray() {
+    return _AsyncIterator.toArray(this);
+  }
+  /**
+   * Get all of the remaining values in the provided {@link AsyncIterator} in a {@link T}
+   * {@link Array}.
+   */
+  static toArray(iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    return PromiseAsyncResult.create(async () => {
+      const result = [];
+      if (iterator.hasCurrent()) {
+        result.push(iterator.getCurrent());
+      }
+      while (await iterator.next()) {
+        result.push(iterator.getCurrent());
+      }
+      return result;
+    });
+  }
+  /**
+   * Get an {@link AsyncIterator} that will only return values that match the provided condition.
+   * @param condition The condition to run against each of the values in this {@link AsyncIterator}.
+   */
+  where(condition) {
+    return _AsyncIterator.where(this, condition);
+  }
+  static where(iterator, condition) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
+    return WhereAsyncIterator.create(iterator, condition);
+  }
+  /**
+   * Get a {@link MapIterator} that will map all {@link T} values from this {@link AsyncIterator} to
+   * {@link TOutput} values.
+   * @param mapping The mapping that maps {@link T} values to {@link TOutput} values.
+   */
+  map(mapping) {
+    return _AsyncIterator.map(this, mapping);
+  }
+  static map(iterator, mapping) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
+    return MapAsyncIterator.create(iterator, mapping);
+  }
+  /**
+   * Get an {@link AsyncIterator} that will filter this {@link AsyncIterator} to only the values that are
+   * instances of {@link U} based on the provided type check {@link Function}.
+   * @param typeCheck The {@link Function} that will be used to determine if values are of type
+   * {@link U}.
+   */
+  whereInstanceOf(typeCheck) {
+    return _AsyncIterator.whereInstanceOf(this, typeCheck);
+  }
+  static whereInstanceOf(iterator, typeCheck) {
+    PreCondition.assertNotUndefinedAndNotNull(typeCheck, "typeCheck");
+    return iterator.where(typeCheck).map((value) => value);
+  }
+  /**
+   * Get an {@link AsyncIterator} that will filter this {@link AsyncIterator} to only the values that are
+   * instances of the provided {@link Type}.
+   * @param type The type of values to return from the new {@link AsyncIterator}.
+   */
+  whereInstanceOfType(type) {
+    return _AsyncIterator.whereInstanceOfType(this, type);
+  }
+  static whereInstanceOfType(iterator, type) {
+    PreCondition.assertNotUndefinedAndNotNull(type, "type");
+    return iterator.whereInstanceOf((value) => instanceOfType(value, type));
+  }
+  /**
+   * If the condition function is undefined, then this function will return the first value in
+   * this {@link AsyncIterator}. If this condition function is provided, then this function will return
+   * the first value that matches the provided condition.
+   * @param condition The condition that the returned value must satisfy.
+   */
+  first(condition) {
+    return _AsyncIterator.first(this, condition);
+  }
+  /**
+   * If the condition function is undefined, then this function will return the first value in
+   * the {@link AsyncIterator}. If this condition function is provided, then this function will return
+   * the first value that matches the provided condition.
+   * @param iterator The {@link AsyncIterator} to get the first value from.
+   */
+  static first(iterator, condition) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    return PromiseAsyncResult.create(async () => {
+      await iterator.start();
+      if (isUndefinedOrNull(condition)) {
+        if (!iterator.hasCurrent()) {
+          throw new EmptyError();
+        }
+      } else {
+        while (iterator.hasCurrent() && !await condition(iterator.getCurrent())) {
+          await iterator.next();
+        }
+        if (!iterator.hasCurrent()) {
+          throw new NotFoundError("No value was found in the AsyncIterator that matched the provided condition.");
+        }
+      }
+      return iterator.getCurrent();
+    });
+  }
+  /**
+   * If the condition function is undefined, then this function will return the last value in this
+   * {@link AsyncIterator}. If this condition function is provided, then this function will return the
+   * last value that matches the provided condition.
+   * @param condition The condition that the returned value must satisfy.
+   */
+  last(condition) {
+    return _AsyncIterator.last(this, condition);
+  }
+  /**
+   * If the condition function is undefined, then this function will return the last value in the
+   * {@link AsyncIterator}. If this condition function is provided, then this function will return the
+   * last value that matches the provided condition.
+   * @param iterator The {@link AsyncIterator} to get the last value from.
+   */
+  static last(iterator, condition) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterator");
+    return PromiseAsyncResult.create(async () => {
+      await iterator.start();
+      if (!iterator.hasCurrent()) {
+        throw new EmptyError();
+      }
+      let result;
+      let found = false;
+      do {
+        if (!condition || await condition(iterator.getCurrent())) {
+          result = iterator.getCurrent();
+          found = true;
+        }
+      } while (await iterator.next());
+      if (!found) {
+        if (!condition) {
+          throw new EmptyError();
+        } else {
+          throw new NotFoundError("No value was found in the AsyncIterator that matched the provided condition.");
+        }
+      }
+      return result;
+    });
+  }
+  /**
+   * Find the maximum value in the provided {@link AsyncIterator}.
+   * @param iterator The values to find the maximum of.
+   */
+  static findMaximum(iterator) {
+    PreCondition.assertNotUndefinedAndNotNull(iterator, "iterable");
+    return PromiseAsyncResult.create(async () => {
+      if (isJavascriptAsyncIterator(iterator)) {
+        iterator = _AsyncIterator.create(iterator);
+      }
+      let result = await iterator.first().convertError(EmptyError, () => new EmptyError("Can't find the maximum of an empty Iterator."));
+      while (await iterator.next()) {
+        const currentValue = iterator.getCurrent();
+        if (result.lessThan(currentValue)) {
+          result = currentValue;
+        }
+      }
+      return result;
+    });
+  }
+  /**
+   * Get a new {@link AsyncIterator} that wraps around this {@link AsyncIterator} and only
+   * returns a maximum number of values from this {@link AsyncIterator}.
+   * @param maximumToTake The maximum number of values to take from this {@link AsyncIterator}.
+   */
+  take(maximumToTake) {
+    return _AsyncIterator.take(this, maximumToTake);
+  }
+  static take(iterator, maximumToTake) {
+    return TakeAsyncIterator.create(iterator, maximumToTake);
+  }
+  /**
+   * Get a new {@link AsyncIterator} that wraps around this {@link AsyncIterator} and will skip the initial
+   * provided number of values before beginning to return values.
+   * @param maximumToSkip The maximum number of values to skip from this {@link AsyncIterator}.
+   */
+  skip(maximumToSkip) {
+    return _AsyncIterator.skip(this, maximumToSkip);
+  }
+  static skip(iterator, maximumToSkip) {
+    return SkipAsyncIterator.create(iterator, maximumToSkip);
+  }
+};
+
+// 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;
+    });
   }
-  [Symbol.iterator]() {
-    return Iterator[Symbol.iterator](this);
+  isDisposed() {
+    return this.disposed;
   }
 };
 
-// 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 = "";
+// 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;
   }
-  static create(values) {
-    return new _CharacterList(values);
+  add(value) {
+    return List.add(this, value);
   }
-  getCount() {
-    return SyncResult.value(this.characters.length);
+  addAll(values) {
+    return List.addAll(this, values);
   }
   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;
+    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 {
-      this.characters = this.characters.slice(0, index) + value + this.characters.slice(index);
+      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;
   }
-  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) {
+    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 List.any(this);
+    return this.getCount().then((count) => count > 0);
+  }
+  getCount() {
+    return SyncResult.value(this.count);
   }
   equals(right, equalFunctions) {
     return List.equals(this, right, equalFunctions);
@@ -6279,100 +6505,42 @@ var CharacterList = class _CharacterList {
   }
 };
 
-// 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/characterListStream.ts
-var CharacterListStream = class _CharacterListStream {
+// sources/byteListStream.ts
+var ByteListStream = class _ByteListStream {
   list;
   constructor() {
-    this.list = CharacterList.create();
+    this.list = ByteList.create();
   }
   static create(initialValues) {
-    const result = new _CharacterListStream();
+    const result = new _ByteListStream();
     if (initialValues) {
-      result.writeCharacters(initialValues).await();
+      result.writeBytes(initialValues).await();
     }
     return result;
   }
-  writeCharacters(characters, startIndex, length) {
-    PreCondition.assertNotUndefinedAndNotNull(characters, "characters");
-    const characterString = isString(characters) ? characters : join("", characters);
+  /**
+   * 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 = characterString.length - startIndex;
+      length = bytes.length - startIndex;
     }
-    PreCondition.assertInsertIndex(startIndex, characterString.length, "startIndex");
-    PreCondition.assertBetween(0, length, characterString.length - startIndex, "length");
-    this.list.addAll(characterString.slice(startIndex, 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);
   }
-  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) {
+  readBytes(countOrOutput, startIndex, count) {
     let result;
     if (isNumber(countOrOutput)) {
       PreCondition.assertGreaterThanOrEqualTo(countOrOutput, 0, "count");
@@ -6380,9 +6548,9 @@ var CharacterListStream = class _CharacterListStream {
         result = SyncResult.error(new EmptyError());
       } else {
         const bytesReadCount = Math.min(countOrOutput, this.list.getCount().await());
-        let output = "";
+        const output = new Uint8Array(bytesReadCount);
         for (let i = 0; i < bytesReadCount; i++) {
-          output += this.list.removeFirst().await();
+          output[i] = this.list.removeFirst().await();
         }
         result = SyncResult.value(output);
       }
@@ -6408,32 +6576,41 @@ var CharacterListStream = class _CharacterListStream {
     }
     return result;
   }
-  readUntil(searchString) {
-    return CharacterReadStream.readUntil(this, searchString);
-  }
-  readLine() {
-    return CharacterReadStream.readLine(this);
-  }
 };
 
-// sources/characterReadStreamIterator.ts
-var CharacterReadStreamAsyncIterator = class _CharacterReadStreamAsyncIterator {
-  readStream;
-  current;
+// sources/byteReadStream.ts
+var ByteReadStream = class {
+};
+
+// sources/byteWriteStream.ts
+var ByteWriteStream = class {
+};
+
+// sources/stringIterator.ts
+var StringIterator = class _StringIterator {
+  value;
+  currentIndex;
   started;
-  constructor(readStream) {
-    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-    this.readStream = readStream;
-    this.current = "";
+  constructor(value) {
+    this.value = value;
+    this.currentIndex = 0;
     this.started = false;
   }
-  static create(readStream) {
-    return new _CharacterReadStreamAsyncIterator(readStream);
+  static create(value) {
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
+    return new _StringIterator(value);
+  }
+  getCurrentIndex() {
+    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+    return this.currentIndex;
   }
   next() {
-    return PromiseAsyncResult.create(async () => {
-      this.started = true;
-      this.current = await this.readStream.readCharacter().catch(NotFoundError, () => "");
+    return SyncResult.create(() => {
+      if (!this.hasStarted()) {
+        this.started = true;
+      } else if (this.hasCurrent()) {
+        this.currentIndex++;
+      }
       return this.hasCurrent();
     });
   }
@@ -6441,638 +6618,712 @@ var CharacterReadStreamAsyncIterator = class _CharacterReadStreamAsyncIterator {
     return this.started;
   }
   hasCurrent() {
-    return this.current !== "";
+    return this.hasStarted() && this.currentIndex < this.value.length;
   }
   getCurrent() {
     PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.current;
+    return this.value[this.currentIndex];
   }
   start() {
-    return AsyncIterator.start(this);
+    return Iterator.start(this);
   }
   takeCurrent() {
-    return AsyncIterator.takeCurrent(this);
+    return Iterator.takeCurrent(this);
   }
   any() {
-    return AsyncIterator.any(this);
+    return Iterator.any(this);
   }
   getCount() {
-    return AsyncIterator.getCount(this);
+    return Iterator.getCount(this);
   }
   toArray() {
-    return AsyncIterator.toArray(this);
+    return Iterator.toArray(this);
   }
-  where(condition) {
-    return AsyncIterator.where(this, condition);
+  concatenate(...toConcatenate) {
+    return Iterator.concatenate(this, ...toConcatenate);
   }
   map(mapping) {
-    return AsyncIterator.map(this, mapping);
+    return Iterator.map(this, mapping);
   }
-  whereInstanceOf(typeCheck) {
-    return AsyncIterator.whereInstanceOf(this, typeCheck);
+  flatMap(mapping) {
+    return Iterator.flatMap(this, mapping);
   }
-  whereInstanceOfType(type) {
-    return AsyncIterator.whereInstanceOfType(this, type);
+  first() {
+    return Iterator.first(this);
   }
-  first(condition) {
-    return AsyncIterator.first(this, condition);
+  last() {
+    return Iterator.last(this);
   }
-  last(condition) {
-    return AsyncIterator.last(this, condition);
+  where(condition) {
+    return Iterator.where(this, condition);
+  }
+  whereInstanceOf(typeCheck) {
+    return Iterator.whereInstanceOf(this, typeCheck);
+  }
+  whereInstanceOfType(type) {
+    return Iterator.whereInstanceOfType(this, type);
   }
   take(maximumToTake) {
-    return AsyncIterator.take(this, maximumToTake);
+    return Iterator.take(this, maximumToTake);
   }
   skip(maximumToSkip) {
-    return AsyncIterator.skip(this, maximumToSkip);
+    return Iterator.skip(this, maximumToSkip);
   }
-  [Symbol.asyncIterator]() {
-    return AsyncIterator[Symbol.asyncIterator](this);
+  [Symbol.iterator]() {
+    return Iterator[Symbol.iterator](this);
   }
 };
 
-// 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} `;
-      }
+// 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 = "";
     }
-    result += currentValue;
-    index++;
   }
-  return result;
-}
-
-// sources/commandLineParameters.ts
-var CommandLineParameters = class _CommandLineParameters {
-  args;
-  parameters;
-  constructor(argv) {
-    PreCondition.assertNotUndefinedAndNotNull(argv, "argv");
-    this.args = isIterable(argv) ? argv : Iterable.create(argv);
-    this.parameters = List.create();
+  static create(values) {
+    return new _CharacterList(values);
   }
-  static create(args) {
-    return new _CommandLineParameters(args);
+  getCount() {
+    return SyncResult.value(this.characters.length);
   }
-  static getArgumentName(arg) {
-    return arg[0] === "-" ? arg.substring(arg[1] === "-" ? 2 : 1) : void 0;
+  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;
   }
-  getArguments() {
-    return this.args;
+  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);
   }
-  /**
-   * Get the value of the first argument that matches one of the provided names. 
-   * @param names The possible names to look for.
-   */
-  getNamedArgumentStringValue(nameOrNames) {
-    PreCondition.assertNotEmpty(nameOrNames, "nameOrNames");
-    return SyncResult.create(() => {
-      let foundArgName = false;
-      let result;
-      if (isString(nameOrNames)) {
-        nameOrNames = [nameOrNames];
-      }
-      const searchNames = Iterable.create(nameOrNames);
-      for (const arg of this.args) {
-        if (!foundArgName) {
-          const argName = _CommandLineParameters.getArgumentName(arg);
-          foundArgName = !!(argName && searchNames.contains(argName));
-        } else {
-          result = arg;
-          break;
-        }
-      }
-      if (result === void 0) {
-        const toStringFunctions = ToStringFunctions.create();
-        throw new NotFoundError(`No argument found that matches ${orList(searchNames.map((n) => toStringFunctions.toString(n)))}.`);
-      }
-      return result;
-    });
+  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;
   }
-  nameOrAliasExists(nameOrAlias) {
-    PreCondition.assertNotEmpty(nameOrAlias, "nameOrAlias");
-    let result = false;
-    for (const parameter of this.parameters) {
-      if (parameter.getNameAndAliases().contains(nameOrAlias).await()) {
-        result = true;
-        break;
-      }
-    }
-    return result;
+  iterate() {
+    return StringIterator.create(this.characters);
   }
-  add(name) {
-    const result = CommandLineParameter.create({
-      owner: this,
-      name
-    });
-    this.parameters.add(result);
-    return result;
+  get(index) {
+    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
+    return SyncResult.value(this.characters.charAt(index));
   }
-};
-
-// sources/commandLineParameter.ts
-var CommandLineParameter = class _CommandLineParameter {
-  owner;
-  name;
-  aliases;
-  description;
-  constructor(owner, name) {
-    PreCondition.assertNotUndefinedAndNotNull(owner, "owner");
-    PreCondition.assertNotEmpty(name, "name");
-    PreCondition.assertFalse(owner.nameOrAliasExists(name), "owner.nameOrAliasExists(name)");
-    this.owner = owner;
-    this.name = name;
+  add(value) {
+    return List.add(this, value);
   }
-  static create(ownerOrProperties, name) {
-    let owner;
-    if (ownerOrProperties instanceof CommandLineParameters) {
-      owner = ownerOrProperties;
-      name = name;
-    } else {
-      owner = ownerOrProperties.owner;
-      name = ownerOrProperties.name;
-    }
-    return new _CommandLineParameter(owner, name);
+  addAll(values) {
+    return List.addAll(this, values);
   }
-  /**
-   * Get the name of this {@link CommandLineParameter}.
-   */
-  getName() {
-    return this.name;
+  insertAll(index, values) {
+    return List.insertAll(this, index, values);
   }
-  getAliases() {
-    return this.aliases ?? Iterable.create();
+  remove(value, equalFunctions) {
+    return List.remove(this, value, equalFunctions);
   }
-  nameOrAliasExists(nameOrAlias) {
-    return this.owner.nameOrAliasExists(nameOrAlias);
+  removeFirst() {
+    return List.removeFirst(this);
   }
-  addAlias(alias) {
-    PreCondition.assertNotEmpty(alias, "alias");
-    PreCondition.assertFalse(this.nameOrAliasExists(alias), "this.nameOrAliasExists(alias)");
-    if (this.aliases === void 0) {
-      this.aliases = List.create();
-    }
-    this.aliases.add(alias);
-    return this;
+  removeLast() {
+    return List.removeLast(this);
   }
-  addAliases(aliases) {
-    for (const alias of aliases) {
-      this.addAlias(alias);
-    }
-    return this;
+  toArray() {
+    return List.toArray(this);
+  }
+  any() {
+    return List.any(this);
+  }
+  equals(right, equalFunctions) {
+    return List.equals(this, right, equalFunctions);
   }
-  getNameAndAliases() {
-    return List.create().add(this.getName()).addAll(this.getAliases());
+  toString(toStringFunctions) {
+    return List.toString(this, toStringFunctions);
   }
-  getDescription() {
-    return this.description ?? "";
+  concatenate(...toConcatenate) {
+    return List.concatenate(this, ...toConcatenate);
   }
-  setDescription(description) {
-    PreCondition.assertNotUndefinedAndNotNull(description, "description");
-    this.description = description;
-    return this;
+  map(mapping) {
+    return List.map(this, mapping);
   }
-};
-
-// sources/comparable.ts
-var Comparable = class _Comparable {
-  constructor() {
+  flatMap(mapping) {
+    return List.flatMap(this, mapping);
   }
-  /**
-   * Get whether this value is less than the provided value.
-   * @param value The value to compare against.
-   */
-  lessThan(value) {
-    return _Comparable.lessThan(this, value);
+  where(condition) {
+    return List.where(this, condition);
   }
-  /**
-   * Get whether the left value is less than the right value.
-   * @param left The left value in the comparison.
-   * @param right The right value in the comparison.
-   */
-  static lessThan(left, right) {
-    PreCondition.assertNotUndefinedAndNotNull(left, "left");
-    return left.compareTo(right) === 0 /* LessThan */;
+  instanceOf(typeOrTypeCheck) {
+    return List.instanceOf(this, typeOrTypeCheck);
   }
-  /**
-   * Get whether this value is less than or equal to the provided value.
-   * @param value The value to compare against.
-   */
-  lessThanOrEqualTo(value) {
-    return _Comparable.lessThanOrEqualTo(this, value);
+  first(condition) {
+    return List.first(this, condition);
   }
-  /**
-   * Get whether the left value is less than or equal to the right value.
-   * @param left The left value in the comparison.
-   * @param right The right value in the comparison.
-   */
-  static lessThanOrEqualTo(left, right) {
-    PreCondition.assertNotUndefinedAndNotNull(left, "left");
-    return left.compareTo(right) !== 2 /* GreaterThan */;
+  last(condition) {
+    return List.last(this, condition);
   }
-  /**
-   * Get whether this value equals the provided value.
-   * @param value The value to compare against.
-   */
-  equals(value) {
-    return _Comparable.equals(this, value);
+  contains(value, equalFunctions) {
+    return List.contains(this, value, equalFunctions);
   }
-  /**
-   * Get whether the left value equals the right value.
-   * @param left The left value in the comparison.
-   * @param right The right value in the comparison.
-   */
-  static equals(left, right) {
-    PreCondition.assertNotUndefinedAndNotNull(left, "left");
-    return left.compareTo(right) === 1 /* Equal */;
+  [Symbol.iterator]() {
+    return List[Symbol.iterator](this);
   }
-  /**
-   * Get whether this value is not equal to the provided value.
-   * @param value The value to compare against.
-   */
-  notEquals(value) {
-    return _Comparable.notEquals(this, value);
+};
+
+// sources/characterReadStream.ts
+var CharacterReadStream = class _CharacterReadStream {
+  readCharacters(count) {
+    return _CharacterReadStream.readCharacters(this, count);
   }
-  /**
-   * Get whether the left value is not equal to the right value.
-   * @param left The left value in the comparison.
-   * @param right The right value in the comparison.
-   */
-  static notEquals(left, right) {
-    PreCondition.assertNotUndefinedAndNotNull(left, "left");
-    return left.compareTo(right) !== 1 /* Equal */;
+  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);
   }
   /**
-   * Get whether this value is greater than or equal to the provided value.
-   * @param value The value to compare against.
+   * 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.
    */
-  greaterThanOrEqualTo(value) {
-    return _Comparable.greaterThanOrEqualTo(this, value);
+  readUntil(searchString) {
+    return _CharacterReadStream.readUntil(this, searchString);
   }
-  /**
-   * Get whether the left value is greater than or equal to the right value.
-   * @param left The left value in the comparison.
-   * @param right The right value in the comparison.
-   */
-  static greaterThanOrEqualTo(left, right) {
-    PreCondition.assertNotUndefinedAndNotNull(left, "left");
-    return left.compareTo(right) !== 0 /* LessThan */;
+  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();
   }
   /**
-   * Get whether this value is greater than the provided value.
-   * @param value The value to compare against.
+   * 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.
    */
-  greaterThan(value) {
-    return _Comparable.greaterThan(this, value);
+  readLine() {
+    return _CharacterReadStream.readLine(this);
   }
-  /**
-   * Get whether the left value is greater than the right value.
-   * @param left The left value in the comparison.
-   * @param right The right value in the comparison.
-   */
-  static greaterThan(left, right) {
-    PreCondition.assertNotUndefinedAndNotNull(left, "left");
-    return left.compareTo(right) === 2 /* GreaterThan */;
+  static readLine(readStream) {
+    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
+    return readStream.readUntil("\n");
   }
 };
 
-// sources/nodeJSCharacterWriteStream.ts
-var NodeJSCharacterWriteStream = class _NodeJSCharacterWriteStream extends CharacterWriteStream {
-  nodeJSWriteStream;
-  constructor(nodeJSWriteStream) {
-    PreCondition.assertNotUndefinedAndNotNull(nodeJSWriteStream, "nodeJSWriteStream");
-    super();
-    this.nodeJSWriteStream = nodeJSWriteStream;
+// sources/characterListStream.ts
+var CharacterListStream = class _CharacterListStream {
+  list;
+  constructor() {
+    this.list = CharacterList.create();
   }
-  static create(nodeJSWriteStream) {
-    return new _NodeJSCharacterWriteStream(nodeJSWriteStream);
+  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) {
-    PreCondition.assertNotUndefinedAndNotNull(text, "text");
-    return PromiseAsyncResult.create(new Promise((resolve, reject) => {
-      this.nodeJSWriteStream.write(text, (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(text.length);
-        }
-      });
-    }));
+    this.list.addAll(text);
+    return SyncResult.value(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;
+  writeLine(text) {
+    return CharacterWriteStream.writeLine(this, text);
   }
-  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;
+  /**
+   * 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 {
-      let initialValue = getterOptionsOrInitialValue;
-      getter = () => {
-        return initialValue;
-      };
-      setter = (value) => {
-        initialValue = value;
-      };
+      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);
+      }
     }
-    PreCondition.assertNotUndefinedAndNotNull(getter, "getter");
-    PreCondition.assertNotUndefinedAndNotNull(setter, "setter");
-    return new _Property(getter, setter);
-  }
-  getValue() {
-    return this.getter();
+    return result;
   }
-  setValue(value) {
-    this.setter(value);
-    return this;
+  readUntil(searchString) {
+    return CharacterReadStream.readUntil(this, searchString);
   }
-  toString() {
-    return `${this.getValue()}`;
+  readLine() {
+    return CharacterReadStream.readLine(this);
   }
 };
 
-// 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);
+// sources/characterReadStreamIterator.ts
+var CharacterReadStreamAsyncIterator = class _CharacterReadStreamAsyncIterator {
+  readStream;
+  current;
+  started;
+  constructor(readStream) {
+    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
+    this.readStream = readStream;
+    this.current = "";
+    this.started = false;
   }
-  getName() {
-    return this.name;
+  static create(readStream) {
+    return new _CharacterReadStreamAsyncIterator(readStream);
   }
-  getValue() {
-    return this.value;
+  next() {
+    return PromiseAsyncResult.create(async () => {
+      this.started = true;
+      this.current = await this.readStream.readCharacter().catch(NotFoundError, () => "");
+      return this.hasCurrent();
+    });
   }
-  toString() {
-    return `${escapeAndQuote(this.name)}:${escapeAndQuote(this.value)}`;
+  hasStarted() {
+    return this.started;
   }
-};
-
-// sources/mutableHttpHeaders.ts
-var MutableHttpHeaders = class _MutableHttpHeaders {
-  headers;
-  constructor(headers) {
-    this.headers = List.create();
-    if (headers) {
-      this.setAll(headers);
-    }
+  hasCurrent() {
+    return this.current !== "";
   }
-  static create(headers) {
-    return new _MutableHttpHeaders(headers);
+  getCurrent() {
+    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+    return this.current;
   }
-  iterate() {
-    return this.headers.iterate();
+  start() {
+    return AsyncIterator.start(this);
   }
-  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;
-    });
+  takeCurrent() {
+    return AsyncIterator.takeCurrent(this);
   }
-  getValue(headerName) {
-    return this.get(headerName).then((header) => header.getValue());
+  any() {
+    return AsyncIterator.any(this);
   }
-  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;
+  getCount() {
+    return AsyncIterator.getCount(this);
   }
-  setAll(headers) {
-    PreCondition.assertNotUndefinedAndNotNull(headers, "headers");
-    for (const header of headers) {
-      this.set(header);
-    }
-    return this;
+  toArray() {
+    return AsyncIterator.toArray(this);
   }
-  setContentType(contentType) {
-    return this.set(HttpHeaders.contentTypeHeaderName, contentType);
+  where(condition) {
+    return AsyncIterator.where(this, condition);
   }
-  getContentType() {
-    return this.get(HttpHeaders.contentTypeHeaderName);
+  map(mapping) {
+    return AsyncIterator.map(this, mapping);
   }
-  getContentTypeValue() {
-    return this.getValue(HttpHeaders.contentTypeHeaderName);
+  whereInstanceOf(typeCheck) {
+    return AsyncIterator.whereInstanceOf(this, typeCheck);
   }
-  getCount() {
-    return this.headers.getCount();
+  whereInstanceOfType(type) {
+    return AsyncIterator.whereInstanceOfType(this, type);
   }
-  toArray() {
-    return HttpHeaders.toArray(this);
+  first(condition) {
+    return AsyncIterator.first(this, condition);
   }
-  any() {
-    return HttpHeaders.any(this);
+  last(condition) {
+    return AsyncIterator.last(this, condition);
   }
-  equals(right, equalFunctions) {
-    return HttpHeaders.equals(this, right, equalFunctions);
+  take(maximumToTake) {
+    return AsyncIterator.take(this, maximumToTake);
   }
-  toString(toStringFunctions) {
-    return HttpHeaders.toString(this, toStringFunctions);
+  skip(maximumToSkip) {
+    return AsyncIterator.skip(this, maximumToSkip);
   }
-  concatenate(...toConcatenate) {
-    return HttpHeaders.concatenate(this, ...toConcatenate);
+  [Symbol.asyncIterator]() {
+    return AsyncIterator[Symbol.asyncIterator](this);
   }
-  map(mapping) {
-    return HttpHeaders.map(this, mapping);
+};
+
+// 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++;
   }
-  flatMap(mapping) {
-    return HttpHeaders.flatMap(this, mapping);
+  return result;
+}
+
+// sources/commandLineParameters.ts
+var CommandLineParameters = class _CommandLineParameters {
+  args;
+  parameters;
+  constructor(argv) {
+    PreCondition.assertNotUndefinedAndNotNull(argv, "argv");
+    this.args = isIterable(argv) ? argv : Iterable.create(argv);
+    this.parameters = List.create();
   }
-  where(condition) {
-    return HttpHeaders.where(this, condition);
+  static create(args) {
+    return new _CommandLineParameters(args);
   }
-  instanceOf(typeOrTypeCheck) {
-    return HttpHeaders.instanceOf(this, typeOrTypeCheck);
+  static getArgumentName(arg) {
+    return arg[0] === "-" ? arg.substring(arg[1] === "-" ? 2 : 1) : void 0;
   }
-  first(condition) {
-    return HttpHeaders.first(this, condition);
+  getArguments() {
+    return this.args;
   }
-  last(condition) {
-    return HttpHeaders.last(this, condition);
+  /**
+   * Get the value of the first argument that matches one of the provided names. 
+   * @param names The possible names to look for.
+   */
+  getNamedArgumentStringValue(nameOrNames) {
+    PreCondition.assertNotEmpty(nameOrNames, "nameOrNames");
+    return SyncResult.create(() => {
+      let foundArgName = false;
+      let result;
+      if (isString(nameOrNames)) {
+        nameOrNames = [nameOrNames];
+      }
+      const searchNames = Iterable.create(nameOrNames);
+      for (const arg of this.args) {
+        if (!foundArgName) {
+          const argName = _CommandLineParameters.getArgumentName(arg);
+          foundArgName = !!(argName && searchNames.contains(argName));
+        } else {
+          result = arg;
+          break;
+        }
+      }
+      if (result === void 0) {
+        const toStringFunctions = ToStringFunctions.create();
+        throw new NotFoundError(`No argument found that matches ${orList(searchNames.map((n) => toStringFunctions.toString(n)))}.`);
+      }
+      return result;
+    });
   }
-  [Symbol.iterator]() {
-    return HttpHeaders[Symbol.iterator](this);
+  nameOrAliasExists(nameOrAlias) {
+    PreCondition.assertNotEmpty(nameOrAlias, "nameOrAlias");
+    let result = false;
+    for (const parameter of this.parameters) {
+      if (parameter.getNameAndAliases().contains(nameOrAlias).await()) {
+        result = true;
+        break;
+      }
+    }
+    return result;
   }
-  contains(value, equalFunctions) {
-    return HttpHeaders.contains(this, value, equalFunctions);
+  add(name) {
+    const result = CommandLineParameter.create({
+      owner: this,
+      name
+    });
+    this.parameters.add(result);
+    return result;
   }
 };
 
-// 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);
+// sources/commandLineParameter.ts
+var CommandLineParameter = class _CommandLineParameter {
+  owner;
+  name;
+  aliases;
+  description;
+  constructor(owner, name) {
+    PreCondition.assertNotUndefinedAndNotNull(owner, "owner");
+    PreCondition.assertNotEmpty(name, "name");
+    PreCondition.assertFalse(owner.nameOrAliasExists(name), "owner.nameOrAliasExists(name)");
+    this.owner = owner;
+    this.name = name;
   }
-  static getContentTypeValue(headers) {
-    return headers.getValue(_HttpHeaders.contentTypeHeaderName);
+  static create(ownerOrProperties, name) {
+    let owner;
+    if (ownerOrProperties instanceof CommandLineParameters) {
+      owner = ownerOrProperties;
+      name = name;
+    } else {
+      owner = ownerOrProperties.owner;
+      name = ownerOrProperties.name;
+    }
+    return new _CommandLineParameter(owner, name);
   }
   /**
-   * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
+   * Get the name of this {@link CommandLineParameter}.
    */
-  toArray() {
-    return _HttpHeaders.toArray(this);
+  getName() {
+    return this.name;
   }
-  static toArray(headers) {
-    return Iterable.toArray(headers);
+  getAliases() {
+    return this.aliases ?? Iterable.create();
   }
-  any() {
-    return _HttpHeaders.any(this);
+  nameOrAliasExists(nameOrAlias) {
+    return this.owner.nameOrAliasExists(nameOrAlias);
   }
-  static any(headers) {
-    return Iterable.any(headers);
+  addAlias(alias) {
+    PreCondition.assertNotEmpty(alias, "alias");
+    PreCondition.assertFalse(this.nameOrAliasExists(alias), "this.nameOrAliasExists(alias)");
+    if (this.aliases === void 0) {
+      this.aliases = List.create();
+    }
+    this.aliases.add(alias);
+    return this;
   }
-  getCount() {
-    return _HttpHeaders.getCount(this);
+  addAliases(aliases) {
+    for (const alias of aliases) {
+      this.addAlias(alias);
+    }
+    return this;
   }
-  static getCount(headers) {
-    return Iterable.getCount(headers);
+  getNameAndAliases() {
+    return List.create().add(this.getName()).addAll(this.getAliases());
   }
-  equals(right, equalFunctions) {
-    return _HttpHeaders.equals(this, right, equalFunctions);
+  getDescription() {
+    return this.description ?? "";
   }
-  static equals(headers, right, equalFunctions) {
-    return Iterable.equals(headers, right, equalFunctions);
+  setDescription(description) {
+    PreCondition.assertNotUndefinedAndNotNull(description, "description");
+    this.description = description;
+    return this;
   }
-  toString(toStringFunctions) {
-    return _HttpHeaders.toString(this, toStringFunctions);
+};
+
+// sources/comparable.ts
+var Comparable = class _Comparable {
+  constructor() {
   }
-  static toString(headers, toStringFunctions) {
-    return Iterable.toString(headers, toStringFunctions);
+  /**
+   * Get whether this value is less than the provided value.
+   * @param value The value to compare against.
+   */
+  lessThan(value) {
+    return _Comparable.lessThan(this, value);
   }
-  concatenate(...toConcatenate) {
-    return _HttpHeaders.concatenate(this, ...toConcatenate);
+  /**
+   * Get whether the left value is less than the right value.
+   * @param left The left value in the comparison.
+   * @param right The right value in the comparison.
+   */
+  static lessThan(left, right) {
+    PreCondition.assertNotUndefinedAndNotNull(left, "left");
+    return left.compareTo(right) === 0 /* LessThan */;
   }
-  static concatenate(headers, ...toConcatenate) {
-    return Iterable.concatenate(headers, ...toConcatenate);
+  /**
+   * Get whether this value is less than or equal to the provided value.
+   * @param value The value to compare against.
+   */
+  lessThanOrEqualTo(value) {
+    return _Comparable.lessThanOrEqualTo(this, value);
   }
-  map(mapping) {
-    return _HttpHeaders.map(this, mapping);
+  /**
+   * Get whether the left value is less than or equal to the right value.
+   * @param left The left value in the comparison.
+   * @param right The right value in the comparison.
+   */
+  static lessThanOrEqualTo(left, right) {
+    PreCondition.assertNotUndefinedAndNotNull(left, "left");
+    return left.compareTo(right) !== 2 /* GreaterThan */;
   }
-  static map(headers, mapping) {
-    return Iterable.map(headers, mapping);
+  /**
+   * Get whether this value equals the provided value.
+   * @param value The value to compare against.
+   */
+  equals(value) {
+    return _Comparable.equals(this, value);
   }
-  flatMap(mapping) {
-    return _HttpHeaders.flatMap(this, mapping);
+  /**
+   * Get whether the left value equals the right value.
+   * @param left The left value in the comparison.
+   * @param right The right value in the comparison.
+   */
+  static equals(left, right) {
+    PreCondition.assertNotUndefinedAndNotNull(left, "left");
+    return left.compareTo(right) === 1 /* Equal */;
   }
-  static flatMap(headers, mapping) {
-    return Iterable.flatMap(headers, mapping);
+  /**
+   * Get whether this value is not equal to the provided value.
+   * @param value The value to compare against.
+   */
+  notEquals(value) {
+    return _Comparable.notEquals(this, value);
   }
-  where(condition) {
-    return _HttpHeaders.where(this, condition);
+  /**
+   * Get whether the left value is not equal to the right value.
+   * @param left The left value in the comparison.
+   * @param right The right value in the comparison.
+   */
+  static notEquals(left, right) {
+    PreCondition.assertNotUndefinedAndNotNull(left, "left");
+    return left.compareTo(right) !== 1 /* Equal */;
   }
-  static where(headers, condition) {
-    return Iterable.where(headers, condition);
+  /**
+   * Get whether this value is greater than or equal to the provided value.
+   * @param value The value to compare against.
+   */
+  greaterThanOrEqualTo(value) {
+    return _Comparable.greaterThanOrEqualTo(this, value);
   }
-  instanceOf(typeOrTypeCheck) {
-    return _HttpHeaders.instanceOf(this, typeOrTypeCheck);
+  /**
+   * Get whether the left value is greater than or equal to the right value.
+   * @param left The left value in the comparison.
+   * @param right The right value in the comparison.
+   */
+  static greaterThanOrEqualTo(left, right) {
+    PreCondition.assertNotUndefinedAndNotNull(left, "left");
+    return left.compareTo(right) !== 0 /* LessThan */;
   }
-  static instanceOf(headers, typeOrTypeCheck) {
-    return Iterable.instanceOf(headers, typeOrTypeCheck);
+  /**
+   * Get whether this value is greater than the provided value.
+   * @param value The value to compare against.
+   */
+  greaterThan(value) {
+    return _Comparable.greaterThan(this, value);
   }
-  first(condition) {
-    return _HttpHeaders.first(this, condition);
+  /**
+   * Get whether the left value is greater than the right value.
+   * @param left The left value in the comparison.
+   * @param right The right value in the comparison.
+   */
+  static greaterThan(left, right) {
+    PreCondition.assertNotUndefinedAndNotNull(left, "left");
+    return left.compareTo(right) === 2 /* GreaterThan */;
   }
-  static first(headers, condition) {
-    return Iterable.first(headers, condition);
+};
+
+// sources/nodeJSCharacterWriteStream.ts
+var NodeJSCharacterWriteStream = class _NodeJSCharacterWriteStream extends CharacterWriteStream {
+  nodeJSWriteStream;
+  constructor(nodeJSWriteStream) {
+    PreCondition.assertNotUndefinedAndNotNull(nodeJSWriteStream, "nodeJSWriteStream");
+    super();
+    this.nodeJSWriteStream = nodeJSWriteStream;
   }
-  last(condition) {
-    return _HttpHeaders.last(this, condition);
+  static create(nodeJSWriteStream) {
+    return new _NodeJSCharacterWriteStream(nodeJSWriteStream);
   }
-  static last(headers, condition) {
-    return Iterable.last(headers, condition);
+  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;
   }
-  [Symbol.iterator]() {
-    return _HttpHeaders[Symbol.iterator](this);
+  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);
   }
-  static [Symbol.iterator](headers) {
-    return Iterable[Symbol.iterator](headers);
+  getValue() {
+    return this.getter();
   }
-  contains(value, equalFunctions) {
-    return _HttpHeaders.contains(this, value, equalFunctions);
+  setValue(value) {
+    this.setter(value);
+    return this;
   }
-  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();
-    });
+  toString() {
+    return `${this.getValue()}`;
   }
 };
 
@@ -7317,14 +7568,27 @@ var FetchHttpClient = class _FetchHttpClient {
   }
   sendRequest(request) {
     PreCondition.assertNotUndefinedAndNotNull(request, "request");
-    return PromiseAsyncResult.create(async () => {
+    return AsyncResult.create(async () => {
+      const fetchURL = request.getURL();
+      const fetchMethod = _FetchHttpClient.convertMethod(request.getMethod());
+      const fetchHeaders = request.getHeaders().map((header) => [header.getName(), header.getValue()]).toArray().await();
+      const fetchBody = request.getBody() || void 0;
       const requestInit = {
-        method: _FetchHttpClient.convertMethod(request.getMethod()),
-        headers: request.getHeaders().map((header) => [header.getName(), header.getValue()]).toArray().await(),
-        body: request.getBody() || void 0
+        method: fetchMethod,
+        headers: fetchHeaders,
+        body: fetchBody
       };
-      const fetchResponse = await fetch(request.getURL(), requestInit);
-      return FetchHttpIncomingResponse.create(fetchResponse);
+      let result;
+      try {
+        const fetchResponse = await fetch(fetchURL, requestInit);
+        result = FetchHttpIncomingResponse.create(fetchResponse);
+      } catch (error) {
+        if (error instanceof Error && error.cause instanceof Error) {
+          throw new FetchError(error.cause);
+        }
+        throw error;
+      }
+      return result;
     });
   }
   sendGetRequest(url) {
@@ -7378,83 +7642,6 @@ var http = __toESM(require("http"), 1);
 var HttpServer = class {
 };
 
-// sources/httpOutgoingResponse.ts
-var HttpOutgoingResponse = class _HttpOutgoingResponse {
-  statusCode;
-  headers;
-  body;
-  constructor() {
-    this.statusCode = 200;
-    this.headers = MutableHttpHeaders.create();
-    this.body = "";
-  }
-  static create() {
-    return new _HttpOutgoingResponse();
-  }
-  /**
-   * Get the status code of this {@link HttpOutgoingResponse}.
-   */
-  getStatusCode() {
-    return this.statusCode;
-  }
-  /**
-   * Set the status code of this {@link HttpOutgoingResponse}.
-   * @param statusCode The status code of this {@link HttpOutgoingResponse}.
-   */
-  setStatusCode(statusCode) {
-    PreCondition.assertBetween(100, statusCode, 599, "statusCode");
-    this.statusCode = statusCode;
-    return this;
-  }
-  getHeaders() {
-    return this.headers;
-  }
-  /**
-   * 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);
-  }
-  /**
-   * 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);
-  }
-  /**
-   * Set the HTTP header in this {@link HttpOutgoingResponse}.
-   * @param headerName The name of the HTTP header.
-   * @param headerValue The value of the HTTP header.
-   */
-  setHeader(headerName, headerValue) {
-    this.headers.set(headerName, headerValue);
-    return this;
-  }
-  setContentTypeHeader(contentType) {
-    this.headers.setContentType(contentType);
-    return this;
-  }
-  /**
-   * Get the body of this {@link HttpOutgoingResponse}.
-   */
-  getBody() {
-    return this.body;
-  }
-  /**
-   * 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/nodeJSHttpServer.ts
 var NodeJSHttpServer = class _NodeJSHttpServer extends HttpServer {
   httpServer;
@@ -7507,16 +7694,9 @@ var NodeJSHttpServer = class _NodeJSHttpServer extends 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("request", async (rawRequest, rawResponse) => {
+          const response = NodeJSHttpOutgoingResponse.create(rawResponse).setStatusCode(200).setHeader("Content-Type", "text/plain").setBodyString("Hello world!");
+          await response.end();
         });
         this.httpServer.on("close", () => {
           resolve();
@@ -7643,149 +7823,6 @@ var CurrentProcess = class _CurrentProcess {
   }
 };
 
-// sources/luxonDateTime.ts
-var luxon = __toESM(require("luxon"), 1);
-var pctTimeZone = "America/Los_Angeles";
-var LuxonDateTime = class _LuxonDateTime {
-  dateTime;
-  constructor(dateTime) {
-    this.dateTime = dateTime;
-  }
-  static create(dateTime) {
-    return new _LuxonDateTime(dateTime);
-  }
-  static parse(text) {
-    return _LuxonDateTime.create(luxon.DateTime.fromISO(text, { zone: pctTimeZone }));
-  }
-  static now() {
-    return _LuxonDateTime.create(luxon.DateTime.now().setZone(pctTimeZone));
-  }
-  getYear() {
-    return this.dateTime.year;
-  }
-  getMonth() {
-    return this.dateTime.month;
-  }
-  getDay() {
-    return this.dateTime.day;
-  }
-  getHour() {
-    return this.dateTime.hour;
-  }
-  getMinute() {
-    return this.dateTime.minute;
-  }
-  getSecond() {
-    return this.dateTime.second;
-  }
-  addDays(days) {
-    return _LuxonDateTime.create(this.dateTime.plus({ days }));
-  }
-  toString() {
-    return this.dateTime.toISO();
-  }
-  toDateString() {
-    return this.dateTime.toISODate();
-  }
-  compareTo(dateTime, compareTimes) {
-    return DateTime2.compareTo(this, dateTime, compareTimes);
-  }
-  lessThan(dateTime, compareTimes) {
-    return DateTime2.lessThan(this, dateTime, compareTimes);
-  }
-  lessThanOrEqualTo(dateTime, compareTimes) {
-    return DateTime2.lessThanOrEqualTo(this, dateTime, compareTimes);
-  }
-  equals(dateTime, compareTimes) {
-    return DateTime2.equals(this, dateTime, compareTimes);
-  }
-  greaterThanOrEqualTo(dateTime, compareTimes) {
-    return DateTime2.greaterThanOrEqualTo(this, dateTime, compareTimes);
-  }
-  greaterThan(dateTime, compareTimes) {
-    return DateTime2.greaterThan(this, dateTime, compareTimes);
-  }
-  get debug() {
-    return DateTime2.debug(this);
-  }
-};
-
-// sources/dateTime.ts
-var DateTime2 = 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);
-  }
-  static lessThan(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) < 0;
-  }
-  lessThanOrEqualTo(dateTime, compareTimes) {
-    return _DateTime.lessThanOrEqualTo(this, dateTime, compareTimes);
-  }
-  static lessThanOrEqualTo(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) <= 0;
-  }
-  equals(dateTime, compareTimes) {
-    return _DateTime.equals(this, dateTime, compareTimes);
-  }
-  static equals(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) === 0;
-  }
-  greaterThanOrEqualTo(dateTime, compareTimes) {
-    return _DateTime.greaterThanOrEqualTo(this, dateTime, compareTimes);
-  }
-  static greaterThanOrEqualTo(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) >= 0;
-  }
-  greaterThan(dateTime, compareTimes) {
-    return _DateTime.greaterThan(this, dateTime, compareTimes);
-  }
-  static greaterThan(left, right, compareTimes) {
-    return left.compareTo(right, compareTimes) > 0;
-  }
-  get debug() {
-    return _DateTime.debug(this);
-  }
-  static debug(dateTime) {
-    return dateTime.toString();
-  }
-};
-
 // sources/listStack.ts
 var ListStack = class _ListStack {
   list;
@@ -8145,6 +8182,10 @@ var HttpClient = class _HttpClient {
 var HttpIncomingRequest = class {
 };
 
+// sources/httpOutgoingResponse.ts
+var HttpOutgoingResponse = class {
+};
+
 // sources/inMemoryCharacterWriteStream.ts
 var InMemoryCharacterWriteStream = class _InMemoryCharacterWriteStream extends CharacterWriteStream {
   writtenText;
@@ -9591,6 +9632,7 @@ var WonderlandTrailClient = class _WonderlandTrailClient {
   CharacterReadStreamAsyncIterator,
   CharacterTable,
   CharacterWriteStream,
+  Clock,
   CommandLineParameter,
   CommandLineParameters,
   Comparable,
@@ -9604,6 +9646,7 @@ var WonderlandTrailClient = class _WonderlandTrailClient {
   Disposable,
   EmptyError,
   EqualFunctions,
+  FetchError,
   FetchHttpClient,
   FetchHttpIncomingResponse,
   FlatMapIterable,
@@ -9647,6 +9690,7 @@ var WonderlandTrailClient = class _WonderlandTrailClient {
   Node,
   NodeJSCharacterWriteStream,
   NodeJSHttpIncomingRequest,
+  NodeJSHttpOutgoingResponse,
   NodeJSHttpServer,
   NotFoundError,
   PostCondition,
@@ -9656,6 +9700,7 @@ var WonderlandTrailClient = class _WonderlandTrailClient {
   PromiseAsyncResult,
   Property,
   Queue,
+  RealClock,
   RealNetwork,
   RecreationDotGovClient,
   RecreationDotGovDivisionAvailability,