@alchemy.run/sigil 0.0.0-alpha.2 → 0.0.0-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alchemy.run/sigil",
-  "version": "0.0.0-alpha.2",
+  "version": "0.0.0-alpha.4",
   "description": "React for CLIs. A self-contained fork of Ink with an integrated TypeScript Yoga layout engine.",
   "keywords": [
     "cli",
@@ -33,7 +33,7 @@
   ],
   "type": "module",
   "imports": {
-    "#/": "./src"
+    "#/*": "./src/*"
   },
   "exports": {
     ".": {
@@ -70,7 +70,6 @@
     "@types/react": "^19.2.18",
     "@types/react-reconciler": "^0.33.0",
     "@types/scheduler": "^0.26.0",
-    "@types/ws": "^8.18.1",
     "react": "^19.2.8",
     "react-devtools-core": "^7.0.1",
     "react-router": "^8.3.0",
@@ -78,14 +77,12 @@
     "typescript": "^7.0.2",
     "vite-plus": "^0.2.9",
     "vitest": "4.1.11",
-    "ws": "^8.20.0",
     "zigpty": "^0.2.1"
   },
   "peerDependencies": {
     "@types/react": ">=19.2.0",
     "react": ">=19.2.0",
-    "react-devtools-core": ">=6.1.2",
-    "ws": ">=8.20.0"
+    "react-devtools-core": ">=6.1.2"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -93,9 +90,6 @@
     },
     "react-devtools-core": {
       "optional": true
-    },
-    "ws": {
-      "optional": true
     }
   },
   "engines": {

package/src/ansi/chalk.ts

@@ -1,7 +1,7 @@
 // Terminal string styling with a chalk-compatible API for the styles Ink uses.
 // Ported from `chalk` (MIT, Sindre Sorhus) without the chaining builder —
 // Ink only ever applies one style per call.
-import { ESC } from "./escapes.ts";
+import { ESC } from "#/ansi/escapes.ts";
 import {
   background,
   backgroundColorNames,
@@ -15,12 +15,12 @@ import {
   type BackgroundColorName,
   type ForegroundColorName,
   type ModifierName,
-} from "./sgr.ts";
+} from "#/ansi/sgr.ts";
 import {
   supportsColor as supportsColorDetection,
   type ColorInfo,
   type ColorSupportLevel,
-} from "./supports-color.ts";
+} from "#/ansi/supports-color.ts";
 
 export type { BackgroundColorName, ForegroundColorName, ModifierName };
 
@@ -38,50 +38,6 @@ const state = {
 
 // Replace every occurrence of `substring` with `substring + replacer`,
 // re-opening a style after a nested close code would have ended it.
-const stringReplaceAll = (string: string, substring: string, replacer: string): string => {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-
-  returnValue += string.slice(endIndex);
-  return returnValue;
-};
-
-// Close the style before every line break and reopen it after, to prevent
-// background bleed across lines (https://github.com/chalk/chalk/pull/92).
-const stringEncaseCRLFWithFirstIndex = (
-  string: string,
-  prefix: string,
-  postfix: string,
-  index: number,
-): string => {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue +=
-      string.slice(endIndex, gotCR ? index - 1 : index) +
-      prefix +
-      (gotCR ? "\r\n" : "\n") +
-      postfix;
-    endIndex = index + 1;
-    index = string.indexOf("\n", endIndex);
-  } while (index !== -1);
-
-  returnValue += string.slice(endIndex);
-  return returnValue;
-};
-
 const applyStyle = (open: string, close: string, text: string): string => {
   if (state.level <= 0 || !text) {
     return text;
@@ -92,12 +48,13 @@ const applyStyle = (open: string, close: string, text: string): string => {
   if (string.includes(ESC)) {
     // Re-open the style wherever the text already contains its close code,
     // otherwise only the part before that code would stay styled.
-    string = stringReplaceAll(string, close, open);
+    string = string.replaceAll(close, close + open);
   }
 
-  const lfIndex = string.indexOf("\n");
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, close, open, lfIndex);
+  if (string.includes("\n")) {
+    // Close the style before every line break and reopen it after, to prevent
+    // background bleed across lines (https://github.com/chalk/chalk/pull/92).
+    string = string.replaceAll(/\r?\n/g, `${close}$&${open}`);
   }
 
   return open + string + close;

package/src/ansi/cursor.ts

@@ -1,10 +1,8 @@
+import { cursorHide, cursorShow } from "#/ansi/escapes.ts";
 // Derived from `cli-cursor` + `restore-cursor` (MIT, Sindre Sorhus),
 // collapsed into one module. Restores the cursor on process exit once
 // `hide()` has been called, like `restore-cursor` did.
-import process from "node:process";
-
-import { signalExit } from "../signal-exit.ts";
-import { cursorHide, cursorShow } from "./escapes.ts";
+import { signalExit } from "#/signal-exit.ts";
 
 type CursorStream = {
   isTTY?: boolean;

package/src/ansi/east-asian-width.ts

@@ -206,6 +206,50 @@ export function eastAsianWidth(
   return 1;
 }
 
+/**
+Grapheme-cluster width test shared by the tokenizer (slice/clip path): the
+base code point's East Asian Width, plus emoji presentation rules.
+*/
+export function isFullwidthGrapheme(grapheme: string, baseCodePoint: number): boolean {
+  if (isFullwidthCodePoint(baseCodePoint)) return true;
+  // Variation Selector 16 forces emoji presentation (2 columns wide)
+  if (grapheme.includes("\uFE0F")) return true;
+  // Regional indicator pairs form flag emoji (2 columns wide)
+  if (baseCodePoint >= 0x1f1e6 && baseCodePoint <= 0x1f1ff) return true;
+  return false;
+}
+
+/**
+Wide code points not covered by string-width's CJKT script regex or emoji
+regex — the fallback bucket of its block parser. A disjoint decomposition of
+the `wide` table above, kept alongside it so the width data lives in one
+module.
+*/
+export const isWideNotCJKTNotEmoji = (x: number): boolean => {
+  return (
+    x === 0x231b ||
+    x === 0x2329 ||
+    (x >= 0x2ff0 && x <= 0x2fff) ||
+    (x >= 0x3001 && x <= 0x303e) ||
+    (x >= 0x3099 && x <= 0x30ff) ||
+    (x >= 0x3105 && x <= 0x312f) ||
+    (x >= 0x3131 && x <= 0x318e) ||
+    (x >= 0x3190 && x <= 0x31e3) ||
+    (x >= 0x31ef && x <= 0x321e) ||
+    (x >= 0x3220 && x <= 0x3247) ||
+    (x >= 0x3250 && x <= 0x4dbf) ||
+    (x >= 0xfe10 && x <= 0xfe19) ||
+    (x >= 0xfe30 && x <= 0xfe52) ||
+    (x >= 0xfe54 && x <= 0xfe66) ||
+    (x >= 0xfe68 && x <= 0xfe6b) ||
+    (x >= 0x1f200 && x <= 0x1f202) ||
+    (x >= 0x1f210 && x <= 0x1f23b) ||
+    (x >= 0x1f240 && x <= 0x1f248) ||
+    (x >= 0x20000 && x <= 0x2fffd) ||
+    (x >= 0x30000 && x <= 0x3fffd)
+  );
+};
+
 export function isFullwidthCodePoint(codePoint: number): boolean {
   if (!Number.isInteger(codePoint)) {
     return false;

package/src/ansi/escapes.ts

@@ -1,7 +1,4 @@
-import os from "node:os";
 // Derived from `ansi-escapes` (MIT, Sindre Sorhus), reduced to the escapes Ink uses.
-import process from "node:process";
-
 // Control characters and sequence introducers. This module is the single
 // home for escape sequences: everything else imports these instead of
 // spelling out `\u001B[...` inline.
@@ -51,29 +48,10 @@ export const eraseLines = (count: number): string => {
   return clear;
 };
 
-// Windows 10 builds before 10586 don't support the `3J` escape.
-const isOldWindows = (): boolean => {
-  if (process.platform !== "win32") {
-    return false;
-  }
-
-  const parts = os.release().split(".");
-  const major = Number(parts[0]);
-  const build = Number(parts[2] ?? 0);
-
-  if (major < 10) {
-    return true;
-  }
-
-  return major === 10 && build < 10_586;
-};
-
-export const clearTerminal = isOldWindows()
-  ? `${eraseScreen}${CSI}0f`
-  : // 1. Erases the screen (only done in case `2` is not supported)
-    // 2. Erases the whole screen including scrollback buffer
-    // 3. Moves cursor to the top-left position
-    `${eraseScreen}${CSI}3J${CSI}H`;
+// 1. Erases the screen (only done in case `2` is not supported)
+// 2. Erases the whole screen including scrollback buffer
+// 3. Moves cursor to the top-left position
+export const clearTerminal = `${eraseScreen}${CSI}3J${CSI}H`;
 
 export const enterAlternativeScreen = CSI + "?1049h";
 export const exitAlternativeScreen = CSI + "?1049l";

package/src/ansi/index.ts

@@ -3,25 +3,23 @@
 // `@alchemy.run/sigil/ansi`.
 
 // Styling
-export { chalk } from "./chalk.ts";
-export { supportsColor } from "./supports-color.ts";
-export * from "./sgr.ts";
+export { chalk } from "#/ansi/chalk.ts";
+export { supportsColor } from "#/ansi/supports-color.ts";
+export * from "#/ansi/sgr.ts";
 
 // Escape sequences (raw building blocks + named sequences)
-export { ansiEscapes } from "./escapes.ts";
-export * from "./escapes.ts";
-export { cliCursor } from "./cursor.ts";
+export * from "#/ansi/escapes.ts";
+export { cliCursor } from "#/ansi/cursor.ts";
 
 // Measurement
-export { stringWidth } from "./string-width.ts";
-export { widestLine } from "./widest-line.ts";
-export * from "./east-asian-width.ts";
+export { stringWidth, widestLine } from "#/ansi/string-width.ts";
+export * from "#/ansi/east-asian-width.ts";
 
 // String manipulation
-export { stripAnsi, ansiRegex } from "./strip.ts";
-export { sliceAnsi } from "./slice.ts";
-export { cliTruncate as truncateAnsi } from "./truncate.ts";
-export { wrapAnsi } from "./wrap.ts";
+export { stripAnsi } from "#/ansi/strip.ts";
+export { sliceAnsi } from "#/ansi/slice.ts";
+export { cliTruncate as truncateAnsi } from "#/ansi/truncate.ts";
+export { wrapAnsi } from "#/ansi/wrap.ts";
 
 // Tokenizer: style-aware parsing and minimal re-emission
-export * from "./tokenize.ts";
+export * from "#/ansi/tokenize.ts";

package/src/ansi/sgr.ts

@@ -1,6 +1,6 @@
 // ANSI SGR style tables and color-space conversions.
 // Ported from `ansi-styles` (MIT, Sindre Sorhus).
-import { CSI } from "./escapes.ts";
+import { CSI } from "#/ansi/escapes.ts";
 
 const ANSI_BACKGROUND_OFFSET = 10;
 
@@ -173,10 +173,7 @@ export const hexToRgb = (hex: string): [number, number, number] => {
   let [colorString] = matches;
 
   if (colorString.length === 3) {
-    colorString = colorString
-      .split("")
-      .map((character) => character + character)
-      .join("");
+    colorString = colorString.replaceAll(/./g, "$&$&");
   }
 
   const integer = Number.parseInt(colorString, 16);

package/src/ansi/slice.ts

@@ -8,7 +8,7 @@ import {
   styledCharsToString,
   tokenize,
   type StyledChar,
-} from "./tokenize.ts";
+} from "#/ansi/tokenize.ts";
 
 export function sliceAnsi(string: string, start: number, end?: number): string {
   const sliceEnd = end ?? Number.POSITIVE_INFINITY;

package/src/ansi/string-width.ts

@@ -1,236 +1,121 @@
-import { eastAsianWidth } from "./east-asian-width.ts";
-// Visual width of a string: how many terminal columns it occupies.
-// Ported from `string-width` (MIT, Sindre Sorhus).
-//
-// 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).
-import { C1_CSI, ESC } from "./escapes.ts";
-import { stripAnsi } from "./strip.ts";
-
-export type StringWidthOptions = {
-  readonly ambiguousIsNarrow?: boolean;
-  readonly countAnsiEscapeCodes?: boolean;
-};
-
-type EastAsianWidthOptions = {
-  readonly ambiguousAsWide: boolean;
-};
-
-const segmenter = new Intl.Segmenter();
-
-// Whole-cluster zero-width
-const zeroWidthClusterRegex =
-  /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Nonspacing_Mark}|\p{Enclosing_Mark}|\p{Surrogate})+$/v;
+// Derived from `fast-string-truncated-width` (MIT, Fabio Spampinato),
+// reduced to plain width measurement: Sigil truncates via `truncate.ts`, and
+// no caller customizes per-class widths, so those are constants here.
+// Width tables live in east-asian-width.ts, the single width-data module.
 
-// 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;
+import { isFullWidth, isWideNotCJKTNotEmoji } from "#/ansi/east-asian-width.ts";
 
-// RGI emoji sequences
-const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
-
-// Detect minimally-qualified/unqualified emoji sequences (missing VS16 but
-// still rendering as double-width)
-const unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
-const extendedPictographicRegex = /\p{Extended_Pictographic}/gu;
-
-function isDoubleWidthNonRgiEmojiSequence(segment: string): boolean {
-  // Real emoji clusters are < 30 chars; guard against pathological input
-  if (segment.length > 50) {
-    return false;
-  }
-
-  if (unqualifiedKeycapRegex.test(segment)) {
-    return true;
-  }
+const getCodePointsLength = (input: string): number => {
+  let length = 0;
 
-  // ZWJ sequences with 2+ Extended_Pictographic
-  if (segment.includes("\u200D")) {
-    const pictographics = segment.match(extendedPictographicRegex);
-    return pictographics !== null && pictographics.length >= 2;
+  for (const _ of input) {
+    length += 1;
   }
 
-  return false;
-}
-
-function baseVisible(segment: string): string {
-  return segment.replace(leadingNonPrintingRegex, "");
-}
-
-function isZeroWidthCluster(segment: string): boolean {
-  return zeroWidthClusterRegex.test(segment);
-}
-
-function isHangulLeadingJamo(codePoint: number | undefined): boolean {
-  return (
-    codePoint !== undefined &&
-    ((codePoint >= 0x11_00 && codePoint <= 0x11_5f) ||
-      (codePoint >= 0xa9_60 && codePoint <= 0xa9_7c))
-  );
-}
-
-function isHangulVowelJamo(codePoint: number | undefined): boolean {
-  return (
-    codePoint !== undefined &&
-    ((codePoint >= 0x11_60 && codePoint <= 0x11_a7) ||
-      (codePoint >= 0xd7_b0 && codePoint <= 0xd7_c6))
-  );
-}
-
-function isHangulTrailingJamo(codePoint: number | undefined): boolean {
-  return (
-    codePoint !== undefined &&
-    ((codePoint >= 0x11_a8 && codePoint <= 0x11_ff) ||
-      (codePoint >= 0xd7_cb && codePoint <= 0xd7_fb))
-  );
-}
-
-function isHangulJamo(codePoint: number): boolean {
-  return (
-    isHangulLeadingJamo(codePoint) ||
-    isHangulVowelJamo(codePoint) ||
-    isHangulTrailingJamo(codePoint)
-  );
-}
-
-function hangulClusterWidth(
-  visibleSegment: string,
-  eastAsianWidthOptions: EastAsianWidthOptions,
-): number | undefined {
-  const codePoints: number[] = [];
-
-  for (const character of visibleSegment) {
-    if (zeroWidthClusterRegex.test(character)) {
-      continue;
-    }
+  return length;
+};
 
-    codePoints.push(character.codePointAt(0)!);
-  }
+// Unlike the original port, CSI parameters also allow `:` so ITU T.416
+// colon-parameter SGR sequences (which Sigil preserves) measure as width 0.
+const ANSI_RE =
+  /[\u001b\u009b][[()#;?]*[0-9;:]*[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+const CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+const CJKT_WIDE_RE =
+  /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/uy;
+const TAB_RE = /\t{1,1000}/y;
+const EMOJI_RE =
+  /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/uy;
+const LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+const MODIFIER_RE = /\p{M}+/gu;
+
+const ANSI_WIDTH = 0;
+const CONTROL_WIDTH = 0;
+const TAB_WIDTH = 8;
+const EMOJI_WIDTH = 2;
+const FULL_WIDTH_WIDTH = 2;
+const REGULAR_WIDTH = 1;
+const WIDE_WIDTH = 2;
+
+const PARSE_BLOCKS: [RegExp, number][] = [
+  [LATIN_RE, REGULAR_WIDTH],
+  [ANSI_RE, ANSI_WIDTH],
+  [CONTROL_RE, CONTROL_WIDTH],
+  [TAB_RE, TAB_WIDTH],
+  [EMOJI_RE, EMOJI_WIDTH],
+  [CJKT_WIDE_RE, WIDE_WIDTH],
+];
+
+export const stringWidth = (input: string): number => {
+  let indexPrev = 0;
+  let index = 0;
+  const length = input.length;
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
 
-  if (codePoints.length === 0) {
-    return;
-  }
+  outer: while (true) {
+    /* UNMATCHED */
 
-  let width = 0;
+    if (unmatchedEnd > unmatchedStart || (index >= length && index > indexPrev)) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
 
-  for (let index = 0; index < codePoints.length; index++) {
-    const codePoint = codePoints[index]!;
-    if (!isHangulJamo(codePoint)) {
-      if (width === 0) {
-        return;
-      }
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
 
-      // Mixed cluster (e.g., L + precomposed syllable): use EAW for the
-      // non-jamo remainder
-      for (let remaining = index; remaining < codePoints.length; remaining++) {
-        width += eastAsianWidth(codePoints[remaining]!, eastAsianWidthOptions);
+        width += isFullWidth(codePoint)
+          ? FULL_WIDTH_WIDTH
+          : isWideNotCJKTNotEmoji(codePoint)
+            ? WIDE_WIDTH
+            : REGULAR_WIDTH;
       }
 
-      return width;
+      unmatchedStart = unmatchedEnd = 0;
     }
 
-    // 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;
-    }
-
-    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
-  }
+    /* EXITING */
 
-  return width;
-}
-
-function trailingWidth(
-  visibleSegment: string,
-  eastAsianWidthOptions: EastAsianWidthOptions,
-): number {
-  let extra = 0;
-  let first = true;
-
-  for (const character of visibleSegment) {
-    if (first) {
-      first = false;
-      continue;
+    if (index >= length) {
+      break;
     }
 
-    if (spacingMarkRegex.test(character) || (character >= "\uFF00" && character <= "\uFFEF")) {
-      extra += eastAsianWidth(character.codePointAt(0)!, eastAsianWidthOptions);
-    }
-  }
+    /* PARSE BLOCKS */
 
-  return extra;
-}
+    for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i]!;
 
-export function stringWidth(input: string, options: StringWidthOptions = {}): number {
-  if (typeof input !== "string" || input.length === 0) {
-    return 0;
-  }
+      BLOCK_RE.lastIndex = index;
 
-  const { ambiguousIsNarrow = true, countAnsiEscapeCodes = false } = options;
+      if (BLOCK_RE.test(input)) {
+        const lengthExtra =
+          BLOCK_RE === CJKT_WIDE_RE
+            ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex))
+            : BLOCK_RE === EMOJI_RE
+              ? 1
+              : BLOCK_RE.lastIndex - index;
 
-  let string = input;
+        width += lengthExtra * BLOCK_WIDTH;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
 
-  // Avoid calling stripAnsi when there are no ANSI escape sequences
-  // (ESC = 0x1B, CSI = 0x9B)
-  if (!countAnsiEscapeCodes && (string.includes(ESC) || string.includes(C1_CSI))) {
-    string = stripAnsi(string);
-  }
+        continue outer;
+      }
+    }
 
-  if (string.length === 0) {
-    return 0;
-  }
+    /* UNMATCHED INDEX */
 
-  // Fast path: printable ASCII (0x20–0x7E) needs no segmenter, regex, or EAW
-  // lookup — width equals length.
-  if (/^[ -~]*$/.test(string)) {
-    return string.length;
+    index += 1;
   }
 
-  let width = 0;
-  const eastAsianWidthOptions: 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;
-    }
+  return width;
+};
 
-    // Everything else: EAW of the cluster's first visible scalar
-    const codePoint = visibleSegment.codePointAt(0)!;
-    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+export const widestLine = (text: string): number => {
+  let lineWidth = 0;
 
-    // Add width for trailing spacing marks and Halfwidth/Fullwidth Forms
-    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+  for (const line of text.split("\n")) {
+    lineWidth = Math.max(lineWidth, stringWidth(line));
   }
 
-  return width;
-}
+  return lineWidth;
+};