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

package/src/ansi-tokenizer.ts

@@ -0,0 +1,510 @@
+import { BEL, C1_CSI, C1_ST, ESC } from "#/ansi/escapes.ts";
+
+const bellCharacter = BEL;
+const escapeCharacter = ESC;
+const stringTerminatorCharacter = C1_ST;
+const csiCharacter = C1_CSI;
+const oscCharacter = "\u009D";
+const dcsCharacter = "\u0090";
+const pmCharacter = "\u009E";
+const apcCharacter = "\u009F";
+const sosCharacter = "\u0098";
+
+type ControlStringType = "osc" | "dcs" | "pm" | "apc" | "sos";
+
+type CsiToken = {
+  readonly type: "csi";
+  readonly value: string;
+  readonly parameterString: string;
+  readonly intermediateString: string;
+  readonly finalCharacter: string;
+};
+
+type EscToken = {
+  readonly type: "esc";
+  readonly value: string;
+  readonly intermediateString: string;
+  readonly finalCharacter: string;
+};
+
+type ControlStringToken = {
+  readonly type: ControlStringType;
+  readonly value: string;
+};
+
+type TextToken = {
+  readonly type: "text";
+  readonly value: string;
+};
+
+type StToken = {
+  readonly type: "st";
+  readonly value: string;
+};
+
+type C1Token = {
+  readonly type: "c1";
+  readonly value: string;
+};
+
+type InvalidToken = {
+  readonly type: "invalid";
+  readonly value: string;
+};
+
+export type AnsiToken =
+  | TextToken
+  | CsiToken
+  | EscToken
+  | ControlStringToken
+  | StToken
+  | C1Token
+  | InvalidToken;
+
+const isCsiParameterCharacter = (character: string): boolean => {
+  const codePoint = character.codePointAt(0);
+
+  return codePoint !== undefined && codePoint >= 0x30 && codePoint <= 0x3f;
+};
+
+const isCsiIntermediateCharacter = (character: string): boolean => {
+  const codePoint = character.codePointAt(0);
+
+  return codePoint !== undefined && codePoint >= 0x20 && codePoint <= 0x2f;
+};
+
+const isCsiFinalCharacter = (character: string): boolean => {
+  const codePoint = character.codePointAt(0);
+
+  return codePoint !== undefined && codePoint >= 0x40 && codePoint <= 0x7e;
+};
+
+const isEscapeIntermediateCharacter = (character: string): boolean => {
+  const codePoint = character.codePointAt(0);
+
+  return codePoint !== undefined && codePoint >= 0x20 && codePoint <= 0x2f;
+};
+
+const isEscapeFinalCharacter = (character: string): boolean => {
+  const codePoint = character.codePointAt(0);
+
+  return codePoint !== undefined && codePoint >= 0x30 && codePoint <= 0x7e;
+};
+
+const isC1ControlCharacter = (character: string): boolean => {
+  const codePoint = character.codePointAt(0);
+
+  return codePoint !== undefined && codePoint >= 0x80 && codePoint <= 0x9f;
+};
+
+// Standards references:
+// ECMA-48 control functions and CSI byte classes: https://ecma-international.org/publications-and-standards/standards/ecma-48/
+// xterm CSI parameter/intermediate/final format notes: https://invisible-island.net/xterm/ecma-48-parameter-format.html
+// xterm/OSC BEL termination behavior: https://davidrg.github.io/ckwin/dev/ctlseqs.html
+const readCsiSequence = (
+  text: string,
+  fromIndex: number,
+):
+  | {
+      readonly endIndex: number;
+      readonly parameterString: string;
+      readonly intermediateString: string;
+      readonly finalCharacter: string;
+    }
+  | undefined => {
+  let index = fromIndex;
+
+  while (index < text.length) {
+    const character = text[index]!;
+
+    if (!isCsiParameterCharacter(character)) {
+      break;
+    }
+
+    index++;
+  }
+
+  const parameterString = text.slice(fromIndex, index);
+  const intermediateStartIndex = index;
+
+  while (index < text.length) {
+    const character = text[index]!;
+
+    if (!isCsiIntermediateCharacter(character)) {
+      break;
+    }
+
+    index++;
+  }
+
+  const intermediateString = text.slice(intermediateStartIndex, index);
+  const finalCharacter = text[index];
+
+  if (finalCharacter === undefined || !isCsiFinalCharacter(finalCharacter)) {
+    return;
+  }
+
+  return {
+    endIndex: index + 1,
+    parameterString,
+    intermediateString,
+    finalCharacter,
+  };
+};
+
+const findControlStringTerminatorIndex = (
+  text: string,
+  fromIndex: number,
+  allowBellTerminator: boolean,
+): number | undefined => {
+  for (let index = fromIndex; index < text.length; index++) {
+    const character = text[index];
+
+    if (allowBellTerminator && character === bellCharacter) {
+      return index + 1;
+    }
+
+    if (character === stringTerminatorCharacter) {
+      return index + 1;
+    }
+
+    if (character === escapeCharacter) {
+      const followingCharacter = text[index + 1];
+
+      // Tmux escapes ESC bytes in payload as ESC ESC.
+      if (followingCharacter === escapeCharacter) {
+        index++;
+        continue;
+      }
+
+      if (followingCharacter === "\\") {
+        return index + 2;
+      }
+    }
+  }
+
+  return;
+};
+
+const readEscapeSequence = (
+  text: string,
+  fromIndex: number,
+):
+  | {
+      readonly endIndex: number;
+      readonly intermediateString: string;
+      readonly finalCharacter: string;
+    }
+  | undefined => {
+  let index = fromIndex;
+
+  while (index < text.length) {
+    const character = text[index]!;
+
+    if (!isEscapeIntermediateCharacter(character)) {
+      break;
+    }
+
+    index++;
+  }
+
+  const intermediateString = text.slice(fromIndex, index);
+  const finalCharacter = text[index];
+
+  if (finalCharacter === undefined || !isEscapeFinalCharacter(finalCharacter)) {
+    return;
+  }
+
+  return {
+    endIndex: index + 1,
+    intermediateString,
+    finalCharacter,
+  };
+};
+
+// Centralize control-string rules so ESC and C1 paths do not diverge.
+const getControlStringFromEscapeIntroducer = (
+  character: string,
+):
+  | {
+      readonly type: ControlStringType;
+      readonly allowBellTerminator: boolean;
+    }
+  | undefined => {
+  switch (character) {
+    case "]": {
+      return { type: "osc", allowBellTerminator: true };
+    }
+
+    case "P": {
+      return { type: "dcs", allowBellTerminator: false };
+    }
+
+    case "^": {
+      return { type: "pm", allowBellTerminator: false };
+    }
+
+    case "_": {
+      return { type: "apc", allowBellTerminator: false };
+    }
+
+    case "X": {
+      return { type: "sos", allowBellTerminator: false };
+    }
+
+    default: {
+      return;
+    }
+  }
+};
+
+const getControlStringFromC1Introducer = (
+  character: string,
+):
+  | {
+      readonly type: ControlStringType;
+      readonly allowBellTerminator: boolean;
+    }
+  | undefined => {
+  switch (character) {
+    case oscCharacter: {
+      return { type: "osc", allowBellTerminator: true };
+    }
+
+    case dcsCharacter: {
+      return { type: "dcs", allowBellTerminator: false };
+    }
+
+    case pmCharacter: {
+      return { type: "pm", allowBellTerminator: false };
+    }
+
+    case apcCharacter: {
+      return { type: "apc", allowBellTerminator: false };
+    }
+
+    case sosCharacter: {
+      return { type: "sos", allowBellTerminator: false };
+    }
+
+    default: {
+      return;
+    }
+  }
+};
+
+export const hasAnsiControlCharacters = (text: string): boolean => {
+  if (text.includes(escapeCharacter)) {
+    return true;
+  }
+
+  for (const character of text) {
+    if (isC1ControlCharacter(character)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+const malformedFromIndex = (
+  tokens: AnsiToken[],
+  text: string,
+  textStartIndex: number,
+  fromIndex: number,
+): AnsiToken[] => {
+  if (fromIndex > textStartIndex) {
+    tokens.push({ type: "text", value: text.slice(textStartIndex, fromIndex) });
+  }
+
+  // Treat the remainder as invalid so callers can drop it as one unsafe unit.
+  tokens.push({ type: "invalid", value: text.slice(fromIndex) });
+
+  return tokens;
+};
+
+export const tokenizeAnsi = (text: string): AnsiToken[] => {
+  if (!hasAnsiControlCharacters(text)) {
+    return [{ type: "text", value: text }];
+  }
+
+  const tokens: AnsiToken[] = [];
+  let textStartIndex = 0;
+
+  for (let index = 0; index < text.length;) {
+    const character = text[index];
+
+    if (character === undefined) {
+      break;
+    }
+
+    if (character === escapeCharacter) {
+      const followingCharacter = text[index + 1];
+
+      if (followingCharacter === undefined) {
+        return malformedFromIndex(tokens, text, textStartIndex, index);
+      }
+
+      if (followingCharacter === "[") {
+        const csiSequence = readCsiSequence(text, index + 2);
+
+        if (csiSequence === undefined) {
+          return malformedFromIndex(tokens, text, textStartIndex, index);
+        }
+
+        if (index > textStartIndex) {
+          tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+        }
+
+        tokens.push({
+          type: "csi",
+          value: text.slice(index, csiSequence.endIndex),
+          parameterString: csiSequence.parameterString,
+          intermediateString: csiSequence.intermediateString,
+          finalCharacter: csiSequence.finalCharacter,
+        });
+        index = csiSequence.endIndex;
+        textStartIndex = index;
+        continue;
+      }
+
+      const escapeControlString = getControlStringFromEscapeIntroducer(followingCharacter);
+
+      if (escapeControlString !== undefined) {
+        const controlStringTerminatorIndex = findControlStringTerminatorIndex(
+          text,
+          index + 2,
+          escapeControlString.allowBellTerminator,
+        );
+
+        if (controlStringTerminatorIndex === undefined) {
+          return malformedFromIndex(tokens, text, textStartIndex, index);
+        }
+
+        if (index > textStartIndex) {
+          tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+        }
+
+        tokens.push({
+          type: escapeControlString.type,
+          value: text.slice(index, controlStringTerminatorIndex),
+        });
+        index = controlStringTerminatorIndex;
+        textStartIndex = index;
+        continue;
+      }
+
+      const escapeSequence = readEscapeSequence(text, index + 1);
+
+      if (escapeSequence === undefined) {
+        // Incomplete escape sequences with intermediates are malformed control strings.
+        if (isEscapeIntermediateCharacter(followingCharacter)) {
+          return malformedFromIndex(tokens, text, textStartIndex, index);
+        }
+
+        if (index > textStartIndex) {
+          tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+        }
+
+        // Ignore lone ESC and continue tokenizing the rest.
+        index++;
+        textStartIndex = index;
+        continue;
+      }
+
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+
+      tokens.push({
+        type: "esc",
+        value: text.slice(index, escapeSequence.endIndex),
+        intermediateString: escapeSequence.intermediateString,
+        finalCharacter: escapeSequence.finalCharacter,
+      });
+      index = escapeSequence.endIndex;
+      textStartIndex = index;
+      continue;
+    }
+
+    if (character === csiCharacter) {
+      const csiSequence = readCsiSequence(text, index + 1);
+
+      if (csiSequence === undefined) {
+        return malformedFromIndex(tokens, text, textStartIndex, index);
+      }
+
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+
+      tokens.push({
+        type: "csi",
+        value: text.slice(index, csiSequence.endIndex),
+        parameterString: csiSequence.parameterString,
+        intermediateString: csiSequence.intermediateString,
+        finalCharacter: csiSequence.finalCharacter,
+      });
+      index = csiSequence.endIndex;
+      textStartIndex = index;
+      continue;
+    }
+
+    const c1ControlString = getControlStringFromC1Introducer(character);
+
+    if (c1ControlString !== undefined) {
+      const controlStringTerminatorIndex = findControlStringTerminatorIndex(
+        text,
+        index + 1,
+        c1ControlString.allowBellTerminator,
+      );
+
+      if (controlStringTerminatorIndex === undefined) {
+        return malformedFromIndex(tokens, text, textStartIndex, index);
+      }
+
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+
+      tokens.push({
+        type: c1ControlString.type,
+        value: text.slice(index, controlStringTerminatorIndex),
+      });
+      index = controlStringTerminatorIndex;
+      textStartIndex = index;
+      continue;
+    }
+
+    if (character === stringTerminatorCharacter) {
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+
+      tokens.push({ type: "st", value: character });
+      index++;
+      textStartIndex = index;
+      continue;
+    }
+
+    // Strip remaining C1 controls as standalone functions.
+    if (isC1ControlCharacter(character)) {
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+
+      tokens.push({ type: "c1", value: character });
+      index++;
+      textStartIndex = index;
+      continue;
+    }
+
+    index++;
+  }
+
+  if (textStartIndex < text.length) {
+    tokens.push({ type: "text", value: text.slice(textStartIndex) });
+  }
+
+  return tokens;
+};

package/src/capabilities/color-policy.ts

@@ -0,0 +1,34 @@
+import type { ColorSupportLevel } from "#/capabilities/detect.ts";
+import { colorProfileFromLevel, type ColorProfile } from "#/screen/color-profile.ts";
+
+/** A user-selected output policy. `auto` follows the target stream. */
+export type ColorPolicy = "auto" | ColorProfile;
+
+/** The three distinct inputs and result of terminal color negotiation. */
+export type ColorState = {
+  /** The stream/terminal fact after environment and query detection. */
+  readonly detected: ColorProfile;
+  /** The application's policy for this render instance. */
+  readonly policy: ColorPolicy;
+  /** The profile the serializer must actually emit. */
+  readonly effective: ColorProfile;
+};
+
+export function resolveColorProfile(
+  detectedLevel: ColorSupportLevel,
+  policy: ColorPolicy = "auto",
+): ColorProfile {
+  return policy === "auto" ? colorProfileFromLevel(detectedLevel) : policy;
+}
+
+export function colorState(
+  capabilities: { readonly color: { readonly level: ColorSupportLevel } },
+  policy: ColorPolicy = "auto",
+): ColorState {
+  const detected = colorProfileFromLevel(capabilities.color.level);
+  return {
+    detected,
+    policy,
+    effective: policy === "auto" ? detected : policy,
+  };
+}