@corbado/observe 1.7.2 → 1.9.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/input-paste.mjs

@@ -0,0 +1,91 @@
+// src/readers/input-paste.ts
+var InputPasteObserver = class {
+  constructor(_meta, inputs, logger, changed, reserveCaptureSeq) {
+    this.inputs = inputs;
+    this.logger = logger;
+    this.changed = changed;
+    this.reserveCaptureSeq = reserveCaptureSeq;
+    for (const input of inputs) {
+      input.addEventListener("paste", this.onPaste, true);
+      input.addEventListener("beforeinput", this.onBeforeInput, true);
+    }
+  }
+  before = null;
+  timestamp = 0;
+  captureSeq;
+  pasteEvent;
+  timer = null;
+  onPaste = (event) => this.begin(event);
+  onBeforeInput = (event) => {
+    if (event.inputType === "insertFromPaste") this.begin(event);
+    else this.flush();
+  };
+  /** An unrelated input event invalidates pending paste provenance before recording its change. */
+  handlesInput(event) {
+    if (!this.before) return false;
+    const inPasteDispatch = this.pasteEvent?.type === "paste" && (this.pasteEvent.eventPhase ?? 0) > 0;
+    if (event.inputType === "insertFromPaste" || inPasteDispatch) {
+      return true;
+    }
+    this.clear();
+    return false;
+  }
+  get pending() {
+    return this.before !== null;
+  }
+  begin(event) {
+    if (!event.isTrusted || this.before) return;
+    try {
+      this.before = this.inputs.map((input) => input.value);
+      this.pasteEvent = event;
+      this.timestamp = Date.now();
+      this.captureSeq = this.reserveCaptureSeq?.();
+      this.timer = setTimeout(() => this.flush(), 0);
+    } catch (error) {
+      this.logger.error("Failed to observe paste", error);
+      this.clear();
+    }
+  }
+  flush() {
+    const before = this.before;
+    if (!before) return;
+    const timestamp = this.timestamp;
+    const captureSeq = this.captureSeq;
+    this.clear();
+    try {
+      let inserted = 0;
+      let changed = false;
+      this.inputs.forEach((input, index) => {
+        const old = before[index];
+        const value = input.value;
+        if (old === value) return;
+        changed = true;
+        let start = 0;
+        while (start < old.length && start < value.length && old[start] === value[start]) start++;
+        let end = 0;
+        while (end < old.length - start && end < value.length - start && old[old.length - end - 1] === value[value.length - end - 1])
+          end++;
+        inserted += value.length - start - end;
+      });
+      if (changed) this.changed(timestamp, inserted, captureSeq);
+    } catch (error) {
+      this.logger.error("Failed to finish paste observation", error);
+    }
+  }
+  clear() {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    this.before = null;
+    this.pasteEvent = void 0;
+  }
+  destroy() {
+    this.flush();
+    for (const input of this.inputs) {
+      input.removeEventListener("paste", this.onPaste, true);
+      input.removeEventListener("beforeinput", this.onBeforeInput, true);
+    }
+  }
+};
+export {
+  InputPasteObserver
+};

package/dist/analysis/readers/input.mjs

@@ -0,0 +1,61 @@
+// src/readers/input.ts
+var FIELD_EVENTS = ["focus", "blur", "pointerdown", "pointerup", "click", "input", "keyup"];
+function observeInputField(_meta, field, handlers, guard, order = FIELD_EVENTS) {
+  const listeners = [];
+  for (const type of order) {
+    const listener = reduceFieldEvent(type, handlers, guard);
+    if (listener) listeners.push([type, listener]);
+  }
+  for (const [type, listener] of listeners) field.addEventListener(type, listener);
+  return () => {
+    for (const [type, listener] of listeners) field.removeEventListener(type, listener);
+  };
+}
+function reduceFieldEvent(type, handlers, guard) {
+  switch (type) {
+    case "focus":
+    case "blur": {
+      const handler = handlers[type];
+      return handler && ((event) => guard(type, () => handler(event.relatedTarget)));
+    }
+    case "pointerdown":
+    case "pointerup":
+    case "click": {
+      const handler = handlers[type];
+      return handler && (() => guard(type, () => handler()));
+    }
+    case "input": {
+      const handler = handlers.input;
+      return handler && ((event) => guard(
+        "input",
+        () => handler(
+          event.isComposing || event.inputType === "insertCompositionText",
+          event
+        )
+      ));
+    }
+    case "keyup": {
+      const handler = handlers.keyupEscape;
+      return handler && ((event) => guard("keyup", () => {
+        if (event.key === "Escape") handler();
+      }));
+    }
+  }
+}
+function readInputContentLength(_meta, field) {
+  if (field.type === "checkbox" || field.type === "radio") return field.checked ? 1 : 0;
+  return field.value.length;
+}
+function readInputGroupValueLength(_meta, fields) {
+  return fields.reduce((total, field) => total + field.value.length, 0);
+}
+function readFocusedField(_meta, fields) {
+  const active = document.activeElement;
+  return fields.find((field) => field === active);
+}
+export {
+  observeInputField,
+  readFocusedField,
+  readInputContentLength,
+  readInputGroupValueLength
+};

package/dist/analysis/readers/loader-global.mjs

@@ -0,0 +1,15 @@
+// src/readers/loader-global.ts
+function drainLoaderQueue(_meta, name, replay) {
+  const global = window.Corbado;
+  if (global?.[name]) {
+    replay(global[name]);
+    delete window.Corbado[name];
+  }
+}
+function installLoaderGlobal(_meta, api) {
+  window.Corbado = api;
+}
+export {
+  drainLoaderQueue,
+  installLoaderGlobal
+};

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/network.mjs

@@ -0,0 +1,14 @@
+// src/readers/network.ts
+function sendFetch(_meta, url, init) {
+  return fetch(url, init);
+}
+function beaconSender(_meta) {
+  if (typeof navigator?.sendBeacon !== "function") {
+    return void 0;
+  }
+  return (url, data) => navigator.sendBeacon(url, data);
+}
+export {
+  beaconSender,
+  sendFetch
+};

package/dist/analysis/readers/page.mjs

@@ -0,0 +1,30 @@
+// src/readers/page.ts
+import { applySourcePathQuery } from "../utils/source-path.mjs";
+function listenWindow(_meta, type, handler, options) {
+  if (options === void 0) {
+    window.addEventListener(type, handler);
+  } else {
+    window.addEventListener(type, handler, options);
+  }
+  return () => window.removeEventListener(type, handler);
+}
+function readDocumentHidden(_meta) {
+  return document.visibilityState === "hidden";
+}
+function readDocumentComplete(_meta) {
+  return document.readyState === "complete";
+}
+function readPageUrl(_meta) {
+  return window.location.href;
+}
+function readSourcePath(_meta, mode, allow) {
+  const search = applySourcePathQuery(window.location.search, mode, allow);
+  return `${window.location.pathname}${search}`;
+}
+export {
+  listenWindow,
+  readDocumentComplete,
+  readDocumentHidden,
+  readPageUrl,
+  readSourcePath
+};

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
+};