@peteanderson/ansi 0.2.0 → 0.2.2

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 {State} = require("./state");
+
+const rxSGR = /\x1b\[([0-9;]+)m/;
+
+/** @type {(text: string) => string} */
+function simplify(text) {
+	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};

package/src/strip.js

@@ -3,7 +3,7 @@
 const {reset} = require("./sgr");
 
 const rxCSI    = /\x1b\[[0-?]*[ -/]*[@-~]/g;
-const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR (m) codes.
+const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR codes (m).
 
 /**
  * Remove all ANSI escape codes from the given text.
@@ -12,7 +12,7 @@ const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR (m) cod
 const strip = text => text.replace(rxCSI, '');
 
 /**
- * Remove all ANSI escape codes except SGR (m) codes, which are used for color and styling.
+ * Remove all ANSI escape codes except SGR codes (m), which are used for color and styling.
  * @type {(text: string) => string}
  */
 const sanitize = text => text.replace(rxUnsafe, '');

package/dist/sgr.d.ts

@@ -1,205 +0,0 @@
-export const reset: "\u001B[0m";
-export namespace style {
-    let bold: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let dim: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let italic: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let underline: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let inverse: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let hidden: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let strikethrough: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let doubleUnderline: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let frame: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let encircle: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let overline: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-}
-export namespace fg {
-    export let black: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let red: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let green: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let yellow: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let blue: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let magenta: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let cyan: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let white: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let brightBlack: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let brightRed: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let brightGreen: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let brightYellow: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let brightBlue: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let brightMagenta: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let brightCyan: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export let brightWhite: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    let _default: string;
-    export { _default as default };
-    export let rgb: (r: number, g: number, b: number) => (text: string) => string;
-    export let x256: (r: number, g: number, b: number) => (text: string) => string;
-}
-export namespace bg {
-    let black_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { black_1 as black };
-    let red_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { red_1 as red };
-    let green_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { green_1 as green };
-    let yellow_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { yellow_1 as yellow };
-    let blue_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { blue_1 as blue };
-    let magenta_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { magenta_1 as magenta };
-    let cyan_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { cyan_1 as cyan };
-    let white_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { white_1 as white };
-    let brightBlack_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { brightBlack_1 as brightBlack };
-    let brightRed_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { brightRed_1 as brightRed };
-    let brightGreen_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { brightGreen_1 as brightGreen };
-    let brightYellow_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { brightYellow_1 as brightYellow };
-    let brightBlue_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { brightBlue_1 as brightBlue };
-    let brightMagenta_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { brightMagenta_1 as brightMagenta };
-    let brightCyan_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { brightCyan_1 as brightCyan };
-    let brightWhite_1: ((s: string) => string) & {
-        open: string;
-        close: string;
-    };
-    export { brightWhite_1 as brightWhite };
-    let _default_1: string;
-    export { _default_1 as default };
-    let rgb_1: (r: number, g: number, b: number) => (text: string) => string;
-    export { rgb_1 as rgb };
-    let x256_1: (r: number, g: number, b: number) => (text: string) => string;
-    export { x256_1 as x256 };
-}

package/dist/sgr.js

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * @param {number | string} open
- * @param {number | string} close
- */
-function sgr(open, close) {
-    const openSequence = `\x1b[${open}m`;
-    const closeSequence = `\x1b[${close}m`;
-    return Object.assign(
-    /** @type {(text: string) => string} */
-    s => openSequence +
-        s.replaceAll(openSequence, '').replaceAll(closeSequence, openSequence) +
-        closeSequence, { open: openSequence, close: closeSequence });
-}
-/** @type {(r: number, g: number, b: number, open: number, close: number) => (text: string) => string} */
-const rgb = (r, g, b, open, close) => sgr(`${open};2;${r};${g};${b}`, close);
-/** @type {(r: number, g: number, b: number, open: number, close: number) => (text: string) => string} */
-function x256(r, g, b, open, close) {
-    if (r === g && g === b) {
-        // grayscale
-        return sgr(`${open};5;${232 + Math.floor(r * 24 / 256)}`, close);
-    }
-    // 6x6x6 color cube
-    return sgr(`${open};5;${16 +
-        Math.floor(r * 6 / 256) * 36 +
-        Math.floor(g * 6 / 256) * 6 +
-        Math.floor(b * 6 / 256)}`, close);
-}
-const reset = "\x1b[0m";
-const style = {
-    bold: sgr(1, 22),
-    dim: sgr(2, 22),
-    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),
-};
-const fg = {
-    black: sgr(30, 39),
-    red: sgr(31, 39),
-    green: sgr(32, 39),
-    yellow: sgr(33, 39),
-    blue: sgr(34, 39),
-    magenta: sgr(35, 39),
-    cyan: sgr(36, 39),
-    white: sgr(37, 39),
-    brightBlack: sgr(90, 39),
-    brightRed: sgr(91, 39),
-    brightGreen: sgr(92, 39),
-    brightYellow: sgr(93, 39),
-    brightBlue: sgr(94, 39),
-    brightMagenta: sgr(95, 39),
-    brightCyan: sgr(96, 39),
-    brightWhite: sgr(97, 39),
-    default: "\x1b[39m",
-    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
-    rgb: (r, g, b) => rgb(r, g, b, 38, 39),
-    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
-    x256: (r, g, b) => x256(r, g, b, 38, 39),
-};
-const bg = {
-    black: sgr(40, 49),
-    red: sgr(41, 49),
-    green: sgr(42, 49),
-    yellow: sgr(43, 49),
-    blue: sgr(44, 49),
-    magenta: sgr(45, 49),
-    cyan: sgr(46, 49),
-    white: sgr(47, 49),
-    brightBlack: sgr(100, 49),
-    brightRed: sgr(101, 49),
-    brightGreen: sgr(102, 49),
-    brightYellow: sgr(103, 49),
-    brightBlue: sgr(104, 49),
-    brightMagenta: sgr(105, 49),
-    brightCyan: sgr(106, 49),
-    brightWhite: sgr(107, 49),
-    default: "\x1b[49m",
-    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
-    rgb: (r, g, b) => rgb(r, g, b, 48, 49),
-    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
-    x256: (r, g, b) => x256(r, g, b, 48, 49),
-};
-module.exports = { reset, style, fg, bg };

package/src/sgr.js

@@ -1,113 +0,0 @@
-"use strict";
-
-/**
- * @param {number | string} open
- * @param {number | string} close
- */
-function sgr(open, close) {
-	const openSequence  = `\x1b[${open}m`;
-	const closeSequence = `\x1b[${close}m`;
-
-	return Object.assign(
-		/** @type {(text: string) => string} */
-		s =>
-			openSequence +
-			s.replaceAll(openSequence, '').replaceAll(closeSequence, openSequence) +
-			closeSequence,
-		{open: openSequence, close: closeSequence}
-	);
-}
-
-/** @type {(r: number, g: number, b: number, open: number, close: number) => (text: string) => string} */
-const rgb = (r, g, b, open, close) => sgr(`${open};2;${r};${g};${b}`, close);
-
-/** @type {(r: number, g: number, b: number, open: number, close: number) => (text: string) => string} */
-function x256(r, g, b, open, close) {
-	if (r === g && g === b) {
-		// grayscale
-		return sgr(`${open};5;${232 + Math.floor(r * 24 / 256)}`, close);
-	}
-
-	// 6x6x6 color cube
-	return sgr(
-		`${open};5;${
-			16 +
-			Math.floor(r * 6 / 256) * 36 +
-			Math.floor(g * 6 / 256) * 6 +
-			Math.floor(b * 6 / 256)
-		}`,
-		close,
-	);
-}
-
-const reset = "\x1b[0m";
-
-const style = {
-	bold            : sgr(1, 22),
-	dim             : sgr(2, 22),
-	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),
-};
-
-const fg = {
-	black   : sgr(30, 39),
-	red     : sgr(31, 39),
-	green   : sgr(32, 39),
-	yellow  : sgr(33, 39),
-	blue    : sgr(34, 39),
-	magenta : sgr(35, 39),
-	cyan    : sgr(36, 39),
-	white   : sgr(37, 39),
-
-	brightBlack   : sgr(90, 39),
-	brightRed     : sgr(91, 39),
-	brightGreen   : sgr(92, 39),
-	brightYellow  : sgr(93, 39),
-	brightBlue    : sgr(94, 39),
-	brightMagenta : sgr(95, 39),
-	brightCyan    : sgr(96, 39),
-	brightWhite   : sgr(97, 39),
-
-	default : "\x1b[39m",
-
-	/** @type {(r: number, g: number, b: number) => (text: string) => string} */
-	rgb  : (r, g, b) => rgb(r, g, b, 38, 39),
-	/** @type {(r: number, g: number, b: number) => (text: string) => string} */
-	x256 : (r, g, b) => x256(r, g, b, 38, 39),
-};
-
-const bg = {
-	black   : sgr(40, 49),
-	red     : sgr(41, 49),
-	green   : sgr(42, 49),
-	yellow  : sgr(43, 49),
-	blue    : sgr(44, 49),
-	magenta : sgr(45, 49),
-	cyan    : sgr(46, 49),
-	white   : sgr(47, 49),
-
-	brightBlack   : sgr(100, 49),
-	brightRed     : sgr(101, 49),
-	brightGreen   : sgr(102, 49),
-	brightYellow  : sgr(103, 49),
-	brightBlue    : sgr(104, 49),
-	brightMagenta : sgr(105, 49),
-	brightCyan    : sgr(106, 49),
-	brightWhite   : sgr(107, 49),
-
-	default : "\x1b[49m",
-
-	/** @type {(r: number, g: number, b: number) => (text: string) => string} */
-	rgb  : (r, g, b) => rgb(r, g, b, 48, 49),
-	/** @type {(r: number, g: number, b: number) => (text: string) => string} */
-	x256 : (r, g, b) => x256(r, g, b, 48, 49),
-};
-
-module.exports = {reset, style, fg, bg};