joopjs 2.0.0

package/dist/device/index.js

@@ -0,0 +1,960 @@
+'use strict';
+
+// src/device/device-fingerprint.service.ts
+var JoopDeviceFingerprintService = class {
+  collect() {
+    const nav = typeof navigator !== "undefined" ? navigator : null;
+    const scr = typeof screen !== "undefined" ? screen : null;
+    return {
+      userAgent: nav?.userAgent ?? "",
+      language: nav?.language ?? "",
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      screenResolution: scr ? `${scr.width}x${scr.height}` : "",
+      colorDepth: scr?.colorDepth ?? 0,
+      platform: nav?.platform ?? "",
+      hardwareConcurrency: nav?.hardwareConcurrency ?? 0,
+      maxTouchPoints: nav?.maxTouchPoints ?? 0
+    };
+  }
+  async generate() {
+    const info = this.collect();
+    const raw = Object.values(info).join("|");
+    const hashBuffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(raw));
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  async getStableId() {
+    const key = "__joop_did";
+    const stored = typeof localStorage !== "undefined" ? localStorage.getItem(key) : null;
+    if (stored) return stored;
+    const id = await this.generate();
+    if (typeof localStorage !== "undefined") localStorage.setItem(key, id);
+    return id;
+  }
+};
+
+// src/platform/platform.ts
+var _webStorage = (store) => ({
+  getItem: (k) => store.getItem(k),
+  setItem: (k, v) => store.setItem(k, v),
+  removeItem: (k) => store.removeItem(k),
+  clear: () => store.clear()
+});
+var _MemStorageImpl = class {
+  _m = /* @__PURE__ */ new Map();
+  getItem(k) {
+    return this._m.get(k) ?? null;
+  }
+  setItem(k, v) {
+    this._m.set(k, v);
+  }
+  removeItem(k) {
+    this._m.delete(k);
+  }
+  clear() {
+    this._m.clear();
+  }
+};
+function _detect() {
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") return "react-native";
+  const _proc = globalThis["process"];
+  if (typeof window === "undefined" && _proc?.versions?.node) return "node";
+  if (typeof window !== "undefined") return "web";
+  return "unknown";
+}
+var JoopPlatform = class {
+  static _type = _detect();
+  static _adapter = {};
+  static _memStorage = null;
+  /**
+   * Call once at app startup to configure adapters for your platform.
+   *
+   * Web (default — no call needed):
+   *   JoopPlatform.init();
+   *
+   * React Native with react-native-mmkv:
+   *   import { MMKV } from 'react-native-mmkv';
+   *   const mmkv = new MMKV();
+   *   JoopPlatform.init({ adapter: { storage: mmkv } });
+   *
+   * React Native with custom compression (fflate):
+   *   import { gzip, ungzip } from 'fflate';
+   *   JoopPlatform.init({
+   *     adapter: {
+   *       compression: {
+   *         compress: (d, fmt) => new Promise((res, rej) => gzip(d, (e, r) => e ? rej(e) : res(r))),
+   *         decompress: (d, fmt) => new Promise((res, rej) => ungzip(d, (e, r) => e ? rej(e) : res(r))),
+   *       },
+   *     },
+   *   });
+   */
+  static init(config = {}) {
+    if (config.platform) this._type = config.platform;
+    this._adapter = { ...this._adapter, ...config.adapter ?? {} };
+  }
+  /** Current detected or overridden platform type */
+  static get type() {
+    return this._type;
+  }
+  static is(type) {
+    return this._type === type;
+  }
+  static isMobile() {
+    return this._type === "react-native";
+  }
+  static isWeb() {
+    return this._type === "web";
+  }
+  static isNode() {
+    return this._type === "node";
+  }
+  /** Raw adapter config registered via init() */
+  static getAdapter() {
+    return this._adapter;
+  }
+  /**
+   * Returns the best available storage adapter:
+   *   1. Custom adapter registered via init()
+   *   2. localStorage (web)
+   *   3. In-memory fallback (Node / RN without adapter)
+   */
+  static getStorage() {
+    if (this._adapter.storage) return this._adapter.storage;
+    if (typeof localStorage !== "undefined") return _webStorage(localStorage);
+    if (!this._memStorage) this._memStorage = new _MemStorageImpl();
+    return this._memStorage;
+  }
+  /**
+   * Returns the best available session-scoped storage:
+   *   1. Custom adapter registered via init()
+   *   2. sessionStorage (web)
+   *   3. Shared in-memory fallback
+   */
+  static getSessionStorage() {
+    if (this._adapter.storage) return this._adapter.storage;
+    if (typeof sessionStorage !== "undefined") return _webStorage(sessionStorage);
+    if (!this._memStorage) this._memStorage = new _MemStorageImpl();
+    return this._memStorage;
+  }
+  /** What APIs are available in the current environment */
+  static capabilities() {
+    return {
+      compression: typeof CompressionStream !== "undefined" || !!this._adapter.compression,
+      workers: typeof Worker !== "undefined" || !!this._adapter.worker,
+      cryptoSubtle: !!(typeof globalThis !== "undefined" && globalThis.crypto?.subtle),
+      persistentStorage: typeof localStorage !== "undefined" || !!this._adapter.storage,
+      dom: typeof document !== "undefined",
+      serviceWorker: typeof navigator !== "undefined" && "serviceWorker" in navigator
+    };
+  }
+  /** Reset to auto-detected defaults — useful between tests */
+  static _reset() {
+    this._type = _detect();
+    this._adapter = {};
+    this._memStorage = null;
+  }
+};
+
+// src/device/key-vault.ts
+var JoopKeyVault = class {
+  _prefix;
+  _encKey;
+  _adapter;
+  _cryptoKey = null;
+  constructor(config = {}) {
+    this._prefix = config.prefix ?? "joop_vault_";
+    this._encKey = config.encryptionKey;
+    this._adapter = config.adapter ?? JoopPlatform.getAdapter().keyVault ?? null;
+  }
+  /** Store a secret. On web: AES-GCM encrypted if `encryptionKey` was provided. */
+  async set(key, value) {
+    if (this._adapter) return this._adapter.set(key, value);
+    const stored = this._encKey ? await _encrypt(value, await this._key()) : btoa(unescape(encodeURIComponent(value)));
+    JoopPlatform.getStorage().setItem(this._prefix + key, stored);
+  }
+  /** Retrieve a secret, or null if not found. */
+  async get(key) {
+    if (this._adapter) return this._adapter.get(key);
+    const raw = JoopPlatform.getStorage().getItem(this._prefix + key);
+    if (!raw) return null;
+    try {
+      return this._encKey ? await _decrypt(raw, await this._key()) : decodeURIComponent(escape(atob(raw)));
+    } catch {
+      return null;
+    }
+  }
+  async remove(key) {
+    if (this._adapter) return this._adapter.remove(key);
+    JoopPlatform.getStorage().removeItem(this._prefix + key);
+  }
+  async clear() {
+    if (this._adapter) return this._adapter.clear();
+    JoopPlatform.getStorage().clear?.();
+  }
+  async has(key) {
+    return await this.get(key) !== null;
+  }
+  /** Rotate the encryption key: re-encrypts all known entries with a new key. */
+  async rotateKey(newEncryptionKey, keys) {
+    if (this._adapter) throw new Error("rotateKey not supported with native adapter");
+    const values = await Promise.all(keys.map((k) => this.get(k)));
+    this._encKey = newEncryptionKey;
+    this._cryptoKey = null;
+    for (let i = 0; i < keys.length; i++) {
+      if (values[i] !== null) await this.set(keys[i], values[i]);
+    }
+  }
+  async _key() {
+    if (!this._cryptoKey) this._cryptoKey = await _deriveKey(this._encKey);
+    return this._cryptoKey;
+  }
+};
+var _SALT = new Uint8Array([
+  106,
+  111,
+  111,
+  112,
+  45,
+  118,
+  97,
+  117,
+  108,
+  116,
+  45,
+  118,
+  49,
+  0,
+  0,
+  0
+]);
+async function _deriveKey(password) {
+  const km = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    { name: "PBKDF2" },
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    { name: "PBKDF2", salt: _SALT, iterations: 1e5, hash: "SHA-256" },
+    km,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function _encrypt(value, key) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encrypted = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    new TextEncoder().encode(value)
+  );
+  const combined = new Uint8Array(12 + encrypted.byteLength);
+  combined.set(iv);
+  combined.set(new Uint8Array(encrypted), 12);
+  return btoa(String.fromCharCode(...combined));
+}
+async function _decrypt(encoded, key) {
+  const combined = Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+  const iv = combined.slice(0, 12);
+  const data = combined.slice(12);
+  const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, data);
+  return new TextDecoder().decode(decrypted);
+}
+
+// src/device/biometric-auth.ts
+var JoopBiometricAuth = class {
+  _rpId;
+  _rpName;
+  _adapter;
+  constructor(config = {}) {
+    this._rpId = config.rpId ?? (typeof location !== "undefined" ? location.hostname : "localhost");
+    this._rpName = config.rpName ?? this._rpId;
+    this._adapter = config.adapter ?? JoopPlatform.getAdapter().biometric ?? null;
+  }
+  /** True when a platform authenticator is available. */
+  async isAvailable() {
+    if (this._adapter) return this._adapter.isAvailable();
+    if (typeof window === "undefined" || !window.PublicKeyCredential) return false;
+    if (typeof PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable !== "function") return false;
+    return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
+  }
+  /**
+   * Enroll a new credential for the given user.
+   * Web: creates a WebAuthn passkey via navigator.credentials.create().
+   * React Native: delegates to the injected adapter.
+   */
+  async enroll(userId, displayName) {
+    if (this._adapter) throw new Error("Enrollment must be handled by the native adapter");
+    if (typeof navigator?.credentials?.create !== "function") {
+      throw new Error("WebAuthn not available in this environment");
+    }
+    const challenge = crypto.getRandomValues(new Uint8Array(32));
+    const cred = await navigator.credentials.create({
+      publicKey: {
+        challenge,
+        rp: { id: this._rpId, name: this._rpName },
+        user: { id: new TextEncoder().encode(userId), name: userId, displayName },
+        pubKeyCredParams: [
+          { type: "public-key", alg: -7 },
+          // ES256
+          { type: "public-key", alg: -257 }
+          // RS256
+        ],
+        authenticatorSelection: {
+          authenticatorAttachment: "platform",
+          userVerification: "required",
+          residentKey: "preferred"
+        },
+        timeout: 6e4,
+        attestation: "none"
+      }
+    });
+    const response = cred.response;
+    const pubKey = response.getPublicKey?.();
+    return {
+      credentialId: _b64url(cred.rawId),
+      publicKey: pubKey ? _b64url(pubKey) : void 0
+    };
+  }
+  /**
+   * Verify identity against an existing credential.
+   * Web: navigator.credentials.get() with WebAuthn assertion.
+   * React Native: delegates to the injected adapter.
+   */
+  async authenticate(options = {}) {
+    if (this._adapter) return this._adapter.authenticate(options.reason);
+    if (typeof navigator?.credentials?.get !== "function") return false;
+    const challenge = crypto.getRandomValues(new Uint8Array(32));
+    const allowCredentials = options.credentialId ? [{ type: "public-key", id: _b64urlToBytes(options.credentialId) }] : [];
+    try {
+      const cred = await navigator.credentials.get({
+        publicKey: {
+          challenge,
+          allowCredentials,
+          userVerification: "required",
+          timeout: options.timeout ?? 6e4
+        }
+      });
+      return !!cred;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Quick check — asks the platform if biometrics can be used right now.
+   * Does not prompt the user.
+   */
+  async canAuthenticate() {
+    if (this._adapter) return this._adapter.isAvailable();
+    return this.isAvailable();
+  }
+};
+function _b64url(buf) {
+  return btoa(String.fromCharCode(...new Uint8Array(buf))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function _b64urlToBytes(s) {
+  const padded = s.replace(/-/g, "+").replace(/_/g, "/").padEnd(
+    s.length + (4 - s.length % 4) % 4,
+    "="
+  );
+  return Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
+}
+
+// src/device/push-service.ts
+var JoopPushService = class {
+  _cfg;
+  _adapter;
+  _messageHandlers = [];
+  _adapterUnsub = null;
+  constructor(config = {}) {
+    this._cfg = config;
+    this._adapter = config.adapter ?? JoopPlatform.getAdapter().push ?? null;
+    if (this._adapter) {
+      this._adapterUnsub = this._adapter.onMessage((p) => this._emit(p));
+    }
+  }
+  /** Request push notification permission from the user. */
+  async requestPermission() {
+    if (this._adapter) {
+      const result = await this._adapter.requestPermission();
+      return result;
+    }
+    if (typeof Notification === "undefined") return "unsupported";
+    if (Notification.permission === "granted") return "granted";
+    const perm = await Notification.requestPermission();
+    return perm;
+  }
+  /** Get the current permission status without prompting. */
+  getPermission() {
+    if (this._adapter) return "default";
+    if (typeof Notification === "undefined") return "unsupported";
+    return Notification.permission;
+  }
+  /**
+   * Subscribe to web push and return subscription info to send to your server.
+   * Requires a service worker and a VAPID key.
+   */
+  async subscribe(options) {
+    if (this._adapter) {
+      const token = await this._adapter.getToken(options?.vapidPublicKey ?? this._cfg.vapidPublicKey);
+      return token ? { endpoint: token, p256dh: "", auth: "" } : null;
+    }
+    if (typeof navigator?.serviceWorker === "undefined") return null;
+    if (Notification.permission !== "granted") return null;
+    const vapidKey = options?.vapidPublicKey ?? this._cfg.vapidPublicKey;
+    if (!vapidKey) return null;
+    const reg = await navigator.serviceWorker.register(this._cfg.serviceWorkerPath ?? "/sw.js");
+    const sub = await reg.pushManager.subscribe({
+      userVisibleOnly: true,
+      applicationServerKey: _urlBase64ToUint8(vapidKey)
+    });
+    const keys = sub.getKey ? {
+      p256dh: btoa(String.fromCharCode(...new Uint8Array(sub.getKey("p256dh")))),
+      auth: btoa(String.fromCharCode(...new Uint8Array(sub.getKey("auth"))))
+    } : { p256dh: "", auth: "" };
+    return { endpoint: sub.endpoint, ...keys };
+  }
+  /** Unsubscribe from web push. */
+  async unsubscribe() {
+    if (this._adapter) return false;
+    if (typeof navigator?.serviceWorker === "undefined") return false;
+    try {
+      const reg = await navigator.serviceWorker.ready;
+      const sub = await reg.pushManager.getSubscription();
+      return sub ? sub.unsubscribe() : false;
+    } catch {
+      return false;
+    }
+  }
+  /** Display an immediate local notification (no server push required). */
+  async show(payload) {
+    if (this._adapter) {
+      this._emit(payload);
+      return;
+    }
+    if (typeof Notification === "undefined") return;
+    if (Notification.permission !== "granted") return;
+    new Notification(payload.title ?? "", {
+      body: payload.body,
+      icon: payload.icon,
+      badge: payload.icon,
+      tag: payload.tag,
+      data: payload.data
+    });
+  }
+  /** Set the app badge count (mobile only via adapter). */
+  async setBadgeCount(count) {
+    if (this._adapter?.setBadgeCount) await this._adapter.setBadgeCount(count);
+    else if (typeof navigator?.setAppBadge === "function") {
+      await navigator.setAppBadge(count);
+    }
+  }
+  /** Clear the app badge. */
+  async clearBadge() {
+    if (typeof navigator?.clearAppBadge === "function") {
+      await navigator.clearAppBadge();
+    }
+  }
+  /** Register a handler for incoming push payloads (foreground messages). */
+  onMessage(handler) {
+    this._messageHandlers.push(handler);
+    return () => {
+      this._messageHandlers = this._messageHandlers.filter((h) => h !== handler);
+    };
+  }
+  destroy() {
+    this._adapterUnsub?.();
+    this._adapterUnsub = null;
+    this._messageHandlers = [];
+  }
+  _emit(payload) {
+    for (const h of this._messageHandlers) h(payload);
+  }
+};
+function _urlBase64ToUint8(base64String) {
+  const padding = "=".repeat((4 - base64String.length % 4) % 4);
+  const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(base64);
+  const out = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
+  return out;
+}
+
+// src/events/index.ts
+var JoopSubject = class {
+  _listeners = [];
+  subscribe(listener) {
+    this._listeners.push(listener);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== listener);
+    };
+  }
+  next(value) {
+    for (const listener of this._listeners) {
+      listener(value);
+    }
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopBehaviorSubject = class extends JoopSubject {
+  _value;
+  constructor(initialValue) {
+    super();
+    this._value = initialValue;
+  }
+  getValue() {
+    return this._value;
+  }
+  next(value) {
+    this._value = value;
+    super.next(value);
+  }
+  subscribe(listener) {
+    listener(this._value);
+    return super.subscribe(listener);
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopObservable = class {
+  constructor(_subscribeFn) {
+    this._subscribeFn = _subscribeFn;
+  }
+  _subscribeFn;
+  subscribe(listener) {
+    return this._subscribeFn(listener);
+  }
+  /** Returns the current value without subscribing (only meaningful for BehaviorSubject-backed observables). */
+  getOnce() {
+    let result;
+    const unsub = this.subscribe((v) => {
+      result = v;
+    });
+    unsub();
+    return result;
+  }
+};
+
+// src/device/app-lifecycle.ts
+var JoopAppLifecycle = class {
+  _state$ = new JoopBehaviorSubject("unknown");
+  _cleanup = [];
+  _adapter;
+  constructor(config = {}) {
+    this._adapter = config.adapter ?? JoopPlatform.getAdapter().lifecycle ?? null;
+    this._init();
+  }
+  _init() {
+    if (this._adapter) {
+      this._state$.next(this._adapter.getState());
+      const unsub = this._adapter.onChange((s) => this._state$.next(s));
+      this._cleanup.push(unsub);
+      return;
+    }
+    if (typeof document === "undefined") {
+      this._state$.next("unknown");
+      return;
+    }
+    this._state$.next(document.hidden ? "background" : "active");
+    const onVisibility = () => this._state$.next(document.hidden ? "background" : "active");
+    const onFocus = () => this._state$.next("active");
+    const onBlur = () => this._state$.next("background");
+    document.addEventListener("visibilitychange", onVisibility);
+    window.addEventListener("focus", onFocus);
+    window.addEventListener("blur", onBlur);
+    this._cleanup.push(
+      () => document.removeEventListener("visibilitychange", onVisibility),
+      () => window.removeEventListener("focus", onFocus),
+      () => window.removeEventListener("blur", onBlur)
+    );
+  }
+  getState() {
+    return this._state$.getValue();
+  }
+  state$() {
+    return this._state$.asObservable();
+  }
+  isActive() {
+    return this.getState() === "active";
+  }
+  /** Call fn each time the app comes to the foreground (background → active). */
+  onForeground(fn) {
+    let prev = this.getState();
+    return this._state$.subscribe((s) => {
+      if (s === "active" && prev !== "active") fn();
+      prev = s;
+    });
+  }
+  /** Call fn each time the app goes to the background (active → background). */
+  onBackground(fn) {
+    let prev = this.getState();
+    return this._state$.subscribe((s) => {
+      if (s === "background" && prev !== "background") fn();
+      prev = s;
+    });
+  }
+  destroy() {
+    for (const fn of this._cleanup) fn();
+    this._cleanup = [];
+  }
+};
+
+// src/device/network-monitor.ts
+var JoopNetworkMonitor = class {
+  _adapter;
+  _state$;
+  _cleanup = [];
+  constructor(config = {}) {
+    this._adapter = config.adapter ?? JoopPlatform.getAdapter().network ?? null;
+    this._state$ = new JoopBehaviorSubject(this._read());
+    this._init();
+  }
+  _init() {
+    if (this._adapter) {
+      this._state$.next(this._adapter.getState());
+      const unsub = this._adapter.onChange((s) => this._state$.next(s));
+      this._cleanup.push(unsub);
+      return;
+    }
+    if (typeof window === "undefined") return;
+    const refresh = () => this._state$.next(this._read());
+    window.addEventListener("online", refresh);
+    window.addEventListener("offline", refresh);
+    const conn = navigator.connection;
+    if (conn) {
+      conn.addEventListener("change", refresh);
+      this._cleanup.push(() => conn.removeEventListener("change", refresh));
+    }
+    this._cleanup.push(
+      () => window.removeEventListener("online", refresh),
+      () => window.removeEventListener("offline", refresh)
+    );
+  }
+  _read() {
+    if (this._adapter) return this._adapter.getState();
+    if (typeof navigator === "undefined") return { online: false, type: "unknown" };
+    const online = navigator.onLine;
+    if (!online) return { online: false, type: "offline" };
+    const conn = navigator.connection;
+    const type = conn ? _mapType(conn.type) : "unknown";
+    return {
+      online,
+      type,
+      effectiveType: conn?.effectiveType,
+      downlink: conn?.downlink,
+      rtt: conn?.rtt,
+      saveData: conn?.saveData,
+      metered: conn?.metered ?? type === "cellular"
+    };
+  }
+  getState() {
+    return this._state$.getValue();
+  }
+  state$() {
+    return this._state$.asObservable();
+  }
+  isOnline() {
+    return this.getState().online;
+  }
+  isMetered() {
+    return this.getState().metered ?? this.getState().type === "cellular";
+  }
+  /** Call fn when connectivity is regained. */
+  onOnline(fn) {
+    let prev = this.getState().online;
+    return this._state$.subscribe((s) => {
+      if (s.online && !prev) fn();
+      prev = s.online;
+    });
+  }
+  /** Call fn when connectivity is lost. */
+  onOffline(fn) {
+    let prev = this.getState().online;
+    return this._state$.subscribe((s) => {
+      if (!s.online && prev) fn();
+      prev = s.online;
+    });
+  }
+  /** Call fn when the connection type changes (e.g. wifi → cellular). */
+  onTypeChange(fn) {
+    let prev = this.getState().type;
+    return this._state$.subscribe((s) => {
+      if (s.type !== prev) {
+        fn(s.type);
+        prev = s.type;
+      }
+    });
+  }
+  destroy() {
+    for (const fn of this._cleanup) fn();
+    this._cleanup = [];
+  }
+};
+function _mapType(raw) {
+  if (!raw) return "unknown";
+  if (raw === "wifi" || raw === "wimax") return "wifi";
+  if (raw === "cellular" || raw === "2g" || raw === "3g" || raw === "4g" || raw === "5g") return "cellular";
+  if (raw === "ethernet") return "ethernet";
+  if (raw === "none" || raw === "offline") return "offline";
+  return "unknown";
+}
+var EXPIRY_RE = /\b(0[1-9]|1[0-2])\s*[\/\-]\s*(\d{2}|\d{4})\b/g;
+var HOLDER_RE = /\b([A-Z]{2,}\s+[A-Z]{2,}(?:\s+[A-Z]{2,})?)\b/g;
+function parseCardText(text) {
+  const result = {};
+  const numMatch = text.replace(/\s/g, "").match(/\d{13,19}/);
+  if (numMatch) result.number = numMatch[0];
+  const expMatch = EXPIRY_RE.exec(text);
+  if (expMatch) result.expiry = expMatch[1] + "/" + expMatch[2].slice(-2);
+  const holderMatch = HOLDER_RE.exec(text.toUpperCase());
+  if (holderMatch) result.holder = holderMatch[0];
+  if (result.number) {
+    const n = result.number[0];
+    if (n === "4") result.network = "Visa";
+    else if (n === "5") result.network = "Mastercard";
+    else if (n === "3") result.network = result.number[1] === "4" || result.number[1] === "7" ? "Amex" : "Diners";
+    else if (n === "6") result.network = "Discover";
+  }
+  return result;
+}
+var JoopCardScanner = class {
+  _stream = null;
+  _video = null;
+  _canvas = null;
+  _ctx = null;
+  _frameInterval = null;
+  _frameCount = 0;
+  _onResult = null;
+  _onError = null;
+  _config;
+  constructor(config = {}) {
+    this._config = {
+      frameRate: config.frameRate ?? 5,
+      maxFrames: config.maxFrames ?? 30,
+      facingMode: config.facingMode ?? "environment"
+    };
+  }
+  async start(container) {
+    if (!navigator.mediaDevices?.getUserMedia) {
+      throw new Error("Camera not available");
+    }
+    this._stream = await navigator.mediaDevices.getUserMedia({
+      video: { facingMode: this._config.facingMode, width: { ideal: 1280 }, height: { ideal: 720 } }
+    });
+    this._video = document.createElement("video");
+    this._video.srcObject = this._stream;
+    this._video.setAttribute("playsinline", "true");
+    this._video.setAttribute("autoplay", "true");
+    this._video.muted = true;
+    if (container) {
+      Object.assign(this._video.style, { width: "100%", height: "100%", objectFit: "cover" });
+      container.appendChild(this._video);
+    }
+    await new Promise((resolve) => {
+      this._video.onloadedmetadata = () => {
+        this._video.play();
+        resolve();
+      };
+    });
+    this._canvas = document.createElement("canvas");
+    this._ctx = this._canvas.getContext("2d");
+    this._startCapture();
+  }
+  stop() {
+    if (this._frameInterval) {
+      clearInterval(this._frameInterval);
+      this._frameInterval = null;
+    }
+    if (this._stream) {
+      this._stream.getTracks().forEach((t) => t.stop());
+      this._stream = null;
+    }
+    if (this._video) {
+      this._video.remove();
+      this._video = null;
+    }
+  }
+  onResult(fn) {
+    this._onResult = fn;
+    return this;
+  }
+  onError(fn) {
+    this._onError = fn;
+    return this;
+  }
+  static fillCard(form, result) {
+    if (result.number && form.number) form.number.value = result.number;
+    if (result.expiry && form.expiry) form.expiry.value = result.expiry;
+    if (result.holder && form.holder) form.holder.value = result.holder;
+  }
+  _startCapture() {
+    const interval = Math.round(1e3 / this._config.frameRate);
+    this._frameInterval = setInterval(() => {
+      if (!this._video || !this._canvas || !this._ctx) return;
+      if (this._frameCount >= this._config.maxFrames) {
+        this.stop();
+        return;
+      }
+      this._frameCount++;
+      this._canvas.width = this._video.videoWidth;
+      this._canvas.height = this._video.videoHeight;
+      this._ctx.drawImage(this._video, 0, 0);
+      this._processFrame();
+    }, interval);
+  }
+  _processFrame() {
+    if (!this._canvas) return;
+    try {
+      const dataUrl = this._canvas.toDataURL("image/jpeg", 0.7);
+      const simulatedText = this._extractTextFromDataUrl(dataUrl);
+      if (simulatedText) {
+        const result = parseCardText(simulatedText);
+        if (result.number) {
+          this.stop();
+          this._onResult?.(result);
+        }
+      }
+    } catch (err) {
+      this._onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  _extractTextFromDataUrl(_dataUrl) {
+    return "";
+  }
+};
+
+// src/device/client-info.service.ts
+function _parseBrowser(ua) {
+  if (/Edg\//.test(ua)) return { name: "Edge", version: ua.match(/Edg\/([\d.]+)/)?.[1] ?? "", engine: "Blink" };
+  if (/OPR\//.test(ua)) return { name: "Opera", version: ua.match(/OPR\/([\d.]+)/)?.[1] ?? "", engine: "Blink" };
+  if (/Chrome\//.test(ua)) return { name: "Chrome", version: ua.match(/Chrome\/([\d.]+)/)?.[1] ?? "", engine: "Blink" };
+  if (/Firefox\//.test(ua)) return { name: "Firefox", version: ua.match(/Firefox\/([\d.]+)/)?.[1] ?? "", engine: "Gecko" };
+  if (/Safari\//.test(ua) && !/Chrome/.test(ua))
+    return { name: "Safari", version: ua.match(/Version\/([\d.]+)/)?.[1] ?? "", engine: "WebKit" };
+  if (/MSIE|Trident/.test(ua)) return { name: "IE", version: ua.match(/(?:MSIE |rv:)([\d.]+)/)?.[1] ?? "", engine: "Trident" };
+  return { name: "Unknown", version: "", engine: "Unknown" };
+}
+function _parseOs(ua) {
+  if (/Windows NT 10/.test(ua)) return { name: "Windows", version: "10/11", arch: ua.includes("x64") ? "x64" : "x86" };
+  if (/Windows NT 6\.3/.test(ua)) return { name: "Windows", version: "8.1", arch: "x86" };
+  if (/Windows NT 6\.1/.test(ua)) return { name: "Windows", version: "7", arch: "x86" };
+  if (/Mac OS X ([\d_]+)/.test(ua)) return { name: "macOS", version: (ua.match(/Mac OS X ([\d_]+)/)?.[1] ?? "").replace(/_/g, "."), arch: "x64" };
+  if (/Android ([\d.]+)/.test(ua)) return { name: "Android", version: ua.match(/Android ([\d.]+)/)?.[1] ?? "", arch: "arm" };
+  if (/iPhone OS ([\d_]+)/.test(ua)) return { name: "iOS", version: (ua.match(/iPhone OS ([\d_]+)/)?.[1] ?? "").replace(/_/g, "."), arch: "arm" };
+  if (/iPad.*OS ([\d_]+)/.test(ua)) return { name: "iPadOS", version: (ua.match(/OS ([\d_]+)/)?.[1] ?? "").replace(/_/g, "."), arch: "arm" };
+  if (/Linux/.test(ua)) return { name: "Linux", version: "", arch: ua.includes("x86_64") ? "x64" : "x86" };
+  return { name: "Unknown", version: "", arch: "Unknown" };
+}
+function _detectDevice(ua) {
+  if (/tablet|ipad|playbook|silk/i.test(ua)) return "tablet";
+  if (/mobile|android|iphone|ipod|blackberry|windows phone/i.test(ua)) return "mobile";
+  return "desktop";
+}
+function _getNetwork() {
+  const conn = navigator.connection ?? navigator.mozConnection ?? navigator.webkitConnection;
+  return {
+    online: navigator.onLine,
+    type: conn?.type ?? "unknown",
+    effectiveType: conn?.effectiveType ?? "unknown",
+    downlink: conn?.downlink ?? null
+  };
+}
+var JoopClientInfoService = class {
+  _config;
+  constructor(config = {}) {
+    this._config = {
+      includeLocation: config.includeLocation ?? false,
+      ipApiUrl: config.ipApiUrl ?? "https://api.ipify.org?format=json",
+      timeout: config.timeout ?? 5e3
+    };
+  }
+  async collect() {
+    const ua = navigator.userAgent;
+    const [ip, location2] = await Promise.all([
+      this._fetchIp(),
+      this._config.includeLocation ? this._fetchLocation() : Promise.resolve(null)
+    ]);
+    return {
+      ip,
+      userAgent: ua,
+      browser: _parseBrowser(ua),
+      os: _parseOs(ua),
+      device: _detectDevice(ua),
+      screen: {
+        width: screen.width,
+        height: screen.height,
+        colorDepth: screen.colorDepth,
+        pixelRatio: devicePixelRatio
+      },
+      network: _getNetwork(),
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      locale: navigator.language,
+      location: location2,
+      timestamp: Date.now()
+    };
+  }
+  /** Collect and return as a flat record safe for HTTP headers or analytics events */
+  async collectFlat() {
+    const info = await this.collect();
+    return {
+      ip: info.ip,
+      userAgent: info.userAgent,
+      browser: `${info.browser.name} ${info.browser.version}`,
+      browserEngine: info.browser.engine,
+      os: `${info.os.name} ${info.os.version}`,
+      osArch: info.os.arch,
+      device: info.device,
+      screenWidth: info.screen.width,
+      screenHeight: info.screen.height,
+      pixelRatio: info.screen.pixelRatio,
+      online: info.network.online,
+      networkType: info.network.type,
+      effectiveType: info.network.effectiveType,
+      timezone: info.timezone,
+      locale: info.locale,
+      lat: info.location?.latitude ?? null,
+      lng: info.location?.longitude ?? null,
+      timestamp: info.timestamp
+    };
+  }
+  async _fetchIp() {
+    try {
+      const controller = new AbortController();
+      const tid = setTimeout(() => controller.abort(), this._config.timeout);
+      const res = await fetch(this._config.ipApiUrl, { signal: controller.signal });
+      clearTimeout(tid);
+      const data = await res.json();
+      return data.ip ?? data.query ?? null;
+    } catch {
+      return null;
+    }
+  }
+  _fetchLocation() {
+    return new Promise((resolve) => {
+      if (!navigator.geolocation) {
+        resolve(null);
+        return;
+      }
+      navigator.geolocation.getCurrentPosition(
+        (pos) => resolve({ latitude: pos.coords.latitude, longitude: pos.coords.longitude, accuracy: pos.coords.accuracy }),
+        () => resolve(null),
+        { timeout: this._config.timeout, maximumAge: 6e4 }
+      );
+    });
+  }
+};
+
+exports.JoopAppLifecycle = JoopAppLifecycle;
+exports.JoopBiometricAuth = JoopBiometricAuth;
+exports.JoopCardScanner = JoopCardScanner;
+exports.JoopClientInfoService = JoopClientInfoService;
+exports.JoopDeviceFingerprintService = JoopDeviceFingerprintService;
+exports.JoopKeyVault = JoopKeyVault;
+exports.JoopNetworkMonitor = JoopNetworkMonitor;
+exports.JoopPushService = JoopPushService;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map