vtac-terminal 1.0.0

package/dist/VTAC/VTAC.js

@@ -0,0 +1,1134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VTAC = void 0;
+const sdl_1 = __importDefault(require("@kmamal/sdl"));
+const serialport_1 = require("serialport");
+class VTAC {
+    constructor() {
+        this.baudRate = 9600;
+        this.parity = 'none';
+        this.dataBits = 8;
+        this.stopBits = 1;
+        this.scale = 2;
+        this.fullscreen = false;
+        this.buffer = Buffer.alloc(VTAC.WIDTH * VTAC.HEIGHT).fill(0x00);
+        this.mode = 'text';
+        this.column = 0;
+        this.row = 0;
+        this.offset = 0;
+        this.columnNextByte = false;
+        this.rowNextByte = false;
+        this.cursorChar = 0x00; // OFF
+        this.cursorMode = 'solid';
+        this.cursorCharNextByte = false;
+        this.cursorBlinkTime = 0;
+        this.cursorVisible = true;
+        this.cursorBlinkInterval = 500; // Blink every 500ms (twice per second)
+        this.dataNextByte = false;
+        this.foregroundColor = 0xFF; // White
+        this.backgroundColor = 0x00; // Black
+        this.foregroundColorNextByte = false;
+        this.backgroundColorNextByte = false;
+        this.lastRenderTime = 0;
+        this.targetFrameTime = 1000 / 60; // 60fps = ~16.67ms per frame
+        //
+        // MAIN
+        //
+        this.launch = () => {
+            if (this.path) {
+                this.port = new serialport_1.SerialPort({
+                    path: this.path,
+                    baudRate: this.baudRate,
+                    parity: this.parity,
+                    dataBits: this.dataBits,
+                    stopBits: this.stopBits
+                }, (err) => {
+                    if (err) {
+                        console.log('Error: ', err.message);
+                    }
+                });
+                this.port.on('data', this.receive);
+            }
+            this.window = sdl_1.default.video.createWindow({
+                title: "VT-AC",
+                width: VTAC.WIDTH * this.scale,
+                height: VTAC.HEIGHT * this.scale,
+                fullscreen: this.fullscreen,
+                resizable: false
+            });
+            this.window.on('keyDown', this.onKey);
+            this.window.on('textInput', this.onText);
+            this.window.on('close', (event) => {
+                if (this.port && this.port.isOpen) {
+                    this.port.close();
+                }
+            });
+            // Start the render loop
+            this.render();
+        };
+        this.render = () => {
+            if (!this.window) {
+                return;
+            }
+            if (this.window.destroyed) {
+                return;
+            }
+            const now = Date.now();
+            const elapsed = now - this.lastRenderTime;
+            // Update cursor blink state
+            if (this.cursorMode === 'blinking') {
+                this.cursorBlinkTime += elapsed;
+                if (this.cursorBlinkTime >= this.cursorBlinkInterval) {
+                    this.cursorVisible = !this.cursorVisible;
+                    this.cursorBlinkTime = 0;
+                }
+            }
+            else {
+                this.cursorVisible = true;
+            }
+            // Create temporary render buffer
+            const renderBuffer = Buffer.from(this.buffer);
+            // Draw cursor if visible and cursorChar is not 0x00 (OFF)
+            if (this.cursorVisible && this.cursorChar !== 0x00) {
+                this.drawCursor(renderBuffer);
+            }
+            this.window.render(VTAC.WIDTH, VTAC.HEIGHT, VTAC.WIDTH, 'rgb332', renderBuffer);
+            this.lastRenderTime = now;
+            // Calculate delay to maintain target frame rate
+            const renderTime = Date.now() - now;
+            const delay = Math.max(0, this.targetFrameTime - renderTime);
+            setTimeout(this.render, delay);
+        };
+        this.drawCursor = (renderBuffer) => {
+            const character = VTAC.CHARACTERS[this.cursorChar];
+            const startRow = this.row * 8;
+            const startColumn = this.column * 8;
+            // Draw cursor character with inverted colors
+            for (let y = 0; y < 8; y++) {
+                const rowByte = character[y];
+                const bufferRowStart = (startRow + y) * VTAC.WIDTH;
+                for (let x = 0; x < 8; x++) {
+                    const bit = (rowByte >> (7 - x)) & 1;
+                    // Invert the colors: if bit is 1, use background; if 0, use foreground
+                    const color = bit ? this.backgroundColor : this.foregroundColor;
+                    renderBuffer[bufferRowStart + startColumn + x] = color;
+                }
+            }
+        };
+        //
+        // METHODS
+        // 
+        this.reset = () => {
+            this.column = 0;
+            this.row = 0;
+            this.offset = 0;
+            this.mode = 'text';
+            this.cursorChar = 0x00;
+            this.cursorMode = 'solid';
+            this.backgroundColor = 0x00;
+            this.foregroundColor = 0xFF;
+            this.columnNextByte = false;
+            this.rowNextByte = false;
+            this.cursorCharNextByte = false;
+            this.foregroundColorNextByte = false;
+            this.backgroundColorNextByte = false;
+            this.buffer.fill(0x00);
+        };
+        this.bell = () => {
+            process.stdout.write('\u0007');
+        };
+        this.backspace = () => {
+            if (this.column > 0) {
+                this.column--;
+            }
+            this.offset = 0;
+        };
+        this.tab = () => {
+            this.column = Math.min((Math.floor(this.column / 4) + 1) * 4, VTAC.COLUMNS - 1);
+            this.offset = 0;
+        };
+        this.lineFeed = () => {
+            let nextRow = this.row + 1;
+            if (nextRow >= VTAC.ROWS) {
+                nextRow = VTAC.ROWS - 1;
+                this.scroll('up');
+            }
+            this.row = nextRow;
+            this.offset = 0;
+        };
+        this.carriageReturn = () => {
+            this.column = 0;
+            this.offset = 0;
+        };
+        this.deleteTo = (destination) => {
+            switch (destination) {
+                case 'startOfLine':
+                    // Clear from start of current line to current cursor position
+                    for (let col = 0; col <= this.column; col++) {
+                        this.clearCharacterCell(col, this.row);
+                    }
+                    break;
+                case 'endOfLine':
+                    // Clear from current cursor position to end of current line
+                    for (let col = this.column; col < VTAC.COLUMNS; col++) {
+                        this.clearCharacterCell(col, this.row);
+                    }
+                    break;
+                case 'startOfScreen':
+                    // Clear from start of screen to current cursor position
+                    for (let row = 0; row < this.row; row++) {
+                        for (let col = 0; col < VTAC.COLUMNS; col++) {
+                            this.clearCharacterCell(col, row);
+                        }
+                    }
+                    // Clear partial line up to and including cursor
+                    for (let col = 0; col <= this.column; col++) {
+                        this.clearCharacterCell(col, this.row);
+                    }
+                    break;
+                case 'endOfScreen':
+                    // Clear from current cursor position to end of screen
+                    for (let col = this.column; col < VTAC.COLUMNS; col++) {
+                        this.clearCharacterCell(col, this.row);
+                    }
+                    // Clear remaining lines
+                    for (let row = this.row + 1; row < VTAC.ROWS; row++) {
+                        for (let col = 0; col < VTAC.COLUMNS; col++) {
+                            this.clearCharacterCell(col, row);
+                        }
+                    }
+                    break;
+            }
+        };
+        this.scroll = (direction) => {
+            switch (direction) {
+                case 'left':
+                    // Shift all character cells one position to the left
+                    for (let row = 0; row < VTAC.ROWS; row++) {
+                        for (let col = 0; col < VTAC.COLUMNS - 1; col++) {
+                            this.copyCharacterCell(col + 1, row, col, row);
+                        }
+                        // Fill rightmost column with background color
+                        this.clearCharacterCell(VTAC.COLUMNS - 1, row);
+                    }
+                    break;
+                case 'right':
+                    // Shift all character cells one position to the right
+                    for (let row = 0; row < VTAC.ROWS; row++) {
+                        for (let col = VTAC.COLUMNS - 1; col > 0; col--) {
+                            this.copyCharacterCell(col - 1, row, col, row);
+                        }
+                        // Fill leftmost column with background color
+                        this.clearCharacterCell(0, row);
+                    }
+                    break;
+                case 'up':
+                    // Shift all character cells one position up
+                    for (let row = 0; row < VTAC.ROWS - 1; row++) {
+                        for (let col = 0; col < VTAC.COLUMNS; col++) {
+                            this.copyCharacterCell(col, row + 1, col, row);
+                        }
+                    }
+                    // Fill bottom row with background color
+                    for (let col = 0; col < VTAC.COLUMNS; col++) {
+                        this.clearCharacterCell(col, VTAC.ROWS - 1);
+                    }
+                    break;
+                case 'down':
+                    // Shift all character cells one position down
+                    for (let row = VTAC.ROWS - 1; row > 0; row--) {
+                        for (let col = 0; col < VTAC.COLUMNS; col++) {
+                            this.copyCharacterCell(col, row - 1, col, row);
+                        }
+                    }
+                    // Fill top row with background color
+                    for (let col = 0; col < VTAC.COLUMNS; col++) {
+                        this.clearCharacterCell(col, 0);
+                    }
+                    break;
+            }
+        };
+        this.cursor = (direction) => {
+            switch (direction) {
+                case 'left':
+                    if (this.column > 0) {
+                        this.column--;
+                    }
+                    break;
+                case 'right':
+                    if (this.column < VTAC.COLUMNS - 1) {
+                        this.column++;
+                    }
+                    break;
+                case 'up':
+                    if (this.row > 0) {
+                        this.row--;
+                    }
+                    break;
+                case 'down':
+                    if (this.row < VTAC.ROWS - 1) {
+                        this.row++;
+                    }
+                    break;
+            }
+            this.offset = 0;
+        };
+        this.delete = () => {
+            const startRow = this.row * 8;
+            const startColumn = this.column * 8;
+            // Clear 8x8 pixel block with background color
+            for (let y = 0; y < 8; y++) {
+                const bufferRowStart = (startRow + y) * VTAC.WIDTH;
+                for (let x = 0; x < 8; x++) {
+                    this.buffer[bufferRowStart + startColumn + x] = this.backgroundColor;
+                }
+            }
+        };
+        this.data = (data) => {
+            switch (this.mode) {
+                case 'text':
+                    this.insertTextData(data);
+                    break;
+                case 'graphics':
+                    this.insertGraphicsData(data);
+                    break;
+            }
+        };
+        //
+        // INSERT
+        //
+        this.insertTextData = (data) => {
+            const character = VTAC.CHARACTERS[data];
+            const startRow = this.row * 8;
+            const startColumn = this.column * 8;
+            // Render 8x8 character bitmap
+            for (let y = 0; y < 8; y++) {
+                const rowByte = character[y];
+                const bufferRowStart = (startRow + y) * VTAC.WIDTH;
+                for (let x = 0; x < 8; x++) {
+                    const bit = (rowByte >> (7 - x)) & 1;
+                    const color = bit ? this.foregroundColor : this.backgroundColor;
+                    this.buffer[bufferRowStart + startColumn + x] = color;
+                }
+            }
+            // Move to next character position
+            this.column++;
+            if (this.column >= VTAC.COLUMNS) {
+                this.column = 0;
+                this.row++;
+                if (this.row >= VTAC.ROWS) {
+                    this.row = VTAC.ROWS - 1;
+                }
+            }
+            this.offset = 0;
+        };
+        this.insertGraphicsData = (data) => {
+            // Calculate starting pixel position (offset is the row within the 8x8 block)
+            const pixelRow = this.row * 8 + this.offset;
+            const startColumn = this.column * 8;
+            const bufferRowStart = pixelRow * VTAC.WIDTH;
+            // Write 8 pixels horizontally - each bit in data represents one pixel
+            // Bit 7 (MSB) is leftmost pixel, bit 0 (LSB) is rightmost pixel
+            for (let i = 0; i < 8; i++) {
+                const bit = (data >> (7 - i)) & 1;
+                const color = bit ? this.foregroundColor : this.backgroundColor;
+                this.buffer[bufferRowStart + startColumn + i] = color;
+            }
+            // Move to next location in pixel array
+            this.offset++;
+            if (this.offset >= 8) {
+                this.offset = 0;
+                this.column++;
+                if (this.column >= VTAC.COLUMNS) {
+                    this.column = 0;
+                    this.row++;
+                    if (this.row >= VTAC.ROWS) {
+                        this.row = 0;
+                    }
+                }
+            }
+        };
+        //
+        // HELPERS
+        //
+        this.copyCharacterCell = (sourceCol, sourceRow, destCol, destRow) => {
+            const sourceStartRow = sourceRow * 8;
+            const sourceStartColumn = sourceCol * 8;
+            const destStartRow = destRow * 8;
+            const destStartColumn = destCol * 8;
+            // Copy 8x8 pixel block
+            for (let y = 0; y < 8; y++) {
+                const sourceBufferRowStart = (sourceStartRow + y) * VTAC.WIDTH;
+                const destBufferRowStart = (destStartRow + y) * VTAC.WIDTH;
+                for (let x = 0; x < 8; x++) {
+                    this.buffer[destBufferRowStart + destStartColumn + x] =
+                        this.buffer[sourceBufferRowStart + sourceStartColumn + x];
+                }
+            }
+        };
+        this.clearCharacterCell = (col, row) => {
+            const startRow = row * 8;
+            const startColumn = col * 8;
+            // Clear 8x8 pixel block with background color
+            for (let y = 0; y < 8; y++) {
+                const bufferRowStart = (startRow + y) * VTAC.WIDTH;
+                for (let x = 0; x < 8; x++) {
+                    this.buffer[bufferRowStart + startColumn + x] = this.backgroundColor;
+                }
+            }
+        };
+        //
+        // EVENTS
+        //
+        this.parse = (data) => {
+            if (this.cursorCharNextByte) {
+                this.cursorChar = data;
+                this.cursorCharNextByte = false;
+                return;
+            }
+            if (this.columnNextByte) {
+                this.column = data % VTAC.COLUMNS; // 0 to COLUMNS-1
+                this.offset = 0;
+                this.columnNextByte = false;
+                return;
+            }
+            if (this.rowNextByte) {
+                this.row = data % VTAC.ROWS; // 0 to ROWS-1
+                this.offset = 0;
+                this.rowNextByte = false;
+                return;
+            }
+            if (this.foregroundColorNextByte) {
+                this.foregroundColor = data;
+                this.foregroundColorNextByte = false;
+                return;
+            }
+            if (this.backgroundColorNextByte) {
+                this.backgroundColor = data;
+                this.backgroundColorNextByte = false;
+                return;
+            }
+            if (this.dataNextByte) {
+                this.data(data);
+                this.dataNextByte = false;
+                return;
+            }
+            switch (true) {
+                case (data == 0x00): // NULL
+                    break;
+                case (data == 0x01): // CURSOR HOME
+                    this.column = 0;
+                    this.row = 0;
+                    this.offset = 0;
+                    break;
+                case (data == 0x02): // CURSOR CHARACTER
+                    this.cursorCharNextByte = true;
+                    break;
+                case (data == 0x03): // CURSOR BLINKING
+                    this.cursorMode == 'solid' ? this.cursorMode = 'blinking' : this.cursorMode = 'solid';
+                    break;
+                case (data == 0x04): // RESET
+                    this.reset();
+                    break;
+                case (data == 0x05): // RESERVED
+                    // Reserved for future use
+                    break;
+                case (data == 0x06): // RESERVED
+                    // Reserved for future use
+                    break;
+                case (data == 0x07): // BELL
+                    this.bell();
+                    break;
+                case (data == 0x08): // BACKSPACE
+                    this.backspace();
+                    break;
+                case (data == 0x09): // TAB
+                    this.tab();
+                    break;
+                case (data == 0x0A): // LINE FEED
+                    this.lineFeed();
+                    break;
+                case (data == 0x0B): // SCREEN MODE
+                    this.mode == 'text' ? this.mode = 'graphics' : this.mode = 'text';
+                    break;
+                case (data == 0x0C): // CLEAR SCREEN
+                    this.buffer.fill(this.backgroundColor);
+                    break;
+                case (data == 0x0D): // CARRIAGE RETURN
+                    this.carriageReturn();
+                    break;
+                case (data == 0x0E): // SET COLUMN
+                    this.columnNextByte = true;
+                    break;
+                case (data == 0x0F): // SET ROW
+                    this.rowNextByte = true;
+                    break;
+                case (data == 0x10): // DELETE TO START OF LINE
+                    this.deleteTo('startOfLine');
+                    break;
+                case (data == 0x11): // DELETE TO END OF LINE
+                    this.deleteTo('endOfLine');
+                    break;
+                case (data == 0x12): // DELETE TO START OF SCREEN
+                    this.deleteTo('startOfScreen');
+                    break;
+                case (data == 0x13): // DELETE TO END OF SCREEN
+                    this.deleteTo('endOfScreen');
+                    break;
+                case (data == 0x14): // SCROLL LEFT
+                    this.scroll('left');
+                    break;
+                case (data == 0x15): // SCROLL RIGHT
+                    this.scroll('right');
+                    break;
+                case (data == 0x16): // SCROLL UP
+                    this.scroll('up');
+                    break;
+                case (data == 0x17): // SCROLL DOWN
+                    this.scroll('down');
+                    break;
+                case (data == 0x18): // FOREGROUND COLOR
+                    this.foregroundColorNextByte = true;
+                    break;
+                case (data == 0x19): // BACKGROUND COLOR
+                    this.backgroundColorNextByte = true;
+                    break;
+                case (data == 0x1A): // NEXT BYTE AS DATA
+                    this.dataNextByte = true;
+                    break;
+                case (data == 0x1B): // ESCAPE
+                    // Reserved for future ANSI escape code handling
+                    break;
+                case (data == 0x1C): // CURSOR LEFT
+                    this.cursor('left');
+                    break;
+                case (data == 0x1D): // CURSOR RIGHT
+                    this.cursor('right');
+                    break;
+                case (data == 0x1E): // CURSOR UP
+                    this.cursor('up');
+                    break;
+                case (data == 0x1F): // CURSOR DOWN
+                    this.cursor('down');
+                    break;
+                case (data >= 0x20 && data <= 0x7E): // ASCII CHARACTERS
+                    this.data(data);
+                    break;
+                case (data == 0x7F): // DELETE
+                    this.delete();
+                    break;
+                case (data >= 0x80 && data <= 0xFF): // EXTENDED CHARACTERS
+                    this.data(data);
+                    break;
+                default:
+                    break;
+            }
+        };
+        this.transmit = (data) => {
+            var _a;
+            (_a = this.port) === null || _a === void 0 ? void 0 : _a.write([data], 'hex', (err) => {
+                if (err) {
+                    console.log('Error: ', err.message);
+                }
+            });
+        };
+        this.receive = (data) => {
+            for (let i = 0; i < data.length; i++) {
+                this.parse(data[i]);
+            }
+        };
+        this.onKey = (event) => {
+            switch (event.key) {
+                case 'backspace':
+                    this.transmit(0x08);
+                    break;
+                case 'tab':
+                    this.transmit(0x09);
+                    break;
+                case 'enter':
+                case 'return':
+                    this.transmit(0x0D);
+                    this.transmit(0x0A);
+                    break;
+                case 'escape':
+                    this.transmit(0x1B);
+                    break;
+                case 'left':
+                    this.transmit(0x1C);
+                    break;
+                case 'right':
+                    this.transmit(0x1D);
+                    break;
+                case 'up':
+                    this.transmit(0x1E);
+                    break;
+                case 'down':
+                    this.transmit(0x1F);
+                    break;
+                case 'delete':
+                    this.transmit(0x7F);
+                    break;
+                default:
+                    break;
+            }
+        };
+        this.onText = (event) => {
+            switch (event.text) {
+                case ' ':
+                    this.transmit(0x20);
+                    break;
+                case '!':
+                    this.transmit(0x21);
+                    break;
+                case '"':
+                    this.transmit(0x22);
+                    break;
+                case '#':
+                    this.transmit(0x23);
+                    break;
+                case '$':
+                    this.transmit(0x24);
+                    break;
+                case '%':
+                    this.transmit(0x25);
+                    break;
+                case '&':
+                    this.transmit(0x26);
+                    break;
+                case '\'':
+                    this.transmit(0x27);
+                    break;
+                case '(':
+                    this.transmit(0x28);
+                    break;
+                case ')':
+                    this.transmit(0x29);
+                    break;
+                case '*':
+                    this.transmit(0x2A);
+                    break;
+                case '+':
+                    this.transmit(0x2B);
+                    break;
+                case ',':
+                    this.transmit(0x2C);
+                    break;
+                case '-':
+                    this.transmit(0x2D);
+                    break;
+                case '.':
+                    this.transmit(0x2E);
+                    break;
+                case '/':
+                    this.transmit(0x2F);
+                    break;
+                case '0':
+                    this.transmit(0x30);
+                    break;
+                case '1':
+                    this.transmit(0x31);
+                    break;
+                case '2':
+                    this.transmit(0x32);
+                    break;
+                case '3':
+                    this.transmit(0x33);
+                    break;
+                case '4':
+                    this.transmit(0x34);
+                    break;
+                case '5':
+                    this.transmit(0x35);
+                    break;
+                case '6':
+                    this.transmit(0x36);
+                    break;
+                case '7':
+                    this.transmit(0x37);
+                    break;
+                case '8':
+                    this.transmit(0x38);
+                    break;
+                case '9':
+                    this.transmit(0x39);
+                    break;
+                case ':':
+                    this.transmit(0x3A);
+                    break;
+                case ';':
+                    this.transmit(0x3B);
+                    break;
+                case '<':
+                    this.transmit(0x3C);
+                    break;
+                case '=':
+                    this.transmit(0x3D);
+                    break;
+                case '>':
+                    this.transmit(0x3E);
+                    break;
+                case '?':
+                    this.transmit(0x3F);
+                    break;
+                case '@':
+                    this.transmit(0x40);
+                    break;
+                case 'A':
+                    this.transmit(0x41);
+                    break;
+                case 'B':
+                    this.transmit(0x42);
+                    break;
+                case 'C':
+                    this.transmit(0x43);
+                    break;
+                case 'D':
+                    this.transmit(0x44);
+                    break;
+                case 'E':
+                    this.transmit(0x45);
+                    break;
+                case 'F':
+                    this.transmit(0x46);
+                    break;
+                case 'G':
+                    this.transmit(0x47);
+                    break;
+                case 'H':
+                    this.transmit(0x48);
+                    break;
+                case 'I':
+                    this.transmit(0x49);
+                    break;
+                case 'J':
+                    this.transmit(0x4A);
+                    break;
+                case 'K':
+                    this.transmit(0x4B);
+                    break;
+                case 'L':
+                    this.transmit(0x4C);
+                    break;
+                case 'M':
+                    this.transmit(0x4D);
+                    break;
+                case 'N':
+                    this.transmit(0x4E);
+                    break;
+                case 'O':
+                    this.transmit(0x4F);
+                    break;
+                case 'P':
+                    this.transmit(0x50);
+                    break;
+                case 'Q':
+                    this.transmit(0x51);
+                    break;
+                case 'R':
+                    this.transmit(0x52);
+                    break;
+                case 'S':
+                    this.transmit(0x53);
+                    break;
+                case 'T':
+                    this.transmit(0x54);
+                    break;
+                case 'U':
+                    this.transmit(0x55);
+                    break;
+                case 'V':
+                    this.transmit(0x56);
+                    break;
+                case 'W':
+                    this.transmit(0x57);
+                    break;
+                case 'X':
+                    this.transmit(0x58);
+                    break;
+                case 'Y':
+                    this.transmit(0x59);
+                    break;
+                case 'Z':
+                    this.transmit(0x5A);
+                    break;
+                case '[':
+                    this.transmit(0x5B);
+                    break;
+                case '\\':
+                    this.transmit(0x5C);
+                    break;
+                case ']':
+                    this.transmit(0x5D);
+                    break;
+                case '^':
+                    this.transmit(0x5E);
+                    break;
+                case '_':
+                    this.transmit(0x5F);
+                    break;
+                case '`':
+                    this.transmit(0x60);
+                    break;
+                case 'a':
+                    this.transmit(0x61);
+                    break;
+                case 'b':
+                    this.transmit(0x62);
+                    break;
+                case 'c':
+                    this.transmit(0x63);
+                    break;
+                case 'd':
+                    this.transmit(0x64);
+                    break;
+                case 'e':
+                    this.transmit(0x65);
+                    break;
+                case 'f':
+                    this.transmit(0x66);
+                    break;
+                case 'g':
+                    this.transmit(0x67);
+                    break;
+                case 'h':
+                    this.transmit(0x68);
+                    break;
+                case 'i':
+                    this.transmit(0x69);
+                    break;
+                case 'j':
+                    this.transmit(0x6A);
+                    break;
+                case 'k':
+                    this.transmit(0x6B);
+                    break;
+                case 'l':
+                    this.transmit(0x6C);
+                    break;
+                case 'm':
+                    this.transmit(0x6D);
+                    break;
+                case 'n':
+                    this.transmit(0x6E);
+                    break;
+                case 'o':
+                    this.transmit(0x6F);
+                    break;
+                case 'p':
+                    this.transmit(0x70);
+                    break;
+                case 'q':
+                    this.transmit(0x71);
+                    break;
+                case 'r':
+                    this.transmit(0x72);
+                    break;
+                case 's':
+                    this.transmit(0x73);
+                    break;
+                case 't':
+                    this.transmit(0x74);
+                    break;
+                case 'u':
+                    this.transmit(0x75);
+                    break;
+                case 'v':
+                    this.transmit(0x76);
+                    break;
+                case 'w':
+                    this.transmit(0x77);
+                    break;
+                case 'x':
+                    this.transmit(0x78);
+                    break;
+                case 'y':
+                    this.transmit(0x79);
+                    break;
+                case 'z':
+                    this.transmit(0x7A);
+                    break;
+                case '{':
+                    this.transmit(0x7B);
+                    break;
+                case '|':
+                    this.transmit(0x7C);
+                    break;
+                case '}':
+                    this.transmit(0x7D);
+                    break;
+                case '~':
+                    this.transmit(0x7E);
+                    break;
+                default:
+                    break;
+            }
+        };
+    }
+}
+exports.VTAC = VTAC;
+VTAC.COLUMNS = 40;
+VTAC.ROWS = 30;
+VTAC.WIDTH = VTAC.COLUMNS * 8;
+VTAC.HEIGHT = VTAC.ROWS * 8;
+VTAC.CHARACTERS = [
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], // [] (0)
+    [0x7e, 0x81, 0xa5, 0x81, 0xbd, 0x99, 0x81, 0x7e], // [☺] (1)
+    [0x7e, 0xff, 0xdb, 0xff, 0xc3, 0xe7, 0xff, 0x7e], // [☻] (2)
+    [0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00], // [♥] (3)
+    [0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00], // [♦] (4)
+    [0x38, 0x7c, 0x38, 0xfe, 0xfe, 0x7c, 0x38, 0x7c], // [♣] (5)
+    [0x10, 0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x7c], // [♠] (6)
+    [0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00], // [•] (7)
+    [0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff], // [◘] (8)
+    [0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00], // [○] (9)
+    [0xff, 0xc3, 0x99, 0xbd, 0xbd, 0x99, 0xc3, 0xff], // [◙] (10)
+    [0x0f, 0x07, 0x0f, 0x7d, 0xcc, 0xcc, 0xcc, 0x78], // [♂] (11)
+    [0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18], // [♀] (12)
+    [0x3f, 0x33, 0x3f, 0x30, 0x30, 0x70, 0xf0, 0xe0], // [♪] (13)
+    [0x7f, 0x63, 0x7f, 0x63, 0x63, 0x67, 0xe6, 0xc0], // [♫] (14)
+    [0x99, 0x5a, 0x3c, 0xe7, 0xe7, 0x3c, 0x5a, 0x99], // [☼] (15)
+    [0x80, 0xe0, 0xf8, 0xfe, 0xf8, 0xe0, 0x80, 0x00], // [►] (16)
+    [0x02, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x02, 0x00], // [◄] (17)
+    [0x18, 0x3c, 0x7e, 0x18, 0x18, 0x7e, 0x3c, 0x18], // [↕] (18)
+    [0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00], // [‼] (19)
+    [0x7f, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x00], // [¶] (20)
+    [0x3e, 0x63, 0x38, 0x6c, 0x6c, 0x38, 0xcc, 0x78], // [§] (21)
+    [0x00, 0x00, 0x00, 0x00, 0x7e, 0x7e, 0x7e, 0x00], // [▬] (22)
+    [0x18, 0x3c, 0x7e, 0x18, 0x7e, 0x3c, 0x18, 0xff], // [↨] (23)
+    [0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x00], // [↑] (24)
+    [0x18, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00], // [↓] (25)
+    [0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00], // [→] (26)
+    [0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00], // [←] (27)
+    [0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00], // [∟] (28)
+    [0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00], // [↔] (29)
+    [0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x00, 0x00], // [▲] (30)
+    [0x00, 0xff, 0xff, 0x7e, 0x3c, 0x18, 0x00, 0x00], // [▼] (31)
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], // [ ] (32)
+    [0x30, 0x78, 0x78, 0x30, 0x30, 0x00, 0x30, 0x00], // [!] (33)
+    [0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00], // ["] (34)
+    [0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00], // [#] (35)
+    [0x30, 0x7c, 0xc0, 0x78, 0x0c, 0xf8, 0x30, 0x00], // [$] (36)
+    [0x00, 0xc6, 0xcc, 0x18, 0x30, 0x66, 0xc6, 0x00], // [%] (37)
+    [0x38, 0x6c, 0x38, 0x76, 0xdc, 0xcc, 0x76, 0x00], // [&] (38)
+    [0x60, 0x60, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00], // ['] (39)
+    [0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00], // [(] (40)
+    [0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00], // [)] (41)
+    [0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00], // [*] (42)
+    [0x00, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x00, 0x00], // [+] (43)
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x60], // [,] (44)
+    [0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00], // [-] (45)
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00], // [.] (46)
+    [0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80, 0x00], // [/] (47)
+    [0x7c, 0xc6, 0xce, 0xde, 0xf6, 0xe6, 0x7c, 0x00], // [0] (48)
+    [0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x00], // [1] (49)
+    [0x78, 0xcc, 0x0c, 0x38, 0x60, 0xcc, 0xfc, 0x00], // [2] (50)
+    [0x78, 0xcc, 0x0c, 0x38, 0x0c, 0xcc, 0x78, 0x00], // [3] (51)
+    [0x1c, 0x3c, 0x6c, 0xcc, 0xfe, 0x0c, 0x1e, 0x00], // [4] (52)
+    [0xfc, 0xc0, 0xf8, 0x0c, 0x0c, 0xcc, 0x78, 0x00], // [5] (53)
+    [0x38, 0x60, 0xc0, 0xf8, 0xcc, 0xcc, 0x78, 0x00], // [6] (54)
+    [0xfc, 0xcc, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x00], // [7] (55)
+    [0x78, 0xcc, 0xcc, 0x78, 0xcc, 0xcc, 0x78, 0x00], // [8] (56)
+    [0x78, 0xcc, 0xcc, 0x7c, 0x0c, 0x18, 0x70, 0x00], // [9] (57)
+    [0x00, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x00], // [:] (58)
+    [0x00, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x60], // [;] (59)
+    [0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x00], // [<] (60)
+    [0x00, 0x00, 0xfc, 0x00, 0x00, 0xfc, 0x00, 0x00], // [=] (61)
+    [0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00], // [>] (62)
+    [0x78, 0xcc, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00], // [?] (63)
+    [0x7c, 0xc6, 0xde, 0xde, 0xde, 0xc0, 0x78, 0x00], // [@] (64)
+    [0x30, 0x78, 0xcc, 0xcc, 0xfc, 0xcc, 0xcc, 0x00], // [A] (65)
+    [0xfc, 0x66, 0x66, 0x7c, 0x66, 0x66, 0xfc, 0x00], // [B] (66)
+    [0x3c, 0x66, 0xc0, 0xc0, 0xc0, 0x66, 0x3c, 0x00], // [C] (67)
+    [0xf8, 0x6c, 0x66, 0x66, 0x66, 0x6c, 0xf8, 0x00], // [D] (68)
+    [0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0xfe, 0x00], // [E] (69)
+    [0xfe, 0x62, 0x68, 0x78, 0x68, 0x60, 0xf0, 0x00], // [F] (70)
+    [0x3c, 0x66, 0xc0, 0xc0, 0xce, 0x66, 0x3e, 0x00], // [G] (71)
+    [0xcc, 0xcc, 0xcc, 0xfc, 0xcc, 0xcc, 0xcc, 0x00], // [H] (72)
+    [0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00], // [I] (73)
+    [0x1e, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00], // [J] (74)
+    [0xe6, 0x66, 0x6c, 0x78, 0x6c, 0x66, 0xe6, 0x00], // [K] (75)
+    [0xf0, 0x60, 0x60, 0x60, 0x62, 0x66, 0xfe, 0x00], // [L] (76)
+    [0xc6, 0xee, 0xfe, 0xfe, 0xd6, 0xc6, 0xc6, 0x00], // [M] (77)
+    [0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00], // [N] (78)
+    [0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00], // [O] (79)
+    [0xfc, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00], // [P] (80)
+    [0x78, 0xcc, 0xcc, 0xcc, 0xdc, 0x78, 0x1c, 0x00], // [Q] (81)
+    [0xfc, 0x66, 0x66, 0x7c, 0x6c, 0x66, 0xe6, 0x00], // [R] (82)
+    [0x78, 0xcc, 0xe0, 0x70, 0x1c, 0xcc, 0x78, 0x00], // [S] (83)
+    [0xfc, 0xb4, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00], // [T] (84)
+    [0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xfc, 0x00], // [U] (85)
+    [0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x00], // [V] (86)
+    [0xc6, 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x00], // [W] (87)
+    [0xc6, 0xc6, 0x6c, 0x38, 0x38, 0x6c, 0xc6, 0x00], // [X] (88)
+    [0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x30, 0x78, 0x00], // [Y] (89)
+    [0xfe, 0xc6, 0x8c, 0x18, 0x32, 0x66, 0xfe, 0x00], // [Z] (90)
+    [0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x78, 0x00], // [[] (91)
+    [0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x02, 0x00], // [\] (92)
+    [0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00], // []] (93)
+    [0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00], // [^] (94)
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff], // [_] (95)
+    [0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00], // [`] (96)
+    [0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00], // [a] (97)
+    [0xe0, 0x60, 0x60, 0x7c, 0x66, 0x66, 0xdc, 0x00], // [b] (98)
+    [0x00, 0x00, 0x78, 0xcc, 0xc0, 0xcc, 0x78, 0x00], // [c] (99)
+    [0x1c, 0x0c, 0x0c, 0x7c, 0xcc, 0xcc, 0x76, 0x00], // [d] (100)
+    [0x00, 0x00, 0x78, 0xcc, 0xfc, 0xc0, 0x78, 0x00], // [e] (101)
+    [0x38, 0x6c, 0x60, 0xf0, 0x60, 0x60, 0xf0, 0x00], // [f] (102)
+    [0x00, 0x00, 0x76, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8], // [g] (103)
+    [0xe0, 0x60, 0x6c, 0x76, 0x66, 0x66, 0xe6, 0x00], // [h] (104)
+    [0x30, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00], // [i] (105)
+    [0x0c, 0x00, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78], // [j] (106)
+    [0xe0, 0x60, 0x66, 0x6c, 0x78, 0x6c, 0xe6, 0x00], // [k] (107)
+    [0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00], // [l] (108)
+    [0x00, 0x00, 0xcc, 0xfe, 0xfe, 0xd6, 0xc6, 0x00], // [m] (109)
+    [0x00, 0x00, 0xf8, 0xcc, 0xcc, 0xcc, 0xcc, 0x00], // [n] (110)
+    [0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x00], // [o] (111)
+    [0x00, 0x00, 0xdc, 0x66, 0x66, 0x7c, 0x60, 0xf0], // [p] (112)
+    [0x00, 0x00, 0x76, 0xcc, 0xcc, 0x7c, 0x0c, 0x1e], // [q] (113)
+    [0x00, 0x00, 0xdc, 0x76, 0x66, 0x60, 0xf0, 0x00], // [r] (114)
+    [0x00, 0x00, 0x7c, 0xc0, 0x78, 0x0c, 0xf8, 0x00], // [s] (115)
+    [0x10, 0x30, 0x7c, 0x30, 0x30, 0x34, 0x18, 0x00], // [t] (116)
+    [0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00], // [u] (117)
+    [0x00, 0x00, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x00], // [v] (118)
+    [0x00, 0x00, 0xc6, 0xd6, 0xfe, 0xfe, 0x6c, 0x00], // [w] (119)
+    [0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00], // [x] (120)
+    [0x00, 0x00, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8], // [y] (121)
+    [0x00, 0x00, 0xfc, 0x98, 0x30, 0x64, 0xfc, 0x00], // [z] (122)
+    [0x1c, 0x30, 0x30, 0xe0, 0x30, 0x30, 0x1c, 0x00], // [{] (123)
+    [0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00], // [|] (124)
+    [0xe0, 0x30, 0x30, 0x1c, 0x30, 0x30, 0xe0, 0x00], // [}] (125)
+    [0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], // [~] (126)
+    [0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0x00], // [⌂] (127)
+    [0x78, 0xcc, 0xc0, 0xcc, 0x78, 0x18, 0x0c, 0x78], // [Ç] (128)
+    [0x00, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0x7e, 0x00], // [ü] (129)
+    [0x1c, 0x00, 0x78, 0xcc, 0xfc, 0xc0, 0x78, 0x00], // [é] (130)
+    [0x7e, 0xc3, 0x3c, 0x06, 0x3e, 0x66, 0x3f, 0x00], // [â] (131)
+    [0xcc, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x7e, 0x00], // [ä] (132)
+    [0xe0, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x7e, 0x00], // [à] (133)
+    [0x30, 0x30, 0x78, 0x0c, 0x7c, 0xcc, 0x7e, 0x00], // [å] (134)
+    [0x00, 0x00, 0x78, 0xc0, 0xc0, 0x78, 0x0c, 0x38], // [ç] (135)
+    [0x7e, 0xc3, 0x3c, 0x66, 0x7e, 0x60, 0x3c, 0x00], // [ê] (136)
+    [0xcc, 0x00, 0x78, 0xcc, 0xfc, 0xc0, 0x78, 0x00], // [ë] (137)
+    [0xe0, 0x00, 0x78, 0xcc, 0xfc, 0xc0, 0x78, 0x00], // [è] (138)
+    [0xcc, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00], // [ï] (139)
+    [0x7c, 0xc6, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00], // [î] (140)
+    [0xe0, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00], // [ì] (141)
+    [0xc6, 0x38, 0x6c, 0xc6, 0xfe, 0xc6, 0xc6, 0x00], // [Ä] (142)
+    [0x30, 0x30, 0x00, 0x78, 0xcc, 0xfc, 0xcc, 0x00], // [Å] (143)
+    [0x1c, 0x00, 0xfc, 0x60, 0x78, 0x60, 0xfc, 0x00], // [É] (144)
+    [0x00, 0x00, 0x7f, 0x0c, 0x7f, 0xcc, 0x7f, 0x00], // [æ] (145)
+    [0x3e, 0x6c, 0xcc, 0xfe, 0xcc, 0xcc, 0xce, 0x00], // [Æ] (146)
+    [0x78, 0xcc, 0x00, 0x78, 0xcc, 0xcc, 0x78, 0x00], // [ô] (147)
+    [0x00, 0xcc, 0x00, 0x78, 0xcc, 0xcc, 0x78, 0x00], // [ö] (148)
+    [0x00, 0xe0, 0x00, 0x78, 0xcc, 0xcc, 0x78, 0x00], // [ò] (149)
+    [0x78, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0x7e, 0x00], // [û] (150)
+    [0x00, 0xe0, 0x00, 0xcc, 0xcc, 0xcc, 0x7e, 0x00], // [ù] (151)
+    [0x00, 0xcc, 0x00, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8], // [ÿ] (152)
+    [0xc3, 0x18, 0x3c, 0x66, 0x66, 0x3c, 0x18, 0x00], // [Ö] (153)
+    [0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00], // [Ü] (154)
+    [0x18, 0x18, 0x7e, 0xc0, 0xc0, 0x7e, 0x18, 0x18], // [¢] (155)
+    [0x38, 0x6c, 0x64, 0xf0, 0x60, 0xe6, 0xfc, 0x00], // [£] (156)
+    [0xcc, 0xcc, 0x78, 0xfc, 0x30, 0xfc, 0x30, 0x30], // [¥] (157)
+    [0xf8, 0xcc, 0xcc, 0xfa, 0xc6, 0xcf, 0xc6, 0xc7], // [₧] (158)
+    [0x0e, 0x1b, 0x18, 0x3c, 0x18, 0x18, 0xd8, 0x70], // [ƒ] (159)
+    [0x1c, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x7e, 0x00], // [á] (160)
+    [0x38, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00], // [í] (161)
+    [0x00, 0x1c, 0x00, 0x78, 0xcc, 0xcc, 0x78, 0x00], // [ó] (162)
+    [0x00, 0x1c, 0x00, 0xcc, 0xcc, 0xcc, 0x7e, 0x00], // [ú] (163)
+    [0x00, 0xf8, 0x00, 0xf8, 0xcc, 0xcc, 0xcc, 0x00], // [ñ] (164)
+    [0xfc, 0x00, 0xcc, 0xec, 0xfc, 0xdc, 0xcc, 0x00], // [Ñ] (165)
+    [0x3c, 0x6c, 0x6c, 0x3e, 0x00, 0x7e, 0x00, 0x00], // [ª] (166)
+    [0x38, 0x6c, 0x6c, 0x38, 0x00, 0x7c, 0x00, 0x00], // [º] (167)
+    [0x30, 0x00, 0x30, 0x60, 0xc0, 0xcc, 0x78, 0x00], // [¿] (168)
+    [0x00, 0x00, 0x00, 0xfc, 0xc0, 0xc0, 0x00, 0x00], // [⌐] (169)
+    [0x00, 0x00, 0x00, 0xfc, 0x0c, 0x0c, 0x00, 0x00], // [¬] (170)
+    [0xc3, 0xc6, 0xcc, 0xde, 0x33, 0x66, 0xcc, 0x0f], // [½] (171)
+    [0xc3, 0xc6, 0xcc, 0xdb, 0x37, 0x6f, 0xcf, 0x03], // [¼] (172)
+    [0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00], // [¡] (173)
+    [0x00, 0x33, 0x66, 0xcc, 0x66, 0x33, 0x00, 0x00], // [«] (174)
+    [0x00, 0xcc, 0x66, 0x33, 0x66, 0xcc, 0x00, 0x00], // [»] (175)
+    [0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88], // [░] (176)
+    [0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa], // [▒] (177)
+    [0xdb, 0x77, 0xdb, 0xee, 0xdb, 0x77, 0xdb, 0xee], // [▓] (178)
+    [0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18], // [│] (179)
+    [0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18], // [┤] (180)
+    [0x18, 0x18, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18], // [╡] (181)
+    [0x36, 0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36], // [╢] (182)
+    [0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36], // [╖] (183)
+    [0x00, 0x00, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18], // [╕] (184)
+    [0x36, 0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36], // [╣] (185)
+    [0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36], // [║] (186)
+    [0x00, 0x00, 0xfe, 0x06, 0xf6, 0x36, 0x36, 0x36], // [╗] (187)
+    [0x36, 0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x00], // [╝] (188)
+    [0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00], // [╜] (189)
+    [0x18, 0x18, 0xf8, 0x18, 0xf8, 0x00, 0x00, 0x00], // [╛] (190)
+    [0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18], // [┐] (191)
+    [0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00], // [└] (192)
+    [0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0x00, 0x00], // [┴] (193)
+    [0x00, 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18], // [┬] (194)
+    [0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18], // [├] (195)
+    [0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00], // [─] (196)
+    [0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18], // [┼] (197)
+    [0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18], // [╞] (198)
+    [0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36], // [╟] (199)
+    [0x36, 0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00], // [╚] (200)
+    [0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36, 0x36], // [╔] (201)
+    [0x36, 0x36, 0xf7, 0x00, 0xff, 0x00, 0x00, 0x00], // [╩] (202)
+    [0x00, 0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36], // [╦] (203)
+    [0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36], // [╠] (204)
+    [0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00], // [═] (205)
+    [0x36, 0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36], // [╬] (206)
+    [0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00], // [╧] (207)
+    [0x36, 0x36, 0x36, 0x36, 0xff, 0x00, 0x00, 0x00], // [╨] (208)
+    [0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18], // [╤] (209)
+    [0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36], // [╥] (210)
+    [0x36, 0x36, 0x36, 0x36, 0x3f, 0x00, 0x00, 0x00], // [╙] (211)
+    [0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00], // [╘] (212)
+    [0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18], // [╒] (213)
+    [0x00, 0x00, 0x00, 0x00, 0x3f, 0x36, 0x36, 0x36], // [╓] (214)
+    [0x36, 0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36], // [╫] (215)
+    [0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18], // [╪] (216)
+    [0x18, 0x18, 0x18, 0x18, 0xf8, 0x00, 0x00, 0x00], // [┘] (217)
+    [0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18], // [┌] (218)
+    [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], // [█] (219)
+    [0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff], // [▄] (220)
+    [0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0], // [▌] (221)
+    [0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f], // [▐] (222)
+    [0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00], // [▀] (223)
+    [0x00, 0x00, 0x76, 0xdc, 0xc8, 0xdc, 0x76, 0x00], // [α] (224)
+    [0x00, 0x78, 0xcc, 0xf8, 0xcc, 0xf8, 0xc0, 0xc0], // [ß] (225)
+    [0x00, 0xfc, 0xcc, 0xc0, 0xc0, 0xc0, 0xc0, 0x00], // [Γ] (226)
+    [0x00, 0xfe, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00], // [π] (227)
+    [0xfc, 0xcc, 0x60, 0x30, 0x60, 0xcc, 0xfc, 0x00], // [Σ] (228)
+    [0x00, 0x00, 0x7e, 0xd8, 0xd8, 0xd8, 0x70, 0x00], // [σ] (229)
+    [0x00, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x60, 0xc0], // [µ] (230)
+    [0x00, 0x76, 0xdc, 0x18, 0x18, 0x18, 0x18, 0x00], // [τ] (231)
+    [0xfc, 0x30, 0x78, 0xcc, 0xcc, 0x78, 0x30, 0xfc], // [Φ] (232)
+    [0x38, 0x6c, 0xc6, 0xfe, 0xc6, 0x6c, 0x38, 0x00], // [Θ] (233)
+    [0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x6c, 0xee, 0x00], // [Ω] (234)
+    [0x1c, 0x30, 0x18, 0x7c, 0xcc, 0xcc, 0x78, 0x00], // [δ] (235)
+    [0x00, 0x00, 0x7e, 0xdb, 0xdb, 0x7e, 0x00, 0x00], // [∞] (236)
+    [0x06, 0x0c, 0x7e, 0xdb, 0xdb, 0x7e, 0x60, 0xc0], // [φ] (237)
+    [0x38, 0x60, 0xc0, 0xf8, 0xc0, 0x60, 0x38, 0x00], // [ε] (238)
+    [0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x00], // [∩] (239)
+    [0x00, 0xfc, 0x00, 0xfc, 0x00, 0xfc, 0x00, 0x00], // [≡] (240)
+    [0x30, 0x30, 0xfc, 0x30, 0x30, 0x00, 0xfc, 0x00], // [±] (241)
+    [0x60, 0x30, 0x18, 0x30, 0x60, 0x00, 0xfc, 0x00], // [≥] (242)
+    [0x18, 0x30, 0x60, 0x30, 0x18, 0x00, 0xfc, 0x00], // [≤] (243)
+    [0x0e, 0x1b, 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18], // [⌠] (244)
+    [0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70], // [⌡] (245)
+    [0x30, 0x30, 0x00, 0xfc, 0x00, 0x30, 0x30, 0x00], // [÷] (246)
+    [0x00, 0x76, 0xdc, 0x00, 0x76, 0xdc, 0x00, 0x00], // [≈] (247)
+    [0x38, 0x6c, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00], // [°] (248)
+    [0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00], // [∙] (249)
+    [0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00], // [·] (250)
+    [0x0f, 0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x3c, 0x1c], // [√] (251)
+    [0x78, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00], // [ⁿ] (252)
+    [0x70, 0x18, 0x30, 0x60, 0x78, 0x00, 0x00, 0x00], // [²] (253)
+    [0x00, 0x00, 0x3c, 0x3c, 0x3c, 0x3c, 0x00, 0x00], // [■] (254)
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], // [ ] (255)
+];
+//# sourceMappingURL=VTAC.js.map