// #region ANSI section

const ESC = "\u001b";

const BrightClassPostfix = "-br";

// match characters that could be enclosing url to cleanly handle url formatting

export const URLRegex = /([{([]*https?:\/\/[a-z0-9]+(?:-[a-z0-9]+)*\.[^\s<>|'",]{2,})/gi;

/**

* Regex for matching ANSI escape codes

* \u001b - ESC character

* ?: Non-capturing group

* (?:\u001b[) : Match ESC[

* (?:[\?|#])??: Match also ? and # formats that we don't supports but want to eat our special characters to get rid of ESC character

* (?:[0-9]{1,3})?: Match one or more occurrences of the simple format we want with out semicolon

* (?:(?:;[0-9]{0,3})*)?: Match one or more occurrences of the format we want with semicolon

*/

// eslint-disable-next-line no-control-regex

const _ansiEscapeCodeRegex = /(?:\u001b\[)(?:[?|#])?(?:(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-Z|a-z])/;

/**

* https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters

* We support sequences of format:

* Esc[CONTENTHEREm

* Where CONTENTHERE can be of format: VALUE;VALUE;VALUE or VALUE

* Where VALUE is SGR parameter https://www.vt100.net/docs/vt510-rm/SGR

* We support: 0 (reset), 1 (bold), 3 (italic), 4 (underline), 22 (not bold), 23 (not italic), 24 (not underline), 38 (set fg), 39 (default fg), 48 (set bg), 49 (default bg),

* fg colors - 30 (black), 31 (red), 32 (green), 33 (yellow), 34 (blue), 35 (magenta), 36 (cyan), 37 (white), 90 (grey)

* with more brightness - 91 (red), 92 (green), 93 (yellow), 94 (blue), 95 (magenta), 96 (cyan), 97 (white)

* bg colors - 40 (black), 41 (red), 42 (green), 43 (yellow), 44 (blue), 45 (magenta), 46 (cyan), 47 (white), 100 (grey)

* with more brightness- 101 (red), 102 (green), 103 (yellow), 104 (blue), 105 (magenta), 106 (cyan), 107 (white)

* Where m refers to the "Graphics mode"

*

* 8-bit color is supported

* https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit

* Esc[38;5;<n> To set the foreground color

* Esc[48;5;<n> To set the background color

* n can be from 0-255

* 0-7 are standard colors that match the 4_bit color palette

* 8-15 are high intensity colors that match the 4_bit high intensity color palette

* 16-231 are 216 colors that cover the entire spectrum

* 232-255 are grayscale colors that go from black to white in 24 steps

*

* 24-bit color is also supported

* https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit

* Esc[38;2;<r>;<g>;<b> To set the foreground color

* Esc[48;2;<r>;<g>;<b> To set the background color

* Where r,g and b must be between 0-255

*/

// #endregion ANSI section

// #region commands

enum Resets {

Reset = "0",

Bold = "22",

Italic = "23",

Underline = "24",

Set_Fg = "38",

Default_Fg = "39",

Set_Bg = "48",

Default_Bg = "49"

}

const specials = {

"1": "bold",

"3": "italic",

"4": "underline"

} as {[key: string]: string};

const bgColors = {

// 40 (black), 41 (red), 42 (green), 43 (yellow), 44 (blue), 45 (magenta), 46 (cyan), 47 (white), 100 (grey)

"40": "b",

"41": "r",

"42": "g",

"43": "y",

"44": "bl",

"45": "m",

"46": "c",

"47": "w",

"100": "gr"

} as {[key: string]: string};

const fgColors = {

// 30 (black), 31 (red), 32 (green), 33 (yellow), 34 (blue), 35 (magenta), 36 (cyan), 37 (white), 90 (grey)

"30": "b",

"31": "r",

"32": "g",

"33": "y",

"34": "bl",

"35": "m",

"36": "c",

"37": "w",

"90": "gr"

} as {[key: string]: string};

const base8BitColors = {

// 0 (black), 1 (red), 2 (green), 3 (yellow), 4 (blue), 5 (magenta), 6 (cyan), 7 (white), 8 (grey)

"0": "b",

"1": "r",

"2": "g",

"3": "y",

"4": "bl",

"5": "m",

"6": "c",

"7": "w"

} as Record<string, string>;

// VS Code default values taken from this table: https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit

export const VSCodeDefaultColors = {

b: "#000000", // '30/40',

r: "#cd3131", // '31/41',

g: "#0dbc79", // '32/42',

y: "#e5e510", // '33/43',

bl: "#2472c8", // '34/44',

m: "#bc3fbc", // '35/45',

c: "#11a8cd", // '36/46',

w: "#e5e5e5", // '37/47',

gr: "#666666", // '90/100'

"b-br": "#666666", // '90/100',

"r-br": "#f14c4c", // '91/101',

"g-br": "#23d18b", // '92/102',

"y-br": "#f5f543", // '93/103',

"bl-br": "#3b8eea", // '94/104',

"m-br": "#d670d6", // '95/105',

"c-br": "#21b8db", // '96/106',

"w-br": "#e5e5e5" // '97/107',

} as Record<string, string>;

//0-255 in 6 increments, used to generate 216 equally incrementing colors

const colorIncrements216 = {

0: 0,

1: 51,

2: 102,

3: 153,

4: 204,

5: 255

} as Record<number, number>;

// #endregion commands

export interface IStyle {

fg: string;

bg: string;

isFgRGB: boolean;

isBgRGB: boolean;

bold: boolean;

italic: boolean;

underline: boolean;

[key: string]: boolean | string;

}

interface IRGBColor {

r: number;

g: number;

b: number;

}

interface IAnsiEscapeCodeState {

output: string;

style?: IStyle;

}

export class Parser {

/**

* Parses the content into ANSI states

* @param content content to parse

*/

public getStates(content: string): IAnsiEscapeCodeState[] {

const result: IAnsiEscapeCodeState[] = [];

// Eg: "ESC[0KESC[33;1mWorker informationESC[0m

if (!_ansiEscapeCodeRegex.test(content)) {

// Not of interest, don't touch content

return [

{

output: content

}

];

}

let command = "";

let currentText = "";

let code = "";

let state = {} as IAnsiEscapeCodeState;

let isCommandActive = false;

let codes = [];

for (let index = 0; index < content.length; index++) {

const character = content[index];

if (isCommandActive) {

if (character === ";") {

if (code) {

codes.push(code);

code = "";

}

} else if (character === "m") {

if (code) {

isCommandActive = false;

// done

codes.push(code);

state.style = state.style || ({} as IStyle);

let setForeground = false;

let setBackground = false;

let isSingleColorCode = false;

let isRGBColorCode = false;

const rgbColors: number[] = [];

for (const currentCode of codes) {

const style = state.style;

const codeNumber = parseInt(currentCode);

if (setForeground && isSingleColorCode) {

// set foreground color using 8-bit (256 color) palette - Esc[ 38:5:<n> m

if (codeNumber >= 0 && codeNumber < 16) {

style.fg = this._get8BitColorClasses(codeNumber);

} else if (codeNumber >= 16 && codeNumber < 256) {

style.fg = this._get8BitRGBColors(codeNumber);

style.isFgRGB = true;

}

setForeground = false;

isSingleColorCode = false;

} else if (setForeground && isRGBColorCode) {

// set foreground color using 24-bit (true color) palette - Esc[ 38:2:<r>:<g>:<b> m

if (codeNumber >= 0 && codeNumber < 256) {

rgbColors.push(codeNumber);

if (rgbColors.length === 3) {

style.fg = `${rgbColors[0]},${rgbColors[1]},${rgbColors[2]}`;

style.isFgRGB = true;

rgbColors.length = 0; // clear array

setForeground = false;

isRGBColorCode = false;

}

}

} else if (setBackground && isSingleColorCode) {

// set background color using 8-bit (256 color) palette - Esc[ 48:5:<n> m

if (codeNumber >= 0 && codeNumber < 16) {

style.bg = this._get8BitColorClasses(codeNumber);

} else if (codeNumber >= 16 && codeNumber < 256) {

style.bg = this._get8BitRGBColors(codeNumber);

style.isBgRGB = true;

}

setBackground = false;

isSingleColorCode = false;

} else if (setBackground && isRGBColorCode) {

// set background color using 24-bit (true color) palette - Esc[ 48:2:<r>:<g>:<b> m

if (codeNumber >= 0 && codeNumber < 256) {

rgbColors.push(codeNumber);

if (rgbColors.length === 3) {

style.bg = `${rgbColors[0]},${rgbColors[1]},${rgbColors[2]}`;

style.isBgRGB = true;

rgbColors.length = 0; // clear array

setBackground = false;

isRGBColorCode = false;

}

}

} else if (setForeground || setBackground) {

if (codeNumber === 5) {

isSingleColorCode = true;

} else if (codeNumber === 2) {

isRGBColorCode = true;

}

} else if (fgColors[currentCode]) {

style.fg = fgColors[currentCode];

} else if (bgColors[currentCode]) {

style.bg = bgColors[currentCode];

} else if (currentCode === Resets.Reset) {

// reset

state.style = {} as IStyle;

} else if (currentCode === Resets.Set_Bg) {

setBackground = true;

} else if (currentCode === Resets.Set_Fg) {

setForeground = true;

} else if (currentCode === Resets.Default_Fg) {

style.fg = "";

} else if (currentCode === Resets.Default_Bg) {

style.bg = "";

} else if (codeNumber >= 91 && codeNumber <= 97) {

style.fg = fgColors[codeNumber - 60] + BrightClassPostfix;

} else if (codeNumber >= 101 && codeNumber <= 107) {

style.bg = bgColors[codeNumber - 60] + BrightClassPostfix;

} else if (specials[currentCode]) {

style[specials[currentCode]] = true;

} else if (currentCode === Resets.Bold) {

style.bold = false;

} else if (currentCode === Resets.Italic) {

style.italic = false;

} else if (currentCode === Resets.Underline) {

style.underline = false;

}

}

// clear

command = "";

currentText = "";

code = "";

} else {

// To handle ESC[m, we should just ignore them

isCommandActive = false;

command = "";

state.style = {} as IStyle;

}

codes = [];

} else if (isNaN(parseInt(character))) {

// if this is not a number, eg: 0K, this isn't something we support

code = "";

isCommandActive = false;

command = "";

} else if (code.length === 4) {

// we probably got code that we don't support, ignore

code = "";

isCommandActive = false;

if (character !== ESC) {

// if this is not an ESC, let's not consider command from now on

// eg: ESC[0Ksometexthere, at this point, code would be 0K, character would be 's'

command = "";

currentText += character;

}

} else {

code += character;

}

continue;

} else if (command) {

if (command === ESC && character === "[") {

isCommandActive = true;

// push state

if (currentText) {

state.output = currentText;

result.push(state);

// deep copy existing style for the line to preserve different styles between commands

let previousStyle;

if (state.style) {

previousStyle = Object.assign({}, state.style);

}

state = {} as IAnsiEscapeCodeState;

if (previousStyle) {

state.style = previousStyle;

}

currentText = "";

}

}

continue;

}

if (character === ESC) {

command = character;

} else {

currentText += character;

}

}

// still pending text

if (currentText) {

state.output = currentText + (command ? command : "");

result.push(state);

}

return result;

}

/**

* Gets a unique key for each style

* @param style style to get key for

* @returns a string that is guaranteed to be unique for every different style

*/

public static styleKey(style: IStyle): string {

const fg = style.fg ?? "-";

const bg = style.bg ?? "-";

const bold = style.bold ? "b" : "n";

const ital = style.italic ? "i" : "n";

const underline = style.underline ? "u" : "n";

return fg + bg + bold + ital + underline;

}

/**

* With 8 bit colors, from 16-256, rgb color combinations are used

* 16-231 (216 colors) is a 6 x 6 x 6 color cube

* 232 - 256 are grayscale colors

* @param codeNumber 16-256 number

*/

private _get8BitRGBColors(codeNumber: number): string {

let rgbColor: IRGBColor;

if (codeNumber < 232) {

rgbColor = this._get216Color(codeNumber - 16);

} else {

rgbColor = this._get8bitGrayscale(codeNumber - 232);

}

return `${rgbColor.r},${rgbColor.g},${rgbColor.b}`;

}

/**

* With 8 bit color, from 0-15, css classes are used to represent customer colors

* @param codeNumber 0-15 number that indicates the standard or high intensity color code that should be used

*/

private _get8BitColorClasses(codeNumber: number): string {

let colorClass = "";

if (codeNumber < 8) {

colorClass = `${base8BitColors[codeNumber]}`;

} else {

colorClass = `${base8BitColors[codeNumber - 8] + BrightClassPostfix}`;

}

return colorClass;

}

/**

* 6 x 6 x 6 (216 colors) rgb color generator

* https://en.wikipedia.org/wiki/Web_colors#Web-safe_colors

* @param increment 0-215 value

*/

private _get216Color(increment: number): IRGBColor {

return {

r: colorIncrements216[Math.floor(increment / 36)],

g: colorIncrements216[Math.floor(increment / 6) % 6],

b: colorIncrements216[increment % 6]

};

}

/**

* Grayscale from black to white in 24 steps. The first value of 0 represents rgb(8,8,8) while the last value represents rgb(238,238,238)

* @param increment 0-23 value

*/

private _get8bitGrayscale(increment: number): IRGBColor {

const colorCode = increment * 10 + 8;

return {

r: colorCode,

g: colorCode,

b: colorCode

};

}

}