Download web/scanner.js from devmandan/qr-scan-difficulty-check: direct link, hf CLI and curl.
- Browser
- Download file 13.8 kB
-
https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/web/scanner.js
- Command line
-
hf download hf://spaces/devmandan/qr-scan-difficulty-check/web/scanner.js
-
curl -L -o scanner.js https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/web/scanner.js
13.8 kB
| // This browser's own scanner in a design test. Whether the browser has one the test can use is found once a page | |
| // session, sending nothing (the probe and its working check), and it is named by platform. In a test it reads the | |
| // scenes' rebuilt frames (frames.js), the plain code's and the design's, as they arrive, and stops once no reads of | |
| // the scenes left could change its answer (the exact early stop), or when the scans come too slowly for the budget. | |
| // The rule every scanner is judged by is here too, as the server has it. What this scanner reads stays in the page. | |
| import { CAPTURE, FRAME, decodeGrey, ending, fetchScene, linked, sha256Hex, toBitmap } from './frames.js'; | |
| let T = null; // web/data/test.json (useTest) | |
| let C = null; // binomial coefficients C[n][k], for n up to the test's scenes | |
| const encoder = new TextEncoder(); | |
| /** test.js, before useTest: what the code relies on in test.json: whole numbers where it counts, the frame sizes the | |
| * shrink is exact for, and a sign test whose alpha is one over a whole number. */ | |
| export function fits(s) { | |
| const whole = (...xs) => xs.every((x) => Number.isInteger(x) && x >= 0); | |
| const pair = (a, b) => Array.isArray(a) && a[0] === b[0] && a[1] === b[1]; | |
| const inv = 1 / s.rule.alpha; | |
| return typeof s.page === 'boolean' && whole(s.scenes.s, s.rule.like_cost, s.rule.q, s.join, s.limits.max_version) | |
| && s.scenes.s >= 1 && s.scenes.s <= 20 && Math.abs(inv - Math.round(inv)) < 1e-9 && pair(s.frames.capture, CAPTURE) | |
| && pair(s.frames.frame, FRAME) && Boolean(s.check.png && s.check.jpeg && s.mb.jpeg && s.mb.png && s.figures); | |
| } | |
| /** test.js, once test.json is in: the settings everything here reads. */ | |
| export function useTest(settings) { | |
| T = settings; | |
| C = [[1]]; | |
| for (let n = 1; n <= T.scenes.s; n += 1) C.push(C[n - 1].map((v, k) => v + (C[n - 1][k - 1] || 0)).concat(1)); | |
| } | |
| // ---- the rule, per scanner, over the paired scenes ----------------------------------------------------------------- | |
| /** The one-sided exact sign test on (b, c) under the rule's alpha, in whole numbers: sum over k = b..n of C(n, k), | |
| * times 1 / alpha, under 2^n (n = b + c), so this and the server's never round differently. */ | |
| const under = (b, c) => Math.round(1 / T.rule.alpha) * C[b + c].slice(b).reduce((sum, v) => sum + v, 0) < 2 ** (b + c); | |
| /** One scanner's answer: b counts the scenes where it read the plain code and missed the design, c the reverse, t | |
| * and d the scenes where it read the plain code and the design. 'worse' when the sign test confirms the loss; 'like' | |
| * (as well as a plain code) with a cost b - c of at most like_cost, and t or d at least q; otherwise it can't tell: | |
| * 'close' with a higher cost, else 'few'. */ | |
| export function answer(b, c, t, d) { | |
| const { like_cost: cost, q } = T.rule; | |
| if (under(b, c)) return 'worse'; | |
| if (b - c <= cost && (t >= q || d >= q)) return 'like'; | |
| return b - c > cost ? 'close' : 'few'; | |
| } | |
| /** The answer once no reads of the r scenes left could change it, else null: the exact early stop in closed form | |
| * (equal to trying every way the scenes left could read). At r = 0 it is the answer itself. */ | |
| export function settled(b, c, t, d, r) { | |
| const { like_cost: cost, q } = T.rule; | |
| if (r === 0) return answer(b, c, t, d); | |
| if (under(b, c + r)) return 'worse'; | |
| if ((t >= q || d >= q) && b - c + r <= cost) return 'like'; | |
| if (b - c - r > cost && !under(b + r, c)) return 'close'; | |
| if (b - c + r <= cost && t + r < q && d + r < q) return 'few'; | |
| return null; | |
| } | |
| // ---- the probe: once a page session, sending nothing ---------------------------------------------------------------- | |
| let probing = null; | |
| let found = { state: 'pending' }; | |
| /** Whether this browser has a scanner the test can use: { state: 'ready', name: 'apple' | 'google', frames: 'jpeg' | | |
| * 'png' }, 'none' with the step that failed (1: no BarcodeDetector here, 2: not Google Chrome on macOS or Android, | |
| * 3: it lists no QR codes), 'broken' (the working check's read failed) or 'blocked' (this browser's canvas reads are | |
| * altered or blocked). Run once a page session, when a picture is first marked The original graphic. */ | |
| export function probe() { | |
| probing ||= steps().catch(() => ({ state: 'none', step: 1 })).then((r) => { found = r; return r; }); | |
| return probing; | |
| } | |
| /** The probe's result so far: { state: 'pending' } until it has one. */ | |
| export const probed = () => found; | |
| async function steps() { | |
| if (!(window.isSecureContext && 'BarcodeDetector' in window)) return { state: 'none', step: 1 }; | |
| if (!platformName()) return { state: 'none', step: 2 }; | |
| let formats = []; | |
| try { formats = await BarcodeDetector.getSupportedFormats(); } catch { /* none listed */ } | |
| if (!Array.isArray(formats) || !formats.includes('qr_code')) return { state: 'none', step: 3 }; | |
| return check(); | |
| } | |
| /** After 'broken', a test's start runs the working check again (local, with the same two pictures), so the next test | |
| * or Try again can bring the scanner back; any other result stands for the page session. */ | |
| export async function recheck() { | |
| if (found.state === 'broken') found = await check(); | |
| return found; | |
| } | |
| /** 'apple' or 'google' for Google Chrome on macOS or on Android, from userAgentData's brands and platform (never its | |
| * high-entropy hints, which the Hub's iframe may not pass), else ''. */ | |
| function platformName() { | |
| const ua = navigator.userAgentData; | |
| const { brand, platforms } = T.browsers; | |
| const chrome = Array.isArray(ua?.brands) && ua.brands.some((b) => b.brand === brand); | |
| return chrome && Object.hasOwn(platforms, ua.platform) ? platforms[ua.platform] : ''; | |
| } | |
| /** Which words fit this browser: 'chrome-mac', 'chrome-android', 'mac' (a Mac, not Chrome: "Macintosh" with no touch | |
| * points, so an iPad isn't taken for one) or 'other'. It only chooses words. */ | |
| export function platformKind() { | |
| if (platformName()) return navigator.userAgentData.platform === 'Android' ? 'chrome-android' : 'chrome-mac'; | |
| return /Macintosh/.test(navigator.userAgent) && navigator.maxTouchPoints === 0 ? 'mac' : 'other'; | |
| } | |
| /** Whether this browser's scanner can read a test's code, given whether its two truths differ (differ: the SHA-256 of | |
| * its raw bytes, then of its text in UTF-8, from the 202, or before it where the first reading shows it, test_turn.js | |
| * rawNotText): in Chrome on Android only when they don't, raw bytes that are UTF-8 text; elsewhere always. Chrome 113 | |
| * on Android crashed its GPU process on every other code measured (detect rejected with NotSupportedError, each | |
| * time), so trying again can't help there. */ | |
| export const readsContent = (differ) => platformKind() !== 'chrome-android' || !differ; | |
| /** Whether this browser asks to save data: read at every test's start, so turning it off and Try again bring the | |
| * scanner in. */ | |
| export const saveDataOn = () => navigator.connection?.saveData === true; | |
| /** What this browser's scanner does in a test (rec: test.js's record; joins: tests it joined by itself so far this | |
| * page session), from the probe's result: { decision, name, frames }. It joins (with its frames: 'jpeg', or 'png' | |
| * when this browser decodes JPEG differently); is offered, once a page session's first {join} tests have taken it | |
| * by themselves, unless Add was pressed or this test's first decision was to join; is kept out by Save-Data; or | |
| * isn't in the test: 'late' (the probe not done in time), 'broken', 'none' or 'blocked'. A code the record already | |
| * knows this scanner can't read (readsContent) gives 'none' from the start, whatever the probe found. */ | |
| export function partFor(rec, joins, pr = found) { | |
| const part = { name: pr.name || platformName(), frames: pr.frames || 'jpeg' }; | |
| if (!readsContent(rec.truthsDiffer)) part.decision = 'none'; | |
| else if (pr.state !== 'ready') part.decision = pr.state === 'pending' ? 'late' : pr.state; | |
| else if (saveDataOn()) part.decision = 'save_data'; | |
| else part.decision = rec.added || rec.first === 'joins' || joins < T.join ? 'joins' : 'offered'; | |
| return part; | |
| } | |
| /** At a test's start: the probe, waited for at most probe_wait_s, and after 'broken' the working check again. */ | |
| export async function decide(rec, joins) { | |
| if (found.state === 'pending') await Promise.race([probe(), wait(T.page_waits.probe_wait_s * 1000)]); | |
| if (found.state === 'broken') await recheck(); | |
| return partFor(rec, joins); | |
| } | |
| const bytesOf = (b64) => Uint8Array.from(atob(b64), (ch) => ch.charCodeAt(0)); | |
| const wait = (ms) => new Promise((resolve) => { setTimeout(resolve, ms); }); | |
| /** The working check, on test.json's two pictures, decoded along the frames' own path: the plain code's PNG must | |
| * give its pinned grey bytes (else 'blocked': this browser's canvas reads are altered or blocked, as a readback that | |
| * throws is), and a new detector must read its known content (else 'broken'); either is tried once more after | |
| * check_retry_s. A JPEG that decodes to other bytes keeps the scanner, with PNG frames from the start. */ | |
| async function check() { | |
| let got = await checkOnce(); | |
| if (got.state !== 'ready') { | |
| await wait(T.page_waits.check_retry_s * 1000); | |
| got = await checkOnce(); | |
| } | |
| return got; | |
| } | |
| async function checkOnce() { | |
| const { png, jpeg } = T.check; | |
| let code; | |
| let frames = 'jpeg'; | |
| try { | |
| code = await decodeGrey(bytesOf(png.b64), 'image/png', png.w, png.h); | |
| if ((await sha256Hex(code)) !== png.grey_sha256) return { state: 'blocked' }; | |
| const scene = await decodeGrey(bytesOf(jpeg.b64), 'image/jpeg', jpeg.w, jpeg.h); | |
| if ((await sha256Hex(scene)) !== jpeg.grey_sha256) frames = 'png'; | |
| } catch { | |
| return { state: 'blocked' }; | |
| } | |
| try { | |
| const detector = new BarcodeDetector({ formats: ['qr_code'] }); | |
| if (!(await reads(detector, code, png.w, png.h, [png.content_sha256]))) return { state: 'broken' }; | |
| } catch { | |
| return { state: 'broken' }; | |
| } | |
| return { state: 'ready', name: platformName(), frames }; | |
| } | |
| /** Whether the detector reads one of truths (the content's UTF-8 SHA-256s) from grey bytes, through an ImageBitmap | |
| * of them; throws when detect throws, or takes over detect_s. */ | |
| async function reads(detector, grey, w, h, truths) { | |
| const bitmap = await toBitmap(grey, w, h); | |
| const detecting = detector.detect(bitmap); | |
| detecting.then(() => bitmap.close(), () => bitmap.close()); | |
| let timer = 0; | |
| const late = new Promise((resolve, reject) => { | |
| timer = setTimeout(() => reject(new Error('detect')), T.budget.detect_s * 1000); | |
| }); | |
| try { | |
| const codes = await Promise.race([detecting, late]); | |
| for (const code of codes) if (truths.includes(await sha256Hex(encoder.encode(code.rawValue)))) return true; | |
| return false; | |
| } finally { | |
| clearTimeout(timer); | |
| } | |
| } | |
| // ---- the browser's part of one test -------------------------------------------------------------------------------- | |
| /** The browser's part of a test. opts: base (the test's routes), truths, mode ('jpeg' or 'png': the probe's frames), | |
| * signal (aborted when the page leaves the test, or Leave it out is pressed), onScene(k) after each whole scene, and | |
| * onMode('png') once the rest of the test takes PNG frames. One detector reads every frame; one scene is in hand and | |
| * the next in flight. The budget counts only the pictures' fetches: after project_after_scenes scenes, and after | |
| * each one from then on, the part stops when the time they took, projected over every scene from the link's own | |
| * pace, passes fetch_s (it can't count on an early stop), and at once when they reach it. Resolves to { end, answer }: | |
| * 'settled' (the early stop) or 'complete', with the scanner's answer; 'start', 'stopped' or 'slow' (a fallback); | |
| * 'dropped' (the server no longer has the test); or 'aborted'. Never rejects. */ | |
| export async function runBrowserPart(opts) { | |
| const n = T.scenes.s; | |
| const [w, h] = FRAME; | |
| const B = T.budget; | |
| const meter = { | |
| bytes: 0, ms: 0, scenes: 0, limit: B.fetch_s * 1000, tries: B.fetch_tries, wait: T.page_waits.scene_retry_s * 1000, | |
| hold: 2 * T.server.scene_wait_s * 1000, // facts come within scene_wait_s, a 503 included: twice that is a stall | |
| }; | |
| let detector; | |
| try { | |
| detector = new BarcodeDetector({ formats: ['qr_code'] }); | |
| } catch { | |
| return { end: 'start' }; | |
| } | |
| let mode = opts.mode; | |
| const fetchOne = (i) => { | |
| const ctl = linked(opts.signal); | |
| const job = fetchScene(opts.base, i, mode, ctl.signal, meter); | |
| job.catch(() => {}); // awaited in turn, or aborted unread | |
| return { ctl, job }; | |
| }; | |
| let next = fetchOne(0); | |
| let b = 0; | |
| let c = 0; | |
| let t = 0; | |
| let d = 0; | |
| try { | |
| for (let i = 0; i < n; i += 1) { | |
| const scene = await next.job; | |
| if (scene.switched && mode === 'jpeg') { | |
| mode = 'png'; | |
| opts.onMode('png'); | |
| } | |
| next = i + 1 < n ? fetchOne(i + 1) : null; // in flight while this scene is read, so a switch wastes nothing | |
| const plain = await reads(detector, scene.plain, w, h, opts.truths); | |
| const design = await reads(detector, scene.design, w, h, opts.truths); | |
| if (opts.signal.aborted) throw ending('aborted'); | |
| b += plain && !design; | |
| c += design && !plain; | |
| t += plain; | |
| d += design; | |
| const k = i + 1; | |
| opts.onScene(k); | |
| const a = settled(b, c, t, d, n - k); | |
| if (a) { | |
| next?.ctl.abort(); | |
| return { end: k === n ? 'complete' : 'settled', answer: a }; | |
| } | |
| if (k >= B.project_after_scenes && (meter.ms * n) / Math.max(1, meter.scenes) > meter.limit) { | |
| next?.ctl.abort(); | |
| return { end: 'slow' }; | |
| } | |
| } | |
| } catch (err) { | |
| next?.ctl.abort(); | |
| return { end: err.end || (opts.signal.aborted ? 'aborted' : 'stopped') }; | |
| } | |
| return { end: 'stopped' }; // not reached: the last scene always settles | |
| } | |