@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.10

package/src/ansi/escapes.ts

@@ -0,0 +1,120 @@
+// Derived from `ansi-escapes` (MIT, Sindre Sorhus), reduced to the escapes Ink uses.
+// Control characters and sequence introducers. This module is the single
+// home for escape sequences: everything else imports these instead of
+// spelling out `\u001B[...` inline.
+export const ESC = "\u001B";
+export const BEL = "\u0007";
+export const DEL = "\u007F";
+/** Control Sequence Introducer. */
+export const CSI = `${ESC}[`;
+/** Operating System Command. */
+export const OSC = `${ESC}]`;
+/** String Terminator. */
+export const ST = `${ESC}\\`;
+/** Single-byte C1 forms of CSI and ST. */
+export const C1_CSI = "\u009B";
+export const C1_ST = "\u009C";
+
+const sep = ";";
+
+export const cursorTo = (x: number, y?: number): string => {
+  if (typeof y !== "number") {
+    return CSI + (x + 1) + "G";
+  }
+
+  return CSI + (y + 1) + sep + (x + 1) + "H";
+};
+
+export const cursorUp = (count = 1): string => CSI + count + "A";
+export const cursorDown = (count = 1): string => CSI + count + "B";
+export const cursorLeft = CSI + "G";
+export const cursorNextLine = CSI + "E";
+
+export const eraseEndLine = CSI + "K";
+export const eraseLine = CSI + "2K";
+export const eraseScreen = CSI + "2J";
+
+export const eraseLines = (count: number): string => {
+  let clear = "";
+
+  for (let i = 0; i < count; i++) {
+    clear += eraseLine + (i < count - 1 ? cursorUp() : "");
+  }
+
+  if (count) {
+    clear += cursorLeft;
+  }
+
+  return clear;
+};
+
+// 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";
+
+export const cursorShow = CSI + "?25h";
+export const cursorHide = CSI + "?25l";
+export type CursorShape = "block" | "underline" | "bar";
+export const cursorShape = (shape: CursorShape, blinking = true): string => {
+  const value = {
+    block: blinking ? 1 : 2,
+    underline: blinking ? 3 : 4,
+    bar: blinking ? 5 : 6,
+  }[shape];
+  return `${CSI}${value} q`;
+};
+export const cursorColor = (color: string): string => `${OSC}12;${color}${BEL}`;
+export const resetCursorColor = `${OSC}112${BEL}`;
+
+export const enableBracketedPaste = CSI + "?2004h";
+export const disableBracketedPaste = CSI + "?2004l";
+
+// Markers the terminal wraps around pasted input while bracketed paste is on.
+export const pasteStart = CSI + "200~";
+export const pasteEnd = CSI + "201~";
+
+// Synchronized update mode (DEC mode 2026): begin / end synchronized update.
+export const bsu = CSI + "?2026h";
+export const esu = CSI + "?2026l";
+
+// Kitty keyboard protocol: query support, push a flag set, pop it off.
+export const kittyQuery = CSI + "?u";
+export const pushKittyKeyboard = (flags: number): string => `${CSI}>${flags}u`;
+export const popKittyKeyboard = CSI + "<u";
+
+export const link = (text: string, url: string): string =>
+  [OSC, "8", sep, sep, url, BEL, text, OSC, "8", sep, sep, BEL].join("");
+
+export const ansiEscapes = {
+  cursorTo,
+  cursorUp,
+  cursorDown,
+  cursorLeft,
+  cursorNextLine,
+  eraseEndLine,
+  eraseLine,
+  eraseScreen,
+  eraseLines,
+  clearTerminal,
+  enterAlternativeScreen,
+  exitAlternativeScreen,
+  cursorShow,
+  cursorHide,
+  cursorShape,
+  cursorColor,
+  resetCursorColor,
+  enableBracketedPaste,
+  disableBracketedPaste,
+  pasteStart,
+  pasteEnd,
+  bsu,
+  esu,
+  kittyQuery,
+  pushKittyKeyboard,
+  popKittyKeyboard,
+  link,
+};

package/src/ansi/graphemes.ts

@@ -0,0 +1,8 @@
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/** The canonical grapheme segmentation service for measurement and rasterization. */
+export function* graphemes(text: string): Generator<string> {
+  for (const { segment } of segmenter.segment(text)) {
+    yield segment;
+  }
+}

package/src/ansi/hyperlink.ts

@@ -0,0 +1,44 @@
+// Standalone OSC 8 hyperlink builder with fallback — the string counterpart
+// to the <Hyperlink> component, for use outside the React renderer.
+import { link } from "#/ansi/escapes.ts";
+import { detectHyperlinkSupport } from "#/capabilities/detect.ts";
+
+type HyperlinkOptions = {
+  /**
+	When the terminal does not support OSC 8 hyperlinks, append the URL in
+	parentheses after the text so it stays reachable. Set to `false` to
+	return the text alone.
+
+	@default true
+	*/
+  fallback?: boolean;
+
+  /**
+	The stream the text will be written to, for support detection.
+
+	@default process.stdout
+	*/
+  stream?: { isTTY?: boolean };
+};
+
+/**
+Wraps text in a clickable OSC 8 hyperlink when the terminal supports it,
+falling back to `text (url)`.
+
+```ts
+import { hyperlink } from "@alchemy.run/sigil/ansi";
+
+console.log(hyperlink("Documentation", "https://example.com"));
+```
+*/
+export const hyperlink = (
+  text: string,
+  url: string,
+  { fallback = true, stream = process.stdout }: HyperlinkOptions = {},
+): string => {
+  if (detectHyperlinkSupport(stream)) {
+    return link(text, url);
+  }
+
+  return fallback ? `${text} (${url})` : text;
+};

package/src/ansi/index.ts

@@ -0,0 +1,27 @@
+// Standalone ANSI toolkit — styling, measurement, and manipulation of
+// terminal strings. Importable without the React renderer via
+// `@alchemy.run/sigil/ansi`.
+
+// Styling
+export { chalk } from "#/ansi/chalk.ts";
+export { supportsColor } from "#/ansi/chalk.ts";
+export { hyperlink } from "#/ansi/hyperlink.ts";
+export * from "#/ansi/sgr.ts";
+
+// Escape sequences (raw building blocks + named sequences)
+export * from "#/ansi/escapes.ts";
+export * from "#/ansi/osc.ts";
+export { cliCursor } from "#/ansi/cursor.ts";
+
+// Measurement
+export { stringWidth, widestLine } from "#/ansi/string-width.ts";
+export * from "#/ansi/east-asian-width.ts";
+
+// String manipulation
+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 "#/ansi/tokenize.ts";

package/src/ansi/osc.ts

@@ -0,0 +1,77 @@
+import { pathToFileURL } from "node:url";
+
+import { ESC, OSC, ST } from "#/ansi/escapes.ts";
+
+export type ClipboardSelection = "clipboard" | "primary" | "selection";
+export type TerminalProgressState = "inactive" | "normal" | "error" | "indeterminate" | "paused";
+
+const clipboardCode: Record<ClipboardSelection, string> = {
+  clipboard: "c",
+  primary: "p",
+  selection: "s",
+};
+
+const progressCode: Record<TerminalProgressState, number> = {
+  inactive: 0,
+  normal: 1,
+  error: 2,
+  indeterminate: 3,
+  paused: 4,
+};
+
+const field = (value: string): string => value.replace(/[\u0000-\u001F\u007F-\u009F]/g, "");
+
+const command = (code: number, payload: string): string => `${OSC}${code};${payload}${ST}`;
+
+/** Change the terminal window title (OSC 2). */
+export const setWindowTitle = (title: string): string => command(2, field(title));
+
+/** Announce the current directory as a file URI (OSC 7). */
+export const setWorkingDirectory = (directory: URL | string): string => {
+  const uri =
+    directory instanceof URL
+      ? directory
+      : directory.startsWith("file:")
+        ? new URL(directory)
+        : pathToFileURL(directory);
+  if (uri.protocol !== "file:") throw new Error("Terminal working directory must be a file URI");
+  return command(7, uri.href);
+};
+
+/** Show a desktop notification (OSC 9). */
+export const notify = (title: string): string => {
+  const safe = field(title);
+  return command(9, /^\d+;/.test(safe) ? ` ${safe}` : safe);
+};
+
+/** Change the terminal pointer shape (OSC 22; terminal support varies). */
+export const setPointerShape = (shape: string): string => command(22, field(shape));
+
+/** Write UTF-8 text to a terminal clipboard using OSC 52. */
+export const setClipboard = (text: string, selection: ClipboardSelection = "clipboard"): string =>
+  command(52, `${clipboardCode[selection]};${Buffer.from(text).toString("base64")}`);
+
+/** Request clipboard contents. The response is another OSC 52 sequence. */
+export const queryClipboard = (selection: ClipboardSelection = "clipboard"): string =>
+  command(52, `${clipboardCode[selection]};?`);
+
+/** Clear a terminal clipboard. */
+export const clearClipboard = (selection: ClipboardSelection = "clipboard"): string =>
+  command(52, `${clipboardCode[selection]};`);
+
+/** Report terminal-native progress using OSC 9;4. */
+export const setTerminalProgress = (state: TerminalProgressState, value?: number): string => {
+  const code = progressCode[state];
+  if (state === "inactive" || state === "indeterminate") {
+    return command(9, `4;${code}`);
+  }
+  if (value === undefined && (state === "error" || state === "paused")) {
+    return command(9, `4;${code}`);
+  }
+  const percentage = Math.max(0, Math.min(100, Math.round(value ?? 0)));
+  return command(9, `4;${code};${percentage}`);
+};
+
+/** Wrap a sequence for transport through tmux's DCS passthrough. */
+export const tmuxPassthrough = (sequence: string): string =>
+  `${ESC}Ptmux;${sequence.replaceAll(ESC, `${ESC}${ESC}`)}${ST}`;

package/src/ansi/sgr.ts

@@ -0,0 +1,234 @@
+// ANSI SGR style tables and color-space conversions.
+// Ported from `ansi-styles` (MIT, Sindre Sorhus).
+import { CSI } from "#/ansi/escapes.ts";
+
+const ANSI_BACKGROUND_OFFSET = 10;
+
+export type StylePair = {
+  readonly open: string;
+  readonly close: string;
+};
+
+const wrapAnsi16 =
+  (offset = 0) =>
+  (code: number): string =>
+    `${CSI}${code + offset}m`;
+
+const wrapAnsi256 =
+  (offset = 0) =>
+  (code: number): string =>
+    `${CSI}${38 + offset};5;${code}m`;
+
+const wrapAnsi16m =
+  (offset = 0) =>
+  (red: number, green: number, blue: number): string =>
+    `${CSI}${38 + offset};2;${red};${green};${blue}m`;
+
+const modifierCodes = {
+  reset: [0, 0],
+  // 21 isn't widely supported and 22 does the same thing
+  bold: [1, 22],
+  dim: [2, 22],
+  italic: [3, 23],
+  underline: [4, 24],
+  overline: [53, 55],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+} as const;
+
+const colorCodes = {
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+
+  // Bright colors
+  blackBright: [90, 39],
+  gray: [90, 39], // Alias of `blackBright`
+  grey: [90, 39], // Alias of `blackBright`
+  redBright: [91, 39],
+  greenBright: [92, 39],
+  yellowBright: [93, 39],
+  blueBright: [94, 39],
+  magentaBright: [95, 39],
+  cyanBright: [96, 39],
+  whiteBright: [97, 39],
+} as const;
+
+const bgColorCodes = {
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+
+  // Bright colors
+  bgBlackBright: [100, 49],
+  bgGray: [100, 49], // Alias of `bgBlackBright`
+  bgGrey: [100, 49], // Alias of `bgBlackBright`
+  bgRedBright: [101, 49],
+  bgGreenBright: [102, 49],
+  bgYellowBright: [103, 49],
+  bgBlueBright: [104, 49],
+  bgMagentaBright: [105, 49],
+  bgCyanBright: [106, 49],
+  bgWhiteBright: [107, 49],
+} as const;
+
+export type ModifierName = keyof typeof modifierCodes;
+export type ForegroundColorName = keyof typeof colorCodes;
+export type BackgroundColorName = keyof typeof bgColorCodes;
+export type StyleName = ModifierName | ForegroundColorName | BackgroundColorName;
+
+export const modifierNames = Object.keys(modifierCodes) as ModifierName[];
+export const foregroundColorNames = Object.keys(colorCodes) as ForegroundColorName[];
+export const backgroundColorNames = Object.keys(bgColorCodes) as BackgroundColorName[];
+
+const toPairs = <Name extends string>(
+  codes: Record<Name, readonly [number, number]>,
+): Record<Name, StylePair> => {
+  const result = {} as Record<Name, StylePair>;
+
+  for (const [name, [open, close]] of Object.entries(codes) as Array<
+    [Name, readonly [number, number]]
+  >) {
+    result[name] = { open: `${CSI}${open}m`, close: `${CSI}${close}m` };
+  }
+
+  return result;
+};
+
+/**
+Named SGR styles as `{open, close}` escape sequence pairs.
+*/
+export const styles: Record<StyleName, StylePair> = {
+  ...toPairs(modifierCodes),
+  ...toPairs(colorCodes),
+  ...toPairs(bgColorCodes),
+};
+
+/**
+Raw SGR code numbers: open code → close code.
+*/
+export const codes: ReadonlyMap<number, number> = new Map(
+  [
+    ...Object.values<readonly [number, number]>(modifierCodes),
+    ...Object.values<readonly [number, number]>(colorCodes),
+    ...Object.values<readonly [number, number]>(bgColorCodes),
+  ].map(([open, close]) => [open, close]),
+);
+
+export const foreground = {
+  close: `${CSI}39m`,
+  ansi: wrapAnsi16(),
+  ansi256: wrapAnsi256(),
+  ansi16m: wrapAnsi16m(),
+};
+
+export const background = {
+  close: `${CSI}49m`,
+  ansi: wrapAnsi16(ANSI_BACKGROUND_OFFSET),
+  ansi256: wrapAnsi256(ANSI_BACKGROUND_OFFSET),
+  ansi16m: wrapAnsi16m(ANSI_BACKGROUND_OFFSET),
+};
+
+// Conversions from https://github.com/Qix-/color-convert
+export const rgbToAnsi256 = (red: number, green: number, blue: number): number => {
+  // We use the extended greyscale palette here, with the exception of
+  // black and white. The normal palette only has 4 greyscale shades.
+  if (red === green && green === blue) {
+    if (red < 8) {
+      return 16;
+    }
+
+    if (red > 248) {
+      return 231;
+    }
+
+    return Math.round(((red - 8) / 247) * 24) + 232;
+  }
+
+  return (
+    16 +
+    36 * Math.round((red / 255) * 5) +
+    6 * Math.round((green / 255) * 5) +
+    Math.round((blue / 255) * 5)
+  );
+};
+
+export const hexToRgb = (hex: string): [number, number, number] => {
+  const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex);
+  if (!matches) {
+    return [0, 0, 0];
+  }
+
+  let [colorString] = matches;
+
+  if (colorString.length === 3) {
+    colorString = colorString.replaceAll(/./g, "$&$&");
+  }
+
+  const integer = Number.parseInt(colorString, 16);
+
+  /* eslint-disable no-bitwise */
+  return [(integer >> 16) & 0xff, (integer >> 8) & 0xff, integer & 0xff];
+  /* eslint-enable no-bitwise */
+};
+
+export const hexToAnsi256 = (hex: string): number => rgbToAnsi256(...hexToRgb(hex));
+
+export const ansi256ToAnsi = (code: number): number => {
+  if (code < 8) {
+    return 30 + code;
+  }
+
+  if (code < 16) {
+    return 90 + (code - 8);
+  }
+
+  let red;
+  let green;
+  let blue;
+
+  if (code >= 232) {
+    red = ((code - 232) * 10 + 8) / 255;
+    green = red;
+    blue = red;
+  } else {
+    code -= 16;
+
+    const remainder = code % 36;
+
+    red = Math.floor(code / 36) / 5;
+    green = Math.floor(remainder / 6) / 5;
+    blue = (remainder % 6) / 5;
+  }
+
+  const value = Math.max(red, green, blue) * 2;
+
+  if (value === 0) {
+    return 30;
+  }
+
+  // eslint-disable-next-line no-bitwise
+  let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
+
+  if (value === 2) {
+    result += 60;
+  }
+
+  return result;
+};
+
+export const rgbToAnsi = (red: number, green: number, blue: number): number =>
+  ansi256ToAnsi(rgbToAnsi256(red, green, blue));
+
+export const hexToAnsi = (hex: string): number => ansi256ToAnsi(hexToAnsi256(hex));

package/src/ansi/slice.ts

@@ -0,0 +1,43 @@
+// Slice a string by visible column positions, preserving active ANSI styles.
+// Replaces `slice-ansi`, built on the shared tokenizer instead of a second
+// escape parser: characters keep their computed style lists, and the result
+// is re-emitted with minimal escape codes. A full-width character that would
+// be cut in half at either boundary is dropped, like `slice-ansi` does.
+import {
+  styledCharsFromTokens,
+  styledCharsToString,
+  tokenize,
+  type StyledChar,
+} from "#/ansi/tokenize.ts";
+
+export function sliceAnsi(string: string, start: number, end?: number): string {
+  const sliceEnd = end ?? Number.POSITIVE_INFINITY;
+
+  if (start >= sliceEnd || string === "") {
+    return "";
+  }
+
+  if (start === 0 && sliceEnd === Number.POSITIVE_INFINITY) {
+    return string;
+  }
+
+  const chars = styledCharsFromTokens(tokenize(string));
+  const included: StyledChar[] = [];
+  let column = 0;
+
+  for (const char of chars) {
+    const width = char.fullWidth ? 2 : 1;
+
+    if (column + width > sliceEnd) {
+      break;
+    }
+
+    if (column >= start) {
+      included.push(char);
+    }
+
+    column += width;
+  }
+
+  return styledCharsToString(included);
+}

package/src/ansi/string-width.ts

@@ -0,0 +1,121 @@
+// 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.
+
+import { isFullWidth, isWideNotCJKTNotEmoji } from "#/ansi/east-asian-width.ts";
+
+const getCodePointsLength = (input: string): number => {
+  let length = 0;
+
+  for (const _ of input) {
+    length += 1;
+  }
+
+  return length;
+};
+
+// 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;
+
+  outer: while (true) {
+    /* UNMATCHED */
+
+    if (unmatchedEnd > unmatchedStart || (index >= length && index > indexPrev)) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+
+        width += isFullWidth(codePoint)
+          ? FULL_WIDTH_WIDTH
+          : isWideNotCJKTNotEmoji(codePoint)
+            ? WIDE_WIDTH
+            : REGULAR_WIDTH;
+      }
+
+      unmatchedStart = unmatchedEnd = 0;
+    }
+
+    /* EXITING */
+
+    if (index >= length) {
+      break;
+    }
+
+    /* PARSE BLOCKS */
+
+    for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i]!;
+
+      BLOCK_RE.lastIndex = index;
+
+      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;
+
+        width += lengthExtra * BLOCK_WIDTH;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
+
+        continue outer;
+      }
+    }
+
+    /* UNMATCHED INDEX */
+
+    index += 1;
+  }
+
+  return width;
+};
+
+export const widestLine = (text: string): number => {
+  let lineWidth = 0;
+
+  for (const line of text.split("\n")) {
+    lineWidth = Math.max(lineWidth, stringWidth(line));
+  }
+
+  return lineWidth;
+};

package/src/ansi/strip.ts

@@ -0,0 +1,13 @@
+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, ""));