@peteanderson/ansi 0.2.3 → 0.2.4

package/dist/sgr/index.d.ts

@@ -1,59 +0,0 @@
-declare const _exports: {
-    fg: {
-        black: import("./sgr").SGR;
-        red: import("./sgr").SGR;
-        green: import("./sgr").SGR;
-        yellow: import("./sgr").SGR;
-        blue: import("./sgr").SGR;
-        magenta: import("./sgr").SGR;
-        cyan: import("./sgr").SGR;
-        white: import("./sgr").SGR;
-        brightBlack: import("./sgr").SGR;
-        brightRed: import("./sgr").SGR;
-        brightGreen: import("./sgr").SGR;
-        brightYellow: import("./sgr").SGR;
-        brightBlue: import("./sgr").SGR;
-        brightMagenta: import("./sgr").SGR;
-        brightCyan: import("./sgr").SGR;
-        brightWhite: import("./sgr").SGR;
-        default: string;
-        rgb: (r: number, g: number, b: number) => (text: string) => string;
-        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
-    };
-    bg: {
-        black: import("./sgr").SGR;
-        red: import("./sgr").SGR;
-        green: import("./sgr").SGR;
-        yellow: import("./sgr").SGR;
-        blue: import("./sgr").SGR;
-        magenta: import("./sgr").SGR;
-        cyan: import("./sgr").SGR;
-        white: import("./sgr").SGR;
-        brightBlack: import("./sgr").SGR;
-        brightRed: import("./sgr").SGR;
-        brightGreen: import("./sgr").SGR;
-        brightYellow: import("./sgr").SGR;
-        brightBlue: import("./sgr").SGR;
-        brightMagenta: import("./sgr").SGR;
-        brightCyan: import("./sgr").SGR;
-        brightWhite: import("./sgr").SGR;
-        default: string;
-        rgb: (r: number, g: number, b: number) => (text: string) => string;
-        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
-    };
-    style: {
-        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;
-    };
-    reset: "\u001B[0m";
-};
-export = _exports;

package/dist/sgr/index.js

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

package/dist/sgr/reset.d.ts

@@ -1 +0,0 @@
-export const reset: "\u001B[0m";

package/dist/sgr/reset.js

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

package/dist/sgr/sgr.d.ts

@@ -1,14 +0,0 @@
-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 sgr(open: Code, close: Code, reset?: boolean): SGR;
-declare const $codes: unique symbol;
-export {};

package/dist/sgr/sgr.js

@@ -1,47 +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/dist/sgr/style.d.ts

@@ -1,13 +0,0 @@
-export namespace style {
-    let bold: import("./sgr").SGR;
-    let dim: import("./sgr").SGR;
-    let italic: import("./sgr").SGR;
-    let underline: import("./sgr").SGR;
-    let inverse: import("./sgr").SGR;
-    let hidden: import("./sgr").SGR;
-    let strikethrough: import("./sgr").SGR;
-    let doubleUnderline: import("./sgr").SGR;
-    let frame: import("./sgr").SGR;
-    let encircle: import("./sgr").SGR;
-    let overline: import("./sgr").SGR;
-}

package/dist/sgr/style.js

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

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

package/dist/sgr/utils.js

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

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

@@ -1,28 +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/dist/simplify/index.d.ts

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

package/dist/simplify/index.js

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

package/dist/simplify/lookup.d.ts

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

@@ -1,77 +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/dist/simplify/simplify.d.ts

@@ -1 +0,0 @@
-export function simplify(text: string): string;

package/dist/simplify/simplify.js

@@ -1,25 +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/dist/simplify/state.d.ts

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

@@ -1,57 +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/dist/simplify/utils.d.ts

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

@@ -1,31 +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 };

package/dist/slice.d.ts

@@ -1 +0,0 @@
-export function slice(text: string, start: number, end: number): string;

package/dist/slice.js

@@ -1,83 +0,0 @@
-"use strict";
-const { rxCSI, rxSGR } = require("./patterns");
-const { simplify } = require("./simplify");
-const { visibleLength } = require("./strip");
-/**
-@type {
-    (
-        text            : string,
-        fromStringIndex : number,
-        visibleCount    : number,
-    ) => {index: number, length: number}
-}
-*/
-function scanCSI(text, fromStringIndex, visibleCount) {
-    // We intentionally mutate `lastIndex` here, so we need a clone.
-    const rx = new RegExp(rxCSI);
-    let length = 0;
-    let index = fromStringIndex;
-    while (index < text.length && length < visibleCount) {
-        if (text[index] === "\x1b") {
-            rx.lastIndex = index;
-            const match = rx.exec(text);
-            if (match?.index === index) {
-                index += match[0].length;
-                continue;
-            }
-        }
-        index++;
-        length++;
-    }
-    return { index, length };
-}
-/** @type {(text: string, start: number, end?: number) => string} */
-function skippedSequences(text, start, end) {
-    const sequences = text.slice(start, end).match(new RegExp(rxSGR));
-    return sequences ? simplify(sequences.join("")) : "";
-}
-/**
- * Return a slice of the given text, counting only visible characters (i.e. ignoring ANSI escape
- * codes). The returned slice will include any ANSI escape codes from within the slice. In addition,
- * SGR codes (m) from before and after the slice will be combined, simplified, and included so that
- * the terminal state before and after the slice will be the same as if the whole string were
- * printed. If you compose two or more slices together, there may be redundant SGR sequences at the
- * boundaries, but the result will be correct. You can use `simplify` to remove the redundancies.
- *
- * Note the following caveats:
- *
- *   * Any non-SGR ANSI codes prior to or after the slice will be ignored.
- *   * Control characters (such as newlines and backspaces) both outside and inside the slice are
- *     counted as visible characters.
- *
- * These caveats mean that text may not appear on screen to be the same number of characters as the
- * length of the slice, and that the terminal state may not be exactly the same at the start and end
- * of the slice as it would be if the whole string were printed. This function is intended mostly
- * for text that contains SGR codes, but no other ANSI codes or control characters.
- *
- * @type {(text: string, start: number, end: number) => string}
- */
-function slice(text, start, end) {
-    /** @type {number | undefined} */
-    let textVisibleLength;
-    const getVisibleLength = () => textVisibleLength ??= visibleLength(text);
-    if (start < 0 || end < 0) {
-        textVisibleLength = getVisibleLength();
-        if (start < 0)
-            start = Math.max(0, textVisibleLength + start);
-        if (end < 0)
-            end = Math.max(0, textVisibleLength + end);
-    }
-    if (start > end)
-        return "";
-    if (start === 0 && (end >= text.length || end >= getVisibleLength()))
-        return text;
-    const { index: startIndex, length: visibleSkipped } = scanCSI(text, 0, start);
-    const endIndex = startIndex < text.length && visibleSkipped < end
-        ? scanCSI(text, startIndex, end - visibleSkipped).index
-        : text.length;
-    // Start and end the string in the same terminal state it would be in if the string weren't sliced.
-    const leadingSequences = skippedSequences(text, 0, startIndex);
-    const trailingSequences = skippedSequences(text, endIndex);
-    return leadingSequences + text.slice(startIndex, endIndex) + trailingSequences;
-}
-module.exports = { slice };

package/dist/strip.d.ts

@@ -1,15 +0,0 @@
-/**
- * Remove all ANSI escape codes from the given text.
- * @type {(text: string) => string}
- */
-export const strip: (text: string) => string;
-/**
- * Calculate the visible length of a string with ANSI escape codes stripped.
- * @type {(text: string) => number}
- */
-export const visibleLength: (text: string) => number;
-/**
- * Remove all ANSI escape codes except SGR codes (m), which are used for color and styling.
- * @type {(text: string) => string}
- */
-export const sanitize: (text: string) => string;

package/dist/strip.js

@@ -1,18 +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 };

package/src/caret.js

@@ -1,49 +0,0 @@
-"use strict";
-
-/** @type {(code: string) => (count?: number) => string} */
-const move = code =>
-	count => `\x1b[${count === undefined ? "" : count ? count : "?"}${code}`;
-
-const caret = {
-	up       : move("A"),
-	down     : move("B"),
-	forward  : move("C"),
-	backward : move("D"),
-	nextLine : move("E"),
-	prevLine : move("F"),
-
-	/** @type {(x: number) => string} */
-	x: x => `\x1b[${x}G`,
-
-	// These are the old VT100 codes, but they're widely supported by old and new terminals. The
-	// newer VT220 codes are standardized by ECMA and ISO, and are also widely supported, but might
-	// not work in some older terminals. The VT220 codes are:
-	//
-	// ```
-	// save    : "\x1b[s",
-	// restore : "\x1b[u",
-	// ```
-	save    : "\x1b7",
-	restore : "\x1b8",
-
-	hide : "\x1b[?25l",
-	show : "\x1b[?25h",
-
-	position: {
-		get: "\x1b[6n",
-		/** @type {(x: number, y: number) => string} */
-		set: (x, y) => `\x1b[${y};${x}H`,
-	},
-
-	shape: {
-		steadyBlock       : "\x1b[2 q",
-		steadyBar         : "\x1b[6 q",
-		steadyUnderline   : "\x1b[4 q",
-		blinkingBlock     : "\x1b[1 q",
-		blinkingBar       : "\x1b[5 q",
-		blinkingUnderline : "\x1b[3 q",
-		default           : "\x1b[0 q",
-	},
-};
-
-module.exports = caret;

package/src/erase.js

@@ -1,17 +0,0 @@
-"use strict";
-
-const erase = {
-	line: {
-		toStart: "\x1b[1K",
-		toEnd  : "\x1b[0K",
-		full   : "\x1b[2K",
-	},
-	screen: {
-		toStart    : "\x1b[1J",
-		toEnd      : "\x1b[0J",
-		full       : "\x1b[2J",
-		scrollback : "\x1b[3J",
-	},
-};
-
-module.exports = erase;

package/src/index.js

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