Расчёт длины c ANSI эскейп‑последовательностями

.{
    $e = [char] 27
 
    $reset = "$e[0m"
    $bold  = "$e[1m"
 
    $black   = "$e[30m"
    $red     = "$e[31m"
    $green   = "$e[32m"
    $yellow  = "$e[33m"
    $blue    = "$e[34m"
    $magenta = "$e[35m"
    $cyan    = "$e[36m"
    $gray    = "$e[37m"
 
    $darkGray      = "$e[90m"
    $brightRed     = "$e[91m"
    $brightGreen   = "$e[92m"
    $brightYellow  = "$e[93m"
    $brightBlue    = "$e[94m"
    $brightMagenta = "$e[95m"
    $brightCyan    = "$e[96m"
    $white         = "$e[97m"
 
    $string = '`n${bold}${red}TEST-11${reset}`n${yellow}TEST-21${reset}`n${green}TEST-31${reset}`n'
    $expanded = $ExecutionContext.InvokeCommand.ExpandString($string)
    [string[]] $lines = $expanded -split '\r?\n'
 
    Clear-Host
    Write-Host $expanded
 
    Write-Host ("Всего строк: {0}" -f $lines.Count)
 
    for ($i = 1; $i -le $lines.Count; $i++) {
        Write-Host ('Длина строки {0}: {1} символов' -f $i, ($lines[$i-1].Length))
    }
}

$a = "`e[32;5;214mtest`e[0m"
$a # мигает?
$a -replace "(\e[^m]+m)([^\e]+)(\e[^m]+m)?",{$([string]$_.groups[2]).substring(2)} # мигает?

$a = "$([char]27)[38;5;214mHello, world$([char]27)[0m"+"`e[38;5;112mtest & test`e[0mab"
"Исходная строка:"
$a
"================"
$a -replace "(\e[^m]+m)([^\e]+)(\e[^m]+m)?",{
    [string]$_.groups[1]+([string]$_.groups[2]).substring(2)+$_.groups[3]
}
$a -replace "(\e[^m]+m)([^\e]+)(\e[^m]+m)?",{
    [string]$_.groups[1]+([string]$_.groups[2]).padleft(15,'Ц')+$_.groups[3]
}

...
$expanded  -replace "(\e[^m]+m)([^\e]+)(\e[^m]+m)?",{
    [string]$_.groups[1]+([string]$_.groups[2]).substring(0,6)+$_.groups[3]
}
...

.{
    $e = [char] 27
 
    $reset = "$e[0m"
    $bold = "$e[1m"
 
    $black = "$e[30m"
    $red = "$e[31m"
    $green = "$e[32m"
    $yellow = "$e[33m"
    $blue = "$e[34m"
    $magenta = "$e[35m"
    $cyan = "$e[36m"
    $gray = "$e[37m"
 
    $darkGray = "$e[90m"
    $brightRed = "$e[91m"
    $brightGreen = "$e[92m"
    $brightYellow = "$e[93m"
    $brightBlue = "$e[94m"
    $brightMagenta = "$e[95m"
    $brightCyan = "$e[96m"
    $white = "$e[97m"
 
    $string = '`n${bold}${red}TEST-11${reset}`n${yellow}TEST-21${reset}`n${green}TEST-31${reset}`n'
    $expanded = $ExecutionContext.InvokeCommand.ExpandString($string)
    [string[]] $lines = $expanded -split '\r?\n'
 
    Clear-Host
    Write-Host $expanded
 
    Write-Host ('Всего строк: {0}' -f $lines.Count)
 
    for ($i = 1; $i -le $lines.Count; $i++) {
        Write-Host ('Длина строки {0}: {1} символов' -f $i, ($lines[$i - 1].Length))
    }
 
    $expanded -replace '(\e[^m]+m)([^\e]+)(\e[^m]+m)?', {
        '[' + [string]$_.groups[1] + ([string]$_.groups[2]).substring(0, 6).PadRight(20) + $_.groups[3] + ']'
    }
}

enum TokenType {
    Literal
    ControlSequence
    End
}
 
# Класс для представления токенов
class Token {
    [TokenType] $Type
    [string] $Value
 
    Token ([TokenType] $type) {
        $this.Type = $type
        $this.Value = ""
    }
 
    Token ([TokenType] $type, [string] $value) {
        $this.Type = $type
        $this.Value = $value
    }
}
 
# Лексический анализатор для управляющих последовательностей
class Lexer {
    [string] $in
    [int] $position
 
    Lexer ([string] $in) {
        $this.in = $in
        $this.position = 0
    }
 
    [Token] GetNextToken() {
        # Конец строки
        if ($this.position -ge $this.in.Length) {
            return [Token]::new([TokenType]::End)
        }
 
        [char] $current = $this.in[$this.position]
 
        # Управляющая последовательность начинается с ESC (27) и заканчивается 'm'
        if ($current -eq [char]27 -and $this.position + 1 -lt $this.in.Length -and $this.in[$this.position + 1] -eq '[') {
            return $this.ReadControlSequence()
        }
 
        # Обычный символ
        return $this.ReadLiteral()
    }
 
    [Token] ReadControlSequence() {
        [int] $start = $this.position
 
        # Пропускаем ESC[
        $this.position += 2
 
        # Читаем до символа 'm'
        while ($this.position -lt $this.in.Length -and $this.in[$this.position] -ne 'm') {
            $this.position++
        }
 
        # Если не найден 'm', это ошибка, возвращаем как литерал
        if ($this.position -ge $this.in.Length) {
            $this.position = $start
            return $this.ReadLiteral()
        }
 
        # Включаем 'm' в последовательность
        $this.position++
 
        [string] $sequence = $this.in.Substring($start, $this.position - $start)
        return [Token]::new([TokenType]::ControlSequence, $sequence)
    }
 
    [Token] ReadLiteral() {
        [int] $start = $this.position
 
        # Читаем до начала управляющей последовательности или конца строки
        while ($this.position -lt $this.in.Length) {
            [char] $current = $this.in[$this.position]
 
            # Проверяем начало управляющей последовательности
            if ($current -eq [char]27 -and $this.position + 1 -lt $this.in.Length -and $this.in[$this.position + 1] -eq '[') {
                break
            }
 
            $this.position++
        }
 
        [string] $literal = $this.in.Substring($start, $this.position - $start)
        return [Token]::new([TokenType]::Literal, $literal)
    }
}
 
# Класс для работы с форматированными строками
class FormattedString {
    [string] $Text
 
    FormattedString([string] $text) {
        $this.Text = $text
    }
 
    # Возвращает видимую длину строки (без учета управляющих последовательностей)
    [int] GetDisplayLength() {
        [Lexer] $lexer = [Lexer]::new($this.Text)
        [Token] $token = $lexer.GetNextToken()
        [int] $length = 0
 
        while ($token.Type -ne [TokenType]::End) {
            if ($token.Type -eq [TokenType]::Literal) {
                $length += $token.Value.Length
            }
            # Управляющие последовательности не увеличивают видимую длину
            $token = $lexer.GetNextToken()
        }
 
        return $length
    }
 
    # Обрезает строку до заданной видимой длины, сохраняя форматирование
    [string] Substring([int] $maxLength) {
        [Lexer] $lexer = [Lexer]::new($this.Text)
        [Token] $token = $lexer.GetNextToken()
        [string] $result = ""
        [int] $displayLength = 0
 
        while ($token.Type -ne [TokenType]::End -and $displayLength -lt $maxLength) {
            if ($token.Type -eq [TokenType]::Literal) {
                # Проверяем, нужно ли усечь этот литерал
                [int] $remaining = $maxLength - $displayLength
                if ($token.Value.Length -le $remaining) {
                    $result += $token.Value
                    $displayLength += $token.Value.Length
                } else {
                    $result += $token.Value.Substring(0, $remaining)
                    $displayLength = $maxLength  # Достигли максимальной длины
                }
            } elseif ($token.Type -eq [TokenType]::ControlSequence) {
                # Управляющие последовательности добавляем без изменения
                $result += $token.Value
            }
            $token = $lexer.GetNextToken()
        }
 
        return $result
    }
 
    # Дополняет строку пробелами справа до заданной видимой длины
    [string] PadRight([int] $totalWidth) {
        [int] $currentDisplayLength = $this.GetDisplayLength()
        if ($currentDisplayLength -ge $totalWidth) {
            return $this.Text
        }
 
        [int] $padding = $totalWidth - $currentDisplayLength
        [string] $result = $this.Text
 
        # Если строка содержит управляющие последовательности и не заканчивается на сброс,
        # временно добавим сброс, чтобы не испортить следующий текст
        [bool] $endsWithReset = $result.EndsWith([char]27 + "[0m")
        if (-not $endsWithReset) {
            $result += [char]27 + "[0m"
            # Добавляем нужное количество пробелов
            $result += ' ' * $padding
            # Добавляем снова сброс, чтобы форматирование точно закончилось
            $result += [char]27 + "[0m"
        } else {
            # Добавляем нужное количество пробелов
            $result += ' ' * $padding
        }
 
        return $result
    }
}
 
# Объявляем все переменные цвета
$e = [char] 27
 
$reset = "$e[0m"
$bold  = "$e[1m"
 
$black   = "$e[30m"
$red     = "$e[31m"
$green   = "$e[32m"
$yellow  = "$e[33m"
$blue    = "$e[34m"
$magenta = "$e[35m"
$cyan    = "$e[36m"
$gray    = "$e[37m"
 
$darkGray      = "$e[90m"
$brightRed     = "$e[91m"
$brightGreen   = "$e[92m"
$brightYellow  = "$e[93m"
$brightBlue    = "$e[94m"
$brightMagenta = "$e[95m"
$brightCyan    = "$e[96m"
$white         = "$e[97m"
 
$originalString = '`n${bold}${red}TEST-11${reset}`n${yellow}TEST-21${reset}`n${green}TEST-31${reset}`n'
$expanded = $ExecutionContext.InvokeCommand.ExpandString($originalString)
$lines = $expanded -split "`n"
 
Write-Host ("Оригинальная строка: {0}" -f $originalString)
 
Write-Host "Расширенная строка:"
$expanded
 
Write-Host "Количество строк после разделения: $($lines.Count)`n"
 
for ($i = 0; $i -lt $lines.Count; $i++) {
    $formattedLine = [FormattedString]::new($lines[$i])
    Write-Host "Строка $i (длина $($formattedLine.GetDisplayLength())): $($lines[$i])" -NoNewline
 
    # Обрезаем строку до 6 символов
    if ($formattedLine.GetDisplayLength() -gt 6) {
        $trimmedLine = $formattedLine.Substring(6)
        Write-Host "  Обрезанная до 6: '$trimmedLine' (длина: $($([FormattedString]::new($trimmedLine)).GetDisplayLength()))"
    } else {
        Write-Host ''
    }
}

"`nЗапущен $($psstyle.background.blue)PowerShell$($psstyle.reset) $($psstyle.foreground.yellow)v{0}$($psstyle.reset) в ОС $($psstyle.foreground.magenta){1}$($psstyle.reset)." -f $($psversiontable.psversion),(gcim win32_operatingsystem).caption

function foo ( [string] $string, [int] $n ) {
    1..$n | % { $i = $_
        $expanded = $ExecutionContext.InvokeCommand.ExpandString($string)
        [string[]] $lines = $expanded -split '\r?\n'
        foreach ($line in $lines) {
            Write-Host $line }
        sleep 1
    }
}
# Вызов функции с разными строками вывода, а задаём строки при вызове функции
foo -string '`nВсего: $n`nСейчас: $i' -n 5
foo -string '`n$i из $n' -n 5
foo -string '`n`e[36;1m$i`e[0m из $n' -n 5

"`e[91m{0,-10}`e[0m{1}" -f "строка 1", "строка 2"     # как и задумано
"{0,-10}{1}" -f "`e[91mстрока 1`e[0m", "строка 2"     # битое форматирование

$e = [char]27
$a = "Строка: $e[38;5;214mHello, world$e[0m здесь тоже строка $e[38;5;112mtest & test$e[0m и ещё строка"
"Исходная строка:"
$a
"Длина: $($a.length)"
""
"Строка без спецсимволов:"
$a -replace '(\e[^m]+m)([^\e]+)(\e\[0m)?','$2'
"Длина без спецсимволов: $(($a -replace '(\e[^m]+m)([^\e]+)(\e\[0m)?','$2').length)"
""
"================"

$e = [char]27
$res = "Строка: $e[38;5;214mHello, world$e[0m здесь тоже строка $e[38;5;112mtest &$e[0m"
$res