@ansi-tools/parser 0.0.1 → 1.0.0

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

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, parser } from "./parse-BE4NnMTj.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-DX-Po36R.js";
 
 //#region src/tokenize.escaped.ts
 const CSI_ESCAPED = "\\u009b";
@@ -61,77 +61,72 @@ function* tokenizer(input) {
 		if (i < input.length) {
 			const candidates = INTRODUCER_LOOKUP.get(input[i + 1]);
 			if (candidates) {
-				for (const [sequence, len] of candidates) if (i + len <= input.length && input.substring(i, i + len) === sequence) {
-					if (sequence === CSI_ESCAPED) {
+				let matched = false;
+				for (const [seq, len] of candidates) if (i + len <= input.length && input.substring(i, i + len) === seq) {
+					matched = true;
+					if (seq === CSI_ESCAPED) {
 						yield emit({
 							type: TOKEN_TYPES.INTRODUCER,
 							pos: i,
-							raw: sequence,
+							raw: seq,
 							code: CSI
 						});
 						i += len;
 						setState("SEQUENCE", CSI);
 					} else {
-						const nextChar = input[i + len];
-						if (nextChar === CSI_OPEN) {
+						const next = input[i + len];
+						if (next === CSI_OPEN) {
 							yield emit({
 								type: TOKEN_TYPES.INTRODUCER,
 								pos: i,
-								raw: sequence + nextChar,
+								raw: seq + next,
 								code: CSI
 							});
 							i += len + 1;
 							setState("SEQUENCE", CSI);
-						} else if (nextChar === OSC_OPEN) {
+						} else if (next === OSC_OPEN) {
 							yield emit({
 								type: TOKEN_TYPES.INTRODUCER,
 								pos: i,
-								raw: sequence + nextChar,
+								raw: seq + next,
 								code: OSC
 							});
 							i += len + 1;
 							setState("SEQUENCE", OSC);
-						} else if (STRING_OPENERS.has(nextChar)) {
+						} else if (STRING_OPENERS.has(next)) {
 							yield emit({
 								type: TOKEN_TYPES.INTRODUCER,
 								pos: i,
-								raw: sequence + nextChar,
-								code: nextChar
+								raw: seq + next,
+								code: next
 							});
 							i += len + 1;
-							setState("SEQUENCE", nextChar);
-						} else if (nextChar && nextChar.charCodeAt(0) >= 32 && nextChar.charCodeAt(0) <= 47) {
+							setState("SEQUENCE", next);
+						} else if (next && next.charCodeAt(0) >= 32 && next.charCodeAt(0) <= 47) {
 							yield emit({
 								type: TOKEN_TYPES.INTRODUCER,
 								pos: i,
-								raw: sequence + nextChar,
+								raw: seq + next,
 								code: ESC,
-								intermediate: nextChar
+								intermediate: next
 							});
 							i += len + 1;
 							setState("SEQUENCE", ESC);
-						} else if (nextChar) {
+						} else if (next) {
 							yield emit({
 								type: TOKEN_TYPES.INTRODUCER,
 								pos: i,
-								raw: sequence,
+								raw: seq,
 								code: ESC
 							});
 							i += len;
 							setState("SEQUENCE", ESC);
-						} else {
-							yield emit({
-								type: TOKEN_TYPES.INTRODUCER,
-								pos: i,
-								raw: sequence,
-								code: ESC
-							});
-							i += len;
 						}
 					}
 					break;
 				}
-			}
+				if (!matched) i++;
+			} else i++;
 		}
 	} else if (state === "SEQUENCE") {
 		let terminator = "";

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-BE4NnMTj.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-DX-Po36R.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-BE4NnMTj.js → parse-DX-Po36R.js}

@@ -47,7 +47,9 @@ const CODE_TYPES = {
 
 //#endregion
 //#region src/parsers/csi.ts
-function parseCSI(pos, raw, data, final) {
+function parseCSI(introducer, dataTokens, final) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const raw = introducer.raw + data + final.raw;
 	const params = [];
 	let intermediates = "";
 	if (data) {
@@ -59,30 +61,28 @@ function parseCSI(pos, raw, data, final) {
 		}
 		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 parts = paramSection.replace(/:/g, ";").split(";");
+			for (const part of parts) params.push(part || "-1");
 		}
 	}
-	const command = intermediates + final;
+	const command = intermediates + (final?.raw ?? "");
 	return {
 		type: CODE_TYPES.CSI,
-		pos,
+		pos: introducer.pos,
 		raw,
 		command,
 		params
 	};
 }
-function parsePrivateCSI(pos, raw, data, final) {
-	const privateIndicator = data[0];
+function parsePrivateCSI(introducer, dataTokens, finalToken) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const raw = introducer.raw + data + (finalToken?.raw ?? "");
+	const privateIndicator = data[0] || "";
 	const withoutIndicator = data.slice(1);
-	const match = withoutIndicator.match(/^([\d;]*)(.*)/);
+	const match = withoutIndicator.match(/^([\d;:]*)(.*)/);
 	const paramsRaw = match?.[1] ?? "";
 	const intermediates = match?.[2] ?? "";
-	const command = `${privateIndicator}${intermediates}${final}`;
+	const command = `${privateIndicator}${intermediates}${finalToken.raw}`;
 	const params = [];
 	if (paramsRaw) {
 		let current = "";
@@ -94,7 +94,7 @@ function parsePrivateCSI(pos, raw, data, final) {
 	}
 	return {
 		type: CODE_TYPES.PRIVATE,
-		pos,
+		pos: introducer.pos,
 		raw,
 		command,
 		params
@@ -110,10 +110,12 @@ const DCS_PATTERNS = new Map([
 	["|", 1],
 	["{", 1]
 ]);
-function parseDCS(pos, raw, data) {
+function parseDCS(introducer, dataTokens, final) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const raw = introducer.raw + data + (final?.raw ?? "");
 	if (!data) return {
 		type: CODE_TYPES.DCS,
-		pos,
+		pos: introducer.pos,
 		raw,
 		command: "",
 		params: []
@@ -131,7 +133,7 @@ function parseDCS(pos, raw, data) {
 		}
 		return {
 			type: CODE_TYPES.DCS,
-			pos,
+			pos: introducer.pos,
 			raw,
 			command: pattern,
 			params
@@ -139,7 +141,7 @@ function parseDCS(pos, raw, data) {
 	}
 	return {
 		type: CODE_TYPES.DCS,
-		pos,
+		pos: introducer.pos,
 		raw,
 		command: "",
 		params: [data]
@@ -148,15 +150,16 @@ function parseDCS(pos, raw, data) {
 
 //#endregion
 //#region src/parsers/dec.ts
-function parseDEC(pos, raw, data, final) {
-	const withoutPrefix = data.slice(1);
+function parseDEC(introducer, dataTokens, final) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const raw = introducer.raw + data + final.raw;
 	let i = 0;
 	let paramsRaw = "";
-	while (i < withoutPrefix.length && (withoutPrefix.charCodeAt(i) >= 48 && withoutPrefix.charCodeAt(i) <= 57 || withoutPrefix[i] === ";")) {
-		paramsRaw += withoutPrefix[i];
+	while (i < data.length && data.charCodeAt(i) >= 48 && data.charCodeAt(i) <= 63) {
+		paramsRaw += data[i];
 		i++;
 	}
-	const command = withoutPrefix.slice(i) + final;
+	const command = data.slice(i) + final.raw;
 	const params = [];
 	if (paramsRaw) {
 		let current = "";
@@ -168,7 +171,7 @@ function parseDEC(pos, raw, data, final) {
 	}
 	return {
 		type: CODE_TYPES.DEC,
-		pos,
+		pos: introducer.pos,
 		raw,
 		command,
 		params
@@ -177,30 +180,29 @@ function parseDEC(pos, raw, data, final) {
 
 //#endregion
 //#region src/parsers/esc.ts
-function parseESC(token, raw, command, data) {
-	if (token.intermediate) return {
-		type: CODE_TYPES.ESC,
-		pos: token.pos,
-		raw,
-		command: token.intermediate,
-		params: command ? [command] : []
-	};
+function parseESC(introducer, dataTokens, final) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const command = introducer.intermediate || (dataTokens[0]?.raw ?? final?.raw);
+	const params = introducer.intermediate ? final?.raw ? [final.raw] : [] : [];
+	const raw = introducer.raw + data + (final?.raw ?? "");
 	return {
 		type: CODE_TYPES.ESC,
-		pos: token.pos,
+		pos: introducer.pos,
 		raw,
 		command,
-		params: data ? [data] : []
+		params
 	};
 }
 
 //#endregion
 //#region src/parsers/osc.ts
-function parseOSC(pos, raw, data) {
+function parseOSC(introducer, dataTokens, final) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const raw = introducer.raw + data + final.raw;
 	const semicolonIndex = data.indexOf(";");
 	if (semicolonIndex === -1) return {
 		type: CODE_TYPES.OSC,
-		pos,
+		pos: introducer.pos,
 		raw,
 		command: data,
 		params: []
@@ -209,7 +211,7 @@ function parseOSC(pos, raw, data) {
 	const remainder = data.slice(semicolonIndex + 1);
 	if (command === "1337") return {
 		type: CODE_TYPES.OSC,
-		pos,
+		pos: introducer.pos,
 		raw,
 		command,
 		params: [remainder]
@@ -225,13 +227,55 @@ function parseOSC(pos, raw, data) {
 	}
 	return {
 		type: CODE_TYPES.OSC,
-		pos,
+		pos: introducer.pos,
 		raw,
 		command,
 		params
 	};
 }
 
+//#endregion
+//#region src/parsers/apc.ts
+function parseAPC(introducer, dataTokens, final) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const raw = introducer.raw + data + final.raw;
+	return {
+		type: CODE_TYPES.STRING,
+		pos: introducer.pos,
+		raw,
+		command: "APC",
+		params: data ? [data] : []
+	};
+}
+
+//#endregion
+//#region src/parsers/pm.ts
+function parsePM(introducer, dataTokens, final) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const raw = introducer.raw + data + final.raw;
+	return {
+		type: CODE_TYPES.STRING,
+		pos: introducer.pos,
+		raw,
+		command: "PM",
+		params: data ? [data] : []
+	};
+}
+
+//#endregion
+//#region src/parsers/sos.ts
+function parseSOS(introducer, dataTokens, final) {
+	const data = dataTokens.map((t) => t.raw).join("");
+	const raw = introducer.raw + data + final.raw;
+	return {
+		type: CODE_TYPES.STRING,
+		pos: introducer.pos,
+		raw,
+		command: "SOS",
+		params: data ? [data] : []
+	};
+}
+
 //#endregion
 //#region src/tokenize.ts
 const INTRODUCERS = new Set([
@@ -317,15 +361,6 @@ function* tokenizer(input) {
 					i += 2;
 					setState("SEQUENCE", ESC);
 				} else if (next) {
-					yield emit$1({
-						type: TOKEN_TYPES.INTRODUCER,
-						pos: i,
-						raw: char,
-						code: ESC
-					});
-					i += 1;
-					setState("SEQUENCE", ESC);
-				} else {
 					yield emit$1({
 						type: TOKEN_TYPES.INTRODUCER,
 						pos: i,
@@ -333,6 +368,7 @@ function* tokenizer(input) {
 						code: ESC
 					});
 					i++;
+					setState("SEQUENCE", ESC);
 				}
 			}
 		}
@@ -419,70 +455,50 @@ function* parser(tokens) {
 			continue;
 		}
 		if (token.type === TOKEN_TYPES.INTRODUCER) {
-			const pos = token.pos;
-			let raw = token.raw;
-			let data = "";
-			let finalToken;
+			const introducer = token;
+			const data = [];
+			let final;
 			current = tokens.next();
-			while (!current.done && !finalToken) {
+			while (!current.done) {
 				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;
+				if (nextToken.type === TOKEN_TYPES.DATA) data.push(nextToken);
+				else if (nextToken.type === TOKEN_TYPES.FINAL) {
+					final = nextToken;
+					current = tokens.next();
+					break;
 				}
 				current = tokens.next();
 			}
-			if (finalToken) switch (token.code) {
+			if (final) switch (introducer.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));
+					if (data[0]?.raw.startsWith(DEC_OPEN)) yield emit(parseDEC(introducer, data, final));
+					else if (PRIVATE_OPENERS.has(data[0]?.raw)) yield emit(parsePrivateCSI(introducer, data, final));
+					else yield emit(parseCSI(introducer, data, final));
 					break;
 				case OSC:
-					yield emit(parseOSC(pos, raw, data));
+					yield emit(parseOSC(introducer, data, final));
 					break;
 				case DCS:
 				case DCS_OPEN:
-					yield emit(parseDCS(pos, raw, data));
+					yield emit(parseDCS(introducer, data, final));
 					break;
 				case APC:
 				case APC_OPEN:
-					yield emit({
-						type: CODE_TYPES.STRING,
-						pos,
-						raw,
-						command: "APC",
-						params: data ? [data] : []
-					});
+					yield emit(parseAPC(introducer, data, final));
 					break;
 				case PM:
 				case PM_OPEN:
-					yield emit({
-						type: CODE_TYPES.STRING,
-						pos,
-						raw,
-						command: "PM",
-						params: data ? [data] : []
-					});
+					yield emit(parsePM(introducer, data, final));
 					break;
 				case SOS:
 				case SOS_OPEN:
-					yield emit({
-						type: CODE_TYPES.STRING,
-						pos,
-						raw,
-						command: "SOS",
-						params: data ? [data] : []
-					});
+					yield emit(parseSOS(introducer, data, final));
 					break;
 				case ESC:
-					yield emit(parseESC(token, raw, finalToken.raw, data));
+					yield emit(parseESC(introducer, data, final));
 					break;
 			}
-			else if (token.code === ESC) yield emit(parseESC(token, raw, "", ""));
+			else if (introducer.code === ESC) yield emit(parseESC(introducer, data, void 0));
 		} else current = tokens.next();
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansi-tools/parser",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "description": "Tokenize and parse strings containing ANSI escape sequences and control codes",
   "main": "./dist/index.js",
   "type": "module",
@@ -19,6 +19,13 @@
   "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",
@@ -29,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"
   }
-}
+}