"use strict";

let systemName = "bedrock-js";
let systemVersion = "1.0.0";
let systemAuthors = "Ben Bridle";
let initialScreenScale = 2;


// Upgrade every pre.bedrock element to a full assembler, and every
// bedrock to a full emulator.
window.addEventListener('DOMContentLoaded', function() {
    injectStyles();

    for (let element of document.querySelectorAll('pre.bedrock')) {
        // Click on the element to upgrade to an assembler.
        element.style.cursor = 'pointer';
        element.addEventListener('click', function(e) {
            e.preventDefault();
            upgradeToAssembler(element);
        })
        // Prevent text selection on the element.
        element.addEventListener('selectstart', function(e) {
            e.preventDefault();
        })
    }
    for (let element of document.querySelectorAll('bedrock')) {
        upgradeToEmulator(element);
    }
})


// Insert the styles for the assembler and emulator into the page.
function injectStyles() {
    let css = document.createElement('style');
    css.textContent = bedrockStyles;
    document.head.appendChild(css);
}


// Upgrade a text element to a full assembler.
function upgradeToAssembler(element) {
    let assembler = new AssemblerElement(element);

    // HACK 2: Track the top of the original element relative to the viewport.
        let topStart = element.getBoundingClientRect().top;
        let scrollStart = window.scrollY;

    // HACK 1: Insert a fake spacer element following the original element to
    // prevent the page from jumping when the original element is replaced.
        // Spacer ensures that there is at least element height below the
        // viewport, filling the gap created while element is being replaced.
        let windowHeight = document.documentElement.clientHeight;
        let documentHeight = document.documentElement.scrollHeight;
        let belowViewport = documentHeight - (window.scrollY + windowHeight);
        let elementHeight = element.scrollHeight;
        let spacerHeight = Math.max(0, elementHeight - belowViewport);
        let spacer = document.createElement('div');
        spacer.style.height = spacerHeight + 'px';
        element.parentElement.insertBefore(spacer, element.nextSibling);

    element.replaceWith(assembler);

    // HACK 1: Remove the spacer after a short delay.
        setTimeout(()=>spacer.remove());

    // HACK 2: Check if the page jumped as the assembler was inserted.
       let topEnd = assembler.getBoundingClientRect().top;
       if (topStart != topEnd) {
            window.scrollTo({top: scrollStart, behavior: 'instant'});
           // Wait for the document layout to settle.
           setTimeout(() => {
               topEnd = assembler.getBoundingClientRect().top;
               let topTarget = (topEnd - topStart) + window.scrollY;
               window.scrollTo({top: topTarget, behavior: 'instant'});
           });
       }

    return assembler;
}


// Upgrade a bedrock element with attributes to a full emulator.
function upgradeToEmulator(element) {
    let attr = element.attributes;
    if (!attr.src || !attr.src.value) {
        console.error("No valid src attribute provided for <bedrock> element");
        return;
    }
    let scale = 1;
    try { scale = clamp(parseInt(attr.scale.value), 1, 10) } catch {}
    let options = {
        scale,
        controls: 'controls' in attr,
        autoplay: true,
    };
    let url = URL.parse(attr.src.value, window.location.href);
    if (!url) {
        console.error(`Invalid src attribute ${attr.src.value} provided for <bedrock> element`);
        return;
    }
    let request = new XMLHttpRequest();
    request.open("GET", url, true);
    request.responseType = "arraybuffer";
    request.onreadystatechange = function() {
        if (request.readyState == 4) {
            if (request.status == 200) {
                options.bytecode = new Uint8Array(request.response);
                let emulator = new EmulatorElement(options);
                element.replaceWith(emulator);
            } else {
                console.error(`Could not load Bedrock program from ${url.href}`);
            }
        }
    }
    request.send();
}


// ----------------------------------------------------------------------------------------------- +
//  :::::: ELEMENTS :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +
// ----------------------------------------------------------------------------------------------- +


// Constructor for an interactive assembler element.
function AssemblerElement(element) {
    let assembler = elementFromHTML(assemblerTemplate);
    let textarea = assembler.querySelector('textarea');
    let viewer = assembler.querySelector('.viewer');
    let editor = assembler.querySelector('.editor');
    let errorPanel = assembler.querySelector('.panel.errors');
    let bytecodePanel = assembler.querySelector('.panel.bytecode');
    let status = assembler.querySelector('.status');
    let checkButton = assembler.querySelector('button[name="check"]');
    let runButton = assembler.querySelector('button[name="run"]');
    let fullscreenButton = assembler.querySelector('button[name="fullscreen"]');
    assembler.autoGrow = true;
    assembler.emulator = null;


    // Show and hide the error and bytecode panels.
    assembler.showErrorPanel = function() {
        errorPanel.classList.remove('hidden'); }
    assembler.hideErrorPanel = function() {
        errorPanel.classList.add('hidden'); }
    assembler.showBytecodePanel = function() {
        bytecodePanel.classList.remove('hidden'); }
    assembler.hideBytecodePanel = function() {
        bytecodePanel.classList.add('hidden'); }


    // Place focus on the editor.
    assembler.focus = function() {
        textarea.focus();
    }

    // Lock the viewer to the textarea by syncing their scroll positions.
    assembler.syncScroll = function() {
        viewer.scrollTop = textarea.scrollTop;
        viewer.scrollLeft = textarea.scrollLeft;
    }

    // Lock the viewer to the textarea by syncing their sizes.
    assembler.syncSize = function() {
        // Disable auto-grow if editor was made smaller by the user.
        if (textarea.clientHeight < viewer.clientHeight) {
            assembler.autoGrow = false; }
        viewer.style.height = textarea.clientHeight + 'px';
        editor.style.height = textarea.clientHeight + 'px';
    }

    // Copy text from textarea to viewer with syntax highlighting.
    assembler.renderText = function() {
        // Force viewer to show trailing newlines.
        let text = textarea.value;
        if (text.slice(-1) == "\n") text += ' ';
        // Replace contents of viewer.
        viewer.innerHTML = '';
        for (let child of highlightSource(text)) {
            viewer.appendChild(child); }
        // Auto-grow the text area as text is entered.
        if (assembler.autoGrow && textarea.scrollHeight > textarea.clientHeight) {
            textarea.style.height = textarea.scrollHeight + 'px'; }
        // Lock viewer to textarea.
        assembler.syncScroll();
    }

    // Assemble the program and show bytecode or errors.
    assembler.checkProgram = function() {
        let { bytecode, symbols, errors } = assembleProgram(textarea.value);
        errorPanel.innerHTML = '';
        bytecodePanel.innerHTML = '';
        if (errors.length) {
            let list = document.createElement('ul');
            for (let error of errors) {
                let item = document.createElement('li');
                let line = error.start.line + 1;
                let column = error.start.column + 1;
                item.textContent = `[${line}:${column}] ${error.text}`;
                list.appendChild(item); }
            errorPanel.appendChild(list);
            let unit = errors.length == 1 ? 'error' : 'errors';
            status.textContent = `${errors.length} ${unit}`;
            assembler.hideBytecodePanel();
            assembler.showErrorPanel();
        } else {
            let unit = bytecode.length == 1 ? 'byte' : 'bytes';
            status.textContent = `no errors (${bytecode.length} ${unit})`;
            let hexString = '';
            for (let byte of bytecode) hexString += hex(byte, 2) + ' ';
            let programListing = document.createElement('div');
            programListing.textContent = hexString;
            bytecodePanel.appendChild(programListing);
            assembler.hideErrorPanel();
            assembler.hideBytecodePanel();
            // if (bytecode.length) assembler.showBytecodePanel();
            return { bytecode, symbols };
        }
    }

    assembler.runProgram = function() {
        // Create an emulator if none exists.
        if (!assembler.emulator) {
            assembler.emulator = new EmulatorElement();
            assembler.emulator.assembler = assembler;
            assembler.parentElement.insertBefore(assembler.emulator, assembler.nextSibling); }
        let program = assembler.checkProgram();
        if (program) {
            let { bytecode, symbols } = program;
            assembler.emulator.showStatePanel();
            assembler.emulator.startProgram(bytecode, symbols);
        }
    }

    // Change the fullscreen state of the whole assembler.
    assembler.toggleFullscreen = function() {
        if (document.fullscreenElement != assembler) {
            assembler.requestFullscreen();
        } else {
            document.exitFullscreen();
        }
    }

    // Handle keypresses on the whole assembler.
    assembler.onKeyPress = function(event) {
        if (event.key == "Escape") {
            event.preventDefault();
            assembler.hideErrorPanel();
            assembler.hideBytecodePanel();
        } else if (event.key == "s" && event.ctrlKey) {
            event.preventDefault();
            assembler.checkProgram();
        }
    }

    // Handle keypresses on just the editor.
    assembler.onEditorKeyPress = function(event) {
        let size = 2; let indent = '  ';
        let text = textarea.value;
        let selectionStart = textarea.selectionStart;
        let selectionEnd = textarea.selectionEnd;

        // Find the character index following the previous newline character.
        function findLineStart(i) {
            while (i>0 && text[i-1] != '\n') i -= 1;
            return i; }

        if (event.key == "Enter" && event.ctrlKey) {
            event.preventDefault();
            assembler.runProgram();
        } else if (event.key == "Tab") {
            event.preventDefault();
            // Find the start index of every line in the selection.
            let i = findLineStart(selectionStart);
            let lineStarts = [i];
            for (; i<selectionEnd; i++) if (text[i] == '\n') lineStarts.push(i+1);
            if (event.shiftKey) {
                // Find length of the leading whitespace in each line.
                let whitespaceLengths = [];
                for (let start of lineStarts) {
                    let end = start;
                    while ('\t '.includes(text[end])) end++;
                    whitespaceLengths.push(end-start); }
                // Unindent each line in reverse order.
                selectionStart -= Math.min(size, whitespaceLengths[0]);
                for (let i=lineStarts.length-1; i>=0; i--) {
                    let start = lineStarts[i];
                    let trim = Math.min(size, whitespaceLengths[i]);
                    text = text.slice(0, start) + text.slice(start+trim);
                    selectionEnd -= trim; }
            } else {
                // Indent each line in reverse order.
                selectionStart += size;
                for (let i=lineStarts.length-1; i>=0; i--) {
                    let start = lineStarts[i];
                    text = text.slice(0, start) + indent + text.slice(start);
                    selectionEnd += size; }
            }
            // Update textarea content and viewer.
            textarea.value = text;
            textarea.selectionStart = selectionStart;
            textarea.selectionEnd = selectionEnd;
            assembler.renderText();
        }
    }

    textarea.addEventListener('input', assembler.renderText);
    textarea.addEventListener('scroll', assembler.syncScroll);
    textarea.addEventListener('keydown', assembler.onEditorKeyPress);
    assembler.addEventListener('keydown', assembler.onKeyPress);
    checkButton.addEventListener('click', assembler.checkProgram);
    runButton.addEventListener('click', assembler.runProgram);
    fullscreenButton.addEventListener('click', assembler.toggleFullscreen);

    assembler.resizeObserver = new ResizeObserver(assembler.syncSize).observe(textarea);
    textarea.value = element.textContent.trim();
    textarea.selectionStart = 0;
    textarea.selectionEnd = 0;
    textarea.scrollLeft = 0;
    textarea.style.height = element.clientHeight + 'px';
    assembler.renderText();

    return assembler;
}


/// Constructor for a interactive emulator element.
function EmulatorElement(options) {
    let emulator = elementFromHTML(emulatorTemplate);
    // Menu bar
    let menuBar = emulator.querySelector('.menubar');
    let fullscreenButton = menuBar.querySelector('button[name="fullscreen"]');
    let stateButton = menuBar.querySelector('button[name="state"]');
    let runButton = menuBar.querySelector('button[name="run"]');
    let pauseButton = menuBar.querySelector('button[name="pause"]');
    let stopButton = menuBar.querySelector('button[name="stop"]');
    let stepButton = menuBar.querySelector('button[name="step"]');
    let status = menuBar.querySelector('.status');
    // Screen panel
    let screenPanel = emulator.querySelector('.screen');
    let canvas = screenPanel.querySelector('canvas');
    // Stream panel
    let streamPanel = emulator.querySelector('.stream');
    let transmissions = emulator.querySelector('.transmissions');
    // State panel
    let statePanel = emulator.querySelector('.panel.state');
    let pcState = statePanel.querySelector('.pc');
    let labelState = statePanel.querySelector('.label');
    let wstState = statePanel.querySelector('.wst');
    let rstState = statePanel.querySelector('.rst');

    let loadedBytecode = options ? options.bytecode : new Uint8Array(0);
    let loadedSymbols = new SymbolTable();
    let loadedMetadata = parseMetadata(loadedBytecode);
    let currentTransmission = null;
    let transmissionParser = new Utf8StreamParser();

    emulator.screen = screenPanel;
    emulator.canvas = canvas;
    let br = new Bedrock(emulator);
    br.reset();
    br.onUpdate = () => emulator.updateStatePanel();

    emulator.showStatePanel = function() {
        statePanel.classList.remove('hidden'); }
    emulator.toggleStatePanel = function() {
        statePanel.classList.toggle('hidden'); }
    emulator.showStreamPanel = function() {
        streamPanel.classList.remove('hidden'); }
    emulator.hideStreamPanel = function() {
        streamPanel.classList.add('hidden'); }
    emulator.showScreenPanel = function() {
        screenPanel.classList.remove('hidden'); }
    emulator.hideScreenPanel = function() {
        screenPanel.classList.add('hidden'); }
    emulator.hideMenuBar = function() {
        menuBar.classList.add('hidden'); }

    // Reset the emulator and load a new program.
    emulator.startProgram = function(bytecode, symbols) {
        emulator.stopProgram();
        loadedBytecode = bytecode;
        loadedSymbols = symbols;
        loadedMetadata = parseMetadata(bytecode);
        br.loadProgram(bytecode);
        br.run();
    }
    // Fires when the play button is pressed.
    emulator.runProgram = function() {
        br.blank ? emulator.startProgram(loadedBytecode, loadedSymbols) : br.run();
    }
    // Fires when the pause button is pressed.
    emulator.pauseProgram = function() {
        br.pause();
    }
    // Fires when the stop button is pressed.
    emulator.stopProgram = function() {
        br.stop();
        emulator.updateStatePanel();
        transmissions.innerHTML = '';
        emulator.hideStreamPanel();
        emulator.hideScreenPanel();
        currentTransmission = null;
    }

    emulator.updateStatePanel = function() {
        function renderStack(stack) {
            let string = '';
            for (let i=0; i<stack.p; i++) string += hex(stack.mem[i], 2) + ' ';
            return string;
        }
        pcState.textContent = hex(br.p, 4);
        labelState.textContent = loadedSymbols.findSymbol(br.p);
        wstState.textContent = renderStack(br.wst);
        rstState.textContent = renderStack(br.rst);
        if (br.halted) {
            status.textContent = 'ended';
        } else if (br.blank) {
            status.textContent = '';
        } else if (br.paused) {
            status.textContent = 'paused';
        } else if (br.asleep) {
            let wakeMask = br.dev.system.wakeMask;
            status.textContent = `sleeping / 0x${hex(wakeMask, 4)}`;
        } else {
            status.textContent = `running / ${br.cycle}`;
        }
    }

    emulator.updateScreenSize = function() {
        if (!screenPanel.classList.contains('hidden')) {
            if (document.fullscreenElement == emulator) {
                let width = screenPanel.clientWidth;
                let height = screenPanel.clientHeight;
                br.dev.screen.resizeToFill(width, height);
            } else {
                let width = screenPanel.clientWidth;
                let height = width * 9/16;
                br.dev.screen.resizeToFill(width, height);
            }
        }
    }

    // Receive an incoming byte from the local stream.
    emulator.receiveTransmissionByte = function(byte) {
        if (!currentTransmission) {
            emulator.showStreamPanel();
            let element = document.createElement('li');
            element.addEventListener('click', function() {
                copyText(element.textContent); })
            currentTransmission = element;
            transmissions.appendChild(element); }
        transmissionParser.push(byte);
        currentTransmission.textContent += transmissionParser.read();
        streamPanel.scrollTop = streamPanel.scrollHeight;
    }

    // End the current incoming transmission.
    emulator.endTransmission = function() {
        streamPanel.scrollTop = streamPanel.scrollHeight;
        currentTransmission = null;

    }

    // Change the fullscreen state of the whole emulator.
    emulator.toggleFullscreen = function() {
        if (document.fullscreenElement != emulator) {
            emulator.requestFullscreen();
        } else {
            document.exitFullscreen();
        }
    }

    emulator.mouseMove = function(e) {
        let bounds = canvas.getBoundingClientRect();
        let scale = br.dev.screen.scale;
        let x = ((e.clientX - bounds.left) / scale) & 0xFFFF;
        let y = ((e.clientY - bounds.top ) / scale) & 0xFFFF;
        br.dev.input.applyPosition(x, y);
    }
    emulator.mouseDown = function(e) {
        br.dev.input.applyButtons(e.buttons);
    }
    emulator.mouseUp = function(e) {
        br.dev.input.applyButtons(e.buttons);
    }
    emulator.mouseEnter = function(e) {
        br.dev.input.applyActive(true);
        emulator.mouseMove(e);
    }
    emulator.mouseExit = function(e) {
        br.dev.input.applyActive(false);
        emulator.mouseMove(e);
    }
    emulator.mouseScroll = function(e) {
        // Only capture scroll events if canvas is focused.
        if (document.activeElement == canvas) {
            e.preventDefault();
            let scale;
            // TODO: Dial these numbers in a bit.
            switch (e.deltaMode) {
                case (e.DOM_DELTA_PIXEL): scale =  1; break;
                case (e.DOM_DELTA_LINE):  scale =  5; break;
                case (e.DOM_DELTA_PAGE):  scale = 30; break;
            };
            br.dev.input.applyHScroll(e.deltaX * scale);
            br.dev.input.applyVScroll(e.deltaY * scale);
        }
    }
    emulator.keyInput = function(e, pressed) {
        e.preventDefault();
        br.dev.input.applyModifiers(e);
        if (!e.repeat && !e.isComposing) {
            br.dev.input.applyKey(e, pressed);
        }
    }

    fullscreenButton.addEventListener('click', emulator.toggleFullscreen);
    stateButton.addEventListener('click', emulator.toggleStatePanel);
    runButton.addEventListener('click', emulator.runProgram);
    pauseButton.addEventListener('click', emulator.pauseProgram);
    stopButton.addEventListener('click', emulator.stopProgram);
    stepButton.addEventListener('click', br.step);

    canvas.addEventListener('mousemove', emulator.mouseMove);
    canvas.addEventListener('pointermove', emulator.mouseMove);
    canvas.addEventListener('mousedown', emulator.mouseDown);
    canvas.addEventListener('mouseup', emulator.mouseUp);
    canvas.addEventListener('mouseenter', emulator.mouseEnter);
    canvas.addEventListener('mouseleave', emulator.mouseExit);
    canvas.addEventListener('wheel', emulator.mouseScroll);
    canvas.addEventListener('contextmenu', (e)=>{e.preventDefault()});
    canvas.addEventListener('keydown', (e)=>emulator.keyInput(e, true));
    canvas.addEventListener('keyup', (e)=>emulator.keyInput(e, false));
    // Make canvas focusable to be able to receive keydown and keyup events.
    canvas.tabIndex = 0;

    emulator.resizeObserver = new ResizeObserver(emulator.updateScreenSize).observe(screenPanel);

    if (options && !options.controls) emulator.hideMenuBar();
    if (options && options.autoplay) emulator.runProgram();

    return emulator;
}


// Create an element from an HTML string.
function elementFromHTML(html) {
    let template = document.createElement('template');
    template.innerHTML = html.trim();
    return template.content.firstChild;
}


// Convert an integer to a hexadecimal string.
function hex(value, pad) {
    return value.toString(16).toUpperCase().padStart(pad, '0');
}


function parseMetadata(bytecode) {
    // Test identifier to see if program has metadata.
    let id = [0xE8,0x00,0x18,0x42,0x45,0x44,0x52,0x4F,0x43,0x4B];
    for (let i=0; i<10; i++) if (bytecode[i] != id[i]) return;
    // Parse each metadata item.
    let name = getString(0x000A);
    let authors = getString(0x000C);
    let description = getString(0x000E);
    let bgColour = getColour(0x0010);
    let fgColour = getColour(0x0012);
    let smallIcon = getIcon(0x0014, 24);
    let largeIcon = getIcon(0x0016, 64);
    return { name, authors, description, bgColour, fgColour, smallIcon, largeIcon };

    function getByte(addr) {
        return bytecode[addr] || 0;
    }
    function getDouble(addr) {
        return getByte(addr) << 8 | getByte(addr+1);
    }
    function getString(addr) {
        addr = getDouble(addr);
        if (addr) {
            let parser = new Utf8StreamParser();
            while (true) {
                let byte = bytecode[addr++];
                if (!byte) break;
                parser.push(byte);
            }
            return parser.read();
        }
    }
    function getColour(addr) {
        addr = getDouble(addr);
        if (addr) {
            let colour = getDouble(addr);
            let r = (colour >> 8 & 0xF) * 17;
            let g = (colour >> 8 & 0xF) * 17;
            let b = (colour >> 8 & 0xF) * 17;
            return [r, g, b];
        }
    }
    function getIcon(addr, size) {
        // TODO: Return a custom type containing the dimensions and raw
        // pixel data, and a colourise method to generate a coloured ImageData.
    }
}


// Copy a string to the clipboard.
function copyText(text) {
    navigator.clipboard.writeText(text);
}

let encoder = new TextEncoder();
function encodeUtf8(text) {
    return encoder.encode(text);
}

// Incrementally parse a UTF-8 string.
function Utf8StreamParser() {
    // Full characters parsed so far.
    this.string = '';
    // Current partial code point.
    this.codePoint;
    // True if the current code point is being dropped.
    this.dropBytes = false;
    // Number of bytes received of the current code point.
    this.i = 0;
    // Expected byte length of the current code point.
    this.len = 0;

    // Push a code point to the string.
    let pushCodePoint = (codePoint) => {
        this.string += String.fromCodePoint(codePoint);
    }
    // Drop the current partial code point, if any.
    let dropCodePoint = () => {
        // Push a 'replacement character' if there is a partial code point
        // that hasn't already been dropped.
        if (this.i && !this.dropBytes) pushCodePoint(0xFFFD);
        this.codePoint = 0;
        this.dropBytes = false;
        this.i = 0;
        this.len = 0;
    }
    // Parse the start of an encoded code point.
    let parseStartByte = (byte, length) => {
        dropCodePoint();
        this.len = length;
        parseContinuationByte(byte);
    }
    // Parse the remaining bytes of an encoded code point.
    let parseContinuationByte = (byte) => {
        if (!this.dropBytes) {
            if (this.len) {
                this.codePoint = this.codePoint << 6 | (byte & 0x3F);
                this.i += 1;
                if (this.i == this.len) {
                    pushCodePoint(this.codePoint);
                    this.len = 0;
                }
            } else {
                this.dropBytes = true;
                pushCodePoint(0xFFFD);
            }
        }
    }

    // Parse a UTF-8 encoded byte.
    this.push = (byte) => {
        if        (byte < 0x80) {  // start of a 1-byte code point
            dropCodePoint();
            pushCodePoint(byte);
        } else if (byte < 0xC0) {  // not a start byte
            parseContinuationByte(byte);
        } else if (byte < 0xE0) {  // start of a 2-byte code point
            parseStartByte(byte, 2);
        } else if (byte < 0xF0) {  // start of a 3-byte code point
            parseStartByte(byte, 3);
        } else if (byte < 0xF8) {  // start of a 4-byte code point
            parseStartByte(byte, 4);
        }
    }
    // Parse an array of bytes.
    this.pushList = (list) => {
        for (let byte of list) this.push(byte);
    }

    // Take the characters that have been parsed so far.
    this.read = () => {
        let output = this.string;
        this.string = '';
        return output;
    }
}






// ----------------------------------------------------------------------------------------------- +
//  :::::: ASSEMBLER:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +
// ----------------------------------------------------------------------------------------------- +


// Convert a string of Bedrock source code into syntax-highlighted nodes.
function highlightSource(source) {
    let currentText = '', currentClass = '';
    let items = [];
    let typeLookup = {
             'comment': 'comment',
            'markOpen': 'comment',
           'markClose': 'comment',
           'blockOpen': '',
          'blockClose': '',
           'rawString': 'value',
    'terminatedString': 'value',
     'macroDefinition': 'definition',
         'globalLabel': 'definition',
          'localLabel': 'definition',
     'macroTerminator': 'definition',
              'spacer': '',
              'symbol': 'reference',
         'byteLiteral': 'value',
       'doubleLiteral': 'value',
         'instruction': '',
          'whitespace': '',
    };
    function pushItem(text, className) {
        if (currentClass != className) {
            if (currentClass) {
                let span = document.createElement('span');
                span.textContent = currentText;
                span.className = currentClass;
                items.push(span);
            } else {
                items.push(document.createTextNode(currentText));
            }
            currentClass = className;
            currentText = text;
        } else {
            currentText += text;
        }
    }
    for (let token of tokeniseProgram(source).tokens) {
        pushItem(token.text, typeLookup[token.type]);
    }
    pushItem(' ');
    return items;
}


// Tokenise a string of Bedrock source code.
function tokeniseProgram(source) {
    let tokens = [], errors = [];
    let currentText = '', endChar = '', label = '';
    let currentLine = 0, currentColumn = 0;  // position of next character
    let prevLine    = 0, prevColumn    = 0;  // position before current
    let rewindLine  = 0, rewindColumn  = 0;  // position before prev
    let startLine   = 0, startColumn   = 0;  // position of token start

    // Rewind the prev position by one character.
    function rewind() {
        prevLine = rewindLine; prevColumn = rewindColumn;
    }
    // Attach a start and end location to a string.
    function trackText(text) {
        let start = { line: startLine, column: startColumn };
        let end   = { line: prevLine,  column: prevColumn  };
        return { text, start, end };
    }
    // Report an error.
    function error(text) {
        errors.push(trackText(text));
    }
    // Parse a literal string.
    function parseLiteral(string) {
        if (string.length == 2 || string.length == 4) {
            const hexDigits = "0123456789ABCDEFabcdef";
            for (let c of string) if (!hexDigits.includes(c)) return;
            let value = parseInt(string, 16);
            if (!isNaN(value)) return value;
        }
    };
    // Commit the current token.
    function commit() {
        if (currentText) {
            let firstChar = currentText[0];
            let token = trackText(currentText);
            if ('()'.includes(firstChar)) {
                token.type  = 'comment';
            } else if (firstChar == '[') {
                token.type  = 'markOpen';
            } else if (firstChar == ']') {
                token.type  = 'markClose';
            } else if (firstChar == '{') {
                token.type  = 'blockOpen';
            } else if (firstChar == '}') {
                token.type  = 'blockClose';
            } else if (firstChar == '\'') {
                token.type  = 'rawString';
                token.value = currentText.slice(1,-1);
            } else if (firstChar == '"') {
                token.type  = 'terminatedString';
                token.value = currentText.slice(1,-1);
            } else if (firstChar == '%') {
                token.type  = 'macroDefinition';
                token.name = currentText.slice(1);
            } else if (firstChar == '@') {
                token.type  = 'globalLabel';
                label = currentText.slice(1);
                token.name = label;
            } else if (firstChar == '&') {
                token.type  = 'localLabel';
                token.name = label + '/' + currentText.slice(1);
            } else if (firstChar == ';') {
                token.type = 'macroTerminator';
            } else if (firstChar == '#') {
                token.type = 'spacer';
                token.value = parseLiteral(currentText.slice(1));
                if (token.value == undefined) {
                    error(`Invalid value for spacer: ${currentText.slice(1)}`)
                }
            } else if (firstChar == '~') {
                token.type = 'symbol';
                token.name = label + '/' + currentText.slice(1);
            } else {
                let value = parseLiteral(currentText);
                if (value != undefined) {
                    token.type = currentText.length == 2 ? 'byteLiteral' : 'doubleLiteral';
                    token.value = value;
                } else {
                    let value = instructionTable[currentText];
                    if (value != undefined) {
                        token.type = 'instruction';
                        token.value = value;
                    } else {
                        token.type = 'symbol';
                        token.name = currentText;
                    }
                }
            }
            tokens.push(token);
            currentText = '';
            startLine = currentLine; startColumn = currentColumn;
        }
    }

    for (let c of source) {
        // Advance position.
        rewindLine = prevLine; rewindColumn = prevColumn;
        prevLine = currentLine; prevColumn = currentColumn;
        currentColumn += 1;
        if (c == '\n') { currentLine += 1; currentColumn = 0; }

        if (endChar) {
            currentText += c;
            if (c == endChar) {
                commit(); endChar = '';
            }
        } else if ('()'.includes(c)) {
            commit(); currentText += c;
            if (c == '(') {
                endChar = ')';
            } else {
                error("Unmatched ')', no comment was in progress");
                commit();
            }
        } else if (!currentText && '"\''.includes(c)) {
            currentText += c; endChar = c;
        } else if ('\r\n\t '.includes(c)) {
            let token = {
                text: c, type: 'whitespace',
                start: { line: prevLine, column: prevColumn },
                end:   { line: prevLine, column: prevColumn },
            };
            rewind(); commit();
            tokens.push(token);
        } else if ('[]{};'.includes(c)) {
            rewind(); commit(); currentText += c; commit();
        } else if (c == ':') {
            currentText += c; commit();
        } else {
            currentText += c;
        }
    }
    // Report unclosed token.
    if (endChar == ')') {
        error("Unclosed comment");
    } else if (endChar) {
        error("Unclosed string");
    }

    // Commit final token.
    commit();
    return { tokens, errors };
}


// Assemble a string of Bedrock source code.
function assembleProgram(source) {
    let { tokens, errors } = tokeniseProgram(source);
    let program = new Uint8Array(65536);
    // Populated up front with all names.
    let macros = {}, labels = {}, address = 0;
    for (let token of tokens) {
        if (['globalLabel', 'localLabel'].includes(token.type)) {
            labels[token.name] = { refs:[], address:0 };
        } else if ('macroDefinition' == token.type) {
            macros[token.name] = [];
        }
    }
    // Populated gradually as each definition is reached.
    let macroNames = {}, labelNames = {};

    // Assemble a byte value.
    function pushByte(byte) {
        program[address++] = byte;
    }
    // Assemble a double value.
    function pushDouble(double) {
        program[address++] = double >> 8;
        program[address++] = double & 0xFF;
    }
    // Report an error message.
    function error(text, token) {
        let start = { line: token.start.line, column: token.start.column };
        let end =   { line: token.end.line,   column: token.end.column   };
        errors.push({ text, start, end });
    }
    // Returns true if the name has been defined at this point in the program.
    function nameTaken(name) {
        return name in macroNames || name in labelNames || name in instructionTable;
    }
    // Recursively assemble an array of tokens.
    function assembleTokens(tokens) {
        let stack = [];
        for (let i=0; i<tokens.length; i++) {
            let token = tokens[i];
            if (['comment', 'markOpen', 'markClose', 'whitespace'].includes(token.type)) {
                // ignore comments and whitespace.
            } else if (['rawString', 'terminatedString'].includes(token.type)) {
                for (let byte of encodeUtf8(token.value)) program[address++] = byte;
                if (token.type == 'terminatedString') pushByte(0);
            } else if (token.type == 'spacer') {
                for (let i=0; i<token.value; i++) pushByte(0);
            } else if (token.type == 'blockOpen') {
                stack.push({ token, address });
                pushDouble(0);
            } else if (token.type == 'blockClose') {
                let stash = address;
                let pop = stack.pop();
                if (pop != undefined) {
                    address = pop.address;
                    pushDouble(stash);
                    if (stash > 0xFFFF) {
                        error(`Block address too high`, token);
                    }
                } else {
                    error("Unmatched '}', no block was in progress", token);
                }
                address = stash;
            } else if (['globalLabel', 'localLabel'].includes(token.type)) {
                if (nameTaken(token.name)) {
                    error(`Label name already taken: ${token.name}`, token);
                } else {
                    labelNames[token.name] = true;
                    labels[token.name].address = address;
                    if (address > 0xFFFF) {
                        error(`Label address too high: ${token.name}`, token);
                    }
                }
            } else if (token.type == 'macroDefinition') {
                if (nameTaken(token.name)) {
                    error(`Macro name already taken: ${token.name}`, token);
                } else {
                    let body = [], terminated = false;
                    i += 1;
                    while (i<tokens.length) {
                        let bodyToken = tokens[i++]
                        let name = bodyToken.name;
                        let type = bodyToken.type;
                        if (['whitespace', 'comment', 'markOpen', 'markClose'].includes(type)) {
                            // ignore comments and whitespace
                        } else if (type == 'macroTerminator') {
                            terminated = true; break;
                        } else if (['globalLabel', 'localLabel'].includes(type)) {
                            error(`Label definition inside macro definition: ${name}`, bodyToken);
                        } else if (type == 'macroDefinition') {
                            error(`Macro definition inside macro definition: ${name}`, bodyToken);
                        } else if (type == 'symbol') {
                            if (name in labels) {
                                body.push(bodyToken);
                            } else if (name in macroNames) {
                                body.push(bodyToken);
                            } else if (name in macros) {
                                error(`Macro cannot reference itself: ${name}`, bodyToken);
                            } else if (name in macros) {
                                error(`Macro referenced before definition: ${name}`, bodyToken);
                            } else {
                                error(`Undefined symbol: ${name}`, bodyToken);
                            }
                        } else {
                            body.push(bodyToken);
                        }
                    }
                    if (terminated) {
                        macroNames[token.name] = true;
                        macros[token.name] = body;
                    } else {
                        error('Unterminated macro definition', token);
                    }
                }
            } else if (token.type == 'macroTerminator') {
                error("Unmatched ';', no macro definition was in progress", token);
            } else if (['byteLiteral', 'instruction'].includes(token.type)) {
                pushByte(token.value);
            } else if (token.type == 'doubleLiteral') {
                pushDouble(token.value);
            } else if (token.type == 'symbol') {
                if (token.name in labels) {
                    labels[token.name].refs.push(address);
                    pushDouble(0);
                } else if (token.name in macroNames) {
                    assembleTokens(macros[token.name]);
                } else if (token.name in macros) {
                    error('Macro referenced before definition', token);
                } else {
                    error(`Undefined symbol: ${token.name}`, token);
                }
            } else {
                console.log("Unknown token type: " + token.type);
            }
        }
        for (let { token, address } of stack) {
            error('Unclosed block', token);
        }
    }

    assembleTokens(tokens);
    let endAddress = address;
    let symbols = new SymbolTable();
    // Backfill label references with real label addresses.
    for (let [name, label] of Object.entries(labels)) {
        for (let ref of label.refs) {
            address = ref; pushDouble(label.address);
        }
        // Add label and address to symbols table.
        symbols.addSymbol(label.address, name);
    }
    let bytecode = program.slice(0, endAddress);
    return { bytecode, symbols, errors };
}


function SymbolTable() {
    this.names = [];
    this.addresses = [];

    // Add a symbol to the table. Symbols must be added in address order.
    this.addSymbol = function(address, name) {
        this.names.push(name);
        this.addresses.push(address);
    }

    // Get the symbol that is at or comes before this address.
    this.findSymbol = function(address) {
        // Perform a binary search, based on Rust's slice::binary_search_by.
        let size = this.addresses.length;
        let base = 0;
        while (size > 1) {
            let half = size >> 1;
            let mid = base + half;
            base = this.addresses[mid] > address ? base : mid;
            size -= half;
        }
        if (this.addresses[base] == address) {
            return '@' + this.names[base];
        } else {
            if (address >= this.addresses[0]) {
                let i = base + (this.addresses[base] > address);
                return '@' + this.names[i];
            } else {
                return '';
            }
        }
    }
}



// ----------------------------------------------------------------------------------------------- +
//  :::::: EMULATOR::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +
// ----------------------------------------------------------------------------------------------- +


// The core Bedrock emulator. Receives an EmulatorElement.
function Bedrock(e) {
    this.e = e;
    this.mem = new Uint8Array(65536);
    this.wst = new Stack();
    this.rst = new Stack();
    this.dev = new DeviceBus(this);
    // Callback functions.
    this.onUpdate;

    // Reset the emulator, preserving the contents of program memory.
    this.reset = () => {
        this.p = 0;
        this.wst.reset();
        this.rst.reset();
        this.dev.reset();
        this.cycle = 0;
        this.blank = true;    // true when emulator has been reset.
        this.paused = true;   // true when program is paused for the user.
        this.asleep = false;  // true when program is waiting for input.
        this.halted = false;  // true when program has halted.
    }

    // Reset the emulator and load in a new program.
    this.loadProgram = (bytecode) => {
        this.reset();
        this.mem.fill(0);
        this.mem.set(bytecode.slice(0, 65536));
        this.blank = false;
    }

    this.run = () => {
        this.paused = false;
        this.update();
        this.runLoop();
    }

    this.step = () => {
        if (this.paused && !this.halted) {
            if (this.asleep) {
                this.sleepLoop()
            } else {
                this.blank = false;
                switch (this.evaluate(1)) {
                    case 5: this.halt();    break; // HALT
                    case 4: this.reset();   break; // RESET
                    case 3: this.reset();   break; // FORK
                    case 2: this.sleep();   break; // SLEEP
                    case 1: this.pause();   break; // DEBUG
                    default:                break; // NORMAL
                }
                this.update();
                this.render();
            }
        }
    }

    this.pause = () => {
        this.paused = true;
        this.update();
        this.render();
    }

    this.stop = () => {
        this.reset();
        this.update();
        this.render();
    }

    this.halt = () => {
        this.halted = true;
        this.update();
        this.render();
    }

    this.sleep = () => {
        this.asleep = true;
        this.update();
        this.render();
        this.sleepLoop();
    }

    this.update = () => {
        if (this.onUpdate) this.onUpdate(this);
    }

    // Render the screen contents to the canvas.
    this.render = () => {
        if (this.dev.input.accessed || this.dev.screen.accessed) {
            e.showScreenPanel();
        }
        let scr = this.dev.screen;
        if (scr.dirty()) {
            scr.render();
            let image = new ImageData(scr.pixels, scr.width, scr.height);
            scr.ctx.putImageData(image, 0, 0, scr.dx0, scr.dy0, scr.dx1, scr.dy1);
            scr.unmark();
        }
    }

    this.runLoop = () => {
        if (!this.halted && !this.paused) {
            if (this.asleep) {
                setTimeout(this.sleepLoop.bind(this));
            } else {
                // Tail-recursive with timeout to allow other code to run.
                switch (this.evaluate(100000)) {
                    case 5: this.halt();   return; // HALT
                    case 4: this.reset();   break; // RESET
                    case 3: this.reset();   break; // FORK
                    case 2: this.sleep();  return; // SLEEP
                    case 1: this.pause();   break; // DEBUG
                    default:                       // NORMAL
                }
                this.update();
                setTimeout(this.runLoop.bind(this), 0);
            }
        }
    }

    this.sleepLoop = () => {
        if (!this.halted) {
            if (!this.asleep) {
                setTimeout(this.runLoop.bind(this), 0);
            } else {
                let queue = this.dev.queue.get(this.dev.system.wakeMask);
                for (let slot of queue) {
                    if (this.dev.devices[slot].wake()) {
                        this.asleep = false;
                        this.dev.system.wakeSlot = slot;
                        setTimeout(this.runLoop.bind(this));
                        return;
                    }
                }
                setTimeout(this.sleepLoop.bind(this), 0);
            }
        }
    }

    // Evaluate at most n processor cycles, returning a signal value.
    this.evaluate = (n) => {
        for (let i=0; i<n; i++) {
            this.cycle += 1;
            let instr = this.mem[this.p++];
            let rMode = instr & 0x80;
            let wMode = instr & 0x40;
            let iMode = instr & 0x20;
            let w = rMode ? this.rst : this.wst;
            let r = rMode ? this.wst : this.rst;

            // Memory access functions.
            let mpop1 = ( )   => { return this.mem[this.p++]; }
            let mpop2 = ( )   => { return mpop1() << 8 | mpop1(); }
            let mpopx = ( )   => { return wMode ? mpop2() : mpop1(); }
            let mpsh1 = (v)   => { this.mem[this.p++] = v; }
            let mpsh2 = (v)   => { this.mpsh1(v >> 8); this.mpsh1(v); }
            let mpshx = (v)   => { wMode ? mpsh2(v) : mpsh1(v); }
            let mget1 = (a)   => { return this.mem[a]; }
            let mget2 = (a)   => { return mget1(a) << 8 | mget1(a+1); }
            let mgetx = (a)   => { return wMode ? mget2(a) : mget1(a); }
            let mset1 = (a,v) => { this.mem[a] = v; }
            let mset2 = (a,v) => { mset1(a, v >> 8); mset1(a+1, v); }
            let msetx = (a,v) => { wMode ? mset2(a,v) : mset1(a,v); }
            // Device access functions.
            let dget1 = (p)   => { return this.dev.read(p); }
            let dget2 = (p)   => { return dget1(p) << 8 | dget1(p+1); }
            let dgetx = (p)   => { return wMode ? dget2(p) : dget1(p); }
            let dset1 = (p,v) => { return this.dev.write(p,v); }
            let dset2 = (p,v) => { let s1 = dset1(p, v >> 8); let s2 = dset1(p+1, v & 0xFF); return s1 || s2; }
            let dsetx = (p,v) => { if (wMode) { return dset2(p,v) } else { return dset1(p,v) } }
            // Stack access functions.
            let wpop1 = ( )   => { return iMode ? (iMode=0, mpop1()) : w.pop1(); }
            let wpop2 = ( )   => { return iMode ? (iMode=0, mpop2()) : w.pop2(); }
            let wpopx = ( )   => { return wMode ? wpop2() : wpop1(); }
            let rpop1 = ( )   => { return iMode ? (iMode=0, mpop1()) : r.pop1(); }
            let rpop2 = ( )   => { return iMode ? (iMode=0, mpop2()) : r.pop2(); }
            let rpopx = ( )   => { return wMode ? rpop2() : rpop1(); }
            let wpsh1 = (v)   => { w.psh1(v); }
            let wpsh2 = (v)   => { w.psh2(v); }
            let wpshx = (v)   => { wMode ? w.psh2(v) : w.psh1(v); }
            let rpsh1 = (v)   => { r.psh1(v); }
            let rpsh2 = (v)   => { r.psh2(v); }
            let rpshx = (v)   => { wMode ? r.psh2(v) : r.psh1(v); }
            // Shifting operations.
            let shl1 = (v,d) => { return d <  8 ? v << d & 0xFF   : 0; }
            let shl2 = (v,d) => { return d < 16 ? v << d & 0xFFFF : 0; }
            let shlx = (v,d) => { return wMode ? shl2(v,d) : shl1(v,d); }
            let shr1 = (v,d) => { return d <  8 ? v >> d & 0xFF   : 0; }
            let shr2 = (v,d) => { return d < 16 ? v >> d & 0xFFFF : 0; }
            let shrx = (v,d) => { return wMode ? shr2(v,d) : shr1(v,d); }
            let rol1 = (v,d) => { d %=  8; return shl1(v, d) | shr1(v,  8-d); }
            let rol2 = (v,d) => { d %= 16; return shl2(v, d) | shr2(v, 16-d); }
            let rolx = (v,d) => { return wMode ? rol2(v,d) : rol1(v,d); }
            let ror1 = (v,d) => { d %=  8; return shr1(v, d) | shl1(v,  8-d); }
            let ror2 = (v,d) => { d %= 16; return shr2(v, d) | shl2(v, 16-d); }
            let rorx = (v,d) => { return wMode ? ror2(v,d) : ror1(v,d); }

            let a, p, s, t, v, x, y, z;
            switch (instr & 0x1F) {
            /* HLT */ case 0x00: switch(instr) { case 0x00: return 5; case 0x40: return 1; default: } break;
            /* PSH */ case 0x01: x=rpopx(); wpshx(x);                                                 break;
            /* POP */ case 0x02:   wpopx();                                                           break;
            /* CPY */ case 0x03: x=rpopx(); rpshx(x); wpshx(x);                                       break;
            /* DUP */ case 0x04: x=wpopx(); wpshx(x); wpshx(x);                                       break;
            /* OVR */ case 0x05: y=wpopx(); x=wpopx();            wpshx(x); wpshx(y); wpshx(x);       break;
            /* SWP */ case 0x06: y=wpopx(); x=wpopx();            wpshx(y); wpshx(x);                 break;
            /* ROT */ case 0x07: z=wpopx(); y=wpopx(); x=wpopx(); wpshx(y); wpshx(z); wpshx(x);       break;
            /* JMP */ case 0x08: a=wpop2();                                    this.p = a;            break;
            /* JMS */ case 0x09: a=wpop2();                     rpsh2(this.p); this.p = a;            break;
            /* JCN */ case 0x0A: a=wpop2(); t=wpop1(); if (t) {                this.p = a; }          break;
            /* JCS */ case 0x0B: a=wpop2(); t=wpop1(); if (t) { rpsh2(this.p); this.p = a; }          break;
            /* LDA */ case 0x0C: a=wpop2(); v=mgetx(a); wpshx(v);                                     break;
            /* STA */ case 0x0D: a=wpop2(); v=wpopx(); msetx(a,v);                                    break;
            /* LDD */ case 0x0E: p=wpop1(); v=dgetx(p); wpshx(v);                                     break;
            /* STD */ case 0x0F: p=wpop1(); v=wpopx(); s=dsetx(p,v); if (s) { return s; }             break;
            /* ADD */ case 0x10: y=wpopx(); x=wpopx(); wpshx(x+y);                                    break;
            /* SUB */ case 0x11: y=wpopx(); x=wpopx(); wpshx(x-y);                                    break;
            /* INC */ case 0x12:            x=wpopx(); wpshx(x+1);                                    break;
            /* DEC */ case 0x13:            x=wpopx(); wpshx(x-1);                                    break;
            /* LTH */ case 0x14: y=wpopx(); x=wpopx();                     wpsh1(0-(x <y));           break;
            /* GTH */ case 0x15: y=wpopx(); x=wpopx();                     wpsh1(0-(x >y));           break;
            /* EQU */ case 0x16: y=wpopx(); x=wpopx();                     wpsh1(0-(x==y));           break;
            /* NQK */ case 0x17: y=wpopx(); x=wpopx(); wpshx(x); wpshx(y); wpsh1(0-(x!=y));           break;
            /* SHL */ case 0x18: y=wpop1(); x=wpopx(); wpshx(shlx(x,y));                              break;
            /* SHR */ case 0x19: y=wpop1(); x=wpopx(); wpshx(shrx(x,y));                              break;
            /* ROL */ case 0x1A: y=wpop1(); x=wpopx(); wpshx(rolx(x,y));                              break;
            /* ROR */ case 0x1B: y=wpop1(); x=wpopx(); wpshx(rorx(x,y));                              break;
            /* IOR */ case 0x1C: y=wpopx(); x=wpopx(); wpshx(x|y);                                    break;
            /* XOR */ case 0x1D: y=wpopx(); x=wpopx(); wpshx(x^y);                                    break;
            /* AND */ case 0x1E: y=wpopx(); x=wpopx(); wpshx(x&y);                                    break;
            /* NOT */ case 0x1F:            x=wpopx(); wpshx(~x );                                    break;
            }
        }
    };
}


// Stack for the core system.
function Stack() {
    this.mem = new Uint8Array(256);
    this.p = 0;

    this.reset = ( ) => { this.mem.fill(0); this.p = 0; }
    this.psh1  = (v) => { this.mem[this.p++] = v; }
    this.psh2  = (v) => { this.psh1(v >> 8); this.psh1(v); }
    this.pop1  = ( ) => { return this.mem[--this.p]; }
    this.pop2  = ( ) => { return this.pop1() | this.pop1() << 8; }
}


// Device bus for the core system.
function DeviceBus(br) {
    this.system    = new SystemDevice(br);
    this.memory    = new MemoryDevice(br);
    this.math      = new MathDevice(br);
    this.clock     = new ClockDevice(br);
    this.input     = new InputDevice(br);
    this.screen    = new ScreenDevice(br);
    this.tone      = new NullDevice();
    this.sampler   = new NullDevice();
    this.stream    = new StreamDevice(br);
    this.file      = new NullDevice();
    this.clipboard = new ClipboardDevice(br);
    this.registry  = new NullDevice();
    this.custom1   = new NullDevice();
    this.custom2   = new NullDevice();
    this.custom3   = new NullDevice();
    this.custom4   = new NullDevice();

    this.devices = [
        this.system,   this.memory,   this.math,       this.clock,
        this.input,    this.screen,   this.tone,       this.sampler,
        this.stream,   this.file,     this.clipboard,  this.registry,
        this.custom1,  this.custom2,  this.custom3,    this.custom4,
    ];
    for (let device of this.devices) {
        if (device.init) device.init();
    }

    this.queue = new WakeQueue();

    this.reset = function() {
        for (let d of this.devices) d.reset(); }
    this.read = function(p) {
        return this.devices[p >> 4].read(p & 0x0F); }
    this.write = function(p,v) {
        return this.devices[p >> 4].write(p & 0x0F, v); }
}


function WakeQueue() {
    this.queue = [0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF];

    // Return the queue after applying a wake mask.
    this.get = function(wakeMask) {
        let masked = [];
        for (let slot of this.queue)
            if (wakeMask & 0x8000 >> slot)
                masked.push(slot);
        // Add slot zero last.
        if (wakeMask & 0x8000) masked.push(0);
        return masked;
    }
    // Move slot to the back of the queue.
    this.wake = function(slot) {
        let i = this.queue.indexOf(slot);
        if (i > -1) this.queue.splice(i, 1);
        this.queue.push(slot);
    }
}


// Disconnected device.
function NullDevice() {
    this.reset = function()    {               }
    this.read  = function(p)   { return 0;     }
    this.write = function(p,v) { return;       }
    this.wake  = function()    { return false; }
}


function SystemDevice(br) {
    this.reset = function() {
        this.wakeMask = 0;
        this.wakeSlot = 0;
        this.nameBuffer = new TextBuffer(`${systemName}/${systemVersion}`);
        this.authorsBuffer = new TextBuffer(systemAuthors);
    }
    this.read = function(p) {
        switch (p) {
            case 0x2:  return this.wakeSlot;
            case 0x8:  return this.nameBuffer.read();
            case 0x9:  return this.authorsBuffer.read();
            case 0xE:  return 0b1111_1100;
            case 0xF:  return 0b1010_0000;
            default:   return 0x00;
        }
    }
    this.write = function(p,v) {
        switch (p) {
            case 0x0:  this.wakeMask = setH(this.wakeMask, v);  break;
            case 0x1:  this.wakeMask = setL(this.wakeMask, v);  return 2;
            case 0x3:  let s = v ? 3 : 4;                       return s;
            case 0x8:  this.nameBuffer.reset();                 break;
            case 0x9:  this.authorsBuffer.reset();              break;
            default:                                            return;
        }
    }
    this.wake = function() {
        return true;
    }
}


function MemoryDevice(br) {
    this.reset = function() {
        this.mem = new Uint8Array();
        this.count = 0;
        this.countW = 0;
        this.copyW = 0;
        this.page1 = 0;
        this.addr1 = 0;
        this.page2 = 0;
        this.addr2 = 0;
    }
    this.read = function(p) {
        switch (p) {
            case 0x0: return getH(this.count);
            case 0x1: return getL(this.count);
            case 0x2: return getH(this.page1);
            case 0x3: return getL(this.page1);
            case 0x4: return getH(this.addr1);
            case 0x5: return getL(this.addr1);
            case 0x6:
            case 0x7: return this.read1();
            case 0xA: return getH(this.page2);
            case 0xB: return getL(this.page2);
            case 0xC: return getH(this.addr2);
            case 0xD: return getL(this.addr2);
            case 0xE:
            case 0xF: return this.read2();
            default:  return 0x00;
        }
    }
    this.write = function(p,v) {
        switch (p) {
            case 0x0: this.countW = setH(this.countW, v);                  return;
            case 0x1: this.countW = setL(this.countW, v); this.allocate(); return;
            case 0x2: this.page1 = setH(this.page1, v);                    return;
            case 0x3: this.page1 = setL(this.page1, v);                    return;
            case 0x4: this.addr1 = setH(this.addr1, v);                    return;
            case 0x5: this.addr1 = setL(this.addr1, v);                    return;
            case 0x6:
            case 0x7: this.write1(v);                                      return;
            case 0x8: this.copyW = setH(this.copyW, v);                    return;
            case 0x9: this.copyW = setL(this.copyW, v); this.copy();       return;
            case 0xA: this.page2 = setH(this.page2, v);                    return;
            case 0xB: this.page2 = setL(this.page2, v);                    return;
            case 0xC: this.addr2 = setH(this.addr2, v);                    return;
            case 0xD: this.addr2 = setL(this.addr2, v);                    return;
            case 0xE:
            case 0xF: this.write2(v);                                      return;
            default:                                                       return;
        }
    }
    this.wake = function() {
        return false;
    }

    // Update number of allocated pages to equal count.
    this.allocate = function() {
        // Allocate memory.
        if (this.countW > this.count) {
            let old = this.mem;
            this.mem = new Uint8Array(this.countW * 256);
            this.mem.set(old);
        // Deallocate memory.
        } else if (this.countW < this.count) {
            this.mem = this.mem.slice(0, this.countW);
        }
        this.count = this.countW;
    }
    // Read a byte from head 1.
    this.read1 = function() {
        let i = (this.page1 * 256) + this.addr1;
        this.addr1 = (this.addr1 + 1) & 0xFFFF;
        return this.mem.length > i ? this.mem[i] : 0;
    }
    // Read a byte from head 2.
    this.read2 = function() {
        let i = (this.page2 * 256) + this.addr2;
        this.addr2 = (this.addr2 + 1) & 0xFFFF;
        return this.mem.length > i ? this.mem[i] : 0;
    }
    // Write a byte to head 1.
    this.write1 = function(v) {
        let i = (this.page1 * 256) + this.addr1;
        this.addr1 = (this.addr1 + 1) & 0xFFFF;
        if (this.mem.length > i) this.mem[i] = v;
    }
    // Write a byte to head 2.
    this.write2 = function(v) {
        let i = (this.page2 * 256) + this.addr2;
        this.addr2 = (this.addr2 + 1) & 0xFFFF;
        if (this.mem.length > i) this.mem[i] = v;
    }
    // Copy pages from head 2 to head 1.
    this.copy = function() {
        let src = this.page2;
        let dst = this.page1;
        let remaining = this.copyW
        while (remaining && this.count > src && this.count > dst) {
            let index = dst++ * 256;
            let start = src++ * 256;
            let end = start + 256;
            this.mem.copyWithin(index, start, end);
        }
    }
}


function MathDevice() {
    this.reset = function() {
        this.x = 0;
        this.y = 0;
        this.r = 0;
        this.t = 0;
    }
    this.read = function(p) {
        switch (p) {
            case 0x0: return getH(this.px());
            case 0x1: return getL(this.px());
            case 0x2: return getH(this.py());
            case 0x3: return getL(this.py());
            case 0x4: return getH(this.cr());
            case 0x5: return getL(this.cr());
            case 0x6: return getH(this.ct());
            case 0x7: return getL(this.ct());
            case 0x8: return getHH(this.prod());
            case 0x9: return getHL(this.prod());
            case 0xA: return getH(this.prod());
            case 0xB: return getL(this.prod());
            case 0xC: return getH(this.quot());
            case 0xD: return getL(this.quot());
            case 0xE: return getH(this.rem());
            case 0xF: return getL(this.rem());
            default:  return 0x00;
        }
    }
    this.write = function(p,v) {
        switch (p) {
            case 0x0: this.x = setH(this.x, v); return;
            case 0x1: this.x = setL(this.x, v); return;
            case 0x2: this.y = setH(this.y, v); return;
            case 0x3: this.y = setL(this.y, v); return;
            case 0x4: this.r = setH(this.r, v); return;
            case 0x5: this.r = setL(this.r, v); return;
            case 0x6: this.t = setH(this.t, v); return;
            case 0x7: this.t = setL(this.t, v); return;
            default:                            return;
        }
    }
    this.wake = function() {
        return false;
    }

    // Return x coordinate of polar point.
    this.px = function() {
        let x = Math.trunc(Math.cos((2 * Math.PI * this.t) / 65536) * this.r);
        return x <= 32767 && x >= -32768 ? x : 0; };
    // Return y coordinate of polar point.
    this.py = function() {
        let y = Math.trunc(Math.sin((2 * Math.PI * this.t) / 65536) * this.r);
        return y <= 32767 && y >= -32768 ? y : 0; };
    // Return r coordinate of cartesian point.
    this.cr = function() {
        return Math.trunc(Math.sqrt(Math.pow(signed(this.x), 2) + Math.pow(signed(this.y), 2))); };
    // Return t coordinate of cartesian point.
    this.ct = function() {
        return Math.trunc(Math.atan2(signed(this.y), signed(this.x)) * 65536 / (2 * Math.PI)); };
    // Return product of x and y operands.
    this.prod = function() {
        return this.x * this.y; };
    this.quot = function() {
        return this.y ? this.x / this.y : 0; };
    this.rem  = function() {
        return this.y ? this.x % this.y : 0; };
}


function ClockDevice(br) {
    this.reset = function() {
        this.start = performance.now();
        this.uptime = 0;
        this.t1 = new CountdownTimer();
        this.t2 = new CountdownTimer();
        this.t3 = new CountdownTimer();
        this.t4 = new CountdownTimer();
    }
    this.read = function(p) {
        switch (p) {
            case 0x0:                      return new Date().getFullYear()-2000;
            case 0x1:                      return new Date().getMonth();
            case 0x2:                      return new Date().getDate()-1;
            case 0x3:                      return new Date().getHours();
            case 0x4:                      return new Date().getMinutes();
            case 0x5:                      return new Date().getSeconds();
            case 0x6: this.updateUptime(); return getH(this.uptime);
            case 0x7:                      return getL(this.uptime);
            case 0x8: this.t1.update();    return getH(this.t1.read);
            case 0x9:                      return getL(this.t1.read);
            case 0xA: this.t2.update();    return getH(this.t2.read);
            case 0xB:                      return getL(this.t2.read);
            case 0xC: this.t3.update();    return getH(this.t3.read);
            case 0xD:                      return getL(this.t3.read);
            case 0xE: this.t4.update();    return getH(this.t4.read);
            case 0xF:                      return getL(this.t4.read);
            default:  return 0x00;
        }
    }
    this.write = function(p,v) {
        switch (p) {
            case 0x8: this.t1.write = setH(this.t1.write, v);                   return;
            case 0x9: this.t1.write = setL(this.t1.write, v); this.t1.commit(); return;
            case 0xA: this.t2.write = setH(this.t2.write, v);                   return;
            case 0xB: this.t2.write = setL(this.t2.write, v); this.t2.commit(); return;
            case 0xC: this.t3.write = setH(this.t3.write, v);                   return;
            case 0xD: this.t3.write = setL(this.t3.write, v); this.t3.commit(); return;
            case 0xE: this.t4.write = setH(this.t4.write, v);                   return;
            case 0xF: this.t4.write = setL(this.t4.write, v); this.t4.commit(); return;
            default:                                                            return;
        }
    }
    this.wake = function() {
        let t1 = this.t1.wake();
        let t2 = this.t2.wake();
        let t3 = this.t3.wake();
        let t4 = this.t4.wake();
        return t1 || t2 || t3 || t4;
    }

    this.updateUptime = function() {
        let delta = performance.now() - this.start;
        this.uptime = delta * 0.256 & 0xFFFF;
    }
}


function InputDevice(br) {
    this.reset = function() {
        this.x = 0;
        this.y = 0;
        this.xR = 0;
        this.yR = 0;
        this.hScroll = 0;
        this.vScroll = 0;
        this.hScrollR = 0;
        this.vScrollR = 0;
        this.pointerButtons = 0;
        this.pointerActive = false;
        // Navigation state
        this.navigation = 0;
        this.navUp = false;
        this.navDown = false;
        this.navLeft = false;
        this.navRight = false;
        this.navConfirm = false;
        this.navCancel = false;
        this.navTab = false;
        this.navShift = false;
        //
        this.modifiers = 0;
        this.characterBytes = new ByteQueue(1024);
        // Flags
        this.wakeFlag = false;
        this.accessed = false;
    }
    this.read = function(p) {
        this.accessed = true;
        switch (p) {
            case 0x0: this.xR = this.x;     return getH(this.xR);
            case 0x1:                       return getL(this.xR);
            case 0x2: this.yR = this.y;     return getH(this.yR);
            case 0x3:                       return getL(this.yR);
            case 0x4: this.updateHScroll(); return getH(this.hScrollR);
            case 0x5:                       return getL(this.hScrollR);
            case 0x6: this.updateVScroll(); return getH(this.vScrollR);
            case 0x7:                       return getL(this.vScrollR);
            case 0x8:                       return bool(this.pointerActive);
            case 0x9:                       return this.pointerButtons;
            case 0xA:                       return this.characterBytes.pop();
            case 0xB:                       return this.modifiers;
            case 0xC:                       return this.navigation;
            default:                        return 0x00;
        }
    }
    this.write = function(p,v) {
        this.accessed = true;
        switch (p) {
            case 0xA: this.characterBytes = []; return;
            default:                            return;
        }
    }
    this.wake = function() {
        let wake = this.wakeFlag; this.wakeFlag = false;
        return wake;
    }

    this.updateHScroll = function() {
        let delta = Math.trunc(this.hScroll);
        this.hScroll -= delta;
        this.hScrollR = delta;
    }
    this.updateVScroll = function() {
        let delta = Math.trunc(this.vScroll);
        this.vScroll -= delta;
        this.vScrollR = delta;
    }
    this.applyPosition = function(x, y) {
        let wake = x != this.x || y != this.y;
        this.x = x; this.y = y;
        if (wake) this.wakeFlag = true;
    }
    this.applyButtons = function(jsButtons) {
        let pointerButtons = 0;
        pointerButtons |= jsButtons & 0x01 ? 0x80 : 0x00;
        pointerButtons |= jsButtons & 0x02 ? 0x40 : 0x00;
        pointerButtons |= jsButtons & 0x04 ? 0x20 : 0x00;
        let wake = pointerButtons != this.pointerButtons;
        this.pointerButtons = pointerButtons;
        if (wake) this.wakeFlag = true;
    }
    this.applyActive = function(active) {
        let wake = active != this.pointerActive;
        this.pointerActive = active;
        if (wake) this.wakeFlag = true;
    }
    this.applyKey = function(event, pressed) {
        // Handle navigation keys.
        switch (event.key) {
            case "ArrowUp":    this.navUp      = pressed; break;
            case "ArrowDown":  this.navDown    = pressed; break;
            case "ArrowLeft":  this.navLeft    = pressed; break;
            case "ArrowRight": this.navRight   = pressed; break;
            case "Enter":      this.navConfirm = pressed; break;
            case "Escape":     this.navCancel  = pressed; break;
            case "Tab":        this.navTab     = pressed; break;
            case "Shift":      this.navShift   = pressed; break;
        }
        let navigation = 0;
        navigation |= this.navUp                    ? 0x80 : 0x00;
        navigation |= this.navDown                  ? 0x40 : 0x00;
        navigation |= this.navLeft                  ? 0x20 : 0x00;
        navigation |= this.navRight                 ? 0x10 : 0x00;
        navigation |= this.navConfirm               ? 0x08 : 0x00;
        navigation |= this.navCancel                ? 0x04 : 0x00;
        navigation |= this.navTab && !this.navShift ? 0x02 : 0x00;
        navigation |= this.navTab &&  this.navShift ? 0x01 : 0x00;
        if (navigation != this.navigation) {
            this.wakeFlag = true;
            this.navigation = navigation;
        }
        // Handle character input.
        if (pressed) {
            if (event.key.length == 1) {
                let byteList = encodeUtf8(event.key);
                this.characterBytes.pushList(byteList);
                this.wakeFlag = true;
            } else {
                switch (event.key) {
                    case "Backspace": this.characterBytes.push(0x08); break;
                    case "Tab":       this.characterBytes.push(0x09); break;
                    case "Enter":     this.characterBytes.push(0x0A); break;
                    case "Spacebar":  this.characterBytes.push(0x20); break;
                    default:                                     return;
                }
                this.wakeFlag = true;
            }
        }
    }
    this.applyModifiers = function(event) {
        let modifiers = 0;
        modifiers |= event.ctrlKey  ? 0x80 : 0x00;
        modifiers |= event.shiftKey ? 0x40 : 0x00;
        modifiers |= event.altKey   ? 0x20 : 0x00;
        modifiers |= event.metaKey ? 0x10 : 0x00;
        let wake = modifiers != this.modifiers;
        this.modifiers = modifiers;
        if (wake) this.wakeFlag = true;
    }
    this.applyHScroll = function(delta) {
        if (delta) {
            this.wakeFlag = true;
            this.hScroll += delta;
            this.hScroll = clamp(this.hScroll, -32768, 32767);
        }
    }
    this.applyVScroll = function(delta) {
        if (delta) {
            this.wakeFlag = true;
            this.vScroll += delta;
            this.vScroll = clamp(this.vScroll, -32768, 32767);
        }
    }
}


function ScreenDevice(br) {
    this.init = function() {
        this.ctx = br.e.canvas.getContext("2d", {
            alpha: false,
            willReadFrequently: false,
        });
    }
    this.reset = function() {
        this.x = 0;
        this.y = 0;
        this.px = 0;  // previous x
        this.py = 0;  // previous y
        this.widthW = 0;
        this.heightW = 0;
        this.palette = [
            [0x00,0x00,0x00],[0xFF,0xFF,0xFF],[0x55,0x55,0x55],[0xAA,0xAA,0xAA],
            [0x00,0x00,0x00],[0xFF,0xFF,0xFF],[0x55,0x55,0x55],[0xAA,0xAA,0xAA],
            [0x00,0x00,0x00],[0xFF,0xFF,0xFF],[0x55,0x55,0x55],[0xAA,0xAA,0xAA],
            [0x00,0x00,0x00],[0xFF,0xFF,0xFF],[0x55,0x55,0x55],[0xAA,0xAA,0xAA],
        ];
        this.paletteW = 0;
        this.selection = [0, 0, 0, 0];
        this.sprite = new SpriteBuffer();
        let initialWidth = Math.trunc(br.e.clientWidth / initialScreenScale);
        let initialHeight = Math.trunc(initialWidth * 9/16);
        this.width = -1;  // screen won't resize if dimensions aren't different
        this.resize(initialWidth, initialHeight, initialScreenScale);
        this.wakeFlag = false;
        this.accessed = false;
    }
    this.read = function(p) {
        this.accessed = true;
        switch (p) {
            case 0x0: return getH(this.x);
            case 0x1: return getL(this.x);
            case 0x2: return getH(this.y);
            case 0x3: return getL(this.y);
            case 0x4: return getH(this.width);
            case 0x5: return getL(this.width);
            case 0x6: return getH(this.height);
            case 0x7: return getL(this.height);
            default:   return 0x00;
        }
    }
    this.write = function(p,v) {
        this.accessed = true;
        switch (p) {
            case 0x0: this.x = setH(this.x, v);                                     return;
            case 0x1: this.x = setL(this.x, v);                                     return;
            case 0x2: this.y = setH(this.y, v);                                     return;
            case 0x3: this.y = setL(this.y, v);                                     return;
            case 0x4: this.widthW  = setH(this.widthW,  v);                         return;
            case 0x5: this.widthW  = setL(this.widthW,  v); this.commitWidth();     return;
            case 0x6: this.heightW = setH(this.heightW, v);                         return;
            case 0x7: this.heightW = setL(this.heightW, v); this.commitHeight();    return;
            case 0x8: this.paletteW = setH(this.paletteW, v);                       return;
            case 0x9: this.paletteW = setL(this.paletteW, v); this.commitPalette(); return;
            case 0xA: this.selection[0] = v >> 4; this.selection[1] = v & 0xF;      return;
            case 0xB: this.selection[2] = v >> 4; this.selection[3] = v & 0xF;      return;
            case 0xC:
            case 0xD: this.sprite.push(v);                                          return;
            case 0xE: this.draw(v);                                                 return;
            case 0xF: this.move(v);                                                 return;
            default:                                                                return;
        }
    }
    this.wake = function() {
        let wake = this.wakeFlag; this.wakeFlag = false;
        return wake;
    }

    // Mark a region as dirty, with 0 inclusive and 1 exclusive.
    this.mark = function(x0, y0, x1, y1) {
        if(x0 < this.dx0) this.dx0 = x0;
        if(y0 < this.dy0) this.dy0 = y0;
        if(x1 > this.dx1) this.dx1 = x1;
        if(y1 > this.dy1) this.dy1 = y1;
    }
    // Unmark the dirty region.
    this.unmark = function() {
        this.dx0 =  32767;
        this.dy0 =  32767;
        this.dx1 = -32768;
        this.dy1 = -32768;
    }
    // Check if the screen has a visible dirty region.
    this.dirty = function() {
        // TODO: Does clamp pull a distant dirty region into the viewport?
        this.dx0 = clamp(this.dx0, 0, this.width);
        this.dx1 = clamp(this.dx1, 0, this.width);
        this.dy0 = clamp(this.dy0, 0, this.height);
        this.dy1 = clamp(this.dy1, 0, this.height);
        return this.dx1 > this.dx0 && this.dy1 > this.dy0;
    }
    // Update the dirty region of this.pixels from fg and bg.
    this.render = function() {
        let dw = this.dx1 - this.dx0;
        for (let y=this.dy0; y<this.dy1; y++) {
            let i0 = y * this.width + this.dx0;
            let i1 = i0 + dw;
            let j = i0 * 4;
            for (let i=i0; i<i1; i++) {
                let index = this.fg[i] || this.bg[i];
                let [r, g, b] = this.palette[index];
                this.pixels[j++] = r;
                this.pixels[j++] = g;
                this.pixels[j++] = b;
                this.pixels[j++] = 0xFF;
            }
        }
    }
    // Resize to fill a container, dimensions given in real pixels.
    this.resizeToFill = function(width, height) {
        width = width / this.scale;
        height = height / this.scale;
        if (this.resize(width, height)) {
            this.wakeFlag = true;
            // TODO: Preserve current canvas contents when resizing.
            let [r, g, b] = this.palette[0];
            this.ctx.fillStyle = '#'+hex(r,2)+hex(g,2)+hex(b,2);
            this.ctx.fillRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
        };
    }
    // Resize to an absolute size.
    this.resize = function(width, height, scale) {
        width = Math.trunc(width);
        height = Math.trunc(height);
        if (width != this.width || height != this.height) {
            if (width != undefined) this.width = width;
            if (height != undefined) this.height = height;
            if (scale != undefined) this.scale = scale;
            this.fg = new Uint8Array(this.width * this.height);
            this.bg = new Uint8Array(this.width * this.height);
            this.pixels = new Uint8ClampedArray(this.width * this.height * 4);
            this.ctx.canvas.width = this.width;
            this.ctx.canvas.height = this.height;
            this.ctx.canvas.style.width = (this.width * this.scale) + 'px';
            this.ctx.canvas.style.height = (this.height * this.scale) + 'px';
            this.mark(0, 0, this.width, this.height);
            return true;
        } else {
            return false;
        }
    }
    this.commitWidth = function() {
        console.log("Resizing the canvas has not yet been implemented.")
        // this.width = this.widthW;
        // this.resize(this.width, this.height);
    }
    this.commitHeight = function() {
        console.log("Resizing the canvas has not yet been implemented.")
        // this.height = this.heightW;
        // this.resize(this.width, this.height);
    }
    this.commitPalette = function() {
        let r = (this.paletteW >> 8 & 0x0F) * 17;
        let g = (this.paletteW >> 4 & 0x0F) * 17;
        let b = (this.paletteW      & 0x0F) * 17;
        this.palette[this.paletteW>>12] = [r,g,b];
        this.mark(0, 0, this.width, this.height);
    }
    this.draw = function(v) {
        let layer = v & 0x80 ? this.fg : this.bg;
        let lower = v & 0x0F;
        switch (v >> 4 & 0x07) {
            case 0: this.drawPixel(layer, this.x, this.y, lower); break;
            case 1: this.draw1BitSprite(layer, lower);            break;
            case 2: this.fillLayer(layer, lower);                 break;
            case 3: this.draw2BitSprite(layer, lower);            break;
            case 4: this.drawSolidLine(layer, lower);             break;
            case 5: this.drawTexturedLine(layer, lower);          break;
            case 6: this.drawSolidRect(layer, lower);             break;
            case 7: this.drawTexturedRect(layer, lower);          break;
        }
        this.px = this.x;
        this.py = this.y;
    }
    this.move = function(v) {
        let dist = v & 0x3F;
        switch (v & 0xC0) {
            case 0x00: this.x += dist; this.x &= 0xFFFF; return;
            case 0x40: this.y += dist; this.y &= 0xFFFF; return;
            case 0x80: this.x -= dist; this.x &= 0xFFFF; return;
            case 0xC0: this.y -= dist; this.y &= 0xFFFF; return;
        }
    }

    this.drawPixel = function(layer, x, y, colour) {
        x = x & 0xFFFF; y = y & 0xFFFF;
        if (x < this.width && y < this.height) {
            layer[x + (y * this.width)] = colour;
            this.mark(x, y, x+1, y+1);
        }
    }
    this.fillLayer = function(layer, colour) {
        layer.fill(colour);
        this.mark(0, 0, this.width, this.height);
    }
    this.draw1BitSprite = function(layer, transform) {
        let sprite = this.sprite.get1Bit(transform);
        this.drawSprite(layer, sprite, transform);
    }
    this.draw2BitSprite = function(layer, transform) {
        let sprite = this.sprite.get2Bit(transform);
        this.drawSprite(layer, sprite, transform);
    }
    this.drawSprite = function(layer, sprite, transform) {
        let opaque = !(transform & 0x8);
        for (let y=0; y<8; y++) {
            for (let x=0; x<8; x++) {
                let index = sprite[y*8+x];
                if (opaque || index) {
                    let colour = this.selection[index];
                    this.drawPixel(layer, this.x+x, this.y+y, colour)
                };
            }
        }
    }
    this.drawSolidLine = function(layer, colour) {
        this.drawLine((x, y) => this.drawPixel(layer, x, y, colour));
    }
    this.drawSolidRect = function(layer, colour) {
        this.drawRect((x, y) => this.drawPixel(layer, x, y, colour));
    }
    this.drawTexturedLine = function(layer, transform) {
        let sprite = this.sprite.get1Bit(transform);
        let opaque = !(transform & 0x8);
        this.drawLine((x, y) => {
            let index = sprite[(y%8)*8+(x%8)];
            if (opaque || index) {
                let colour = this.selection[index];
                this.drawPixel(layer, x, y, colour);
            }
        })
    }
    this.drawTexturedRect = function(layer, transform) {
        let sprite = this.sprite.get1Bit(transform);
        let opaque = !(transform & 0x8);
        this.drawRect((x, y) => {
            let index = sprite[(y%8)*8+(x%8)];
            if (opaque || index) {
                let colour = this.selection[index];
                this.drawPixel(layer, x, y, colour);
            }
        })
    }
    this.drawLine = function(drawFn) {
        let xEnd = signed(this.x);
        let yEnd = signed(this.y);
        let x    = signed(this.px);
        let y    = signed(this.py);
        let dx   =  Math.abs(xEnd - x);
        let dy   = -Math.abs(yEnd - y);
        let sx   = x < xEnd ? 1 : -1;
        let sy   = y < yEnd ? 1 : -1;
        let e1   = dx + dy;
        while (true) {
            drawFn(x, y);
            if (x == xEnd && y == yEnd) break;
            let e2 = e1 << 1;
            if (e2 >= dy) { e1 += dy; x += sx; }
            if (e2 <= dx) { e1 += dx; y += sy; }
        }
    }
    this.drawRect = function(drawFn) {
        let x = signed(this.x); let px = signed(this.px);
        let y = signed(this.y); let py = signed(this.py);
        let x0 = Math.min(x, px); let x1 = Math.max(x, px);
        let y0 = Math.min(y, py); let y1 = Math.max(y, py);
        if (x1 >= 0 && y1 >= 0 && x0 < this.width && y0 < this.height) {
            for (let y=y0; y<=y1; y++) {
                for (let x=x0; x<=x1; x++) {
                    drawFn(x, y);
                }
            }
        }
    }
}


function StreamDevice(br) {
    this.reset = function() {
    }
    this.read = function(p) {
        switch (p) {
            case 0x1:  return 0xFF;
            case 0x3:  return 0xFF;
            case 0x5:  return 0xFF;
            default:   return 0x00;
        }
    }
    this.write = function(p,v) {
        switch (p) {
            case 0x3: br.e.endTransmission();              break;
            case 0x6:
            case 0x7: br.e.receiveTransmissionByte(v);     break;
            default:                                      return;
        }
    }
}


function ClipboardDevice(br) {
    this.reset = function() {
        this.readQueue = [];   // reverse order
        this.writeQueue = [];  // normal order
    }
    this.read = function(p) {
        switch (p) {
            case 0x4: return clamp(this.readQueue.length,  0, 0xFF);
            case 0x5: return clamp(this.writeQueue.length, 0, 0xFF);
            case 0x6:
            case 0x7: return this.readQueue.pop() || 0x00;
            default:  return 0x00;
        }
    }
    this.write = function(p,v) {
        // HACK: The -1 is to break the run loop to allow the br.pause() to take hold.
        switch (p) {
            case 0x2: this.readEntry(v);               return -1;
            case 0x3: this.writeEntry(v);              return -1;
            case 0x5: this.writeQueue = [];                break;
            case 0x6:
            case 0x7: this.writeQueue.push(v);             break;
            default:                                      return;
        }
    }

    this.readEntry = function(v) {
        this.readQueue = [];
        if (v) {
            // TODO: Figure out how to make this synchronous.
            // HACK: Pause the emulator until promise resolves.
            if (navigator.clipboard.readText) {
                br.pause();
                navigator.clipboard.readText().then(
                    (text) => {
                        this.readQueue = Array.from(encodeUtf8(text));
                        this.readQueue.reverse();
                        br.run();
                    },
                    () => {
                        br.run();
                    },
                );
            }
        } else {
            // TODO: Look into valid clipboard binary formats.
        }
    }
    this.writeEntry = function(v) {
        if (v) {
            // TODO: Figure out how to make this synchronous.
            // HACK: Pause the emulator until promise resolves.
            if (navigator.clipboard.writeText) {
                br.pause();
                let parser = new Utf8StreamParser();
                parser.pushList(this.writeQueue);
                navigator.clipboard.writeText(parser.read()).then(
                    () => {
                        br.run();
                    },
                    () => {
                        br.run();
                    }
                );
            }
        } else {
            // TODO: Look into valid clipboard binary formats.
            // let array = new Uint8Array(this.writeQueue);
            // let type = "application/octet-stream";
            // let blob = new Blob([array.buffer], {type});
            // let items = [new ClipboardItem({ [type]: blob })];
            // navigator.clipboard.write(items);
        }
        this.writeQueue = 0;
    }
}



// Read-only buffer for reading a string from a device.
function TextBuffer(text) {
    this.mem = new Uint8Array(text.length);
    this.p = 0;

    // Populate the buffer.
    for (let i=0; i<text.length; i++) this.mem[i] = text.codePointAt(i);

    this.reset = function() {
        this.p = 0;
    }
    this.read = function() {
        return this.mem[this.p++] ?? 0;
    }
}


/// Countdown timer for the clock device.
function CountdownTimer() {
    this.reset = function() {
        this.end = 0;
        this.read = 0;
        this.write = 0;
        this.wakeFlag = false;
    }
    this.reset();

    this.wake = function() {
        if (this.end && this.end <= performance.now()) {
            this.end = 0;
            this.wakeFlag = true;
        }
        let wake = this.wakeFlag; this.wakeFlag = false;
        return wake;
    }
    this.update = function() {
        if (this.end) {
            let remaining = this.end - performance.now();
            if (remaining > 0) {
                this.read = remaining * 0.256;
            } else {
                this.read = 0;
                this.end = 0;
                this.wakeFlag = true;
            }
        } else {
            this.read = 0;
        }
    }
    this.commit = function() {
        this.end = performance.now() + (this.write / 0.256);
    }
}


// Byte queue implemented as a circular buffer.
function ByteQueue(capacity) {
    this.mem = new Uint8Array(capacity);
    this.length = 0;
    this.head = 0;
    this.tail = 0;

    this.clear = function() {
        this.length = 0;
        this.head = 0;
        this.tail = 0;
    }
    this.push = function(v) {
        // Only push if there is sufficient remaining capacity.
        if (this.length < this.mem.length) {
            this.mem[this.head] = v;
            this.head = (this.head + 1) % this.mem.length;
            this.length += 1;
        }
    }
    this.pushList = function(list) {
        // Only push if there is sufficient remaining capacity.
        if (this.mem.length - this.length >= list.length) {
            for (let byte of list) this.push(byte);
        }
    }
    this.pop = function() {
        if (this.length) {
            let byte = this.mem[this.tail];
            this.tail = (this.tail + 1) % this.mem.length;
            this.length -= 1;
            return byte;
        } else {
            return 0x00;
        }
    }
}


// Circular buffer that holds sprite data for the screen device.
function SpriteBuffer() {
    this.mem = new Uint8Array(16);
    this.p = 0;
    this.cache1 = new Uint8Array(64);  // cached 1-bit sprite
    this.cache2 = new Uint8Array(64);  // cached 2-bit sprite
    this.dirty1 = true;                // dirty flag for 1-bit sprite
    this.dirty2 = true;                // dirty flag for 2-bit sprite

    this.push = function(v) {
        this.mem[this.p] = v;
        this.p = (this.p + 1) & 0xF;
        this.dirty1 = true;
        this.dirty2 = true;
    }
    this.get1Bit = function(transform) {
        if (this.dirty1) {
            for (let i=0; i<8; i++) {
                let rowL = this.mem[this.p+i+8 & 0xF];
                for (let j=0; j<8; j++) {
                    let bit = rowL >> (7-j) & 0x1;
                    this.cache1[i*8+j] = bit;
                }
            }
            this.dirty1 = false;
        }
        return this.transform(this.cache1, transform);
    }
    this.get2Bit = function(transform) {
        if (this.dirty2) {
            for (let i=0; i<8; i++) {
                let rowH = this.mem[this.p+i   & 0xF];
                let rowL = this.mem[this.p+i+8 & 0xF];
                for (let j=0; j<8; j++) {
                    let bitH = rowH >> (7-j) & 0x1;
                    let bitL = rowL >> (7-j) & 0x1;
                    this.cache2[i*8+j] = bitH << 1 | bitL;
                }
            }
            this.dirty2 = false;
        }
        return this.transform(this.cache2, transform);
    }

    this.transform = function(sprite, transform) {
        let x, y; let t = new Uint8Array(64);
        switch (transform & 0x7) {
            case 0: for (y=0; y<8; y++) { for (x=0; x<8; x++) { t[y*8+x] = sprite[   y *8+   x ] } }; break;
            case 1: for (y=0; y<8; y++) { for (x=0; x<8; x++) { t[y*8+x] = sprite[   y *8+(7-x)] } }; break;
            case 2: for (y=0; y<8; y++) { for (x=0; x<8; x++) { t[y*8+x] = sprite[(7-y)*8+   x ] } }; break;
            case 3: for (y=0; y<8; y++) { for (x=0; x<8; x++) { t[y*8+x] = sprite[(7-y)*8+(7-x)] } }; break;
            case 4: for (y=0; y<8; y++) { for (x=0; x<8; x++) { t[y*8+x] = sprite[   x *8+   y ] } }; break;
            case 5: for (y=0; y<8; y++) { for (x=0; x<8; x++) { t[y*8+x] = sprite[   x *8+(7-y)] } }; break;
            case 6: for (y=0; y<8; y++) { for (x=0; x<8; x++) { t[y*8+x] = sprite[(7-x)*8+   y ] } }; break;
            case 7: for (y=0; y<8; y++) { for (x=0; x<8; x++) { t[y*8+x] = sprite[(7-x)*8+(7-y)] } }; break;
        }
        return t;
    }
}


function setHH(v, byte) { return byte << 24 | v       & 0x00FFFFFF; }
function setHL(v, byte) { return byte << 16 | v       & 0xFF00FFFF; }
function setH (v, byte) { return byte <<  8 | v       & 0xFFFF00FF; }
function setL (v, byte) { return byte       | v       & 0xFFFFFF00; }
function getHH(v)       { return              v >> 24 & 0x000000FF; }
function getHL(v)       { return              v >> 16 & 0x000000FF; }
function getH (v)       { return              v >>  8 & 0x000000FF; }
function getL (v)       { return              v       & 0x000000FF; }

function bool (b)       { return b ? 0xFF : 0x00; }
function signed(v)      { return v << 16 >> 16; }
function clamp(v,a,b)   { return v>=a ? v<b ? v : b : a; }  // inclusive a and b



// ----------------------------------------------------------------------------------------------- +
//  :::::: CONSTANTS ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +
// ----------------------------------------------------------------------------------------------- +


const projectLink = `
    <a href='https://benbridle.com/bedrock-js' target='_blank'>
        <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8' width='8' height='8'>
            <g fill='currentColor'>
                <rect x='0' y='0' width='8' height='1' />
                <rect x='0' y='2' width='8' height='1' />
                <rect x='0' y='4' width='8' height='4' />
            </g>
        </svg><span style='margin:0 4px'>bedrock-js</span>
    </a>
`;

const fullscreenIcon = `
    <svg xmlns='http://www.w3.org/2000/svg' viewBox='8 8 20 20' width='1em' fill='currentColor'>
        <path d='m 10,16 2,0 0,-4 4,0 0,-2 L 10,10 l 0,6 0,0 z'></path>
        <path d='m 20,10 0,2 4,0 0,4 2,0 L 26,10 l -6,0 0,0 z'></path>
        <path d='m 24,24 -4,0 0,2 L 26,26 l 0,-6 -2,0 0,4 0,0 z'></path>
        <path d='M 12,20 10,20 10,26 l 6,0 0,-2 -4,0 0,-4 0,0 z'></path>
    </svg>
`;

const runIcon = `
    <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' width='1em' fill='currentColor'>
        <path d='m 5,2 6,6 -6,6 z'></path>
    </svg>
`;

const pauseIcon = `
    <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' width='1em' fill='currentColor'>
        <path d='m 2.5,2.5 4.5,0 0,11 -4.5,0 z'></path>
        <path d='m 9.5,2.5 4.5,0 0,11 -4.5,0 z'></path>
    </svg>
`;

const stopIcon = `
    <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' width='1em' fill='currentColor'>
        <path d='m 2.5,2.5 11,0 0,11 -11,0 z'></path>
    </svg>
`;

const stepIcon = `
    <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' width='1em' fill='currentColor'>
        <path d='m 3,2 6,6 -6,6 z'></path>
        <path d='m 9,2.5 2.5,0 0,11 -2.5,0 z'></path>
    </svg>
`;

const assemblerTemplate = `
    <div class='bedrock assembler'>
        <div class='editor'>
            <div class='viewer' aria-hidden=true></div>
            <textarea spellcheck=false></textarea>
        </div>
        <div class='menubar'>
            <button name='fullscreen'>${fullscreenIcon}</button>
            <button name='check'>CHECK</button>
            <button name='run'>RUN</button>
            <span class='status'></span>
            ${projectLink}
        </div>
        <div class='hidden panel errors'></div>
        <div class='hidden panel bytecode'></div>
    </div>
`;


const emulatorTemplate = `
    <div class='bedrock emulator'>
        <div class='menubar'>
            <button name='fullscreen'>${fullscreenIcon}</button>
            <button name='state'>STATE</button>
            <button name='run'>${runIcon}</button>
            <button name='pause'>${pauseIcon}</button>
            <button name='stop'>${stopIcon}</button>
            <button name='step'>${stepIcon}</button>
            <span class='status'></span>
            ${projectLink}
        </div>
        <div class='hidden panel state'><ul>
            <li>PC:  <span class='pc'></span>  <span class='label'></span></li>
            <li>WST: <span class='wst'></span></li>
            <li>RST: <span class='rst'></span></li>
        </ul></div>
        <div class='hidden stream'><ul class='transmissions'></ul></div>
        <div class='hidden screen'><canvas></canvas></div>
    </div>
`;


const bedrockStyles = `
    div.bedrock {
      --br-fg:var(--fg,#222); --br-bg:var(--bg,#eed); --br-accent:var(--accent,#467); }
    div.bedrock * {
        font-family:var(--font-family),monospace; font-weight:var(--font-weight); font-size:var(--font-size);
        box-sizing:border-box; color:var(--br-bg); }
    div.bedrock {
        display:flex; flex-direction:column; overflow:hidden; border-radius:2px;  }
    div.bedrock .hidden {
        display:none }

    .bedrock.assembler .editor {
        position:relative; flex-grow:1; }
    .bedrock.assembler textarea, .bedrock.assembler .viewer {
        position:absolute; top:0; left:0; width:100%; height:100%; margin:0; padding:0.5rem 0.7rem;
        max-height:calc(100vh); overflow:auto; border:none; white-space:pre; tab-size:2; }
    .bedrock.assembler textarea {
        z-index:1; background:transparent; color:transparent; caret-color:var(--br-fg); resize:vertical }
    .bedrock.assembler textarea:focus {
        outline:none; }
    .bedrock:fullscreen textarea, .bedrock:fullscreen .screen {
        resize:none; height:100% !important; }

    .bedrock.assembler .viewer {
        z-index:0; background:var(--br-bg); color:var(--br-fg) }
    .bedrock.assembler .viewer .comment    { color:var(--comment,    #998) }
    .bedrock.assembler .viewer .value      { color:var(--value,      #532) }
    .bedrock.assembler .viewer .definition { color:var(--definition, #245) }
    .bedrock.assembler .viewer .reference  { color:var(--reference       ) }

    .bedrock .menubar {
        background:var(--br-accent); display:flex; padding:3px; gap:3px }
    .bedrock button {
        display:flex; align-items:center; background:#0004; border:none; border-radius:2px; cursor:pointer; }
    .bedrock .menubar button:hover  {
        background:#0006; }
    .bedrock .menubar button:active {
        background:#000c; }
    .bedrock .menubar .status {
        font-size:85%;  }
    .bedrock .menubar a {
        text-decoration:none; white-space:nowrap; padding-left:0.4em }
    .bedrock .menubar a:hover {
        text-decoration:underline  }
    .bedrock .menubar .status {
        flex-grow:1; white-space:nowrap; overflow-x:hidden; align-self:center; padding-left:0.4rem; }

    .bedrock .panel {
        color:var(--br-bg); background:var(--br-accent); }
    .bedrock .panel > * {
        background:#0006; padding:0.3rem 0.5rem;  }
    .bedrock .panel ul {
        overflow:scroll; margin:0; list-style:none; }
    .bedrock .panel li {
        white-space:pre; }
    .bedrock .panel .label {
        opacity:60%; }

    .bedrock .stream {
        overflow:auto; background:var(--br-bg); padding:0.3rem; flex-grow:1; max-height:10rem; }
    .bedrock .stream ul {
        margin:0; padding:0; padding-left:0.5rem }
    .bedrock .stream li {
        color:var(--br-fg); padding:0 0.3rem; cursor:pointer; white-space:break-spaces }
    .bedrock .stream li::marker {
        content:'>'; }
    .bedrock .stream li:hover {
        text-decoration:underline }
    .bedrock .screen {
        background:#111; }
    .bedrock .screen canvas {
        display:block; margin:0 auto; image-rendering:pixelated; touch-action:none; }
    .bedrock:fullscreen .stream {
        max-height:none; }
`;


const instructionTable = {
    'HLT': 0x00, 'NOP' : 0x20, 'DB1' : 0x40, 'DB2'  : 0x60, 'DB3' : 0x80, 'DB4'  : 0xA0, 'DB5'  : 0xC0, 'DB6'   : 0xE0,
    'PSH': 0x01, 'PSH:': 0x21, 'PSH*': 0x41, 'PSH*:': 0x61, 'PSHr': 0x81, 'PSHr:': 0xA1, 'PSHr*': 0xC1, 'PSHr*:': 0xE1,
                    ':': 0x21,                  '*:': 0x61,                  'r:': 0xA1,                   'r*:': 0xE1,
    'POP': 0x02, 'POP:': 0x22, 'POP*': 0x42, 'POP*:': 0x62, 'POPr': 0x82, 'POPr:': 0xA2, 'POPr*': 0xC2, 'POPr*:': 0xE2,
    'CPY': 0x03, 'CPY:': 0x23, 'CPY*': 0x43, 'CPY*:': 0x63, 'CPYr': 0x83, 'CPYr:': 0xA3, 'CPYr*': 0xC3, 'CPYr*:': 0xE3,
    'DUP': 0x04, 'DUP:': 0x24, 'DUP*': 0x44, 'DUP*:': 0x64, 'DUPr': 0x84, 'DUPr:': 0xA4, 'DUPr*': 0xC4, 'DUPr*:': 0xE4,
    'OVR': 0x05, 'OVR:': 0x25, 'OVR*': 0x45, 'OVR*:': 0x65, 'OVRr': 0x85, 'OVRr:': 0xA5, 'OVRr*': 0xC5, 'OVRr*:': 0xE5,
    'SWP': 0x06, 'SWP:': 0x26, 'SWP*': 0x46, 'SWP*:': 0x66, 'SWPr': 0x86, 'SWPr:': 0xA6, 'SWPr*': 0xC6, 'SWPr*:': 0xE6,
    'ROT': 0x07, 'ROT:': 0x27, 'ROT*': 0x47, 'ROT*:': 0x67, 'ROTr': 0x87, 'ROTr:': 0xA7, 'ROTr*': 0xC7, 'ROTr*:': 0xE7,
    'JMP': 0x08, 'JMP:': 0x28, 'JMP*': 0x48, 'JMP*:': 0x68, 'JMPr': 0x88, 'JMPr:': 0xA8, 'JMPr*': 0xC8, 'JMPr*:': 0xE8,
    'JMS': 0x09, 'JMS:': 0x29, 'JMS*': 0x49, 'JMS*:': 0x69, 'JMSr': 0x89, 'JMSr:': 0xA9, 'JMSr*': 0xC9, 'JMSr*:': 0xE9,
    'JCN': 0x0A, 'JCN:': 0x2A, 'JCN*': 0x4A, 'JCN*:': 0x6A, 'JCNr': 0x8A, 'JCNr:': 0xAA, 'JCNr*': 0xCA, 'JCNr*:': 0xEA,
    'JCS': 0x0B, 'JCS:': 0x2B, 'JCS*': 0x4B, 'JCS*:': 0x6B, 'JCSr': 0x8B, 'JCSr:': 0xAB, 'JCSr*': 0xCB, 'JCSr*:': 0xEB,
    'LDA': 0x0C, 'LDA:': 0x2C, 'LDA*': 0x4C, 'LDA*:': 0x6C, 'LDAr': 0x8C, 'LDAr:': 0xAC, 'LDAr*': 0xCC, 'LDAr*:': 0xEC,
    'STA': 0x0D, 'STA:': 0x2D, 'STA*': 0x4D, 'STA*:': 0x6D, 'STAr': 0x8D, 'STAr:': 0xAD, 'STAr*': 0xCD, 'STAr*:': 0xED,
    'LDD': 0x0E, 'LDD:': 0x2E, 'LDD*': 0x4E, 'LDD*:': 0x6E, 'LDDr': 0x8E, 'LDDr:': 0xAE, 'LDDr*': 0xCE, 'LDDr*:': 0xEE,
    'STD': 0x0F, 'STD:': 0x2F, 'STD*': 0x4F, 'STD*:': 0x6F, 'STDr': 0x8F, 'STDr:': 0xAF, 'STDr*': 0xCF, 'STDr*:': 0xEF,
    'ADD': 0x10, 'ADD:': 0x30, 'ADD*': 0x50, 'ADD*:': 0x70, 'ADDr': 0x90, 'ADDr:': 0xB0, 'ADDr*': 0xD0, 'ADDr*:': 0xF0,
    'SUB': 0x11, 'SUB:': 0x31, 'SUB*': 0x51, 'SUB*:': 0x71, 'SUBr': 0x91, 'SUBr:': 0xB1, 'SUBr*': 0xD1, 'SUBr*:': 0xF1,
    'INC': 0x12, 'INC:': 0x32, 'INC*': 0x52, 'INC*:': 0x72, 'INCr': 0x92, 'INCr:': 0xB2, 'INCr*': 0xD2, 'INCr*:': 0xF2,
    'DEC': 0x13, 'DEC:': 0x33, 'DEC*': 0x53, 'DEC*:': 0x73, 'DECr': 0x93, 'DECr:': 0xB3, 'DECr*': 0xD3, 'DECr*:': 0xF3,
    'LTH': 0x14, 'LTH:': 0x34, 'LTH*': 0x54, 'LTH*:': 0x74, 'LTHr': 0x94, 'LTHr:': 0xB4, 'LTHr*': 0xD4, 'LTHr*:': 0xF4,
    'GTH': 0x15, 'GTH:': 0x35, 'GTH*': 0x55, 'GTH*:': 0x75, 'GTHr': 0x95, 'GTHr:': 0xB5, 'GTHr*': 0xD5, 'GTHr*:': 0xF5,
    'EQU': 0x16, 'EQU:': 0x36, 'EQU*': 0x56, 'EQU*:': 0x76, 'EQUr': 0x96, 'EQUr:': 0xB6, 'EQUr*': 0xD6, 'EQUr*:': 0xF6,
    'NQK': 0x17, 'NQK:': 0x37, 'NQK*': 0x57, 'NQK*:': 0x77, 'NQKr': 0x97, 'NQKr:': 0xB7, 'NQKr*': 0xD7, 'NQKr*:': 0xF7,
    'SHL': 0x18, 'SHL:': 0x38, 'SHL*': 0x58, 'SHL*:': 0x78, 'SHLr': 0x98, 'SHLr:': 0xB8, 'SHLr*': 0xD8, 'SHLr*:': 0xF8,
    'SHR': 0x19, 'SHR:': 0x39, 'SHR*': 0x59, 'SHR*:': 0x79, 'SHRr': 0x99, 'SHRr:': 0xB9, 'SHRr*': 0xD9, 'SHRr*:': 0xF9,
    'ROL': 0x1A, 'ROL:': 0x3A, 'ROL*': 0x5A, 'ROL*:': 0x7A, 'ROLr': 0x9A, 'ROLr:': 0xBA, 'ROLr*': 0xDA, 'ROLr*:': 0xFA,
    'ROR': 0x1B, 'ROR:': 0x3B, 'ROR*': 0x5B, 'ROR*:': 0x7B, 'RORr': 0x9B, 'RORr:': 0xBB, 'RORr*': 0xDB, 'RORr*:': 0xFB,
    'IOR': 0x1C, 'IOR:': 0x3C, 'IOR*': 0x5C, 'IOR*:': 0x7C, 'IORr': 0x9C, 'IORr:': 0xBC, 'IORr*': 0xDC, 'IORr*:': 0xFC,
    'XOR': 0x1D, 'XOR:': 0x3D, 'XOR*': 0x5D, 'XOR*:': 0x7D, 'XORr': 0x9D, 'XORr:': 0xBD, 'XORr*': 0xDD, 'XORr*:': 0xFD,
    'AND': 0x1E, 'AND:': 0x3E, 'AND*': 0x5E, 'AND*:': 0x7E, 'ANDr': 0x9E, 'ANDr:': 0xBE, 'ANDr*': 0xDE, 'ANDr*:': 0xFE,
    'NOT': 0x1F, 'NOT:': 0x3F, 'NOT*': 0x5F, 'NOT*:': 0x7F, 'NOTr': 0x9F, 'NOTr:': 0xBF, 'NOTr*': 0xDF, 'NOTr*:': 0xFF,

    // TODO: Remove.
    '?':0x40,
};