@ginger-ai/ginger-js 0.0.1

package/src/device/components/system/browser.ts

@@ -0,0 +1,838 @@
+// Enhanced browser detection with multiple techniques
+type BrowserDetails = {
+  name: string;
+  version: string;
+  confidence: number; // 0-100 score of detection confidence
+  engine: string;
+};
+
+/**
+ * Detect browser using multiple techniques to be resilient against spoofing and user agent changes
+ */
+export function getBrowserName(): string {
+  const details = detectBrowser();
+  return details.name;
+}
+
+/**
+ * Enhanced browser detection that uses multiple techniques to identify the browser
+ * with high confidence even when user agent is spoofed or in mobile simulation mode
+ */
+export function detectBrowser(): BrowserDetails {
+  // Default result with low confidence
+  const result: BrowserDetails = {
+    name: "Unknown",
+    version: "Unknown",
+    confidence: 0,
+    engine: "Unknown",
+  };
+
+  // Collection of detection results with confidence scores
+  const detections: { name: string; confidence: number }[] = [];
+
+  // First check for Edge in user agent (this is a fast check before other more intensive checks)
+  const ua = navigator.userAgent.toLowerCase();
+  if (ua.indexOf("edg/") !== -1 || ua.indexOf("edge/") !== -1) {
+    detections.push({ name: "Edge", confidence: 75 });
+  }
+
+  // 1. Engine detection based on error messages (more reliable than UA)
+  const engineSignatures = getEngineSignatures();
+  detectByEngineSignatures(detections, engineSignatures);
+
+  // 2. Feature detection for specific browsers
+  detectByFeatures(detections);
+
+  // 3. Protocol handler detection
+  detectByProtocolHandlers(detections);
+
+  // 4. CSS property detection
+  detectByCssProperties(detections);
+
+  // 5. Performance timing
+  detectByPerformance(detections);
+
+  // 6. JavaScript behavior patterns
+  detectByJsBehavior(detections);
+
+  // 7. Edge-specific detection - separate function to better differentiate Edge from Chrome
+  detectEdgeBrowser(detections);
+
+  // 8. Chrome-specific detection - enhanced Chrome detection
+  detectChromeBrowser(detections);
+
+  // 9. Brave-specific detection - get specific Brave signals
+  detectBraveBrowser(detections);
+
+  // Combine all detection results and calculate final browser with confidence
+  if (detections.length > 0) {
+    // Group by browser name and sum confidence
+    const grouped = detections.reduce((acc, curr) => {
+      acc[curr.name] = (acc[curr.name] || 0) + curr.confidence;
+      return acc;
+    }, {} as Record<string, number>);
+
+    // Find the browser with highest confidence
+    let maxConfidence = 0;
+    let detectedBrowser = "Unknown";
+
+    for (const [browser, confidence] of Object.entries(grouped)) {
+      if (confidence > maxConfidence) {
+        maxConfidence = confidence;
+        detectedBrowser = browser;
+      }
+    }
+
+    // Extra Edge check - check if incognito detection can confirm this is Edge
+    if (detectedBrowser === "Chrome" && isActuallyEdge()) {
+      detectedBrowser = "Edge";
+    }
+
+    result.name = detectedBrowser;
+    result.confidence = Math.min(100, maxConfidence);
+
+    // Set engine based on browser
+    if (["Chrome", "Edge", "Opera", "Brave"].includes(detectedBrowser)) {
+      result.engine = "Blink";
+    } else if (detectedBrowser === "Firefox") {
+      result.engine = "Gecko";
+    } else if (detectedBrowser === "Safari") {
+      result.engine = "WebKit";
+    }
+
+    // Try to extract version
+    result.version = getBrowserVersion(detectedBrowser);
+  }
+
+  return result;
+}
+
+/**
+ * Special detection for Brave browser
+ */
+function detectBraveBrowser(
+  detections: { name: string; confidence: number }[]
+): void {
+  try {
+    // Check for Brave API directly
+    if ((navigator as any).brave) {
+      detections.push({ name: "Brave", confidence: 95 });
+      return;
+    }
+
+    // Check for specific Brave patterns in the user agent
+    const ua = navigator.userAgent;
+    if (ua.includes("Brave") || ua.includes("brave")) {
+      detections.push({ name: "Brave", confidence: 90 });
+      return;
+    }
+
+    // Brave specific behavior checks
+    // 1. Brave removes certain tracking headers
+    // 2. Brave blocks fingerprinting by default
+    // 3. Brave has specific privacy features
+
+    // Check for Chrome without Google Chrome-specific features
+    if (
+      typeof (window as any).chrome !== "undefined" &&
+      (window as any).chrome.runtime &&
+      !(window as any).google
+    ) {
+      // Additional check for absence of Chrome-specific features
+      const hasNoChromeFeatures =
+        !("google" in window) &&
+        !(window as any).chrome.webstore &&
+        typeof (navigator as any).brave !== "undefined";
+
+      if (hasNoChromeFeatures) {
+        detections.push({ name: "Brave", confidence: 60 });
+      }
+    }
+  } catch (e) {
+    // Ignore detection errors
+  }
+}
+
+/**
+ * Specific check to determine if a browser is Edge by using the same techniques
+ * that incognito detection uses, which seems to report Edge correctly
+ */
+function isActuallyEdge(): boolean {
+  try {
+    // Check user agent for Edge keywords
+    const ua = navigator.userAgent.toLowerCase();
+    if (ua.indexOf("edg/") !== -1 || ua.indexOf("edge/") !== -1) {
+      return true;
+    }
+
+    // Check if any MS-specific APIs or DOM elements are available
+    if (
+      (window as any).msCredentials ||
+      (document as any).documentMode ||
+      typeof (window as any).MSInputMethodContext !== "undefined" ||
+      typeof (navigator as any).msLaunchUri === "function"
+    ) {
+      return true;
+    }
+
+    // Check Edge-specific combination of features
+    if (
+      typeof (window as any).chrome !== "undefined" &&
+      (window as any).chrome.runtime &&
+      !(window as any).chrome.webstore &&
+      !(window as any).opr &&
+      !(window as any).opera
+    ) {
+      // Additional Edge-specific check
+      try {
+        // Edge typically does not have the Chrome PDF viewer plugin
+        const hasChromePdfViewer = Array.from(navigator.plugins).some(
+          (plugin) => plugin.name === "Chrome PDF Viewer"
+        );
+
+        // Check for unique Edge plugin patterns
+        const hasEdgePluginPattern = Array.from(navigator.plugins).some(
+          (plugin) => plugin.name.indexOf("Edge") !== -1
+        );
+
+        if (!hasChromePdfViewer || hasEdgePluginPattern) {
+          return true;
+        }
+      } catch (e) {
+        // Plugin check failed
+      }
+    }
+
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Gets browser error behavior signature from various engine-specific behaviors
+ */
+function getEngineSignatures(): {
+  toFixedErrorLength: number;
+  functionToStringLength: number;
+} {
+  // Error message length from toFixed with negative values
+  let toFixedErrorLength = 0;
+  try {
+    const neg = parseInt("-1");
+    neg.toFixed(neg);
+  } catch (e: any) {
+    toFixedErrorLength = e.message.length;
+  }
+
+  // Function.toString() behavior - varies by browser
+  let functionToStringLength = 0;
+  try {
+    functionToStringLength = Function.prototype.toString.call(Function).length;
+  } catch (e) {
+    // Ignore error
+  }
+
+  return {
+    toFixedErrorLength,
+    functionToStringLength,
+  };
+}
+
+/**
+ * Detects browsers based on engine-specific error message patterns
+ */
+function detectByEngineSignatures(
+  detections: { name: string; confidence: number }[],
+  signatures: { toFixedErrorLength: number; functionToStringLength: number }
+): void {
+  // Safari typically has error message length of 44
+  if (signatures.toFixedErrorLength === 44) {
+    detections.push({ name: "Safari", confidence: 40 });
+  }
+
+  // Chrome typically has error message length of 51
+  else if (signatures.toFixedErrorLength === 51) {
+    detections.push({ name: "Chrome", confidence: 30 }); // Increased from 15
+  }
+
+  // Firefox typically has error message length of 25
+  else if (signatures.toFixedErrorLength === 25) {
+    detections.push({ name: "Firefox", confidence: 30 });
+  }
+
+  // Function.toString length can help differentiate browsers too
+  if (
+    signatures.functionToStringLength > 30 &&
+    signatures.functionToStringLength < 40
+  ) {
+    detections.push({ name: "Firefox", confidence: 10 });
+  } else if (signatures.functionToStringLength > 40) {
+    detections.push({ name: "Chrome", confidence: 15 }); // Increased from 5
+  }
+}
+
+/**
+ * Detects browser by checking for browser-specific features and APIs
+ */
+function detectByFeatures(
+  detections: { name: string; confidence: number }[]
+): void {
+  // Brave detection
+  if (
+    (navigator as any).brave &&
+    typeof (navigator as any).brave.isBrave === "function"
+  ) {
+    detections.push({ name: "Brave", confidence: 90 });
+  }
+
+  // Check for Chrome-specific APIs
+  if (
+    typeof (window as any).chrome !== "undefined" &&
+    (window as any).chrome.app &&
+    (window as any).chrome.runtime
+  ) {
+    // First check if it's not actually Edge
+    const ua = navigator.userAgent.toLowerCase();
+    if (ua.indexOf("edg/") === -1 && ua.indexOf("edge/") === -1) {
+      if ((navigator as any).brave === undefined) {
+        detections.push({ name: "Chrome", confidence: 40 }); // Increased from 25
+      }
+    } else {
+      // This is more likely Edge than Chrome
+      detections.push({ name: "Edge", confidence: 40 });
+    }
+  }
+
+  // Additional Chrome-specific feature detection
+  if (
+    (window as any).chrome &&
+    (window as any).chrome.csi &&
+    (window as any).chrome.loadTimes &&
+    !(window as any).opr &&
+    !(window as any).opera &&
+    !(
+      (navigator as any).brave &&
+      typeof (navigator as any).brave.isBrave === "function"
+    )
+  ) {
+    // These features are very specific to Chrome and not present in most other Chromium browsers
+    detections.push({ name: "Chrome", confidence: 60 });
+  }
+
+  // Firefox-specific objects
+  if (
+    typeof (window as any).InstallTrigger !== "undefined" ||
+    typeof (window as any).sidebar !== "undefined"
+  ) {
+    detections.push({ name: "Firefox", confidence: 70 });
+  }
+
+  // Safari detection
+  if (
+    /constructor/i.test((window as any).HTMLElement as any) ||
+    (function (p) {
+      return p.toString() === "[object SafariRemoteNotification]";
+    })(
+      !(typeof (window as any).safari === "undefined") &&
+        (window as any).safari.pushNotification
+    )
+  ) {
+    detections.push({ name: "Safari", confidence: 70 });
+  }
+
+  // Basic Edge detection - more detailed in detectEdgeBrowser function
+  if ((window as any).msCredentials || (document as any).documentMode) {
+    detections.push({ name: "Edge", confidence: 60 }); // Increased confidence
+  }
+
+  // Opera detection
+  if ((window as any).opr || (window as any).opera) {
+    detections.push({ name: "Opera", confidence: 60 });
+  }
+}
+
+/**
+ * Detects browser by checking for browser-specific protocol handlers
+ */
+function detectByProtocolHandlers(
+  detections: { name: string; confidence: number }[]
+): void {
+  // Chrome/Chromium protocols
+  if (typeof navigator.registerProtocolHandler === "function") {
+    try {
+      if ("chrome" in (window as any)) {
+        // Only consider chrome protocol if not Edge
+        const ua = navigator.userAgent.toLowerCase();
+        if (ua.indexOf("edg/") === -1 && ua.indexOf("edge/") === -1) {
+          detections.push({ name: "Chrome", confidence: 25 }); // Increased from 15
+        }
+      }
+
+      // Edge has ms-* protocols available
+      if (
+        "ms-access" in (navigator as any) ||
+        "ms-browser-extension" in (navigator as any) ||
+        "ms-calculator" in (navigator as any) ||
+        "ms-drive-to" in (navigator as any) ||
+        "ms-excel" in (navigator as any) ||
+        "ms-gamebarservices" in (navigator as any) ||
+        "ms-search" in (navigator as any) ||
+        "ms-word" in (navigator as any)
+      ) {
+        detections.push({ name: "Edge", confidence: 80 }); // Increased confidence
+      }
+
+      // Opera has specific protocol handlers
+      if ("opr:" in navigator.plugins || "opera:" in navigator.plugins) {
+        detections.push({ name: "Opera", confidence: 25 });
+      }
+    } catch (e) {
+      // Protocol detection failed
+    }
+  }
+}
+
+/**
+ * Detects browser by checking for browser-specific CSS properties
+ */
+function detectByCssProperties(
+  detections: { name: string; confidence: number }[]
+): void {
+  const docStyle = window.getComputedStyle(document.documentElement);
+
+  // Webkit-specific properties
+  if (
+    docStyle.getPropertyValue("--apple-trailing-word") !== "" ||
+    docStyle.getPropertyValue("-webkit-app-region") !== ""
+  ) {
+    detections.push({ name: "Safari", confidence: 20 });
+  }
+
+  // Firefox-specific properties
+  if (
+    docStyle.getPropertyValue("-moz-context-properties") !== "" ||
+    docStyle.getPropertyValue("-moz-user-focus") !== ""
+  ) {
+    detections.push({ name: "Firefox", confidence: 20 });
+  }
+
+  // Edge-specific CSS properties
+  if (
+    docStyle.getPropertyValue("-ms-ime-align") !== "" ||
+    docStyle.getPropertyValue("-ms-flow-from") !== ""
+  ) {
+    detections.push({ name: "Edge", confidence: 60 }); // Increased confidence
+  }
+}
+
+/**
+ * Detects browser by analyzing performance characteristics
+ */
+function detectByPerformance(
+  detections: { name: string; confidence: number }[]
+): void {
+  // Chrome/Chromium-based browsers expose memory info
+  if (
+    (performance as any).memory &&
+    (performance as any).memory.jsHeapSizeLimit
+  ) {
+    // Different Chromium browsers have different heap size limits
+    const heapLimit = (performance as any).memory.jsHeapSizeLimit;
+
+    if (heapLimit > 2000000000) {
+      // Check if it's not actually Edge before assuming Chrome
+      const ua = navigator.userAgent.toLowerCase();
+      if (ua.indexOf("edg/") === -1 && ua.indexOf("edge/") === -1) {
+        detections.push({ name: "Chrome", confidence: 20 }); // Increased from 10
+      }
+    }
+  }
+
+  // Chrome-specific performance timing features
+  if (
+    typeof (window as any).chrome !== "undefined" &&
+    typeof (window as any).chrome.loadTimes === "function"
+  ) {
+    try {
+      const chromeLoad = (window as any).chrome.loadTimes();
+      if (
+        chromeLoad &&
+        typeof chromeLoad.firstPaintTime === "number" &&
+        typeof chromeLoad.requestTime === "number"
+      ) {
+        detections.push({ name: "Chrome", confidence: 30 });
+      }
+    } catch (e) {
+      // Performance timing check failed
+    }
+  }
+}
+
+/**
+ * Detects browser by JavaScript behavior patterns
+ */
+function detectByJsBehavior(
+  detections: { name: string; confidence: number }[]
+): void {
+  // Firefox specific behavior with error stack
+  try {
+    throw new Error();
+  } catch (err: any) {
+    if (err.stack && err.stack.indexOf("()@") >= 0) {
+      detections.push({ name: "Firefox", confidence: 15 });
+    }
+
+    // Chrome-specific stack trace format
+    if (err.stack && err.stack.indexOf("at new") >= 0) {
+      // Check if it's not actually Edge
+      const ua = navigator.userAgent.toLowerCase();
+      if (ua.indexOf("edg/") === -1 && ua.indexOf("edge/") === -1) {
+        detections.push({ name: "Chrome", confidence: 20 }); // Increased from 10
+      }
+    }
+
+    // Safari-specific stack trace format
+    if (
+      err.stack &&
+      err.stack.indexOf("@") === -1 &&
+      err.stack.indexOf("at ") === -1
+    ) {
+      detections.push({ name: "Safari", confidence: 15 });
+    }
+  }
+
+  // Brave shields detection
+  if (
+    document.createElement("canvas").toDataURL().length > 15 &&
+    (navigator as any).brave === undefined &&
+    typeof (window as any).chrome !== "undefined"
+  ) {
+    // Try to detect if Brave shields are on
+    const img = new Image();
+    let loadCount = 0;
+
+    img.onload = () => {
+      loadCount++;
+      if (loadCount === 0) {
+        detections.push({ name: "Brave", confidence: 20 });
+      }
+    };
+
+    img.onerror = () => {
+      detections.push({ name: "Brave", confidence: 10 });
+    };
+
+    // Try loading a tracking pixel
+    img.src = "https://www.facebook.com/tr?id=1234567890&ev=PageView";
+  }
+
+  // Additional Chrome-specific behavior check (Chrome DevTools Protocol)
+  try {
+    // Check if __JQUERY_OBJECT__ is defined (used in Chrome Developer Tools)
+    // This will throw an error in most other browsers
+    const hasDevTools = !!(window as any).__JQUERY_OBJECT__;
+    if (hasDevTools) {
+      detections.push({ name: "Chrome", confidence: 15 });
+    }
+  } catch (e) {
+    // DevTools check failed
+  }
+
+  // Check Chrome user agent pattern more directly when combined with other Chrome features
+  if (
+    navigator.userAgent.indexOf("Chrome") !== -1 &&
+    navigator.userAgent.indexOf("Edg") === -1 &&
+    navigator.userAgent.indexOf("OPR") === -1 &&
+    navigator.userAgent.indexOf("Brave") === -1 &&
+    typeof (window as any).chrome !== "undefined" &&
+    (window as any).chrome.runtime
+  ) {
+    detections.push({ name: "Chrome", confidence: 35 });
+  }
+}
+
+/**
+ * Specialized Edge browser detection to differentiate it from Chrome
+ */
+function detectEdgeBrowser(
+  detections: { name: string; confidence: number }[]
+): void {
+  // Check for Edge in User Agent as a supplementary signal (still useful)
+  const ua = navigator.userAgent.toLowerCase();
+  if (ua.indexOf("edg/") !== -1 || ua.indexOf("edge/") !== -1) {
+    detections.push({ name: "Edge", confidence: 80 }); // Increased from 30 to 80
+  }
+
+  // Check for Edge-specific objects
+  try {
+    // Check for CSS.supports method with -ms vendor prefix
+    if (CSS.supports("-ms-ime-align", "auto")) {
+      detections.push({ name: "Edge", confidence: 70 }); // Increased confidence
+    }
+  } catch (e) {
+    // CSS.supports might not be available
+  }
+
+  // Check for Edge-specific behaviors
+  try {
+    // Test if msLaunchUri is available (Edge-specific)
+    if (typeof (navigator as any).msLaunchUri === "function") {
+      detections.push({ name: "Edge", confidence: 85 }); // Increased confidence
+    }
+
+    // Test if MS-specific APIs are available
+    if (typeof (window as any).MSInputMethodContext !== "undefined") {
+      detections.push({ name: "Edge", confidence: 80 }); // Increased confidence
+    }
+
+    // Check for Edge-specific storage behavior
+    if ((document as any).documentMode || /edge/i.test(navigator.userAgent)) {
+      detections.push({ name: "Edge", confidence: 75 }); // Increased confidence
+    }
+
+    // Check window.chrome properties patterns specific to Edge
+    if (
+      typeof (window as any).chrome !== "undefined" &&
+      (window as any).chrome.runtime &&
+      !(window as any).chrome.webstore
+    ) {
+      // This combination is more common in Edge than Chrome
+      detections.push({ name: "Edge", confidence: 60 }); // Increased confidence
+    }
+  } catch (e) {
+    // Ignore errors in detection
+  }
+
+  // Get text rendering metrics - Edge and Chrome render text differently
+  try {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (ctx) {
+      canvas.width = 200;
+      canvas.height = 50;
+      ctx.font = "20px Arial";
+      ctx.textBaseline = "top";
+      ctx.fillText("EdgeBrowserTest", 0, 0);
+
+      // Get image data to analyze text rendering
+      const imageData = ctx.getImageData(
+        0,
+        0,
+        canvas.width,
+        canvas.height
+      ).data;
+
+      // Create a simple hash of the first few pixels
+      let hash = 0;
+      for (let i = 0; i < 400; i += 4) {
+        hash = (hash << 5) - hash + imageData[i];
+      }
+
+      // Edge typically has different text rendering than Chrome
+      if (hash < 0) {
+        // Just an example threshold, would need calibration
+        detections.push({ name: "Edge", confidence: 50 }); // Increased confidence
+      }
+    }
+  } catch (e) {
+    // Canvas access might be restricted
+  }
+}
+
+/**
+ * Enhanced detection for Chrome browser
+ */
+function detectChromeBrowser(
+  detections: { name: string; confidence: number }[]
+): void {
+  // Complex feature combination check specific to Chrome but not other Chromium browsers
+  if (
+    // Must have Chrome in user agent but not be Edge or Opera
+    navigator.userAgent.indexOf("Chrome") !== -1 &&
+    navigator.userAgent.indexOf("Edg") === -1 &&
+    navigator.userAgent.indexOf("OPR") === -1 &&
+    // Must have chrome object with specific properties
+    typeof (window as any).chrome !== "undefined" &&
+    (window as any).chrome.runtime &&
+    // Check for Chrome-exclusive features
+    typeof (window as any).chrome.loadTimes === "function" &&
+    typeof (window as any).chrome.csi === "function" &&
+    // Ensure not Brave
+    typeof (navigator as any).brave === "undefined"
+  ) {
+    detections.push({ name: "Chrome", confidence: 75 });
+  }
+
+  // Check for Chrome PDF viewer plugin (generally not present in other Chromium browsers)
+  try {
+    const hasPdfViewer = Array.from(navigator.plugins).some(
+      (plugin) => plugin.name === "Chrome PDF Viewer"
+    );
+
+    if (
+      hasPdfViewer &&
+      navigator.userAgent.indexOf("Chrome") !== -1 &&
+      navigator.userAgent.indexOf("Edg") === -1
+    ) {
+      detections.push({ name: "Chrome", confidence: 60 });
+    }
+  } catch (e) {
+    // Plugin check failed
+  }
+
+  // Check Chrome version consistency in User Agent
+  // This helps differentiate from browsers that modify the Chrome version string
+  try {
+    const chromeMatch = navigator.userAgent.match(/Chrome\/([0-9.]+)/);
+    if (chromeMatch) {
+      const chromeVersion = chromeMatch[1];
+
+      // If app version contains the Chrome version and doesn't have Edg
+      if (
+        navigator.appVersion.indexOf(chromeVersion) !== -1 &&
+        navigator.userAgent.indexOf("Edg") === -1 &&
+        navigator.userAgent.indexOf("OPR") === -1
+      ) {
+        detections.push({ name: "Chrome", confidence: 30 });
+      }
+    }
+  } catch (e) {
+    // Version check failed
+  }
+}
+
+/**
+ * Attempts to get the browser version
+ */
+function getBrowserVersion(browserName: string): string {
+  const userAgent = navigator.userAgent;
+  let version = "Unknown";
+
+  try {
+    if (browserName === "Chrome") {
+      const match = userAgent.match(/Chrome\/([0-9.]+)/);
+      if (match) {
+        version = match[1];
+      }
+    } else if (browserName === "Firefox") {
+      const match = userAgent.match(/Firefox\/([0-9.]+)/);
+      if (match) {
+        version = match[1];
+      }
+    } else if (browserName === "Safari") {
+      const match = userAgent.match(/Version\/([0-9.]+)/);
+      if (match) {
+        version = match[1];
+      }
+    } else if (browserName === "Edge") {
+      // Modern Edge (Chromium-based)
+      const edgeMatch = userAgent.match(/Edg(?:e)?\/([0-9.]+)/);
+      if (edgeMatch) {
+        version = edgeMatch[1];
+      }
+    } else if (browserName === "Opera") {
+      const match = userAgent.match(/OPR\/([0-9.]+)/);
+      if (match) {
+        version = match[1];
+      }
+    } else if (browserName === "Brave") {
+      // First try to get version through Brave API if available
+      if ((navigator as any).brave && (navigator as any).brave.version) {
+        version = (navigator as any).brave.version;
+      } else {
+        // Otherwise extract from user agent like Chrome
+        // Brave uses the same Chrome version string but with Brave/[version]
+        const braveMatch = userAgent.match(/Brave\/([0-9.]+)/);
+        if (braveMatch) {
+          version = braveMatch[1];
+        } else {
+          // Fall back to Chrome version
+          const chromeMatch = userAgent.match(/Chrome\/([0-9.]+)/);
+          if (chromeMatch) {
+            version = chromeMatch[1];
+          }
+        }
+
+        // Try to access the Brave browser version via JavaScript API if available
+        if (typeof (navigator as any).brave !== "undefined") {
+          try {
+            // Request brave version info
+            (navigator as any).brave.isBrave().then((isBrave: boolean) => {
+              if (isBrave) {
+                // Remove console log
+              }
+            });
+          } catch (e) {
+            // API access failed
+          }
+        }
+      }
+    }
+  } catch (e) {
+    // Keep default 'Unknown' value
+  }
+
+  return version;
+}
+interface BrowserResult {
+  name: string;
+  version: string;
+}
+
+export function getBrowser(): BrowserResult {
+  if (typeof navigator === "undefined") {
+    return {
+      name: "unknown",
+      version: "unknown",
+    };
+  }
+  const ua = navigator.userAgent;
+  // Define some regular expressions to match different browsers and their versions
+  const regexes = [
+    // Edge
+    /(?<name>Edge|Edg)\/(?<version>\d+(?:\.\d+)?)/,
+    // Chrome, Chromium, Opera, Vivaldi, Brave, etc.
+    /(?<name>(?:Chrome|Chromium|OPR|Opera|Vivaldi|Brave))\/(?<version>\d+(?:\.\d+)?)/,
+    // Firefox, Waterfox, etc.
+    /(?<name>(?:Firefox|Waterfox|Iceweasel|IceCat))\/(?<version>\d+(?:\.\d+)?)/,
+    // Safari, Mobile Safari, etc.
+    /(?<name>Safari)\/(?<version>\d+(?:\.\d+)?)/,
+    // Internet Explorer, IE Mobile, etc.
+    /(?<name>MSIE|Trident|IEMobile).+?(?<version>\d+(?:\.\d+)?)/,
+    // Other browsers that use the format "BrowserName/version"
+    /(?<name>[A-Za-z]+)\/(?<version>\d+(?:\.\d+)?)/,
+    // Samsung internet browser
+    /(?<name>SamsungBrowser)\/(?<version>\d+(?:\.\d+)?)/,
+    // Samsung browser (Tizen format)
+    /(?<name>samsung).*Version\/(?<version>\d+(?:\.\d+)?)/i,
+  ];
+
+  // Define a map for browser name translations
+  const browserNameMap: { [key: string]: string } = {
+    edg: "Edge",
+    opr: "Opera",
+    samsung: "SamsungBrowser",
+  };
+
+  // Loop through the regexes and try to find a match
+  for (const regex of regexes) {
+    const match = ua.match(regex);
+    if (match && match.groups) {
+      // Translate the browser name if necessary
+      const name =
+        browserNameMap[match.groups.name.toLowerCase()] || match.groups.name;
+      // Return the browser name and version
+      return {
+        name: name,
+        version: match.groups.version,
+      };
+    }
+  }
+
+  // If no match is found, return unknown
+  return {
+    name: "unknown",
+    version: "unknown",
+  };
+}