jsbeeb 1.23.0 → 1.24.0

package/src/main.js

@@ -3,10 +3,8 @@ import { version } from "../package.json";
 import "bootswatch/dist/darkly/bootstrap.min.css";
 import "./jsbeeb.css";
 
-import * as utils from "./utils.js";
 import { Debugger } from "./web/debug.js";
-import * as utils_atom from "./utils_atom.js";
-import { GamePad } from "./gamepads.js";
+import { GamePad } from "./web/gamepads.js";
 import { initialise as electron } from "./app/electron.js";
 import { AudioHandler } from "./web/audio-handler.js";
 import { installIcons } from "./web/icons.js";
@@ -21,7 +19,9 @@ import { isSnapshotFile, SnapshotUI } from "./web/snapshot-ui.js";
 import { Autoboot } from "./web/autoboot.js";
 import { Display } from "./web/display.js";
 import { Layout } from "./web/layout.js";
-import { EmulationLoop, RewindCaptureInterval } from "./web/emulation-loop.js";
+import { EmulationLoop } from "./web/emulation-loop.js";
+import { RunControls } from "./web/run-controls.js";
+import { exposeConsoleSurface } from "./web/console-surface.js";
 import { KeyboardSetup } from "./web/keyboard-setup.js";
 import { AccessibilitySwitches } from "./web/accessibility-switches.js";
 import { AnalogueInputs } from "./web/analogue-inputs.js";
@@ -31,14 +31,17 @@ import { Drives } from "./web/drives.js";
 import { UrlState } from "./web/url-state.js";
 import { Modals } from "./web/modals.js";
 import { Settings } from "./web/settings.js";
+import { Config } from "./web/config.js";
+import { SpeechOutput } from "./web/speech-output.js";
 import { Printer } from "./printer.js";
-import { RewindBuffer } from "./rewind.js";
 import { RewindUI } from "./web/rewind-ui.js";
 import { DiscVisualiser } from "./web/disc-visualiser.js";
-import { downloadDriveData } from "./dom-utils.js";
+import { PageActions } from "./web/page-actions.js";
 import { parseMediaParams, processAutobootParams, processDriveTrackParams, processInputParams } from "./url-params.js";
+import { adaptKeyCodesToBrowser, keyCodes, userKeymap } from "./keymap.js";
 
 installIcons();
+adaptKeyCodesToBrowser();
 
 // ------------------------------------------------------------------------
 // What the URL asked for.
@@ -70,11 +73,6 @@ const stationId = parsedQuery.stationId !== undefined ? parsedQuery.stationId :
 const tryGl = parsedQuery.glEnabled ?? true;
 const lowLatency = parsedQuery.lowLatency ?? true;
 
-if (parsedQuery.embed) {
-    for (const el of document.querySelectorAll(".embed-hide")) el.style.display = "none";
-    document.body.style.backgroundColor = "transparent";
-}
-
 // ------------------------------------------------------------------------
 // The pieces that exist before the machine: settings, screen, sound.
 // ------------------------------------------------------------------------
@@ -88,29 +86,26 @@ if (!window.isSecureContext)
         quietKey: "quietInsecureGamepads",
     });
 
-const printer = new Printer({
-    onOutput: (char) => frontPanel.printChar(char),
-    onFirstOutput: () =>
-        toast("Printer output is being kept. Press Ctrl-B to open the printer window.", {
-            title: "Printer",
-            quietKey: "quietPrinterOutput",
-        }),
-});
+const printer = new Printer();
 
 const accessibilitySwitches = new AccessibilitySwitches();
 
 const settings = new Settings({ urlState });
-const { config, speechOutput, keyLayout, displayMode, audioOutput, speakerAmount } = settings;
+const { keyLayout, displayMode, audioOutput, speakerAmount } = settings;
 const model = settings.model;
+const config = new Config(settings);
+
+const speechOutput = new SpeechOutput();
+const speak = (enabled) => {
+    speechOutput.enabled = enabled;
+    if (enabled && typeof speechSynthesis === "undefined")
+        toast("This browser has no speech synthesis, so speech output has nothing to speak with.", { title: "Speech" });
+};
+speak(settings.speechOutput);
+settings.on("speechOutput", speak);
 
 // Must come after we know the model, to validate names against those of the hardware.
-const keyMappingWarnings = processInputParams(
-    parsedQuery,
-    model.isAtom ? utils_atom.ATOM : utils.BBC,
-    utils.keyCodes,
-    utils.userKeymap,
-    gamepad,
-);
+const keyMappingWarnings = processInputParams(parsedQuery, model.keys, keyCodes, userKeymap, gamepad);
 if (keyMappingWarnings.length) {
     toast(`${keyMappingWarnings.join(" ")} The key names are listed in the README.`, {
         title: "Mappings in the URL",
@@ -152,21 +147,14 @@ const audioHandler = new AudioHandler({
     noSeek,
     cpuSpeed,
     isAtom: model.isAtom,
-    hasMusic5000: config.hasMusic5000,
+    hasMusic5000: settings.hasMusic5000,
 });
 // Firefox will report that audio is suspended even when it will
 // start playing without user interaction, so we need to delay a
 // little to get a reliable indication.
 window.setTimeout(() => audioHandler.checkStatus(), 1000);
 
-const quickSettings = new QuickSettings(
-    {
-        onAudioOutput: (output) => settings.applyAudioOutput(output),
-        onSpeakerAmount: (amount) => settings.applySpeakerAmount(amount),
-        onDisplayMode: (mode) => settings.applyDisplayMode(mode),
-    },
-    { audioOutput, speakerAmount, displayMode },
-);
+new QuickSettings(settings);
 
 // ------------------------------------------------------------------------
 // The machine, the loop that runs it, and everything that feeds it.
@@ -175,7 +163,7 @@ const quickSettings = new QuickSettings(
 // Depends on the settings having applied the URL parameters.
 const machine = new Machine({
     model,
-    config,
+    settings,
     parsedQuery,
     keyLayout,
     cpuMultiplier,
@@ -190,7 +178,7 @@ const machine = new Machine({
 });
 const processor = machine.processor;
 
-const keys = new KeyboardSetup({
+const { keyboard } = new KeyboardSetup({
     actions: {
         enterDebugger: () => loop.stop(true),
         reload: () => window.location.reload(),
@@ -199,7 +187,7 @@ const keys = new KeyboardSetup({
         openPrinter: () => frontPanel.checkPrinterWindow(),
         pause: () => loop.stop(false),
         resume: () => loop.go(),
-        paste: (text) => keys.sendRawKeyboard(autoBoot.stringToMachineKeys(text), true),
+        paste: (text) => keyboard.sendRawKeyboard(autoBoot.stringToMachineKeys(text), true),
         onAnyKeyDown: () => {
             audioHandler.tryResume();
             inputs.ensureMicrophoneRunning();
@@ -211,31 +199,20 @@ const keys = new KeyboardSetup({
     keyLayout,
 });
 
-const rewindBuffer = new RewindBuffer(30);
 const loop = new EmulationLoop({
     processor,
     display,
     audioHandler,
     dbgr,
     gamepad,
-    keyboard: keys,
-    syncLights: () => frontPanel.syncLights(),
-    rewindBuffer,
-    onRewindCaptured: () => rewindUI.updateButtonState(),
+    keyboard,
     clocksPerSecond,
     cpuSpeed,
     fastTape: !!parsedQuery.fasttape,
     audioStatsNode,
 });
 
-const debugPause = document.getElementById("debug-pause");
-const debugPlay = document.getElementById("debug-play");
-loop.addEventListener("running", () => {
-    const running = loop.isRunning();
-    keys.setRunning(running);
-    debugPlay.disabled = running;
-    debugPause.disabled = !running;
-});
+const runControls = new RunControls({ loop, dbgr, keyboard });
 
 const modals = new Modals({ loop });
 
@@ -252,7 +229,7 @@ const media = new MediaLoader({
 const autoBoot = new Autoboot({
     model,
     processor,
-    sendKeys: (keysToSend, check) => keys.sendRawKeyboard(keysToSend, check),
+    sendKeys: (keysToSend, check) => keyboard.sendRawKeyboard(keysToSend, check),
 });
 const autobootTicks = new AutobootTicks({ urlState });
 const sthPicker = new SthPicker({
@@ -287,12 +264,11 @@ const snapshots = new SnapshotUI({
 const inputs = new AnalogueInputs({
     processor,
     screenCanvas,
-    getGamepads: machine.emulationConfig.getGamepads,
-    urlState,
-    config,
+    getGamepads: machine.spec.getGamepads,
+    settings,
     audioHandler,
 });
-if (parsedQuery.microphoneChannel !== undefined) {
+if (settings.microphoneChannel !== undefined) {
     // We need to use setTimeout to make sure this runs after the page has loaded
     // This is needed because some browsers require user interaction for audio context
     setTimeout(async () => {
@@ -300,105 +276,54 @@ if (parsedQuery.microphoneChannel !== undefined) {
     }, 1000);
 }
 // Apply ADC source settings from URL parameters
-inputs.updateAdcSources(parsedQuery.mouseJoystickEnabled, parsedQuery.microphoneChannel);
+inputs.updateAdcSources(settings.mouseJoystickEnabled, settings.microphoneChannel);
 
-const frontPanel = new FrontPanel({ processor, model, printer });
+const frontPanel = new FrontPanel({ processor, model, printer, loop });
 
 // ------------------------------------------------------------------------
 // Rewind, the visualiser and the layout.
 // ------------------------------------------------------------------------
 
-const rewindUI = new RewindUI({
-    rewindBuffer,
-    processor,
-    video,
-    captureInterval: RewindCaptureInterval,
-    loop,
-});
+const rewindUI = new RewindUI({ processor, video, loop });
 rewindUI.updateButtonState();
 
-if (processor.fdc) new DiscVisualiser({ fdc: processor.fdc });
-else document.getElementById("disc-visualiser-open").classList.add("disabled");
+new DiscVisualiser({ fdc: processor.fdc });
 
 const layout = new Layout({
     screenCanvas,
     display,
-    embed: parsedQuery.embed !== undefined,
+    embed: !!parsedQuery.embed,
     sidebars: { left: parsedQuery.sbLeft, right: parsedQuery.sbRight, bottom: parsedQuery.sbBottom },
 });
 
 // Everything a setting can reach now exists.
-settings.wire({ audioHandler, display, layout, quickSettings, machine, keys, inputs, modals });
-
-// ------------------------------------------------------------------------
-// The page's own handlers.
-// ------------------------------------------------------------------------
-
-for (const el of document.querySelectorAll(".initially-hidden")) el.classList.remove("initially-hidden");
-
-document.getElementById("paste-form").addEventListener("submit", (event) => event.preventDefault());
-
-window.addEventListener("blur", function () {
-    keys.clearKeys();
-    loop.setEmulationLead(audioHandler.setWindowFocused(false));
+settings.on("audioOutput", (output) => audioHandler.setAudioOutput(output));
+settings.on("speakerAmount", (amount) => audioHandler.setSpeakerAmount(amount));
+settings.on("displayMode", (mode) => {
+    display.setMode(mode);
+    // The monitor picture may have changed shape.
+    layout.resize();
 });
-window.addEventListener("focus", () => loop.setEmulationLead(audioHandler.setWindowFocused(true)));
-
-function pauseIntoDebugger() {
-    loop.stop(true);
-}
-
-function resumeFromDebugger() {
-    dbgr.hide();
-    keys.resumeEmulation();
-}
-
-debugPause.addEventListener("click", pauseIntoDebugger);
-debugPlay.addEventListener("click", resumeFromDebugger);
-
-// To lower chance of data loss, only accept drop events in the drop
-// zone in the menu bar.
-document.addEventListener("dragover", function (event) {
-    event.preventDefault();
-    event.dataTransfer.dropEffect = "none";
-});
-document.addEventListener("drop", function (event) {
-    event.preventDefault();
+settings.on("keyLayout", (chosen) => keyboard.setKeyLayout(chosen));
+settings.on("tubeCpuMultiplier", (multiplier) => {
+    if (processor.hasTube) processor.tube.cpuMultiplier = multiplier;
 });
-
-window.addEventListener("beforeunload", function (event) {
-    if (loop.isRunning() && processor.sysvia.hasAnyKeyDown()) {
-        const message =
-            "It seems like you're still using the emulator. If you're in Chrome, it's impossible for jsbeeb to prevent some shortcuts (like ctrl-W) from performing their default behaviour (e.g. closing the window).\n" +
-            "As a workarond, create an 'Application Shortcut' from the Tools menu.  When jsbeeb runs as an application, it *can* prevent ctrl-W from closing the window.";
-        event.preventDefault();
-        event.returnValue = message;
-        return message;
-    }
-});
-
-function hardReset() {
-    rewindUI.reset();
-    processor.reset(true);
-}
-
-document.getElementById("hard-reset").addEventListener("click", function (event) {
-    hardReset();
-    event.preventDefault();
+const rerouteAnalogue = () => inputs.updateAdcSources(settings.mouseJoystickEnabled, settings.microphoneChannel);
+settings.on("mouseJoystickEnabled", rerouteAnalogue);
+settings.on("microphoneChannel", (channel) => {
+    rerouteAnalogue();
+    if (channel !== undefined) inputs.setupMicrophone();
 });
-
-document.getElementById("soft-reset").addEventListener("click", function (event) {
-    processor.reset(false);
-    event.preventDefault();
-});
-
-document.getElementById("download-filestore-link").addEventListener("click", function () {
-    if (!processor.filestore) return;
-    downloadDriveData(processor.filestore.scsi, "scsi", ".dat");
+config.addEventListener("restart-required", async () => {
+    const restart = await modals.confirm(
+        "Your change is saved, but only takes effect when the emulator restarts. Restart now?",
+        "Restart now",
+        "Later",
+    );
+    if (restart) window.location.reload();
 });
 
-if (Object.hasOwn(parsedQuery, "about")) modals.show("info");
-if (Object.hasOwn(parsedQuery, "pp-tos")) modals.show("pp-tos");
+const page = new PageActions({ loop, processor, keyboard, audioHandler, rewindUI, modals, parsedQuery, version });
 
 // ------------------------------------------------------------------------
 // Start it up.
@@ -460,47 +385,14 @@ const startPromise = machine.start({
 // The console surface the wiki documents, and the desktop app's hooks.
 // ------------------------------------------------------------------------
 
-// Handy shortcuts. bench/profile stuff is delayed so that they can be
-// safely run from the JS console in firefox.
-window.benchmarkCpu = utils.debounce((numCycles) => loop.benchmarkCpu(numCycles), 1);
-window.profileCpu = utils.debounce((arg) => loop.profileCpu(arg), 1);
-window.benchmarkVideo = utils.debounce((numCycles) => loop.benchmarkVideo(numCycles), 1);
-window.profileVideo = utils.debounce((arg) => loop.profileVideo(arg), 1);
-window.go = () => loop.go();
-window.stop = (debug) => loop.stop(debug);
-window.soundChip = audioHandler.soundChip;
-window.processor = processor;
-window.video = video;
-window.hd = function (start, end) {
-    console.log(
-        utils.hd(
-            function (x) {
-                return processor.readmem(x);
-            },
-            start,
-            end,
-        ),
-    );
-};
-window.m7dump = function () {
-    console.log(
-        utils.hd(
-            function (x) {
-                return processor.readmem(x) & 0x7f;
-            },
-            0x7c00,
-            0x7fe8,
-            { width: 40, gap: false },
-        ),
-    );
-};
+exposeConsoleSurface(window, { loop, processor, video, audioHandler });
 
 // Hooks for electron.
 electron({
     loadDiscImage: media.loadDiscImage.bind(media),
     loadTapeImage: media.loadTapeImage.bind(media),
     processor,
-    config,
+    settings,
     media,
     modals: {
         show: (modalId, sthType) => {
@@ -513,17 +405,11 @@ electron({
     },
     loadStateFile: snapshots.loadStateFromFile.bind(snapshots),
     actions: {
-        "soft-reset": () => processor.reset(false),
-        "hard-reset": hardReset,
+        "soft-reset": () => page.softReset(),
+        "hard-reset": () => page.hardReset(),
         "save-state": () => snapshots.saveState(),
         rewind: () => rewindUI.open(),
-        pause: pauseIntoDebugger,
-        resume: resumeFromDebugger,
+        pause: () => runControls.pause(),
+        resume: () => runControls.resume(),
     },
 });
-
-// Display version in About dialog
-const versionElement = document.getElementById("jsbeeb-version");
-if (versionElement) {
-    versionElement.textContent = `Version ${version}`;
-}

package/src/media-resolver.js

@@ -0,0 +1,68 @@
+import { unzipDiscImage } from "./archive.js";
+import { stringToUint8Array } from "./binary.js";
+import { loadData } from "./loader.js";
+
+/** Splits an image reference into its schema (empty for a bare name) and the image it names. */
+export function splitImage(image) {
+    const match = image.match(/(([^:]+):\/?\/?|[!^|])?(.*)/);
+    return { schema: match[2] || match[1] || "", image: match[3] };
+}
+
+// Where a bare name is looked for, and which registered source serves the archive.
+const Kinds = {
+    disc: { folder: "discs", sth: "sth" },
+    tape: { folder: "tapes", sth: "tapeSth" },
+};
+
+/** The image itself when `name` is a zip, else the bytes as given, either way as `{ name, data, ignored }`. */
+export function openIfZip(name, data) {
+    return /\.zip/i.test(name) ? unzipDiscImage(data) : { name, data, ignored: [] };
+}
+
+/**
+ * Turns any image reference the URL can name into bytes, `{ name, data, ignored }`,
+ * for a disc or a tape: the archives through the sources registered for them,
+ * `data:` and `b64data:` inline, `http:`, `https:` and `file:` by URL, and a
+ * bare name from the built-in folder. Zips are opened once, here. Nothing in
+ * it needs a page, so a headless machine can load the same references.
+ */
+export class MediaResolver {
+    constructor({ load = loadData } = {}) {
+        this.sources = {};
+        this.load = load;
+    }
+
+    /** Registers the fetcher behind an archive schema; each archive registers as it is constructed. */
+    addSource(schema, fetcher) {
+        this.sources[schema] = fetcher;
+    }
+
+    async resolve(kind, ref) {
+        const { schema, image } = splitImage(ref);
+        const { folder, sth } = Kinds[kind];
+        switch (schema) {
+            case "|":
+            case "sth":
+                return this.source(sth)(image);
+            case "hfe":
+                return { name: image, data: await this.source("hfe")(image), ignored: [] };
+            case "b64data":
+                return { name: "disk.ssd", data: stringToUint8Array(atob(image)), ignored: [] };
+            case "data":
+                return unzipDiscImage(stringToUint8Array(atob(image)));
+            case "http":
+            case "https":
+            case "file":
+                // The URL may end in query parameters, which would upset the extension check.
+                return openIfZip(new URL(ref).pathname, await this.load(ref));
+            default:
+                return openIfZip(image, await this.load(`${folder}/${image}`));
+        }
+    }
+
+    source(schema) {
+        const fetcher = this.sources[schema];
+        if (!fetcher) throw new Error(`No ${schema} archive is available here`);
+        return fetcher;
+    }
+}

package/src/mmc.js

@@ -1,4 +1,5 @@
-import { loadData, unzip, createZipBlob } from "./utils.js";
+import { createZipBlob, unzip } from "./archive.js";
+import { loadData } from "./loader.js";
 
 /*
 highly adapted from:
@@ -617,7 +618,7 @@ class WFN {
         let fname = this.trimToFilename(this.globalData);
 
         if (this.filenum === 0) {
-            this.fildataIndex = 0; // FIXME : should be one for each fildata if going down this line!
+            this.fildataIndex = 0; // FIXME(#1068) should be one for each fildata if going down this line!
             // The scratch file is fixed, so we are backwards compatible with 2.9 firmware
             let fopen = this.f_open(fname, mode);
             if (fopen.error == FR_OK) this.fildata[0] = this.allfiles[fopen.fp];

package/src/models.js

@@ -1,8 +1,9 @@
-"use strict";
-
 import { NoiseAwareWdFdc } from "./wd-fdc.js";
 import { NoiseAwareIntelFdc } from "./intel-fdc.js";
 import * as opcodes from "./6502.opcodes.js";
+import { AtomCpu6502, Cpu6502 } from "./6502.js";
+import { BBC, stringToBBCKeys } from "./keymap.js";
+import { ATOM, stringToATOMKeys } from "./keymap-atom.js";
 
 const CpuModel = Object.freeze({
     MOS6502: 0,
@@ -43,6 +44,19 @@ class Model {
         this._cpuModel = cpuModel;
         this.isMaster = isMaster;
         this.isAtom = !!isAtom;
+        // The one place the two machine families part: everything else asks the model.
+        this.Cpu = this.isAtom ? AtomCpu6502 : Cpu6502;
+        this.keys = this.isAtom ? ATOM : BBC;
+        this.stringToKeys = this.isAtom ? stringToATOMKeys : stringToBBCKeys;
+        // The OS write-character vector, watched to capture what the machine prints.
+        this.wrchvAddress = this.isAtom ? 0x0208 : 0x020e;
+        // Where the machine sits waiting for a key: the Atom kernel's read loop, or BASIC's.
+        this.idleAddress = this.isAtom ? 0xfe94 : isMaster ? 0xe7e6 : 0xe581;
+        // The Atom ROM polls its keyboard once per VSync, so pasted keys need longer apart.
+        this.pasteKeyDelayMs = this.isAtom ? 80 : 50;
+        // Two of those 60 Hz scans, 33 ms, with margin: the ROM wants a key seen up
+        // twice before it takes the next.
+        this.pasteReleaseGapMs = this.isAtom ? 40 : 0;
         this.Fdc = fdc;
         this.swram = swram;
         this.isTest = false;
@@ -106,7 +120,7 @@ function atomModel({ name, synonyms, os, banks }) {
     });
 }
 
-// TODO: semi-bplus-style to get swram for exile hardcoded here
+// TODO(#1066) semi-bplus-style to get swram for exile hardcoded here
 const beebSwram = [
     true,
     true,

package/src/music5000.js

@@ -1,5 +1,3 @@
-"use strict";
-
 // Code ported from Beebem (C to .js) by Jason Robson
 const AUDIO_BUFFER_SIZE = 256;
 

package/src/ppia.js

@@ -1,4 +1,4 @@
-import { getKeyMapAtom } from "./utils_atom.js";
+import { getKeyMapAtom } from "./keymap-atom.js";
 
 // 8255 Programmable Peripheral Interface Adapter for the Acorn Atom.
 // Reference: http://mdfs.net/Docs/Comp/Acorn/Atom/atap25.htm
@@ -415,9 +415,8 @@ export class AtomPPIA extends PPIA {
     }
 
     rewindTape() {
-        if (this.tape) {
-            this.tape.rewind();
-        }
+        this.stopTape();
+        if (this.tape) this.tape.rewind();
     }
 
     playTape() {

package/src/printer.js

@@ -1,21 +1,14 @@
-"use strict";
-
 /**
  * Centronics printer attached to the user VIA: acknowledges each character and keeps the most
- * recent output so it can be shown whenever a printer window is opened.
+ * recent output so it can be shown whenever a printer window is opened. Dispatches "output" with
+ * each character as its detail, and "first-output" once, when the machine first prints.
  */
 
 export const MaxBufferedChars = 64 * 1024;
 
-export class Printer {
-    /**
-     * @param {object} [handlers]
-     * @param {function(string): void} [handlers.onOutput] called with each character as it is printed
-     * @param {function(): void} [handlers.onFirstOutput] called once, when the machine first prints
-     */
-    constructor({ onOutput = () => {}, onFirstOutput = () => {} } = {}) {
-        this._onOutput = onOutput;
-        this._onFirstOutput = onFirstOutput;
+export class Printer extends EventTarget {
+    constructor() {
+        super();
         this._uservia = null;
         this._olderText = "";
         this._newerText = "";
@@ -52,8 +45,8 @@ export class Printer {
         }
         if (!this._hasPrinted) {
             this._hasPrinted = true;
-            this._onFirstOutput();
+            this.dispatchEvent(new Event("first-output"));
         }
-        this._onOutput(char);
+        this.dispatchEvent(new CustomEvent("output", { detail: char }));
     }
 }

package/src/relaynoise.js

@@ -1,4 +1,3 @@
-"use strict";
 // Cassette motor relay click sound (issue #296).
 // Audio samples recorded from a real BBC Master cassette motor relay.
 import { SamplePlayer } from "./sample-player.js";

package/src/rewind.js

@@ -1,5 +1,3 @@
-"use strict";
-
 /**
  * Circular buffer of emulator state snapshots for rewind functionality.
  * Snapshots are stored directly without deep-copying, since

package/src/sample-player.js

@@ -1,5 +1,4 @@
-"use strict";
-import * as utils from "./utils.js";
+import { loadData } from "./loader.js";
 
 /**
  * Base class for audio components that load and play back sample buffers
@@ -27,7 +26,7 @@ export class SamplePlayer {
         const entries = Object.entries(pathMap);
         const decoded = await Promise.all(
             entries.map(async ([, path]) => {
-                const data = await utils.loadData(path);
+                const data = await loadData(path);
                 // Safari doesn't support the promise form of decodeAudioData.
                 return new Promise((resolve, reject) => {
                     this.context.decodeAudioData(

package/src/serial.js

@@ -1,5 +1,3 @@
-"use strict";
-
 const table = [19200, 9600, 4800, 2400, 1200, 300, 150, 75];
 
 export class Serial {

package/src/snapshot-helpers.js

@@ -1,5 +1,3 @@
-"use strict";
-
 // Shared helpers for snapshot importers (bem-snapshot.js, uef-snapshot.js).
 // Contains volume table, default peripheral state, video state builder,
 // and the common snapshot envelope that wraps per-format parsed state.

package/src/snapshot.js

@@ -1,5 +1,3 @@
-"use strict";
-
 import { typedArrayToBase64, base64ToTypedArray } from "./state-utils.js";
 import { findModel } from "./models.js";
 

package/src/soundchip.js

@@ -347,7 +347,7 @@ export class SoundChip {
     updateSlowDataBus(slowDataBus, active) {
         this.slowDataBus = slowDataBus;
         this.active = active;
-        // TODO: this probably isn't modeled correctly. Currently the sound chip "notices" a new data bus value some
+        // TODO(#835) this probably isn't modeled correctly. Currently the sound chip "notices" a new data bus value some
         // fixed number of cycles after WE (write enable) is triggered. In reality, the sound chip likely pulls data off
         // the bus at a fixed point in its cycle, iff WE is active.
         if (active) {

package/src/state-utils.js

@@ -1,5 +1,3 @@
-"use strict";
-
 /**
  * Convert a TypedArray to a base64 string for JSON serialization.
  * @param {ArrayBufferView} typedArray