@peteanderson/ansi 0.2.4 → 0.3.0

package/src/sgr/color/color.js

@@ -0,0 +1,104 @@
+const {makeSGR}                                       = require("../sgr");
+const {makeStyle}                                     = require("../style");
+const {clip, rgbToX256, rgbToX16, rgbToX8, x256ToRgb} = require("./utils");
+
+/** @typedef {import("../sgr").Code}                     Code */
+/** @typedef {import("../../features/types").ColorDepth} ColorDepth */
+/** @typedef {import("../sgr").SGR}                      SGR */
+/** @typedef {import("./types").Channel}                 Channel */
+
+const fgOpen = 30, fgClose = 39;
+const bgOpen = 40, bgClose = 49;
+
+/** @type {(colorDepth: ColorDepth, open: number, close: number) => Channel} */
+function makeChannel(colorDepth, open, close) {
+	const sgrBase = makeSGR(colorDepth > 1);
+	const style   = makeStyle(colorDepth > 1);
+
+	/** @type {(code: Code) => SGR} */
+	const sgr = code => sgrBase(code, close);
+
+	/** @type {(index: number) => SGR} */
+	const bright =
+		colorDepth >= 4 ? index => sgr(open + 60 + index) :
+		colorDepth === 3 ?
+			open === fgOpen ?
+				index => style.bold.combine(sgr(open + index)) :
+				index => sgr(open + index) :
+		() => sgr(0);
+
+	/** @type {(code: number) => SGR} */
+	const x16ToX8 =
+		open === fgOpen ?
+			code => code >= 60 ? style.bold.combine(sgr(open + code - 60)) : sgr(open + code) :
+			code => code >= 60 ? sgr(open + code - 60) : sgr(open + code);
+
+	return {
+		black   : sgr(open + 0),
+		red     : sgr(open + 1),
+		green   : sgr(open + 2),
+		yellow  : sgr(open + 3),
+		blue    : sgr(open + 4),
+		magenta : sgr(open + 5),
+		cyan    : sgr(open + 6),
+		white   : sgr(open + 7),
+
+		brightBlack   : bright(0),
+		brightRed     : bright(1),
+		brightGreen   : bright(2),
+		brightYellow  : bright(3),
+		brightBlue    : bright(4),
+		brightMagenta : bright(5),
+		brightCyan    : bright(6),
+		brightWhite   : bright(7),
+
+		rgb:
+			colorDepth >= 24 ? (r, g, b) => sgr([open + 8, 2, ...clip(r, g, b)]) :
+			colorDepth >=  8 ? (r, g, b) => sgr([open + 8, 5, rgbToX256(...clip(r, g, b))]) :
+			colorDepth >=  4 ? (r, g, b) => sgr(open + rgbToX16(...clip(r, g, b))) :
+			colorDepth === 3 ?
+				open === fgOpen ?
+					(r, g, b) => x16ToX8(rgbToX16(...clip(r, g, b))) :
+					(r, g, b) => sgr(open + rgbToX8(...clip(r, g, b))) :
+			() => sgr(0),
+
+		/** @type {(...args: [number] | [number, number, number]) => SGR} */
+		x256:
+			colorDepth >= 8 ?
+				(...args) => sgr(
+					[open + 8, 5, args.length === 3 ? rgbToX256(...clip(...args)) : clip(args[0])],
+				) :
+			colorDepth >= 4 ?
+				(...args) => sgr(
+					open +
+					rgbToX16(...(args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0])))),
+				) :
+			colorDepth === 3 ?
+				open === fgOpen ?
+					(...args) => x16ToX8(
+						args.length === 3 ?
+							rgbToX16(...clip(...args)) :
+							rgbToX16(...x256ToRgb(clip(args[0]))),
+					) :
+					(...args) => sgr(
+						open + rgbToX8(
+						...args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0])),
+						),
+					) :
+			() => sgr(0),
+
+		default: colorDepth > 1 ? `\x1b[${close}m` : "",
+	};
+}
+
+/** @type {Partial<Record<ColorDepth, {fg: Channel, bg: Channel}>>} */
+const cache = {};
+
+/** @type {(colorDepth: ColorDepth) => {fg: Channel, bg: Channel}} */
+const makeColor = (colorDepth = 4) =>
+	cache[colorDepth] ?? (cache[colorDepth] = {
+		fg : makeChannel(colorDepth, fgOpen, fgClose),
+		bg : makeChannel(colorDepth, bgOpen, bgClose),
+	});
+
+module.exports = {makeColor};

package/src/sgr/color/index.js

@@ -0,0 +1 @@
+module.exports = require("./color");

package/src/sgr/color/types.d.ts

@@ -0,0 +1,28 @@
+export interface Channel {
+	black   : SGR;
+	red     : SGR;
+	green   : SGR;
+	yellow  : SGR;
+	blue    : SGR;
+	magenta : SGR;
+	cyan    : SGR;
+	white   : SGR;
+
+	brightBlack   : SGR;
+	brightRed     : SGR;
+	brightGreen   : SGR;
+	brightYellow  : SGR;
+	brightBlue    : SGR;
+	brightMagenta : SGR;
+	brightCyan    : SGR;
+	brightWhite   : SGR;
+
+	rgb: (r: number, g: number, b: number) => SGR;
+
+	x256: {
+		(code: number): SGR;
+		(r: number, g: number, b: number): SGR;
+	};
+
+	default: string,
+}

package/src/sgr/color/utils.js

@@ -0,0 +1,81 @@
+/** @typedef {import("../sgr").Code} Code */
+
+/** @type {(r: number, g: number, b: number) => number} */
+function rgbToX256(r, g, b) {
+	if (r === g && g === b) {
+		// grayscale
+		return 232 + Math.floor(r * 24 / 256);
+	}
+
+	// 6x6x6 color cube
+	return (
+		16 +
+		Math.floor(r * 6 / 256) * 36 +
+		Math.floor(g * 6 / 256) * 6 +
+		Math.floor(b * 6 / 256)
+	);
+}
+
+/** @type {(code: number) => [number, number, number]} */
+function x256ToRgb(code) {
+	if (code >= 232) {
+		// grayscale
+		const gray = Math.round((code - 232) * 255 / 24);
+		return [gray, gray, gray];
+	}
+
+	code -= 16;
+	const r = Math.floor(code / 36) * 51;
+	const g = Math.floor((code % 36) / 6) * 51;
+	const b = (code % 6) * 51;
+	return [r, g, b];
+}
+
+/** @type {(r: number, g: number, b: number) => number} */
+function rgbToX16(r, g, b) {
+	// First calculate it as a 4x4x4 cube.
+
+	r = Math.min(2, Math.floor(r / 85));
+	g = Math.min(2, Math.floor(g / 85));
+	b = Math.min(2, Math.floor(b / 85));
+
+	// Which channels are "on" determines the hue (ANSI color index 0–7).
+	const index = (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0);
+
+	// The bright bit is derived from the max channel level across all three.
+	const twos   = (r === 2 ? 1 : 0) + (g === 2 ? 1 : 0) + (b === 2 ? 1 : 0);
+	const ones   = (r === 1 ? 1 : 0) + (g === 1 ? 1 : 0) + (b === 1 ? 1 : 0);
+	const bright = twos > 0 && twos >= ones;
+
+	// Return value uses the SGR offset scheme: 0–7 for normal, 60–67 for bright.
+	return index + (bright ? 60 : 0);
+}
+
+/** @type {(r: number, g: number, b: number) => number} */
+function rgbToX8(r, g, b) {
+	r = r >= 128 ? 1 : 0;
+	g = g >= 128 ? 1 : 0;
+	b = b >= 128 ? 1 : 0;
+
+	return (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0);
+}
+
+/**
+ * @overload
+ * @param   {number} x
+ * @returns {number}
+ * @overload
+ * @param   {number} r
+ * @param   {number} g
+ * @param   {number} b
+ * @returns {[number, number, number]}
+ *//** @param {[number] | [number, number, number]} args */
+const clip = (...args) => args.length === 1 ?
+	Math.max(0, Math.min(255, Math.floor(args[0]))) :
+	[
+		Math.max(0, Math.min(255, Math.floor(args[0]))),
+		Math.max(0, Math.min(255, Math.floor(args[1]))),
+		Math.max(0, Math.min(255, Math.floor(args[2]))),
+	];
+
+module.exports = {rgbToX256, x256ToRgb, rgbToX16, rgbToX8, clip};

package/src/sgr/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+	...require("./reset"),
+	...require("./style"),
+	...require("./color"),
+};

package/src/sgr/reset.js

@@ -0,0 +1,3 @@
+const makeReset = (enabled = true) => enabled ? "\x1b[0m" : "";
+
+module.exports = {makeReset};

package/src/sgr/sgr.js

@@ -0,0 +1,77 @@
+"use strict";
+
+/**
+@typedef {number | number[]} Code
+@typedef {{
+	(text: string): string;
+	open    : string;
+	close   : string;
+	codes   : {open: Code, close: Code};
+	combine : (...styles: SGR[]) => SGR;
+}} SGR
+*/
+
+/** @type {(code: Code, codes: Code[]) => Code} */
+function combine(code, codes, ) {
+	if (!codes.length)
+		return code;
+
+	const rtn = Array.isArray(code) ? [...code] : [code];
+
+	for (const c of codes) {
+		if (Array.isArray(c))
+			rtn.push(...c);
+		else
+			rtn.push(c);
+	}
+
+	return rtn;
+}
+
+/** @type {(code: Code) => string | number} */
+const codeSequence = code => Array.isArray(code) ? code.join(';') : code;
+
+/** @type {(open: Code, close: Code, reset?: boolean) => SGR} */
+function sgr(open, close, reset = false) {
+	const openCode       = codeSequence(open);
+	const closeCode      = codeSequence(close);
+	const openSequence   = `\x1b[${openCode}m`;
+	const closeSequence  = `\x1b[${closeCode}m`;
+	const reopenCode     = reset ? `${closeCode};${openCode}` : openCode;
+
+	const rxClose = new RegExp(
+		`(?<start>\\x1b\\[(?:\\d+;)*)${closeCode}(?<end>(?:;\\d+)*m)`,
+		"g"
+	);
+	const replace = `$<start>${reopenCode}$<end>`;
+
+	/** @type {(text: string) => string} */
+	const func = s => openSequence + s.replace(rxClose, replace) + closeSequence;
+
+	return Object.assign(func, {
+		codes : {open, close},
+		open  : openSequence,
+		close : closeSequence,
+
+		/** @type {(...styles: SGR[]) => SGR} */
+		combine: (...styles) => sgr(
+			combine(open, styles.map(s => s.codes.open)),
+			combine(close, styles.map(s => s.codes.close)),
+		),
+	});
+};
+
+/** @type {SGR} */
+const disabledSGR = Object.assign(/** @type {(text: string) => string} */ s => s, {
+	codes   : {open: 0, close: 0},
+	open    : "",
+	close   : "",
+	combine : () => disabledSGR,
+});
+
+/** @type {typeof sgr} */
+const disabled = () => disabledSGR;
+
+const makeSGR = (enabled = true) => enabled ? sgr : disabled;
+
+module.exports = {makeSGR};

package/src/sgr/style.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const {makeSGR} = require("./sgr");
+
+function makeStyle(enabled = true) {
+	const sgr = makeSGR(enabled);
+
+	return {
+		bold            : sgr(1, 22, true),
+		dim             : sgr(2, 22, true),
+		italic          : sgr(3, 23),
+		underline       : sgr(4, 24),
+		inverse         : sgr(7, 27),
+		hidden          : sgr(8, 28),
+		strikethrough   : sgr(9, 29),
+		doubleUnderline : sgr(21, 24),
+		frame           : sgr(51, 54),
+		encircle        : sgr(52, 54),
+		overline        : sgr(53, 55),
+	};
+}
+
+module.exports = {makeStyle};

package/src/sgr/utils.js

@@ -0,0 +1,20 @@
+/** @typedef {number | number[]} Code */
+
+/** @type {(code: Code, codes: Code[]) => Code} */
+function combine(code, codes, ) {
+	if (!codes.length)
+		return code;
+
+	const rtn = Array.isArray(code) ? [...code] : [code];
+
+	for (const c of codes) {
+		if (Array.isArray(c))
+			rtn.push(...c);
+		else
+			rtn.push(c);
+	}
+
+	return rtn;
+}
+
+module.exports = {combine};

package/src/simplify/atom.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/** @typedef {import("./types").BuildAtom} BuildAtom */
+
+/** @type {BuildAtom} */
+function buildExtendedColorAtom(attribute, codes, index) {
+	switch (codes[index + 1]) {
+		case 2:
+			if (index + 5 >= codes.length)
+				return {attribute, code: codes.slice(index), skip: codes.length - index - 1};
+			return {attribute, code: codes.slice(index, index + 5), skip: 4};
+		case 5:
+			if (index + 3 >= codes.length)
+				return {attribute, code: codes.slice(index), skip: codes.length - index - 1};
+			return {attribute, code: codes.slice(index, index + 3), skip: 2};
+		default:
+			return {attribute, code: codes.slice(index, index + 2), skip: 1};
+	}
+}
+
+/** @type {BuildAtom} */
+function buildIntensityAtom(attribute, codes, index, state) {
+	const code = codes[index];
+	if (code === 22)
+		return {attribute, code: [code]};
+
+	const current = state.get("intensity");
+	if (!current || current.length == 1 && current[0] === code || current[0] === 22)
+		return {attribute, code: [code]};
+
+	return {attribute, code: [1, 2]};
+}
+
+module.exports = {buildExtendedColorAtom, buildIntensityAtom};

package/src/simplify/index.js

@@ -0,0 +1 @@
+module.exports = require("./simplify");

package/src/simplify/lookup.js

@@ -0,0 +1,86 @@
+"use strict";
+
+const {buildExtendedColorAtom, buildIntensityAtom} = require("./atom");
+
+/** @typedef {import("./types").Atom}         Atom */
+/** @typedef {import("./types").Attribute}    Attribute */
+/** @typedef {import("./types").AttributeMap} AttributeMap */
+/** @typedef {import("./types").BuildAtom}    BuildAtom */
+
+/** @type {Record<number, [attribute: Attribute, buildAtom?: BuildAtom]>} */
+const codeMap = {
+	0   : ["reset"],
+	1   : ["intensity", buildIntensityAtom],
+	2   : ["intensity", buildIntensityAtom],
+	3   : ["italic"],
+	4   : ["underline"],
+	7   : ["inverse"],
+	8   : ["hidden"],
+	9   : ["strikethrough"],
+	21  : ["underline"],
+	22  : ["intensity", buildIntensityAtom],
+	23  : ["italic"],
+	24  : ["underline"],
+	27  : ["inverse"],
+	28  : ["hidden"],
+	29  : ["strikethrough"],
+	30  : ["fg"],
+	31  : ["fg"],
+	32  : ["fg"],
+	33  : ["fg"],
+	34  : ["fg"],
+	35  : ["fg"],
+	36  : ["fg"],
+	37  : ["fg"],
+	38  : ["fg", buildExtendedColorAtom],
+	39  : ["fg"],
+	40  : ["bg"],
+	41  : ["bg"],
+	42  : ["bg"],
+	43  : ["bg"],
+	44  : ["bg"],
+	45  : ["bg"],
+	46  : ["bg"],
+	47  : ["bg"],
+	48  : ["bg", buildExtendedColorAtom],
+	49  : ["bg"],
+	51  : ["frame"],
+	52  : ["frame"],
+	53  : ["overline"],
+	54  : ["frame"],
+	55  : ["overline"],
+	90  : ["fg"],
+	91  : ["fg"],
+	92  : ["fg"],
+	93  : ["fg"],
+	94  : ["fg"],
+	95  : ["fg"],
+	96  : ["fg"],
+	97  : ["fg"],
+	100 : ["bg"],
+	101 : ["bg"],
+	102 : ["bg"],
+	103 : ["bg"],
+	104 : ["bg"],
+	105 : ["bg"],
+	106 : ["bg"],
+	107 : ["bg"],
+};
+
+/** @type {(codes: number[], index: number, state: AttributeMap) => Atom} */
+function lookUpAtom(codes, index, state) {
+	const code  = codes[index];
+	const entry = codeMap[code];
+
+	if (!entry)
+		return {attribute: code, code: [code]};
+
+	const [attribute, buildAtom] = entry;
+
+	if (buildAtom)
+		return buildAtom(attribute, codes, index, state);
+
+	return {attribute, code: [code]};
+}
+
+module.exports = {lookUpAtom};

package/src/simplify/simplify.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const {rxSGR} = require("../patterns");
+const {State} = require("./state");
+
+/** @type {(text: string) => string} */
+function simplify(text) {
+	// `.split` doesn't modify `lastIndex`, so no clone is necessary here.
+	const parts = text.split(rxSGR);
+
+	const state  = new State();
+	let   result = parts[0];
+
+	for (let i = 1; i < parts.length; ) {
+		let codes = parts[i++].split(";").map(Number);
+		let chunk = parts[i++];
+
+		while (!chunk && i < parts.length) {
+			// Merge consecutive SGR sequences.
+			codes.push(...parts[i++].split(";").map(Number));
+			chunk = parts[i++];
+		}
+
+		codes = state.update(codes);
+		if (codes.length)
+			result += `\x1b[${codes.join(";")}m`;
+		result += chunk;
+	}
+
+	return result;
+}
+
+module.exports = {simplify};

package/src/simplify/state.js

@@ -0,0 +1,73 @@
+"use strict";
+
+const {lookUpAtom}                       = require("./lookup");
+const {arraysEqual, transitionIntensity} = require("./utils");
+
+/** @typedef {import("./types").Attribute}    Attribute */
+/** @typedef {import("./types").AttributeMap} AttributeMap */
+
+/** @type {Map<Attribute, number[]>} */
+const defaultCodes = new Map([
+	["intensity",    [22]],
+	["italic",       [23]],
+	["underline",    [24]],
+	["inverse",      [27]],
+	["hidden",       [28]],
+	["strikethrough",[29]],
+	["fg",           [39]],
+	["bg",           [49]],
+	["frame",        [54]],
+	["overline",     [55]],
+]);
+
+/** @type {AttributeMap} */
+class State extends Map {
+	/** @type {(codes: number[]) => number[]} */
+	update(codes) {
+		/** @type {AttributeMap} */
+		let snapshot = new Map(this);
+
+		/** @type {Set<Attribute>} */
+		const attributes = new Set();
+
+		for (let i = 0; i < codes.length; i++) {
+			const {attribute, code, skip} = lookUpAtom(codes, i, this);
+
+			if (attribute === "reset") {
+				attributes.clear();
+				this.clear();
+				attributes.add("reset");
+				for (const [attr, defaultCode] of defaultCodes)
+					this.set(attr, defaultCode);
+
+				snapshot = new Map(this);
+				continue;
+			}
+
+			attributes.add(attribute);
+			this.set(attribute, code);
+
+			if (skip)
+				i += skip;
+		}
+
+		return Array.from(attributes).flatMap(attribute => {
+			if (attribute === "reset")
+				return [0];
+
+			const code = this.get(attribute);
+
+			if (arraysEqual(code, snapshot.get(attribute)))
+				return [];
+
+			if (attribute === "intensity") {
+				const previous = snapshot.get(attribute);
+				return transitionIntensity(previous, code);
+			}
+
+			return code;
+		});
+	}
+}
+
+module.exports = {State};

package/src/simplify/types.d.ts

@@ -0,0 +1,28 @@
+export type Attribute =
+	| "intensity"
+	| "italic"
+	| "underline"
+	| "inverse"
+	| "hidden"
+	| "strikethrough"
+	| "fg"
+	| "bg"
+	| "frame"
+	| "overline"
+	| "reset"
+	| number;
+
+type AttributeMap = Map<Attribute, number[]>;
+
+export interface Atom {
+	attribute : Attribute;
+	code      : number[];
+	skip?     : number;
+}
+
+export type BuildAtom = (
+	attribute: Attribute,
+	codes    : number[],
+	index    : number,
+	state    : AttributeMap,
+) => Atom;

package/src/simplify/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+
+/** @type {<T>(a: T[] | undefined, b: T[] | undefined) => boolean} */
+function arraysEqual(a, b) {
+	if (a === b)
+		return true;
+
+	if (!a || !b || a.length !== b.length)
+		return false;
+
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i])
+			return false;
+	}
+
+	return true;
+}
+
+/** @type {(previous: number[] | undefined, current: number[]) => number[]} */
+function transitionIntensity(previous, current) {
+	if (!previous || previous[0] === 22 || current[0] === 22)
+		return current;
+
+	const oldBold = previous[0] === 1;
+	const newBold = current[0] === 1;
+	const oldDim  = previous[previous.length - 1] === 2;
+	const newDim  = current[current.length - 1] === 2;
+
+	const result = [];
+
+	if (oldBold && !newBold || oldDim && !newDim)
+		result.push(22);
+	if (newBold && (!oldBold || result[0] === 22))
+		result.push(1);
+	if (newDim && (!oldDim || result[0] === 22))
+		result.push(2);
+
+	return result;
+}
+
+module.exports = {arraysEqual, transitionIntensity};