@flowscripter/dynamic-cli-framework 1.7.2 → 1.7.4

package/dist/src/service/tableGenerator/DefaultTableGeneratorService.js

@@ -0,0 +1,344 @@
+import { Align } from "../../api/service/core/TableGeneratorService.js";
+import Table from "../../api/service/core/Table.js";
+const BORDER_TOP_LEFT = "┌";
+const BORDER_TOP = "─";
+const BORDER_TOP_MIDDLE = "┬";
+const BORDER_TOP_RIGHT = "┐";
+const BORDER_LEFT = "│";
+const BORDER_MIDDLE_VERTICAL = "│";
+const BORDER_RIGHT = "│";
+const BORDER_LEFT_MIDDLE = "├";
+const BORDER_MIDDLE = "─";
+const BORDER_MIDDLE_MIDDLE = "┼";
+const BORDER_RIGHT_MIDDLE = "┤";
+const BORDER_BOTTOM_LEFT = "└";
+const BORDER_BOTTOM = "─";
+const BORDER_BOTTOM_MIDDLE = "┴";
+const BORDER_BOTTOM_RIGHT = "┘";
+export default class DefaultTableGeneratorService {
+    colorEnabled = true;
+    colorFunction = (text) => text;
+    backgroundColorFunction = (text) => text;
+    createTable(rowCount, columnCount, options) {
+        return new Table(rowCount, columnCount, options);
+    }
+    #resolveAlign(table, rowIndex, columnIndex) {
+        const cellOpts = table.getCell(rowIndex, columnIndex)?.options;
+        if (cellOpts?.align !== undefined)
+            return cellOpts.align;
+        const rowOpts = table.getRowOptions(rowIndex);
+        if (rowOpts?.align !== undefined)
+            return rowOpts.align;
+        const colOpts = table.getColumnOptions(columnIndex);
+        if (colOpts?.align !== undefined)
+            return colOpts.align;
+        return table.options.align ?? Align.LEFT;
+    }
+    #calculateColumnWidths(table) {
+        const border = table.options.border !== false;
+        const padding = table.options.padding ?? 1;
+        const maxWidth = table.options.maxWidth ?? 80;
+        const borderOverhead = border ? table.columnCount + 1 : Math.max(table.columnCount - 1, 0);
+        const paddingOverhead = table.columnCount * 2 * padding;
+        const contentBudget = Math.max(maxWidth - borderOverhead - paddingOverhead, table.columnCount);
+        const naturalWidths = [];
+        for (let col = 0; col < table.columnCount; col++) {
+            let maxCellWidth = 0;
+            for (let row = 0; row < table.rowCount; row++) {
+                const cell = table.getCell(row, col);
+                if (cell) {
+                    const lines = cell.contents.split("\n");
+                    for (const line of lines) {
+                        const w = Bun.stringWidth(line);
+                        if (w > maxCellWidth)
+                            maxCellWidth = w;
+                    }
+                }
+            }
+            const colOpts = table.getColumnOptions(col);
+            if (colOpts?.minWidth !== undefined && maxCellWidth < colOpts.minWidth) {
+                maxCellWidth = colOpts.minWidth;
+            }
+            if (colOpts?.maxWidth !== undefined && maxCellWidth > colOpts.maxWidth) {
+                maxCellWidth = colOpts.maxWidth;
+            }
+            naturalWidths.push(maxCellWidth);
+        }
+        const totalNatural = naturalWidths.reduce((a, b) => a + b, 0);
+        if (totalNatural <= contentBudget) {
+            const surplus = contentBudget - totalNatural;
+            const totalFlexWeight = this.#sumFlexWeights(table);
+            if (surplus > 0 && totalFlexWeight > 0) {
+                this.#distributeGrow(table, naturalWidths, surplus, totalFlexWeight);
+            }
+        }
+        else {
+            const excess = totalNatural - contentBudget;
+            this.#distributeShrink(table, naturalWidths, excess);
+        }
+        return naturalWidths;
+    }
+    #sumFlexWeights(table) {
+        let total = 0;
+        for (let col = 0; col < table.columnCount; col++) {
+            const colOpts = table.getColumnOptions(col);
+            total += colOpts?.flexWeight ?? 0;
+        }
+        return total;
+    }
+    #distributeGrow(table, widths, surplus, totalFlexWeight) {
+        let remaining = surplus;
+        for (let col = 0; col < table.columnCount; col++) {
+            const colOpts = table.getColumnOptions(col);
+            const weight = colOpts?.flexWeight ?? 0;
+            if (weight <= 0)
+                continue;
+            const share = Math.floor((weight / totalFlexWeight) * surplus);
+            let newWidth = widths[col] + share;
+            if (colOpts?.maxWidth !== undefined && newWidth > colOpts.maxWidth) {
+                newWidth = colOpts.maxWidth;
+            }
+            const added = newWidth - widths[col];
+            widths[col] = newWidth;
+            remaining -= added;
+        }
+        // distribute any rounding remainder to first flex column
+        if (remaining > 0) {
+            for (let col = 0; col < table.columnCount; col++) {
+                const colOpts = table.getColumnOptions(col);
+                if ((colOpts?.flexWeight ?? 0) > 0) {
+                    let newWidth = widths[col] + remaining;
+                    if (colOpts?.maxWidth !== undefined && newWidth > colOpts.maxWidth) {
+                        newWidth = colOpts.maxWidth;
+                    }
+                    widths[col] = newWidth;
+                    break;
+                }
+            }
+        }
+    }
+    #distributeShrink(table, widths, excess) {
+        let remaining = excess;
+        const shrinkable = new Set();
+        for (let col = 0; col < table.columnCount; col++) {
+            const colOpts = table.getColumnOptions(col);
+            if ((colOpts?.flexWeight ?? 0) > 0) {
+                shrinkable.add(col);
+            }
+        }
+        while (remaining > 0 && shrinkable.size > 0) {
+            let totalWeightedWidth = 0;
+            for (const col of shrinkable) {
+                const colOpts = table.getColumnOptions(col);
+                totalWeightedWidth += (colOpts?.flexWeight ?? 0) * widths[col];
+            }
+            if (totalWeightedWidth <= 0)
+                break;
+            let shrank = false;
+            for (const col of shrinkable) {
+                if (remaining <= 0)
+                    break;
+                const colOpts = table.getColumnOptions(col);
+                const weight = colOpts?.flexWeight ?? 0;
+                const share = Math.max(1, Math.floor(((weight * widths[col]) / totalWeightedWidth) * remaining));
+                const minWidth = colOpts?.minWidth ?? 1;
+                const maxShrink = widths[col] - minWidth;
+                if (maxShrink <= 0) {
+                    shrinkable.delete(col);
+                    continue;
+                }
+                const actual = Math.min(share, maxShrink);
+                widths[col] = widths[col] - actual;
+                remaining -= actual;
+                shrank = true;
+                if (widths[col] <= minWidth) {
+                    shrinkable.delete(col);
+                }
+            }
+            if (!shrank)
+                break;
+        }
+    }
+    #wrapLine(line, width) {
+        if (width <= 0)
+            return [line];
+        if (Bun.stringWidth(line) <= width)
+            return [line];
+        const wrapped = [];
+        const words = line.split(/(\s+)/);
+        let currentLine = "";
+        let currentWidth = 0;
+        for (const word of words) {
+            const wordWidth = Bun.stringWidth(word);
+            if (currentWidth === 0) {
+                if (wordWidth <= width) {
+                    currentLine = word;
+                    currentWidth = wordWidth;
+                }
+                else {
+                    this.#hardBreak(word, width, wrapped);
+                    currentLine = "";
+                    currentWidth = 0;
+                    if (wrapped.length > 0) {
+                        const last = wrapped[wrapped.length - 1];
+                        if (Bun.stringWidth(last) < width) {
+                            currentLine = wrapped.pop();
+                            currentWidth = Bun.stringWidth(currentLine);
+                        }
+                    }
+                }
+            }
+            else if (currentWidth + wordWidth <= width) {
+                currentLine += word;
+                currentWidth += wordWidth;
+            }
+            else {
+                wrapped.push(currentLine);
+                const trimmed = word.replace(/^\s+/, "");
+                const trimmedWidth = Bun.stringWidth(trimmed);
+                if (trimmedWidth <= width) {
+                    currentLine = trimmed;
+                    currentWidth = trimmedWidth;
+                }
+                else {
+                    this.#hardBreak(trimmed, width, wrapped);
+                    currentLine = "";
+                    currentWidth = 0;
+                    if (wrapped.length > 0) {
+                        const last = wrapped[wrapped.length - 1];
+                        if (Bun.stringWidth(last) < width) {
+                            currentLine = wrapped.pop();
+                            currentWidth = Bun.stringWidth(currentLine);
+                        }
+                    }
+                }
+            }
+        }
+        if (currentLine.length > 0) {
+            wrapped.push(currentLine);
+        }
+        return wrapped.length > 0 ? wrapped : [""];
+    }
+    #hardBreak(text, width, output) {
+        let remaining = text;
+        while (Bun.stringWidth(remaining) > width) {
+            let breakAt = 0;
+            let w = 0;
+            for (const char of remaining) {
+                const cw = Bun.stringWidth(char);
+                if (w + cw > width)
+                    break;
+                w += cw;
+                breakAt += char.length;
+            }
+            if (breakAt === 0)
+                breakAt = 1;
+            output.push(remaining.slice(0, breakAt));
+            remaining = remaining.slice(breakAt);
+        }
+        if (remaining.length > 0) {
+            output.push(remaining);
+        }
+    }
+    #wrapCellContent(contents, width) {
+        const inputLines = contents.split("\n");
+        const result = [];
+        for (const line of inputLines) {
+            result.push(...this.#wrapLine(line, width));
+        }
+        return result.length > 0 ? result : [""];
+    }
+    #alignText(text, width, align) {
+        const textWidth = Bun.stringWidth(text);
+        const gap = width - textWidth;
+        if (gap <= 0)
+            return text;
+        switch (align) {
+            case Align.LEFT:
+                return text + " ".repeat(gap);
+            case Align.RIGHT:
+                return " ".repeat(gap) + text;
+            case Align.CENTER: {
+                const left = Math.floor(gap / 2);
+                const right = gap - left;
+                return " ".repeat(left) + text + " ".repeat(right);
+            }
+        }
+    }
+    #colorBorder(char, table) {
+        let result = char;
+        if (this.colorEnabled && table.options.borderBackgroundColor) {
+            result = this.backgroundColorFunction(result, table.options.borderBackgroundColor);
+        }
+        if (this.colorEnabled && table.options.borderColor) {
+            result = this.colorFunction(result, table.options.borderColor);
+        }
+        return result;
+    }
+    render(table) {
+        const border = table.options.border !== false;
+        const padding = table.options.padding ?? 1;
+        const columnWidths = this.#calculateColumnWidths(table);
+        const pad = " ".repeat(padding);
+        const wrappedCells = [];
+        const rowHeights = [];
+        for (let row = 0; row < table.rowCount; row++) {
+            const rowCells = [];
+            let maxHeight = 1;
+            for (let col = 0; col < table.columnCount; col++) {
+                const cell = table.getCell(row, col);
+                const lines = this.#wrapCellContent(cell?.contents ?? "", columnWidths[col]);
+                rowCells.push(lines);
+                if (lines.length > maxHeight)
+                    maxHeight = lines.length;
+            }
+            wrappedCells.push(rowCells);
+            rowHeights.push(maxHeight);
+        }
+        const output = [];
+        if (border) {
+            output.push(this.#renderHorizontalBorder(table, columnWidths, padding, BORDER_TOP_LEFT, BORDER_TOP, BORDER_TOP_MIDDLE, BORDER_TOP_RIGHT));
+        }
+        for (let row = 0; row < table.rowCount; row++) {
+            for (let subLine = 0; subLine < rowHeights[row]; subLine++) {
+                let line = "";
+                if (border)
+                    line += this.#colorBorder(BORDER_LEFT, table);
+                for (let col = 0; col < table.columnCount; col++) {
+                    if (!border && col > 0)
+                        line += " ".repeat(padding * 2);
+                    const cellLines = wrappedCells[row][col];
+                    const content = subLine < cellLines.length ? cellLines[subLine] : "";
+                    const align = this.#resolveAlign(table, row, col);
+                    const aligned = this.#alignText(content, columnWidths[col], align);
+                    line += pad + aligned + pad;
+                    if (border && col < table.columnCount - 1) {
+                        line += this.#colorBorder(BORDER_MIDDLE_VERTICAL, table);
+                    }
+                }
+                if (border)
+                    line += this.#colorBorder(BORDER_RIGHT, table);
+                output.push(border ? line : line.trimEnd());
+            }
+            if (border && row < table.rowCount - 1) {
+                output.push(this.#renderHorizontalBorder(table, columnWidths, padding, BORDER_LEFT_MIDDLE, BORDER_MIDDLE, BORDER_MIDDLE_MIDDLE, BORDER_RIGHT_MIDDLE));
+            }
+        }
+        if (border) {
+            output.push(this.#renderHorizontalBorder(table, columnWidths, padding, BORDER_BOTTOM_LEFT, BORDER_BOTTOM, BORDER_BOTTOM_MIDDLE, BORDER_BOTTOM_RIGHT));
+        }
+        return output.join("\n");
+    }
+    #renderHorizontalBorder(table, columnWidths, padding, left, horizontal, middle, right) {
+        let line = this.#colorBorder(left, table);
+        for (let col = 0; col < table.columnCount; col++) {
+            const segment = horizontal.repeat(columnWidths[col] + padding * 2);
+            line += this.#colorBorder(segment, table);
+            if (col < table.columnCount - 1) {
+                line += this.#colorBorder(middle, table);
+            }
+        }
+        line += this.#colorBorder(right, table);
+        return line;
+    }
+}

package/dist/src/service/tableGenerator/TableGeneratorServiceProvider.js

@@ -0,0 +1,26 @@
+import DefaultTableGeneratorService from "./DefaultTableGeneratorService.js";
+import { TABLE_GENERATOR_SERVICE_ID } from "../../api/service/core/TableGeneratorService.js";
+import { PRINTER_SERVICE_ID } from "../../api/service/core/PrinterService.js";
+export default class TableGeneratorServiceProvider {
+    servicePriority;
+    serviceId = TABLE_GENERATOR_SERVICE_ID;
+    #defaultTableGeneratorService;
+    constructor(servicePriority) {
+        this.servicePriority = servicePriority;
+        this.#defaultTableGeneratorService = new DefaultTableGeneratorService();
+    }
+    getServiceInfo(_cliConfig) {
+        return Promise.resolve({
+            service: this.#defaultTableGeneratorService,
+            commands: [],
+        });
+    }
+    initService(context) {
+        const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+        this.#defaultTableGeneratorService.colorEnabled = printerService.colorEnabled;
+        this.#defaultTableGeneratorService.colorFunction = printerService.color.bind(printerService);
+        this.#defaultTableGeneratorService.backgroundColorFunction =
+            printerService.backgroundColor.bind(printerService);
+        return Promise.resolve(undefined);
+    }
+}

package/dist/src/service/treePrinter/DefaultTreePrinterService.js

@@ -0,0 +1,35 @@
+const DEFAULT_NODE_COLOR = "#839496";
+export default class DefaultTreePrinterService {
+    colorEnabled = true;
+    colorFunction = (text) => text;
+    #nodeColor;
+    constructor(nodeColor = DEFAULT_NODE_COLOR) {
+        this.#nodeColor = nodeColor;
+    }
+    #colorLabel(label) {
+        if (this.colorEnabled) {
+            return this.colorFunction(label, this.#nodeColor);
+        }
+        return label;
+    }
+    #renderChildren(children, prefix, lines) {
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            const isLast = i === children.length - 1;
+            const connector = isLast ? "└── " : "├── ";
+            const extension = isLast ? "    " : "│   ";
+            if (typeof child === "string") {
+                lines.push(prefix + connector + this.#colorLabel(child));
+            }
+            else {
+                lines.push(prefix + connector + this.#colorLabel(child.label));
+                this.#renderChildren(child.children ?? [], prefix + extension, lines);
+            }
+        }
+    }
+    print(node) {
+        const lines = [this.#colorLabel(node.label)];
+        this.#renderChildren(node.children ?? [], "", lines);
+        return lines.join("\n");
+    }
+}

package/dist/src/service/treePrinter/TreePrinterServiceProvider.js

@@ -0,0 +1,24 @@
+import DefaultTreePrinterService from "./DefaultTreePrinterService.js";
+import { TREE_PRINTER_SERVICE_ID } from "../../api/service/core/TreePrinterService.js";
+import { PRINTER_SERVICE_ID } from "../../api/service/core/PrinterService.js";
+export default class TreePrinterServiceProvider {
+    servicePriority;
+    serviceId = TREE_PRINTER_SERVICE_ID;
+    #defaultTreePrinterService;
+    constructor(servicePriority) {
+        this.servicePriority = servicePriority;
+        this.#defaultTreePrinterService = new DefaultTreePrinterService();
+    }
+    getServiceInfo(_cliConfig) {
+        return Promise.resolve({
+            service: this.#defaultTreePrinterService,
+            commands: [],
+        });
+    }
+    initService(context) {
+        const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+        this.#defaultTreePrinterService.colorEnabled = printerService.colorEnabled;
+        this.#defaultTreePrinterService.colorFunction = printerService.color.bind(printerService);
+        return Promise.resolve(undefined);
+    }
+}

package/dist/src/terminal/Ansi.js

@@ -0,0 +1,23 @@
+const CSI = "\x1b[";
+const OSC = "\x1b]";
+const BEL = "\x07";
+const SEP = ";";
+export const CLEAR_LINE = CSI + "2K";
+export const CURSOR_LEFT = CSI + "G";
+export const CURSOR_UP = CSI + "1A";
+export const HIDE_CURSOR = CSI + "?25l";
+export const SHOW_CURSOR = CSI + "?25h";
+export const ITALIC_START = CSI + "3m";
+export const ITALIC_END = CSI + "23m";
+export const FOREGROUND_COLOR_END = CSI + "39m";
+export const BACKGROUND_COLOR_END = CSI + "49m";
+export const HYPERLINK_END = `${OSC}8${SEP}${SEP}${BEL}`;
+export function foregroundColorStart(r, g, b) {
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+export function backgroundColorStart(r, g, b) {
+    return `\x1b[48;2;${r};${g};${b}m`;
+}
+export function hyperlinkStart(url) {
+    return `${OSC}8${SEP}${SEP}${url}${BEL}`;
+}

package/dist/src/terminal/ImageRenderer.js

@@ -0,0 +1,164 @@
+import process from "node:process";
+import supportsTerminalGraphics from "supports-terminal-graphics";
+import { decodePngToRGBA } from "./PngDecoder.js";
+import { BACKGROUND_COLOR_END, backgroundColorStart, FOREGROUND_COLOR_END, foregroundColorStart, } from "./Ansi.js";
+import { Buffer } from "node:buffer";
+export default class ImageRenderer {
+    #terminal;
+    constructor(terminal) {
+        this.#terminal = terminal;
+    }
+    renderImage(imageBuffer, widthPercentage = 100, hexFormattedBackgroundColor) {
+        if (!this.#isMultiplexer()) {
+            if (supportsTerminalGraphics.stdout.kitty) {
+                return this.#renderKitty(imageBuffer, widthPercentage);
+            }
+            if (supportsTerminalGraphics.stdout.iterm2) {
+                return this.#renderITerm2(imageBuffer, widthPercentage);
+            }
+        }
+        return this.#renderAnsiBlocks(imageBuffer, widthPercentage, hexFormattedBackgroundColor);
+    }
+    #isMultiplexer() {
+        const term = (process.env.TERM || "").toLowerCase();
+        const termProgram = (process.env.TERM_PROGRAM || "").toLowerCase();
+        return (termProgram === "tmux" ||
+            termProgram === "screen" ||
+            term.startsWith("tmux") ||
+            term.startsWith("screen"));
+    }
+    // https://sw.kovidgoyal.net/kitty/graphics-protocol/
+    async #renderKitty(imageBuffer, widthPercentage) {
+        const pngBytes = await new Bun.Image(imageBuffer).png().bytes();
+        const columns = Math.floor((this.#terminal.columns() * widthPercentage) / 100);
+        const base64 = Buffer.from(pngBytes).toString("base64");
+        const chunks = [];
+        for (let i = 0; i < base64.length; i += 4096) {
+            chunks.push(base64.slice(i, i + 4096));
+        }
+        let result = "";
+        for (let i = 0; i < chunks.length; i++) {
+            const isLast = i === chunks.length - 1;
+            if (i === 0) {
+                result += `\x1b_Gf=100,a=T,c=${columns},m=${isLast ? 0 : 1};${chunks[i]}\x1b\\`;
+            }
+            else {
+                result += `\x1b_Gm=${isLast ? 0 : 1};${chunks[i]}\x1b\\`;
+            }
+        }
+        return result;
+    }
+    // https://iterm2.com/documentation-images.html
+    async #renderITerm2(imageBuffer, widthPercentage) {
+        const pngBytes = await new Bun.Image(imageBuffer).png().bytes();
+        const base64 = Buffer.from(pngBytes).toString("base64");
+        return `\x1b]1337;File=inline=1;width=${widthPercentage}%:${base64}\x07`;
+    }
+    static #parseHexColor(hex) {
+        const match = hex.match(/^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+        if (!match)
+            return undefined;
+        return {
+            r: Number.parseInt(match[1], 16),
+            g: Number.parseInt(match[2], 16),
+            b: Number.parseInt(match[3], 16),
+        };
+    }
+    async #renderAnsiBlocks(imageBuffer, widthPercentage, hexFormattedBackgroundColor) {
+        const bg = hexFormattedBackgroundColor
+            ? ImageRenderer.#parseHexColor(hexFormattedBackgroundColor)
+            : undefined;
+        const columns = this.#terminal.columns();
+        const rows = this.#terminal.rows();
+        const targetWidth = Math.floor((columns * widthPercentage) / 100);
+        const meta = await new Bun.Image(imageBuffer).metadata();
+        const aspectRatio = meta.height / meta.width;
+        let targetHeight = Math.round(targetWidth * aspectRatio);
+        if (targetHeight % 2 !== 0)
+            targetHeight++;
+        const maxHeight = (rows - 2) * 2;
+        if (targetHeight > maxHeight)
+            targetHeight = maxHeight;
+        const resizedPng = await new Bun.Image(imageBuffer)
+            .resize(targetWidth, targetHeight, { fit: "inside" })
+            .png()
+            .bytes();
+        const { width, height, pixels } = decodePngToRGBA(resizedPng);
+        const lines = [];
+        for (let y = 0; y < height; y += 2) {
+            let line = "";
+            const hasBottom = y + 1 < height;
+            for (let x = 0; x < width; x++) {
+                const topIdx = (y * width + x) * 4;
+                const r = pixels[topIdx];
+                const g = pixels[topIdx + 1];
+                const b = pixels[topIdx + 2];
+                const a = pixels[topIdx + 3];
+                if (hasBottom) {
+                    const botIdx = ((y + 1) * width + x) * 4;
+                    const r2 = pixels[botIdx];
+                    const g2 = pixels[botIdx + 1];
+                    const b2 = pixels[botIdx + 2];
+                    const a2 = pixels[botIdx + 3];
+                    if (a === 0 && a2 === 0) {
+                        if (bg) {
+                            line += backgroundColorStart(bg.r, bg.g, bg.b) + " " + BACKGROUND_COLOR_END;
+                        }
+                        else {
+                            line += " ";
+                        }
+                    }
+                    else if (a === 0) {
+                        if (bg) {
+                            line +=
+                                backgroundColorStart(bg.r, bg.g, bg.b) +
+                                    foregroundColorStart(r2, g2, b2) +
+                                    "▄" +
+                                    FOREGROUND_COLOR_END +
+                                    BACKGROUND_COLOR_END;
+                        }
+                        else {
+                            line += foregroundColorStart(r2, g2, b2) + "▄" + FOREGROUND_COLOR_END;
+                        }
+                    }
+                    else if (a2 === 0) {
+                        if (bg) {
+                            line +=
+                                backgroundColorStart(bg.r, bg.g, bg.b) +
+                                    foregroundColorStart(r, g, b) +
+                                    "▀" +
+                                    FOREGROUND_COLOR_END +
+                                    BACKGROUND_COLOR_END;
+                        }
+                        else {
+                            line += foregroundColorStart(r, g, b) + "▀" + FOREGROUND_COLOR_END;
+                        }
+                    }
+                    else {
+                        line +=
+                            backgroundColorStart(r, g, b) +
+                                foregroundColorStart(r2, g2, b2) +
+                                "▄" +
+                                FOREGROUND_COLOR_END +
+                                BACKGROUND_COLOR_END;
+                    }
+                }
+                else {
+                    if (a === 0) {
+                        if (bg) {
+                            line += backgroundColorStart(bg.r, bg.g, bg.b) + " " + BACKGROUND_COLOR_END;
+                        }
+                        else {
+                            line += " ";
+                        }
+                    }
+                    else {
+                        line += backgroundColorStart(r, g, b) + " " + BACKGROUND_COLOR_END;
+                    }
+                }
+            }
+            lines.push(line);
+        }
+        return lines.join("\n");
+    }
+}

package/dist/src/terminal/KeyReader.js

@@ -0,0 +1,13 @@
+export var SpecialKey;
+(function (SpecialKey) {
+    SpecialKey[SpecialKey["UP"] = 0] = "UP";
+    SpecialKey[SpecialKey["DOWN"] = 1] = "DOWN";
+    SpecialKey[SpecialKey["LEFT"] = 2] = "LEFT";
+    SpecialKey[SpecialKey["RIGHT"] = 3] = "RIGHT";
+    SpecialKey[SpecialKey["ENTER"] = 4] = "ENTER";
+    SpecialKey[SpecialKey["SPACE"] = 5] = "SPACE";
+    SpecialKey[SpecialKey["BACKSPACE"] = 6] = "BACKSPACE";
+    SpecialKey[SpecialKey["ESCAPE"] = 7] = "ESCAPE";
+    SpecialKey[SpecialKey["TAB"] = 8] = "TAB";
+    SpecialKey[SpecialKey["INTERRUPT"] = 9] = "INTERRUPT";
+})(SpecialKey || (SpecialKey = {}));