joopjs 2.0.0

package/dist/security/index.js

@@ -0,0 +1,1297 @@
+'use strict';
+
+// src/security/secure-storage.ts
+var MemoryBackend = class {
+  store = /* @__PURE__ */ new Map();
+  getItem(key) {
+    return this.store.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.store.set(key, value);
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+  key(index) {
+    return Array.from(this.store.keys())[index] ?? null;
+  }
+  get length() {
+    return this.store.size;
+  }
+};
+function deviceFingerprint() {
+  if (typeof window === "undefined") return "server-side";
+  return [
+    navigator.userAgent,
+    String(screen.width),
+    String(screen.height),
+    String(screen.colorDepth),
+    Intl.DateTimeFormat().resolvedOptions().timeZone,
+    navigator.language
+  ].join("|");
+}
+async function deriveKey(fingerprint, salt) {
+  const enc = new TextEncoder();
+  const keyMat = await crypto.subtle.importKey("raw", enc.encode(fingerprint), "PBKDF2", false, ["deriveKey"]);
+  return crypto.subtle.deriveKey(
+    { name: "PBKDF2", salt: enc.encode(salt), iterations: 1e5, hash: "SHA-256" },
+    keyMat,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function encryptValue(key, plaintext) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encoded = new TextEncoder().encode(plaintext);
+  const ciphertext = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, encoded);
+  const combined = new Uint8Array(12 + ciphertext.byteLength);
+  combined.set(iv);
+  combined.set(new Uint8Array(ciphertext), 12);
+  return btoa(String.fromCharCode(...combined));
+}
+async function decryptValue(key, data) {
+  const combined = Uint8Array.from(atob(data), (c) => c.charCodeAt(0));
+  const iv = combined.slice(0, 12);
+  const ciphertext = combined.slice(12);
+  const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+  return new TextDecoder().decode(decrypted);
+}
+var JoopSecureStorage = class {
+  ns;
+  salt;
+  backend;
+  _key;
+  constructor(config = {}) {
+    this.ns = config.namespace ?? "joop";
+    this.salt = config.salt ?? (typeof location !== "undefined" ? location.hostname : "joopjs") + ":" + this.ns;
+    const b = config.backend ?? "localStorage";
+    if (b === "memory" || typeof window === "undefined") {
+      this.backend = new MemoryBackend();
+    } else if (b === "sessionStorage") {
+      this.backend = sessionStorage;
+    } else {
+      this.backend = localStorage;
+    }
+  }
+  async cryptoKey() {
+    if (!this._key) this._key = await deriveKey(deviceFingerprint(), this.salt);
+    return this._key;
+  }
+  storageKey(key) {
+    return `${this.ns}:${key}`;
+  }
+  async setItem(key, value) {
+    const encrypted = await encryptValue(await this.cryptoKey(), JSON.stringify(value));
+    this.backend.setItem(this.storageKey(key), encrypted);
+  }
+  async getItem(key) {
+    const raw = this.backend.getItem(this.storageKey(key));
+    if (raw === null) return null;
+    try {
+      const decrypted = await decryptValue(await this.cryptoKey(), raw);
+      return JSON.parse(decrypted);
+    } catch {
+      return null;
+    }
+  }
+  async removeItem(key) {
+    this.backend.removeItem(this.storageKey(key));
+  }
+  async has(key) {
+    return this.backend.getItem(this.storageKey(key)) !== null;
+  }
+  async keys() {
+    const prefix = `${this.ns}:`;
+    const result = [];
+    for (let i = 0; i < this.backend.length; i++) {
+      const k = this.backend.key(i);
+      if (k?.startsWith(prefix)) result.push(k.slice(prefix.length));
+    }
+    return result;
+  }
+  async clear() {
+    const ks = await this.keys();
+    ks.forEach((k) => this.backend.removeItem(this.storageKey(k)));
+  }
+  async setItems(entries) {
+    await Promise.all(Object.entries(entries).map(([k, v]) => this.setItem(k, v)));
+  }
+  async getAll() {
+    const ks = await this.keys();
+    const pairs = await Promise.all(ks.map(async (k) => [k, await this.getItem(k)]));
+    return Object.fromEntries(pairs);
+  }
+};
+
+// 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/security/behavioral-biometrics.ts
+var JoopBehavioralBiometrics = class {
+  _running = false;
+  _profile$ = new JoopBehaviorSubject(null);
+  _anomaly$ = new JoopSubject();
+  _listeners = [];
+  // Raw samples
+  _keyIntervals = [];
+  _dwellTimes = [];
+  _mouseSpeeds = [];
+  _mouseAccels = [];
+  _scrollVelocities = [];
+  _pressures = [];
+  // State
+  _lastKeyDown = 0;
+  _lastKeyDownMap = /* @__PURE__ */ new Map();
+  _lastMouse = { x: 0, y: 0, t: 0, speed: 0 };
+  _lastScroll = { y: 0, t: 0 };
+  _baseline = null;
+  start() {
+    if (this._running) return;
+    this._running = true;
+    this._attach("keydown", this._onKeyDown.bind(this));
+    this._attach("keyup", this._onKeyUp.bind(this));
+    this._attach("mousemove", this._onMouseMove.bind(this));
+    this._attach("scroll", this._onScroll.bind(this), { passive: true });
+    this._attach("touchstart", this._onTouch.bind(this), { passive: true });
+  }
+  stop() {
+    this._running = false;
+    for (const remove of this._listeners) remove();
+    this._listeners = [];
+  }
+  reset() {
+    this._keyIntervals = [];
+    this._dwellTimes = [];
+    this._mouseSpeeds = [];
+    this._mouseAccels = [];
+    this._scrollVelocities = [];
+    this._pressures = [];
+    this._baseline = null;
+    this._profile$.next(null);
+  }
+  setBaseline(profile) {
+    this._baseline = profile ?? this._profile$.getValue();
+  }
+  getScore() {
+    const p = this._profile$.getValue();
+    if (!p || p.sampleCount < 20) return { human: 0.5, bot: 0.5, confidence: 0 };
+    let humanScore = 0;
+    let checks = 0;
+    if (p.sampleCount >= 5) {
+      const cv = _cv(this._keyIntervals);
+      humanScore += cv > 0.15 ? 1 : cv > 0.05 ? 0.5 : 0;
+      checks++;
+    }
+    if (this._mouseSpeeds.length >= 10) {
+      const cv = _cv(this._mouseSpeeds);
+      humanScore += cv > 0.2 ? 1 : cv > 0.08 ? 0.5 : 0;
+      checks++;
+    }
+    if (this._scrollVelocities.length >= 5) {
+      const cv = _cv(this._scrollVelocities);
+      humanScore += cv > 0.1 ? 1 : 0.3;
+      checks++;
+    }
+    const confidence = Math.min(1, p.sampleCount / 100);
+    const human = checks ? humanScore / checks : 0.5;
+    return { human, bot: 1 - human, confidence };
+  }
+  getProfile() {
+    return this._profile$.getValue();
+  }
+  profile$() {
+    return this._profile$.asObservable();
+  }
+  anomaly$() {
+    return this._anomaly$.asObservable();
+  }
+  /** Similarity to another profile (0=different, 1=identical) */
+  compare(other) {
+    const p = this._profile$.getValue();
+    if (!p) return 0;
+    const delta = (a, b) => 1 - Math.min(1, Math.abs(a - b) / (Math.max(a, b) || 1));
+    return (delta(p.avgTypingInterval, other.avgTypingInterval) + delta(p.mouseSpeed, other.mouseSpeed) + delta(p.scrollVelocity, other.scrollVelocity)) / 3;
+  }
+  _onKeyDown(e) {
+    const now = Date.now();
+    if (this._lastKeyDown > 0) this._keyIntervals.push(now - this._lastKeyDown);
+    this._lastKeyDownMap.set(e.key, now);
+    this._lastKeyDown = now;
+    this._update();
+  }
+  _onKeyUp(e) {
+    const down = this._lastKeyDownMap.get(e.key);
+    if (down) {
+      this._dwellTimes.push(Date.now() - down);
+      this._lastKeyDownMap.delete(e.key);
+    }
+    this._update();
+  }
+  _onMouseMove(e) {
+    const now = Date.now();
+    const { x: lx, y: ly, t: lt, speed: ls } = this._lastMouse;
+    if (lt > 0) {
+      const dx = e.clientX - lx, dy = e.clientY - ly, dt = now - lt;
+      if (dt > 0) {
+        const speed = Math.sqrt(dx * dx + dy * dy) / dt;
+        const accel = Math.abs(speed - ls) / dt;
+        this._mouseSpeeds.push(speed);
+        this._mouseAccels.push(accel);
+        this._lastMouse = { x: e.clientX, y: e.clientY, t: now, speed };
+        this._update();
+        return;
+      }
+    }
+    this._lastMouse = { x: e.clientX, y: e.clientY, t: now, speed: 0 };
+  }
+  _onScroll() {
+    const now = Date.now();
+    const y = window.scrollY;
+    const { y: ly, t: lt } = this._lastScroll;
+    if (lt > 0 && now - lt > 0) {
+      this._scrollVelocities.push(Math.abs(y - ly) / (now - lt));
+      this._update();
+    }
+    this._lastScroll = { y, t: now };
+  }
+  _onTouch(e) {
+    if (e.touches[0] && e.touches[0].force !== void 0) {
+      const f = e.touches[0].force;
+      this._pressures.push(f);
+    }
+    this._update();
+  }
+  _update() {
+    const count = this._keyIntervals.length + this._mouseSpeeds.length;
+    const profile = {
+      avgTypingInterval: _mean(this._keyIntervals),
+      avgDwellTime: _mean(this._dwellTimes),
+      mouseSpeed: _mean(this._mouseSpeeds),
+      mouseAcceleration: _mean(this._mouseAccels),
+      scrollVelocity: _mean(this._scrollVelocities),
+      touchPressureAvg: _mean(this._pressures),
+      sampleCount: count,
+      capturedAt: Date.now()
+    };
+    this._profile$.next(profile);
+    if (this._baseline && count >= 30) {
+      const { avgTypingInterval: bt } = this._baseline;
+      const devs = _stddev(this._keyIntervals.slice(-20));
+      if (bt > 0 && devs > 0) {
+        const z = Math.abs(profile.avgTypingInterval - bt) / devs;
+        if (z > 2.5) this._anomaly$.next({ type: "typing", deviation: z, value: profile.avgTypingInterval, baseline: bt });
+      }
+    }
+  }
+  _attach(event, handler, opts) {
+    document.addEventListener(event, handler, opts);
+    this._listeners.push(() => document.removeEventListener(event, handler));
+  }
+};
+function _mean(arr) {
+  return arr.length ? arr.reduce((a, b) => a + b, 0) / arr.length : 0;
+}
+function _stddev(arr) {
+  if (arr.length < 2) return 0;
+  const m = _mean(arr);
+  return Math.sqrt(arr.reduce((s, v) => s + (v - m) ** 2, 0) / (arr.length - 1));
+}
+function _cv(arr) {
+  const m = _mean(arr);
+  return m ? _stddev(arr) / m : 0;
+}
+
+// src/security/risk-engine.ts
+var BUILT_IN_FACTORS = [
+  {
+    name: "failed_attempts",
+    weight: 0.25,
+    evaluate: (ctx) => Math.min(1, (ctx.failedAttempts ?? 0) / 5)
+  },
+  {
+    name: "biometrics",
+    weight: 0.2,
+    evaluate: (ctx) => {
+      if (ctx.biometricScore === void 0) return 0.3;
+      return 1 - ctx.biometricScore;
+    }
+  },
+  {
+    name: "mfa",
+    weight: 0.15,
+    evaluate: (ctx) => ctx.mfaVerified ? 0 : 0.5
+  },
+  {
+    name: "known_device",
+    weight: 0.15,
+    evaluate: (ctx) => ctx.knownDevice === false ? 0.7 : 0
+  },
+  {
+    name: "vpn",
+    weight: 0.1,
+    evaluate: (ctx) => ctx.vpnDetected ? 0.6 : 0
+  },
+  {
+    name: "time_anomaly",
+    weight: 0.1,
+    evaluate: (ctx) => {
+      const h = ctx.hourOfDay ?? 12;
+      return h >= 1 && h <= 5 ? 0.4 : 0;
+    }
+  },
+  {
+    name: "transaction_amount",
+    weight: 0.05,
+    evaluate: (ctx) => {
+      const amt = ctx.transactionAmount ?? 0;
+      if (amt > 1e5) return 0.9;
+      if (amt > 1e4) return 0.5;
+      if (amt > 1e3) return 0.2;
+      return 0;
+    }
+  }
+];
+var JoopRiskEngine = class {
+  _factors = [...BUILT_IN_FACTORS];
+  _score$ = new JoopBehaviorSubject(null);
+  _highRiskHandlers = [];
+  _stepUpHandler = null;
+  _stepUpThreshold = 70;
+  /** Replace all factors */
+  configure(factors) {
+    this._factors = factors;
+  }
+  /** Add or update a single named factor */
+  addFactor(name, weight, evaluate) {
+    const idx = this._factors.findIndex((f) => f.name === name);
+    if (idx >= 0) this._factors[idx] = { name, weight, evaluate };
+    else this._factors.push({ name, weight, evaluate });
+  }
+  removeFactor(name) {
+    this._factors = this._factors.filter((f) => f.name !== name);
+  }
+  evaluate(ctx) {
+    const totalWeight = this._factors.reduce((s, f) => s + f.weight, 0) || 1;
+    const factors = {};
+    let weighted = 0;
+    for (const f of this._factors) {
+      const raw = Math.max(0, Math.min(1, f.evaluate(ctx)));
+      factors[f.name] = raw;
+      weighted += raw * (f.weight / totalWeight);
+    }
+    const total = Math.round(weighted * 100);
+    const level = total >= 75 ? "critical" : total >= 50 ? "high" : total >= 25 ? "medium" : "low";
+    const score = { total, level, factors, context: ctx, timestamp: Date.now() };
+    this._score$.next(score);
+    for (const { threshold, handler } of this._highRiskHandlers) {
+      if (total >= threshold) handler(score);
+    }
+    if (this._stepUpHandler && total >= this._stepUpThreshold) this._stepUpHandler(score);
+    return score;
+  }
+  score$() {
+    return this._score$.asObservable();
+  }
+  lastScore() {
+    return this._score$.getValue();
+  }
+  /** Register a handler triggered when score ≥ threshold */
+  onHighRisk(threshold, handler) {
+    const entry = { threshold, handler };
+    this._highRiskHandlers.push(entry);
+    return () => {
+      this._highRiskHandlers = this._highRiskHandlers.filter((h) => h !== entry);
+    };
+  }
+  /** Configure automatic step-up auth trigger */
+  onStepUpRequired(threshold, handler) {
+    this._stepUpThreshold = threshold;
+    this._stepUpHandler = handler;
+  }
+};
+
+// src/security/pii-scanner.ts
+var BUILT_IN_PATTERNS = [
+  { name: "credit_card", regex: /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})\b/g },
+  { name: "ssn", regex: /\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/g },
+  { name: "email", regex: /\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b/g },
+  { name: "phone_us", regex: /(?:\+1[\s-]?)?(?:\(\d{3}\)|\d{3})[-.\s]?\d{3}[-.\s]?\d{4}\b/g },
+  { name: "iban", regex: /\b[A-Z]{2}\d{2}[A-Z0-9]{4}\d{7}(?:[A-Z0-9]{0,16})?\b/g },
+  { name: "passport", regex: /\b[A-Z]{1,2}[0-9]{6,9}\b/g },
+  { name: "ip_address", regex: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g },
+  { name: "jwt", regex: /eyJ[A-Za-z0-9_\-]+\.eyJ[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+/g },
+  { name: "api_key", regex: /\b(?:sk|pk|api|key)[_\-]?[a-zA-Z0-9]{20,}\b/gi }
+];
+var DEFAULT_REPLACER = {
+  credit_card: "[CARD-REDACTED]",
+  ssn: "[SSN-REDACTED]",
+  email: "[EMAIL-REDACTED]",
+  phone_us: "[PHONE-REDACTED]",
+  iban: "[IBAN-REDACTED]",
+  passport: "[PASSPORT-REDACTED]",
+  ip_address: "[IP-REDACTED]",
+  jwt: "[JWT-REDACTED]",
+  api_key: "[KEY-REDACTED]"
+};
+var JoopPIIScanner = class {
+  _patterns = [...BUILT_IN_PATTERNS];
+  /** Add or replace a custom pattern */
+  addPattern(name, regex) {
+    const idx = this._patterns.findIndex((p) => p.name === name);
+    if (idx >= 0) this._patterns[idx] = { name, regex };
+    else this._patterns.push({ name, regex });
+  }
+  removePattern(name) {
+    this._patterns = this._patterns.filter((p) => p.name !== name);
+  }
+  /** Return all PII findings in text */
+  scan(text) {
+    const findings = [];
+    for (const { name, regex } of this._patterns) {
+      const r = new RegExp(regex.source, regex.flags.includes("g") ? regex.flags : regex.flags + "g");
+      r.lastIndex = 0;
+      let m;
+      while ((m = r.exec(text)) !== null) {
+        findings.push({ type: name, value: m[0], start: m.index, end: m.index + m[0].length });
+      }
+    }
+    return findings.sort((a, b) => a.start - b.start);
+  }
+  /** Replace all PII in text. Replacement can be a string or function(type) */
+  redact(text, replacement) {
+    const findings = this.scan(text);
+    if (findings.length === 0) return text;
+    let result = text;
+    for (const f of [...findings].reverse()) {
+      const repl = replacement ? typeof replacement === "string" ? replacement : replacement(f.type) : DEFAULT_REPLACER[f.type] ?? `[${f.type.toUpperCase()}-REDACTED]`;
+      result = result.slice(0, f.start) + repl + result.slice(f.end);
+    }
+    return result;
+  }
+  /** Returns true if the text contains any PII */
+  contains(text) {
+    return this.scan(text).length > 0;
+  }
+  /** Hash PII values (SHA-256 truncated) — returns text with hashed placeholders */
+  async pseudonymize(text) {
+    const findings = this.scan(text);
+    if (findings.length === 0) return text;
+    const cache = /* @__PURE__ */ new Map();
+    const hash = async (val) => {
+      if (cache.has(val)) return cache.get(val);
+      const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(val));
+      const h = Array.from(new Uint8Array(buf)).slice(0, 8).map((b) => b.toString(16).padStart(2, "0")).join("");
+      cache.set(val, h);
+      return h;
+    };
+    let result = text;
+    for (const f of [...findings].reverse()) {
+      const h = await hash(f.value);
+      result = result.slice(0, f.start) + `[${f.type}:${h}]` + result.slice(f.end);
+    }
+    return result;
+  }
+};
+
+// src/security/secret-sharing.ts
+var PRIME = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
+var JoopSecretSharing = class {
+  /**
+   * Split a secret string into `n` shares, requiring `k` shares to reconstruct.
+   * Uses Shamir's Secret Sharing over GF(PRIME).
+   */
+  split(secret, n, k) {
+    if (k > n) throw new Error("k must be \u2264 n");
+    if (k < 2) throw new Error("k must be at least 2");
+    const secretBytes = new TextEncoder().encode(secret);
+    const secretBig = _bytesToBigInt(secretBytes);
+    if (secretBig >= PRIME) throw new Error("Secret too large for this field");
+    const coefficients = [secretBig];
+    for (let i = 1; i < k; i++) {
+      coefficients.push(_randomBigInt(PRIME));
+    }
+    const shares = [];
+    for (let x = 1; x <= n; x++) {
+      let y = BigInt(0);
+      const xBig = BigInt(x);
+      for (let i = 0; i < coefficients.length; i++) {
+        y = _modAdd(y, _modMul(coefficients[i], _modPow(xBig, BigInt(i), PRIME), PRIME), PRIME);
+      }
+      shares.push({ x, y });
+    }
+    return shares;
+  }
+  /**
+   * Reconstruct the secret from k or more shares using Lagrange interpolation.
+   */
+  combine(shares) {
+    if (shares.length < 2) throw new Error("At least 2 shares required");
+    let secret = BigInt(0);
+    for (let i = 0; i < shares.length; i++) {
+      const xi = BigInt(shares[i].x);
+      let num = BigInt(1);
+      let den = BigInt(1);
+      for (let j = 0; j < shares.length; j++) {
+        if (i === j) continue;
+        const xj = BigInt(shares[j].x);
+        num = _modMul(num, _modSub(BigInt(0), xj, PRIME), PRIME);
+        den = _modMul(den, _modSub(xi, xj, PRIME), PRIME);
+      }
+      const lagrange = _modMul(num, _modPow(den, PRIME - BigInt(2), PRIME), PRIME);
+      secret = _modAdd(secret, _modMul(shares[i].y, lagrange, PRIME), PRIME);
+    }
+    const bytes = _bigIntToBytes(secret);
+    return new TextDecoder().decode(bytes);
+  }
+  /** Verify that a set of shares produces a consistent secret */
+  verify(sharesA, sharesB) {
+    try {
+      return this.combine(sharesA) === this.combine(sharesB);
+    } catch {
+      return false;
+    }
+  }
+  /** Serialize shares to base64 strings for transport */
+  serializeShare(share) {
+    return btoa(JSON.stringify({ x: share.x, y: share.y.toString(16) }));
+  }
+  /** Deserialize a base64 share */
+  deserializeShare(encoded) {
+    const { x, y } = JSON.parse(atob(encoded));
+    return { x, y: BigInt(`0x${y}`) };
+  }
+};
+function _modAdd(a, b, p) {
+  return ((a + b) % p + p) % p;
+}
+function _modSub(a, b, p) {
+  return ((a - b) % p + p) % p;
+}
+function _modMul(a, b, p) {
+  return a * b % p;
+}
+function _modPow(base, exp, mod) {
+  let result = BigInt(1);
+  base = base % mod;
+  while (exp > 0n) {
+    if (exp % 2n === 1n) result = _modMul(result, base, mod);
+    exp >>= 1n;
+    base = _modMul(base, base, mod);
+  }
+  return result;
+}
+function _bytesToBigInt(bytes) {
+  let result = 0n;
+  for (const byte of bytes) result = result << 8n | BigInt(byte);
+  return result;
+}
+function _bigIntToBytes(n) {
+  if (n === 0n) return new Uint8Array([0]);
+  const hex = n.toString(16).padStart(2, "0");
+  const padded = hex.length % 2 ? "0" + hex : hex;
+  const bytes = new Uint8Array(padded.length / 2);
+  for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(padded.slice(i * 2, i * 2 + 2), 16);
+  return bytes;
+}
+function _randomBigInt(max) {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return _bytesToBigInt(bytes) % max;
+}
+
+// src/security/differential-privacy.ts
+var JoopDifferentialPrivacy = class {
+  /**
+   * Add Laplace noise to a numeric value.
+   * @param value  - the true value
+   * @param sensitivity - L1 sensitivity (max change in output from one record change)
+   * @param epsilon - privacy budget (smaller = more privacy)
+   */
+  addLaplaceNoise(value, sensitivity, epsilon) {
+    const b = sensitivity / epsilon;
+    return value + _sampleLaplace(b);
+  }
+  /**
+   * Privatize a count (integer ≥ 0).
+   * Returns a rounded, non-negative noisy count.
+   */
+  privatizeCount(count, epsilon = 1) {
+    const noisy = this.addLaplaceNoise(count, 1, epsilon);
+    return Math.max(0, Math.round(noisy));
+  }
+  /**
+   * Privatize an average over an array of values.
+   * @param values    - the actual values
+   * @param epsilon   - privacy budget
+   * @param valueRange - [min, max] of each value (for sensitivity calculation)
+   */
+  privatizeAverage(values, epsilon = 1, valueRange = [0, 1]) {
+    if (values.length === 0) return 0;
+    const sensitivity = (valueRange[1] - valueRange[0]) / values.length;
+    const trueAvg = values.reduce((s, v) => s + v, 0) / values.length;
+    return this.addLaplaceNoise(trueAvg, sensitivity, epsilon);
+  }
+  /**
+   * Privatize a sum.
+   */
+  privatizeSum(values, epsilon = 1, sensitivity = 1) {
+    const trueSum = values.reduce((s, v) => s + v, 0);
+    return this.addLaplaceNoise(trueSum, sensitivity, epsilon);
+  }
+  /**
+   * Randomized response for boolean values (local differential privacy).
+   * Each individual flips their true value with probability p = 1/(1+e^epsilon).
+   * @returns a potentially flipped boolean
+   */
+  randomizedResponse(value, epsilon = 1) {
+    const p = 1 / (1 + Math.exp(epsilon));
+    return Math.random() < p ? !value : value;
+  }
+  /**
+   * Randomized response for categorical values (k-ary randomized response).
+   * Returns the true value with probability p, and a random other value with 1-p.
+   */
+  randomizedResponseCategorical(value, domain, epsilon = 1) {
+    const k = domain.length;
+    if (k < 2) return value;
+    const p = Math.exp(epsilon) / (Math.exp(epsilon) + k - 1);
+    if (Math.random() < p) return value;
+    const others = domain.filter((v) => v !== value);
+    return others[Math.floor(Math.random() * others.length)];
+  }
+  /**
+   * Gaussian mechanism: add N(0, sigma^2) noise where sigma = sqrt(2*ln(1.25/delta)) * sensitivity / epsilon
+   * Provides (epsilon, delta)-DP.
+   */
+  addGaussianNoise(value, sensitivity, epsilon, delta = 1e-5) {
+    const sigma = Math.sqrt(2 * Math.log(1.25 / delta)) * sensitivity / epsilon;
+    return value + _sampleGaussian(sigma);
+  }
+  /**
+   * Compute the epsilon required to achieve (epsilon)-DP for Laplace mechanism.
+   */
+  requiredEpsilon(sensitivity, targetNoise) {
+    return sensitivity / targetNoise;
+  }
+  /**
+   * Privacy amplification: effective epsilon after subsampling fraction q of the data.
+   */
+  amplifiedEpsilon(epsilon, samplingRate) {
+    return Math.log(1 + samplingRate * (Math.exp(epsilon) - 1));
+  }
+};
+function _sampleLaplace(b) {
+  const u = Math.random() - 0.5;
+  return -b * Math.sign(u) * Math.log(1 - 2 * Math.abs(u));
+}
+function _sampleGaussian(sigma) {
+  const u1 = 1 - Math.random();
+  const u2 = Math.random();
+  return sigma * Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+
+// src/security/screen-security.ts
+var JoopScreenSecurityService = class {
+  _config;
+  _listeners = /* @__PURE__ */ new Map();
+  _active = false;
+  _devtoolsTimer = null;
+  // Elements registered as sensitive
+  _sensitiveElements = /* @__PURE__ */ new Set();
+  _blurOverlay = null;
+  constructor(config = {}) {
+    this._config = {
+      blurOnTabSwitch: config.blurOnTabSwitch ?? true,
+      clipboardProtection: config.clipboardProtection ?? false,
+      devtoolsDetection: config.devtoolsDetection ?? false,
+      screenshotWarning: config.screenshotWarning ?? false
+    };
+  }
+  activate() {
+    if (this._active) return;
+    this._active = true;
+    if (this._config.blurOnTabSwitch) {
+      document.addEventListener("visibilitychange", this._onVisibilityChange);
+    }
+    if (this._config.screenshotWarning) {
+      document.addEventListener("keyup", this._onKeyUp);
+    }
+    if (this._config.devtoolsDetection) {
+      this._startDevtoolsDetection();
+    }
+  }
+  deactivate() {
+    if (!this._active) return;
+    this._active = false;
+    document.removeEventListener("visibilitychange", this._onVisibilityChange);
+    document.removeEventListener("keyup", this._onKeyUp);
+    if (this._devtoolsTimer) {
+      clearInterval(this._devtoolsTimer);
+      this._devtoolsTimer = null;
+    }
+    this._removeOverlay();
+  }
+  registerSensitive(element) {
+    this._sensitiveElements.add(element);
+    if (this._config.clipboardProtection) {
+      element.addEventListener("copy", this._blockCopy);
+      element.addEventListener("cut", this._blockCopy);
+    }
+    return () => this.unregisterSensitive(element);
+  }
+  unregisterSensitive(element) {
+    this._sensitiveElements.delete(element);
+    element.removeEventListener("copy", this._blockCopy);
+    element.removeEventListener("cut", this._blockCopy);
+  }
+  on(event, handler) {
+    if (!this._listeners.has(event)) this._listeners.set(event, /* @__PURE__ */ new Set());
+    this._listeners.get(event).add(handler);
+    return () => this._listeners.get(event)?.delete(handler);
+  }
+  isDevtoolsOpen() {
+    const threshold = 160;
+    return window.outerWidth - window.innerWidth > threshold || window.outerHeight - window.innerHeight > threshold;
+  }
+  destroy() {
+    this.deactivate();
+    this._sensitiveElements.clear();
+    this._listeners.clear();
+  }
+  _onVisibilityChange = () => {
+    if (document.hidden) {
+      this._showOverlay();
+      this._emit("tab-hidden");
+    } else {
+      this._removeOverlay();
+      this._emit("tab-visible");
+    }
+  };
+  _onKeyUp = (e) => {
+    if (e.key === "PrintScreen" || e.code === "PrintScreen") {
+      this._emit("screenshot-attempt");
+      this._showOverlay();
+      setTimeout(() => this._removeOverlay(), 300);
+    }
+  };
+  _blockCopy = (e) => {
+    e.preventDefault();
+    this._emit("clipboard-blocked");
+  };
+  _startDevtoolsDetection() {
+    this._devtoolsTimer = setInterval(() => {
+      if (this.isDevtoolsOpen()) this._emit("devtools-open");
+    }, 1e3);
+  }
+  _showOverlay() {
+    if (this._blurOverlay) return;
+    const overlay = document.createElement("div");
+    overlay.style.cssText = `
+      position: fixed; inset: 0; z-index: 999999;
+      backdrop-filter: blur(20px); -webkit-backdrop-filter: blur(20px);
+      background: rgba(0,0,0,0.4); display: flex;
+      align-items: center; justify-content: center;
+    `;
+    overlay.setAttribute("aria-hidden", "true");
+    const msg = document.createElement("div");
+    msg.textContent = "Switch back to continue";
+    msg.style.cssText = "color:#fff; font-size:18px; font-weight:600; pointer-events:none;";
+    overlay.appendChild(msg);
+    document.body.appendChild(overlay);
+    this._blurOverlay = overlay;
+  }
+  _removeOverlay() {
+    if (this._blurOverlay) {
+      this._blurOverlay.remove();
+      this._blurOverlay = null;
+    }
+  }
+  _emit(event) {
+    this._listeners.get(event)?.forEach((fn) => fn());
+  }
+};
+
+// src/security/request-signing.service.ts
+async function _hmac(secret, message) {
+  const enc = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, enc.encode(message));
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function _uuid() {
+  if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+var JoopRequestSigningService = class {
+  _secret;
+  _maxAgeMs;
+  constructor(config) {
+    this._secret = config.secret;
+    this._maxAgeMs = config.maxAgeMs ?? 3e4;
+  }
+  /** Sign a payload. Returns the signed envelope to send in the request body. */
+  async sign(data) {
+    const nonce = _uuid();
+    const timestamp = Date.now();
+    const message = `${nonce}.${timestamp}.${JSON.stringify(data)}`;
+    const signature = await _hmac(this._secret, message);
+    return { data, nonce, timestamp, signature };
+  }
+  /** Verify a signed payload (for testing/debugging — production verification runs server-side). */
+  async verify(payload) {
+    const age = Date.now() - payload.timestamp;
+    if (age > this._maxAgeMs) return { valid: false, reason: `Request expired (${age}ms old)` };
+    if (age < -5e3) return { valid: false, reason: "Timestamp in the future" };
+    const message = `${payload.nonce}.${payload.timestamp}.${JSON.stringify(payload.data)}`;
+    const expected = await _hmac(this._secret, message);
+    if (expected !== payload.signature) return { valid: false, reason: "Signature mismatch" };
+    return { valid: true };
+  }
+  /** Add the signed envelope as the request body, returning updated fetch init. */
+  async signRequest(data, init = {}) {
+    const signed = await this.sign(data);
+    return {
+      ...init,
+      method: init.method ?? "POST",
+      headers: { "Content-Type": "application/json", ...init.headers ?? {} },
+      body: JSON.stringify(signed)
+    };
+  }
+};
+
+// src/security/secure-clipboard.ts
+var DEFAULT_SENSITIVE_PATTERNS = [
+  /\b\d{13,19}\b/,
+  // card numbers
+  /\b[A-Z]{2}\d{2}[A-Z0-9]{11,30}\b/,
+  // IBAN
+  /\b\d{3}-\d{2}-\d{4}\b/,
+  // SSN
+  /^\d{6,8}$/,
+  // OTP / PIN
+  /\b\d{4}\s\d{4}\s\d{4}\s\d{4}\b/
+  // formatted card
+];
+var JoopSecureClipboard = class {
+  _config;
+  _current = null;
+  _timer = null;
+  _event$ = new JoopSubject();
+  _visibilityHandler = null;
+  constructor(config = {}) {
+    this._config = {
+      defaultTtlMs: config.defaultTtlMs ?? 3e4,
+      sensitivePatterns: config.sensitivePatterns ?? DEFAULT_SENSITIVE_PATTERNS,
+      autoClearOnHide: config.autoClearOnHide ?? true
+    };
+    if (this._config.autoClearOnHide && typeof document !== "undefined") {
+      this._visibilityHandler = () => {
+        if (document.visibilityState === "hidden") this.clear("expired");
+      };
+      document.addEventListener("visibilitychange", this._visibilityHandler);
+    }
+  }
+  // ── Write ─────────────────────────────────────────────────────────────────
+  async copy(text, options = {}) {
+    const ttl = options.ttlMs ?? this._config.defaultTtlMs;
+    const now = Date.now();
+    const entry = {
+      text,
+      copiedAt: now,
+      expiresAt: now + ttl,
+      label: options.label,
+      isSensitive: this._detectSensitive(text)
+    };
+    if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+      await navigator.clipboard.writeText(text);
+    }
+    this._cancelTimer();
+    this._current = entry;
+    this._event$.next({ type: "copied", entry: { ...entry } });
+    this._timer = setTimeout(() => this.clear("expired"), ttl);
+  }
+  // ── Read ──────────────────────────────────────────────────────────────────
+  async read() {
+    if (typeof navigator !== "undefined" && navigator.clipboard?.readText) {
+      try {
+        return await navigator.clipboard.readText();
+      } catch {
+      }
+    }
+    return this._current?.text ?? null;
+  }
+  // ── Clear ─────────────────────────────────────────────────────────────────
+  async clear(reason = "manual") {
+    this._cancelTimer();
+    const entry = this._current;
+    this._current = null;
+    if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+      try {
+        await navigator.clipboard.writeText("");
+      } catch {
+      }
+    }
+    this._event$.next({ type: reason === "expired" ? "expired" : "cleared", entry: entry ?? void 0 });
+  }
+  // ── Introspection ─────────────────────────────────────────────────────────
+  getCurrent() {
+    if (!this._current) return null;
+    if (Date.now() > this._current.expiresAt) {
+      this.clear("expired");
+      return null;
+    }
+    return { ...this._current };
+  }
+  isExpired() {
+    return !this._current || Date.now() > this._current.expiresAt;
+  }
+  getRemainingMs() {
+    if (!this._current) return 0;
+    return Math.max(0, this._current.expiresAt - Date.now());
+  }
+  isSensitive(text) {
+    return this._detectSensitive(text);
+  }
+  // ── Observable ────────────────────────────────────────────────────────────
+  events$() {
+    return this._event$.asObservable();
+  }
+  // ── Cleanup ───────────────────────────────────────────────────────────────
+  destroy() {
+    this._cancelTimer();
+    if (this._visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this._visibilityHandler);
+    }
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _detectSensitive(text) {
+    return this._config.sensitivePatterns.some((p) => p.test(text.trim()));
+  }
+  _cancelTimer() {
+    if (this._timer !== null) {
+      clearTimeout(this._timer);
+      this._timer = null;
+    }
+  }
+};
+
+// src/security/anti-tamper.service.ts
+var SEVERITY = {
+  "devtools": "medium",
+  "dom-injection": "high",
+  "prototype-pollution": "critical",
+  "console-override": "medium",
+  "function-override": "high"
+};
+var SEVERITY_ORDER = ["low", "medium", "high", "critical"];
+var JoopAntiTamperService = class {
+  _monitor = null;
+  _tamper$ = new JoopSubject();
+  _alertHandlers = [];
+  _lastReport = null;
+  _nativeFetch = typeof fetch !== "undefined" ? fetch : null;
+  _nativeConsoleLog = typeof console !== "undefined" ? console.log : null;
+  // ── Checks ────────────────────────────────────────────────────────────────
+  checkDevTools() {
+    let detected = false;
+    let detail;
+    if (typeof window !== "undefined") {
+      const threshold = 160;
+      if (window.outerWidth - window.innerWidth > threshold || window.outerHeight - window.innerHeight > threshold) {
+        detected = true;
+        detail = "Window size delta suggests DevTools panel is open";
+      }
+    }
+    return { type: "devtools", detected, severity: SEVERITY["devtools"], detail };
+  }
+  checkDomInjection() {
+    let detected = false;
+    let detail;
+    if (typeof document !== "undefined") {
+      const scripts = document.querySelectorAll("script[src]");
+      const suspicious = Array.from(scripts).filter((s) => {
+        const src = s.src;
+        return src && !src.startsWith(location.origin) && !src.startsWith("chrome-extension://");
+      });
+      if (suspicious.length > 0) {
+        detected = true;
+        detail = `${suspicious.length} external script(s) found: ${suspicious.map((s) => s.src.split("/")[2]).join(", ")}`;
+      }
+    }
+    return { type: "dom-injection", detected, severity: SEVERITY["dom-injection"], detail };
+  }
+  checkPrototypePollution() {
+    const probes = ["__proto__", "constructor", "toString", "valueOf", "hasOwnProperty"];
+    const polluted = [];
+    for (const key of probes) {
+      const obj = {};
+      if (typeof obj[key] !== (key === "__proto__" ? "object" : "function")) {
+        polluted.push(key);
+      }
+    }
+    for (const key in {}) {
+      polluted.push(key);
+      break;
+    }
+    const detected = polluted.length > 0;
+    return { type: "prototype-pollution", detected, severity: SEVERITY["prototype-pollution"], detail: detected ? `Polluted keys: ${polluted.join(", ")}` : void 0 };
+  }
+  checkConsoleOverride() {
+    let detected = false;
+    let detail;
+    if (typeof console !== "undefined" && this._nativeConsoleLog) {
+      const isNative = Function.prototype.toString.call(console.log).includes("[native code]");
+      if (!isNative && console.log !== this._nativeConsoleLog) {
+        detected = true;
+        detail = "console.log has been overridden";
+      }
+    }
+    return { type: "console-override", detected, severity: SEVERITY["console-override"], detail };
+  }
+  checkFunctionOverride() {
+    let detected = false;
+    let detail;
+    const overridden = [];
+    if (typeof fetch !== "undefined" && this._nativeFetch && fetch !== this._nativeFetch) {
+      overridden.push("fetch");
+    }
+    if (typeof XMLHttpRequest !== "undefined") {
+      const isNative = Function.prototype.toString.call(XMLHttpRequest.prototype.open).includes("[native code]");
+      if (!isNative) overridden.push("XMLHttpRequest.open");
+    }
+    if (overridden.length > 0) {
+      detected = true;
+      detail = `Overridden: ${overridden.join(", ")}`;
+    }
+    return { type: "function-override", detected, severity: SEVERITY["function-override"], detail };
+  }
+  // ── Integrity scan ────────────────────────────────────────────────────────
+  checkIntegrity() {
+    const checks = [
+      this.checkDevTools(),
+      this.checkDomInjection(),
+      this.checkPrototypePollution(),
+      this.checkConsoleOverride(),
+      this.checkFunctionOverride()
+    ];
+    const threats = checks.filter((c) => c.detected);
+    const severities = threats.map((c) => SEVERITY_ORDER.indexOf(c.severity));
+    const highestIdx = severities.length > 0 ? Math.max(...severities) : -1;
+    const report = {
+      timestamp: Date.now(),
+      checks,
+      threatCount: threats.length,
+      highestSeverity: highestIdx >= 0 ? SEVERITY_ORDER[highestIdx] : null
+    };
+    this._lastReport = report;
+    if (report.threatCount > 0) {
+      this._alertHandlers.forEach((h) => h(report));
+      this._tamper$.next(report);
+    }
+    return report;
+  }
+  isTampered() {
+    return (this._lastReport?.threatCount ?? 0) > 0;
+  }
+  getLastReport() {
+    return this._lastReport;
+  }
+  // ── Monitoring ────────────────────────────────────────────────────────────
+  startMonitoring(intervalMs = 1e4) {
+    if (this._monitor !== null) return;
+    this.checkIntegrity();
+    this._monitor = setInterval(() => this.checkIntegrity(), intervalMs);
+  }
+  stopMonitoring() {
+    if (this._monitor !== null) {
+      clearInterval(this._monitor);
+      this._monitor = null;
+    }
+  }
+  isMonitoring() {
+    return this._monitor !== null;
+  }
+  // ── Events ────────────────────────────────────────────────────────────────
+  onTamperDetected(handler) {
+    this._alertHandlers.push(handler);
+    return () => {
+      this._alertHandlers = this._alertHandlers.filter((h) => h !== handler);
+    };
+  }
+  tamper$() {
+    return this._tamper$.asObservable();
+  }
+  destroy() {
+    this.stopMonitoring();
+  }
+};
+
+// src/security/cert-pinning.service.ts
+var JoopCertPinningService = class {
+  _pins = /* @__PURE__ */ new Map();
+  _violations = [];
+  _violation$ = new JoopSubject();
+  _violationHandlers = [];
+  // ── Pin management ────────────────────────────────────────────────────────
+  addPin(pin) {
+    const hostname = this._normalizeHostname(pin.hostname);
+    this._pins.set(hostname, { ...pin, hostname, addedAt: Date.now(), fingerprints: pin.fingerprints.map((f) => f.toLowerCase().replace(/:/g, "")) });
+  }
+  removePin(hostname) {
+    this._pins.delete(this._normalizeHostname(hostname));
+  }
+  getPin(hostname) {
+    return this._pins.get(this._normalizeHostname(hostname));
+  }
+  getAllPins() {
+    return Array.from(this._pins.values());
+  }
+  // ── Validation ────────────────────────────────────────────────────────────
+  validate(url, fingerprint) {
+    const hostname = this._hostnameFromUrl(url);
+    const pin = this._findPin(hostname);
+    if (!pin) return { valid: true, pinned: false };
+    if (pin.expiresAt && Date.now() > pin.expiresAt) {
+      return { valid: true, pinned: false };
+    }
+    const normalized = fingerprint.toLowerCase().replace(/:/g, "");
+    const matched = pin.fingerprints.includes(normalized);
+    if (!matched) {
+      const violation = {
+        hostname,
+        receivedFingerprint: normalized,
+        expectedFingerprints: pin.fingerprints,
+        timestamp: Date.now(),
+        url
+      };
+      this._violations.push(violation);
+      this._violationHandlers.forEach((h) => h(violation));
+      this._violation$.next(violation);
+      return { valid: false, pinned: true, violation, pin };
+    }
+    return { valid: true, pinned: true, pin };
+  }
+  validateResponse(url, response) {
+    const fingerprint = response.headers.get("x-cert-fingerprint") ?? "";
+    if (!fingerprint) return { valid: true, pinned: false };
+    return this.validate(url, fingerprint);
+  }
+  // ── Expiry ────────────────────────────────────────────────────────────────
+  getExpiring(withinMs = 7 * 24 * 36e5) {
+    const now = Date.now();
+    return this.getAllPins().filter((p) => p.expiresAt && p.expiresAt - now <= withinMs && p.expiresAt > now);
+  }
+  isExpired(hostname) {
+    const pin = this.getPin(hostname);
+    return !!(pin?.expiresAt && Date.now() > pin.expiresAt);
+  }
+  // ── Violations ────────────────────────────────────────────────────────────
+  getViolations() {
+    return [...this._violations];
+  }
+  clearViolations() {
+    this._violations = [];
+  }
+  onViolation(handler) {
+    this._violationHandlers.push(handler);
+    return () => {
+      this._violationHandlers = this._violationHandlers.filter((h) => h !== handler);
+    };
+  }
+  violations$() {
+    return this._violation$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _normalizeHostname(hostname) {
+    return hostname.toLowerCase().replace(/^https?:\/\//, "").split("/")[0].split("?")[0];
+  }
+  _hostnameFromUrl(url) {
+    try {
+      return new URL(url).hostname.toLowerCase();
+    } catch {
+      return this._normalizeHostname(url);
+    }
+  }
+  _findPin(hostname) {
+    return this._pins.get(hostname) ?? this._pins.get(`*.${hostname.split(".").slice(1).join(".")}`);
+  }
+};
+
+exports.JoopAntiTamperService = JoopAntiTamperService;
+exports.JoopBehavioralBiometrics = JoopBehavioralBiometrics;
+exports.JoopCertPinningService = JoopCertPinningService;
+exports.JoopDifferentialPrivacy = JoopDifferentialPrivacy;
+exports.JoopPIIScanner = JoopPIIScanner;
+exports.JoopRequestSigningService = JoopRequestSigningService;
+exports.JoopRiskEngine = JoopRiskEngine;
+exports.JoopScreenSecurityService = JoopScreenSecurityService;
+exports.JoopSecretSharing = JoopSecretSharing;
+exports.JoopSecureClipboard = JoopSecureClipboard;
+exports.JoopSecureStorage = JoopSecureStorage;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map