@everyonesoftware/common 11.0.0 → 12.0.0

package/outputs/testIndex.cjs

@@ -34,6 +34,7 @@ __export(tests_exports, {
   BasicTestSkip: () => BasicTestSkip,
   ConsoleTestRunner: () => ConsoleTestRunner,
   FailedTest: () => FailedTest,
+  FakeClock: () => FakeClock,
   SkippedTest: () => SkippedTest,
   Test: () => Test,
   TestAction: () => TestAction,
@@ -4165,6 +4166,184 @@ var ANSIStyles = class {
   }
 };
 
+// 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/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) {
@@ -4546,592 +4725,658 @@ 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;
   }
+  getValue() {
+    return this.value;
+  }
+  toString() {
+    return `${escapeAndQuote(this.name)}:${escapeAndQuote(this.value)}`;
+  }
 };
 
-// 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;
+// sources/mutableHttpHeaders.ts
+var MutableHttpHeaders = class _MutableHttpHeaders {
+  headers;
+  constructor(headers) {
+    this.headers = List.create();
+    if (headers) {
+      this.setAll(headers);
+    }
   }
-  static create(text, type) {
-    return new _Token(text, type);
+  static create(headers) {
+    return new _MutableHttpHeaders(headers);
   }
-  static whitespace(text) {
-    return _Token.create(text, TokenType.Whitespace);
+  iterate() {
+    return this.headers.iterate();
   }
-  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);
+  get(headerName) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    return SyncResult.create(() => {
+      let result;
+      const lowerHeaderName = headerName.toLowerCase();
+      for (const header of this.headers) {
+        if (header.getName().toLowerCase() === lowerHeaderName) {
+          result = header;
+          break;
+        }
+      }
+      if (result === void 0) {
+        throw new NotFoundError(`No HttpHeader found with the name ${escapeAndQuote(headerName)}.`);
+      }
+      return result;
+    });
+  }
+  getValue(headerName) {
+    return this.get(headerName).then((header) => header.getValue());
+  }
+  set(headerOrHeaderName, headerValue) {
+    let headerName;
+    if (isString(headerOrHeaderName)) {
+      headerName = headerOrHeaderName;
+    } else {
+      headerName = headerOrHeaderName.getName();
+      headerValue = headerOrHeaderName.getValue();
+    }
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
+    let insertIndex = 0;
+    for (let insertIndex2 = 0; insertIndex2 < this.headers.getCount().await(); insertIndex2++) {
+      const header = this.headers.get(insertIndex2).await();
+      if (header.getName() === headerName) {
+        this.headers.removeAt(insertIndex2);
         break;
+      }
     }
-    return result;
+    this.headers.insert(insertIndex, HttpHeader.create(headerName, headerValue));
+    return this;
   }
-  static leftParenthesis() {
-    return _Token.leftParenthesisToken;
+  setAll(headers) {
+    PreCondition.assertNotUndefinedAndNotNull(headers, "headers");
+    for (const header of headers) {
+      this.set(header);
+    }
+    return this;
   }
-  static rightParenthesis() {
-    return _Token.rightParenthesisToken;
+  setContentType(contentType) {
+    return this.set(HttpHeaders.contentTypeHeaderName, contentType);
   }
-  static backslash() {
-    return _Token.backslashToken;
+  getContentType() {
+    return this.get(HttpHeaders.contentTypeHeaderName);
   }
-  static forwardSlash() {
-    return _Token.forwardSlashToken;
+  getContentTypeValue() {
+    return this.getValue(HttpHeaders.contentTypeHeaderName);
   }
-  static period() {
-    return _Token.periodToken;
+  getCount() {
+    return this.headers.getCount();
   }
-  static underscore() {
-    return _Token.underscoreToken;
+  toArray() {
+    return HttpHeaders.toArray(this);
   }
-  static colon() {
-    return _Token.colonToken;
+  any() {
+    return HttpHeaders.any(this);
   }
-  static letters(text) {
-    return _Token.create(text, TokenType.Letters);
+  equals(right, equalFunctions) {
+    return HttpHeaders.equals(this, right, equalFunctions);
   }
-  static digits(text) {
-    return _Token.create(text, TokenType.Digits);
+  toString(toStringFunctions) {
+    return HttpHeaders.toString(this, toStringFunctions);
   }
-  static unknown(text) {
-    return _Token.create(text, TokenType.Unknown);
+  concatenate(...toConcatenate) {
+    return HttpHeaders.concatenate(this, ...toConcatenate);
   }
-  getText() {
-    return this.text;
+  map(mapping) {
+    return HttpHeaders.map(this, mapping);
   }
-  getType() {
-    return this.type;
+  flatMap(mapping) {
+    return HttpHeaders.flatMap(this, mapping);
+  }
+  where(condition) {
+    return HttpHeaders.where(this, condition);
+  }
+  instanceOf(typeOrTypeCheck) {
+    return HttpHeaders.instanceOf(this, typeOrTypeCheck);
+  }
+  first(condition) {
+    return HttpHeaders.first(this, condition);
+  }
+  last(condition) {
+    return HttpHeaders.last(this, condition);
+  }
+  [Symbol.iterator]() {
+    return HttpHeaders[Symbol.iterator](this);
+  }
+  contains(value, equalFunctions) {
+    return HttpHeaders.contains(this, value, equalFunctions);
   }
 };
 
-// sources/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++;
+// sources/httpHeaders.ts
+var HttpHeaders = class _HttpHeaders {
+  static contentTypeHeaderName = "Content-Type";
+  static create(headers) {
+    return MutableHttpHeaders.create(headers);
   }
-  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();
+  getContentType() {
+    return _HttpHeaders.getContentType(this);
   }
-  static create(args) {
-    return new _CommandLineParameters(args);
+  static getContentType(headers) {
+    return headers.get(_HttpHeaders.contentTypeHeaderName);
   }
-  static getArgumentName(arg) {
-    return arg[0] === "-" ? arg.substring(arg[1] === "-" ? 2 : 1) : void 0;
+  getContentTypeValue() {
+    return _HttpHeaders.getContentTypeValue(this);
   }
-  getArguments() {
-    return this.args;
+  static getContentTypeValue(headers) {
+    return headers.getValue(_HttpHeaders.contentTypeHeaderName);
   }
   /**
-   * Get the value of the first argument that matches one of the provided names. 
-   * @param names The possible names to look for.
+   * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
    */
-  getNamedArgumentStringValue(nameOrNames) {
-    PreCondition.assertNotEmpty(nameOrNames, "nameOrNames");
-    return SyncResult.create(() => {
-      let foundArgName = false;
-      let result;
-      if (isString(nameOrNames)) {
-        nameOrNames = [nameOrNames];
-      }
-      const searchNames = Iterable.create(nameOrNames);
-      for (const arg of this.args) {
-        if (!foundArgName) {
-          const argName = _CommandLineParameters.getArgumentName(arg);
-          foundArgName = !!(argName && searchNames.contains(argName));
-        } else {
-          result = arg;
-          break;
-        }
-      }
-      if (result === void 0) {
-        const toStringFunctions = ToStringFunctions.create();
-        throw new NotFoundError(`No argument found that matches ${orList(searchNames.map((n) => toStringFunctions.toString(n)))}.`);
-      }
-      return result;
-    });
-  }
-  nameOrAliasExists(nameOrAlias) {
-    PreCondition.assertNotEmpty(nameOrAlias, "nameOrAlias");
-    let result = false;
-    for (const parameter of this.parameters) {
-      if (parameter.getNameAndAliases().contains(nameOrAlias).await()) {
-        result = true;
-        break;
-      }
-    }
-    return result;
-  }
-  add(name) {
-    const result = CommandLineParameter.create({
-      owner: this,
-      name
-    });
-    this.parameters.add(result);
-    return result;
+  toArray() {
+    return _HttpHeaders.toArray(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 toArray(headers) {
+    return Iterable.toArray(headers);
   }
-  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);
+  any() {
+    return _HttpHeaders.any(this);
   }
-  /**
-   * Get the name of this {@link CommandLineParameter}.
-   */
-  getName() {
-    return this.name;
+  static any(headers) {
+    return Iterable.any(headers);
   }
-  getAliases() {
-    return this.aliases ?? Iterable.create();
+  getCount() {
+    return _HttpHeaders.getCount(this);
   }
-  nameOrAliasExists(nameOrAlias) {
-    return this.owner.nameOrAliasExists(nameOrAlias);
+  static getCount(headers) {
+    return Iterable.getCount(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;
+  equals(right, equalFunctions) {
+    return _HttpHeaders.equals(this, right, equalFunctions);
   }
-  addAliases(aliases) {
-    for (const alias of aliases) {
-      this.addAlias(alias);
-    }
-    return this;
+  static equals(headers, right, equalFunctions) {
+    return Iterable.equals(headers, right, equalFunctions);
   }
-  getNameAndAliases() {
-    return List.create().add(this.getName()).addAll(this.getAliases());
+  toString(toStringFunctions) {
+    return _HttpHeaders.toString(this, toStringFunctions);
   }
-  getDescription() {
-    return this.description ?? "";
+  static toString(headers, toStringFunctions) {
+    return Iterable.toString(headers, toStringFunctions);
   }
-  setDescription(description) {
-    PreCondition.assertNotUndefinedAndNotNull(description, "description");
-    this.description = description;
-    return this;
+  concatenate(...toConcatenate) {
+    return _HttpHeaders.concatenate(this, ...toConcatenate);
   }
-};
-
-// sources/nodeJSCharacterWriteStream.ts
-var NodeJSCharacterWriteStream = class _NodeJSCharacterWriteStream extends CharacterWriteStream {
-  nodeJSWriteStream;
-  constructor(nodeJSWriteStream) {
-    PreCondition.assertNotUndefinedAndNotNull(nodeJSWriteStream, "nodeJSWriteStream");
-    super();
-    this.nodeJSWriteStream = nodeJSWriteStream;
+  static concatenate(headers, ...toConcatenate) {
+    return Iterable.concatenate(headers, ...toConcatenate);
   }
-  static create(nodeJSWriteStream) {
-    return new _NodeJSCharacterWriteStream(nodeJSWriteStream);
+  map(mapping) {
+    return _HttpHeaders.map(this, mapping);
   }
-  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);
-        }
-      });
-    }));
+  static map(headers, mapping) {
+    return Iterable.map(headers, mapping);
   }
-};
-
-// 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;
+  flatMap(mapping) {
+    return _HttpHeaders.flatMap(this, mapping);
   }
-  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 flatMap(headers, mapping) {
+    return Iterable.flatMap(headers, mapping);
   }
-  getValue() {
-    return this.getter();
+  where(condition) {
+    return _HttpHeaders.where(this, condition);
   }
-  setValue(value) {
-    this.setter(value);
-    return this;
+  static where(headers, condition) {
+    return Iterable.where(headers, condition);
   }
-  toString() {
-    return `${this.getValue()}`;
+  instanceOf(typeOrTypeCheck) {
+    return _HttpHeaders.instanceOf(this, typeOrTypeCheck);
   }
-};
-
-// 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 instanceOf(headers, typeOrTypeCheck) {
+    return Iterable.instanceOf(headers, typeOrTypeCheck);
   }
-  static create(name, value) {
-    return new _HttpHeader(name, value);
+  first(condition) {
+    return _HttpHeaders.first(this, condition);
   }
-  getName() {
-    return this.name;
+  static first(headers, condition) {
+    return Iterable.first(headers, condition);
   }
-  getValue() {
-    return this.value;
+  last(condition) {
+    return _HttpHeaders.last(this, condition);
   }
-  toString() {
-    return `${escapeAndQuote(this.name)}:${escapeAndQuote(this.value)}`;
+  static last(headers, condition) {
+    return Iterable.last(headers, condition);
   }
-};
-
-// sources/mutableHttpHeaders.ts
-var MutableHttpHeaders = class _MutableHttpHeaders {
-  headers;
-  constructor(headers) {
-    this.headers = List.create();
-    if (headers) {
-      this.setAll(headers);
-    }
+  [Symbol.iterator]() {
+    return _HttpHeaders[Symbol.iterator](this);
   }
-  static create(headers) {
-    return new _MutableHttpHeaders(headers);
+  static [Symbol.iterator](headers) {
+    return Iterable[Symbol.iterator](headers);
   }
-  iterate() {
-    return this.headers.iterate();
+  contains(value, equalFunctions) {
+    return _HttpHeaders.contains(this, value, equalFunctions);
   }
-  get(headerName) {
-    PreCondition.assertNotEmpty(headerName, "headerName");
+  static contains(headers, value, equalFunctions) {
     return SyncResult.create(() => {
-      let result;
-      const lowerHeaderName = headerName.toLowerCase();
-      for (const header of this.headers) {
-        if (header.getName().toLowerCase() === lowerHeaderName) {
-          result = header;
-          break;
-        }
-      }
-      if (result === void 0) {
-        throw new NotFoundError(`No HttpHeader found with the name ${escapeAndQuote(headerName)}.`);
-      }
-      return result;
-    });
-  }
-  getValue(headerName) {
-    return this.get(headerName).then((header) => header.getValue());
-  }
-  set(headerOrHeaderName, headerValue) {
-    let headerName;
-    if (isString(headerOrHeaderName)) {
-      headerName = headerOrHeaderName;
-    } else {
-      headerName = headerOrHeaderName.getName();
-      headerValue = headerOrHeaderName.getValue();
-    }
-    PreCondition.assertNotEmpty(headerName, "headerName");
-    PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
-    let insertIndex = 0;
-    for (let insertIndex2 = 0; insertIndex2 < this.headers.getCount().await(); insertIndex2++) {
-      const header = this.headers.get(insertIndex2).await();
-      if (header.getName() === headerName) {
-        this.headers.removeAt(insertIndex2);
-        break;
+      if (!equalFunctions) {
+        equalFunctions = EqualFunctions.create();
       }
-    }
-    this.headers.insert(insertIndex, HttpHeader.create(headerName, headerValue));
+      return headers.getValue(value.getName()).then((headerValue) => equalFunctions.areEqual(headerValue, value.getValue()).await()).catch(NotFoundError, () => false).await();
+    });
+  }
+};
+
+// sources/NodeJSHttpOutgoingResponse.ts
+var NodeJSHttpOutgoingResponse = class _NodeJSHttpOutgoingResponse {
+  innerResponse;
+  bodyString;
+  constructor(innerResponse) {
+    PreCondition.assertNotUndefinedAndNotNull(innerResponse, "innerResponse");
+    this.innerResponse = innerResponse;
+  }
+  static create(innerResponse) {
+    return new _NodeJSHttpOutgoingResponse(innerResponse);
+  }
+  setStatusCode(statusCode) {
+    this.innerResponse.statusCode = statusCode;
     return this;
   }
-  setAll(headers) {
-    PreCondition.assertNotUndefinedAndNotNull(headers, "headers");
-    for (const header of headers) {
-      this.set(header);
+  getStatusCode() {
+    return SyncResult.value(this.innerResponse.statusCode);
+  }
+  static headerValueToString(headerValue) {
+    PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
+    return isArray(headerValue) ? join(",", headerValue) : headerValue.toString();
+  }
+  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 this;
+    return result;
   }
-  setContentType(contentType) {
-    return this.set(HttpHeaders.contentTypeHeaderName, contentType);
+  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)));
   }
-  getContentType() {
-    return this.get(HttpHeaders.contentTypeHeaderName);
+  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));
   }
-  getContentTypeValue() {
-    return this.getValue(HttpHeaders.contentTypeHeaderName);
+  setHeader(headerName, headerValue) {
+    PreCondition.assertNotEmpty(headerName, "headerName");
+    PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
+    this.innerResponse.setHeader(headerName, headerValue);
+    return this;
   }
-  getCount() {
-    return this.headers.getCount();
+  setBodyString(body) {
+    PreCondition.assertNotUndefinedAndNotNull(body, "body");
+    this.bodyString = body;
+    return this;
   }
-  toArray() {
-    return HttpHeaders.toArray(this);
+  setBodyJSON(body) {
+    PreCondition.assertNotUndefinedAndNotNull(body, "body");
+    return this.setBodyString(JSON.stringify(body));
   }
-  any() {
-    return HttpHeaders.any(this);
+  end() {
+    return AsyncResult.create(new Promise((resolve, reject) => {
+      this.innerResponse.end(this.bodyString, () => {
+        resolve();
+      });
+    }));
   }
-  equals(right, equalFunctions) {
-    return HttpHeaders.equals(this, right, equalFunctions);
+};
+
+// sources/TokenType.ts
+var TokenType = class _TokenType {
+  name;
+  constructor(name) {
+    PreCondition.assertNotEmpty(name, "name");
+    this.name = name;
   }
-  toString(toStringFunctions) {
-    return HttpHeaders.toString(this, toStringFunctions);
+  static create(name) {
+    return new _TokenType(name);
   }
-  concatenate(...toConcatenate) {
-    return HttpHeaders.concatenate(this, ...toConcatenate);
+  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;
   }
-  map(mapping) {
-    return HttpHeaders.map(this, mapping);
+};
+
+// 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;
   }
-  flatMap(mapping) {
-    return HttpHeaders.flatMap(this, mapping);
+  static create(text, type) {
+    return new _Token(text, type);
   }
-  where(condition) {
-    return HttpHeaders.where(this, condition);
+  static whitespace(text) {
+    return _Token.create(text, TokenType.Whitespace);
   }
-  instanceOf(typeOrTypeCheck) {
-    return HttpHeaders.instanceOf(this, typeOrTypeCheck);
+  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;
   }
-  first(condition) {
-    return HttpHeaders.first(this, condition);
+  static leftParenthesis() {
+    return _Token.leftParenthesisToken;
   }
-  last(condition) {
-    return HttpHeaders.last(this, condition);
+  static rightParenthesis() {
+    return _Token.rightParenthesisToken;
   }
-  [Symbol.iterator]() {
-    return HttpHeaders[Symbol.iterator](this);
+  static backslash() {
+    return _Token.backslashToken;
   }
-  contains(value, equalFunctions) {
-    return HttpHeaders.contains(this, value, equalFunctions);
+  static forwardSlash() {
+    return _Token.forwardSlashToken;
   }
-};
-
-// sources/httpHeaders.ts
-var HttpHeaders = class _HttpHeaders {
-  static contentTypeHeaderName = "Content-Type";
-  static create(headers) {
-    return MutableHttpHeaders.create(headers);
+  static period() {
+    return _Token.periodToken;
   }
-  getContentType() {
-    return _HttpHeaders.getContentType(this);
+  static underscore() {
+    return _Token.underscoreToken;
   }
-  static getContentType(headers) {
-    return headers.get(_HttpHeaders.contentTypeHeaderName);
+  static colon() {
+    return _Token.colonToken;
   }
-  getContentTypeValue() {
-    return _HttpHeaders.getContentTypeValue(this);
+  static letters(text) {
+    return _Token.create(text, TokenType.Letters);
   }
-  static getContentTypeValue(headers) {
-    return headers.getValue(_HttpHeaders.contentTypeHeaderName);
+  static digits(text) {
+    return _Token.create(text, TokenType.Digits);
   }
-  /**
-   * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
-   */
-  toArray() {
-    return _HttpHeaders.toArray(this);
+  static unknown(text) {
+    return _Token.create(text, TokenType.Unknown);
   }
-  static toArray(headers) {
-    return Iterable.toArray(headers);
+  getText() {
+    return this.text;
   }
-  any() {
-    return _HttpHeaders.any(this);
+  getType() {
+    return this.type;
   }
-  static any(headers) {
-    return Iterable.any(headers);
+};
+
+// 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++;
   }
-  getCount() {
-    return _HttpHeaders.getCount(this);
+  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 getCount(headers) {
-    return Iterable.getCount(headers);
+  static create(args) {
+    return new _CommandLineParameters(args);
   }
-  equals(right, equalFunctions) {
-    return _HttpHeaders.equals(this, right, equalFunctions);
+  static getArgumentName(arg) {
+    return arg[0] === "-" ? arg.substring(arg[1] === "-" ? 2 : 1) : void 0;
   }
-  static equals(headers, right, equalFunctions) {
-    return Iterable.equals(headers, right, equalFunctions);
+  getArguments() {
+    return this.args;
+  }
+  /**
+   * Get the value of the first argument that matches one of the provided names. 
+   * @param names The possible names to look for.
+   */
+  getNamedArgumentStringValue(nameOrNames) {
+    PreCondition.assertNotEmpty(nameOrNames, "nameOrNames");
+    return SyncResult.create(() => {
+      let foundArgName = false;
+      let result;
+      if (isString(nameOrNames)) {
+        nameOrNames = [nameOrNames];
+      }
+      const searchNames = Iterable.create(nameOrNames);
+      for (const arg of this.args) {
+        if (!foundArgName) {
+          const argName = _CommandLineParameters.getArgumentName(arg);
+          foundArgName = !!(argName && searchNames.contains(argName));
+        } else {
+          result = arg;
+          break;
+        }
+      }
+      if (result === void 0) {
+        const toStringFunctions = ToStringFunctions.create();
+        throw new NotFoundError(`No argument found that matches ${orList(searchNames.map((n) => toStringFunctions.toString(n)))}.`);
+      }
+      return result;
+    });
   }
-  toString(toStringFunctions) {
-    return _HttpHeaders.toString(this, toStringFunctions);
+  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;
   }
-  static toString(headers, toStringFunctions) {
-    return Iterable.toString(headers, toStringFunctions);
+  add(name) {
+    const result = CommandLineParameter.create({
+      owner: this,
+      name
+    });
+    this.parameters.add(result);
+    return result;
   }
-  concatenate(...toConcatenate) {
-    return _HttpHeaders.concatenate(this, ...toConcatenate);
+};
+
+// 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 concatenate(headers, ...toConcatenate) {
-    return Iterable.concatenate(headers, ...toConcatenate);
+  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);
   }
-  map(mapping) {
-    return _HttpHeaders.map(this, mapping);
+  /**
+   * Get the name of this {@link CommandLineParameter}.
+   */
+  getName() {
+    return this.name;
   }
-  static map(headers, mapping) {
-    return Iterable.map(headers, mapping);
+  getAliases() {
+    return this.aliases ?? Iterable.create();
   }
-  flatMap(mapping) {
-    return _HttpHeaders.flatMap(this, mapping);
+  nameOrAliasExists(nameOrAlias) {
+    return this.owner.nameOrAliasExists(nameOrAlias);
   }
-  static flatMap(headers, mapping) {
-    return Iterable.flatMap(headers, mapping);
+  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;
   }
-  where(condition) {
-    return _HttpHeaders.where(this, condition);
+  addAliases(aliases) {
+    for (const alias of aliases) {
+      this.addAlias(alias);
+    }
+    return this;
   }
-  static where(headers, condition) {
-    return Iterable.where(headers, condition);
+  getNameAndAliases() {
+    return List.create().add(this.getName()).addAll(this.getAliases());
   }
-  instanceOf(typeOrTypeCheck) {
-    return _HttpHeaders.instanceOf(this, typeOrTypeCheck);
+  getDescription() {
+    return this.description ?? "";
   }
-  static instanceOf(headers, typeOrTypeCheck) {
-    return Iterable.instanceOf(headers, typeOrTypeCheck);
+  setDescription(description) {
+    PreCondition.assertNotUndefinedAndNotNull(description, "description");
+    this.description = description;
+    return this;
   }
-  first(condition) {
-    return _HttpHeaders.first(this, condition);
+};
+
+// sources/nodeJSCharacterWriteStream.ts
+var NodeJSCharacterWriteStream = class _NodeJSCharacterWriteStream extends CharacterWriteStream {
+  nodeJSWriteStream;
+  constructor(nodeJSWriteStream) {
+    PreCondition.assertNotUndefinedAndNotNull(nodeJSWriteStream, "nodeJSWriteStream");
+    super();
+    this.nodeJSWriteStream = nodeJSWriteStream;
   }
-  static first(headers, condition) {
-    return Iterable.first(headers, condition);
+  static create(nodeJSWriteStream) {
+    return new _NodeJSCharacterWriteStream(nodeJSWriteStream);
   }
-  last(condition) {
-    return _HttpHeaders.last(this, 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);
+        }
+      });
+    }));
   }
-  static last(headers, condition) {
-    return Iterable.last(headers, condition);
+};
+
+// 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()}`;
   }
 };
 
@@ -5289,14 +5534,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) {
@@ -5350,83 +5608,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;
@@ -5479,16 +5660,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();
@@ -5615,9 +5789,6 @@ var CurrentProcess = class _CurrentProcess {
   }
 };
 
-// sources/luxonDateTime.ts
-var luxon = __toESM(require("luxon"), 1);
-
 // sources/listStack.ts
 var ListStack = class _ListStack {
   list;
@@ -6834,12 +7005,37 @@ var ConsoleTestRunner = class _ConsoleTestRunner {
     return this.ui.writeSummary(this.passedTestCount, this.getSkippedTests(), this.getFailedTests());
   }
 };
+
+// tests/FakeClock.ts
+var FakeClock = class _FakeClock extends Clock {
+  currentTime;
+  constructor(currentTime) {
+    PreCondition.assertNotUndefinedAndNotNull(currentTime, "currentTime");
+    super();
+    this.currentTime = currentTime;
+  }
+  static create(currentTime) {
+    return new _FakeClock(currentTime ?? DateTime2.now());
+  }
+  /**
+   * Set the {@link DateTime} that this {@link FakeClock} will return.
+   * @param currentTime The {@link DateTime} that this {@link FakeClock} will return.
+   */
+  setCurrentTime(currentTime) {
+    this.currentTime = currentTime;
+    return this;
+  }
+  now() {
+    return this.currentTime;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssertTest,
   BasicTestSkip,
   ConsoleTestRunner,
   FailedTest,
+  FakeClock,
   SkippedTest,
   Test,
   TestAction,