paotin/plugins/lib/xtintin/raw.tin

#nop vim: set filetype=tt:;

/*
本文件属于 PaoTin++ 的一部分。
PaoTin++ © 2020~2026 的所有版权均由担子炮(dzp <danzipao@gmail.com>) 享有并保留一切法律权利
你可以在遵照 GPLv3 协议的基础之上使用、修改及重新分发本程序。
*/

#nop 本文件是 xtintin 的一部分，实现了一些颜色字符串处理函数;

///=== {
///// 颜色字符串处理函数：
//
// #@ str.Plain <字符串>
//    去除字符串中的颜色代码和 ANSI 控制字符。
//
// #@ str.Color <字符串>
//    仅保留字符串中的颜色代码，去掉其余成分，方便比较颜色。
//    本函数与 str.SimpleColor 的区别在于，本函数不会简化颜色。
//
// #@ str.SimpleColor <字符串>
//    仅保留字符串中的颜色代码，去掉其余成分，方便比较颜色。
//    本函数与 str.Color 的区别在于，本函数会简化颜色。
//    所谓简化是指对颜色代码串进行了 color.Trim 和 color.Clean 操作。
//
// #@ color.Trim <颜色代码串>
//    去掉颜色代码串两头的复位代码。
//
// #@ color.Clean <颜色代码串>
//    压缩颜色代码串，只保留经过运算后的效果。
//    NOTE: 注意某些情况下你可能需要先进行 color.Trim 操作。
// };

#func {str.Plain}   {#format result {%P} {%0}};

#func {str.Color} {
    #local color    {};
    #local state    {START};
    #local ch       {};

    #parse {%0} {ch} {
        #switch {"$state/$ch"} {
            #case {"START/\e"}  {#local state {ESCAPE}};
            #case {"START/%*"}  {#0};
            #case {"ESCAPE/["}  {#local state {INNER}};
            #case {"ESCAPE/%*"} {#local state {OUTER}};
            #case {"INNER/m"}   {#cat color {;}; #local state {OUTER}};
            #case {"INNER/%*"}  {#cat color {$ch}};
            #case {"OUTER/\e"}  {#local state {ESCAPE}};
        };
    };

    #replace {color} {;$} {};

    #return {$color};
};

#func {str.SimpleColor} {
    #local color {@str.Color{%0}};
    #local color {@color.Trim{$color}};
    #local color {@color.Clean{$color}};
    #return {$color};
};

#func {color.Trim} {
    #local color {%0};
    #replace color {^{(2;37;0(;|))+}} {};
    #replace color {^{(0(;|))+}} {};
    #replace color {{((;|)2;37;0)+}$} {};
    #replace color {{(0(;|))+}$} {};

    #return {$color};
};

#func {color.Clean} {
    #local color {%0};

    #local str {};
    #line sub escapes #format str {%s} {@raw.ParseFragments{{\e[${color}m}}};
    #if { &str[color][] == 0 } {
        #return {};
    };

    #local color {$str[color]};
    #local attr {};
    #local output {};

    #foreach {$color[attrs]} {attr} {
        #switch {"$attr"} {
            #case {"bold"}      {#cat output {;1}};
            #case {"dim"}       {#cat output {;2}};
            #case {"italic"}    {#cat output {;3}};
            #case {"underline"} {#cat output {;4}};
            #case {"blink"}     {#cat output {;5}};
            #case {"reverse"}   {#cat output {;7}};
            #case {"f16"}       {#cat output {;$color[fg]}};
            #case {"b16"}       {#cat output {;$color[bg]}};
            #case {"F16"}       {#cat output {;$color[fg]}};
            #case {"B16"}       {#cat output {;$color[bg]}};
            #case {"f256"}      {#cat output {;38;5;$color[fg]}};
            #case {"b256"}      {#cat output {;48;5;$color[bg]}};
            #case {"ftrue"}     {#cat output {;38;2;$color[fg]}};
            #case {"btrue"}     {#cat output {;48;2;$color[bg]}};
        };
    };

    #replace output {^;} {};

    #return {$output};
};

///=== {
// #@ util.WordColor <字符串> <子字符串>
//    从字符串中检索子字符串，如果找到它，就把它的颜色取出来并作为返回值，否则返回空。
// };
#func {str.WordColor} {
    #local str      {%1};
    #local word     {%2};

    #replace word {%+1u} {(?:\e\[[0-9;:]*m)*&1};
    #replace str {^%*{$word}%*$} {&2};

    #local color {@str.Color{$str}};

    #replace color {^0;} {};
    #replace color {;0$} {};

    #replace color {2;37;0;} {};
    #replace color {;2;37;0} {};

    #return {$color};
};

///=== {
// #@ util.ColorBar <字符串> <颜色1> <权重1> <颜色2> <权重2> [...]
//    将字符串按照颜色及其对应的权重占比，渲染成彩色字符串。注意颜色参数须按顺序排列。
// };
#func {util.ColorBar} {
    #local str {%1};

    #local args {};
    #list args create {%0};
    #list args delete {1} {1};

    #local parts {};
    #list parts create {};
    #local count {0};
    #local sum {0};
    #while { $count < &args[] } {
        #local color    {$args[@math.Eval{$count + 1}]};
        #local weight   {@defaultNum{$args[@math.Eval{$count + 2}];0}};
        #list parts {add} {{
            {color}{$color}
            {weight}{$weight}
        }};
        #math count {$count + 2};
        #math sum {$sum + $weight};
    };

    #local elem {};
    #local len {@str.Len{$str}};
    #local leftLen {0};
    #local leftWeight {0};
    #local colorStr {};
    #foreach {$parts[%*]} {elem} {
        #local elemLen {@math.Eval{($elem[weight] + $leftWeight) * $len / $sum - $leftLen}};
        #local text {@str.Sub{{$str};$leftLen;$elemLen}};
        #cat colorStr {$elem[color]$text<299>};
        #math leftLen {$leftLen + $elemLen};
        #math leftWeight {$leftWeight + $elem[weight]};
    };

    #return {$colorStr};
};

///=== {
// #@ raw.ParseFragments <颜色字符串> [<之前的颜色>]
//    解析包含颜色代码的字符串，将其拆分成一系列的文本片段，每个片段包含一段文本和对应的颜色属性。
//    本函数实际上有两个返回值，以 table 形式打包返回，其中包含以下内容：
//      - color: 字符串解析完毕之后，最后的颜色状态（可供之后调用），参见下面的 color 属性。
//      - fragments: 一个表格列表，其中每个元素是一个表格，包含以下两个字段：
//        - text: 文本片段
//        - color:
//          - fg: 前景色，可能是一个一位数（16色系统）或一个多位数（256色系统）或三个数（RGB颜色）
//          - bg: 背景色，同上
//          - attrs: 文本样式属性，是一个字符串集合(sset)，包含以下可能的值：
//              - bold
//              - dim
//              - italic
//              - underline
//              - blink
//              - reverse
//              - f16       表示前景色是 16 色系统
//              - b16       表示背景色是 16 色系统
//              - F16       表示前景色是 AIXterm 16 色系统
//              - B16       表示背景色是 AIXterm 16 色系统
//              - f256      表示前景色是 256 色系统
//              - b256      表示背景色是 256 色系统
//              - ftrue     表示前景色是真彩色
//              - btrue     表示背景色是真彩色
//            注意以上属性承诺按照以上顺序出现，但如果未设置该属性则不出现。
// };
#func {raw.ParseFragments} {
    #local str      {%1};
    #local color    {%2};

    #local fragments    {};
    #local fragment     {};
    #local tokens       {};
    #local mode         {TEXT};

    #while {1} {
        #if { &tokens[] == 0 } {
            raw.ParseFragments.nextToken;
            #if { "$str" === "" } {
                #break;
            };

            #if { "$str[text]" !== "" } {
                #local fragment[text] {$str[text]};
                #local fragment[color] {@raw.ParseFragments.buildColor{$color}};
                #list fragments add {{$fragment}};
                #local fragment {};
            };
            #elseif { "$str[color]" !== "" } {
                #replace str[color] {^\e[} {};
                #replace str[color] {m$}   {};
                #if { "$str[color]" !== "" } {
                    #list tokens add {$str[color]};
                    #local mode {SGR};
                };
            };

            #local str {$str[rest]};
            #continue;
        };

        #local token {$tokens[1]};
        #list tokens delete 1;

        #switch {"$mode/$token"} {
            #case {"SGR/0"}             {#local color[fg] {}; #local color[bg] {}; #local color[attrs] {}};
            #case {"SGR/1"}             {#local color[attrs][bold]      {1}};
            #case {"SGR/2"}             {#local color[attrs][dim]       {1}};
            #case {"SGR/3"}             {#local color[attrs][italic]    {1}};
            #case {"SGR/4"}             {#local color[attrs][underline] {1}};
            #case {"SGR/5"}             {#local color[attrs][blink]     {1}};
            #case {"SGR/7"}             {#local color[attrs][reverse]   {1}};
            #case {"SGR/3{[0-7]}"}      {#local color[fg] {$token}; #local color[attrs][fcolors] {8}};
            #case {"SGR/4{[0-7]}"}      {#local color[bg] {$token}; #local color[attrs][bcolors] {8}};
            #case {"SGR/9{[0-7]}"}      {#local color[fg] {$token}; #local color[attrs][fcolors] {16}};
            #case {"SGR/10{[0-7]}"}     {#local color[bg] {$token}; #local color[attrs][bcolors] {16}};
            #case {"SGR/38"}            {#local mode {SGR38}};
            #case {"SGR38/2"}           {#local mode {SGR382}; #local color[fg] {}; #local color[attrs][fcolors] {256}};
            #case {"SGR382/%+1..d"}     {#local mode {SGR}; #local color[fg] {$token}};
            #case {"SGR38/5"}           {#local mode {SGR385}; #local color[fg] {}; #local color[attrs][fcolors] {true}};
            #case {"SGR385/%+1..d"}     {#local mode {SGR3851}; #local color[fg] {@slist.Append{{$color[fg]};$token}}};
            #case {"SGR3851/%+1..d"}    {#local mode {SGR3852}; #local color[fg] {@slist.Append{{$color[fg]};$token}}};
            #case {"SGR3852/%+1..d"}    {#local mode {SGR};     #local color[fg] {@slist.Append{{$color[fg]};$token}}};
            #case {"SGR/48"}            {#local mode {SGR48}};
            #case {"SGR48/2"}           {#local mode {SGR482}; #local color[bg] {}; #local color[attrs][bcolors] {256}};
            #case {"SGR482/%+1..d"}     {#local mode {SGR}; #local color[bg] {$token}};
            #case {"SGR48/5"}           {#local mode {SGR485}; #local color[bg] {}; #local color[attrs][bcolors] {true}};
            #case {"SGR485/%+1..d"}     {#local mode {SGR4851}; #local color[bg] {@slist.Append{{$color[bg]};$token}}};
            #case {"SGR4851/%+1..d"}    {#local mode {SGR4852}; #local color[bg] {@slist.Append{{$color[bg]};$token}}};
            #case {"SGR4852/%+1..d"}    {#local mode {SGR};     #local color[bg] {@slist.Append{{$color[bg]};$token}}};
        };
    };

    #local color {@raw.ParseFragments.buildColor{$color}};

    #if { "$str[text]" !== "" } {
        #local fragment[text] {$str[text]};
        #local fragment[color] {$color};
        #list fragments add {{$fragment}};
    };

    #return {
        {fragments} {$fragments}
        {color}     {$color}
    };
};

#func {raw.ParseFragments.buildColor} {
    #local color {%0};

    #local attrs {$color[attrs]};
    #local attr {};
    #local newAttrs {};
    #foreach {bold;dim;italic;underline;blink;reverse} {attr} {
        #if { $attrs[$attr] } {
            #cat newAttrs {;$attr};
        };
    };

    #nop 前景色只能有一个系统，以最后出现的为准。;
    #switch {"$color[attrs][fcolors]/@slist.Size{$color[fg]}"} {
        #case {"8/1"}       {#cat newAttrs {;f16}};
        #case {"16/1"}      {#cat newAttrs {;F16}};
        #case {"256/1"}     {#cat newAttrs {;f256}};
        #case {"true/3"}    {#cat newAttrs {;ftrue}};
    };

    #nop 背景色只能有一个系统，以最后出现的为准。;
    #switch {"$color[attrs][bcolors]/@slist.Size{$color[bg]}"} {
        #case {"8/1"}       {#cat newAttrs {;b16}};
        #case {"16/1"}      {#cat newAttrs {;B16}};
        #case {"256/1"}     {#cat newAttrs {;b256}};
        #case {"true/3"}    {#cat newAttrs {;btrue}};
    };

    #replace newAttrs {^;} {};
    #local color[attrs] {$newAttrs};

    #return {$color};
};

#alias {raw.ParseFragments.nextToken} {
    #if { "$str" === "" } {
        #return;
    };

    #replace str {^{[^\e]+}%*$} {
        {text}  {&1}
        {rest}  {&2}
    };

    #var str {$str};

    #if { "$str[text]" !== "" } {
        #return {$str};
    };

    #replace str {^%+1c%*$} {
        {color} {&1}
        {rest}  {&2}
    };

    #var str {$str};

    #if { "$str[text]" !== "" } {
        #return {$str};
    };

    #replace str {^\e%*} {
        {esc}   {&1}
        {rest}  {&2}
    };

    #var str {$str};
};

///=== {
// #@ raw.EraseInvisible <颜色字符串> [<是否压缩>]
//    解析包含颜色代码的字符串，将其拆分成多个片段，并擦掉其中前景色与背景色相同的部分。
//    如果同时指定了第二个参数为真，则将颜色相同的连续多个部分进行合并。
//    最终返回值格式与 raw.ParseFragments 相同。
// };
#func {raw.EraseInvisible} {
    #local str {%1};
    #local zip {%2};

    #local color {};
    #local output {};

    #local str {@raw.ParseFragments{{$str}}};
    #foreach {*str[fragments][]} {fragment} {
        #local fragment {$str[fragments][$fragment]};

        #if {  ! @sset.Contains{{$fragment[color][attrs]};f256}
            && ! @sset.Contains{{$fragment[color][attrs]};b256}
            && ! @sset.Contains{{$fragment[color][attrs]};ftrue}
            && ! @sset.Contains{{$fragment[color][attrs]};btrue}
            && $fragment[color][fg] + 10 == $fragment[color][bg] } {
            #continue;
        };

        #if {  @sset.Contains{{$fragment[color][attrs]};f256}
            && @sset.Contains{{$fragment[color][attrs]};b256}
            && "$fragment[color][fg]" === "$fragment[color][bg]" } {
            #continue;
        };

        #if {  @sset.Contains{{$fragment[color][attrs]};ftrue}
            && @sset.Contains{{$fragment[color][attrs]};btrue}
            && "$fragment[color][fg]" === "$fragment[color][bg]" } {
            #continue;
        };

        #if { @isTrue{$zip} && "$color" != "" && "$fragment[color]" === "$color" } {
            #cat output[-1][text] {$fragment[text]};
        };
        #else {
            #list output add {{$fragment}};
            #local color {$fragment[color]};
        };
    };

    #return {
        {fragments} {$output}
        {color}     {$color}
    };
};