@ansi-tools/parser 0.0.0

package/src/parse.test.ts

@@ -0,0 +1,86 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { tokenizer } from "./tokenize.ts";
+import { parser } from "./parse.ts";
+import { CODE_TYPES } from "./constants.ts";
+
+test("parse simple text", () => {
+  const input = "hello world";
+  const tokens = tokenizer(input);
+  const codes = [...parser(tokens)];
+  assert.deepEqual(codes, [{ type: CODE_TYPES.TEXT, pos: 0, raw: "hello world" }]);
+});
+
+test("parse mixed text and csi", () => {
+  const input = `hello \x1b[31mworld\x1b[0m`;
+  const tokens = tokenizer(input);
+  const codes = [...parser(tokens)];
+  assert.deepEqual(codes, [
+    { type: CODE_TYPES.TEXT, pos: 0, raw: "hello " },
+    { type: CODE_TYPES.CSI, pos: 6, raw: "\x1b[31m", params: ["31"], command: "m" },
+    { type: CODE_TYPES.TEXT, pos: 11, raw: "world" },
+    { type: CODE_TYPES.CSI, pos: 16, raw: "\x1b[0m", params: ["0"], command: "m" },
+  ]);
+});
+
+test("subsequent escape sequences", () => {
+  const input = `\x1b[31m\x1b[32m\x1b[33m`;
+  const tokens = tokenizer(input);
+  const codes = [...parser(tokens)];
+  assert.deepEqual(codes, [
+    { type: CODE_TYPES.CSI, pos: 0, raw: "\x1b[31m", params: ["31"], command: "m" },
+    { type: CODE_TYPES.CSI, pos: 5, raw: "\x1b[32m", params: ["32"], command: "m" },
+    { type: CODE_TYPES.CSI, pos: 10, raw: "\x1b[33m", params: ["33"], command: "m" },
+  ]);
+});
+
+test("parse multiple different sequence types", () => {
+  const input = `\x1b[1;32m\x1b]0;title\x07\x1b=\x1bPdata\x1b\\`;
+  const tokens = tokenizer(input);
+  const codes = [...parser(tokens)];
+  assert.deepEqual(codes, [
+    { type: CODE_TYPES.CSI, pos: 0, raw: "\x1b[1;32m", params: ["1", "32"], command: "m" },
+    { type: CODE_TYPES.OSC, pos: 7, raw: "\x1b]0;title\x07", params: ["title"], command: "0" },
+    { type: CODE_TYPES.ESC, pos: 17, raw: "\x1b=", command: "=", params: [] },
+    { type: CODE_TYPES.DCS, pos: 19, raw: "\x1bPdata\x1b\\", params: ["data"], command: "" },
+  ]);
+});
+
+test("parse mixed standard and private sequences", () => {
+  const input = `\x1b[31m\x1b[<5h\x1b[?25l\x1b[>c`;
+  const tokens = tokenizer(input);
+  const codes = [...parser(tokens)];
+  assert.deepEqual(codes, [
+    { type: CODE_TYPES.CSI, pos: 0, raw: "\x1b[31m", params: ["31"], command: "m" },
+    { type: CODE_TYPES.PRIVATE, pos: 5, raw: "\x1b[<5h", params: ["5"], command: "<h" },
+    { type: CODE_TYPES.DEC, pos: 10, raw: "\x1b[?25l", params: ["25"], command: "l" },
+    { type: CODE_TYPES.PRIVATE, pos: 16, raw: "\x1b[>c", params: [], command: ">c" },
+  ]);
+});
+
+test("parse complex missing parameter scenarios", () => {
+  const input = `\x1b[;5;m\x1b[?;h\x1bP$q;;\x1b\\`;
+  const tokens = tokenizer(input);
+  const codes = [...parser(tokens)];
+  assert.deepEqual(codes, [
+    { type: CODE_TYPES.CSI, pos: 0, raw: "\x1b[;5;m", params: ["-1", "5", "-1"], command: "m" },
+    { type: CODE_TYPES.DEC, pos: 6, raw: "\x1b[?;h", params: ["-1", "-1"], command: "h" },
+    { type: CODE_TYPES.DCS, pos: 11, raw: "\x1bP$q;;\x1b\\", params: ["-1", "-1", "-1"], command: "$q" },
+  ]);
+});
+
+test("parse iTerm2 image sequence", () => {
+  const input = `\x1b]1337;File=inline=1;width=1;height=1:R0lG=\x07`;
+  const tokens = tokenizer(input);
+  const codes = [...parser(tokens)];
+  assert.deepEqual(codes, [
+    { type: CODE_TYPES.OSC, pos: 0, raw: input, command: "1337", params: ["File=inline=1;width=1;height=1:R0lG="] },
+  ]);
+});
+
+test("parse DECUDK sequence", () => {
+  const input = `\x1bP0|23/68656c6c6f\x1b\\`;
+  const tokens = tokenizer(input);
+  const codes = [...parser(tokens)];
+  assert.deepEqual(codes, [{ type: CODE_TYPES.DCS, pos: 0, raw: input, command: "", params: ["0|23/68656c6c6f"] }]);
+});

package/src/parse.ts

@@ -0,0 +1,111 @@
+import {
+  APC_OPEN,
+  APC,
+  CODE_TYPES,
+  CSI,
+  DCS_OPEN,
+  DCS,
+  DEC_OPEN,
+  ESC,
+  OSC,
+  PM_OPEN,
+  PM,
+  PRIVATE_OPENERS,
+  SOS_OPEN,
+  SOS,
+  TOKEN_TYPES,
+} from "./constants.ts";
+import { parseCSI, parsePrivateCSI } from "./parsers/csi.ts";
+import { parseDCS } from "./parsers/dcs.ts";
+import { parseDEC } from "./parsers/dec.ts";
+import { parseESC } from "./parsers/esc.ts";
+import { parseOSC } from "./parsers/osc.ts";
+import { tokenizer } from "./tokenize.ts";
+import type { CODE, TOKEN } from "./types.ts";
+
+const debug = false;
+
+function emit(token: CODE) {
+  if (debug) console.log("code", token);
+  return token;
+}
+
+export function* parser(tokens: Generator<TOKEN>): Generator<CODE> {
+  let current = tokens.next();
+
+  while (!current.done) {
+    const token = current.value;
+
+    if (token.type === TOKEN_TYPES.TEXT) {
+      yield emit({ type: CODE_TYPES.TEXT, pos: token.pos, raw: token.raw });
+      current = tokens.next();
+      continue;
+    }
+
+    if (token.type === TOKEN_TYPES.INTRODUCER) {
+      const pos = token.pos;
+      let raw = token.raw;
+      let data = "";
+      let finalToken: TOKEN | undefined;
+
+      current = tokens.next();
+
+      while (!current.done && !finalToken) {
+        const nextToken = current.value;
+
+        if (nextToken.type === TOKEN_TYPES.DATA) {
+          data += nextToken.raw;
+          raw += nextToken.raw;
+        } else if (nextToken.type === TOKEN_TYPES.FINAL) {
+          finalToken = nextToken;
+          raw += nextToken.raw;
+        }
+        current = tokens.next();
+      }
+
+      if (finalToken) {
+        switch (token.code) {
+          case CSI:
+            if (data.startsWith(DEC_OPEN)) {
+              yield emit(parseDEC(pos, raw, data, finalToken.raw));
+            } else if (PRIVATE_OPENERS.has(data[0])) {
+              yield emit(parsePrivateCSI(pos, raw, data, finalToken.raw));
+            } else {
+              yield emit(parseCSI(pos, raw, data, finalToken.raw));
+            }
+            break;
+          case OSC:
+            yield emit(parseOSC(pos, raw, data));
+            break;
+          case DCS:
+          case DCS_OPEN:
+            yield emit(parseDCS(pos, raw, data));
+            break;
+          case APC:
+          case APC_OPEN:
+            yield emit({ type: CODE_TYPES.STRING, pos, raw, command: "APC", params: data ? [data] : [] });
+            break;
+          case PM:
+          case PM_OPEN:
+            yield emit({ type: CODE_TYPES.STRING, pos, raw, command: "PM", params: data ? [data] : [] });
+            break;
+          case SOS:
+          case SOS_OPEN:
+            yield emit({ type: CODE_TYPES.STRING, pos, raw, command: "SOS", params: data ? [data] : [] });
+            break;
+          case ESC:
+            yield emit(parseESC(pos, raw, finalToken.raw, data));
+            break;
+        }
+      } else if (token.code === ESC) {
+        yield emit(parseESC(pos, raw, "", ""));
+      }
+    } else {
+      current = tokens.next();
+    }
+  }
+}
+
+export function parse(input: string): CODE[] {
+  return Array.from(parser(tokenizer(input)));
+}

package/src/parsers/csi.test.ts

@@ -0,0 +1,55 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseCSI, parsePrivateCSI } from "./csi.ts";
+import { CODE_TYPES } from "../constants.ts";
+
+test("parseCSI simple command", () => {
+  const result = parseCSI(0, "\\e[31m", "31", "m");
+  assert.deepEqual(result, { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[31m", params: ["31"], command: "m" });
+});
+
+test("parseCSI with multiple params", () => {
+  const result = parseCSI(0, "\\e[1;31m", "1;31", "m");
+  assert.deepEqual(result, { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[1;31m", params: ["1", "31"], command: "m" });
+});
+
+test("parseCSI with missing parameters", () => {
+  const result = parseCSI(0, "\\e[;31m", ";31", "m");
+  assert.deepEqual(result, { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[;31m", params: ["-1", "31"], command: "m" });
+});
+
+test("parseCSI with trailing semicolon", () => {
+  const result = parseCSI(0, "\\e[31;m", "31;", "m");
+  assert.deepEqual(result, { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[31;m", params: ["31", "-1"], command: "m" });
+});
+
+test("parseCSI with leading semicolon", () => {
+  const result = parseCSI(0, "\\e[;m", ";", "m");
+  assert.deepEqual(result, { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[;m", params: ["-1", "-1"], command: "m" });
+});
+
+test("parseCSI no data", () => {
+  const result = parseCSI(0, "\\e[m", "", "m");
+  assert.deepEqual(result, { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[m", params: [], command: "m" });
+});
+
+test("parsePrivateCSI with < introducer", () => {
+  const result = parsePrivateCSI(0, "\\e[<31m", "<31", "m");
+  assert.deepEqual(result, { type: CODE_TYPES.PRIVATE, pos: 0, raw: "\\e[<31m", params: ["31"], command: "<m" });
+});
+
+test("parsePrivateCSI with > introducer", () => {
+  const result = parsePrivateCSI(0, "\\e[>c", ">", "c");
+  assert.deepEqual(result, { type: CODE_TYPES.PRIVATE, pos: 0, raw: "\\e[>c", params: [], command: ">c" });
+});
+
+test("parsePrivateCSI with = introducer", () => {
+  const result = parsePrivateCSI(0, "\\e[=1;2c", "=1;2", "c");
+  assert.deepEqual(result, {
+    type: CODE_TYPES.PRIVATE,
+    pos: 0,
+    raw: "\\e[=1;2c",
+    params: ["1", "2"],
+    command: "=c",
+  });
+});

package/src/parsers/csi.ts

@@ -0,0 +1,54 @@
+import { CODE_TYPES } from "../constants.ts";
+import type { CONTROL_CODE } from "../types.ts";
+
+export function parseCSI(pos: number, raw: string, data: string, final: string): CONTROL_CODE {
+  const params = [];
+  let intermediates = "";
+  if (data) {
+    let i = 0;
+    let paramSection = "";
+    while (i < data.length && data.charCodeAt(i) >= 0x30 && data.charCodeAt(i) <= 0x3f) {
+      paramSection += data[i];
+      i++;
+    }
+    intermediates = data.slice(i);
+    if (paramSection) {
+      let current = "";
+      for (let j = 0; j < paramSection.length; j++) {
+        if (paramSection[j] === ";") {
+          params.push(current || "-1");
+          current = "";
+        } else {
+          current += paramSection[j];
+        }
+      }
+      params.push(current || "-1");
+    }
+  }
+  const command = intermediates + final;
+  return { type: CODE_TYPES.CSI, pos, raw, command, params };
+}
+
+export function parsePrivateCSI(pos: number, raw: string, data: string, final: string): CONTROL_CODE {
+  const privateIndicator = data[0];
+  const withoutIndicator = data.slice(1);
+  const match = withoutIndicator.match(/^([\d;]*)(.*)/);
+  const paramsRaw = match?.[1] ?? "";
+  const intermediates = match?.[2] ?? "";
+  const command = `${privateIndicator}${intermediates}${final}`;
+  const params = [];
+  if (paramsRaw) {
+    let current = "";
+    for (let i = 0; i < paramsRaw.length; i++) {
+      if (paramsRaw[i] === ";") {
+        params.push(current || "-1");
+        current = "";
+      } else {
+        current += paramsRaw[i];
+      }
+    }
+    params.push(current || "-1");
+  }
+
+  return { type: CODE_TYPES.PRIVATE, pos, raw, command, params };
+}

package/src/parsers/dcs.test.ts

@@ -0,0 +1,47 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseDCS } from "./dcs.ts";
+import { CODE_TYPES } from "../constants.ts";
+
+test("parseDCS simple sequence", () => {
+  const result = parseDCS(0, "\\eP0;1|name\\e\\\\", "0;1|name");
+  assert.deepEqual(result, {
+    type: CODE_TYPES.DCS,
+    pos: 0,
+    raw: "\\eP0;1|name\\e\\\\",
+    params: ["0;1|name"],
+    command: "",
+  });
+});
+
+test("parseDCS with missing parameters", () => {
+  const result = parseDCS(0, "\\eP$q;\\e\\\\", "$q;");
+  assert.deepEqual(result, {
+    type: CODE_TYPES.DCS,
+    pos: 0,
+    raw: "\\eP$q;\\e\\\\",
+    params: ["-1", "-1"],
+    command: "$q",
+  });
+});
+
+test("parseDCS with known pattern", () => {
+  const result = parseDCS(0, "\\eP$qm\\e\\\\", "$qm");
+  assert.deepEqual(result, { type: CODE_TYPES.DCS, pos: 0, raw: "\\eP$qm\\e\\\\", params: ["m"], command: "$q" });
+});
+
+test("parseDCS empty data", () => {
+  const result = parseDCS(0, "\\eP\\e\\\\", "");
+  assert.deepEqual(result, { type: CODE_TYPES.DCS, pos: 0, raw: "\\eP\\e\\\\", command: "", params: [] });
+});
+
+test("parseDCS unknown pattern", () => {
+  const result = parseDCS(0, "\\ePunknown\\e\\\\", "unknown");
+  assert.deepEqual(result, {
+    type: CODE_TYPES.DCS,
+    pos: 0,
+    raw: "\\ePunknown\\e\\\\",
+    command: "",
+    params: ["unknown"],
+  });
+});

package/src/parsers/dcs.ts

@@ -0,0 +1,36 @@
+import { CODE_TYPES } from "../constants.ts";
+import type { CONTROL_CODE } from "../types.ts";
+
+const DCS_PATTERNS = new Map([
+  ["$q", 2],
+  ["+q", 2],
+  ["+p", 2],
+  ["|", 1],
+  ["{", 1],
+]);
+
+export function parseDCS(pos: number, raw: string, data: string): CONTROL_CODE {
+  if (!data) return { type: CODE_TYPES.DCS, pos, raw, command: "", params: [] };
+
+  for (const [pattern, length] of DCS_PATTERNS) {
+    if (data.startsWith(pattern)) {
+      const remainder = data.slice(length);
+      const params = [];
+      if (remainder) {
+        let current = "";
+        for (let i = 0; i < remainder.length; i++) {
+          if (remainder[i] === ";") {
+            params.push(current || "-1");
+            current = "";
+          } else {
+            current += remainder[i];
+          }
+        }
+        params.push(current || "-1");
+      }
+      return { type: CODE_TYPES.DCS, pos, raw, command: pattern, params };
+    }
+  }
+
+  return { type: CODE_TYPES.DCS, pos, raw, command: "", params: [data] };
+}

package/src/parsers/dec.test.ts

@@ -0,0 +1,24 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseDEC } from "./dec.ts";
+import { CODE_TYPES } from "../constants.ts";
+
+test("parseDEC basic sequence", () => {
+  const result = parseDEC(0, "\\e[?25h", "?25", "h");
+  assert.deepEqual(result, { type: CODE_TYPES.DEC, pos: 0, raw: "\\e[?25h", params: ["25"], command: "h" });
+});
+
+test("parseDEC with missing parameters", () => {
+  const result = parseDEC(0, "\\e[?;h", "?;", "h");
+  assert.deepEqual(result, { type: CODE_TYPES.DEC, pos: 0, raw: "\\e[?;h", params: ["-1", "-1"], command: "h" });
+});
+
+test("parseDEC with intermediate bytes", () => {
+  const result = parseDEC(0, "\\e[?1$p", "?1$", "p");
+  assert.deepEqual(result, { type: CODE_TYPES.DEC, pos: 0, raw: "\\e[?1$p", params: ["1"], command: "$p" });
+});
+
+test("parseDEC multiple parameters with intermediates", () => {
+  const result = parseDEC(0, "\\e[?1;2$p", "?1;2$", "p");
+  assert.deepEqual(result, { type: CODE_TYPES.DEC, pos: 0, raw: "\\e[?1;2$p", params: ["1", "2"], command: "$p" });
+});

package/src/parsers/dec.ts

@@ -0,0 +1,30 @@
+import { CODE_TYPES } from "../constants.ts";
+import type { CONTROL_CODE } from "../types.ts";
+
+export function parseDEC(pos: number, raw: string, data: string, final: string): CONTROL_CODE {
+  const withoutPrefix = data.slice(1);
+  let i = 0;
+  let paramsRaw = "";
+  while (
+    i < withoutPrefix.length &&
+    ((withoutPrefix.charCodeAt(i) >= 48 && withoutPrefix.charCodeAt(i) <= 57) || withoutPrefix[i] === ";")
+  ) {
+    paramsRaw += withoutPrefix[i];
+    i++;
+  }
+  const command = withoutPrefix.slice(i) + final;
+  const params = [];
+  if (paramsRaw) {
+    let current = "";
+    for (let j = 0; j < paramsRaw.length; j++) {
+      if (paramsRaw[j] === ";") {
+        params.push(current || "-1");
+        current = "";
+      } else {
+        current += paramsRaw[j];
+      }
+    }
+    params.push(current || "-1");
+  }
+  return { type: CODE_TYPES.DEC, pos, raw, command, params };
+}

package/src/parsers/esc.test.ts

@@ -0,0 +1,19 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseESC } from "./esc.ts";
+import { CODE_TYPES } from "../constants.ts";
+
+test("parseESC simple command", () => {
+  const result = parseESC(0, "\\e=", "=");
+  assert.deepEqual(result, { type: CODE_TYPES.ESC, pos: 0, raw: "\\e=", command: "=", params: [] });
+});
+
+test("parseESC with data", () => {
+  const result = parseESC(0, "\\e(A", "(", "A");
+  assert.deepEqual(result, { type: CODE_TYPES.ESC, pos: 0, raw: "\\e(A", command: "(", params: ["A"] });
+});
+
+test("parseESC charset sequence", () => {
+  const result = parseESC(0, "\\e)A", ")", "A");
+  assert.deepEqual(result, { type: CODE_TYPES.ESC, pos: 0, raw: "\\e)A", command: ")", params: ["A"] });
+});

package/src/parsers/esc.ts

@@ -0,0 +1,6 @@
+import { CODE_TYPES } from "../constants.ts";
+import type { CONTROL_CODE } from "../types.ts";
+
+export function parseESC(pos: number, raw: string, command: string, data?: string): CONTROL_CODE {
+  return { type: CODE_TYPES.ESC, pos, raw, command, params: data ? [data] : [] };
+}

package/src/parsers/osc.test.ts

@@ -0,0 +1,36 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseOSC } from "./osc.ts";
+import { CODE_TYPES } from "../constants.ts";
+
+test("parseOSC simple command", () => {
+  const result = parseOSC(0, "\\e]8;;http://example.com\\a", "8;;http://example.com");
+  assert.deepEqual(result, {
+    type: CODE_TYPES.OSC,
+    pos: 0,
+    raw: "\\e]8;;http://example.com\\a",
+    params: ["", "http://example.com"],
+    command: "8",
+  });
+});
+
+test("parseOSC no parameters", () => {
+  const result = parseOSC(0, "\\e]0\\a", "0");
+  assert.deepEqual(result, { type: CODE_TYPES.OSC, pos: 0, raw: "\\e]0\\a", command: "0", params: [] });
+});
+
+test("parseOSC with trailing semicolon (empty remainder)", () => {
+  const result = parseOSC(0, "\\e]8;\\a", "8;");
+  assert.deepEqual(result, { type: CODE_TYPES.OSC, pos: 0, raw: "\\e]8;\\a", command: "8", params: [] });
+});
+
+test("parseOSC real-world example", () => {
+  const result = parseOSC(0, "\\e]2;Window Title\\a", "2;Window Title");
+  assert.deepEqual(result, {
+    type: CODE_TYPES.OSC,
+    pos: 0,
+    raw: "\\e]2;Window Title\\a",
+    command: "2",
+    params: ["Window Title"],
+  });
+});

package/src/parsers/osc.ts

@@ -0,0 +1,29 @@
+import { CODE_TYPES } from "../constants.ts";
+import type { CONTROL_CODE } from "../types.ts";
+
+export function parseOSC(pos: number, raw: string, data: string): CONTROL_CODE {
+  const semicolonIndex = data.indexOf(";");
+  if (semicolonIndex === -1) {
+    return { type: CODE_TYPES.OSC, pos, raw, command: data, params: [] };
+  }
+  const command = data.slice(0, semicolonIndex);
+  const remainder = data.slice(semicolonIndex + 1);
+
+  if (command === "1337") return { type: CODE_TYPES.OSC, pos, raw, command, params: [remainder] };
+
+  const params = [];
+  if (remainder) {
+    let current = "";
+    for (let i = 0; i < remainder.length; i++) {
+      if (remainder[i] === ";") {
+        params.push(current);
+        current = "";
+      } else {
+        current += remainder[i];
+      }
+    }
+    params.push(current);
+  }
+
+  return { type: CODE_TYPES.OSC, pos, raw, command, params };
+}