@symbo.ls/sdk 2.33.41 → 2.34.0

package/dist/esm/services/index.js

@@ -80,7 +80,7 @@ var init_set = __esm({
 });
 
 // ../../../node_modules/lib0/array.js
-var last, appendTo, from, isArray;
+var last, appendTo, from, every, some, unfold, isArray;
 var init_array = __esm({
   "../../../node_modules/lib0/array.js"() {
     last = (arr) => arr[arr.length - 1];
@@ -90,6 +90,29 @@ var init_array = __esm({
       }
     };
     from = Array.from;
+    every = (arr, f3) => {
+      for (let i3 = 0; i3 < arr.length; i3++) {
+        if (!f3(arr[i3], i3, arr)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    some = (arr, f3) => {
+      for (let i3 = 0; i3 < arr.length; i3++) {
+        if (f3(arr[i3], i3, arr)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    unfold = (len, f3) => {
+      const array = new Array(len);
+      for (let i3 = 0; i3 < len; i3++) {
+        array[i3] = f3(i3, array);
+      }
+      return array;
+    };
     isArray = Array.isArray;
   }
 });
@@ -285,23 +308,24 @@ var init_binary = __esm({
 });
 
 // ../../../node_modules/lib0/number.js
-var MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, LOWEST_INT32, isInteger, isNaN3, parseInt2;
+var MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, LOWEST_INT32, isInteger2, isNaN3, parseInt2;
 var init_number = __esm({
   "../../../node_modules/lib0/number.js"() {
     init_math();
     MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
     MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
     LOWEST_INT32 = 1 << 31;
-    isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
+    isInteger2 = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
     isNaN3 = Number.isNaN;
     parseInt2 = Number.parseInt;
   }
 });
 
 // ../../../node_modules/lib0/string.js
-var fromCharCode, fromCodePoint, MAX_UTF16_CHARACTER, toLowerCase, trimLeftRegex, trimLeft, fromCamelCaseRegex, fromCamelCase, _encodeUtf8Polyfill, utf8TextEncoder, _encodeUtf8Native, encodeUtf8, utf8TextDecoder;
+var fromCharCode, fromCodePoint, MAX_UTF16_CHARACTER, toLowerCase, trimLeftRegex, trimLeft, fromCamelCaseRegex, fromCamelCase, _encodeUtf8Polyfill, utf8TextEncoder, _encodeUtf8Native, encodeUtf8, utf8TextDecoder, repeat;
 var init_string = __esm({
   "../../../node_modules/lib0/string.js"() {
+    init_array();
     fromCharCode = String.fromCharCode;
     fromCodePoint = String.fromCodePoint;
     MAX_UTF16_CHARACTER = fromCharCode(65535);
@@ -309,7 +333,7 @@ var init_string = __esm({
     trimLeftRegex = /^\s*/g;
     trimLeft = (s3) => s3.replace(trimLeftRegex, "");
     fromCamelCaseRegex = /([A-Z])/g;
-    fromCamelCase = (s3, separator) => trimLeft(s3.replace(fromCamelCaseRegex, (match) => `${separator}${toLowerCase(match)}`));
+    fromCamelCase = (s3, separator) => trimLeft(s3.replace(fromCamelCaseRegex, (match2) => `${separator}${toLowerCase(match2)}`));
     _encodeUtf8Polyfill = (str) => {
       const encodedString = unescape(encodeURIComponent(str));
       const len = encodedString.length;
@@ -328,6 +352,7 @@ var init_string = __esm({
     if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
       utf8TextDecoder = null;
     }
+    repeat = (source, n3) => unfold(n3, () => source).join("");
   }
 });
 
@@ -472,7 +497,7 @@ var init_encoding = __esm({
           writeVarString(encoder, data2);
           break;
         case "number":
-          if (isInteger(data2) && abs(data2) <= BITS31) {
+          if (isInteger2(data2) && abs(data2) <= BITS31) {
             write(encoder, 125);
             writeVarInt(encoder, data2);
           } else if (isFloat32(data2)) {
@@ -675,7 +700,7 @@ var init_decoding = __esm({
     errorIntegerOutOfRange = create3("Integer out of Range");
     Decoder2 = class {
       /**
-       * @param {Uint8Array} uint8Array Binary data to decode
+       * @param {Uint8Array<Buf>} uint8Array Binary data to decode
        */
       constructor(uint8Array) {
         this.arr = uint8Array;
@@ -1002,10 +1027,24 @@ var init_storage = __esm({
   }
 });
 
+// ../../../node_modules/lib0/trait/equality.js
+var EqualityTraitSymbol, equals;
+var init_equality = __esm({
+  "../../../node_modules/lib0/trait/equality.js"() {
+    EqualityTraitSymbol = Symbol("Equality");
+    equals = (a3, b3) => {
+      var _a2;
+      return a3 === b3 || !!((_a2 = a3 == null ? void 0 : a3[EqualityTraitSymbol]) == null ? void 0 : _a2.call(a3, b3)) || false;
+    };
+  }
+});
+
 // ../../../node_modules/lib0/object.js
-var assign, keys, forEach, size, isEmpty, every, hasProperty, equalFlat, freeze, deepFreeze;
+var isObject2, assign, keys, forEach, size, isEmpty, every2, hasProperty, equalFlat, freeze, deepFreeze;
 var init_object = __esm({
   "../../../node_modules/lib0/object.js"() {
+    init_equality();
+    isObject2 = (o3) => typeof o3 === "object";
     assign = Object.assign;
     keys = Object.keys;
     forEach = (obj, f3) => {
@@ -1020,7 +1059,7 @@ var init_object = __esm({
       }
       return true;
     };
-    every = (obj, f3) => {
+    every2 = (obj, f3) => {
       for (const key in obj) {
         if (!f3(obj[key], key)) {
           return false;
@@ -1029,7 +1068,7 @@ var init_object = __esm({
       return true;
     };
     hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-    equalFlat = (a3, b3) => a3 === b3 || size(a3) === size(b3) && every(a3, (val, key) => (val !== void 0 || hasProperty(b3, key)) && b3[key] === val);
+    equalFlat = (a3, b3) => a3 === b3 || size(a3) === size(b3) && every2(a3, (val, key) => (val !== void 0 || hasProperty(b3, key)) && equals(b3[key], val));
     freeze = Object.freeze;
     deepFreeze = (o3) => {
       for (const key in o3) {
@@ -1044,9 +1083,11 @@ var init_object = __esm({
 });
 
 // ../../../node_modules/lib0/function.js
-var callAll, id, isOneOf;
+var callAll, id, equalityDeep, isOneOf;
 var init_function = __esm({
   "../../../node_modules/lib0/function.js"() {
+    init_object();
+    init_equality();
     callAll = (fs, args2, i3 = 0) => {
       try {
         for (; i3 < fs.length; i3++) {
@@ -1059,6 +1100,80 @@ var init_function = __esm({
       }
     };
     id = (a3) => a3;
+    equalityDeep = (a3, b3) => {
+      if (a3 === b3) {
+        return true;
+      }
+      if (a3 == null || b3 == null || a3.constructor !== b3.constructor && (a3.constructor || Object) !== (b3.constructor || Object)) {
+        return false;
+      }
+      if (a3[EqualityTraitSymbol] != null) {
+        return a3[EqualityTraitSymbol](b3);
+      }
+      switch (a3.constructor) {
+        case ArrayBuffer:
+          a3 = new Uint8Array(a3);
+          b3 = new Uint8Array(b3);
+        // eslint-disable-next-line no-fallthrough
+        case Uint8Array: {
+          if (a3.byteLength !== b3.byteLength) {
+            return false;
+          }
+          for (let i3 = 0; i3 < a3.length; i3++) {
+            if (a3[i3] !== b3[i3]) {
+              return false;
+            }
+          }
+          break;
+        }
+        case Set: {
+          if (a3.size !== b3.size) {
+            return false;
+          }
+          for (const value2 of a3) {
+            if (!b3.has(value2)) {
+              return false;
+            }
+          }
+          break;
+        }
+        case Map: {
+          if (a3.size !== b3.size) {
+            return false;
+          }
+          for (const key of a3.keys()) {
+            if (!b3.has(key) || !equalityDeep(a3.get(key), b3.get(key))) {
+              return false;
+            }
+          }
+          break;
+        }
+        case void 0:
+        case Object:
+          if (size(a3) !== size(b3)) {
+            return false;
+          }
+          for (const key in a3) {
+            if (!hasProperty(a3, key) || !equalityDeep(a3[key], b3[key])) {
+              return false;
+            }
+          }
+          break;
+        case Array:
+          if (a3.length !== b3.length) {
+            return false;
+          }
+          for (let i3 = 0; i3 < a3.length; i3++) {
+            if (!equalityDeep(a3[i3], b3[i3])) {
+              return false;
+            }
+          }
+          break;
+        default:
+          return false;
+      }
+      return true;
+    };
     isOneOf = (value2, options) => options.includes(value2);
   }
 });
@@ -1156,15 +1271,769 @@ var init_pair = __esm({
   }
 });
 
+// ../../../node_modules/lib0/prng.js
+var bool, int53, int32, int31, letter, word, oneOf;
+var init_prng = __esm({
+  "../../../node_modules/lib0/prng.js"() {
+    init_string();
+    init_math();
+    bool = (gen) => gen.next() >= 0.5;
+    int53 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
+    int32 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
+    int31 = (gen, min2, max2) => int32(gen, min2, max2);
+    letter = (gen) => fromCharCode(int31(gen, 97, 122));
+    word = (gen, minLen = 0, maxLen = 20) => {
+      const len = int31(gen, minLen, maxLen);
+      let str = "";
+      for (let i3 = 0; i3 < len; i3++) {
+        str += letter(gen);
+      }
+      return str;
+    };
+    oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
+  }
+});
+
+// ../../../node_modules/lib0/schema.js
+var schemaSymbol, ValidationError, shapeExtends, Schema, $ConstructedBy, $constructedBy, $$constructedBy, $Custom, $custom, $$custom, $Literal, $literal, $$literal, _regexEscape, _schemaStringTemplateToRegex, $StringTemplate, $$stringTemplate, isOptionalSymbol, $Optional, $$optional, $Never, $never, $$never, _$Object, $Object, $object, $$object, $objectAny, $Record, $record, $$record, $Tuple, $tuple, $$tuple, $Array, $array, $$array, $arrayAny, $InstanceOf, $instanceOf, $$instanceOf, $$schema, $Lambda, $$lambda, $function, $Intersection, $$intersect, $Union, $union, $$union, _t, $any, $$any, $bigint, $$bigint, $symbol, $$symbol, $number, $$number, $string, $$string, $boolean, $$boolean, $undefined, $$undefined, $void, $null, $$null, $uint8Array, $$uint8Array, $primitive, $json, $, assert, PatternMatcher, match, _random, random;
+var init_schema = __esm({
+  "../../../node_modules/lib0/schema.js"() {
+    init_object();
+    init_array();
+    init_error();
+    init_environment();
+    init_equality();
+    init_function();
+    init_string();
+    init_prng();
+    init_number();
+    schemaSymbol = Symbol("0schema");
+    ValidationError = class {
+      constructor() {
+        this._rerrs = [];
+      }
+      /**
+       * @param {string?} path
+       * @param {string} expected
+       * @param {string} has
+       * @param {string?} message
+       */
+      extend(path, expected, has, message = null) {
+        this._rerrs.push({ path, expected, has, message });
+      }
+      toString() {
+        const s3 = [];
+        for (let i3 = this._rerrs.length - 1; i3 > 0; i3--) {
+          const r3 = this._rerrs[i3];
+          s3.push(repeat(" ", (this._rerrs.length - i3) * 2) + `${r3.path != null ? `[${r3.path}] ` : ""}${r3.has} doesn't match ${r3.expected}. ${r3.message}`);
+        }
+        return s3.join("\n");
+      }
+    };
+    shapeExtends = (a3, b3) => {
+      if (a3 === b3) return true;
+      if (a3 == null || b3 == null || a3.constructor !== b3.constructor) return false;
+      if (a3[EqualityTraitSymbol]) return equals(a3, b3);
+      if (isArray(a3)) {
+        return every(
+          a3,
+          (aitem) => some(b3, (bitem) => shapeExtends(aitem, bitem))
+        );
+      } else if (isObject2(a3)) {
+        return every2(
+          a3,
+          (aitem, akey) => shapeExtends(aitem, b3[akey])
+        );
+      }
+      return false;
+    };
+    Schema = class {
+      /**
+       * @param {Schema<any>} other
+       */
+      extends(other) {
+        let [a3, b3] = [
+          /** @type {any} */
+          this.shape,
+          /** @type {any} */
+          other.shape
+        ];
+        if (
+          /** @type {typeof Schema<any>} */
+          this.constructor._dilutes
+        ) [b3, a3] = [a3, b3];
+        return shapeExtends(a3, b3);
+      }
+      /**
+       * Overwrite this when necessary. By default, we only check the `shape` property which every shape
+       * should have.
+       * @param {Schema<any>} other
+       */
+      equals(other) {
+        return this.constructor === other.constructor && equalityDeep(this.shape, other.shape);
+      }
+      [schemaSymbol]() {
+        return true;
+      }
+      /**
+       * @param {object} other
+       */
+      [EqualityTraitSymbol](other) {
+        return this.equals(
+          /** @type {any} */
+          other
+        );
+      }
+      /**
+       * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
+       * Schema. Validate will check the structure of the parameter and return true iff the instance
+       * really is an instance of Schema.
+       *
+       * @param {T} o
+       * @return {boolean}
+       */
+      validate(o3) {
+        return this.check(o3);
+      }
+      /* c8 ignore start */
+      /**
+       * Similar to validate, but this method accepts untyped parameters.
+       *
+       * @param {any} _o
+       * @param {ValidationError} [_err]
+       * @return {_o is T}
+       */
+      check(_o, _err) {
+        methodUnimplemented();
+      }
+      /* c8 ignore stop */
+      /**
+       * @type {Schema<T?>}
+       */
+      get nullable() {
+        return $union(this, $null);
+      }
+      /**
+       * @type {$Optional<Schema<T>>}
+       */
+      get optional() {
+        return new $Optional(
+          /** @type {Schema<T>} */
+          this
+        );
+      }
+      /**
+       * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
+       * Use this if you know that the type is of a specific type and you just want to convince the type
+       * system.
+       *
+       * **Do not rely on these error messages!**
+       * Performs an assertion check only if not in a production environment.
+       *
+       * @template OO
+       * @param {OO} o
+       * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
+       */
+      cast(o3) {
+        assert(o3, this);
+        return (
+          /** @type {any} */
+          o3
+        );
+      }
+      /**
+       * EXPECTO PATRONUM!! 🪄
+       * This function protects against type errors. Though it may not work in the real world.
+       *
+       * "After all this time?"
+       * "Always." - Snape, talking about type safety
+       *
+       * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
+       * Use this if you know that the type is of a specific type and you just want to convince the type
+       * system.
+       *
+       * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
+       *
+       * **Do not rely on these error messages!**
+       * Performs an assertion check if not in a production environment.
+       *
+       * @param {T} o
+       * @return {o extends T ? T : never}
+       */
+      expect(o3) {
+        assert(o3, this);
+        return o3;
+      }
+    };
+    // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
+    /**
+     * If true, the more things are added to the shape the more objects this schema will accept (e.g.
+     * union). By default, the more objects are added, the the fewer objects this schema will accept.
+     * @protected
+     */
+    __publicField(Schema, "_dilutes", false);
+    $ConstructedBy = class extends Schema {
+      /**
+       * @param {C} c
+       * @param {((o:Instance<C>)=>boolean)|null} check
+       */
+      constructor(c3, check) {
+        super();
+        this.shape = c3;
+        this._c = check;
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} [err]
+       * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
+       */
+      check(o3, err = void 0) {
+        const c3 = (o3 == null ? void 0 : o3.constructor) === this.shape && (this._c == null || this._c(o3));
+        !c3 && (err == null ? void 0 : err.extend(null, this.shape.name, o3 == null ? void 0 : o3.constructor.name, (o3 == null ? void 0 : o3.constructor) !== this.shape ? "Constructor match failed" : "Check failed"));
+        return c3;
+      }
+    };
+    $constructedBy = (c3, check = null) => new $ConstructedBy(c3, check);
+    $$constructedBy = $constructedBy($ConstructedBy);
+    $Custom = class extends Schema {
+      /**
+       * @param {(o:any) => boolean} check
+       */
+      constructor(check) {
+        super();
+        this.shape = check;
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} err
+       * @return {o is any}
+       */
+      check(o3, err) {
+        const c3 = this.shape(o3);
+        !c3 && (err == null ? void 0 : err.extend(null, "custom prop", o3 == null ? void 0 : o3.constructor.name, "failed to check custom prop"));
+        return c3;
+      }
+    };
+    $custom = (check) => new $Custom(check);
+    $$custom = $constructedBy($Custom);
+    $Literal = class extends Schema {
+      /**
+       * @param {Array<T>} literals
+       */
+      constructor(literals) {
+        super();
+        this.shape = literals;
+      }
+      /**
+       *
+       * @param {any} o
+       * @param {ValidationError} [err]
+       * @return {o is T}
+       */
+      check(o3, err) {
+        const c3 = this.shape.some((a3) => a3 === o3);
+        !c3 && (err == null ? void 0 : err.extend(null, this.shape.join(" | "), o3.toString()));
+        return c3;
+      }
+    };
+    $literal = (...literals) => new $Literal(literals);
+    $$literal = $constructedBy($Literal);
+    _regexEscape = /** @type {any} */
+    RegExp.escape || /** @type {(str:string) => string} */
+    ((str) => str.replace(/[().|&,$^[\]]/g, (s3) => "\\" + s3));
+    _schemaStringTemplateToRegex = (s3) => {
+      if ($string.check(s3)) {
+        return [_regexEscape(s3)];
+      }
+      if ($$literal.check(s3)) {
+        return (
+          /** @type {Array<string|number>} */
+          s3.shape.map((v3) => v3 + "")
+        );
+      }
+      if ($$number.check(s3)) {
+        return ["[+-]?\\d+.?\\d*"];
+      }
+      if ($$string.check(s3)) {
+        return [".*"];
+      }
+      if ($$union.check(s3)) {
+        return s3.shape.map(_schemaStringTemplateToRegex).flat(1);
+      }
+      unexpectedCase();
+    };
+    $StringTemplate = class extends Schema {
+      /**
+       * @param {T} shape
+       */
+      constructor(shape) {
+        super();
+        this.shape = shape;
+        this._r = new RegExp("^" + shape.map(_schemaStringTemplateToRegex).map((opts) => `(${opts.join("|")})`).join("") + "$");
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} [err]
+       * @return {o is CastStringTemplateArgsToTemplate<T>}
+       */
+      check(o3, err) {
+        const c3 = this._r.exec(o3) != null;
+        !c3 && (err == null ? void 0 : err.extend(null, this._r.toString(), o3.toString(), "String doesn't match string template."));
+        return c3;
+      }
+    };
+    $$stringTemplate = $constructedBy($StringTemplate);
+    isOptionalSymbol = Symbol("optional");
+    $Optional = class extends Schema {
+      /**
+       * @param {S} shape
+       */
+      constructor(shape) {
+        super();
+        this.shape = shape;
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} [err]
+       * @return {o is (Unwrap<S>|undefined)}
+       */
+      check(o3, err) {
+        const c3 = o3 === void 0 || this.shape.check(o3);
+        !c3 && (err == null ? void 0 : err.extend(null, "undefined (optional)", "()"));
+        return c3;
+      }
+      get [isOptionalSymbol]() {
+        return true;
+      }
+    };
+    $$optional = $constructedBy($Optional);
+    $Never = class extends Schema {
+      /**
+       * @param {any} _o
+       * @param {ValidationError} [err]
+       * @return {_o is never}
+       */
+      check(_o, err) {
+        err == null ? void 0 : err.extend(null, "never", typeof _o);
+        return false;
+      }
+    };
+    $never = new $Never();
+    $$never = $constructedBy($Never);
+    _$Object = class _$Object extends Schema {
+      /**
+       * @param {S} shape
+       * @param {boolean} partial
+       */
+      constructor(shape, partial = false) {
+        super();
+        this.shape = shape;
+        this._isPartial = partial;
+      }
+      /**
+       * @type {Schema<Partial<$ObjectToType<S>>>}
+       */
+      get partial() {
+        return new _$Object(this.shape, true);
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} err
+       * @return {o is $ObjectToType<S>}
+       */
+      check(o3, err) {
+        if (o3 == null) {
+          err == null ? void 0 : err.extend(null, "object", "null");
+          return false;
+        }
+        return every2(this.shape, (vv, vk) => {
+          const c3 = this._isPartial && !hasProperty(o3, vk) || vv.check(o3[vk], err);
+          !c3 && (err == null ? void 0 : err.extend(vk.toString(), vv.toString(), typeof o3[vk], "Object property does not match"));
+          return c3;
+        });
+      }
+    };
+    __publicField(_$Object, "_dilutes", true);
+    $Object = _$Object;
+    $object = (def) => (
+      /** @type {any} */
+      new $Object(def)
+    );
+    $$object = $constructedBy($Object);
+    $objectAny = $custom((o3) => o3 != null && (o3.constructor === Object || o3.constructor == null));
+    $Record = class extends Schema {
+      /**
+       * @param {Keys} keys
+       * @param {Values} values
+       */
+      constructor(keys2, values) {
+        super();
+        this.shape = {
+          keys: keys2,
+          values
+        };
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} err
+       * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
+       */
+      check(o3, err) {
+        return o3 != null && every2(o3, (vv, vk) => {
+          const ck = this.shape.keys.check(vk, err);
+          !ck && (err == null ? void 0 : err.extend(vk + "", "Record", typeof o3, ck ? "Key doesn't match schema" : "Value doesn't match value"));
+          return ck && this.shape.values.check(vv, err);
+        });
+      }
+    };
+    $record = (keys2, values) => new $Record(keys2, values);
+    $$record = $constructedBy($Record);
+    $Tuple = class extends Schema {
+      /**
+       * @param {S} shape
+       */
+      constructor(shape) {
+        super();
+        this.shape = shape;
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} err
+       * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
+       */
+      check(o3, err) {
+        return o3 != null && every2(this.shape, (vv, vk) => {
+          const c3 = (
+            /** @type {Schema<any>} */
+            vv.check(o3[vk], err)
+          );
+          !c3 && (err == null ? void 0 : err.extend(vk.toString(), "Tuple", typeof vv));
+          return c3;
+        });
+      }
+    };
+    $tuple = (...def) => new $Tuple(def);
+    $$tuple = $constructedBy($Tuple);
+    $Array = class extends Schema {
+      /**
+       * @param {Array<S>} v
+       */
+      constructor(v3) {
+        super();
+        this.shape = v3.length === 1 ? v3[0] : new $Union(v3);
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} [err]
+       * @return {o is Array<S extends Schema<infer T> ? T : never>} o
+       */
+      check(o3, err) {
+        const c3 = isArray(o3) && every(o3, (oi) => this.shape.check(oi));
+        !c3 && (err == null ? void 0 : err.extend(null, "Array", ""));
+        return c3;
+      }
+    };
+    $array = (...def) => new $Array(def);
+    $$array = $constructedBy($Array);
+    $arrayAny = $custom((o3) => isArray(o3));
+    $InstanceOf = class extends Schema {
+      /**
+       * @param {new (...args:any) => T} constructor
+       * @param {((o:T) => boolean)|null} check
+       */
+      constructor(constructor, check) {
+        super();
+        this.shape = constructor;
+        this._c = check;
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} err
+       * @return {o is T}
+       */
+      check(o3, err) {
+        const c3 = o3 instanceof this.shape && (this._c == null || this._c(o3));
+        !c3 && (err == null ? void 0 : err.extend(null, this.shape.name, o3 == null ? void 0 : o3.constructor.name));
+        return c3;
+      }
+    };
+    $instanceOf = (c3, check = null) => new $InstanceOf(c3, check);
+    $$instanceOf = $constructedBy($InstanceOf);
+    $$schema = $instanceOf(Schema);
+    $Lambda = class extends Schema {
+      /**
+       * @param {Args} args
+       */
+      constructor(args2) {
+        super();
+        this.len = args2.length - 1;
+        this.args = $tuple(...args2.slice(-1));
+        this.res = args2[this.len];
+      }
+      /**
+       * @param {any} f
+       * @param {ValidationError} err
+       * @return {f is _LArgsToLambdaDef<Args>}
+       */
+      check(f3, err) {
+        const c3 = f3.constructor === Function && f3.length <= this.len;
+        !c3 && (err == null ? void 0 : err.extend(null, "function", typeof f3));
+        return c3;
+      }
+    };
+    $$lambda = $constructedBy($Lambda);
+    $function = $custom((o3) => typeof o3 === "function");
+    $Intersection = class extends Schema {
+      /**
+       * @param {T} v
+       */
+      constructor(v3) {
+        super();
+        this.shape = v3;
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} [err]
+       * @return {o is Intersect<UnwrapArray<T>>}
+       */
+      check(o3, err) {
+        const c3 = every(this.shape, (check) => check.check(o3, err));
+        !c3 && (err == null ? void 0 : err.extend(null, "Intersectinon", typeof o3));
+        return c3;
+      }
+    };
+    $$intersect = $constructedBy($Intersection, (o3) => o3.shape.length > 0);
+    $Union = class extends Schema {
+      /**
+       * @param {Array<Schema<S>>} v
+       */
+      constructor(v3) {
+        super();
+        this.shape = v3;
+      }
+      /**
+       * @param {any} o
+       * @param {ValidationError} [err]
+       * @return {o is S}
+       */
+      check(o3, err) {
+        const c3 = some(this.shape, (vv) => vv.check(o3, err));
+        err == null ? void 0 : err.extend(null, "Union", typeof o3);
+        return c3;
+      }
+    };
+    __publicField($Union, "_dilutes", true);
+    $union = (...schemas) => schemas.findIndex(($s) => $$union.check($s)) >= 0 ? $union(...schemas.map(($s) => $($s)).map(($s) => $$union.check($s) ? $s.shape : [$s]).flat(1)) : schemas.length === 1 ? schemas[0] : new $Union(schemas);
+    $$union = /** @type {Schema<$Union<any>>} */
+    $constructedBy($Union);
+    _t = () => true;
+    $any = $custom(_t);
+    $$any = /** @type {Schema<Schema<any>>} */
+    $constructedBy($Custom, (o3) => o3.shape === _t);
+    $bigint = $custom((o3) => typeof o3 === "bigint");
+    $$bigint = /** @type {Schema<Schema<BigInt>>} */
+    $custom((o3) => o3 === $bigint);
+    $symbol = $custom((o3) => typeof o3 === "symbol");
+    $$symbol = /** @type {Schema<Schema<Symbol>>} */
+    $custom((o3) => o3 === $symbol);
+    $number = $custom((o3) => typeof o3 === "number");
+    $$number = /** @type {Schema<Schema<number>>} */
+    $custom((o3) => o3 === $number);
+    $string = $custom((o3) => typeof o3 === "string");
+    $$string = /** @type {Schema<Schema<string>>} */
+    $custom((o3) => o3 === $string);
+    $boolean = $custom((o3) => typeof o3 === "boolean");
+    $$boolean = /** @type {Schema<Schema<Boolean>>} */
+    $custom((o3) => o3 === $boolean);
+    $undefined = $literal(void 0);
+    $$undefined = /** @type {Schema<Schema<undefined>>} */
+    $constructedBy($Literal, (o3) => o3.shape.length === 1 && o3.shape[0] === void 0);
+    $void = $literal(void 0);
+    $null = $literal(null);
+    $$null = /** @type {Schema<Schema<null>>} */
+    $constructedBy($Literal, (o3) => o3.shape.length === 1 && o3.shape[0] === null);
+    $uint8Array = $constructedBy(Uint8Array);
+    $$uint8Array = /** @type {Schema<Schema<Uint8Array>>} */
+    $constructedBy($ConstructedBy, (o3) => o3.shape === Uint8Array);
+    $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
+    $json = (() => {
+      const $jsonArr = (
+        /** @type {$Array<$any>} */
+        $array($any)
+      );
+      const $jsonRecord = (
+        /** @type {$Record<$string,$any>} */
+        $record($string, $any)
+      );
+      const $json2 = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
+      $jsonArr.shape = $json2;
+      $jsonRecord.shape.values = $json2;
+      return $json2;
+    })();
+    $ = (o3) => {
+      if ($$schema.check(o3)) {
+        return (
+          /** @type {any} */
+          o3
+        );
+      } else if ($objectAny.check(o3)) {
+        const o22 = {};
+        for (const k3 in o3) {
+          o22[k3] = $(o3[k3]);
+        }
+        return (
+          /** @type {any} */
+          $object(o22)
+        );
+      } else if ($arrayAny.check(o3)) {
+        return (
+          /** @type {any} */
+          $union(...o3.map($))
+        );
+      } else if ($primitive.check(o3)) {
+        return (
+          /** @type {any} */
+          $literal(o3)
+        );
+      } else if ($function.check(o3)) {
+        return (
+          /** @type {any} */
+          $constructedBy(
+            /** @type {any} */
+            o3
+          )
+        );
+      }
+      unexpectedCase();
+    };
+    assert = production ? () => {
+    } : (o3, schema) => {
+      const err = new ValidationError();
+      if (!schema.check(o3, err)) {
+        throw create3(`Expected value to be of type ${schema.constructor.name}.
+${err.toString()}`);
+      }
+    };
+    PatternMatcher = class {
+      /**
+       * @param {Schema<State>} [$state]
+       */
+      constructor($state) {
+        this.patterns = [];
+        this.$state = $state;
+      }
+      /**
+       * @template P
+       * @template R
+       * @param {P} pattern
+       * @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
+       * @return {PatternMatcher<State,Patterns|Pattern<Unwrap<ReadSchema<P>>,R>>}
+       */
+      if(pattern, handler) {
+        this.patterns.push({ if: $(pattern), h: handler });
+        return this;
+      }
+      /**
+       * @template R
+       * @param {(o:any,s:State)=>R} h
+       */
+      else(h3) {
+        return this.if($any, h3);
+      }
+      /**
+       * @return {State extends undefined
+       *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
+       *   : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
+       */
+      done() {
+        return (
+          /** @type {any} */
+          (o3, s3) => {
+            for (let i3 = 0; i3 < this.patterns.length; i3++) {
+              const p3 = this.patterns[i3];
+              if (p3.if.check(o3)) {
+                return p3.h(o3, s3);
+              }
+            }
+            throw create3("Unhandled pattern");
+          }
+        );
+      }
+    };
+    match = (state) => new PatternMatcher(
+      /** @type {any} */
+      state
+    );
+    _random = /** @type {any} */
+    match(
+      /** @type {Schema<prng.PRNG>} */
+      $any
+    ).if($$number, (_o, gen) => int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER)).if($$string, (_o, gen) => word(gen)).if($$boolean, (_o, gen) => bool(gen)).if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER))).if($$union, (o3, gen) => random(gen, oneOf(gen, o3.shape))).if($$object, (o3, gen) => {
+      const res = {};
+      for (const k3 in o3.shape) {
+        let prop = o3.shape[k3];
+        if ($$optional.check(prop)) {
+          if (bool(gen)) {
+            continue;
+          }
+          prop = prop.shape;
+        }
+        res[k3] = _random(prop, gen);
+      }
+      return res;
+    }).if($$array, (o3, gen) => {
+      const arr = [];
+      const n3 = int32(gen, 0, 42);
+      for (let i3 = 0; i3 < n3; i3++) {
+        arr.push(random(gen, o3.shape));
+      }
+      return arr;
+    }).if($$literal, (o3, gen) => {
+      return oneOf(gen, o3.shape);
+    }).if($$null, (o3, gen) => {
+      return null;
+    }).if($$lambda, (o3, gen) => {
+      const res = random(gen, o3.res);
+      return () => res;
+    }).if($$any, (o3, gen) => random(gen, oneOf(gen, [
+      $number,
+      $string,
+      $null,
+      $undefined,
+      $bigint,
+      $boolean,
+      $array($number),
+      $record($union("a", "b", "c"), $number)
+    ]))).if($$record, (o3, gen) => {
+      const res = {};
+      const keysN = int53(gen, 0, 3);
+      for (let i3 = 0; i3 < keysN; i3++) {
+        const key = random(gen, o3.shape.keys);
+        const val = random(gen, o3.shape.values);
+        res[key] = val;
+      }
+      return res;
+    }).done();
+    random = (gen, schema) => (
+      /** @type {any} */
+      _random($(schema), gen)
+    );
+  }
+});
+
 // ../../../node_modules/lib0/dom.js
-var doc, domParser, mapToStyleString, ELEMENT_NODE, TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, DOCUMENT_FRAGMENT_NODE;
+var doc, $fragment, domParser, $element, $text, mapToStyleString, ELEMENT_NODE, TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, DOCUMENT_FRAGMENT_NODE, $node;
 var init_dom = __esm({
   "../../../node_modules/lib0/dom.js"() {
     init_map();
+    init_schema();
     doc = /** @type {Document} */
     typeof document !== "undefined" ? document : {};
+    $fragment = $custom((el) => el.nodeType === DOCUMENT_FRAGMENT_NODE);
     domParser = /** @type {DOMParser} */
     typeof DOMParser !== "undefined" ? new DOMParser() : null;
+    $element = $custom((el) => el.nodeType === ELEMENT_NODE);
+    $text = $custom((el) => el.nodeType === TEXT_NODE);
     mapToStyleString = (m3) => map(m3, (value2, key) => `${key}:${value2};`).join("");
     ELEMENT_NODE = doc.ELEMENT_NODE;
     TEXT_NODE = doc.TEXT_NODE;
@@ -1173,6 +2042,7 @@ var init_dom = __esm({
     DOCUMENT_NODE = doc.DOCUMENT_NODE;
     DOCUMENT_TYPE_NODE = doc.DOCUMENT_TYPE_NODE;
     DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
+    $node = $custom((el) => el.nodeType === DOCUMENT_NODE);
   }
 });
 
@@ -2963,15 +3833,19 @@ var init_yjs = __esm({
                   event._path = null;
                 });
                 events.sort((event1, event2) => event1.path.length - event2.path.length);
-                callEventHandlerListeners(type._dEH, events, transaction);
+                fs.push(() => {
+                  callEventHandlerListeners(type._dEH, events, transaction);
+                });
+              }
+            });
+            fs.push(() => doc2.emit("afterTransaction", [transaction, doc2]));
+            fs.push(() => {
+              if (transaction._needFormattingCleanup) {
+                cleanupYTextAfterTransaction(transaction);
               }
             });
           });
-          fs.push(() => doc2.emit("afterTransaction", [transaction, doc2]));
           callAll(fs, []);
-          if (transaction._needFormattingCleanup) {
-            cleanupYTextAfterTransaction(transaction);
-          }
         } finally {
           if (doc2.gc) {
             tryGcDeleteSet(ds, store, doc2.gcFilter);
@@ -3355,7 +4229,7 @@ var init_yjs = __esm({
         return isDeleted(this.transaction.deleteSet, struct.id);
       }
       /**
-       * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}
+       * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
        */
       get keys() {
         if (this._keys === null) {
@@ -6061,11 +6935,13 @@ var init_yjs = __esm({
         const el = new _YXmlElement(this.nodeName);
         const attrs = this.getAttributes();
         forEach(attrs, (value2, key) => {
-          if (typeof value2 === "string") {
-            el.setAttribute(key, value2);
-          }
+          el.setAttribute(
+            key,
+            /** @type {any} */
+            value2
+          );
         });
-        el.insert(0, this.toArray().map((item) => item instanceof AbstractType ? item.clone() : item));
+        el.insert(0, this.toArray().map((v3) => v3 instanceof AbstractType ? v3.clone() : v3));
         return el;
       }
       /**
@@ -8118,7 +8994,7 @@ var require_dexie = __commonJS({
       function override(origFunc, overridedFactory) {
         return overridedFactory(origFunc);
       }
-      function assert(b3) {
+      function assert2(b3) {
         if (!b3)
           throw new Error("Assertion Failed");
       }
@@ -8162,7 +9038,7 @@ var require_dexie = __commonJS({
         if ("isFrozen" in Object && Object.isFrozen(obj))
           return;
         if (typeof keyPath !== "string" && "length" in keyPath) {
-          assert(typeof value2 !== "string" && "length" in value2);
+          assert2(typeof value2 !== "string" && "length" in value2);
           for (var i3 = 0, l3 = keyPath.length; i3 < l3; ++i3) {
             setByKeyPath(obj, keyPath[i3], value2[i3]);
           }
@@ -9432,7 +10308,7 @@ var require_dexie = __commonJS({
           if (!compoundIndex && debug)
             console.warn("The query ".concat(JSON.stringify(indexOrCrit), " on ").concat(this.name, " would benefit from a ") + "compound index [".concat(keyPaths.join("+"), "]"));
           var idxByName = this.schema.idxByName;
-          function equals(a3, b3) {
+          function equals2(a3, b3) {
             return cmp2(a3, b3) === 0;
           }
           var _a3 = keyPaths.reduce(function(_a4, keyPath) {
@@ -9444,10 +10320,10 @@ var require_dexie = __commonJS({
               prevIndex || !index ? combine(prevFilterFn, index && index.multi ? function(x3) {
                 var prop = getByKeyPath(x3, keyPath);
                 return isArray5(prop) && prop.some(function(item) {
-                  return equals(value2, item);
+                  return equals2(value2, item);
                 });
               } : function(x3) {
-                return equals(value2, getByKeyPath(x3, keyPath));
+                return equals2(value2, getByKeyPath(x3, keyPath));
               }) : prevFilterFn
             ];
           }, [null, null]), idx = _a3[0], filterFunction = _a3[1];
@@ -10435,7 +11311,7 @@ var require_dexie = __commonJS({
           return key.substr(0, upperNeedle.length);
         return llp < 0 ? null : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1);
       }
-      function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix) {
+      function addIgnoreCaseAlgorithm(whereClause, match2, needles, suffix) {
         var upper, lower, compare, upperNeedles, lowerNeedles, direction, nextKeySuffix, needlesLen = needles.length;
         if (!needles.every(function(s3) {
           return typeof s3 === "string";
@@ -10473,7 +11349,7 @@ var require_dexie = __commonJS({
           if (typeof key !== "string")
             return false;
           var lowerKey = lower(key);
-          if (match(lowerKey, lowerNeedles, firstPossibleNeedle)) {
+          if (match2(lowerKey, lowerNeedles, firstPossibleNeedle)) {
             return true;
           } else {
             var lowestPossibleCasing = null;
@@ -10811,14 +11687,14 @@ var require_dexie = __commonJS({
         function Transaction3() {
         }
         Transaction3.prototype._lock = function() {
-          assert(!PSD.global);
+          assert2(!PSD.global);
           ++this._reculock;
           if (this._reculock === 1 && !PSD.global)
             PSD.lockOwnerFor = this;
           return this;
         };
         Transaction3.prototype._unlock = function() {
-          assert(!PSD.global);
+          assert2(!PSD.global);
           if (--this._reculock === 0) {
             if (!PSD.global)
               PSD.lockOwnerFor = null;
@@ -10841,7 +11717,7 @@ var require_dexie = __commonJS({
             return this;
           var idbdb = this.db.idbdb;
           var dbOpenError = this.db._state.dbOpenError;
-          assert(!this.idbtrans);
+          assert2(!this.idbtrans);
           if (!idbtrans && !idbdb) {
             switch (dbOpenError && dbOpenError.name) {
               case "DatabaseClosedError":
@@ -10854,7 +11730,7 @@ var require_dexie = __commonJS({
           }
           if (!this.active)
             throw new exceptions.TransactionInactive();
-          assert(this._completion._state === null);
+          assert2(this._completion._state === null);
           idbtrans = this.idbtrans = idbtrans || (this.db.core ? this.db.core.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }) : idbdb.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }));
           idbtrans.onerror = wrap2(function(ev) {
             preventDefault(ev);
@@ -15751,20 +16627,29 @@ function getKeyPairs(baggage) {
   });
 }
 function parsePairKeyValue(entry) {
-  const valueProps = entry.split(BAGGAGE_PROPERTIES_SEPARATOR);
-  if (valueProps.length <= 0)
-    return;
-  const keyPairPart = valueProps.shift();
-  if (!keyPairPart)
+  if (!entry)
     return;
+  const metadataSeparatorIndex = entry.indexOf(BAGGAGE_PROPERTIES_SEPARATOR);
+  const keyPairPart = metadataSeparatorIndex === -1 ? entry : entry.substring(0, metadataSeparatorIndex);
   const separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
   if (separatorIndex <= 0)
     return;
-  const key = decodeURIComponent(keyPairPart.substring(0, separatorIndex).trim());
-  const value2 = decodeURIComponent(keyPairPart.substring(separatorIndex + 1).trim());
+  const rawKey = keyPairPart.substring(0, separatorIndex).trim();
+  const rawValue = keyPairPart.substring(separatorIndex + 1).trim();
+  if (!rawKey || !rawValue)
+    return;
+  let key;
+  let value2;
+  try {
+    key = decodeURIComponent(rawKey);
+    value2 = decodeURIComponent(rawValue);
+  } catch {
+    return;
+  }
   let metadata;
-  if (valueProps.length > 0) {
-    metadata = baggageEntryMetadataFromString(valueProps.join(BAGGAGE_PROPERTIES_SEPARATOR));
+  if (metadataSeparatorIndex !== -1 && metadataSeparatorIndex < entry.length - 1) {
+    const metadataString = entry.substring(metadataSeparatorIndex + 1);
+    metadata = baggageEntryMetadataFromString(metadataString);
   }
   return { key, value: value2, metadata };
 }
@@ -15964,19 +16849,11 @@ var init_environment2 = __esm({
   }
 });
 
-// ../../../node_modules/@opentelemetry/core/build/esm/platform/browser/performance.js
-var otperformance;
-var init_performance = __esm({
-  "../../../node_modules/@opentelemetry/core/build/esm/platform/browser/performance.js"() {
-    otperformance = performance;
-  }
-});
-
 // ../../../node_modules/@opentelemetry/core/build/esm/version.js
 var VERSION2;
 var init_version2 = __esm({
   "../../../node_modules/@opentelemetry/core/build/esm/version.js"() {
-    VERSION2 = "2.2.0";
+    VERSION2 = "2.5.0";
   }
 });
 
@@ -18089,11 +18966,12 @@ var init_sdk_info = __esm({
 });
 
 // ../../../node_modules/@opentelemetry/core/build/esm/platform/browser/index.js
+var otperformance;
 var init_browser2 = __esm({
   "../../../node_modules/@opentelemetry/core/build/esm/platform/browser/index.js"() {
     init_environment2();
-    init_performance();
     init_sdk_info();
+    otperformance = performance;
   }
 });
 
@@ -18104,16 +18982,8 @@ function millisToHrTime(epochMillis) {
   const nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS);
   return [seconds, nanos];
 }
-function getTimeOrigin() {
-  let timeOrigin = otperformance.timeOrigin;
-  if (typeof timeOrigin !== "number") {
-    const perf = otperformance;
-    timeOrigin = perf.timing && perf.timing.fetchStart;
-  }
-  return timeOrigin;
-}
 function hrTime(performanceNow) {
-  const timeOrigin = millisToHrTime(getTimeOrigin());
+  const timeOrigin = millisToHrTime(otperformance.timeOrigin);
   const now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
   return addHrTimes(timeOrigin, now);
 }
@@ -18314,15 +19184,15 @@ var init_TraceState = __esm({
 
 // ../../../node_modules/@opentelemetry/core/build/esm/trace/W3CTraceContextPropagator.js
 function parseTraceParent(traceParent) {
-  const match = TRACE_PARENT_REGEX.exec(traceParent);
-  if (!match)
+  const match2 = TRACE_PARENT_REGEX.exec(traceParent);
+  if (!match2)
     return null;
-  if (match[1] === "00" && match[5])
+  if (match2[1] === "00" && match2[5])
     return null;
   return {
-    traceId: match[2],
-    spanId: match[3],
-    traceFlags: parseInt(match[4], 16)
+    traceId: match2[2],
+    spanId: match2[3],
+    traceFlags: parseInt(match2[4], 16)
   };
 }
 var TRACE_PARENT_HEADER, TRACE_STATE_HEADER, VERSION3, VERSION_PART, TRACE_ID_PART, PARENT_ID_PART, FLAGS_PART, TRACE_PARENT_REGEX, W3CTraceContextPropagator;
@@ -18463,15 +19333,15 @@ function mergeTwoObjects(one, two, level = 0, objects) {
       for (let i3 = 0, j3 = two.length; i3 < j3; i3++) {
         result.push(takeValue(two[i3]));
       }
-    } else if (isObject2(two)) {
+    } else if (isObject3(two)) {
       const keys2 = Object.keys(two);
       for (let i3 = 0, j3 = keys2.length; i3 < j3; i3++) {
         const key = keys2[i3];
         result[key] = takeValue(two[key]);
       }
     }
-  } else if (isObject2(one)) {
-    if (isObject2(two)) {
+  } else if (isObject3(one)) {
+    if (isObject3(two)) {
       if (!shouldMerge(one, two)) {
         return two;
       }
@@ -18492,7 +19362,7 @@ function mergeTwoObjects(one, two, level = 0, objects) {
           if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
             delete result[key];
           } else {
-            if (isObject2(obj1) && isObject2(obj2)) {
+            if (isObject3(obj1) && isObject3(obj2)) {
               const arr1 = objects.get(obj1) || [];
               const arr2 = objects.get(obj2) || [];
               arr1.push({ obj: one, key });
@@ -18526,7 +19396,7 @@ function isArray3(value2) {
 function isFunction2(value2) {
   return typeof value2 === "function";
 }
-function isObject2(value2) {
+function isObject3(value2) {
   return !isPrimitive(value2) && !isArray3(value2) && !isFunction2(value2) && typeof value2 === "object";
 }
 function isPrimitive(value2) {
@@ -18579,13 +19449,13 @@ var init_callback = __esm({
   "../../../node_modules/@opentelemetry/core/build/esm/utils/callback.js"() {
     init_promise2();
     BindOnceFuture = class {
-      constructor(_callback, _that) {
-        __publicField(this, "_callback");
-        __publicField(this, "_that");
+      constructor(callback, that) {
         __publicField(this, "_isCalled", false);
         __publicField(this, "_deferred", new Deferred());
-        this._callback = _callback;
-        this._that = _that;
+        __publicField(this, "_callback");
+        __publicField(this, "_that");
+        this._callback = callback;
+        this._that = that;
       }
       get isCalled() {
         return this._isCalled;
@@ -19432,15 +20302,15 @@ var require_W3CTraceContextPropagator = __commonJS({
     var FLAGS_PART2 = "[\\da-f]{2}";
     var TRACE_PARENT_REGEX2 = new RegExp(`^\\s?(${VERSION_PART2})-(${TRACE_ID_PART2})-(${PARENT_ID_PART2})-(${FLAGS_PART2})(-.*)?\\s?$`);
     function parseTraceParent2(traceParent) {
-      const match = TRACE_PARENT_REGEX2.exec(traceParent);
-      if (!match)
+      const match2 = TRACE_PARENT_REGEX2.exec(traceParent);
+      if (!match2)
         return null;
-      if (match[1] === "00" && match[5])
+      if (match2[1] === "00" && match2[5])
         return null;
       return {
-        traceId: match[2],
-        spanId: match[3],
-        traceFlags: parseInt(match[4], 16)
+        traceId: match2[2],
+        spanId: match2[3],
+        traceFlags: parseInt(match2[4], 16)
       };
     }
     exports.parseTraceParent = parseTraceParent2;
@@ -19607,15 +20477,15 @@ var require_merge = __commonJS({
           for (let i3 = 0, j3 = two.length; i3 < j3; i3++) {
             result.push(takeValue2(two[i3]));
           }
-        } else if (isObject4(two)) {
+        } else if (isObject5(two)) {
           const keys2 = Object.keys(two);
           for (let i3 = 0, j3 = keys2.length; i3 < j3; i3++) {
             const key = keys2[i3];
             result[key] = takeValue2(two[key]);
           }
         }
-      } else if (isObject4(one)) {
-        if (isObject4(two)) {
+      } else if (isObject5(one)) {
+        if (isObject5(two)) {
           if (!shouldMerge2(one, two)) {
             return two;
           }
@@ -19636,7 +20506,7 @@ var require_merge = __commonJS({
               if (wasObjectReferenced2(one, key, objects) || wasObjectReferenced2(two, key, objects)) {
                 delete result[key];
               } else {
-                if (isObject4(obj1) && isObject4(obj2)) {
+                if (isObject5(obj1) && isObject5(obj2)) {
                   const arr1 = objects.get(obj1) || [];
                   const arr2 = objects.get(obj2) || [];
                   arr1.push({ obj: one, key });
@@ -19670,7 +20540,7 @@ var require_merge = __commonJS({
     function isFunction4(value2) {
       return typeof value2 === "function";
     }
-    function isObject4(value2) {
+    function isObject5(value2) {
       return !isPrimitive3(value2) && !isArray5(value2) && !isFunction4(value2) && typeof value2 === "object";
     }
     function isPrimitive3(value2) {
@@ -20296,12 +21166,12 @@ function isEmpty2(value2) {
   if (isArray4(value2) || isString(value2)) {
     return value2.length === 0;
   }
-  if (isObject3(value2)) {
+  if (isObject4(value2)) {
     return Object.keys(value2).length === 0;
   }
   return false;
 }
-var isUndefined, isNull, isString, isNumber, isInt, isBoolean, isSymbol, isObject3, isFunction3, isArray4, isRegExp, isThenable, isPrimitive2, isEventDefined, isEvent, isErrorDefined, isError, isErrorEvent, isDomError, isDomException, isElementDefined, isElement, isMapDefined, isMap, isSyntheticEvent;
+var isUndefined, isNull, isString, isNumber, isInt, isBoolean, isSymbol, isObject4, isFunction3, isArray4, isRegExp, isThenable, isPrimitive2, isEventDefined, isEvent, isErrorDefined, isError, isErrorEvent, isDomError, isDomException, isElementDefined, isElement, isMapDefined, isMap, isSyntheticEvent;
 var init_is = __esm({
   "../../../node_modules/@grafana/faro-core/dist/esm/utils/is.js"() {
     isUndefined = ((value2) => isTypeof(value2, "undefined"));
@@ -20311,12 +21181,12 @@ var init_is = __esm({
     isInt = ((value2) => isNumber(value2) && Number.isInteger(value2));
     isBoolean = ((value2) => isTypeof(value2, "boolean"));
     isSymbol = ((value2) => isTypeof(value2, "symbol"));
-    isObject3 = ((value2) => !isNull(value2) && isTypeof(value2, "object"));
+    isObject4 = ((value2) => !isNull(value2) && isTypeof(value2, "object"));
     isFunction3 = ((value2) => isTypeof(value2, "function"));
     isArray4 = ((value2) => isToString(value2, "Array"));
     isRegExp = ((value2) => isToString(value2, "RegExp"));
     isThenable = ((value2) => isFunction3(value2 === null || value2 === void 0 ? void 0 : value2.then));
-    isPrimitive2 = ((value2) => !isObject3(value2) && !isFunction3(value2));
+    isPrimitive2 = ((value2) => !isObject4(value2) && !isFunction3(value2));
     isEventDefined = typeof Event !== "undefined";
     isEvent = ((value2) => isEventDefined && isInstanceOf(value2, Event));
     isErrorDefined = typeof Error !== "undefined";
@@ -20328,7 +21198,7 @@ var init_is = __esm({
     isElement = ((value2) => isElementDefined && isInstanceOf(value2, Element));
     isMapDefined = typeof Map !== "undefined";
     isMap = ((value2) => isMapDefined && isInstanceOf(value2, Map));
-    isSyntheticEvent = ((value2) => isObject3(value2) && "nativeEvent" in value2 && "preventDefault" in value2 && "stopPropagation" in value2);
+    isSyntheticEvent = ((value2) => isObject4(value2) && "nativeEvent" in value2 && "preventDefault" in value2 && "stopPropagation" in value2);
   }
 });
 
@@ -20357,8 +21227,8 @@ function deepEqual2(a3, b3) {
     }
     return true;
   }
-  const aIsObject = isObject3(a3);
-  const bIsObject = isObject3(b3);
+  const aIsObject = isObject4(a3);
+  const bIsObject = isObject4(b3);
   if (aIsObject !== bIsObject) {
     return false;
   }
@@ -20519,7 +21389,7 @@ var init_sourceMaps = __esm({
 function getCircularDependencyReplacer() {
   const valueSeen = /* @__PURE__ */ new WeakSet();
   return function(_key, value2) {
-    if (isObject3(value2) && value2 !== null) {
+    if (isObject4(value2) && value2 !== null) {
       if (valueSeen.has(value2)) {
         return null;
       }
@@ -20534,7 +21404,7 @@ function stringifyExternalJson(json = {}) {
 function stringifyObjectValues(obj = {}) {
   const o3 = {};
   for (const [key, value2] of Object.entries(obj)) {
-    o3[key] = isObject3(value2) && value2 !== null ? stringifyExternalJson(value2) : String(value2);
+    o3[key] = isObject4(value2) && value2 !== null ? stringifyExternalJson(value2) : String(value2);
   }
   return o3;
 }
@@ -21201,7 +22071,7 @@ var init_const5 = __esm({
     defaultExceptionType = "Error";
     defaultErrorArgsSerializer = (args2) => {
       return args2.map((arg) => {
-        if (isObject3(arg)) {
+        if (isObject4(arg)) {
           return stringifyExternalJson(arg);
         }
         return String(arg);
@@ -21287,7 +22157,7 @@ function parseCause(error) {
   let cause = error.cause;
   if (isError(cause)) {
     cause = error.cause.toString();
-  } else if (cause !== null && (isObject3(error.cause) || isArray4(error.cause))) {
+  } else if (cause !== null && (isObject4(error.cause) || isArray4(error.cause))) {
     cause = stringifyExternalJson(error.cause);
   } else if (cause != null) {
     cause = error.cause.toString();
@@ -22128,7 +22998,7 @@ var require_ua_parser = __commonJS({
         }
       };
       var rgxMapper = function(ua, arrays) {
-        var i3 = 0, j3, k3, p3, q3, matches, match;
+        var i3 = 0, j3, k3, p3, q3, matches, match2;
         while (i3 < arrays.length && !matches) {
           var regex = arrays[i3], props = arrays[i3 + 1];
           j3 = k3 = 0;
@@ -22139,26 +23009,26 @@ var require_ua_parser = __commonJS({
             matches = regex[j3++].exec(ua);
             if (!!matches) {
               for (p3 = 0; p3 < props.length; p3++) {
-                match = matches[++k3];
+                match2 = matches[++k3];
                 q3 = props[p3];
                 if (typeof q3 === OBJ_TYPE && q3.length > 0) {
                   if (q3.length === 2) {
                     if (typeof q3[1] == FUNC_TYPE) {
-                      this[q3[0]] = q3[1].call(this, match);
+                      this[q3[0]] = q3[1].call(this, match2);
                     } else {
                       this[q3[0]] = q3[1];
                     }
                   } else if (q3.length === 3) {
                     if (typeof q3[1] === FUNC_TYPE && !(q3[1].exec && q3[1].test)) {
-                      this[q3[0]] = match ? q3[1].call(this, match, q3[2]) : undefined2;
+                      this[q3[0]] = match2 ? q3[1].call(this, match2, q3[2]) : undefined2;
                     } else {
-                      this[q3[0]] = match ? match.replace(q3[1], q3[2]) : undefined2;
+                      this[q3[0]] = match2 ? match2.replace(q3[1], q3[2]) : undefined2;
                     }
                   } else if (q3.length === 4) {
-                    this[q3[0]] = match ? q3[3].call(this, match.replace(q3[1], q3[2])) : undefined2;
+                    this[q3[0]] = match2 ? q3[3].call(this, match2.replace(q3[1], q3[2])) : undefined2;
                   }
                 } else {
-                  this[q3] = match ? match : undefined2;
+                  this[q3] = match2 ? match2 : undefined2;
                 }
               }
             }
@@ -23518,18 +24388,18 @@ var require_ua_parser = __commonJS({
           window2.UAParser = UAParser2;
         }
       }
-      var $3 = typeof window2 !== UNDEF_TYPE && (window2.jQuery || window2.Zepto);
-      if ($3 && !$3.ua) {
+      var $4 = typeof window2 !== UNDEF_TYPE && (window2.jQuery || window2.Zepto);
+      if ($4 && !$4.ua) {
         var parser = new UAParser2();
-        $3.ua = parser.getResult();
-        $3.ua.get = function() {
+        $4.ua = parser.getResult();
+        $4.ua.get = function() {
           return parser.getUA();
         };
-        $3.ua.set = function(ua) {
+        $4.ua.set = function(ua) {
           parser.setUA(ua);
           var result = parser.getResult();
           for (var prop in result) {
-            $3.ua[prop] = result[prop];
+            $4.ua[prop] = result[prop];
           }
         };
       }
@@ -23879,11 +24749,11 @@ function sendOverrideEvent(hasSessionOverridesChanged, sessionOverrides = {}, st
   if (!hasSessionOverridesChanged) {
     return;
   }
-  const serviceName = sessionOverrides.serviceName;
+  const serviceName2 = sessionOverrides.serviceName;
   const previousServiceName = (_c = (_a2 = storedSessionOverrides.serviceName) !== null && _a2 !== void 0 ? _a2 : (_b = faro.metas.value.app) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : "";
-  if (serviceName && serviceName !== previousServiceName) {
+  if (serviceName2 && serviceName2 !== previousServiceName) {
     faro.api.pushEvent(EVENT_OVERRIDES_SERVICE_NAME, {
-      serviceName,
+      serviceName: serviceName2,
       previousServiceName
     });
   }
@@ -24325,7 +25195,7 @@ function getErrorDetails(evt) {
   } else if (isError(evt)) {
     value2 = evt.message;
     stackFrames = getStackFramesFromError(evt);
-  } else if (isObject3(evt) || (isEventRes = isEvent(evt))) {
+  } else if (isObject4(evt) || (isEventRes = isEvent(evt))) {
     type = isEventRes ? evt.constructor.name : void 0;
     value2 = `${objectEventValue} ${Object.keys(evt)}`;
   }
@@ -24556,7 +25426,7 @@ var init_view = __esm({
 });
 
 // ../../../node_modules/web-vitals/dist/web-vitals.js
-var e, n, t, r, i, o, a, c, u, f, s, d, l, p, v, m, h, g, y, T, E, C, b, S, L, w, A, I, P, M, k, F, D, x, R, B, H, q, O, N, j, _, z, G, J, K, Q, U, V, W, X, Y, Z, $, ee;
+var e, n, t, r, i, o, a, c, u, f, s, d, l, p, v, m, h, g, y, T, E, C, b, S, L, w, A, I, P, M, k, F, D, x, R, B, H, q, O, N, j, _, z, G, J, K, Q, U, V, W, X, Y, Z, $2, ee;
 var init_web_vitals = __esm({
   "../../../node_modules/web-vitals/dist/web-vitals.js"() {
     o = -1;
@@ -24820,7 +25690,7 @@ var init_web_vitals = __esm({
         return e4(n3, Y, U);
       }));
     };
-    $ = [100, 300];
+    $2 = [100, 300];
     ee = function(e4, r3) {
       r3 = r3 || {}, C((function() {
         var o3, c3 = E(), u3 = f("FID"), l3 = function(e5) {
@@ -24828,11 +25698,11 @@ var init_web_vitals = __esm({
         }, m3 = function(e5) {
           e5.forEach(l3);
         }, h3 = s("first-input", m3);
-        o3 = d(e4, u3, $, r3.reportAllChanges), h3 && (p(v((function() {
+        o3 = d(e4, u3, $2, r3.reportAllChanges), h3 && (p(v((function() {
           m3(h3.takeRecords()), h3.disconnect();
         }))), a((function() {
           var a3;
-          u3 = f("FID"), o3 = d(e4, u3, $, r3.reportAllChanges), i = [], t = -1, n = null, Z(addEventListener), a3 = l3, i.push(a3), X();
+          u3 = f("FID"), o3 = d(e4, u3, $2, r3.reportAllChanges), i = [], t = -1, n = null, Z(addEventListener), a3 = l3, i.push(a3), X();
         })));
       }));
     };
@@ -24875,7 +25745,7 @@ var init_webVitalsBasic = __esm({
 });
 
 // ../../../node_modules/web-vitals/dist/web-vitals.attribution.js
-var t2, e3, n2, r2, i2, a2, o2, c2, u2, s2, f2, d2, l2, m2, p2, v2, g2, h2, T2, y2, E2, S2, b2, L2, C2, M2, D2, w2, x2, I2, k2, A2, F2, P2, B2, O2, R2, j2, q2, H2, N2, W2, z2, U2, V2, _2, G2, J2, K2, Q2, X2, Y2, Z2, $2, tt, et, nt, rt, it, at2, ot, ct, ut, st, ft, dt, lt, mt, pt, vt, gt, ht, Tt, yt;
+var t2, e3, n2, r2, i2, a2, o2, c2, u2, s2, f2, d2, l2, m2, p2, v2, g2, h2, T2, y2, E2, S2, b2, L2, C2, M2, D2, w2, x2, I2, k2, A2, F2, P2, B2, O2, R2, j2, q2, H2, N2, W2, z2, U2, V2, _2, G2, J2, K2, Q2, X2, Y2, Z2, $3, tt, et, nt, rt, it, at2, ot, ct, ut, st, ft, dt, lt, mt, pt, vt, gt, ht, Tt, yt;
 var init_web_vitals_attribution = __esm({
   "../../../node_modules/web-vitals/dist/web-vitals.attribution.js"() {
     n2 = function() {
@@ -25273,11 +26143,11 @@ var init_web_vitals_attribution = __esm({
     dt = { passive: true, capture: true };
     lt = /* @__PURE__ */ new Date();
     mt = function(t4, e4) {
-      Z2 || (Z2 = e4, $2 = t4, tt = /* @__PURE__ */ new Date(), gt(removeEventListener), pt());
+      Z2 || (Z2 = e4, $3 = t4, tt = /* @__PURE__ */ new Date(), gt(removeEventListener), pt());
     };
     pt = function() {
-      if ($2 >= 0 && $2 < tt - lt) {
-        var t4 = { entryType: "first-input", name: Z2.type, target: Z2.target, cancelable: Z2.cancelable, startTime: Z2.timeStamp, processingStart: Z2.timeStamp + $2 };
+      if ($3 >= 0 && $3 < tt - lt) {
+        var t4 = { entryType: "first-input", name: Z2.type, target: Z2.target, cancelable: Z2.cancelable, startTime: Z2.timeStamp, processingStart: Z2.timeStamp + $3 };
         et.forEach((function(e4) {
           e4(t4);
         })), et = [];
@@ -25315,7 +26185,7 @@ var init_web_vitals_attribution = __esm({
           o3(c3.takeRecords()), c3.disconnect();
         }))), u2((function() {
           var r4;
-          i3 = f2("FID"), n3 = l2(t4, i3, ht, e4.reportAllChanges), et = [], $2 = -1, Z2 = null, gt(addEventListener), r4 = a3, et.push(r4), pt();
+          i3 = f2("FID"), n3 = l2(t4, i3, ht, e4.reportAllChanges), et = [], $3 = -1, Z2 = null, gt(addEventListener), r4 = a3, et.push(r4), pt();
         })));
       }));
     };
@@ -25813,7 +26683,7 @@ var init_instrumentation6 = __esm({
 });
 
 // ../../../node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/performance/index.js
-var init_performance2 = __esm({
+var init_performance = __esm({
   "../../../node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/performance/index.js"() {
     init_instrumentation6();
   }
@@ -26221,7 +27091,7 @@ var init_instrumentations2 = __esm({
     init_errors();
     init_view();
     init_webVitals();
-    init_performance2();
+    init_performance();
     init_userActions();
     init_csp();
   }
@@ -26578,7 +27448,7 @@ function createDefaultMetas(browserConfig) {
     createPageMeta({ generatePageId, initialPageMeta: page }),
     ...(_b = browserConfig.metas) !== null && _b !== void 0 ? _b : []
   ];
-  const isK6BrowserSession = isObject3(window.k6);
+  const isK6BrowserSession = isObject4(window.k6);
   if (isK6BrowserSession) {
     return [...initialMetas, k6Meta];
   }
@@ -26733,7 +27603,7 @@ __export(esm_exports4, {
   isMapDefined: () => isMapDefined,
   isNull: () => isNull,
   isNumber: () => isNumber,
-  isObject: () => isObject3,
+  isObject: () => isObject4,
   isPrimitive: () => isPrimitive2,
   isRegExp: () => isRegExp,
   isString: () => isString,
@@ -27466,7 +28336,7 @@ var init_globalThis3 = __esm({
 
 // ../../../node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/core/build/esm/platform/browser/performance.js
 var otperformance2;
-var init_performance3 = __esm({
+var init_performance2 = __esm({
   "../../../node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/core/build/esm/platform/browser/performance.js"() {
     otperformance2 = performance;
   }
@@ -27477,7 +28347,7 @@ var init_browser6 = __esm({
   "../../../node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/core/build/esm/platform/browser/index.js"() {
     init_environment3();
     init_globalThis3();
-    init_performance3();
+    init_performance2();
   }
 });
 
@@ -28357,7 +29227,7 @@ var init_environment4 = __esm({
 
 // ../../../node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/core/build/esm/platform/browser/performance.js
 var otperformance3;
-var init_performance4 = __esm({
+var init_performance3 = __esm({
   "../../../node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/core/build/esm/platform/browser/performance.js"() {
     otperformance3 = performance;
   }
@@ -28367,7 +29237,7 @@ var init_performance4 = __esm({
 var init_browser7 = __esm({
   "../../../node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/core/build/esm/platform/browser/index.js"() {
     init_environment4();
-    init_performance4();
+    init_performance3();
   }
 });
 
@@ -29344,19 +30214,21 @@ var init_getDefaultOTELInstrumentations = __esm({
   }
 });
 
-// ../../../node_modules/@opentelemetry/resources/build/esm/platform/browser/default-service-name.js
+// ../../../node_modules/@opentelemetry/resources/build/esm/default-service-name.js
 function defaultServiceName() {
-  return "unknown_service";
+  if (serviceName === void 0) {
+    try {
+      const argv0 = globalThis.process.argv0;
+      serviceName = argv0 ? `unknown_service:${argv0}` : "unknown_service";
+    } catch {
+      serviceName = "unknown_service";
+    }
+  }
+  return serviceName;
 }
+var serviceName;
 var init_default_service_name = __esm({
-  "../../../node_modules/@opentelemetry/resources/build/esm/platform/browser/default-service-name.js"() {
-  }
-});
-
-// ../../../node_modules/@opentelemetry/resources/build/esm/platform/browser/index.js
-var init_browser8 = __esm({
-  "../../../node_modules/@opentelemetry/resources/build/esm/platform/browser/index.js"() {
-    init_default_service_name();
+  "../../../node_modules/@opentelemetry/resources/build/esm/default-service-name.js"() {
   }
 });
 
@@ -29426,7 +30298,7 @@ var init_ResourceImpl = __esm({
     init_esm();
     init_esm3();
     init_esm2();
-    init_browser8();
+    init_default_service_name();
     init_utils14();
     ResourceImpl = class _ResourceImpl {
       constructor(resource, options) {
@@ -29563,7 +30435,7 @@ var init_Span = __esm({
         const now = Date.now();
         this._spanContext = opts.spanContext;
         this._performanceStartTime = otperformance.now();
-        this._performanceOffset = now - (this._performanceStartTime + getTimeOrigin());
+        this._performanceOffset = now - (this._performanceStartTime + otperformance.timeOrigin);
         this._startTimeProvided = opts.startTime != null;
         this._spanLimits = opts.spanLimits;
         this._attributeValueLengthLimit = this._spanLimits.attributeValueLengthLimit || 0;
@@ -29675,7 +30547,6 @@ var init_Span = __esm({
           diag2.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
           return;
         }
-        this._ended = true;
         this.endTime = this._getTime(endTime);
         this._duration = hrTimeDuration(this.startTime, this.endTime);
         if (this._duration[0] < 0) {
@@ -29686,6 +30557,10 @@ var init_Span = __esm({
         if (this._droppedEventsCount > 0) {
           diag2.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`);
         }
+        if (this._spanProcessor.onEnding) {
+          this._spanProcessor.onEnding(this);
+        }
+        this._ended = true;
         this._spanProcessor.onEnd(this);
       }
       _getTime(inp) {
@@ -29898,11 +30773,10 @@ var init_TraceIdRatioBasedSampler = __esm({
     init_esm();
     init_Sampler();
     TraceIdRatioBasedSampler = class {
-      constructor(_ratio = 0) {
+      constructor(ratio = 0) {
         __publicField(this, "_ratio");
         __publicField(this, "_upperBound");
-        this._ratio = _ratio;
-        this._ratio = this._normalize(_ratio);
+        this._ratio = this._normalize(ratio);
         this._upperBound = Math.floor(this._ratio * 4294967295);
       }
       shouldSample(context2, traceId) {
@@ -30048,19 +30922,19 @@ var init_BatchSpanProcessorBase = __esm({
     init_esm();
     init_esm3();
     BatchSpanProcessorBase = class {
-      constructor(_exporter, config) {
-        __publicField(this, "_exporter");
+      constructor(exporter, config) {
         __publicField(this, "_maxExportBatchSize");
         __publicField(this, "_maxQueueSize");
         __publicField(this, "_scheduledDelayMillis");
         __publicField(this, "_exportTimeoutMillis");
+        __publicField(this, "_exporter");
         __publicField(this, "_isExporting", false);
         __publicField(this, "_finishedSpans", []);
         __publicField(this, "_timer");
         __publicField(this, "_shutdownOnce");
         __publicField(this, "_droppedSpansCount", 0);
         var _a2, _b, _c, _d;
-        this._exporter = _exporter;
+        this._exporter = exporter;
         this._maxExportBatchSize = typeof (config == null ? void 0 : config.maxExportBatchSize) === "number" ? config.maxExportBatchSize : (_a2 = getNumberFromEnv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE")) != null ? _a2 : 512;
         this._maxQueueSize = typeof (config == null ? void 0 : config.maxQueueSize) === "number" ? config.maxQueueSize : (_b = getNumberFromEnv("OTEL_BSP_MAX_QUEUE_SIZE")) != null ? _b : 2048;
         this._scheduledDelayMillis = typeof (config == null ? void 0 : config.scheduledDelayMillis) === "number" ? config.scheduledDelayMillis : (_c = getNumberFromEnv("OTEL_BSP_SCHEDULE_DELAY")) != null ? _c : 5e3;
@@ -30296,7 +31170,7 @@ var init_RandomIdGenerator = __esm({
 });
 
 // ../../../node_modules/@opentelemetry/sdk-trace-web/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/browser/index.js
-var init_browser9 = __esm({
+var init_browser8 = __esm({
   "../../../node_modules/@opentelemetry/sdk-trace-web/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/browser/index.js"() {
     init_BatchSpanProcessor();
     init_RandomIdGenerator();
@@ -30311,7 +31185,7 @@ var init_Tracer = __esm({
     init_esm3();
     init_Span();
     init_utility();
-    init_browser9();
+    init_browser8();
     Tracer = class {
       /**
        * Constructs a new Tracer instance.
@@ -30433,9 +31307,9 @@ var init_MultiSpanProcessor = __esm({
   "../../../node_modules/@opentelemetry/sdk-trace-web/node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js"() {
     init_esm3();
     MultiSpanProcessor = class {
-      constructor(_spanProcessors) {
+      constructor(spanProcessors) {
         __publicField(this, "_spanProcessors");
-        this._spanProcessors = _spanProcessors;
+        this._spanProcessors = spanProcessors;
       }
       forceFlush() {
         const promises = [];
@@ -30456,6 +31330,13 @@ var init_MultiSpanProcessor = __esm({
           spanProcessor.onStart(span, context2);
         }
       }
+      onEnding(span) {
+        for (const spanProcessor of this._spanProcessors) {
+          if (spanProcessor.onEnding) {
+            spanProcessor.onEnding(span);
+          }
+        }
+      }
       onEnd(span) {
         for (const spanProcessor of this._spanProcessors) {
           spanProcessor.onEnd(span);
@@ -30561,7 +31442,7 @@ var init_BasicTracerProvider = __esm({
 var init_esm15 = __esm({
   "../../../node_modules/@opentelemetry/sdk-trace-web/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js"() {
     init_BasicTracerProvider();
-    init_browser9();
+    init_browser8();
     init_Sampler();
   }
 });
@@ -33379,7 +34260,7 @@ var Transport = class extends Emitter {
     return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
   }
   _port() {
-    if (this.opts.port && (this.opts.secure && Number(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80)) {
+    if (this.opts.port && (this.opts.secure && Number(this.opts.port) !== 443 || !this.opts.secure && Number(this.opts.port) !== 80)) {
       return ":" + this.opts.port;
     } else {
       return "";
@@ -34610,6 +35491,7 @@ __export(esm_exports, {
   Decoder: () => Decoder,
   Encoder: () => Encoder,
   PacketType: () => PacketType,
+  isPacketValid: () => isPacketValid,
   protocol: () => protocol3
 });
 
@@ -34715,10 +35597,15 @@ function _reconstructPacket(data2, buffers) {
 // ../../../node_modules/socket.io-parser/build/esm/index.js
 var RESERVED_EVENTS = [
   "connect",
+  // used on the client side
   "connect_error",
+  // used on the client side
   "disconnect",
+  // used on both sides
   "disconnecting",
+  // used on the server side
   "newListener",
+  // used by the Node.js EventEmitter
   "removeListener"
   // used by the Node.js EventEmitter
 ];
@@ -34793,9 +35680,6 @@ var Encoder = class {
     return buffers;
   }
 };
-function isObject(value2) {
-  return Object.prototype.toString.call(value2) === "[object Object]";
-}
 var Decoder = class _Decoder extends Emitter {
   /**
    * Decoder constructor
@@ -34967,6 +35851,37 @@ var BinaryReconstructor = class {
     this.buffers = [];
   }
 };
+function isNamespaceValid(nsp) {
+  return typeof nsp === "string";
+}
+var isInteger = Number.isInteger || function(value2) {
+  return typeof value2 === "number" && isFinite(value2) && Math.floor(value2) === value2;
+};
+function isAckIdValid(id2) {
+  return id2 === void 0 || isInteger(id2);
+}
+function isObject(value2) {
+  return Object.prototype.toString.call(value2) === "[object Object]";
+}
+function isDataValid(type, payload) {
+  switch (type) {
+    case PacketType.CONNECT:
+      return payload === void 0 || isObject(payload);
+    case PacketType.DISCONNECT:
+      return payload === void 0;
+    case PacketType.EVENT:
+      return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1);
+    case PacketType.ACK:
+      return Array.isArray(payload);
+    case PacketType.CONNECT_ERROR:
+      return typeof payload === "string" || isObject(payload);
+    default:
+      return false;
+  }
+}
+function isPacketValid(packet) {
+  return isNamespaceValid(packet.nsp) && isAckIdValid(packet.id) && isDataValid(packet.type, packet.data);
+}
 
 // ../../../node_modules/socket.io-client/build/esm/on.js
 function on(obj, ev, fn) {
@@ -35232,7 +36147,6 @@ var Socket2 = class extends Emitter {
     };
     args2.push((err, ...responseArgs) => {
       if (packet !== this._queue[0]) {
-        return;
       }
       const hasError = err !== null;
       if (hasError) {
@@ -35464,8 +36378,8 @@ var Socket2 = class extends Emitter {
     this._pid = pid;
     this.connected = true;
     this.emitBuffered();
-    this.emitReserved("connect");
     this._drainQueue(true);
+    this.emitReserved("connect");
   }
   /**
    * Emit buffered events (received and emitted).
@@ -37133,17 +38047,17 @@ pp$9.strictDirective = function(start) {
   for (; ; ) {
     skipWhiteSpace.lastIndex = start;
     start += skipWhiteSpace.exec(this.input)[0].length;
-    var match = literal.exec(this.input.slice(start));
-    if (!match) {
+    var match2 = literal.exec(this.input.slice(start));
+    if (!match2) {
       return false;
     }
-    if ((match[1] || match[2]) === "use strict") {
-      skipWhiteSpace.lastIndex = start + match[0].length;
+    if ((match2[1] || match2[2]) === "use strict") {
+      skipWhiteSpace.lastIndex = start + match2[0].length;
       var spaceAfter = skipWhiteSpace.exec(this.input), end = spaceAfter.index + spaceAfter[0].length;
       var next = this.input.charAt(end);
       return next === ";" || next === "}" || lineBreak.test(spaceAfter[0]) && !(/[(`.[+\-/*%<>=,?^&]/.test(next) || next === "!" && this.input.charAt(end + 1) === "=");
     }
-    start += match[0].length;
+    start += match2[0].length;
     skipWhiteSpace.lastIndex = start;
     start += skipWhiteSpace.exec(this.input)[0].length;
     if (this.input[start] === ";") {
@@ -42123,7 +43037,7 @@ pp.readHexChar = function(len) {
 };
 pp.readWord1 = function() {
   this.containsEsc = false;
-  var word = "", first = true, chunkStart = this.pos;
+  var word2 = "", first = true, chunkStart = this.pos;
   var astral = this.options.ecmaVersion >= 6;
   while (this.pos < this.input.length) {
     var ch = this.fullCharCodeAtPos();
@@ -42131,7 +43045,7 @@ pp.readWord1 = function() {
       this.pos += ch <= 65535 ? 1 : 2;
     } else if (ch === 92) {
       this.containsEsc = true;
-      word += this.input.slice(chunkStart, this.pos);
+      word2 += this.input.slice(chunkStart, this.pos);
       var escStart = this.pos;
       if (this.input.charCodeAt(++this.pos) !== 117) {
         this.invalidStringToken(this.pos, "Expecting Unicode escape sequence \\uXXXX");
@@ -42141,22 +43055,22 @@ pp.readWord1 = function() {
       if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral)) {
         this.invalidStringToken(escStart, "Invalid Unicode escape");
       }
-      word += codePointToString(esc);
+      word2 += codePointToString(esc);
       chunkStart = this.pos;
     } else {
       break;
     }
     first = false;
   }
-  return word + this.input.slice(chunkStart, this.pos);
+  return word2 + this.input.slice(chunkStart, this.pos);
 };
 pp.readWord = function() {
-  var word = this.readWord1();
+  var word2 = this.readWord1();
   var type = types$1.name;
-  if (this.keywords.test(word)) {
-    type = keywords[word];
+  if (this.keywords.test(word2)) {
+    type = keywords[word2];
   }
-  return this.finishToken(type, word);
+  return this.finishToken(type, word2);
 };
 var version = "8.15.0";
 Parser.acorn = {
@@ -45289,6 +46203,9 @@ var PlanService = class extends BaseService {
         }
       });
     }
+    if (Object.hasOwn(planData, "key") && planData.key == null) {
+      throw new Error("Plan key must be a valid string");
+    }
     if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error(
         "Plan key must contain only lowercase letters, numbers, and hyphens"
@@ -45343,7 +46260,7 @@ var PlanService = class extends BaseService {
             `Pricing option '${key}' must have a non-negative numeric 'amount'`
           );
         }
-        if (interval != null && !allowedIntervals.has(interval)) {
+        if (interval !== null && !allowedIntervals.has(interval)) {
           throw new Error(
             `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
           );
@@ -45355,6 +46272,9 @@ var PlanService = class extends BaseService {
         }
       });
     }
+    if (Object.hasOwn(planData, "key") && planData.key == null) {
+      throw new Error("Plan key must be a valid string");
+    }
     if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error(
         "Plan key must contain only lowercase letters, numbers, and hyphens"