terminal-png 0.1.1 → 0.1.3

package/dist/ansi-parser.d.ts

@@ -19,5 +19,7 @@ export type StyledRun = {
     underline: boolean;
     strikethrough: boolean;
     dim: boolean;
+    inverse: boolean;
+    conceal: boolean;
 };
 export declare function parseAnsi(input: string): StyledRun[];

package/dist/ansi-parser.js

@@ -7,7 +7,9 @@ function createDefaultStyle() {
         italic: false,
         underline: false,
         strikethrough: false,
-        dim: false
+        dim: false,
+        inverse: false,
+        conceal: false
     };
 }
 function cloneStyle(style) {
@@ -19,6 +21,8 @@ function stylesEqual(left, right) {
         left.underline === right.underline &&
         left.strikethrough === right.strikethrough &&
         left.dim === right.dim &&
+        left.inverse === right.inverse &&
+        left.conceal === right.conceal &&
         colorsEqual(left.fg, right.fg) &&
         colorsEqual(left.bg, right.bg));
 }
@@ -54,18 +58,20 @@ function pushRun(runs, style, text) {
         italic: style.italic,
         underline: style.underline,
         strikethrough: style.strikethrough,
-        dim: style.dim
+        dim: style.dim,
+        inverse: style.inverse,
+        conceal: style.conceal
     });
 }
-function parseCsi(input, start) {
-    let index = start + 2;
+function parseCsi(input, start, prefixLength) {
+    let index = start + prefixLength;
     while (index < input.length) {
         const code = input.charCodeAt(index);
         if (code >= 0x40 && code <= 0x7e) {
             return {
                 end: index + 1,
                 final: input[index],
-                params: input.slice(start + 2, index)
+                params: input.slice(start + prefixLength, index)
             };
         }
         index += 1;
@@ -73,7 +79,7 @@ function parseCsi(input, start) {
     return {
         end: input.length,
         final: null,
-        params: input.slice(start + 2)
+        params: input.slice(start + prefixLength)
     };
 }
 function toInteger(value) {
@@ -125,16 +131,24 @@ function applyExtendedColor(params, start) {
 function applySgr(style, paramsText) {
     const nextStyle = cloneStyle(style);
     const rawParams = paramsText.length === 0 ? ["0"] : paramsText.split(";");
-    const params = [];
-    for (const rawParam of rawParams) {
-        const value = toInteger(rawParam);
+    for (let index = 0; index < rawParams.length; index += 1) {
+        const rawParam = rawParams[index] ?? "";
+        const colonColor = applyColonExtendedColor(rawParam);
+        if (colonColor !== undefined) {
+            if (colonColor !== null) {
+                if (colonColor.target === 38) {
+                    nextStyle.fg = colonColor.color;
+                }
+                else {
+                    nextStyle.bg = colonColor.color;
+                }
+            }
+            continue;
+        }
+        const value = rawParam.length === 0 ? 0 : toInteger(rawParam);
         if (value === null) {
             return nextStyle;
         }
-        params.push(value);
-    }
-    for (let index = 0; index < params.length; index += 1) {
-        const value = params[index];
         if (value === 0) {
             Object.assign(nextStyle, createDefaultStyle());
             continue;
@@ -176,6 +190,22 @@ function applySgr(style, paramsText) {
             nextStyle.strikethrough = false;
             continue;
         }
+        if (value === 7) {
+            nextStyle.inverse = true;
+            continue;
+        }
+        if (value === 27) {
+            nextStyle.inverse = false;
+            continue;
+        }
+        if (value === 8) {
+            nextStyle.conceal = true;
+            continue;
+        }
+        if (value === 28) {
+            nextStyle.conceal = false;
+            continue;
+        }
         if (value === 39) {
             nextStyle.fg = null;
             continue;
@@ -201,8 +231,14 @@ function applySgr(style, paramsText) {
             continue;
         }
         if (value === 38 || value === 48) {
-            const extended = applyExtendedColor(params, index + 1);
+            const params = rawParams.map((param) => toInteger(param));
+            const extended = params.every((param) => param !== null)
+                ? applyExtendedColor(params, index + 1)
+                : null;
             if (!extended) {
+                if (rawParams[index + 1] === "2" || rawParams[index + 1] === "5") {
+                    break;
+                }
                 continue;
             }
             if (value === 38) {
@@ -216,32 +252,149 @@ function applySgr(style, paramsText) {
     }
     return nextStyle;
 }
-export function parseAnsi(input) {
+function applyColonExtendedColor(rawParam) {
+    if (!rawParam.includes(":")) {
+        return undefined;
+    }
+    const segments = rawParam.split(":");
+    const target = toInteger(segments[0]);
+    if (target !== 38 && target !== 48) {
+        return null;
+    }
+    const mode = toInteger(segments[1]);
+    if (mode === 5) {
+        const index = toInteger(segments[2]);
+        return index === null ? null : { target, color: { type: "ansi8", index: clampByte(index) } };
+    }
+    if (mode !== 2) {
+        return null;
+    }
+    const offset = segments[2] === "" ? 3 : 2;
+    const r = toInteger(segments[offset]);
+    const g = toInteger(segments[offset + 1]);
+    const b = toInteger(segments[offset + 2]);
+    if (r === null || g === null || b === null) {
+        return null;
+    }
+    return { target, color: { type: "rgb", r: clampByte(r), g: clampByte(g), b: clampByte(b) } };
+}
+function parseOscEnd(input, start) {
+    let index = start + 2;
+    while (index < input.length) {
+        if (input[index] === "\u0007") {
+            return index + 1;
+        }
+        if (input[index] === ESC && input[index + 1] === "\\") {
+            return index + 2;
+        }
+        index += 1;
+    }
+    return input.length;
+}
+function positionParameter(params, index, fallback) {
+    const value = toInteger(params.split(";")[index]);
+    return value === null || value < 1 ? fallback : value;
+}
+function buildRuns(lines, lineBreakStyles) {
     const runs = [];
+    const defaultStyle = createDefaultStyle();
+    for (let row = 0; row < lines.length; row += 1) {
+        const line = lines[row] ?? [];
+        let lastCell = line.length - 1;
+        while (lastCell >= 0 && line[lastCell] === undefined) {
+            lastCell -= 1;
+        }
+        for (let column = 0; column <= lastCell; column += 1) {
+            const cell = line[column] ?? { text: " ", style: defaultStyle };
+            pushRun(runs, cell.style, cell.text);
+        }
+        if (row < lines.length - 1) {
+            pushRun(runs, lineBreakStyles[row] ?? defaultStyle, "\n");
+        }
+    }
+    return runs;
+}
+export function parseAnsi(input) {
+    const lines = [[]];
+    const lineBreakStyles = [];
     let style = createDefaultStyle();
-    let textStart = 0;
+    let row = 0;
+    let column = 0;
     let index = 0;
+    const ensureLine = () => {
+        while (lines.length <= row) {
+            lines.push([]);
+        }
+    };
+    const moveDown = (keepColumn) => {
+        lineBreakStyles[row] = cloneStyle(style);
+        row += 1;
+        if (!keepColumn) {
+            column = 0;
+        }
+        ensureLine();
+    };
     while (index < input.length) {
         const char = input[index];
         if (char === "\n") {
-            pushRun(runs, style, input.slice(textStart, index));
-            pushRun(runs, style, "\n");
+            moveDown(false);
             index += 1;
-            textStart = index;
             continue;
         }
-        if (char === ESC && input[index + 1] === "[") {
-            pushRun(runs, style, input.slice(textStart, index));
-            const sequence = parseCsi(input, index);
+        if (char === "\v") {
+            moveDown(true);
+            index += 1;
+            continue;
+        }
+        if (char === "\r") {
+            column = 0;
+            index += 1;
+            continue;
+        }
+        if (char === "\b") {
+            column = Math.max(0, column - 1);
+            index += 1;
+            continue;
+        }
+        if (char === ESC && input[index + 1] === "]") {
+            index = parseOscEnd(input, index);
+            continue;
+        }
+        const csiPrefixLength = char === "\u009b" ? 1 : char === ESC && input[index + 1] === "[" ? 2 : null;
+        if (csiPrefixLength !== null) {
+            const sequence = parseCsi(input, index, csiPrefixLength);
             if (sequence.final === "m") {
                 style = applySgr(style, sequence.params);
             }
+            else if (sequence.final === "G") {
+                column = positionParameter(sequence.params, 0, 1) - 1;
+            }
+            else if (sequence.final === "C") {
+                column += positionParameter(sequence.params, 0, 1);
+            }
+            else if (sequence.final === "D") {
+                column = Math.max(0, column - positionParameter(sequence.params, 0, 1));
+            }
+            else if (sequence.final === "A") {
+                row = Math.max(0, row - positionParameter(sequence.params, 0, 1));
+            }
+            else if (sequence.final === "B") {
+                row += positionParameter(sequence.params, 0, 1);
+                ensureLine();
+            }
+            else if (sequence.final === "H" || sequence.final === "f") {
+                row = positionParameter(sequence.params, 0, 1) - 1;
+                column = positionParameter(sequence.params, 1, 1) - 1;
+                ensureLine();
+            }
             index = sequence.end;
-            textStart = index;
             continue;
         }
-        index += 1;
+        const codePoint = input.codePointAt(index);
+        const text = codePoint === undefined ? "" : String.fromCodePoint(codePoint);
+        lines[row][column] = { text, style: cloneStyle(style) };
+        column += 1;
+        index += text.length;
     }
-    pushRun(runs, style, input.slice(textStart));
-    return runs;
+    return buildRuns(lines, lineBreakStyles);
 }

package/dist/font.js

@@ -22,12 +22,12 @@ function createFontFace(base64, weight, style) {
 }`;
 }
 export const JETBRAINS_MONO_BASE64 = readWebfontBase64("JetBrainsMono-Regular.woff2");
-export const JETBRAINS_MONO_FONT_FILES = [
+export const JETBRAINS_MONO_FONT_FILES = Object.freeze([
     resolveAssetPath("jetbrains-mono-400-normal.ttf"),
     resolveAssetPath("jetbrains-mono-700-normal.ttf"),
     resolveAssetPath("jetbrains-mono-400-italic.ttf"),
     resolveAssetPath("jetbrains-mono-700-italic.ttf")
-];
+]);
 export const JETBRAINS_MONO_TTF_PATH = JETBRAINS_MONO_FONT_FILES[0];
 export const FONT_FACE_CSS = [
     createFontFace(JETBRAINS_MONO_BASE64, 400, "normal"),

package/dist/index.js

@@ -1,8 +1,12 @@
-import { writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { rename, rm, writeFile } from "node:fs/promises";
 import { parseAnsi } from "./ansi-parser.js";
 import { renderPng } from "./png-renderer.js";
 import { renderSvg } from "./svg-renderer.js";
 export async function renderTerminalPng(ansiText, options = {}) {
+    if (options.padding !== undefined && (!Number.isInteger(options.padding) || options.padding < 0)) {
+        throw new Error("Padding must be a non-negative integer.");
+    }
     const runs = parseAnsi(ansiText);
     const svg = renderSvg(runs, {
         padding: options.padding,
@@ -10,7 +14,24 @@ export async function renderTerminalPng(ansiText, options = {}) {
     });
     const png = renderPng(svg);
     if (options.output) {
-        await writeFile(options.output, png);
+        const temporaryPath = `${options.output}.${randomUUID()}.tmp`;
+        let temporaryCreated = false;
+        try {
+            await writeFile(temporaryPath, png, { flag: "wx" });
+            temporaryCreated = true;
+            await rename(temporaryPath, options.output);
+        }
+        catch (error) {
+            if (temporaryCreated) {
+                try {
+                    await rm(temporaryPath, { force: true });
+                }
+                catch (cleanupError) {
+                    void cleanupError;
+                }
+            }
+            throw error;
+        }
     }
     return png;
 }

package/dist/svg-renderer.js

@@ -114,16 +114,30 @@ function splitIntoLines(runs) {
     return lines;
 }
 function measureLines(lines) {
-    return Math.max(...lines.map(line => line.reduce((width, run) => width + (displayWidth(run.text) * CHARACTER_WIDTH), 0)), 0);
+    return Math.max(...lines.map((line) => displayWidth(line.map((run) => run.text).join("")) * CHARACTER_WIDTH), 0);
 }
-function displayWidth(text) {
+function displayWidth(text, startColumn = 0) {
     const segmenter = new Intl.Segmenter();
-    let width = 0;
+    let column = startColumn;
     for (const { segment } of segmenter.segment(text)) {
+        if (segment === "\t") {
+            column += 8 - (column % 8);
+            continue;
+        }
         const cp = segment.codePointAt(0);
-        width += cp !== undefined && isWideCodePoint(cp) ? 2 : 1;
+        if (cp !== undefined && isZeroWidthCodePoint(cp)) {
+            continue;
+        }
+        column += cp !== undefined && (isWideCodePoint(cp) || isFlagSegment(segment)) ? 2 : 1;
     }
-    return width;
+    return column - startColumn;
+}
+function isZeroWidthCodePoint(cp) {
+    return (cp >= 0x0300 && cp <= 0x036f) || (cp >= 0x1ab0 && cp <= 0x1aff) || (cp >= 0x1dc0 && cp <= 0x1dff) || (cp >= 0x20d0 && cp <= 0x20ff) || (cp >= 0xfe20 && cp <= 0xfe2f);
+}
+function isFlagSegment(segment) {
+    const codePoints = [...segment].map((character) => character.codePointAt(0));
+    return codePoints.length === 2 && codePoints.every((cp) => cp !== undefined && cp >= 0x1f1e6 && cp <= 0x1f1ff);
 }
 function isWideCodePoint(cp) {
     return ((cp >= 0x1100 && cp <= 0x115F) || // Hangul Jamo
@@ -155,6 +169,7 @@ function renderLines(lines, textStartX, textStartY, lineHeightPx) {
             return `<text x="${formatNumber(textStartX)}" y="${y}" xml:space="preserve"/>`;
         }
         return [
+            renderBackgrounds(line, textStartX, textStartY + (index * lineHeightPx) - lineHeightPx, lineHeightPx),
             `<text x="${formatNumber(textStartX)}" y="${y}" xml:space="preserve">`,
             line.map(renderRun).join(""),
             "</text>"
@@ -162,9 +177,22 @@ function renderLines(lines, textStartX, textStartY, lineHeightPx) {
     })
         .join("");
 }
+function renderBackgrounds(line, startX, y, height) {
+    let column = 0;
+    const rectangles = [];
+    for (const run of line) {
+        const width = displayWidth(run.text, column);
+        const background = resolveBackgroundColor(run);
+        if (background !== BACKGROUND && width > 0) {
+            rectangles.push(`<rect x="${formatNumber(startX + (column * CHARACTER_WIDTH))}" y="${formatNumber(y)}" width="${formatNumber(width * CHARACTER_WIDTH)}" height="${formatNumber(height)}" fill="${escapeXmlAttribute(background)}" />`);
+        }
+        column += width;
+    }
+    return rectangles.join("");
+}
 function renderRun(run) {
     const attributes = ['xml:space="preserve"'];
-    const color = resolveColor(run.fg);
+    const color = resolveForegroundColor(run);
     const textDecorations = [];
     if (color !== DEFAULT_FOREGROUND) {
         attributes.push(`fill="${escapeXmlAttribute(color)}"`);
@@ -187,7 +215,8 @@ function renderRun(run) {
     if (run.dim) {
         attributes.push('opacity="0.7"');
     }
-    return `<tspan ${attributes.join(" ")}>${escapeXmlText(run.text)}</tspan>`;
+    const text = run.conceal ? " ".repeat(displayWidth(run.text)) : run.text;
+    return `<tspan ${attributes.join(" ")}>${escapeXmlText(text)}</tspan>`;
 }
 function renderWindowControls() {
     return [
@@ -211,6 +240,15 @@ function resolveColor(color) {
     }
     return `rgb(${color.r},${color.g},${color.b})`;
 }
+function resolveForegroundColor(run) {
+    return run.inverse ? resolveColorOrDefault(run.bg, BACKGROUND) : resolveColor(run.fg);
+}
+function resolveBackgroundColor(run) {
+    return run.inverse ? resolveColor(run.fg) : resolveColorOrDefault(run.bg, BACKGROUND);
+}
+function resolveColorOrDefault(color, defaultColor) {
+    return color === null ? defaultColor : resolveColor(color);
+}
 function escapeXmlText(value) {
     return value
         .replaceAll("&", "&amp;")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-png",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Render PNG images from ANSI terminal output.",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,7 +10,8 @@
     "terminal-png": "./bin/terminal-png"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc -p tsconfig.build.json",
+    "prepack": "node ../../scripts/set-bin-executable.mjs",
     "compare": "tsx scripts/compare.ts"
   },
   "files": [