More cleanups for color parsing

Using rounding when converting float to uint8 for more accuracy.
Fix rgb:3 and rgbi: parsing in Go code. Various other minor cleanups.

tools/utils/style/colorspaces.go

@@ -3,6 +3,7 @@
 package style
 
 import (
+	"errors"
 	"fmt"
 	"math"
 	"regexp"
@@ -10,6 +11,8 @@ import (
 	"strings"
 )
 
+var _ = fmt.Println
+
 // Color space conversion functions for wide gamut color support
 // Implements OKLCH, Display P3, and CIE LAB color formats with
 // CSS Color Module Level 4 gamut mapping.
@@ -96,14 +99,6 @@ func deltaEOk(lab1, lab2 [3]float64) float64 {
 
 // oklchToSrgbGamutMap converts OKLCH to sRGB with CSS Color Module Level 4 gamut mapping
 func oklchToSrgbGamutMap(l, c, h float64) (float64, float64, float64) {
-	// Validate for NaN and infinity
-	if !math.IsInf(l, 0) && !math.IsInf(c, 0) && !math.IsInf(h, 0) &&
-		!math.IsNaN(l) && !math.IsNaN(c) && !math.IsNaN(h) {
-		// Valid input
-	} else {
-		return 0.0, 0.0, 0.0 // Fallback to black
-	}
-
 	// Constants from CSS Color Module Level 4
 	const jnd = 0.02              // Just Noticeable Difference threshold
 	const minConvergence = 0.0001 // Binary search precision
@@ -236,11 +231,11 @@ func labToOklch(l, a, b float64) (float64, float64, float64) {
 
 // parseOklch parses OKLCH color: oklch(l c h) or oklch(l, c, h)
 func parseOklch(spec string) (RGBA, error) {
-	spec = strings.Trim(spec, "()")
+	spec = strings.TrimRight(spec, ")")
 	parts := splitColorComponents(spec)
 
 	if len(parts) != 3 {
-		return RGBA{}, errInvalidColor
+		return RGBA{}, errors.New("not enough parts")
 	}
 
 	l, err := parseFloatValue(parts[0])
@@ -260,17 +255,17 @@ func parseOklch(spec string) (RGBA, error) {
 	if math.IsNaN(l) || math.IsInf(l, 0) ||
 		math.IsNaN(c) || math.IsInf(c, 0) ||
 		math.IsNaN(h) || math.IsInf(h, 0) {
-		return RGBA{}, errInvalidColor
+		return RGBA{}, errors.New("invalid float value")
 	}
 
 	// Handle percentages for L
 	if strings.Contains(parts[0], "%") {
-		l = l / 100.0
+		l /= 100.0
 	}
 
 	// Clamp to reasonable ranges
-	l = math.Max(0.0, math.Min(1.0, l))
-	c = math.Max(0.0, c) // Chroma is unbounded
+	l = max(0.0, min(l, 1.0))
+	c = max(0.0, c)      // Chroma is unbounded
 	h = math.Mod(h, 360) // Wrap hue to 0-360
 	if h < 0 {
 		h += 360
@@ -278,21 +273,18 @@ func parseOklch(spec string) (RGBA, error) {
 
 	// Convert OKLCH to sRGB with gamut mapping
 	r, g, b := oklchToSrgbGamutMap(l, c, h)
-
-	return RGBA{
-		Red:   uint8(r * 255),
-		Green: uint8(g * 255),
-		Blue:  uint8(b * 255),
-	}, nil
+	return RGBA{as8bit(r), as8bit(g), as8bit(b), 0}, nil
 }
 
+func as8bit(x float64) uint8 { return uint8(math.Round(x * 255)) }
+
 // parseLab parses LAB color: lab(l a b) or lab(l, a, b)
 func parseLab(spec string) (RGBA, error) {
-	spec = strings.Trim(spec, "()")
+	spec = strings.TrimRight(spec, ")")
 	parts := splitColorComponents(spec)
 
 	if len(parts) != 3 {
-		return RGBA{}, errInvalidColor
+		return RGBA{}, errors.New("not enough parts")
 	}
 
 	l, err := parseFloatValue(parts[0])
@@ -312,23 +304,18 @@ func parseLab(spec string) (RGBA, error) {
 	if math.IsNaN(l) || math.IsInf(l, 0) ||
 		math.IsNaN(a) || math.IsInf(a, 0) ||
 		math.IsNaN(b) || math.IsInf(b, 0) {
-		return RGBA{}, errInvalidColor
+		return RGBA{}, errors.New("invalid float value")
 	}
 
 	// Clamp L to 0-100
-	l = math.Max(0.0, math.Min(100.0, l))
+	l = max(0.0, min(l, 100.0))
 
 	// Convert LAB to OKLCH, then use gamut mapping to sRGB
 	lOk, c, h := labToOklch(l, a, b)
 
 	// Apply gamut mapping in OKLCH space
 	r, g, bVal := oklchToSrgbGamutMap(lOk, c, h)
-
-	return RGBA{
-		Red:   uint8(r * 255),
-		Green: uint8(g * 255),
-		Blue:  uint8(bVal * 255),
-	}, nil
+	return RGBA{as8bit(r), as8bit(g), as8bit(bVal), 0}, nil
 }
 
 // splitColorComponents splits color components by comma or whitespace
@@ -353,5 +340,3 @@ func parseFloatValue(s string) (float64, error) {
 	s = strings.TrimRight(s, "%,")
 	return strconv.ParseFloat(s, 64)
 }
-
-var errInvalidColor = fmt.Errorf("invalid color format")

tools/utils/style/colorspaces_test.go

@@ -3,123 +3,40 @@
 package style
 
 import (
-	"math"
 	"testing"
 )
 
-func TestParseOklch(t *testing.T) {
-	tests := []struct {
-		name  string
-		input string
-		want  RGBA
-	}{
-		{
-			name:  "basic oklch",
-			input: "0.5 0.1 180",
-			want:  RGBA{Red: 0, Green: 117, Blue: 101}, // cyan-ish with gamut mapping
-		},
-		{
-			name:  "white",
-			input: "1.0 0 0",
-			want:  RGBA{Red: 255, Green: 255, Blue: 255},
-		},
-		{
-			name:  "black",
-			input: "0 0 0",
-			want:  RGBA{Red: 0, Green: 0, Blue: 0},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := parseOklch(tt.input)
-			if err != nil {
-				t.Errorf("parseOklch() error = %v", err)
-				return
-			}
-			// Allow some tolerance due to rounding
-			if math.Abs(float64(got.Red)-float64(tt.want.Red)) > 2 ||
-				math.Abs(float64(got.Green)-float64(tt.want.Green)) > 2 ||
-				math.Abs(float64(got.Blue)-float64(tt.want.Blue)) > 2 {
-				t.Errorf("parseOklch() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestParseLab(t *testing.T) {
-	tests := []struct {
-		name  string
-		input string
-		want  RGBA
-	}{
-		{
-			name:  "basic lab",
-			input: "50 0 0",
-			want:  RGBA{Red: 198, Green: 198, Blue: 198}, // light gray (LAB 50 is lighter than sRGB 50%)
-		},
-		{
-			name:  "white",
-			input: "100 0 0",
-			want:  RGBA{Red: 255, Green: 255, Blue: 255},
-		},
-		{
-			name:  "black",
-			input: "0 0 0",
-			want:  RGBA{Red: 0, Green: 0, Blue: 0},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := parseLab(tt.input)
-			if err != nil {
-				t.Errorf("parseLab() error = %v", err)
-				return
-			}
-			// Allow some tolerance due to rounding
-			if math.Abs(float64(got.Red)-float64(tt.want.Red)) > 2 ||
-				math.Abs(float64(got.Green)-float64(tt.want.Green)) > 2 ||
-				math.Abs(float64(got.Blue)-float64(tt.want.Blue)) > 2 {
-				t.Errorf("parseLab() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func TestParseColor(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		wantErr bool
-	}{
-		{
-			name:    "oklch format",
-			input:   "oklch(0.5 0.1 180)",
-			wantErr: false,
-		},
-		{
-			name:    "lab format",
-			input:   "lab(50 0 0)",
-			wantErr: false,
-		},
-		{
-			name:    "with inline comment",
-			input:   "oklch(0.5 0.1 180) # vibrant color",
-			wantErr: false,
-		},
-		{
-			name:    "hex color",
-			input:   "#ff0000",
-			wantErr: false,
-		},
+	type tr struct {
+		input    string
+		expected RGBA
+	}
+	c := func(t string, r, g, b uint8) tr { return tr{t, RGBA{r, g, b, 0}} }
+	tests := []tr{
+		c(`#eee # comment`, 0xee, 0xee, 0xee),
+		c(`#234567`, 0x23, 0x45, 0x67),
+		c(`#abcabcdef`, 0xab, 0xab, 0xde),
+		c(`rgb:e/e/e # comment`, 0xee, 0xee, 0xee),
+		c(`rgb:23/45/67`, 0x23, 0x45, 0x67),
+		c(`rgb:abc/abc/def`, 0xab, 0xab, 0xde),
+		c(`red`, 0xff, 0, 0),
+		c(`alice blue # comment`, 240, 248, 255),
+		c(`oklch(1,0,0)`, 255, 255, 255),
+		c(`oklch(0,0,0)`, 0, 0, 0),
+		c(`oklch(0.5,0.1,180)`, 0, 117, 101),
+		c(`oklch(0.7 0.15 140) # comment`, 0x68, 0xb4, 0x57),
+		c(`oklch(0.9 0.05 265)`, 0xce, 0xde, 0xff),
+		c(`lab(70 50 -30)`, 0xea, 0x88, 0xe2),
+		c(`lab(50,0,0)`, 199, 199, 199),
+		c(`lab(100,0,0)`, 255, 255, 255),
+		c(`lab(0,0,0)`, 0, 0, 0),
 	}
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := ParseColor(tt.input)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ParseColor() error = %v, wantErr %v", err, tt.wantErr)
+		t.Run(tt.input, func(t *testing.T) {
+			actual, err := ParseColor(tt.input)
+			if actual != tt.expected {
+				t.Errorf("ParseColor(%#v) error = %v, got %v wanted %v", tt.input, err, actual, tt.expected)
 			}
 		})
 	}

tools/utils/style/wrapper.go

@@ -65,19 +65,45 @@ func (self RGBA) AsRGBSharp() string {
 func (self *RGBA) parse_rgb_strings(r string, g string, b string) bool {
 	var rv, gv, bv uint64
 	var err error
-	if rv, err = strconv.ParseUint(r, 16, 8); err != nil {
+	if len(r) == 1 {
+		r += r
+		g += g
+		b += b
+	}
+	if rv, err = strconv.ParseUint(r[:min(len(r), 2)], 16, 8); err != nil {
 		return false
 	}
-	if gv, err = strconv.ParseUint(g, 16, 8); err != nil {
+	if gv, err = strconv.ParseUint(g[:min(len(r), 2)], 16, 8); err != nil {
 		return false
 	}
-	if bv, err = strconv.ParseUint(b, 16, 8); err != nil {
+	if bv, err = strconv.ParseUint(b[:min(len(r), 2)], 16, 8); err != nil {
 		return false
 	}
 	self.Red, self.Green, self.Blue = uint8(rv), uint8(gv), uint8(bv)
 	return true
 }
 
+func fas_uint8(x float64) uint8 {
+	x = max(0, min(x, 1))
+	return uint8(x * 255)
+}
+
+func (self *RGBA) parse_rgb_intensities(r string, g string, b string) bool {
+	var rv, gv, bv float64
+	var err error
+	if rv, err = strconv.ParseFloat(r, 64); err != nil {
+		return false
+	}
+	if gv, err = strconv.ParseFloat(g, 64); err != nil {
+		return false
+	}
+	if bv, err = strconv.ParseFloat(b, 64); err != nil {
+		return false
+	}
+	self.Red, self.Green, self.Blue = fas_uint8(rv), fas_uint8(gv), fas_uint8(bv)
+	return true
+}
+
 func (self *RGBA) AsRGB() uint32 {
 	return uint32(self.Blue) | (uint32(self.Green) << 8) | (uint32(self.Red) << 16)
 }
@@ -123,31 +149,41 @@ type color_value struct {
 
 func parse_sharp(color string) (ans RGBA, err error) {
 	if len(color)%3 != 0 {
-		return RGBA{}, fmt.Errorf("Not a valid color: #%s", color)
+		return RGBA{}, fmt.Errorf("length not a multiple of 3")
 	}
 	part_size := len(color) / 3
-	r, g, b := color[:part_size], color[part_size:2*part_size], color[part_size*2:]
-	if part_size == 1 {
-		r += r
-		g += g
-		b += b
-	}
+	r, g, b := color[:part_size], color[part_size:2*part_size], color[part_size*2:part_size*3]
 	if !ans.parse_rgb_strings(r, g, b) {
-		err = fmt.Errorf("Not a valid color: #%s", color)
+		err = fmt.Errorf("invalid rgb numbers")
 	}
 	return
 }
 
 func parse_rgb(color string) (ans RGBA, err error) {
 	colors := strings.Split(color, "/")
-	if len(colors) == 3 && ans.parse_rgb_strings(colors[0], colors[1], colors[2]) {
+	if len(colors) != 3 {
+		return RGBA{}, fmt.Errorf("length not a multiple of 3")
+	}
+	if ans.parse_rgb_strings(colors[0], colors[1], colors[2]) {
 		return
 	}
-	err = fmt.Errorf("Not a valid RGB color: %#v", color)
+	err = fmt.Errorf("invalid rgb numbers")
 	return
 }
 
-func ParseColor(color string) (RGBA, error) {
+func parse_rgbi(color string) (ans RGBA, err error) {
+	colors := strings.Split(color, "/")
+	if len(colors) != 3 {
+		return RGBA{}, fmt.Errorf("length not a multiple of 3")
+	}
+	if ans.parse_rgb_intensities(colors[0], colors[1], colors[2]) {
+		return
+	}
+	err = fmt.Errorf("invalid rgb numbers")
+	return
+}
+
+func ParseColor(color string) (ans RGBA, err error) {
 	// Strip inline comments (e.g., "oklch(...) # comment")
 	// For hex colors like "#ff0000", preserve the first #, but strip comments after spaces
 	color = strings.TrimSpace(color)
@@ -168,19 +204,43 @@ func ParseColor(color string) (RGBA, error) {
 	if val, ok := ColorNames[raw]; ok {
 		return val, nil
 	}
-	if strings.HasPrefix(raw, "#") {
-		return parse_sharp(raw[1:])
+	if len(raw) < 4 {
+		return RGBA{}, fmt.Errorf("not a valid color name: %#v", color)
 	}
-	if strings.HasPrefix(raw, "oklch(") {
-		return parseOklch(raw[6:])
+	var parser func(string) (RGBA, error)
+	switch raw[0] {
+	case '#':
+		parser = parse_sharp
+		raw = raw[1:]
+	case 'o':
+		if strings.HasPrefix(raw, "oklch(") {
+			parser, raw = parseOklch, raw[6:]
+		}
+	case 'l':
+		if strings.HasPrefix(raw, "lab(") {
+			parser, raw = parseLab, raw[4:]
+		}
+	case 'r':
+		if len(raw) > 4 && strings.HasPrefix(raw, "rgb") {
+			raw = raw[3:]
+			switch raw[0] {
+			case ':':
+				parser, raw = parse_rgb, raw[1:]
+			case 'i':
+				if strings.HasPrefix(raw, "i:") {
+					parser, raw = parse_rgbi, raw[2:]
+				}
+			}
+		}
 	}
-	if strings.HasPrefix(raw, "lab(") {
-		return parseLab(raw[4:])
+	if parser == nil {
+		err = fmt.Errorf("not a valid color name: %#v", color)
+	} else {
+		if ans, err = parser(raw); err != nil {
+			err = fmt.Errorf("not a valid color name: %#v %w", color, err)
+		}
 	}
-	if strings.HasPrefix(raw, "rgb:") {
-		return parse_rgb(raw[4:])
-	}
-	return RGBA{}, fmt.Errorf("Not a valid color name: %#v", color)
+	return
 }
 
 type NullableColor struct {

tools/utils/style/wrapper_test.go

@@ -39,7 +39,7 @@ func TestANSIStyleSprint(t *testing.T) {
 	test("fg=15", "\x1b[97m", "\x1b[39m")
 	test("bg=15", "\x1b[107m", "\x1b[49m")
 	test("fg=#123", "\x1b[38:2:17:34:51m", "\x1b[39m")
-	test("fg=rgb:1/2/3", "\x1b[38:2:1:2:3m", "\x1b[39m")
+	test("fg=rgb:1/2/3", "\x1b[38:2:17:34:51m", "\x1b[39m")
 	test("bg=123", "\x1b[48:5:123m", "\x1b[49m")
 	test("uc=123", "\x1b[58:5:123m", "\x1b[59m")
 	test("uc=1", "\x1b[58:5:1m", "\x1b[59m")