@peteanderson/ansi 2.2.0 → 2.3.1

package/src/sgr/types.ts

@@ -22,7 +22,7 @@ export type ChainBuilder = <Keys extends ChainKey>(
 	baseFormat : FormatBase,
 ) => Chain<Keys>;
 
-export type Code = number | number[];
+export type Code = number | "" | ReadonlyArray<number | "">;
 
 export interface FormatBase {
 	(text: string): string;
@@ -88,5 +88,6 @@ export interface SGR {
 	fg    : Channel<Exclude<ChainKey, "fg">>;
 	bg    : Channel<Exclude<ChainKey, "bg">>;
 	style : Style;
+	plain : Format<ChainKey>;
 	reset : string;
 }

package/src/simplify/lookup.ts

@@ -1,8 +1,9 @@
 import {buildExtendedColorAtom, buildIntensityAtom} from "./atom";
 
-import type {Atom, Attribute, AttributeMap, BuildAtom} from "./types";
+import type {Atom, Attribute, AttributeMap, BuildAtom, CodeArray} from "./types";
 
-const codeMap: Record<number, [attribute: Attribute, buildAtom?: BuildAtom]> = {
+const codeMap: Record<number | "", [attribute: Attribute, buildAtom?: BuildAtom]> = {
+	""  : ["reset"],
 	0   : ["reset"],
 	1   : ["intensity", buildIntensityAtom],
 	2   : ["intensity", buildIntensityAtom],
@@ -61,7 +62,7 @@ const codeMap: Record<number, [attribute: Attribute, buildAtom?: BuildAtom]> = {
 	107 : ["bg"],
 };
 
-export function lookUpAtom(codes: number[], index: number, state: AttributeMap): Atom {
+export function lookUpAtom(codes: CodeArray, index: number, state: AttributeMap): Atom {
 	const code  = codes[index];
 	const entry = codeMap[code];
 

package/src/simplify/simplify.ts

@@ -9,12 +9,12 @@ export function simplify(text: string): string {
 	let   result = parts[0];
 
 	for (let i = 1; i < parts.length; ) {
-		let codes = parts[i++].split(";").map(Number);
-		let chunk = parts[i++];
+		const codes = parts[i++].split(";").map(s => s ? Number(s) : "");
+		let   chunk = parts[i++];
 
 		while (!chunk && i < parts.length) {
 			// Merge consecutive SGR sequences with no text between them.
-			codes.push(...parts[i++].split(";").map(Number));
+			codes.push(...parts[i++].split(";").map(s => s ? Number(s) : ""));
 			chunk = parts[i++];
 		}
 

package/src/simplify/state.ts

@@ -1,9 +1,9 @@
 import {lookUpAtom}                       from "./lookup";
 import {arraysEqual, transitionIntensity} from "./utils";
 
-import type {Attribute, AttributeMap} from "./types";
+import type {Attribute, AttributeMap, CodeArray} from "./types";
 
-const defaultCodes: Map<Attribute, number[]> = new Map([
+const defaultCodes: Map<Attribute, CodeArray> = new Map([
 	["intensity",     [22]],
 	["italic",        [23]],
 	["underline",     [24]],
@@ -16,7 +16,7 @@ const defaultCodes: Map<Attribute, number[]> = new Map([
 	["overline",      [55]],
 ]);
 
-export class State extends Map<Attribute, number[]> implements AttributeMap {
+export class State extends Map<Attribute, CodeArray> implements AttributeMap {
 	#isDefaultState(except?: Attribute): boolean {
 		for (const [attribute, defaultCode] of defaultCodes) {
 			if (attribute === except)
@@ -29,7 +29,7 @@ export class State extends Map<Attribute, number[]> implements AttributeMap {
 		return true;
 	}
 
-	update(codes: number[]): Array<number | string> {
+	update(codes: CodeArray): CodeArray {
 		let snapshot: AttributeMap = new Map(this);
 
 		const attributes = new Set<Attribute>();
@@ -58,7 +58,7 @@ export class State extends Map<Attribute, number[]> implements AttributeMap {
 				i += skip;
 		}
 
-		const rtn: Array<number | string> = [];
+		const rtn: Array<number | ""> = [];
 
 		for (const attribute of attributes) {
 			if (attribute === "reset") {

package/src/simplify/types.ts

@@ -1,3 +1,5 @@
+export type CodeArray = ReadonlyArray<number | "">;
+
 export type Attribute =
 	| "intensity"
 	| "italic"
@@ -10,19 +12,20 @@ export type Attribute =
 	| "frame"
 	| "overline"
 	| "reset"
-	| number;
+	| number
+	| "";
 
-export type AttributeMap = Map<Attribute, number[]>;
+export type AttributeMap = Map<Attribute, CodeArray>;
 
 export interface Atom {
 	attribute : Attribute;
-	code      : number[];
+	code      : CodeArray;
 	skip?     : number;
 }
 
 export type BuildAtom = (
 	attribute : Attribute,
-	codes     : number[],
+	codes     : CodeArray,
 	index     : number,
 	state     : AttributeMap,
 ) => Atom;

package/src/simplify/utils.ts

@@ -1,4 +1,6 @@
-export function arraysEqual<T>(a: T[] | undefined, b: T[] | undefined): boolean {
+import type {CodeArray} from "./types";
+
+export function arraysEqual<T>(a: readonly T[] | undefined, b: readonly T[] | undefined): boolean {
 	if (a === b)
 		return true;
 
@@ -13,7 +15,10 @@ export function arraysEqual<T>(a: T[] | undefined, b: T[] | undefined): boolean
 	return true;
 }
 
-export function transitionIntensity(previous: number[] | undefined, current: number[]): number[] {
+export function transitionIntensity(
+	previous : CodeArray | undefined,
+	current  : CodeArray,
+): CodeArray {
 	if (!previous || previous[0] === 22 || current[0] === 22)
 		return current;
 

package/src/utility-types.d.ts

@@ -15,4 +15,8 @@ type EntriesOf<T, K extends [...(keyof T)[]] = (keyof T)[]> = {
 	[P in keyof K]: K[P] extends keyof T ? EntryOf<T, K[P]> : never;
 };
 
-type SkipFirst<T> = T extends [infer First, ...infer Rest] ? Rest : [];
+type SkipFirst<T> = T extends [infer First, ...infer Rest] ? Rest : [];
+
+interface ArrayConstructor {
+	isArray(value: unknown): value is readonly unknown[];
+}