@ansi-tools/parser 1.0.12 → 1.0.13

package/dist/parse-BCjxFvJh.js

@@ -1,530 +0,0 @@
-//#region src/constants.ts
-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([
-	"<",
-	"=",
-	">"
-]);
-const DCS_OPEN = "P";
-const APC_OPEN = "_";
-const SOS_OPEN = "^";
-const PM_OPEN = "X";
-const STRING_OPENERS = new Set([
-	DCS_OPEN,
-	APC_OPEN,
-	SOS_OPEN,
-	PM_OPEN
-]);
-const INTERRUPTERS = new Set([
-	CAN,
-	SUB,
-	ESC,
-	CSI,
-	OSC,
-	DCS,
-	APC,
-	PM,
-	SOS
-]);
-const C0_INTERRUPTERS = new Set([CAN, SUB]);
-const PARAM_SEPARATOR = /[;:]/;
-const TOKEN_TYPES = {
-	TEXT: "TEXT",
-	INTRODUCER: "INTRODUCER",
-	DATA: "DATA",
-	FINAL: "FINAL"
-};
-const CODE_TYPES = {
-	CSI: "CSI",
-	DCS: "DCS",
-	DEC: "DEC",
-	ESC: "ESC",
-	OSC: "OSC",
-	PRIVATE: "PRIVATE",
-	SGR: "SGR",
-	STRING: "STRING",
-	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) {
-	const data = dataTokens.map((t) => t.raw).join("");
-	const raw = introducer.raw + data + (final?.raw || "");
-	const params = [];
-	let type = CODE_TYPES.CSI;
-	let intermediates = "";
-	let paramSection = "";
-	if (data) {
-		let i = 0;
-		while (i < data.length) {
-			const charCode = data.charCodeAt(i);
-			if (charCode >= 48 && charCode <= 63) {
-				paramSection += data[i];
-				i++;
-			} else break;
-		}
-		intermediates = data.slice(i);
-	}
-	if (paramSection) for (const part of paramSection.split(PARAM_SEPARATOR)) params.push(part || "0");
-	const command = intermediates + (final?.raw ?? "");
-	const start = params[0];
-	if (start?.startsWith("?")) {
-		type = CODE_TYPES.DEC;
-		if (start.length > 1) params[0] = start.slice(1);
-		else params.shift();
-		return {
-			type,
-			pos: introducer.pos,
-			raw,
-			command,
-			params
-		};
-	}
-	for (const param of params) if (param && 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] && params[i].length > 0 && PRIVATE_OPENERS.has(params[i][0])) {
-			if (params[i].length > 1) params[i] = params[i].slice(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" && (start === "38" || start === "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
-	};
-}
-
-//#endregion
-//#region src/parsers/dcs.ts
-const DCS_PATTERNS = new Map([
-	["$q", 2],
-	["+q", 2],
-	["+p", 2],
-	["|", 1],
-	["{", 1]
-]);
-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: introducer.pos,
-		raw,
-		command: "",
-		params: []
-	};
-	for (const [pattern, length] of DCS_PATTERNS) if (data.startsWith(pattern)) {
-		const remainder = data.slice(length);
-		const params = [];
-		if (remainder) for (const part of remainder.split(PARAM_SEPARATOR)) params.push(part || "-1");
-		return {
-			type: CODE_TYPES.DCS,
-			pos: introducer.pos,
-			raw,
-			command: pattern,
-			params
-		};
-	}
-	return {
-		type: CODE_TYPES.DCS,
-		pos: introducer.pos,
-		raw,
-		command: "",
-		params: [data]
-	};
-}
-
-//#endregion
-//#region src/parsers/esc.ts
-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: introducer.pos,
-		raw,
-		command,
-		params
-	};
-}
-
-//#endregion
-//#region src/parsers/osc.ts
-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: introducer.pos,
-		raw,
-		command: data,
-		params: []
-	};
-	const command = data.slice(0, semicolonIndex);
-	const remainder = data.slice(semicolonIndex + 1);
-	if (command === "1337") return {
-		type: CODE_TYPES.OSC,
-		pos: introducer.pos,
-		raw,
-		command,
-		params: [remainder]
-	};
-	const params = [];
-	if (remainder) {
-		let current = "";
-		for (let i = 0; i < remainder.length; i++) if (remainder[i] === ";") {
-			params.push(current);
-			current = "";
-		} else current += remainder[i];
-		params.push(current);
-	}
-	return {
-		type: CODE_TYPES.OSC,
-		pos: introducer.pos,
-		raw,
-		command,
-		params
-	};
-}
-
-//#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
-function emit$1(token) {
-	return token;
-}
-function* tokenizer(input) {
-	let i = 0;
-	let state = "GROUND";
-	let currentCode;
-	function setState(next, code) {
-		state = next;
-		currentCode = code;
-	}
-	while (i < input.length) if (state === "GROUND") {
-		const textStart = i;
-		let charCode = input.charCodeAt(i);
-		let char = input[i];
-		while (i < input.length) {
-			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,
-			pos: textStart,
-			raw: input.substring(textStart, i)
-		});
-		if (i < input.length) {
-			if (charCode === CSI || charCode === OSC || charCode === DCS || charCode === APC || charCode === PM || charCode === SOS) {
-				yield emit$1({
-					type: TOKEN_TYPES.INTRODUCER,
-					pos: i,
-					raw: char,
-					code: char
-				});
-				i++;
-				setState("SEQUENCE", charCode);
-			} else if (charCode === ESC) {
-				const next = input[i + 1];
-				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
-					});
-					i += 2;
-					setState("SEQUENCE", CSI);
-				} else if (nextCode === OSC_OPEN) {
-					yield emit$1({
-						type: TOKEN_TYPES.INTRODUCER,
-						pos: i,
-						raw: char + next,
-						code: OSC_CODE
-					});
-					i += 2;
-					setState("SEQUENCE", OSC);
-				} else if (STRING_OPENERS.has(next)) {
-					yield emit$1({
-						type: TOKEN_TYPES.INTRODUCER,
-						pos: i,
-						raw: char + next,
-						code: next
-					});
-					i += 2;
-					setState("SEQUENCE", nextCode);
-				} else if (next) {
-					let j = i + 1;
-					while (j < input.length && input.charCodeAt(j) >= 32 && input.charCodeAt(j) <= 47) j++;
-					if (j < input.length) {
-						const is = input.slice(i + 1, j);
-						if (is) yield emit$1({
-							type: TOKEN_TYPES.INTRODUCER,
-							pos: i,
-							raw: char + is,
-							code: ESC_CODE,
-							intermediate: is
-						});
-						else yield emit$1({
-							type: TOKEN_TYPES.INTRODUCER,
-							pos: i,
-							raw: char,
-							code: ESC_CODE
-						});
-						i = j;
-						setState("SEQUENCE", ESC);
-					} else i = j;
-				} else i++;
-			}
-		}
-	} else if (state === "SEQUENCE") {
-		const pos = i;
-		let data = "";
-		if (currentCode === CSI) while (i < input.length) {
-			const charCode = input.charCodeAt(i);
-			const char = input[i];
-			if (INTERRUPTERS.has(charCode)) {
-				if (data) yield emit$1({
-					type: TOKEN_TYPES.DATA,
-					pos,
-					raw: data
-				});
-				setState("GROUND");
-				if (C0_INTERRUPTERS.has(charCode)) i++;
-				break;
-			}
-			if (charCode >= 64 && charCode <= 126) {
-				if (data) yield emit$1({
-					type: TOKEN_TYPES.DATA,
-					pos,
-					raw: data
-				});
-				yield emit$1({
-					type: TOKEN_TYPES.FINAL,
-					pos: i,
-					raw: char
-				});
-				i++;
-				setState("GROUND");
-				break;
-			}
-			data += char;
-			i++;
-		}
-		else if (currentCode === ESC) {
-			if (i < input.length) {
-				const charCode = input.charCodeAt(i);
-				if (INTERRUPTERS.has(charCode)) {
-					setState("GROUND");
-					if (C0_INTERRUPTERS.has(charCode)) i++;
-				} else {
-					yield emit$1({
-						type: TOKEN_TYPES.FINAL,
-						pos: i,
-						raw: input[i]
-					});
-					i++;
-					setState("GROUND");
-				}
-			}
-		} else if (currentCode) while (i < input.length) {
-			const char = input[i];
-			const charCode = char.charCodeAt(0);
-			let terminator;
-			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,
-					pos,
-					raw: data
-				});
-				yield emit$1({
-					type: TOKEN_TYPES.FINAL,
-					pos: i,
-					raw: terminator
-				});
-				i += terminator.length;
-				setState("GROUND");
-				break;
-			}
-			if (INTERRUPTERS.has(charCode)) {
-				if (data) yield emit$1({
-					type: TOKEN_TYPES.DATA,
-					pos,
-					raw: data
-				});
-				setState("GROUND");
-				if (C0_INTERRUPTERS.has(charCode)) i++;
-				break;
-			}
-			data += char;
-			i++;
-		}
-		if (state === "SEQUENCE") setState("GROUND");
-	}
-}
-function tokenize(input) {
-	return Array.from(tokenizer(input));
-}
-
-//#endregion
-//#region src/parse.ts
-function emit(token) {
-	return token;
-}
-function* parser(tokens) {
-	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 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 if (nextToken.type === TOKEN_TYPES.INTRODUCER) break;
-				else if (nextToken.type === TOKEN_TYPES.TEXT) break;
-				current = tokens.next();
-			}
-			switch (introducer.code) {
-				case CSI_CODE:
-					yield emit(parseCSI(introducer, data, final));
-					break;
-				case OSC_CODE:
-					yield emit(parseOSC(introducer, data, final));
-					break;
-				case DCS_CODE:
-				case DCS_OPEN:
-					yield emit(parseDCS(introducer, data, final));
-					break;
-				case APC_CODE:
-				case APC_OPEN:
-					yield emit(parseAPC(introducer, data, final));
-					break;
-				case PM_CODE:
-				case PM_OPEN:
-					yield emit(parsePM(introducer, data, final));
-					break;
-				case SOS_CODE:
-				case SOS_OPEN:
-					yield emit(parseSOS(introducer, data, final));
-					break;
-				case ESC_CODE:
-					yield emit(parseESC(introducer, data, final));
-					break;
-			}
-		} else current = tokens.next();
-	}
-}
-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 };

package/dist/parse-BzJl6pBN.d.ts

@@ -1,85 +0,0 @@
-//#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 };