@ansi-tools/parser 1.0.10 → 1.0.12

package/dist/escaped.d.ts

@@ -1,4 +1,4 @@
-import { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE, CODE_TYPES, CONTROL_CODE, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TEXT, TOKEN, TOKEN_TYPES, parser } from "./parse-DV2rRazL.js";
+import { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, CODE, CODE_TYPES, CONTROL_CODE, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, TEXT, TOKEN, TOKEN_TYPES, parser } from "./parse-BzJl6pBN.js";
 
 //#region src/parse.escaped.d.ts
 declare function parse(input: string): CODE[];
@@ -7,4 +7,4 @@ declare function parse(input: string): CODE[];
 declare function tokenizer(input: string): IterableIterator<TOKEN>;
 declare function tokenize(input: string): TOKEN[];
 //#endregion
-export { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE, CODE_TYPES, CONTROL_CODE, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TEXT, TOKEN, TOKEN_TYPES, parse, parser, tokenize, tokenizer };
+export { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, type CODE, CODE_TYPES, type CONTROL_CODE, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, type TEXT, type TOKEN, TOKEN_TYPES, parse, parser, tokenize, tokenizer };

package/dist/escaped.js

@@ -1,4 +1,4 @@
-import { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TOKEN_TYPES, parser } from "./parse-DmFIqYg6.js";
+import { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, CODE_TYPES, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, TOKEN_TYPES, parser } from "./parse-BCjxFvJh.js";
 
 //#region src/tokenize.escaped.ts
 const CSI_ESCAPED = "\\u009b";
@@ -40,6 +40,7 @@ function* tokenizer(input) {
 	let i = 0;
 	let state = "GROUND";
 	let currentCode;
+	let backslashIndex = input.indexOf(BACKSLASH_CODE);
 	function setState(next, code) {
 		state = next;
 		currentCode = code;
@@ -47,7 +48,11 @@ function* tokenizer(input) {
 	while (i < l) if (state === "GROUND") {
 		const textStart = i;
 		while (i < l) {
-			const backslashIndex = input.indexOf(BACKSLASH, i);
+			if (backslashIndex === -1) {
+				i = l;
+				break;
+			}
+			if (backslashIndex < i) backslashIndex = input.indexOf(BACKSLASH_CODE, i);
 			if (backslashIndex === -1) {
 				i = l;
 				break;
@@ -56,12 +61,7 @@ function* tokenizer(input) {
 			const candidates = INTRODUCER_LOOKUP.get(input[backslashIndex + 1]);
 			if (candidates) for (const [seq, len] of candidates) {
 				if (backslashIndex + len > l) continue;
-				let matched = true;
-				for (let k = 0; k < len && matched; k += 2) {
-					matched = input[backslashIndex + k] === seq[k];
-					if (matched && k + 1 < len) matched = input[backslashIndex + k + 1] === seq[k + 1];
-				}
-				if (matched) {
+				if (input.startsWith(seq, backslashIndex)) {
 					isIntroducer = true;
 					break;
 				}
@@ -82,39 +82,34 @@ function* tokenizer(input) {
 				let isMatch = false;
 				for (const [seq, len] of candidates) {
 					if (i + len > l) continue;
-					let isSeqMatch = true;
-					for (let k = 0; k < len && isSeqMatch; k += 2) {
-						isSeqMatch = input[i + k] === seq[k];
-						if (isSeqMatch && k + 1 < len) isSeqMatch = input[i + k + 1] === seq[k + 1];
-					}
-					if (isSeqMatch) {
+					if (input.startsWith(seq, i)) {
 						isMatch = true;
 						if (seq === CSI_ESCAPED || seq === CSI_ESCAPED_HEX) {
 							yield emit({
 								type: TOKEN_TYPES.INTRODUCER,
 								pos: i,
 								raw: seq,
-								code: CSI
+								code: CSI_CODE
 							});
 							i += len;
 							setState("SEQUENCE", CSI);
 						} else {
 							const next = input[i + len];
-							if (next === CSI_OPEN) {
+							if (next === CSI_OPEN_CODE) {
 								yield emit({
 									type: TOKEN_TYPES.INTRODUCER,
 									pos: i,
 									raw: seq + next,
-									code: CSI
+									code: CSI_CODE
 								});
 								i += len + 1;
 								setState("SEQUENCE", CSI);
-							} else if (next === OSC_OPEN) {
+							} else if (next === OSC_OPEN_CODE) {
 								yield emit({
 									type: TOKEN_TYPES.INTRODUCER,
 									pos: i,
 									raw: seq + next,
-									code: OSC
+									code: OSC_CODE
 								});
 								i += len + 1;
 								setState("SEQUENCE", OSC);
@@ -126,7 +121,7 @@ function* tokenizer(input) {
 									code: next
 								});
 								i += len + 1;
-								setState("SEQUENCE", next);
+								setState("SEQUENCE", next.charCodeAt(0));
 							} else if (next) {
 								let j = i + len;
 								while (j < l && input.charCodeAt(j) >= 32 && input.charCodeAt(j) <= 47) j++;
@@ -136,14 +131,14 @@ function* tokenizer(input) {
 										type: TOKEN_TYPES.INTRODUCER,
 										pos: i,
 										raw: seq + is,
-										code: ESC,
+										code: ESC_CODE,
 										intermediate: is
 									});
 									else yield emit({
 										type: TOKEN_TYPES.INTRODUCER,
 										pos: i,
 										raw: seq,
-										code: ESC
+										code: ESC_CODE
 									});
 									i = j;
 									setState("SEQUENCE", ESC);
@@ -160,10 +155,8 @@ function* tokenizer(input) {
 		let terminator = "";
 		let terminatorPos = -1;
 		const pos = i;
-		const code = currentCode;
 		while (!terminator && i < l) {
-			const char = input[i];
-			if (char === BACKSLASH) {
+			if (input.charCodeAt(i) === BACKSLASH) {
 				const next = input[i + 1];
 				if (next) {
 					const interrupters = INTERRUPTER_LOOKUP.get(next);
@@ -184,9 +177,9 @@ function* tokenizer(input) {
 					}
 				}
 				if (terminator) break;
-				if (code !== CSI && code !== ESC) {
+				if (currentCode !== CSI && currentCode !== ESC) {
 					if (next === "a" && i + 2 <= l) {
-						if (code === OSC && input[i + 1] === "a") {
+						if (currentCode === OSC && input[i + 1] === "a") {
 							terminator = "\\a";
 							terminatorPos = i;
 							i += 2;
@@ -195,7 +188,7 @@ function* tokenizer(input) {
 						if (i + 4 <= l) {
 							const char3 = input[i + 2];
 							const char4 = input[i + 3];
-							if (char3 === "0" && char4 === "7" && code === OSC) {
+							if (char3 === "0" && char4 === "7" && currentCode === OSC) {
 								terminator = "\\x07";
 								terminatorPos = i;
 								i += 4;
@@ -203,20 +196,20 @@ function* tokenizer(input) {
 								terminator = "\\x9c";
 								terminatorPos = i;
 								i += 4;
-							} else if (char3 === "1" && char4 === "b" && i + 6 <= l && input[i + 4] === BACKSLASH && input[i + 5] === BACKSLASH) {
+							} else if (char3 === "1" && char4 === "b" && i + 6 <= l && input.charCodeAt(i + 4) === BACKSLASH && input.charCodeAt(i + 5) === BACKSLASH) {
 								terminator = "\\x1b\\\\";
 								terminatorPos = i;
 								i += 6;
 							}
 						}
-					} else if (next === "u" && code === OSC && i + 6 <= l) {
+					} else if (next === "u" && currentCode === OSC && i + 6 <= l) {
 						if (input[i + 2] === "0" && input[i + 3] === "0" && input[i + 4] === "0" && input[i + 5] === "7") {
 							terminator = "\\u0007";
 							terminatorPos = i;
 							i += 6;
 						}
 					} else if (next === "e" && i + 4 <= l) {
-						if (input[i + 2] === BACKSLASH && input[i + 3] === BACKSLASH) {
+						if (input.charCodeAt(i + 2) === BACKSLASH && input.charCodeAt(i + 3) === BACKSLASH) {
 							terminator = "\\e\\\\";
 							terminatorPos = i;
 							i += 4;
@@ -241,28 +234,25 @@ function* tokenizer(input) {
 						}
 					}
 				}
-			} else if (code === CSI) {
+			} else if (currentCode === CSI) {
 				const charCode = input.charCodeAt(i);
 				if (charCode >= 64 && charCode <= 126) {
-					terminator = char;
+					terminator = input[i];
 					terminatorPos = i;
 					i++;
 				}
-			} else if (code === ESC) {
-				terminator = char;
+			} else if (currentCode === ESC) {
+				terminator = input[i];
 				terminatorPos = i;
 				i++;
 			}
 			if (!terminator) i++;
 		}
-		if (terminatorPos > pos) {
-			const data = input.substring(pos, terminatorPos);
-			yield emit({
-				type: TOKEN_TYPES.DATA,
-				pos,
-				raw: data
-			});
-		}
+		if (terminatorPos > pos) yield emit({
+			type: TOKEN_TYPES.DATA,
+			pos,
+			raw: input.substring(pos, terminatorPos)
+		});
 		if (terminator && terminator !== ABANDONED) yield emit({
 			type: TOKEN_TYPES.FINAL,
 			pos: terminatorPos,
@@ -282,4 +272,4 @@ function parse(input) {
 }
 
 //#endregion
-export { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TOKEN_TYPES, parse, parser, tokenize, tokenizer };
+export { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, CODE_TYPES, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, TOKEN_TYPES, parse, parser, tokenize, tokenizer };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE, CODE_TYPES, CONTROL_CODE, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TEXT, TOKEN, TOKEN_TYPES, parse, parser } from "./parse-DV2rRazL.js";
+import { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, CODE, CODE_TYPES, CONTROL_CODE, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, TEXT, TOKEN, TOKEN_TYPES, parse, parser } from "./parse-BzJl6pBN.js";
 
 //#region src/tokenize.d.ts
 declare function tokenizer(input: string): IterableIterator<TOKEN>;
 declare function tokenize(input: string): TOKEN[];
 //#endregion
-export { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE, CODE_TYPES, CONTROL_CODE, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TEXT, TOKEN, TOKEN_TYPES, parse, parser, tokenize, tokenizer };
+export { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, type CODE, CODE_TYPES, type CONTROL_CODE, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, type TEXT, type TOKEN, TOKEN_TYPES, parse, parser, tokenize, tokenizer };

package/dist/index.js

@@ -1,3 +1,3 @@
-import { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TOKEN_TYPES, parse, parser, tokenize, tokenizer } from "./parse-DmFIqYg6.js";
+import { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, CODE_TYPES, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, TOKEN_TYPES, parse, parser, tokenize, tokenizer } from "./parse-BCjxFvJh.js";
 
-export { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TOKEN_TYPES, parse, parser, tokenize, tokenizer };
+export { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, CODE_TYPES, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, TOKEN_TYPES, parse, parser, tokenize, tokenizer };

package/dist/{parse-DmFIqYg6.js → parse-BCjxFvJh.js}

@@ -1,19 +1,33 @@
 //#region src/constants.ts
-const BELL = String.fromCharCode(7);
-const CAN = String.fromCharCode(24);
-const SUB = String.fromCharCode(26);
-const ESC = String.fromCharCode(27);
-const BACKSLASH = String.fromCharCode(92);
-const DCS = String.fromCharCode(144);
-const SOS = String.fromCharCode(152);
-const CSI = String.fromCharCode(155);
-const ST = String.fromCharCode(156);
-const OSC = String.fromCharCode(157);
-const PM = String.fromCharCode(158);
-const APC = String.fromCharCode(159);
-const CSI_OPEN = "[";
-const OSC_OPEN = "]";
-const DEC_OPEN = "?";
+const BELL = 7;
+const BELL_CODE = String.fromCharCode(BELL);
+const CAN = 24;
+const CAN_CODE = String.fromCharCode(CAN);
+const SUB = 26;
+const SUB_CODE = String.fromCharCode(SUB);
+const ESC = 27;
+const ESC_CODE = String.fromCharCode(ESC);
+const BACKSLASH = 92;
+const BACKSLASH_CODE = String.fromCharCode(BACKSLASH);
+const DCS = 144;
+const DCS_CODE = String.fromCharCode(DCS);
+const SOS = 152;
+const SOS_CODE = String.fromCharCode(SOS);
+const CSI = 155;
+const CSI_CODE = String.fromCharCode(CSI);
+const ST = 156;
+const ST_CODE = String.fromCharCode(ST);
+const OSC = 157;
+const OSC_CODE = String.fromCharCode(OSC);
+const PM = 158;
+const PM_CODE = String.fromCharCode(PM);
+const APC = 159;
+const APC_CODE = String.fromCharCode(APC);
+const CSI_OPEN = "[".charCodeAt(0);
+const CSI_OPEN_CODE = String.fromCharCode(CSI_OPEN);
+const OSC_OPEN = "]".charCodeAt(0);
+const OSC_OPEN_CODE = String.fromCharCode(OSC_OPEN);
+const DEC_OPEN = "?".charCodeAt(0);
 const PRIVATE_OPENERS = new Set([
 	"<",
 	"=",
@@ -60,6 +74,20 @@ const CODE_TYPES = {
 	TEXT: "TEXT"
 };
 
+//#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/csi.ts
 function parseCSI(introducer, dataTokens, final) {
@@ -218,20 +246,6 @@ function parseOSC(introducer, dataTokens, final) {
 	};
 }
 
-//#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) {
@@ -262,15 +276,6 @@ function parseSOS(introducer, dataTokens, final) {
 
 //#endregion
 //#region src/tokenize.ts
-const INTRODUCERS = new Set([
-	ESC,
-	CSI,
-	OSC,
-	DCS,
-	APC,
-	PM,
-	SOS
-]);
 function emit$1(token) {
 	return token;
 }
@@ -284,10 +289,13 @@ function* tokenizer(input) {
 	}
 	while (i < input.length) if (state === "GROUND") {
 		const textStart = i;
+		let charCode = input.charCodeAt(i);
+		let char = input[i];
 		while (i < input.length) {
-			const char = input[i];
-			if (INTRODUCERS.has(char)) break;
+			if (charCode === ESC || charCode === CSI || charCode === OSC || charCode === DCS || charCode === APC || charCode === PM || charCode === SOS) break;
 			i++;
+			charCode = input.charCodeAt(i);
+			char = input[i];
 		}
 		if (i > textStart) yield emit$1({
 			type: TOKEN_TYPES.TEXT,
@@ -295,8 +303,7 @@ function* tokenizer(input) {
 			raw: input.substring(textStart, i)
 		});
 		if (i < input.length) {
-			const char = input[i];
-			if (char === CSI || char === OSC || char === DCS || char === APC || char === PM || char === SOS) {
+			if (charCode === CSI || charCode === OSC || charCode === DCS || charCode === APC || charCode === PM || charCode === SOS) {
 				yield emit$1({
 					type: TOKEN_TYPES.INTRODUCER,
 					pos: i,
@@ -304,24 +311,25 @@ function* tokenizer(input) {
 					code: char
 				});
 				i++;
-				setState("SEQUENCE", char);
-			} else if (char === ESC) {
+				setState("SEQUENCE", charCode);
+			} else if (charCode === ESC) {
 				const next = input[i + 1];
-				if (next === CSI_OPEN) {
+				const nextCode = input.charCodeAt(i + 1);
+				if (nextCode === CSI_OPEN) {
 					yield emit$1({
 						type: TOKEN_TYPES.INTRODUCER,
 						pos: i,
 						raw: char + next,
-						code: CSI
+						code: CSI_CODE
 					});
 					i += 2;
 					setState("SEQUENCE", CSI);
-				} else if (next === OSC_OPEN) {
+				} else if (nextCode === OSC_OPEN) {
 					yield emit$1({
 						type: TOKEN_TYPES.INTRODUCER,
 						pos: i,
 						raw: char + next,
-						code: OSC
+						code: OSC_CODE
 					});
 					i += 2;
 					setState("SEQUENCE", OSC);
@@ -333,7 +341,7 @@ function* tokenizer(input) {
 						code: next
 					});
 					i += 2;
-					setState("SEQUENCE", next);
+					setState("SEQUENCE", nextCode);
 				} else if (next) {
 					let j = i + 1;
 					while (j < input.length && input.charCodeAt(j) >= 32 && input.charCodeAt(j) <= 47) j++;
@@ -343,14 +351,14 @@ function* tokenizer(input) {
 							type: TOKEN_TYPES.INTRODUCER,
 							pos: i,
 							raw: char + is,
-							code: ESC,
+							code: ESC_CODE,
 							intermediate: is
 						});
 						else yield emit$1({
 							type: TOKEN_TYPES.INTRODUCER,
 							pos: i,
 							raw: char,
-							code: ESC
+							code: ESC_CODE
 						});
 						i = j;
 						setState("SEQUENCE", ESC);
@@ -360,21 +368,20 @@ function* tokenizer(input) {
 		}
 	} else if (state === "SEQUENCE") {
 		const pos = i;
-		const code = currentCode;
 		let data = "";
-		if (code === CSI) while (i < input.length) {
+		if (currentCode === CSI) while (i < input.length) {
+			const charCode = input.charCodeAt(i);
 			const char = input[i];
-			if (INTERRUPTERS.has(char)) {
+			if (INTERRUPTERS.has(charCode)) {
 				if (data) yield emit$1({
 					type: TOKEN_TYPES.DATA,
 					pos,
 					raw: data
 				});
 				setState("GROUND");
-				if (C0_INTERRUPTERS.has(char)) i++;
+				if (C0_INTERRUPTERS.has(charCode)) i++;
 				break;
 			}
-			const charCode = char.charCodeAt(0);
 			if (charCode >= 64 && charCode <= 126) {
 				if (data) yield emit$1({
 					type: TOKEN_TYPES.DATA,
@@ -393,28 +400,29 @@ function* tokenizer(input) {
 			data += char;
 			i++;
 		}
-		else if (code === ESC) {
+		else if (currentCode === ESC) {
 			if (i < input.length) {
-				const char = input[i];
-				if (INTERRUPTERS.has(char)) {
+				const charCode = input.charCodeAt(i);
+				if (INTERRUPTERS.has(charCode)) {
 					setState("GROUND");
-					if (C0_INTERRUPTERS.has(char)) i++;
+					if (C0_INTERRUPTERS.has(charCode)) i++;
 				} else {
 					yield emit$1({
 						type: TOKEN_TYPES.FINAL,
 						pos: i,
-						raw: char
+						raw: input[i]
 					});
 					i++;
 					setState("GROUND");
 				}
 			}
-		} else if (code) while (i < input.length) {
+		} else if (currentCode) while (i < input.length) {
 			const char = input[i];
+			const charCode = char.charCodeAt(0);
 			let terminator;
-			if (char === ESC && input[i + 1] === BACKSLASH) terminator = ESC + BACKSLASH;
-			else if (char === ST) terminator = ST;
-			else if (char === BELL && code === OSC) terminator = BELL;
+			if (charCode === ESC && input.charCodeAt(i + 1) === BACKSLASH) terminator = ESC_CODE + BACKSLASH_CODE;
+			else if (charCode === ST) terminator = ST_CODE;
+			else if (charCode === BELL && currentCode === OSC) terminator = BELL_CODE;
 			if (terminator) {
 				if (data) yield emit$1({
 					type: TOKEN_TYPES.DATA,
@@ -430,14 +438,14 @@ function* tokenizer(input) {
 				setState("GROUND");
 				break;
 			}
-			if (INTERRUPTERS.has(char)) {
+			if (INTERRUPTERS.has(charCode)) {
 				if (data) yield emit$1({
 					type: TOKEN_TYPES.DATA,
 					pos,
 					raw: data
 				});
 				setState("GROUND");
-				if (C0_INTERRUPTERS.has(char)) i++;
+				if (C0_INTERRUPTERS.has(charCode)) i++;
 				break;
 			}
 			data += char;
@@ -485,29 +493,29 @@ function* parser(tokens) {
 				current = tokens.next();
 			}
 			switch (introducer.code) {
-				case CSI:
+				case CSI_CODE:
 					yield emit(parseCSI(introducer, data, final));
 					break;
-				case OSC:
+				case OSC_CODE:
 					yield emit(parseOSC(introducer, data, final));
 					break;
-				case DCS:
+				case DCS_CODE:
 				case DCS_OPEN:
 					yield emit(parseDCS(introducer, data, final));
 					break;
-				case APC:
+				case APC_CODE:
 				case APC_OPEN:
 					yield emit(parseAPC(introducer, data, final));
 					break;
-				case PM:
+				case PM_CODE:
 				case PM_OPEN:
 					yield emit(parsePM(introducer, data, final));
 					break;
-				case SOS:
+				case SOS_CODE:
 				case SOS_OPEN:
 					yield emit(parseSOS(introducer, data, final));
 					break;
-				case ESC:
+				case ESC_CODE:
 					yield emit(parseESC(introducer, data, final));
 					break;
 			}
@@ -519,4 +527,4 @@ function parse(input) {
 }
 
 //#endregion
-export { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE_TYPES, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TOKEN_TYPES, parse, parser, tokenize, tokenizer };
+export { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, CODE_TYPES, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, TOKEN_TYPES, parse, parser, tokenize, tokenizer };

package/dist/parse-BzJl6pBN.d.ts

@@ -0,0 +1,85 @@
+//#region src/constants.d.ts
+declare const BELL = 7;
+declare const BELL_CODE: string;
+declare const CAN = 24;
+declare const CAN_CODE: string;
+declare const SUB = 26;
+declare const SUB_CODE: string;
+declare const ESC = 27;
+declare const ESC_CODE: string;
+declare const BACKSLASH = 92;
+declare const BACKSLASH_CODE: string;
+declare const DCS = 144;
+declare const DCS_CODE: string;
+declare const SOS = 152;
+declare const SOS_CODE: string;
+declare const CSI = 155;
+declare const CSI_CODE: string;
+declare const ST = 156;
+declare const ST_CODE: string;
+declare const OSC = 157;
+declare const OSC_CODE: string;
+declare const PM = 158;
+declare const PM_CODE: string;
+declare const APC = 159;
+declare const APC_CODE: string;
+declare const CSI_OPEN: number;
+declare const CSI_OPEN_CODE: string;
+declare const OSC_OPEN: number;
+declare const OSC_OPEN_CODE: string;
+declare const DEC_OPEN: number;
+declare const PRIVATE_OPENERS: Set<string>;
+declare const DCS_OPEN = "P";
+declare const APC_OPEN = "_";
+declare const SOS_OPEN = "^";
+declare const PM_OPEN = "X";
+declare const STRING_OPENERS: Set<string>;
+declare const INTERRUPTERS: Set<number>;
+declare const C0_INTERRUPTERS: Set<number>;
+declare const PARAM_SEPARATOR: RegExp;
+declare const TOKEN_TYPES: {
+  readonly TEXT: "TEXT";
+  readonly INTRODUCER: "INTRODUCER";
+  readonly DATA: "DATA";
+  readonly FINAL: "FINAL";
+};
+declare const CODE_TYPES: {
+  readonly CSI: "CSI";
+  readonly DCS: "DCS";
+  readonly DEC: "DEC";
+  readonly ESC: "ESC";
+  readonly OSC: "OSC";
+  readonly PRIVATE: "PRIVATE";
+  readonly SGR: "SGR";
+  readonly STRING: "STRING";
+  readonly TEXT: "TEXT";
+};
+//#endregion
+//#region src/types.d.ts
+type TOKEN = {
+  type: keyof typeof TOKEN_TYPES;
+  pos: number;
+  raw: string;
+  code?: string;
+  intermediate?: string;
+};
+type CONTROL_CODE_TYPE = Exclude<keyof typeof CODE_TYPES, TEXT["type"]>;
+type CONTROL_CODE = {
+  type: CONTROL_CODE_TYPE;
+  command: string;
+  raw: string;
+  params: string[];
+  pos: number;
+};
+type TEXT = {
+  type: "TEXT";
+  raw: string;
+  pos: number;
+};
+type CODE = CONTROL_CODE | TEXT;
+//#endregion
+//#region src/parse.d.ts
+declare function parser(tokens: IterableIterator<TOKEN>): IterableIterator<CODE>;
+declare function parse(input: string): CODE[];
+//#endregion
+export { APC, APC_CODE, APC_OPEN, BACKSLASH, BACKSLASH_CODE, BELL, BELL_CODE, C0_INTERRUPTERS, CAN, CAN_CODE, CODE, CODE_TYPES, CONTROL_CODE, CSI, CSI_CODE, CSI_OPEN, CSI_OPEN_CODE, DCS, DCS_CODE, DCS_OPEN, DEC_OPEN, ESC, ESC_CODE, INTERRUPTERS, OSC, OSC_CODE, OSC_OPEN, OSC_OPEN_CODE, PARAM_SEPARATOR, PM, PM_CODE, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_CODE, SOS_OPEN, ST, STRING_OPENERS, ST_CODE, SUB, SUB_CODE, TEXT, TOKEN, TOKEN_TYPES, parse, parser };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansi-tools/parser",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Tokenize and parse strings containing ANSI escape sequences and control codes",
   "main": "./dist/index.js",
   "type": "module",
@@ -23,7 +23,7 @@
     "prebuild": "pnpm type-check && pnpm test",
     "build": "tsdown --dts src/index.ts src/escaped.ts",
     "dev": "tsdown --dts src/index.ts src/escaped.ts --watch",
-    "test": "node --test",
+    "test": "node --import ./test/assertions.ts --test",
     "type-check": "tsc",
     "prepack": "pnpm build"
   },
@@ -45,8 +45,8 @@
     "directory": "packages/parser"
   },
   "devDependencies": {
-    "@types/node": "^24.0.13",
-    "tsdown": "^0.12.9",
-    "typescript": "^5.8.3"
+    "@types/node": "^24.7.2",
+    "tsdown": "^0.15.7",
+    "typescript": "^5.9.3"
   }
 }

package/dist/parse-DV2rRazL.d.ts

@@ -1,71 +0,0 @@
-//#region src/constants.d.ts
-declare const BELL: string;
-declare const CAN: string;
-declare const SUB: string;
-declare const ESC: string;
-declare const BACKSLASH: string;
-declare const DCS: string;
-declare const SOS: string;
-declare const CSI: string;
-declare const ST: string;
-declare const OSC: string;
-declare const PM: string;
-declare const APC: string;
-declare const CSI_OPEN = "[";
-declare const OSC_OPEN = "]";
-declare const DEC_OPEN = "?";
-declare const PRIVATE_OPENERS: Set<string>;
-declare const DCS_OPEN = "P";
-declare const APC_OPEN = "_";
-declare const SOS_OPEN = "^";
-declare const PM_OPEN = "X";
-declare const STRING_OPENERS: Set<string>;
-declare const INTERRUPTERS: Set<string>;
-declare const C0_INTERRUPTERS: Set<string>;
-declare const PARAM_SEPARATOR: RegExp;
-declare const TOKEN_TYPES: {
-  readonly TEXT: "TEXT";
-  readonly INTRODUCER: "INTRODUCER";
-  readonly DATA: "DATA";
-  readonly FINAL: "FINAL";
-};
-declare const CODE_TYPES: {
-  readonly CSI: "CSI";
-  readonly DCS: "DCS";
-  readonly DEC: "DEC";
-  readonly ESC: "ESC";
-  readonly OSC: "OSC";
-  readonly PRIVATE: "PRIVATE";
-  readonly SGR: "SGR";
-  readonly STRING: "STRING";
-  readonly TEXT: "TEXT";
-};
-//#endregion
-//#region src/types.d.ts
-type TOKEN = {
-  type: keyof typeof TOKEN_TYPES;
-  pos: number;
-  raw: string;
-  code?: string;
-  intermediate?: string;
-};
-type CONTROL_CODE_TYPE = Exclude<keyof typeof CODE_TYPES, TEXT["type"]>;
-type CONTROL_CODE = {
-  type: CONTROL_CODE_TYPE;
-  command: string;
-  raw: string;
-  params: string[];
-  pos: number;
-};
-type TEXT = {
-  type: "TEXT";
-  raw: string;
-  pos: number;
-};
-type CODE = CONTROL_CODE | TEXT;
-//#endregion
-//#region src/parse.d.ts
-declare function parser(tokens: IterableIterator<TOKEN>): IterableIterator<CODE>;
-declare function parse(input: string): CODE[];
-//#endregion
-export { APC, APC_OPEN, BACKSLASH, BELL, C0_INTERRUPTERS, CAN, CODE, CODE_TYPES, CONTROL_CODE, CSI, CSI_OPEN, DCS, DCS_OPEN, DEC_OPEN, ESC, INTERRUPTERS, OSC, OSC_OPEN, PARAM_SEPARATOR, PM, PM_OPEN, PRIVATE_OPENERS, SOS, SOS_OPEN, ST, STRING_OPENERS, SUB, TEXT, TOKEN, TOKEN_TYPES, parse, parser };