@peteanderson/ansi 0.2.3 → 0.2.4

package/src/patterns.js

@@ -1,44 +0,0 @@
-/*
-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/src/scroll.js

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

package/src/sgr/color.js

@@ -1,130 +0,0 @@
-"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

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

package/src/sgr/reset.js

@@ -1,3 +0,0 @@
-const reset = "\x1b[0m";
-
-module.exports = {reset};

package/src/sgr/sgr.js

@@ -1,66 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-"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

@@ -1,20 +0,0 @@
-/** @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

@@ -1,34 +0,0 @@
-"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

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

package/src/simplify/lookup.js

@@ -1,86 +0,0 @@
-"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

@@ -1,33 +0,0 @@
-"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

@@ -1,73 +0,0 @@
-"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

@@ -1,28 +0,0 @@
-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

@@ -1,41 +0,0 @@
-"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};