@peteanderson/ansi 0.3.2 → 1.0.0

package/src/sgr/color/utils.js

@@ -1,81 +0,0 @@
-/** @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/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 makeReset = (enabled = true) => enabled ? "\x1b[0m" : "";
-
-module.exports = {makeReset};

package/src/sgr/sgr.js

@@ -1,77 +0,0 @@
-"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} */ 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/src/simplify/index.js

@@ -1 +0,0 @@
-module.exports = require("./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/strip.js

@@ -1,23 +0,0 @@
-"use strict";
-
-const {rxCSI, rxUnsafe} = require("./patterns");
-
-/**
- * Remove all ANSI escape codes from the given text.
- * @type {(text: string) => string}
- */
-const strip = text => text.replace(new RegExp(rxCSI), "");
-
-/**
- * Calculate the visible length of a string with ANSI escape codes stripped.
- * @type {(text: string) => number}
- */
-const visibleLength = text => strip(text).length;
-
-/**
- * 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(new RegExp(rxUnsafe), "");
-
-module.exports = {strip, visibleLength, sanitize};