@dereekb/util 10.1.30 → 10.2.0

package/index.cjs.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var extraSet = require('extra-set');
 var makeError = require('make-error');
-var lodash = require('lodash');
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -8261,6 +8260,12 @@ function firstAndLastCharacterOccurrence(input, find) {
     occurences
   };
 }
+/**
+ * Returns true if the input string contains the character (or string) to find.
+ */
+function stringContains(input, find) {
+  return input.indexOf(find) !== -1;
+}
 /**
  * Replaces the last character with the replacement string if it is any of the input values.
  *
@@ -8378,6 +8383,54 @@ function findStringsRegexString(find) {
   const escapedInput = input.map(escapeStringForRegex);
   return escapedInput.join('|');
 }
+/**
+ * Creates an EscapeStringCharactersFunction
+ *
+ * @param config
+ * @returns
+ */
+function escapeStringCharactersFunction(config) {
+  const {
+    escapeTargets: inputEscapeTargets,
+    escapeCharacter
+  } = config;
+  const escapeTargets = inputEscapeTargets instanceof Set ? inputEscapeTargets : new Set(inputEscapeTargets);
+  return input => {
+    /**
+     * Find index of all occurences in the input to replace/merge together.
+     */
+    const occurrences = findAllCharacterOccurences(escapeTargets, input);
+    let result;
+    switch (occurrences.length) {
+      case 0:
+        result = input;
+        break;
+      case 1:
+        const charToReplace = input[occurrences[0]];
+        result = replaceCharacterAtIndexWith(input, occurrences[0], escapeCharacter(charToReplace)); //Add an escape to the character
+        break;
+      default:
+        const parts = [];
+        const endAt = occurrences.length;
+        let start = 0;
+        let occurrence = 0;
+        for (let i = 0; i < endAt; i += 1) {
+          occurrence = occurrences[i];
+          const char = input[occurrence];
+          const sub = input.substring(start, occurrence);
+          const part = sub + escapeCharacter(char);
+          parts.push(part);
+          start = occurrence + 1;
+        }
+        // add in the last substring
+        parts.push(input.substring(start));
+        // join all parts together
+        result = parts.join('');
+        break;
+    }
+    return result;
+  };
+}
 /**
  * Escapes the input string to be usable in a Regex value.
  *
@@ -8385,44 +8438,12 @@ function findStringsRegexString(find) {
  *
  * @param input
  */
-function escapeStringForRegex(input) {
-  /**
-   * index of all occurences in the input to replace/merge together.
-   */
-  const occurrences = findAllCharacterOccurences(REGEX_SPECIAL_CHARACTERS_SET, input);
-  let result;
-  function escapeCharacter(char) {
+const escapeStringForRegex = escapeStringCharactersFunction({
+  escapeTargets: REGEX_SPECIAL_CHARACTERS_SET,
+  escapeCharacter(char) {
     return `\\${char}`;
   }
-  switch (occurrences.length) {
-    case 0:
-      result = input;
-      break;
-    case 1:
-      const charToReplace = input[occurrences[0]];
-      result = replaceCharacterAtIndexWith(input, occurrences[0], escapeCharacter(charToReplace)); //Add an escape to the character
-      break;
-    default:
-      const parts = [];
-      const endAt = occurrences.length;
-      let start = 0;
-      let occurrence = 0;
-      for (let i = 0; i < endAt; i += 1) {
-        occurrence = occurrences[i];
-        const char = input[occurrence];
-        const sub = input.substring(start, occurrence);
-        const part = sub + escapeCharacter(char);
-        parts.push(part);
-        start = occurrence + 1;
-      }
-      // add in the last substring
-      parts.push(input.substring(start));
-      // join all parts together
-      result = parts.join('');
-      break;
-  }
-  return result;
-}
+});
 function findAllCharacterOccurencesFunction(characterSet) {
   return (input, maxToReturn) => {
     const max = maxToReturn !== null && maxToReturn !== void 0 ? maxToReturn : Number.MAX_SAFE_INTEGER;
@@ -9655,6 +9676,16 @@ function makeDateMonthForMonthOfYear(monthOfYear) {
 function isDate(value) {
   return value instanceof Date || typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]';
 }
+/**
+ * Returns true if the two input dates are equal.
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+function isEqualDate(a, b) {
+  return a.getTime() === b.getTime();
+}
 
 const FRACTIONAL_HOURS_PRECISION_FUNCTION = cutValueToPrecisionFunction(3);
 /**
@@ -11465,258 +11496,160 @@ function objectIsEmpty(obj) {
 }
 
 /**
- * Performs a deep comparison to check if all values on the input filters are equal.
+ * Returns the day of the week for the input day.
+ *
+ * Equivalent to date.getDay()
+ *
+ * @param date
+ * @returns
  */
-function areEqualPOJOValues(a, b) {
-  return lodash.isEqual(a, b);
-}
-function objectFieldEqualityChecker(config) {
-  const {
-    fields,
-    defaultEqualityFunction = (a, b) => a === b
-  } = config;
-  const _fields = new Map();
-  fields.forEach(input => {
-    let field;
-    if (typeof input === 'object') {
-      field = input;
-    } else {
-      field = {
-        fieldName: input,
-        isEqual: defaultEqualityFunction
-      };
-    }
-    _fields.set(field.fieldName, field);
-  });
-  const fn = (a, b) => {
-    const equalFields = [];
-    const unequalFields = [];
-    _fields.forEach((fieldConfig, fieldName) => {
-      const {
-        isEqual
-      } = fieldConfig;
-      isEqual(a[fieldName], b[fieldName]) ? equalFields.push(fieldName) : unequalFields.push(fieldName);
-    });
-    return {
-      a,
-      b,
-      isEqual: unequalFields.length === 0,
-      equalFields,
-      unequalFields
-    };
-  };
-  fn._fields = _fields;
-  return fn;
+function dayOfWeek(date) {
+  return date.getDay();
 }
-
 /**
- * Creates a EqualityComparatorFunction that compares the two input values
+ * Creates a DecisionFunction that checks whether or not the input day or days of
  *
- * @param readKey
+ * @param allowedDaysOfWeek
  * @returns
  */
-function objectKeysEqualityComparatorFunction(readKey) {
-  const readKeysSet = readKeysSetFunction(readKey);
-  const readKeysArray = readKeysFunction(readKey);
-  return safeEqualityComparatorFunction((a, b) => {
-    if (a.length === b.length) {
-      if (a.length === 0) {
-        return true; // both the same/empty arrays
-      }
-
-      const aKeys = readKeysSet(a);
-      const bKeys = readKeysArray(b);
-      if (aKeys.size === bKeys.length) {
-        return setContainsAllValues(aKeys, bKeys);
-      }
-    }
-    return false;
+function isInAllowedDaysOfWeekSet(allowedDaysOfWeek) {
+  return isInSetDecisionFunction(allowedDaysOfWeek, x => {
+    return typeof x === 'number' ? x : dayOfWeek(x);
   });
 }
 /**
- * Creates a EqualityComparatorFunction that compares the two input values
+ * Returns all days of the week starting from the given day up to the specified number of days.
  *
- * @param readKey
- * @returns
+ * Returns 7 days by default.
+ *
+ * @param startingOn
  */
-function objectKeyEqualityComparatorFunction(readKey) {
-  return safeEqualityComparatorFunction((a, b) => readKey(a) === readKey(b));
-}
-
-function makeCopyModelFieldFunction(key, inputConfig) {
-  const config = inputConfig !== null && inputConfig !== void 0 ? inputConfig : {};
-  const hasDefault = objectHasKey(config, 'default');
-  const defaultValue = config.default;
-  return (from, target) => {
-    var _a;
-    if (objectHasKey(from, key)) {
-      target[key] = (_a = from[key]) !== null && _a !== void 0 ? _a : defaultValue;
-    } else if (hasDefault) {
-      target[key] = defaultValue;
+function daysOfWeekArray(startingOn = exports.Day.SUNDAY, maxDays = 7) {
+  const days = [];
+  let day = startingOn;
+  while (days.length < maxDays) {
+    days.push(day);
+    if (day === exports.Day.SATURDAY) {
+      day = exports.Day.SUNDAY;
+    } else {
+      day += 1;
     }
-  };
+  }
+  return days;
 }
-
-function makeModelMapFunctions(fields) {
-  const keys = filterKeyValueTuples(fields);
-  const conversionsByKey = keys.map(([key, field]) => [key, field]);
-  const fromConversions = conversionsByKey.map(([key, configs]) => [key, configs.from]);
-  const toConversions = conversionsByKey.map(([key, configs]) => [key, configs.to]);
-  const from = makeModelConversionFieldValuesFunction(fromConversions);
-  const to = makeModelConversionFieldValuesFunction(toConversions);
+/**
+ * Enum for the days of the week.
+ */
+exports.Day = void 0;
+(function (Day) {
+  Day[Day["SUNDAY"] = 0] = "SUNDAY";
+  Day[Day["MONDAY"] = 1] = "MONDAY";
+  Day[Day["TUESDAY"] = 2] = "TUESDAY";
+  Day[Day["WEDNESDAY"] = 3] = "WEDNESDAY";
+  Day[Day["THURSDAY"] = 4] = "THURSDAY";
+  Day[Day["FRIDAY"] = 5] = "FRIDAY";
+  Day[Day["SATURDAY"] = 6] = "SATURDAY";
+})(exports.Day || (exports.Day = {}));
+function enabledDaysFromDaysOfWeek(input) {
+  const set = new Set(input);
   return {
-    from,
-    to
+    sunday: set.has(exports.Day.SUNDAY),
+    monday: set.has(exports.Day.MONDAY),
+    tuesday: set.has(exports.Day.TUESDAY),
+    wednesday: set.has(exports.Day.WEDNESDAY),
+    thursday: set.has(exports.Day.THURSDAY),
+    friday: set.has(exports.Day.FRIDAY),
+    saturday: set.has(exports.Day.SATURDAY)
   };
 }
-function makeModelConversionFieldValuesFunction(fields) {
-  return (input, inputTarget, options) => {
-    const target = inputTarget !== null && inputTarget !== void 0 ? inputTarget : {};
-    if (input != null) {
-      let targetFields = fields;
-      // if options are provided, filter down.
-      if (options) {
-        const fieldsToMap = new Set(findPOJOKeys(input, {
-          keysFilter: options.fields,
-          valueFilter: options.definedOnly === false ? exports.KeyValueTypleValueFilter.NONE : exports.KeyValueTypleValueFilter.UNDEFINED
-        }));
-        targetFields = fields.filter(x => fieldsToMap.has(x[0]));
-      }
-      targetFields.forEach(([key, convert]) => target[key] = convert(input[key]));
+function daysOfWeekFromEnabledDays(input) {
+  const daysOfWeek = [];
+  if (input) {
+    if (input.sunday) {
+      daysOfWeek.push(exports.Day.SUNDAY);
     }
-    return target;
-  };
-}
-function modelFieldConversions(config) {
-  return mapObjectMap(config, x => modelFieldMapFunctions(x));
-}
-function modelFieldMapFunctions(config) {
-  return {
-    from: modelFieldMapFunction(config.from),
-    to: modelFieldMapFunction(config.to)
-  };
+    if (input.monday) {
+      daysOfWeek.push(exports.Day.MONDAY);
+    }
+    if (input.tuesday) {
+      daysOfWeek.push(exports.Day.TUESDAY);
+    }
+    if (input.wednesday) {
+      daysOfWeek.push(exports.Day.WEDNESDAY);
+    }
+    if (input.thursday) {
+      daysOfWeek.push(exports.Day.THURSDAY);
+    }
+    if (input.friday) {
+      daysOfWeek.push(exports.Day.FRIDAY);
+    }
+    if (input.saturday) {
+      daysOfWeek.push(exports.Day.SATURDAY);
+    }
+  }
+  return daysOfWeek;
 }
 /**
- * Creates a ModelFieldMapFunction.
+ * Returns an array of strinsg with each day of the week named.
  *
- * @param config
  * @returns
  */
-function modelFieldMapFunction(config) {
-  const convert = config.convert;
-  const convertMaybe = config.convertMaybe;
-  const defaultOutput = config.default;
-  const defaultInput = config.defaultInput;
-  const hasDefaultInput = defaultInput != null;
-  const getDefaultOutput = asGetter(defaultOutput);
-  const getDefaultInput = asGetter(defaultInput);
-  return input => {
-    let result;
-    if (isMaybeSo(input)) {
-      result = convert(input);
-    } else {
-      if (convertMaybe) {
-        result = convertMaybe(input !== null && input !== void 0 ? input : getDefaultInput());
-      } else if (hasDefaultInput) {
-        result = convert(getDefaultInput());
-      } else {
-        result = getDefaultOutput();
-      }
-    }
-    return result;
-  };
-}
-/**
- * Converts the input to a ModelFieldConversions value.
- *
- * @param input
- * @returns
- */
-function toModelFieldConversions(input) {
-  var _a;
-  const conversions = (_a = input.fieldConversions) !== null && _a !== void 0 ? _a : modelFieldConversions(input.fields);
-  return conversions;
-}
-function toModelMapFunctions(input) {
-  let mapFunctions;
-  if (input.mapFunctions != null) {
-    mapFunctions = input.mapFunctions;
+function getDaysOfWeekNames(sundayFirst = true, transform) {
+  const days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+  const sunday = 'Sunday';
+  let dayOfWeekNames;
+  if (sundayFirst) {
+    dayOfWeekNames = [sunday, ...days];
   } else {
-    const conversions = toModelFieldConversions(input);
-    mapFunctions = makeModelMapFunctions(conversions);
+    dayOfWeekNames = [...days, sunday];
   }
-  return mapFunctions;
-}
-
-/**
- * Field conversion that copies the same value across.
- *
- * @param defaultValue
- * @returns
- */
-function copyField(defaultOutput) {
-  return {
-    from: {
-      default: defaultOutput,
-      convert: x => x
-    },
-    to: {
-      default: defaultOutput,
-      convert: x => x
+  if (transform != null) {
+    if (transform.abbreviation) {
+      dayOfWeekNames = dayOfWeekNames.map(x => x.slice(0, 3));
     }
-  };
+    if (transform.uppercase) {
+      dayOfWeekNames = dayOfWeekNames.map(x => x.toUpperCase());
+    }
+  }
+  return dayOfWeekNames;
 }
-
-function maybeMergeModelModifiers(input) {
-  const modifiers = asArray(input);
-  const allModifyData = filterMaybeValues(modifiers.map(x => x.modifyData));
-  const allModifyModel = filterMaybeValues(modifiers.map(x => x.modifyModel));
-  const modifyData = maybeMergeModifiers(allModifyData);
-  const modifyModel = maybeMergeModifiers(allModifyModel);
-  return {
-    modifyData,
-    modifyModel
-  };
+function daysOfWeekNameMap(transform) {
+  const dayOfWeekNames = getDaysOfWeekNames(true, transform);
+  return new Map(dayOfWeekNames.map((x, i) => [i, x]));
 }
-function modifyModelMapFunctions(config) {
-  const {
-    copy,
-    copyModel = copy,
-    copyData = copy,
-    mapFunctions,
-    modifiers
-  } = config;
-  const {
-    from,
-    to
-  } = mapFunctions;
-  const {
-    modifyData,
-    modifyModel
-  } = maybeMergeModelModifiers(modifiers);
-  const modifyFrom = modifyModelMapFunction(from, modifyData, copyData);
-  const modifyTo = modifyModelMapFunction(to, modifyModel, copyModel);
-  return {
-    from: modifyFrom,
-    to: modifyTo
+function daysOfWeekNameFunction(transform) {
+  const map = daysOfWeekNameMap(transform);
+  return dayOfWeek => {
+    var _a;
+    return (_a = map.get(dayOfWeek)) !== null && _a !== void 0 ? _a : 'UNKNOWN';
   };
 }
-/**
- * Merges a ModifierFunction with a ModelMapFunction
- *
- * @param mapFn
- * @param modifyModel
- * @param copy
- * @returns
- */
-function modifyModelMapFunction(mapFn, modifyModel, copy = true) {
-  return modifyModel ? (input, target, options) => {
-    const inputToMap = copy && input != null ? Object.assign({}, input) : input;
-    if (inputToMap != null) {
-      modifyModel(inputToMap);
-    }
-    return mapFn(inputToMap, target, options);
-  } : mapFn;
+function getDayTomorrow(day) {
+  return getNextDay(day, 1);
+}
+function getDayYesterday(day) {
+  return getPreviousDay(day, 1);
+}
+function getDayOffset(day, days) {
+  if (days === 0) {
+    return day;
+  } else if (days < 0) {
+    return getPreviousDay(day, days);
+  } else {
+    return getNextDay(day, days);
+  }
+}
+function getPreviousDay(day, days = 1) {
+  const offset = Math.abs(days) % 7;
+  const cap = 7 - offset;
+  return getNextDay(day, cap);
+}
+function getNextDay(day, days = 1) {
+  let result = (day + days) % 7;
+  if (result < 0) {
+    result = 7 + result;
+  }
+  return result;
 }
 
 var isPrototypeOf$1 = objectIsPrototypeOf;
@@ -12680,43 +12613,6 @@ $({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
   }
 });
 
-/**
- * Creates a new ReadableStreamToStringFunction
- * @param encoding
- * @returns
- */
-function readableStreamToStringFunction(encoding) {
-  return stream => {
-    return readableStreamToBuffer(stream).then(x => x.toString(encoding));
-  };
-}
-/**
- * ReadableStreamToStringFunction for Base64
- */
-const readableStreamToBase64 = readableStreamToStringFunction('base64');
-/**
- * Converts a ReadableStream to a Buffer promise.
- *
- * @param encoding
- * @returns
- */
-function readableStreamToBuffer(stream) {
-  const chunks = [];
-  return new Promise((resolve, reject) => {
-    stream.on('data', chunk => chunks.push(Buffer.from(chunk)));
-    stream.on('error', err => reject(err));
-    stream.on('end', () => resolve(Buffer.concat(chunks)));
-  });
-}
-
-function joinHostAndPort(config) {
-  if (config) {
-    return `${config.host}:${config.port}`;
-  } else {
-    return config;
-  }
-}
-
 function useCallback(use) {
   return __awaiter(this, void 0, void 0, function* () {
     return new Promise((resolve, reject) => {
@@ -13179,1198 +13075,1399 @@ function usePromise(input) {
   return useFn => _getter().then(useFn);
 }
 
-exports.RelationChange = void 0;
-(function (RelationChange) {
-  /**
-   * Adds a model to the relation. If the model already exists in
-   * the relation, the new one is used.
-   *
-   * Use INSERT to merge the two values together.
-   */
-  RelationChange["ADD"] = "add";
-  /**
-   * Sets the relation to be equal to the input.
-   */
-  RelationChange["SET"] = "set";
-  /**
-   * Variation of SET that performs REMOVE on the collection, and then follows it up with INSERT.
-   *
-   * This can allow the modification function to behave selectively with the items targeted for removal.
-   */
-  RelationChange["REMOVE_AND_INSERT"] = "remove_and_insert";
-  /**
-   * Removes a model from the relation.
-   */
-  RelationChange["REMOVE"] = "remove";
-  /**
-   * Updates an existing relation, if it exists.
-   * The existing object is merged with the update object.
-   */
-  RelationChange["UPDATE"] = "update";
-  /**
-   * Updates an existing relation, if it exists, or creates a new one.
-   */
-  RelationChange["INSERT"] = "insert";
-})(exports.RelationChange || (exports.RelationChange = {}));
-/**
- * Utility class for modifying a collection of relational objects.
- *
- * For instance, a string collection of keys.
- */
-class ModelRelationUtility {
-  static modifyStringCollection(current, change, mods) {
-    return ModelRelationUtility.modifyCollection(current, change, mods, {
-      readKey: x => x,
-      merge: (a, b) => b
-    });
+function timePeriodCounter(timePeriodLength, lastTimePeriodStart) {
+  function reset(inputStart) {
+    const start = inputStart !== null && inputStart !== void 0 ? inputStart : new Date();
+    fn._timePeriodCount = 0;
+    fn._lastTimePeriodStart = start;
+    fn._nextTimePeriodEnd = new Date(start.getTime() + timePeriodLength);
+    return fn._nextTimePeriodEnd;
   }
-  static modifyCollection(current, change, mods, config) {
-    const {
-      mask,
-      readKey
-    } = config;
-    current = current !== null && current !== void 0 ? current : []; //init current if not set.
-    if (mask) {
-      const {
-        included: currentModify,
-        excluded: currentRetain
-      } = separateValues(current, mask);
-      const {
-        included: modModify
-      } = separateValues(mods, mask);
-      const modifiedResults = this._modifyCollectionWithoutMask(currentModify, change, modModify, config);
-      return this._mergeMaskResults(current, currentRetain, modifiedResults, readKey);
+  const fn = () => {
+    const now = new Date();
+    if (now > fn._nextTimePeriodEnd) {
+      reset(now);
     } else {
-      return this._modifyCollectionWithoutMask(current, change, mods, config);
+      fn._timePeriodCount += 1;
     }
+    return fn._timePeriodCount;
+  };
+  fn._timePeriodLength = timePeriodLength;
+  reset(lastTimePeriodStart);
+  fn._timePeriodCount = -1;
+  fn._reset = reset;
+  return fn;
+}
+class TimerCancelledError extends makeError.BaseError {
+  constructor() {
+    super(`The timer was destroyed before it was completed.`);
   }
-  /**
-   * The mask results are merged together.
-   *
-   * Order from the "current" is retained. Anything in currentRetain overrides modifiedResults.
-   */
-  static _mergeMaskResults(current, currentRetain, modifiedResults, readKey) {
-    return restoreOrderWithValues(current, [...currentRetain, ...modifiedResults], {
-      readKey
-    });
-  }
-  static _modifyCollectionWithoutMask(current, change, mods, config) {
-    const {
-      readKey,
-      merge,
-      shouldRemove
-    } = config;
-    const readType = config.readType;
-    function remove(rCurrent = current, rMods = mods) {
-      return ModelRelationUtility._modifyCollection(rCurrent, rMods, (x, y) => {
-        return ModelRelationUtility.removeFromCollection(x, y, readKey, shouldRemove);
-      }, readType);
-    }
-    function performAdd() {
-      return ModelRelationUtility._modifyCollection(current, mods, (x, y) => ModelRelationUtility.addToCollection(x, y, readKey), readType);
-    }
-    function performInsert() {
-      return ModelRelationUtility.insertCollection(current, mods, {
-        readKey,
-        readType,
-        merge
-      });
-    }
-    switch (change) {
-      case exports.RelationChange.SET:
-        current = []; // Set current before performing add.
-        return performAdd();
-      case exports.RelationChange.ADD:
-        return performAdd();
-      case exports.RelationChange.REMOVE:
-        return remove();
-      case exports.RelationChange.UPDATE:
-        return ModelRelationUtility.updateCollection(current, mods, {
-          readKey,
-          readType,
-          merge
-        });
-      case exports.RelationChange.REMOVE_AND_INSERT:
-        current = remove(current, current); // Remove all current values before performing an insert.
-        return performInsert();
-      case exports.RelationChange.INSERT:
-        return performInsert();
+}
+class TimerInstance {
+  constructor(duration, startImmediately = true) {
+    this._createdAt = new Date();
+    this._startedAt = new Date();
+    this._state = 'paused';
+    this._promiseRef = promiseReference();
+    this._duration = duration;
+    if (startImmediately) {
+      this.start();
+      this._startedAt = this._createdAt;
     }
   }
-  static updateCollection(current, update, {
-    readKey,
-    readType,
-    merge
-  }) {
-    ModelRelationUtility._assertMergeProvided(merge);
-    return ModelRelationUtility._modifyCollection(current, update, (x, y) => ModelRelationUtility._updateSingleTypeCollection(x, y, {
-      readKey,
-      merge
-    }), readType);
+  get state() {
+    return this._state;
   }
-  static insertCollection(current, update, {
-    readKey,
-    readType,
-    merge
-  }) {
-    ModelRelationUtility._assertMergeProvided(merge);
-    return ModelRelationUtility._modifyCollection(current, update, (x, y) => ModelRelationUtility._insertSingleTypeCollection(x, y, {
-      readKey,
-      merge
-    }), readType);
+  get createdAt() {
+    return this._createdAt;
   }
-  /**
-   * Used to modify a collection which may be multi-type. If readType is provided, the collection is handled as a multi-type map.
-   */
-  static _modifyCollection(current, mods, modifyCollection, readType) {
-    if (readType) {
-      return ModelRelationUtility._modifyMultiTypeCollection(current, mods, readType, modifyCollection);
-    } else {
-      return modifyCollection(current, mods);
-    }
+  get pausedAt() {
+    return this._pausedAt;
   }
-  static _modifyMultiTypeCollection(input, mods, readType, modifyCollection) {
-    const inputMap = makeValuesGroupMap(input, readType);
-    const modsMap = makeValuesGroupMap(mods, readType);
-    const typesModified = new Set([...inputMap.keys(), ...modsMap.keys()]);
-    // Break the collections up into their individual types and process separately.
-    const modifiedSubcollections = Array.from(typesModified).map(type => {
-      var _a, _b;
-      const values = (_a = inputMap.get(type)) !== null && _a !== void 0 ? _a : [];
-      const mods = (_b = modsMap.get(type)) !== null && _b !== void 0 ? _b : [];
-      // Only modify if they've got changes for their type.
-      if (mods.length === 0) {
-        return values; // No mods, no change to those types.
-      } else {
-        return modifyCollection(values, mods);
-      }
-    });
-    // Rejoin all changes.
-    return modifiedSubcollections.reduce((x, y) => x.concat(y), []);
+  get startedAt() {
+    return this._startedAt;
   }
-  static _insertSingleTypeCollection(current, insert, {
-    readKey,
-    merge
-  }) {
-    const currentKeys = arrayToMap(current, readKey);
-    const updateValues = [];
-    const addValues = [];
-    insert.forEach(value => {
-      const key = readKey(value);
-      if (currentKeys.has(key)) {
-        updateValues.push(value);
-      } else {
-        addValues.push(value);
-      }
-    });
-    const added = ModelRelationUtility.addToCollection(current, addValues, readKey);
-    const results = ModelRelationUtility._updateSingleTypeCollection(added, updateValues, {
-      readKey,
-      merge
-    });
-    return results;
+  get promise() {
+    return this._promiseRef.promise;
   }
-  static _updateSingleTypeCollection(current, update, {
-    readKey,
-    merge
-  }) {
-    const keysToUpdate = arrayToMap(update, readKey);
-    const updateValues = [];
-    current.forEach(value => {
-      const key = readKey(value);
-      const mergeWith = keysToUpdate.get(key);
-      if (mergeWith != null) {
-        updateValues.push(merge(value, mergeWith));
-      }
-    });
-    // Add to merge all values and remove duplicates.
-    return ModelRelationUtility.addToCollection(current, updateValues, readKey);
+  get duration() {
+    return this._duration;
   }
-  static addToCollection(current, add, readKey) {
-    current = current !== null && current !== void 0 ? current : [];
-    return (add === null || add === void 0 ? void 0 : add.length) ? ModelRelationUtility.removeDuplicates([...add, ...current], readKey) : current; // Will keep any "added" before any existing ones.
+  get durationRemaining() {
+    let remaining;
+    switch (this._state) {
+      case 'complete':
+        remaining = 0;
+        break;
+      case 'running':
+        remaining = Math.max(0, this._duration - (new Date().getTime() - this._startedAt.getTime()));
+        break;
+      case 'paused':
+        remaining = null;
+        break;
+    }
+    return remaining;
   }
-
-  static removeFromCollection(current, remove, readKey, shouldRemove) {
-    if (current === null || current === void 0 ? void 0 : current.length) {
-      if (shouldRemove) {
-        const currentKeyPairs = makeKeyPairs(current, readKey);
-        const map = new Map(currentKeyPairs);
-        remove.forEach(x => {
-          const key = readKey(x);
-          const removalTarget = map.get(key);
-          if (removalTarget && shouldRemove(removalTarget)) {
-            map.delete(key); // Remove from the map.
-          }
-        });
-
-        return currentKeyPairs.filter(x => map.has(x[0])).map(x => x[1]); // Retain order, remove from map.
-      } else {
-        return ModelRelationUtility.removeKeysFromCollection(current, remove.map(readKey), readKey);
-      }
-    } else {
-      return [];
+  start() {
+    if (this._state === 'paused') {
+      this._state = 'running';
+      this._startedAt = new Date();
+      this._enqueueCheck();
     }
   }
-  static removeKeysFromCollection(current, keysToRemove, readKey) {
-    return ModelRelationUtility.removeDuplicates(current, readKey, keysToRemove);
+  stop() {
+    if (this._state === 'running') {
+      this._state = 'paused';
+      this._pausedAt = new Date();
+    }
   }
-  static removeDuplicates(relations, readKey, additionalKeys = []) {
-    return (relations === null || relations === void 0 ? void 0 : relations.length) ? filterUniqueValues(relations, readKey, additionalKeys) : [];
+  reset() {
+    if (this._state !== 'complete') {
+      this._state = 'running';
+      this._startedAt = new Date();
+      this._enqueueCheck();
+    }
   }
-  // MARK: Internal Utility
-  static _assertMergeProvided(merge) {
-    if (!merge) {
-      throw new Error('Merge was not provided.');
+  setDuration(duration) {
+    this._duration = duration;
+  }
+  destroy() {
+    this._checkComplete();
+    if (this._state === 'running') {
+      const error = new TimerCancelledError();
+      this._promiseRef.reject(error);
+      this._state = 'complete'; // mark as complete
     }
   }
-}
 
+  _checkComplete() {
+    if (this._state !== 'complete' && this.durationRemaining === 0) {
+      this._state = 'complete';
+      this._promiseRef.resolve();
+    }
+  }
+  _enqueueCheck() {
+    const durationRemaining = this.durationRemaining;
+    if (durationRemaining != null && this._state !== 'complete') {
+      setTimeout(() => {
+        this._checkComplete();
+        this._enqueueCheck();
+      }, durationRemaining);
+    }
+  }
+}
+function timer(duration, startNow = true) {
+  return new TimerInstance(duration, startNow);
+}
 /**
- * Key used to signify
+ * Toggles the input Timer's running state.
+ *
+ * @param timer
+ * @param toggleRun
  */
-const CATCH_ALL_HANDLE_RESULT_KEY = '__CATCH_ALL_HANDLE_RESULT_KEY__';
-function handlerFactory(readKey) {
-  return () => {
-    let catchAll;
-    const map = new Map();
-    const set = (key, handle) => {
-      if (key === CATCH_ALL_HANDLE_RESULT_KEY) {
-        catchAll = handle;
-      } else {
-        setKeysOnMap(map, key, handle);
+function toggleTimerRunning(timer, toggleRun) {
+  toggleRun = toggleRun != null ? toggleRun : timer.state !== 'running';
+  if (toggleRun) {
+    timer.start();
+  } else {
+    timer.stop();
+  }
+}
+/**
+ * Returns the approximate end date of the given timer. If a timer is already complete, it returns the time for now.
+ */
+function approximateTimerEndDate(timer) {
+  const durationRemaining = timer.durationRemaining;
+  if (durationRemaining != null) {
+    return new Date(Date.now() + durationRemaining);
+  } else {
+    return null;
+  }
+}
+
+exports.TimeAM = void 0;
+(function (TimeAM) {
+  TimeAM["AM"] = "AM";
+  TimeAM["PM"] = "PM";
+})(exports.TimeAM || (exports.TimeAM = {}));
+const DATE_NOW_VALUE = 'now';
+function dateFromLogicalDate(logicalDate) {
+  let result;
+  if (typeof logicalDate === 'string') {
+    switch (logicalDate.toLocaleLowerCase()) {
+      case DATE_NOW_VALUE:
+        result = new Date();
+        break;
+      default:
+        throw new Error(`Unknown logical date string "${logicalDate}"`);
+    }
+  } else {
+    result = logicalDate;
+  }
+  return result;
+}
+function isLogicalDateStringCode(logicalDate) {
+  let isLogicalDateStringCode = false;
+  if (typeof logicalDate === 'string') {
+    switch (logicalDate.toLocaleLowerCase()) {
+      case DATE_NOW_VALUE:
+        isLogicalDateStringCode = true;
+        break;
+    }
+  }
+  return isLogicalDateStringCode;
+}
+
+/**
+ * Performs a deep comparison to check if all values on the input filters are equal.
+ *
+ * Recursively compares Arrays, Objects, Maps, Sets, Primatives, and Dates.
+ */
+function areEqualPOJOValues(a, b) {
+  // check self
+  if (a === b) {
+    return true;
+  }
+  // check one value is nullish and other is not
+  if ((a == null || b == null) && (a || b)) {
+    return false;
+  }
+  // object check
+  if (typeof a === 'object') {
+    // check if they are arrays
+    if (isIterable(a, false)) {
+      if (Array.isArray(a)) {
+        if (a.length !== b.length) {
+          return false;
+        }
+        const firstInequalityIndex = a.findIndex((aValue, i) => {
+          const bValue = b[i];
+          return !areEqualPOJOValues(aValue, bValue);
+        });
+        return firstInequalityIndex === -1;
+      } else if (a instanceof Set) {
+        return setsAreEquivalent(a, b);
+      } else if (a instanceof Map) {
+        const bMap = b;
+        if (a.size !== bMap.size) {
+          return false;
+        }
+        const firstInequalityIndex = Array.from(a.entries()).findIndex(([key, aValue]) => {
+          const bValue = bMap.get(key);
+          return !areEqualPOJOValues(aValue, bValue);
+        });
+        return firstInequalityIndex === -1;
       }
-    };
-    const bindSet = (bindTo, key, handle) => {
-      const bindHandle = handle.bind(bindTo);
-      set(key, bindHandle);
-    };
-    const fn = build({
-      base: value => {
-        var _a;
-        const key = readKey(value);
-        const handler = (_a = key != null ? map.get(key) : undefined) !== null && _a !== void 0 ? _a : catchAll;
-        let handled = false;
-        if (handler) {
-          handled = handler(value);
+    } else if (typeof b === 'object') {
+      // check contructors/types
+      const firstType = a === null || a === void 0 ? void 0 : a.constructor.name;
+      const secondType = b === null || b === void 0 ? void 0 : b.constructor.name;
+      if (firstType !== secondType) {
+        return false; // false if not the same type
+      }
+      // check Date comparison
+      if (isDate(a)) {
+        return isEqualDate(a, b);
+      }
+      // check object comparison via keys
+      const aObject = a;
+      const bObject = b;
+      const aKeys = Object.keys(aObject);
+      const bKeys = Object.keys(bObject);
+      // compare keys
+      if (aKeys.length === bKeys.length) {
+        const firstInequalityIndex = aKeys.findIndex(key => {
+          const aKeyValue = aObject[key];
+          const bKeyValue = bObject[key];
+          return !areEqualPOJOValues(aKeyValue, bKeyValue);
+        });
+        if (firstInequalityIndex === -1) {
+          return true; // is equal if no non-matching key/value pair is found
         }
-        return handled;
-      },
-      build: x => {
-        x.readKey = readKey;
-        x.set = set;
-        x.bindSet = bindSet;
       }
+    }
+  }
+  // still not equal if down here
+  return false;
+}
+function objectFieldEqualityChecker(config) {
+  const {
+    fields,
+    defaultEqualityFunction = (a, b) => a === b
+  } = config;
+  const _fields = new Map();
+  fields.forEach(input => {
+    let field;
+    if (typeof input === 'object') {
+      field = input;
+    } else {
+      field = {
+        fieldName: input,
+        isEqual: defaultEqualityFunction
+      };
+    }
+    _fields.set(field.fieldName, field);
+  });
+  const fn = (a, b) => {
+    const equalFields = [];
+    const unequalFields = [];
+    _fields.forEach((fieldConfig, fieldName) => {
+      const {
+        isEqual
+      } = fieldConfig;
+      isEqual(a[fieldName], b[fieldName]) ? equalFields.push(fieldName) : unequalFields.push(fieldName);
     });
-    return fn;
+    return {
+      a,
+      b,
+      isEqual: unequalFields.length === 0,
+      equalFields,
+      unequalFields
+    };
   };
-}
-function makeHandler(readKey) {
-  return handlerFactory(readKey)();
-}
-function catchAllHandlerKey() {
-  return CATCH_ALL_HANDLE_RESULT_KEY;
+  fn._fields = _fields;
+  return fn;
 }
 
 /**
- * Creates a HandlerBindAccessor<T, K> for the input values.
+ * Creates a EqualityComparatorFunction that compares the two input values
  *
- * @param bindTo
- * @param accessor
+ * @param readKey
  * @returns
  */
-function handlerBindAccessor(boundTo, accessor) {
-  return {
-    accessor,
-    boundTo,
-    set: (key, handle) => {
-      accessor.bindSet(boundTo, key, handle);
+function objectKeysEqualityComparatorFunction(readKey) {
+  const readKeysSet = readKeysSetFunction(readKey);
+  const readKeysArray = readKeysFunction(readKey);
+  return safeEqualityComparatorFunction((a, b) => {
+    if (a.length === b.length) {
+      if (a.length === 0) {
+        return true; // both the same/empty arrays
+      }
+
+      const aKeys = readKeysSet(a);
+      const bKeys = readKeysArray(b);
+      if (aKeys.size === bKeys.length) {
+        return setContainsAllValues(aKeys, bKeys);
+      }
     }
-  };
+    return false;
+  });
 }
 /**
- * Creates a HandlerSetFunction.
+ * Creates a EqualityComparatorFunction that compares the two input values
  *
- * @param accessor
- * @param key
+ * @param readKey
  * @returns
  */
-function handlerSetFunction(accessor, key) {
-  const fn = handlerFunction => {
-    accessor.set(key, handlerFunction); // set the handler on the pre-defined key.
+function objectKeyEqualityComparatorFunction(readKey) {
+  return safeEqualityComparatorFunction((a, b) => readKey(a) === readKey(b));
+}
+
+function makeCopyModelFieldFunction(key, inputConfig) {
+  const config = inputConfig !== null && inputConfig !== void 0 ? inputConfig : {};
+  const hasDefault = objectHasKey(config, 'default');
+  const defaultValue = config.default;
+  return (from, target) => {
+    var _a;
+    if (objectHasKey(from, key)) {
+      target[key] = (_a = from[key]) !== null && _a !== void 0 ? _a : defaultValue;
+    } else if (hasDefault) {
+      target[key] = defaultValue;
+    }
   };
+}
 
-  fn.key = key;
-  return fn;
+function makeModelMapFunctions(fields) {
+  const keys = filterKeyValueTuples(fields);
+  const conversionsByKey = keys.map(([key, field]) => [key, field]);
+  const fromConversions = conversionsByKey.map(([key, configs]) => [key, configs.from]);
+  const toConversions = conversionsByKey.map(([key, configs]) => [key, configs.to]);
+  const from = makeModelConversionFieldValuesFunction(fromConversions);
+  const to = makeModelConversionFieldValuesFunction(toConversions);
+  return {
+    from,
+    to
+  };
 }
-function handlerMappedSetFunction(accessor, key, mapFn) {
-  const handlerSet = handlerSetFunction(accessor, key);
-  return handlerFunction => {
-    // set an intermediary function that calls the target function. We don't use an arrow function so we have access to the "this", if bound.
-    handlerSet(function (value) {
-      const mapped = mapFn(value); // fowards "this" to the next call.
-      return handlerFunction.call(this, mapped);
-    });
+function makeModelConversionFieldValuesFunction(fields) {
+  return (input, inputTarget, options) => {
+    const target = inputTarget !== null && inputTarget !== void 0 ? inputTarget : {};
+    if (input != null) {
+      let targetFields = fields;
+      // if options are provided, filter down.
+      if (options) {
+        const fieldsToMap = new Set(findPOJOKeys(input, {
+          keysFilter: options.fields,
+          valueFilter: options.definedOnly === false ? exports.KeyValueTypleValueFilter.NONE : exports.KeyValueTypleValueFilter.UNDEFINED
+        }));
+        targetFields = fields.filter(x => fieldsToMap.has(x[0]));
+      }
+      targetFields.forEach(([key, convert]) => target[key] = convert(input[key]));
+    }
+    return target;
   };
 }
-function handlerMappedSetFunctionFactory(accessor, mapFn) {
-  return key => handlerMappedSetFunction(accessor, key, mapFn);
+function modelFieldConversions(config) {
+  return mapObjectMap(config, x => modelFieldMapFunctions(x));
 }
-function handlerConfigurerFactory(config) {
-  return handler => {
-    return (bindTo, configure) => {
-      const accessor = handlerBindAccessor(bindTo, handler);
-      const configurer = config.configurerForAccessor(accessor);
-      configure(configurer);
-    };
+function modelFieldMapFunctions(config) {
+  return {
+    from: modelFieldMapFunction(config.from),
+    to: modelFieldMapFunction(config.to)
   };
 }
-
 /**
- * TypedServiceRegistry implementation.
+ * Creates a ModelFieldMapFunction.
+ *
+ * @param config
+ * @returns
  */
-class TypedServiceRegistryInstance {
-  constructor() {
-    this._map = new Map();
-  }
-  registerServiceForType(type, service) {
-    const getter = asGetter(service);
-    this._map.set(type, getter);
-  }
-  serviceForType(type) {
-    const getter = this._map.get(type);
-    const service = getter === null || getter === void 0 ? void 0 : getter();
-    if (service == null) {
-      throw new Error(`no service registered for type "${type}"`);
+function modelFieldMapFunction(config) {
+  const convert = config.convert;
+  const convertMaybe = config.convertMaybe;
+  const defaultOutput = config.default;
+  const defaultInput = config.defaultInput;
+  const hasDefaultInput = defaultInput != null;
+  const getDefaultOutput = asGetter(defaultOutput);
+  const getDefaultInput = asGetter(defaultInput);
+  return input => {
+    let result;
+    if (isMaybeSo(input)) {
+      result = convert(input);
+    } else {
+      if (convertMaybe) {
+        result = convertMaybe(input !== null && input !== void 0 ? input : getDefaultInput());
+      } else if (hasDefaultInput) {
+        result = convert(getDefaultInput());
+      } else {
+        result = getDefaultOutput();
+      }
     }
-    return service;
-  }
+    return result;
+  };
 }
 /**
- * Creates a new TypedServiceRegistryInstance and registers the input types.
+ * Converts the input to a ModelFieldConversions value.
+ *
+ * @param input
  * @returns
  */
-function typedServiceRegistry(config) {
-  const instance = new TypedServiceRegistryInstance();
-  forEachKeyValue(config.services, {
-    forEach: ([key, service]) => {
-      instance.registerServiceForType(key, service);
-    }
-  });
-  return instance;
-}
-
-class StoredDataError extends makeError.BaseError {
-  constructor(message) {
-    super(message);
-  }
-}
-class DataDoesNotExistError extends StoredDataError {
-  constructor(message) {
-    super(message);
-  }
-}
-class DataIsExpiredError extends StoredDataError {
-  constructor(data, message) {
-    super(message);
-    this.data = data;
-  }
+function toModelFieldConversions(input) {
+  var _a;
+  const conversions = (_a = input.fieldConversions) !== null && _a !== void 0 ? _a : modelFieldConversions(input.fields);
+  return conversions;
 }
-
-class MemoryStorageInstance {
-  constructor() {
-    this._length = 0;
-    this._storage = {};
-  }
-  get length() {
-    return this._length;
-  }
-  key(index) {
-    var _a;
-    return (_a = Object.keys(this._storage)[index]) !== null && _a !== void 0 ? _a : null;
-  }
-  hasKey(key) {
-    return objectHasKey(this._storage, key);
-  }
-  getItem(key) {
-    var _a;
-    return (_a = this._storage[key]) !== null && _a !== void 0 ? _a : null;
-  }
-  setItem(key, item) {
-    if (item == null) {
-      this.removeItem(key);
-    } else {
-      if (!this.hasKey(key)) {
-        this._length = this._length + 1;
-      }
-      this._storage[key] = String(item);
-    }
-  }
-  removeItem(key) {
-    if (this.hasKey(key)) {
-      delete this._storage[key]; // Remove the property
-      this._length = this._length - 1;
-    }
-  }
-  clear() {
-    this._storage = {};
-    this._length = 0;
+function toModelMapFunctions(input) {
+  let mapFunctions;
+  if (input.mapFunctions != null) {
+    mapFunctions = input.mapFunctions;
+  } else {
+    const conversions = toModelFieldConversions(input);
+    mapFunctions = makeModelMapFunctions(conversions);
   }
+  return mapFunctions;
 }
-const SHARED_MEMORY_STORAGE = new MemoryStorageInstance();
 
 /**
- * Limited Class/Interface for storing string values synchronously.
- */
-class SimpleStorageObject {}
-/**
- * Synchronous Class/Interface for storing string values.
+ * Field conversion that copies the same value across.
  *
- * Has the same interface as localStorage for the web.
+ * @param defaultValue
+ * @returns
  */
-class StorageObject extends SimpleStorageObject {}
-class FullStorageObject extends StorageObject {}
-class StorageObjectUtility {
-  static allKeysFromStorageObject(storageObject, prefix) {
-    const length = storageObject.length;
-    let result;
-    if (length > 0) {
-      result = range({
-        start: 0,
-        end: length
-      }).map(x => storageObject.key(x)).filter(hasNonNullValue);
-      if (prefix) {
-        result = result.filter(x => x.startsWith(prefix));
-      }
-    } else {
-      result = [];
+function copyField(defaultOutput) {
+  return {
+    from: {
+      default: defaultOutput,
+      convert: x => x
+    },
+    to: {
+      default: defaultOutput,
+      convert: x => x
     }
-    return result;
-  }
+  };
 }
 
-/**
- * Joins together various array of classes and only keeps the unique values.
- *
- * @param cssClasses
- * @returns
- */
-function spaceSeparatedCssClasses(cssClasses) {
-  let result = '';
-  if (cssClasses) {
-    const allClasses = cssClassesSet(cssClasses);
-    result = joinStringsWithSpaces(Array.from(allClasses));
-  }
-  return result;
+function maybeMergeModelModifiers(input) {
+  const modifiers = asArray(input);
+  const allModifyData = filterMaybeValues(modifiers.map(x => x.modifyData));
+  const allModifyModel = filterMaybeValues(modifiers.map(x => x.modifyModel));
+  const modifyData = maybeMergeModifiers(allModifyData);
+  const modifyModel = maybeMergeModifiers(allModifyModel);
+  return {
+    modifyData,
+    modifyModel
+  };
+}
+function modifyModelMapFunctions(config) {
+  const {
+    copy,
+    copyModel = copy,
+    copyData = copy,
+    mapFunctions,
+    modifiers
+  } = config;
+  const {
+    from,
+    to
+  } = mapFunctions;
+  const {
+    modifyData,
+    modifyModel
+  } = maybeMergeModelModifiers(modifiers);
+  const modifyFrom = modifyModelMapFunction(from, modifyData, copyData);
+  const modifyTo = modifyModelMapFunction(to, modifyModel, copyModel);
+  return {
+    from: modifyFrom,
+    to: modifyTo
+  };
 }
 /**
- * Joins together various array of classes and returns the set of unique CSS classes.
+ * Merges a ModifierFunction with a ModelMapFunction
  *
- * @param cssClasses
+ * @param mapFn
+ * @param modifyModel
+ * @param copy
  * @returns
  */
-function cssClassesSet(cssClasses) {
-  let result;
-  if (cssClasses) {
-    const arrayOfClasses = iterableToArray(cssClasses, false);
-    const arrayOfAllClassValues = arrayOfClasses.map(x => asArray(x).map(x => x.split(' ')).flat()).flat();
-    result = new Set(arrayOfAllClassValues);
-  } else {
-    result = new Set();
-  }
-  return result;
+function modifyModelMapFunction(mapFn, modifyModel, copy = true) {
+  return modifyModel ? (input, target, options) => {
+    const inputToMap = copy && input != null ? Object.assign({}, input) : input;
+    if (inputToMap != null) {
+      modifyModel(inputToMap);
+    }
+    return mapFn(inputToMap, target, options);
+  } : mapFn;
 }
 
 /**
- * Creates a SortByStringFunction that sorts values in ascending order.
+ * Creates a new ReadableStreamToStringFunction
+ * @param encoding
+ * @returns
  */
-function sortByStringFunction(readStringFn) {
-  return (a, b) => {
-    const as = readStringFn(a);
-    const bs = readStringFn(b);
-    return as.localeCompare(bs);
+function readableStreamToStringFunction(encoding) {
+  return stream => {
+    return readableStreamToBuffer(stream).then(x => x.toString(encoding));
   };
 }
-const sortByLabelFunction = sortByStringFunction(x => x.label);
-
 /**
- * Creates a SearchStringFilterFunction
+ * ReadableStreamToStringFunction for Base64
+ */
+const readableStreamToBase64 = readableStreamToStringFunction('base64');
+/**
+ * Converts a ReadableStream to a Buffer promise.
  *
- * @param config
+ * @param encoding
  * @returns
  */
-function searchStringFilterFunction(config) {
-  const {
-    readStrings,
-    decisionFactory = caseInsensitiveFilterByIndexOfDecisionFactory
-  } = typeof config === 'function' ? {
-    readStrings: config
-  } : config;
-  return (filterText, values) => {
-    const decision = decisionFactory(filterText);
-    return values.filter(value => {
-      const searchResult = readStrings(value);
-      let match = false;
-      if (Array.isArray(searchResult)) {
-        match = searchResult.findIndex(decision) !== -1;
-      } else if (searchResult != null) {
-        match = decision(searchResult);
-      }
-      return match;
-    });
-  };
+function readableStreamToBuffer(stream) {
+  const chunks = [];
+  return new Promise((resolve, reject) => {
+    stream.on('data', chunk => chunks.push(Buffer.from(chunk)));
+    stream.on('error', err => reject(err));
+    stream.on('end', () => resolve(Buffer.concat(chunks)));
+  });
 }
-/**
- * SearchStringDecisionFunctionFactory that searches for string matches using the input search term/filter text.
- *
- * @param filterText
- * @returns
- */
-const caseInsensitiveFilterByIndexOfDecisionFactory = filterText => {
-  const searchString = filterText.toLocaleLowerCase();
-  return string => string.toLocaleLowerCase().indexOf(searchString) !== -1;
-};
 
-const SPLIT_STRING_TREE_NODE_ROOT_VALUE = '';
+function joinHostAndPort(config) {
+  if (config) {
+    return `${config.host}:${config.port}`;
+  } else {
+    return config;
+  }
+}
+
+exports.RelationChange = void 0;
+(function (RelationChange) {
+  /**
+   * Adds a model to the relation. If the model already exists in
+   * the relation, the new one is used.
+   *
+   * Use INSERT to merge the two values together.
+   */
+  RelationChange["ADD"] = "add";
+  /**
+   * Sets the relation to be equal to the input.
+   */
+  RelationChange["SET"] = "set";
+  /**
+   * Variation of SET that performs REMOVE on the collection, and then follows it up with INSERT.
+   *
+   * This can allow the modification function to behave selectively with the items targeted for removal.
+   */
+  RelationChange["REMOVE_AND_INSERT"] = "remove_and_insert";
+  /**
+   * Removes a model from the relation.
+   */
+  RelationChange["REMOVE"] = "remove";
+  /**
+   * Updates an existing relation, if it exists.
+   * The existing object is merged with the update object.
+   */
+  RelationChange["UPDATE"] = "update";
+  /**
+   * Updates an existing relation, if it exists, or creates a new one.
+   */
+  RelationChange["INSERT"] = "insert";
+})(exports.RelationChange || (exports.RelationChange = {}));
 /**
- * Creates a SplitStringTreeFactory with the configured splitter.
+ * Utility class for modifying a collection of relational objects.
  *
- * @param config
- * @returns
+ * For instance, a string collection of keys.
  */
-function splitStringTreeFactory(config) {
-  const {
-    separator
-  } = config;
-  const fn = (input, existing) => {
+class ModelRelationUtility {
+  static modifyStringCollection(current, change, mods) {
+    return ModelRelationUtility.modifyCollection(current, change, mods, {
+      readKey: x => x,
+      merge: (a, b) => b
+    });
+  }
+  static modifyCollection(current, change, mods, config) {
     const {
-      leafMeta,
-      nodeMeta,
-      values
-    } = input;
-    const result = existing !== null && existing !== void 0 ? existing : {
-      fullValue: SPLIT_STRING_TREE_NODE_ROOT_VALUE,
-      nodeValue: SPLIT_STRING_TREE_NODE_ROOT_VALUE,
-      children: {}
-    };
-    asArray(values).forEach(value => {
-      addToSplitStringTree(result, {
-        value,
-        leafMeta,
-        nodeMeta
-      }, config);
+      mask,
+      readKey
+    } = config;
+    current = current !== null && current !== void 0 ? current : []; //init current if not set.
+    if (mask) {
+      const {
+        included: currentModify,
+        excluded: currentRetain
+      } = separateValues(current, mask);
+      const {
+        included: modModify
+      } = separateValues(mods, mask);
+      const modifiedResults = this._modifyCollectionWithoutMask(currentModify, change, modModify, config);
+      return this._mergeMaskResults(current, currentRetain, modifiedResults, readKey);
+    } else {
+      return this._modifyCollectionWithoutMask(current, change, mods, config);
+    }
+  }
+  /**
+   * The mask results are merged together.
+   *
+   * Order from the "current" is retained. Anything in currentRetain overrides modifiedResults.
+   */
+  static _mergeMaskResults(current, currentRetain, modifiedResults, readKey) {
+    return restoreOrderWithValues(current, [...currentRetain, ...modifiedResults], {
+      readKey
     });
-    return result;
-  };
-  fn._separator = separator;
-  return fn;
-}
-function applySplitStringTreeWithMultipleValues(input) {
-  const {
-    entries,
-    factory,
-    existing
-  } = input;
-  let result = existing;
-  entries.forEach(entry => {
-    result = factory(entry, result);
-  });
-  if (!result) {
-    result = factory({
-      values: []
+  }
+  static _modifyCollectionWithoutMask(current, change, mods, config) {
+    const {
+      readKey,
+      merge,
+      shouldRemove
+    } = config;
+    const readType = config.readType;
+    function remove(rCurrent = current, rMods = mods) {
+      return ModelRelationUtility._modifyCollection(rCurrent, rMods, (x, y) => {
+        return ModelRelationUtility.removeFromCollection(x, y, readKey, shouldRemove);
+      }, readType);
+    }
+    function performAdd() {
+      return ModelRelationUtility._modifyCollection(current, mods, (x, y) => ModelRelationUtility.addToCollection(x, y, readKey), readType);
+    }
+    function performInsert() {
+      return ModelRelationUtility.insertCollection(current, mods, {
+        readKey,
+        readType,
+        merge
+      });
+    }
+    switch (change) {
+      case exports.RelationChange.SET:
+        current = []; // Set current before performing add.
+        return performAdd();
+      case exports.RelationChange.ADD:
+        return performAdd();
+      case exports.RelationChange.REMOVE:
+        return remove();
+      case exports.RelationChange.UPDATE:
+        return ModelRelationUtility.updateCollection(current, mods, {
+          readKey,
+          readType,
+          merge
+        });
+      case exports.RelationChange.REMOVE_AND_INSERT:
+        current = remove(current, current); // Remove all current values before performing an insert.
+        return performInsert();
+      case exports.RelationChange.INSERT:
+        return performInsert();
+    }
+  }
+  static updateCollection(current, update, {
+    readKey,
+    readType,
+    merge
+  }) {
+    ModelRelationUtility._assertMergeProvided(merge);
+    return ModelRelationUtility._modifyCollection(current, update, (x, y) => ModelRelationUtility._updateSingleTypeCollection(x, y, {
+      readKey,
+      merge
+    }), readType);
+  }
+  static insertCollection(current, update, {
+    readKey,
+    readType,
+    merge
+  }) {
+    ModelRelationUtility._assertMergeProvided(merge);
+    return ModelRelationUtility._modifyCollection(current, update, (x, y) => ModelRelationUtility._insertSingleTypeCollection(x, y, {
+      readKey,
+      merge
+    }), readType);
+  }
+  /**
+   * Used to modify a collection which may be multi-type. If readType is provided, the collection is handled as a multi-type map.
+   */
+  static _modifyCollection(current, mods, modifyCollection, readType) {
+    if (readType) {
+      return ModelRelationUtility._modifyMultiTypeCollection(current, mods, readType, modifyCollection);
+    } else {
+      return modifyCollection(current, mods);
+    }
+  }
+  static _modifyMultiTypeCollection(input, mods, readType, modifyCollection) {
+    const inputMap = makeValuesGroupMap(input, readType);
+    const modsMap = makeValuesGroupMap(mods, readType);
+    const typesModified = new Set([...inputMap.keys(), ...modsMap.keys()]);
+    // Break the collections up into their individual types and process separately.
+    const modifiedSubcollections = Array.from(typesModified).map(type => {
+      var _a, _b;
+      const values = (_a = inputMap.get(type)) !== null && _a !== void 0 ? _a : [];
+      const mods = (_b = modsMap.get(type)) !== null && _b !== void 0 ? _b : [];
+      // Only modify if they've got changes for their type.
+      if (mods.length === 0) {
+        return values; // No mods, no change to those types.
+      } else {
+        return modifyCollection(values, mods);
+      }
     });
+    // Rejoin all changes.
+    return modifiedSubcollections.reduce((x, y) => x.concat(y), []);
   }
-  return result;
-}
-/**
- * Adds a value to the target SplitStringTree.
- *
- * @param tree
- * @param value
- * @param separator
- * @returns
- */
-function addToSplitStringTree(tree, inputValue, config) {
-  const {
-    separator,
-    mergeMeta
-  } = config;
-  const {
-    value,
-    leafMeta,
-    nodeMeta
-  } = inputValue;
-  function nextMeta(node, nextMeta) {
-    if (mergeMeta && node.meta != null) {
-      return mergeMeta(node.meta, nextMeta);
+  static _insertSingleTypeCollection(current, insert, {
+    readKey,
+    merge
+  }) {
+    const currentKeys = arrayToMap(current, readKey);
+    const updateValues = [];
+    const addValues = [];
+    insert.forEach(value => {
+      const key = readKey(value);
+      if (currentKeys.has(key)) {
+        updateValues.push(value);
+      } else {
+        addValues.push(value);
+      }
+    });
+    const added = ModelRelationUtility.addToCollection(current, addValues, readKey);
+    const results = ModelRelationUtility._updateSingleTypeCollection(added, updateValues, {
+      readKey,
+      merge
+    });
+    return results;
+  }
+  static _updateSingleTypeCollection(current, update, {
+    readKey,
+    merge
+  }) {
+    const keysToUpdate = arrayToMap(update, readKey);
+    const updateValues = [];
+    current.forEach(value => {
+      const key = readKey(value);
+      const mergeWith = keysToUpdate.get(key);
+      if (mergeWith != null) {
+        updateValues.push(merge(value, mergeWith));
+      }
+    });
+    // Add to merge all values and remove duplicates.
+    return ModelRelationUtility.addToCollection(current, updateValues, readKey);
+  }
+  static addToCollection(current, add, readKey) {
+    current = current !== null && current !== void 0 ? current : [];
+    return (add === null || add === void 0 ? void 0 : add.length) ? ModelRelationUtility.removeDuplicates([...add, ...current], readKey) : current; // Will keep any "added" before any existing ones.
+  }
+
+  static removeFromCollection(current, remove, readKey, shouldRemove) {
+    if (current === null || current === void 0 ? void 0 : current.length) {
+      if (shouldRemove) {
+        const currentKeyPairs = makeKeyPairs(current, readKey);
+        const map = new Map(currentKeyPairs);
+        remove.forEach(x => {
+          const key = readKey(x);
+          const removalTarget = map.get(key);
+          if (removalTarget && shouldRemove(removalTarget)) {
+            map.delete(key); // Remove from the map.
+          }
+        });
+
+        return currentKeyPairs.filter(x => map.has(x[0])).map(x => x[1]); // Retain order, remove from map.
+      } else {
+        return ModelRelationUtility.removeKeysFromCollection(current, remove.map(readKey), readKey);
+      }
     } else {
-      return nextMeta;
+      return [];
     }
   }
-  const parts = value.split(separator);
-  let currentNode = tree;
-  parts.forEach(nodeValue => {
-    const existingChildNode = currentNode.children[nodeValue];
-    const childNode = existingChildNode !== null && existingChildNode !== void 0 ? existingChildNode : {
-      nodeValue,
-      children: {}
-    }; // use the existing node or create a new node
-    if (!existingChildNode) {
-      childNode.fullValue = currentNode.fullValue ? currentNode.fullValue + separator + nodeValue : nodeValue;
-      currentNode.children[nodeValue] = childNode;
-    }
-    // add the meta to the node
-    if (nodeMeta != null) {
-      childNode.meta = nextMeta(childNode, nodeMeta);
-    }
-    currentNode = childNode;
-  });
-  // add the meta to the leaf node
-  if (leafMeta != null) {
-    currentNode.meta = nextMeta(currentNode, leafMeta);
+  static removeKeysFromCollection(current, keysToRemove, readKey) {
+    return ModelRelationUtility.removeDuplicates(current, readKey, keysToRemove);
   }
-  return tree;
-}
-// MARK: Search
-/**
- * Returns the best match for the value in the tree, including the input tree value.
- *
- * Only returns a result if there is match of any kind.
- *
- * @param tree
- * @param value
- * @returns
- */
-function findBestSplitStringTreeMatch(tree, value) {
-  return lastValue(findBestSplitStringTreeMatchPath(tree, value));
-}
-/**
- * Returns the best match for the value in the true, excluding the input tree value.
- *
- * Only returns a result if there is match of any kind.
- *
- * @param tree
- * @param value
- * @returns
- */
-function findBestSplitStringTreeChildMatch(tree, value) {
-  return lastValue(findBestSplitStringTreeChildMatchPath(tree, value));
-}
-/**
- * Returns the best match for the value in the tree, including the input tree value.
- *
- * Only returns a result if there is match of any kind.
- *
- * @param tree
- * @param value
- * @returns
- */
-function findBestSplitStringTreeMatchPath(tree, value) {
-  let bestResult = findBestSplitStringTreeChildMatchPath(tree, value);
-  if (!bestResult && tree.fullValue && value.startsWith(tree.fullValue)) {
-    bestResult = [tree];
+  static removeDuplicates(relations, readKey, additionalKeys = []) {
+    return (relations === null || relations === void 0 ? void 0 : relations.length) ? filterUniqueValues(relations, readKey, additionalKeys) : [];
   }
-  return bestResult;
-}
-/**
- * Returns the best match for the value in the true, excluding the input tree value.
- *
- * Only returns a result if there is match of any kind.
- *
- * @param tree
- * @param value
- * @returns
- */
-function findBestSplitStringTreeChildMatchPath(tree, value) {
-  const {
-    children
-  } = tree;
-  let bestMatchPath;
-  Object.entries(children).find(([_, child]) => {
-    var _a;
-    let stopScan = false;
-    if (value.startsWith(child.fullValue)) {
-      const bestChildPath = (_a = findBestSplitStringTreeChildMatchPath(child, value)) !== null && _a !== void 0 ? _a : [];
-      bestMatchPath = [child, ...bestChildPath];
-      stopScan = true;
+  // MARK: Internal Utility
+  static _assertMergeProvided(merge) {
+    if (!merge) {
+      throw new Error('Merge was not provided.');
     }
-    return stopScan;
-  });
-  return bestMatchPath;
+  }
 }
 
-/*eslint @typescript-eslint/no-explicit-any:"off"*/
-// any is used with intent here, as the recursive TreeNode value requires its use to terminate.
-function expandTreeFunction(config) {
-  var _a;
-  const makeNode = (_a = config.makeNode) !== null && _a !== void 0 ? _a : node => node;
-  const expandFn = (value, parent) => {
-    const depth = parent ? parent.depth + 1 : 0;
-    const treeNode = {
-      depth,
-      parent,
-      value
+/**
+ * Key used to signify
+ */
+const CATCH_ALL_HANDLE_RESULT_KEY = '__CATCH_ALL_HANDLE_RESULT_KEY__';
+function handlerFactory(readKey) {
+  return () => {
+    let catchAll;
+    const map = new Map();
+    const set = (key, handle) => {
+      if (key === CATCH_ALL_HANDLE_RESULT_KEY) {
+        catchAll = handle;
+      } else {
+        setKeysOnMap(map, key, handle);
+      }
     };
-    const node = makeNode(treeNode);
-    const childrenValues = config.getChildren(value);
-    node.children = childrenValues ? childrenValues.map(x => expandFn(x, node)) : undefined;
-    return node;
+    const bindSet = (bindTo, key, handle) => {
+      const bindHandle = handle.bind(bindTo);
+      set(key, bindHandle);
+    };
+    const fn = build({
+      base: value => {
+        var _a;
+        const key = readKey(value);
+        const handler = (_a = key != null ? map.get(key) : undefined) !== null && _a !== void 0 ? _a : catchAll;
+        let handled = false;
+        if (handler) {
+          handled = handler(value);
+        }
+        return handled;
+      },
+      build: x => {
+        x.readKey = readKey;
+        x.set = set;
+        x.bindSet = bindSet;
+      }
+    });
+    return fn;
   };
-  return root => expandFn(root);
 }
-/**
- * Convenience function for expanding multiple values into trees then merging them together into a single array.
- *
- * @param values
- * @param expandFn
- * @returns
- */
-function expandTrees(values, expandFn) {
-  return values.map(expandFn);
+function makeHandler(readKey) {
+  return handlerFactory(readKey)();
 }
-
-/**
- * Traverses the tree and flattens it into all tree nodes.
- */
-function flattenTree(tree) {
-  return flattenTreeToArray(tree, []);
+function catchAllHandlerKey() {
+  return CATCH_ALL_HANDLE_RESULT_KEY;
 }
+
 /**
- * Traverses the tree and pushes the nodes into the input array.
+ * Creates a HandlerBindAccessor<T, K> for the input values.
  *
- * @param tree
- * @param array
+ * @param bindTo
+ * @param accessor
  * @returns
  */
-function flattenTreeToArray(tree, array) {
-  return flattenTreeToArrayFunction()(tree, array);
-}
-function flattenTreeToArrayFunction(mapNodeFn) {
-  const mapNode = mapNodeFn !== null && mapNodeFn !== void 0 ? mapNodeFn : x => x;
-  const flattenFn = (tree, array = []) => {
-    array.push(mapNode(tree));
-    if (tree.children) {
-      tree.children.forEach(x => flattenFn(x, array));
+function handlerBindAccessor(boundTo, accessor) {
+  return {
+    accessor,
+    boundTo,
+    set: (key, handle) => {
+      accessor.bindSet(boundTo, key, handle);
     }
-    return array;
   };
-  return flattenFn;
-}
-/**
- * Convenience function for flattening multiple trees with a flatten function.
- *
- * @param trees
- * @param flattenFn
- * @returns
- */
-function flattenTrees(trees, flattenFn) {
-  const array = [];
-  trees.forEach(x => flattenFn(x, array));
-  return array;
 }
-
-/*eslint @typescript-eslint/no-explicit-any:"off"*/
 /**
- * Creates an ExpandFlattenTree function.
+ * Creates a HandlerSetFunction.
  *
- * @param expand
- * @param flatten
+ * @param accessor
+ * @param key
  * @returns
  */
-function expandFlattenTreeFunction(expand, flatten) {
-  return values => {
-    return flattenTrees(expandTrees(values, expand), flatten);
+function handlerSetFunction(accessor, key) {
+  const fn = handlerFunction => {
+    accessor.set(key, handlerFunction); // set the handler on the pre-defined key.
   };
-}
 
-// MARK: Reduce
-function reduceBooleansWithAnd(array, emptyArrayValue) {
-  return reduceBooleansWithAndFn(emptyArrayValue)(array);
-}
-function reduceBooleansWithOr(array, emptyArrayValue) {
-  return reduceBooleansWithOrFn(emptyArrayValue)(array);
-}
-function reduceBooleansWithAndFn(emptyArrayValue) {
-  return reduceBooleansFn((a, b) => a && b, emptyArrayValue);
-}
-function reduceBooleansWithOrFn(emptyArrayValue) {
-  return reduceBooleansFn((a, b) => a || b, emptyArrayValue);
-}
-function reduceBooleansFn(reduceFn, emptyArrayValue) {
-  const rFn = array => Boolean(array.reduce(reduceFn));
-  if (emptyArrayValue != null) {
-    return array => array.length ? rFn(array) : emptyArrayValue;
-  } else {
-    return rFn;
-  }
-}
-/**
- * Creates a new BooleanFactory.
- *
- * @param config
- * @returns
- */
-function booleanFactory(config) {
-  const {
-    chance: inputChance
-  } = config;
-  const chance = inputChance / 100;
-  return () => {
-    const roll = Math.random();
-    const result = roll <= chance;
-    return result;
+  fn.key = key;
+  return fn;
+}
+function handlerMappedSetFunction(accessor, key, mapFn) {
+  const handlerSet = handlerSetFunction(accessor, key);
+  return handlerFunction => {
+    // set an intermediary function that calls the target function. We don't use an arrow function so we have access to the "this", if bound.
+    handlerSet(function (value) {
+      const mapped = mapFn(value); // fowards "this" to the next call.
+      return handlerFunction.call(this, mapped);
+    });
   };
 }
-/**
- * Returns a random boolean.
- *
- * @param chance Number between 0 and 100
- * @returns
- */
-function randomBoolean(chance = 50) {
-  return booleanFactory({
-    chance
-  })();
+function handlerMappedSetFunctionFactory(accessor, mapFn) {
+  return key => handlerMappedSetFunction(accessor, key, mapFn);
+}
+function handlerConfigurerFactory(config) {
+  return handler => {
+    return (bindTo, configure) => {
+      const accessor = handlerBindAccessor(bindTo, handler);
+      const configurer = config.configurerForAccessor(accessor);
+      configure(configurer);
+    };
+  };
 }
 
 /**
- * Returns the day of the week for the input day.
- *
- * Equivalent to date.getDay()
- *
- * @param date
- * @returns
+ * TypedServiceRegistry implementation.
  */
-function dayOfWeek(date) {
-  return date.getDay();
+class TypedServiceRegistryInstance {
+  constructor() {
+    this._map = new Map();
+  }
+  registerServiceForType(type, service) {
+    const getter = asGetter(service);
+    this._map.set(type, getter);
+  }
+  serviceForType(type) {
+    const getter = this._map.get(type);
+    const service = getter === null || getter === void 0 ? void 0 : getter();
+    if (service == null) {
+      throw new Error(`no service registered for type "${type}"`);
+    }
+    return service;
+  }
 }
 /**
- * Creates a DecisionFunction that checks whether or not the input day or days of
- *
- * @param allowedDaysOfWeek
+ * Creates a new TypedServiceRegistryInstance and registers the input types.
  * @returns
  */
-function isInAllowedDaysOfWeekSet(allowedDaysOfWeek) {
-  return isInSetDecisionFunction(allowedDaysOfWeek, x => {
-    return typeof x === 'number' ? x : dayOfWeek(x);
+function typedServiceRegistry(config) {
+  const instance = new TypedServiceRegistryInstance();
+  forEachKeyValue(config.services, {
+    forEach: ([key, service]) => {
+      instance.registerServiceForType(key, service);
+    }
   });
+  return instance;
 }
-/**
- * Returns all days of the week starting from the given day up to the specified number of days.
- *
- * Returns 7 days by default.
- *
- * @param startingOn
- */
-function daysOfWeekArray(startingOn = exports.Day.SUNDAY, maxDays = 7) {
-  const days = [];
-  let day = startingOn;
-  while (days.length < maxDays) {
-    days.push(day);
-    if (day === exports.Day.SATURDAY) {
-      day = exports.Day.SUNDAY;
-    } else {
-      day += 1;
-    }
+
+class StoredDataError extends makeError.BaseError {
+  constructor(message) {
+    super(message);
   }
-  return days;
 }
-/**
- * Enum for the days of the week.
- */
-exports.Day = void 0;
-(function (Day) {
-  Day[Day["SUNDAY"] = 0] = "SUNDAY";
-  Day[Day["MONDAY"] = 1] = "MONDAY";
-  Day[Day["TUESDAY"] = 2] = "TUESDAY";
-  Day[Day["WEDNESDAY"] = 3] = "WEDNESDAY";
-  Day[Day["THURSDAY"] = 4] = "THURSDAY";
-  Day[Day["FRIDAY"] = 5] = "FRIDAY";
-  Day[Day["SATURDAY"] = 6] = "SATURDAY";
-})(exports.Day || (exports.Day = {}));
-function enabledDaysFromDaysOfWeek(input) {
-  const set = new Set(input);
-  return {
-    sunday: set.has(exports.Day.SUNDAY),
-    monday: set.has(exports.Day.MONDAY),
-    tuesday: set.has(exports.Day.TUESDAY),
-    wednesday: set.has(exports.Day.WEDNESDAY),
-    thursday: set.has(exports.Day.THURSDAY),
-    friday: set.has(exports.Day.FRIDAY),
-    saturday: set.has(exports.Day.SATURDAY)
-  };
+class DataDoesNotExistError extends StoredDataError {
+  constructor(message) {
+    super(message);
+  }
 }
-function daysOfWeekFromEnabledDays(input) {
-  const daysOfWeek = [];
-  if (input) {
-    if (input.sunday) {
-      daysOfWeek.push(exports.Day.SUNDAY);
-    }
-    if (input.monday) {
-      daysOfWeek.push(exports.Day.MONDAY);
-    }
-    if (input.tuesday) {
-      daysOfWeek.push(exports.Day.TUESDAY);
-    }
-    if (input.wednesday) {
-      daysOfWeek.push(exports.Day.WEDNESDAY);
-    }
-    if (input.thursday) {
-      daysOfWeek.push(exports.Day.THURSDAY);
-    }
-    if (input.friday) {
-      daysOfWeek.push(exports.Day.FRIDAY);
+class DataIsExpiredError extends StoredDataError {
+  constructor(data, message) {
+    super(message);
+    this.data = data;
+  }
+}
+
+class MemoryStorageInstance {
+  constructor() {
+    this._length = 0;
+    this._storage = {};
+  }
+  get length() {
+    return this._length;
+  }
+  key(index) {
+    var _a;
+    return (_a = Object.keys(this._storage)[index]) !== null && _a !== void 0 ? _a : null;
+  }
+  hasKey(key) {
+    return objectHasKey(this._storage, key);
+  }
+  getItem(key) {
+    var _a;
+    return (_a = this._storage[key]) !== null && _a !== void 0 ? _a : null;
+  }
+  setItem(key, item) {
+    if (item == null) {
+      this.removeItem(key);
+    } else {
+      if (!this.hasKey(key)) {
+        this._length = this._length + 1;
+      }
+      this._storage[key] = String(item);
     }
-    if (input.saturday) {
-      daysOfWeek.push(exports.Day.SATURDAY);
+  }
+  removeItem(key) {
+    if (this.hasKey(key)) {
+      delete this._storage[key]; // Remove the property
+      this._length = this._length - 1;
     }
   }
-  return daysOfWeek;
+  clear() {
+    this._storage = {};
+    this._length = 0;
+  }
 }
+const SHARED_MEMORY_STORAGE = new MemoryStorageInstance();
+
 /**
- * Returns an array of strinsg with each day of the week named.
+ * Limited Class/Interface for storing string values synchronously.
+ */
+class SimpleStorageObject {}
+/**
+ * Synchronous Class/Interface for storing string values.
  *
- * @returns
+ * Has the same interface as localStorage for the web.
  */
-function getDaysOfWeekNames(sundayFirst = true, transform) {
-  const days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-  const sunday = 'Sunday';
-  let dayOfWeekNames;
-  if (sundayFirst) {
-    dayOfWeekNames = [sunday, ...days];
-  } else {
-    dayOfWeekNames = [...days, sunday];
-  }
-  if (transform != null) {
-    if (transform.abbreviation) {
-      dayOfWeekNames = dayOfWeekNames.map(x => x.slice(0, 3));
-    }
-    if (transform.uppercase) {
-      dayOfWeekNames = dayOfWeekNames.map(x => x.toUpperCase());
+class StorageObject extends SimpleStorageObject {}
+class FullStorageObject extends StorageObject {}
+class StorageObjectUtility {
+  static allKeysFromStorageObject(storageObject, prefix) {
+    const length = storageObject.length;
+    let result;
+    if (length > 0) {
+      result = range({
+        start: 0,
+        end: length
+      }).map(x => storageObject.key(x)).filter(hasNonNullValue);
+      if (prefix) {
+        result = result.filter(x => x.startsWith(prefix));
+      }
+    } else {
+      result = [];
     }
+    return result;
   }
-  return dayOfWeekNames;
-}
-function daysOfWeekNameMap(transform) {
-  const dayOfWeekNames = getDaysOfWeekNames(true, transform);
-  return new Map(dayOfWeekNames.map((x, i) => [i, x]));
-}
-function daysOfWeekNameFunction(transform) {
-  const map = daysOfWeekNameMap(transform);
-  return dayOfWeek => {
-    var _a;
-    return (_a = map.get(dayOfWeek)) !== null && _a !== void 0 ? _a : 'UNKNOWN';
-  };
-}
-function getDayTomorrow(day) {
-  return getNextDay(day, 1);
 }
-function getDayYesterday(day) {
-  return getPreviousDay(day, 1);
+
+/**
+ * Joins together various array of classes and only keeps the unique values.
+ *
+ * @param cssClasses
+ * @returns
+ */
+function spaceSeparatedCssClasses(cssClasses) {
+  let result = '';
+  if (cssClasses) {
+    const allClasses = cssClassesSet(cssClasses);
+    result = joinStringsWithSpaces(Array.from(allClasses));
+  }
+  return result;
 }
-function getDayOffset(day, days) {
-  if (days === 0) {
-    return day;
-  } else if (days < 0) {
-    return getPreviousDay(day, days);
+/**
+ * Joins together various array of classes and returns the set of unique CSS classes.
+ *
+ * @param cssClasses
+ * @returns
+ */
+function cssClassesSet(cssClasses) {
+  let result;
+  if (cssClasses) {
+    const arrayOfClasses = iterableToArray(cssClasses, false);
+    const arrayOfAllClassValues = arrayOfClasses.map(x => asArray(x).map(x => x.split(' ')).flat()).flat();
+    result = new Set(arrayOfAllClassValues);
   } else {
-    return getNextDay(day, days);
+    result = new Set();
   }
+  return result;
 }
-function getPreviousDay(day, days = 1) {
-  const offset = Math.abs(days) % 7;
-  const cap = 7 - offset;
-  return getNextDay(day, cap);
+
+/**
+ * Creates a SortByStringFunction that sorts values in ascending order.
+ */
+function sortByStringFunction(readStringFn) {
+  return (a, b) => {
+    const as = readStringFn(a);
+    const bs = readStringFn(b);
+    return as.localeCompare(bs);
+  };
 }
-function getNextDay(day, days = 1) {
-  let result = (day + days) % 7;
-  if (result < 0) {
-    result = 7 + result;
-  }
-  return result;
+const sortByLabelFunction = sortByStringFunction(x => x.label);
+
+/**
+ * Creates a SearchStringFilterFunction
+ *
+ * @param config
+ * @returns
+ */
+function searchStringFilterFunction(config) {
+  const {
+    readStrings,
+    decisionFactory = caseInsensitiveFilterByIndexOfDecisionFactory
+  } = typeof config === 'function' ? {
+    readStrings: config
+  } : config;
+  return (filterText, values) => {
+    const decision = decisionFactory(filterText);
+    return values.filter(value => {
+      const searchResult = readStrings(value);
+      let match = false;
+      if (Array.isArray(searchResult)) {
+        match = searchResult.findIndex(decision) !== -1;
+      } else if (searchResult != null) {
+        match = decision(searchResult);
+      }
+      return match;
+    });
+  };
 }
+/**
+ * SearchStringDecisionFunctionFactory that searches for string matches using the input search term/filter text.
+ *
+ * @param filterText
+ * @returns
+ */
+const caseInsensitiveFilterByIndexOfDecisionFactory = filterText => {
+  const searchString = filterText.toLocaleLowerCase();
+  return string => string.toLocaleLowerCase().indexOf(searchString) !== -1;
+};
 
-function timePeriodCounter(timePeriodLength, lastTimePeriodStart) {
-  function reset(inputStart) {
-    const start = inputStart !== null && inputStart !== void 0 ? inputStart : new Date();
-    fn._timePeriodCount = 0;
-    fn._lastTimePeriodStart = start;
-    fn._nextTimePeriodEnd = new Date(start.getTime() + timePeriodLength);
-    return fn._nextTimePeriodEnd;
-  }
-  const fn = () => {
-    const now = new Date();
-    if (now > fn._nextTimePeriodEnd) {
-      reset(now);
-    } else {
-      fn._timePeriodCount += 1;
-    }
-    return fn._timePeriodCount;
+const SPLIT_STRING_TREE_NODE_ROOT_VALUE = '';
+/**
+ * Creates a SplitStringTreeFactory with the configured splitter.
+ *
+ * @param config
+ * @returns
+ */
+function splitStringTreeFactory(config) {
+  const {
+    separator
+  } = config;
+  const fn = (input, existing) => {
+    const {
+      leafMeta,
+      nodeMeta,
+      values
+    } = input;
+    const result = existing !== null && existing !== void 0 ? existing : {
+      fullValue: SPLIT_STRING_TREE_NODE_ROOT_VALUE,
+      nodeValue: SPLIT_STRING_TREE_NODE_ROOT_VALUE,
+      children: {}
+    };
+    asArray(values).forEach(value => {
+      addToSplitStringTree(result, {
+        value,
+        leafMeta,
+        nodeMeta
+      }, config);
+    });
+    return result;
   };
-  fn._timePeriodLength = timePeriodLength;
-  reset(lastTimePeriodStart);
-  fn._timePeriodCount = -1;
-  fn._reset = reset;
+  fn._separator = separator;
   return fn;
 }
-class TimerCancelledError extends makeError.BaseError {
-  constructor() {
-    super(`The timer was destroyed before it was completed.`);
+function applySplitStringTreeWithMultipleValues(input) {
+  const {
+    entries,
+    factory,
+    existing
+  } = input;
+  let result = existing;
+  entries.forEach(entry => {
+    result = factory(entry, result);
+  });
+  if (!result) {
+    result = factory({
+      values: []
+    });
   }
+  return result;
 }
-class TimerInstance {
-  constructor(duration, startImmediately = true) {
-    this._createdAt = new Date();
-    this._startedAt = new Date();
-    this._state = 'paused';
-    this._promiseRef = promiseReference();
-    this._duration = duration;
-    if (startImmediately) {
-      this.start();
-      this._startedAt = this._createdAt;
-    }
-  }
-  get state() {
-    return this._state;
-  }
-  get createdAt() {
-    return this._createdAt;
-  }
-  get pausedAt() {
-    return this._pausedAt;
-  }
-  get startedAt() {
-    return this._startedAt;
-  }
-  get promise() {
-    return this._promiseRef.promise;
-  }
-  get duration() {
-    return this._duration;
-  }
-  get durationRemaining() {
-    let remaining;
-    switch (this._state) {
-      case 'complete':
-        remaining = 0;
-        break;
-      case 'running':
-        remaining = Math.max(0, this._duration - (new Date().getTime() - this._startedAt.getTime()));
-        break;
-      case 'paused':
-        remaining = null;
-        break;
-    }
-    return remaining;
-  }
-  start() {
-    if (this._state === 'paused') {
-      this._state = 'running';
-      this._startedAt = new Date();
-      this._enqueueCheck();
-    }
-  }
-  stop() {
-    if (this._state === 'running') {
-      this._state = 'paused';
-      this._pausedAt = new Date();
-    }
-  }
-  reset() {
-    if (this._state !== 'complete') {
-      this._state = 'running';
-      this._startedAt = new Date();
-      this._enqueueCheck();
-    }
-  }
-  setDuration(duration) {
-    this._duration = duration;
-  }
-  destroy() {
-    this._checkComplete();
-    if (this._state === 'running') {
-      const error = new TimerCancelledError();
-      this._promiseRef.reject(error);
-      this._state = 'complete'; // mark as complete
+/**
+ * Adds a value to the target SplitStringTree.
+ *
+ * @param tree
+ * @param value
+ * @param separator
+ * @returns
+ */
+function addToSplitStringTree(tree, inputValue, config) {
+  const {
+    separator,
+    mergeMeta
+  } = config;
+  const {
+    value,
+    leafMeta,
+    nodeMeta
+  } = inputValue;
+  function nextMeta(node, nextMeta) {
+    if (mergeMeta && node.meta != null) {
+      return mergeMeta(node.meta, nextMeta);
+    } else {
+      return nextMeta;
     }
   }
-
-  _checkComplete() {
-    if (this._state !== 'complete' && this.durationRemaining === 0) {
-      this._state = 'complete';
-      this._promiseRef.resolve();
+  const parts = value.split(separator);
+  let currentNode = tree;
+  parts.forEach(nodeValue => {
+    const existingChildNode = currentNode.children[nodeValue];
+    const childNode = existingChildNode !== null && existingChildNode !== void 0 ? existingChildNode : {
+      nodeValue,
+      children: {}
+    }; // use the existing node or create a new node
+    if (!existingChildNode) {
+      childNode.fullValue = currentNode.fullValue ? currentNode.fullValue + separator + nodeValue : nodeValue;
+      currentNode.children[nodeValue] = childNode;
     }
-  }
-  _enqueueCheck() {
-    const durationRemaining = this.durationRemaining;
-    if (durationRemaining != null && this._state !== 'complete') {
-      setTimeout(() => {
-        this._checkComplete();
-        this._enqueueCheck();
-      }, durationRemaining);
+    // add the meta to the node
+    if (nodeMeta != null) {
+      childNode.meta = nextMeta(childNode, nodeMeta);
     }
+    currentNode = childNode;
+  });
+  // add the meta to the leaf node
+  if (leafMeta != null) {
+    currentNode.meta = nextMeta(currentNode, leafMeta);
   }
+  return tree;
 }
-function timer(duration, startNow = true) {
-  return new TimerInstance(duration, startNow);
+// MARK: Search
+/**
+ * Returns the best match for the value in the tree, including the input tree value.
+ *
+ * Only returns a result if there is match of any kind.
+ *
+ * @param tree
+ * @param value
+ * @returns
+ */
+function findBestSplitStringTreeMatch(tree, value) {
+  return lastValue(findBestSplitStringTreeMatchPath(tree, value));
 }
 /**
- * Toggles the input Timer's running state.
+ * Returns the best match for the value in the true, excluding the input tree value.
  *
- * @param timer
- * @param toggleRun
+ * Only returns a result if there is match of any kind.
+ *
+ * @param tree
+ * @param value
+ * @returns
  */
-function toggleTimerRunning(timer, toggleRun) {
-  toggleRun = toggleRun != null ? toggleRun : timer.state !== 'running';
-  if (toggleRun) {
-    timer.start();
-  } else {
-    timer.stop();
-  }
+function findBestSplitStringTreeChildMatch(tree, value) {
+  return lastValue(findBestSplitStringTreeChildMatchPath(tree, value));
 }
 /**
- * Returns the approximate end date of the given timer. If a timer is already complete, it returns the time for now.
+ * Returns the best match for the value in the tree, including the input tree value.
+ *
+ * Only returns a result if there is match of any kind.
+ *
+ * @param tree
+ * @param value
+ * @returns
  */
-function approximateTimerEndDate(timer) {
-  const durationRemaining = timer.durationRemaining;
-  if (durationRemaining != null) {
-    return new Date(Date.now() + durationRemaining);
-  } else {
-    return null;
+function findBestSplitStringTreeMatchPath(tree, value) {
+  let bestResult = findBestSplitStringTreeChildMatchPath(tree, value);
+  if (!bestResult && tree.fullValue && value.startsWith(tree.fullValue)) {
+    bestResult = [tree];
   }
+  return bestResult;
+}
+/**
+ * Returns the best match for the value in the true, excluding the input tree value.
+ *
+ * Only returns a result if there is match of any kind.
+ *
+ * @param tree
+ * @param value
+ * @returns
+ */
+function findBestSplitStringTreeChildMatchPath(tree, value) {
+  const {
+    children
+  } = tree;
+  let bestMatchPath;
+  Object.entries(children).find(([_, child]) => {
+    var _a;
+    let stopScan = false;
+    if (value.startsWith(child.fullValue)) {
+      const bestChildPath = (_a = findBestSplitStringTreeChildMatchPath(child, value)) !== null && _a !== void 0 ? _a : [];
+      bestMatchPath = [child, ...bestChildPath];
+      stopScan = true;
+    }
+    return stopScan;
+  });
+  return bestMatchPath;
 }
 
-exports.TimeAM = void 0;
-(function (TimeAM) {
-  TimeAM["AM"] = "AM";
-  TimeAM["PM"] = "PM";
-})(exports.TimeAM || (exports.TimeAM = {}));
-const DATE_NOW_VALUE = 'now';
-function dateFromLogicalDate(logicalDate) {
-  let result;
-  if (typeof logicalDate === 'string') {
-    switch (logicalDate.toLocaleLowerCase()) {
-      case DATE_NOW_VALUE:
-        result = new Date();
-        break;
-      default:
-        throw new Error(`Unknown logical date string "${logicalDate}"`);
+/*eslint @typescript-eslint/no-explicit-any:"off"*/
+// any is used with intent here, as the recursive TreeNode value requires its use to terminate.
+function expandTreeFunction(config) {
+  var _a;
+  const makeNode = (_a = config.makeNode) !== null && _a !== void 0 ? _a : node => node;
+  const expandFn = (value, parent) => {
+    const depth = parent ? parent.depth + 1 : 0;
+    const treeNode = {
+      depth,
+      parent,
+      value
+    };
+    const node = makeNode(treeNode);
+    const childrenValues = config.getChildren(value);
+    node.children = childrenValues ? childrenValues.map(x => expandFn(x, node)) : undefined;
+    return node;
+  };
+  return root => expandFn(root);
+}
+/**
+ * Convenience function for expanding multiple values into trees then merging them together into a single array.
+ *
+ * @param values
+ * @param expandFn
+ * @returns
+ */
+function expandTrees(values, expandFn) {
+  return values.map(expandFn);
+}
+
+/**
+ * Traverses the tree and flattens it into all tree nodes.
+ */
+function flattenTree(tree) {
+  return flattenTreeToArray(tree, []);
+}
+/**
+ * Traverses the tree and pushes the nodes into the input array.
+ *
+ * @param tree
+ * @param array
+ * @returns
+ */
+function flattenTreeToArray(tree, array) {
+  return flattenTreeToArrayFunction()(tree, array);
+}
+function flattenTreeToArrayFunction(mapNodeFn) {
+  const mapNode = mapNodeFn !== null && mapNodeFn !== void 0 ? mapNodeFn : x => x;
+  const flattenFn = (tree, array = []) => {
+    array.push(mapNode(tree));
+    if (tree.children) {
+      tree.children.forEach(x => flattenFn(x, array));
     }
+    return array;
+  };
+  return flattenFn;
+}
+/**
+ * Convenience function for flattening multiple trees with a flatten function.
+ *
+ * @param trees
+ * @param flattenFn
+ * @returns
+ */
+function flattenTrees(trees, flattenFn) {
+  const array = [];
+  trees.forEach(x => flattenFn(x, array));
+  return array;
+}
+
+/*eslint @typescript-eslint/no-explicit-any:"off"*/
+/**
+ * Creates an ExpandFlattenTree function.
+ *
+ * @param expand
+ * @param flatten
+ * @returns
+ */
+function expandFlattenTreeFunction(expand, flatten) {
+  return values => {
+    return flattenTrees(expandTrees(values, expand), flatten);
+  };
+}
+
+// MARK: Reduce
+function reduceBooleansWithAnd(array, emptyArrayValue) {
+  return reduceBooleansWithAndFn(emptyArrayValue)(array);
+}
+function reduceBooleansWithOr(array, emptyArrayValue) {
+  return reduceBooleansWithOrFn(emptyArrayValue)(array);
+}
+function reduceBooleansWithAndFn(emptyArrayValue) {
+  return reduceBooleansFn((a, b) => a && b, emptyArrayValue);
+}
+function reduceBooleansWithOrFn(emptyArrayValue) {
+  return reduceBooleansFn((a, b) => a || b, emptyArrayValue);
+}
+function reduceBooleansFn(reduceFn, emptyArrayValue) {
+  const rFn = array => Boolean(array.reduce(reduceFn));
+  if (emptyArrayValue != null) {
+    return array => array.length ? rFn(array) : emptyArrayValue;
   } else {
-    result = logicalDate;
+    return rFn;
   }
-  return result;
 }
-function isLogicalDateStringCode(logicalDate) {
-  let isLogicalDateStringCode = false;
-  if (typeof logicalDate === 'string') {
-    switch (logicalDate.toLocaleLowerCase()) {
-      case DATE_NOW_VALUE:
-        isLogicalDateStringCode = true;
-        break;
-    }
-  }
-  return isLogicalDateStringCode;
+/**
+ * Creates a new BooleanFactory.
+ *
+ * @param config
+ * @returns
+ */
+function booleanFactory(config) {
+  const {
+    chance: inputChance
+  } = config;
+  const chance = inputChance / 100;
+  return () => {
+    const roll = Math.random();
+    const result = roll <= chance;
+    return result;
+  };
+}
+/**
+ * Returns a random boolean.
+ *
+ * @param chance Number between 0 and 100
+ * @returns
+ */
+function randomBoolean(chance = 50) {
+  return booleanFactory({
+    chance
+  })();
 }
 
 /**
@@ -14453,7 +14550,9 @@ function isFinalPage(page) {
 }
 
 /**
- * Page calcuaktion context for calculating the amount to skip/etc.
+ * Page calculation context for calculating the amount to skip/etc.
+ *
+ * @deprecated
  */
 class PageCalculator {
   constructor(config) {
@@ -14783,6 +14882,7 @@ exports.encodeBitwiseSet = encodeBitwiseSet;
 exports.encodeModelKeyTypePair = encodeModelKeyTypePair;
 exports.errorMessageContainsString = errorMessageContainsString;
 exports.errorMessageContainsStringFunction = errorMessageContainsStringFunction;
+exports.escapeStringCharactersFunction = escapeStringCharactersFunction;
 exports.escapeStringForRegex = escapeStringForRegex;
 exports.excludeValues = excludeValues;
 exports.excludeValuesFromArray = excludeValuesFromArray;
@@ -14924,6 +15024,7 @@ exports.isE164PhoneNumber = isE164PhoneNumber;
 exports.isE164PhoneNumberWithExtension = isE164PhoneNumberWithExtension;
 exports.isEmptyIterable = isEmptyIterable;
 exports.isEqualContext = isEqualContext;
+exports.isEqualDate = isEqualDate;
 exports.isEqualToValueDecisionFunction = isEqualToValueDecisionFunction;
 exports.isEvenNumber = isEvenNumber;
 exports.isFalseBooleanKeyArray = isFalseBooleanKeyArray;
@@ -15289,6 +15390,7 @@ exports.startOfDayForUTCDateInUTC = startOfDayForUTCDateInUTC;
 exports.stepsFromIndex = stepsFromIndex;
 exports.stepsFromIndexFunction = stepsFromIndexFunction;
 exports.stringCharactersToIndexRecord = stringCharactersToIndexRecord;
+exports.stringContains = stringContains;
 exports.stringFactoryFromFactory = stringFactoryFromFactory;
 exports.stringToLowercaseFunction = stringToLowercaseFunction;
 exports.stringToUppercaseFunction = stringToUppercaseFunction;