@nsshunt/stsobservability 1.0.97 → 1.0.99

package/dist/stsobservability.mjs

@@ -3945,11 +3945,11 @@ function requireSource() {
 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;
@@ -3958,7 +3958,7 @@ function utf8Count(str) {
     } 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;
@@ -3975,11 +3975,11 @@ function utf8Count(str) {
   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;
@@ -3988,7 +3988,7 @@ function utf8EncodeJs(str, output, outputOffset) {
     } 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;
@@ -4007,8 +4007,8 @@ function utf8EncodeJs(str, output, outputOffset) {
     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));
 }
@@ -4020,103 +4020,73 @@ function utf8Encode(str, output, outputOffset) {
   }
 }
 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
@@ -4124,105 +4094,100 @@ function encodeDateToTimeSpec(date) {
 }
 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) {
@@ -4230,359 +4195,477 @@ function ensureUint8Array(buffer) {
     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 STSOptionsBase {
@@ -5727,7 +5810,7 @@ const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.
 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 || {};