` → the vendored bundle."""
def __init__(self):
page = _PAGE.encode()
+ creep_page = _CREEP_PAGE.encode()
vendor = _VENDOR
class H(http.server.BaseHTTPRequestHandler):
def do_GET(self): # noqa: N802
- if self.path == "/" or self.path.startswith("/?"):
+ p = self.path.split("?")[0]
+ if p == "/":
body, ctype = page, "text/html; charset=utf-8"
+ elif p == "/creepjs":
+ body, ctype = creep_page, "text/html; charset=utf-8"
else:
- f = vendor / Path(self.path.lstrip("/")).name
+ f = vendor / Path(p.lstrip("/")).name
if not f.is_file():
self.send_error(404); return
body = f.read_bytes()
@@ -99,6 +141,10 @@ class _DetectorSite:
def url(self):
return f"http://127.0.0.1:{self.port}/"
+ @property
+ def creep_url(self):
+ return f"http://127.0.0.1:{self.port}/creepjs"
+
def close(self):
self._srv.shutdown()
@@ -111,7 +157,7 @@ def detector_site():
def _run_detectors(firefox_binary, url):
- """Launch the binary, load the page, return (botd, fp, err)."""
+ """Launch the binary, load the page, return (botd, fp, fps, err)."""
with InvisiblePlaywright(seed=42, binary_path=firefox_binary) as browser:
page = browser.new_page()
page.goto(url, wait_until="load", timeout=45000)
@@ -121,16 +167,48 @@ def _run_detectors(firefox_binary, url):
)
botd = page.evaluate("() => window.__botd")
fp = page.evaluate("() => window.__fp")
+ fps = page.evaluate("() => window.__fps")
err = page.evaluate("() => window.__err")
- return botd, fp, err
+ return botd, fp, fps, err
+
+
+def _run_creepjs(firefox_binary, creep_url):
+ """Launch the binary, run CreepJS fully offline, return its headless result."""
+ _EV = """() => {
+ const f = window.Fingerprint;
+ if (!f || !f.headless) return { ready: false };
+ const h = f.headless;
+ return {
+ ready: true,
+ headlessRating: h.headlessRating,
+ stealthRating: h.stealthRating,
+ likeHeadlessRating: h.likeHeadlessRating,
+ headless: h.headless || {},
+ stealth: h.stealth || {},
+ totalLies: (f.lies && f.lies.totalLies) || 0,
+ };
+ }"""
+ with InvisiblePlaywright(seed=42, binary_path=firefox_binary) as browser:
+ page = browser.new_page()
+ # truly offline: abort every non-loopback request (CreepJS's optional
+ # crowd-comparison POST to arh.antoinevastel.com never runs).
+ page.route(
+ "**/*",
+ lambda r: r.abort() if "127.0.0.1" not in r.request.url else r.continue_(),
+ )
+ page.goto(creep_url, wait_until="domcontentloaded", timeout=45000)
+ page.wait_for_function(
+ "() => !!(window.Fingerprint && window.Fingerprint.headless)",
+ timeout=60000,
+ )
+ return page.evaluate(_EV)
@pytest.mark.e2e
def test_botd_no_detector_flags_automation(firefox_binary, detector_site):
"""The real BotD must not flag the build — aggregate AND every one of its
- individual detectors (webDriver/userAgent/appVersion/plugins/process/... ).
- """
- botd, _fp, err = _run_detectors(firefox_binary, detector_site.url)
+ individual detectors (webDriver/userAgent/appVersion/plugins/process/...)."""
+ botd, _fp, _fps, err = _run_detectors(firefox_binary, detector_site.url)
assert botd is not None, f"BotD produced no result (err:{err!r})"
assert botd.get("bot") is False, (
f"BotD aggregate flagged a bot: botKind={botd.get('botKind')!r}"
@@ -146,8 +224,8 @@ def test_fingerprintjs_visitorid_stable_across_launches(firefox_binary, detector
"""FingerprintJS visitorId must be present and identical across two fresh
launches with the same seed — a real browser is stable; an over-randomized
spoof drifts (and a drifting fingerprint is itself a bot tell)."""
- _b1, fp1, err1 = _run_detectors(firefox_binary, detector_site.url)
- _b2, fp2, err2 = _run_detectors(firefox_binary, detector_site.url)
+ _b1, fp1, _f1, err1 = _run_detectors(firefox_binary, detector_site.url)
+ _b2, fp2, _f2, err2 = _run_detectors(firefox_binary, detector_site.url)
assert fp1 and fp1.get("visitorId"), f"no visitorId on run 1 (err:{err1!r})"
assert fp2 and fp2.get("visitorId"), f"no visitorId on run 2 (err:{err2!r})"
assert fp1["visitorId"] == fp2["visitorId"], (
@@ -159,13 +237,58 @@ def test_fingerprintjs_visitorid_stable_across_launches(firefox_binary, detector
@pytest.mark.e2e
def test_fingerprintjs_collects_rich_fingerprint(firefox_binary, detector_site):
"""FingerprintJS must collect a RICH component surface (a real browser
- exposes many signals; a stripped/blocked surface is itself suspicious).
- We don't assert zero errored components (some are legitimately unsupported
- per browser), only that the surface is substantial and the id computed."""
- _b, fp, err = _run_detectors(firefox_binary, detector_site.url)
+ exposes many signals; a stripped/blocked surface is itself suspicious)."""
+ _b, fp, _f, err = _run_detectors(firefox_binary, detector_site.url)
assert fp and fp.get("visitorId"), f"FingerprintJS produced no id (err:{err!r})"
keys = fp.get("componentKeys") or []
assert len(keys) >= 15, (
f"FingerprintJS collected only {len(keys)} components — surface too thin "
f"(suppressed signals are themselves a tell): {keys}"
)
+
+
+@pytest.mark.e2e
+def test_fpscanner_no_automation_rules(firefox_binary, detector_site):
+ """fpscanner's engine-agnostic bot rules (webdriver/selenium/bot-UA/platform/
+ timezone/language) must all be clean. The Chrome/GPU-only rules are ignored
+ on purpose (see module docstring) — they false-red on a software-WebGL host."""
+ _b, _fp, fps, err = _run_detectors(firefox_binary, detector_site.url)
+ assert fps is not None, f"fpscanner produced no result (err:{err!r})"
+ details = fps.get("details") or {}
+ assert details, f"fpscanner returned no detection details (err:{err!r})"
+ flagged = [
+ k for k in _FPSCANNER_AGNOSTIC
+ if details.get(k) and details[k].get("detected")
+ ]
+ assert not flagged, (
+ f"fpscanner flagged automation on engine-agnostic rules: {flagged} "
+ f"(full details: { {k: v for k, v in details.items() if v.get('detected')} })"
+ )
+
+
+@pytest.mark.e2e
+def test_creepjs_headless_and_proxy_clean(firefox_binary, detector_site):
+ """CreepJS (Firefox-aware) must see no headless tell and no JS-proxy stealth
+ tell. ``headlessRating`` aggregates webDriverIsOn + headless-UA checks (all
+ GPU-independent). The proxy/runtime stealth sub-signals (hasIframeProxy,
+ hasToStringProxy, hasBadChromeRuntime) must be false — a spoof implemented
+ with a JS Proxy is exactly what CreepJS catches. stealthRating/totalLies/
+ likeHeadlessRating are GPU/theme-sensitive, so we log them, not assert."""
+ r = _run_creepjs(firefox_binary, detector_site.creep_url)
+ assert r and r.get("ready"), f"CreepJS never populated window.Fingerprint: {r!r}"
+ print(
+ f"[creepjs] headlessRating={r['headlessRating']} stealthRating={r['stealthRating']} "
+ f"likeHeadlessRating={r['likeHeadlessRating']} totalLies={r['totalLies']} "
+ f"headless={r['headless']} stealth={r['stealth']}"
+ )
+ assert r["headlessRating"] == 0, (
+ f"CreepJS headless tells fired: headless={r['headless']} "
+ f"(headlessRating={r['headlessRating']})"
+ )
+ stealth = r.get("stealth") or {}
+ proxy_tells = {
+ k: stealth.get(k)
+ for k in ("hasIframeProxy", "hasToStringProxy", "hasBadChromeRuntime")
+ if stealth.get(k)
+ }
+ assert not proxy_tells, f"CreepJS JS-proxy stealth tells fired: {proxy_tells}"
diff --git a/tests/vendor/README.md b/tests/vendor/README.md
index 8b4ae4a..b252d8b 100644
--- a/tests/vendor/README.md
+++ b/tests/vendor/README.md
@@ -6,13 +6,19 @@ on a dev box and on a GitHub runner (no external CDN at test time — Firefox
tracking-protection blocks the openfpcdn.io CDN anyway, and we want CI offline).
They are served from a localhost HTTP server and loaded into the patched Firefox;
-the tests assert the REAL detectors don't flag the stealth build (BotD: `bot===false`)
-and that the fingerprint is stable (FingerprintJS: same `visitorId` across launches).
+the tests assert the REAL detectors don't flag the stealth build (BotD: `bot===false`;
+fpscanner: engine-agnostic rules clean; CreepJS: `headlessRating===0` + no JS-proxy
+tells) and that the fingerprint is stable (FingerprintJS: same `visitorId` across
+launches). CreepJS runs fully offline — the tests abort every non-loopback request,
+so its optional crowd-comparison POST never fires and the verdict is computed locally.
| File | Package | Version | Source | License |
|---|---|---|---|---|
| `botd-2.0.0.esm.js` | `@fingerprintjs/botd` | 2.0.0 | https://cdn.jsdelivr.net/npm/@fingerprintjs/botd@2.0.0/dist/botd.esm.js | MIT |
| `fingerprintjs-5.2.0.umd.min.js` | `@fingerprintjs/fingerprintjs` | 5.2.0 | https://cdn.jsdelivr.net/npm/@fingerprintjs/fingerprintjs@5.2.0/dist/fp.umd.min.js | MIT |
+| `fpscanner-1.0.6.es.js` | `fpscanner` | 1.0.6 | https://cdn.jsdelivr.net/npm/fpscanner@1.0.6/dist/fpScanner.es.js | MIT |
+| `creepjs-10aa672.js` | `abrahamjuliot/creepjs` | git `10aa6724` | https://raw.githubusercontent.com/abrahamjuliot/creepjs/10aa6724cd33a1015db1574211890518cd04f0cc/docs/creep.js | MIT |
-Both are MIT (Copyright © FingerprintJS, Inc.). To update: download the pinned
-dist from jsdelivr, drop it here, and bump the version in the filename + this table.
+All MIT (FingerprintJS Inc. / Antoine Vastel / Abraham Juliot). To update: download
+the pinned dist (jsdelivr for npm packages, raw.githubusercontent for CreepJS at a
+commit SHA), drop it here, and bump the version in the filename + this table.
diff --git a/tests/vendor/creepjs-10aa672.js b/tests/vendor/creepjs-10aa672.js
new file mode 100644
index 0000000..1e920f1
--- /dev/null
+++ b/tests/vendor/creepjs-10aa672.js
@@ -0,0 +1,9710 @@
+(function () {
+ 'use strict';
+
+ var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+ // @ts-expect-error
+ const IS_WORKER_SCOPE = !self.document && self.WorkerGlobalScope;
+ // Detect Browser
+ function getEngine() {
+ const x = [].constructor;
+ try {
+ (-1).toFixed(-1);
+ }
+ catch (err) {
+ return err.message.length + (x + '').split(x.name).join('').length;
+ }
+ }
+ const ENGINE_IDENTIFIER = getEngine();
+ const IS_BLINK = ENGINE_IDENTIFIER == 80;
+ const IS_GECKO = ENGINE_IDENTIFIER == 58;
+ const IS_WEBKIT = ENGINE_IDENTIFIER == 77;
+ const JS_ENGINE = ({
+ 80: 'V8',
+ 58: 'SpiderMonkey',
+ 77: 'JavaScriptCore',
+ })[ENGINE_IDENTIFIER] || null;
+ const LIKE_BRAVE = IS_BLINK && 'flat' in Array.prototype /* Chrome 69 */ && !('ReportingObserver' in self /* Brave */);
+ function braveBrowser() {
+ const brave = ('brave' in navigator &&
+ // @ts-ignore
+ Object.getPrototypeOf(navigator.brave).constructor.name == 'Brave' &&
+ // @ts-ignore
+ navigator.brave.isBrave.toString() == 'function isBrave() { [native code] }');
+ return brave;
+ }
+ function getBraveMode() {
+ const mode = {
+ unknown: false,
+ allow: false,
+ standard: false,
+ strict: false,
+ };
+ try {
+ // strict mode adds float frequency data AnalyserNode
+ const strictMode = () => {
+ try {
+ window.OfflineAudioContext = (
+ // @ts-ignore
+ OfflineAudioContext || webkitOfflineAudioContext);
+ }
+ catch (err) { }
+ if (!window.OfflineAudioContext) {
+ return false;
+ }
+ const context = new OfflineAudioContext(1, 1, 44100);
+ const analyser = context.createAnalyser();
+ const data = new Float32Array(analyser.frequencyBinCount);
+ analyser.getFloatFrequencyData(data);
+ const strict = new Set(data).size > 1; // native only has -Infinity
+ return strict;
+ };
+ if (strictMode()) {
+ mode.strict = true;
+ return mode;
+ }
+ // standard and strict mode do not have chrome plugins
+ const chromePlugins = /(Chrom(e|ium)|Microsoft Edge) PDF (Plugin|Viewer)/;
+ const pluginsList = [...navigator.plugins];
+ const hasChromePlugins = pluginsList
+ .filter((plugin) => chromePlugins.test(plugin.name)).length == 2;
+ if (pluginsList.length && !hasChromePlugins) {
+ mode.standard = true;
+ return mode;
+ }
+ mode.allow = true;
+ return mode;
+ }
+ catch (e) {
+ mode.unknown = true;
+ return mode;
+ }
+ }
+ const getBraveUnprotectedParameters = (parameters) => {
+ const blocked = new Set([
+ 'FRAGMENT_SHADER.HIGH_FLOAT.precision',
+ 'FRAGMENT_SHADER.HIGH_FLOAT.rangeMax',
+ 'FRAGMENT_SHADER.HIGH_FLOAT.rangeMin',
+ 'FRAGMENT_SHADER.HIGH_INT.precision',
+ 'FRAGMENT_SHADER.HIGH_INT.rangeMax',
+ 'FRAGMENT_SHADER.HIGH_INT.rangeMin',
+ 'FRAGMENT_SHADER.LOW_FLOAT.precision',
+ 'FRAGMENT_SHADER.LOW_FLOAT.rangeMax',
+ 'FRAGMENT_SHADER.LOW_FLOAT.rangeMin',
+ 'FRAGMENT_SHADER.MEDIUM_FLOAT.precision',
+ 'FRAGMENT_SHADER.MEDIUM_FLOAT.rangeMax',
+ 'FRAGMENT_SHADER.MEDIUM_FLOAT.rangeMin',
+ 'MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS',
+ 'MAX_COMBINED_UNIFORM_BLOCKS',
+ 'MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS',
+ 'MAX_DRAW_BUFFERS_WEBGL',
+ 'MAX_FRAGMENT_INPUT_COMPONENTS',
+ 'MAX_FRAGMENT_UNIFORM_BLOCKS',
+ 'MAX_FRAGMENT_UNIFORM_COMPONENTS',
+ 'MAX_TEXTURE_MAX_ANISOTROPY_EXT',
+ 'MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS',
+ 'MAX_UNIFORM_BUFFER_BINDINGS',
+ 'MAX_VARYING_COMPONENTS',
+ 'MAX_VERTEX_OUTPUT_COMPONENTS',
+ 'MAX_VERTEX_UNIFORM_BLOCKS',
+ 'MAX_VERTEX_UNIFORM_COMPONENTS',
+ 'SHADING_LANGUAGE_VERSION',
+ 'UNMASKED_RENDERER_WEBGL',
+ 'UNMASKED_VENDOR_WEBGL',
+ 'VERSION',
+ 'VERTEX_SHADER.HIGH_FLOAT.precision',
+ 'VERTEX_SHADER.HIGH_FLOAT.rangeMax',
+ 'VERTEX_SHADER.HIGH_FLOAT.rangeMin',
+ 'VERTEX_SHADER.HIGH_INT.precision',
+ 'VERTEX_SHADER.HIGH_INT.rangeMax',
+ 'VERTEX_SHADER.HIGH_INT.rangeMin',
+ 'VERTEX_SHADER.LOW_FLOAT.precision',
+ 'VERTEX_SHADER.LOW_FLOAT.rangeMax',
+ 'VERTEX_SHADER.LOW_FLOAT.rangeMin',
+ 'VERTEX_SHADER.MEDIUM_FLOAT.precision',
+ 'VERTEX_SHADER.MEDIUM_FLOAT.rangeMax',
+ 'VERTEX_SHADER.MEDIUM_FLOAT.rangeMin',
+ ]);
+ const safeParameters = Object.keys(parameters).reduce((acc, curr) => {
+ if (blocked.has(curr)) {
+ return acc;
+ }
+ acc[curr] = parameters[curr];
+ return acc;
+ }, {});
+ return safeParameters;
+ };
+ // system
+ const getOS = (userAgent) => {
+ const os = (
+ // order is important
+ /windows phone/ig.test(userAgent) ? 'Windows Phone' :
+ /win(dows|16|32|64|95|98|nt)|wow64/ig.test(userAgent) ? 'Windows' :
+ /android/ig.test(userAgent) ? 'Android' :
+ /cros/ig.test(userAgent) ? 'Chrome OS' :
+ /linux/ig.test(userAgent) ? 'Linux' :
+ /ipad/ig.test(userAgent) ? 'iPad' :
+ /iphone/ig.test(userAgent) ? 'iPhone' :
+ /ipod/ig.test(userAgent) ? 'iPod' :
+ /ios/ig.test(userAgent) ? 'iOS' :
+ /mac/ig.test(userAgent) ? 'Mac' :
+ 'Other');
+ return os;
+ };
+ function getReportedPlatform(userAgent, platform) {
+ // user agent os lie
+ const userAgentOS = (
+ // order is important
+ /win(dows|16|32|64|95|98|nt)|wow64/ig.test(userAgent) ? "Windows" /* PlatformClassifier.WINDOWS */ :
+ /android|linux|cros/ig.test(userAgent) ? "Linux" /* PlatformClassifier.LINUX */ :
+ /(i(os|p(ad|hone|od)))|mac/ig.test(userAgent) ? "Apple" /* PlatformClassifier.APPLE */ :
+ "Other" /* PlatformClassifier.OTHER */);
+ if (!platform)
+ return [userAgentOS];
+ const platformOS = (
+ // order is important
+ /win/ig.test(platform) ? "Windows" /* PlatformClassifier.WINDOWS */ :
+ /android|arm|linux/ig.test(platform) ? "Linux" /* PlatformClassifier.LINUX */ :
+ /(i(os|p(ad|hone|od)))|mac/ig.test(platform) ? "Apple" /* PlatformClassifier.APPLE */ :
+ "Other" /* PlatformClassifier.OTHER */);
+ return [userAgentOS, platformOS];
+ }
+ const { userAgent: navUserAgent, platform: navPlatform } = self.navigator || {};
+ const [USER_AGENT_OS, PLATFORM_OS] = getReportedPlatform(navUserAgent, navPlatform);
+ const decryptUserAgent = ({ ua, os, isBrave }) => {
+ const apple = /ipad|iphone|ipod|ios|mac/ig.test(os);
+ const isOpera = /OPR\//g.test(ua);
+ const isVivaldi = /Vivaldi/g.test(ua);
+ const isDuckDuckGo = /DuckDuckGo/g.test(ua);
+ const isYandex = /YaBrowser/g.test(ua);
+ const paleMoon = ua.match(/(palemoon)\/(\d+)./i);
+ const edge = ua.match(/(edgios|edg|edge|edga)\/(\d+)./i);
+ const edgios = edge && /edgios/i.test(edge[1]);
+ const chromium = ua.match(/(crios|chrome)\/(\d+)./i);
+ const firefox = ua.match(/(fxios|firefox)\/(\d+)./i);
+ const likeSafari = (/AppleWebKit/g.test(ua) &&
+ /Safari/g.test(ua));
+ const safari = (likeSafari &&
+ !firefox &&
+ !chromium &&
+ !edge &&
+ ua.match(/(version)\/(\d+)\.(\d|\.)+\s(mobile|safari)/i));
+ if (chromium) {
+ const browser = chromium[1];
+ const version = chromium[2];
+ const like = (isOpera ? ' Opera' :
+ isVivaldi ? ' Vivaldi' :
+ isDuckDuckGo ? ' DuckDuckGo' :
+ isYandex ? ' Yandex' :
+ edge ? ' Edge' :
+ isBrave ? ' Brave' : '');
+ return `${browser} ${version}${like}`;
+ }
+ else if (edgios) {
+ const browser = edge[1];
+ const version = edge[2];
+ return `${browser} ${version}`;
+ }
+ else if (firefox) {
+ const browser = paleMoon ? paleMoon[1] : firefox[1];
+ const version = paleMoon ? paleMoon[2] : firefox[2];
+ return `${browser} ${version}`;
+ }
+ else if (apple && safari) {
+ const browser = 'Safari';
+ const version = safari[2];
+ return `${browser} ${version}`;
+ }
+ return 'unknown';
+ };
+ const getUserAgentPlatform = ({ userAgent, excludeBuild = true }) => {
+ if (!userAgent) {
+ return 'unknown';
+ }
+ // patterns
+ const nonPlatformParenthesis = /\((khtml|unlike|vizio|like gec|internal dummy|org\.eclipse|openssl|ipv6|via translate|safari|cardamon).+|xt\d+\)/ig;
+ const parenthesis = /\((.+)\)/;
+ const android = /((android).+)/i;
+ const androidNoise = /^(linux|[a-z]|wv|mobile|[a-z]{2}(-|_)[a-z]{2}|[a-z]{2})$|windows|(rv:|trident|webview|iemobile).+/i;
+ const androidBuild = /build\/.+\s|\sbuild\/.+/i;
+ const androidRelease = /android( |-)\d+/i;
+ const windows = /((windows).+)/i;
+ const windowsNoise = /^(windows|ms(-|)office|microsoft|compatible|[a-z]|x64|[a-z]{2}(-|_)[a-z]{2}|[a-z]{2})$|(rv:|outlook|ms(-|)office|microsoft|trident|\.net|msie|httrack|media center|infopath|aol|opera|iemobile|webbrowser).+/i;
+ const windows64bitCPU = /w(ow|in)64/i;
+ const cros = /cros/i;
+ const crosNoise = /^([a-z]|x11|[a-z]{2}(-|_)[a-z]{2}|[a-z]{2})$|(rv:|trident).+/i;
+ const crosBuild = /\d+\.\d+\.\d+/i;
+ const linux = /linux|x11|ubuntu|debian/i;
+ const linuxNoise = /^([a-z]|x11|unknown|compatible|[a-z]{2}(-|_)[a-z]{2}|[a-z]{2})$|(rv:|java|oracle|\+http|http|unknown|mozilla|konqueror|valve).+/i;
+ const apple = /(cpu iphone|cpu os|iphone os|mac os|macos|intel os|ppc mac).+/i;
+ const appleNoise = /^([a-z]|macintosh|compatible|mimic|[a-z]{2}(-|_)[a-z]{2}|[a-z]{2}|rv|\d+\.\d+)$|(rv:|silk|valve).+/i;
+ const appleRelease = /(ppc |intel |)(mac|mac |)os (x |x|)(\d{2}(_|\.)\d{1,2}|\d{2,})/i;
+ const otherOS = /((symbianos|nokia|blackberry|morphos|mac).+)|\/linux|freebsd|symbos|series \d+|win\d+|unix|hp-ux|bsdi|bsd|x86_64/i;
+ const isDevice = (list, device) => list.filter((x) => device.test(x)).length;
+ userAgent = userAgent.trim().replace(/\s{2,}/, ' ').replace(nonPlatformParenthesis, '');
+ if (parenthesis.test(userAgent)) {
+ const platformSection = userAgent.match(parenthesis)[0];
+ const identifiers = platformSection.slice(1, -1).replace(/,/g, ';').split(';').map((x) => x.trim());
+ if (isDevice(identifiers, android)) {
+ return identifiers
+ // @ts-ignore
+ .map((x) => androidRelease.test(x) ? androidRelease.exec(x)[0].replace('-', ' ') : x)
+ .filter((x) => !(androidNoise.test(x)))
+ .join(' ')
+ .replace((excludeBuild ? androidBuild : ''), '')
+ .trim().replace(/\s{2,}/, ' ');
+ }
+ else if (isDevice(identifiers, windows)) {
+ return identifiers
+ .filter((x) => !(windowsNoise.test(x)))
+ .join(' ')
+ .replace(/\sNT (\d+\.\d+)/, (match, version) => {
+ return (version == '10.0' ? ' 10' :
+ version == '6.3' ? ' 8.1' :
+ version == '6.2' ? ' 8' :
+ version == '6.1' ? ' 7' :
+ version == '6.0' ? ' Vista' :
+ version == '5.2' ? ' XP Pro' :
+ version == '5.1' ? ' XP' :
+ version == '5.0' ? ' 2000' :
+ version == '4.0' ? match :
+ ' ' + version);
+ })
+ .replace(windows64bitCPU, '(64-bit)')
+ .trim().replace(/\s{2,}/, ' ');
+ }
+ else if (isDevice(identifiers, cros)) {
+ return identifiers
+ .filter((x) => !(crosNoise.test(x)))
+ .join(' ')
+ .replace((excludeBuild ? crosBuild : ''), '')
+ .trim().replace(/\s{2,}/, ' ');
+ }
+ else if (isDevice(identifiers, linux)) {
+ return identifiers
+ .filter((x) => !(linuxNoise.test(x)))
+ .join(' ')
+ .trim().replace(/\s{2,}/, ' ');
+ }
+ else if (isDevice(identifiers, apple)) {
+ return identifiers
+ .map((x) => {
+ if (appleRelease.test(x)) {
+ // @ts-ignore
+ const release = appleRelease.exec(x)[0];
+ const versionMap = {
+ '10_7': 'Lion',
+ '10_8': 'Mountain Lion',
+ '10_9': 'Mavericks',
+ '10_10': 'Yosemite',
+ '10_11': 'El Capitan',
+ '10_12': 'Sierra',
+ '10_13': 'High Sierra',
+ '10_14': 'Mojave',
+ '10_15': 'Catalina',
+ '11': 'Big Sur',
+ '12': 'Monterey',
+ '13': 'Ventura',
+ };
+ const version = ((/(\d{2}(_|\.)\d{1,2}|\d{2,})/.exec(release) || [])[0] ||
+ '').replace(/\./g, '_');
+ const isOSX = /^10/.test(version);
+ const id = isOSX ? version : (/^\d{2,}/.exec(version) || [])[0];
+ const codeName = versionMap[id];
+ return codeName ? `macOS ${codeName}` : release;
+ }
+ return x;
+ })
+ .filter((x) => !(appleNoise.test(x)))
+ .join(' ')
+ .replace(/\slike mac.+/ig, '')
+ .trim().replace(/\s{2,}/, ' ');
+ }
+ else {
+ const other = identifiers.filter((x) => otherOS.test(x));
+ if (other.length) {
+ return other.join(' ').trim().replace(/\s{2,}/, ' ');
+ }
+ return identifiers.join(' ');
+ }
+ }
+ else {
+ return 'unknown';
+ }
+ };
+ const computeWindowsRelease = ({ platform, platformVersion, fontPlatformVersion }) => {
+ if ((platform != 'Windows') || !(IS_BLINK && CSS.supports('accent-color', 'initial'))) {
+ return;
+ }
+ const platformVersionNumber = +(/(\d+)\./.exec(platformVersion) || [])[1];
+ // https://github.com/WICG/ua-client-hints/issues/220#issuecomment-870858413
+ // https://docs.microsoft.com/en-us/microsoft-edge/web-platform/how-to-detect-win11
+ // https://docs.microsoft.com/en-us/microsoft-edge/web-platform/user-agent-guidance
+ const release = {
+ '0.1.0': '7',
+ '0.2.0': '8',
+ '0.3.0': '8.1',
+ '1.0.0': '10 (1507)',
+ '2.0.0': '10 (1511)',
+ '3.0.0': '10 (1607)',
+ '4.0.0': '10 (1703)',
+ '5.0.0': '10 (1709)',
+ '6.0.0': '10 (1803)',
+ '7.0.0': '10 (1809)',
+ '8.0.0': '10 (1903|1909)',
+ '10.0.0': '10 (2004|20H2|21H1)',
+ '11.0.0': '10',
+ '12.0.0': '10',
+ };
+ const oldFontPlatformVersionNumber = (/7|8\.1|8/.exec(fontPlatformVersion) || [])[0];
+ const version = (platformVersionNumber >= 13 ? '11' :
+ platformVersionNumber == 0 && oldFontPlatformVersionNumber ? oldFontPlatformVersionNumber :
+ (release[platformVersion] || 'Unknown'));
+ return (`Windows ${version} [${platformVersion}]`);
+ };
+ // attempt restore from User-Agent Reduction
+ const isUAPostReduction = (userAgent) => {
+ const matcher = /Mozilla\/5\.0 \((Macintosh; Intel Mac OS X 10_15_7|Windows NT 10\.0; Win64; x64|(X11; (CrOS|Linux) x86_64)|(Linux; Android 10(; K|)))\) AppleWebKit\/537\.36 \(KHTML, like Gecko\) Chrome\/\d+\.0\.0\.0( Mobile|) Safari\/537\.36/;
+ const unifiedPlatform = (matcher.exec(userAgent) || [])[1];
+ return IS_BLINK && !!unifiedPlatform;
+ };
+ const createPerformanceLogger = () => {
+ const log = {};
+ let total = 0;
+ return {
+ logTestResult: ({ test, passed, time = 0 }) => {
+ total += time;
+ const timeString = `${time.toFixed(2)}ms`;
+ log[test] = timeString;
+ const color = passed ? '#4cca9f' : 'lightcoral';
+ const result = passed ? 'passed' : 'failed';
+ const symbol = passed ? '✔' : '-';
+ return console.log(`%c${symbol}${time ? ` (${timeString})` : ''} ${test} ${result}`, `color:${color}`);
+ },
+ getLog: () => log,
+ getTotal: () => total,
+ };
+ };
+ const performanceLogger = createPerformanceLogger();
+ const { logTestResult } = performanceLogger;
+ const createTimer = () => {
+ let start = 0;
+ const log = [];
+ return {
+ stop: () => {
+ if (start) {
+ log.push(performance.now() - start);
+ return log.reduce((acc, n) => acc += n, 0);
+ }
+ return start;
+ },
+ start: () => {
+ start = performance.now();
+ return start;
+ },
+ };
+ };
+ const queueEvent = (timer, delay = 0) => {
+ timer.stop();
+ return new Promise((resolve) => setTimeout(() => resolve(timer.start()), delay))
+ .catch((e) => { });
+ };
+ const formatEmojiSet = (emojiSet, limit = 3) => {
+ const maxLen = (limit * 2) + 3;
+ const list = (emojiSet || []);
+ return list.length > maxLen ? `${emojiSet.slice(0, limit).join('')}...${emojiSet.slice(-limit).join('')}` :
+ list.join('');
+ };
+ const EMOJIS = [
+ [128512], [9786], [129333, 8205, 9794, 65039], [9832], [9784], [9895], [8265], [8505], [127987, 65039, 8205, 9895, 65039], [129394], [9785], [9760], [129489, 8205, 129456], [129487, 8205, 9794, 65039], [9975], [129489, 8205, 129309, 8205, 129489], [9752], [9968], [9961], [9972], [9992], [9201], [9928], [9730], [9969], [9731], [9732], [9976], [9823], [9937], [9000], [9993], [9999],
+ [128105, 8205, 10084, 65039, 8205, 128139, 8205, 128104],
+ [128104, 8205, 128105, 8205, 128103, 8205, 128102],
+ [128104, 8205, 128105, 8205, 128102],
+ // android 11
+ [128512],
+ [169], [174], [8482],
+ [128065, 65039, 8205, 128488, 65039],
+ // other
+ [10002], [9986], [9935], [9874], [9876], [9881], [9939], [9879], [9904], [9905], [9888], [9762], [9763], [11014], [8599], [10145], [11013], [9883], [10017], [10013], [9766], [9654], [9197], [9199], [9167], [9792], [9794], [10006], [12336], [9877], [9884], [10004], [10035], [10055], [9724], [9642], [10083], [10084], [9996], [9757], [9997], [10052], [9878], [8618], [9775], [9770], [9774], [9745], [10036], [127344], [127359],
+ ].map((emojiCode) => String.fromCodePoint(...emojiCode));
+ const CSS_FONT_FAMILY = `
+ 'Segoe Fluent Icons',
+ 'Ink Free',
+ 'Bahnschrift',
+ 'Segoe MDL2 Assets',
+ 'HoloLens MDL2 Assets',
+ 'Leelawadee UI',
+ 'Javanese Text',
+ 'Segoe UI Emoji',
+ 'Aldhabi',
+ 'Gadugi',
+ 'Myanmar Text',
+ 'Nirmala UI',
+ 'Lucida Console',
+ 'Cambria Math',
+ 'Bai Jamjuree',
+ 'Chakra Petch',
+ 'Charmonman',
+ 'Fahkwang',
+ 'K2D',
+ 'Kodchasan',
+ 'KoHo',
+ 'Sarabun',
+ 'Srisakdi',
+ 'Galvji',
+ 'MuktaMahee Regular',
+ 'InaiMathi Bold',
+ 'American Typewriter Semibold',
+ 'Futura Bold',
+ 'SignPainter-HouseScript Semibold',
+ 'PingFang HK Light',
+ 'Kohinoor Devanagari Medium',
+ 'Luminari',
+ 'Geneva',
+ 'Helvetica Neue',
+ 'Droid Sans Mono',
+ 'Dancing Script',
+ 'Roboto',
+ 'Ubuntu',
+ 'Liberation Mono',
+ 'Source Code Pro',
+ 'DejaVu Sans',
+ 'OpenSymbol',
+ 'Chilanka',
+ 'Cousine',
+ 'Arimo',
+ 'Jomolhari',
+ 'MONO',
+ 'Noto Color Emoji',
+ sans-serif !important
+`;
+ const hashSlice = (x) => !x ? x : x.slice(0, 8);
+ function getGpuBrand(gpu) {
+ if (!gpu)
+ return null;
+ const gpuBrandMatcher = /(adreno|amd|apple|intel|llvm|mali|microsoft|nvidia|parallels|powervr|samsung|swiftshader|virtualbox|vmware)/i;
+ const brand = (/radeon/i.test(gpu) ? 'AMD' :
+ /geforce/i.test(gpu) ? 'NVIDIA' :
+ (gpuBrandMatcher.exec(gpu)?.[0] || 'other').toLocaleUpperCase());
+ return brand;
+ }
+ // collect fingerprints for analysis
+ const Analysis = {};
+ // use if needed to stable fingerprint
+ const LowerEntropy = {
+ AUDIO: false,
+ CANVAS: false,
+ FONTS: false,
+ SCREEN: false,
+ TIME_ZONE: false,
+ WEBGL: false,
+ };
+
+ // template views
+ function patch(oldEl, newEl, fn) {
+ if (!oldEl)
+ return null;
+ oldEl.parentNode?.replaceChild(newEl, oldEl);
+ return typeof fn === 'function' ? fn() : true;
+ }
+ function html(templateStr, ...expressionSet) {
+ const template = document.createElement('template');
+ template.innerHTML = templateStr.map((s, i) => `${s}${expressionSet[i] || ''}`).join('');
+ return document.importNode(template.content, true);
+ }
+ // template helpers
+ const HTMLNote = {
+ UNKNOWN: 'unknown ',
+ UNSUPPORTED: 'unsupported ',
+ BLOCKED: 'blocked ',
+ LIED: 'lied ',
+ SECRET: 'secret ',
+ };
+ const count = (arr) => arr && arr.constructor.name === 'Array' ? '' + (arr.length) : '0';
+ const getDiffs = ({ stringA, stringB, charDiff = false, decorate = (diff) => `[${diff}]` }) => {
+ if (!stringA || !stringB)
+ return;
+ const splitter = charDiff ? '' : ' ';
+ const listA = ('' + stringA).split(splitter);
+ const listB = ('' + stringB).split(splitter);
+ const listBWithDiffs = listB.map((x, i) => {
+ const matcher = listA[i];
+ const match = x == matcher;
+ return !match ? decorate(x) : x;
+ });
+ return listBWithDiffs.join(splitter);
+ };
+ // modal component
+ const modal = (name, result, linkname = 'details') => {
+ if (!result.length) {
+ return '';
+ }
+ return `
+
+ ${linkname}
+
+
+ ×
+ ${result}
+
+
+ `;
+ };
+
+ const createErrorsCaptured = () => {
+ const errors = [];
+ return {
+ getErrors: () => errors,
+ captureError: (error, customMessage = '') => {
+ const type = {
+ Error: true,
+ EvalError: true,
+ InternalError: true,
+ RangeError: true,
+ ReferenceError: true,
+ SyntaxError: true,
+ TypeError: true,
+ URIError: true,
+ InvalidStateError: true,
+ SecurityError: true,
+ };
+ const hasInnerSpace = (s) => /.+(\s).+/g.test(s); // ignore AOPR noise
+ console.error(error); // log error to educate
+ const { name, message } = error;
+ const trustedMessage = (!hasInnerSpace(message) ? undefined :
+ !customMessage ? message :
+ `${message} [${customMessage}]`);
+ const trustedName = type[name] ? name : undefined;
+ errors.push({ trustedName, trustedMessage });
+ return undefined;
+ },
+ };
+ };
+ const errorsCaptured = createErrorsCaptured();
+ const { captureError } = errorsCaptured;
+ const attempt = (fn, customMessage = '') => {
+ try {
+ return fn();
+ }
+ catch (error) {
+ if (customMessage) {
+ return captureError(error, customMessage);
+ }
+ return captureError(error);
+ }
+ };
+ const caniuse = (fn, objChainList = [], args = [], method = false) => {
+ let api;
+ try {
+ api = fn();
+ }
+ catch (error) {
+ return undefined;
+ }
+ let i;
+ const len = objChainList.length;
+ let chain = api;
+ try {
+ for (i = 0; i < len; i++) {
+ const obj = objChainList[i];
+ chain = chain[obj];
+ }
+ }
+ catch (error) {
+ return undefined;
+ }
+ return (method && args.length ? chain.apply(api, args) :
+ method && !args.length ? chain.apply(api) :
+ chain);
+ };
+ // Log performance time
+ const timer = (logStart) => {
+ let start = 0;
+ try {
+ start = performance.now();
+ }
+ catch (error) {
+ captureError(error);
+ }
+ return (logEnd) => {
+ let end = 0;
+ try {
+ end = performance.now() - start;
+ logEnd && console.log(`${logEnd}: ${end / 1000} seconds`);
+ return end;
+ }
+ catch (error) {
+ captureError(error);
+ return 0;
+ }
+ };
+ };
+ const getCapturedErrors = () => ({ data: errorsCaptured.getErrors() });
+
+ /* eslint-disable new-cap */
+ /* eslint-disable no-unused-vars */
+ // warm up while we detect lies
+ try {
+ speechSynthesis.getVoices();
+ }
+ catch (err) { }
+ // Collect lies detected
+ function createLieRecords() {
+ const records = {};
+ return {
+ getRecords: () => records,
+ documentLie: (name, lie) => {
+ const isArray = lie instanceof Array;
+ if (records[name]) {
+ if (isArray) {
+ return (records[name] = [...records[name], ...lie]);
+ }
+ return records[name].push(lie);
+ }
+ return isArray ? (records[name] = lie) : (records[name] = [lie]);
+ },
+ };
+ }
+ const lieRecords = createLieRecords();
+ const { documentLie } = lieRecords;
+ const GHOST = `
+ height: 100vh;
+ width: 100vw;
+ position: absolute;
+ left:-10000px;
+ visibility: hidden;
+`;
+ function getRandomValues() {
+ return (String.fromCharCode(Math.random() * 26 + 97) +
+ Math.random().toString(36).slice(-7));
+ }
+ function getBehemothIframe(win) {
+ try {
+ if (!IS_BLINK)
+ return win;
+ const div = win.document.createElement('div');
+ div.setAttribute('id', getRandomValues());
+ div.setAttribute('style', GHOST);
+ div.innerHTML = `
`;
+ win.document.body.appendChild(div);
+ const iframe = [...[...div.childNodes][0].childNodes][0];
+ if (!iframe)
+ return null;
+ const { contentWindow } = iframe || {};
+ if (!contentWindow)
+ return null;
+ const div2 = contentWindow.document.createElement('div');
+ div2.innerHTML = `
`;
+ contentWindow.document.body.appendChild(div2);
+ const iframe2 = [...[...div2.childNodes][0].childNodes][0];
+ return iframe2.contentWindow;
+ }
+ catch (error) {
+ captureError(error, 'client blocked behemoth iframe');
+ return win;
+ }
+ }
+ const RAND = getRandomValues();
+ const HAS_REFLECT = 'Reflect' in self;
+ function isTypeError(err) {
+ return err.constructor.name == 'TypeError';
+ }
+ function failsTypeError({ spawnErr, withStack, final }) {
+ try {
+ spawnErr();
+ throw Error();
+ }
+ catch (err) {
+ if (!isTypeError(err))
+ return true;
+ return withStack ? withStack(err) : false;
+ }
+ finally {
+ final && final();
+ }
+ }
+ function failsWithError(fn) {
+ try {
+ fn();
+ return false;
+ }
+ catch (err) {
+ return true;
+ }
+ }
+ function hasKnownToString(name) {
+ return {
+ [`function ${name}() { [native code] }`]: true,
+ [`function get ${name}() { [native code] }`]: true,
+ [`function () { [native code] }`]: true,
+ [`function ${name}() {${'\n'} [native code]${'\n'}}`]: true,
+ [`function get ${name}() {${'\n'} [native code]${'\n'}}`]: true,
+ [`function () {${'\n'} [native code]${'\n'}}`]: true,
+ };
+ }
+ function hasValidStack(err, reg, i = 1) {
+ if (i === 0)
+ return reg.test(err.message);
+ return reg.test(err.stack.split('\n')[i]);
+ }
+ const AT_FUNCTION = /at Function\.toString /;
+ const AT_OBJECT = /at Object\.toString/;
+ const FUNCTION_INSTANCE = /at (Function\.)?\[Symbol.hasInstance\]/; // useful if < Chrome 102
+ const PROXY_INSTANCE = /at (Proxy\.)?\[Symbol.hasInstance\]/; // useful if < Chrome 102
+ const STRICT_MODE = /strict mode/;
+ function queryLies({ scope, apiFunction, proto, obj, lieProps, }) {
+ if (typeof apiFunction != 'function') {
+ return {
+ lied: 0,
+ lieTypes: [],
+ };
+ }
+ const name = apiFunction.name.replace(/get\s/, '');
+ const objName = obj?.name;
+ const nativeProto = Object.getPrototypeOf(apiFunction);
+ let lies = {
+ // custom lie string names
+ ['failed illegal error']: !!obj && failsTypeError({
+ spawnErr: () => obj.prototype[name],
+ }),
+ ['failed undefined properties']: (!!obj && /^(screen|navigator)$/i.test(objName) && !!(Object.getOwnPropertyDescriptor(self[objName.toLowerCase()], name) || (HAS_REFLECT &&
+ Reflect.getOwnPropertyDescriptor(self[objName.toLowerCase()], name)))),
+ ['failed call interface error']: failsTypeError({
+ spawnErr: () => {
+ // @ts-expect-error
+ new apiFunction();
+ apiFunction.call(proto);
+ },
+ }),
+ ['failed apply interface error']: failsTypeError({
+ spawnErr: () => {
+ // @ts-expect-error
+ new apiFunction();
+ apiFunction.apply(proto);
+ },
+ }),
+ ['failed new instance error']: failsTypeError({
+ // @ts-expect-error
+ spawnErr: () => new apiFunction(),
+ }),
+ ['failed class extends error']: !IS_WEBKIT && failsTypeError({
+ spawnErr: () => {
+ // @ts-expect-error
+ class Fake extends apiFunction {
+ }
+ },
+ }),
+ ['failed null conversion error']: failsTypeError({
+ spawnErr: () => Object.setPrototypeOf(apiFunction, null).toString(),
+ final: () => Object.setPrototypeOf(apiFunction, nativeProto),
+ }),
+ ['failed toString']: (!hasKnownToString(name)[scope.Function.prototype.toString.call(apiFunction)] ||
+ !hasKnownToString('toString')[scope.Function.prototype.toString.call(apiFunction.toString)]),
+ ['failed "prototype" in function']: 'prototype' in apiFunction,
+ ['failed descriptor']: !!(Object.getOwnPropertyDescriptor(apiFunction, 'arguments') ||
+ Reflect.getOwnPropertyDescriptor(apiFunction, 'arguments') ||
+ Object.getOwnPropertyDescriptor(apiFunction, 'caller') ||
+ Reflect.getOwnPropertyDescriptor(apiFunction, 'caller') ||
+ Object.getOwnPropertyDescriptor(apiFunction, 'prototype') ||
+ Reflect.getOwnPropertyDescriptor(apiFunction, 'prototype') ||
+ Object.getOwnPropertyDescriptor(apiFunction, 'toString') ||
+ Reflect.getOwnPropertyDescriptor(apiFunction, 'toString')),
+ ['failed own property']: !!(apiFunction.hasOwnProperty('arguments') ||
+ apiFunction.hasOwnProperty('caller') ||
+ apiFunction.hasOwnProperty('prototype') ||
+ apiFunction.hasOwnProperty('toString')),
+ ['failed descriptor keys']: (Object.keys(Object.getOwnPropertyDescriptors(apiFunction)).sort().toString() != 'length,name'),
+ ['failed own property names']: (Object.getOwnPropertyNames(apiFunction).sort().toString() != 'length,name'),
+ ['failed own keys names']: HAS_REFLECT && (Reflect.ownKeys(apiFunction).sort().toString() != 'length,name'),
+ // Proxy Detection
+ ['failed object toString error']: (failsTypeError({
+ spawnErr: () => Object.create(apiFunction).toString(),
+ withStack: (err) => IS_BLINK && !hasValidStack(err, AT_FUNCTION),
+ }) ||
+ failsTypeError({
+ spawnErr: () => Object.create(new Proxy(apiFunction, {})).toString(),
+ withStack: (err) => IS_BLINK && !hasValidStack(err, AT_OBJECT),
+ })),
+ ['failed at incompatible proxy error']: failsTypeError({
+ spawnErr: () => {
+ apiFunction.arguments;
+ apiFunction.caller;
+ },
+ withStack: (err) => IS_GECKO && !hasValidStack(err, STRICT_MODE, 0),
+ }),
+ ['failed at toString incompatible proxy error']: failsTypeError({
+ spawnErr: () => {
+ apiFunction.toString.arguments;
+ apiFunction.toString.caller;
+ },
+ withStack: (err) => IS_GECKO && !hasValidStack(err, STRICT_MODE, 0),
+ }),
+ ['failed at too much recursion error']: failsTypeError({
+ spawnErr: () => {
+ Object.setPrototypeOf(apiFunction, Object.create(apiFunction)).toString();
+ },
+ final: () => Object.setPrototypeOf(apiFunction, nativeProto),
+ }),
+ };
+ // conditionally increase difficulty
+ const detectProxies = (name == 'toString' ||
+ !!lieProps['Function.toString'] ||
+ !!lieProps['Permissions.query']);
+ if (detectProxies) {
+ const proxy1 = new Proxy(apiFunction, {});
+ const proxy2 = new Proxy(apiFunction, {});
+ const proxy3 = new Proxy(apiFunction, {});
+ lies = {
+ ...lies,
+ // Advanced Proxy Detection
+ ['failed at too much recursion __proto__ error']: !failsTypeError({
+ spawnErr: () => {
+ // @ts-expect-error
+ apiFunction.__proto__ = proxy;
+ apiFunction++;
+ },
+ final: () => Object.setPrototypeOf(apiFunction, nativeProto),
+ }),
+ ['failed at chain cycle error']: !failsTypeError({
+ spawnErr: () => {
+ Object.setPrototypeOf(proxy1, Object.create(proxy1)).toString();
+ },
+ final: () => Object.setPrototypeOf(proxy1, nativeProto),
+ }),
+ ['failed at chain cycle __proto__ error']: !failsTypeError({
+ spawnErr: () => {
+ // @ts-expect-error
+ proxy2.__proto__ = proxy2;
+ proxy2++;
+ },
+ final: () => Object.setPrototypeOf(proxy2, nativeProto),
+ }),
+ ['failed at reflect set proto']: HAS_REFLECT && failsTypeError({
+ spawnErr: () => {
+ Reflect.setPrototypeOf(apiFunction, Object.create(apiFunction));
+ RAND in apiFunction;
+ throw new TypeError();
+ },
+ final: () => Object.setPrototypeOf(apiFunction, nativeProto),
+ }),
+ ['failed at reflect set proto proxy']: HAS_REFLECT && !failsTypeError({
+ spawnErr: () => {
+ Reflect.setPrototypeOf(proxy3, Object.create(proxy3));
+ RAND in proxy3;
+ },
+ final: () => Object.setPrototypeOf(proxy3, nativeProto),
+ }),
+ ['failed at instanceof check error']: IS_BLINK && (failsTypeError({
+ spawnErr: () => {
+ apiFunction instanceof apiFunction;
+ },
+ withStack: (err) => !hasValidStack(err, FUNCTION_INSTANCE),
+ }) ||
+ failsTypeError({
+ spawnErr: () => {
+ const proxy = new Proxy(apiFunction, {});
+ proxy instanceof proxy;
+ },
+ withStack: (err) => !hasValidStack(err, PROXY_INSTANCE),
+ })),
+ ['failed at define properties']: IS_BLINK && HAS_REFLECT && failsWithError(() => {
+ Object.defineProperty(apiFunction, '', { configurable: true }).toString();
+ Reflect.deleteProperty(apiFunction, '');
+ }),
+ };
+ }
+ const lieTypes = Object.keys(lies).filter((key) => !!lies[key]);
+ return {
+ lied: lieTypes.length,
+ lieTypes,
+ };
+ }
+ function createLieDetector(scope) {
+ const isSupported = (obj) => typeof obj != 'undefined' && !!obj;
+ const props = {}; // lie list and detail
+ const propsSearched = []; // list of properties searched
+ return {
+ getProps: () => props,
+ getPropsSearched: () => propsSearched,
+ searchLies: (fn, config) => {
+ const { target, ignore } = config || {};
+ let obj;
+ // check if api is blocked or not supported
+ try {
+ obj = fn();
+ if (!isSupported(obj)) {
+ return;
+ }
+ }
+ catch (error) {
+ return;
+ }
+ const interfaceObject = !!obj.prototype ? obj.prototype : obj;
+ [...new Set([
+ ...Object.getOwnPropertyNames(interfaceObject),
+ ...Object.keys(interfaceObject), // backup
+ ])].sort().forEach((name) => {
+ const skip = (name == 'constructor' ||
+ (target && !new Set(target).has(name)) ||
+ (ignore && new Set(ignore).has(name)));
+ if (skip)
+ return;
+ const objectNameString = /\s(.+)\]/;
+ const apiName = `${obj.name ? obj.name :
+ objectNameString.test(obj) ? objectNameString.exec(obj)?.[1] :
+ undefined}.${name}`;
+ propsSearched.push(apiName);
+ try {
+ const proto = obj.prototype ? obj.prototype : obj;
+ let res; // response from getLies
+ // search if function
+ try {
+ const apiFunction = proto[name]; // may trigger TypeError
+ if (typeof apiFunction == 'function') {
+ res = queryLies({
+ scope,
+ apiFunction: proto[name],
+ proto,
+ obj: null,
+ lieProps: props,
+ });
+ if (res.lied) {
+ documentLie(apiName, res.lieTypes);
+ return (props[apiName] = res.lieTypes);
+ }
+ return;
+ }
+ // since there is no TypeError and the typeof is not a function,
+ // handle invalid values and ignore name, length, and constants
+ if (name != 'name' &&
+ name != 'length' &&
+ name[0] !== name[0].toUpperCase()) {
+ const lie = ['failed descriptor.value undefined'];
+ documentLie(apiName, lie);
+ return (props[apiName] = lie);
+ }
+ }
+ catch (error) { }
+ // else search getter function
+ // @ts-ignore
+ const getterFunction = Object.getOwnPropertyDescriptor(proto, name).get;
+ res = queryLies({
+ scope,
+ apiFunction: getterFunction,
+ proto,
+ obj,
+ lieProps: props,
+ }); // send the obj for special tests
+ if (res.lied) {
+ documentLie(apiName, res.lieTypes);
+ return (props[apiName] = res.lieTypes);
+ }
+ return;
+ }
+ catch (error) {
+ const lie = `failed prototype test execution`;
+ documentLie(apiName, lie);
+ return (props[apiName] = [lie]);
+ }
+ });
+ },
+ };
+ }
+ function getPhantomIframe() {
+ if (IS_WORKER_SCOPE)
+ return { iframeWindow: self };
+ try {
+ const numberOfIframes = self.length;
+ const frag = new DocumentFragment();
+ const div = document.createElement('div');
+ const id = getRandomValues();
+ div.setAttribute('id', id);
+ frag.appendChild(div);
+ div.innerHTML = `
`;
+ document.body.appendChild(frag);
+ const iframeWindow = self[numberOfIframes];
+ const phantomWindow = getBehemothIframe(iframeWindow);
+ return { iframeWindow: phantomWindow || self, div };
+ }
+ catch (error) {
+ captureError(error, 'client blocked phantom iframe');
+ return { iframeWindow: self };
+ }
+ }
+ const { iframeWindow: PHANTOM_DARKNESS, div: PARENT_PHANTOM } = getPhantomIframe() || {};
+ function getPrototypeLies(scope) {
+ const lieDetector = createLieDetector(scope);
+ const { searchLies, } = lieDetector;
+ // search lies: remove target to search all properties
+ // test Function.toString first to determine the depth of the search
+ searchLies(() => Function, {
+ target: [
+ 'toString',
+ ],
+ ignore: [
+ 'caller',
+ 'arguments',
+ ],
+ });
+ // other APIs
+ searchLies(() => AnalyserNode);
+ searchLies(() => AudioBuffer, {
+ target: [
+ 'copyFromChannel',
+ 'getChannelData',
+ ],
+ });
+ searchLies(() => BiquadFilterNode, {
+ target: [
+ 'getFrequencyResponse',
+ ],
+ });
+ searchLies(() => CanvasRenderingContext2D, {
+ target: [
+ 'getImageData',
+ 'getLineDash',
+ 'isPointInPath',
+ 'isPointInStroke',
+ 'measureText',
+ 'quadraticCurveTo',
+ 'fillText',
+ 'strokeText',
+ 'font',
+ ],
+ });
+ searchLies(() => CSSStyleDeclaration, {
+ target: [
+ 'setProperty',
+ ],
+ });
+ // @ts-expect-error
+ searchLies(() => CSS2Properties, {
+ target: [
+ 'setProperty',
+ ],
+ });
+ searchLies(() => Date, {
+ target: [
+ 'getDate',
+ 'getDay',
+ 'getFullYear',
+ 'getHours',
+ 'getMinutes',
+ 'getMonth',
+ 'getTime',
+ 'getTimezoneOffset',
+ 'setDate',
+ 'setFullYear',
+ 'setHours',
+ 'setMilliseconds',
+ 'setMonth',
+ 'setSeconds',
+ 'setTime',
+ 'toDateString',
+ 'toJSON',
+ 'toLocaleDateString',
+ 'toLocaleString',
+ 'toLocaleTimeString',
+ 'toString',
+ 'toTimeString',
+ 'valueOf',
+ ],
+ });
+ // @ts-expect-error if not supported
+ searchLies(() => GPU, {
+ target: [
+ 'requestAdapter',
+ ],
+ });
+ // @ts-expect-error if not supported
+ searchLies(() => GPUAdapter, {
+ target: [
+ 'requestAdapterInfo',
+ ],
+ });
+ searchLies(() => Intl.DateTimeFormat, {
+ target: [
+ 'format',
+ 'formatRange',
+ 'formatToParts',
+ 'resolvedOptions',
+ ],
+ });
+ searchLies(() => Document, {
+ target: [
+ 'createElement',
+ 'createElementNS',
+ 'getElementById',
+ 'getElementsByClassName',
+ 'getElementsByName',
+ 'getElementsByTagName',
+ 'getElementsByTagNameNS',
+ 'referrer',
+ 'write',
+ 'writeln',
+ ],
+ ignore: [
+ // Gecko
+ 'onreadystatechange',
+ 'onmouseenter',
+ 'onmouseleave',
+ ],
+ });
+ searchLies(() => DOMRect);
+ searchLies(() => DOMRectReadOnly);
+ searchLies(() => Element, {
+ target: [
+ 'append',
+ 'appendChild',
+ 'getBoundingClientRect',
+ 'getClientRects',
+ 'insertAdjacentElement',
+ 'insertAdjacentHTML',
+ 'insertAdjacentText',
+ 'insertBefore',
+ 'prepend',
+ 'replaceChild',
+ 'replaceWith',
+ 'setAttribute',
+ ],
+ });
+ searchLies(() => FontFace, {
+ target: [
+ 'family',
+ 'load',
+ 'status',
+ ],
+ });
+ searchLies(() => HTMLCanvasElement);
+ searchLies(() => HTMLElement, {
+ target: [
+ 'clientHeight',
+ 'clientWidth',
+ 'offsetHeight',
+ 'offsetWidth',
+ 'scrollHeight',
+ 'scrollWidth',
+ ],
+ ignore: [
+ // Gecko
+ 'onmouseenter',
+ 'onmouseleave',
+ ],
+ });
+ searchLies(() => HTMLIFrameElement, {
+ target: [
+ 'contentDocument',
+ 'contentWindow',
+ ],
+ });
+ searchLies(() => IntersectionObserverEntry, {
+ target: [
+ 'boundingClientRect',
+ 'intersectionRect',
+ 'rootBounds',
+ ],
+ });
+ searchLies(() => Math, {
+ target: [
+ 'acos',
+ 'acosh',
+ 'asinh',
+ 'atan',
+ 'atan2',
+ 'atanh',
+ 'cbrt',
+ 'cos',
+ 'cosh',
+ 'exp',
+ 'expm1',
+ 'log',
+ 'log10',
+ 'log1p',
+ 'sin',
+ 'sinh',
+ 'sqrt',
+ 'tan',
+ 'tanh',
+ ],
+ });
+ searchLies(() => MediaDevices, {
+ target: [
+ 'enumerateDevices',
+ 'getDisplayMedia',
+ 'getUserMedia',
+ ],
+ });
+ searchLies(() => Navigator, {
+ target: [
+ 'appCodeName',
+ 'appName',
+ 'appVersion',
+ 'buildID',
+ 'connection',
+ 'deviceMemory',
+ 'getBattery',
+ 'getGamepads',
+ 'getVRDisplays',
+ 'hardwareConcurrency',
+ 'language',
+ 'languages',
+ 'maxTouchPoints',
+ 'mimeTypes',
+ 'oscpu',
+ 'platform',
+ 'plugins',
+ 'product',
+ 'productSub',
+ 'sendBeacon',
+ 'serviceWorker',
+ 'storage',
+ 'userAgent',
+ 'vendor',
+ 'vendorSub',
+ 'webdriver',
+ 'gpu',
+ ],
+ });
+ searchLies(() => Node, {
+ target: [
+ 'appendChild',
+ 'insertBefore',
+ 'replaceChild',
+ ],
+ });
+ // @ts-expect-error
+ searchLies(() => OffscreenCanvas, {
+ target: [
+ 'convertToBlob',
+ 'getContext',
+ ],
+ });
+ // @ts-expect-error
+ searchLies(() => OffscreenCanvasRenderingContext2D, {
+ target: [
+ 'getImageData',
+ 'getLineDash',
+ 'isPointInPath',
+ 'isPointInStroke',
+ 'measureText',
+ 'quadraticCurveTo',
+ 'font',
+ ],
+ });
+ searchLies(() => Permissions, {
+ target: [
+ 'query',
+ ],
+ });
+ searchLies(() => Range, {
+ target: [
+ 'getBoundingClientRect',
+ 'getClientRects',
+ ],
+ });
+ // @ts-expect-error
+ searchLies(() => Intl.RelativeTimeFormat, {
+ target: [
+ 'resolvedOptions',
+ ],
+ });
+ searchLies(() => Screen);
+ searchLies(() => speechSynthesis, {
+ target: [
+ 'getVoices',
+ ],
+ });
+ searchLies(() => String, {
+ target: [
+ 'fromCodePoint',
+ ],
+ });
+ searchLies(() => StorageManager, {
+ target: [
+ 'estimate',
+ ],
+ });
+ searchLies(() => SVGRect);
+ searchLies(() => SVGRectElement, {
+ target: [
+ 'getBBox',
+ ],
+ });
+ searchLies(() => SVGTextContentElement, {
+ target: [
+ 'getExtentOfChar',
+ 'getSubStringLength',
+ 'getComputedTextLength',
+ ],
+ });
+ searchLies(() => TextMetrics);
+ searchLies(() => WebGLRenderingContext, {
+ target: [
+ 'bufferData',
+ 'getParameter',
+ 'readPixels',
+ ],
+ });
+ searchLies(() => WebGL2RenderingContext, {
+ target: [
+ 'bufferData',
+ 'getParameter',
+ 'readPixels',
+ ],
+ });
+ /* potential targets:
+ RTCPeerConnection
+ Plugin
+ PluginArray
+ MimeType
+ MimeTypeArray
+ Worker
+ History
+ */
+ // return lies list and detail
+ const props = lieDetector.getProps();
+ const propsSearched = lieDetector.getPropsSearched();
+ return {
+ lieDetector,
+ lieList: Object.keys(props).sort(),
+ lieDetail: props,
+ lieCount: Object.keys(props).reduce((acc, key) => acc + props[key].length, 0),
+ propsSearched,
+ };
+ }
+ // start program
+ const start = performance.now();
+ const { lieDetector, lieList, lieDetail,
+ // lieCount,
+ propsSearched, } = getPrototypeLies(PHANTOM_DARKNESS); // execute and destructure the list and detail
+ // disregard Function.prototype.toString lies when determining if the API can be trusted
+ const getNonFunctionToStringLies = (x) => !x ? x : x.filter((x) => !/object toString|toString incompatible proxy/.test(x)).length;
+ let lieProps;
+ let prototypeLies;
+ let PROTO_BENCHMARK = 0;
+ if (!IS_WORKER_SCOPE) {
+ lieProps = (() => {
+ const props = lieDetector.getProps();
+ return Object.keys(props).reduce((acc, key) => {
+ acc[key] = getNonFunctionToStringLies(props[key]);
+ return acc;
+ }, {});
+ })();
+ prototypeLies = JSON.parse(JSON.stringify(lieDetail));
+ const perf = performance.now() - start;
+ PROTO_BENCHMARK = +perf.toFixed(2);
+ const message = `${propsSearched.length} API properties analyzed in ${PROTO_BENCHMARK}ms (${lieList.length} corrupted)`;
+ setTimeout(() => console.log(message), 3000);
+ }
+ const getPluginLies = (plugins, mimeTypes) => {
+ const lies = []; // collect lie types
+ const pluginsOwnPropertyNames = Object.getOwnPropertyNames(plugins).filter((name) => isNaN(+name));
+ const mimeTypesOwnPropertyNames = Object.getOwnPropertyNames(mimeTypes).filter((name) => isNaN(+name));
+ // cast to array
+ const pluginsList = [...plugins];
+ const mimeTypesList = [...mimeTypes];
+ // get initial trusted mimeType names
+ const trustedMimeTypes = new Set(mimeTypesOwnPropertyNames);
+ // get initial trusted plugin names
+ const excludeDuplicates = (arr) => [...new Set(arr)];
+ const mimeTypeEnabledPlugins = excludeDuplicates(mimeTypesList.map((mimeType) => mimeType.enabledPlugin));
+ const trustedPluginNames = new Set(pluginsOwnPropertyNames);
+ const mimeTypeEnabledPluginsNames = mimeTypeEnabledPlugins.map((plugin) => plugin && plugin.name);
+ const trustedPluginNamesArray = [...trustedPluginNames];
+ trustedPluginNamesArray.forEach((name) => {
+ const validName = new Set(mimeTypeEnabledPluginsNames).has(name);
+ if (!validName) {
+ trustedPluginNames.delete(name);
+ }
+ });
+ // 3. Expect MimeType object in plugins
+ const invalidPlugins = pluginsList.filter((plugin) => {
+ try {
+ const validMimeType = Object.getPrototypeOf(plugin[0]).constructor.name == 'MimeType';
+ if (!validMimeType) {
+ trustedPluginNames.delete(plugin.name);
+ }
+ return !validMimeType;
+ }
+ catch (error) {
+ trustedPluginNames.delete(plugin.name);
+ return true; // sign of tampering
+ }
+ });
+ if (invalidPlugins.length) {
+ lies.push('missing mimetype');
+ }
+ // 4. Expect valid MimeType(s) in plugin
+ const pluginMimeTypes = pluginsList
+ .map((plugin) => Object.values(plugin)).flat();
+ const pluginMimeTypesNames = pluginMimeTypes.map((mimetype) => mimetype.type);
+ pluginMimeTypesNames.forEach((name) => {
+ const validName = trustedMimeTypes.has(name);
+ if (!validName) {
+ trustedMimeTypes.delete(name);
+ }
+ });
+ pluginsList.forEach((plugin) => {
+ const pluginMimeTypes = Object.values(plugin).map((mimetype) => mimetype.type);
+ return pluginMimeTypes.forEach((mimetype) => {
+ if (!trustedMimeTypes.has(mimetype)) {
+ lies.push('invalid mimetype');
+ return trustedPluginNames.delete(plugin.name);
+ }
+ return;
+ });
+ });
+ return {
+ validPlugins: pluginsList.filter((plugin) => trustedPluginNames.has(plugin.name)),
+ validMimeTypes: mimeTypesList.filter((mimeType) => trustedMimeTypes.has(mimeType.type)),
+ lies: [...new Set(lies)], // remove duplicates
+ };
+ };
+ const getLies = () => {
+ const records = lieRecords.getRecords();
+ const totalLies = Object.keys(records).reduce((acc, key) => {
+ acc += records[key].length;
+ return acc;
+ }, 0);
+ return { data: records, totalLies };
+ };
+
+ // Detect proxy behavior
+ const proxyBehavior = (x) => typeof x == 'function' ? true : false;
+ const GIBBERS = /[cC]f|[jJ][bcdfghlmprsty]|[qQ][bcdfghjklmnpsty]|[vV][bfhjkmpt]|[xX][dkrz]|[yY]y|[zZ][fr]|[cCxXzZ]j|[bBfFgGjJkKpPvVqQtTwWyYzZ]q|[cCfFgGjJpPqQwW]v|[jJqQvV]w|[bBcCdDfFgGhHjJkKmMpPqQsSvVwWxXzZ]x|[bBfFhHjJkKmMpPqQ]z/g;
+ // Detect gibberish
+ const gibberish = (str, { strict = false } = {}) => {
+ if (!str)
+ return [];
+ // test letter case sequence
+ const letterCaseSequenceGibbers = [];
+ const tests = [
+ /([A-Z]{3,}[a-z])/g, // ABCd
+ /([a-z][A-Z]{3,})/g, // aBCD
+ /([a-z][A-Z]{2,}[a-z])/g, // aBC...z
+ /([a-z][\d]{2,}[a-z])/g, // a##...b
+ /([A-Z][\d]{2,}[a-z])/g, // A##...b
+ /([a-z][\d]{2,}[A-Z])/g, // a##...B
+ ];
+ tests.forEach((regExp) => {
+ const match = str.match(regExp);
+ if (match) {
+ return letterCaseSequenceGibbers.push(match.join(', '));
+ }
+ return;
+ });
+ // test letter sequence
+ const letterSequenceGibbers = [];
+ const clean = str.replace(/\d|\W|_/g, ' ').replace(/\s+/g, ' ').trim().split(' ').join('_');
+ const len = clean.length;
+ const arr = [...clean];
+ arr.forEach((char, index) => {
+ const nextIndex = index + 1;
+ const nextChar = arr[nextIndex];
+ const isWordSequence = nextChar !== '_' && char !== '_' && nextIndex !== len;
+ if (isWordSequence) {
+ const combo = char + nextChar;
+ if (GIBBERS.test(combo))
+ letterSequenceGibbers.push(combo);
+ }
+ });
+ const gibbers = [
+ // ignore sequence if less than 3 exist
+ ...(!strict && (letterSequenceGibbers.length < 3) ? [] : letterSequenceGibbers),
+ ...(!strict && (letterCaseSequenceGibbers.length < 4) ? [] : letterCaseSequenceGibbers),
+ ];
+ const allow = [
+ // known gibbers
+ 'bz',
+ 'cf',
+ 'fx',
+ 'mx',
+ 'vb',
+ 'xd',
+ 'gx',
+ 'PCIe',
+ 'vm',
+ 'NVIDIAGa',
+ ];
+ return gibbers.filter((x) => !allow.includes(x));
+ };
+ // WebGL Renderer helpers
+ function compressWebGLRenderer(x) {
+ if (!x)
+ return;
+ return ('' + x)
+ .replace(/ANGLE \(|\sDirect3D.+|\sD3D.+|\svs_.+\)|\((DRM|POLARIS|LLVM).+|Mesa.+|(ATI|INTEL)-.+|Metal\s-\s.+|NVIDIA\s[\d|\.]+/ig, '')
+ .replace(/(\s(ti|\d{1,2}GB|super)$)/ig, '')
+ .replace(/\s{2,}/g, ' ')
+ .trim()
+ .replace(/((r|g)(t|)(x|s|\d) |Graphics |GeForce |Radeon (HD |Pro |))(\d+)/i, (...args) => {
+ return `${args[1]}${args[6][0]}${args[6].slice(1).replace(/\d/g, '0')}s`;
+ });
+ }
+ const getWebGLRendererParts = (x) => {
+ const knownParts = [
+ 'AMD',
+ 'ANGLE',
+ 'ASUS',
+ 'ATI',
+ 'ATI Radeon',
+ 'ATI Technologies Inc',
+ 'Adreno',
+ 'Android Emulator',
+ 'Apple',
+ 'Apple GPU',
+ 'Apple M1',
+ 'Chipset',
+ 'D3D11',
+ 'Direct3D',
+ 'Express Chipset',
+ 'GeForce',
+ 'Generation',
+ 'Generic Renderer',
+ 'Google',
+ 'Google SwiftShader',
+ 'Graphics',
+ 'Graphics Media Accelerator',
+ 'HD Graphics Family',
+ 'Intel',
+ 'Intel(R) HD Graphics',
+ 'Intel(R) UHD Graphics',
+ 'Iris',
+ 'KBL Graphics',
+ 'Mali',
+ 'Mesa',
+ 'Mesa DRI',
+ 'Metal',
+ 'Microsoft',
+ 'Microsoft Basic Render Driver',
+ 'Microsoft Corporation',
+ 'NVIDIA',
+ 'NVIDIA Corporation',
+ 'NVIDIAGameReadyD3D',
+ 'OpenGL',
+ 'OpenGL Engine',
+ 'Open Source Technology Center',
+ 'Parallels',
+ 'Parallels Display Adapter',
+ 'PCIe',
+ 'Plus Graphics',
+ 'PowerVR',
+ 'Pro Graphics',
+ 'Quadro',
+ 'Radeon',
+ 'Radeon Pro',
+ 'Radeon Pro Vega',
+ 'Samsung',
+ 'SSE2',
+ 'VMware',
+ 'VMware SVGA 3D',
+ 'Vega',
+ 'VirtualBox',
+ 'VirtualBox Graphics Adapter',
+ 'Vulkan',
+ 'Xe Graphics',
+ 'llvmpipe',
+ ];
+ const parts = [...knownParts].filter((name) => ('' + x).includes(name));
+ return [...new Set(parts)].sort().join(', ');
+ };
+ const getWebGLRendererConfidence = (x) => {
+ if (!x) {
+ return;
+ }
+ const parts = getWebGLRendererParts(x);
+ const hasKnownParts = parts.length;
+ const hasBlankSpaceNoise = /\s{2,}|^\s|\s$/.test(x);
+ const hasBrokenAngleStructure = /^ANGLE/.test(x) && !(/^ANGLE \((.+)\)/.exec(x) || [])[1];
+ // https://chromium.googlesource.com/angle/angle/+/83fa18905d8fed4f394e4f30140a83a3e76b1577/src/gpu_info_util/SystemInfo.cpp
+ // https://chromium.googlesource.com/angle/angle/+/83fa18905d8fed4f394e4f30140a83a3e76b1577/src/gpu_info_util/SystemInfo.h
+ // https://chromium.googlesource.com/chromium/src/+/refs/heads/main/ui/gl/gl_version_info.cc
+ /*
+ const knownVendors = [
+ 'AMD',
+ 'ARM',
+ 'Broadcom',
+ 'Google',
+ 'ImgTec',
+ 'Intel',
+ 'Kazan',
+ 'NVIDIA',
+ 'Qualcomm',
+ 'VeriSilicon',
+ 'Vivante',
+ 'VMWare',
+ 'Apple',
+ 'Unknown'
+ ]
+ const angle = {
+ vendorId: (/^ANGLE \(([^,]+),/.exec(x)||[])[1] || knownVendors.find(vendor => x.includes(vendor)),
+ deviceId: (
+ (x.match(/,/g)||[]).length == 2 ? (/^ANGLE \(([^,]+), ([^,]+)[,|\)]/.exec(x)||[])[2] :
+ (/^ANGLE \(([^,]+), ([^,]+)[,|\)]/.exec(x)||[])[1] || (/^ANGLE \((.+)\)$/.exec(x)||[])[1]
+ ).replace(/\sDirect3D.+/, '')
+ }
+ */
+ const gibbers = gibberish(x, { strict: true }).join(', ');
+ const valid = (hasKnownParts && !hasBlankSpaceNoise && !hasBrokenAngleStructure);
+ const confidence = (valid && !gibbers.length ? 'high' :
+ valid && gibbers.length ? 'moderate' :
+ 'low');
+ const grade = (confidence == 'high' ? 'A' :
+ confidence == 'moderate' ? 'C' :
+ 'F');
+ const warnings = new Set([
+ (hasBlankSpaceNoise ? 'found extra spaces' : undefined),
+ (hasBrokenAngleStructure ? 'broken angle structure' : undefined),
+ ]);
+ warnings.delete(undefined);
+ return {
+ parts,
+ warnings: [...warnings],
+ gibbers,
+ confidence,
+ grade,
+ };
+ };
+ // Collect trash values
+ const createTrashBin = () => {
+ const bin = [];
+ return {
+ getBin: () => bin,
+ sendToTrash: (name, val, response = undefined) => {
+ const proxyLike = proxyBehavior(val);
+ const value = !proxyLike ? val : 'proxy behavior detected';
+ bin.push({ name, value });
+ return response;
+ },
+ };
+ };
+ const trashBin = createTrashBin();
+ const { sendToTrash } = trashBin;
+ const getTrash = () => ({ trashBin: trashBin.getBin() });
+
+ function isFontOSBad(userAgentOS, fonts) {
+ if (!userAgentOS || !fonts || !fonts.length)
+ return false;
+ const fontMap = fonts.reduce((acc, x) => {
+ acc[x] = true;
+ return acc;
+ }, {});
+ const isLikeWindows = ('Cambria Math' in fontMap ||
+ 'Nirmala UI' in fontMap ||
+ 'Leelawadee UI' in fontMap ||
+ 'HoloLens MDL2 Assets' in fontMap ||
+ 'Segoe Fluent Icons' in fontMap);
+ const isLikeApple = ('Helvetica Neue' in fontMap ||
+ 'Luminari' in fontMap ||
+ 'PingFang HK Light' in fontMap ||
+ 'InaiMathi Bold' in fontMap ||
+ 'Galvji' in fontMap ||
+ 'Chakra Petch' in fontMap);
+ const isLikeLinux = ('Arimo' in fontMap ||
+ 'MONO' in fontMap ||
+ 'Ubuntu' in fontMap ||
+ 'Noto Color Emoji' in fontMap ||
+ 'Dancing Script' in fontMap ||
+ 'Droid Sans Mono' in fontMap);
+ if (isLikeWindows && userAgentOS != "Windows" /* PlatformClassifier.WINDOWS */) {
+ return true;
+ }
+ else if (isLikeApple && userAgentOS != "Apple" /* PlatformClassifier.APPLE */) {
+ return true;
+ }
+ else if (isLikeLinux && userAgentOS != "Linux" /* PlatformClassifier.LINUX */) {
+ return true;
+ }
+ return false;
+ }
+
+ let WORKER_TYPE = '';
+ let WORKER_NAME = '';
+ async function spawnWorker() {
+ const ask = (fn) => {
+ try {
+ return fn();
+ }
+ catch (e) {
+ return;
+ }
+ };
+ function getWorkerPrototypeLies(scope) {
+ const lieDetector = createLieDetector(scope);
+ const { searchLies, } = lieDetector;
+ searchLies(() => Function, {
+ target: [
+ 'toString',
+ ],
+ ignore: [
+ 'caller',
+ 'arguments',
+ ],
+ });
+ // @ts-expect-error
+ searchLies(() => WorkerNavigator, {
+ target: [
+ 'deviceMemory',
+ 'hardwareConcurrency',
+ 'language',
+ 'languages',
+ 'platform',
+ 'userAgent',
+ ],
+ });
+ // return lies list and detail
+ const props = lieDetector.getProps();
+ const propsSearched = lieDetector.getPropsSearched();
+ return {
+ lieDetector,
+ lieList: Object.keys(props).sort(),
+ lieDetail: props,
+ lieCount: Object.keys(props).reduce((acc, key) => acc + props[key].length, 0),
+ propsSearched,
+ };
+ }
+ const getUserAgentData = async (navigator) => {
+ if (!('userAgentData' in navigator)) {
+ return;
+ }
+ const data = await navigator.userAgentData.getHighEntropyValues(['platform', 'platformVersion', 'architecture', 'bitness', 'model', 'uaFullVersion']);
+ const { brands, mobile } = navigator.userAgentData || {};
+ const compressedBrands = (brands, captureVersion = false) => brands
+ .filter((obj) => !/Not/.test(obj.brand)).map((obj) => `${obj.brand}${captureVersion ? ` ${obj.version}` : ''}`);
+ const removeChromium = (brands) => (brands.length > 1 ? brands.filter((brand) => !/Chromium/.test(brand)) : brands);
+ // compress brands
+ if (!data.brands) {
+ data.brands = brands;
+ }
+ data.brandsVersion = compressedBrands(data.brands, true);
+ data.brands = compressedBrands(data.brands);
+ data.brandsVersion = removeChromium(data.brandsVersion);
+ data.brands = removeChromium(data.brands);
+ if (!data.mobile) {
+ data.mobile = mobile;
+ }
+ const dataSorted = Object.keys(data).sort().reduce((acc, key) => {
+ acc[key] = data[key];
+ return acc;
+ }, {});
+ return dataSorted;
+ };
+ const getWebglData = () => ask(() => {
+ // @ts-ignore
+ const canvasOffscreenWebgl = new OffscreenCanvas(256, 256);
+ const contextWebgl = canvasOffscreenWebgl.getContext('webgl');
+ const rendererInfo = contextWebgl.getExtension('WEBGL_debug_renderer_info');
+ return {
+ webglVendor: contextWebgl.getParameter(rendererInfo.UNMASKED_VENDOR_WEBGL),
+ webglRenderer: contextWebgl.getParameter(rendererInfo.UNMASKED_RENDERER_WEBGL),
+ };
+ });
+ const computeTimezoneOffset = () => {
+ const date = new Date().getDate();
+ const month = new Date().getMonth();
+ // @ts-ignore
+ const year = Date().split ` `[3]; // current year
+ const format = (n) => ('' + n).length == 1 ? `0${n}` : n;
+ const dateString = `${month + 1}/${format(date)}/${year}`;
+ const dateStringUTC = `${year}-${format(month + 1)}-${format(date)}`;
+ // @ts-ignore
+ const utc = Date.parse(new Date(dateString));
+ const now = +new Date(dateStringUTC);
+ return +(((utc - now) / 60000).toFixed(0));
+ };
+ const getLocale = () => {
+ const constructors = [
+ 'Collator',
+ 'DateTimeFormat',
+ 'DisplayNames',
+ 'ListFormat',
+ 'NumberFormat',
+ 'PluralRules',
+ 'RelativeTimeFormat',
+ ];
+ // @ts-ignore
+ const locale = constructors.reduce((acc, name) => {
+ try {
+ const obj = new Intl[name];
+ if (!obj) {
+ return acc;
+ }
+ const { locale } = obj.resolvedOptions() || {};
+ return [...acc, locale];
+ }
+ catch (error) {
+ return acc;
+ }
+ }, []);
+ return [...new Set(locale)];
+ };
+ const getWorkerData = async () => {
+ const timer = createTimer();
+ await queueEvent(timer);
+ const userAgentData = await getUserAgentData(navigator).catch((error) => console.error(error));
+ // webgl
+ const { webglVendor, webglRenderer } = getWebglData() || {};
+ // timezone & locale
+ const timezoneOffset = computeTimezoneOffset();
+ // eslint-disable-next-line new-cap
+ const timezoneLocation = Intl.DateTimeFormat().resolvedOptions().timeZone;
+ const locale = getLocale();
+ // navigator
+ const { hardwareConcurrency, language, languages, platform, userAgent,
+ // @ts-expect-error
+ deviceMemory, } = navigator || {};
+ // prototype lies
+ await queueEvent(timer);
+ const {
+ // lieDetector: lieProps,
+ lieList, lieDetail,
+ // lieCount,
+ // propsSearched,
+ } = getWorkerPrototypeLies(self); // execute and destructure the list and detail
+ // const prototypeLies = JSON.parse(JSON.stringify(lieDetail))
+ const protoLieLen = lieList.length;
+ // match engine locale to system locale to determine if locale entropy is trusty
+ let systemCurrencyLocale;
+ const lang = ('' + language).split(',')[0];
+ try {
+ systemCurrencyLocale = (1).toLocaleString((lang || undefined), {
+ style: 'currency',
+ currency: 'USD',
+ currencyDisplay: 'name',
+ minimumFractionDigits: 0,
+ maximumFractionDigits: 0,
+ });
+ }
+ catch (e) { }
+ const engineCurrencyLocale = (1).toLocaleString(undefined, {
+ style: 'currency',
+ currency: 'USD',
+ currencyDisplay: 'name',
+ minimumFractionDigits: 0,
+ maximumFractionDigits: 0,
+ });
+ const localeEntropyIsTrusty = engineCurrencyLocale == systemCurrencyLocale;
+ const localeIntlEntropyIsTrusty = new Set(('' + language).split(',')).has('' + locale);
+ const { href, pathname } = self.location || {};
+ const locationPathNameLie = (!href ||
+ !pathname ||
+ !/^\/(docs|creepjs|public)|\/creep.js$/.test(pathname) ||
+ !new RegExp(`${pathname}$`).test(href));
+ return {
+ lied: protoLieLen || +locationPathNameLie,
+ lies: {
+ proto: protoLieLen ? lieDetail : false,
+ },
+ locale: '' + locale,
+ systemCurrencyLocale,
+ engineCurrencyLocale,
+ localeEntropyIsTrusty,
+ localeIntlEntropyIsTrusty,
+ timezoneOffset,
+ timezoneLocation,
+ deviceMemory,
+ hardwareConcurrency,
+ language,
+ languages: '' + languages,
+ platform,
+ userAgent,
+ webglRenderer,
+ webglVendor,
+ userAgentData,
+ };
+ };
+ // Compute and communicate from worker scope
+ const onEvent = (eventType, fn) => addEventListener(eventType, fn);
+ const send = (source) => {
+ return getWorkerData().then((data) => source.postMessage(data));
+ };
+ if (IS_WORKER_SCOPE) {
+ globalThis.ServiceWorkerGlobalScope ? onEvent('message', (e) => send(e.source)) :
+ globalThis.SharedWorkerGlobalScope ? onEvent('connect', (e) => send(e.ports[0])) :
+ send(self); // DedicatedWorkerGlobalScope
+ }
+ return IS_WORKER_SCOPE ? 0 /* Scope.WORKER */ : 1 /* Scope.WINDOW */;
+ }
+ async function getBestWorkerScope() {
+ try {
+ const timer = createTimer();
+ await queueEvent(timer);
+ const ask = (fn) => {
+ try {
+ return fn();
+ }
+ catch (e) {
+ return;
+ }
+ };
+ const hasConstructor = (x, name) => x && x.__proto__.constructor.name == name;
+ const getDedicatedWorker = ({ scriptSource }) => new Promise((resolve) => {
+ const giveUpOnWorker = setTimeout(() => {
+ return resolve(null);
+ }, 3000);
+ const dedicatedWorker = ask(() => new Worker(scriptSource));
+ if (!hasConstructor(dedicatedWorker, 'Worker'))
+ return resolve(null);
+ dedicatedWorker.onmessage = (event) => {
+ dedicatedWorker.terminate();
+ clearTimeout(giveUpOnWorker);
+ return resolve(event.data);
+ };
+ });
+ const getSharedWorker = ({ scriptSource }) => new Promise((resolve) => {
+ const giveUpOnWorker = setTimeout(() => {
+ return resolve(null);
+ }, 3000);
+ const sharedWorker = ask(() => new SharedWorker(scriptSource));
+ if (!hasConstructor(sharedWorker, 'SharedWorker'))
+ return resolve(null);
+ sharedWorker.port.start();
+ sharedWorker.port.onmessage = (event) => {
+ sharedWorker.port.close();
+ clearTimeout(giveUpOnWorker);
+ return resolve(event.data);
+ };
+ });
+ const getServiceWorker = ({ scriptSource }) => new Promise((resolve) => {
+ const giveUpOnWorker = setTimeout(() => {
+ return resolve(null);
+ }, 4000);
+ if (!ask(() => navigator.serviceWorker.register))
+ return resolve(null);
+ return navigator.serviceWorker.register(scriptSource).then((registration) => {
+ if (!hasConstructor(registration, 'ServiceWorkerRegistration'))
+ return resolve(null);
+ return navigator.serviceWorker.ready.then((registration) => {
+ // @ts-ignore
+ registration.active.postMessage(undefined);
+ navigator.serviceWorker.onmessage = (event) => {
+ registration.unregister();
+ clearTimeout(giveUpOnWorker);
+ return resolve(event.data);
+ };
+ });
+ }).catch((error) => {
+ console.error(error);
+ clearTimeout(giveUpOnWorker);
+ return resolve(null);
+ });
+ });
+ const scriptSource = './creep.js';
+ WORKER_NAME = 'ServiceWorkerGlobalScope';
+ WORKER_TYPE = 'service'; // loads fast but is not available in frames
+ let workerScope = await getServiceWorker({ scriptSource }).catch((error) => {
+ captureError(error);
+ console.error(error.message);
+ return;
+ });
+ if (!(workerScope || {}).userAgent) {
+ WORKER_NAME = 'SharedWorkerGlobalScope';
+ WORKER_TYPE = 'shared'; // no support in Safari, iOS, and Chrome Android
+ workerScope = await getSharedWorker({ scriptSource }).catch((error) => {
+ captureError(error);
+ console.error(error.message);
+ return;
+ });
+ }
+ if (!(workerScope || {}).userAgent) {
+ WORKER_NAME = 'DedicatedWorkerGlobalScope';
+ WORKER_TYPE = 'dedicated'; // device emulators can easily spoof dedicated scope
+ workerScope = await getDedicatedWorker({ scriptSource }).catch((error) => {
+ captureError(error);
+ console.error(error.message);
+ return;
+ });
+ }
+ if (!(workerScope || {}).userAgent) {
+ return;
+ }
+ workerScope.system = getOS(workerScope.userAgent);
+ workerScope.device = getUserAgentPlatform({ userAgent: workerScope.userAgent });
+ // detect lies
+ const { system, userAgent, userAgentData, platform, deviceMemory, hardwareConcurrency, } = workerScope || {};
+ // navigator lies
+ // skip language and languages to respect valid engine language switching bug in Chrome
+ // these are more likely navigator lies, so don't trigger lied worker scope
+ const workerScopeMatchLie = 'does not match worker scope';
+ if (platform != navigator.platform) {
+ documentLie('Navigator.platform', workerScopeMatchLie);
+ }
+ if (userAgent != navigator.userAgent) {
+ documentLie('Navigator.userAgent', workerScopeMatchLie);
+ }
+ if (hardwareConcurrency && (hardwareConcurrency != navigator.hardwareConcurrency)) {
+ documentLie('Navigator.hardwareConcurrency', workerScopeMatchLie);
+ }
+ // @ts-ignore
+ if (deviceMemory && (deviceMemory != navigator.deviceMemory)) {
+ documentLie('Navigator.deviceMemory', workerScopeMatchLie);
+ }
+ // prototype lies
+ if (workerScope.lies.proto) {
+ const { proto } = workerScope.lies;
+ const keys = Object.keys(proto);
+ keys.forEach((key) => {
+ const api = `WorkerGlobalScope.${key}`;
+ const lies = proto[key];
+ lies.forEach((lie) => documentLie(api, lie));
+ });
+ }
+ // user agent os lie
+ const [userAgentOS, platformOS] = getReportedPlatform(userAgent, platform);
+ if (userAgentOS != platformOS) {
+ workerScope.lied = true;
+ workerScope.lies.os = `${platformOS} platform and ${userAgentOS} user agent do not match`;
+ documentLie('WorkerGlobalScope', workerScope.lies.os);
+ }
+ // user agent engine lie
+ const decryptedName = decryptUserAgent({
+ ua: userAgent,
+ os: system,
+ isBrave: false, // default false since we are only looking for JS runtime and version
+ });
+ const userAgentEngine = ((/safari/i.test(decryptedName) || /iphone|ipad/i.test(userAgent)) ? 'JavaScriptCore' :
+ /firefox/i.test(userAgent) ? 'SpiderMonkey' :
+ /chrome/i.test(userAgent) ? 'V8' :
+ undefined);
+ if (userAgentEngine != JS_ENGINE) {
+ workerScope.lied = true;
+ workerScope.lies.engine = `${JS_ENGINE} JS runtime and ${userAgentEngine} user agent do not match`;
+ documentLie('WorkerGlobalScope', workerScope.lies.engine);
+ }
+ // user agent version lie
+ const getVersion = (x) => (/\d+/.exec(x) || [])[0];
+ const userAgentVersion = getVersion(decryptedName);
+ const userAgentDataVersion = getVersion(userAgentData ? userAgentData.uaFullVersion : '');
+ const versionSupported = userAgentDataVersion && userAgentVersion;
+ const versionMatch = userAgentDataVersion == userAgentVersion;
+ if (versionSupported && !versionMatch) {
+ workerScope.lied = true;
+ workerScope.lies.version = `userAgentData version ${userAgentDataVersion} and user agent version ${userAgentVersion} do not match`;
+ documentLie('WorkerGlobalScope', workerScope.lies.version);
+ }
+ // platformVersion lie
+ const FEATURE_CASE = IS_BLINK && CSS.supports('accent-color: initial');
+ const getPlatformVersionLie = (device, userAgentData) => {
+ if (!/windows|mac/i.test(device) || !userAgentData?.platformVersion) {
+ return false;
+ }
+ if (userAgentData.platform == 'macOS') {
+ return FEATURE_CASE ? /_/.test(userAgentData.platformVersion) : false;
+ }
+ const reportedVersionNumber = (/windows ([\d|\.]+)/i.exec(device) || [])[1];
+ const windows10OrHigherReport = +reportedVersionNumber == 10;
+ const { platformVersion } = userAgentData;
+ const versionMap = {
+ '6.1': '7',
+ '6.2': '8',
+ '6.3': '8.1',
+ '10.0': '10',
+ };
+ const version = versionMap[platformVersion];
+ if (!FEATURE_CASE && version) {
+ return version != reportedVersionNumber;
+ }
+ const parts = platformVersion.split('.');
+ if (parts.length != 3)
+ return true;
+ const windows10OrHigherPlatform = +parts[0] > 0;
+ return ((windows10OrHigherPlatform && !windows10OrHigherReport) ||
+ (!windows10OrHigherPlatform && windows10OrHigherReport));
+ };
+ const windowsVersionLie = getPlatformVersionLie(workerScope.device, userAgentData);
+ if (windowsVersionLie) {
+ workerScope.lied = true;
+ workerScope.lies.platformVersion = `platform version is fake`;
+ documentLie('WorkerGlobalScope', workerScope.lies.platformVersion);
+ }
+ // capture userAgent version
+ workerScope.userAgentVersion = userAgentVersion;
+ workerScope.userAgentDataVersion = userAgentDataVersion;
+ workerScope.userAgentEngine = userAgentEngine;
+ const gpu = {
+ ...(getWebGLRendererConfidence(workerScope.webglRenderer) || {}),
+ compressedGPU: compressWebGLRenderer(workerScope.webglRenderer),
+ };
+ logTestResult({ time: timer.stop(), test: `${WORKER_TYPE} worker`, passed: true });
+ return {
+ ...workerScope,
+ gpu,
+ uaPostReduction: isUAPostReduction(workerScope.userAgent),
+ };
+ }
+ catch (error) {
+ logTestResult({ test: 'worker', passed: false });
+ captureError(error, 'workers failed or blocked by client');
+ return;
+ }
+ }
+ function workerScopeHTML(fp) {
+ if (!fp.workerScope) {
+ return `
+
+
Worker
+
lang/timezone:
+
${HTMLNote.BLOCKED}
+
gpu:
+
${HTMLNote.BLOCKED}
+
+
userAgent:
+
${HTMLNote.BLOCKED}
+
device:
+
${HTMLNote.BLOCKED}
+
userAgentData:
+
${HTMLNote.BLOCKED}
+
${performanceLogger.getLog()[`${WORKER_TYPE} worker`]}
+ ${WORKER_NAME || ''}
+
+
+
+
Worker ${hashSlice($hash)}
+
lang/timezone:
+
+ ${localeEntropyIsTrusty ? `${language} (${systemCurrencyLocale})` :
+ `${language} (${engineCurrencyLocale} )`}
+ ${locale === language ? '' : localeIntlEntropyIsTrusty ? ` ${locale}` :
+ ` ${locale} `}
+
+
+
${confidence ? `confidence: ${confidence} ` : ''}gpu:
+
+ ${webglVendor ? webglVendor : ''}
+ ${webglRenderer ? `
+
+
+
+
userAgent:${!uaPostReduction ? '' : `ua reduction `}
+
+
${userAgent || HTMLNote.UNSUPPORTED}
+
+
+
device:
+
+ ${`${system}${platform ? ` (${platform})` : ''}`}
+ ${device ? `
+
+
userAgentData:
+
+
+ ${((userAgentData) => {
+ const { architecture, bitness, brandsVersion, uaFullVersion, mobile, model, platformVersion, platform, } = userAgentData || {};
+ // @ts-ignore
+ const windowsRelease = computeWindowsRelease({ platform, platformVersion });
+ return !userAgentData ? HTMLNote.UNSUPPORTED : `
+ ${(brandsVersion || []).join(',')}${uaFullVersion ? ` (${uaFullVersion})` : ''}
+
+
+
+
+
Audio
+
sum: ${HTMLNote.BLOCKED}
+
gain: ${HTMLNote.BLOCKED}
+
freq: ${HTMLNote.BLOCKED}
+
time: ${HTMLNote.BLOCKED}
+
trap: ${HTMLNote.BLOCKED}
+
unique: ${HTMLNote.BLOCKED}
+
data: ${HTMLNote.BLOCKED}
+
copy: ${HTMLNote.BLOCKED}
+
values: ${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog().audio}
+
Audio ${hashSlice($hash)}
+
sum: ${!sampleSum ? HTMLNote.BLOCKED : (!validAudio || matchesKnownAudio) ? sampleSum : getDiffs({
+ stringA: knownSums[0],
+ stringB: sampleSum,
+ charDiff: true,
+ decorate: (diff) => `${diff} `,
+ })}
+
gain: ${compressorGainReduction || HTMLNote.BLOCKED}
+
freq: ${floatFrequencyDataSum || HTMLNote.BLOCKED}
+
time: ${floatTimeDomainDataSum || HTMLNote.UNSUPPORTED}
+
trap: ${!noise ? AUDIO_TRAP : getDiffs({
+ stringA: AUDIO_TRAP,
+ stringB: noise,
+ charDiff: true,
+ decorate: (diff) => `${diff} `,
+ })}
+
unique: ${totalUniqueSamples}
+
data:${'' + binsSample[0] == 'undefined' ? ` ${HTMLNote.BLOCKED}` :
+ `${hashMini(binsSample)} `}
+
copy:${'' + copySample[0] == 'undefined' ? ` ${HTMLNote.BLOCKED}` :
+ `${hashMini(copySample)} `}
+
values: ${modal('creep-offline-audio-context', Object.keys(values).map((key) => `
${key}: ${values[key]}
`).join(''), hashMini(values))}
+
+
Canvas 2d ${HTMLNote.BLOCKED}
+
data: ${HTMLNote.BLOCKED}
+
rendering:
+
${HTMLNote.BLOCKED}
+
${HTMLNote.BLOCKED}
+
textMetrics:
+
${HTMLNote.BLOCKED}
+
` : ''}
+
` : ''}
+
` : ''}
+
` : ''}
+
` : ''}
+
+
+
${performanceLogger.getLog()['canvas 2d']}
+
Canvas 2d ${hashSlice($hash)}
+
data: ${modal('creep-canvas-data', dataTemplate, hashMini({
+ dataURI,
+ pixelImage,
+ paintURI,
+ paintCpuURI,
+ textURI,
+ emojiURI,
+ }))}
+
rendering: ${rgba ? `${modPercent}% rgba noise ${rgbaHTML}` : ''}
+
+ ${textURI ? `
` : ''}
+ ${emojiURI ? `
` : ''}
+ ${paintCpuURI ? `
` : ''}
+ ${dataURI ? `
` : ''}
+
+
+
textMetrics:
+
+ ${textMetricsSystemSum || HTMLNote.UNSUPPORTED}
+
+ ${formatEmojiSet(emojiSet)}
+
+
+
+
Computed Style
+
keys (0): ${HTMLNote.BLOCKED}
+
system styles: ${HTMLNote.BLOCKED}
+
+
+
${performanceLogger.getLog()['computed style']}
+
Computed Style ${hashSlice($hash)}
+
keys (${!computedStyle ? '0' : count(computedStyle.keys)}): ${!computedStyle ? HTMLNote.BLOCKED :
+ modal('creep-computed-style', computedStyle.keys.join(', '), hashMini(computedStyle))}
+
system styles: ${system && system.colors ? modal(`${id}-system-styles`, [
+ ...system.colors.map((color) => {
+ const key = Object.keys(color)[0];
+ const val = color[key];
+ return `
+
+ `;
+ }),
+ ...system.fonts.map((font) => {
+ const key = Object.keys(font)[0];
+ const val = font[key];
+ return `
+
${key}: ${val}
+ `;
+ }),
+ ].join(''), hashMini(system)) : HTMLNote.BLOCKED}
+
+
+
+
CSS Media Queries
+
@media: ${HTMLNote.BLOCKED}
+
matchMedia: ${HTMLNote.BLOCKED}
+
touch device: ${HTMLNote.BLOCKED}
+
screen query: ${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog()['css media']}
+
CSS Media Queries ${hashSlice($hash)}
+
@media: ${!mediaCSS || !Object.keys(mediaCSS).filter((key) => !!mediaCSS[key]).length ?
+ HTMLNote.BLOCKED :
+ modal('creep-css-media', `@media
+
matchMedia: ${!matchMediaCSS || !Object.keys(matchMediaCSS).filter((key) => !!matchMediaCSS[key]).length ?
+ HTMLNote.BLOCKED :
+ modal('creep-css-match-media', `matchMedia
+
touch device: ${!mediaCSS ? HTMLNote.BLOCKED : mediaCSS['any-pointer'] == 'coarse' ? true : HTMLNote.UNKNOWN}
+
screen query:
+ ${!screenQuery ? HTMLNote.BLOCKED : `${screenQuery.width} x ${screenQuery.height}`}
+
+
+
HTMLElement
+
keys (0): ${HTMLNote.Blocked}
+
+
${performanceLogger.getLog()['html element']}
+
HTMLElement ${hashSlice($hash)}
+
keys (${count(keys)}): ${keys && keys.length ? modal('creep-html-element-version', keys.join(', ')) : HTMLNote.Blocked}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ${EMOJIS.map((emoji) => {
+ return `
${emoji}
`;
+ }).join('')}
+
+
+
DOMRect
+
elems A: ${HTMLNote.BLOCKED}
+
elems B: ${HTMLNote.BLOCKED}
+
range A: ${HTMLNote.BLOCKED}
+
range B: ${HTMLNote.BLOCKED}
+
${HTMLNote.BLOCKED}
+
${diff} `,
+ });
+ };
+ const helpTitle = `Element.getClientRects()\nhash: ${hashMini(emojiSet)}\n${emojiSet.map((x, i) => i && (i % 6 == 0) ? `${x}\n` : x).join('')}`;
+ return `
+
+
${performanceLogger.getLog().rects}
+
DOMRect ${hashSlice($hash)}
+
elems A: ${computeDiffs(elementClientRects)}
+
elems B: ${computeDiffs(elementBoundingClientRect)}
+
range A: ${computeDiffs(rangeClientRects)}
+
range B: ${computeDiffs(rangeBoundingClientRect)}
+
+ ${domrectSystemSum || HTMLNote.UNSUPPORTED}
+ ${formatEmojiSet(emojiSet)}
+
+
+
Error
+
results: ${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog()['console errors']}
+
Error ${hashSlice($hash)}
+
results: ${modal('creep-console-errors', results.join('
+
+
Features: ${HTMLNote.UNKNOWN}
+
JS/DOM: ${HTMLNote.UNKNOWN}
+
+
CSS: ${HTMLNote.UNKNOWN}
+
Window: ${HTMLNote.UNKNOWN}
+
diffs from ${version} :
+
+ ${diff && diff.added.length ?
+ diff.added.map((key) => `
${key}
`).join('') : ''}
+ ${diff && diff.removed.length ?
+ diff.removed.map((key) => `
${key}
`).join('') : ''}
+
${key} :${prop} `;
+ }).join('${performanceLogger.getLog().features}
+
+
Features: ${versionRange.length ? `${browserIcon}${version}+` : HTMLNote.UNKNOWN}
+
JS/DOM: ${jsVersion ? `${jsModal} (v${jsVersion})` : HTMLNote.UNKNOWN}
+
+
CSS: ${cssVersion ? `${cssModal} (v${cssVersion})` : HTMLNote.UNKNOWN}
+
Window: ${windowVersion ? `${windowModal} (v${windowVersion})` : HTMLNote.UNKNOWN}
+
+
+ ${emojis.map((emoji) => {
+ return `
${emoji}
`;
+ }).join('')}
+
+
Fonts
+
load (0):
+
apps:${HTMLNote.BLOCKED}
+
${HTMLNote.BLOCKED}
+
${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog().fonts}
+
Fonts ${hashSlice($hash)}
+
load (${fontFaceLoadFonts ? count(fontFaceLoadFonts) : '0'}/${'' + FONT_LIST.length}): ${`Like ${platformVersion}` || ((fonts) => {
+ return !(fonts || []).length ? '' : ((('' + fonts).match(/Lucida Console/) || []).length ? `${icon.Windows}Like Windows` :
+ (('' + fonts).match(/Droid Sans Mono|Noto Color Emoji|Roboto/g) || []).length == 3 ? `${icon.Linux}${icon.Android}Like Linux Android` :
+ (('' + fonts).match(/Droid Sans Mono|Roboto/g) || []).length == 2 ? `${icon.Android}Like Android` :
+ (('' + fonts).match(/Noto Color Emoji|Roboto/g) || []).length == 2 ? `${icon.CrOS}Like Chrome OS` :
+ (('' + fonts).match(/Noto Color Emoji/) || []).length ? `${icon.Linux}Like Linux` :
+ (('' + fonts).match(/Arimo/) || []).length ? `${icon.Linux}Like Linux` :
+ (('' + fonts).match(/Helvetica Neue/g) || []).length == 2 ? `${icon.Apple}Like Apple` :
+ `${(fonts || [])[0]}...`);
+ })(fontFaceLoadFonts)}
+
apps: ${(apps || []).length ? apps.join(', ') : HTMLNote.UNSUPPORTED}
+
+ ${fontFaceLoadFonts.join(', ') || HTMLNote.UNSUPPORTED}
+
+
+
+ ${pixelSizeSystemSum || HTMLNote.UNSUPPORTED}
+ ${formatEmojiSet(emojiSet)}
+
+
+
+
Headless
+
chromium: ${HTMLNote.BLOCKED}
+
0% like headless: ${HTMLNote.BLOCKED}
+
0% headless: ${HTMLNote.BLOCKED}
+
0% stealth: ${HTMLNote.BLOCKED}
+
platform hints:
+
${HTMLNote.BLOCKED}
+
${IconMap[key]} `;
+ }).join('')}
+ `;
+ return `
+
+
+
${performanceLogger.getLog().headless}
+
Headless ${hashSlice($hash)}
+
chromium: ${'' + chromium}
+
${'' + likeHeadlessRating}% like headless: ${modal('creep-like-headless', 'Like Headless
+
${'' + headlessRating}% headless: ${modal('creep-headless', 'Headless
+
${'' + stealthRating}% stealth: ${modal('creep-stealth', 'Stealth
+
platform hints:
+
+ ${systemFonts ? `
${systemFonts}
` : ''}
+ ${platformTemplate ? `
${platformTemplate}
` : ''}
+
+
+
Intl
+
locale: ${HTMLNote.Blocked}
+
date: ${HTMLNote.Blocked}
+
display: ${HTMLNote.Blocked}
+
list: ${HTMLNote.Blocked}
+
number: ${HTMLNote.Blocked}
+
plural: ${HTMLNote.Blocked}
+
relative: ${HTMLNote.Blocked}
+
+
${performanceLogger.getLog().intl}
+
Intl ${hashSlice($hash)}
+
+ ${[
+ locale,
+ dateTimeFormat,
+ displayNames,
+ numberFormat,
+ relativeTimeFormat,
+ listFormat,
+ pluralRules,
+ ].join('
+
+
Math
+
results: ${HTMLNote.Blocked}
+
+
+
+ C - Chromium
+ F - Firefox
+ T - Tor Browser
+ S - Safari
+
`;
+ const results = Object.keys(data).map((key) => {
+ const value = data[key];
+ const { chrome, firefox, torBrowser, safari } = value;
+ return `
+ ${chrome ? 'C ' : '- '}${firefox ? 'F ' : '- '}${torBrowser ? 'T ' : '- '}${safari ? 'S ' : '- '} ${key}`;
+ });
+ return `
+
+
${performanceLogger.getLog().math}
+
Math ${hashSlice($hash)}
+
results: ${!data ? HTMLNote.Blocked :
+ modal('creep-maths', header + results.join('
+
+
Media
+
mimes (0): ${HTMLNote.BLOCKED}
+
+ audioPlayType
+ videoPlayType
+ mediaSource
+ mediaRecorder
+ P (Probably)
+ M (Maybe)
+ T (True)
+
+ `;
+ const invalidMimeTypes = !mimeTypes || !mimeTypes.length;
+ const mimes = invalidMimeTypes ? undefined : mimeTypes.map((type) => {
+ const { mimeType, audioPlayType, videoPlayType, mediaSource, mediaRecorder } = type;
+ return `
+ ${audioPlayType == 'probably' ? 'P ' : audioPlayType == 'maybe' ? 'M ' : '- '}${videoPlayType == 'probably' ? 'P ' : videoPlayType == 'maybe' ? 'M ' : '- '}${mediaSource ? 'T ' : '- '}${mediaRecorder ? 'T ' : '- '}: ${mimeType}
+ `;
+ });
+ const mimesListLen = getMimeTypeShortList().length;
+ return `
+
+
${performanceLogger.getLog().media}
+
Media ${hashSlice($hash)}
+
mimes (${count(mimeTypes)}/${mimesListLen}): ${invalidMimeTypes ? HTMLNote.BLOCKED :
+ modal('creep-media-mimeTypes', header + mimes.join('
+
+
Navigator
+
properties (0): ${HTMLNote.BLOCKED}
+
dnt: ${HTMLNote.BLOCKED}
+
gpc:${HTMLNote.BLOCKED}
+
lang: ${HTMLNote.BLOCKED}
+
mimeTypes (0): ${HTMLNote.BLOCKED}
+
permissions (0): ${HTMLNote.BLOCKED}
+
plugins (0): ${HTMLNote.BLOCKED}
+
vendor: ${HTMLNote.BLOCKED}
+
webgpu: ${HTMLNote.BLOCKED}
+
userAgentData:
+
${HTMLNote.BLOCKED}
+
+
device:
+
${HTMLNote.BLOCKED}
+
ua parsed: ${HTMLNote.BLOCKED}
+
userAgent:
+
${HTMLNote.BLOCKED}
+
appVersion:
+
${HTMLNote.BLOCKED}
+
${performanceLogger.getLog().navigator}
+
+
Navigator ${hashSlice($hash)}
+
properties (${count(properties)}): ${modal(`${id}-properties`, properties.join(', '), hashMini(properties))}
+
dnt: ${'' + doNotTrack}
+
gpc: ${'' + globalPrivacyControl == 'undefined' ? HTMLNote.UNSUPPORTED : '' + globalPrivacyControl}
+
lang: ${!blocked[language] ? language : HTMLNote.BLOCKED}
+
mimeTypes (${count(mimeTypes)}): ${!blocked['' + mimeTypes] ?
+ modal(`${id}-mimeTypes`, mimeTypes.join('
+
permissions (${'' + permissionsGranted}): ${!permissions || !permissionsKeys ? HTMLNote.UNSUPPORTED : modal('creep-permissions', permissionsKeys.map((key) => `
${key} :
`).join(''), hashMini(permissions))}
+
plugins (${count(plugins)}): ${!blocked['' + plugins] ?
+ modal(`${id}-plugins`, plugins.map((plugin) => plugin.name).join('
+
vendor: ${!blocked[vendor] ? vendor : HTMLNote.BLOCKED}
+
webgpu: ${!webgpu ? HTMLNote.UNSUPPORTED :
+ modal(`${id}-webgpu`, ((webgpu) => {
+ const { adapterInfo, limits } = webgpu;
+ return `
+
+ Adapter
+
+ Limits
+ `;
+ })(webgpu), hashMini(webgpu))}
+
userAgentData:
+
+
+ ${((userAgentData) => {
+ const { architecture, bitness, brandsVersion, uaFullVersion, mobile, model, platformVersion, platform, } = userAgentData || {};
+ // @ts-ignore
+ const windowsRelease = computeWindowsRelease({ platform, platformVersion });
+ return !userAgentData ? HTMLNote.UNSUPPORTED : `
+ ${(brandsVersion || []).join(',')}${uaFullVersion ? ` (${uaFullVersion})` : ''}
+
+
+
+
device:
+
+ ${oscpu ? oscpu : ''}
+ ${`${oscpu ? '
+
ua parsed: ${userAgentParsed || HTMLNote.BLOCKED}
+
userAgent:${!uaPostReduction ? '' : `ua reduction `}
+
+
${userAgent || HTMLNote.BLOCKED}
+
+
appVersion:
+
+
${appVersion || HTMLNote.BLOCKED}
+
+
+
Resistance
+
privacy: ${HTMLNote.BLOCKED}
+
security: ${HTMLNote.BLOCKED}
+
mode: ${HTMLNote.BLOCKED}
+
extension: ${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog().resistance}
+
Resistance ${hashSlice($hash)}
+
privacy: ${privacy ? `${browserIcon}${privacy}` : HTMLNote.UNKNOWN}
+
security: ${!security ? HTMLNote.UNKNOWN :
+ modal('creep-resistance', 'Security
+
mode: ${mode || HTMLNote.UNKNOWN}
+
extension: ${!Object.keys(extensionHashPattern || {}).length ? HTMLNote.UNKNOWN :
+ modal('creep-extension', 'Pattern
+
+
Screen
+
...screen: ${HTMLNote.BLOCKED}
+
....avail: ${HTMLNote.BLOCKED}
+
touch: ${HTMLNote.BLOCKED}
+
depth: ${HTMLNote.BLOCKED}
+
viewport: ${HTMLNote.BLOCKED}
+
+
+
${perf}
+
Screen ${hashSlice($hash)}
+
...screen: ${width} x ${height}
+
....avail: ${availWidth} x ${availHeight}
+
touch: ${touch}
+
depth: ${colorDepth}|${pixelDepth}
+
viewport:
+
+
+
${outerWidth}
+
${innerWidth}
+
${toFix(vVWidth, 6)}
+
${outerHeight}
+
${innerHeight}
+
${toFix(vVHeight, 6)}
+
${displayMode}
+
${mediaOrientation}
+
${orientationType}
+
${dpr}
+
+
+
+
Speech
+
local (0): ${HTMLNote.BLOCKED}
+
remote (0): ${HTMLNote.BLOCKED}
+
lang (0): ${HTMLNote.BLOCKED}
+
default:
+
${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog().speech}
+
Speech ${hashSlice($hash)}
+
local (${count(local)}): ${!local || !local.length ? HTMLNote.UNSUPPORTED :
+ modal('creep-voices-local', local.join('
+
remote (${count(remote)}): ${!remote || !remote.length ? HTMLNote.UNSUPPORTED :
+ modal('creep-voices-remote', remote.join('
+
lang (${count(languages)}): ${!languages || !languages.length ? HTMLNote.BLOCKED :
+ languages.length == 1 ? languages[0] : modal('creep-voices-languages', languages.join('
+
default:
+
+ ${!defaultVoiceName ? HTMLNote.UNSUPPORTED :
+ `${defaultVoiceName}${defaultVoiceLang ? ` [${defaultVoiceLang}]` : ''}`}
+
+
+
Status
+
network:
+
${HTMLNote.BLOCKED}
+
+
battery:
+
${HTMLNote.BLOCKED}
+
+
available:
+
${HTMLNote.BLOCKED}
+
+
Status ${statusHash}
+
network:
+
${isNaN(Number(rtt)) ? HTMLNote.UNSUPPORTED : `
+
rtt: ${rtt}, downlink: ${downlink}${downlinkMax ? `, max: ${downlinkMax}` : ''}
+
effectiveType: ${effectiveType}
+
saveData: ${saveData}${type ? `, type: ${type}` : ''}
+ `}
+
+
+
battery:
+
${!level || isNaN(Number(level)) ? HTMLNote.UNSUPPORTED : `
+
level: ${level * 100}%
+
charging: ${charging}
+
charge time: ${chargingTime === Infinity ? 'discharging' :
+ chargingTime === 0 ? 'fully charged' :
+ `${+(chargingTime / 60).toFixed(1)} min.`}
+
discharge time: ${dischargingTime === Infinity ? 'charging' :
+ `${+(dischargingTime / 60).toFixed(1)} min.`}
+ `}
+
+
available:
+
+ ${quota ? `
storage: ${quotaInGigabytes}GB
` : ''}
+ ${memory ? `
memory: ${memoryInGigabytes}GB
` : ''}
+ ${timingRes ? `
timing res:
` : ''}
+
stack: ${stackSize || HTMLNote.BLOCKED}
+
+
+
+
+
+ ${EMOJIS.map((emoji) => {
+ return `${emoji} `;
+ }).join('')}
+
+
+
+ `);
+ // SVG
+ const reduceToObject = (nativeObj) => {
+ const keys = Object.keys(nativeObj.__proto__);
+ return keys.reduce((acc, key) => {
+ const val = nativeObj[key];
+ const isMethod = typeof val == 'function';
+ return isMethod ? acc : { ...acc, [key]: val };
+ }, {});
+ };
+ const reduceToSum = (nativeObj) => {
+ const keys = Object.keys(nativeObj.__proto__);
+ return keys.reduce((acc, key) => {
+ const val = nativeObj[key];
+ return isNaN(val) ? acc : (acc += val);
+ }, 0);
+ };
+ const getObjectSum = (obj) => !obj ? 0 : Object.keys(obj).reduce((acc, key) => acc += Math.abs(obj[key]), 0);
+ // SVGRect
+ const svgBox = doc.getElementById('svgBox');
+ const bBox = reduceToObject(svgBox.getBBox());
+ // compute SVGRect emojis
+ const pattern = new Set();
+ const svgElems = [...svgBox.getElementsByClassName('svgrect-emoji')];
+ await queueEvent(timer);
+ const emojiSet = svgElems.reduce((emojiSet, el, i) => {
+ const emoji = EMOJIS[i];
+ const dimensions = '' + el.getComputedTextLength();
+ if (!pattern.has(dimensions)) {
+ pattern.add(dimensions);
+ emojiSet.add(emoji);
+ }
+ return emojiSet;
+ }, new Set());
+ // svgRect System Sum
+ const svgrectSystemSum = 0.00001 * [...pattern].map((x) => {
+ return x.split(',').reduce((acc, x) => acc += (+x || 0), 0);
+ }).reduce((acc, x) => acc += x, 0);
+ // detect failed shift calculation
+ const svgEmojiEl = svgElems[0];
+ const initial = svgEmojiEl.getComputedTextLength();
+ svgEmojiEl.classList.add('shift-svg');
+ const shifted = svgEmojiEl.getComputedTextLength();
+ svgEmojiEl.classList.remove('shift-svg');
+ const unshifted = svgEmojiEl.getComputedTextLength();
+ if ((initial - shifted) != (unshifted - shifted)) {
+ lied = true;
+ documentLie('SVGTextContentElement.getComputedTextLength', 'failed unshift calculation');
+ }
+ const data = {
+ bBox: getObjectSum(bBox),
+ extentOfChar: reduceToSum(svgElems[0].getExtentOfChar(EMOJIS[0])),
+ subStringLength: svgElems[0].getSubStringLength(0, 10),
+ computedTextLength: svgElems[0].getComputedTextLength(),
+ emojiSet: [...emojiSet],
+ svgrectSystemSum,
+ lied,
+ };
+ doc.body.removeChild(doc.getElementById('svg-container'));
+ logTestResult({ time: timer.stop(), test: 'svg', passed: true });
+ return data;
+ }
+ catch (error) {
+ logTestResult({ test: 'svg', passed: false });
+ captureError(error);
+ return;
+ }
+ }
+ function svgHTML(fp) {
+ if (!fp.svg) {
+ return `
+
+
SVGRect
+
bBox: ${HTMLNote.BLOCKED}
+
char: ${HTMLNote.BLOCKED}
+
subs: ${HTMLNote.BLOCKED}
+
text: ${HTMLNote.BLOCKED}
+
${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog().svg}
+
SVGRect ${hashSlice($hash)}
+
bBox: ${bBox ? (bBox / divisor) : HTMLNote.BLOCKED}
+
char: ${extentOfChar ? (extentOfChar / divisor) : HTMLNote.BLOCKED}
+
subs: ${subStringLength ? (subStringLength / divisor) : HTMLNote.BLOCKED}
+
text: ${computedTextLength ? (computedTextLength / divisor) : HTMLNote.BLOCKED}
+
+ ${svgrectSystemSum || HTMLNote.UNSUPPORTED}
+ ${formatEmojiSet(emojiSet)}
+
+
+
Timezone
+
${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog().timezone}
+
Timezone ${hashSlice($hash)}
+
+ ${zone ? zone : ''}
+
+
+
WebGL
+
images: ${HTMLNote.BLOCKED}
+
pixels: ${HTMLNote.BLOCKED}
+
params (0): ${HTMLNote.BLOCKED}
+
exts (0): ${HTMLNote.BLOCKED}
+
gpu:
+
${HTMLNote.BLOCKED}
+
+
+
${performanceLogger.getLog().webgl}
+
WebGL ${hashSlice($hash)}
+
images:${!dataURI ? ' ' + HTMLNote.BLOCKED : `${hashMini(dataURI)} ${!dataURI2 || dataURI == dataURI2 ? '' : `${hashMini(dataURI2)} `}`}
+
pixels:${!pixels ? ' ' + HTMLNote.BLOCKED : `${hashSlice(pixels)} ${!pixels2 || pixels == pixels2 ? '' : `${hashSlice(pixels2)} `}`}
+
params (${count(paramKeys)}): ${!paramKeys.length ? HTMLNote.BLOCKED :
+ modal(`${id}-parameters`, paramKeys.map((key) => `${key}: ${parameters[key]}`).join('
+
exts (${count(extensions)}): ${!extensions.length ? HTMLNote.BLOCKED :
+ modal(`${id}-extensions`, extensions.sort().join('
+
+
gpu:${confidence ? `confidence: ${confidence} ` : ''}
+
+
+ ${parameters.UNMASKED_VENDOR_WEBGL ? parameters.UNMASKED_VENDOR_WEBGL : ''}
+ ${!parameters.UNMASKED_RENDERER_WEBGL ? HTMLNote.BLOCKED : `
+
+ ${!dataURI ? '
' : `
`}
+
+
WebRTC
+
host connection:
+
${HTMLNote.BLOCKED}
+
foundation/ip:
+
${HTMLNote.BLOCKED}
+
+
sdp capabilities: ${HTMLNote.BLOCKED}
+
stun connection:
+
${HTMLNote.BLOCKED}
+
devices (0): ${HTMLNote.BLOCKED}
+
${HTMLNote.BLOCKED}
+
${x.mimeType}
+
+
WebRTC ${webRTCHash}
+
host connection:
+
${iceCandidate || HTMLNote.BLOCKED}
+
foundation/ip:
+
+
${foundation ? `type & base ip: ${foundation}` : HTMLNote.UNSUPPORTED}
+
${address ? `ip: ${address}` : HTMLNote.BLOCKED}
+
+
+
sdp capabilities: ${!codecsSdp ? HTMLNote.BLOCKED :
+ modal(`${id}-sdp-capabilities`, getModalTemplate(audio) +
+ 'extensions
+
stun connection:
+
${stunConnection || HTMLNote.BLOCKED}
+
devices (${count(mediaDevices)}):
+
${!mediaDevices || !mediaDevices.length ? HTMLNote.BLOCKED :
+ mediaDevicesByType.join(', ')}
+
+
+
Window
+
keys (0): ${HTMLNote.BLOCKED}
+
+
${performanceLogger.getLog().window}
+
Window ${hashSlice($hash)}
+
keys (${count(keys)}): ${keys && keys.length ? modal('creep-iframe-content-window-version', keys.join(', ')) : HTMLNote.BLOCKED}
+
+
+
+
+
WebRTC
+
host connection:
+
+ candidate:0000000000 1 udp 9353978903 93549af7-47d4-485c-a57a-751a3d213876.local 56518 typ host generation 0 ufrag bk84 network-cost 999
+
+
foundation/ip:
+
+
0000000000
+
000.000.000.000
+
+
+
+
capabilities:
+
stun connection:
+
+ candidate:0000000000 1 udp 9353978903 93549af7-47d4-485c-a57a-751a3d213876.local 56518 typ host generation 0 ufrag bk84 network-cost 999
+
+
devices (0):
+
mic, audio, webcam
+
+
+
+ ${timezoneHTML(fp)}
+ ${intlHTML(fp)}
+
+
+ ${headlessFeaturesHTML(fp)}
+ ${resistanceHTML(fp)}
+
+
${workerScopeHTML(fp)}
+
+ ${webglHTML(fp)}
+ ${screenHTML(fp)}
+
+
+ ${canvasHTML(fp)}
+ ${fontsHTML(fp)}
+
+
+ ${clientRectsHTML(fp)}
+ ${svgHTML(fp)}
+
+
+ ${audioHTML(fp)}
+ ${voicesHTML(fp)}
+ ${mediaHTML(fp)}
+
+
${featuresHTML(fp)}
+
+ ${cssMediaHTML(fp)}
+ ${cssHTML(fp)}
+
+
+
+ ${mathsHTML(fp)}
+ ${consoleErrorsHTML(fp)}
+
+
+ ${windowFeaturesHTML(fp)}
+ ${htmlElementVersionHTML(fp)}
+
+
+
${navigatorHTML(fp)}
+
+
+
+ ${webrtcHTML(webRTC, mediaDevices)}
+
+ `);
+ patch(document.getElementById('status-info'), html `
+
+ ${statusHTML(status)}
+
+ `);
+ }).catch((err) => console.error(err));
+ // expose results to the window
+ // @ts-expect-error does not exist
+ window.Fingerprint = JSON.parse(JSON.stringify(fp));
+ // @ts-expect-error does not exist
+ window.Creep = JSON.parse(JSON.stringify(creep));
+ const fuzzyFingerprint = await getFuzzyHash(fp);
+ const fuzzyFpEl = document.getElementById('fuzzy-fingerprint');
+ patch(fuzzyFpEl, html `
+
+
Fuzzy: ${fuzzyFingerprint}
+
FP ID: ${creepHash?.split('').map((x, i) => {
+ return `${x} `;
+ }).join('')}
+ `);
+ }, 50);
+ });
+ }();
+
+})();
diff --git a/tests/vendor/fpscanner-1.0.6.es.js b/tests/vendor/fpscanner-1.0.6.es.js
new file mode 100644
index 0000000..4df30e4
--- /dev/null
+++ b/tests/vendor/fpscanner-1.0.6.es.js
@@ -0,0 +1,1253 @@
+function ie() {
+ return navigator.webdriver;
+}
+function ae() {
+ return navigator.userAgent;
+}
+function oe() {
+ return navigator.platform;
+}
+const l = "ERROR", r = "INIT", s = "NA", v = "SKIPPED", h = "high", S = "low", se = "medium";
+function f(t) {
+ let e = 0;
+ for (let n = 0, i = t.length; n < i; n++) {
+ let a = t.charCodeAt(n);
+ e = (e << 5) - e + a, e |= 0;
+ }
+ return e.toString(16).padStart(8, "0");
+}
+function d(t, e) {
+ for (const n in t)
+ t[n] = e;
+}
+function ce() {
+ return navigator.buildID === "20181001000000";
+}
+function le() {
+ try {
+ let t = !1;
+ const e = Error.prepareStackTrace;
+ Error.prepareStackTrace = function() {
+ return t = !0, e;
+ };
+ const n = new Error("");
+ return console.log(n), t;
+ } catch {
+ return l;
+ }
+}
+function ue() {
+ const t = {
+ vendor: r,
+ renderer: r
+ };
+ if (ce())
+ return d(t, s), t;
+ try {
+ var e = document.createElement("canvas"), n = e.getContext("webgl") || e.getContext("experimental-webgl");
+ n.getSupportedExtensions().indexOf("WEBGL_debug_renderer_info") >= 0 ? (t.vendor = n.getParameter(n.getExtension("WEBGL_debug_renderer_info").UNMASKED_VENDOR_WEBGL), t.renderer = n.getParameter(n.getExtension("WEBGL_debug_renderer_info").UNMASKED_RENDERER_WEBGL)) : d(t, s);
+ } catch {
+ d(t, l);
+ }
+ return t;
+}
+function de() {
+ return "__pwInitScripts" in window || "__playwright__binding__" in window;
+}
+function ge() {
+ return navigator.hardwareConcurrency || s;
+}
+function he() {
+ const t = [], e = 0.123456789;
+ return ["E", "LN10", "LN2", "LOG10E", "LOG2E", "PI", "SQRT1_2", "SQRT2"].forEach(function(a) {
+ try {
+ t.push(Math[a]);
+ } catch {
+ t.push(-1);
+ }
+ }), ["tan", "sin", "exp", "atan", "acosh", "asinh", "atanh", "expm1", "log1p", "sinh"].forEach(function(a) {
+ try {
+ t.push(Math[a](e));
+ } catch {
+ t.push(-1);
+ }
+ }), "sumPrecise" in Math ? t.push(Math.sumPrecise([1e20, 0.1, -1e20])) : t.push(-1), f(t.map(String).join(","));
+}
+function me() {
+ return navigator.deviceMemory || s;
+}
+function pe() {
+ return eval.toString().length;
+}
+function fe() {
+ const t = {
+ timezone: r,
+ localeLanguage: r
+ };
+ try {
+ if (typeof Intl < "u" && typeof Intl.DateTimeFormat < "u") {
+ const e = Intl.DateTimeFormat().resolvedOptions();
+ t.timezone = e.timeZone, t.localeLanguage = e.locale;
+ } else
+ t.timezone = s, t.localeLanguage = s;
+ } catch {
+ t.timezone = l, t.localeLanguage = l;
+ }
+ return t;
+}
+function ve() {
+ return {
+ width: window.screen.width,
+ height: window.screen.height,
+ pixelDepth: window.screen.pixelDepth,
+ colorDepth: window.screen.colorDepth,
+ availableWidth: window.screen.availWidth,
+ availableHeight: window.screen.availHeight,
+ innerWidth: window.innerWidth,
+ innerHeight: window.innerHeight,
+ hasMultipleDisplays: typeof screen.isExtended < "u" ? screen.isExtended : s
+ };
+}
+function ye() {
+ return {
+ languages: navigator.languages,
+ language: navigator.language
+ };
+}
+async function we() {
+ const t = {
+ vendor: r,
+ architecture: r,
+ device: r,
+ description: r
+ };
+ if ("gpu" in navigator)
+ try {
+ const e = await navigator.gpu.requestAdapter();
+ e && (t.vendor = e.info.vendor, t.architecture = e.info.architecture, t.device = e.info.device, t.description = e.info.description);
+ } catch {
+ d(t, l);
+ }
+ else
+ d(t, s);
+ return t;
+}
+function be() {
+ const t = [
+ "__driver_evaluate",
+ "__webdriver_evaluate",
+ "__selenium_evaluate",
+ "__fxdriver_evaluate",
+ "__driver_unwrapped",
+ "__webdriver_unwrapped",
+ "__selenium_unwrapped",
+ "__fxdriver_unwrapped",
+ "_Selenium_IDE_Recorder",
+ "_selenium",
+ "calledSelenium",
+ "$cdc_asdjflasutopfhvcZLmcfl_",
+ "$chrome_asyncScriptInfo",
+ "__$webdriverAsyncExecutor",
+ "webdriver",
+ "__webdriverFunc",
+ "domAutomation",
+ "domAutomationController",
+ "__lastWatirAlert",
+ "__lastWatirConfirm",
+ "__lastWatirPrompt",
+ "__webdriver_script_fn",
+ "_WEBDRIVER_ELEM_CACHE"
+ ];
+ let e = !1;
+ for (let n = 0; n < t.length; n++)
+ if (t[n] in window) {
+ e = !0;
+ break;
+ }
+ return e = e || !!document.__webdriver_script_fn || !!window.domAutomation || !!window.domAutomationController, e;
+}
+function Se() {
+ try {
+ const t = "webdriver", e = window.navigator;
+ if (!e[t] && !e.hasOwnProperty(t)) {
+ e[t] = 1;
+ const n = e[t] === 1;
+ return delete e[t], n;
+ }
+ return !0;
+ } catch {
+ return !1;
+ }
+}
+async function Ce() {
+ const t = window.navigator, e = {
+ architecture: r,
+ bitness: r,
+ brands: r,
+ mobile: r,
+ model: r,
+ platform: r,
+ platformVersion: r,
+ uaFullVersion: r
+ };
+ if ("userAgentData" in t)
+ try {
+ const n = await t.userAgentData.getHighEntropyValues([
+ "architecture",
+ "bitness",
+ "brands",
+ "mobile",
+ "model",
+ "platform",
+ "platformVersion",
+ "uaFullVersion"
+ ]);
+ e.architecture = n.architecture, e.bitness = n.bitness, e.brands = n.brands, e.mobile = n.mobile, e.model = n.model, e.platform = n.platform, e.platformVersion = n.platformVersion, e.uaFullVersion = n.uaFullVersion;
+ } catch {
+ d(e, l);
+ }
+ else
+ d(e, s);
+ return e;
+}
+function Ae() {
+ if (!navigator.plugins) return !1;
+ const t = typeof navigator.plugins.toString == "function" ? navigator.plugins.toString() : navigator.plugins.constructor && typeof navigator.plugins.constructor.toString == "function" ? navigator.plugins.constructor.toString() : typeof navigator.plugins;
+ return t === "[object PluginArray]" || t === "[object MSPluginsCollection]" || t === "[object HTMLPluginsCollection]";
+}
+function Pe() {
+ if (!navigator.plugins) return s;
+ const t = [];
+ for (let e = 0; e < navigator.plugins.length; e++)
+ t.push(navigator.plugins[e].name);
+ return f(t.join(","));
+}
+function ke() {
+ return navigator.plugins ? navigator.plugins.length : s;
+}
+function Me() {
+ if (!navigator.plugins) return s;
+ try {
+ return navigator.plugins[0] === navigator.plugins[0][0].enabledPlugin;
+ } catch {
+ return l;
+ }
+}
+function xe() {
+ if (!navigator.plugins) return s;
+ try {
+ return navigator.plugins.item(4294967296) !== navigator.plugins[0];
+ } catch {
+ return l;
+ }
+}
+function We() {
+ const t = {
+ isValidPluginArray: r,
+ pluginCount: r,
+ pluginNamesHash: r,
+ pluginConsistency1: r,
+ pluginOverflow: r
+ };
+ try {
+ t.isValidPluginArray = Ae(), t.pluginCount = ke(), t.pluginNamesHash = Pe(), t.pluginConsistency1 = Me(), t.pluginOverflow = xe();
+ } catch {
+ d(t, l);
+ }
+ return t;
+}
+async function Ee() {
+ return new Promise(async function(t) {
+ var e = {
+ audiooutput: 0,
+ audioinput: 0,
+ videoinput: 0
+ };
+ if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+ const a = await navigator.mediaDevices.enumerateDevices();
+ if (typeof a < "u") {
+ for (var n = 0; n < a.length; n++) {
+ var i = a[n].kind;
+ e[i] = e[i] + 1;
+ }
+ return t({
+ speakers: e.audiooutput,
+ microphones: e.audioinput,
+ webcams: e.videoinput
+ });
+ } else
+ return d(e, s), t(e);
+ } else
+ return d(e, s), t(e);
+ });
+}
+function De() {
+ const t = {
+ webdriver: r,
+ userAgent: r,
+ platform: r,
+ memory: r,
+ cpuCount: r,
+ language: r
+ }, e = document.createElement("iframe");
+ let n = !1;
+ try {
+ e.style.display = "none", e.src = "about:blank", document.body.appendChild(e), n = !0;
+ const i = e.contentWindow?.navigator;
+ t.webdriver = i.webdriver ?? !1, t.userAgent = i.userAgent ?? s, t.platform = i.platform ?? s, t.memory = i.deviceMemory ?? s, t.cpuCount = i.hardwareConcurrency ?? s, t.language = i.language ?? s;
+ } catch {
+ d(t, l);
+ } finally {
+ if (n)
+ try {
+ document.body.removeChild(e);
+ } catch {
+ }
+ }
+ return t;
+}
+async function _e() {
+ return new Promise((t) => {
+ const e = {
+ vendor: r,
+ renderer: r,
+ userAgent: r,
+ language: r,
+ platform: r,
+ memory: r,
+ cpuCount: r
+ };
+ let n = null, i = null, a = null;
+ const g = () => {
+ a && clearTimeout(a), n && n.terminate(), i && URL.revokeObjectURL(i);
+ };
+ try {
+ const p = `var fingerprintWorker = {
+ userAgent: 'NA',
+ language: 'NA',
+ cpuCount: 'NA',
+ platform: 'NA',
+ memory: 'NA',
+ vendor: 'NA',
+ renderer: 'NA'
+ };
+ try {
+ fingerprintWorker.userAgent = navigator.userAgent;
+ fingerprintWorker.language = navigator.language;
+ fingerprintWorker.cpuCount = navigator.hardwareConcurrency;
+ fingerprintWorker.platform = navigator.platform;
+ if (typeof navigator.deviceMemory !== 'undefined') {
+ fingerprintWorker.memory = navigator.deviceMemory;
+ }
+
+ try {
+ if (typeof OffscreenCanvas === 'undefined') {
+ fingerprintWorker.vendor = 'NA';
+ fingerprintWorker.renderer = 'NA';
+ } else {
+ var canvas = new OffscreenCanvas(1, 1);
+ var gl = canvas.getContext('webgl');
+ var isFirefox = navigator.userAgent.indexOf('Firefox') !== -1;
+ if (gl && !isFirefox) {
+ var glExt = gl.getExtension('WEBGL_debug_renderer_info');
+ if (glExt) {
+ fingerprintWorker.vendor = gl.getParameter(glExt.UNMASKED_VENDOR_WEBGL);
+ fingerprintWorker.renderer = gl.getParameter(glExt.UNMASKED_RENDERER_WEBGL);
+ } else {
+ fingerprintWorker.vendor = 'NA';
+ fingerprintWorker.renderer = 'NA';
+ }
+ } else {
+ fingerprintWorker.vendor = 'NA';
+ fingerprintWorker.renderer = 'NA';
+ }
+ }
+ } catch (_) {
+ fingerprintWorker.vendor = 'ERROR';
+ fingerprintWorker.renderer = 'ERROR';
+ }
+ self.postMessage(fingerprintWorker);
+ } catch (e) {
+ self.postMessage(fingerprintWorker);
+ }`, y = new Blob([p], { type: "application/javascript" });
+ i = URL.createObjectURL(y), n = new Worker(i), a = window.setTimeout(() => {
+ g(), d(e, l), t(e);
+ }, 2e3), n.onmessage = function(o) {
+ try {
+ const m = (w) => typeof w > "u" ? s : w;
+ e.vendor = m(o.data.vendor), e.renderer = m(o.data.renderer), e.userAgent = m(o.data.userAgent), e.language = m(o.data.language), e.platform = m(o.data.platform), e.memory = m(o.data.memory), e.cpuCount = m(o.data.cpuCount);
+ } catch {
+ d(e, l);
+ } finally {
+ g(), t(e);
+ }
+ }, n.onerror = function() {
+ g(), d(e, l), t(e);
+ };
+ } catch {
+ g(), d(e, l), t(e);
+ }
+ });
+}
+function Re() {
+ const t = {
+ toSourceError: r,
+ hasToSource: !1
+ };
+ try {
+ null.usdfsh;
+ } catch (e) {
+ t.toSourceError = e.toString();
+ }
+ try {
+ throw "xyz";
+ } catch (e) {
+ try {
+ e.toSource(), t.hasToSource = !0;
+ } catch {
+ t.hasToSource = !1;
+ }
+ }
+ return t;
+}
+const C = [
+ 'audio/mp4; codecs="mp4a.40.2"',
+ "audio/mpeg;",
+ 'audio/webm; codecs="vorbis"',
+ 'audio/ogg; codecs="vorbis"',
+ 'audio/wav; codecs="1"',
+ 'audio/ogg; codecs="speex"',
+ 'audio/ogg; codecs="flac"',
+ 'audio/3gpp; codecs="samr"'
+], A = [
+ 'video/mp4; codecs="avc1.42E01E, mp4a.40.2"',
+ 'video/mp4; codecs="avc1.42E01E"',
+ 'video/mp4; codecs="avc1.58A01E"',
+ 'video/mp4; codecs="avc1.4D401E"',
+ 'video/mp4; codecs="avc1.64001E"',
+ 'video/mp4; codecs="mp4v.20.8"',
+ 'video/mp4; codecs="mp4v.20.240"',
+ 'video/webm; codecs="vp8"',
+ 'video/ogg; codecs="theora"',
+ 'video/ogg; codecs="dirac"',
+ 'video/3gpp; codecs="mp4v.20.8"',
+ 'video/x-matroska; codecs="theora"'
+];
+function P(t, e) {
+ const n = {};
+ try {
+ const i = document.createElement(e);
+ for (const a of t)
+ try {
+ n[a] = i.canPlayType(a) || null;
+ } catch {
+ n[a] = null;
+ }
+ } catch {
+ for (const i of t)
+ n[i] = null;
+ }
+ return n;
+}
+function k(t) {
+ const e = {}, n = window.MediaSource;
+ if (!n || typeof n.isTypeSupported != "function") {
+ for (const i of t)
+ e[i] = null;
+ return e;
+ }
+ for (const i of t)
+ try {
+ e[i] = n.isTypeSupported(i);
+ } catch {
+ e[i] = null;
+ }
+ return e;
+}
+function M(t) {
+ try {
+ const e = window.RTCRtpReceiver;
+ if (e && typeof e.getCapabilities == "function") {
+ const n = e.getCapabilities(t);
+ return f(JSON.stringify(n));
+ }
+ return s;
+ } catch {
+ return l;
+ }
+}
+function Ie() {
+ const t = {
+ audioCanPlayTypeHash: s,
+ videoCanPlayTypeHash: s,
+ audioMediaSourceHash: s,
+ videoMediaSourceHash: s,
+ rtcAudioCapabilitiesHash: s,
+ rtcVideoCapabilitiesHash: s,
+ hasMediaSource: !1
+ };
+ try {
+ t.hasMediaSource = !!window.MediaSource;
+ const e = P(C, "audio"), n = P(A, "video");
+ t.audioCanPlayTypeHash = f(JSON.stringify(e)), t.videoCanPlayTypeHash = f(JSON.stringify(n));
+ const i = k(C), a = k(A);
+ t.audioMediaSourceHash = f(JSON.stringify(i)), t.videoMediaSourceHash = f(JSON.stringify(a)), t.rtcAudioCapabilitiesHash = M("audio"), t.rtcVideoCapabilitiesHash = M("video");
+ } catch {
+ d(t, l);
+ }
+ return t;
+}
+async function Le() {
+ return new Promise((t) => {
+ try {
+ const e = new Image(), n = document.createElement("canvas").getContext("2d");
+ e.onload = () => {
+ n.drawImage(e, 0, 0), t(n.getImageData(0, 0, 1, 1).data.filter((i) => i === 0).length != 4);
+ }, e.onerror = () => {
+ t(l);
+ }, e.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";
+ } catch {
+ t(l);
+ }
+ });
+}
+function Te() {
+ var t = document.createElement("canvas");
+ t.width = 400, t.height = 200, t.style.display = "inline";
+ var e = t.getContext("2d");
+ try {
+ return e.rect(0, 0, 10, 10), e.rect(2, 2, 6, 6), e.textBaseline = "alphabetic", e.fillStyle = "#f60", e.fillRect(125, 1, 62, 20), e.fillStyle = "#069", e.font = "11pt no-real-font-123", e.fillText("Cwm fjordbank glyphs vext quiz, 😃", 2, 15), e.fillStyle = "rgba(102, 204, 0, 0.2)", e.font = "18pt Arial", e.fillText("Cwm fjordbank glyphs vext quiz, 😃", 4, 45), e.globalCompositeOperation = "multiply", e.fillStyle = "rgb(255,0,255)", e.beginPath(), e.arc(50, 50, 50, 0, 2 * Math.PI, !0), e.closePath(), e.fill(), e.fillStyle = "rgb(0,255,255)", e.beginPath(), e.arc(100, 50, 50, 0, 2 * Math.PI, !0), e.closePath(), e.fill(), e.fillStyle = "rgb(255,255,0)", e.beginPath(), e.arc(75, 100, 50, 0, 2 * Math.PI, !0), e.closePath(), e.fill(), e.fillStyle = "rgb(255,0,255)", e.arc(75, 75, 75, 0, 2 * Math.PI, !0), e.arc(75, 75, 25, 0, 2 * Math.PI, !0), e.fill("evenodd"), f(t.toDataURL());
+ } catch {
+ return l;
+ }
+}
+async function Oe() {
+ const t = {
+ hasModifiedCanvas: r,
+ canvasFingerprint: r
+ };
+ return t.hasModifiedCanvas = await Le(), t.canvasFingerprint = Te(), t;
+}
+function He() {
+ const t = ["deviceMemory", "hardwareConcurrency", "language", "languages", "platform"], e = [];
+ for (const n of t) {
+ const i = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(navigator), n);
+ i && i.value ? e.push("1") : e.push("0");
+ }
+ return e.join("");
+}
+function ze() {
+ return Math.random().toString(36).substring(2, 15);
+}
+function Ue() {
+ return (/* @__PURE__ */ new Date()).getTime();
+}
+function Ne() {
+ return window.location.href;
+}
+function x(t, e) {
+ const n = t.signals;
+ return e === "iframe" ? n.contexts.iframe.webdriver !== n.automation.webdriver || n.contexts.iframe.userAgent !== n.browser.userAgent || n.contexts.iframe.platform !== n.device.platform || n.contexts.iframe.memory !== n.device.memory || n.contexts.iframe.cpuCount !== n.device.cpuCount : n.contexts.webWorker.webdriver !== n.automation.webdriver || n.contexts.webWorker.userAgent !== n.browser.userAgent || n.contexts.webWorker.platform !== n.device.platform || n.contexts.webWorker.memory !== n.device.memory || n.contexts.webWorker.cpuCount !== n.device.cpuCount;
+}
+function Fe() {
+ const t = {
+ bitmask: r,
+ extensions: []
+ }, e = document.body.hasAttribute("data-gr-ext-installed"), n = typeof window.ethereum < "u", i = document.getElementById("coupon-birds-drop-div") !== null, a = document.querySelector("deepl-input-controller") !== null, g = document.getElementById("monica-content-root") !== null, p = document.querySelector("chatgpt-sidebar") !== null, y = typeof window.__REQUESTLY__ < "u", o = Array.from(document.querySelectorAll("*")).filter((m) => m.tagName.toLowerCase().startsWith("veepn-")).length > 0;
+ return t.bitmask = [
+ e ? "1" : "0",
+ n ? "1" : "0",
+ i ? "1" : "0",
+ a ? "1" : "0",
+ g ? "1" : "0",
+ p ? "1" : "0",
+ y ? "1" : "0",
+ o ? "1" : "0"
+ ].join(""), e && t.extensions.push("grammarly"), n && t.extensions.push("metamask"), i && t.extensions.push("coupon-birds"), a && t.extensions.push("deepl"), g && t.extensions.push("monica-ai"), p && t.extensions.push("sider-ai"), y && t.extensions.push("requestly"), o && t.extensions.push("veepn"), t;
+}
+function c(t) {
+ try {
+ return t();
+ } catch {
+ return !1;
+ }
+}
+function Ge() {
+ const t = {
+ bitmask: r,
+ chrome: c(() => "chrome" in window),
+ brave: c(() => "brave" in navigator),
+ applePaySupport: c(() => "ApplePaySetup" in window),
+ opera: c(() => typeof window.opr < "u" || typeof window.onoperadetachedviewchange == "object"),
+ serial: c(() => window.navigator.serial !== void 0),
+ attachShadow: c(() => !!Element.prototype.attachShadow),
+ caches: c(() => !!window.caches),
+ webAssembly: c(() => !!window.WebAssembly && !!window.WebAssembly.instantiate),
+ buffer: c(() => "Buffer" in window),
+ showModalDialog: c(() => "showModalDialog" in window),
+ safari: c(() => "safari" in window),
+ webkitPrefixedFunction: c(() => "webkitCancelAnimationFrame" in window),
+ mozPrefixedFunction: c(() => "mozGetUserMedia" in navigator),
+ usb: c(() => typeof window.USB == "function"),
+ browserCapture: c(() => typeof window.BrowserCaptureMediaStreamTrack == "function"),
+ paymentRequestUpdateEvent: c(() => typeof window.PaymentRequestUpdateEvent == "function"),
+ pressureObserver: c(() => typeof window.PressureObserver == "function"),
+ audioSession: c(() => "audioSession" in navigator),
+ selectAudioOutput: c(() => typeof navigator < "u" && typeof navigator.mediaDevices < "u" && typeof navigator.mediaDevices.selectAudioOutput == "function"),
+ barcodeDetector: c(() => "BarcodeDetector" in window),
+ battery: c(() => "getBattery" in navigator),
+ devicePosture: c(() => "DevicePosture" in window),
+ documentPictureInPicture: c(() => "documentPictureInPicture" in window),
+ eyeDropper: c(() => "EyeDropper" in window),
+ editContext: c(() => "EditContext" in window),
+ fencedFrame: c(() => "FencedFrameConfig" in window),
+ sanitizer: c(() => "Sanitizer" in window),
+ otpCredential: c(() => "OTPCredential" in window),
+ sumPrecise: c(() => "sumPrecise" in Math)
+ }, e = Object.keys(t).filter((n) => n !== "bitmask").map((n) => t[n] ? "1" : "0").join("");
+ return t.bitmask = e, t;
+}
+function Ve() {
+ const t = {
+ prefersColorScheme: r,
+ prefersReducedMotion: r,
+ prefersReducedTransparency: r,
+ colorGamut: r,
+ pointer: r,
+ anyPointer: r,
+ hover: r,
+ anyHover: r,
+ colorDepth: r
+ };
+ try {
+ window.matchMedia("(prefers-color-scheme: dark)").matches ? t.prefersColorScheme = "dark" : window.matchMedia("(prefers-color-scheme: light)").matches ? t.prefersColorScheme = "light" : t.prefersColorScheme = null, t.prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches, t.prefersReducedTransparency = window.matchMedia("(prefers-reduced-transparency: reduce)").matches, window.matchMedia("(color-gamut: rec2020)").matches ? t.colorGamut = "rec2020" : window.matchMedia("(color-gamut: p3)").matches ? t.colorGamut = "p3" : window.matchMedia("(color-gamut: srgb)").matches ? t.colorGamut = "srgb" : t.colorGamut = null, window.matchMedia("(pointer: fine)").matches ? t.pointer = "fine" : window.matchMedia("(pointer: coarse)").matches ? t.pointer = "coarse" : window.matchMedia("(pointer: none)").matches ? t.pointer = "none" : t.pointer = null, window.matchMedia("(any-pointer: fine)").matches ? t.anyPointer = "fine" : window.matchMedia("(any-pointer: coarse)").matches ? t.anyPointer = "coarse" : window.matchMedia("(any-pointer: none)").matches ? t.anyPointer = "none" : t.anyPointer = null, t.hover = window.matchMedia("(hover: hover)").matches, t.anyHover = window.matchMedia("(any-hover: hover)").matches;
+ let e = 0;
+ for (let n = 0; n <= 16; n++)
+ window.matchMedia(`(color: ${n})`).matches && (e = n);
+ t.colorDepth = e;
+ } catch {
+ d(t, l);
+ }
+ return t;
+}
+async function Be() {
+ const t = {
+ layout: r,
+ layoutSize: r
+ };
+ if ("keyboard" in navigator && typeof navigator.keyboard.getLayoutMap < "u")
+ try {
+ const e = await navigator.keyboard.getLayoutMap();
+ t.layout = Array.from(
+ e.entries()
+ ).map(([n, i]) => `${n},${i}`).join(" "), t.layoutSize = e.size;
+ } catch {
+ d(t, l);
+ }
+ else
+ d(t, s);
+ return t;
+}
+async function je() {
+ const t = {
+ summarizerAvailability: r,
+ summarizerLanguageAvailability: r
+ };
+ if ("Summarizer" in window)
+ try {
+ t.summarizerAvailability = await window.Summarizer.availability(), t.summarizerLanguageAvailability = await window.Summarizer.availability({
+ expectedInputLanguages: [navigator.language]
+ });
+ } catch {
+ d(t, l);
+ }
+ else
+ d(t, s);
+ return t;
+}
+function $e(t) {
+ const e = t.signals.device.screenResolution;
+ return e.width === 800 && e.height === 600 || e.availableWidth === 800 && e.availableHeight === 600 || e.innerWidth === 800 && e.innerHeight === 600;
+}
+function Qe(t) {
+ return t.signals.automation.webdriver === !0;
+}
+function qe(t) {
+ return !!t.signals.automation.selenium;
+}
+function Ke(t) {
+ return t.signals.automation.cdp === !0;
+}
+function Je(t) {
+ return t.signals.automation.playwright === !0;
+}
+function Ye(t) {
+ return typeof t.signals.device.memory != "number" ? !1 : t.signals.device.memory > 32 || t.signals.device.memory < 0.25;
+}
+function Ze(t) {
+ return typeof t.signals.device.cpuCount != "number" ? !1 : t.signals.device.cpuCount > 70;
+}
+function Xe(t) {
+ return t.includes("Android") || t.includes("iPhone") || t.includes("iPod") || t.includes("iPad");
+}
+function et(t) {
+ const e = t.signals.browser.userAgent;
+ return typeof e != "string" || !e.includes("Chrome") || Xe(e) ? !1 : t.signals.browser.features.chrome === !1;
+}
+function tt(t) {
+ return t.signals.contexts.iframe.webdriver === !0;
+}
+function rt(t) {
+ return t.signals.contexts.webWorker.webdriver === !0;
+}
+function b(t) {
+ return typeof t != "string" || t.length === 0 ? !0 : t === s || t === l || t === v || t === r;
+}
+function nt(t) {
+ const e = t.signals.contexts.webWorker, n = t.signals.graphics.webGL;
+ return b(n.vendor) || b(n.renderer) || b(e.vendor) || b(e.renderer) ? !1 : e.vendor !== n.vendor || e.renderer !== n.renderer;
+}
+function it(t, e) {
+ const n = t.includes("iPad"), i = e.includes("iPad");
+ if (n === i)
+ return !1;
+ const a = (g) => g === "MacIntel" || g === "MacPPC";
+ return a(t) || a(e);
+}
+function at(t) {
+ if (t.signals.contexts.webWorker.platform === s || t.signals.contexts.webWorker.platform === l || t.signals.contexts.webWorker.platform === v)
+ return !1;
+ const e = t.signals.device.platform, n = t.signals.contexts.webWorker.platform;
+ return !(e === n || it(e, n));
+}
+function ot(t) {
+ return t.signals.contexts.iframe.platform === s || t.signals.contexts.iframe.platform === l ? !1 : t.signals.device.platform !== t.signals.contexts.iframe.platform;
+}
+function st(t) {
+ return t.signals.automation.webdriverWritable === !0;
+}
+function ct(t) {
+ return t.signals.graphics.webGL.renderer.includes("SwiftShader");
+}
+function lt(t) {
+ return t.signals.locale.internationalization.timezone === "UTC";
+}
+function ut(t) {
+ const e = t.signals.locale.languages.languages, n = t.signals.locale.languages.language;
+ return n && e && Array.isArray(e) && e.length > 0 ? e[0] !== n : !1;
+}
+function dt(t) {
+ return !!(t.signals.browser.features.chrome && t.signals.browser.etsl !== 33 || t.signals.browser.features.safari && t.signals.browser.etsl !== 37 || t.signals.browser.userAgent.includes("Firefox") && t.signals.browser.etsl !== 37);
+}
+function gt(t) {
+ return [
+ t.signals.browser.userAgent,
+ t.signals.contexts.iframe.userAgent,
+ t.signals.contexts.webWorker.userAgent
+ ].some((n) => /bot|headless/i.test(n.toLowerCase()));
+}
+function ht(t) {
+ const e = t.signals.graphics.webgpu, n = t.signals.graphics.webGL, i = t.signals.browser.userAgent;
+ return !!((n.vendor.includes("Apple") || n.renderer.includes("Apple")) && !i.includes("Mac") || e.vendor.includes("apple") && !i.includes("Mac") || e.vendor.includes("apple") && !n.renderer.includes("Apple"));
+}
+function mt(t) {
+ const e = t.signals.device.platform, n = t.signals.browser.userAgent, i = t.signals.browser.highEntropyValues.platform;
+ return !!(n.includes("Mac") && (e.includes("Win") || e.includes("Linux")) || n.includes("Windows") && (e.includes("Mac") || e.includes("Linux")) || n.includes("Linux") && (e.includes("Mac") || e.includes("Win")) || i !== l && i !== s && (i.includes("Mac") && (e.includes("Win") || e.includes("Linux")) || i.includes("Windows") && (e.includes("Mac") || e.includes("Linux")) || i.includes("Linux") && (e.includes("Mac") || e.includes("Win"))));
+}
+async function pt(t, e) {
+ const n = new TextEncoder().encode(e), i = new TextEncoder().encode(t), a = new Uint8Array(i.length);
+ for (let p = 0; p < i.length; p++)
+ a[p] = i[p] ^ n[p % n.length];
+ const g = String.fromCharCode(...a);
+ return btoa(g);
+}
+class vt {
+ constructor() {
+ this.fingerprint = {
+ signals: {
+ // Automation/Bot detection signals
+ automation: {
+ webdriver: r,
+ webdriverWritable: r,
+ selenium: r,
+ cdp: r,
+ playwright: r,
+ navigatorPropertyDescriptors: r
+ },
+ // Device hardware characteristics
+ device: {
+ cpuCount: r,
+ memory: r,
+ platform: r,
+ screenResolution: {
+ width: r,
+ height: r,
+ pixelDepth: r,
+ colorDepth: r,
+ availableWidth: r,
+ availableHeight: r,
+ innerWidth: r,
+ innerHeight: r,
+ hasMultipleDisplays: r
+ },
+ multimediaDevices: {
+ speakers: r,
+ microphones: r,
+ webcams: r
+ },
+ mediaQueries: {
+ prefersColorScheme: r,
+ prefersReducedMotion: r,
+ prefersReducedTransparency: r,
+ colorGamut: r,
+ pointer: r,
+ anyPointer: r,
+ hover: r,
+ anyHover: r,
+ colorDepth: r
+ },
+ keyboard: {
+ layout: r,
+ layoutSize: r
+ }
+ },
+ // Browser identity & features
+ browser: {
+ userAgent: r,
+ features: {
+ bitmask: r,
+ chrome: r,
+ brave: r,
+ applePaySupport: r,
+ opera: r,
+ serial: r,
+ attachShadow: r,
+ caches: r,
+ webAssembly: r,
+ buffer: r,
+ showModalDialog: r,
+ safari: r,
+ webkitPrefixedFunction: r,
+ mozPrefixedFunction: r,
+ usb: r,
+ browserCapture: r,
+ paymentRequestUpdateEvent: r,
+ pressureObserver: r,
+ audioSession: r,
+ selectAudioOutput: r,
+ barcodeDetector: r,
+ battery: r,
+ devicePosture: r,
+ documentPictureInPicture: r,
+ eyeDropper: r,
+ editContext: r,
+ fencedFrame: r,
+ sanitizer: r,
+ otpCredential: r
+ },
+ plugins: {
+ isValidPluginArray: r,
+ pluginCount: r,
+ pluginNamesHash: r,
+ pluginConsistency1: r,
+ pluginOverflow: r
+ },
+ extensions: {
+ bitmask: r,
+ extensions: r
+ },
+ highEntropyValues: {
+ architecture: r,
+ bitness: r,
+ brands: r,
+ mobile: r,
+ model: r,
+ platform: r,
+ platformVersion: r,
+ uaFullVersion: r
+ },
+ etsl: r,
+ maths: r,
+ toSourceError: {
+ toSourceError: r,
+ hasToSource: r
+ },
+ ai: {
+ summarizerAvailability: r,
+ summarizerLanguageAvailability: r
+ }
+ },
+ // Graphics & rendering
+ graphics: {
+ webGL: {
+ vendor: r,
+ renderer: r
+ },
+ webgpu: {
+ vendor: r,
+ architecture: r,
+ device: r,
+ description: r
+ },
+ canvas: {
+ hasModifiedCanvas: r,
+ canvasFingerprint: r
+ }
+ },
+ // Media codecs (at root level)
+ codecs: {
+ audioCanPlayTypeHash: r,
+ videoCanPlayTypeHash: r,
+ audioMediaSourceHash: r,
+ videoMediaSourceHash: r,
+ rtcAudioCapabilitiesHash: r,
+ rtcVideoCapabilitiesHash: r,
+ hasMediaSource: r
+ },
+ // Locale & internationalization
+ locale: {
+ internationalization: {
+ timezone: r,
+ localeLanguage: r
+ },
+ languages: {
+ languages: r,
+ language: r
+ }
+ },
+ // Isolated execution contexts
+ contexts: {
+ iframe: {
+ webdriver: r,
+ userAgent: r,
+ platform: r,
+ memory: r,
+ cpuCount: r,
+ language: r
+ },
+ webWorker: {
+ webdriver: r,
+ userAgent: r,
+ platform: r,
+ memory: r,
+ cpuCount: r,
+ language: r,
+ vendor: r,
+ renderer: r
+ }
+ }
+ },
+ fsid: r,
+ nonce: r,
+ time: r,
+ url: r,
+ fastBotDetection: !1,
+ fastBotDetectionDetails: {
+ headlessChromeScreenResolution: { detected: !1, severity: "high" },
+ hasWebdriver: { detected: !1, severity: "high" },
+ hasWebdriverWritable: { detected: !1, severity: "high" },
+ hasSeleniumProperty: { detected: !1, severity: "high" },
+ hasCDP: { detected: !1, severity: "high" },
+ hasPlaywright: { detected: !1, severity: "high" },
+ hasImpossibleDeviceMemory: { detected: !1, severity: "high" },
+ hasHighCPUCount: { detected: !1, severity: "high" },
+ hasMissingChromeObject: { detected: !1, severity: "high" },
+ hasWebdriverIframe: { detected: !1, severity: "high" },
+ hasWebdriverWorker: { detected: !1, severity: "high" },
+ hasMismatchWebGLInWorker: { detected: !1, severity: "high" },
+ hasMismatchPlatformIframe: { detected: !1, severity: "high" },
+ hasMismatchPlatformWorker: { detected: !1, severity: "high" },
+ hasSwiftshaderRenderer: { detected: !1, severity: "low" },
+ hasUTCTimezone: { detected: !1, severity: "medium" },
+ hasMismatchLanguages: { detected: !1, severity: "low" },
+ hasInconsistentEtsl: { detected: !1, severity: "high" },
+ hasBotUserAgent: { detected: !1, severity: "high" },
+ hasGPUMismatch: { detected: !1, severity: "high" },
+ hasPlatformMismatch: { detected: !1, severity: "high" }
+ }
+ };
+ }
+ async collectSignal(e) {
+ try {
+ return await e();
+ } catch {
+ return l;
+ }
+ }
+ /**
+ * Generate a JA4-inspired fingerprint scanner ID
+ * Format: FS1________
+ *
+ * Each section is delimited by '_', allowing partial matching.
+ * Sections use the pattern: h where applicable.
+ * Bitmasks are extensible - new boolean fields are appended without breaking existing positions.
+ *
+ * Sections:
+ * - det: fastBotDetectionDetails bitmask (21 bits: headlessChromeScreenResolution, hasWebdriver,
+ * hasWebdriverWritable, hasSeleniumProperty, hasCDP, hasPlaywright, hasImpossibleDeviceMemory,
+ * hasHighCPUCount, hasMissingChromeObject, hasWebdriverIframe, hasWebdriverWorker,
+ * hasMismatchWebGLInWorker, hasMismatchPlatformIframe, hasMismatchPlatformWorker,
+ * hasMismatchLanguages, hasInconsistentEtsl, hasBotUserAgent, hasGPUMismatch, hasPlatformMismatch)
+ * - auto: automation bitmask (5 bits: webdriver, webdriverWritable, selenium, cdp, playwright) + hash
+ * - dev: WIDTHxHEIGHT + cpu + mem + device bitmask + hash of all device signals
+ * - brw: features.bitmask + extensions.bitmask + plugins bitmask (3 bits) + hash of browser signals
+ * - gfx: canvas bitmask (1 bit: hasModifiedCanvas) + hash of all graphics signals
+ * - cod: codecs bitmask (1 bit: hasMediaSource) + hash of all codec hashes
+ * - loc: language code (2 chars) + language count + hash of locale signals
+ * - ctx: context mismatch bitmask (2 bits: iframe, worker) + hash of all context signals
+ */
+ generateFingerprintScannerId() {
+ try {
+ const e = this.fingerprint.signals, n = this.fingerprint.fastBotDetectionDetails, i = "FS1", g = [
+ n.headlessChromeScreenResolution.detected,
+ n.hasWebdriver.detected,
+ n.hasWebdriverWritable.detected,
+ n.hasSeleniumProperty.detected,
+ n.hasCDP.detected,
+ n.hasPlaywright.detected,
+ n.hasImpossibleDeviceMemory.detected,
+ n.hasHighCPUCount.detected,
+ n.hasMissingChromeObject.detected,
+ n.hasWebdriverIframe.detected,
+ n.hasWebdriverWorker.detected,
+ n.hasMismatchWebGLInWorker.detected,
+ n.hasMismatchPlatformIframe.detected,
+ n.hasMismatchPlatformWorker.detected,
+ n.hasSwiftshaderRenderer.detected,
+ n.hasUTCTimezone.detected,
+ n.hasMismatchLanguages.detected,
+ n.hasInconsistentEtsl.detected,
+ n.hasBotUserAgent.detected,
+ n.hasGPUMismatch.detected,
+ n.hasPlatformMismatch.detected
+ // Add other detection rules output here
+ ].map((u) => u ? "1" : "0").join(""), p = [
+ e.automation.webdriver === !0,
+ e.automation.webdriverWritable === !0,
+ e.automation.selenium === !0,
+ e.automation.cdp === !0,
+ e.automation.playwright === !0
+ ].map((u) => u ? "1" : "0").join(""), y = f(String(e.automation.navigatorPropertyDescriptors)).slice(0, 4), o = `${p}h${y}`, m = typeof e.device.screenResolution.width == "number" ? e.device.screenResolution.width : 0, w = typeof e.device.screenResolution.height == "number" ? e.device.screenResolution.height : 0, W = typeof e.device.cpuCount == "number" ? String(e.device.cpuCount).padStart(2, "0") : "00", E = typeof e.device.memory == "number" ? String(Math.round(e.device.memory)).padStart(2, "0") : "00", D = [
+ e.device.screenResolution.hasMultipleDisplays === !0,
+ e.device.mediaQueries.prefersReducedMotion === !0,
+ e.device.mediaQueries.prefersReducedTransparency === !0,
+ e.device.mediaQueries.hover === !0,
+ e.device.mediaQueries.anyHover === !0
+ ].map((u) => u ? "1" : "0").join(""), _ = [
+ e.device.platform,
+ e.device.screenResolution.pixelDepth,
+ e.device.screenResolution.colorDepth,
+ e.device.multimediaDevices.speakers,
+ e.device.multimediaDevices.microphones,
+ e.device.multimediaDevices.webcams,
+ e.device.mediaQueries.prefersColorScheme,
+ e.device.mediaQueries.colorGamut,
+ e.device.mediaQueries.pointer,
+ e.device.mediaQueries.anyPointer,
+ e.device.mediaQueries.colorDepth,
+ e.device.keyboard.layout,
+ e.device.keyboard.layoutSize
+ ].map((u) => String(u)).join("|"), R = f(_).slice(0, 6), I = `${m}x${w}c${W}m${E}b${D}h${R}`, L = typeof e.browser.features.bitmask == "string" ? e.browser.features.bitmask : "0".repeat(29), T = typeof e.browser.extensions.bitmask == "string" ? e.browser.extensions.bitmask : "0".repeat(8), O = [
+ e.browser.plugins.isValidPluginArray === !0,
+ e.browser.plugins.pluginConsistency1 === !0,
+ e.browser.plugins.pluginOverflow === !0,
+ e.browser.toSourceError.hasToSource === !0
+ ].map((u) => u ? "1" : "0").join(""), H = [
+ e.browser.userAgent,
+ e.browser.etsl,
+ e.browser.maths,
+ e.browser.plugins.pluginCount,
+ e.browser.plugins.pluginNamesHash,
+ e.browser.toSourceError.toSourceError,
+ e.browser.highEntropyValues.architecture,
+ e.browser.highEntropyValues.bitness,
+ e.browser.highEntropyValues.platform,
+ e.browser.highEntropyValues.platformVersion,
+ e.browser.highEntropyValues.uaFullVersion,
+ e.browser.highEntropyValues.mobile,
+ e.browser.ai.summarizerAvailability,
+ e.browser.ai.summarizerLanguageAvailability
+ ].map((u) => String(u)).join("|"), z = f(H).slice(0, 6), U = `f${L}e${T}p${O}h${z}`, N = [
+ e.graphics.canvas.hasModifiedCanvas === !0
+ ].map((u) => u ? "1" : "0").join(""), F = [
+ e.graphics.webGL.vendor,
+ e.graphics.webGL.renderer,
+ e.graphics.webgpu.vendor,
+ e.graphics.webgpu.architecture,
+ e.graphics.webgpu.device,
+ e.graphics.webgpu.description,
+ e.graphics.canvas.canvasFingerprint
+ ].map((u) => String(u)).join("|"), G = f(F).slice(0, 6), V = `${N}h${G}`, B = [
+ e.codecs.hasMediaSource === !0
+ ].map((u) => u ? "1" : "0").join(""), j = [
+ e.codecs.audioCanPlayTypeHash,
+ e.codecs.videoCanPlayTypeHash,
+ e.codecs.audioMediaSourceHash,
+ e.codecs.videoMediaSourceHash,
+ e.codecs.rtcAudioCapabilitiesHash,
+ e.codecs.rtcVideoCapabilitiesHash
+ ].map((u) => String(u)).join("|"), $ = f(j).slice(0, 6), Q = `${B}h${$}`, q = typeof e.locale.languages.language == "string" ? e.locale.languages.language.slice(0, 2).toLowerCase() : "xx", K = Array.isArray(e.locale.languages.languages) ? e.locale.languages.languages.length : 0, J = (typeof e.locale.internationalization.timezone == "string" ? e.locale.internationalization.timezone : "unknown").replace(/[\/\s]/g, "-"), Y = [
+ e.locale.internationalization.timezone,
+ e.locale.internationalization.localeLanguage,
+ Array.isArray(e.locale.languages.languages) ? e.locale.languages.languages.join(",") : e.locale.languages.languages,
+ e.locale.languages.language
+ ].map((u) => String(u)).join("|"), Z = f(Y).slice(0, 4), X = `${q}${K}t${J}_h${Z}`, ee = [
+ x(this.fingerprint, "iframe"),
+ x(this.fingerprint, "worker"),
+ e.contexts.iframe.webdriver === !0,
+ e.contexts.webWorker.webdriver === !0
+ ].map((u) => u ? "1" : "0").join(""), te = [
+ e.contexts.iframe.userAgent,
+ e.contexts.iframe.platform,
+ e.contexts.iframe.memory,
+ e.contexts.iframe.cpuCount,
+ e.contexts.iframe.language,
+ e.contexts.webWorker.userAgent,
+ e.contexts.webWorker.platform,
+ e.contexts.webWorker.memory,
+ e.contexts.webWorker.cpuCount,
+ e.contexts.webWorker.language,
+ e.contexts.webWorker.vendor,
+ e.contexts.webWorker.renderer
+ ].map((u) => String(u)).join("|"), re = f(te).slice(0, 6), ne = `${ee}h${re}`;
+ return [
+ i,
+ g,
+ o,
+ I,
+ U,
+ V,
+ Q,
+ X,
+ ne
+ ].join("_");
+ } catch (e) {
+ return console.error("Error generating fingerprint scanner id", e), l;
+ }
+ }
+ async encryptFingerprint(e) {
+ const n = "__DEFAULT_FPSCANNER_KEY__";
+ return n.length > 20 && n.indexOf("DEFAULT") > 0 && n.indexOf("FPSCANNER") > 0 && console.warn(
+ '[fpscanner] WARNING: Using default encryption key! Run "npx fpscanner build --key=your-secret-key" to inject your own key. See: https://github.com/antoinevastel/fpscanner#advanced-custom-builds'
+ ), await pt(JSON.stringify(e), n);
+ }
+ /**
+ * Detection rules with name and severity.
+ */
+ getDetectionRules() {
+ return [
+ { name: "headlessChromeScreenResolution", severity: h, test: $e },
+ { name: "hasWebdriver", severity: h, test: Qe },
+ { name: "hasWebdriverWritable", severity: h, test: st },
+ { name: "hasSeleniumProperty", severity: h, test: qe },
+ { name: "hasCDP", severity: h, test: Ke },
+ { name: "hasPlaywright", severity: h, test: Je },
+ { name: "hasImpossibleDeviceMemory", severity: h, test: Ye },
+ { name: "hasHighCPUCount", severity: h, test: Ze },
+ { name: "hasMissingChromeObject", severity: h, test: et },
+ { name: "hasWebdriverIframe", severity: h, test: tt },
+ { name: "hasWebdriverWorker", severity: h, test: rt },
+ { name: "hasMismatchWebGLInWorker", severity: h, test: nt },
+ { name: "hasMismatchPlatformIframe", severity: h, test: ot },
+ { name: "hasMismatchPlatformWorker", severity: h, test: at },
+ { name: "hasSwiftshaderRenderer", severity: S, test: ct },
+ { name: "hasUTCTimezone", severity: se, test: lt },
+ { name: "hasMismatchLanguages", severity: S, test: ut },
+ { name: "hasInconsistentEtsl", severity: h, test: dt },
+ { name: "hasBotUserAgent", severity: h, test: gt },
+ { name: "hasGPUMismatch", severity: h, test: ht },
+ { name: "hasPlatformMismatch", severity: h, test: mt }
+ ];
+ }
+ runDetectionRules() {
+ const e = this.getDetectionRules(), n = {
+ headlessChromeScreenResolution: { detected: !1, severity: "high" },
+ hasWebdriver: { detected: !1, severity: "high" },
+ hasWebdriverWritable: { detected: !1, severity: "high" },
+ hasSeleniumProperty: { detected: !1, severity: "high" },
+ hasCDP: { detected: !1, severity: "high" },
+ hasPlaywright: { detected: !1, severity: "high" },
+ hasImpossibleDeviceMemory: { detected: !1, severity: "high" },
+ hasHighCPUCount: { detected: !1, severity: "high" },
+ hasMissingChromeObject: { detected: !1, severity: "high" },
+ hasWebdriverIframe: { detected: !1, severity: "high" },
+ hasWebdriverWorker: { detected: !1, severity: "high" },
+ hasMismatchWebGLInWorker: { detected: !1, severity: "high" },
+ hasMismatchPlatformIframe: { detected: !1, severity: "high" },
+ hasMismatchPlatformWorker: { detected: !1, severity: "high" },
+ hasSwiftshaderRenderer: { detected: !1, severity: "low" },
+ hasUTCTimezone: { detected: !1, severity: "medium" },
+ hasMismatchLanguages: { detected: !1, severity: "low" },
+ hasInconsistentEtsl: { detected: !1, severity: "high" },
+ hasBotUserAgent: { detected: !1, severity: "high" },
+ hasGPUMismatch: { detected: !1, severity: "high" },
+ hasPlatformMismatch: { detected: !1, severity: "high" }
+ };
+ for (const i of e)
+ try {
+ const a = i.test(this.fingerprint);
+ n[i.name] = { detected: a, severity: i.severity };
+ } catch {
+ n[i.name] = { detected: !1, severity: i.severity };
+ }
+ return n;
+ }
+ async collectFingerprint(e = { encrypt: !0 }) {
+ const { encrypt: n = !0, skipWorker: i = !1 } = e, a = this.fingerprint.signals, g = {
+ // Automation signals
+ webdriver: this.collectSignal(ie),
+ webdriverWritable: this.collectSignal(Se),
+ selenium: this.collectSignal(be),
+ cdp: this.collectSignal(le),
+ playwright: this.collectSignal(de),
+ navigatorPropertyDescriptors: this.collectSignal(He),
+ // Device signals
+ cpuCount: this.collectSignal(ge),
+ memory: this.collectSignal(me),
+ platform: this.collectSignal(oe),
+ screenResolution: this.collectSignal(ve),
+ multimediaDevices: this.collectSignal(Ee),
+ mediaQueries: this.collectSignal(Ve),
+ keyboard: this.collectSignal(Be),
+ // Browser signals
+ userAgent: this.collectSignal(ae),
+ browserFeatures: this.collectSignal(Ge),
+ plugins: this.collectSignal(We),
+ browserExtensions: this.collectSignal(Fe),
+ highEntropyValues: this.collectSignal(Ce),
+ etsl: this.collectSignal(pe),
+ maths: this.collectSignal(he),
+ toSourceError: this.collectSignal(Re),
+ ai: this.collectSignal(je),
+ // Graphics signals
+ webGL: this.collectSignal(ue),
+ webgpu: this.collectSignal(we),
+ canvas: this.collectSignal(Oe),
+ // Codecs
+ mediaCodecs: this.collectSignal(Ie),
+ // Locale signals
+ internationalization: this.collectSignal(fe),
+ languages: this.collectSignal(ye),
+ // Context signals
+ iframe: this.collectSignal(De),
+ webWorker: i ? Promise.resolve({
+ webdriver: v,
+ userAgent: v,
+ platform: v,
+ memory: v,
+ cpuCount: v,
+ language: v,
+ vendor: v,
+ renderer: v
+ }) : this.collectSignal(_e),
+ // Meta signals
+ nonce: this.collectSignal(ze),
+ time: this.collectSignal(Ue),
+ url: this.collectSignal(Ne)
+ }, p = Object.keys(g), y = await Promise.all(Object.values(g)), o = Object.fromEntries(p.map((m, w) => [m, y[w]]));
+ return a.automation.webdriver = o.webdriver, a.automation.webdriverWritable = o.webdriverWritable, a.automation.selenium = o.selenium, a.automation.cdp = o.cdp, a.automation.playwright = o.playwright, a.automation.navigatorPropertyDescriptors = o.navigatorPropertyDescriptors, a.device.cpuCount = o.cpuCount, a.device.memory = o.memory, a.device.platform = o.platform, a.device.screenResolution = o.screenResolution, a.device.multimediaDevices = o.multimediaDevices, a.device.mediaQueries = o.mediaQueries, a.device.keyboard = o.keyboard, a.browser.userAgent = o.userAgent, a.browser.features = o.browserFeatures, a.browser.plugins = o.plugins, a.browser.extensions = o.browserExtensions, a.browser.highEntropyValues = o.highEntropyValues, a.browser.etsl = o.etsl, a.browser.maths = o.maths, a.browser.toSourceError = o.toSourceError, a.browser.ai = o.ai, a.graphics.webGL = o.webGL, a.graphics.webgpu = o.webgpu, a.graphics.canvas = o.canvas, a.codecs = o.mediaCodecs, a.locale.internationalization = o.internationalization, a.locale.languages = o.languages, a.contexts.iframe = o.iframe, a.contexts.webWorker = o.webWorker, this.fingerprint.nonce = o.nonce, this.fingerprint.time = o.time, this.fingerprint.url = o.url, this.fingerprint.fastBotDetectionDetails = this.runDetectionRules(), this.fingerprint.fastBotDetection = Object.values(this.fingerprint.fastBotDetectionDetails).some((m) => m.detected), this.fingerprint.fsid = this.generateFingerprintScannerId(), n ? await this.encryptFingerprint(JSON.stringify(this.fingerprint)) : this.fingerprint;
+ }
+}
+export {
+ vt as default
+};