@cjser/string-width 8.2.2-cjser.2 → 9.0.0-cjser.2

package/dist-cjser/index.cjs

@@ -26,7 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/@cjser/string-width.tmp-26-1783614088733/index.js
+// packages/@cjser/string-width.tmp-24-1794504182864/index.js
 var index_exports = {};
 __export(index_exports, {
   default: () => stringWidth
@@ -35,88 +35,106 @@ module.exports = __toCommonJS(index_exports);
 var import_strip_ansi = __toESM(require("@cjser/strip-ansi"), 1);
 var import_get_east_asian_width = require("@cjser/get-east-asian-width");
 var segmenter = new Intl.Segmenter();
-var zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Format}|\\p{Nonspacing_Mark}|\\p{Enclosing_Mark}|\\p{Surrogate})+$", "v");
-var leadingNonPrintingRegex = new RegExp("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Nonspacing_Mark}\\p{Enclosing_Mark}\\p{Surrogate}]+", "v");
-var spacingMarkRegex = new RegExp("\\p{Spacing_Mark}", "v");
-var rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
-var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
-var extendedPictographicRegex = new RegExp("\\p{Extended_Pictographic}", "gu");
-function isDoubleWidthNonRgiEmojiSequence(segment) {
-  if (segment.length > 50) {
-    return false;
-  }
-  if (unqualifiedKeycapRegex.test(segment)) {
-    return true;
-  }
-  if (segment.includes("\u200D")) {
-    const pictographics = segment.match(extendedPictographicRegex);
-    return pictographics !== null && pictographics.length >= 2;
-  }
-  return false;
+var nonAsciiOrControlRegex = new RegExp("[^\\u{20}-\\u{7E}]", "v");
+var prependedConcatenationMarks = String.raw`\u{600}-\u{605}\u{6DD}\u{890}\u{891}\u{8E2}\u{110BD}\u{110CD}`;
+var prependedConcatenationMarksRegex = new RegExp(`^[${prependedConcatenationMarks}]+`, "v");
+var visibleCharacterRegex = new RegExp(String.raw`[^\p{Default_Ignorable_Code_Point}\p{Control}\p{Enclosing_Mark}\p{Nonspacing_Mark}[\p{Format}--[${prependedConcatenationMarks}]]]`, "v");
+var emojiPrefixRegex = new RegExp("^(?:\\p{RGI_Emoji}|\\p{Regional_Indicator}{1,2}|[\\d#*]\\u{FE0F})", "v");
+var textPresentationEmojiRegex = new RegExp("^[\\p{Emoji_Presentation}--[\\u{10000}-\\u{10FFFF}]]\\u{FE0E}", "v");
+function strayEmojiModifierCount(string, fromIndex) {
+  if (fromIndex >= string.length) {
+    return 0;
+  }
+  const modifierRegex = new RegExp("(?<![\\p{Emoji_Modifier_Base}\\u{200D}])\\p{Emoji_Modifier}", "gv");
+  modifierRegex.lastIndex = fromIndex;
+  let count = 0;
+  while (modifierRegex.test(string)) {
+    count++;
+  }
+  return count;
 }
+var emojiZwjSequenceRegex = new RegExp("\\u{200D}\\p{Extended_Pictographic}", "v");
 function baseVisible(segment) {
-  return segment.replace(leadingNonPrintingRegex, "");
-}
-function isZeroWidthCluster(segment) {
-  return zeroWidthClusterRegex.test(segment);
-}
-function isHangulLeadingJamo(codePoint) {
-  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
-}
-function isHangulVowelJamo(codePoint) {
-  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+  const index = segment.search(visibleCharacterRegex);
+  return index === -1 ? void 0 : segment.slice(index);
 }
-function isHangulTrailingJamo(codePoint) {
-  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+function isHangul(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4607 || codePoint >= 43360 && codePoint <= 43388 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 55216 && codePoint <= 55238 || codePoint >= 55243 && codePoint <= 55291;
 }
-function isHangulJamo(codePoint) {
-  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
-}
-function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
-  const codePoints = [];
+function visibleCodePointsWidth(visibleSegment, eastAsianWidthOptions) {
+  let width = 0;
   for (const character of visibleSegment) {
-    if (zeroWidthClusterRegex.test(character)) {
-      continue;
+    if (character === "\u200D") {
+      break;
     }
-    codePoints.push(character.codePointAt(0));
+    if (visibleCharacterRegex.test(character)) {
+      width += (0, import_get_east_asian_width.eastAsianWidth)(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return width;
+}
+function clusterWidth(segment, eastAsianWidthOptions) {
+  const firstCodePoint = segment.codePointAt(0);
+  const marks = firstCodePoint === 69821 || firstCodePoint === 69837 || firstCodePoint >= 1536 && firstCodePoint <= 2303 ? prependedConcatenationMarksRegex.exec(segment) : void 0;
+  if (marks) {
+    const rest = segment.slice(marks[0].length);
+    const restWidth = clusterWidth(rest, eastAsianWidthOptions);
+    const visibleRest = baseVisible(rest);
+    const isWideGlyph = restWidth >= 2 && ((0, import_get_east_asian_width.eastAsianWidth)(visibleRest.codePointAt(0), eastAsianWidthOptions) === 2 || emojiPrefixRegex.test(visibleRest) || emojiZwjSequenceRegex.test(visibleRest));
+    return isWideGlyph ? restWidth : [...marks[0]].length + restWidth;
+  }
+  const visibleSegment = baseVisible(segment);
+  if (visibleSegment === void 0) {
+    return 0;
   }
-  if (codePoints.length === 0) {
-    return void 0;
+  if (isHangul(firstCodePoint)) {
+    return (0, import_get_east_asian_width.eastAsianWidth)(firstCodePoint, eastAsianWidthOptions) + strayEmojiModifierCount(segment, 1) * 2;
   }
+  if (textPresentationEmojiRegex.test(visibleSegment)) {
+    return 1;
+  }
+  const emoji = emojiPrefixRegex.exec(visibleSegment);
+  if (emoji) {
+    return 2 + strayEmojiModifierCount(visibleSegment, emoji[0].length) * 2;
+  }
+  const zwjSequence = emojiZwjSequenceRegex.exec(visibleSegment);
+  return zwjSequence ? 2 + strayEmojiModifierCount(visibleSegment, zwjSequence.index + zwjSequence[0].length) * 2 : visibleCodePointsWidth(visibleSegment, eastAsianWidthOptions);
+}
+function unicodeWidth(string, ambiguousIsNarrow) {
   let width = 0;
-  for (let index = 0; index < codePoints.length; index++) {
-    const codePoint = codePoints[index];
-    if (!isHangulJamo(codePoint)) {
-      if (width === 0) {
-        return void 0;
-      }
-      for (let remaining = index; remaining < codePoints.length; remaining++) {
-        width += (0, import_get_east_asian_width.eastAsianWidth)(codePoints[remaining], eastAsianWidthOptions);
-      }
-      return width;
-    }
-    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
-      width += 2;
-      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
-      continue;
+  const firstNonAsciiIndex = string.search(nonAsciiOrControlRegex);
+  if (firstNonAsciiIndex > 1) {
+    width = firstNonAsciiIndex - 1;
+    string = string.slice(width);
+  }
+  let suffixStart = string.length;
+  while (suffixStart > 0) {
+    const codePoint = string.codePointAt(suffixStart - 1);
+    if (codePoint < 32 || codePoint > 126) {
+      break;
     }
-    width += (0, import_get_east_asian_width.eastAsianWidth)(codePoint, eastAsianWidthOptions);
+    suffixStart--;
   }
-  return width;
-}
-function trailingWidth(visibleSegment, eastAsianWidthOptions) {
-  let extra = 0;
-  let first = true;
-  for (const character of visibleSegment) {
-    if (first) {
-      first = false;
+  if (suffixStart + 1 < string.length) {
+    width += string.length - suffixStart - 1;
+    string = string.slice(0, suffixStart + 1);
+  }
+  if (!new RegExp("[^\\u{20}-\\u{7E}\\u{4E00}-\\u{9FFF}\\u{AC00}-\\u{D7A3}]", "v").test(string)) {
+    return width + string.length + string.replaceAll(new RegExp("[\\u{20}-\\u{7E}]", "gv"), "").length;
+  }
+  string = string.toWellFormed();
+  string = string.replaceAll(new RegExp("(?<=[\\u{16D63}-\\u{16D6A}])[\\u{16D63}-\\u{16D6A}]+", "gv"), "");
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string)) {
+    if (segment.length === 1) {
+      if (visibleCharacterRegex.test(segment)) {
+        width += (0, import_get_east_asian_width.eastAsianWidth)(segment.codePointAt(0), eastAsianWidthOptions);
+      }
       continue;
     }
-    if (spacingMarkRegex.test(character) || character >= "\uFF00" && character <= "\uFFEF") {
-      extra += (0, import_get_east_asian_width.eastAsianWidth)(character.codePointAt(0), eastAsianWidthOptions);
-    }
+    width += clusterWidth(segment, eastAsianWidthOptions);
   }
-  return extra;
+  return width;
 }
 function stringWidth(input, options = {}) {
   if (typeof input !== "string" || input.length === 0) {
@@ -130,31 +148,5 @@ function stringWidth(input, options = {}) {
   if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("\x9B"))) {
     string = (0, import_strip_ansi.default)(string);
   }
-  if (string.length === 0) {
-    return 0;
-  }
-  if (/^[\u0020-\u007E]*$/.test(string)) {
-    return string.length;
-  }
-  let width = 0;
-  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
-  for (const { segment } of segmenter.segment(string)) {
-    if (isZeroWidthCluster(segment)) {
-      continue;
-    }
-    if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
-      width += 2;
-      continue;
-    }
-    const visibleSegment = baseVisible(segment);
-    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
-    if (hangulWidth !== void 0) {
-      width += hangulWidth;
-      continue;
-    }
-    const codePoint = visibleSegment.codePointAt(0);
-    width += (0, import_get_east_asian_width.eastAsianWidth)(codePoint, eastAsianWidthOptions);
-    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
-  }
-  return width;
+  return nonAsciiOrControlRegex.test(string) ? unicodeWidth(string, ambiguousIsNarrow) : string.length;
 }

package/index.d.ts

@@ -5,7 +5,7 @@ export type Options = {
 	@default true
 
 	> Ambiguous characters behave like wide or narrow characters depending on the context (language tag, script identification, associated font, source of data, or explicit markup; all can provide the context). __If the context cannot be established reliably, they should be treated as narrow characters by default.__
-	> - http://www.unicode.org/reports/tr11/
+	> - https://www.unicode.org/reports/tr11/
 	*/
 	readonly ambiguousIsNarrow?: boolean;
 
@@ -20,7 +20,7 @@ export type Options = {
 /**
 Get the visual width of a string - the number of columns required to display it.
 
-Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and doesn't affect the width.
+Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and do not affect the width.
 
 @example
 ```

package/index.js

@@ -5,146 +5,189 @@ import {eastAsianWidth} from '@cjser/get-east-asian-width';
 Logic:
 - Segment graphemes to match how terminals render clusters.
 - Width rules:
-	1. Skip non-printing clusters (Default_Ignorable, Control, pure nonspacing/enclosing Mark, lone Surrogates). Tabs are ignored by design.
-	2. RGI emoji clusters (\p{RGI_Emoji}) are double-width.
-	3. Minimally-qualified/unqualified emoji clusters (ZWJ sequences with 2+ Extended_Pictographic, or keycap sequences) are double-width.
-	4. Hangul jamo collapse each standard modern Hangul L+V or L+V+T syllable piece to width 2.
-	   Unmatched repeated leading/vowel/trailing jamo stay additive because that matches how the terminals we target render them.
-	5. Otherwise use East Asian Width of the cluster's first visible code point, and add widths for trailing spacing marks and Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
+	1. Skip non-printing clusters (Default_Ignorable, Control, Format except spacing prepended concatenation marks like ARABIC NUMBER SIGN, pure nonspacing/enclosing Mark). Tabs are ignored by design. Lone surrogates are measured as U+FFFD, which is how they are written out.
+	2. Clusters starting with an RGI emoji (\p{RGI_Emoji}), regional indicators, or a digit/#/* with VS16 are double-width, even with trailing extenders (e.g., a dangling ZWJ, an extra variation selector, or a spacing mark). Only a stray emoji modifier adds its own swatch width.
+	   A wide BMP emoji followed by VS15 (text presentation) is one column; anything after the VS15 is ignored.
+	3. Minimally-qualified emoji ZWJ sequences (2+ Extended_Pictographic) are double-width, except that a stray emoji modifier after the sequence adds its own swatch width. An unqualified keycap (no VS16) is text, so it uses the width of its base.
+	4. A cluster starting with Hangul (jamo or a precomposed syllable) is one syllable block with the width of its first code point (plus stray emoji modifiers), as in iTerm, Ghostty, and kitty.
+	5. Otherwise sum the East Asian Width of every visible code point in the cluster: the base plus trailing spacing marks (including Thai/Lao AM), stray emoji modifiers, Indic conjunct consonants, and halfwidth dakuten/handakuten. Nothing after a ZWJ is counted.
+	6. Spacing prepended concatenation marks (e.g., ARABIC NUMBER SIGN before digits) are one column each, unless the following glyph is wide (East Asian Wide or emoji, but not in VS15 text style), which takes them into its own cell.
 */
 
 const segmenter = new Intl.Segmenter();
+const nonAsciiOrControlRegex = /[^\u{20}-\u{7E}]/v;
 
-// Whole-cluster zero-width
-const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Nonspacing_Mark}|\p{Enclosing_Mark}|\p{Surrogate})+$/v;
+// Spacing Prepended_Concatenation_Mark format characters (e.g., ARABIC NUMBER SIGN) that are visible signs spanning the following characters. Excludes the zero-width U+070F SYRIAC ABBREVIATION MARK.
+const prependedConcatenationMarks = String.raw`\u{600}-\u{605}\u{6DD}\u{890}\u{891}\u{8E2}\u{110BD}\u{110CD}`;
+const prependedConcatenationMarksRegex = new RegExp(`^[${prependedConcatenationMarks}]+`, 'v');
 
-// Pick the base scalar if the cluster starts with Prepend/Format/Marks
-const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Nonspacing_Mark}\p{Enclosing_Mark}\p{Surrogate}]+/v;
-const spacingMarkRegex = /\p{Spacing_Mark}/v;
+// Matches a visible (printing) character. Used to find the base scalar of a cluster (skipping leading Format characters and marks), to detect whole-cluster zero-width, and to skip invisible code points when summing widths.
+// Intentionally a single negated class without a quantifier: a repeated pattern like `^(?:…|…)+$` backtracks exponentially on overlapping properties, and even `^[…]+$` overflows V8's backtrack stack (RangeError) on clusters with millions of marks.
+// Line and paragraph separators (U+2028, U+2029) are intentionally not skipped: iTerm, Terminal.app, and kitty show them as one column.
+const visibleCharacterRegex = new RegExp(String.raw`[^\p{Default_Ignorable_Code_Point}\p{Control}\p{Enclosing_Mark}\p{Nonspacing_Mark}[\p{Format}--[${prependedConcatenationMarks}]]]`, 'v');
 
-// RGI emoji sequences
-const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+// Clusters starting with an RGI emoji sequence. Not anchored at the end, so trailing extenders (ZWJ, marks, variation selectors) in the same cluster do not hide the emoji.
+// Regional indicators that do not form a valid flag (alone, or an unknown pair) are also shown as one wide symbol, and so is a digit, number sign, or asterisk with VS16 (an emoji presentation sequence that is not RGI on its own).
+const emojiPrefixRegex = /^(?:\p{RGI_Emoji}|\p{Regional_Indicator}{1,2}|[\d#*]\u{FE0F})/v;
 
-// Detect minimally-qualified/unqualified emoji sequences (missing VS16 but still render as double-width)
-const unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
-const extendedPictographicRegex = /\p{Extended_Pictographic}/gu;
+// A wide BMP emoji followed by VS15 asks for its narrow text style. Every BMP Emoji_Presentation character has a standardized text variation sequence.
+// Limitation: astral emoji (e.g., 👍︎) keep their width, because only some of them have a text variation sequence and terminals disagree.
+const textPresentationEmojiRegex = /^[\p{Emoji_Presentation}--[\u{10000}-\u{10FFFF}]]\u{FE0E}/v;
 
-function isDoubleWidthNonRgiEmojiSequence(segment) {
-	// Real emoji clusters are < 30 chars; guard against pathological input
-	if (segment.length > 50) {
-		return false;
+// Counts stray emoji modifiers from `fromIndex`, keeping the whole string for lookbehind context.
+function strayEmojiModifierCount(string, fromIndex) {
+	// Most emoji clusters are fully consumed by the emoji match
+	if (fromIndex >= string.length) {
+		return 0;
 	}
 
-	if (unqualifiedKeycapRegex.test(segment)) {
-		return true;
-	}
+	// An emoji modifier that does not follow an emoji modifier base (or a ZWJ) is shown as a standalone color swatch (UTS #51)
+	const modifierRegex = /(?<![\p{Emoji_Modifier_Base}\u{200D}])\p{Emoji_Modifier}/gv;
+	modifierRegex.lastIndex = fromIndex;
 
-	// ZWJ sequences with 2+ Extended_Pictographic
-	if (segment.includes('\u200D')) {
-		const pictographics = segment.match(extendedPictographicRegex);
-		return pictographics !== null && pictographics.length >= 2;
+	let count = 0;
+	while (modifierRegex.test(string)) {
+		count++;
 	}
 
-	return false;
+	return count;
 }
 
+// Detect minimally-qualified emoji ZWJ sequences (missing VS16 but still render as double-width)
+// A ZWJ only joins a following Extended_Pictographic into the cluster when an Extended_Pictographic comes before it (GB11), so this means 2+ Extended_Pictographic joined by a ZWJ.
+const emojiZwjSequenceRegex = /\u{200D}\p{Extended_Pictographic}/v;
+
+// Returns the cluster starting at its first visible character, or `undefined` if the whole cluster is zero-width.
 function baseVisible(segment) {
-	return segment.replace(leadingNonPrintingRegex, '');
+	const index = segment.search(visibleCharacterRegex);
+	return index === -1 ? undefined : segment.slice(index);
 }
 
-function isZeroWidthCluster(segment) {
-	return zeroWidthClusterRegex.test(segment);
+// Hangul jamo (U+1100..U+11FF, Hangul Jamo Extended-A and -B) and precomposed syllables. Includes the Default_Ignorable HANGUL CHOSEONG/JUNGSEONG FILLER (U+115F, U+1160), which start a syllable block in place of a missing jamo.
+function isHangul(codePoint) {
+	return (codePoint >= 0x11_00 && codePoint <= 0x11_FF)
+		|| (codePoint >= 0xA9_60 && codePoint <= 0xA9_7C)
+		|| (codePoint >= 0xAC_00 && codePoint <= 0xD7_A3)
+		|| (codePoint >= 0xD7_B0 && codePoint <= 0xD7_C6)
+		|| (codePoint >= 0xD7_CB && codePoint <= 0xD7_FB);
 }
 
-function isHangulLeadingJamo(codePoint) {
-	return (codePoint >= 0x11_00 && codePoint <= 0x11_5F)
-		|| (codePoint >= 0xA9_60 && codePoint <= 0xA9_7C);
-}
+// Sums the East Asian Width of the visible code points of a cluster.
+// Everything visible after the base still takes columns: spacing marks (Grapheme_Cluster_Break=SpacingMark, including Thai/Lao AM which are Lo), an emoji modifier not consumed by an emoji modifier sequence (shown as a standalone swatch), the consonants of an Indic conjunct joined by a virama (GB9c), and halfwidth dakuten/handakuten. A ZWJ ends the counting.
+function visibleCodePointsWidth(visibleSegment, eastAsianWidthOptions) {
+	let width = 0;
 
-function isHangulVowelJamo(codePoint) {
-	return (codePoint >= 0x11_60 && codePoint <= 0x11_A7)
-		|| (codePoint >= 0xD7_B0 && codePoint <= 0xD7_C6);
-}
+	for (const character of visibleSegment) {
+		// Match terminal handling of explicit Indic half-forms by counting only the visible characters before a ZWJ in the cluster
+		if (character === '\u{200D}') {
+			break;
+		}
 
-function isHangulTrailingJamo(codePoint) {
-	return (codePoint >= 0x11_A8 && codePoint <= 0x11_FF)
-		|| (codePoint >= 0xD7_CB && codePoint <= 0xD7_FB);
-}
+		if (visibleCharacterRegex.test(character)) {
+			width += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+		}
+	}
 
-function isHangulJamo(codePoint) {
-	return isHangulLeadingJamo(codePoint)
-		|| isHangulVowelJamo(codePoint)
-		|| isHangulTrailingJamo(codePoint);
+	return width;
 }
 
-function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
-	const codePoints = [];
+function clusterWidth(segment, eastAsianWidthOptions) {
+	// Spacing prepended concatenation marks (e.g., ARABIC NUMBER SIGN) are visible one-column signs that join the next character. A wide glyph (East Asian Wide or emoji, but not a VS15 text style) takes them into its own cell.
+	// The marks are in U+0600..U+08FF plus U+110BD and U+110CD, so most clusters skip the regex
+	const firstCodePoint = segment.codePointAt(0);
+	const marks = firstCodePoint === 0x1_10_BD || firstCodePoint === 0x1_10_CD || (firstCodePoint >= 0x6_00 && firstCodePoint <= 0x8_FF) ? prependedConcatenationMarksRegex.exec(segment) : undefined;
+	if (marks) {
+		const rest = segment.slice(marks[0].length);
+		const restWidth = clusterWidth(rest, eastAsianWidthOptions);
+		const visibleRest = baseVisible(rest);
+		const isWideGlyph = restWidth >= 2 && (
+			eastAsianWidth(visibleRest.codePointAt(0), eastAsianWidthOptions) === 2
+			|| emojiPrefixRegex.test(visibleRest)
+			|| emojiZwjSequenceRegex.test(visibleRest)
+		);
+		return isWideGlyph ? restWidth : [...marks[0]].length + restWidth;
+	}
 
-	for (const character of visibleSegment) {
-		if (zeroWidthClusterRegex.test(character)) {
-			continue;
-		}
+	// Zero-width / non-printing clusters (including a Hangul filler with only invisible extenders)
+	const visibleSegment = baseVisible(segment);
+	if (visibleSegment === undefined) {
+		return 0;
+	}
 
-		codePoints.push(character.codePointAt(0));
+	// Checked on the raw cluster, since it can start with a Default_Ignorable filler
+	if (isHangul(firstCodePoint)) {
+		return eastAsianWidth(firstCodePoint, eastAsianWidthOptions) + (strayEmojiModifierCount(segment, 1) * 2);
 	}
 
-	if (codePoints.length === 0) {
-		return undefined;
+	if (textPresentationEmojiRegex.test(visibleSegment)) {
+		return 1;
 	}
 
-	let width = 0;
+	// Emoji width logic. Uses the visible part, so leading invisible characters do not hide the emoji.
+	const emoji = emojiPrefixRegex.exec(visibleSegment);
+	if (emoji) {
+		return 2 + (strayEmojiModifierCount(visibleSegment, emoji[0].length) * 2);
+	}
 
-	for (let index = 0; index < codePoints.length; index++) {
-		const codePoint = codePoints[index];
-		if (!isHangulJamo(codePoint)) {
-			if (width === 0) {
-				return undefined;
-			}
+	// Minimally-qualified emoji ZWJ sequences are double-width, like RGI emoji, except that a stray emoji modifier after the sequence is shown as its own swatch. Everything else: EAW of the cluster’s visible scalars, including trailing spacing marks and Halfwidth/Fullwidth Forms (e.g., ﾞ, ﾟ)
+	const zwjSequence = emojiZwjSequenceRegex.exec(visibleSegment);
+	return zwjSequence
+		? 2 + (strayEmojiModifierCount(visibleSegment, zwjSequence.index + zwjSequence[0].length) * 2)
+		: visibleCodePointsWidth(visibleSegment, eastAsianWidthOptions);
+}
 
-			// Mixed cluster (e.g., L + precomposed syllable): use EAW for non-jamo remainder
-			for (let remaining = index; remaining < codePoints.length; remaining++) {
-				width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
-			}
+function unicodeWidth(string, ambiguousIsNarrow) {
+	// Count the initial printable ASCII directly, keeping its last character as a possible grapheme base.
+	let width = 0;
+	const firstNonAsciiIndex = string.search(nonAsciiOrControlRegex);
+	if (firstNonAsciiIndex > 1) {
+		width = firstNonAsciiIndex - 1;
+		string = string.slice(width);
+	}
 
-			return width;
+	// Keep the first trailing ASCII character with the Unicode prefix.
+	let suffixStart = string.length;
+	while (suffixStart > 0) {
+		const codePoint = string.codePointAt(suffixStart - 1);
+		if (codePoint < 0x20 || codePoint > 0x7E) {
+			break;
 		}
 
-		// Modern Hangul L+V(+T) shapes as one syllable block. Unmatched jamo stay additive:
-		// U+1100 U+1100 U+1161 => U+1100 + (U+1100 U+1161) => 2 + 2.
-		if (
-			isHangulLeadingJamo(codePoint)
-			&& isHangulVowelJamo(codePoints[index + 1])
-		) {
-			width += 2;
-			index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
-			continue;
-		}
+		suffixStart--;
+	}
 
-		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+	if (suffixStart + 1 < string.length) {
+		width += string.length - suffixStart - 1;
+		string = string.slice(0, suffixStart + 1);
 	}
 
-	return width;
-}
+	// Printable ASCII, common Han, and precomposed Hangul have fixed widths and cannot form multi-character graphemes together.
+	if (!/[^\u{20}-\u{7E}\u{4E00}-\u{9FFF}\u{AC00}-\u{D7A3}]/v.test(string)) {
+		return width + string.length + string.replaceAll(/[\u{20}-\u{7E}]/gv, '').length;
+	}
 
-function trailingWidth(visibleSegment, eastAsianWidthOptions) {
-	let extra = 0;
-	let first = true;
+	// A lone surrogate is written out as U+FFFD REPLACEMENT CHARACTER
+	string = string.toWellFormed();
+
+	// Kirat Rai vowel runs form one glyph, including canonically decomposed vowels. Collapse them before segmentation so older Unicode tables give the same width.
+	string = string.replaceAll(/(?<=[\u{16D63}-\u{16D6A}])[\u{16D63}-\u{16D6A}]+/gv, '');
+
+	const eastAsianWidthOptions = {ambiguousAsWide: !ambiguousIsNarrow};
+
+	for (const {segment} of segmenter.segment(string)) {
+		// Fast path: a single visible UTF-16 code unit has its East Asian Width under every rule above (a single-code-point RGI emoji is East Asian Wide, and a Hangul cluster uses the width of its first code point).
+		if (segment.length === 1) {
+			if (visibleCharacterRegex.test(segment)) {
+				width += eastAsianWidth(segment.codePointAt(0), eastAsianWidthOptions);
+			}
 
-	for (const character of visibleSegment) {
-		if (first) {
-			first = false;
 			continue;
 		}
 
-		if (
-			spacingMarkRegex.test(character)
-			|| (character >= '\uFF00' && character <= '\uFFEF')
-		) {
-			extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
-		}
+		width += clusterWidth(segment, eastAsianWidthOptions);
 	}
 
-	return extra;
+	return width;
 }
 
 export default function stringWidth(input, options = {}) {
@@ -160,48 +203,11 @@ export default function stringWidth(input, options = {}) {
 	let string = input;
 
 	// Avoid calling stripAnsi when there are no ANSI escape sequences (ESC = 0x1B, CSI = 0x9B)
-	if (!countAnsiEscapeCodes && (string.includes('\u001B') || string.includes('\u009B'))) {
+	if (!countAnsiEscapeCodes && (string.includes('\u{1B}') || string.includes('\u{9B}'))) {
 		string = stripAnsi(string);
 	}
 
-	if (string.length === 0) {
-		return 0;
-	}
-
-	// Fast path: printable ASCII (0x20–0x7E) needs no segmenter, regex, or EAW lookup — width equals length.
-	if (/^[\u0020-\u007E]*$/.test(string)) {
-		return string.length;
-	}
-
-	let width = 0;
-	const eastAsianWidthOptions = {ambiguousAsWide: !ambiguousIsNarrow};
-
-	for (const {segment} of segmenter.segment(string)) {
-		// Zero-width / non-printing clusters
-		if (isZeroWidthCluster(segment)) {
-			continue;
-		}
-
-		// Emoji width logic
-		if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
-			width += 2;
-			continue;
-		}
-
-		const visibleSegment = baseVisible(segment);
-		const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
-		if (hangulWidth !== undefined) {
-			width += hangulWidth;
-			continue;
-		}
-
-		// Everything else: EAW of the cluster’s first visible scalar
-		const codePoint = visibleSegment.codePointAt(0);
-		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
-
-		// Add width for trailing spacing marks and Halfwidth/Fullwidth Forms (e.g., ﾞ, ﾟ, ｰ)
-		width += trailingWidth(visibleSegment, eastAsianWidthOptions);
-	}
-
-	return width;
+	// Fast path: printable ASCII (0x20–0x7E) needs no segmenter, regex, or EAW lookup. Its width equals its length.
+	// A negated class without a quantifier, since `^[…]*$` overflows V8's backtrack stack (RangeError) on strings with millions of characters.
+	return nonAsciiOrControlRegex.test(string) ? unicodeWidth(string, ambiguousIsNarrow) : string.length;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjser/string-width",
-  "version": "8.2.2-cjser.2",
+  "version": "9.0.0-cjser.2",
   "description": "Get the visual width of a string - the number of columns required to display it",
   "license": "MIT",
   "repository": {
@@ -8,11 +8,7 @@
     "url": "https://code.moenext.com/3rdeye/cjser.git"
   },
   "funding": "https://github.com/sponsors/sindresorhus",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "https://sindresorhus.com"
-  },
+  "author": "Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)",
   "type": "module",
   "exports": {
     "types": "./index.d.ts",
@@ -21,10 +17,10 @@
   },
   "sideEffects": false,
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "scripts": {
-    "test": "xo && ava && tsd"
+    "test": "xo && node --test"
   },
   "files": [
     "index.js",
@@ -59,37 +55,35 @@
     "east-asian-width"
   ],
   "dependencies": {
-    "@cjser/get-east-asian-width": "1.6.0-cjser.2",
+    "@cjser/get-east-asian-width": "1.7.0-cjser.2",
     "@cjser/strip-ansi": "7.2.0-cjser.2"
   },
   "devDependencies": {
-    "ava": "^6.4.1",
-    "tsd": "^0.33.0",
-    "xo": "^1.2.3"
+    "xo": "^5.0.1"
   },
   "types": "./index.d.ts",
   "main": "./dist-cjser/index.cjs",
   "cjser": {
-    "sourceVersion": "8.2.2",
+    "sourceVersion": "9.0.0",
     "cjserVersion": 2,
     "original": {
       "name": "string-width",
-      "version": "8.2.2",
+      "version": "9.0.0",
       "exports": {
         "types": "./index.d.ts",
         "default": "./index.js"
       },
       "repository": "sindresorhus/string-width",
       "dependencies": {
-        "get-east-asian-width": "^1.5.0",
-        "strip-ansi": "^7.1.2"
+        "get-east-asian-width": "^1.7.0",
+        "strip-ansi": "^7.2.0"
       },
       "files": [
         "index.js",
         "index.d.ts"
       ],
       "scripts": {
-        "test": "xo && ava && tsd"
+        "test": "xo && node --test"
       }
     }
   }

package/readme.md

@@ -49,7 +49,7 @@ Default: `true`
 Count [ambiguous width characters](https://www.unicode.org/reports/tr11/#Ambiguous) as having narrow width (count of 1) instead of wide width (count of 2).
 
 > Ambiguous characters behave like wide or narrow characters depending on the context (language tag, script identification, associated font, source of data, or explicit markup; all can provide the context). **If the context cannot be established reliably, they should be treated as narrow characters by default.**
-> - http://www.unicode.org/reports/tr11/
+> - https://www.unicode.org/reports/tr11/
 
 ##### countAnsiEscapeCodes