jsbeeb 1.12.0 → 1.13.1

package/src/6847_fontdata.js

@@ -0,0 +1,124 @@
+"use strict";
+
+// MC6847 internal character ROM data (PAL square pixel variant, 8x12).
+// Derived from the MAME project's MC6847 VDG emulation:
+//   https://github.com/mamedev/mame/blob/master/src/devices/video/mc6847.cpp
+//   Copyright Nathan Woods, licensed under BSD-3-Clause.
+//   See https://github.com/mamedev/mame/blob/master/LICENSE.md
+export function makeCharsAtom() {
+    return new Uint8Array([
+        0x00, 0x00, 0x00, 0x1c, 0x22, 0x02, 0x1a, 0x2a, 0x2a, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x14, 0x22,
+        0x22, 0x3e, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x12, 0x12, 0x1c, 0x12, 0x12, 0x3c, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x1c, 0x22, 0x20, 0x20, 0x20, 0x22, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x12, 0x12,
+        0x12, 0x12, 0x12, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x20, 0x20, 0x3c, 0x20, 0x20, 0x3e, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x3e, 0x20, 0x20, 0x3c, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x20, 0x20,
+        0x26, 0x22, 0x22, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x3e, 0x22, 0x22, 0x22, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x1c, 0x08, 0x08, 0x08, 0x08, 0x08, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02,
+        0x02, 0x22, 0x22, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x24, 0x28, 0x30, 0x28, 0x24, 0x22, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x36, 0x2a,
+        0x2a, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x32, 0x2a, 0x26, 0x22, 0x22, 0x22, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x3e, 0x22, 0x22, 0x22, 0x22, 0x22, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x22, 0x22,
+        0x3c, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x2a, 0x24, 0x1a, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x3c, 0x22, 0x22, 0x3c, 0x28, 0x24, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x10,
+        0x08, 0x04, 0x22, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22,
+        0x14, 0x14, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x2a, 0x2a, 0x36, 0x22, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x22, 0x22, 0x14, 0x08, 0x14, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x14,
+        0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x02, 0x04, 0x08, 0x10, 0x20, 0x3e, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x38, 0x20, 0x20, 0x20, 0x20, 0x20, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x10,
+        0x08, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0e, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x08, 0x1c, 0x2a, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10,
+        0x3e, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x14, 0x14,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x14, 0x36, 0x00, 0x36, 0x14, 0x14, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x08, 0x1e, 0x20, 0x1c, 0x02, 0x3c, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x32, 0x04,
+        0x08, 0x10, 0x26, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x28, 0x28, 0x10, 0x2a, 0x24, 0x1a, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x20,
+        0x20, 0x20, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x08, 0x1c, 0x3e, 0x1c, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08,
+        0x3e, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x10, 0x20, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x04, 0x08, 0x10, 0x20, 0x20, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x18, 0x24, 0x24, 0x24, 0x24, 0x24, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x18, 0x08,
+        0x08, 0x08, 0x08, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x02, 0x1c, 0x20, 0x20, 0x3e, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x1c, 0x22, 0x02, 0x0c, 0x02, 0x22, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0c, 0x14,
+        0x3e, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x20, 0x3c, 0x02, 0x02, 0x22, 0x1c, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x1c, 0x20, 0x20, 0x3c, 0x22, 0x22, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x02, 0x04,
+        0x08, 0x10, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x22, 0x1c, 0x22, 0x22, 0x1c, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x1c, 0x22, 0x22, 0x1e, 0x02, 0x02, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18,
+        0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e,
+        0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x18, 0x24, 0x04, 0x08, 0x08, 0x00, 0x08, 0x00, 0x00,
+
+        // graphics
+
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f,
+        0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+        0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f,
+        0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0,
+        0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff,
+        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+        0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0,
+        0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f,
+        0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00,
+        0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00,
+        0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+        0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff,
+        0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0,
+        0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+        0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff,
+        0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f,
+        0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff,
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00,
+        0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+        0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f,
+        0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0,
+        0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+        0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f,
+        0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+        0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+        0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff,
+        0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
+        0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0,
+        0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f,
+        0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+        0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f,
+        0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00,
+        0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0,
+        0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff,
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+        0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0,
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+
+        /* Lower case */
+        0x00, 0x00, 0x00, 0x0c, 0x12, 0x10, 0x38, 0x10, 0x12, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c,
+        0x02, 0x1e, 0x22, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x3c, 0x22, 0x22, 0x22, 0x3c, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x20, 0x20, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x1e,
+        0x22, 0x22, 0x22, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x3e, 0x20, 0x1c, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x0c, 0x12, 0x10, 0x38, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e,
+        0x22, 0x22, 0x22, 0x1e, 0x02, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x20, 0x3c, 0x22, 0x22, 0x22, 0x22, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x08, 0x00, 0x18, 0x08, 0x08, 0x08, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x0c,
+        0x04, 0x04, 0x04, 0x04, 0x24, 0x18, 0x00, 0x00, 0x00, 0x20, 0x20, 0x24, 0x28, 0x38, 0x24, 0x22, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
+        0x2a, 0x2a, 0x2a, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x32, 0x22, 0x22, 0x22, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
+        0x22, 0x22, 0x22, 0x3c, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x22, 0x22, 0x22, 0x1e, 0x02, 0x03,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x32, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e,
+        0x20, 0x1c, 0x02, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x3c, 0x10, 0x10, 0x10, 0x12, 0x0c, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x26, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22,
+        0x22, 0x14, 0x14, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x2a, 0x2a, 0x1c, 0x14, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x14, 0x08, 0x14, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22,
+        0x22, 0x22, 0x22, 0x1e, 0x02, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x04, 0x08, 0x10, 0x3e, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x08, 0x10, 0x10, 0x20, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08,
+        0x00, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0x04, 0x02, 0x04, 0x04, 0x08, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x2a, 0x1c, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0x3e,
+        0x04, 0x08, 0x00, 0x00, 0x00, 0x00,
+    ]);
+}

package/src/app/app.js

@@ -5,6 +5,8 @@ import * as fs from "fs";
 import * as path from "path";
 import { ArgumentParser } from "argparse";
 
+import { getArguments } from "./args.js";
+
 const store = new Store();
 
 ipcMain.on("set-title", (event, title) => {
@@ -20,21 +22,6 @@ ipcMain.on("save-settings", (event, settings) => {
 
 const isMac = process.platform === "darwin";
 
-function getArguments() {
-    // Heinous hack to get "built" versions working
-    let args;
-    if (path.basename(process.argv[0]) === "jsbeeb")
-        // Is this ia "built" version?
-        args = process.argv.slice(1);
-    else args = process.argv.slice(2);
-
-    // Filter out Chrome switches that appear in process.argv. The snap wrapper
-    // adds --no-sandbox for compatibility, and `--disable-gpu` might be useful.
-    // Note that we don't support snap any more, but these seemed useful to leave.
-    const ignoredChromeFlags = ["--no-sandbox", "--disable-gpu"];
-    return args.filter((arg) => !ignoredChromeFlags.includes(arg));
-}
-
 const parser = new ArgumentParser({
     prog: "jsbeeb",
     add_help: true,

package/src/app/args.js

@@ -0,0 +1,26 @@
+"use strict";
+
+/**
+ * Returns the command-line arguments the user actually passed to jsbeeb, with
+ * the Electron binary path(s) and known runtime-injected flags stripped.
+ *
+ * @param {string[]} [argv=process.argv] Full argv array.
+ * @param {boolean} [defaultApp=process.defaultApp]
+ *   True when running under `electron .` (dev). Electron only sets
+ *   process.defaultApp in that case, so we use it instead of comparing
+ *   basename(argv[0]) === "jsbeeb" (the previous check), which failed on
+ *   Windows where the binary is jsbeeb.exe, silently dropping the first
+ *   user argument. See issue #684.
+ * @returns {string[]}
+ */
+export function getArguments(argv = process.argv, defaultApp = process.defaultApp) {
+    // In a packaged Electron app argv is [appBinary, ...userArgs]; when running
+    // under `electron .` (dev) it is [electronBinary, appPath, ...userArgs].
+    const args = defaultApp ? argv.slice(2) : argv.slice(1);
+
+    // Filter out Chrome switches that appear in argv. The snap wrapper adds
+    // --no-sandbox for compatibility, and --disable-gpu might be useful. We
+    // don't support snap any more, but these seemed useful to leave.
+    const ignoredChromeFlags = ["--no-sandbox", "--disable-gpu"];
+    return args.filter((arg) => !ignoredChromeFlags.includes(arg));
+}

package/src/disc.js

@@ -1,25 +1,7 @@
 // Translated from beebjit by Chris Evans.
 // https://github.com/scarybeasts/beebjit
 
-import * as utils from "./utils.js";
-
-/**
- * Compute CRC32 of a Uint8Array.
- * @param {Uint8Array} data
- * @returns {number} CRC32 as a signed 32-bit integer
- */
-export function crc32(data) {
-    let crc = 0xffffffff;
-    for (let i = 0; i < data.length; ++i) {
-        crc ^= data[i];
-        for (let j = 0; j < 8; ++j) {
-            const doEor = crc & 1;
-            crc = crc >>> 1;
-            if (doEor) crc ^= 0xedb88320;
-        }
-    }
-    return ~crc;
-}
+import { hexbyte, crc32 } from "./utils.js";
 class TrackBuilder {
     /**
      * @param {Track} track
@@ -482,7 +464,7 @@ class Track {
                     }
                     break;
                 default:
-                    console.log(`Unknown marker byte ${utils.hexbyte(dataByte)} ${this.description}`);
+                    console.log(`Unknown marker byte ${hexbyte(dataByte)} ${this.description}`);
             }
         }
         return sectors;

package/src/fake6502.js

@@ -6,7 +6,7 @@ import { FakeSoundChip } from "./soundchip.js";
 import { findModel, TEST_6502, TEST_65C02, TEST_65C12 } from "./models.js";
 import { FakeDdNoise } from "./ddnoise.js";
 import { FakeRelayNoise } from "./relaynoise.js";
-import { Cpu6502 } from "./6502.js";
+import { Cpu6502, AtomCpu6502 } from "./6502.js";
 import { Cmos } from "./cmos.js";
 import { FakeMusic5000 } from "./music5000.js";
 
@@ -20,7 +20,8 @@ export function fake6502(model, opts) {
     opts = opts || {};
     model = model || TEST_6502;
     if (opts.tube) model.tube = findModel("Tube65c02");
-    return new Cpu6502(model, {
+    const CpuClass = model.isAtom ? AtomCpu6502 : Cpu6502;
+    return new CpuClass(model, {
         dbgr,
         video: opts.video || fakeVideo,
         soundChip: opts.soundChip || soundChip,

package/src/jsbeeb.css

@@ -188,6 +188,29 @@ div.led {
   background-image: url(/images/yellow-on-16.png);
 }
 
+.tape-btn {
+  background: #333;
+  color: #ccc;
+  border: 1px solid #666;
+  border-radius: 3px;
+  font-size: 10px;
+  width: 20px;
+  height: 18px;
+  padding: 0;
+  line-height: 18px;
+  cursor: pointer;
+  text-align: center;
+}
+
+.tape-btn:hover {
+  background: #555;
+  color: #fff;
+}
+
+.tape-btn.playing {
+  color: #4c4;
+}
+
 #pages {
   margin-top: 10px;
 }

package/src/keyboard.js

@@ -1,5 +1,6 @@
 "use strict";
 import * as utils from "./utils.js";
+import { ATOM } from "./utils_atom.js";
 
 const isMac = typeof window !== "undefined" && /^Mac/i.test(window.navigator?.platform || "");
 
@@ -28,6 +29,14 @@ export class Keyboard extends EventTarget {
         this.inputEnabledFunction = inputEnabledFunction;
         this.dbgr = dbgr;
 
+        // Key interface: routes key events to SysVia (BBC) or PPIA (Atom).
+        // Both provide keyDown, keyUp, keyToggleRaw, setKeyLayout,
+        // clearKeys, disableKeyboard, enableKeyboard.
+        this.keyInterface = processor.model.isAtom ? processor.atomppia : processor.sysvia;
+        // The SHIFT key constant used by stringToMachineKeys in the paste key array.
+        // Compared by reference in _deliverPasteKey to avoid toggling shift off.
+        this._shiftKey = processor.model.isAtom ? ATOM.SHIFT : utils.BBC.SHIFT;
+
         // State
         this.emuKeyHandlers = {};
         this.running = false;
@@ -133,7 +142,7 @@ export class Keyboard extends EventTarget {
      */
     setKeyLayout(layout) {
         this.keyLayout = layout;
-        this.processor.sysvia.setKeyLayout(layout);
+        this.keyInterface.setKeyLayout(layout);
     }
 
     /**
@@ -225,7 +234,7 @@ export class Keyboard extends EventTarget {
         const isSpecialHandled = this._handleSpecialKeys(code);
         if (isSpecialHandled) return;
 
-        // Check for registered handlers first; if one fires, don't also send to the BBC.
+        // Check for registered handlers first; if one fires, don't pass to the emulator.
         // This lets Alt+key and Ctrl+key handlers cleanly own their keys without the
         // underlying key leaking through to the emulated machine.
         const handler = this._findKeyHandler(code, evt.altKey, evt.ctrlKey);
@@ -234,8 +243,8 @@ export class Keyboard extends EventTarget {
             return;
         }
 
-        // No handler claimed the key — pass it to the BBC Micro.
-        this.processor.sysvia.keyDown(code, evt.shiftKey);
+        // No handler claimed the key; pass it to the emulated machine.
+        this.keyInterface.keyDown(code, evt.shiftKey);
     }
 
     /**
@@ -268,7 +277,7 @@ export class Keyboard extends EventTarget {
 
         // Always let the key ups come through to avoid sticky keys in the debugger
         const code = this.keyCode(evt);
-        this.processor.sysvia.keyUp(code);
+        this.keyInterface.keyUp(code);
 
         // No further special handling needed if not running
         if (!this.running) return;
@@ -301,10 +310,10 @@ export class Keyboard extends EventTarget {
 
         // Mac browsers seem to model caps lock as a physical key that's down when capslock is on, and up when it's off.
         // No event is generated when it is physically released on the keyboard. So, we simulate a "tap" here.
-        this.processor.sysvia.keyDown(utils.keyCodes.CAPSLOCK);
+        this.keyInterface.keyDown(utils.keyCodes.CAPSLOCK);
 
         // Simulate a key release after a short delay
-        setTimeout(() => this.processor.sysvia.keyUp(utils.keyCodes.CAPSLOCK), CAPS_LOCK_DELAY);
+        setTimeout(() => this.keyInterface.keyUp(utils.keyCodes.CAPSLOCK), CAPS_LOCK_DELAY);
 
         if (isMac && window.localStorage && !window.localStorage.getItem("warnedAboutRubbishMacs")) {
             this.dispatchEvent(
@@ -324,20 +333,21 @@ export class Keyboard extends EventTarget {
     }
 
     /**
-     * Send raw keyboard input to the BBC
-     * @param {Array} keysToSend - Array of keys to send
+     * Send raw keyboard input to the emulated machine (for paste/autotype).
+     * @param {Array} keysToSend - Array of machine-specific key codes to send
      * @param {boolean} checkCapsAndShiftLocks - Whether to check caps and shift locks
      */
-    sendRawKeyboardToBBC(keysToSend, checkCapsAndShiftLocks) {
+    sendRawKeyboard(keysToSend, checkCapsAndShiftLocks) {
         if (this.isPasting) this.cancelPaste();
 
-        this.processor.sysvia.disableKeyboard();
-        this._pasteClocksPerMs = Math.floor(this.processor.cpuMultiplier * 2000000) / 1000;
+        this.keyInterface.disableKeyboard();
+        this._pasteClocksPerMs =
+            Math.floor(this.processor.cpuMultiplier * this.processor.peripheralCyclesPerSecond) / 1000;
 
         if (checkCapsAndShiftLocks) {
             let toggleKey = null;
-            if (!this.processor.sysvia.capsLockLight) toggleKey = utils.BBC.CAPSLOCK;
-            else if (this.processor.sysvia.shiftLockLight) toggleKey = utils.BBC.SHIFTLOCK;
+            if (!this.keyInterface.capsLockLight) toggleKey = utils.BBC.CAPSLOCK;
+            else if (this.keyInterface.shiftLockLight) toggleKey = utils.BBC.SHIFTLOCK;
             if (toggleKey) {
                 keysToSend.unshift(toggleKey);
                 keysToSend.push(toggleKey);
@@ -356,13 +366,22 @@ export class Keyboard extends EventTarget {
      * @private
      */
     _deliverPasteKey() {
-        if (this._pasteLastChar && this._pasteLastChar !== utils.BBC.SHIFT) {
-            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+        if (this._pasteLastChar && this._pasteLastChar !== this._shiftKey) {
+            this.keyInterface.keyToggleRaw(this._pasteLastChar);
         }
 
         if (this._pasteKeys.length === 0) {
             this._pasteLastChar = undefined;
-            this.processor.sysvia.enableKeyboard();
+            this.keyInterface.enableKeyboard();
+            return;
+        }
+
+        // Atom's PPIA keyboard is polled, not interrupt-driven like the BBC's
+        // SysVIA. Insert a debounce gap after every key release so the ROM
+        // sees the key-up before the next key-down arrives.
+        if (this._pasteLastChar && this._pasteLastChar !== this._shiftKey && this.processor.model.isAtom) {
+            this._pasteLastChar = undefined;
+            this._pasteTask.schedule(30 * this._pasteClocksPerMs);
             return;
         }
 
@@ -375,12 +394,15 @@ export class Keyboard extends EventTarget {
             return;
         }
 
-        let delayMs = 50;
+        // Atom ROM polls the keyboard once per VSync (~16ms at 60 Hz).
+        // 80ms gives the ROM ~5 scan cycles to detect, debounce, and
+        // process each keypress.
+        let delayMs = this.processor.model.isAtom ? 80 : 50;
         if (typeof this._pasteLastChar === "number") {
             delayMs = this._pasteLastChar;
             this._pasteLastChar = undefined;
         } else {
-            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+            this.keyInterface.keyToggleRaw(this._pasteLastChar);
         }
 
         this._pasteKeys.shift();
@@ -393,12 +415,12 @@ export class Keyboard extends EventTarget {
     cancelPaste() {
         if (!this.isPasting) return;
         this._pasteTask.cancel();
-        if (this._pasteLastChar && this._pasteLastChar !== utils.BBC.SHIFT) {
-            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+        if (this._pasteLastChar && this._pasteLastChar !== this._shiftKey) {
+            this.keyInterface.keyToggleRaw(this._pasteLastChar);
         }
         this._pasteLastChar = undefined;
         this._pasteKeys = [];
-        this.processor.sysvia.enableKeyboard();
+        this.keyInterface.enableKeyboard();
     }
 
     /**
@@ -413,7 +435,7 @@ export class Keyboard extends EventTarget {
      * Clears all pressed keys
      */
     clearKeys() {
-        this.processor.sysvia.clearKeys();
+        this.keyInterface.clearKeys();
     }
 
     /**

package/src/machine-session.js

@@ -9,7 +9,7 @@ import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import path from "path";
 import { TestMachine } from "../tests/test-machine.js";
-import { InstrumentedSoundChip } from "./soundchip.js";
+import { InstrumentedSoundChip, FakeSoundChip } from "./soundchip.js";
 
 // Resolve the jsbeeb package root from our own location (src/machine-session.js
 // → go up one level).  Passed to setNodeBasePath() so the ROM loader resolves
@@ -46,22 +46,31 @@ export class MachineSession {
 
         // Create a real Video instance so we get pixel output
         const modelObj = findModel(modelName);
-        this._video = new Video(modelObj.isMaster, this._fb32, (minx, miny, maxx, maxy) => {
-            this._lastPaint = { minx, miny, maxx, maxy };
-            this._frameDirty = true;
-            // Snapshot the complete frame now, before clearPaintBuffer() wipes _fb32.
-            // This mirrors what the browser does: paint_ext fires → canvas updated → fb32 cleared.
-            this._completeFb8.set(this._fb8);
-        });
-
-        // Use a real (instrumented) sound chip so we can read registers and capture writes
-        this._soundChip = new InstrumentedSoundChip();
+        this._isAtom = modelObj.isAtom;
+        this._video = new Video(
+            modelObj.isMaster,
+            this._fb32,
+            (minx, miny, maxx, maxy) => {
+                this._lastPaint = { minx, miny, maxx, maxy };
+                this._frameDirty = true;
+                // Snapshot the complete frame now, before clearPaintBuffer() wipes _fb32.
+                // This mirrors what the browser does: paint_ext fires → canvas updated → fb32 cleared.
+                this._completeFb8.set(this._fb8);
+            },
+            { isAtom: modelObj.isAtom },
+        );
+
+        // Use a real (instrumented) sound chip so we can read registers and capture writes.
+        // Atom models use AtomSoundChip which has a different interface (speakerGenerator,
+        // toneGenerator); FakeSoundChip provides compatible no-op stubs for headless mode.
+        this._soundChip = modelObj.isAtom ? new FakeSoundChip() : new InstrumentedSoundChip();
 
         // TestMachine forwards opts.video and opts.soundChip to fake6502
         this._machine = new TestMachine(modelName, { video: this._video, soundChip: this._soundChip });
 
         // Accumulated VDU text output — drained by callers
         this._pendingOutput = [];
+        this._flushCapture = () => {};
 
         // Breakpoint management — persistent hooks that survive across run calls
         this._breakpoints = new Map(); // id → { hook, type, address, hit }
@@ -90,8 +99,9 @@ export class MachineSession {
     /**
      * Install the VDU character-output capture hook.
      *
-     * WRCHV discovery: RAM at 0x20E/0x20F initialises to 0xFFFF before the
-     * OS runs.  We read directly from cpu.ramRomOs (two array lookups — no
+     * WRCHV discovery: RAM at the OS write-character vector (0x20E on BBC,
+     * 0x208 on Atom) initialises to 0x0000 before the OS runs.  We read
+     * directly from cpu.ramRomOs (two array lookups — no
      * readmem() dispatch overhead) on every instruction, waiting for the
      * value to change from its initial 0xFFFF.  Once the OS installs a real
      * handler we use that address for the lifetime of the session.  Programs
@@ -105,7 +115,9 @@ export class MachineSession {
     _installCaptureHook() {
         const cpu = this._machine.processor;
         const ram = cpu.ramRomOs; // direct Uint8Array — no dispatch overhead
-        const initialWrchv = ram[0x20e] | (ram[0x20f] << 8); // 0xFFFF pre-boot
+        // WRCHV vector: BBC at $020E, Atom at $0208.
+        const wrchvAddr = this._isAtom ? 0x208 : 0x20e;
+        const initialWrchv = ram[wrchvAddr] | (ram[wrchvAddr + 1] << 8); // 0xFFFF pre-boot
 
         const attributes = { x: 0, y: 0, text: "", foreground: 7, background: 0, mode: 7 };
         let currentText = "";
@@ -124,6 +136,12 @@ export class MachineSession {
             currentText = "";
         }
 
+        // Expose flush so drainOutput can capture trailing text
+        // that hasn't been terminated by a control character.
+        this._flushCapture = flush;
+
+        const isAtom = this._isAtom;
+
         function onChar(c) {
             if (nextN) {
                 params.push(c);
@@ -135,9 +153,6 @@ export class MachineSession {
                 return;
             }
             switch (c) {
-                case 1: // next char to printer only
-                    nextN = 1;
-                    break;
                 case 10: // LF
                     flush();
                     attributes.y++;
@@ -151,48 +166,58 @@ export class MachineSession {
                     flush();
                     attributes.x = 0;
                     break;
-                case 17: // COLOUR n
-                    nextN = 1;
-                    vduProc = (p) => {
-                        if (p[0] & 0x80) attributes.background = p[0] & 0xf;
-                        else attributes.foreground = p[0] & 0xf;
-                    };
-                    break;
-                case 18: // GCOL
-                    nextN = 2;
-                    break;
-                case 19: // define logical colour
-                    nextN = 5;
-                    break;
-                case 22: // MODE n
-                    nextN = 1;
-                    vduProc = (p) => {
-                        flush();
-                        attributes.mode = p[0];
-                        attributes.x = 0;
-                        attributes.y = 0;
-                        attributes.foreground = 7;
-                        attributes.background = 0;
-                    };
-                    break;
-                case 25: // PLOT
-                    nextN = 5;
-                    break;
-                case 28: // define text window
-                    nextN = 4;
-                    break;
-                case 29: // define graphics origin
-                    nextN = 4;
-                    break;
-                case 31: // TAB(x,y)
-                    nextN = 2;
-                    vduProc = (p) => {
-                        flush();
-                        attributes.x = p[0];
-                        attributes.y = p[1];
-                    };
-                    break;
                 default:
+                    // BBC VDU control codes (multi-byte sequences).
+                    // The Atom doesn't use these; skip them to avoid
+                    // swallowing printable characters.
+                    if (!isAtom) {
+                        switch (c) {
+                            case 1: // next char to printer only
+                                nextN = 1;
+                                return;
+                            case 17: // COLOUR n
+                                nextN = 1;
+                                vduProc = (p) => {
+                                    if (p[0] & 0x80) attributes.background = p[0] & 0xf;
+                                    else attributes.foreground = p[0] & 0xf;
+                                };
+                                return;
+                            case 18: // GCOL
+                                nextN = 2;
+                                return;
+                            case 19: // define logical colour
+                                nextN = 5;
+                                return;
+                            case 22: // MODE n
+                                nextN = 1;
+                                vduProc = (p) => {
+                                    flush();
+                                    attributes.mode = p[0];
+                                    attributes.x = 0;
+                                    attributes.y = 0;
+                                    attributes.foreground = 7;
+                                    attributes.background = 0;
+                                };
+                                return;
+                            case 25: // PLOT
+                                nextN = 5;
+                                return;
+                            case 28: // define text window
+                                nextN = 4;
+                                return;
+                            case 29: // define graphics origin
+                                nextN = 4;
+                                return;
+                            case 31: // TAB(x,y)
+                                nextN = 2;
+                                vduProc = (p) => {
+                                    flush();
+                                    attributes.x = p[0];
+                                    attributes.y = p[1];
+                                };
+                                return;
+                        }
+                    }
                     if (c >= 32 && c < 0x7f) {
                         currentText += String.fromCharCode(c);
                     } else {
@@ -207,7 +232,7 @@ export class MachineSession {
             // Once the OS sets WRCHV (it changes from 0xFFFF), we start
             // capturing.  Programs that install a custom VDU driver mid-run
             // are handled transparently because we re-read on every call.
-            const wrchv = ram[0x20e] | (ram[0x20f] << 8);
+            const wrchv = ram[wrchvAddr] | (ram[wrchvAddr + 1] << 8);
             if (wrchv !== initialWrchv && addr === wrchv) {
                 onChar(cpu.a);
             }
@@ -391,6 +416,7 @@ export class MachineSession {
      * Also includes a flat `screenText` reconstruction.
      */
     drainOutput({ clear = true } = {}) {
+        this._flushCapture();
         const elements = clear ? this._pendingOutput.splice(0) : [...this._pendingOutput];
         return {
             elements,