@streamlayer/sdk-web-anonymous-auth 1.3.16 → 1.4.0

package/lib/es/index.js

@@ -1,12 +1,9 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { importJWK, EncryptJWT } from "jose";
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
-var browser = { exports: {} };
-var process = browser.exports = {};
+var browser$1 = { exports: {} };
+var process = browser$1.exports = {};
 var cachedSetTimeout;
 var cachedClearTimeout;
 function defaultSetTimout() {
@@ -162,50 +159,555 @@ process.chdir = function(dir) {
 process.umask = function() {
   return 0;
 };
-var browserExports = browser.exports;
-const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
-const LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
-const LEVEL_MAP = {
-  trace: "debug",
-  debug: "debug",
-  info: "info",
-  warn: "warn",
-  error: "error",
-  fatal: "error"
-};
-const enabled = typeof window !== "undefined" && !!window.localStorage.getItem("SL_DEBUG");
-function createLogFn(consoleFn, prefix) {
-  if (!enabled)
-    return () => {
+var browserExports$1 = browser$1.exports;
+const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports$1);
+var browser = { exports: {} };
+var quickFormatUnescaped;
+var hasRequiredQuickFormatUnescaped;
+function requireQuickFormatUnescaped() {
+  if (hasRequiredQuickFormatUnescaped) return quickFormatUnescaped;
+  hasRequiredQuickFormatUnescaped = 1;
+  function tryStringify(o) {
+    try {
+      return JSON.stringify(o);
+    } catch (e) {
+      return '"[Circular]"';
+    }
+  }
+  quickFormatUnescaped = format;
+  function format(f, args, opts) {
+    var ss = opts && opts.stringify || tryStringify;
+    var offset = 1;
+    if (typeof f === "object" && f !== null) {
+      var len = args.length + offset;
+      if (len === 1) return f;
+      var objects = new Array(len);
+      objects[0] = ss(f);
+      for (var index = 1; index < len; index++) {
+        objects[index] = ss(args[index]);
+      }
+      return objects.join(" ");
+    }
+    if (typeof f !== "string") {
+      return f;
+    }
+    var argLen = args.length;
+    if (argLen === 0) return f;
+    var str = "";
+    var a = 1 - offset;
+    var lastPos = -1;
+    var flen = f && f.length || 0;
+    for (var i = 0; i < flen; ) {
+      if (f.charCodeAt(i) === 37 && i + 1 < flen) {
+        lastPos = lastPos > -1 ? lastPos : 0;
+        switch (f.charCodeAt(i + 1)) {
+          case 100:
+          // 'd'
+          case 102:
+            if (a >= argLen)
+              break;
+            if (args[a] == null) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += Number(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 105:
+            if (a >= argLen)
+              break;
+            if (args[a] == null) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += Math.floor(Number(args[a]));
+            lastPos = i + 2;
+            i++;
+            break;
+          case 79:
+          // 'O'
+          case 111:
+          // 'o'
+          case 106:
+            if (a >= argLen)
+              break;
+            if (args[a] === void 0) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            var type = typeof args[a];
+            if (type === "string") {
+              str += "'" + args[a] + "'";
+              lastPos = i + 2;
+              i++;
+              break;
+            }
+            if (type === "function") {
+              str += args[a].name || "<anonymous>";
+              lastPos = i + 2;
+              i++;
+              break;
+            }
+            str += ss(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 115:
+            if (a >= argLen)
+              break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += String(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 37:
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += "%";
+            lastPos = i + 2;
+            i++;
+            a--;
+            break;
+        }
+        ++a;
+      }
+      ++i;
+    }
+    if (lastPos === -1)
+      return f;
+    else if (lastPos < flen) {
+      str += f.slice(lastPos);
+    }
+    return str;
+  }
+  return quickFormatUnescaped;
+}
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser.exports;
+  hasRequiredBrowser = 1;
+  const format = requireQuickFormatUnescaped();
+  browser.exports = pino;
+  const _console = pfGlobalThisOrFallback().console || {};
+  const stdSerializers = {
+    mapHttpRequest: mock,
+    mapHttpResponse: mock,
+    wrapRequestSerializer: passthrough,
+    wrapResponseSerializer: passthrough,
+    wrapErrorSerializer: passthrough,
+    req: mock,
+    res: mock,
+    err: asErrValue,
+    errWithCause: asErrValue
+  };
+  function levelToValue(level, logger2) {
+    return level === "silent" ? Infinity : logger2.levels.values[level];
+  }
+  const baseLogFunctionSymbol = /* @__PURE__ */ Symbol("pino.logFuncs");
+  const hierarchySymbol = /* @__PURE__ */ Symbol("pino.hierarchy");
+  const logFallbackMap = {
+    error: "log",
+    fatal: "error",
+    warn: "error",
+    info: "log",
+    debug: "log",
+    trace: "log"
+  };
+  function appendChildLogger(parentLogger, childLogger) {
+    const newEntry = {
+      logger: childLogger,
+      parent: parentLogger[hierarchySymbol]
+    };
+    childLogger[hierarchySymbol] = newEntry;
+  }
+  function setupBaseLogFunctions(logger2, levels, proto) {
+    const logFunctions = {};
+    levels.forEach((level) => {
+      logFunctions[level] = proto[level] ? proto[level] : _console[level] || _console[logFallbackMap[level] || "log"] || noop2;
+    });
+    logger2[baseLogFunctionSymbol] = logFunctions;
+  }
+  function shouldSerialize(serialize, serializers) {
+    if (Array.isArray(serialize)) {
+      const hasToFilter = serialize.filter(function(k) {
+        return k !== "!stdSerializers.err";
+      });
+      return hasToFilter;
+    } else if (serialize === true) {
+      return Object.keys(serializers);
+    }
+    return false;
+  }
+  function pino(opts) {
+    opts = opts || {};
+    opts.browser = opts.browser || {};
+    const transmit2 = opts.browser.transmit;
+    if (transmit2 && typeof transmit2.send !== "function") {
+      throw Error("pino: transmit option must have a send function");
+    }
+    const proto = opts.browser.write || _console;
+    if (opts.browser.write) opts.browser.asObject = true;
+    const serializers = opts.serializers || {};
+    const serialize = shouldSerialize(opts.browser.serialize, serializers);
+    let stdErrSerialize = opts.browser.serialize;
+    if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false;
+    const customLevels = Object.keys(opts.customLevels || {});
+    const levels = ["error", "fatal", "warn", "info", "debug", "trace"].concat(customLevels);
+    if (typeof proto === "function") {
+      levels.forEach(function(level2) {
+        proto[level2] = proto;
+      });
+    }
+    if (opts.enabled === false || opts.browser.disabled) opts.level = "silent";
+    const level = opts.level || "info";
+    const logger2 = Object.create(proto);
+    if (!logger2.log) logger2.log = noop2;
+    setupBaseLogFunctions(logger2, levels, proto);
+    appendChildLogger({}, logger2);
+    Object.defineProperty(logger2, "levelVal", {
+      get: getLevelVal
+    });
+    Object.defineProperty(logger2, "level", {
+      get: getLevel,
+      set: setLevel
+    });
+    const setOpts = {
+      transmit: transmit2,
+      serialize,
+      asObject: opts.browser.asObject,
+      formatters: opts.browser.formatters,
+      levels,
+      timestamp: getTimeFunction(opts),
+      messageKey: opts.messageKey || "msg",
+      onChild: opts.onChild || noop2
+    };
+    logger2.levels = getLevels(opts);
+    logger2.level = level;
+    logger2.setMaxListeners = logger2.getMaxListeners = logger2.emit = logger2.addListener = logger2.on = logger2.prependListener = logger2.once = logger2.prependOnceListener = logger2.removeListener = logger2.removeAllListeners = logger2.listeners = logger2.listenerCount = logger2.eventNames = logger2.write = logger2.flush = noop2;
+    logger2.serializers = serializers;
+    logger2._serialize = serialize;
+    logger2._stdErrSerialize = stdErrSerialize;
+    logger2.child = function(...args) {
+      return child.call(this, setOpts, ...args);
     };
-  return (...args) => {
-    if (args.length === 0)
+    if (transmit2) logger2._logEvent = createLogEventShape();
+    function getLevelVal() {
+      return levelToValue(this.level, this);
+    }
+    function getLevel() {
+      return this._level;
+    }
+    function setLevel(level2) {
+      if (level2 !== "silent" && !this.levels.values[level2]) {
+        throw Error("unknown level " + level2);
+      }
+      this._level = level2;
+      set(this, setOpts, logger2, "error");
+      set(this, setOpts, logger2, "fatal");
+      set(this, setOpts, logger2, "warn");
+      set(this, setOpts, logger2, "info");
+      set(this, setOpts, logger2, "debug");
+      set(this, setOpts, logger2, "trace");
+      customLevels.forEach((level3) => {
+        set(this, setOpts, logger2, level3);
+      });
+    }
+    function child(setOpts2, bindings, childOptions) {
+      if (!bindings) {
+        throw new Error("missing bindings for child Pino");
+      }
+      childOptions = childOptions || {};
+      if (serialize && bindings.serializers) {
+        childOptions.serializers = bindings.serializers;
+      }
+      const childOptionsSerializers = childOptions.serializers;
+      if (serialize && childOptionsSerializers) {
+        var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
+        var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize;
+        delete bindings.serializers;
+        applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
+      }
+      function Child(parent) {
+        this._childLevel = (parent._childLevel | 0) + 1;
+        this.bindings = bindings;
+        if (childSerializers) {
+          this.serializers = childSerializers;
+          this._serialize = childSerialize;
+        }
+        if (transmit2) {
+          this._logEvent = createLogEventShape(
+            [].concat(parent._logEvent.bindings, bindings)
+          );
+        }
+      }
+      Child.prototype = this;
+      const newLogger = new Child(this);
+      appendChildLogger(this, newLogger);
+      newLogger.child = function(...args) {
+        return child.call(this, setOpts2, ...args);
+      };
+      newLogger.level = childOptions.level || this.level;
+      setOpts2.onChild(newLogger);
+      return newLogger;
+    }
+    return logger2;
+  }
+  function getLevels(opts) {
+    const customLevels = opts.customLevels || {};
+    const values = Object.assign({}, pino.levels.values, customLevels);
+    const labels = Object.assign({}, pino.levels.labels, invertObject(customLevels));
+    return {
+      values,
+      labels
+    };
+  }
+  function invertObject(obj) {
+    const inverted = {};
+    Object.keys(obj).forEach(function(key) {
+      inverted[obj[key]] = key;
+    });
+    return inverted;
+  }
+  pino.levels = {
+    values: {
+      fatal: 60,
+      error: 50,
+      warn: 40,
+      info: 30,
+      debug: 20,
+      trace: 10
+    },
+    labels: {
+      10: "trace",
+      20: "debug",
+      30: "info",
+      40: "warn",
+      50: "error",
+      60: "fatal"
+    }
+  };
+  pino.stdSerializers = stdSerializers;
+  pino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime });
+  function getBindingChain(logger2) {
+    const bindings = [];
+    if (logger2.bindings) {
+      bindings.push(logger2.bindings);
+    }
+    let hierarchy = logger2[hierarchySymbol];
+    while (hierarchy.parent) {
+      hierarchy = hierarchy.parent;
+      if (hierarchy.logger.bindings) {
+        bindings.push(hierarchy.logger.bindings);
+      }
+    }
+    return bindings.reverse();
+  }
+  function set(self2, opts, rootLogger, level) {
+    Object.defineProperty(self2, level, {
+      value: levelToValue(self2.level, rootLogger) > levelToValue(level, rootLogger) ? noop2 : rootLogger[baseLogFunctionSymbol][level],
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    if (self2[level] === noop2) {
+      if (!opts.transmit) return;
+      const transmitLevel = opts.transmit.level || self2.level;
+      const transmitValue = rootLogger.levels.values[transmitLevel];
+      const methodValue = rootLogger.levels.values[level];
+      if (methodValue < transmitValue) return;
+    }
+    self2[level] = createWrap(self2, opts, rootLogger, level);
+    const bindings = getBindingChain(self2);
+    if (bindings.length === 0) {
       return;
-    if (typeof args[0] === "string") {
-      consoleFn(`[${prefix}]`, ...args);
+    }
+    self2[level] = prependBindingsInArguments(bindings, self2[level]);
+  }
+  function prependBindingsInArguments(bindings, logFunc) {
+    return function() {
+      return logFunc.apply(this, [...bindings, ...arguments]);
+    };
+  }
+  function createWrap(self2, opts, rootLogger, level) {
+    return /* @__PURE__ */ (function(write) {
+      return function LOG() {
+        const ts = opts.timestamp();
+        const args = new Array(arguments.length);
+        const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this;
+        for (var i = 0; i < args.length; i++) args[i] = arguments[i];
+        var argsIsSerialized = false;
+        if (opts.serialize) {
+          applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
+          argsIsSerialized = true;
+        }
+        if (opts.asObject || opts.formatters) {
+          write.call(proto, asObject(this, level, args, ts, opts));
+        } else write.apply(proto, args);
+        if (opts.transmit) {
+          const transmitLevel = opts.transmit.level || self2._level;
+          const transmitValue = rootLogger.levels.values[transmitLevel];
+          const methodValue = rootLogger.levels.values[level];
+          if (methodValue < transmitValue) return;
+          transmit(this, {
+            ts,
+            methodLevel: level,
+            methodValue,
+            transmitValue: rootLogger.levels.values[opts.transmit.level || self2._level],
+            send: opts.transmit.send,
+            val: levelToValue(self2._level, rootLogger)
+          }, args, argsIsSerialized);
+        }
+      };
+    })(self2[baseLogFunctionSymbol][level]);
+  }
+  function asObject(logger2, level, args, ts, opts) {
+    const {
+      level: levelFormatter,
+      log: logObjectFormatter = (obj) => obj
+    } = opts.formatters || {};
+    const argsCloned = args.slice();
+    let msg = argsCloned[0];
+    const logObject = {};
+    if (ts) {
+      logObject.time = ts;
+    }
+    if (levelFormatter) {
+      const formattedLevel = levelFormatter(level, logger2.levels.values[level]);
+      Object.assign(logObject, formattedLevel);
     } else {
-      const [obj, ...rest] = args;
-      consoleFn(`[${prefix}]`, ...rest, obj);
+      logObject.level = logger2.levels.values[level];
     }
-  };
-}
-function createLoggerInstance(bindings) {
-  const prefix = bindings.name || "app";
-  const instance = {
-    level: "trace",
-    child(childBindings, _options) {
-      return createLoggerInstance({ ...bindings, ...childBindings });
+    let lvl = (logger2._childLevel | 0) + 1;
+    if (lvl < 1) lvl = 1;
+    if (msg !== null && typeof msg === "object") {
+      while (lvl-- && typeof argsCloned[0] === "object") {
+        Object.assign(logObject, argsCloned.shift());
+      }
+      msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0;
+    } else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned);
+    if (msg !== void 0) logObject[opts.messageKey] = msg;
+    const formattedLogObject = logObjectFormatter(logObject);
+    return formattedLogObject;
+  }
+  function applySerializers(args, serialize, serializers, stdErrSerialize) {
+    for (const i in args) {
+      if (stdErrSerialize && args[i] instanceof Error) {
+        args[i] = pino.stdSerializers.err(args[i]);
+      } else if (typeof args[i] === "object" && !Array.isArray(args[i]) && serialize) {
+        for (const k in args[i]) {
+          if (serialize.indexOf(k) > -1 && k in serializers) {
+            args[i][k] = serializers[k](args[i][k]);
+          }
+        }
+      }
     }
-  };
-  for (const level of LEVELS) {
-    const method = LEVEL_MAP[level];
-    const consoleFn = (...a) => console[method](...a);
-    instance[level] = createLogFn(consoleFn, prefix);
   }
-  return instance;
+  function transmit(logger2, opts, args, argsIsSerialized = false) {
+    const send = opts.send;
+    const ts = opts.ts;
+    const methodLevel = opts.methodLevel;
+    const methodValue = opts.methodValue;
+    const val = opts.val;
+    const bindings = logger2._logEvent.bindings;
+    if (!argsIsSerialized) {
+      applySerializers(
+        args,
+        logger2._serialize || Object.keys(logger2.serializers),
+        logger2.serializers,
+        logger2._stdErrSerialize === void 0 ? true : logger2._stdErrSerialize
+      );
+    }
+    logger2._logEvent.ts = ts;
+    logger2._logEvent.messages = args.filter(function(arg) {
+      return bindings.indexOf(arg) === -1;
+    });
+    logger2._logEvent.level.label = methodLevel;
+    logger2._logEvent.level.value = methodValue;
+    send(methodLevel, logger2._logEvent, val);
+    logger2._logEvent = createLogEventShape(bindings);
+  }
+  function createLogEventShape(bindings) {
+    return {
+      ts: 0,
+      messages: [],
+      bindings: bindings || [],
+      level: { label: "", value: 0 }
+    };
+  }
+  function asErrValue(err) {
+    const obj = {
+      type: err.constructor.name,
+      msg: err.message,
+      stack: err.stack
+    };
+    for (const key in err) {
+      if (obj[key] === void 0) {
+        obj[key] = err[key];
+      }
+    }
+    return obj;
+  }
+  function getTimeFunction(opts) {
+    if (typeof opts.timestamp === "function") {
+      return opts.timestamp;
+    }
+    if (opts.timestamp === false) {
+      return nullTime;
+    }
+    return epochTime;
+  }
+  function mock() {
+    return {};
+  }
+  function passthrough(a) {
+    return a;
+  }
+  function noop2() {
+  }
+  function nullTime() {
+    return false;
+  }
+  function epochTime() {
+    return Date.now();
+  }
+  function unixTime() {
+    return Math.round(Date.now() / 1e3);
+  }
+  function isoTime() {
+    return new Date(Date.now()).toISOString();
+  }
+  function pfGlobalThisOrFallback() {
+    function defd(o) {
+      return typeof o !== "undefined" && o;
+    }
+    try {
+      if (typeof globalThis !== "undefined") return globalThis;
+      Object.defineProperty(Object.prototype, "globalThis", {
+        get: function() {
+          delete Object.prototype.globalThis;
+          return this.globalThis = this;
+        },
+        configurable: true
+      });
+      return globalThis;
+    } catch (e) {
+      return defd(self) || defd(window) || defd(this) || {};
+    }
+  }
+  browser.exports.default = pino;
+  browser.exports.pino = pino;
+  return browser.exports;
 }
-const rootLogger = createLoggerInstance({});
-const createLogger = (name, options) => rootLogger.child({ name }, options);
+var browserExports = requireBrowser();
+const logger = browserExports.pino({
+  level: "trace",
+  enabled: typeof window !== "undefined" && !!window.localStorage.getItem("SL_DEBUG"),
+  browser: {
+    write: (o) => {
+      console.log(o);
+    }
+  }
+});
+const createLogger = (name, options) => logger.child({ name }, options);
 createLogger("event-bus");
 function protoCamelCase(snakeCase) {
   let capNext = false;
@@ -536,7 +1038,7 @@ function isScalarZeroValue(type, value) {
   }
 }
 const IMPLICIT$2 = 2;
-const unsafeLocal = Symbol.for("reflect unsafe local");
+const unsafeLocal = /* @__PURE__ */ Symbol.for("reflect unsafe local");
 function unsafeOneofCase(target, oneof) {
   const c = target[oneof.localName].case;
   if (c === void 0) {
@@ -557,6 +1059,7 @@ function unsafeIsSet(target, field) {
       return target[name].length > 0;
     case "map":
       return Object.keys(target[name]).length > 0;
+    // eslint-disable-line @typescript-eslint/no-unsafe-argument
     case "scalar":
       return !isScalarZeroValue(field.scalar, target[name]);
     case "enum":
@@ -1582,13 +2085,17 @@ function base64Decode(base64Str) {
     b = table[base64Str.charCodeAt(i)];
     if (b === void 0) {
       switch (base64Str[i]) {
+        // @ts-expect-error TS7029: Fallthrough case in switch
         case "=":
           groupPos = 0;
+        // reset state when padding found
+        // eslint-disable-next-line no-fallthrough
         case "\n":
         case "\r":
         case "	":
         case " ":
           continue;
+        // skip white-space, and padding
         default:
           throw Error("invalid base64 string");
       }
@@ -1683,7 +2190,7 @@ function isReflectMap(arg, field) {
 function isReflectMessage(arg, messageDesc2) {
   return isObject(arg) && unsafeLocal in arg && "desc" in arg && isObject(arg.desc) && arg.desc.kind === "message" && (messageDesc2 === void 0 || arg.desc.typeName == messageDesc2.typeName);
 }
-const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+const symbol = /* @__PURE__ */ Symbol.for("@bufbuild/protobuf/text-encoding");
 function getTextEncoding() {
   if (globalThis[symbol] == void 0) {
     const te = new globalThis.TextEncoder();
@@ -1753,8 +2260,11 @@ class BinaryReader {
         while (this.buf[this.pos++] & 128) {
         }
         break;
+      // eslint-disable-next-line
+      // @ts-expect-error TS7029: Fallthrough case in switch
       case WireType.Bit64:
         this.pos += 4;
+      // eslint-disable-next-line no-fallthrough
       case WireType.Bit32:
         this.pos += 4;
         break;
@@ -2125,7 +2635,7 @@ function create(schema, init) {
   const message = createZeroMessage(schema);
   return message;
 }
-const tokenZeroMessageField = Symbol();
+const tokenZeroMessageField = /* @__PURE__ */ Symbol();
 const messagePrototypes = /* @__PURE__ */ new WeakMap();
 function createZeroMessage(desc) {
   let msg;
@@ -3006,40 +3516,40 @@ function isQuotaExceededError(err) {
   err.name === "NS_ERROR_DOM_QUOTA_REACHED");
 }
 class Storage {
+  delimiter = ":";
+  prefix;
+  storage;
   constructor(prefix = "main", storage2 = window.localStorage) {
-    __publicField(this, "delimiter", ":");
-    __publicField(this, "prefix");
-    __publicField(this, "storage");
-    __publicField(this, "clear", () => {
-      for (const key in window.localStorage) {
-        if (key.startsWith(this.prefix)) {
-          this.storage.removeItem(key);
-        }
-      }
-    });
-    __publicField(this, "generateKey", (keyParts) => `${this.prefix}${this.delimiter}${keyParts.join(this.delimiter)}`);
-    __publicField(this, "write", (...keyParts) => {
-      const value = keyParts.pop() || "";
-      const key = this.generateKey(keyParts);
-      try {
-        this.storage.setItem(key, value);
-      } catch (err) {
-        if (isQuotaExceededError(err) && this.storage === window.sessionStorage) {
-          window.sessionStorage.removeItem("slstreamlogs");
-          this.storage.setItem(key, value);
-        }
-      }
-    });
-    __publicField(this, "read", (...keyParts) => {
-      const value = this.storage.getItem(this.generateKey(keyParts));
-      return value === null ? void 0 : value;
-    });
-    __publicField(this, "remove", (...keyParts) => {
-      this.storage.removeItem(this.generateKey(keyParts));
-    });
     this.prefix = `sl-sdk${this.delimiter}${prefix}`;
     this.storage = storage2;
   }
+  clear = () => {
+    for (const key in window.localStorage) {
+      if (key.startsWith(this.prefix)) {
+        this.storage.removeItem(key);
+      }
+    }
+  };
+  generateKey = (keyParts) => `${this.prefix}${this.delimiter}${keyParts.join(this.delimiter)}`;
+  write = (...keyParts) => {
+    const value = keyParts.pop() || "";
+    const key = this.generateKey(keyParts);
+    try {
+      this.storage.setItem(key, value);
+    } catch (err) {
+      if (isQuotaExceededError(err) && this.storage === window.sessionStorage) {
+        window.sessionStorage.removeItem("slstreamlogs");
+        this.storage.setItem(key, value);
+      }
+    }
+  };
+  read = (...keyParts) => {
+    const value = this.storage.getItem(this.generateKey(keyParts));
+    return value === null ? void 0 : value;
+  };
+  remove = (...keyParts) => {
+    this.storage.removeItem(this.generateKey(keyParts));
+  };
 }
 var ServerStreamSubscriptionStatus;
 (function(ServerStreamSubscriptionStatus2) {
@@ -3084,31 +3594,31 @@ var KEY_PREFIX;
 class UserStorage extends Storage {
   constructor() {
     super("user");
-    // Schema
-    __publicField(this, "setSchema", (value) => {
-      this.write(KEY_PREFIX.SCHEMA, value);
-    });
-    __publicField(this, "getSchema", () => {
-      return this.read(KEY_PREFIX.SCHEMA);
-    });
-    // Token
-    __publicField(this, "setToken", (value) => {
-      this.write(KEY_PREFIX.TOKEN, value);
-    });
-    __publicField(this, "getToken", () => {
-      return this.read(KEY_PREFIX.TOKEN);
-    });
-    // External Token
-    __publicField(this, "setExternalToken", (value) => {
-      this.write(KEY_PREFIX.EXTERNAL_TOKEN, value);
-    });
-    __publicField(this, "getExternalToken", () => {
-      return this.read(KEY_PREFIX.EXTERNAL_TOKEN);
-    });
-    __publicField(this, "removeToken", () => {
-      this.remove(KEY_PREFIX.TOKEN);
-    });
   }
+  // Schema
+  setSchema = (value) => {
+    this.write(KEY_PREFIX.SCHEMA, value);
+  };
+  getSchema = () => {
+    return this.read(KEY_PREFIX.SCHEMA);
+  };
+  // Token
+  setToken = (value) => {
+    this.write(KEY_PREFIX.TOKEN, value);
+  };
+  getToken = () => {
+    return this.read(KEY_PREFIX.TOKEN);
+  };
+  // External Token
+  setExternalToken = (value) => {
+    this.write(KEY_PREFIX.EXTERNAL_TOKEN, value);
+  };
+  getExternalToken = () => {
+    return this.read(KEY_PREFIX.EXTERNAL_TOKEN);
+  };
+  removeToken = () => {
+    this.remove(KEY_PREFIX.TOKEN);
+  };
 }
 var CoreStatus;
 (function(CoreStatus2) {
@@ -3122,7 +3632,6 @@ createLogger("deep_link");
 createLogger("bypass");
 const storage = new UserStorage();
 const login = async (instance, opts = {}) => {
-  var _a, _b;
   const { schemaName, issuer } = {
     schemaName: "slra",
     issuer: "sdk-web",
@@ -3133,10 +3642,10 @@ const login = async (instance, opts = {}) => {
   if (!organization) {
     throw new Error("unknown organization");
   }
-  const userKey = `${(_a = organization.pub) == null ? void 0 : _a.kid}`;
+  const userKey = `${organization.pub?.kid}`;
   const schema = `${schemaName}:${organization.id}`;
   const anonymous2 = await bypassAuth(instance.transport, { userKey, schema, init: true });
-  const token = (_b = anonymous2.meta) == null ? void 0 : _b.token;
+  const token = anonymous2.meta?.token;
   const pubKey = organization.pub;
   const pub = await importJWK({ ...pubKey });
   const deviceId = window.crypto.randomUUID();