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

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 "./chalk.ts";
+export { supportsColor } from "./supports-color.ts";
+export * from "./sgr.ts";
+
+// Escape sequences (raw building blocks + named sequences)
+export { ansiEscapes } from "./escapes.ts";
+export * from "./escapes.ts";
+export { cliCursor } from "./cursor.ts";
+
+// Measurement
+export { stringWidth } from "./string-width.ts";
+export { widestLine } from "./widest-line.ts";
+export * from "./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";
+
+// Tokenizer: style-aware parsing and minimal re-emission
+export * from "./tokenize.ts";

package/src/ansi/sgr.ts

@@ -0,0 +1,237 @@
+// ANSI SGR style tables and color-space conversions.
+// Ported from `ansi-styles` (MIT, Sindre Sorhus).
+import { CSI } from "./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
+      .split("")
+      .map((character) => character + character)
+      .join("");
+  }
+
+  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 "./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,236 @@
+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;
+
+// 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;
+
+// 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;
+  }
+
+  // ZWJ sequences with 2+ Extended_Pictographic
+  if (segment.includes("\u200D")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+
+  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;
+    }
+
+    codePoints.push(character.codePointAt(0)!);
+  }
+
+  if (codePoints.length === 0) {
+    return;
+  }
+
+  let width = 0;
+
+  for (let index = 0; index < codePoints.length; index++) {
+    const codePoint = codePoints[index]!;
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return;
+      }
+
+      // 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);
+      }
+
+      return width;
+    }
+
+    // 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);
+  }
+
+  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 (spacingMarkRegex.test(character) || (character >= "\uFF00" && character <= "\uFFEF")) {
+      extra += eastAsianWidth(character.codePointAt(0)!, eastAsianWidthOptions);
+    }
+  }
+
+  return extra;
+}
+
+export function stringWidth(input: string, options: StringWidthOptions = {}): number {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+
+  const { ambiguousIsNarrow = true, countAnsiEscapeCodes = false } = options;
+
+  let string = input;
+
+  // 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);
+  }
+
+  if (string.length === 0) {
+    return 0;
+  }
+
+  // Fast path: printable ASCII (0x20–0x7E) needs no segmenter, regex, or EAW
+  // lookup — width equals length.
+  if (/^[ -~]*$/.test(string)) {
+    return string.length;
+  }
+
+  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;
+    }
+
+    // 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
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+  }
+
+  return width;
+}

package/src/ansi/strip.ts

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