@peteanderson/ansi 0.2.0 → 0.2.2

package/dist/sgr/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+/** @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/dist/simplify/atom.d.ts

@@ -0,0 +1,3 @@
+export type BuildAtom = import("./types").BuildAtom;
+export function buildExtendedColorAtom(attribute: import("./types").Attribute, codes: number[], index: number, state: import("./types").AttributeMap): import("./types").Atom;
+export function buildIntensityAtom(attribute: import("./types").Attribute, codes: number[], index: number, state: import("./types").AttributeMap): import("./types").Atom;

package/dist/simplify/atom.js

@@ -0,0 +1,28 @@
+"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/dist/simplify/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: typeof import("./simplify");
+export = _exports;

package/dist/simplify/index.js

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

package/dist/simplify/lookup.d.ts

@@ -0,0 +1,5 @@
+export type Atom = import("./types").Atom;
+export type Attribute = import("./types").Attribute;
+export type AttributeMap = import("./types").AttributeMap;
+export type BuildAtom = import("./types").BuildAtom;
+export function lookUpAtom(codes: number[], index: number, state: AttributeMap): Atom;

package/dist/simplify/lookup.js

@@ -0,0 +1,77 @@
+"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/dist/simplify/simplify.d.ts

@@ -0,0 +1 @@
+export function simplify(text: string): string;

package/dist/simplify/simplify.js

@@ -0,0 +1,24 @@
+"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/dist/simplify/state.d.ts

@@ -0,0 +1,10 @@
+export type Attribute = import("./types").Attribute;
+export type AttributeMap = import("./types").AttributeMap;
+/** @type {AttributeMap} */
+export class State extends Map<any, any> {
+    constructor();
+    constructor(entries?: readonly (readonly [any, any])[] | null | undefined);
+    constructor();
+    constructor(iterable?: Iterable<readonly [any, any]> | null | undefined);
+    update(codes: number[]): number[];
+}

package/dist/simplify/state.js

@@ -0,0 +1,57 @@
+"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/dist/simplify/utils.d.ts

@@ -0,0 +1,2 @@
+export function arraysEqual<T>(a: T[] | undefined, b: T[] | undefined): boolean;
+export function transitionIntensity(previous: number[] | undefined, current: number[]): number[];

package/dist/simplify/utils.js

@@ -0,0 +1,31 @@
+"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/dist/strip.d.ts

@@ -4,7 +4,7 @@
  */
 export const strip: (text: string) => string;
 /**
- * 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}
  */
 export const sanitize: (text: string) => string;

package/dist/strip.js

@@ -1,14 +1,14 @@
 "use strict";
 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.
  * @type {(text: string) => string}
  */
 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name"            : "@peteanderson/ansi",
-	"version"         : "0.2.0",
+	"version"         : "0.2.2",
 	"description"     : "ANSI escape sequence generation with automatic feature detection",
 	"author"          : {
 		"name"  : "Pete Anderson",

package/src/ansi.js

@@ -4,6 +4,7 @@ const caret                    = require("./caret");
 const erase                    = require("./erase");
 const scroll                   = require("./scroll");
 const {bg, fg, reset, style}   = require("./sgr");
+const {simplify}               = require("./simplify");
 const {sanitize, slice, strip} = require("./strip");
 
 const ansi = {
@@ -19,6 +20,7 @@ const ansi = {
 	strip,
 	sanitize,
 	slice,
+	simplify,
 };
 
 module.exports = ansi;

package/src/sgr/color.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const {sgr} = require("./sgr");
+
+/** @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);
+
+/**
+ * @overload
+ * @param {number} code
+ * @param {number} open
+ * @param {number} close
+ * @returns {(text: string) => string}
+ *//**
+ * @overload
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @param {number} open
+ * @param {number} close
+ * @returns {(text: string) => string}
+ *//**
+@type {
+	(
+		...args: [number, number, number] | [number, number, number, number, number]
+	) => (text: string) => string}
+*/
+function x256(...args) {
+	if (args.length === 3)
+		return sgr([args[1], 5, args[0]], args[2]);
+
+	const [r, g, b, open, close] = args;
+	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 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),
+
+	/**
+	 * @overload
+	 * @param {number} code
+	 * @returns {(text: string) => string}
+	 *//**
+	 * @param {number} r
+	 * @param {number} g
+	 * @param {number} b
+	 * @returns {(text: string) => string}
+	 *//** @type {(arg0: number, arg1?: number, arg2?: number) => (text: string) => string} */
+	x256 : (arg0, arg1, arg2) => arg1 === undefined || arg2 === undefined
+		? x256(arg0 , 38, 39)
+		: x256(arg0, arg1, arg2, 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),
+
+	/**
+	 * @overload
+	 * @param {number} code
+	 * @returns {(text: string) => string}
+	 *//**
+	 * @param {number} r
+	 * @param {number} g
+	 * @param {number} b
+	 * @returns {(text: string) => string}
+	 *//** @type {(arg0: number, arg1?: number, arg2?: number) => (text: string) => string} */
+	x256 : (arg0, arg1, arg2) => arg1 === undefined || arg2 === undefined
+		? x256(arg0 , 48, 49)
+		: x256(arg0, arg1, arg2, 48, 49),
+};
+
+module.exports = {fg, bg};

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 reset = "\x1b[0m";
+
+module.exports = {reset};

package/src/sgr/sgr.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const $codes = Symbol();
+
+/**
+@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)),
+		),
+	});
+}
+
+module.exports = {sgr};

package/src/sgr/style.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const {sgr} = require("./sgr");
+
+const style = {
+	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 = {style};

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");