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

package/src/parse-keypress.ts

@@ -0,0 +1,515 @@
+// Copied from https://github.com/enquirer/enquirer/blob/36785f3399a41cd61e9d28d1eb9c2fcd73d69b4c/lib/keypress.js
+import { DEL, ESC } from "#/ansi/escapes.ts";
+import { kittyModifiers } from "#/kitty-keyboard.ts";
+
+const textDecoder = new TextDecoder();
+
+const metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
+
+const fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
+
+const keyName: Record<string, string> = {
+  /* xterm/gnome ESC O letter */
+  OP: "f1",
+  OQ: "f2",
+  OR: "f3",
+  OS: "f4",
+  /* vt220-style ESC [ letter (e.g. Ctrl+F1 sends ESC [ 1 ; 5 P) */
+  "[P": "f1",
+  "[Q": "f2",
+  "[R": "f3",
+  "[S": "f4",
+  /* xterm/rxvt ESC [ number ~ */
+  "[11~": "f1",
+  "[12~": "f2",
+  "[13~": "f3",
+  "[14~": "f4",
+  /* from Cygwin and used in libuv */
+  "[[A": "f1",
+  "[[B": "f2",
+  "[[C": "f3",
+  "[[D": "f4",
+  "[[E": "f5",
+  /* common */
+  "[15~": "f5",
+  "[17~": "f6",
+  "[18~": "f7",
+  "[19~": "f8",
+  "[20~": "f9",
+  "[21~": "f10",
+  "[23~": "f11",
+  "[24~": "f12",
+  /* xterm ESC [ letter */
+  "[A": "up",
+  "[B": "down",
+  "[C": "right",
+  "[D": "left",
+  "[E": "clear",
+  "[F": "end",
+  "[H": "home",
+  /* xterm/gnome ESC O letter */
+  OA: "up",
+  OB: "down",
+  OC: "right",
+  OD: "left",
+  OE: "clear",
+  OF: "end",
+  OH: "home",
+  /* xterm/rxvt ESC [ number ~ */
+  "[1~": "home",
+  "[2~": "insert",
+  "[3~": "delete",
+  "[4~": "end",
+  "[5~": "pageup",
+  "[6~": "pagedown",
+  /* putty */
+  "[[5~": "pageup",
+  "[[6~": "pagedown",
+  /* rxvt */
+  "[7~": "home",
+  "[8~": "end",
+  /* rxvt keys with modifiers */
+  "[a": "up",
+  "[b": "down",
+  "[c": "right",
+  "[d": "left",
+  "[e": "clear",
+
+  "[2$": "insert",
+  "[3$": "delete",
+  "[5$": "pageup",
+  "[6$": "pagedown",
+  "[7$": "home",
+  "[8$": "end",
+
+  Oa: "up",
+  Ob: "down",
+  Oc: "right",
+  Od: "left",
+  Oe: "clear",
+
+  "[2^": "insert",
+  "[3^": "delete",
+  "[5^": "pageup",
+  "[6^": "pagedown",
+  "[7^": "home",
+  "[8^": "end",
+  /* misc. */
+  "[Z": "tab",
+};
+
+export const nonAlphanumericKeys = [...Object.values(keyName), "backspace"];
+
+const isShiftKey = (code: string) => {
+  return ["[a", "[b", "[c", "[d", "[e", "[2$", "[3$", "[5$", "[6$", "[7$", "[8$", "[Z"].includes(
+    code,
+  );
+};
+
+const isCtrlKey = (code: string) => {
+  return ["Oa", "Ob", "Oc", "Od", "Oe", "[2^", "[3^", "[5^", "[6^", "[7^", "[8^"].includes(code);
+};
+
+type ParsedKey = {
+  name: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  sequence: string;
+  raw: string | undefined;
+  code?: string;
+  super?: boolean;
+  hyper?: boolean;
+  capsLock?: boolean;
+  numLock?: boolean;
+  eventType?: "press" | "repeat" | "release";
+  isKittyProtocol?: boolean;
+  text?: string;
+  // Whether this key represents printable text input.
+  // When false, the key is a control/function/modifier key that should not
+  // produce text input (e.g., arrows, function keys, capslock, media keys).
+  // Only set by the kitty protocol parser.
+  isPrintable?: boolean;
+};
+
+// Kitty keyboard protocol: CSI codepoint ; modifiers [: eventType] [; text-as-codepoints] u
+const kittyKeyRe = /^\x1b\[(\d+)(?:;(\d+)(?::(\d+))?(?:;([\d:]+))?)?u$/;
+
+// Kitty-enhanced special keys: CSI number ; modifiers : eventType {letter|~}
+// These are legacy CSI sequences enhanced with the :eventType field.
+// Examples: \x1b[1;1:1A (up arrow press), \x1b[3;1:3~ (delete release)
+const kittySpecialKeyRe = /^\x1b\[(\d+);(\d+):(\d+)([A-Za-z~])$/;
+
+// Letter-terminated special key names (CSI 1 ; mods letter)
+const kittySpecialLetterKeys: Record<string, string> = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left",
+  E: "clear",
+  F: "end",
+  H: "home",
+  P: "f1",
+  Q: "f2",
+  R: "f3",
+  S: "f4",
+};
+
+// Number-terminated special key names (CSI number ; mods ~)
+const kittySpecialNumberKeys: Record<number, string> = {
+  2: "insert",
+  3: "delete",
+  5: "pageup",
+  6: "pagedown",
+  7: "home",
+  8: "end",
+  11: "f1",
+  12: "f2",
+  13: "f3",
+  14: "f4",
+  15: "f5",
+  17: "f6",
+  18: "f7",
+  19: "f8",
+  20: "f9",
+  21: "f10",
+  23: "f11",
+  24: "f12",
+};
+
+// Map of special codepoints to key names in kitty protocol
+const kittyCodepointNames: Record<number, string> = {
+  27: "escape",
+  // 13 (return) and 32 (space) are handled before this lookup
+  // in parseKittyKeypress so they can be marked as printable.
+  9: "tab",
+  127: "backspace",
+  8: "backspace",
+  57358: "capslock",
+  57359: "scrolllock",
+  57360: "numlock",
+  57361: "printscreen",
+  57362: "pause",
+  57363: "menu",
+  57376: "f13",
+  57377: "f14",
+  57378: "f15",
+  57379: "f16",
+  57380: "f17",
+  57381: "f18",
+  57382: "f19",
+  57383: "f20",
+  57384: "f21",
+  57385: "f22",
+  57386: "f23",
+  57387: "f24",
+  57388: "f25",
+  57389: "f26",
+  57390: "f27",
+  57391: "f28",
+  57392: "f29",
+  57393: "f30",
+  57394: "f31",
+  57395: "f32",
+  57396: "f33",
+  57397: "f34",
+  57398: "f35",
+  57399: "kp0",
+  57400: "kp1",
+  57401: "kp2",
+  57402: "kp3",
+  57403: "kp4",
+  57404: "kp5",
+  57405: "kp6",
+  57406: "kp7",
+  57407: "kp8",
+  57408: "kp9",
+  57409: "kpdecimal",
+  57410: "kpdivide",
+  57411: "kpmultiply",
+  57412: "kpsubtract",
+  57413: "kpadd",
+  57414: "kpenter",
+  57415: "kpequal",
+  57416: "kpseparator",
+  57417: "kpleft",
+  57418: "kpright",
+  57419: "kpup",
+  57420: "kpdown",
+  57421: "kppageup",
+  57422: "kppagedown",
+  57423: "kphome",
+  57424: "kpend",
+  57425: "kpinsert",
+  57426: "kpdelete",
+  57427: "kpbegin",
+  57428: "mediaplay",
+  57429: "mediapause",
+  57430: "mediaplaypause",
+  57431: "mediareverse",
+  57432: "mediastop",
+  57433: "mediafastforward",
+  57434: "mediarewind",
+  57435: "mediatracknext",
+  57436: "mediatrackprevious",
+  57437: "mediarecord",
+  57438: "lowervolume",
+  57439: "raisevolume",
+  57440: "mutevolume",
+  57441: "leftshift",
+  57442: "leftcontrol",
+  57443: "leftalt",
+  57444: "leftsuper",
+  57445: "lefthyper",
+  57446: "leftmeta",
+  57447: "rightshift",
+  57448: "rightcontrol",
+  57449: "rightalt",
+  57450: "rightsuper",
+  57451: "righthyper",
+  57452: "rightmeta",
+  57453: "isoLevel3Shift",
+  57454: "isoLevel5Shift",
+};
+
+// Valid Unicode codepoint range, excluding surrogates
+const isValidCodepoint = (cp: number): boolean =>
+  cp >= 0 && cp <= 0x10_ffff && !(cp >= 0xd8_00 && cp <= 0xdf_ff);
+
+const safeFromCodePoint = (cp: number): string =>
+  isValidCodepoint(cp) ? String.fromCodePoint(cp) : "?";
+
+type EventType = "press" | "repeat" | "release";
+
+function resolveEventType(value: number): EventType {
+  if (value === 3) return "release";
+  if (value === 2) return "repeat";
+  return "press";
+}
+
+function parseKittyModifiers(
+  modifiers: number,
+): Pick<ParsedKey, "ctrl" | "shift" | "meta" | "super" | "hyper" | "capsLock" | "numLock"> {
+  return {
+    ctrl: !!(modifiers & kittyModifiers.ctrl),
+    shift: !!(modifiers & kittyModifiers.shift),
+    meta: !!(modifiers & (kittyModifiers.meta | kittyModifiers.alt)),
+    super: !!(modifiers & kittyModifiers.super),
+    hyper: !!(modifiers & kittyModifiers.hyper),
+    capsLock: !!(modifiers & kittyModifiers.capsLock),
+    numLock: !!(modifiers & kittyModifiers.numLock),
+  };
+}
+
+const parseKittyKeypress = (s: string): ParsedKey | null => {
+  const match = kittyKeyRe.exec(s);
+  if (!match) return null;
+
+  const codepoint = parseInt(match[1]!, 10);
+  const modifiers = match[2] ? Math.max(0, parseInt(match[2], 10) - 1) : 0;
+  const eventType = match[3] ? parseInt(match[3], 10) : 1;
+  const textField = match[4];
+
+  // Bail on invalid primary codepoint
+  if (!isValidCodepoint(codepoint)) {
+    return null;
+  }
+
+  // Parse text-as-codepoints field (colon-separated Unicode codepoints)
+  let text: string | undefined;
+  if (textField) {
+    text = textField
+      .split(":")
+      .map((cp) => safeFromCodePoint(parseInt(cp, 10)))
+      .join("");
+  }
+
+  // Determine key name from codepoint
+  let name: string;
+  let isPrintable: boolean;
+  if (codepoint === 32) {
+    name = "space";
+    isPrintable = true;
+  } else if (codepoint === 13) {
+    name = "return";
+    isPrintable = true;
+  } else if (kittyCodepointNames[codepoint]) {
+    name = kittyCodepointNames[codepoint]!;
+    isPrintable = false;
+  } else if (codepoint >= 1 && codepoint <= 26) {
+    // Ctrl+letter comes as codepoint 1-26
+    name = String.fromCodePoint(codepoint + 96); // 'a' is 97
+    isPrintable = false;
+  } else {
+    name = safeFromCodePoint(codepoint).toLowerCase();
+    isPrintable = true;
+  }
+
+  // Default text to the character from the codepoint when not explicitly
+  // provided by the protocol, so keys like space and return produce their
+  // expected text input (' ' and '\r' respectively).
+  if (isPrintable && !text) {
+    text = safeFromCodePoint(codepoint);
+  }
+
+  return {
+    name,
+    ...parseKittyModifiers(modifiers),
+    eventType: resolveEventType(eventType),
+    sequence: s,
+    raw: s,
+    isKittyProtocol: true,
+    isPrintable,
+    text,
+  };
+};
+
+// Parse kitty-enhanced special key sequences (arrow keys, function keys, etc.)
+// These use the legacy CSI format but with an added :eventType field.
+const parseKittySpecialKey = (s: string): ParsedKey | null => {
+  const match = kittySpecialKeyRe.exec(s);
+  if (!match) return null;
+
+  const number = parseInt(match[1]!, 10);
+  const modifiers = Math.max(0, parseInt(match[2]!, 10) - 1);
+  const eventType = parseInt(match[3]!, 10);
+  const terminator = match[4]!;
+
+  const name =
+    terminator === "~" ? kittySpecialNumberKeys[number] : kittySpecialLetterKeys[terminator];
+
+  if (!name) return null;
+
+  return {
+    name,
+    ...parseKittyModifiers(modifiers),
+    eventType: resolveEventType(eventType),
+    sequence: s,
+    raw: s,
+    isKittyProtocol: true,
+    isPrintable: false,
+  };
+};
+
+export const parseKeypress = (s: Uint8Array | string = ""): ParsedKey => {
+  let parts;
+
+  if (s instanceof Uint8Array) {
+    if (s[0]! > 127 && s[1] === undefined) {
+      s = ESC + textDecoder.decode(Uint8Array.of(s[0]! - 128));
+    } else {
+      s = textDecoder.decode(s);
+    }
+  } else if (s !== undefined && typeof s !== "string") {
+    s = String(s);
+  } else if (!s) {
+    s = "";
+  }
+
+  // Try kitty keyboard protocol parsers first
+  const kittyResult = parseKittyKeypress(s);
+  if (kittyResult) return kittyResult;
+
+  const kittySpecialResult = parseKittySpecialKey(s);
+  if (kittySpecialResult) return kittySpecialResult;
+
+  // If the input matched the kitty CSI-u pattern but was rejected (e.g.,
+  // invalid codepoint), return a safe empty keypress instead of falling
+  // through to legacy parsing which can produce unsafe states (undefined name)
+  if (kittyKeyRe.test(s)) {
+    return {
+      name: "",
+      ctrl: false,
+      meta: false,
+      shift: false,
+      sequence: s,
+      raw: s,
+      isKittyProtocol: true,
+      isPrintable: false,
+    };
+  }
+
+  const key: ParsedKey = {
+    name: "",
+    ctrl: false,
+    meta: false,
+    shift: false,
+    sequence: s,
+    raw: s,
+  };
+
+  key.sequence = key.sequence || s || key.name;
+
+  if (s === "\r" || s === ESC + "\r") {
+    // carriage return (or meta+return on macOS)
+    key.raw = undefined;
+    key.name = "return";
+    key.meta = s.length === 2;
+  } else if (s === "\n") {
+    // enter, should have been called linefeed
+    key.name = "enter";
+  } else if (s === "\t") {
+    // tab
+    key.name = "tab";
+  } else if (s === "\b" || s === ESC + "\b") {
+    // backspace or ctrl+h
+    key.name = "backspace";
+    key.meta = s.charAt(0) === ESC;
+  } else if (s === DEL || s === ESC + DEL) {
+    // backspace
+    key.name = "backspace";
+    key.meta = s.charAt(0) === ESC;
+  } else if (s === ESC || s === ESC + ESC) {
+    // escape key
+    key.name = "escape";
+    key.meta = s.length === 2;
+  } else if (s === " " || s === ESC + " ") {
+    key.name = "space";
+    key.meta = s.length === 2;
+  } else if (s.length === 1 && s <= "\x1a") {
+    // ctrl+letter
+    key.name = String.fromCharCode(s.charCodeAt(0) + "a".charCodeAt(0) - 1);
+    key.ctrl = true;
+  } else if (s.length === 1 && s >= "0" && s <= "9") {
+    // number
+    key.name = "number";
+  } else if (s.length === 1 && s >= "a" && s <= "z") {
+    // lowercase letter
+    key.name = s;
+  } else if (s.length === 1 && s >= "A" && s <= "Z") {
+    // shift+letter
+    key.name = s.toLowerCase();
+    key.shift = true;
+  } else if ((parts = metaKeyCodeRe.exec(s))) {
+    // meta+character key
+    key.name = parts[1]!.toLowerCase();
+    key.meta = true;
+    key.shift = /^[A-Z]$/.test(parts[1]!);
+  } else if ((parts = fnKeyRe.exec(s))) {
+    // oxlint-disable-next-line typescript/no-misused-spread
+    const segs = [...s];
+
+    if (segs[0] === ESC && segs[1] === ESC) {
+      key.meta = true;
+    }
+
+    // ansi escape sequence
+    // reassemble the key code leaving out leading \x1b's,
+    // the modifier key bitflag and any meaningless "1;" sequence
+    const code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join("");
+
+    const modifier = Number(parts[3] || parts[5] || 1) - 1;
+
+    // Parse the key modifier
+    key.ctrl = !!(modifier & 4);
+    key.meta = key.meta || !!(modifier & 10);
+    key.shift = !!(modifier & 1);
+    key.code = code;
+
+    key.name = keyName[code] ?? "";
+    key.shift = isShiftKey(code) || key.shift;
+    key.ctrl = isCtrlKey(code) || key.ctrl;
+  }
+
+  return key;
+};

package/src/parse-stack-line.ts

@@ -0,0 +1,138 @@
+// Derived from `stack-utils` (MIT, Isaac Z. Schlueter, James Talmage),
+// reduced to the `parseLine()` surface Ink's error overview uses.
+
+export type ParsedStackLine = {
+  line?: number;
+  column?: number;
+  file?: string;
+  function?: string;
+  method?: string;
+  native?: boolean;
+  evalOrigin?: string;
+  evalFile?: string;
+  evalLine?: number;
+  evalColumn?: number;
+};
+
+const lineRegExp = new RegExp(
+  "^" +
+    // Sometimes we strip out the '    at' because it's noisy
+    String.raw`(?:\s*at )?` +
+    // $1 = ctor if 'new'
+    "(?:(new) )?" +
+    // $2 = function name (can be literally anything). May contain method at
+    // the end as [as xyz]
+    String.raw`(?:(.*?) \()?` +
+    // (eval at <anonymous> (file.js:1:1),
+    // $3 = eval origin; $4:$5:$6 are eval file/line/col
+    String.raw`(?:eval at ([^ ]+) \((.+?):(\d+):(\d+)\), )?` +
+    // File:line:col: $7:$8:$9; $10 = 'native' if native
+    String.raw`(?:(.+?):(\d+):(\d+)|(native))` +
+    // Maybe close the paren, then end. If $11 is ), then we only allow
+    // balanced parens in the filename; any imbalance is placed on the fname.
+    String.raw`(\)?)$`,
+);
+
+const methodRegExp = /^(.*?) \[as (.*?)]$/;
+
+const cwd = process.cwd().replaceAll("\\", "/");
+
+const setFile = (result: ParsedStackLine, filename: string): void => {
+  if (filename) {
+    filename = filename.replaceAll("\\", "/");
+
+    if (filename.startsWith(`${cwd}/`)) {
+      filename = filename.slice(cwd.length + 1);
+    }
+
+    result.file = filename;
+  }
+};
+
+export const parseStackLine = (line: string): ParsedStackLine | undefined => {
+  const match = lineRegExp.exec(line);
+
+  if (!match) {
+    return;
+  }
+
+  let functionName = match[2];
+  const evalOrigin = match[3];
+  const evalFile = match[4];
+  const evalLine = Number(match[5]);
+  const evalColumn = Number(match[6]);
+  let file = match[7];
+  const lineNumber = match[8];
+  const columnNumber = match[9];
+  const native = match[10] === "native";
+  const closeParen = match[11] === ")";
+  let method;
+
+  const result: ParsedStackLine = {};
+
+  if (lineNumber) {
+    result.line = Number(lineNumber);
+  }
+
+  if (columnNumber) {
+    result.column = Number(columnNumber);
+  }
+
+  if (closeParen && file) {
+    // Make sure parens are balanced. If we have a file like
+    // "asdf) [as foo] (xyz.js", then odds are that the fname should be
+    // += " (asdf) [as foo]" and the file should be just "xyz.js". Walk
+    // backwards from the end to find the last unbalanced (.
+    let closes = 0;
+
+    for (let index = file.length - 1; index > 0; index--) {
+      if (file.charAt(index) === ")") {
+        closes++;
+      } else if (file.charAt(index) === "(" && file.charAt(index - 1) === " ") {
+        closes--;
+
+        if (closes === -1 && file.charAt(index - 1) === " ") {
+          const before = file.slice(0, index - 1);
+          const after = file.slice(index + 1);
+          file = after;
+          functionName += ` (${before}`;
+          break;
+        }
+      }
+    }
+  }
+
+  if (functionName) {
+    const methodMatch = methodRegExp.exec(functionName);
+
+    if (methodMatch) {
+      functionName = methodMatch[1];
+      method = methodMatch[2];
+    }
+  }
+
+  if (file) {
+    setFile(result, file);
+  }
+
+  if (evalOrigin) {
+    result.evalOrigin = evalOrigin;
+    result.evalLine = evalLine;
+    result.evalColumn = evalColumn;
+    result.evalFile = evalFile?.replaceAll("\\", "/");
+  }
+
+  if (native) {
+    result.native = true;
+  }
+
+  if (functionName) {
+    result.function = functionName;
+  }
+
+  if (method && functionName !== method) {
+    result.method = method;
+  }
+
+  return result;
+};