apparently this looks like a fastest colorizer for now

Author: OverwriteMC

src/main/java/ru/overwrite/rtp/color/impl/LegacyColorizer.java

@@ -1,78 +1,110 @@
 package ru.overwrite.rtp.color.impl;
 
-import org.jetbrains.annotations.Nullable;
 import ru.overwrite.rtp.color.Colorizer;
 
 public class LegacyColorizer implements Colorizer {
 
     private static final char COLOR_CHAR = '§';
     private static final char ALT_COLOR_CHAR = '&';
 
+    private static final boolean[] HEX = new boolean[128];
+    private static final boolean[] COLOR = new boolean[128];
+
+    static {
+        for (int c = '0'; c <= '9'; c++) {
+            HEX[c] = true;
+            COLOR[c] = true;
+        }
+        for (int c = 'a'; c <= 'f'; c++) {
+            HEX[c] = true;
+            COLOR[c] = true;
+        }
+        for (int c = 'A'; c <= 'F'; c++) {
+            HEX[c] = true;
+            COLOR[c] = true;
+        }
+        for (int c : new int[]{'r', 'R', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O'}) {
+            COLOR[c] = true;
+        }
+    }
+
     @Override
-    public String colorize(@Nullable String message) {
-        if (message == null || message.isEmpty()) {
+    public String colorize(String message) {
+        if (message == null) {
+            return null;
+        }
+        final char[] s = message.toCharArray();
+        final int len = s.length;
+        if (len == 0) {
+            return message;
+        }
+
+        final int firstAmp = message.indexOf(ALT_COLOR_CHAR);
+        if (firstAmp < 0) {
             return message;
         }
 
-        final char[] chars = message.toCharArray();
-        final int length = chars.length;
-
-        final StringBuilder builder = new StringBuilder(length + 32);
-        char[] hex = null;
-
-        int start = 0, end;
-        loop:
-        for (int i = 0; i < length - 1; ) {
-            final char ch = chars[i];
-            if (ch == ALT_COLOR_CHAR) {
-                final char nextChar = chars[++i];
-                if (nextChar == '#') {
-                    if (i + 6 >= length) break;
-                    if (hex == null) {
-                        hex = new char[14];
-                        hex[0] = COLOR_CHAR;
-                        hex[1] = 'x';
-                    }
-                    end = i - 1;
-                    for (int j = 0, hexI = 1; j < 6; j++) {
-                        final char hexChar = chars[++i];
-                        if (!isHexCharacter(hexChar)) {
-                            continue loop;
-                        }
-                        hex[++hexI] = COLOR_CHAR;
-                        hex[++hexI] = hexChar;
-                    }
-                    builder.append(chars, start, end - start).append(hex);
-                    start = i + 1;
-                } else {
-                    if (isColorCharacter(nextChar)) {
-                        chars[i - 1] = COLOR_CHAR;
-                        chars[i] |= 0x20;
-                    }
+        final char[] d = new char[len * 3];
+        int w = 0;
+        int i = 0;
+
+        if (firstAmp > 8) {
+            System.arraycopy(s, 0, d, 0, firstAmp);
+            w = firstAmp;
+            i = firstAmp;
+        } else {
+            while (i < firstAmp) d[w++] = s[i++];
+        }
+
+        while (i < len) {
+            final char c = s[i];
+
+            if (c != ALT_COLOR_CHAR) {
+                d[w++] = c;
+                i++;
+                continue;
+            }
+
+            final int remaining = len - i;
+
+            if (remaining >= 8 && s[i + 1] == '#') {
+                final char h0 = s[i + 2], h1 = s[i + 3], h2 = s[i + 4], h3 = s[i + 5], h4 = s[i + 6], h5 = s[i + 7];
+                if (h0 < 128 && HEX[h0] && h1 < 128 && HEX[h1] && h2 < 128 && HEX[h2] && h3 < 128 && HEX[h3] && h4 < 128 && HEX[h4] && h5 < 128 && HEX[h5]) {
+                    d[w] = COLOR_CHAR;
+                    d[w + 1] = 'x';
+                    d[w + 2] = COLOR_CHAR;
+                    d[w + 3] = h0;
+                    d[w + 4] = COLOR_CHAR;
+                    d[w + 5] = h1;
+                    d[w + 6] = COLOR_CHAR;
+                    d[w + 7] = h2;
+                    d[w + 8] = COLOR_CHAR;
+                    d[w + 9] = h3;
+                    d[w + 10] = COLOR_CHAR;
+                    d[w + 11] = h4;
+                    d[w + 12] = COLOR_CHAR;
+                    d[w + 13] = h5;
+                    w += 14;
+                    i += 8;
+                    continue;
                 }
             }
-            ++i;
-        }
 
-        builder.append(chars, start, length - start);
-        return builder.toString();
-    }
+            if (remaining >= 2) {
+                final char next = s[i + 1];
+                if (next < 128 && COLOR[next]) {
+                    d[w] = COLOR_CHAR;
+                    d[w + 1] = next;
+                    w += 2;
+                    i += 2;
+                    continue;
+                }
+            }
 
-    public static boolean isHexCharacter(final char ch) {
-        return switch (ch) {
-            case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-                 'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F' -> true;
-            default -> false;
-        };
-    }
+            d[w++] = ALT_COLOR_CHAR;
+            i++;
+        }
 
-    private boolean isColorCharacter(char c) {
-        return switch (c) {
-            case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-                 'a', 'b', 'c', 'd', 'e', 'f',
-                 'A', 'B', 'C', 'D', 'E', 'F',
-                 'r', 'R', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'x', 'X' -> true;
-            default -> false;
-        };
+        return new String(d, 0, w);
     }
 }