@alchemy.run/sigil 0.0.0-alpha.3 → 0.0.0-alpha.5

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;
+};

package/src/ansi/strip.ts

@@ -1,33 +1,13 @@
-// ANSI escape sequence matching and removal.
-// Ported from `ansi-regex` and `strip-ansi` (MIT, Sindre Sorhus).
-import { BEL, C1_CSI, C1_ST, ESC } from "./escapes.ts";
-
-export function ansiRegex({ onlyFirst = false }: { onlyFirst?: boolean } = {}): RegExp {
-  // Valid string terminator sequences are BEL, ESC\, and C1 ST
-  const st = `(?:${BEL}|${ESC}\\\\|${C1_ST})`;
-
-  // OSC sequences only: ESC ] ... ST
-  // The payload stops at the first terminator character rather than scanning
-  // ahead for one, so an unterminated `ESC ]` cannot rescan the rest of the
-  // input. Terminals likewise abort a control string on an unexpected ESC.
-  const osc = `(?:${ESC}\\][^${BEL}${ESC}${C1_ST}]*${st})`;
-
-  // CSI and related: ESC/C1, optional intermediates, optional params
-  // (supports ; and :) then final byte
-  const csi = `[${ESC}${C1_CSI}][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]`;
-
-  return new RegExp(`${osc}|${csi}`, onlyFirst ? undefined : "g");
-}
-
-const regex = ansiRegex();
-
-export function stripAnsi(string: string): string {
-  // Fast path: ANSI codes require ESC (7-bit) or CSI (8-bit) introducer
-  if (!string.includes(ESC) && !string.includes(C1_CSI)) {
-    return string;
-  }
-
-  // Even though the regex is global, we don't need to reset `.lastIndex`
-  // because `.replace()` does it automatically.
-  return string.replace(regex, "");
-}
+import { stripVTControlCharacters } from "node:util";
+
+// Node's stripVTControlCharacters only understands semicolon-separated CSI
+// parameters, so an ITU T.416 colon-parameter SGR sequence like
+// `\u001B[38:2::255:100:0m` — which Sigil deliberately preserves in output
+// (see sanitize-ansi.ts) — would leave `:2::255:100:0m` behind. Remove those
+// first, then let Node handle everything else.
+// https://github.com/nodejs/node/pull/65379 fixes this upstream; this wrapper
+// can go once the minimum supported Node version ships it.
+const colonSgrRegex = /(?:\u001B\[|\u009B)[\d;]*:[\d;:]*m/g;
+
+export const stripAnsi = (input: string): string =>
+  stripVTControlCharacters(input.replaceAll(colonSgrRegex, ""));