@nsshunt/stsobservability 1.0.92 → 1.0.94

package/dist/stsobservability.mjs

@@ -1197,675 +1197,696 @@ SetVal_fn4 = function(updatedValue) {
     __privateSet(this, _start, performance.now() - updatedValue);
   }
 };
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var timsort$1 = {};
-(function(exports) {
-  (function(global2, factory) {
-    {
-      factory(exports);
-    }
-  })(commonjsGlobal, function(exports2) {
-    exports2.__esModule = true;
-    exports2.sort = sort;
-    function _classCallCheck(instance, Constructor) {
-      if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-      }
-    }
-    var DEFAULT_MIN_MERGE = 32;
-    var DEFAULT_MIN_GALLOPING = 7;
-    var DEFAULT_TMP_STORAGE_LENGTH = 256;
-    var POWERS_OF_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9];
-    function log10(x) {
-      if (x < 1e5) {
-        if (x < 100) {
-          return x < 10 ? 0 : 1;
-        }
-        if (x < 1e4) {
-          return x < 1e3 ? 2 : 3;
+var hasRequiredTimsort$1;
+function requireTimsort$1() {
+  if (hasRequiredTimsort$1) return timsort$1;
+  hasRequiredTimsort$1 = 1;
+  (function(exports) {
+    (function(global, factory) {
+      {
+        factory(exports);
+      }
+    })(timsort$1, function(exports2) {
+      exports2.__esModule = true;
+      exports2.sort = sort;
+      function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) {
+          throw new TypeError("Cannot call a class as a function");
         }
-        return 4;
-      }
-      if (x < 1e7) {
-        return x < 1e6 ? 5 : 6;
-      }
-      if (x < 1e9) {
-        return x < 1e8 ? 7 : 8;
-      }
-      return 9;
-    }
-    function alphabeticalCompare(a, b) {
-      if (a === b) {
-        return 0;
       }
-      if (~~a === a && ~~b === b) {
-        if (a === 0 || b === 0) {
-          return a < b ? -1 : 1;
-        }
-        if (a < 0 || b < 0) {
-          if (b >= 0) {
-            return -1;
+      var DEFAULT_MIN_MERGE = 32;
+      var DEFAULT_MIN_GALLOPING = 7;
+      var DEFAULT_TMP_STORAGE_LENGTH = 256;
+      var POWERS_OF_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9];
+      function log10(x) {
+        if (x < 1e5) {
+          if (x < 100) {
+            return x < 10 ? 0 : 1;
           }
-          if (a >= 0) {
-            return 1;
+          if (x < 1e4) {
+            return x < 1e3 ? 2 : 3;
           }
-          a = -a;
-          b = -b;
+          return 4;
         }
-        var al = log10(a);
-        var bl = log10(b);
-        var t = 0;
-        if (al < bl) {
-          a *= POWERS_OF_TEN[bl - al - 1];
-          b /= 10;
-          t = -1;
-        } else if (al > bl) {
-          b *= POWERS_OF_TEN[al - bl - 1];
-          a /= 10;
-          t = 1;
+        if (x < 1e7) {
+          return x < 1e6 ? 5 : 6;
         }
-        if (a === b) {
-          return t;
+        if (x < 1e9) {
+          return x < 1e8 ? 7 : 8;
         }
-        return a < b ? -1 : 1;
+        return 9;
       }
-      var aStr = String(a);
-      var bStr = String(b);
-      if (aStr === bStr) {
-        return 0;
-      }
-      return aStr < bStr ? -1 : 1;
-    }
-    function minRunLength(n) {
-      var r = 0;
-      while (n >= DEFAULT_MIN_MERGE) {
-        r |= n & 1;
-        n >>= 1;
-      }
-      return n + r;
-    }
-    function makeAscendingRun(array, lo, hi, compare) {
-      var runHi = lo + 1;
-      if (runHi === hi) {
-        return 1;
-      }
-      if (compare(array[runHi++], array[lo]) < 0) {
-        while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) {
-          runHi++;
+      function alphabeticalCompare(a, b) {
+        if (a === b) {
+          return 0;
         }
-        reverseRun(array, lo, runHi);
-      } else {
-        while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) {
-          runHi++;
+        if (~~a === a && ~~b === b) {
+          if (a === 0 || b === 0) {
+            return a < b ? -1 : 1;
+          }
+          if (a < 0 || b < 0) {
+            if (b >= 0) {
+              return -1;
+            }
+            if (a >= 0) {
+              return 1;
+            }
+            a = -a;
+            b = -b;
+          }
+          var al = log10(a);
+          var bl = log10(b);
+          var t = 0;
+          if (al < bl) {
+            a *= POWERS_OF_TEN[bl - al - 1];
+            b /= 10;
+            t = -1;
+          } else if (al > bl) {
+            b *= POWERS_OF_TEN[al - bl - 1];
+            a /= 10;
+            t = 1;
+          }
+          if (a === b) {
+            return t;
+          }
+          return a < b ? -1 : 1;
         }
+        var aStr = String(a);
+        var bStr = String(b);
+        if (aStr === bStr) {
+          return 0;
+        }
+        return aStr < bStr ? -1 : 1;
       }
-      return runHi - lo;
-    }
-    function reverseRun(array, lo, hi) {
-      hi--;
-      while (lo < hi) {
-        var t = array[lo];
-        array[lo++] = array[hi];
-        array[hi--] = t;
-      }
-    }
-    function binaryInsertionSort(array, lo, hi, start, compare) {
-      if (start === lo) {
-        start++;
+      function minRunLength(n) {
+        var r = 0;
+        while (n >= DEFAULT_MIN_MERGE) {
+          r |= n & 1;
+          n >>= 1;
+        }
+        return n + r;
       }
-      for (; start < hi; start++) {
-        var pivot = array[start];
-        var left = lo;
-        var right = start;
-        while (left < right) {
-          var mid = left + right >>> 1;
-          if (compare(pivot, array[mid]) < 0) {
-            right = mid;
-          } else {
-            left = mid + 1;
+      function makeAscendingRun(array, lo, hi, compare) {
+        var runHi = lo + 1;
+        if (runHi === hi) {
+          return 1;
+        }
+        if (compare(array[runHi++], array[lo]) < 0) {
+          while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) {
+            runHi++;
+          }
+          reverseRun(array, lo, runHi);
+        } else {
+          while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) {
+            runHi++;
           }
         }
-        var n = start - left;
-        switch (n) {
-          case 3:
-            array[left + 3] = array[left + 2];
-          case 2:
-            array[left + 2] = array[left + 1];
-          case 1:
-            array[left + 1] = array[left];
-            break;
-          default:
-            while (n > 0) {
-              array[left + n] = array[left + n - 1];
-              n--;
-            }
+        return runHi - lo;
+      }
+      function reverseRun(array, lo, hi) {
+        hi--;
+        while (lo < hi) {
+          var t = array[lo];
+          array[lo++] = array[hi];
+          array[hi--] = t;
         }
-        array[left] = pivot;
-      }
-    }
-    function gallopLeft(value, array, start, length, hint, compare) {
-      var lastOffset = 0;
-      var maxOffset = 0;
-      var offset = 1;
-      if (compare(value, array[start + hint]) > 0) {
-        maxOffset = length - hint;
-        while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
-          lastOffset = offset;
-          offset = (offset << 1) + 1;
-          if (offset <= 0) {
-            offset = maxOffset;
-          }
+      }
+      function binaryInsertionSort(array, lo, hi, start, compare) {
+        if (start === lo) {
+          start++;
         }
-        if (offset > maxOffset) {
-          offset = maxOffset;
+        for (; start < hi; start++) {
+          var pivot = array[start];
+          var left = lo;
+          var right = start;
+          while (left < right) {
+            var mid = left + right >>> 1;
+            if (compare(pivot, array[mid]) < 0) {
+              right = mid;
+            } else {
+              left = mid + 1;
+            }
+          }
+          var n = start - left;
+          switch (n) {
+            case 3:
+              array[left + 3] = array[left + 2];
+            case 2:
+              array[left + 2] = array[left + 1];
+            case 1:
+              array[left + 1] = array[left];
+              break;
+            default:
+              while (n > 0) {
+                array[left + n] = array[left + n - 1];
+                n--;
+              }
+          }
+          array[left] = pivot;
         }
-        lastOffset += hint;
-        offset += hint;
-      } else {
-        maxOffset = hint + 1;
-        while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
-          lastOffset = offset;
-          offset = (offset << 1) + 1;
-          if (offset <= 0) {
+      }
+      function gallopLeft(value, array, start, length, hint, compare) {
+        var lastOffset = 0;
+        var maxOffset = 0;
+        var offset = 1;
+        if (compare(value, array[start + hint]) > 0) {
+          maxOffset = length - hint;
+          while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
+            lastOffset = offset;
+            offset = (offset << 1) + 1;
+            if (offset <= 0) {
+              offset = maxOffset;
+            }
+          }
+          if (offset > maxOffset) {
             offset = maxOffset;
           }
-        }
-        if (offset > maxOffset) {
-          offset = maxOffset;
-        }
-        var tmp = lastOffset;
-        lastOffset = hint - offset;
-        offset = hint - tmp;
-      }
-      lastOffset++;
-      while (lastOffset < offset) {
-        var m = lastOffset + (offset - lastOffset >>> 1);
-        if (compare(value, array[start + m]) > 0) {
-          lastOffset = m + 1;
+          lastOffset += hint;
+          offset += hint;
         } else {
-          offset = m;
-        }
-      }
-      return offset;
-    }
-    function gallopRight(value, array, start, length, hint, compare) {
-      var lastOffset = 0;
-      var maxOffset = 0;
-      var offset = 1;
-      if (compare(value, array[start + hint]) < 0) {
-        maxOffset = hint + 1;
-        while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
-          lastOffset = offset;
-          offset = (offset << 1) + 1;
-          if (offset <= 0) {
+          maxOffset = hint + 1;
+          while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
+            lastOffset = offset;
+            offset = (offset << 1) + 1;
+            if (offset <= 0) {
+              offset = maxOffset;
+            }
+          }
+          if (offset > maxOffset) {
             offset = maxOffset;
           }
+          var tmp = lastOffset;
+          lastOffset = hint - offset;
+          offset = hint - tmp;
         }
-        if (offset > maxOffset) {
-          offset = maxOffset;
+        lastOffset++;
+        while (lastOffset < offset) {
+          var m = lastOffset + (offset - lastOffset >>> 1);
+          if (compare(value, array[start + m]) > 0) {
+            lastOffset = m + 1;
+          } else {
+            offset = m;
+          }
         }
-        var tmp = lastOffset;
-        lastOffset = hint - offset;
-        offset = hint - tmp;
-      } else {
-        maxOffset = length - hint;
-        while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
-          lastOffset = offset;
-          offset = (offset << 1) + 1;
-          if (offset <= 0) {
+        return offset;
+      }
+      function gallopRight(value, array, start, length, hint, compare) {
+        var lastOffset = 0;
+        var maxOffset = 0;
+        var offset = 1;
+        if (compare(value, array[start + hint]) < 0) {
+          maxOffset = hint + 1;
+          while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
+            lastOffset = offset;
+            offset = (offset << 1) + 1;
+            if (offset <= 0) {
+              offset = maxOffset;
+            }
+          }
+          if (offset > maxOffset) {
             offset = maxOffset;
           }
-        }
-        if (offset > maxOffset) {
-          offset = maxOffset;
-        }
-        lastOffset += hint;
-        offset += hint;
-      }
-      lastOffset++;
-      while (lastOffset < offset) {
-        var m = lastOffset + (offset - lastOffset >>> 1);
-        if (compare(value, array[start + m]) < 0) {
-          offset = m;
+          var tmp = lastOffset;
+          lastOffset = hint - offset;
+          offset = hint - tmp;
         } else {
-          lastOffset = m + 1;
-        }
-      }
-      return offset;
-    }
-    var TimSort = function() {
-      function TimSort2(array, compare) {
-        _classCallCheck(this, TimSort2);
-        this.array = null;
-        this.compare = null;
-        this.minGallop = DEFAULT_MIN_GALLOPING;
-        this.length = 0;
-        this.tmpStorageLength = DEFAULT_TMP_STORAGE_LENGTH;
-        this.stackLength = 0;
-        this.runStart = null;
-        this.runLength = null;
-        this.stackSize = 0;
-        this.array = array;
-        this.compare = compare;
-        this.length = array.length;
-        if (this.length < 2 * DEFAULT_TMP_STORAGE_LENGTH) {
-          this.tmpStorageLength = this.length >>> 1;
-        }
-        this.tmp = new Array(this.tmpStorageLength);
-        this.stackLength = this.length < 120 ? 5 : this.length < 1542 ? 10 : this.length < 119151 ? 19 : 40;
-        this.runStart = new Array(this.stackLength);
-        this.runLength = new Array(this.stackLength);
-      }
-      TimSort2.prototype.pushRun = function pushRun(runStart, runLength) {
-        this.runStart[this.stackSize] = runStart;
-        this.runLength[this.stackSize] = runLength;
-        this.stackSize += 1;
-      };
-      TimSort2.prototype.mergeRuns = function mergeRuns() {
-        while (this.stackSize > 1) {
-          var n = this.stackSize - 2;
-          if (n >= 1 && this.runLength[n - 1] <= this.runLength[n] + this.runLength[n + 1] || n >= 2 && this.runLength[n - 2] <= this.runLength[n] + this.runLength[n - 1]) {
-            if (this.runLength[n - 1] < this.runLength[n + 1]) {
-              n--;
+          maxOffset = length - hint;
+          while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
+            lastOffset = offset;
+            offset = (offset << 1) + 1;
+            if (offset <= 0) {
+              offset = maxOffset;
             }
-          } else if (this.runLength[n] > this.runLength[n + 1]) {
-            break;
           }
-          this.mergeAt(n);
-        }
-      };
-      TimSort2.prototype.forceMergeRuns = function forceMergeRuns() {
-        while (this.stackSize > 1) {
-          var n = this.stackSize - 2;
-          if (n > 0 && this.runLength[n - 1] < this.runLength[n + 1]) {
-            n--;
+          if (offset > maxOffset) {
+            offset = maxOffset;
           }
-          this.mergeAt(n);
-        }
-      };
-      TimSort2.prototype.mergeAt = function mergeAt(i) {
-        var compare = this.compare;
-        var array = this.array;
-        var start1 = this.runStart[i];
-        var length1 = this.runLength[i];
-        var start2 = this.runStart[i + 1];
-        var length2 = this.runLength[i + 1];
-        this.runLength[i] = length1 + length2;
-        if (i === this.stackSize - 3) {
-          this.runStart[i + 1] = this.runStart[i + 2];
-          this.runLength[i + 1] = this.runLength[i + 2];
-        }
-        this.stackSize--;
-        var k = gallopRight(array[start2], array, start1, length1, 0, compare);
-        start1 += k;
-        length1 -= k;
-        if (length1 === 0) {
-          return;
-        }
-        length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
-        if (length2 === 0) {
-          return;
+          lastOffset += hint;
+          offset += hint;
         }
-        if (length1 <= length2) {
-          this.mergeLow(start1, length1, start2, length2);
-        } else {
-          this.mergeHigh(start1, length1, start2, length2);
+        lastOffset++;
+        while (lastOffset < offset) {
+          var m = lastOffset + (offset - lastOffset >>> 1);
+          if (compare(value, array[start + m]) < 0) {
+            offset = m;
+          } else {
+            lastOffset = m + 1;
+          }
         }
-      };
-      TimSort2.prototype.mergeLow = function mergeLow(start1, length1, start2, length2) {
-        var compare = this.compare;
-        var array = this.array;
-        var tmp = this.tmp;
-        var i = 0;
-        for (i = 0; i < length1; i++) {
-          tmp[i] = array[start1 + i];
+        return offset;
+      }
+      var TimSort = function() {
+        function TimSort2(array, compare) {
+          _classCallCheck(this, TimSort2);
+          this.array = null;
+          this.compare = null;
+          this.minGallop = DEFAULT_MIN_GALLOPING;
+          this.length = 0;
+          this.tmpStorageLength = DEFAULT_TMP_STORAGE_LENGTH;
+          this.stackLength = 0;
+          this.runStart = null;
+          this.runLength = null;
+          this.stackSize = 0;
+          this.array = array;
+          this.compare = compare;
+          this.length = array.length;
+          if (this.length < 2 * DEFAULT_TMP_STORAGE_LENGTH) {
+            this.tmpStorageLength = this.length >>> 1;
+          }
+          this.tmp = new Array(this.tmpStorageLength);
+          this.stackLength = this.length < 120 ? 5 : this.length < 1542 ? 10 : this.length < 119151 ? 19 : 40;
+          this.runStart = new Array(this.stackLength);
+          this.runLength = new Array(this.stackLength);
         }
-        var cursor1 = 0;
-        var cursor2 = start2;
-        var dest = start1;
-        array[dest++] = array[cursor2++];
-        if (--length2 === 0) {
+        TimSort2.prototype.pushRun = function pushRun(runStart, runLength) {
+          this.runStart[this.stackSize] = runStart;
+          this.runLength[this.stackSize] = runLength;
+          this.stackSize += 1;
+        };
+        TimSort2.prototype.mergeRuns = function mergeRuns() {
+          while (this.stackSize > 1) {
+            var n = this.stackSize - 2;
+            if (n >= 1 && this.runLength[n - 1] <= this.runLength[n] + this.runLength[n + 1] || n >= 2 && this.runLength[n - 2] <= this.runLength[n] + this.runLength[n - 1]) {
+              if (this.runLength[n - 1] < this.runLength[n + 1]) {
+                n--;
+              }
+            } else if (this.runLength[n] > this.runLength[n + 1]) {
+              break;
+            }
+            this.mergeAt(n);
+          }
+        };
+        TimSort2.prototype.forceMergeRuns = function forceMergeRuns() {
+          while (this.stackSize > 1) {
+            var n = this.stackSize - 2;
+            if (n > 0 && this.runLength[n - 1] < this.runLength[n + 1]) {
+              n--;
+            }
+            this.mergeAt(n);
+          }
+        };
+        TimSort2.prototype.mergeAt = function mergeAt(i) {
+          var compare = this.compare;
+          var array = this.array;
+          var start1 = this.runStart[i];
+          var length1 = this.runLength[i];
+          var start2 = this.runStart[i + 1];
+          var length2 = this.runLength[i + 1];
+          this.runLength[i] = length1 + length2;
+          if (i === this.stackSize - 3) {
+            this.runStart[i + 1] = this.runStart[i + 2];
+            this.runLength[i + 1] = this.runLength[i + 2];
+          }
+          this.stackSize--;
+          var k = gallopRight(array[start2], array, start1, length1, 0, compare);
+          start1 += k;
+          length1 -= k;
+          if (length1 === 0) {
+            return;
+          }
+          length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
+          if (length2 === 0) {
+            return;
+          }
+          if (length1 <= length2) {
+            this.mergeLow(start1, length1, start2, length2);
+          } else {
+            this.mergeHigh(start1, length1, start2, length2);
+          }
+        };
+        TimSort2.prototype.mergeLow = function mergeLow(start1, length1, start2, length2) {
+          var compare = this.compare;
+          var array = this.array;
+          var tmp = this.tmp;
+          var i = 0;
           for (i = 0; i < length1; i++) {
-            array[dest + i] = tmp[cursor1 + i];
+            tmp[i] = array[start1 + i];
           }
-          return;
-        }
-        if (length1 === 1) {
-          for (i = 0; i < length2; i++) {
-            array[dest + i] = array[cursor2 + i];
+          var cursor1 = 0;
+          var cursor2 = start2;
+          var dest = start1;
+          array[dest++] = array[cursor2++];
+          if (--length2 === 0) {
+            for (i = 0; i < length1; i++) {
+              array[dest + i] = tmp[cursor1 + i];
+            }
+            return;
           }
-          array[dest + length2] = tmp[cursor1];
-          return;
-        }
-        var minGallop = this.minGallop;
-        while (true) {
-          var count1 = 0;
-          var count2 = 0;
-          var exit = false;
-          do {
-            if (compare(array[cursor2], tmp[cursor1]) < 0) {
+          if (length1 === 1) {
+            for (i = 0; i < length2; i++) {
+              array[dest + i] = array[cursor2 + i];
+            }
+            array[dest + length2] = tmp[cursor1];
+            return;
+          }
+          var minGallop = this.minGallop;
+          while (true) {
+            var count1 = 0;
+            var count2 = 0;
+            var exit = false;
+            do {
+              if (compare(array[cursor2], tmp[cursor1]) < 0) {
+                array[dest++] = array[cursor2++];
+                count2++;
+                count1 = 0;
+                if (--length2 === 0) {
+                  exit = true;
+                  break;
+                }
+              } else {
+                array[dest++] = tmp[cursor1++];
+                count1++;
+                count2 = 0;
+                if (--length1 === 1) {
+                  exit = true;
+                  break;
+                }
+              }
+            } while ((count1 | count2) < minGallop);
+            if (exit) {
+              break;
+            }
+            do {
+              count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
+              if (count1 !== 0) {
+                for (i = 0; i < count1; i++) {
+                  array[dest + i] = tmp[cursor1 + i];
+                }
+                dest += count1;
+                cursor1 += count1;
+                length1 -= count1;
+                if (length1 <= 1) {
+                  exit = true;
+                  break;
+                }
+              }
               array[dest++] = array[cursor2++];
-              count2++;
-              count1 = 0;
               if (--length2 === 0) {
                 exit = true;
                 break;
               }
-            } else {
+              count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
+              if (count2 !== 0) {
+                for (i = 0; i < count2; i++) {
+                  array[dest + i] = array[cursor2 + i];
+                }
+                dest += count2;
+                cursor2 += count2;
+                length2 -= count2;
+                if (length2 === 0) {
+                  exit = true;
+                  break;
+                }
+              }
               array[dest++] = tmp[cursor1++];
-              count1++;
-              count2 = 0;
               if (--length1 === 1) {
                 exit = true;
                 break;
               }
-            }
-          } while ((count1 | count2) < minGallop);
-          if (exit) {
-            break;
-          }
-          do {
-            count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
-            if (count1 !== 0) {
-              for (i = 0; i < count1; i++) {
-                array[dest + i] = tmp[cursor1 + i];
-              }
-              dest += count1;
-              cursor1 += count1;
-              length1 -= count1;
-              if (length1 <= 1) {
-                exit = true;
-                break;
-              }
-            }
-            array[dest++] = array[cursor2++];
-            if (--length2 === 0) {
-              exit = true;
+              minGallop--;
+            } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+            if (exit) {
               break;
             }
-            count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
-            if (count2 !== 0) {
-              for (i = 0; i < count2; i++) {
-                array[dest + i] = array[cursor2 + i];
-              }
-              dest += count2;
-              cursor2 += count2;
-              length2 -= count2;
-              if (length2 === 0) {
-                exit = true;
-                break;
-              }
-            }
-            array[dest++] = tmp[cursor1++];
-            if (--length1 === 1) {
-              exit = true;
-              break;
+            if (minGallop < 0) {
+              minGallop = 0;
             }
-            minGallop--;
-          } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
-          if (exit) {
-            break;
-          }
-          if (minGallop < 0) {
-            minGallop = 0;
+            minGallop += 2;
           }
-          minGallop += 2;
-        }
-        this.minGallop = minGallop;
-        if (minGallop < 1) {
-          this.minGallop = 1;
-        }
-        if (length1 === 1) {
-          for (i = 0; i < length2; i++) {
-            array[dest + i] = array[cursor2 + i];
+          this.minGallop = minGallop;
+          if (minGallop < 1) {
+            this.minGallop = 1;
           }
-          array[dest + length2] = tmp[cursor1];
-        } else if (length1 === 0) {
-          throw new Error("mergeLow preconditions were not respected");
-        } else {
-          for (i = 0; i < length1; i++) {
-            array[dest + i] = tmp[cursor1 + i];
+          if (length1 === 1) {
+            for (i = 0; i < length2; i++) {
+              array[dest + i] = array[cursor2 + i];
+            }
+            array[dest + length2] = tmp[cursor1];
+          } else if (length1 === 0) {
+            throw new Error("mergeLow preconditions were not respected");
+          } else {
+            for (i = 0; i < length1; i++) {
+              array[dest + i] = tmp[cursor1 + i];
+            }
           }
-        }
-      };
-      TimSort2.prototype.mergeHigh = function mergeHigh(start1, length1, start2, length2) {
-        var compare = this.compare;
-        var array = this.array;
-        var tmp = this.tmp;
-        var i = 0;
-        for (i = 0; i < length2; i++) {
-          tmp[i] = array[start2 + i];
-        }
-        var cursor1 = start1 + length1 - 1;
-        var cursor2 = length2 - 1;
-        var dest = start2 + length2 - 1;
-        var customCursor = 0;
-        var customDest = 0;
-        array[dest--] = array[cursor1--];
-        if (--length1 === 0) {
-          customCursor = dest - (length2 - 1);
+        };
+        TimSort2.prototype.mergeHigh = function mergeHigh(start1, length1, start2, length2) {
+          var compare = this.compare;
+          var array = this.array;
+          var tmp = this.tmp;
+          var i = 0;
           for (i = 0; i < length2; i++) {
-            array[customCursor + i] = tmp[i];
+            tmp[i] = array[start2 + i];
           }
-          return;
-        }
-        if (length2 === 1) {
-          dest -= length1;
-          cursor1 -= length1;
-          customDest = dest + 1;
-          customCursor = cursor1 + 1;
-          for (i = length1 - 1; i >= 0; i--) {
-            array[customDest + i] = array[customCursor + i];
+          var cursor1 = start1 + length1 - 1;
+          var cursor2 = length2 - 1;
+          var dest = start2 + length2 - 1;
+          var customCursor = 0;
+          var customDest = 0;
+          array[dest--] = array[cursor1--];
+          if (--length1 === 0) {
+            customCursor = dest - (length2 - 1);
+            for (i = 0; i < length2; i++) {
+              array[customCursor + i] = tmp[i];
+            }
+            return;
           }
-          array[dest] = tmp[cursor2];
-          return;
-        }
-        var minGallop = this.minGallop;
-        while (true) {
-          var count1 = 0;
-          var count2 = 0;
-          var exit = false;
-          do {
-            if (compare(tmp[cursor2], array[cursor1]) < 0) {
-              array[dest--] = array[cursor1--];
-              count1++;
-              count2 = 0;
-              if (--length1 === 0) {
-                exit = true;
-                break;
+          if (length2 === 1) {
+            dest -= length1;
+            cursor1 -= length1;
+            customDest = dest + 1;
+            customCursor = cursor1 + 1;
+            for (i = length1 - 1; i >= 0; i--) {
+              array[customDest + i] = array[customCursor + i];
+            }
+            array[dest] = tmp[cursor2];
+            return;
+          }
+          var minGallop = this.minGallop;
+          while (true) {
+            var count1 = 0;
+            var count2 = 0;
+            var exit = false;
+            do {
+              if (compare(tmp[cursor2], array[cursor1]) < 0) {
+                array[dest--] = array[cursor1--];
+                count1++;
+                count2 = 0;
+                if (--length1 === 0) {
+                  exit = true;
+                  break;
+                }
+              } else {
+                array[dest--] = tmp[cursor2--];
+                count2++;
+                count1 = 0;
+                if (--length2 === 1) {
+                  exit = true;
+                  break;
+                }
+              }
+            } while ((count1 | count2) < minGallop);
+            if (exit) {
+              break;
+            }
+            do {
+              count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
+              if (count1 !== 0) {
+                dest -= count1;
+                cursor1 -= count1;
+                length1 -= count1;
+                customDest = dest + 1;
+                customCursor = cursor1 + 1;
+                for (i = count1 - 1; i >= 0; i--) {
+                  array[customDest + i] = array[customCursor + i];
+                }
+                if (length1 === 0) {
+                  exit = true;
+                  break;
+                }
               }
-            } else {
               array[dest--] = tmp[cursor2--];
-              count2++;
-              count1 = 0;
               if (--length2 === 1) {
                 exit = true;
                 break;
               }
-            }
-          } while ((count1 | count2) < minGallop);
-          if (exit) {
-            break;
-          }
-          do {
-            count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
-            if (count1 !== 0) {
-              dest -= count1;
-              cursor1 -= count1;
-              length1 -= count1;
-              customDest = dest + 1;
-              customCursor = cursor1 + 1;
-              for (i = count1 - 1; i >= 0; i--) {
-                array[customDest + i] = array[customCursor + i];
+              count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
+              if (count2 !== 0) {
+                dest -= count2;
+                cursor2 -= count2;
+                length2 -= count2;
+                customDest = dest + 1;
+                customCursor = cursor2 + 1;
+                for (i = 0; i < count2; i++) {
+                  array[customDest + i] = tmp[customCursor + i];
+                }
+                if (length2 <= 1) {
+                  exit = true;
+                  break;
+                }
               }
-              if (length1 === 0) {
+              array[dest--] = array[cursor1--];
+              if (--length1 === 0) {
                 exit = true;
                 break;
               }
-            }
-            array[dest--] = tmp[cursor2--];
-            if (--length2 === 1) {
-              exit = true;
+              minGallop--;
+            } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+            if (exit) {
               break;
             }
-            count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
-            if (count2 !== 0) {
-              dest -= count2;
-              cursor2 -= count2;
-              length2 -= count2;
-              customDest = dest + 1;
-              customCursor = cursor2 + 1;
-              for (i = 0; i < count2; i++) {
-                array[customDest + i] = tmp[customCursor + i];
-              }
-              if (length2 <= 1) {
-                exit = true;
-                break;
-              }
-            }
-            array[dest--] = array[cursor1--];
-            if (--length1 === 0) {
-              exit = true;
-              break;
+            if (minGallop < 0) {
+              minGallop = 0;
             }
-            minGallop--;
-          } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
-          if (exit) {
-            break;
+            minGallop += 2;
           }
-          if (minGallop < 0) {
-            minGallop = 0;
+          this.minGallop = minGallop;
+          if (minGallop < 1) {
+            this.minGallop = 1;
           }
-          minGallop += 2;
+          if (length2 === 1) {
+            dest -= length1;
+            cursor1 -= length1;
+            customDest = dest + 1;
+            customCursor = cursor1 + 1;
+            for (i = length1 - 1; i >= 0; i--) {
+              array[customDest + i] = array[customCursor + i];
+            }
+            array[dest] = tmp[cursor2];
+          } else if (length2 === 0) {
+            throw new Error("mergeHigh preconditions were not respected");
+          } else {
+            customCursor = dest - (length2 - 1);
+            for (i = 0; i < length2; i++) {
+              array[customCursor + i] = tmp[i];
+            }
+          }
+        };
+        return TimSort2;
+      }();
+      function sort(array, compare, lo, hi) {
+        if (!Array.isArray(array)) {
+          throw new TypeError("Can only sort arrays");
         }
-        this.minGallop = minGallop;
-        if (minGallop < 1) {
-          this.minGallop = 1;
+        if (!compare) {
+          compare = alphabeticalCompare;
+        } else if (typeof compare !== "function") {
+          hi = lo;
+          lo = compare;
+          compare = alphabeticalCompare;
         }
-        if (length2 === 1) {
-          dest -= length1;
-          cursor1 -= length1;
-          customDest = dest + 1;
-          customCursor = cursor1 + 1;
-          for (i = length1 - 1; i >= 0; i--) {
-            array[customDest + i] = array[customCursor + i];
-          }
-          array[dest] = tmp[cursor2];
-        } else if (length2 === 0) {
-          throw new Error("mergeHigh preconditions were not respected");
-        } else {
-          customCursor = dest - (length2 - 1);
-          for (i = 0; i < length2; i++) {
-            array[customCursor + i] = tmp[i];
-          }
+        if (!lo) {
+          lo = 0;
         }
-      };
-      return TimSort2;
-    }();
-    function sort(array, compare, lo, hi) {
-      if (!Array.isArray(array)) {
-        throw new TypeError("Can only sort arrays");
-      }
-      if (!compare) {
-        compare = alphabeticalCompare;
-      } else if (typeof compare !== "function") {
-        hi = lo;
-        lo = compare;
-        compare = alphabeticalCompare;
-      }
-      if (!lo) {
-        lo = 0;
-      }
-      if (!hi) {
-        hi = array.length;
-      }
-      var remaining = hi - lo;
-      if (remaining < 2) {
-        return;
-      }
-      var runLength = 0;
-      if (remaining < DEFAULT_MIN_MERGE) {
-        runLength = makeAscendingRun(array, lo, hi, compare);
-        binaryInsertionSort(array, lo, hi, lo + runLength, compare);
-        return;
-      }
-      var ts = new TimSort(array, compare);
-      var minRun = minRunLength(remaining);
-      do {
-        runLength = makeAscendingRun(array, lo, hi, compare);
-        if (runLength < minRun) {
-          var force = remaining;
-          if (force > minRun) {
-            force = minRun;
-          }
-          binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
-          runLength = force;
+        if (!hi) {
+          hi = array.length;
         }
-        ts.pushRun(lo, runLength);
-        ts.mergeRuns();
-        remaining -= runLength;
-        lo += runLength;
-      } while (remaining !== 0);
-      ts.forceMergeRuns();
-    }
-  });
-})(timsort$1);
-var timsort = timsort$1;
-function lessThanZeroError(p) {
-  return 'Expect percentile to be >= 0 but given "' + p + '" and its type is "' + typeof p + '".';
-}
-function greaterThanHundredError(p) {
-  return 'Expect percentile to be <= 100 but given "' + p + '" and its type is "' + typeof p + '".';
-}
-function nanError(p) {
-  return 'Expect percentile to be a number but given "' + p + '" and its type is "' + typeof p + '".';
-}
-function validateInput(ps) {
-  return ps.reduce(function(errors, p) {
-    if (isNaN(Number(p))) {
-      errors.push(nanError(p));
-    } else if (p < 0) {
-      errors.push(lessThanZeroError(p));
-    } else if (p > 100) {
-      errors.push(greaterThanHundredError(p));
-    }
-    return errors;
-  }, []);
+        var remaining = hi - lo;
+        if (remaining < 2) {
+          return;
+        }
+        var runLength = 0;
+        if (remaining < DEFAULT_MIN_MERGE) {
+          runLength = makeAscendingRun(array, lo, hi, compare);
+          binaryInsertionSort(array, lo, hi, lo + runLength, compare);
+          return;
+        }
+        var ts = new TimSort(array, compare);
+        var minRun = minRunLength(remaining);
+        do {
+          runLength = makeAscendingRun(array, lo, hi, compare);
+          if (runLength < minRun) {
+            var force = remaining;
+            if (force > minRun) {
+              force = minRun;
+            }
+            binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
+            runLength = force;
+          }
+          ts.pushRun(lo, runLength);
+          ts.mergeRuns();
+          remaining -= runLength;
+          lo += runLength;
+        } while (remaining !== 0);
+        ts.forceMergeRuns();
+      }
+    });
+  })(timsort$1);
+  return timsort$1;
 }
-function getPsValue(p, list) {
-  if (p === 0) return list[0];
-  var kIndex = Math.ceil(list.length * (p / 100)) - 1;
-  return list[kIndex];
+var timsort;
+var hasRequiredTimsort;
+function requireTimsort() {
+  if (hasRequiredTimsort) return timsort;
+  hasRequiredTimsort = 1;
+  timsort = requireTimsort$1();
+  return timsort;
 }
-function percentile(pOrPs, list, fn) {
-  var ps = Array.isArray(pOrPs) ? pOrPs : [pOrPs];
-  var validationErrors = validateInput(ps);
-  if (validationErrors.length) {
-    throw new Error(validationErrors.join(" "));
-  }
-  list = list.slice().sort(function(a, b) {
-    if (fn) {
-      a = fn(a);
-      b = fn(b);
-    }
-    a = Number.isNaN(a) ? Number.NEGATIVE_INFINITY : a;
-    b = Number.isNaN(b) ? Number.NEGATIVE_INFINITY : b;
-    if (a > b) return 1;
-    if (a < b) return -1;
-    return 0;
-  });
-  if (ps.length === 1) {
-    return getPsValue(ps[0], list);
+var timsortExports = requireTimsort();
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  function lessThanZeroError(p) {
+    return 'Expect percentile to be >= 0 but given "' + p + '" and its type is "' + typeof p + '".';
+  }
+  function greaterThanHundredError(p) {
+    return 'Expect percentile to be <= 100 but given "' + p + '" and its type is "' + typeof p + '".';
+  }
+  function nanError(p) {
+    return 'Expect percentile to be a number but given "' + p + '" and its type is "' + typeof p + '".';
+  }
+  function validateInput(ps) {
+    return ps.reduce(function(errors, p) {
+      if (isNaN(Number(p))) {
+        errors.push(nanError(p));
+      } else if (p < 0) {
+        errors.push(lessThanZeroError(p));
+      } else if (p > 100) {
+        errors.push(greaterThanHundredError(p));
+      }
+      return errors;
+    }, []);
+  }
+  function getPsValue(p, list) {
+    if (p === 0) return list[0];
+    var kIndex = Math.ceil(list.length * (p / 100)) - 1;
+    return list[kIndex];
+  }
+  function percentile2(pOrPs, list, fn) {
+    var ps = Array.isArray(pOrPs) ? pOrPs : [pOrPs];
+    var validationErrors = validateInput(ps);
+    if (validationErrors.length) {
+      throw new Error(validationErrors.join(" "));
+    }
+    list = list.slice().sort(function(a, b) {
+      if (fn) {
+        a = fn(a);
+        b = fn(b);
+      }
+      a = Number.isNaN(a) ? Number.NEGATIVE_INFINITY : a;
+      b = Number.isNaN(b) ? Number.NEGATIVE_INFINITY : b;
+      if (a > b) return 1;
+      if (a < b) return -1;
+      return 0;
+    });
+    if (ps.length === 1) {
+      return getPsValue(ps[0], list);
+    }
+    return ps.map(function(p) {
+      return getPsValue(p, list);
+    });
   }
-  return ps.map(function(p) {
-    return getPsValue(p, list);
-  });
+  lib = percentile2;
+  return lib;
 }
-var lib = percentile;
-const percentile$1 = /* @__PURE__ */ getDefaultExportFromCjs(lib);
+var libExports = requireLib();
+const percentile = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
 class InstrumentGaugeOptions extends InstrumentBaseOptions {
   constructor() {
     super(...arguments);
@@ -2131,8 +2152,8 @@ NumberCompare_fn = function(a, b) {
 };
 GetPercentileData_fn = function() {
   const sortedList = __privateGet(this, _timeSeriesList).slice(0);
-  timsort.sort(sortedList, __privateMethod(this, _InstrumentGauge_instances, NumberCompare_fn));
-  return percentile$1([50, 80, 90, 95, 99, 99.95], sortedList);
+  timsortExports.sort(sortedList, __privateMethod(this, _InstrumentGauge_instances, NumberCompare_fn));
+  return percentile([50, 80, 90, 95, 99, 99.95], sortedList);
 };
 class InstrumentObjectOptions extends InstrumentBaseOptions {
   constructor() {
@@ -2472,7 +2493,7 @@ class RequestLoggerMiddleware extends STSOptionsBase {
 }
 _tinyEmitter = new WeakMap();
 _RequestCompleted = new WeakMap();
-var ansiStyles$1 = { exports: {} };
+var ansiStyles = { exports: {} };
 var colorName;
 var hasRequiredColorName;
 function requireColorName() {
@@ -3435,181 +3456,200 @@ function requireColorConvert() {
   colorConvert = convert;
   return colorConvert;
 }
-ansiStyles$1.exports;
-(function(module) {
-  const wrapAnsi16 = (fn, offset) => (...args) => {
-    const code = fn(...args);
-    return `\x1B[${code + offset}m`;
-  };
-  const wrapAnsi256 = (fn, offset) => (...args) => {
-    const code = fn(...args);
-    return `\x1B[${38 + offset};5;${code}m`;
-  };
-  const wrapAnsi16m = (fn, offset) => (...args) => {
-    const rgb = fn(...args);
-    return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
-  };
-  const ansi2ansi = (n) => n;
-  const rgb2rgb = (r, g, b) => [r, g, b];
-  const setLazyProperty = (object, property, get) => {
-    Object.defineProperty(object, property, {
-      get: () => {
-        const value = get();
-        Object.defineProperty(object, property, {
-          value,
-          enumerable: true,
-          configurable: true
-        });
-        return value;
-      },
-      enumerable: true,
-      configurable: true
-    });
-  };
-  let colorConvert2;
-  const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
-    if (colorConvert2 === void 0) {
-      colorConvert2 = requireColorConvert();
-    }
-    const offset = isBackground ? 10 : 0;
-    const styles2 = {};
-    for (const [sourceSpace, suite] of Object.entries(colorConvert2)) {
-      const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
-      if (sourceSpace === targetSpace) {
-        styles2[name] = wrap(identity, offset);
-      } else if (typeof suite === "object") {
-        styles2[name] = wrap(suite[targetSpace], offset);
-      }
-    }
-    return styles2;
-  };
-  function assembleStyles() {
-    const codes = /* @__PURE__ */ new Map();
-    const styles2 = {
-      modifier: {
-        reset: [0, 0],
-        // 21 isn't widely supported and 22 does the same thing
-        bold: [1, 22],
-        dim: [2, 22],
-        italic: [3, 23],
-        underline: [4, 24],
-        inverse: [7, 27],
-        hidden: [8, 28],
-        strikethrough: [9, 29]
-      },
-      color: {
-        black: [30, 39],
-        red: [31, 39],
-        green: [32, 39],
-        yellow: [33, 39],
-        blue: [34, 39],
-        magenta: [35, 39],
-        cyan: [36, 39],
-        white: [37, 39],
-        // Bright color
-        blackBright: [90, 39],
-        redBright: [91, 39],
-        greenBright: [92, 39],
-        yellowBright: [93, 39],
-        blueBright: [94, 39],
-        magentaBright: [95, 39],
-        cyanBright: [96, 39],
-        whiteBright: [97, 39]
-      },
-      bgColor: {
-        bgBlack: [40, 49],
-        bgRed: [41, 49],
-        bgGreen: [42, 49],
-        bgYellow: [43, 49],
-        bgBlue: [44, 49],
-        bgMagenta: [45, 49],
-        bgCyan: [46, 49],
-        bgWhite: [47, 49],
-        // Bright color
-        bgBlackBright: [100, 49],
-        bgRedBright: [101, 49],
-        bgGreenBright: [102, 49],
-        bgYellowBright: [103, 49],
-        bgBlueBright: [104, 49],
-        bgMagentaBright: [105, 49],
-        bgCyanBright: [106, 49],
-        bgWhiteBright: [107, 49]
+ansiStyles.exports;
+var hasRequiredAnsiStyles;
+function requireAnsiStyles() {
+  if (hasRequiredAnsiStyles) return ansiStyles.exports;
+  hasRequiredAnsiStyles = 1;
+  (function(module) {
+    const wrapAnsi16 = (fn, offset) => (...args) => {
+      const code = fn(...args);
+      return `\x1B[${code + offset}m`;
+    };
+    const wrapAnsi256 = (fn, offset) => (...args) => {
+      const code = fn(...args);
+      return `\x1B[${38 + offset};5;${code}m`;
+    };
+    const wrapAnsi16m = (fn, offset) => (...args) => {
+      const rgb = fn(...args);
+      return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+    };
+    const ansi2ansi = (n) => n;
+    const rgb2rgb = (r, g, b) => [r, g, b];
+    const setLazyProperty = (object, property, get) => {
+      Object.defineProperty(object, property, {
+        get: () => {
+          const value = get();
+          Object.defineProperty(object, property, {
+            value,
+            enumerable: true,
+            configurable: true
+          });
+          return value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    };
+    let colorConvert2;
+    const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+      if (colorConvert2 === void 0) {
+        colorConvert2 = requireColorConvert();
+      }
+      const offset = isBackground ? 10 : 0;
+      const styles = {};
+      for (const [sourceSpace, suite] of Object.entries(colorConvert2)) {
+        const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+        if (sourceSpace === targetSpace) {
+          styles[name] = wrap(identity, offset);
+        } else if (typeof suite === "object") {
+          styles[name] = wrap(suite[targetSpace], offset);
+        }
       }
+      return styles;
     };
-    styles2.color.gray = styles2.color.blackBright;
-    styles2.bgColor.bgGray = styles2.bgColor.bgBlackBright;
-    styles2.color.grey = styles2.color.blackBright;
-    styles2.bgColor.bgGrey = styles2.bgColor.bgBlackBright;
-    for (const [groupName, group] of Object.entries(styles2)) {
-      for (const [styleName, style] of Object.entries(group)) {
-        styles2[styleName] = {
-          open: `\x1B[${style[0]}m`,
-          close: `\x1B[${style[1]}m`
-        };
-        group[styleName] = styles2[styleName];
-        codes.set(style[0], style[1]);
+    function assembleStyles() {
+      const codes = /* @__PURE__ */ new Map();
+      const styles = {
+        modifier: {
+          reset: [0, 0],
+          // 21 isn't widely supported and 22 does the same thing
+          bold: [1, 22],
+          dim: [2, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          hidden: [8, 28],
+          strikethrough: [9, 29]
+        },
+        color: {
+          black: [30, 39],
+          red: [31, 39],
+          green: [32, 39],
+          yellow: [33, 39],
+          blue: [34, 39],
+          magenta: [35, 39],
+          cyan: [36, 39],
+          white: [37, 39],
+          // Bright color
+          blackBright: [90, 39],
+          redBright: [91, 39],
+          greenBright: [92, 39],
+          yellowBright: [93, 39],
+          blueBright: [94, 39],
+          magentaBright: [95, 39],
+          cyanBright: [96, 39],
+          whiteBright: [97, 39]
+        },
+        bgColor: {
+          bgBlack: [40, 49],
+          bgRed: [41, 49],
+          bgGreen: [42, 49],
+          bgYellow: [43, 49],
+          bgBlue: [44, 49],
+          bgMagenta: [45, 49],
+          bgCyan: [46, 49],
+          bgWhite: [47, 49],
+          // Bright color
+          bgBlackBright: [100, 49],
+          bgRedBright: [101, 49],
+          bgGreenBright: [102, 49],
+          bgYellowBright: [103, 49],
+          bgBlueBright: [104, 49],
+          bgMagentaBright: [105, 49],
+          bgCyanBright: [106, 49],
+          bgWhiteBright: [107, 49]
+        }
+      };
+      styles.color.gray = styles.color.blackBright;
+      styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+      styles.color.grey = styles.color.blackBright;
+      styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+      for (const [groupName, group] of Object.entries(styles)) {
+        for (const [styleName, style] of Object.entries(group)) {
+          styles[styleName] = {
+            open: `\x1B[${style[0]}m`,
+            close: `\x1B[${style[1]}m`
+          };
+          group[styleName] = styles[styleName];
+          codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+          value: group,
+          enumerable: false
+        });
       }
-      Object.defineProperty(styles2, groupName, {
-        value: group,
+      Object.defineProperty(styles, "codes", {
+        value: codes,
         enumerable: false
       });
-    }
-    Object.defineProperty(styles2, "codes", {
-      value: codes,
-      enumerable: false
+      styles.color.close = "\x1B[39m";
+      styles.bgColor.close = "\x1B[49m";
+      setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+      setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+      setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+      setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+      setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+      setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
+      return styles;
+    }
+    Object.defineProperty(module, "exports", {
+      enumerable: true,
+      get: assembleStyles
     });
-    styles2.color.close = "\x1B[39m";
-    styles2.bgColor.close = "\x1B[49m";
-    setLazyProperty(styles2.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
-    setLazyProperty(styles2.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
-    setLazyProperty(styles2.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
-    setLazyProperty(styles2.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
-    setLazyProperty(styles2.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
-    setLazyProperty(styles2.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
-    return styles2;
-  }
-  Object.defineProperty(module, "exports", {
-    enumerable: true,
-    get: assembleStyles
-  });
-})(ansiStyles$1);
-var ansiStylesExports = ansiStyles$1.exports;
-var browser = {
-  stdout: false,
-  stderr: false
-};
-const stringReplaceAll$1 = (string, substring, replacer) => {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.substr(endIndex);
-  return returnValue;
-};
-const stringEncaseCRLFWithFirstIndex$1 = (string, prefix, postfix, index) => {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
-    endIndex = index + 1;
-    index = string.indexOf("\n", endIndex);
-  } while (index !== -1);
-  returnValue += string.substr(endIndex);
-  return returnValue;
-};
-var util = {
-  stringReplaceAll: stringReplaceAll$1,
-  stringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex$1
-};
+  })(ansiStyles);
+  return ansiStyles.exports;
+}
+var browser;
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser;
+  hasRequiredBrowser = 1;
+  browser = {
+    stdout: false,
+    stderr: false
+  };
+  return browser;
+}
+var util;
+var hasRequiredUtil;
+function requireUtil() {
+  if (hasRequiredUtil) return util;
+  hasRequiredUtil = 1;
+  const stringReplaceAll = (string, substring, replacer) => {
+    let index = string.indexOf(substring);
+    if (index === -1) {
+      return string;
+    }
+    const substringLength = substring.length;
+    let endIndex = 0;
+    let returnValue = "";
+    do {
+      returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+      endIndex = index + substringLength;
+      index = string.indexOf(substring, endIndex);
+    } while (index !== -1);
+    returnValue += string.substr(endIndex);
+    return returnValue;
+  };
+  const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+    let endIndex = 0;
+    let returnValue = "";
+    do {
+      const gotCR = string[index - 1] === "\r";
+      returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+      endIndex = index + 1;
+      index = string.indexOf("\n", endIndex);
+    } while (index !== -1);
+    returnValue += string.substr(endIndex);
+    return returnValue;
+  };
+  util = {
+    stringReplaceAll,
+    stringEncaseCRLFWithFirstIndex
+  };
+  return util;
+}
 var templates;
 var hasRequiredTemplates;
 function requireTemplates() {
@@ -3673,27 +3713,27 @@ function requireTemplates() {
     }
     return results;
   }
-  function buildStyle(chalk2, styles2) {
+  function buildStyle(chalk2, styles) {
     const enabled = {};
-    for (const layer of styles2) {
+    for (const layer of styles) {
       for (const style of layer.styles) {
         enabled[style[0]] = layer.inverse ? null : style.slice(1);
       }
     }
     let current = chalk2;
-    for (const [styleName, styles3] of Object.entries(enabled)) {
-      if (!Array.isArray(styles3)) {
+    for (const [styleName, styles2] of Object.entries(enabled)) {
+      if (!Array.isArray(styles2)) {
         continue;
       }
       if (!(styleName in current)) {
         throw new Error(`Unknown Chalk style: ${styleName}`);
       }
-      current = styles3.length > 0 ? current[styleName](...styles3) : current[styleName];
+      current = styles2.length > 0 ? current[styleName](...styles2) : current[styleName];
     }
     return current;
   }
   templates = (chalk2, temporary) => {
-    const styles2 = [];
+    const styles = [];
     const chunks = [];
     let chunk = [];
     temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
@@ -3702,200 +3742,208 @@ function requireTemplates() {
       } else if (style) {
         const string = chunk.join("");
         chunk = [];
-        chunks.push(styles2.length === 0 ? string : buildStyle(chalk2, styles2)(string));
-        styles2.push({ inverse, styles: parseStyle(style) });
+        chunks.push(styles.length === 0 ? string : buildStyle(chalk2, styles)(string));
+        styles.push({ inverse, styles: parseStyle(style) });
       } else if (close) {
-        if (styles2.length === 0) {
+        if (styles.length === 0) {
           throw new Error("Found extraneous } in Chalk template literal");
         }
-        chunks.push(buildStyle(chalk2, styles2)(chunk.join("")));
+        chunks.push(buildStyle(chalk2, styles)(chunk.join("")));
         chunk = [];
-        styles2.pop();
+        styles.pop();
       } else {
         chunk.push(character);
       }
     });
     chunks.push(chunk.join(""));
-    if (styles2.length > 0) {
-      const errMessage = `Chalk template literal is missing ${styles2.length} closing bracket${styles2.length === 1 ? "" : "s"} (\`}\`)`;
+    if (styles.length > 0) {
+      const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
       throw new Error(errMessage);
     }
     return chunks.join("");
   };
   return templates;
 }
-const ansiStyles = ansiStylesExports;
-const { stdout: stdoutColor, stderr: stderrColor } = browser;
-const {
-  stringReplaceAll,
-  stringEncaseCRLFWithFirstIndex
-} = util;
-const { isArray } = Array;
-const levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-const styles = /* @__PURE__ */ Object.create(null);
-const applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === void 0 ? colorLevel : options.level;
-};
-class ChalkClass {
-  constructor(options) {
+var source;
+var hasRequiredSource;
+function requireSource() {
+  if (hasRequiredSource) return source;
+  hasRequiredSource = 1;
+  const ansiStyles2 = requireAnsiStyles();
+  const { stdout: stdoutColor, stderr: stderrColor } = requireBrowser();
+  const {
+    stringReplaceAll,
+    stringEncaseCRLFWithFirstIndex
+  } = requireUtil();
+  const { isArray } = Array;
+  const levelMapping = [
+    "ansi",
+    "ansi",
+    "ansi256",
+    "ansi16m"
+  ];
+  const styles = /* @__PURE__ */ Object.create(null);
+  const applyOptions = (object, options = {}) => {
+    if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+      throw new Error("The `level` option should be an integer from 0 to 3");
+    }
+    const colorLevel = stdoutColor ? stdoutColor.level : 0;
+    object.level = options.level === void 0 ? colorLevel : options.level;
+  };
+  class ChalkClass {
+    constructor(options) {
+      return chalkFactory(options);
+    }
+  }
+  const chalkFactory = (options) => {
+    const chalk3 = {};
+    applyOptions(chalk3, options);
+    chalk3.template = (...arguments_) => chalkTag(chalk3.template, ...arguments_);
+    Object.setPrototypeOf(chalk3, Chalk.prototype);
+    Object.setPrototypeOf(chalk3.template, chalk3);
+    chalk3.template.constructor = () => {
+      throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+    };
+    chalk3.template.Instance = ChalkClass;
+    return chalk3.template;
+  };
+  function Chalk(options) {
     return chalkFactory(options);
   }
-}
-const chalkFactory = (options) => {
-  const chalk2 = {};
-  applyOptions(chalk2, options);
-  chalk2.template = (...arguments_) => chalkTag(chalk2.template, ...arguments_);
-  Object.setPrototypeOf(chalk2, Chalk.prototype);
-  Object.setPrototypeOf(chalk2.template, chalk2);
-  chalk2.template.constructor = () => {
-    throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
-  };
-  chalk2.template.Instance = ChalkClass;
-  return chalk2.template;
-};
-function Chalk(options) {
-  return chalkFactory(options);
-}
-for (const [styleName, style] of Object.entries(ansiStyles)) {
-  styles[styleName] = {
+  for (const [styleName, style] of Object.entries(ansiStyles2)) {
+    styles[styleName] = {
+      get() {
+        const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+        Object.defineProperty(this, styleName, { value: builder });
+        return builder;
+      }
+    };
+  }
+  styles.visible = {
     get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
-      Object.defineProperty(this, styleName, { value: builder });
+      const builder = createBuilder(this, this._styler, true);
+      Object.defineProperty(this, "visible", { value: builder });
       return builder;
     }
   };
-}
-styles.visible = {
-  get() {
-    const builder = createBuilder(this, this._styler, true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
+  const usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
+  for (const model of usedModels) {
+    styles[model] = {
+      get() {
+        const { level } = this;
+        return function(...arguments_) {
+          const styler = createStyler(ansiStyles2.color[levelMapping[level]][model](...arguments_), ansiStyles2.color.close, this._styler);
+          return createBuilder(this, styler, this._isEmpty);
+        };
+      }
+    };
   }
-};
-const usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
-for (const model of usedModels) {
-  styles[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
-        return createBuilder(this, styler, this._isEmpty);
-      };
+  for (const model of usedModels) {
+    const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+    styles[bgModel] = {
+      get() {
+        const { level } = this;
+        return function(...arguments_) {
+          const styler = createStyler(ansiStyles2.bgColor[levelMapping[level]][model](...arguments_), ansiStyles2.bgColor.close, this._styler);
+          return createBuilder(this, styler, this._isEmpty);
+        };
+      }
+    };
+  }
+  const proto = Object.defineProperties(() => {
+  }, {
+    ...styles,
+    level: {
+      enumerable: true,
+      get() {
+        return this._generator.level;
+      },
+      set(level) {
+        this._generator.level = level;
+      }
     }
-  };
-}
-for (const model of usedModels) {
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
-        return createBuilder(this, styler, this._isEmpty);
-      };
+  });
+  const createStyler = (open, close, parent) => {
+    let openAll;
+    let closeAll;
+    if (parent === void 0) {
+      openAll = open;
+      closeAll = close;
+    } else {
+      openAll = parent.openAll + open;
+      closeAll = close + parent.closeAll;
     }
+    return {
+      open,
+      close,
+      openAll,
+      closeAll,
+      parent
+    };
   };
-}
-const proto = Object.defineProperties(() => {
-}, {
-  ...styles,
-  level: {
-    enumerable: true,
-    get() {
-      return this._generator.level;
-    },
-    set(level) {
-      this._generator.level = level;
-    }
-  }
-});
-const createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === void 0) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
+  const createBuilder = (self, _styler, _isEmpty) => {
+    const builder = (...arguments_) => {
+      if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+        return applyStyle(builder, chalkTag(builder, ...arguments_));
+      }
+      return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+    };
+    Object.setPrototypeOf(builder, proto);
+    builder._generator = self;
+    builder._styler = _styler;
+    builder._isEmpty = _isEmpty;
+    return builder;
   };
-};
-const createBuilder = (self2, _styler, _isEmpty) => {
-  const builder = (...arguments_) => {
-    if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
-      return applyStyle(builder, chalkTag(builder, ...arguments_));
+  const applyStyle = (self, string) => {
+    if (self.level <= 0 || !string) {
+      return self._isEmpty ? "" : string;
+    }
+    let styler = self._styler;
+    if (styler === void 0) {
+      return string;
     }
-    return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+    const { openAll, closeAll } = styler;
+    if (string.indexOf("\x1B") !== -1) {
+      while (styler !== void 0) {
+        string = stringReplaceAll(string, styler.close, styler.open);
+        styler = styler.parent;
+      }
+    }
+    const lfIndex = string.indexOf("\n");
+    if (lfIndex !== -1) {
+      string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+    }
+    return openAll + string + closeAll;
   };
-  Object.setPrototypeOf(builder, proto);
-  builder._generator = self2;
-  builder._styler = _styler;
-  builder._isEmpty = _isEmpty;
-  return builder;
-};
-const applyStyle = (self2, string) => {
-  if (self2.level <= 0 || !string) {
-    return self2._isEmpty ? "" : string;
-  }
-  let styler = self2._styler;
-  if (styler === void 0) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.indexOf("\x1B") !== -1) {
-    while (styler !== void 0) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
+  let template;
+  const chalkTag = (chalk3, ...strings) => {
+    const [firstString] = strings;
+    if (!isArray(firstString) || !isArray(firstString.raw)) {
+      return strings.join(" ");
+    }
+    const arguments_ = strings.slice(1);
+    const parts = [firstString.raw[0]];
+    for (let i = 1; i < firstString.length; i++) {
+      parts.push(
+        String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"),
+        String(firstString.raw[i])
+      );
     }
-  }
-  const lfIndex = string.indexOf("\n");
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-let template;
-const chalkTag = (chalk2, ...strings) => {
-  const [firstString] = strings;
-  if (!isArray(firstString) || !isArray(firstString.raw)) {
-    return strings.join(" ");
-  }
-  const arguments_ = strings.slice(1);
-  const parts = [firstString.raw[0]];
-  for (let i = 1; i < firstString.length; i++) {
-    parts.push(
-      String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"),
-      String(firstString.raw[i])
-    );
-  }
-  if (template === void 0) {
-    template = requireTemplates();
-  }
-  return template(chalk2, parts.join(""));
-};
-Object.defineProperties(Chalk.prototype, styles);
-const chalk = Chalk();
-chalk.supportsColor = stdoutColor;
-chalk.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
-chalk.stderr.supportsColor = stderrColor;
-var source = chalk;
-const chalk$1 = /* @__PURE__ */ getDefaultExportFromCjs(source);
+    if (template === void 0) {
+      template = requireTemplates();
+    }
+    return template(chalk3, parts.join(""));
+  };
+  Object.defineProperties(Chalk.prototype, styles);
+  const chalk2 = Chalk();
+  chalk2.supportsColor = stdoutColor;
+  chalk2.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+  chalk2.stderr.supportsColor = stderrColor;
+  source = chalk2;
+  return source;
+}
+var sourceExports = requireSource();
+const chalk = /* @__PURE__ */ getDefaultExportFromCjs(sourceExports);
 function utf8Count(str) {
   var strLength = str.length;
   var byteLength = 0;
@@ -4007,8 +4055,8 @@ var DecodeError = (
     __extends(DecodeError2, _super);
     function DecodeError2(message) {
       var _this = _super.call(this, message) || this;
-      var proto2 = Object.create(DecodeError2.prototype);
-      Object.setPrototypeOf(_this, proto2);
+      var proto = Object.create(DecodeError2.prototype);
+      Object.setPrototypeOf(_this, proto);
       Object.defineProperty(_this, "name", {
         configurable: true,
         enumerable: false,
@@ -4541,7 +4589,7 @@ class PublishTransportRESTServer extends STSOptionsBase {
     __publicField(this, "Publish", async (payload) => {
       try {
         if (this.options.showPublishPayload) {
-          console.log(chalk$1.grey(`PublishTransportRESTServer::Publish() url: [${this.options.url}]`));
+          console.log(chalk.grey(`PublishTransportRESTServer::Publish() url: [${this.options.url}]`));
           console.log(payload);
         }
         const encodedData = encode(payload, { ignoreUndefined: true });
@@ -4568,19 +4616,19 @@ class PublishTransportRESTServer extends STSOptionsBase {
         }
         if (retVal.status !== 200) {
           if (this.options.showPublishPayload) {
-            console.log(chalk$1.red(`PublishTransportRESTServer::Publish() Error (_PerformPublishRESTAPI:_PerformPublish:#publishmessage): Invalid response from server: [${retVal.status}]`));
+            console.log(chalk.red(`PublishTransportRESTServer::Publish() Error (_PerformPublishRESTAPI:_PerformPublish:#publishmessage): Invalid response from server: [${retVal.status}]`));
           }
-          this.options.logger.debug(chalk$1.red(`Error (_PerformPublishRESTAPI:_PerformPublish:#publishmessage): Invalid response from server: [${retVal.status}]`));
+          this.options.logger.debug(chalk.red(`Error (_PerformPublishRESTAPI:_PerformPublish:#publishmessage): Invalid response from server: [${retVal.status}]`));
           return false;
         } else {
           if (this.options.showPublishPayload) {
-            console.log(chalk$1.grey(`PublishTransportRESTServer::Publish() _PerformPublishRESTAPI:_PerformPublish:#publishmessage: [${this.options.url}] - Valid response from server: [${retVal.status}]`));
+            console.log(chalk.grey(`PublishTransportRESTServer::Publish() _PerformPublishRESTAPI:_PerformPublish:#publishmessage: [${this.options.url}] - Valid response from server: [${retVal.status}]`));
           }
         }
         return true;
       } catch (error) {
         if (this.options.showPublishPayload) {
-          console.log(chalk$1.red(`PublishTransportRESTServer::Publish() Error (PublishRESTServer:_PerformPublishRESTAPI:Error: [${error}]`));
+          console.log(chalk.red(`PublishTransportRESTServer::Publish() Error (PublishRESTServer:_PerformPublishRESTAPI:Error: [${error}]`));
         }
         return false;
       }
@@ -4638,7 +4686,7 @@ class PublishInstruments extends STSOptionsBase {
   }
   async StartPublish() {
     if (__privateGet(this, _publishState) !== 0) {
-      this.options.logger.debug(chalk$1.yellow(`StartPublish:${this.options.processContext.nid}: StartPublish called when not currently in the init state. Current State: [${__privateGet(this, _publishState)}]`));
+      this.options.logger.debug(chalk.yellow(`StartPublish:${this.options.processContext.nid}: StartPublish called when not currently in the init state. Current State: [${__privateGet(this, _publishState)}]`));
       return false;
     }
     __privateMethod(this, _PublishInstruments_instances, UpdateState_fn).call(this, 1, "StartPublish()");
@@ -4647,7 +4695,7 @@ class PublishInstruments extends STSOptionsBase {
   }
   async EndPublish() {
     if (__privateGet(this, _publishState) !== 1) {
-      this.options.logger.debug(chalk$1.yellow(`EndPublish:${this.options.processContext.nid}: EndPublish called when not within the started state. Current State: [${__privateGet(this, _publishState)}]`));
+      this.options.logger.debug(chalk.yellow(`EndPublish:${this.options.processContext.nid}: EndPublish called when not within the started state. Current State: [${__privateGet(this, _publishState)}]`));
       return false;
     }
     __privateMethod(this, _PublishInstruments_instances, UpdateState_fn).call(this, 2, "EndPublish() (1)");
@@ -4687,7 +4735,7 @@ PublishTimeoutLoop_fn = function(publishInterval) {
 UpdateState_fn = function(newState, comment) {
   const previousState = __privateGet(this, _publishState);
   __privateSet(this, _publishState, newState);
-  this.options.logger.debug(chalk$1.yellow(`#UpdateState:${this.options.processContext.nid}: Previous State: [${previousState}]. Current State: [${__privateGet(this, _publishState)}]. Comment: [${comment}]`));
+  this.options.logger.debug(chalk.yellow(`#UpdateState:${this.options.processContext.nid}: Previous State: [${previousState}]. Current State: [${__privateGet(this, _publishState)}]. Comment: [${comment}]`));
 };
 var ePublishState = /* @__PURE__ */ ((ePublishState2) => {
   ePublishState2[ePublishState2["init"] = 0] = "init";
@@ -4750,11 +4798,11 @@ const _PublishInstrumentController = class _PublishInstrumentController extends
   }
   SetupInstrumentation() {
     if (!this.options.instrumentDefinitions) {
-      this.options.logger.debug(chalk$1.yellow(`SetupInstrumentation:${this.options.processContext.nid}: No instrument(s) defined within supplied options.`));
+      this.options.logger.debug(chalk.yellow(`SetupInstrumentation:${this.options.processContext.nid}: No instrument(s) defined within supplied options.`));
       return;
     }
     if (!this.options.processContext) {
-      this.options.logger.debug(chalk$1.yellow(`SetupInstrumentation: No context defined within supplied options.`));
+      this.options.logger.debug(chalk.yellow(`SetupInstrumentation: No context defined within supplied options.`));
       return;
     }
     __privateMethod(this, _PublishInstrumentController_instances, CreateInstruments_fn).call(this, this.options.instrumentDefinitions);
@@ -4779,7 +4827,7 @@ const _PublishInstrumentController = class _PublishInstrumentController extends
     if (__privateGet(this, _instruments)[instrumentName]) {
       __privateMethod(this, _PublishInstrumentController_instances, ProcessTelemetryCommand_fn).call(this, instrumentName, telemetry);
     } else {
-      this.options.logger.debug(chalk$1.red(`UpdateInstrument:${this.options.processContext.nid}: Attempted to UpdateInstrument before initialised.`));
+      this.options.logger.debug(chalk.red(`UpdateInstrument:${this.options.processContext.nid}: Attempted to UpdateInstrument before initialised.`));
     }
   }
   /**
@@ -4852,21 +4900,21 @@ const GetSTSInstrumentController = (app) => {
 const STSInstrumentControllerPlugin = {
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any    
   install: (app, options) => {
-    options.logger.debug(chalk$1.yellow(`STSInstrumentControllerPlugin:install:Start`));
+    options.logger.debug(chalk.yellow(`STSInstrumentControllerPlugin:install:Start`));
     const aic = new PublishInstrumentController(options);
     if (!app.config.globalProperties.$sts) {
-      options.logger.debug(chalk$1.cyan(`STSInstrumentControllerPlugin:install: [app.config.globalProperties.$sts] does not exist.`));
+      options.logger.debug(chalk.cyan(`STSInstrumentControllerPlugin:install: [app.config.globalProperties.$sts] does not exist.`));
       app.config.globalProperties.$sts = {};
-      options.logger.debug(chalk$1.cyan(`STSInstrumentControllerPlugin:install: created empty [app.config.globalProperties.$sts].`));
+      options.logger.debug(chalk.cyan(`STSInstrumentControllerPlugin:install: created empty [app.config.globalProperties.$sts].`));
     } else {
-      options.logger.debug(chalk$1.cyan(`STSInstrumentControllerPlugin:install: [app.config.globalProperties.$sts] already exists.`));
+      options.logger.debug(chalk.cyan(`STSInstrumentControllerPlugin:install: [app.config.globalProperties.$sts] already exists.`));
     }
     app.config.globalProperties.$sts.aic = aic;
     app.config.globalProperties.$sts[STSInstrumentControllerPluginKey] = aic;
-    options.logger.debug(chalk$1.cyan(`STSInstrumentControllerPlugin:install: AgentInstrumentController installed into [app.config.globalProperties.$sts] using: [${String(STSInstrumentControllerPluginKey)}].`));
+    options.logger.debug(chalk.cyan(`STSInstrumentControllerPlugin:install: AgentInstrumentController installed into [app.config.globalProperties.$sts] using: [${String(STSInstrumentControllerPluginKey)}].`));
     app.provide(STSInstrumentControllerPluginKey, aic);
-    options.logger.debug(chalk$1.cyan(`STSInstrumentControllerPlugin:install: AgentInstrumentController installed into 'provide' using: [${String(STSInstrumentControllerPluginKey)}].`));
-    options.logger.debug(chalk$1.green(`STSInstrumentControllerPlugin:install:End`));
+    options.logger.debug(chalk.cyan(`STSInstrumentControllerPlugin:install: AgentInstrumentController installed into 'provide' using: [${String(STSInstrumentControllerPluginKey)}].`));
+    options.logger.debug(chalk.green(`STSInstrumentControllerPlugin:install:End`));
   }
 };
 var SubscriptionTopic = /* @__PURE__ */ ((SubscriptionTopic2) => {
@@ -5475,7 +5523,7 @@ class ObservabilityRESTAPISubscriber {
           subscription.cb(payload);
         }
       } catch (error) {
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk$1.red(`ObservabilityRESTAPISubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
+        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk.red(`ObservabilityRESTAPISubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
         __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subscription);
       }
     });
@@ -5487,11 +5535,11 @@ class ObservabilityRESTAPISubscriber {
   async Subscribe(subscriptions) {
     subscriptions.map(async (subId) => {
       __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subId);
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk$1.yellow(`ObservabilityRESTAPISubscriber:Subscribe(): Sending subscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
+      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk.yellow(`ObservabilityRESTAPISubscriber:Subscribe(): Sending subscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
       try {
         __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, AddKeepAlive_fn).call(this, subId);
       } catch (error) {
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk$1.red(`ObservabilityRESTAPISubscriber:Subscribe(): Error: response: [${JSON.stringify(error)}]`));
+        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk.red(`ObservabilityRESTAPISubscriber:Subscribe(): Error: response: [${JSON.stringify(error)}]`));
         __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subId);
       }
     });
@@ -5502,7 +5550,7 @@ class ObservabilityRESTAPISubscriber {
   UnSubscribe(subscriptions) {
     subscriptions.map(async (subId) => {
       __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subId);
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk$1.yellow(`ObservabilityRESTAPISubscriber:UnSubscribe(): Sending unsubscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
+      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk.yellow(`ObservabilityRESTAPISubscriber:UnSubscribe(): Sending unsubscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
     });
   }
 }
@@ -5519,6 +5567,7 @@ InvokeRESTAPI_fn = async function(subscription) {
   const { subscriptionKey } = subscription;
   let url = "";
   switch (subscriptionKey.topic) {
+    // Services -------------------------------------------------------------------------------------------
     case SubscriptionTopic.AllServicesCombined:
       url = `/metrics`;
       break;
@@ -5540,6 +5589,7 @@ InvokeRESTAPI_fn = async function(subscription) {
       } else {
         throw new Error(`#OutputSubscription(Services): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
       }
+    // Lambdas -------------------------------------------------------------------------------------------
     case SubscriptionTopic.AllLambdasCombined:
       url = `/metrics`;
       break;
@@ -5561,6 +5611,7 @@ InvokeRESTAPI_fn = async function(subscription) {
       } else {
         throw new Error(`#OutputSubscription(Lambdas): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
       }
+    // User Agents -------------------------------------------------------------------------------------------
     case SubscriptionTopic.AllAgentsCombined:
       url = `/metrics`;
       break;
@@ -5626,10 +5677,10 @@ SetupTimeout_fn = function(socketSubscribeKeepAlive, subscription, timeout) {
         }
         socketSubscribeKeepAlive.timeout = __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, SetupTimeout_fn).call(this, socketSubscribeKeepAlive, subscription, timeoutDuration);
       } else {
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk$1.yellow(`Subscription removed: [${socketSubscribeKeepAlive.id}]. Processing terminate.`));
+        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk.yellow(`Subscription removed: [${socketSubscribeKeepAlive.id}]. Processing terminate.`));
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk$1.red(`ObservabilityRESTAPISubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
+      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk.red(`ObservabilityRESTAPISubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
       __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subscription);
     }
   }, timeout);
@@ -5645,40 +5696,38 @@ AddKeepAlive_fn = function(subscription) {
 };
 RemoveKeepAlive_fn = function(subscription) {
   if (__privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id]) {
-    __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk$1.gray(`ObservabilityRESTAPISubscriber:#RemoveKeepAlive(): subscriptionKey: [${subscription.subscriptionKey.id}]`));
+    __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk.gray(`ObservabilityRESTAPISubscriber:#RemoveKeepAlive(): subscriptionKey: [${subscription.subscriptionKey.id}]`));
     clearTimeout(__privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id].timeout);
     delete __privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id].timeout;
     delete __privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id];
   }
 };
-var byteToHex = [];
-for (var i = 0; i < 256; ++i) {
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
 }
 function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
-var getRandomValues;
-var rnds8 = new Uint8Array(16);
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
 function rng() {
   if (!getRandomValues) {
-    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
-    if (!getRandomValues) {
+    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
       throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
     }
+    getRandomValues = crypto.getRandomValues.bind(crypto);
   }
   return getRandomValues(rnds8);
 }
-var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-const native = {
-  randomUUID
-};
+const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const native = { randomUUID };
 function v4(options, buf, offset) {
   if (native.randomUUID && !buf && !options) {
     return native.randomUUID();
   }
   options = options || {};
-  var rnds = options.random || (options.rng || rng)();
+  const rnds = options.random || (options.rng || rng)();
   rnds[6] = rnds[6] & 15 | 64;
   rnds[8] = rnds[8] & 63 | 128;
   return unsafeStringify(rnds);
@@ -5715,7 +5764,7 @@ class SocketIoMessageSender {
     return __privateGet(this, _socket);
   }
   set socket(socket) {
-    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk$1.cyan(`SocketIoMessageSender:set socket(): new socket assigned`));
+    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.cyan(`SocketIoMessageSender:set socket(): new socket assigned`));
     __privateSet(this, _socket, socket);
   }
   AckListener(message, payload) {
@@ -5728,25 +5777,25 @@ class SocketIoMessageSender {
       message.status = "SUCCESS";
       message.subscriptionKeyResponse = payload;
       delete __privateGet(this, _messageWithAckPayloadRecords)[message.id];
-      __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk$1.grey(`SocketIoMessageSender:AckListener(): ack received, event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+      __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.grey(`SocketIoMessageSender:AckListener(): ack received, event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
       message.resolve(message);
     }
   }
   ResponseTimout(message) {
-    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk$1.magenta(`SocketIoMessageSender:ResponseTimout(): timeout reached: [${__privateGet(this, _timeoutValue)}], event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.magenta(`SocketIoMessageSender:ResponseTimout(): timeout reached: [${__privateGet(this, _timeoutValue)}], event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
     delete message.timeoutId;
     __privateGet(this, _socket).off(__privateMethod(this, _SocketIoMessageSender_instances, GetSubscribeKeepAliveAckEventName_fn).call(this, message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
     message.endTime = performance.now();
     if (message.retryCount >= __privateGet(this, _maxReties)) {
       message.status = "FAIL";
-      __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk$1.red(`SocketIoMessageSender:ResponseTimout(): timeout reached after ${__privateGet(this, _maxReties)} retries, event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+      __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.red(`SocketIoMessageSender:ResponseTimout(): timeout reached after ${__privateGet(this, _maxReties)} retries, event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
       delete __privateGet(this, _messageWithAckPayloadRecords)[message.id];
       message.reject(message);
       return;
     }
     message.status = "INRETRY";
     message.retryCount++;
-    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk$1.magenta(`SocketIoMessageSender:ResponseTimout(): timeout reached, retrying. Retries: [${message.retryCount}], event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.magenta(`SocketIoMessageSender:ResponseTimout(): timeout reached, retrying. Retries: [${message.retryCount}], event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
     this.SendMessage(message);
   }
   SendMessage(message) {
@@ -5759,7 +5808,7 @@ class SocketIoMessageSender {
     };
     message.BoundAckListenerCallback = AckListenerCallback.bind(this);
     __privateGet(this, _socket).on(__privateMethod(this, _SocketIoMessageSender_instances, GetSubscribeKeepAliveAckEventName_fn).call(this, message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
-    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk$1.gray(`SocketIoMessageSender:SendMessage(): event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.gray(`SocketIoMessageSender:SendMessage(): event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
     __privateGet(this, _socket).emit(message.eventName, message.subscriptionKey);
   }
   SendMessageWithAck(eventName, subscriptionKey) {
@@ -5783,7 +5832,7 @@ class SocketIoMessageSender {
     const killIds = [];
     for (const [, message] of Object.entries(__privateGet(this, _messageWithAckPayloadRecords))) {
       if (message.subscriptionKey.id.localeCompare(subscriptionKey.id) === 0) {
-        __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk$1.blue(`SocketIoMessageSender:KillMessageInFlight(): event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+        __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.blue(`SocketIoMessageSender:KillMessageInFlight(): event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
         clearTimeout(message.timeoutId);
         delete message.timeoutId;
         __privateGet(this, _socket).off(__privateMethod(this, _SocketIoMessageSender_instances, GetSubscribeKeepAliveAckEventName_fn).call(this, message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
@@ -5829,7 +5878,7 @@ class ObservabilitySocketIOSubscriber {
     return __privateGet(this, _socket2);
   }
   set socket(socket) {
-    __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk$1.cyan(`ObservabilitySocketIOSubscriber:set socket(): new socket assigned`));
+    __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.cyan(`ObservabilitySocketIOSubscriber:set socket(): new socket assigned`));
     __privateSet(this, _socket2, socket);
     __privateGet(this, _socketIoMessageSender).socket = socket;
   }
@@ -5840,14 +5889,14 @@ class ObservabilitySocketIOSubscriber {
     const socket = __privateGet(this, _socket2);
     subscriptions.map(async (subId) => {
       __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subId);
-      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk$1.yellow(`ObservabilitySocketIOSubscriber:Subscribe(): Sending subscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
+      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.yellow(`ObservabilitySocketIOSubscriber:Subscribe(): Sending subscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
       try {
         const retVal = await __privateGet(this, _socketIoMessageSender).SendMessageWithAck("subscribe", subId.subscriptionKey);
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk$1.green(`ObservabilitySocketIOSubscriber:Subscribe(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
+        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.green(`ObservabilitySocketIOSubscriber:Subscribe(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
         __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, AddKeepAlive_fn2).call(this, socket, subId);
         socket.on(GetSocketIOSubscriptionKey(subId.subscriptionKey), subId.cb);
       } catch (error) {
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk$1.red(`ObservabilitySocketIOSubscriber:Subscribe(): Error: response: [${JSON.stringify(error)}]`));
+        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk.red(`ObservabilitySocketIOSubscriber:Subscribe(): Error: response: [${JSON.stringify(error)}]`));
         socket.off(GetSocketIOSubscriptionKey(subId.subscriptionKey), subId.cb);
         __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subId);
       }
@@ -5862,12 +5911,12 @@ class ObservabilitySocketIOSubscriber {
       socket.off(GetSocketIOSubscriptionKey(subId.subscriptionKey), subId.cb);
       __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subId);
       __privateGet(this, _socketIoMessageSender).KillMessageInFlight(subId.subscriptionKey);
-      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk$1.yellow(`ObservabilitySocketIOSubscriber:UnSubscribe(): Sending unsubscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
+      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.yellow(`ObservabilitySocketIOSubscriber:UnSubscribe(): Sending unsubscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
       try {
         const retVal = await __privateGet(this, _socketIoMessageSender).SendMessageWithAck("unsubscribe", subId.subscriptionKey);
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk$1.green(`ObservabilitySocketIOSubscriber:UnSubscribe(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
+        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.green(`ObservabilitySocketIOSubscriber:UnSubscribe(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
       } catch (error) {
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk$1.red(`ObservabilitySocketIOSubscriber:UnSubscribe(): Error response: [${JSON.stringify(error)}]`));
+        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk.red(`ObservabilitySocketIOSubscriber:UnSubscribe(): Error response: [${JSON.stringify(error)}]`));
       }
     });
   }
@@ -5901,13 +5950,13 @@ AddKeepAlive_fn2 = function(socket, subscription) {
   __privateGet(this, _socketSubscribeKeepAlive2)[subscription.subscriptionKey.id] = {
     id: subscription.subscriptionKey.id,
     timeout: setTimeout(async () => {
-      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk$1.yellow(`ObservabilitySocketIOSubscriber:#AddKeepAlive:timeoutCheck(): Sending keepAlive: subscriptionKey: [${subscription.subscriptionKey.id}]`));
+      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.yellow(`ObservabilitySocketIOSubscriber:#AddKeepAlive:timeoutCheck(): Sending keepAlive: subscriptionKey: [${subscription.subscriptionKey.id}]`));
       try {
         const retVal = await __privateGet(this, _socketIoMessageSender).SendMessageWithAck("subscribeKeepAlive", subscription.subscriptionKey);
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk$1.green(`ObservabilitySocketIOSubscriber:#AddKeepAlive(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
+        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.green(`ObservabilitySocketIOSubscriber:#AddKeepAlive(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
         __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, AddKeepAlive_fn2).call(this, socket, subscription);
       } catch (error) {
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk$1.red(`ObservabilitySocketIOSubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
+        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk.red(`ObservabilitySocketIOSubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
         socket.off(GetSocketIOSubscriptionKey(subscription.subscriptionKey), subscription.cb);
         __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subscription);
       }
@@ -5916,7 +5965,7 @@ AddKeepAlive_fn2 = function(socket, subscription) {
 };
 RemoveKeepAlive_fn2 = function(subscription) {
   if (__privateGet(this, _socketSubscribeKeepAlive2)[subscription.subscriptionKey.id]) {
-    __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk$1.gray(`ObservabilitySocketIOSubscriber:#RemoveKeepAlive(): subscriptionKey: [${subscription.subscriptionKey.id}]`));
+    __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.gray(`ObservabilitySocketIOSubscriber:#RemoveKeepAlive(): subscriptionKey: [${subscription.subscriptionKey.id}]`));
     clearTimeout(__privateGet(this, _socketSubscribeKeepAlive2)[subscription.subscriptionKey.id].timeout);
     delete __privateGet(this, _socketSubscribeKeepAlive2)[subscription.subscriptionKey.id];
   }
@@ -5963,7 +6012,7 @@ class ObservabilitySubscriptionManager {
     subscriptions.map((subscription) => {
       const retVal = this.subscriptions.find((v) => v.subscriptionKey.id.localeCompare(subscription.subscriptionKey.id) === 0);
       if (retVal) {
-        __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.magenta(`AddSubscription(): Subscription: [${retVal.subscriptionKey.id}] already exists - ignoring.`));
+        __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.magenta(`AddSubscription(): Subscription: [${retVal.subscriptionKey.id}] already exists - ignoring.`));
       } else {
         subscriptionsToAdd.push(subscription);
       }
@@ -5972,7 +6021,7 @@ class ObservabilitySubscriptionManager {
       subscriptionsToAdd.map((s) => this.subscriptions.push(s));
       (_a2 = __privateGet(this, _observabilitySocketIOSubscriber)) == null ? void 0 : _a2.Subscribe(subscriptionsToAdd);
     } else {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.magenta(`AddSubscription(): No valid subscriptions to subscribe.`));
+      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.magenta(`AddSubscription(): No valid subscriptions to subscribe.`));
     }
   }
   RemoveSubscriptionsByKey(keyToFind) {
@@ -6021,6 +6070,7 @@ class ObservabilitySubscriptionManager {
   }
   TransformSubscriptionPayloadCallback(subscriptionPayload, subscribeToKafka) {
     switch (subscriptionPayload.subscriptionKey.topic) {
+      // Services -----------------------------------------------------------------------------
       case SubscriptionTopic.AllServicesCombined:
         this.CreateModelAllServicesCombined(subscriptionPayload, subscribeToKafka);
         break;
@@ -6033,6 +6083,7 @@ class ObservabilitySubscriptionManager {
       case SubscriptionTopic.ServiceInstance:
         this.CreateModelServiceInstance(subscriptionPayload, subscribeToKafka);
         break;
+      // Lambda -----------------------------------------------------------------------------
       case SubscriptionTopic.AllLambdasCombined:
         this.CreateModelAllLambdasCombined(subscriptionPayload, subscribeToKafka);
         break;
@@ -6045,6 +6096,7 @@ class ObservabilitySubscriptionManager {
       case SubscriptionTopic.LambdaSubTechnologiesInstance:
         this.CreateModelLambdaSubTechnologiesInstance(subscriptionPayload, subscribeToKafka);
         break;
+      // Agents -----------------------------------------------------------------------------
       case SubscriptionTopic.AllAgentsCombined:
         this.CreateModelAllAgentsCombined(subscriptionPayload, subscribeToKafka);
         break;
@@ -6067,7 +6119,7 @@ class ObservabilitySubscriptionManager {
       if (subscriptionPayload.subscriptionKey.topic.localeCompare(SubscriptionTopic.AllServicesCombined.toString()) === 0) {
         __privateGet(this, _serviceModel)["STS-Service"] = ObservabilityModelUtils.GetModelForService("STS-Service", subscriptionPayload.data, subscribeToKafka, __privateGet(this, _options5).logger);
         if (__privateGet(this, _serviceModel)["STS-Service"] === null) {
-          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelAllServicesCombined():Error: GetModelForService() returned null`));
+          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAllServicesCombined():Error: GetModelForService() returned null`));
         }
       }
     } catch (error) {
@@ -6082,7 +6134,7 @@ class ObservabilitySubscriptionManager {
       for (const [serviceId, serviceTelemetry] of Object.entries(subscriptionPayload.data)) {
         __privateGet(this, _serviceModel)[serviceId] = ObservabilityModelUtils.GetModelForService(serviceId, serviceTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
         if (__privateGet(this, _serviceModel)[serviceId] === null) {
-          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelServices():Error: GetModelForService() returned null`));
+          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelServices():Error: GetModelForService() returned null`));
         }
       }
     } catch (error) {
@@ -6116,7 +6168,7 @@ class ObservabilitySubscriptionManager {
                 }
               }
             } else {
-              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelServiceInstances():Error: GetModelForService() returned null`));
+              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelServiceInstances():Error: GetModelForService() returned null`));
             }
           } else {
             if (subscribeToKafka) {
@@ -6159,7 +6211,7 @@ class ObservabilitySubscriptionManager {
                   }
                 }
               } else {
-                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelServiceInstance():Error: GetModelForService() returned null`));
+                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelServiceInstance():Error: GetModelForService() returned null`));
               }
             } else {
               if (subscribeToKafka) {
@@ -6184,7 +6236,7 @@ class ObservabilitySubscriptionManager {
         if (Object.keys(subscriptionPayload.data).length !== 0) {
           __privateGet(this, _agentModel)["STS-Agent"] = ObservabilityModelUtils.GetModelForAgent("STS-Agent", subscriptionPayload.data, subscribeToKafka, __privateGet(this, _options5).logger);
           if (__privateGet(this, _agentModel)["STS-Agent"] === null) {
-            __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelAllAgentsCombined():Error: GetModelForAgent() returned null`));
+            __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAllAgentsCombined():Error: GetModelForAgent() returned null`));
           }
         }
       }
@@ -6218,7 +6270,7 @@ class ObservabilitySubscriptionManager {
               }
             }
           } else {
-            __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelAgents():Error: GetModelForAgent() returned null`));
+            __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAgents():Error: GetModelForAgent() returned null`));
           }
         } else {
           if (subscribeToKafka) {
@@ -6229,7 +6281,7 @@ class ObservabilitySubscriptionManager {
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk$1.red(`UIControllerAgent:CreateModel(): Error: [${error}]`));
+      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk.red(`UIControllerAgent:CreateModel(): Error: [${error}]`));
     }
   }
   // /agentId/agentWorkerId
@@ -6262,7 +6314,7 @@ class ObservabilitySubscriptionManager {
                 }
               }
             } else {
-              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelAgentWorkers():Error: GetModelForAgent() returned null`));
+              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAgentWorkers():Error: GetModelForAgent() returned null`));
             }
           } else {
             if (subscribeToKafka) {
@@ -6274,7 +6326,7 @@ class ObservabilitySubscriptionManager {
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk$1.red(`UIControllerAgentThreads:CreateModel(): Error: [${error}]`));
+      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk.red(`UIControllerAgentThreads:CreateModel(): Error: [${error}]`));
     }
   }
   // /agentId/agentWorkerId/asyncRunnerId
@@ -6304,7 +6356,7 @@ class ObservabilitySubscriptionManager {
                   }
                 }
               } else {
-                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelAgentWorker():Error: GetModelForAgent() returned null`));
+                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAgentWorker():Error: GetModelForAgent() returned null`));
               }
             } else {
               if (subscribeToKafka) {
@@ -6317,7 +6369,7 @@ class ObservabilitySubscriptionManager {
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk$1.red(`UIControllerAgentThread:CreateModel(): Error: [${error}]`));
+      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk.red(`UIControllerAgentThread:CreateModel(): Error: [${error}]`));
     }
   }
   // --- [ Lambdas ] ------------------------------------------------------------------------------------------------------------------------------------------------
@@ -6328,7 +6380,7 @@ class ObservabilitySubscriptionManager {
       if (subscriptionPayload.subscriptionKey.topic.localeCompare(SubscriptionTopic.AllLambdasCombined.toString()) === 0) {
         __privateGet(this, _lambdaModel)["STS-Lambda"] = ObservabilityModelUtils.GetModelForLambda("STS-Lambda", subscriptionPayload.data, subscribeToKafka, __privateGet(this, _options5).logger);
         if (__privateGet(this, _lambdaModel)["STS-Lambda"] === null) {
-          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelAllLambdasCombined():Error: GetModelForLambda() returned null`));
+          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAllLambdasCombined():Error: GetModelForLambda() returned null`));
         }
       }
     } catch (error) {
@@ -6343,7 +6395,7 @@ class ObservabilitySubscriptionManager {
       for (const [technologyId, technologyTelemetry] of Object.entries(subscriptionPayload.data)) {
         __privateGet(this, _lambdaModel)[technologyId] = ObservabilityModelUtils.GetModelForLambda(technologyId, technologyTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
         if (__privateGet(this, _lambdaModel)[technologyId] === null) {
-          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelLambdaTechnologies():Error: GetModelForLambda() returned null`));
+          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelLambdaTechnologies():Error: GetModelForLambda() returned null`));
         }
       }
     } catch (error) {
@@ -6377,7 +6429,7 @@ class ObservabilitySubscriptionManager {
                 }
               }
             } else {
-              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelLambdaSubTechnologies():Error: GetModelForLambda() returned null`));
+              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelLambdaSubTechnologies():Error: GetModelForLambda() returned null`));
             }
           } else {
             if (subscribeToKafka) {
@@ -6420,7 +6472,7 @@ class ObservabilitySubscriptionManager {
                   }
                 }
               } else {
-                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk$1.red(`CreateModelLambdaSubTechnologiesInstance():Error: GetModelForLambda() returned null`));
+                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelLambdaSubTechnologiesInstance():Error: GetModelForLambda() returned null`));
               }
             } else {
               if (subscribeToKafka) {