@peteanderson/ansi 0.2.4 → 0.3.1

package/dist/pad.js

@@ -0,0 +1,15 @@
+"use strict";
+const { visibleLength } = require("./strip");
+/**
+ * Pad the given text at the end with the specified fill string to the target visible length without
+ * counting ANSI escape codes.
+ * @type {(text: string, targetLength: number, fillString?: string) => string}
+ */
+const padEnd = (text, targetLength, fillString = " ") => text + fillString.repeat(Math.max(0, targetLength - visibleLength(text)) / fillString.length);
+/**
+ * Pad the given text at the start with the specified fill string to the target visible length
+ * without counting ANSI escape codes.
+ * @type {(text: string, targetLength: number, fillString?: string) => string}
+ */
+const padStart = (text, targetLength, fillString = " ") => fillString.repeat(Math.max(0, targetLength - visibleLength(text)) / fillString.length) + text;
+module.exports = { padEnd, padStart };

package/dist/patterns.d.ts

@@ -0,0 +1,3 @@
+export const rxSGR: Readonly<RegExp>;
+export const rxCSI: Readonly<RegExp>;
+export const rxUnsafe: Readonly<RegExp>;

package/dist/patterns.js

@@ -0,0 +1,43 @@
+"use strict";
+/*
+I'm freezing these to prevent accidental mutation of the `lastIndex` property, which could keep
+future calls from starting at the beginning of the string.
+
+Code using these objects will have to clone them (with `new RegExp(rx)`) before using functions
+that modify `lastIndex` (such as `exec`). But according to my benchmarks, cloning the regex takes
+mere nanoseconds, and it wasn't even measurable when operating on longer strings. V8 clearly uses a
+global cache of compiled regexes. I assume that SpiderMonkey does the same thing.
+
+Here are my `timeit` benchmark results:
+
+```js
+const {timeit} = require("$timeit");
+
+const rxSGR = /\x1b\[[\d;]*m/g;
+const short = "\x1b[31mred \x1b[32mgreen \x1b[34mblue \x1b[0m";
+const long  = short.repeat(1000);
+
+timeit(() => short.replace(rxSGR, ""),                         {description: "short - no clone     "});
+timeit(() => short.replace(new RegExp(rxSGR), ""),             {description: "short - clone object "});
+timeit(() => short.replace(new RegExp(rxSGR.source, "g"), ""), {description: "short - clone source "});
+
+console.log();
+
+timeit(() => long .replace(rxSGR, ""),                         {description: "long  - no clone     "});
+timeit(() => long .replace(new RegExp(rxSGR), ""),             {description: "long  - clone object "});
+timeit(() => long .replace(new RegExp(rxSGR.source, "g"), ""), {description: "long  - clone source "});
+
+// Output:
+// short - no clone     : 82.73 ns (12,087,731 in 1.000016982 s)
+// short - clone object : 142.132 ns (7,035,692 in 1.0000001770000002 s)
+// short - clone source : 127.872 ns (7,820,293 in 1.00000017 s)
+//
+// long  - no clone     : 47.953 ųs (20,854 in 1.0000098149999999 s)
+// long  - clone object : 46.713 ųs (21,408 in 1.0000285520000003 s)
+// long  - clone source : 46.491 ųs (21,510 in 1.000026492 s)
+```
+*/
+const rxSGR = Object.freeze(/\x1b\[[\d;]*m/g);
+const rxCSI = Object.freeze(/\x1b\[[0-?]*[ -/]*[@-~]/g);
+const rxUnsafe = Object.freeze(/\x1b\[[0-?]*[ -/]*[@-ln-~]/g); // Everything except SGR codes (m).
+module.exports = { rxSGR, rxCSI, rxUnsafe };

package/dist/scroll.d.ts

@@ -0,0 +1,6 @@
+export function makeScroll(enabled?: boolean): {
+    /** @type {(lines?: number) => string} */
+    up: (lines?: number) => string;
+    /** @type {(lines?: number) => string} */
+    down: (lines?: number) => string;
+};

package/dist/scroll.js

@@ -0,0 +1,14 @@
+"use strict";
+const scroll = {
+    /** @type {(lines?: number) => string} */
+    up: lines => `\x1b[${lines ?? 1}S`,
+    /** @type {(lines?: number) => string} */
+    down: lines => `\x1b[${lines ?? 1}T`,
+};
+/** @type {typeof scroll} */
+const disabled = {
+    up: () => "",
+    down: () => "",
+};
+const makeScroll = (enabled = true) => enabled ? scroll : disabled;
+module.exports = { makeScroll };

package/dist/sgr/color/color.d.ts

@@ -0,0 +1,9 @@
+export type Code = import("../sgr").Code;
+export type ColorDepth = import("../../features/types").ColorDepth;
+export type SGR = import("../sgr").SGR;
+export type Channel = import("./types").Channel;
+/** @type {(colorDepth: ColorDepth) => {fg: Channel, bg: Channel}} */
+export const makeColor: (colorDepth: ColorDepth) => {
+    fg: Channel;
+    bg: Channel;
+};

package/dist/sgr/color/color.js

@@ -0,0 +1,76 @@
+"use strict";
+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/dist/sgr/color/index.d.ts

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

package/dist/sgr/color/index.js

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

package/dist/sgr/color/utils.d.ts

@@ -0,0 +1,27 @@
+export type Code = import("../sgr").Code;
+export function rgbToX256(r: number, g: number, b: number): number;
+export function x256ToRgb(code: number): [number, number, number];
+export function rgbToX16(r: number, g: number, b: number): number;
+export function rgbToX8(r: number, g: number, b: number): number;
+/**
+ * @overload
+ * @param   {number} x
+ * @returns {number}
+ * @overload
+ * @param   {number} r
+ * @param   {number} g
+ * @param   {number} b
+ * @returns {[number, number, number]}
+ */
+export function clip(x: number): number;
+/**
+ * @overload
+ * @param   {number} x
+ * @returns {number}
+ * @overload
+ * @param   {number} r
+ * @param   {number} g
+ * @param   {number} b
+ * @returns {[number, number, number]}
+ */
+export function clip(r: number, g: number, b: number): [number, number, number];

package/dist/sgr/color/utils.js

@@ -0,0 +1,67 @@
+"use strict";
+/** @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/dist/sgr/index.d.ts

@@ -0,0 +1,9 @@
+declare const _exports: {
+    makeColor: (colorDepth: ColorDepth) => {
+        fg: Channel;
+        bg: Channel;
+    };
+    makeStyle: typeof import("./style").makeStyle;
+    makeReset: (enabled?: boolean) => "" | "\u001B[0m";
+};
+export = _exports;

package/dist/sgr/index.js

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

package/dist/sgr/reset.d.ts

@@ -0,0 +1 @@
+export function makeReset(enabled?: boolean): "" | "\u001B[0m";

package/dist/sgr/reset.js

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

package/dist/sgr/sgr.d.ts

@@ -0,0 +1,14 @@
+export type Code = number | number[];
+export type SGR = {
+    (text: string): string;
+    open: string;
+    close: string;
+    codes: {
+        open: Code;
+        close: Code;
+    };
+    combine: (...styles: SGR[]) => SGR;
+};
+export function makeSGR(enabled?: boolean): typeof sgr;
+declare function sgr(open: Code, close: Code, reset?: boolean): SGR;
+export {};

package/dist/sgr/sgr.js

@@ -0,0 +1,57 @@
+"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} */ /** @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/dist/sgr/style.d.ts

@@ -0,0 +1,13 @@
+export function makeStyle(enabled?: boolean): {
+    bold: import("./sgr").SGR;
+    dim: import("./sgr").SGR;
+    italic: import("./sgr").SGR;
+    underline: import("./sgr").SGR;
+    inverse: import("./sgr").SGR;
+    hidden: import("./sgr").SGR;
+    strikethrough: import("./sgr").SGR;
+    doubleUnderline: import("./sgr").SGR;
+    frame: import("./sgr").SGR;
+    encircle: import("./sgr").SGR;
+    overline: import("./sgr").SGR;
+};

package/dist/sgr/style.js

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

@@ -0,0 +1,2 @@
+export type Code = number | number[];
+export function combine(code: Code, codes: Code[]): Code;

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,25 @@
+"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/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 };