@everyonesoftware/common 6.0.0 → 7.0.0

package/outputs/chunk-6V7JRJ7P.js

@@ -1,2469 +0,0 @@
-import {
-  CharacterWriteStream,
-  Comparer,
-  EmptyError,
-  FetchHttpClient,
-  HttpOutgoingRequest,
-  Iterable,
-  Iterator,
-  List,
-  Map,
-  MutableMap,
-  NotFoundError,
-  PreCondition,
-  PromiseAsyncResult,
-  Set,
-  SyncResult,
-  getLength,
-  hasProperty,
-  isArray,
-  isJavascriptIterable,
-  isNumber,
-  isObject,
-  isString,
-  isUndefinedOrNull,
-  join
-} from "./chunk-5Z677JON.js";
-
-// sources/basicDisposable.ts
-var SyncDisposable = class _SyncDisposable {
-  disposedFunction;
-  disposed;
-  constructor(disposedFunction) {
-    PreCondition.assertNotUndefinedAndNotNull(disposedFunction, "disposedFunction");
-    this.disposedFunction = disposedFunction;
-    this.disposed = false;
-  }
-  /**
-   * Create a new {@link Disposable} that will invoke the provided {@link Function} when it is
-   * disposed.
-   * @param disposedFunction The function to invoke when the returned {@link Disposable} is
-   * disposed.
-   */
-  static create(disposedFunction) {
-    return new _SyncDisposable(disposedFunction);
-  }
-  dispose() {
-    return SyncResult.create(() => {
-      const result = !this.disposed;
-      if (result) {
-        try {
-          this.disposedFunction();
-        } finally {
-          this.disposed = true;
-        }
-      }
-      return result;
-    });
-  }
-  isDisposed() {
-    return this.disposed;
-  }
-};
-
-// sources/byteList.ts
-var ByteList = class _ByteList {
-  bytes;
-  count;
-  constructor() {
-    this.bytes = new Uint8Array(0);
-    this.count = 0;
-  }
-  static create(initialValues) {
-    const result = new _ByteList();
-    if (initialValues) {
-      result.addAll(initialValues);
-    }
-    return result;
-  }
-  add(value) {
-    return List.add(this, value);
-  }
-  addAll(values) {
-    return List.addAll(this, values);
-  }
-  insert(index, value) {
-    PreCondition.assertInsertIndex(index, this.getCount().await(), "index");
-    PreCondition.assertByte(value, "value");
-    if (this.count < this.bytes.length) {
-      if (index < this.count) {
-        this.bytes.copyWithin(index + 1, index, this.count);
-      }
-      this.bytes[index] = value;
-    } else {
-      const newCapacity = this.bytes.length * 2 + 1;
-      const newBytes = new Uint8Array(newCapacity);
-      if (index > 0) {
-        newBytes.set(this.bytes.subarray(0, index));
-      }
-      newBytes[index] = value;
-      if (index < this.count) {
-        newBytes.set(this.bytes.subarray(index), index + 1);
-      }
-      this.bytes = newBytes;
-    }
-    this.count++;
-    return this;
-  }
-  insertAll(index, values) {
-    return List.insertAll(this, index, values);
-  }
-  remove(value, equalFunctions) {
-    PreCondition.assertByte(value, "value");
-    return List.remove(this, value, equalFunctions);
-  }
-  removeAt(index) {
-    PreCondition.assertAccessIndex(index, this.count, "index");
-    const result = this.bytes[index];
-    this.bytes.copyWithin(index, index + 1, this.count);
-    this.count--;
-    return SyncResult.value(result);
-  }
-  removeFirst() {
-    return List.removeFirst(this);
-  }
-  removeLast() {
-    return List.removeLast(this);
-  }
-  set(index, value) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    PreCondition.assertByte(value, "value");
-    this.bytes[index] = value;
-    return this;
-  }
-  iterate() {
-    return Iterator.create(this.bytes[Symbol.iterator]().take(this.count));
-  }
-  get(index) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    return SyncResult.value(this.bytes.at(index));
-  }
-  toArray() {
-    return List.toArray(this);
-  }
-  any() {
-    return this.getCount().then((count) => count > 0);
-  }
-  getCount() {
-    return SyncResult.value(this.count);
-  }
-  equals(right, equalFunctions) {
-    return List.equals(this, right, equalFunctions);
-  }
-  toString(toStringFunctions) {
-    return List.toString(this, toStringFunctions);
-  }
-  concatenate(...toConcatenate) {
-    return List.concatenate(this, ...toConcatenate);
-  }
-  map(mapping) {
-    return List.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return List.flatMap(this, mapping);
-  }
-  where(condition) {
-    return List.where(this, condition);
-  }
-  instanceOf(typeOrTypeCheck) {
-    return List.instanceOf(this, typeOrTypeCheck);
-  }
-  first(condition) {
-    return List.first(this, condition);
-  }
-  last(condition) {
-    return List.last(this, condition);
-  }
-  contains(value, equalFunctions) {
-    return List.contains(this, value, equalFunctions);
-  }
-  [Symbol.iterator]() {
-    return List[Symbol.iterator](this);
-  }
-};
-
-// sources/byteListStream.ts
-var ByteListStream = class _ByteListStream {
-  list;
-  constructor() {
-    this.list = ByteList.create();
-  }
-  static create(initialValues) {
-    const result = new _ByteListStream();
-    if (initialValues) {
-      result.writeBytes(initialValues).await();
-    }
-    return result;
-  }
-  /**
-   * Get the number of bytes that are available to be read.
-   */
-  getAvailableByteCount() {
-    return this.list.getCount().await();
-  }
-  writeBytes(bytes, startIndex, length) {
-    PreCondition.assertNotUndefinedAndNotNull(bytes, "bytes");
-    if (isArray(bytes)) {
-      bytes = new Uint8Array(bytes);
-    }
-    if (isUndefinedOrNull(startIndex)) {
-      startIndex = 0;
-    }
-    if (isUndefinedOrNull(length)) {
-      length = bytes.length - startIndex;
-    }
-    PreCondition.assertInsertIndex(startIndex, bytes.length, "startIndex");
-    PreCondition.assertBetween(0, length, bytes.length - startIndex, "length");
-    this.list.addAll(bytes.subarray(startIndex, length + startIndex));
-    return SyncResult.value(length);
-  }
-  readBytes(countOrOutput, startIndex, count) {
-    let result;
-    if (isNumber(countOrOutput)) {
-      PreCondition.assertGreaterThanOrEqualTo(countOrOutput, 0, "count");
-      if (!this.list.any().await()) {
-        result = SyncResult.error(new EmptyError());
-      } else {
-        const bytesReadCount = Math.min(countOrOutput, this.list.getCount().await());
-        const output = new Uint8Array(bytesReadCount);
-        for (let i = 0; i < bytesReadCount; i++) {
-          output[i] = this.list.removeFirst().await();
-        }
-        result = SyncResult.value(output);
-      }
-    } else {
-      PreCondition.assertNotUndefinedAndNotNull(countOrOutput, "output");
-      if (isUndefinedOrNull(startIndex)) {
-        startIndex = 0;
-      }
-      if (isUndefinedOrNull(count)) {
-        count = countOrOutput.length - startIndex;
-      }
-      PreCondition.assertInsertIndex(startIndex, countOrOutput.length, "startIndex");
-      PreCondition.assertBetween(0, count, countOrOutput.length - startIndex, "count");
-      if (!this.list.any().await()) {
-        result = SyncResult.error(new EmptyError());
-      } else {
-        const bytesReadCount = Math.min(count, this.list.getCount().await());
-        for (let i = 0; i < bytesReadCount; i++) {
-          countOrOutput[startIndex + i] = this.list.removeFirst().await();
-        }
-        result = SyncResult.value(bytesReadCount);
-      }
-    }
-    return result;
-  }
-};
-
-// sources/stringIterator.ts
-var StringIterator = class _StringIterator {
-  value;
-  currentIndex;
-  started;
-  constructor(value) {
-    this.value = value;
-    this.currentIndex = 0;
-    this.started = false;
-  }
-  static create(value) {
-    PreCondition.assertNotUndefinedAndNotNull(value, "value");
-    return new _StringIterator(value);
-  }
-  getCurrentIndex() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.currentIndex;
-  }
-  next() {
-    return SyncResult.create(() => {
-      if (!this.hasStarted()) {
-        this.started = true;
-      } else if (this.hasCurrent()) {
-        this.currentIndex++;
-      }
-      return this.hasCurrent();
-    });
-  }
-  hasStarted() {
-    return this.started;
-  }
-  hasCurrent() {
-    return this.hasStarted() && this.currentIndex < this.value.length;
-  }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.value[this.currentIndex];
-  }
-  start() {
-    return Iterator.start(this);
-  }
-  takeCurrent() {
-    return Iterator.takeCurrent(this);
-  }
-  any() {
-    return Iterator.any(this);
-  }
-  getCount() {
-    return Iterator.getCount(this);
-  }
-  toArray() {
-    return Iterator.toArray(this);
-  }
-  concatenate(...toConcatenate) {
-    return Iterator.concatenate(this, ...toConcatenate);
-  }
-  map(mapping) {
-    return Iterator.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return Iterator.flatMap(this, mapping);
-  }
-  first() {
-    return Iterator.first(this);
-  }
-  last() {
-    return Iterator.last(this);
-  }
-  where(condition) {
-    return Iterator.where(this, condition);
-  }
-  whereInstanceOf(typeCheck) {
-    return Iterator.whereInstanceOf(this, typeCheck);
-  }
-  whereInstanceOfType(type) {
-    return Iterator.whereInstanceOfType(this, type);
-  }
-  take(maximumToTake) {
-    return Iterator.take(this, maximumToTake);
-  }
-  skip(maximumToSkip) {
-    return Iterator.skip(this, maximumToSkip);
-  }
-  [Symbol.iterator]() {
-    return Iterator[Symbol.iterator](this);
-  }
-};
-
-// sources/characterList.ts
-var CharacterList = class _CharacterList {
-  characters;
-  constructor(values) {
-    if (isString(values)) {
-      this.characters = values;
-    } else if (values) {
-      this.characters = join("", values);
-    } else {
-      this.characters = "";
-    }
-  }
-  static create(values) {
-    return new _CharacterList(values);
-  }
-  getCount() {
-    return SyncResult.value(this.characters.length);
-  }
-  insert(index, value) {
-    PreCondition.assertInsertIndex(index, this.getCount().await(), "index");
-    PreCondition.assertCharacter(value, "value");
-    if (index === 0) {
-      this.characters = value + this.characters;
-    } else if (index === this.getCount().await()) {
-      this.characters += value;
-    } else {
-      this.characters = this.characters.slice(0, index) + value + this.characters.slice(index);
-    }
-    return this;
-  }
-  removeAt(index) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    const result = this.get(index).await();
-    this.characters = (index === 0 ? "" : this.characters.slice(0, index)) + (index === this.getCount().await() - 1 ? "" : this.characters.slice(index + 1));
-    return SyncResult.value(result);
-  }
-  set(index, value) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    PreCondition.assertCharacter(value, "value");
-    this.characters = (index === 0 ? "" : this.characters.slice(0, index)) + value + (index === this.getCount().await() - 1 ? "" : this.characters.slice(index + 1));
-    return this;
-  }
-  iterate() {
-    return StringIterator.create(this.characters);
-  }
-  get(index) {
-    PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-    return SyncResult.value(this.characters.charAt(index));
-  }
-  add(value) {
-    return List.add(this, value);
-  }
-  addAll(values) {
-    return List.addAll(this, values);
-  }
-  insertAll(index, values) {
-    return List.insertAll(this, index, values);
-  }
-  remove(value, equalFunctions) {
-    return List.remove(this, value, equalFunctions);
-  }
-  removeFirst() {
-    return List.removeFirst(this);
-  }
-  removeLast() {
-    return List.removeLast(this);
-  }
-  toArray() {
-    return List.toArray(this);
-  }
-  any() {
-    return List.any(this);
-  }
-  equals(right, equalFunctions) {
-    return List.equals(this, right, equalFunctions);
-  }
-  toString(toStringFunctions) {
-    return List.toString(this, toStringFunctions);
-  }
-  concatenate(...toConcatenate) {
-    return List.concatenate(this, ...toConcatenate);
-  }
-  map(mapping) {
-    return List.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return List.flatMap(this, mapping);
-  }
-  where(condition) {
-    return List.where(this, condition);
-  }
-  instanceOf(typeOrTypeCheck) {
-    return List.instanceOf(this, typeOrTypeCheck);
-  }
-  first(condition) {
-    return List.first(this, condition);
-  }
-  last(condition) {
-    return List.last(this, condition);
-  }
-  contains(value, equalFunctions) {
-    return List.contains(this, value, equalFunctions);
-  }
-  [Symbol.iterator]() {
-    return List[Symbol.iterator](this);
-  }
-};
-
-// sources/characterReadStream.ts
-var CharacterReadStream = class _CharacterReadStream {
-  readCharacters(count) {
-    return _CharacterReadStream.readCharacters(this, count);
-  }
-  static readCharacters(readStream, count) {
-    let characters = "";
-    function readUntilCount(countRemaining) {
-      return readStream.readCharacter().then((character) => {
-        characters += character;
-        return countRemaining === 0 ? SyncResult.value(characters) : readUntilCount(countRemaining - 1);
-      });
-    }
-    return readUntilCount(count);
-  }
-  /**
-   * Read characters from this stream until the provided {@link searchString} is found or the end
-   * of the stream is reached. The {@link searchString} will be included in the returned string if
-   * it is found..
-   * @param searchString The string to search for.
-   */
-  readUntil(searchString) {
-    return _CharacterReadStream.readUntil(this, searchString);
-  }
-  static readUntil(readStream, searchString) {
-    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-    PreCondition.assertNotEmpty(searchString, "searchString");
-    let characters = "";
-    function readUntilSearchString() {
-      return readStream.readCharacter().then((character) => {
-        characters += character;
-        return characters.endsWith(searchString) ? SyncResult.value(characters) : readUntilSearchString();
-      });
-    }
-    return readUntilSearchString();
-  }
-  /**
-   * Read a sequence of characters from this stream until either a newline character ('\\n') or
-   * the end of the stream is reached. Terminating newline characters will be included in the
-   * returned string.
-   */
-  readLine() {
-    return _CharacterReadStream.readLine(this);
-  }
-  static readLine(readStream) {
-    PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-    return readStream.readUntil("\n");
-  }
-};
-
-// sources/characterListStream.ts
-var CharacterListStream = class _CharacterListStream {
-  list;
-  constructor() {
-    this.list = CharacterList.create();
-  }
-  static create(initialValues) {
-    const result = new _CharacterListStream();
-    if (initialValues) {
-      result.writeCharacters(initialValues).await();
-    }
-    return result;
-  }
-  writeCharacters(characters, startIndex, length) {
-    PreCondition.assertNotUndefinedAndNotNull(characters, "characters");
-    const characterString = isString(characters) ? characters : join("", characters);
-    if (isUndefinedOrNull(startIndex)) {
-      startIndex = 0;
-    }
-    if (isUndefinedOrNull(length)) {
-      length = characterString.length - startIndex;
-    }
-    PreCondition.assertInsertIndex(startIndex, characterString.length, "startIndex");
-    PreCondition.assertBetween(0, length, characterString.length - startIndex, "length");
-    this.list.addAll(characterString.slice(startIndex, length + startIndex));
-    return SyncResult.value(length);
-  }
-  writeString(text) {
-    this.list.addAll(text);
-    return SyncResult.value(text.length);
-  }
-  writeLine(text) {
-    return CharacterWriteStream.writeLine(this, text);
-  }
-  /**
-   * Get the number of characters that are available to be read.
-   */
-  getAvailableCharacterCount() {
-    return this.list.getCount().await();
-  }
-  readCharacter() {
-    return !this.list.any().await() ? SyncResult.error(new EmptyError()) : SyncResult.value(this.list.removeFirst().await());
-  }
-  readCharacters(countOrOutput, startIndex, count) {
-    let result;
-    if (isNumber(countOrOutput)) {
-      PreCondition.assertGreaterThanOrEqualTo(countOrOutput, 0, "count");
-      if (!this.list.any().await()) {
-        result = SyncResult.error(new EmptyError());
-      } else {
-        const bytesReadCount = Math.min(countOrOutput, this.list.getCount().await());
-        let output = "";
-        for (let i = 0; i < bytesReadCount; i++) {
-          output += this.list.removeFirst().await();
-        }
-        result = SyncResult.value(output);
-      }
-    } else {
-      PreCondition.assertNotUndefinedAndNotNull(countOrOutput, "output");
-      if (isUndefinedOrNull(startIndex)) {
-        startIndex = 0;
-      }
-      if (isUndefinedOrNull(count)) {
-        count = countOrOutput.length - startIndex;
-      }
-      PreCondition.assertInsertIndex(startIndex, countOrOutput.length, "startIndex");
-      PreCondition.assertBetween(0, count, countOrOutput.length - startIndex, "count");
-      if (!this.list.any().await()) {
-        result = SyncResult.error(new EmptyError());
-      } else {
-        const bytesReadCount = Math.min(count, this.list.getCount().await());
-        for (let i = 0; i < bytesReadCount; i++) {
-          countOrOutput[startIndex + i] = this.list.removeFirst().await();
-        }
-        result = SyncResult.value(bytesReadCount);
-      }
-    }
-    return result;
-  }
-  readUntil(searchString) {
-    return CharacterReadStream.readUntil(this, searchString);
-  }
-  readLine() {
-    return CharacterReadStream.readLine(this);
-  }
-};
-
-// sources/luxonDateTime.ts
-import * as luxon from "luxon";
-
-// sources/dateTime.ts
-var DateTime = class _DateTime {
-  static parse(text) {
-    return LuxonDateTime.parse(text);
-  }
-  static now() {
-    return LuxonDateTime.now();
-  }
-  /**
-   * Compare this {@link DateTime} to the provided {@link DateTime}. If this {@link DateTime} is
-   * less than the provided {@link DateTime}, then a negative number will be returned, 0 if
-   * they're equal, or a positive number if this {@link DateTime} is greater than the provided
-   * {@link DateTime}.
-   * @param dateTime The {@link DateTime} to compare to this {@link DateTime}.
-   */
-  compareTo(dateTime, compareTimes) {
-    return _DateTime.compareTo(this, dateTime, compareTimes);
-  }
-  static compareTo(left, right, compareTimes) {
-    let result = left.getYear() - right.getYear();
-    if (result === 0) {
-      result = left.getMonth() - right.getMonth();
-      if (result === 0) {
-        result = left.getDay() - right.getDay();
-        if (compareTimes && result === 0) {
-          result = left.getHour() - right.getHour();
-          if (result === 0) {
-            result = left.getMinute() - right.getMinute();
-            if (result === 0) {
-              result = left.getSecond();
-              -right.getSecond();
-            }
-          }
-        }
-      }
-    }
-    return result;
-  }
-  lessThan(dateTime, compareTimes) {
-    return _DateTime.lessThan(this, dateTime, compareTimes);
-  }
-  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/luxonDateTime.ts
-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 DateTime.compareTo(this, dateTime, compareTimes);
-  }
-  lessThan(dateTime, compareTimes) {
-    return DateTime.lessThan(this, dateTime, compareTimes);
-  }
-  lessThanOrEqualTo(dateTime, compareTimes) {
-    return DateTime.lessThanOrEqualTo(this, dateTime, compareTimes);
-  }
-  equals(dateTime, compareTimes) {
-    return DateTime.equals(this, dateTime, compareTimes);
-  }
-  greaterThanOrEqualTo(dateTime, compareTimes) {
-    return DateTime.greaterThanOrEqualTo(this, dateTime, compareTimes);
-  }
-  greaterThan(dateTime, compareTimes) {
-    return DateTime.greaterThan(this, dateTime, compareTimes);
-  }
-  get debug() {
-    return DateTime.debug(this);
-  }
-};
-
-// sources/listStack.ts
-var ListStack = class _ListStack {
-  list;
-  constructor(list) {
-    this.list = list ?? List.create();
-  }
-  static create(list) {
-    return new _ListStack(list);
-  }
-  any() {
-    return this.list.any();
-  }
-  add(value) {
-    return SyncResult.create(() => {
-      this.list.add(value);
-    });
-  }
-  addAll(values) {
-    PreCondition.assertNotUndefinedAndNotNull(values, "values");
-    return SyncResult.create(() => {
-      this.list.addAll(values);
-    });
-  }
-  remove() {
-    return SyncResult.create(() => {
-      if (!this.any().await()) {
-        throw new EmptyError();
-      }
-      return this.list.removeLast().await();
-    });
-  }
-  contains(value, equalFunctions) {
-    return this.list.contains(value, equalFunctions);
-  }
-};
-
-// sources/stack.ts
-var Stack = class {
-  /**
-   * Create an instance of the default {@link Stack} implementation.
-   * @returns A new {@link Stack} object.
-   */
-  static create() {
-    return ListStack.create();
-  }
-};
-
-// sources/depthFirstSearch.ts
-var SearchBreakError = class extends Error {
-};
-var DepthFirstSearch = class _DepthFirstSearch {
-  searchAction;
-  toVisit;
-  visited;
-  results;
-  started;
-  done;
-  constructor(initialToVisit, searchAction) {
-    PreCondition.assertNotEmpty(initialToVisit, "initialToVisit");
-    PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
-    this.searchAction = searchAction;
-    this.toVisit = Stack.create();
-    this.toVisit.addAll(initialToVisit).await();
-    this.visited = Set.create();
-    this.results = List.create();
-    this.started = false;
-    this.done = false;
-  }
-  static create(initialToVisit, searchAction) {
-    return new _DepthFirstSearch(initialToVisit, searchAction);
-  }
-  addToVisit(toVisit) {
-    if (!this.hasVisited(toVisit)) {
-      this.toVisit.add(toVisit);
-    }
-  }
-  addAllToVisit(values) {
-    for (const value of values) {
-      this.addToVisit(value);
-    }
-  }
-  hasVisited(toVisit) {
-    return this.visited.contains(toVisit).await();
-  }
-  addResult(result) {
-    this.results.add(result);
-  }
-  addResults(results) {
-    this.results.addAll(results);
-  }
-  break() {
-    throw new SearchBreakError();
-  }
-  next() {
-    return SyncResult.create(() => {
-      let result = false;
-      if (!this.done) {
-        if (!this.started) {
-          this.started = true;
-        } else {
-          this.results.removeFirst().await();
-        }
-        while (!this.hasCurrent() && this.toVisit.any().await()) {
-          const current = this.toVisit.remove().await();
-          this.visited.add(current);
-          this.searchAction(this, current);
-        }
-        result = this.hasCurrent();
-        this.done = !result;
-      }
-      return result;
-    });
-  }
-  hasStarted() {
-    return this.started;
-  }
-  hasCurrent() {
-    return this.results.any().await();
-  }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.results.first().await();
-  }
-  start() {
-    return Iterator.start(this);
-  }
-  takeCurrent() {
-    return Iterator.takeCurrent(this);
-  }
-  any() {
-    return Iterator.any(this);
-  }
-  getCount() {
-    return Iterator.getCount(this);
-  }
-  toArray() {
-    return Iterator.toArray(this);
-  }
-  concatenate(...toConcatenate) {
-    return Iterator.concatenate(this, ...toConcatenate);
-  }
-  where(condition) {
-    return Iterator.where(this, condition);
-  }
-  map(mapping) {
-    return Iterator.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return Iterator.flatMap(this, mapping);
-  }
-  whereInstanceOf(typeCheck) {
-    return Iterator.whereInstanceOf(this, typeCheck);
-  }
-  whereInstanceOfType(type) {
-    return Iterator.whereInstanceOfType(this, type);
-  }
-  first(condition) {
-    return Iterator.first(this, condition);
-  }
-  last(condition) {
-    return Iterator.last(this, condition);
-  }
-  take(maximumToTake) {
-    return Iterator.take(this, maximumToTake);
-  }
-  skip(maximumToSkip) {
-    return Iterator.skip(this, maximumToSkip);
-  }
-  [Symbol.iterator]() {
-    return Iterator[Symbol.iterator](this);
-  }
-};
-function depthFirstSearch(parametersOrInitialToVisit, searchAction) {
-  let initialToVisit;
-  if (isJavascriptIterable(parametersOrInitialToVisit)) {
-    initialToVisit = parametersOrInitialToVisit;
-    searchAction = searchAction;
-  } else {
-    PreCondition.assertNotUndefinedAndNotNull(parametersOrInitialToVisit, "parameters");
-    initialToVisit = parametersOrInitialToVisit.initialToVisit;
-    searchAction = parametersOrInitialToVisit.searchAction;
-  }
-  PreCondition.assertNotUndefinedAndNotNull(initialToVisit, "initialToVisit");
-  PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
-  return DepthFirstSearch.create(initialToVisit, searchAction);
-}
-
-// sources/disposable.ts
-var Disposable = class {
-  /**
-   * Create a new {@link Disposable} that will invoke the provided {@link Function} when it is
-   * disposed.
-   * @param disposedFunction The function to invoke when the returned {@link Disposable} is
-   * disposed.
-   */
-  static create(disposedFunction) {
-    return SyncDisposable.create(disposedFunction);
-  }
-};
-
-// sources/generator.ts
-var InnerGeneratorControl = class _InnerGeneratorControl {
-  returnValues;
-  done;
-  constructor() {
-    this.returnValues = List.create();
-    this.done = false;
-  }
-  static create() {
-    return new _InnerGeneratorControl();
-  }
-  addValue(returnValue) {
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    this.returnValues.add(returnValue);
-  }
-  addValues(returnValues) {
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    this.returnValues.addAll(returnValues);
-  }
-  hasCurrent() {
-    return this.returnValues.any().await();
-  }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    return this.returnValues.first().await();
-  }
-  removeCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    this.returnValues.removeFirst().await();
-  }
-  setDone() {
-    PreCondition.assertFalse(this.hasCurrent(), "this.hasCurrent()");
-    PreCondition.assertFalse(this.isDone(), "this.isDone()");
-    this.done = true;
-  }
-  isDone() {
-    return this.done;
-  }
-};
-var Generator = class _Generator {
-  control;
-  generatorAction;
-  started;
-  constructor(generatorAction) {
-    PreCondition.assertNotUndefinedAndNotNull(generatorAction, "generatorAction");
-    this.control = InnerGeneratorControl.create();
-    this.generatorAction = generatorAction;
-    this.started = false;
-  }
-  static create(generatorAction) {
-    return new _Generator(generatorAction);
-  }
-  next() {
-    return SyncResult.create(() => {
-      if (!this.control.isDone()) {
-        if (!this.hasStarted()) {
-          this.started = true;
-        } else {
-          this.control.removeCurrent();
-        }
-        if (!this.control.hasCurrent()) {
-          const actionResult = this.generatorAction(this.control);
-          if (actionResult !== void 0) {
-            this.control.addValue(actionResult);
-          }
-          if (!this.control.hasCurrent()) {
-            this.control.setDone();
-          }
-        }
-      }
-      return this.hasCurrent();
-    });
-  }
-  hasStarted() {
-    return this.started;
-  }
-  hasCurrent() {
-    return this.control.hasCurrent();
-  }
-  getCurrent() {
-    PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-    return this.control.getCurrent();
-  }
-  start() {
-    return Iterator.start(this);
-  }
-  takeCurrent() {
-    return Iterator.takeCurrent(this);
-  }
-  any() {
-    return Iterator.any(this);
-  }
-  getCount() {
-    return Iterator.getCount(this);
-  }
-  toArray() {
-    return Iterator.toArray(this);
-  }
-  concatenate(...toConcatenate) {
-    return Iterator.concatenate(this, ...toConcatenate);
-  }
-  where(condition) {
-    return Iterator.where(this, condition);
-  }
-  map(mapping) {
-    return Iterator.map(this, mapping);
-  }
-  flatMap(mapping) {
-    return Iterator.flatMap(this, mapping);
-  }
-  whereInstanceOf(typeCheck) {
-    return Iterator.whereInstanceOf(this, typeCheck);
-  }
-  whereInstanceOfType(type) {
-    return Iterator.whereInstanceOfType(this, type);
-  }
-  first(condition) {
-    return Iterator.first(this, condition);
-  }
-  last(condition) {
-    return Iterator.last(this, condition);
-  }
-  take(maximumToTake) {
-    return Iterator.take(this, maximumToTake);
-  }
-  skip(maximumToSkip) {
-    return Iterator.skip(this, maximumToSkip);
-  }
-  [Symbol.iterator]() {
-    return Iterator[Symbol.iterator](this);
-  }
-};
-
-// sources/httpClient.ts
-var HttpClient = class _HttpClient {
-  static create() {
-    return FetchHttpClient.create();
-  }
-  /**
-   * Send a GET {@link HttpOutgoingRequest} to the provided URL.
-   * @param url The URL to send the GET {@link HttpOutgoingRequest} to.
-   */
-  sendGetRequest(url) {
-    return _HttpClient.sendGetRequest(this, url);
-  }
-  static sendGetRequest(httpClient, url) {
-    return httpClient.sendRequest(HttpOutgoingRequest.create(0 /* GET */, url));
-  }
-};
-
-// sources/inMemoryCharacterWriteStream.ts
-var InMemoryCharacterWriteStream = class _InMemoryCharacterWriteStream extends CharacterWriteStream {
-  writtenText;
-  newlineSequence;
-  constructor() {
-    super();
-    this.writtenText = "";
-    this.newlineSequence = "\n";
-  }
-  static create() {
-    return new _InMemoryCharacterWriteStream();
-  }
-  getNewlineSequence() {
-    return this.newlineSequence;
-  }
-  setNewlineSequence(newlineSequence) {
-    PreCondition.assertNotUndefinedAndNotNull(newlineSequence, "newlineSequence");
-    this.newlineSequence = newlineSequence;
-    return this;
-  }
-  getWrittenText() {
-    return this.writtenText;
-  }
-  clearWrittenText() {
-    this.writtenText = "";
-    return this;
-  }
-  writeString(text) {
-    return SyncResult.create(() => {
-      if (text) {
-        this.writtenText += text;
-      }
-      return getLength(text);
-    });
-  }
-  writeLine(text) {
-    return SyncResult.create(() => {
-      let result = 0;
-      if (text) {
-        result += this.writeString(text).await();
-      }
-      if (this.newlineSequence) {
-        result += this.writeString(this.newlineSequence).await();
-      }
-      return result;
-    });
-  }
-};
-
-// sources/listQueue.ts
-var ListQueue = class _ListQueue {
-  list;
-  constructor(list) {
-    this.list = list ?? List.create();
-  }
-  static create(list) {
-    return new _ListQueue(list);
-  }
-  any() {
-    return this.list.any();
-  }
-  add(value) {
-    return SyncResult.create(() => {
-      this.list.add(value);
-    });
-  }
-  addAll(values) {
-    PreCondition.assertNotUndefinedAndNotNull(values, "values");
-    return SyncResult.create(() => {
-      this.list.addAll(values);
-    });
-  }
-  remove() {
-    return SyncResult.create(() => {
-      if (!this.any().await()) {
-        throw new EmptyError();
-      }
-      return this.list.removeLast().await();
-    });
-  }
-  contains(value, equalFunctions) {
-    return this.list.contains(value, equalFunctions);
-  }
-};
-
-// sources/node.ts
-var Node = class _Node {
-  value;
-  connectedNodes;
-  constructor(value) {
-    this.value = value;
-    this.connectedNodes = Set.create();
-  }
-  static create(value) {
-    return new _Node(value);
-  }
-  getValue() {
-    return this.value;
-  }
-  iterateConnectedNodes() {
-    return this.connectedNodes.iterate();
-  }
-  addConnectedNode(node) {
-    PreCondition.assertNotUndefinedAndNotNull(node, "node");
-    this.connectedNodes.add(node);
-  }
-};
-
-// sources/queue.ts
-var Queue = class {
-  /**
-   * Create an instance of the default {@link Queue} implementation.
-   * @returns A new {@link Queue} object.
-   */
-  static create() {
-    return ListQueue.create();
-  }
-};
-
-// sources/recreationDotGovClient.ts
-var RecreationDotGovDivisionAvailability = class _RecreationDotGovDivisionAvailability {
-  json;
-  minimumGroupSize;
-  maximumGroupSize;
-  dayAvailabilities;
-  constructor(json) {
-    PreCondition.assertNotUndefinedAndNotNull(json, "json");
-    this.json = json;
-    const minGroupSize = "MinGroupSize".toLowerCase();
-    const maxGroupSize = "MaxGroupSize".toLowerCase();
-    for (const rule of json.rules) {
-      switch (rule.name.toLowerCase()) {
-        case minGroupSize:
-          this.minimumGroupSize = rule.value;
-          break;
-        case maxGroupSize:
-          this.maximumGroupSize = rule.value;
-          break;
-      }
-    }
-    const dayAvailabilities = List.create();
-    const quotaUsageByMemberDaily = json.quota_type_maps?.QuotaUsageByMemberDaily;
-    if (quotaUsageByMemberDaily) {
-      for (const quotaUsage of Object.entries(quotaUsageByMemberDaily)) {
-        const dateString = quotaUsage[0];
-        const usageData = quotaUsage[1];
-        let walkup = false;
-        let reservationsRemaining = 0;
-        const boolsEntry = json.bools[dateString];
-        if (boolsEntry) {
-          walkup = usageData.show_walkup;
-          reservationsRemaining = usageData.remaining;
-        }
-        dayAvailabilities.add({
-          date: DateTime.parse(dateString),
-          totalSpots: usageData.total,
-          walkup,
-          reservationsRemaining
-        });
-      }
-    }
-    this.dayAvailabilities = dayAvailabilities;
-  }
-  static create(json) {
-    return new _RecreationDotGovDivisionAvailability(json);
-  }
-};
-var RecreationDotGovError = class extends Error {
-  constructor(message) {
-    super(message);
-  }
-};
-var RecreationDotGovClient = class _RecreationDotGovClient {
-  httpClient;
-  constructor(httpClient) {
-    PreCondition.assertNotUndefinedAndNotNull(httpClient, "httpClient");
-    this.httpClient = httpClient;
-  }
-  static create(httpClient) {
-    return new _RecreationDotGovClient(httpClient);
-  }
-  sendRequest(request) {
-    return this.httpClient.sendRequest(request);
-  }
-  sendGetRequest(url) {
-    return HttpClient.sendGetRequest(this, url);
-  }
-  getPermitItinerary(permitItineraryId) {
-    PreCondition.assertNotEmpty(permitItineraryId, "permitItineraryId");
-    return PromiseAsyncResult.create(async () => {
-      const response = await this.sendGetRequest(`https://www.recreation.gov/api/permitcontent/${permitItineraryId}`);
-      const responseBody = await response.getBody();
-      const statusCode = response.getStatusCode();
-      if (statusCode < 200 || 300 <= statusCode) {
-        const responseBodyJson2 = JSON.parse(responseBody);
-        const errorMessage = responseBodyJson2.error;
-        switch (errorMessage.toLowerCase()) {
-          case "permit not found":
-            throw new RecreationDotGovError(`No permit itinerary found for id: ${JSON.stringify(permitItineraryId)}`);
-          default:
-            throw new RecreationDotGovError(`Unrecognized error: ${JSON.stringify(errorMessage)}`);
-        }
-      }
-      const responseBodyJson = JSON.parse(responseBody);
-      return responseBodyJson.payload;
-    });
-  }
-  getDivisionAvailability(permitItineraryId, divisionId, month, year, earlyAccessPermitLotteryId) {
-    PreCondition.assertNotEmpty(permitItineraryId, "permitItineraryId");
-    PreCondition.assertNotEmpty(divisionId, "divisionId");
-    PreCondition.assertBetween(1, month, 12, "month");
-    return PromiseAsyncResult.create(async () => {
-      const url = earlyAccessPermitLotteryId ? `https://www.recreation.gov/api/permititinerary/${permitItineraryId}/division/${divisionId}/eapavailability/month/${earlyAccessPermitLotteryId}?month=${month}&year=${year}` : `https://www.recreation.gov/api/permititinerary/${permitItineraryId}/division/${divisionId}/availability/month?month=${month}&year=${year}`;
-      const response = await this.sendGetRequest(url);
-      let responseBody = await response.getBody();
-      const statusCode = response.getStatusCode();
-      if (statusCode < 200 || 300 <= statusCode) {
-        const responseBodyJson2 = JSON.parse(responseBody);
-        const errorMessage = responseBodyJson2.error;
-        switch (errorMessage.toLowerCase()) {
-          case "invalid permit id":
-            throw new RecreationDotGovError(`No permit itinerary found for id: ${JSON.stringify(permitItineraryId)}`);
-          case "request year is missing or invalid":
-            const emptyResponseBody = {
-              payload: {
-                bools: {},
-                rules: [],
-                quota_type_maps: {}
-              }
-            };
-            responseBody = JSON.stringify(emptyResponseBody);
-            break;
-          default:
-            throw new RecreationDotGovError(`Unrecognized error: ${JSON.stringify(errorMessage)}`);
-        }
-      }
-      const responseBodyJson = JSON.parse(responseBody);
-      return RecreationDotGovDivisionAvailability.create(responseBodyJson.payload);
-    });
-  }
-};
-
-// sources/stringComparer.ts
-var StringComparer = class _StringComparer extends Comparer {
-  constructor() {
-    super();
-  }
-  static create() {
-    return new _StringComparer();
-  }
-  compare(left, right) {
-    return _StringComparer.compare(left, right);
-  }
-  static compare(left, right) {
-    let result = Comparer.compareSameUndefinedNull(left, right);
-    if (result === void 0) {
-      result = left < right ? 0 /* LessThan */ : 2 /* GreaterThan */;
-    }
-    return result;
-  }
-};
-
-// sources/wonderlandTrailClient.ts
-function isWonderlandTrailLocation(value) {
-  return isObject(value) && hasProperty(value, "name") && hasProperty(value, "trailhead") && hasProperty(value, "foodCacheStorage") && hasProperty(value, "divisionId") && hasProperty(value, "groupSiteDivisionId");
-}
-var WonderlandTrailLocations = class {
-  static graniteCreek = {
-    name: "Granite Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170009",
-    groupSiteDivisionId: "46753170010",
-    latitude: 46.92058,
-    longitude: -121.708,
-    elevationFeet: 5851
-  };
-  static sunriseCamp = {
-    name: "Sunrise Camp",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170058",
-    groupSiteDivisionId: "46753170059",
-    latitude: 46.91129,
-    longitude: -121.66002,
-    elevationFeet: 6258
-  };
-  static sunriseVisitorCenter = {
-    name: "Sunrise Visitor Center",
-    trailhead: true,
-    foodCacheStorage: true,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.91448,
-    longitude: -121.64337,
-    elevationFeet: 6410
-  };
-  static whiteRiver = {
-    name: "White River",
-    trailhead: true,
-    foodCacheStorage: true,
-    divisionId: "46753170066",
-    groupSiteDivisionId: "46753170067",
-    latitude: 46.90255,
-    longitude: -121.63869,
-    elevationFeet: 4229
-  };
-  static fryingPanCreek = {
-    name: "Fryingpan Creek",
-    trailhead: true,
-    foodCacheStorage: false,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.88809,
-    longitude: -121.61019,
-    elevationFeet: 3835
-  };
-  static summerland = {
-    name: "Summerland",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170056",
-    groupSiteDivisionId: "46753170057",
-    latitude: 46.86616,
-    longitude: -121.65843,
-    elevationFeet: 5988
-  };
-  static indianBar = {
-    name: "Indian Bar",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170046",
-    groupSiteDivisionId: "46753170047",
-    latitude: 46.82593,
-    longitude: -121.63942,
-    elevationFeet: 5101
-  };
-  static nickelCreek = {
-    name: "Nickel Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170051",
-    groupSiteDivisionId: "46753170052",
-    latitude: 46.77204,
-    longitude: -121.62402,
-    elevationFeet: 3383
-  };
-  static boxCanyon = {
-    name: "Box Canyon",
-    trailhead: true,
-    foodCacheStorage: false,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.7657,
-    longitude: -121.63517,
-    elevationFeet: 3025
-  };
-  static mapleCreek = {
-    name: "Maple Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170027",
-    groupSiteDivisionId: "46753170028",
-    latitude: 46.75745,
-    longitude: -121.65764,
-    elevationFeet: 2806
-  };
-  static reflectionLakes = {
-    name: "Reflection Lakes",
-    trailhead: true,
-    foodCacheStorage: false,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.76824,
-    longitude: -121.7289,
-    elevationFeet: 4862
-  };
-  static paradiseRiver = {
-    name: "Paradise River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170031",
-    groupSiteDivisionId: "46753170032",
-    latitude: 46.77076,
-    longitude: -121.75909,
-    elevationFeet: 3960
-  };
-  static longmire = {
-    name: "Longmire",
-    trailhead: true,
-    foodCacheStorage: true,
-    divisionId: "",
-    groupSiteDivisionId: "",
-    latitude: 46.75011,
-    longitude: -121.81253,
-    elevationFeet: 2750
-  };
-  static pyramidCreek = {
-    name: "Pyramid Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170033",
-    groupSiteDivisionId: "",
-    latitude: 46.77832,
-    longitude: -121.80963,
-    elevationFeet: 3721
-  };
-  static devilsDream = {
-    name: "Devil's Dream",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170040",
-    groupSiteDivisionId: "46753170041",
-    latitude: 46.78196,
-    longitude: -121.83297,
-    elevationFeet: 4929
-  };
-  static southPuyallupRiver = {
-    name: "South Puyallup River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170035",
-    groupSiteDivisionId: "46753170036",
-    latitude: 46.81331,
-    longitude: -121.86445,
-    elevationFeet: 4183
-  };
-  static klapatchePark = {
-    name: "Klapatche Park",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170024",
-    groupSiteDivisionId: "",
-    latitude: 46.83571,
-    longitude: -121.87752,
-    elevationFeet: 5496
-  };
-  static northPuyallupRiver = {
-    name: "North Puyallup River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170029",
-    groupSiteDivisionId: "46753170030",
-    latitude: 46.84751,
-    longitude: -121.87005,
-    elevationFeet: 3733
-  };
-  static goldenLakes = {
-    name: "Golden Lakes",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170022",
-    groupSiteDivisionId: "46753170023",
-    latitude: 46.88327,
-    longitude: -121.89919,
-    elevationFeet: 4927
-  };
-  static southMowichRiver = {
-    name: "South Mowich River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170019",
-    groupSiteDivisionId: "46753170020",
-    latitude: 46.91146,
-    longitude: -121.89314,
-    elevationFeet: 2686
-  };
-  static mowichLake = {
-    name: "Mowich Lake",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170015",
-    groupSiteDivisionId: "46753170016",
-    latitude: 46.93204,
-    longitude: -121.86351,
-    elevationFeet: 4868
-  };
-  static eaglesRoost = {
-    name: "Eagle's Roost",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170006",
-    groupSiteDivisionId: "",
-    latitude: 46.91529,
-    longitude: -121.84816,
-    elevationFeet: 4834
-  };
-  static cataractValley = {
-    name: "Cataract Valley",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170003",
-    groupSiteDivisionId: "46753170004",
-    latitude: 46.94049,
-    longitude: -121.80486,
-    elevationFeet: 4488
-  };
-  static ipsutCreek = {
-    name: "Ipsut Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170011",
-    groupSiteDivisionId: "46753170012",
-    latitude: 46.97615,
-    longitude: -121.83022,
-    elevationFeet: 2359
-  };
-  static carbonRiver = {
-    name: "Carbon River",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170001",
-    groupSiteDivisionId: "46753170002",
-    latitude: 46.95063,
-    longitude: -121.79991,
-    elevationFeet: 3255
-  };
-  static dickCreek = {
-    name: "Dick Creek",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170005",
-    groupSiteDivisionId: "",
-    latitude: 46.94071,
-    longitude: -121.78431,
-    elevationFeet: 4114
-  };
-  static mysticLake = {
-    name: "Mystic Lake",
-    trailhead: false,
-    foodCacheStorage: false,
-    divisionId: "46753170017",
-    groupSiteDivisionId: "46753170018",
-    latitude: 46.9157,
-    longitude: -121.75045,
-    elevationFeet: 5538
-  };
-  static getLocations() {
-    return Iterable.create([
-      this.graniteCreek,
-      this.sunriseCamp,
-      this.sunriseVisitorCenter,
-      this.whiteRiver,
-      this.fryingPanCreek,
-      this.summerland,
-      this.indianBar,
-      this.nickelCreek,
-      this.boxCanyon,
-      this.mapleCreek,
-      this.reflectionLakes,
-      this.paradiseRiver,
-      this.longmire,
-      this.pyramidCreek,
-      this.devilsDream,
-      this.southPuyallupRiver,
-      this.klapatchePark,
-      this.northPuyallupRiver,
-      this.goldenLakes,
-      this.southMowichRiver,
-      this.mowichLake,
-      this.eaglesRoost,
-      this.cataractValley,
-      this.ipsutCreek,
-      this.carbonRiver,
-      this.dickCreek,
-      this.mysticLake
-    ]);
-  }
-  static getTrailheads() {
-    return this.getLocations().where((location) => location.trailhead);
-  }
-};
-var WonderlandTrailReservationType = /* @__PURE__ */ ((WonderlandTrailReservationType2) => {
-  WonderlandTrailReservationType2[WonderlandTrailReservationType2["Reserved"] = 0] = "Reserved";
-  WonderlandTrailReservationType2[WonderlandTrailReservationType2["Walkup"] = 1] = "Walkup";
-  return WonderlandTrailReservationType2;
-})(WonderlandTrailReservationType || {});
-var WonderlandTrailAvailability = class _WonderlandTrailAvailability {
-  availabilityMap;
-  constructor() {
-    this.availabilityMap = Map.create();
-  }
-  static create() {
-    return new _WonderlandTrailAvailability();
-  }
-  any() {
-    return this.availabilityMap.any().await();
-  }
-  addAvailability(location, date, individualSite, groupSite) {
-    PreCondition.assertNotUndefinedAndNotNull(location, "location");
-    PreCondition.assertNotUndefinedAndNotNull(date, "date");
-    const locationAvailability = this.getAvailability(location);
-    const dateString = date.toDateString();
-    const locationDayAvailability = locationAvailability.getOrSet(dateString, () => {
-      return {};
-    }).await();
-    locationAvailability.set(dateString, {
-      individualSite: individualSite ?? locationDayAvailability.individualSite,
-      groupSite: groupSite ?? locationDayAvailability.groupSite
-    });
-  }
-  getAvailability(location) {
-    PreCondition.assertNotUndefinedAndNotNull(location, "location");
-    return this.availabilityMap.getOrSet(location, () => MutableMap.create()).await();
-  }
-  getDayAvailability(location, date) {
-    PreCondition.assertNotUndefinedAndNotNull(location, "location");
-    PreCondition.assertNotUndefinedAndNotNull(date, "date");
-    return this.getAvailability(location).get(date.toDateString()).convertError(NotFoundError, () => new NotFoundError(`No availability was found for ${location.name} on ${date.toDateString()}.`));
-  }
-};
-var WonderlandTrailDirection = class _WonderlandTrailDirection {
-  value;
-  constructor(value) {
-    PreCondition.assertNotEmpty(value, "value");
-    this.value = value;
-  }
-  static clockwise = new _WonderlandTrailDirection("Clockwise");
-  static counterClockwise = new _WonderlandTrailDirection("CounterClockwise");
-  toString() {
-    return this.value;
-  }
-  reverse() {
-    return this === _WonderlandTrailDirection.clockwise ? _WonderlandTrailDirection.counterClockwise : _WonderlandTrailDirection.clockwise;
-  }
-};
-var WonderlandTrailConnection = class _WonderlandTrailConnection {
-  startLocation;
-  endLocation;
-  distanceMiles;
-  ascentFeet;
-  descentFeet;
-  direction;
-  intermediateLocations;
-  constructor(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations) {
-    PreCondition.assertNotUndefinedAndNotNull(startLocation, "startLocation");
-    PreCondition.assertNotUndefinedAndNotNull(endLocation, "endLocation");
-    PreCondition.assertGreaterThanOrEqualTo(distanceMiles, 0, "distanceMiles");
-    PreCondition.assertGreaterThanOrEqualTo(ascentFeet, 0, "ascentFeet");
-    PreCondition.assertGreaterThanOrEqualTo(descentFeet, 0, "descentFeet");
-    PreCondition.assertNotUndefinedAndNotNull(intermediateLocations, "intermediateLocations");
-    this.startLocation = startLocation;
-    this.endLocation = endLocation;
-    this.distanceMiles = distanceMiles;
-    this.ascentFeet = ascentFeet;
-    this.descentFeet = descentFeet;
-    this.direction = direction;
-    this.intermediateLocations = intermediateLocations;
-  }
-  static create(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations) {
-    return new _WonderlandTrailConnection(startLocation, endLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations);
-  }
-  getLocations() {
-    const result = List.create();
-    _WonderlandTrailConnection.ensureExists(result, this.startLocation);
-    _WonderlandTrailConnection.ensureAllExist(result, this.intermediateLocations);
-    _WonderlandTrailConnection.ensureExists(result, this.endLocation);
-    return result;
-  }
-  static ensureExists(list, location) {
-    if (!list.contains(location).await()) {
-      list.add(location);
-    }
-  }
-  static ensureAllExist(list, locations) {
-    for (const location of locations) {
-      _WonderlandTrailConnection.ensureExists(list, location);
-    }
-  }
-  reverseDirection() {
-    return _WonderlandTrailConnection.create(
-      this.endLocation,
-      this.startLocation,
-      this.distanceMiles,
-      this.descentFeet,
-      this.ascentFeet,
-      this.direction.reverse(),
-      this.intermediateLocations
-    );
-  }
-  join(connection) {
-    const intermediateLocations = List.create();
-    _WonderlandTrailConnection.ensureAllExist(intermediateLocations, this.intermediateLocations);
-    _WonderlandTrailConnection.ensureExists(intermediateLocations, this.endLocation);
-    _WonderlandTrailConnection.ensureExists(intermediateLocations, connection.startLocation);
-    _WonderlandTrailConnection.ensureAllExist(intermediateLocations, connection.intermediateLocations);
-    return _WonderlandTrailConnection.create(
-      this.startLocation,
-      connection.endLocation,
-      this.distanceMiles + connection.distanceMiles,
-      this.ascentFeet + connection.ascentFeet,
-      this.descentFeet + connection.descentFeet,
-      this.direction,
-      intermediateLocations
-    );
-  }
-  containsLocation(location) {
-    return this.getLocations().contains(location).await();
-  }
-  isLoop() {
-    return this.startLocation === this.endLocation;
-  }
-};
-var WonderlandTrailConnections = class _WonderlandTrailConnections {
-  connections;
-  addReverseConnectionDefault;
-  constructor(addReverseConnectionDefault) {
-    this.connections = Map.create();
-    this.addReverseConnectionDefault = addReverseConnectionDefault;
-  }
-  static create(addReverseConnectionDefault) {
-    return new _WonderlandTrailConnections(!!addReverseConnectionDefault);
-  }
-  static createDefault() {
-    return _WonderlandTrailConnections.create(true).addConnection({
-      startLocation: WonderlandTrailLocations.whiteRiver,
-      endLocation: WonderlandTrailLocations.fryingPanCreek,
-      distanceMiles: 2.7,
-      ascentFeet: 100,
-      descentFeet: 600
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.fryingPanCreek,
-      endLocation: WonderlandTrailLocations.summerland,
-      distanceMiles: 4.3,
-      ascentFeet: 2200,
-      descentFeet: 100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.summerland,
-      endLocation: WonderlandTrailLocations.indianBar,
-      distanceMiles: 4.7,
-      ascentFeet: 1200,
-      descentFeet: 2100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.indianBar,
-      endLocation: WonderlandTrailLocations.nickelCreek,
-      distanceMiles: 6.8,
-      ascentFeet: 1400,
-      descentFeet: 3200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.nickelCreek,
-      endLocation: WonderlandTrailLocations.boxCanyon,
-      distanceMiles: 0.9,
-      ascentFeet: 100,
-      descentFeet: 400
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.boxCanyon,
-      endLocation: WonderlandTrailLocations.mapleCreek,
-      distanceMiles: 2.7,
-      ascentFeet: 500,
-      descentFeet: 700
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.mapleCreek,
-      endLocation: WonderlandTrailLocations.reflectionLakes,
-      distanceMiles: 4.7,
-      ascentFeet: 2300,
-      descentFeet: 200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.reflectionLakes,
-      endLocation: WonderlandTrailLocations.paradiseRiver,
-      distanceMiles: 2.6,
-      ascentFeet: 200,
-      descentFeet: 1200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.paradiseRiver,
-      endLocation: WonderlandTrailLocations.longmire,
-      distanceMiles: 3.6,
-      ascentFeet: 100,
-      descentFeet: 1200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.longmire,
-      endLocation: WonderlandTrailLocations.pyramidCreek,
-      distanceMiles: 3.3,
-      ascentFeet: 1400,
-      descentFeet: 400
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.pyramidCreek,
-      endLocation: WonderlandTrailLocations.devilsDream,
-      distanceMiles: 2.5,
-      ascentFeet: 1400,
-      descentFeet: 100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.devilsDream,
-      endLocation: WonderlandTrailLocations.southPuyallupRiver,
-      distanceMiles: 6.5,
-      ascentFeet: 1900,
-      descentFeet: 2700
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.southPuyallupRiver,
-      endLocation: WonderlandTrailLocations.klapatchePark,
-      distanceMiles: 4.1,
-      ascentFeet: 2100,
-      descentFeet: 800
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.klapatchePark,
-      endLocation: WonderlandTrailLocations.northPuyallupRiver,
-      distanceMiles: 2.6,
-      ascentFeet: 100,
-      descentFeet: 1900
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.northPuyallupRiver,
-      endLocation: WonderlandTrailLocations.goldenLakes,
-      distanceMiles: 5.1,
-      ascentFeet: 1900,
-      descentFeet: 600
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.goldenLakes,
-      endLocation: WonderlandTrailLocations.southMowichRiver,
-      distanceMiles: 5.8,
-      ascentFeet: 200,
-      descentFeet: 2400
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.southMowichRiver,
-      endLocation: WonderlandTrailLocations.mowichLake,
-      distanceMiles: 4.4,
-      ascentFeet: 2400,
-      descentFeet: 300
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.mowichLake,
-      endLocation: WonderlandTrailLocations.ipsutCreek,
-      distanceMiles: 5.6,
-      ascentFeet: 400,
-      descentFeet: 3e3
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.ipsutCreek,
-      endLocation: WonderlandTrailLocations.carbonRiver,
-      distanceMiles: 4,
-      ascentFeet: 1300,
-      descentFeet: 400
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.mowichLake,
-      endLocation: WonderlandTrailLocations.eaglesRoost,
-      distanceMiles: 2,
-      ascentFeet: 500,
-      descentFeet: 600
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.eaglesRoost,
-      endLocation: WonderlandTrailLocations.cataractValley,
-      distanceMiles: 12.4,
-      ascentFeet: 3300,
-      descentFeet: 3700
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.cataractValley,
-      endLocation: WonderlandTrailLocations.carbonRiver,
-      distanceMiles: 1.6,
-      ascentFeet: 100,
-      descentFeet: 1300
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.carbonRiver,
-      endLocation: WonderlandTrailLocations.dickCreek,
-      distanceMiles: 1.3,
-      ascentFeet: 1e3,
-      descentFeet: 100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.dickCreek,
-      endLocation: WonderlandTrailLocations.mysticLake,
-      distanceMiles: 3.7,
-      ascentFeet: 2100,
-      descentFeet: 600
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.mysticLake,
-      endLocation: WonderlandTrailLocations.graniteCreek,
-      distanceMiles: 4.1,
-      ascentFeet: 1500,
-      descentFeet: 1200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.graniteCreek,
-      endLocation: WonderlandTrailLocations.sunriseCamp,
-      distanceMiles: 4.6,
-      ascentFeet: 1400,
-      descentFeet: 1e3
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.sunriseCamp,
-      endLocation: WonderlandTrailLocations.whiteRiver,
-      distanceMiles: 3.5,
-      ascentFeet: 100,
-      descentFeet: 2100
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.sunriseCamp,
-      endLocation: WonderlandTrailLocations.sunriseVisitorCenter,
-      distanceMiles: 1.4,
-      ascentFeet: 400,
-      descentFeet: 200
-    }).addConnection({
-      startLocation: WonderlandTrailLocations.sunriseVisitorCenter,
-      endLocation: WonderlandTrailLocations.whiteRiver,
-      distanceMiles: 3.1,
-      ascentFeet: 0,
-      descentFeet: 2200
-    });
-  }
-  iterateConnections(startLocationOrProperties, endLocation, direction) {
-    let startLocation;
-    if (isWonderlandTrailLocation(startLocationOrProperties)) {
-      startLocation = startLocationOrProperties;
-    } else if (startLocationOrProperties) {
-      startLocation = startLocationOrProperties.startLocation;
-      endLocation = startLocationOrProperties.endLocation;
-      direction = startLocationOrProperties.direction;
-    }
-    let result;
-    if (!startLocation) {
-      result = this.connections.iterateValues().flatMap((x) => x);
-    } else {
-      result = this.connections.get(startLocation).catch(NotFoundError, () => Iterable.create()).await().iterate();
-    }
-    if (endLocation) {
-      result = result.where((connection) => connection.endLocation == endLocation);
-    }
-    if (direction != null) {
-      result = result.where((connection) => connection.direction == direction);
-    }
-    return result;
-  }
-  addConnectionInner(connection) {
-    const startLocationConnections = this.connections.getOrSet(connection.startLocation, () => List.create()).await();
-    startLocationConnections.add(connection);
-  }
-  addConnection(connectionStartLocationOrProperties, addReverseConnectionOrEndLocation, distanceMiles, ascentFeet, descentFeet, direction, intermediateLocations, addReverseConnection) {
-    let startLocation;
-    let endLocation;
-    if (isWonderlandTrailLocation(connectionStartLocationOrProperties)) {
-      startLocation = connectionStartLocationOrProperties;
-    } else if (connectionStartLocationOrProperties instanceof WonderlandTrailConnection) {
-      startLocation = connectionStartLocationOrProperties.startLocation;
-      endLocation = connectionStartLocationOrProperties.endLocation;
-      distanceMiles = connectionStartLocationOrProperties.distanceMiles;
-      ascentFeet = connectionStartLocationOrProperties.ascentFeet;
-      descentFeet = connectionStartLocationOrProperties.descentFeet;
-      direction = connectionStartLocationOrProperties.direction;
-      intermediateLocations = connectionStartLocationOrProperties.intermediateLocations;
-      addReverseConnection = !!addReverseConnectionOrEndLocation;
-    } else {
-      startLocation = connectionStartLocationOrProperties.startLocation;
-      endLocation = connectionStartLocationOrProperties.endLocation;
-      distanceMiles = connectionStartLocationOrProperties.distanceMiles;
-      ascentFeet = connectionStartLocationOrProperties.ascentFeet;
-      descentFeet = connectionStartLocationOrProperties.descentFeet;
-      direction = connectionStartLocationOrProperties.direction;
-      intermediateLocations = connectionStartLocationOrProperties.intermediateLocations;
-      addReverseConnection = connectionStartLocationOrProperties.addReverseConnection;
-    }
-    const connection = WonderlandTrailConnection.create(
-      startLocation,
-      endLocation,
-      distanceMiles,
-      ascentFeet,
-      descentFeet,
-      direction ?? WonderlandTrailDirection.clockwise,
-      intermediateLocations ?? Iterable.create()
-    );
-    this.addConnectionInner(connection);
-    if (addReverseConnection ?? this.addReverseConnectionDefault) {
-      this.addConnectionInner(connection.reverseDirection());
-    }
-    return this;
-  }
-  containsConnection(connection) {
-    PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
-    const startLocationConnections = this.connections.get(connection.startLocation).catch(() => void 0).await();
-    return startLocationConnections?.contains(connection)?.await() === true;
-  }
-  reverseDirection() {
-    const result = _WonderlandTrailConnections.create(this.addReverseConnectionDefault);
-    for (const connection of this.iterateConnections()) {
-      result.addConnection(connection.reverseDirection());
-    }
-    return result;
-  }
-  expandConnections(startLocation, endLocation, direction) {
-    if (isUndefinedOrNull(direction)) {
-      direction = WonderlandTrailDirection.clockwise;
-    }
-    const result = _WonderlandTrailConnections.create(this.addReverseConnectionDefault);
-    const toVisit = Stack.create();
-    toVisit.addAll(this.iterateConnections(startLocation, void 0, direction));
-    while (toVisit.any().await()) {
-      const currentConnection = toVisit.remove().await();
-      result.addConnection(currentConnection, false);
-      if (!currentConnection.isLoop() && currentConnection.endLocation !== endLocation) {
-        for (const endLocationConnection of this.iterateConnections(currentConnection.endLocation, void 0, direction)) {
-          if (!result.containsConnection(endLocationConnection) && !toVisit.contains(endLocationConnection)) {
-            toVisit.add(endLocationConnection);
-          }
-          if (!currentConnection.intermediateLocations.contains(endLocationConnection.endLocation)) {
-            toVisit.add(currentConnection.join(endLocationConnection));
-          }
-        }
-      }
-    }
-    return result;
-  }
-};
-var WonderlandTrailItinerary = class _WonderlandTrailItinerary {
-  startDay;
-  connections;
-  availabilityTypes;
-  constructor(startDay) {
-    PreCondition.assertNotUndefinedAndNotNull(startDay, "startDay");
-    this.startDay = startDay;
-    this.connections = List.create();
-    this.availabilityTypes = List.create();
-  }
-  static create(startDay) {
-    return new _WonderlandTrailItinerary(startDay);
-  }
-  clone() {
-    return _WonderlandTrailItinerary.create(this.startDay).addConnections(this.connections).addAvailabilityTypes(this.availabilityTypes);
-  }
-  getConnections() {
-    return this.connections;
-  }
-  getEndDay() {
-    return this.startDay.addDays(this.getDayCount() - 1);
-  }
-  getDayCount() {
-    return this.connections.getCount().await();
-  }
-  getStartLocation() {
-    return this.connections.first().then((firstConnection) => firstConnection.startLocation);
-  }
-  getIntermediateLocations() {
-    const result = List.create();
-    for (const connection of this.connections) {
-      if (result.any().await()) {
-        result.add(connection.startLocation);
-      }
-      result.addAll(connection.intermediateLocations);
-    }
-    return result;
-  }
-  getEndLocation() {
-    return this.connections.last().then((lastConnection) => lastConnection.endLocation);
-  }
-  getPath() {
-    const result = List.create();
-    for (const connection of this.connections) {
-      if (!result.any().await()) {
-        result.add(connection.startLocation);
-      }
-      result.add(connection.endLocation);
-    }
-    return result;
-  }
-  getPathStrings(includeAvailabilityTypes) {
-    includeAvailabilityTypes = includeAvailabilityTypes ?? true;
-    const result = List.create();
-    let availabilityTypeIndex = 0;
-    const availabilityTypeCount = this.availabilityTypes.getCount().await();
-    for (const connection of this.connections) {
-      if (!result.any().await()) {
-        result.add(connection.startLocation.name);
-      }
-      let pathString = connection.endLocation.name;
-      if (includeAvailabilityTypes && availabilityTypeIndex < availabilityTypeCount) {
-        pathString += " ";
-        const availabilityType = this.availabilityTypes.get(availabilityTypeIndex).await();
-        availabilityTypeIndex++;
-        if (availabilityType.individualSite !== void 0) {
-          if (availabilityType.groupSite !== void 0) {
-            pathString += `(Individual ${availabilityType.individualSite}/Group ${availabilityType.groupSite})`;
-          } else {
-            pathString += `(Individual ${availabilityType.individualSite})`;
-          }
-        } else {
-          pathString += `(Group ${availabilityType.groupSite})`;
-        }
-      }
-      result.add(pathString);
-    }
-    return result;
-  }
-  contains(parameters) {
-    PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
-    const location = parameters.location;
-    const checkItineraryStartLocation = parameters.checkItineraryStartLocation ?? true;
-    const checkItineraryIntermediateLocations = parameters.checkItineraryIntermediateLocations ?? true;
-    const checkItineraryEndLocation = parameters.checkItineraryEndLocation ?? true;
-    PreCondition.assertNotUndefinedAndNotNull(location, "location");
-    let result = false;
-    const connectionCount = this.connections.getCount().await();
-    for (let i = 0; i < connectionCount; i++) {
-      if (i !== 0 || checkItineraryStartLocation) {
-        result = this.connections.get(i).await().startLocation === location;
-        if (result) {
-          break;
-        }
-      }
-      if (checkItineraryIntermediateLocations) {
-        result = this.connections.get(i).await().intermediateLocations.contains(location).await();
-        if (result) {
-          break;
-        }
-      }
-      if (i === connectionCount - 1 && checkItineraryEndLocation) {
-        result = this.connections.get(i).await().endLocation === location;
-        if (result) {
-          break;
-        }
-      }
-    }
-    return result;
-  }
-  containsAny(parameters) {
-    PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
-    const connection = parameters.connection;
-    const checkConnectionStartLocation = parameters.checkConnectionStartLocation ?? true;
-    const checkConnectionIntermediateLocations = parameters.checkConnectionIntermediateLocations ?? true;
-    const checkConnectionEndLocation = parameters.checkConnectionEndLocation ?? true;
-    const checkItineraryStartLocation = parameters.checkItineraryStartLocation ?? true;
-    const checkItineraryIntermediateLocations = parameters.checkItineraryIntermediateLocations ?? true;
-    const checkItineraryEndLocation = parameters.checkItineraryEndLocation ?? true;
-    PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
-    let result = false;
-    if (!result && checkConnectionStartLocation) {
-      result = this.contains({
-        location: connection.startLocation,
-        checkItineraryStartLocation,
-        checkItineraryIntermediateLocations,
-        checkItineraryEndLocation
-      });
-    }
-    if (!result && checkConnectionIntermediateLocations) {
-      for (const connectionIntermediateLocation of connection.intermediateLocations) {
-        result = this.contains({
-          location: connectionIntermediateLocation,
-          checkItineraryStartLocation,
-          checkItineraryIntermediateLocations,
-          checkItineraryEndLocation
-        });
-        if (result) {
-          break;
-        }
-      }
-    }
-    if (!result && checkConnectionEndLocation) {
-      result = this.contains({
-        location: connection.endLocation,
-        checkItineraryStartLocation,
-        checkItineraryIntermediateLocations,
-        checkItineraryEndLocation
-      });
-    }
-    return result;
-  }
-  addConnection(connection) {
-    PreCondition.assertNotUndefinedAndNotNull(connection, "connection");
-    this.connections.add(connection);
-    return this;
-  }
-  addConnections(connections) {
-    PreCondition.assertNotUndefinedAndNotNull(connections, "connections");
-    this.connections.addAll(connections);
-    return this;
-  }
-  addAvailabilityType(availabilityType) {
-    PreCondition.assertNotUndefinedAndNotNull(availabilityType, "availabilityType");
-    this.availabilityTypes.add(availabilityType);
-    return this;
-  }
-  addAvailabilityTypes(availabilityTypes) {
-    PreCondition.assertNotUndefinedAndNotNull(availabilityTypes, "availabilityTypes");
-    this.availabilityTypes.addAll(availabilityTypes);
-    return this;
-  }
-  toString(includeAvailabilityTypes) {
-    includeAvailabilityTypes = includeAvailabilityTypes ?? true;
-    return `startDay:${this.startDay.toDateString()},path:${this.getPathStrings(includeAvailabilityTypes)}`;
-  }
-};
-var WonderlandTrailClient = class _WonderlandTrailClient {
-  static permitItineraryId = "4675317";
-  httpClient;
-  recreationDotGovClient;
-  constructor(httpClient) {
-    PreCondition.assertNotUndefinedAndNotNull(httpClient, "httpClient");
-    this.httpClient = httpClient;
-    this.recreationDotGovClient = RecreationDotGovClient.create(httpClient);
-  }
-  static create(httpClient) {
-    return new _WonderlandTrailClient(httpClient);
-  }
-  sendRequest(request) {
-    return this.httpClient.sendRequest(request);
-  }
-  sendGetRequest(url) {
-    return HttpClient.sendGetRequest(this, url);
-  }
-  getAvailability(monthOrOptions, year, allowWalkupPermits, allowIndividualSites, allowGroupSites, earlyAccessPermitLotteryId) {
-    let month;
-    if (isNumber(monthOrOptions)) {
-      month = monthOrOptions;
-      year = year;
-      allowWalkupPermits = allowWalkupPermits;
-      allowIndividualSites = allowIndividualSites;
-      allowGroupSites = allowGroupSites;
-    } else {
-      month = monthOrOptions.month;
-      year = monthOrOptions.year;
-      allowWalkupPermits = monthOrOptions.allowWalkupPermits;
-      allowIndividualSites = monthOrOptions.allowIndividualSites;
-      allowGroupSites = monthOrOptions.allowGroupSites;
-      earlyAccessPermitLotteryId = monthOrOptions.earlyAccessPermitLotteryId;
-    }
-    return PromiseAsyncResult.create(async () => {
-      const result = WonderlandTrailAvailability.create();
-      for (const location of WonderlandTrailLocations.getLocations()) {
-        if (allowIndividualSites && location.divisionId) {
-          const divisionAvailability = await this.recreationDotGovClient.getDivisionAvailability(
-            _WonderlandTrailClient.permitItineraryId,
-            location.divisionId,
-            month,
-            year,
-            earlyAccessPermitLotteryId
-          );
-          const divisionDayAvailabilities = divisionAvailability.dayAvailabilities;
-          if (divisionDayAvailabilities) {
-            for (const divisionDayAvailability of divisionDayAvailabilities) {
-              const hasWalkupPermits = allowWalkupPermits && divisionDayAvailability.walkup;
-              const hasReservationPermits = divisionDayAvailability.reservationsRemaining > 0;
-              if (hasWalkupPermits || hasReservationPermits) {
-                result.addAvailability(
-                  location,
-                  divisionDayAvailability.date,
-                  hasWalkupPermits ? 1 /* Walkup */ : 0 /* Reserved */,
-                  void 0
-                );
-              }
-            }
-          }
-        }
-        if (allowGroupSites && location.groupSiteDivisionId) {
-          const groupSiteDivisionAvailability = await this.recreationDotGovClient.getDivisionAvailability(
-            _WonderlandTrailClient.permitItineraryId,
-            location.groupSiteDivisionId,
-            month,
-            year,
-            earlyAccessPermitLotteryId
-          );
-          const groupSiteDivisionDayAvailabilities = groupSiteDivisionAvailability.dayAvailabilities;
-          if (groupSiteDivisionDayAvailabilities) {
-            for (const groupSiteDayAvailability of groupSiteDivisionDayAvailabilities) {
-              const hasWalkupPermits = allowWalkupPermits && groupSiteDayAvailability.walkup;
-              const hasReservationPermits = groupSiteDayAvailability.reservationsRemaining > 0;
-              if (hasWalkupPermits || hasReservationPermits) {
-                result.addAvailability(
-                  location,
-                  groupSiteDayAvailability.date,
-                  void 0,
-                  hasWalkupPermits ? 1 /* Walkup */ : 0 /* Reserved */
-                );
-              }
-            }
-          }
-        }
-      }
-      return result;
-    });
-  }
-  findItineraries(parameters) {
-    PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
-    const availability = parameters.availability;
-    const startDate = parameters.startDate;
-    const startLocation = parameters.startLocation;
-    const endLocation = parameters.endLocation;
-    const direction = parameters.direction;
-    const maximumDayDistanceMiles = parameters.maximumDayDistanceMiles;
-    const maximumItineraryDays = parameters.maximumItineraryDays;
-    const campsitesToAvoid = Iterable.create(parameters.campsitesToAvoid ?? []);
-    const result = List.create();
-    const connections = WonderlandTrailConnections.createDefault().expandConnections(startLocation, endLocation, direction);
-    let startLocationConnections = connections.iterateConnections(startLocation, void 0, direction);
-    if (!isUndefinedOrNull(maximumDayDistanceMiles)) {
-      startLocationConnections = startLocationConnections.where((connection) => connection.distanceMiles <= maximumDayDistanceMiles);
-    }
-    const possibleItineraries = Stack.create();
-    possibleItineraries.addAll(startLocationConnections.map((c) => WonderlandTrailItinerary.create(startDate).addConnection(c)));
-    while (possibleItineraries.any().await()) {
-      const currentItinerary = possibleItineraries.remove().await();
-      const currentItineraryEndLocation = currentItinerary.getEndLocation().await();
-      if ((maximumItineraryDays === void 0 || currentItinerary.getDayCount() <= maximumItineraryDays) && (startLocation === currentItineraryEndLocation || endLocation === currentItineraryEndLocation || !campsitesToAvoid.contains(currentItineraryEndLocation).await())) {
-        if (currentItineraryEndLocation === endLocation) {
-          result.add(currentItinerary);
-        } else {
-          const dayAvailability = availability.getDayAvailability(currentItineraryEndLocation, currentItinerary.getEndDay()).catch(() => void 0).await();
-          if (dayAvailability) {
-            currentItinerary.addAvailabilityType(dayAvailability);
-            for (const nextDayConnection of connections.iterateConnections(currentItineraryEndLocation, void 0, direction)) {
-              if (!currentItinerary.containsAny({
-                connection: nextDayConnection,
-                checkConnectionStartLocation: false,
-                checkItineraryStartLocation: false,
-                checkItineraryEndLocation: false
-              })) {
-                if (maximumDayDistanceMiles === void 0 || nextDayConnection.distanceMiles <= maximumDayDistanceMiles) {
-                  possibleItineraries.add(currentItinerary.clone().addConnection(nextDayConnection));
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    return result;
-  }
-  findItinerariesAsync(parameters) {
-    PreCondition.assertNotUndefinedAndNotNull(parameters, "parameters");
-    const startDay = parameters.startDay;
-    const startLocation = parameters.startLocation;
-    const endLocation = parameters.endLocation;
-    const direction = parameters.direction;
-    const maximumDayDistanceMiles = parameters.maximumDayDistanceMiles;
-    const maximumItineraryDays = parameters.maximumItineraryDays;
-    const allowWalkupPermits = parameters.allowWalkupPermits ?? true;
-    const allowIndividualSites = parameters.allowIndividualSites ?? true;
-    const allowGroupSites = parameters.allowGroupSites ?? false;
-    const campsitesToAvoid = parameters.campsitesToAvoid ?? [];
-    PreCondition.assertNotUndefinedAndNotNull(startDay, "startDay");
-    return PromiseAsyncResult.create(async () => {
-      const result = List.create();
-      const startLocationsToCheck = !isUndefinedOrNull(startLocation) ? Iterable.create([startLocation]) : WonderlandTrailLocations.getTrailheads();
-      const directionsToCheck = !isUndefinedOrNull(direction) ? Iterable.create([direction]) : Iterable.create([WonderlandTrailDirection.clockwise, WonderlandTrailDirection.counterClockwise]);
-      const availability = await this.getAvailability(
-        startDay.getMonth(),
-        startDay.getYear(),
-        allowWalkupPermits,
-        allowIndividualSites,
-        allowGroupSites
-      );
-      for (const startLocationToCheck of startLocationsToCheck) {
-        for (const directionToCheck of directionsToCheck) {
-          result.addAll(this.findItineraries({
-            availability,
-            startDate: startDay,
-            startLocation: startLocationToCheck,
-            endLocation: endLocation ?? startLocationToCheck,
-            direction: directionToCheck,
-            maximumDayDistanceMiles,
-            maximumItineraryDays,
-            campsitesToAvoid
-          }));
-        }
-      }
-      return result;
-    });
-  }
-};
-
-export {
-  SyncDisposable,
-  ByteList,
-  ByteListStream,
-  StringIterator,
-  CharacterList,
-  CharacterReadStream,
-  CharacterListStream,
-  LuxonDateTime,
-  DateTime,
-  ListStack,
-  Stack,
-  depthFirstSearch,
-  Disposable,
-  Generator,
-  HttpClient,
-  InMemoryCharacterWriteStream,
-  ListQueue,
-  Node,
-  Queue,
-  RecreationDotGovDivisionAvailability,
-  RecreationDotGovError,
-  RecreationDotGovClient,
-  StringComparer,
-  isWonderlandTrailLocation,
-  WonderlandTrailLocations,
-  WonderlandTrailReservationType,
-  WonderlandTrailAvailability,
-  WonderlandTrailDirection,
-  WonderlandTrailConnection,
-  WonderlandTrailConnections,
-  WonderlandTrailItinerary,
-  WonderlandTrailClient
-};
-//# sourceMappingURL=chunk-6V7JRJ7P.js.map