@peteanderson/ansi 0.2.1 → 0.2.2

package/README.md

@@ -19,6 +19,7 @@ console.log(ansi.style.bold("important"));
 console.log(ansi.fg.rgb(5, 2, 0)("custom color"));
 console.log(ansi.strip("styled text")); // remove all ANSI codes
 console.log(ansi.slice("styled text", 0, 5)); // slice by visible length
+console.log(ansi.simplify(styledText)); // combine adjacent SGR sequences
 ```
 
 ## API
@@ -52,8 +53,7 @@ Functions that wrap text with style codes:
 `bold` `dim` `italic` `underline` `inverse` `hidden` `strikethrough` `doubleUnderline` `framed`
 `encircled` `overline`
 
-All return functions with `open` and `close` properties for raw sequences. SGR functions also have a
-`combine()` method for appending additional styles.
+All return functions with `open` and `close` properties for raw sequences.
 
 ### `caret`
 
@@ -90,6 +90,11 @@ but counts only visible characters.
 
 Removes "unsafe" CSI sequences (non-SGR), leaving only color and style codes.
 
+### `simplify(text)`
+
+Simplifies ANSI SGR sequences by combining adjacent sequences and removing redundant codes. Useful
+for optimizing styled strings.
+
 ## License
 
 MIT

package/dist/ansi.d.ts

@@ -8,4 +8,5 @@ import { bg } from "./sgr/color";
 import { strip } from "./strip";
 import { sanitize } from "./strip";
 import { slice } from "./strip";
-export { caret, erase, scroll, reset, style, fg, bg, strip, sanitize, slice };
+import { simplify } from "./simplify/simplify";
+export { caret, erase, scroll, reset, style, fg, bg, strip, sanitize, slice, simplify };

package/dist/ansi.js

@@ -3,6 +3,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 = {
     caret,
@@ -15,5 +16,6 @@ const ansi = {
     strip,
     sanitize,
     slice,
+    simplify,
 };
 module.exports = ansi;

package/dist/index.d.ts

@@ -101,5 +101,6 @@ declare const _exports: {
     strip: (text: string) => string;
     sanitize: (text: string) => string;
     slice: typeof import("./strip").slice;
+    simplify: typeof import("./simplify/simplify").simplify;
 };
 export = _exports;

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/package.json

@@ -1,6 +1,6 @@
 {
 	"name"            : "@peteanderson/ansi",
-	"version"         : "0.2.1",
+	"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/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 {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};