Initial QSfera import

Server/vendor/github.com/clipperhouse/uax29/v2/graphemes/ansi.go

@@ -0,0 +1,119 @@
+package graphemes
+
+// ansiEscapeLength returns the byte length of a valid ANSI escape sequence at the
+// start of data, or 0 if none. Input is UTF-8; only 7-bit ESC sequences are
+// recognized (C1 0x80–0x9F can be UTF-8 continuation bytes).
+//
+// Recognized forms (ECMA-48 / ISO 6429):
+//   - CSI: ESC [ then parameter bytes (0x30–0x3F), intermediate (0x20–0x2F), final (0x40–0x7E)
+//   - OSC: ESC ] then payload until ST (ESC \) or BEL (0x07)
+//   - DCS, SOS, PM, APC: ESC P / X / ^ / _ then payload until ST (ESC \)
+//   - Two-byte: ESC + Fe (0x40–0x5F excluding above), or Fp (0x30–0x3F), or nF (0x20–0x2F then final)
+func ansiEscapeLength[T ~string | ~[]byte](data T) int {
+	n := len(data)
+	if n < 2 {
+		return 0
+	}
+	if data[0] != esc {
+		return 0
+	}
+
+	b1 := data[1]
+	switch b1 {
+	case '[': // CSI
+		body := csiLength(data[2:])
+		if body == 0 {
+			return 0
+		}
+		return 2 + body
+	case ']': // OSC – allows BEL or ST as terminator
+		body := oscLength(data[2:])
+		if body == 0 {
+			return 0
+		}
+		return 2 + body
+	case 'P', 'X', '^', '_': // DCS, SOS, PM, APC – require ST (ESC \) only
+		body := stSequenceLength(data[2:])
+		if body == 0 {
+			return 0
+		}
+		return 2 + body
+	}
+	if b1 >= 0x40 && b1 <= 0x5F {
+		// Fe (C1) two-byte; [ ] P X ^ _ handled above
+		return 2
+	}
+	if b1 >= 0x30 && b1 <= 0x3F {
+		// Fp (private) two-byte
+		return 2
+	}
+	if b1 >= 0x20 && b1 <= 0x2F {
+		// nF: intermediates then one final (0x30–0x7E)
+		i := 2
+		for i < n && data[i] >= 0x20 && data[i] <= 0x2F {
+			i++
+		}
+		if i < n && data[i] >= 0x30 && data[i] <= 0x7E {
+			return i + 1
+		}
+		return 0
+	}
+	return 0
+}
+
+// csiLength returns the length of the CSI body (param/intermediate/final bytes).
+// data is the slice after "ESC [".
+// Per ECMA-48, the CSI body has the form:
+//
+//	parameters (0x30–0x3F)*, intermediates (0x20–0x2F)*, final (0x40–0x7E)
+//
+// Once an intermediate byte is seen, subsequent parameter bytes are invalid.
+func csiLength[T ~string | ~[]byte](data T) int {
+	seenIntermediate := false
+	for i := 0; i < len(data); i++ {
+		b := data[i]
+		if b >= 0x30 && b <= 0x3F {
+			if seenIntermediate {
+				return 0
+			}
+			continue
+		}
+		if b >= 0x20 && b <= 0x2F {
+			seenIntermediate = true
+			continue
+		}
+		if b >= 0x40 && b <= 0x7E {
+			return i + 1
+		}
+		return 0
+	}
+	return 0
+}
+
+// oscLength returns the length of the OSC body up to and including
+// the terminator. OSC accepts either BEL (0x07) or ST (ESC \) per
+// widespread terminal convention. data is the slice after "ESC ]".
+func oscLength[T ~string | ~[]byte](data T) int {
+	for i := 0; i < len(data); i++ {
+		b := data[i]
+		if b == bel {
+			return i + 1
+		}
+		if b == esc && i+1 < len(data) && data[i+1] == '\\' {
+			return i + 2
+		}
+	}
+	return 0
+}
+
+// stSequenceLength returns the length of a control-string body up to and
+// including the ST (ESC \) terminator. Used for DCS, SOS, PM, and APC, which
+// per ECMA-48 require ST and do not accept BEL. data is the slice after "ESC x".
+func stSequenceLength[T ~string | ~[]byte](data T) int {
+	for i := 0; i < len(data); i++ {
+		if data[i] == esc && i+1 < len(data) && data[i+1] == '\\' {
+			return i + 2
+		}
+	}
+	return 0
+}