@ansi-tools/parser 0.0.0 → 0.0.1

package/README.md

@@ -179,6 +179,7 @@ type TOKEN = {
   pos: number;
   raw: string;
   code?: string;
+  intermediate?: string;
 };
 ```
 

package/dist/escaped.d.ts

@@ -1,5 +1,8 @@
-import { APC, APC_OPEN, BACKSLASH, BELL, CODE, CODE_TYPES, CONTROL_CODE, CONTROL_CODE_TEXT, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN, TOKEN_TYPES, parse, parser } from "./parse-BirjVUvQ.js";
+import { APC, APC_OPEN, BACKSLASH, BELL, CODE, CODE_TYPES, CONTROL_CODE, CONTROL_CODE_TEXT, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN, TOKEN_TYPES, parser } from "./parse-BtpkwNjf.js";
 
+//#region src/parse.escaped.d.ts
+declare function parse(input: string): CODE[];
+//#endregion
 //#region src/tokenize.escaped.d.ts
 declare function tokenizer(input: string): Generator<TOKEN>;
 declare function tokenize(input: string): TOKEN[];

package/dist/escaped.js

@@ -1,4 +1,4 @@
-import { APC, APC_OPEN, BACKSLASH, BELL, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN_TYPES, parse, parser } from "./parse-ClmKWMZx.js";
+import { APC, APC_OPEN, BACKSLASH, BELL, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN_TYPES, parser } from "./parse-BE4NnMTj.js";
 
 //#region src/tokenize.escaped.ts
 const CSI_ESCAPED = "\\u009b";
@@ -105,10 +105,11 @@ function* tokenizer(input) {
 								type: TOKEN_TYPES.INTRODUCER,
 								pos: i,
 								raw: sequence + nextChar,
-								code: CSI
+								code: ESC,
+								intermediate: nextChar
 							});
 							i += len + 1;
-							setState("SEQUENCE", CSI);
+							setState("SEQUENCE", ESC);
 						} else if (nextChar) {
 							yield emit({
 								type: TOKEN_TYPES.INTRODUCER,
@@ -117,12 +118,7 @@ function* tokenizer(input) {
 								code: ESC
 							});
 							i += len;
-							yield emit({
-								type: TOKEN_TYPES.FINAL,
-								pos: i,
-								raw: nextChar
-							});
-							i++;
+							setState("SEQUENCE", ESC);
 						} else {
 							yield emit({
 								type: TOKEN_TYPES.INTRODUCER,
@@ -137,7 +133,7 @@ function* tokenizer(input) {
 				}
 			}
 		}
-	} else {
+	} else if (state === "SEQUENCE") {
 		let terminator = "";
 		let terminatorPos = -1;
 		const pos = i;
@@ -151,6 +147,10 @@ function* tokenizer(input) {
 					terminatorPos = i;
 					i++;
 				}
+			} else if (code === ESC) {
+				terminator = char;
+				terminatorPos = i;
+				i++;
 			} else if (code) {
 				if (char === BACKSLASH) {
 					if (code === OSC) {
@@ -199,5 +199,11 @@ function tokenize(input) {
 	return Array.from(tokenizer(input));
 }
 
+//#endregion
+//#region src/parse.escaped.ts
+function parse(input) {
+	return Array.from(parser(tokenizer(input)));
+}
+
 //#endregion
 export { APC, APC_OPEN, BACKSLASH, BELL, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN_TYPES, parse, parser, tokenize, tokenizer };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { APC, APC_OPEN, BACKSLASH, BELL, CODE, CODE_TYPES, CONTROL_CODE, CONTROL_CODE_TEXT, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN, TOKEN_TYPES, parse, parser } from "./parse-BirjVUvQ.js";
+import { APC, APC_OPEN, BACKSLASH, BELL, CODE, CODE_TYPES, CONTROL_CODE, CONTROL_CODE_TEXT, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN, TOKEN_TYPES, parse, parser } from "./parse-BtpkwNjf.js";
 
 //#region src/tokenize.d.ts
 declare function tokenizer(input: string): Generator<TOKEN>;

package/dist/index.js

@@ -1,3 +1,3 @@
-import { APC, APC_OPEN, BACKSLASH, BELL, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN_TYPES, parse, parser, tokenize, tokenizer } from "./parse-ClmKWMZx.js";
+import { APC, APC_OPEN, BACKSLASH, BELL, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN_TYPES, parse, parser, tokenize, tokenizer } from "./parse-BE4NnMTj.js";
 
 export { APC, APC_OPEN, BACKSLASH, BELL, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, OSC, OSC_OPEN, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, TOKEN_TYPES, parse, parser, tokenize, tokenizer };

package/dist/{parse-ClmKWMZx.js → parse-BE4NnMTj.js}

@@ -177,10 +177,17 @@ function parseDEC(pos, raw, data, final) {
 
 //#endregion
 //#region src/parsers/esc.ts
-function parseESC(pos, raw, command, data) {
+function parseESC(token, raw, command, data) {
+	if (token.intermediate) return {
+		type: CODE_TYPES.ESC,
+		pos: token.pos,
+		raw,
+		command: token.intermediate,
+		params: command ? [command] : []
+	};
 	return {
 		type: CODE_TYPES.ESC,
-		pos,
+		pos: token.pos,
 		raw,
 		command,
 		params: data ? [data] : []
@@ -303,16 +310,12 @@ function* tokenizer(input) {
 					yield emit$1({
 						type: TOKEN_TYPES.INTRODUCER,
 						pos: i,
-						raw: char,
-						code: ESC
-					});
-					i += 1;
-					yield emit$1({
-						type: TOKEN_TYPES.FINAL,
-						pos: i,
-						raw: next
+						raw: char + next,
+						code: ESC,
+						intermediate: next
 					});
-					i++;
+					i += 2;
+					setState("SEQUENCE", ESC);
 				} else if (next) {
 					yield emit$1({
 						type: TOKEN_TYPES.INTRODUCER,
@@ -320,12 +323,8 @@ function* tokenizer(input) {
 						raw: char,
 						code: ESC
 					});
-					yield emit$1({
-						type: TOKEN_TYPES.FINAL,
-						pos: i + 1,
-						raw: next
-					});
-					i += 2;
+					i += 1;
+					setState("SEQUENCE", ESC);
 				} else {
 					yield emit$1({
 						type: TOKEN_TYPES.INTRODUCER,
@@ -337,7 +336,7 @@ function* tokenizer(input) {
 				}
 			}
 		}
-	} else {
+	} else if (state === "SEQUENCE") {
 		const pos = i;
 		const code = currentCode;
 		let data = "";
@@ -361,7 +360,17 @@ function* tokenizer(input) {
 			data += char;
 			i++;
 		}
-		else if (code) while (i < input.length) {
+		else if (code === ESC) {
+			if (i < input.length) {
+				const char = input[i];
+				yield emit$1({
+					type: TOKEN_TYPES.FINAL,
+					pos: i,
+					raw: char
+				});
+				i++;
+			}
+		} else if (code) while (i < input.length) {
 			const char = input[i];
 			let terminator;
 			if (char === ST) terminator = ST;
@@ -470,10 +479,10 @@ function* parser(tokens) {
 					});
 					break;
 				case ESC:
-					yield emit(parseESC(pos, raw, finalToken.raw, data));
+					yield emit(parseESC(token, raw, finalToken.raw, data));
 					break;
 			}
-			else if (token.code === ESC) yield emit(parseESC(pos, raw, "", ""));
+			else if (token.code === ESC) yield emit(parseESC(token, raw, "", ""));
 		} else current = tokens.next();
 	}
 }

package/dist/{parse-BirjVUvQ.d.ts → parse-BtpkwNjf.d.ts}

@@ -42,6 +42,7 @@ type TOKEN = {
   pos: number;
   raw: string;
   code?: string;
+  intermediate?: string;
 };
 type CONTROL_CODE = {
   type: "CSI" | "DCS" | "DEC" | "ESC" | "OSC" | "SGR" | "STRING" | "PRIVATE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansi-tools/parser",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "Tokenize and parse strings containing ANSI escape sequences and control codes",
   "main": "./dist/index.js",
   "type": "module",
@@ -11,11 +11,14 @@
       "default": "./dist/index.js"
     },
     "./escaped": {
-      "types": "./dist/index.d.ts",
+      "types": "./dist/escaped.d.ts",
       "import": "./dist/escaped.js",
       "default": "./dist/escaped.js"
     }
   },
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "ansi",
     "escape codes",

package/src/constants.ts

@@ -1,40 +0,0 @@
-export const BELL = String.fromCharCode(7);
-export const ESC = String.fromCharCode(27);
-export const BACKSLASH = String.fromCharCode(92);
-export const DCS = String.fromCharCode(144);
-export const SOS = String.fromCharCode(152);
-export const CSI = String.fromCharCode(155);
-export const ST = String.fromCharCode(156);
-export const OSC = String.fromCharCode(157);
-export const PM = String.fromCharCode(158);
-export const APC = String.fromCharCode(159);
-
-export const CSI_OPEN = "[";
-export const OSC_OPEN = "]";
-export const DEC_OPEN = "?";
-export const PRIVATE_OPENERS = new Set(["<", "=", ">"]);
-
-export const DCS_OPEN = "P";
-export const APC_OPEN = "_";
-export const SOS_OPEN = "^";
-export const PM_OPEN = "X";
-export const STRING_OPENERS = new Set([DCS_OPEN, APC_OPEN, SOS_OPEN, PM_OPEN]);
-
-export const TOKEN_TYPES = {
-  TEXT: "TEXT",
-  INTRODUCER: "INTRODUCER",
-  DATA: "DATA",
-  FINAL: "FINAL",
-} as const;
-
-export const CODE_TYPES = {
-  CSI: "CSI",
-  DCS: "DCS",
-  DEC: "DEC",
-  ESC: "ESC",
-  OSC: "OSC",
-  PRIVATE: "PRIVATE",
-  SGR: "SGR",
-  STRING: "STRING",
-  TEXT: "TEXT",
-} as const;

package/src/escaped.ts

@@ -1,4 +0,0 @@
-export * from "./constants.ts";
-export { parse, parser } from "./parse.ts";
-export { tokenize, tokenizer } from "./tokenize.escaped.ts";
-export type { CODE, CONTROL_CODE, CONTROL_CODE_TEXT, TOKEN } from "./types.ts";

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./constants.ts";
-export { parse, parser } from "./parse.ts";
-export { tokenize, tokenizer } from "./tokenize.ts";
-export type { CODE, CONTROL_CODE, CONTROL_CODE_TEXT, TOKEN } from "./types.ts";

package/src/parse.escaped.test.ts

@@ -1,86 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { tokenizer } from "./tokenize.escaped.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 = String.raw`hello \e[31mworld\e[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: "\\e[31m", params: ["31"], command: "m" },
-    { type: CODE_TYPES.TEXT, pos: 12, raw: "world" },
-    { type: CODE_TYPES.CSI, pos: 17, raw: "\\e[0m", params: ["0"], command: "m" },
-  ]);
-});
-
-test("subsequent escape sequences", () => {
-  const input = String.raw`\e[31m\e[32m\e[33m`;
-  const tokens = tokenizer(input);
-  const codes = [...parser(tokens)];
-  assert.deepEqual(codes, [
-    { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[31m", params: ["31"], command: "m" },
-    { type: CODE_TYPES.CSI, pos: 6, raw: "\\e[32m", params: ["32"], command: "m" },
-    { type: CODE_TYPES.CSI, pos: 12, raw: "\\e[33m", params: ["33"], command: "m" },
-  ]);
-});
-
-test("parse multiple different sequence types", () => {
-  const input = String.raw`\e[1;32m\e]0;title\a\e=\ePdata\e\\`;
-  const tokens = tokenizer(input);
-  const codes = [...parser(tokens)];
-  assert.deepEqual(codes, [
-    { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[1;32m", params: ["1", "32"], command: "m" },
-    { type: CODE_TYPES.OSC, pos: 8, raw: "\\e]0;title\\a", params: ["title"], command: "0" },
-    { type: CODE_TYPES.ESC, pos: 20, raw: "\\e=", command: "=", params: [] },
-    { type: CODE_TYPES.DCS, pos: 23, raw: "\\ePdata\\e\\\\", params: ["data"], command: "" },
-  ]);
-});
-
-test("parse mixed standard and private sequences", () => {
-  const input = String.raw`\e[31m\e[<5h\e[?25l\e[>c`;
-  const tokens = tokenizer(input);
-  const codes = [...parser(tokens)];
-  assert.deepEqual(codes, [
-    { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[31m", params: ["31"], command: "m" },
-    { type: CODE_TYPES.PRIVATE, pos: 6, raw: "\\e[<5h", params: ["5"], command: "<h" },
-    { type: CODE_TYPES.DEC, pos: 12, raw: "\\e[?25l", params: ["25"], command: "l" },
-    { type: CODE_TYPES.PRIVATE, pos: 19, raw: "\\e[>c", params: [], command: ">c" },
-  ]);
-});
-
-test("parse complex missing parameter scenarios", () => {
-  const input = String.raw`\e[;5;m\e[?;h\eP$q;;\e\\`;
-  const tokens = tokenizer(input);
-  const codes = [...parser(tokens)];
-  assert.deepEqual(codes, [
-    { type: CODE_TYPES.CSI, pos: 0, raw: "\\e[;5;m", params: ["-1", "5", "-1"], command: "m" },
-    { type: CODE_TYPES.DEC, pos: 7, raw: "\\e[?;h", params: ["-1", "-1"], command: "h" },
-    { type: CODE_TYPES.DCS, pos: 13, raw: "\\eP$q;;\\e\\\\", params: ["-1", "-1", "-1"], command: "$q" },
-  ]);
-});
-
-test("parse iTerm2 image sequence", () => {
-  const input = String.raw`\e]1337;File=inline=1;width=1;height=1:R0lG=\a`;
-  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 = String.raw`\eP0|23/68656c6c6f\e\\`;
-  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.test.ts

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

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

@@ -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 };
-}