@corbado/observe 1.7.1 → 1.8.0

package/dist/analysis/readers/device.mjs

@@ -0,0 +1,73 @@
+// src/readers/device.ts
+function readUserAgent(_meta) {
+  if (typeof navigator === "undefined") {
+    return "";
+  }
+  return navigator.userAgent ?? "";
+}
+async function readBluetoothAvailability(_meta) {
+  if (typeof navigator === "undefined" || !navigator.bluetooth) {
+    return void 0;
+  }
+  return await navigator.bluetooth.getAvailability();
+}
+async function readUserVerifyingPlatformAuthenticatorAvailable(_meta) {
+  if (typeof PublicKeyCredential === "undefined" || !PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable) {
+    return void 0;
+  }
+  return await PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
+}
+async function readConditionalMediationAvailable(_meta) {
+  if (typeof PublicKeyCredential === "undefined" || !PublicKeyCredential.isConditionalMediationAvailable) {
+    return void 0;
+  }
+  return await PublicKeyCredential.isConditionalMediationAvailable();
+}
+async function readClientCapabilities(_meta) {
+  if (typeof PublicKeyCredential === "undefined" || !PublicKeyCredential.getClientCapabilities) {
+    return void 0;
+  }
+  const rawClientCapabilities = await PublicKeyCredential.getClientCapabilities();
+  return Object.fromEntries(Object.entries(rawClientCapabilities).map(([key, value]) => [key, value.toString()]));
+}
+async function readJavaScriptHighEntropy(_meta) {
+  if (typeof navigator === "undefined" || !navigator.userAgentData) {
+    return void 0;
+  }
+  const ua = await navigator.userAgentData.getHighEntropyValues(["platformVersion", "model"]);
+  const platform = ua.platform;
+  const mobile = ua.mobile;
+  const platformVersion = ua.platformVersion;
+  const model = ua.model || void 0;
+  if (!platform || mobile === void 0 || !platformVersion) {
+    return;
+  }
+  return {
+    platform,
+    mobile,
+    platformVersion,
+    model
+  };
+}
+function readWebdriver(_meta) {
+  if (typeof navigator === "undefined") {
+    return void 0;
+  }
+  return navigator.webdriver;
+}
+function readMaxTouchPoints(_meta) {
+  if (typeof navigator === "undefined" || typeof navigator.maxTouchPoints !== "number") {
+    return void 0;
+  }
+  return navigator.maxTouchPoints;
+}
+export {
+  readBluetoothAvailability,
+  readClientCapabilities,
+  readConditionalMediationAvailable,
+  readJavaScriptHighEntropy,
+  readMaxTouchPoints,
+  readUserAgent,
+  readUserVerifyingPlatformAuthenticatorAvailable,
+  readWebdriver
+};

package/dist/analysis/readers/meta.mjs

@@ -0,0 +1,18 @@
+// src/readers/meta.ts
+var READER_EXPOSURES = [
+  "none",
+  "presence",
+  "size",
+  "class",
+  "format",
+  "partial",
+  "enum",
+  "computed",
+  "token",
+  "pseudonym",
+  "redacted",
+  "raw"
+];
+export {
+  READER_EXPOSURES
+};

package/dist/analysis/readers/password-manager-dom.mjs

@@ -0,0 +1,112 @@
+// src/readers/password-manager-dom.ts
+var SIGNAL_TAG_QUERIES = [
+  { query: "com-1password-button", eventType: "pa-1" },
+  { query: "com-1password-menu", eventType: "pa-2" },
+  { query: "com-1password-notification", eventType: "pa-3" }
+];
+var SIGNAL_ATTR_SELECTOR = "[data-lastpass-root], [data-lp], [data-lpignore], [data-lpfieldtype]";
+var SIGNAL_ATTR_EVENT_TYPE = "pa-4";
+var POPOVER_MANUAL_SELECTOR = '[popover="manual"]';
+var PROFILE_A_MIN_STYLE_LENGTH = 400;
+var PROFILE_A_MIN_INITIAL_IMPORTANT = 20;
+var PROFILE_A_EVENT_TYPE = "pa-5";
+var PROFILE_B_EVENT_TYPE = "pa-6";
+var safeQueryAll = (root, selector) => {
+  try {
+    return Array.from(root.querySelectorAll(selector));
+  } catch {
+    return [];
+  }
+};
+var isPopoverProfileA = (el) => {
+  if (el.getAttribute("popover") !== "manual") {
+    return false;
+  }
+  const style = el.getAttribute("style") ?? "";
+  if (style.length < PROFILE_A_MIN_STYLE_LENGTH) {
+    return false;
+  }
+  if (!/z-index:\s*2147483647\b/i.test(style)) {
+    return false;
+  }
+  if (!/position:\s*fixed\b/i.test(style)) {
+    return false;
+  }
+  if (!/display:\s*block\b/i.test(style)) {
+    return false;
+  }
+  const initialImportantHits = style.match(/initial\s*!important/gi);
+  if ((initialImportantHits?.length ?? 0) < PROFILE_A_MIN_INITIAL_IMPORTANT) {
+    return false;
+  }
+  return true;
+};
+var isPopoverProfileB = (el) => {
+  if (isPopoverProfileA(el)) {
+    return false;
+  }
+  if (el.getAttribute("popover") !== "manual") {
+    return false;
+  }
+  const style = el.getAttribute("style") ?? "";
+  if (!/z-index:\s*2147483647\b/i.test(style)) {
+    return false;
+  }
+  if (!/position:\s*fixed\b/i.test(style)) {
+    return false;
+  }
+  if (!/backdrop-filter:\s*[^;]*blur\(\s*20px\s*\)/i.test(style)) {
+    return false;
+  }
+  if (!/background-color:\s*rgba\(\s*35\s*,\s*35\s*,\s*35\s*,/i.test(style)) {
+    return false;
+  }
+  return true;
+};
+var forEachScanRoot = (cb) => {
+  cb(document);
+  for (const host of Array.from(document.querySelectorAll("*"))) {
+    const shadowRoot = host.shadowRoot;
+    if (shadowRoot) {
+      cb(shadowRoot);
+    }
+  }
+};
+var scanInputEnvSignals = () => {
+  const matched = /* @__PURE__ */ new Set();
+  if (typeof document === "undefined") {
+    return matched;
+  }
+  forEachScanRoot((root) => {
+    for (const entry of SIGNAL_TAG_QUERIES) {
+      if (matched.has(entry.eventType)) {
+        continue;
+      }
+      if (safeQueryAll(root, entry.query).length > 0) {
+        matched.add(entry.eventType);
+      }
+    }
+    if (!matched.has(SIGNAL_ATTR_EVENT_TYPE) && safeQueryAll(root, SIGNAL_ATTR_SELECTOR).length > 0) {
+      matched.add(SIGNAL_ATTR_EVENT_TYPE);
+    }
+    if (!matched.has(PROFILE_A_EVENT_TYPE) || !matched.has(PROFILE_B_EVENT_TYPE)) {
+      for (const el of safeQueryAll(root, POPOVER_MANUAL_SELECTOR)) {
+        if (!matched.has(PROFILE_A_EVENT_TYPE) && isPopoverProfileA(el)) {
+          matched.add(PROFILE_A_EVENT_TYPE);
+          continue;
+        }
+        if (!matched.has(PROFILE_B_EVENT_TYPE) && isPopoverProfileB(el)) {
+          matched.add(PROFILE_B_EVENT_TYPE);
+        }
+      }
+    }
+  });
+  return matched;
+};
+function readPasswordManagerDomSignals(_meta) {
+  return scanInputEnvSignals();
+}
+export {
+  readPasswordManagerDomSignals,
+  scanInputEnvSignals
+};

package/dist/analysis/readers/password-manager-extensions.mjs

@@ -0,0 +1,247 @@
+// src/readers/password-manager-extensions.ts
+var ONEPASSWORD_SCRIPT = "/inline/injected/webauthn-listeners.js";
+var DASHLANE_STACK = /\/dashlane-(?:shadow-dom|top-layer)-page-script\.js/;
+var KASPERSKY_SCRIPT = /-extension:\/\/[^/]+\/content-scripts\/passkey_proxy\/index\.js$/;
+var KEEPER_STACK = /-extension:\/\/[^/]+\/content_scripts\/shadow-dom\/shadowAttachNotifier\.js:/;
+var NORDPASS_STACK = /-extension:\/\/[^/]+\/js\/nordpass-script\.js:/;
+var NORDPASS_PASSKEYS_KEY = /-extension:\/\/[^/]+\/js\/passkeys\.js:/;
+var KEEPER_SOURCE = /["'`](?:keeper:shadow-root-attached|webauthn-(?:get|create)-request)["'`]/;
+var PROTONPASS_SOURCE = /Intercept cancelled for `(?:get|create)`|["'`](?:conditionalMediationAvailable|verifyingPlatformAuthenticatorAvailable)["'`]/;
+var sentryDebugIdKeys = () => Object.keys(window._sentryDebugIds ?? {});
+var stackOf = (fn) => {
+  try {
+    fn();
+  } catch (error) {
+    return String(error?.stack ?? "");
+  }
+  return "";
+};
+var attachShadowStack = () => stackOf(() => Element.prototype.attachShadow.call(null, { mode: "open" }));
+var has1PasswordAccessor = () => {
+  const hook = Object.getOwnPropertyDescriptor(navigator.credentials ?? {}, "get");
+  if (!hook?.get || !hook.set || hook.configurable) {
+    return false;
+  }
+  const marker = () => void 0;
+  const read = hook.get.call({ _get: marker });
+  return read === marker || typeof read === "function" && read === hook.get.call({}) && !Function.prototype.toString.call(read).includes("[native code]");
+};
+var credentialSlots = (...keys) => {
+  const credentials = navigator.credentials;
+  return credentials ? keys.map((key) => Object.getOwnPropertyDescriptor(credentials, key)?.value) : [];
+};
+var hasBitwardenOverride = () => [navigator.credentials?.get, ...credentialSlots("get", "_get")].some(
+  (method) => typeof method === "function" && method.name === "getWebAuthnCredential"
+);
+var probeBitwardenKeyframes = () => {
+  const root = document.documentElement;
+  const sheets = document.adoptedStyleSheets;
+  if (!root || typeof root.getAnimations !== "function" || typeof sheets?.push !== "function") {
+    return false;
+  }
+  if (root.getAnimations().length > 0) return false;
+  const sheet = new CSSStyleSheet();
+  sheet.replaceSync(":where(:root){animation:bitwardenfill 1s 1000s paused}");
+  sheets.push(sheet);
+  try {
+    const found = root.getAnimations().filter((animation) => animation.animationName === "bitwardenfill");
+    found.forEach((animation) => animation.cancel());
+    return found.length > 0;
+  } finally {
+    const index = sheets.indexOf(sheet);
+    if (index >= 0) sheets.splice(index, 1);
+  }
+};
+var bitwardenKeyframes;
+var hasBitwardenKeyframes = () => bitwardenKeyframes ??= probeBitwardenKeyframes();
+var hasDashlaneInstanceTrap = () => {
+  const credential = typeof PublicKeyCredential === "undefined" ? void 0 : PublicKeyCredential;
+  if (typeof credential !== "function" || !Object.prototype.hasOwnProperty.call(credential, Symbol.hasInstance)) {
+    return false;
+  }
+  const result = credential[Symbol.hasInstance]({});
+  if (!(result instanceof Promise)) return false;
+  result.catch(() => void 0);
+  return true;
+};
+var nordPassObserverStack = () => {
+  const target = {
+    get nodeType() {
+      throw new Error("probe");
+    }
+  };
+  return stackOf(() => MutationObserver.prototype.observe.call(null, target));
+};
+var hasNordPassObserverProxy = () => {
+  const sentinel = new Error("probe");
+  const read = [];
+  const target = {
+    get nodeType() {
+      read.push("nodeType");
+      return 1;
+    },
+    get ownerDocument() {
+      read.push("ownerDocument");
+      throw sentinel;
+    }
+  };
+  try {
+    MutationObserver.prototype.observe.call(null, target);
+  } catch (error) {
+    return error === sentinel && read.join() === "nodeType,ownerDocument";
+  }
+  return false;
+};
+var hasKeeperOverride = () => {
+  const methods = [
+    Element.prototype.attachShadow,
+    navigator.credentials?.get,
+    navigator.credentials?.create,
+    ...credentialSlots("get", "_get", "create")
+  ];
+  return methods.some((m) => typeof m === "function" && KEEPER_SOURCE.test(Function.prototype.toString.call(m)));
+};
+var hasLastPassRoot = () => {
+  let root = document;
+  while (root) {
+    if (root.querySelector("[data-lastpass-icon-root], [data-lastpass-root]")) {
+      return true;
+    }
+    root = root.activeElement?.shadowRoot;
+  }
+  return false;
+};
+var hasProtonPassOverride = () => {
+  const credential = typeof PublicKeyCredential === "undefined" ? void 0 : PublicKeyCredential;
+  const methods = [
+    navigator.credentials?.get,
+    ...credentialSlots("get", "_get"),
+    credential?.isConditionalMediationAvailable,
+    credential?._isConditionalMediationAvailable,
+    credential?.isUserVerifyingPlatformAuthenticatorAvailable,
+    credential?._isUserVerifyingPlatformAuthenticatorAvailable
+  ];
+  return methods.some((m) => typeof m === "function" && PROTONPASS_SOURCE.test(Function.prototype.toString.call(m)));
+};
+var PROBES = [
+  {
+    name: "1password",
+    signal: "in-field button",
+    signedIn: true,
+    // Renders only for a signed-in account (locked or not), while a login field is focused.
+    test: () => document.querySelector("com-1password-button") !== null
+  },
+  { name: "1password", signal: "credentials.get accessor", test: has1PasswordAccessor },
+  {
+    name: "1password",
+    signal: "Sentry debug id",
+    // Sentry debug-id keys are stack strings naming the injected script.
+    test: () => sentryDebugIdKeys().some((key) => key.includes(ONEPASSWORD_SCRIPT))
+  },
+  { name: "bitwarden", signal: "passkey override", signedIn: true, test: hasBitwardenOverride },
+  { name: "bitwarden", signal: "autofill keyframes", test: hasBitwardenKeyframes },
+  {
+    name: "dashlane",
+    signal: "injected script tag",
+    // Edge injects its page scripts as tags (https only); they are in the DOM before they execute.
+    test: () => document.querySelector('script[src*="-extension://"][src*="/dashlane-"][src$="-page-script.js"]') !== null
+  },
+  { name: "dashlane", signal: "PublicKeyCredential hasInstance trap", test: hasDashlaneInstanceTrap },
+  {
+    name: "dashlane",
+    signal: "page script stack",
+    // The shadow-dom and top-layer page scripts (http too) wrap these methods; a null receiver throws inside them.
+    test: () => DASHLANE_STACK.test(attachShadowStack()) || typeof HTMLDialogElement !== "undefined" && DASHLANE_STACK.test(
+      stackOf(() => HTMLDialogElement.prototype.showModal.call(null))
+    )
+  },
+  {
+    name: "kaspersky",
+    signal: "passkey proxy flag",
+    // Set in every https frame at document_start, with or without its desktop app.
+    test: () => window.wasKPMKeyPassProxyInited === true
+  },
+  {
+    name: "kaspersky",
+    signal: "injected script tag",
+    // Firefox injects the proxy as a script tag, which is in the DOM before it runs.
+    test: () => KASPERSKY_SCRIPT.test(
+      document.querySelector('script[src*="/content-scripts/passkey_proxy/"]')?.src ?? ""
+    )
+  },
+  {
+    name: "keeper",
+    signal: "attachShadow stack",
+    // Wrapped at document_start; a null receiver throws inside the wrapper before it notifies.
+    test: () => KEEPER_STACK.test(attachShadowStack())
+  },
+  { name: "keeper", signal: "override source", test: hasKeeperOverride },
+  {
+    name: "keeper",
+    signal: "field lock",
+    // Tagged on every login field it decorates, signed in or not, shortly after load.
+    test: () => document.querySelector("[data-keeper-lock-id]") !== null
+  },
+  {
+    name: "lastpass",
+    signal: "passkey override",
+    signedIn: true,
+    // Registered at document_start (https) while the vault is unlocked and its passkey support is enabled.
+    test: () => typeof window.__nativeCredentialsGet === "function"
+  },
+  // Otherwise nothing runs in the page until it decorates a login field, shortly after load.
+  { name: "lastpass", signal: "icon root", test: hasLastPassRoot },
+  { name: "nordpass", signal: "observer proxy stack", test: () => NORDPASS_STACK.test(nordPassObserverStack()) },
+  { name: "nordpass", signal: "observer read order", test: hasNordPassObserverProxy },
+  {
+    name: "nordpass",
+    signal: "passkeys Sentry debug id",
+    test: () => sentryDebugIdKeys().some((key) => NORDPASS_PASSKEYS_KEY.test(key))
+  },
+  {
+    name: "nordpass",
+    signal: "Sentry debug id",
+    test: () => sentryDebugIdKeys().some((key) => NORDPASS_STACK.test(key))
+  },
+  { name: "protonpass", signal: "WebAuthn override source", test: hasProtonPassOverride },
+  {
+    name: "protonpass",
+    signal: "field icon",
+    // Plain http, frames and later wrappers: its root and field-icon elements once its client script runs.
+    test: () => document.querySelector("[data-protonpass-role]") !== null
+  }
+];
+function probePasswordManagerExtensions() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return [];
+  }
+  return PROBES.map(({ name, signal, signedIn, test }) => {
+    try {
+      return { name, signal, signedIn, matched: test() };
+    } catch (error) {
+      return { name, signal, signedIn, matched: false, error };
+    }
+  });
+}
+function detectPasswordManagerExtensions() {
+  const detected = /* @__PURE__ */ new Map();
+  for (const { name, signedIn, matched } of probePasswordManagerExtensions()) {
+    if (!matched) {
+      continue;
+    }
+    const extension = detected.get(name) ?? { name };
+    if (signedIn) {
+      extension.signedIn = true;
+    }
+    detected.set(name, extension);
+  }
+  return [...detected.values()];
+}
+function readPasswordManagerExtensions(_meta) {
+  return detectPasswordManagerExtensions();
+}
+export {
+  detectPasswordManagerExtensions,
+  probePasswordManagerExtensions,
+  readPasswordManagerExtensions
+};

package/dist/analysis/readers/private-mode.mjs

@@ -0,0 +1,9 @@
+// src/readers/private-mode.ts
+import detectIncognito from "detectincognitojs";
+async function readPrivateMode(_meta) {
+  const res = await detectIncognito();
+  return res.isPrivate;
+}
+export {
+  readPrivateMode
+};

package/dist/analysis/storage/index.mjs

@@ -0,0 +1,197 @@
+// src/storage/index.ts
+function namespacedKey(key, namespace) {
+  return `${key}_${namespace}`;
+}
+var NamespacedStorage = class {
+  constructor(engine, namespace) {
+    this.engine = engine;
+    this.namespace = namespace;
+  }
+  getItem(key) {
+    return this.engine.getItem(namespacedKey(key, this.namespace));
+  }
+  setItem(key, value) {
+    this.engine.setItem(namespacedKey(key, this.namespace), value);
+  }
+  removeItem(key) {
+    this.engine.removeItem(namespacedKey(key, this.namespace));
+  }
+};
+var LocalStorage = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Error situations:
+   *  - localStorage is not available: return null
+   *  - localStorage.getItem throws: catch exception, log error and return null
+   *  - JSON.parse throws: catch exception, log error and return null
+   */
+  getItem(key) {
+    try {
+      if (typeof localStorage === "undefined") return null;
+      const item = localStorage.getItem(key);
+      if (item) {
+        return JSON.parse(item);
+      }
+      return null;
+    } catch (error) {
+      this.logger.error(`LocalStorage.getItem failed for key "${key}"`, error);
+      return null;
+    }
+  }
+  /**
+   * Error situations:
+   *  - localStorage is not available: return without writing
+   *  - localStorage.setItem throws: catch exception and log error
+   *  - JSON.stringify throws: catch exception and log error
+   */
+  setItem(key, value) {
+    try {
+      if (typeof localStorage === "undefined") return;
+      localStorage.setItem(key, JSON.stringify(value));
+    } catch (error) {
+      this.logger.error(`LocalStorage.setItem failed for key "${key}"`, error);
+      this.logger.reportTelemetry?.("error", `localStorage.setItem failed: ${key}`);
+    }
+  }
+  /**
+   * Error situations:
+   *  - localStorage is not available: return without writing
+   *  - localStorage.removeItem throws: catch exception and log error
+   */
+  removeItem(key) {
+    try {
+      if (typeof localStorage === "undefined") return;
+      localStorage.removeItem(key);
+    } catch (error) {
+      this.logger.error(`LocalStorage.removeItem failed for key "${key}"`, error);
+    }
+  }
+};
+var CookieStorage = class {
+  constructor(logger, domain) {
+    this.logger = logger;
+    this.domain = domain;
+  }
+  /**
+   * Error situations:
+   *  - document is not available: return null
+   *  - document.cookie read throws: catch exception, log error and return null
+   *  - decodeURIComponent throws: catch exception, log error and return null
+   *  - JSON.parse throws: catch exception, log error and return null
+   */
+  getItem(key) {
+    try {
+      if (typeof document === "undefined") return null;
+      const name = key + "=";
+      const parts = document.cookie.split(";");
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i].trim();
+        if (part.indexOf(name) === 0) {
+          const rawValue = part.substring(name.length);
+          return JSON.parse(decodeURIComponent(rawValue));
+        }
+      }
+      return null;
+    } catch (error) {
+      this.logger.error(`CookieStorage.getItem failed for key "${key}"`, error);
+      return null;
+    }
+  }
+  /**
+   * Error situations:
+   *  - document is not available: return without writing
+   *  - document.cookie write throws: catch exception and log error
+   *  - JSON.stringify throws: catch exception and log error
+   */
+  setItem(key, value) {
+    try {
+      if (typeof document === "undefined") return;
+      let cookieString = `${key}=${encodeURIComponent(JSON.stringify(value))}; path=/; SameSite=Lax`;
+      if (this.domain) {
+        cookieString += `; domain=${this.domain}`;
+      }
+      document.cookie = cookieString;
+    } catch (error) {
+      this.logger.error(`CookieStorage.setItem failed for key "${key}"`, error);
+      this.logger.reportTelemetry?.("error", `cookie.setItem failed: ${key}`);
+    }
+  }
+  /**
+   * Error situations:
+   *  - document is not available: return without writing
+   *  - document.cookie write throws: catch exception and log error
+   */
+  removeItem(key) {
+    try {
+      if (typeof document === "undefined") return;
+      let cookieString = `${key}=; Max-Age=-99999999; path=/`;
+      if (this.domain) {
+        cookieString += `; domain=${this.domain}`;
+      }
+      document.cookie = cookieString;
+    } catch (error) {
+      this.logger.error(`CookieStorage.removeItem failed for key "${key}"`, error);
+    }
+  }
+};
+var SessionStorage = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Error situations:
+   *  - sessionStorage is not available: return null
+   *  - sessionStorage.getItem throws: catch exception, log error and return null
+   *  - JSON.parse throws: catch exception, log error and return null
+   */
+  getItem(key) {
+    try {
+      if (typeof sessionStorage === "undefined") return null;
+      const item = sessionStorage.getItem(key);
+      if (item) {
+        return JSON.parse(item);
+      }
+      return null;
+    } catch (error) {
+      this.logger.error(`SessionStorage.getItem failed for key "${key}"`, error);
+      return null;
+    }
+  }
+  /**
+   * Error situations:
+   *  - sessionStorage is not available: return without writing
+   *  - sessionStorage.setItem throws: catch exception and log error
+   *  - JSON.stringify throws: catch exception and log error
+   */
+  setItem(key, value) {
+    try {
+      if (typeof sessionStorage === "undefined") return;
+      sessionStorage.setItem(key, JSON.stringify(value));
+    } catch (error) {
+      this.logger.error(`SessionStorage.setItem failed for key "${key}"`, error);
+      this.logger.reportTelemetry?.("error", `sessionStorage.setItem failed: ${key}`);
+    }
+  }
+  /**
+   * Error situations:
+   *  - sessionStorage is not available: return without writing
+   *  - sessionStorage.removeItem throws: catch exception and log error
+   */
+  removeItem(key) {
+    try {
+      if (typeof sessionStorage === "undefined") return;
+      sessionStorage.removeItem(key);
+    } catch (error) {
+      this.logger.error(`SessionStorage.removeItem failed for key "${key}"`, error);
+    }
+  }
+};
+export {
+  CookieStorage,
+  LocalStorage,
+  NamespacedStorage,
+  SessionStorage,
+  namespacedKey
+};