@ansi-tools/parser 0.0.0 → 0.0.2

package/src/parsers/csi.test.ts

@@ -1,55 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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 };
-}