Add asset verification feature with user preferences

- Introduced a new verification system for asset downloads, allowing users to choose whether to verify assets before downloading.
- Added a `VerificationModal` component to handle the verification process and user preferences.
- Implemented a `verificationStore` to manage the state of verification toasts and progress.
- Updated `SoftwareCard` to trigger background verification based on user preferences stored in local storage.
- Created `VerificationToasts` component to display real-time verification status and progress.
- Enhanced the WASM verifier integration to support the new verification workflow.

frontend/eslint.config.js

@@ -32,6 +32,8 @@ export default [
 				Uint8Array: 'readonly',
 				ArrayBuffer: 'readonly',
 				URL: 'readonly',
+				setTimeout: 'readonly',
+				setInterval: 'readonly',
 			},
 		},
 		plugins: {

frontend/src/lib/components/SoftwareCard.svelte

@@ -21,6 +21,7 @@
 	} from 'lucide-svelte';
 	import type { Software, Asset } from '$lib/types';
 	import VerificationModal from './VerificationModal.svelte';
+	import { backgroundVerify } from '$lib/verificationStore';
 
 	interface Props {
 		software: Software;
@@ -101,6 +102,17 @@
 
 	function handleDownload(e: MouseEvent, asset: Asset) {
 		if (asset.sha256) {
+			const preference = localStorage.getItem('verification_preference');
+
+			if (preference === 'accept') {
+				e.preventDefault();
+				backgroundVerify(asset.name, asset.url, asset.sha256);
+				return;
+			} else if (preference === 'decline') {
+				// Let the default download happen
+				return;
+			}
+
 			e.preventDefault();
 			activeVerification = {
 				name: asset.name,

frontend/src/lib/components/VerificationModal.svelte

@@ -10,12 +10,20 @@
 	}
 
 	let { assetName, assetUrl, expectedHash, onClose }: Props = $props();
+	let dontShowAgain = $state(false);
 
 	let status = $state<'idle' | 'downloading' | 'verifying' | 'success' | 'error'>('idle');
 	let errorMessage = $state('');
 	let progress = $state(0);
 
+	function savePreference(accepted: boolean) {
+		if (dontShowAgain) {
+			localStorage.setItem('verification_preference', accepted ? 'accept' : 'decline');
+		}
+	}
+
 	async function startVerification() {
+		savePreference(true);
 		status = 'downloading';
 		try {
 			const response = await fetch(assetUrl);
@@ -23,6 +31,7 @@
 
 			const contentLength = response.headers.get('content-length');
 			const total = contentLength ? parseInt(contentLength, 10) : 0;
+			const contentType = response.headers.get('content-type') || 'application/octet-stream';
 
 			const reader = response.body?.getReader();
 			if (!reader) throw new Error('Failed to read response body');
@@ -51,7 +60,7 @@
 			if (result === true) {
 				status = 'success';
 				// Trigger actual download from the blob
-				const blob = new Blob([data]);
+				const blob = new Blob([data], { type: contentType });
 				const url = window.URL.createObjectURL(blob);
 				const a = document.createElement('a');
 				a.href = url;
@@ -71,7 +80,13 @@
 	}
 
 	function skipVerification() {
-		window.location.href = assetUrl;
+		savePreference(false);
+		const a = document.createElement('a');
+		a.href = assetUrl;
+		a.download = assetName;
+		document.body.appendChild(a);
+		a.click();
+		document.body.removeChild(a);
 		onClose();
 	}
 </script>
@@ -122,6 +137,30 @@
 							Download without verification
 						</button>
 					</div>
+
+					<div class="flex items-center gap-2 mt-4 pt-4 border-t border-border">
+						<label class="flex items-center gap-2 cursor-pointer group">
+							<div class="relative flex items-center">
+								<input type="checkbox" bind:checked={dontShowAgain} class="peer sr-only" />
+								<div
+									class="w-4 h-4 rounded border border-input bg-background peer-checked:bg-primary peer-checked:border-primary transition-all"
+								></div>
+								<svg
+									class="absolute w-3 h-3 text-primary-foreground opacity-0 peer-checked:opacity-100 transition-opacity left-0.5"
+									fill="none"
+									viewBox="0 0 24 24"
+									stroke="currentColor"
+									stroke-width="4"
+								>
+									<path d="M5 13l4 4L19 7" />
+								</svg>
+							</div>
+							<span
+								class="text-xs text-muted-foreground group-hover:text-foreground transition-colors"
+								>Don't show this again</span
+							>
+						</label>
+					</div>
 				{:else if status === 'downloading' || status === 'verifying'}
 					<div class="py-8 flex flex-col items-center justify-center gap-4">
 						<div class="relative w-16 h-16">

frontend/src/lib/components/VerificationToasts.svelte

@@ -0,0 +1,74 @@
+<script lang="ts">
+	import { verificationToasts, removeToast } from '$lib/verificationStore';
+	import { Shield, ShieldCheck, ShieldAlert, Loader2, X } from 'lucide-svelte';
+	import { flip } from 'svelte/animate';
+	import { fade, fly } from 'svelte/transition';
+</script>
+
+<div class="fixed bottom-4 right-4 z-[110] flex flex-col-reverse gap-3 pointer-events-none">
+	{#each $verificationToasts as toast (toast.id)}
+		<div
+			animate:flip={{ duration: 300 }}
+			in:fly={{ y: 20, opacity: 0 }}
+			out:fade
+			class="w-80 bg-card border border-border rounded-xl shadow-lg overflow-hidden pointer-events-auto"
+		>
+			<div class="p-4">
+				<div class="flex items-start justify-between gap-3">
+					<div class="flex items-center gap-3 min-w-0">
+						<div
+							class="p-2 rounded-lg {toast.status === 'success'
+								? 'bg-green-500/10 text-green-500'
+								: toast.status === 'error'
+									? 'bg-destructive/10 text-destructive'
+									: 'bg-primary/10 text-primary'}"
+						>
+							{#if toast.status === 'downloading' || toast.status === 'verifying'}
+								<Loader2 class="w-4 h-4 animate-spin" />
+							{:else if toast.status === 'success'}
+								<ShieldCheck class="w-4 h-4" />
+							{:else if toast.status === 'error'}
+								<ShieldAlert class="w-4 h-4" />
+							{:else}
+								<Shield class="w-4 h-4" />
+							{/if}
+						</div>
+						<div class="min-w-0">
+							<p class="text-xs font-bold truncate">{toast.assetName}</p>
+							<p class="text-[10px] text-muted-foreground">
+								{#if toast.status === 'downloading'}
+									Downloading ({toast.progress}%)
+								{:else if toast.status === 'verifying'}
+									Verifying Checksum...
+								{:else if toast.status === 'success'}
+									Verified & Downloading
+								{:else if toast.status === 'error'}
+									Verification Failed
+								{/if}
+							</p>
+						</div>
+					</div>
+					<button
+						onclick={() => removeToast(toast.id)}
+						class="p-1 hover:bg-muted rounded-md transition-colors text-muted-foreground"
+					>
+						<X class="w-3.5 h-3.5" />
+					</button>
+				</div>
+
+				{#if toast.status === 'downloading'}
+					<div class="mt-3 w-full bg-muted rounded-full h-1 overflow-hidden">
+						<div
+							class="bg-primary h-full transition-all duration-300"
+							style="width: {toast.progress}%"
+						></div>
+					</div>
+				{:else if toast.status === 'error'}
+					<p class="mt-2 text-[9px] text-destructive leading-tight line-clamp-2">
+						{toast.errorMessage}
+					</p>
+				{/if}
+			</div>
+		</div>
+	{/each}
+</div>

frontend/src/lib/verificationStore.ts

@@ -0,0 +1,93 @@
+import { writable } from 'svelte/store';
+import { verifyAsset } from './verifier';
+
+export type VerificationStatus = 'idle' | 'downloading' | 'verifying' | 'success' | 'error';
+
+export interface VerificationToast {
+	id: string;
+	assetName: string;
+	status: VerificationStatus;
+	progress: number;
+	errorMessage?: string;
+}
+
+export const verificationToasts = writable<VerificationToast[]>([]);
+
+export function addToast(assetName: string) {
+	const id = Math.random().toString(36).substring(7);
+	verificationToasts.update((toasts) => {
+		const newToast: VerificationToast = { id, assetName, status: 'downloading', progress: 0 };
+		const newToasts = [newToast, ...toasts];
+		return newToasts.slice(0, 4); // Max 4 toasts
+	});
+	return id;
+}
+
+export function updateToast(id: string, updates: Partial<VerificationToast>) {
+	verificationToasts.update((toasts) =>
+		toasts.map((t) => (t.id === id ? { ...t, ...updates } : t))
+	);
+}
+
+export function removeToast(id: string) {
+	verificationToasts.update((toasts) => toasts.filter((t) => t.id !== id));
+}
+
+export async function backgroundVerify(assetName: string, assetUrl: string, expectedHash: string) {
+	const id = addToast(assetName);
+
+	try {
+		const response = await fetch(assetUrl);
+		if (!response.ok) throw new Error('Download failed');
+
+		const contentLength = response.headers.get('content-length');
+		const total = contentLength ? parseInt(contentLength, 10) : 0;
+		const contentType = response.headers.get('content-type') || 'application/octet-stream';
+
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error('Failed to read response body');
+
+		let receivedLength = 0;
+		const chunks = [];
+
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			chunks.push(value);
+			receivedLength += value.length;
+			if (total) {
+				updateToast(id, { progress: Math.round((receivedLength / total) * 100) });
+			}
+		}
+
+		const data = new Uint8Array(receivedLength);
+		let position = 0;
+		for (const chunk of chunks) {
+			data.set(chunk, position);
+			position += chunk.length;
+		}
+
+		updateToast(id, { status: 'verifying' });
+		const result = await verifyAsset(data.buffer, expectedHash);
+
+		if (result === true) {
+			updateToast(id, { status: 'success' });
+			const blob = new Blob([data], { type: contentType });
+			const url = window.URL.createObjectURL(blob);
+			const a = document.createElement('a');
+			a.href = url;
+			a.download = assetName;
+			document.body.appendChild(a);
+			a.click();
+			window.URL.revokeObjectURL(url);
+			document.body.removeChild(a);
+
+			// Remove success toast after some time
+			setTimeout(() => removeToast(id), 5000);
+		} else {
+			updateToast(id, { status: 'error', errorMessage: result });
+		}
+	} catch (e: any) {
+		updateToast(id, { status: 'error', errorMessage: e.message });
+	}
+}

frontend/src/routes/+layout.svelte

@@ -5,6 +5,7 @@
 	import { Moon, Sun, Languages, Rss } from 'lucide-svelte';
 	import { locale, waitLocale, locales, t } from 'svelte-i18n';
 	import { version } from '../../package.json';
+	import VerificationToasts from '$lib/components/VerificationToasts.svelte';
 
 	let { children } = $props();
 
@@ -106,6 +107,8 @@
 			{@render children()}
 		</main>
 
+		<VerificationToasts />
+
 		<footer class="border-t border-border mt-auto pt-6 pb-4">
 			<div class="max-w-[1600px] mx-auto px-4 text-center space-y-3">
 				<div class="flex flex-wrap justify-center gap-x-6 gap-y-2 text-sm font-medium">

frontend/static/verifier/wasm_exec.js

@@ -2,30 +2,22 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-'use strict';
+"use strict";
 
 (() => {
 	const enosys = () => {
-		const err = new Error('not implemented');
-		err.code = 'ENOSYS';
+		const err = new Error("not implemented");
+		err.code = "ENOSYS";
 		return err;
 	};
 
 	if (!globalThis.fs) {
-		let outputBuf = '';
+		let outputBuf = "";
 		globalThis.fs = {
-			constants: {
-				O_WRONLY: -1,
-				O_RDWR: -1,
-				O_CREAT: -1,
-				O_TRUNC: -1,
-				O_APPEND: -1,
-				O_EXCL: -1,
-				O_DIRECTORY: -1,
-			}, // unused
+			constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1, O_DIRECTORY: -1 }, // unused
 			writeSync(fd, buf) {
 				outputBuf += decoder.decode(buf);
-				const nl = outputBuf.lastIndexOf('\n');
+				const nl = outputBuf.lastIndexOf("\n");
 				if (nl != -1) {
 					console.log(outputBuf.substring(0, nl));
 					outputBuf = outputBuf.substring(nl + 1);
@@ -40,147 +32,81 @@
 				const n = this.writeSync(fd, buf);
 				callback(null, n);
 			},
-			chmod(path, mode, callback) {
-				callback(enosys());
-			},
-			chown(path, uid, gid, callback) {
-				callback(enosys());
-			},
-			close(fd, callback) {
-				callback(enosys());
-			},
-			fchmod(fd, mode, callback) {
-				callback(enosys());
-			},
-			fchown(fd, uid, gid, callback) {
-				callback(enosys());
-			},
-			fstat(fd, callback) {
-				callback(enosys());
-			},
-			fsync(fd, callback) {
-				callback(null);
-			},
-			ftruncate(fd, length, callback) {
-				callback(enosys());
-			},
-			lchown(path, uid, gid, callback) {
-				callback(enosys());
-			},
-			link(path, link, callback) {
-				callback(enosys());
-			},
-			lstat(path, callback) {
-				callback(enosys());
-			},
-			mkdir(path, perm, callback) {
-				callback(enosys());
-			},
-			open(path, flags, mode, callback) {
-				callback(enosys());
-			},
-			read(fd, buffer, offset, length, position, callback) {
-				callback(enosys());
-			},
-			readdir(path, callback) {
-				callback(enosys());
-			},
-			readlink(path, callback) {
-				callback(enosys());
-			},
-			rename(from, to, callback) {
-				callback(enosys());
-			},
-			rmdir(path, callback) {
-				callback(enosys());
-			},
-			stat(path, callback) {
-				callback(enosys());
-			},
-			symlink(path, link, callback) {
-				callback(enosys());
-			},
-			truncate(path, length, callback) {
-				callback(enosys());
-			},
-			unlink(path, callback) {
-				callback(enosys());
-			},
-			utimes(path, atime, mtime, callback) {
-				callback(enosys());
-			},
+			chmod(path, mode, callback) { callback(enosys()); },
+			chown(path, uid, gid, callback) { callback(enosys()); },
+			close(fd, callback) { callback(enosys()); },
+			fchmod(fd, mode, callback) { callback(enosys()); },
+			fchown(fd, uid, gid, callback) { callback(enosys()); },
+			fstat(fd, callback) { callback(enosys()); },
+			fsync(fd, callback) { callback(null); },
+			ftruncate(fd, length, callback) { callback(enosys()); },
+			lchown(path, uid, gid, callback) { callback(enosys()); },
+			link(path, link, callback) { callback(enosys()); },
+			lstat(path, callback) { callback(enosys()); },
+			mkdir(path, perm, callback) { callback(enosys()); },
+			open(path, flags, mode, callback) { callback(enosys()); },
+			read(fd, buffer, offset, length, position, callback) { callback(enosys()); },
+			readdir(path, callback) { callback(enosys()); },
+			readlink(path, callback) { callback(enosys()); },
+			rename(from, to, callback) { callback(enosys()); },
+			rmdir(path, callback) { callback(enosys()); },
+			stat(path, callback) { callback(enosys()); },
+			symlink(path, link, callback) { callback(enosys()); },
+			truncate(path, length, callback) { callback(enosys()); },
+			unlink(path, callback) { callback(enosys()); },
+			utimes(path, atime, mtime, callback) { callback(enosys()); },
 		};
 	}
 
 	if (!globalThis.process) {
 		globalThis.process = {
-			getuid() {
-				return -1;
-			},
-			getgid() {
-				return -1;
-			},
-			geteuid() {
-				return -1;
-			},
-			getegid() {
-				return -1;
-			},
-			getgroups() {
-				throw enosys();
-			},
+			getuid() { return -1; },
+			getgid() { return -1; },
+			geteuid() { return -1; },
+			getegid() { return -1; },
+			getgroups() { throw enosys(); },
 			pid: -1,
 			ppid: -1,
-			umask() {
-				throw enosys();
-			},
-			cwd() {
-				throw enosys();
-			},
-			chdir() {
-				throw enosys();
-			},
-		};
+			umask() { throw enosys(); },
+			cwd() { throw enosys(); },
+			chdir() { throw enosys(); },
+		}
 	}
 
 	if (!globalThis.path) {
 		globalThis.path = {
 			resolve(...pathSegments) {
-				return pathSegments.join('/');
-			},
-		};
+				return pathSegments.join("/");
+			}
+		}
 	}
 
 	if (!globalThis.crypto) {
-		throw new Error(
-			'globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)'
-		);
+		throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
 	}
 
 	if (!globalThis.performance) {
-		throw new Error(
-			'globalThis.performance is not available, polyfill required (performance.now only)'
-		);
+		throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
 	}
 
 	if (!globalThis.TextEncoder) {
-		throw new Error('globalThis.TextEncoder is not available, polyfill required');
+		throw new Error("globalThis.TextEncoder is not available, polyfill required");
 	}
 
 	if (!globalThis.TextDecoder) {
-		throw new Error('globalThis.TextDecoder is not available, polyfill required');
+		throw new Error("globalThis.TextDecoder is not available, polyfill required");
 	}
 
-	const encoder = new TextEncoder('utf-8');
-	const decoder = new TextDecoder('utf-8');
+	const encoder = new TextEncoder("utf-8");
+	const decoder = new TextDecoder("utf-8");
 
 	globalThis.Go = class {
 		constructor() {
-			this.argv = ['js'];
+			this.argv = ["js"];
 			this.env = {};
 			this.exit = (code) => {
 				if (code !== 0) {
-					console.warn('exit code:', code);
+					console.warn("exit code:", code);
 				}
 			};
 			this._exitPromise = new Promise((resolve) => {
@@ -193,17 +119,17 @@
 			const setInt64 = (addr, v) => {
 				this.mem.setUint32(addr + 0, v, true);
 				this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
-			};
+			}
 
 			const setInt32 = (addr, v) => {
 				this.mem.setUint32(addr + 0, v, true);
-			};
+			}
 
 			const getInt64 = (addr) => {
 				const low = this.mem.getUint32(addr + 0, true);
 				const high = this.mem.getInt32(addr + 4, true);
 				return low + high * 4294967296;
-			};
+			}
 
 			const loadValue = (addr) => {
 				const f = this.mem.getFloat64(addr, true);
@@ -216,12 +142,12 @@
 
 				const id = this.mem.getUint32(addr, true);
 				return this._values[id];
-			};
+			}
 
 			const storeValue = (addr, v) => {
-				const nanHead = 0x7ff80000;
+				const nanHead = 0x7FF80000;
 
-				if (typeof v === 'number' && v !== 0) {
+				if (typeof v === "number" && v !== 0) {
 					if (isNaN(v)) {
 						this.mem.setUint32(addr + 4, nanHead, true);
 						this.mem.setUint32(addr, 0, true);
@@ -249,30 +175,30 @@
 				this._goRefCounts[id]++;
 				let typeFlag = 0;
 				switch (typeof v) {
-					case 'object':
+					case "object":
 						if (v !== null) {
 							typeFlag = 1;
 						}
 						break;
-					case 'string':
+					case "string":
 						typeFlag = 2;
 						break;
-					case 'symbol':
+					case "symbol":
 						typeFlag = 3;
 						break;
-					case 'function':
+					case "function":
 						typeFlag = 4;
 						break;
 				}
 				this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
 				this.mem.setUint32(addr, id, true);
-			};
+			}
 
 			const loadSlice = (addr) => {
 				const array = getInt64(addr + 0);
 				const len = getInt64(addr + 8);
 				return new Uint8Array(this._inst.exports.mem.buffer, array, len);
-			};
+			}
 
 			const loadSliceOfValues = (addr) => {
 				const array = getInt64(addr + 0);
@@ -282,18 +208,18 @@
 					a[i] = loadValue(array + i * 8);
 				}
 				return a;
-			};
+			}
 
 			const loadString = (addr) => {
 				const saddr = getInt64(addr + 0);
 				const len = getInt64(addr + 8);
 				return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
-			};
+			}
 
 			const testCallExport = (a, b) => {
 				this._inst.exports.testExport0();
 				return this._inst.exports.testExport(a, b);
-			};
+			}
 
 			const timeOrigin = Date.now() - performance.now();
 			this.importObject = {
@@ -308,7 +234,7 @@
 					// This changes the SP, thus we have to update the SP used by the imported function.
 
 					// func wasmExit(code int32)
-					'runtime.wasmExit': (sp) => {
+					"runtime.wasmExit": (sp) => {
 						sp >>>= 0;
 						const code = this.mem.getInt32(sp + 8, true);
 						this.exited = true;
@@ -321,7 +247,7 @@
 					},
 
 					// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
-					'runtime.wasmWrite': (sp) => {
+					"runtime.wasmWrite": (sp) => {
 						sp >>>= 0;
 						const fd = getInt64(sp + 8);
 						const p = getInt64(sp + 16);
@@ -330,50 +256,47 @@
 					},
 
 					// func resetMemoryDataView()
-					'runtime.resetMemoryDataView': (sp) => {
+					"runtime.resetMemoryDataView": (sp) => {
 						sp >>>= 0;
 						this.mem = new DataView(this._inst.exports.mem.buffer);
 					},
 
 					// func nanotime1() int64
-					'runtime.nanotime1': (sp) => {
+					"runtime.nanotime1": (sp) => {
 						sp >>>= 0;
 						setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
 					},
 
 					// func walltime() (sec int64, nsec int32)
-					'runtime.walltime': (sp) => {
+					"runtime.walltime": (sp) => {
 						sp >>>= 0;
-						const msec = new Date().getTime();
+						const msec = (new Date).getTime();
 						setInt64(sp + 8, msec / 1000);
 						this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
 					},
 
 					// func scheduleTimeoutEvent(delay int64) int32
-					'runtime.scheduleTimeoutEvent': (sp) => {
+					"runtime.scheduleTimeoutEvent": (sp) => {
 						sp >>>= 0;
 						const id = this._nextCallbackTimeoutID;
 						this._nextCallbackTimeoutID++;
-						this._scheduledTimeouts.set(
-							id,
-							setTimeout(
-								() => {
+						this._scheduledTimeouts.set(id, setTimeout(
+							() => {
+								this._resume();
+								while (this._scheduledTimeouts.has(id)) {
+									// for some reason Go failed to register the timeout event, log and try again
+									// (temporary workaround for https://github.com/golang/go/issues/28975)
+									console.warn("scheduleTimeoutEvent: missed timeout event");
 									this._resume();
-									while (this._scheduledTimeouts.has(id)) {
-										// for some reason Go failed to register the timeout event, log and try again
-										// (temporary workaround for https://github.com/golang/go/issues/28975)
-										console.warn('scheduleTimeoutEvent: missed timeout event');
-										this._resume();
-									}
-								},
-								getInt64(sp + 8)
-							)
-						);
+								}
+							},
+							getInt64(sp + 8),
+						));
 						this.mem.setInt32(sp + 16, id, true);
 					},
 
 					// func clearTimeoutEvent(id int32)
-					'runtime.clearTimeoutEvent': (sp) => {
+					"runtime.clearTimeoutEvent": (sp) => {
 						sp >>>= 0;
 						const id = this.mem.getInt32(sp + 8, true);
 						clearTimeout(this._scheduledTimeouts.get(id));
@@ -381,13 +304,13 @@
 					},
 
 					// func getRandomData(r []byte)
-					'runtime.getRandomData': (sp) => {
+					"runtime.getRandomData": (sp) => {
 						sp >>>= 0;
 						crypto.getRandomValues(loadSlice(sp + 8));
 					},
 
 					// func finalizeRef(v ref)
-					'syscall/js.finalizeRef': (sp) => {
+					"syscall/js.finalizeRef": (sp) => {
 						sp >>>= 0;
 						const id = this.mem.getUint32(sp + 8, true);
 						this._goRefCounts[id]--;
@@ -400,13 +323,13 @@
 					},
 
 					// func stringVal(value string) ref
-					'syscall/js.stringVal': (sp) => {
+					"syscall/js.stringVal": (sp) => {
 						sp >>>= 0;
 						storeValue(sp + 24, loadString(sp + 8));
 					},
 
 					// func valueGet(v ref, p string) ref
-					'syscall/js.valueGet': (sp) => {
+					"syscall/js.valueGet": (sp) => {
 						sp >>>= 0;
 						const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
 						sp = this._inst.exports.getsp() >>> 0; // see comment above
@@ -414,31 +337,31 @@
 					},
 
 					// func valueSet(v ref, p string, x ref)
-					'syscall/js.valueSet': (sp) => {
+					"syscall/js.valueSet": (sp) => {
 						sp >>>= 0;
 						Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
 					},
 
 					// func valueDelete(v ref, p string)
-					'syscall/js.valueDelete': (sp) => {
+					"syscall/js.valueDelete": (sp) => {
 						sp >>>= 0;
 						Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
 					},
 
 					// func valueIndex(v ref, i int) ref
-					'syscall/js.valueIndex': (sp) => {
+					"syscall/js.valueIndex": (sp) => {
 						sp >>>= 0;
 						storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
 					},
 
 					// valueSetIndex(v ref, i int, x ref)
-					'syscall/js.valueSetIndex': (sp) => {
+					"syscall/js.valueSetIndex": (sp) => {
 						sp >>>= 0;
 						Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
 					},
 
 					// func valueCall(v ref, m string, args []ref) (ref, bool)
-					'syscall/js.valueCall': (sp) => {
+					"syscall/js.valueCall": (sp) => {
 						sp >>>= 0;
 						try {
 							const v = loadValue(sp + 8);
@@ -456,7 +379,7 @@
 					},
 
 					// func valueInvoke(v ref, args []ref) (ref, bool)
-					'syscall/js.valueInvoke': (sp) => {
+					"syscall/js.valueInvoke": (sp) => {
 						sp >>>= 0;
 						try {
 							const v = loadValue(sp + 8);
@@ -473,7 +396,7 @@
 					},
 
 					// func valueNew(v ref, args []ref) (ref, bool)
-					'syscall/js.valueNew': (sp) => {
+					"syscall/js.valueNew": (sp) => {
 						sp >>>= 0;
 						try {
 							const v = loadValue(sp + 8);
@@ -490,13 +413,13 @@
 					},
 
 					// func valueLength(v ref) int
-					'syscall/js.valueLength': (sp) => {
+					"syscall/js.valueLength": (sp) => {
 						sp >>>= 0;
 						setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
 					},
 
 					// valuePrepareString(v ref) (ref, int)
-					'syscall/js.valuePrepareString': (sp) => {
+					"syscall/js.valuePrepareString": (sp) => {
 						sp >>>= 0;
 						const str = encoder.encode(String(loadValue(sp + 8)));
 						storeValue(sp + 16, str);
@@ -504,20 +427,20 @@
 					},
 
 					// valueLoadString(v ref, b []byte)
-					'syscall/js.valueLoadString': (sp) => {
+					"syscall/js.valueLoadString": (sp) => {
 						sp >>>= 0;
 						const str = loadValue(sp + 8);
 						loadSlice(sp + 16).set(str);
 					},
 
 					// func valueInstanceOf(v ref, t ref) bool
-					'syscall/js.valueInstanceOf': (sp) => {
+					"syscall/js.valueInstanceOf": (sp) => {
 						sp >>>= 0;
-						this.mem.setUint8(sp + 24, loadValue(sp + 8) instanceof loadValue(sp + 16) ? 1 : 0);
+						this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0);
 					},
 
 					// func copyBytesToGo(dst []byte, src ref) (int, bool)
-					'syscall/js.copyBytesToGo': (sp) => {
+					"syscall/js.copyBytesToGo": (sp) => {
 						sp >>>= 0;
 						const dst = loadSlice(sp + 8);
 						const src = loadValue(sp + 32);
@@ -532,7 +455,7 @@
 					},
 
 					// func copyBytesToJS(dst ref, src []byte) (int, bool)
-					'syscall/js.copyBytesToJS': (sp) => {
+					"syscall/js.copyBytesToJS": (sp) => {
 						sp >>>= 0;
 						const dst = loadValue(sp + 8);
 						const src = loadSlice(sp + 16);
@@ -546,21 +469,20 @@
 						this.mem.setUint8(sp + 48, 1);
 					},
 
-					debug: (value) => {
+					"debug": (value) => {
 						console.log(value);
 					},
-				},
+				}
 			};
 		}
 
 		async run(instance) {
 			if (!(instance instanceof WebAssembly.Instance)) {
-				throw new Error('Go.run: WebAssembly.Instance expected');
+				throw new Error("Go.run: WebAssembly.Instance expected");
 			}
 			this._inst = instance;
 			this.mem = new DataView(this._inst.exports.mem.buffer);
-			this._values = [
-				// JS values that Go currently has references to, indexed by reference id
+			this._values = [ // JS values that Go currently has references to, indexed by reference id
 				NaN,
 				0,
 				null,
@@ -570,8 +492,7 @@
 				this,
 			];
 			this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
-			this._ids = new Map([
-				// mapping from JS values to reference ids
+			this._ids = new Map([ // mapping from JS values to reference ids
 				[0, 1],
 				[null, 2],
 				[true, 3],
@@ -579,7 +500,7 @@
 				[globalThis, 5],
 				[this, 6],
 			]);
-			this._idPool = []; // unused ids that have been garbage collected
+			this._idPool = [];   // unused ids that have been garbage collected
 			this.exited = false; // whether the Go program has exited
 
 			// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
@@ -587,7 +508,7 @@
 
 			const strPtr = (str) => {
 				const ptr = offset;
-				const bytes = encoder.encode(str + '\0');
+				const bytes = encoder.encode(str + "\0");
 				new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
 				offset += bytes.length;
 				if (offset % 8 !== 0) {
@@ -621,7 +542,7 @@
 			// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
 			const wasmMinDataAddr = 4096 + 8192;
 			if (offset >= wasmMinDataAddr) {
-				throw new Error('total length of command line and environment variables exceeds limit');
+				throw new Error("total length of command line and environment variables exceeds limit");
 			}
 
 			this._inst.exports.run(argc, argv);
@@ -633,7 +554,7 @@
 
 		_resume() {
 			if (this.exited) {
-				throw new Error('Go program has already exited');
+				throw new Error("Go program has already exited");
 			}
 			this._inst.exports.resume();
 			if (this.exited) {
@@ -650,5 +571,5 @@
 				return event.result;
 			};
 		}
-	};
+	}
 })();