@ansi-tools/parser 0.0.0 → 0.0.2

package/README.md

@@ -20,6 +20,8 @@ Parser for ANSI escape sequences.
 - ✅ Zero dependencies
 - ✅ Separate optimized modules for raw and escaped input
 
+Used by [ansi.tools](https://ansi.tools).
+
 ## Installation
 
 ```bash
@@ -145,10 +147,11 @@ for (const code of codes) {
 ## Type Definitions
 
 ```ts
-function parse(input: string): CODE[];
 function tokenize(input: string): TOKEN[];
-function* parser(tokens: Generator<TOKEN>): Generator<CODE>;
+function parse(input: string): CODE[];
+
 function* tokenizer(input: string): Generator<TOKEN>;
+function* parser(tokens: Generator<TOKEN>): Generator<CODE>;
 ```
 
 ### CODE
@@ -179,6 +182,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";
@@ -61,7 +61,9 @@ function* tokenizer(input) {
 		if (i < input.length) {
 			const candidates = INTRODUCER_LOOKUP.get(input[i + 1]);
 			if (candidates) {
+				let matched = false;
 				for (const [sequence, len] of candidates) if (i + len <= input.length && input.substring(i, i + len) === sequence) {
+					matched = true;
 					if (sequence === CSI_ESCAPED) {
 						yield emit({
 							type: TOKEN_TYPES.INTRODUCER,
@@ -105,10 +107,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 +120,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,
@@ -135,9 +133,10 @@ function* tokenizer(input) {
 					}
 					break;
 				}
-			}
+				if (!matched) i++;
+			} else i++;
 		}
-	} else {
+	} else if (state === "SEQUENCE") {
 		let terminator = "";
 		let terminatorPos = -1;
 		const pos = i;
@@ -151,6 +150,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 +202,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.2",
   "description": "Tokenize and parse strings containing ANSI escape sequences and control codes",
   "main": "./dist/index.js",
   "type": "module",
@@ -11,11 +11,21 @@
       "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"
+  ],
+  "scripts": {
+    "prebuild": "pnpm type-check && pnpm test",
+    "build": "tsdown --dts src/index.ts src/escaped.ts",
+    "test": "node --test",
+    "type-check": "tsc",
+    "prepack": "pnpm build"
+  },
   "keywords": [
     "ansi",
     "escape codes",
@@ -26,15 +36,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "homepage": "https://github.com/webpro/ANSI.tools/tree/main/packages/parser",
+  "bugs": "https://github.com/webpro/ANSI.tools/issues",
+  "repository": {
+    "type": "git",
+    "url": "github:webpro/ANSI.tools",
+    "directory": "packages/parser"
+  },
   "devDependencies": {
     "@types/node": "^24.0.13",
     "tsdown": "^0.12.9",
     "typescript": "^5.8.3"
-  },
-  "scripts": {
-    "prebuild": "pnpm type-check && pnpm test",
-    "build": "tsdown --dts src/index.ts src/escaped.ts",
-    "test": "node --test",
-    "type-check": "tsc"
   }
-}
+}

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