@nsshunt/stsobservability 1.0.99 → 1.0.100

package/dist/stsobservability.mjs

@@ -4201,64 +4201,6 @@ function ensureUint8Array(buffer) {
     return Uint8Array.from(buffer);
   }
 }
-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 {
@@ -4293,56 +4235,40 @@ class Encoder {
   reinitializeState() {
     this.pos = 0;
   }
-  enteringGuard() {
-    this.entered = true;
-    return {
-      [Symbol.dispose]: () => {
-        this.entered = false;
-      }
-    };
-  }
   /**
    * 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 };
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.encodeSharedRef(object);
+    }
     try {
-      if (this.entered) {
-        const instance = this.clone();
-        return instance.encodeSharedRef(object);
-      }
-      const _guard = __addDisposableResource(env_1, this.enteringGuard(), false);
+      this.entered = true;
       this.reinitializeState();
       this.doEncode(object, 1);
       return this.bytes.subarray(0, this.pos);
-    } catch (e_1) {
-      env_1.error = e_1;
-      env_1.hasError = true;
     } finally {
-      __disposeResources(env_1);
+      this.entered = false;
     }
   }
   /**
    * @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 };
+    if (this.entered) {
+      const instance = this.clone();
+      return instance.encode(object);
+    }
     try {
-      if (this.entered) {
-        const instance = this.clone();
-        return instance.encode(object);
-      }
-      const _guard = __addDisposableResource(env_2, this.enteringGuard(), false);
+      this.entered = true;
       this.reinitializeState();
       this.doEncode(object, 1);
       return this.bytes.slice(0, this.pos);
-    } catch (e_2) {
-      env_2.error = e_2;
-      env_2.hasError = true;
     } finally {
-      __disposeResources(env_2);
+      this.entered = false;
     }
   }
   doEncode(object, depth) {