@nsshunt/stsobservability 1.0.97 → 1.0.99

package/dist/stsobservability.umd.js

@@ -3943,11 +3943,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   var sourceExports = requireSource();
   const chalk = /* @__PURE__ */ getDefaultExportFromCjs(sourceExports);
   function utf8Count(str) {
-    var strLength = str.length;
-    var byteLength = 0;
-    var pos = 0;
+    const strLength = str.length;
+    let byteLength = 0;
+    let pos = 0;
     while (pos < strLength) {
-      var value = str.charCodeAt(pos++);
+      let value = str.charCodeAt(pos++);
       if ((value & 4294967168) === 0) {
         byteLength++;
         continue;
@@ -3956,7 +3956,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       } else {
         if (value >= 55296 && value <= 56319) {
           if (pos < strLength) {
-            var extra = str.charCodeAt(pos);
+            const extra = str.charCodeAt(pos);
             if ((extra & 64512) === 56320) {
               ++pos;
               value = ((value & 1023) << 10) + (extra & 1023) + 65536;
@@ -3973,11 +3973,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     return byteLength;
   }
   function utf8EncodeJs(str, output, outputOffset) {
-    var strLength = str.length;
-    var offset = outputOffset;
-    var pos = 0;
+    const strLength = str.length;
+    let offset = outputOffset;
+    let pos = 0;
     while (pos < strLength) {
-      var value = str.charCodeAt(pos++);
+      let value = str.charCodeAt(pos++);
       if ((value & 4294967168) === 0) {
         output[offset++] = value;
         continue;
@@ -3986,7 +3986,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       } else {
         if (value >= 55296 && value <= 56319) {
           if (pos < strLength) {
-            var extra = str.charCodeAt(pos);
+            const extra = str.charCodeAt(pos);
             if ((extra & 64512) === 56320) {
               ++pos;
               value = ((value & 1023) << 10) + (extra & 1023) + 65536;
@@ -4005,8 +4005,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       output[offset++] = value & 63 | 128;
     }
   }
-  var sharedTextEncoder = new TextEncoder();
-  var TEXT_ENCODER_THRESHOLD = 50;
+  const sharedTextEncoder = new TextEncoder();
+  const TEXT_ENCODER_THRESHOLD = 50;
   function utf8EncodeTE(str, output, outputOffset) {
     sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
   }
@@ -4018,103 +4018,73 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     }
   }
   new TextDecoder();
-  var ExtData = (
-    /** @class */
-    /* @__PURE__ */ function() {
-      function ExtData2(type, data) {
-        this.type = type;
-        this.data = data;
-      }
-      return ExtData2;
-    }()
-  );
-  var __extends = /* @__PURE__ */ function() {
-    var extendStatics = function(d, b) {
-      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-        d2.__proto__ = b2;
-      } || function(d2, b2) {
-        for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
-      };
-      return extendStatics(d, b);
-    };
-    return function(d, b) {
-      if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-      extendStatics(d, b);
-      function __() {
-        this.constructor = d;
-      }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-  }();
-  var DecodeError = (
-    /** @class */
-    function(_super) {
-      __extends(DecodeError2, _super);
-      function DecodeError2(message) {
-        var _this = _super.call(this, message) || this;
-        var proto = Object.create(DecodeError2.prototype);
-        Object.setPrototypeOf(_this, proto);
-        Object.defineProperty(_this, "name", {
-          configurable: true,
-          enumerable: false,
-          value: DecodeError2.name
-        });
-        return _this;
-      }
-      return DecodeError2;
-    }(Error)
-  );
+  class ExtData {
+    constructor(type, data) {
+      this.type = type;
+      this.data = data;
+    }
+  }
+  class DecodeError extends Error {
+    constructor(message) {
+      super(message);
+      const proto = Object.create(DecodeError.prototype);
+      Object.setPrototypeOf(this, proto);
+      Object.defineProperty(this, "name", {
+        configurable: true,
+        enumerable: false,
+        value: DecodeError.name
+      });
+    }
+  }
   function setUint64(view, offset, value) {
-    var high = value / 4294967296;
-    var low = value;
+    const high = value / 4294967296;
+    const low = value;
     view.setUint32(offset, high);
     view.setUint32(offset + 4, low);
   }
   function setInt64(view, offset, value) {
-    var high = Math.floor(value / 4294967296);
-    var low = value;
+    const high = Math.floor(value / 4294967296);
+    const low = value;
     view.setUint32(offset, high);
     view.setUint32(offset + 4, low);
   }
   function getInt64(view, offset) {
-    var high = view.getInt32(offset);
-    var low = view.getUint32(offset + 4);
+    const high = view.getInt32(offset);
+    const low = view.getUint32(offset + 4);
     return high * 4294967296 + low;
   }
-  var EXT_TIMESTAMP = -1;
-  var TIMESTAMP32_MAX_SEC = 4294967296 - 1;
-  var TIMESTAMP64_MAX_SEC = 17179869184 - 1;
-  function encodeTimeSpecToTimestamp(_a2) {
-    var sec = _a2.sec, nsec = _a2.nsec;
+  const EXT_TIMESTAMP = -1;
+  const TIMESTAMP32_MAX_SEC = 4294967296 - 1;
+  const TIMESTAMP64_MAX_SEC = 17179869184 - 1;
+  function encodeTimeSpecToTimestamp({ sec, nsec }) {
     if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
       if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
-        var rv = new Uint8Array(4);
-        var view = new DataView(rv.buffer);
+        const rv = new Uint8Array(4);
+        const view = new DataView(rv.buffer);
         view.setUint32(0, sec);
         return rv;
       } else {
-        var secHigh = sec / 4294967296;
-        var secLow = sec & 4294967295;
-        var rv = new Uint8Array(8);
-        var view = new DataView(rv.buffer);
+        const secHigh = sec / 4294967296;
+        const secLow = sec & 4294967295;
+        const rv = new Uint8Array(8);
+        const view = new DataView(rv.buffer);
         view.setUint32(0, nsec << 2 | secHigh & 3);
         view.setUint32(4, secLow);
         return rv;
       }
     } else {
-      var rv = new Uint8Array(12);
-      var view = new DataView(rv.buffer);
+      const rv = new Uint8Array(12);
+      const view = new DataView(rv.buffer);
       view.setUint32(0, nsec);
       setInt64(view, 4, sec);
       return rv;
     }
   }
   function encodeDateToTimeSpec(date) {
-    var msec = date.getTime();
-    var sec = Math.floor(msec / 1e3);
-    var nsec = (msec - sec * 1e3) * 1e6;
-    var nsecInSec = Math.floor(nsec / 1e9);
+    const msec = date.getTime();
+    const sec = Math.floor(msec / 1e3);
+    const nsec = (msec - sec * 1e3) * 1e6;
+    const nsecInSec = Math.floor(nsec / 1e9);
     return {
       sec: sec + nsecInSec,
       nsec: nsec - nsecInSec * 1e9
@@ -4122,105 +4092,100 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   }
   function encodeTimestampExtension(object) {
     if (object instanceof Date) {
-      var timeSpec = encodeDateToTimeSpec(object);
+      const timeSpec = encodeDateToTimeSpec(object);
       return encodeTimeSpecToTimestamp(timeSpec);
     } else {
       return null;
     }
   }
   function decodeTimestampToTimeSpec(data) {
-    var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
     switch (data.byteLength) {
       case 4: {
-        var sec = view.getUint32(0);
-        var nsec = 0;
+        const sec = view.getUint32(0);
+        const nsec = 0;
         return { sec, nsec };
       }
       case 8: {
-        var nsec30AndSecHigh2 = view.getUint32(0);
-        var secLow32 = view.getUint32(4);
-        var sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
-        var nsec = nsec30AndSecHigh2 >>> 2;
+        const nsec30AndSecHigh2 = view.getUint32(0);
+        const secLow32 = view.getUint32(4);
+        const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+        const nsec = nsec30AndSecHigh2 >>> 2;
         return { sec, nsec };
       }
       case 12: {
-        var sec = getInt64(view, 4);
-        var nsec = view.getUint32(0);
+        const sec = getInt64(view, 4);
+        const nsec = view.getUint32(0);
         return { sec, nsec };
       }
       default:
-        throw new DecodeError("Unrecognized data size for timestamp (expected 4, 8, or 12): ".concat(data.length));
+        throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
     }
   }
   function decodeTimestampExtension(data) {
-    var timeSpec = decodeTimestampToTimeSpec(data);
+    const timeSpec = decodeTimestampToTimeSpec(data);
     return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
   }
-  var timestampExtension = {
+  const timestampExtension = {
     type: EXT_TIMESTAMP,
     encode: encodeTimestampExtension,
     decode: decodeTimestampExtension
   };
-  var ExtensionCodec = (
-    /** @class */
-    function() {
-      function ExtensionCodec2() {
-        this.builtInEncoders = [];
-        this.builtInDecoders = [];
-        this.encoders = [];
-        this.decoders = [];
-        this.register(timestampExtension);
-      }
-      ExtensionCodec2.prototype.register = function(_a2) {
-        var type = _a2.type, encode2 = _a2.encode, decode = _a2.decode;
-        if (type >= 0) {
-          this.encoders[type] = encode2;
-          this.decoders[type] = decode;
-        } else {
-          var index = 1 + type;
-          this.builtInEncoders[index] = encode2;
-          this.builtInDecoders[index] = decode;
-        }
-      };
-      ExtensionCodec2.prototype.tryToEncode = function(object, context) {
-        for (var i = 0; i < this.builtInEncoders.length; i++) {
-          var encodeExt = this.builtInEncoders[i];
-          if (encodeExt != null) {
-            var data = encodeExt(object, context);
-            if (data != null) {
-              var type = -1 - i;
-              return new ExtData(type, data);
-            }
+  class ExtensionCodec {
+    constructor() {
+      this.builtInEncoders = [];
+      this.builtInDecoders = [];
+      this.encoders = [];
+      this.decoders = [];
+      this.register(timestampExtension);
+    }
+    register({ type, encode: encode2, decode }) {
+      if (type >= 0) {
+        this.encoders[type] = encode2;
+        this.decoders[type] = decode;
+      } else {
+        const index = -1 - type;
+        this.builtInEncoders[index] = encode2;
+        this.builtInDecoders[index] = decode;
+      }
+    }
+    tryToEncode(object, context) {
+      for (let i = 0; i < this.builtInEncoders.length; i++) {
+        const encodeExt = this.builtInEncoders[i];
+        if (encodeExt != null) {
+          const data = encodeExt(object, context);
+          if (data != null) {
+            const type = -1 - i;
+            return new ExtData(type, data);
           }
         }
-        for (var i = 0; i < this.encoders.length; i++) {
-          var encodeExt = this.encoders[i];
-          if (encodeExt != null) {
-            var data = encodeExt(object, context);
-            if (data != null) {
-              var type = i;
-              return new ExtData(type, data);
-            }
+      }
+      for (let i = 0; i < this.encoders.length; i++) {
+        const encodeExt = this.encoders[i];
+        if (encodeExt != null) {
+          const data = encodeExt(object, context);
+          if (data != null) {
+            const type = i;
+            return new ExtData(type, data);
           }
         }
-        if (object instanceof ExtData) {
-          return object;
-        }
-        return null;
-      };
-      ExtensionCodec2.prototype.decode = function(data, type, context) {
-        var decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
-        if (decodeExt) {
-          return decodeExt(data, type, context);
-        } else {
-          return new ExtData(type, data);
-        }
-      };
-      ExtensionCodec2.defaultCodec = new ExtensionCodec2();
-      return ExtensionCodec2;
-    }()
-  );
-  function isArrayBuffer(buffer) {
+      }
+      if (object instanceof ExtData) {
+        return object;
+      }
+      return null;
+    }
+    decode(data, type, context) {
+      const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+      if (decodeExt) {
+        return decodeExt(data, type, context);
+      } else {
+        return new ExtData(type, data);
+      }
+    }
+  }
+  ExtensionCodec.defaultCodec = new ExtensionCodec();
+  function isArrayBufferLike(buffer) {
     return buffer instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
   }
   function ensureUint8Array(buffer) {
@@ -4228,359 +4193,477 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       return buffer;
     } else if (ArrayBuffer.isView(buffer)) {
       return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    } else if (isArrayBuffer(buffer)) {
+    } else if (isArrayBufferLike(buffer)) {
       return new Uint8Array(buffer);
     } else {
       return Uint8Array.from(buffer);
     }
   }
-  var DEFAULT_MAX_DEPTH = 100;
-  var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
-  var Encoder = (
-    /** @class */
-    function() {
-      function Encoder2(options) {
-        var _a2, _b, _c, _d, _e, _f, _g, _h;
-        this.extensionCodec = (_a2 = options === null || options === void 0 ? void 0 : options.extensionCodec) !== null && _a2 !== void 0 ? _a2 : ExtensionCodec.defaultCodec;
-        this.context = options === null || options === void 0 ? void 0 : options.context;
-        this.useBigInt64 = (_b = options === null || options === void 0 ? void 0 : options.useBigInt64) !== null && _b !== void 0 ? _b : false;
-        this.maxDepth = (_c = options === null || options === void 0 ? void 0 : options.maxDepth) !== null && _c !== void 0 ? _c : DEFAULT_MAX_DEPTH;
-        this.initialBufferSize = (_d = options === null || options === void 0 ? void 0 : options.initialBufferSize) !== null && _d !== void 0 ? _d : DEFAULT_INITIAL_BUFFER_SIZE;
-        this.sortKeys = (_e = options === null || options === void 0 ? void 0 : options.sortKeys) !== null && _e !== void 0 ? _e : false;
-        this.forceFloat32 = (_f = options === null || options === void 0 ? void 0 : options.forceFloat32) !== null && _f !== void 0 ? _f : false;
-        this.ignoreUndefined = (_g = options === null || options === void 0 ? void 0 : options.ignoreUndefined) !== null && _g !== void 0 ? _g : false;
-        this.forceIntegerToFloat = (_h = options === null || options === void 0 ? void 0 : options.forceIntegerToFloat) !== null && _h !== void 0 ? _h : false;
-        this.pos = 0;
-        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
-        this.bytes = new Uint8Array(this.view.buffer);
-      }
-      Encoder2.prototype.reinitializeState = function() {
-        this.pos = 0;
+  var __addDisposableResource = function(env, value, async) {
+    if (value !== null && value !== void 0) {
+      if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+      var dispose, inner;
+      if (async) {
+        if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+        dispose = value[Symbol.asyncDispose];
+      }
+      if (dispose === void 0) {
+        if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+        dispose = value[Symbol.dispose];
+        if (async) inner = dispose;
+      }
+      if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+      if (inner) dispose = function() {
+        try {
+          inner.call(this);
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      };
+      env.stack.push({ value, dispose, async });
+    } else if (async) {
+      env.stack.push({ async: true });
+    }
+    return value;
+  };
+  var __disposeResources = /* @__PURE__ */ function(SuppressedError2) {
+    return function(env) {
+      function fail(e) {
+        env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e;
+        env.hasError = true;
+      }
+      var r, s = 0;
+      function next() {
+        while (r = env.stack.pop()) {
+          try {
+            if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+            if (r.dispose) {
+              var result = r.dispose.call(r.value);
+              if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                fail(e);
+                return next();
+              });
+            } else s |= 1;
+          } catch (e) {
+            fail(e);
+          }
+        }
+        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+        if (env.hasError) throw env.error;
+      }
+      return next();
+    };
+  }(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  });
+  const DEFAULT_MAX_DEPTH = 100;
+  const DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+  class Encoder {
+    constructor(options) {
+      this.entered = false;
+      this.extensionCodec = (options == null ? void 0 : options.extensionCodec) ?? ExtensionCodec.defaultCodec;
+      this.context = options == null ? void 0 : options.context;
+      this.useBigInt64 = (options == null ? void 0 : options.useBigInt64) ?? false;
+      this.maxDepth = (options == null ? void 0 : options.maxDepth) ?? DEFAULT_MAX_DEPTH;
+      this.initialBufferSize = (options == null ? void 0 : options.initialBufferSize) ?? DEFAULT_INITIAL_BUFFER_SIZE;
+      this.sortKeys = (options == null ? void 0 : options.sortKeys) ?? false;
+      this.forceFloat32 = (options == null ? void 0 : options.forceFloat32) ?? false;
+      this.ignoreUndefined = (options == null ? void 0 : options.ignoreUndefined) ?? false;
+      this.forceIntegerToFloat = (options == null ? void 0 : options.forceIntegerToFloat) ?? false;
+      this.pos = 0;
+      this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+      this.bytes = new Uint8Array(this.view.buffer);
+    }
+    clone() {
+      return new Encoder({
+        extensionCodec: this.extensionCodec,
+        context: this.context,
+        useBigInt64: this.useBigInt64,
+        maxDepth: this.maxDepth,
+        initialBufferSize: this.initialBufferSize,
+        sortKeys: this.sortKeys,
+        forceFloat32: this.forceFloat32,
+        ignoreUndefined: this.ignoreUndefined,
+        forceIntegerToFloat: this.forceIntegerToFloat
+      });
+    }
+    reinitializeState() {
+      this.pos = 0;
+    }
+    enteringGuard() {
+      this.entered = true;
+      return {
+        [Symbol.dispose]: () => {
+          this.entered = false;
+        }
       };
-      Encoder2.prototype.encodeSharedRef = function(object) {
+    }
+    /**
+     * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+     *
+     * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+     */
+    encodeSharedRef(object) {
+      const env_1 = { stack: [], error: void 0, hasError: false };
+      try {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.encodeSharedRef(object);
+        }
+        const _guard = __addDisposableResource(env_1, this.enteringGuard(), false);
         this.reinitializeState();
         this.doEncode(object, 1);
         return this.bytes.subarray(0, this.pos);
-      };
-      Encoder2.prototype.encode = function(object) {
+      } catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+      } finally {
+        __disposeResources(env_1);
+      }
+    }
+    /**
+     * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+     */
+    encode(object) {
+      const env_2 = { stack: [], error: void 0, hasError: false };
+      try {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.encode(object);
+        }
+        const _guard = __addDisposableResource(env_2, this.enteringGuard(), false);
         this.reinitializeState();
         this.doEncode(object, 1);
         return this.bytes.slice(0, this.pos);
-      };
-      Encoder2.prototype.doEncode = function(object, depth) {
-        if (depth > this.maxDepth) {
-          throw new Error("Too deep objects in depth ".concat(depth));
-        }
-        if (object == null) {
-          this.encodeNil();
-        } else if (typeof object === "boolean") {
-          this.encodeBoolean(object);
-        } else if (typeof object === "number") {
-          if (!this.forceIntegerToFloat) {
-            this.encodeNumber(object);
+      } catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+      } finally {
+        __disposeResources(env_2);
+      }
+    }
+    doEncode(object, depth) {
+      if (depth > this.maxDepth) {
+        throw new Error(`Too deep objects in depth ${depth}`);
+      }
+      if (object == null) {
+        this.encodeNil();
+      } else if (typeof object === "boolean") {
+        this.encodeBoolean(object);
+      } else if (typeof object === "number") {
+        if (!this.forceIntegerToFloat) {
+          this.encodeNumber(object);
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      } else if (typeof object === "string") {
+        this.encodeString(object);
+      } else if (this.useBigInt64 && typeof object === "bigint") {
+        this.encodeBigInt64(object);
+      } else {
+        this.encodeObject(object, depth);
+      }
+    }
+    ensureBufferSizeToWrite(sizeToWrite) {
+      const requiredSize = this.pos + sizeToWrite;
+      if (this.view.byteLength < requiredSize) {
+        this.resizeBuffer(requiredSize * 2);
+      }
+    }
+    resizeBuffer(newSize) {
+      const newBuffer = new ArrayBuffer(newSize);
+      const newBytes = new Uint8Array(newBuffer);
+      const newView = new DataView(newBuffer);
+      newBytes.set(this.bytes);
+      this.view = newView;
+      this.bytes = newBytes;
+    }
+    encodeNil() {
+      this.writeU8(192);
+    }
+    encodeBoolean(object) {
+      if (object === false) {
+        this.writeU8(194);
+      } else {
+        this.writeU8(195);
+      }
+    }
+    encodeNumber(object) {
+      if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+        if (object >= 0) {
+          if (object < 128) {
+            this.writeU8(object);
+          } else if (object < 256) {
+            this.writeU8(204);
+            this.writeU8(object);
+          } else if (object < 65536) {
+            this.writeU8(205);
+            this.writeU16(object);
+          } else if (object < 4294967296) {
+            this.writeU8(206);
+            this.writeU32(object);
+          } else if (!this.useBigInt64) {
+            this.writeU8(207);
+            this.writeU64(object);
           } else {
             this.encodeNumberAsFloat(object);
           }
-        } else if (typeof object === "string") {
-          this.encodeString(object);
-        } else if (this.useBigInt64 && typeof object === "bigint") {
-          this.encodeBigInt64(object);
         } else {
-          this.encodeObject(object, depth);
-        }
-      };
-      Encoder2.prototype.ensureBufferSizeToWrite = function(sizeToWrite) {
-        var requiredSize = this.pos + sizeToWrite;
-        if (this.view.byteLength < requiredSize) {
-          this.resizeBuffer(requiredSize * 2);
-        }
-      };
-      Encoder2.prototype.resizeBuffer = function(newSize) {
-        var newBuffer = new ArrayBuffer(newSize);
-        var newBytes = new Uint8Array(newBuffer);
-        var newView = new DataView(newBuffer);
-        newBytes.set(this.bytes);
-        this.view = newView;
-        this.bytes = newBytes;
-      };
-      Encoder2.prototype.encodeNil = function() {
-        this.writeU8(192);
-      };
-      Encoder2.prototype.encodeBoolean = function(object) {
-        if (object === false) {
-          this.writeU8(194);
-        } else {
-          this.writeU8(195);
-        }
-      };
-      Encoder2.prototype.encodeNumber = function(object) {
-        if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
-          if (object >= 0) {
-            if (object < 128) {
-              this.writeU8(object);
-            } else if (object < 256) {
-              this.writeU8(204);
-              this.writeU8(object);
-            } else if (object < 65536) {
-              this.writeU8(205);
-              this.writeU16(object);
-            } else if (object < 4294967296) {
-              this.writeU8(206);
-              this.writeU32(object);
-            } else if (!this.useBigInt64) {
-              this.writeU8(207);
-              this.writeU64(object);
-            } else {
-              this.encodeNumberAsFloat(object);
-            }
+          if (object >= -32) {
+            this.writeU8(224 | object + 32);
+          } else if (object >= -128) {
+            this.writeU8(208);
+            this.writeI8(object);
+          } else if (object >= -32768) {
+            this.writeU8(209);
+            this.writeI16(object);
+          } else if (object >= -2147483648) {
+            this.writeU8(210);
+            this.writeI32(object);
+          } else if (!this.useBigInt64) {
+            this.writeU8(211);
+            this.writeI64(object);
           } else {
-            if (object >= -32) {
-              this.writeU8(224 | object + 32);
-            } else if (object >= -128) {
-              this.writeU8(208);
-              this.writeI8(object);
-            } else if (object >= -32768) {
-              this.writeU8(209);
-              this.writeI16(object);
-            } else if (object >= -2147483648) {
-              this.writeU8(210);
-              this.writeI32(object);
-            } else if (!this.useBigInt64) {
-              this.writeU8(211);
-              this.writeI64(object);
-            } else {
-              this.encodeNumberAsFloat(object);
-            }
+            this.encodeNumberAsFloat(object);
           }
-        } else {
-          this.encodeNumberAsFloat(object);
         }
-      };
-      Encoder2.prototype.encodeNumberAsFloat = function(object) {
-        if (this.forceFloat32) {
-          this.writeU8(202);
-          this.writeF32(object);
-        } else {
-          this.writeU8(203);
-          this.writeF64(object);
-        }
-      };
-      Encoder2.prototype.encodeBigInt64 = function(object) {
-        if (object >= BigInt(0)) {
-          this.writeU8(207);
-          this.writeBigUint64(object);
-        } else {
-          this.writeU8(211);
-          this.writeBigInt64(object);
-        }
-      };
-      Encoder2.prototype.writeStringHeader = function(byteLength) {
-        if (byteLength < 32) {
-          this.writeU8(160 + byteLength);
-        } else if (byteLength < 256) {
-          this.writeU8(217);
-          this.writeU8(byteLength);
-        } else if (byteLength < 65536) {
-          this.writeU8(218);
-          this.writeU16(byteLength);
-        } else if (byteLength < 4294967296) {
-          this.writeU8(219);
-          this.writeU32(byteLength);
-        } else {
-          throw new Error("Too long string: ".concat(byteLength, " bytes in UTF-8"));
-        }
-      };
-      Encoder2.prototype.encodeString = function(object) {
-        var maxHeaderSize = 1 + 4;
-        var byteLength = utf8Count(object);
-        this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
-        this.writeStringHeader(byteLength);
-        utf8Encode(object, this.bytes, this.pos);
-        this.pos += byteLength;
-      };
-      Encoder2.prototype.encodeObject = function(object, depth) {
-        var ext = this.extensionCodec.tryToEncode(object, this.context);
-        if (ext != null) {
-          this.encodeExtension(ext);
-        } else if (Array.isArray(object)) {
-          this.encodeArray(object, depth);
-        } else if (ArrayBuffer.isView(object)) {
-          this.encodeBinary(object);
-        } else if (typeof object === "object") {
-          this.encodeMap(object, depth);
-        } else {
-          throw new Error("Unrecognized object: ".concat(Object.prototype.toString.apply(object)));
-        }
-      };
-      Encoder2.prototype.encodeBinary = function(object) {
-        var size = object.byteLength;
-        if (size < 256) {
-          this.writeU8(196);
-          this.writeU8(size);
-        } else if (size < 65536) {
-          this.writeU8(197);
-          this.writeU16(size);
-        } else if (size < 4294967296) {
-          this.writeU8(198);
-          this.writeU32(size);
-        } else {
-          throw new Error("Too large binary: ".concat(size));
-        }
-        var bytes = ensureUint8Array(object);
-        this.writeU8a(bytes);
-      };
-      Encoder2.prototype.encodeArray = function(object, depth) {
-        var size = object.length;
-        if (size < 16) {
-          this.writeU8(144 + size);
-        } else if (size < 65536) {
-          this.writeU8(220);
-          this.writeU16(size);
-        } else if (size < 4294967296) {
-          this.writeU8(221);
-          this.writeU32(size);
-        } else {
-          throw new Error("Too large array: ".concat(size));
-        }
-        for (var _i = 0, object_1 = object; _i < object_1.length; _i++) {
-          var item = object_1[_i];
-          this.doEncode(item, depth + 1);
-        }
-      };
-      Encoder2.prototype.countWithoutUndefined = function(object, keys) {
-        var count = 0;
-        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-          var key = keys_1[_i];
-          if (object[key] !== void 0) {
-            count++;
-          }
+      } else {
+        this.encodeNumberAsFloat(object);
+      }
+    }
+    encodeNumberAsFloat(object) {
+      if (this.forceFloat32) {
+        this.writeU8(202);
+        this.writeF32(object);
+      } else {
+        this.writeU8(203);
+        this.writeF64(object);
+      }
+    }
+    encodeBigInt64(object) {
+      if (object >= BigInt(0)) {
+        this.writeU8(207);
+        this.writeBigUint64(object);
+      } else {
+        this.writeU8(211);
+        this.writeBigInt64(object);
+      }
+    }
+    writeStringHeader(byteLength) {
+      if (byteLength < 32) {
+        this.writeU8(160 + byteLength);
+      } else if (byteLength < 256) {
+        this.writeU8(217);
+        this.writeU8(byteLength);
+      } else if (byteLength < 65536) {
+        this.writeU8(218);
+        this.writeU16(byteLength);
+      } else if (byteLength < 4294967296) {
+        this.writeU8(219);
+        this.writeU32(byteLength);
+      } else {
+        throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+      }
+    }
+    encodeString(object) {
+      const maxHeaderSize = 1 + 4;
+      const byteLength = utf8Count(object);
+      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+      this.writeStringHeader(byteLength);
+      utf8Encode(object, this.bytes, this.pos);
+      this.pos += byteLength;
+    }
+    encodeObject(object, depth) {
+      const ext = this.extensionCodec.tryToEncode(object, this.context);
+      if (ext != null) {
+        this.encodeExtension(ext);
+      } else if (Array.isArray(object)) {
+        this.encodeArray(object, depth);
+      } else if (ArrayBuffer.isView(object)) {
+        this.encodeBinary(object);
+      } else if (typeof object === "object") {
+        this.encodeMap(object, depth);
+      } else {
+        throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+      }
+    }
+    encodeBinary(object) {
+      const size = object.byteLength;
+      if (size < 256) {
+        this.writeU8(196);
+        this.writeU8(size);
+      } else if (size < 65536) {
+        this.writeU8(197);
+        this.writeU16(size);
+      } else if (size < 4294967296) {
+        this.writeU8(198);
+        this.writeU32(size);
+      } else {
+        throw new Error(`Too large binary: ${size}`);
+      }
+      const bytes = ensureUint8Array(object);
+      this.writeU8a(bytes);
+    }
+    encodeArray(object, depth) {
+      const size = object.length;
+      if (size < 16) {
+        this.writeU8(144 + size);
+      } else if (size < 65536) {
+        this.writeU8(220);
+        this.writeU16(size);
+      } else if (size < 4294967296) {
+        this.writeU8(221);
+        this.writeU32(size);
+      } else {
+        throw new Error(`Too large array: ${size}`);
+      }
+      for (const item of object) {
+        this.doEncode(item, depth + 1);
+      }
+    }
+    countWithoutUndefined(object, keys) {
+      let count = 0;
+      for (const key of keys) {
+        if (object[key] !== void 0) {
+          count++;
         }
-        return count;
-      };
-      Encoder2.prototype.encodeMap = function(object, depth) {
-        var keys = Object.keys(object);
-        if (this.sortKeys) {
-          keys.sort();
-        }
-        var size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
-        if (size < 16) {
-          this.writeU8(128 + size);
-        } else if (size < 65536) {
-          this.writeU8(222);
-          this.writeU16(size);
-        } else if (size < 4294967296) {
-          this.writeU8(223);
-          this.writeU32(size);
-        } else {
-          throw new Error("Too large map object: ".concat(size));
-        }
-        for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
-          var key = keys_2[_i];
-          var value = object[key];
-          if (!(this.ignoreUndefined && value === void 0)) {
-            this.encodeString(key);
-            this.doEncode(value, depth + 1);
-          }
+      }
+      return count;
+    }
+    encodeMap(object, depth) {
+      const keys = Object.keys(object);
+      if (this.sortKeys) {
+        keys.sort();
+      }
+      const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+      if (size < 16) {
+        this.writeU8(128 + size);
+      } else if (size < 65536) {
+        this.writeU8(222);
+        this.writeU16(size);
+      } else if (size < 4294967296) {
+        this.writeU8(223);
+        this.writeU32(size);
+      } else {
+        throw new Error(`Too large map object: ${size}`);
+      }
+      for (const key of keys) {
+        const value = object[key];
+        if (!(this.ignoreUndefined && value === void 0)) {
+          this.encodeString(key);
+          this.doEncode(value, depth + 1);
         }
-      };
-      Encoder2.prototype.encodeExtension = function(ext) {
-        var size = ext.data.length;
-        if (size === 1) {
-          this.writeU8(212);
-        } else if (size === 2) {
-          this.writeU8(213);
-        } else if (size === 4) {
-          this.writeU8(214);
-        } else if (size === 8) {
-          this.writeU8(215);
-        } else if (size === 16) {
-          this.writeU8(216);
-        } else if (size < 256) {
-          this.writeU8(199);
-          this.writeU8(size);
-        } else if (size < 65536) {
-          this.writeU8(200);
-          this.writeU16(size);
-        } else if (size < 4294967296) {
-          this.writeU8(201);
-          this.writeU32(size);
-        } else {
-          throw new Error("Too large extension object: ".concat(size));
+      }
+    }
+    encodeExtension(ext) {
+      if (typeof ext.data === "function") {
+        const data = ext.data(this.pos + 6);
+        const size2 = data.length;
+        if (size2 >= 4294967296) {
+          throw new Error(`Too large extension object: ${size2}`);
         }
+        this.writeU8(201);
+        this.writeU32(size2);
         this.writeI8(ext.type);
-        this.writeU8a(ext.data);
-      };
-      Encoder2.prototype.writeU8 = function(value) {
-        this.ensureBufferSizeToWrite(1);
-        this.view.setUint8(this.pos, value);
-        this.pos++;
-      };
-      Encoder2.prototype.writeU8a = function(values) {
-        var size = values.length;
-        this.ensureBufferSizeToWrite(size);
-        this.bytes.set(values, this.pos);
-        this.pos += size;
-      };
-      Encoder2.prototype.writeI8 = function(value) {
-        this.ensureBufferSizeToWrite(1);
-        this.view.setInt8(this.pos, value);
-        this.pos++;
-      };
-      Encoder2.prototype.writeU16 = function(value) {
-        this.ensureBufferSizeToWrite(2);
-        this.view.setUint16(this.pos, value);
-        this.pos += 2;
-      };
-      Encoder2.prototype.writeI16 = function(value) {
-        this.ensureBufferSizeToWrite(2);
-        this.view.setInt16(this.pos, value);
-        this.pos += 2;
-      };
-      Encoder2.prototype.writeU32 = function(value) {
-        this.ensureBufferSizeToWrite(4);
-        this.view.setUint32(this.pos, value);
-        this.pos += 4;
-      };
-      Encoder2.prototype.writeI32 = function(value) {
-        this.ensureBufferSizeToWrite(4);
-        this.view.setInt32(this.pos, value);
-        this.pos += 4;
-      };
-      Encoder2.prototype.writeF32 = function(value) {
-        this.ensureBufferSizeToWrite(4);
-        this.view.setFloat32(this.pos, value);
-        this.pos += 4;
-      };
-      Encoder2.prototype.writeF64 = function(value) {
-        this.ensureBufferSizeToWrite(8);
-        this.view.setFloat64(this.pos, value);
-        this.pos += 8;
-      };
-      Encoder2.prototype.writeU64 = function(value) {
-        this.ensureBufferSizeToWrite(8);
-        setUint64(this.view, this.pos, value);
-        this.pos += 8;
-      };
-      Encoder2.prototype.writeI64 = function(value) {
-        this.ensureBufferSizeToWrite(8);
-        setInt64(this.view, this.pos, value);
-        this.pos += 8;
-      };
-      Encoder2.prototype.writeBigUint64 = function(value) {
-        this.ensureBufferSizeToWrite(8);
-        this.view.setBigUint64(this.pos, value);
-        this.pos += 8;
-      };
-      Encoder2.prototype.writeBigInt64 = function(value) {
-        this.ensureBufferSizeToWrite(8);
-        this.view.setBigInt64(this.pos, value);
-        this.pos += 8;
-      };
-      return Encoder2;
-    }()
-  );
+        this.writeU8a(data);
+        return;
+      }
+      const size = ext.data.length;
+      if (size === 1) {
+        this.writeU8(212);
+      } else if (size === 2) {
+        this.writeU8(213);
+      } else if (size === 4) {
+        this.writeU8(214);
+      } else if (size === 8) {
+        this.writeU8(215);
+      } else if (size === 16) {
+        this.writeU8(216);
+      } else if (size < 256) {
+        this.writeU8(199);
+        this.writeU8(size);
+      } else if (size < 65536) {
+        this.writeU8(200);
+        this.writeU16(size);
+      } else if (size < 4294967296) {
+        this.writeU8(201);
+        this.writeU32(size);
+      } else {
+        throw new Error(`Too large extension object: ${size}`);
+      }
+      this.writeI8(ext.type);
+      this.writeU8a(ext.data);
+    }
+    writeU8(value) {
+      this.ensureBufferSizeToWrite(1);
+      this.view.setUint8(this.pos, value);
+      this.pos++;
+    }
+    writeU8a(values) {
+      const size = values.length;
+      this.ensureBufferSizeToWrite(size);
+      this.bytes.set(values, this.pos);
+      this.pos += size;
+    }
+    writeI8(value) {
+      this.ensureBufferSizeToWrite(1);
+      this.view.setInt8(this.pos, value);
+      this.pos++;
+    }
+    writeU16(value) {
+      this.ensureBufferSizeToWrite(2);
+      this.view.setUint16(this.pos, value);
+      this.pos += 2;
+    }
+    writeI16(value) {
+      this.ensureBufferSizeToWrite(2);
+      this.view.setInt16(this.pos, value);
+      this.pos += 2;
+    }
+    writeU32(value) {
+      this.ensureBufferSizeToWrite(4);
+      this.view.setUint32(this.pos, value);
+      this.pos += 4;
+    }
+    writeI32(value) {
+      this.ensureBufferSizeToWrite(4);
+      this.view.setInt32(this.pos, value);
+      this.pos += 4;
+    }
+    writeF32(value) {
+      this.ensureBufferSizeToWrite(4);
+      this.view.setFloat32(this.pos, value);
+      this.pos += 4;
+    }
+    writeF64(value) {
+      this.ensureBufferSizeToWrite(8);
+      this.view.setFloat64(this.pos, value);
+      this.pos += 8;
+    }
+    writeU64(value) {
+      this.ensureBufferSizeToWrite(8);
+      setUint64(this.view, this.pos, value);
+      this.pos += 8;
+    }
+    writeI64(value) {
+      this.ensureBufferSizeToWrite(8);
+      setInt64(this.view, this.pos, value);
+      this.pos += 8;
+    }
+    writeBigUint64(value) {
+      this.ensureBufferSizeToWrite(8);
+      this.view.setBigUint64(this.pos, value);
+      this.pos += 8;
+    }
+    writeBigInt64(value) {
+      this.ensureBufferSizeToWrite(8);
+      this.view.setBigInt64(this.pos, value);
+      this.pos += 8;
+    }
+  }
   function encode(value, options) {
-    var encoder = new Encoder(options);
+    const encoder = new Encoder(options);
     return encoder.encodeSharedRef(value);
   }
   class PublishTransportRESTServer extends stsutils.STSOptionsBase {
@@ -5725,7 +5808,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   const native = { randomUUID };
   function v4(options, buf, offset) {
     var _a2;
-    if (native.randomUUID && !buf && !options) {
+    if (native.randomUUID && true && !options) {
       return native.randomUUID();
     }
     options = options || {};