@ansi-tools/parser 1.0.12 → 1.0.13

package/dist/constants.d.ts

@@ -0,0 +1,56 @@
+export declare const BELL = 7;
+export declare const BELL_CODE: string;
+export declare const CAN = 24;
+export declare const CAN_CODE: string;
+export declare const SUB = 26;
+export declare const SUB_CODE: string;
+export declare const ESC = 27;
+export declare const ESC_CODE: string;
+export declare const BACKSLASH = 92;
+export declare const BACKSLASH_CODE: string;
+export declare const DCS = 144;
+export declare const DCS_CODE: string;
+export declare const SOS = 152;
+export declare const SOS_CODE: string;
+export declare const CSI = 155;
+export declare const CSI_CODE: string;
+export declare const ST = 156;
+export declare const ST_CODE: string;
+export declare const OSC = 157;
+export declare const OSC_CODE: string;
+export declare const PM = 158;
+export declare const PM_CODE: string;
+export declare const APC = 159;
+export declare const APC_CODE: string;
+export declare const CSI_OPEN: number;
+export declare const CSI_OPEN_CODE: string;
+export declare const OSC_OPEN: number;
+export declare const OSC_OPEN_CODE: string;
+export declare const DEC_OPEN: number;
+export declare const PRIVATE_OPENERS: Set<string>;
+export declare const DCS_OPEN = "P";
+export declare const APC_OPEN = "_";
+export declare const SOS_OPEN = "^";
+export declare const PM_OPEN = "X";
+export declare const STRING_OPENERS: Set<string>;
+export declare const INTERRUPTERS: Set<number>;
+export declare const C0_INTERRUPTERS: Set<number>;
+export declare const PARAM_SEPARATOR: RegExp;
+export declare const TOKEN_TYPES: {
+    readonly TEXT: "TEXT";
+    readonly INTRODUCER: "INTRODUCER";
+    readonly DATA: "DATA";
+    readonly FINAL: "FINAL";
+};
+export 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";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,IAAI,CAAC;AACtB,eAAO,MAAM,SAAS,QAA4B,CAAC;AACnD,eAAO,MAAM,GAAG,KAAK,CAAC;AACtB,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,eAAO,MAAM,GAAG,KAAK,CAAC;AACtB,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,eAAO,MAAM,GAAG,KAAK,CAAC;AACtB,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,cAAc,QAAiC,CAAC;AAC7D,eAAO,MAAM,GAAG,MAAM,CAAC;AACvB,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,eAAO,MAAM,GAAG,MAAM,CAAC;AACvB,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,eAAO,MAAM,GAAG,MAAM,CAAC;AACvB,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,eAAO,MAAM,EAAE,MAAM,CAAC;AACtB,eAAO,MAAM,OAAO,QAA0B,CAAC;AAC/C,eAAO,MAAM,GAAG,MAAM,CAAC;AACvB,eAAO,MAAM,QAAQ,QAA2B,CAAC;AACjD,eAAO,MAAM,EAAE,MAAM,CAAC;AACtB,eAAO,MAAM,OAAO,QAA0B,CAAC;AAC/C,eAAO,MAAM,GAAG,MAAM,CAAC;AACvB,eAAO,MAAM,QAAQ,QAA2B,CAAC;AAEjD,eAAO,MAAM,QAAQ,QAAoB,CAAC;AAC1C,eAAO,MAAM,aAAa,QAAgC,CAAC;AAC3D,eAAO,MAAM,QAAQ,QAAoB,CAAC;AAC1C,eAAO,MAAM,aAAa,QAAgC,CAAC;AAC3D,eAAO,MAAM,QAAQ,QAAoB,CAAC;AAC1C,eAAO,MAAM,eAAe,aAA2B,CAAC;AAExD,eAAO,MAAM,QAAQ,MAAM,CAAC;AAC5B,eAAO,MAAM,QAAQ,MAAM,CAAC;AAC5B,eAAO,MAAM,QAAQ,MAAM,CAAC;AAC5B,eAAO,MAAM,OAAO,MAAM,CAAC;AAC3B,eAAO,MAAM,cAAc,aAAmD,CAAC;AAE/E,eAAO,MAAM,YAAY,aAAwD,CAAC;AAClF,eAAO,MAAM,eAAe,aAAsB,CAAC;AAEnD,eAAO,MAAM,eAAe,QAAS,CAAC;AAEtC,eAAO,MAAM,WAAW;;;;;CAKd,CAAC;AAEX,eAAO,MAAM,UAAU;;;;;;;;;;CAUb,CAAC"}

package/dist/constants.js

@@ -0,0 +1,55 @@
+export const BELL = 7;
+export const BELL_CODE = String.fromCharCode(BELL);
+export const CAN = 24;
+export const CAN_CODE = String.fromCharCode(CAN);
+export const SUB = 26;
+export const SUB_CODE = String.fromCharCode(SUB);
+export const ESC = 27;
+export const ESC_CODE = String.fromCharCode(ESC);
+export const BACKSLASH = 92;
+export const BACKSLASH_CODE = String.fromCharCode(BACKSLASH);
+export const DCS = 144;
+export const DCS_CODE = String.fromCharCode(DCS);
+export const SOS = 152;
+export const SOS_CODE = String.fromCharCode(SOS);
+export const CSI = 155;
+export const CSI_CODE = String.fromCharCode(CSI);
+export const ST = 156;
+export const ST_CODE = String.fromCharCode(ST);
+export const OSC = 157;
+export const OSC_CODE = String.fromCharCode(OSC);
+export const PM = 158;
+export const PM_CODE = String.fromCharCode(PM);
+export const APC = 159;
+export const APC_CODE = String.fromCharCode(APC);
+export const CSI_OPEN = "[".charCodeAt(0);
+export const CSI_OPEN_CODE = String.fromCharCode(CSI_OPEN);
+export const OSC_OPEN = "]".charCodeAt(0);
+export const OSC_OPEN_CODE = String.fromCharCode(OSC_OPEN);
+export const DEC_OPEN = "?".charCodeAt(0);
+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 INTERRUPTERS = new Set([CAN, SUB, ESC, CSI, OSC, DCS, APC, PM, SOS]);
+export const C0_INTERRUPTERS = new Set([CAN, SUB]);
+export const PARAM_SEPARATOR = /[;:]/;
+export const TOKEN_TYPES = {
+    TEXT: "TEXT",
+    INTRODUCER: "INTRODUCER",
+    DATA: "DATA",
+    FINAL: "FINAL",
+};
+export const CODE_TYPES = {
+    CSI: "CSI",
+    DCS: "DCS",
+    DEC: "DEC",
+    ESC: "ESC",
+    OSC: "OSC",
+    PRIVATE: "PRIVATE",
+    SGR: "SGR",
+    STRING: "STRING",
+    TEXT: "TEXT",
+};

package/dist/escaped.d.ts

@@ -1,10 +1,6 @@
-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[];
-//#endregion
-//#region src/tokenize.escaped.d.ts
-declare function tokenizer(input: string): IterableIterator<TOKEN>;
-declare function tokenize(input: string): TOKEN[];
-//#endregion
-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 };
+export * from "./constants.ts";
+export { parse } from "./parse.escaped.ts";
+export { parser } from "./parse.ts";
+export { tokenize, tokenizer } from "./tokenize.escaped.ts";
+export type { CODE, CONTROL_CODE, TEXT, TOKEN } from "./types.ts";
+//# sourceMappingURL=escaped.d.ts.map

package/dist/escaped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escaped.d.ts","sourceRoot":"","sources":["../src/escaped.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAC5D,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/dist/escaped.js

@@ -1,275 +1,4 @@
-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";
-const CSI_ESCAPED_HEX = "\\x9b";
-const ABANDONED = "ABANDONED";
-const INTRODUCERS = [
-	["\\u001b", 6],
-	[CSI_ESCAPED, 6],
-	[CSI_ESCAPED_HEX, 4],
-	["\\x1b", 4],
-	["\\033", 4],
-	["\\e", 2]
-];
-const INTERRUPTERS_ESCAPED = [
-	["\\x18", 4],
-	["\\x1a", 4],
-	["\\u0018", 6],
-	["\\u001a", 6]
-];
-const INTERRUPTER_LOOKUP = /* @__PURE__ */ new Map();
-for (const [sequence, len] of INTERRUPTERS_ESCAPED) {
-	const secondChar = sequence[1];
-	if (!INTERRUPTER_LOOKUP.has(secondChar)) INTERRUPTER_LOOKUP.set(secondChar, []);
-	INTERRUPTER_LOOKUP.get(secondChar)?.push([sequence, len]);
-}
-const INTRODUCER_LOOKUP = /* @__PURE__ */ new Map();
-const INTRODUCER_FIRST_CHAR_CACHE = /* @__PURE__ */ new Map();
-for (const [sequence, len] of INTRODUCERS) {
-	const secondChar = sequence[1];
-	if (!INTRODUCER_LOOKUP.has(secondChar)) INTRODUCER_LOOKUP.set(secondChar, []);
-	INTRODUCER_LOOKUP.get(secondChar)?.push([sequence, len]);
-	INTRODUCER_FIRST_CHAR_CACHE.set(sequence, true);
-}
-function emit(token) {
-	return token;
-}
-function* tokenizer(input) {
-	const l = input.length;
-	let i = 0;
-	let state = "GROUND";
-	let currentCode;
-	let backslashIndex = input.indexOf(BACKSLASH_CODE);
-	function setState(next, code) {
-		state = next;
-		currentCode = code;
-	}
-	while (i < l) if (state === "GROUND") {
-		const textStart = i;
-		while (i < l) {
-			if (backslashIndex === -1) {
-				i = l;
-				break;
-			}
-			if (backslashIndex < i) backslashIndex = input.indexOf(BACKSLASH_CODE, i);
-			if (backslashIndex === -1) {
-				i = l;
-				break;
-			}
-			let isIntroducer = false;
-			const candidates = INTRODUCER_LOOKUP.get(input[backslashIndex + 1]);
-			if (candidates) for (const [seq, len] of candidates) {
-				if (backslashIndex + len > l) continue;
-				if (input.startsWith(seq, backslashIndex)) {
-					isIntroducer = true;
-					break;
-				}
-			}
-			if (isIntroducer) {
-				i = backslashIndex;
-				break;
-			} else i = backslashIndex + 1;
-		}
-		if (i > textStart) yield emit({
-			type: TOKEN_TYPES.TEXT,
-			pos: textStart,
-			raw: input.substring(textStart, i)
-		});
-		if (i < l) {
-			const candidates = INTRODUCER_LOOKUP.get(input[i + 1]);
-			if (candidates) {
-				let isMatch = false;
-				for (const [seq, len] of candidates) {
-					if (i + len > l) continue;
-					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
-							});
-							i += len;
-							setState("SEQUENCE", CSI);
-						} else {
-							const next = input[i + len];
-							if (next === CSI_OPEN_CODE) {
-								yield emit({
-									type: TOKEN_TYPES.INTRODUCER,
-									pos: i,
-									raw: seq + next,
-									code: CSI_CODE
-								});
-								i += len + 1;
-								setState("SEQUENCE", CSI);
-							} else if (next === OSC_OPEN_CODE) {
-								yield emit({
-									type: TOKEN_TYPES.INTRODUCER,
-									pos: i,
-									raw: seq + next,
-									code: OSC_CODE
-								});
-								i += len + 1;
-								setState("SEQUENCE", OSC);
-							} else if (STRING_OPENERS.has(next)) {
-								yield emit({
-									type: TOKEN_TYPES.INTRODUCER,
-									pos: i,
-									raw: seq + next,
-									code: next
-								});
-								i += len + 1;
-								setState("SEQUENCE", next.charCodeAt(0));
-							} else if (next) {
-								let j = i + len;
-								while (j < l && input.charCodeAt(j) >= 32 && input.charCodeAt(j) <= 47) j++;
-								if (j < l) {
-									const is = input.slice(i + len, j);
-									if (is) yield emit({
-										type: TOKEN_TYPES.INTRODUCER,
-										pos: i,
-										raw: seq + is,
-										code: ESC_CODE,
-										intermediate: is
-									});
-									else yield emit({
-										type: TOKEN_TYPES.INTRODUCER,
-										pos: i,
-										raw: seq,
-										code: ESC_CODE
-									});
-									i = j;
-									setState("SEQUENCE", ESC);
-								} else i = j;
-							} else i += len;
-						}
-						break;
-					}
-				}
-				if (!isMatch) i++;
-			} else i++;
-		}
-	} else if (state === "SEQUENCE") {
-		let terminator = "";
-		let terminatorPos = -1;
-		const pos = i;
-		while (!terminator && i < l) {
-			if (input.charCodeAt(i) === BACKSLASH) {
-				const next = input[i + 1];
-				if (next) {
-					const interrupters = INTERRUPTER_LOOKUP.get(next);
-					if (interrupters) {
-						for (const [seq, len] of interrupters) if (i + len <= l) {
-							let matched = true;
-							for (let k = 0; k < len; k++) if (input[i + k] !== seq[k]) {
-								matched = false;
-								break;
-							}
-							if (matched) {
-								terminator = ABANDONED;
-								terminatorPos = i;
-								i += len;
-								break;
-							}
-						}
-					}
-				}
-				if (terminator) break;
-				if (currentCode !== CSI && currentCode !== ESC) {
-					if (next === "a" && i + 2 <= l) {
-						if (currentCode === OSC && input[i + 1] === "a") {
-							terminator = "\\a";
-							terminatorPos = i;
-							i += 2;
-						}
-					} else if (next === "x") {
-						if (i + 4 <= l) {
-							const char3 = input[i + 2];
-							const char4 = input[i + 3];
-							if (char3 === "0" && char4 === "7" && currentCode === OSC) {
-								terminator = "\\x07";
-								terminatorPos = i;
-								i += 4;
-							} else if (char3 === "9" && char4 === "c") {
-								terminator = "\\x9c";
-								terminatorPos = i;
-								i += 4;
-							} 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" && 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.charCodeAt(i + 2) === BACKSLASH && input.charCodeAt(i + 3) === BACKSLASH) {
-							terminator = "\\e\\\\";
-							terminatorPos = i;
-							i += 4;
-						}
-					}
-				}
-				if (!terminator) {
-					if (next) {
-						const candidates = INTRODUCER_LOOKUP.get(next);
-						if (candidates) for (const [seq, len] of candidates) {
-							if (i + len > l) continue;
-							let matched = true;
-							for (let k = 0; k < len && matched; k += 2) {
-								matched = input[i + k] === seq[k];
-								if (matched && k + 1 < len) matched = input[i + k + 1] === seq[k + 1];
-							}
-							if (matched) {
-								terminator = ABANDONED;
-								terminatorPos = i;
-								break;
-							}
-						}
-					}
-				}
-			} else if (currentCode === CSI) {
-				const charCode = input.charCodeAt(i);
-				if (charCode >= 64 && charCode <= 126) {
-					terminator = input[i];
-					terminatorPos = i;
-					i++;
-				}
-			} else if (currentCode === ESC) {
-				terminator = input[i];
-				terminatorPos = i;
-				i++;
-			}
-			if (!terminator) i++;
-		}
-		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,
-			raw: terminator
-		});
-		setState("GROUND");
-	}
-}
-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_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 };
+export * from "./constants.js";
+export { parse } from "./parse.escaped.js";
+export { parser } from "./parse.js";
+export { tokenize, tokenizer } from "./tokenize.escaped.js";

package/dist/index.d.ts

@@ -1,7 +1,5 @@
-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_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 };
+export * from "./constants.ts";
+export { parse, parser } from "./parse.ts";
+export { tokenize, tokenizer } from "./tokenize.ts";
+export type { CODE, CONTROL_CODE, TEXT, TOKEN } from "./types.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACpD,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,3 +1,3 @@
-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_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 };
+export * from "./constants.js";
+export { parse, parser } from "./parse.js";
+export { tokenize, tokenizer } from "./tokenize.js";

package/dist/parse.d.ts

@@ -0,0 +1,4 @@
+import type { CODE, TOKEN } from "./types.ts";
+export declare function parser(tokens: IterableIterator<TOKEN>): IterableIterator<CODE>;
+export declare function parse(input: string): CODE[];
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAE9C,wBAAiB,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAsC/E;AA2BD,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,CA2C3C"}

package/dist/parse.escaped.d.ts

@@ -0,0 +1,3 @@
+import type { CODE } from "./types.ts";
+export declare function parse(input: string): CODE[];
+//# sourceMappingURL=parse.escaped.d.ts.map

package/dist/parse.escaped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.escaped.d.ts","sourceRoot":"","sources":["../src/parse.escaped.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,CAE3C"}

package/dist/parse.escaped.js

@@ -0,0 +1,5 @@
+import { parser } from "./parse.js";
+import { tokenizer } from "./tokenize.escaped.js";
+export function parse(input) {
+    return Array.from(parser(tokenizer(input)));
+}

package/dist/parse.js

@@ -0,0 +1,109 @@
+import { APC_CODE, APC_OPEN, CODE_TYPES, CSI_CODE, DCS_CODE, DCS_OPEN, ESC_CODE, OSC_CODE, PM_CODE, PM_OPEN, SOS_CODE, SOS_OPEN, TOKEN_TYPES, } from "./constants.js";
+import { parseAPC } from "./parsers/apc.js";
+import { parseCSI } from "./parsers/csi.js";
+import { parseDCS } from "./parsers/dcs.js";
+import { parseESC } from "./parsers/esc.js";
+import { parseOSC } from "./parsers/osc.js";
+import { parsePM } from "./parsers/pm.js";
+import { parseSOS } from "./parsers/sos.js";
+import { tokenize } from "./tokenize.js";
+export function* parser(tokens) {
+    let current = tokens.next();
+    while (!current.done) {
+        const token = current.value;
+        if (token.type === TOKEN_TYPES.TEXT) {
+            yield { type: CODE_TYPES.TEXT, pos: token.pos, raw: token.raw };
+            current = tokens.next();
+            continue;
+        }
+        if (token.type === TOKEN_TYPES.INTRODUCER) {
+            const introducer = token;
+            const data = [];
+            let final;
+            current = tokens.next();
+            while (!current.done) {
+                const nextToken = current.value;
+                if (nextToken.type === TOKEN_TYPES.DATA) {
+                    data.push(nextToken);
+                }
+                else if (nextToken.type === TOKEN_TYPES.FINAL) {
+                    final = nextToken;
+                    current = tokens.next();
+                    break;
+                }
+                else {
+                    break;
+                }
+                current = tokens.next();
+            }
+            yield emitCode(introducer, data, final);
+        }
+        else {
+            current = tokens.next();
+        }
+    }
+}
+function emitCode(introducer, data, final) {
+    switch (introducer.code) {
+        case CSI_CODE:
+            return parseCSI(introducer, data, final);
+        case OSC_CODE:
+            return parseOSC(introducer, data, final);
+        case DCS_CODE:
+        case DCS_OPEN:
+            return parseDCS(introducer, data, final);
+        case APC_CODE:
+        case APC_OPEN:
+            return parseAPC(introducer, data, final);
+        case PM_CODE:
+        case PM_OPEN:
+            return parsePM(introducer, data, final);
+        case SOS_CODE:
+        case SOS_OPEN:
+            return parseSOS(introducer, data, final);
+        case ESC_CODE:
+            return parseESC(introducer, data, final);
+        default:
+            return { type: CODE_TYPES.TEXT, pos: introducer.pos, raw: introducer.raw };
+    }
+}
+export function parse(input) {
+    const tokens = tokenize(input);
+    const result = [];
+    let ti = 0;
+    const tlen = tokens.length;
+    while (ti < tlen) {
+        const token = tokens[ti];
+        if (token.type === TOKEN_TYPES.TEXT) {
+            result.push({ type: CODE_TYPES.TEXT, pos: token.pos, raw: token.raw });
+            ti++;
+            continue;
+        }
+        if (token.type === TOKEN_TYPES.INTRODUCER) {
+            const introducer = token;
+            const data = [];
+            let final;
+            ti++;
+            while (ti < tlen) {
+                const nextToken = tokens[ti];
+                if (nextToken.type === TOKEN_TYPES.DATA) {
+                    data.push(nextToken);
+                }
+                else if (nextToken.type === TOKEN_TYPES.FINAL) {
+                    final = nextToken;
+                    ti++;
+                    break;
+                }
+                else {
+                    break;
+                }
+                ti++;
+            }
+            result.push(emitCode(introducer, data, final));
+        }
+        else {
+            ti++;
+        }
+    }
+    return result;
+}

package/dist/parsers/apc.d.ts

@@ -0,0 +1,3 @@
+import type { CODE, TOKEN } from "../types.ts";
+export declare function parseAPC(introducer: TOKEN, dataTokens: TOKEN[], final: TOKEN | undefined): CODE;
+//# sourceMappingURL=apc.d.ts.map

package/dist/parsers/apc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apc.d.ts","sourceRoot":"","sources":["../../src/parsers/apc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAE/C,wBAAgB,QAAQ,CAAC,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,IAAI,CAI/F"}

package/dist/parsers/apc.js

@@ -0,0 +1,6 @@
+import { CODE_TYPES } from "../constants.js";
+export 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] : [] };
+}

package/dist/parsers/csi.d.ts

@@ -0,0 +1,3 @@
+import type { CODE, TOKEN } from "../types.ts";
+export declare function parseCSI(introducer: TOKEN, dataTokens: TOKEN[], final: TOKEN | undefined): CODE;
+//# sourceMappingURL=csi.d.ts.map

package/dist/parsers/csi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csi.d.ts","sourceRoot":"","sources":["../../src/parsers/csi.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAqB,KAAK,EAAE,MAAM,aAAa,CAAC;AAElE,wBAAgB,QAAQ,CAAC,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,IAAI,CAsE/F"}

package/dist/parsers/csi.js

@@ -0,0 +1,63 @@
+import { CODE_TYPES, PRIVATE_OPENERS } from "../constants.js";
+export function parseCSI(introducer, dataTokens, final) {
+    const data = dataTokens.length === 1 ? dataTokens[0].raw : dataTokens.length === 0 ? "" : dataTokens.map(t => t.raw).join("");
+    const finalRaw = final?.raw ?? "";
+    const raw = introducer.raw + data + finalRaw;
+    const params = [];
+    let type = CODE_TYPES.CSI;
+    let paramEnd = 0;
+    if (data) {
+        while (paramEnd < data.length) {
+            const charCode = data.charCodeAt(paramEnd);
+            if (charCode < 0x30 || charCode > 0x3f)
+                break;
+            paramEnd++;
+        }
+    }
+    const paramSection = paramEnd > 0 ? data.substring(0, paramEnd) : "";
+    const intermediates = paramEnd < data.length ? data.substring(paramEnd) : "";
+    if (paramSection) {
+        let start = 0;
+        for (let i = 0; i <= paramSection.length; i++) {
+            if (i === paramSection.length || paramSection.charCodeAt(i) === 0x3b || paramSection.charCodeAt(i) === 0x3a) {
+                params.push(i > start ? paramSection.substring(start, i) : "0");
+                start = i + 1;
+            }
+        }
+    }
+    const command = intermediates + finalRaw;
+    const first = params[0];
+    if (first !== undefined && first.charCodeAt(0) === 0x3f) {
+        type = CODE_TYPES.DEC;
+        if (first.length > 1)
+            params[0] = first.substring(1);
+        else
+            params.shift();
+        return { type, pos: introducer.pos, raw, command, params };
+    }
+    for (const param of params) {
+        if (param.length > 0 && PRIVATE_OPENERS.has(param[0])) {
+            type = CODE_TYPES.PRIVATE;
+            const privateCommand = param[0] + command;
+            for (let i = 0; i < params.length; i++) {
+                if (params[i].length > 0 && PRIVATE_OPENERS.has(params[i][0])) {
+                    if (params[i].length > 1) {
+                        params[i] = params[i].substring(1);
+                    }
+                    else {
+                        params.splice(i, 1);
+                    }
+                    break;
+                }
+            }
+            return { type, pos: introducer.pos, raw, command: privateCommand, params };
+        }
+    }
+    if (command === "m" && params.length === 5 && params[1] === "2" && (first === "38" || first === "48")) {
+        params.splice(2, 0, "0");
+    }
+    if (command === "r" && params.length === 2 && params[1] === "0") {
+        params[1] = "-1";
+    }
+    return { type, pos: introducer.pos, raw, command, params };
+}