Optimisation

animation.go

@@ -866,8 +866,8 @@ func isTimingFunctionValid(timingFunction string) bool {
 				}
 
 			case "cubic-bezier":
-				if params := strings.Split(args, ","); len(params) == 4 {
+				if strings.Count(args, ",") == 3 {
-					for _, param := range params {
+					for param := range strings.SplitSeq(args, ",") {
 						if _, err := strconv.ParseFloat(strings.Trim(param, " \t\n"), 64); err != nil {
 							return false
 						}

canvas.go

@@ -630,9 +630,8 @@ func (canvas *canvasData) fontWithParams(name string, size SizeUnit, params Font
 		buffer.WriteString(params.LineHeight.cssString("", canvas.View().Session()))
 	}
 
-	names := strings.Split(name, ",")
 	lead := " "
-	for _, font := range names {
+	for font := range strings.SplitSeq(name, ",") {
 		font = strings.Trim(font, " \n\"'")
 		buffer.WriteString(lead)
 		lead = ","

clipShape.go

@@ -480,14 +480,13 @@ func polygonClipDataSet(properties Properties, tag PropertyName, value any) []Pr
 			return []PropertyName{tag}
 
 		case string:
-			values := strings.Split(value, ",")
+			points := make([]any, 0, strings.Count(value, ",")+1)
-			points := make([]any, len(values))
+			for val := range strings.SplitSeq(value, ",") {
-			for i, val := range values {
 				val = strings.Trim(val, " \t\n\r")
 				if ok, _ := isConstantName(val); ok {
-					points[i] = val
+					points = append(points, val)
 				} else if size, ok := StringToSizeUnit(val); ok {
-					points[i] = size
+					points = append(points, size)
 				} else {
 					notCompatibleType(tag, val)
 					return nil

dragAndDrop.go

@@ -229,15 +229,13 @@ func (event *DragAndDropEvent) init(session Session, data DataObject) {
 
 	event.Data = map[string]string{}
 	if value, ok := data.PropertyValue("data"); ok {
-		data := strings.Split(value, ";")
+		for line := range strings.SplitSeq(value, ";") {
-		for _, line := range data {
+			if mimeData, data, ok := strings.Cut(line, ":"); ok {
-			pair := strings.Split(line, ":")
+				mime, err := base64.StdEncoding.DecodeString(mimeData)
-			if len(pair) == 2 {
-				mime, err := base64.StdEncoding.DecodeString(pair[0])
 				if err != nil {
 					ErrorLog(err.Error())
 				} else {
-					val, err := base64.StdEncoding.DecodeString(pair[1])
+					val, err := base64.StdEncoding.DecodeString(data)
 					if err == nil {
 						event.Data[string(mime)] = string(val)
 					} else {
@@ -322,9 +320,8 @@ func (view *viewData) setDropEffect(value any) []PropertyName {
 
 func stringToDropEffectAllowed(text string) (int, bool) {
 	if strings.ContainsRune(text, '|') {
-		elements := strings.Split(text, "|")
 		result := 0
-		for _, element := range elements {
+		for element := range strings.SplitSeq(text, "|") {
 			if n, ok := stringToDropEffect(element); ok && n != DropEffectUndefined {
 				result |= n
 			} else {

gridLayout.go

@@ -489,10 +489,13 @@ func gridCellSizes(properties Properties, tag PropertyName, session Session) []S
 
 		case string:
 			if text, ok := session.resolveConstants(value); ok {
-				values := strings.Split(text, ",")
+				result := make([]SizeUnit, 0, strings.Count(text, ",")+1)
-				result := make([]SizeUnit, len(values))
+				for val := range strings.SplitSeq(text, ",") {
-				for i, val := range values {
+					size, err := stringToSizeUnit(val)
-					result[i], _ = stringToSizeUnit(val)
+					if err != nil {
+						ErrorLog(err.Error())
+					}
+					result = append(result, size)
 				}
 				return result
 			}

imageView.go

@@ -187,12 +187,15 @@ func (imageView *imageViewData) propertyChanged(tag PropertyName) {
 func imageViewSrcSet(view View, path string) string {
 	if value := view.getRaw(SrcSet); value != nil {
 		if text, ok := value.(string); ok {
-			srcset := strings.Split(text, ",")
 			buffer := allocStringBuilder()
 			defer freeStringBuilder(buffer)
-			for i, src := range srcset {
+
-				if i > 0 {
+			comma := false
+			for src := range strings.SplitSeq(text, ",") {
+				if comma {
 					buffer.WriteString(", ")
+				} else {
+					comma = true
 				}
 				src = strings.Trim(src, " \t\n")
 				buffer.WriteString(src)

listView.go

@@ -220,9 +220,8 @@ func (listView *listViewData) setFunc(tag PropertyName, value any) []PropertyNam
 		var checked []int
 		switch value := value.(type) {
 		case string:
-			elements := strings.Split(value, ",")
+			checked = make([]int, 0, strings.Count(value, ",")+1)
-			checked = make([]int, 0, len(elements))
+			for val := range strings.SplitSeq(value, ",") {
-			for _, val := range elements {
 				if val = strings.Trim(val, " \t"); val != "" {
 					n, err := strconv.Atoi(val)
 					if err != nil {

radius.go

@@ -649,22 +649,25 @@ func radiusPropertySet(radius Properties, tag PropertyName, value any) []Propert
 			deleteRadiusUnusedTags(radius, result)
 
 		case string:
-			if strings.ContainsRune(value, '/') {
+			switch strings.Count(value, "/") {
-				if values := strings.Split(value, "/"); len(values) == 2 {
+			case 0:
-					if result = radiusPropertySet(radius, tag+"-x", values[0]); result != nil {
-						if resultY := radiusPropertySet(radius, tag+"-y", values[1]); resultY != nil {
-							result = append(result, resultY...)
-						}
-
-					}
-				} else {
-					notCompatibleType(tag, value)
-				}
-			} else {
 				if result = setSizeProperty(radius, tag, value); result != nil {
 					deleteTags([]PropertyName{tag + "-x", tag + "-y"})
 					deleteRadiusUnusedTags(radius, result)
 				}
+
+			case 1:
+				if x, y, ok := strings.Cut(value, "/"); ok {
+					if result = radiusPropertySet(radius, tag+"-x", x); result != nil {
+						if resultY := radiusPropertySet(radius, tag+"-y", y); resultY != nil {
+							result = append(result, resultY...)
+						}
+					}
+				} else {
+					notCompatibleType(tag, value)
+				}
+			default:
+				notCompatibleType(tag, value)
 			}
 		}
 

range.go

@@ -20,30 +20,34 @@ func (r Range) String() string {
 }
 
 func (r *Range) setValue(value string) bool {
-	var err error
-	if strings.ContainsRune(value, ':') {
-		values := strings.Split(value, ":")
-		if len(values) != 2 {
-			ErrorLog("Invalid range value: " + value)
-			return false
-		}
-		if r.First, err = strconv.Atoi(strings.Trim(values[0], " \t\n\r")); err != nil {
-			ErrorLog(`Invalid first range value "` + value + `" (` + err.Error() + ")")
-			return false
-		}
-		if r.Last, err = strconv.Atoi(strings.Trim(values[1], " \t\n\r")); err != nil {
-			ErrorLog(`Invalid last range value "` + value + `" (` + err.Error() + ")")
-			return false
-		}
-		return true
-	}
 
+	var err error
+
+	switch strings.Count(value, ":") {
+	case 0:
 		if r.First, err = strconv.Atoi(value); err != nil {
 			ErrorLog(`Invalid range value "` + value + `" (` + err.Error() + ")")
 			return false
 		}
 		r.Last = r.First
 		return true
+
+	case 1:
+		if first, last, ok := strings.Cut(value, ":"); ok {
+			if r.First, err = strconv.Atoi(strings.Trim(first, " \t\n\r")); err != nil {
+				ErrorLog(`Invalid first range value "` + value + `" (` + err.Error() + ")")
+				return false
+			}
+			if r.Last, err = strconv.Atoi(strings.Trim(last, " \t\n\r")); err != nil {
+				ErrorLog(`Invalid last range value "` + value + `" (` + err.Error() + ")")
+				return false
+			}
+			return true
+		}
+	}
+
+	ErrorLog("Invalid range value: " + value)
+	return false
 }
 
 func setRangeProperty(properties Properties, tag PropertyName, value any) []PropertyName {

resizable.go

@@ -175,9 +175,8 @@ func resizableSide(view View) int {
 				}
 
 				if strings.ContainsRune(value, '|') {
-					values := strings.Split(value, "|")
 					sides := 0
-					for _, val := range values {
+					for val := range strings.SplitSeq(value, "|") {
 						if n, err := strconv.Atoi(val); err == nil {
 							if n < 1 || n > AllSides {
 								return AllSides

tableView.go

@@ -804,29 +804,37 @@ func (table *tableViewData) setFunc(tag PropertyName, value any) []PropertyName
 			}
 
 		case string:
-			if strings.ContainsRune(value, ',') {
+			switch strings.Count(value, ",") {
-				if values := strings.Split(value, ","); len(values) == 2 {
+			case 0:
-					var n = []int{0, 0}
-					for i := range 2 {
-						var err error
-						if n[i], err = strconv.Atoi(values[i]); err != nil {
-							ErrorLog(err.Error())
-							return nil
-						}
-					}
-					current.Row = n[0]
-					current.Column = n[1]
-				} else {
-					notCompatibleType(tag, value)
-					return nil
-				}
-			} else {
 				n, err := strconv.Atoi(value)
 				if err != nil {
 					ErrorLog(err.Error())
 					return nil
 				}
 				current.Row = n
+
+			case 1:
+				n := make([]int, 0, 2)
+				for val := range strings.SplitSeq(value, ",") {
+					if i, err := strconv.Atoi(val); err != nil {
+						ErrorLog(err.Error())
+						return nil
+					} else {
+						n = append(n, i)
+					}
+				}
+
+				if len(n) == 2 {
+					current.Row = n[0]
+					current.Column = n[1]
+				} else {
+					notCompatibleType(tag, value)
+					return nil
+				}
+
+			default:
+				notCompatibleType(tag, value)
+				return nil
 			}
 
 		default:

timePicker.go

@@ -143,8 +143,8 @@ func stringToTime(value string) (time.Time, bool) {
 	pm := strings.HasSuffix(lowText, "PM") || strings.HasSuffix(lowText, "AM")
 
 	var format string
-	switch len(strings.Split(value, ":")) {
+	switch strings.Count(value, ":") {
-	case 2:
+	case 1:
 		if pm {
 			format = "3:04 PM"
 		} else {