{"id":485947,"date":"2026-07-02T12:28:16","date_gmt":"2026-07-02T12:28:16","guid":{"rendered":"https:\/\/savepearlharbor.com\/?p=485947"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-29T21:00:00","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=485947","title":{"rendered":"Control Sequences (ANSI)"},"content":{"rendered":"
\n

In this series of articles, we explore the capabilities of the AutoHotkey<\/a> language by demonstrating how to output colored text to the terminal for the console version of Launcher<\/a>.<\/p>\n

Part 1: Naive algorithm and its optimization<\/a>
Part 2: Control sequences (you are here)
Part 3: Regular expressions
Part 4: Text styling and coloring library<\/p>\n

In the previous part, we rewrote the algorithm from recursive to iterative and sped up its execution by almost 22 times. However, the final code lost support for nested colors. In this part, we will try to understand why this happened, what ANSI codes are, and how they are processed by the terminal.<\/p>\n

Control sequences<\/h3>\n

Terminals<\/h4>\n

Today, a terminal<\/strong> is synonymous with a terminal emulator<\/strong> (e.g. Cmder, Windows Terminal, Ghostty, and many others), but once upon a time, terminals were quite simple devices: screen and keyboard for communicating with a remote server. These terminals received bytes of data but had no way to distinguish between different types of data received. There was no way to control the behavior of the terminal.<\/p>\n

\"DEC<\/p>\n
DEC VT-100 Terminal<\/figcaption><\/div>\n<\/figure>\n

If you search for \u201cANSI codes\u201d from the previous part, the first result you will see is the ANSI website (American National Standards Institute). The term \u201cANSI codes\u201d does not exist<\/strong>, only the institute. ANSI created a standard for escaping characters in terminals, which was later replaced by the ISO 6429<\/a> standard. ANSI also reserved some bytes for manufacturer-specific escape codes.<\/p>\n

Nowadays, these codes vary across different operating systems and terminal emulators. The emulator itself is responsible for interpreting ANSI. For example, in Cmder you can change the colors and termimnal behavior when it encounters ANSI.<\/p>\n

In PowerShell 3.0+ (which is emulated by pwsh, Cmder, and Windows Terminal), the PSReadLine module is responsible for ANSI and interactive input. Since version 5.0, it allows changing text colors using $([char]0x1b)[91m<\/code> (we\u2019ll explain what this means later)<\/em>, and since version 6.0, a more convenient syntax is available via $PSStyle<\/code>:<\/p>\n

$PSStyle.Formatting.Verbose = $PSStyle.Foreground.Cyan$PSStyle.Formatting.Debug   = $PSStyle.Foreground.DarkGray<\/code>
<\/a><\/div><\/pre>\n
In Windows, there is a mechanism called Console Virtual Terminal Sequences<\/a> at the console level. Starting with Windows 10, the console supports processing of VT100 sequences<\/a>, which allows PowerShell to correctly interpret ANSI codes from the previous part. Thanks to this mechanism, we can output identically styled text from AutoHotkey to both cmd.exe<\/code> and pwsh.exe<\/code> (or any other emulator).<\/p>\n
Escaped sequence<\/h4>\n
To tell the terminal that we want to use ANSI codes for text styling, we must use an escaped sequence<\/strong>. For this purpose, there is a special escape<\/em> character. In Unix-like systems, the escape<\/em> character is usually \\e<\/code> or \\033<\/code>. In PowerShell 6.0+ and AutoHotkey 2.0+, the escape<\/em> character is `e<\/strong>. In AutoHotkey, we used esc := Chr(27)<\/code> for reliability.<\/p>\n
In PowerShell 5.1, you must use $([char]0x1B)<\/code> or [char]27<\/code> instead of `e<\/strong>.<\/p>\n
In this article, we will use the common notation \\e<\/code>.<\/p>\n
Escaped sequences are mixed in with the main text when you type them. However, they disappear during output, since they provide information to the terminal, not to the reader of the message. Therefore, it is important to remember that the length of a message containing escaped sequence is always greater than the length of the output message<\/strong>!<\/p>\n
\"The<\/p>\n
The original message at the top contains more characters than the output message at the bottom<\/figcaption><\/div>\n<\/figure>\n
Control sequence<\/h4>\n
A control sequence begins with the combination of characters \\e<\/code> and [<\/code> — this sequence (combination) is called CSI (Control Sequence Introducer<\/strong>). It is followed by several bytes (remember that 0 is also a number). Each sequence has its own set of rules and conventions about what it does and what arguments it expects. Within the scope of this article, we will consider only one subset of control sequences — changing text color and style. They have the form CSI n1 [;n2 [; ...]] m<\/code>, where m<\/code> is the SGR function (Select Graphic Rendition<\/strong>), and each n1<\/code>, n2<\/code>, \u2026 is an SGR parameter. We are working with single-byte set (\\e[n1;n2m...<\/code>), so n1<\/code> is a number from 0 to 7 (text or cursor style); n1<\/code> is a number from 0 to 107 (color).<\/p>\n
In the early ANSI standard, only 8 colors were available for changing text and background color. The n2<\/code> values 30-37 for the foreground color, and 40-47 for the background color. Later, high-intensity color codes appeared: 90-97 (foreground) and 100-107 (background). This set is called \u201csingle-byte\u201d and it is what we used in the previous part.<\/p>\n
The control sequence also disappears from the output message, since it is a form of escaped sequence.<\/p>\n
256 colors<\/h4>\n
If 8 colors are not enough (which is quite possible), we can use a longer sequence for a palette of 256 colors. The ANSI sequence for using 8-bit color looks as follows: \\e[<text | background code>;5;n<\/code>, where the first code is 38 (text color) or 48 (background color); n<\/code> is a color from 0 to 255. For example, the sequence \\e[38;5;220m<\/code> changes the text color to dark yellow. The range of 256 colors is divided into several sections: 0\u20137 are standard colors, 8\u201315 are bright colors, 16\u2013231 is a 6\u00d76\u00d76 color cube, and 232\u2013255 are grayscale shades.<\/p>\n
\"Available<\/p>\n
Available spectrum<\/figcaption><\/div>\n<\/figure>\n
Various examples of sequences can be found here<\/a>.<\/p>\n
Sequence termination<\/h4>\n
If the terminating combination of the sequence is not specified, it will be applied to all subsequent text output by our code to the screen (whether in PowerShell or AutoHotkey). When running the code snippet below, you will notice that the text on the new line is still bold and inverted. Additionally, the first line break character in the prompt has changed.<\/p>\n
\"Formatting<\/p>\n
Formatting affects the entire prompt and it doesn’t updates<\/figcaption><\/div>\n<\/figure>\n
To terminate the sequence, it is sufficient to add \\e[0m<\/code> at the end. This combination resets the previously applied style, color, and so on.<\/p>\n
\"Full<\/p>\n
Full reset<\/figcaption><\/div>\n<\/figure>\n
An alternative option is to reset each code separately. For example, the sequence \\e[1;7m<\/code> will make the font bold and invert the foreground and background colors. To reset only the inversion, you should add \\e[27m<\/code>. The text will remain bold but not inverted. To reset the bold text, you need to add \\e[22m<\/code>. The text would no longer be inverted or bold.<\/p>\n
\"Partial<\/p>\n
Partial reset<\/figcaption><\/div>\n<\/figure>\n
Control Sequences<\/h4>\n
Now that we know that we need to add \\e[n1;n2m<\/code> at the beginning to change foreground color (e.g. \\e[0;96m<\/code>) and \\e[0m<\/code> at the end, it becomes obvious that the message consists of several control sequences<\/strong>:<\/p>\n
\\e[0;96m message \\e[0m<\/code>
<\/a><\/div><\/pre>\n
Spaces are added for readability<\/em>. Henceforth in the article, we will use the phrase control sequences<\/strong>, since \\e[0;96m<\/code> is one sequence; \\e[0m<\/code> is also one sequence; and the plural form indicates the presence of several such sequences<\/strong> in the message.<\/p>\n
Now that we have figured out what ANSI codes from the previous part actually are, we can call them by their proper name: control sequences.<\/p>\n
Solution for Nested Colors<\/h3>\n
State Machine<\/h4>\n
Let\u2019s return to our console output algorithm and understand why nested colors is not working, i.e. changing the text (foreground) color inside already colored text.<\/p>\n
Control sequences operate on the principle of a finite state machine with a single set of current attributes<\/strong>. The terminal stores exactly one set of active graphic properties in memory: text color, background color, and style (italic, underline, etc.). Each new sequence overwrites<\/strong> the corresponding attributes rather than pushing them onto a stack.<\/p>\n
Suppose we have a message that we want to color as follows:<\/p>\n
<cyan>text<green>and<\/green>text<\/cyan><\/code>
<\/a><\/div><\/pre>\n
HTML tags are provided for readability and understanding of colors. We need to wrap the text in control sequences:<\/p>\n
\"text and text\".Color(\".+\", \"cyan\").Color(\"and\", \"green\")<\/code>
<\/a><\/div><\/pre>\n
The Color()<\/code> method will apply control sequences in the following order:<\/p>\n
\\e[0;96m text \\e[0;92m and \\e[0m text \\e[0m<\/code>
<\/a><\/div><\/pre>\n
\n
<\/figure>\n
Let\u2019s break down step by step how the terminal interprets this:<\/p>\n<\/div>\n
\n
\n\n\n\n\n\n\n\n\n\n\n
\n
Step<\/p>\n<\/th>\n
\n
Sequence<\/p>\n<\/th>\n
\n
Terminal state after application<\/p>\n<\/th>\n<\/tr>\n
\n
1<\/p>\n<\/td>\n
\n
\\e[0;96m<\/code><\/p>\n<\/td>\n
\n
Reset all attributes, then set the text color to cyan (96)<\/p>\n<\/td>\n<\/tr>\n
\n
2<\/p>\n<\/td>\n
\n
Output text<\/code><\/p>\n<\/td>\n
\n
Cyan text color<\/p>\n<\/td>\n<\/tr>\n
\n
3<\/p>\n<\/td>\n
\n
\\e[0;92m <\/code><\/p>\n<\/td>\n
\n
Reset all attributes. Change the text color to green (92)<\/p>\n<\/td>\n<\/tr>\n
\n
4<\/p>\n<\/td>\n
\n
Output and<\/code><\/p>\n<\/td>\n
\n
Green text color<\/p>\n<\/td>\n<\/tr>\n
\n
5<\/p>\n<\/td>\n
\n
\\e[0m<\/code><\/p>\n<\/td>\n
\n
Reset all attributes<\/p>\n<\/td>\n<\/tr>\n
\n
6<\/p>\n<\/td>\n
\n
Output text<\/code><\/p>\n<\/td>\n
\n
Default color<\/p>\n<\/td>\n<\/tr>\n
\n
7<\/p>\n<\/td>\n
\n
\\e[0m <\/code><\/p>\n<\/td>\n
\n
Reset all attributes (redundant, the state has already been reset)<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n
On the third step a full reset<\/strong> occurs. The terminal does not remember that the color was cyan before. Due to the lack of a stack, this information is lost. Unlike HTML\/CSS, where each element has its own set of styles and the browser calculates the cascade, the terminal works with a global state<\/strong>.<\/p>\n
Thus, the correct sequence looks like this:<\/p>\n
\\e[0;96m text \\e[0;92m and \\e[0;96m text \\e[0m<\/code>
<\/a><\/div><\/pre>\n
<\/figure>\n
You can test control sequences on the ansi101<\/a> and ansi.tools<\/a> websites.<\/p>\n
Stack<\/h4>\n
In previous part we developed our own syntax that tells Color()<\/code> where to add colors. Let\u2019s define pairs of characters that will change the text color to cyan and green. Let these be \" \"<\/code> and * *<\/code> respectively:<\/p>\n
\"text *and* text\"<\/code>
<\/a><\/div><\/pre>\n
The idea of the correct algorithm is simple. Before each character, it is necessary to add some control sequence (color). If we are inside a pair of characters (e.g., \" \"<\/code>) and have not found any new nested<\/em> pair (* *<\/code>), we simply add the opening and closing sequence before the opening and after the closing quote, respectively:<\/p>\n
\\e[96m\"# level 1text and text\"\\e[0m<\/code>
<\/a><\/div><\/pre>\n
For each nested pair * <\/code> found inside <\/em>\" \"<\/em><\/code> we switch the color: open a new one for the opening <\/em> and switch to the previous one for \"<\/code>:<\/p>\n
\\e[96m  <- own color\"  ; #1text     \\e[92m   <- own color    *         ; #2      and     *    \\e[96m   <- previous color    text\"\\e[0m   <- no color<\/code>
<\/a><\/div><\/pre>\n
This means that the closing color<\/strong> of each pair (the nesting problem we are trying to solve) depends on the nesting level<\/strong> of that pair: each subsequent level is closed with the color of the level above. And so on until the first top-level pair found that is not nested:<\/p>\n
\n
\n\n\n\n\n\n\n\n
\n
Level<\/p>\n<\/th>\n
\n
Symbol<\/p>\n<\/th>\n
\n
Color<\/p>\n<\/th>\n<\/tr>\n
\n
1<\/p>\n<\/td>\n
\n
«<\/p>\n<\/td>\n
\n
Cyan<\/p>\n<\/td>\n<\/tr>\n
\n
2<\/p>\n<\/td>\n
\n
*<\/p>\n<\/td>\n
\n
Green<\/p>\n<\/td>\n<\/tr>\n
\n
2<\/p>\n<\/td>\n
\n
*<\/p>\n<\/td>\n
\n
Cyan<\/p>\n<\/td>\n<\/tr>\n
\n
1<\/p>\n<\/td>\n
\n
«<\/p>\n<\/td>\n
\n
0<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n
For a top-level pair, there is no previous level, so it can be closed with \\e[0m<\/code> or its own color \\e[96m<\/code>. This entire table can be simplified to a simple stack that only stores the found characters:<\/p>\n
\"**\"<\/code>
<\/a><\/div><\/pre>\n
We can get the previous character from the top of the stack and switch to it\u2019s color, that can be found in chrColors<\/code> — a HashMap with \u201ccharacter-code\u201d pairs:<\/p>\n
\" 96* 92<\/code>
<\/a><\/div><\/pre>\n
The algorithm looks like this:<\/p>\n
stack := []while (pos <= len) {    if !RegExMatch(msg, regex, &match, pos) {        ; Remaining text        clrMsg .= msg.Slice(pos)        break    }        ; Normal text before the match    clrMsg .= msg.Slice(pos, match.pos - pos)    if (stack.Has(-1) && stack[-1] = match[1]) {        clrMsg .= match[1] . end        stack.Pop()    } else {        begin  := esc '[0;' chrColors[match[1]] 'm'        clrMsg .= begin . match[1]        stack.Push(match[1])    }        ; Move position forward    pos := match.pos + match.len}<\/code>
<\/a><\/div><\/pre>\n
You can read what is RegExMatch here<\/a>. Here is a algorithm visualization. Created using staying.fun<\/a><\/p>\n
<\/figure>\n
On the ansi101<\/a>, you can see what the final clrMsg<\/code> message looks like.<\/p>\n
<\/figure>\n
Char-color pairs<\/h4>\n
Obviously, it is inconvenient to pass a HashMap with numeric codes to the Color()<\/code> function. We want to pass «charl-color» pairs:<\/p>\n
msg.Color([   '\"',  'cyan',  '*',  'green'])<\/code>
<\/a><\/div><\/pre>\n
In this case, we pass an array instead of a HashMap for two reasons:<\/p>\n
    \n
  1. \n
    The order is important to us, as it determines the priority of each color.<\/p>\n<\/li>\n
  2. \n
    This is an intermediate container that is only needed for iteration.<\/p>\n<\/li>\n<\/ol>\n
    The array is intermediate because we convert it into a HashMap chrColors<\/code> with \u201csymbol-code\u201d pairs that we can use later:<\/p>\n
    regex     := '' ; resulted regular expressionchars     := '' ; string of characterschrColors := Map() ; there is no shortland for HashMap index := 1loop (aRegexColor.length \/ 2) {; Input array with \"char-color\" pair is `aRegexColor` variable    str   := aRegexColor[index++]    color := aRegexColor[index++]    chars .= str    chrColors[str] := colors[color]  ; `colors` is the HashMap of \"color-code\" pairs}if chars    regex .= '([' chars '])'else    regex := regex.RTrim('|')<\/code>
    <\/a><\/div><\/pre>\n
    <\/figure>\n
    For optimization, we combine all the passed characters into a RegEx set [\"*]<\/code><\/a>, so parsing will go a little faster. Then each character will serve as a key to extract the color from chrColors<\/code>.<\/p>\n
    The source code of the text output algorithm<\/a> is available on GitHub. And here you can read about some additional features of this algorithm<\/a>.<\/p>\n
    Conclusion<\/h3>\n
    Control sequences are a legacy from the days when terminals were physical machines rather than programs. Almost every text formatting library, such as {fmt}<\/a>, adds these invisible characters to a message. Therefore, to work with text colors and styles, we need to understand them.<\/p>\n
    In this article, we\u2019ve seen that it\u2019s possible to read control sequences and understand their meaning; we learned how the terminal interprets them, so we can \u201cask\u201d it to do exactly what we need.<\/p>\n
    In the next article, we will add support for atomic expressions and explore some interesting capabilities of regular expressions. Check out my GitHub<\/a> if you want to see the AutoHotkey capabilities in action!<\/p>\n<\/div>\n
    \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438 https:\/\/habr.com\/ru\/articles\/1054890\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
    In this series of articles, we explore the capabilities of the AutoHotkey language by demonstrating how to output colored text to the terminal for the console version of Launcher.Part 1: Naive algorithm and its optimization Part 2: Control sequences (you are here) Part 3: Regular expressions Part 4: Text styling and coloring libraryIn the previous part, we rewrote the algorithm from recursive to iterative and sped up its execution by almost 22 times. However, the final code lost support for nested colors. In this part, we will try to understand why this happened, what ANSI codes are, and how they are processed by the terminal.Control sequencesTerminalsToday, a terminal is synonymous with a terminal emulator (e.g. Cmder, Windows Terminal, Ghostty, and many others), but once upon a time, terminals were quite simple devices: screen and keyboard for communicating with a remote server. These terminals received bytes of data but had no way to distinguish between different types of data received. There was no way to control the behavior of the terminal.DEC VT-100 TerminalIf you search for \u201cANSI codes\u201d from the previous part, the first result you will see is the ANSI website (American National Standards Institute). The term \u201cANSI codes\u201d does not exist, only the institute. ANSI created a standard for escaping characters in terminals, which was later replaced by the ISO 6429 standard. ANSI also reserved some bytes for manufacturer-specific escape codes.Nowadays, these codes vary across different operating systems and terminal emulators. The emulator itself is responsible for interpreting ANSI. For example, in Cmder you can change the colors and termimnal behavior when it encounters ANSI.In PowerShell 3.0+ (which is emulated by pwsh, Cmder, and Windows Terminal), the PSReadLine module is responsible for ANSI and interactive input. Since version 5.0, it allows changing text colors using $([char]0x1b)[91m (we\u2019ll explain what this means later), and since version 6.0, a more convenient syntax is available via $PSStyle:$PSStyle.Formatting.Verbose = $PSStyle.Foreground.Cyan$PSStyle.Formatting.Debug   = $PSStyle.Foreground.DarkGrayIn Windows, there is a mechanism called Console Virtual Terminal Sequences at the console level. Starting with Windows 10, the console supports processing of VT100 sequences, which allows PowerShell to correctly interpret ANSI codes from the previous part. Thanks to this mechanism, we can output identically styled text from AutoHotkey to both cmd.exe and pwsh.exe (or any other emulator).Escaped sequenceTo tell the terminal that we want to use ANSI codes for text styling, we must use an escaped sequence. For this purpose, there is a special escape character. In Unix-like systems, the escape character is usually \\e or \\033. In PowerShell 6.0+ and AutoHotkey 2.0+, the escape character is `e. In AutoHotkey, we used esc := Chr(27) for reliability.In PowerShell 5.1, you must use $([char]0x1B) or [char]27 instead of `e.In this article, we will use the common notation \\e.Escaped sequences are mixed in with the main text when you type them. However, they disappear during output, since they provide information to the terminal, not to the reader of the message. Therefore, it is important to remember that the length of a message containing escaped sequence is always greater than the length of the output message!The original message at the top contains more characters than the output message at the bottomControl sequenceA control sequence begins with the combination of characters \\e and [ — this sequence (combination) is called CSI (Control Sequence Introducer). It is followed by several bytes (remember that 0 is also a number). Each sequence has its own set of rules and conventions about what it does and what arguments it expects. Within the scope of this article, we will consider only one subset of control sequences — changing text color and style. They have the form CSI n1 [;n2 [; …]] m, where m is the SGR function (Select Graphic Rendition), and each n1, n2, \u2026 is an SGR parameter. We are working with single-byte set (\\e[n1;n2m…), so n1 is a number from 0 to 7 (text or cursor style); n1 is a number from 0 to 107 (color).In the early ANSI standard, only 8 colors were available for changing text and background color. The n2 values 30-37 for the foreground color, and 40-47 for the background color. Later, high-intensity color codes appeared: 90-97 (foreground) and 100-107 (background). This set is called \u201csingle-byte\u201d and it is what we used in the previous part.The control sequence also disappears from the output message, since it is a form of escaped sequence.256 colorsIf 8 colors are not enough (which is quite possible), we can use a longer sequence for a palette of 256 colors. The ANSI sequence for using 8-bit color looks as follows: \\e[<text | background code>;5;n, where the first code is 38 (text color) or 48 (background color); n is a color from 0 to 255. For example, the sequence \\e[38;5;220m changes the text color to dark yellow. The range of 256 colors is divided into several sections: 0\u20137 are standard colors, 8\u201315 are bright colors, 16\u2013231 is a 6\u00d76\u00d76 color cube, and 232\u2013255 are grayscale shades.Available spectrumVarious examples of sequences can be found here.Sequence terminationIf the terminating combination of the sequence is not specified, it will be applied to all subsequent text output by our code to the screen (whether in PowerShell or AutoHotkey). When running the code snippet below, you will notice that the text on the new line is still bold and inverted. Additionally, the first line break character in the prompt has changed.Formatting affects the entire prompt and it doesn’t updatesTo terminate the sequence, it is sufficient to add \\e[0m at the end. This combination resets the previously applied style, color, and so on.Full resetAn alternative option is to reset each code separately. For example, the sequence \\e[1;7m will make the font bold and invert the foreground and background colors. To reset only the inversion, you should add \\e[27m. The text will remain bold but not inverted. To reset the bold text, you need to add \\e[22m. The text would no longer be inverted or bold.Partial resetControl SequencesNow that we know that we need to add \\e[n1;n2m at the beginning to change foreground color (e.g. \\e[0;96m) and \\e[0m at the end, it becomes obvious that the message consists of several control sequences:\\e[0;96m message \\e[0mSpaces are added for readability. Henceforth in the article, we will use the phrase control sequences, since \\e[0;96m is one sequence; \\e[0m is also one sequence; and the plural form indicates the presence of several such sequences in the message.Now that we have figured out what ANSI codes from the previous part actually are, we can call them by their proper name: control sequences.Solution for Nested ColorsState MachineLet\u2019s return to our console output algorithm and understand why nested colors is not working, i.e. changing the text (foreground) color inside already colored text.Control sequences operate on the principle of a finite state machine with a single set of current attributes. The terminal stores exactly one set of active graphic properties in memory: text color, background color, and style (italic, underline, etc.). Each new sequence overwrites the corresponding attributes rather than pushing them onto a stack.Suppose we have a message that we want to color as follows:<cyan>text<green>and<\/green>text<\/cyan>HTML tags are provided for readability and understanding of colors. We need to wrap the text in control sequences:»text and text».Color(«.+», «cyan»).Color(«and», «green»)The Color() method will apply control sequences in the following order:\\e[0;96m text \\e[0;92m and \\e[0m text \\e[0mLet\u2019s break down step by step how the terminal interprets this:StepSequenceTerminal state after application1\\e[0;96mReset all attributes, then set the text color to cyan (96)2Output textCyan text color3\\e[0;92m Reset all attributes. Change the text color to green (92)4Output andGreen text color5\\e[0mReset all attributes6Output textDefault color7\\e[0m Reset all attributes (redundant, the state has already been reset)On the third step a full reset occurs. The terminal does not remember that the color was cyan before. Due to the lack of a stack, this information is lost. Unlike HTML\/CSS, where each element has its own set of styles and the browser calculates the cascade, the terminal works with a global state.Thus, the correct sequence looks like this:\\e[0;96m text \\e[0;92m and \\e[0;96m text \\e[0mYou can test control sequences on the ansi101 and ansi.tools websites.StackIn previous part we developed our own syntax that tells Color() where to add colors. Let\u2019s define pairs of characters that will change the text color to cyan and green. Let these be » » and * * respectively:»text *and* text»The idea of the correct algorithm is simple. Before each character, it is necessary to add some control sequence (color). If we are inside a pair of characters (e.g., » «) and have not found any new nested pair (* *), we simply add the opening and closing sequence before the opening and after the closing quote, respectively:\\e[96m»# level 1text and text»\\e[0mFor each nested pair *  found inside » » we switch the color: open a new one for the opening  and switch to the previous one for «:\\e[96m  <- own color»  ; #1text     \\e[92m   <- own color    *         ; #2      and     *    \\e[96m   <- previous color    text»\\e[0m   <- no colorThis means that the closing color of each pair (the nesting problem we are trying to solve) depends on the nesting level of that pair: each subsequent level is closed with the color of the level above. And so on until the first top-level pair found that is not nested:LevelSymbolColor1″Cyan2*Green2*Cyan1″0For a top-level pair, there is no previous level, so it can be closed with \\e[0m or its own color \\e[96m. This entire…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-485947","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/485947","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=485947"}],"version-history":[{"count":0,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/485947\/revisions"}],"wp:attachment":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=485947"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=485947"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=485947"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}