perf: use codepoint iteration for non-emoji text

Detect grapheme-clustering characters (ZWJ, VS16, regional indicators,
skin tones, keycaps, tags) in a pre-scan. When none found, use for...of
codepoint iteration instead of Intl.Segmenter. Skip zero-width regex
for codepoints known to be visible (wide, ASCII, Latin1).

Author: privatenumber

index.js

@@ -1,5 +1,3 @@
-import stripAnsi from 'strip-ansi';
-
 /**
 Logic:
 - Segment graphemes to match how terminals render clusters.
@@ -9,6 +7,8 @@ Logic:
 	3. Otherwise use East Asian Width of the cluster's first visible code point, and add widths for trailing Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
 */
 
+import stripAnsi from 'strip-ansi';
+
 const segmenter = new Intl.Segmenter();
 
 // Whole-cluster zero-width
@@ -96,6 +96,7 @@ function trailingHalfwidthWidth(segment, ambiguousAsWide) {
 	return extra;
 }
 
+// eslint-disable-next-line complexity
 export default function stringWidth(input, options = {}) {
 	if (typeof input !== 'string' || input.length === 0) {
 		return 0;
@@ -134,9 +135,89 @@ export default function stringWidth(input, options = {}) {
 
 	const ambiguousAsWide = !ambiguousIsNarrow;
 
+	// Try per-codepoint iteration first — avoids Intl.Segmenter overhead (~2–4µs per call).
+	// Bail to segmenter only when we encounter characters that form multi-codepoint grapheme clusters
+	// (emoji ZWJ sequences, flags, skin tones, keycaps, tag sequences).
 	let width = 0;
+	let useSegmenter = false;
+
+	for (const character of string) {
+		const codePoint = character.codePointAt(0);
+
+		// These characters join with adjacent codepoints into multi-codepoint grapheme clusters,
+		// changing the combined width. Fall back to Intl.Segmenter for correctness.
+		if (
+			codePoint === 0x20_0D // ZWJ — joins emoji sequences (e.g., 👩‍👩‍👧‍👦)
+			|| codePoint === 0xFE_0F // VS16 — emoji presentation (e.g., ❤️ vs ❤)
+			|| codePoint === 0x20_E3 // Combining Enclosing Keycap (e.g., 1️⃣)
+			|| (codePoint >= 0x1_F1_E6 && codePoint <= 0x1_F1_FF) // Regional Indicators (flags, e.g., 🇺🇸)
+			|| (codePoint >= 0x1_F3_FB && codePoint <= 0x1_F3_FF) // Skin Tone Modifiers
+			|| (codePoint >= 0xE_00_20 && codePoint <= 0xE_00_7F) // Tag characters (subdivision flags)
+		) {
+			useSegmenter = true;
+			break;
+		}
+
+		// Wide/fullwidth characters (CJK, compatibility forms) are always visible — skip zero-width regex
+		if (isDoubleWidth(codePoint)) {
+			width += 2;
+			continue;
+		}
+
+		if (ambiguousAsWide && isAmbiguous(codePoint)) {
+			width += 2;
+			continue;
+		}
+
+		// Printable ASCII (0x20–0x7E) is always width 1 and never zero-width
+		if (codePoint >= 0x20 && codePoint < 0x7F) {
+			width += 1;
+			continue;
+		}
+
+		// Latin1 through Spacing Modifier Letters (0xA0–0x2FF, except soft hyphen 0xAD)
+		// are all visible width-1 when ambiguous-as-narrow (default)
+		if (!ambiguousAsWide && codePoint >= 0xA0 && codePoint < 0x3_00 && codePoint !== 0xAD) {
+			width += 1;
+			continue;
+		}
+
+		// Remaining: check if zero-width (Control, Format, Mark, Default_Ignorable)
+		if (isZeroWidthCluster(character)) {
+			continue;
+		}
+
+		width += (ambiguousAsWide && isAmbiguous(codePoint)) ? 2 : 1;
+	}
+
+	if (!useSegmenter) {
+		return width;
+	}
+
+	// Slow path: use Intl.Segmenter for strings with multi-codepoint grapheme clusters
+	width = 0;
 
 	for (const {segment} of segmenter.segment(string)) {
+		// Single BMP codepoint — skip regex tests for known-width characters
+		if (segment.length === 1) {
+			const codePoint = segment.codePointAt(0);
+
+			if (isDoubleWidth(codePoint)) {
+				width += 2;
+				continue;
+			}
+
+			if (codePoint >= 0x20 && codePoint < 0x7F) {
+				width += 1;
+				continue;
+			}
+
+			if (!ambiguousAsWide && codePoint >= 0xA0 && codePoint < 0x3_00 && codePoint !== 0xAD) {
+				width += 1;
+				continue;
+			}
+		}
+
 		// Zero-width / non-printing clusters
 		if (isZeroWidthCluster(segment)) {
 			continue;