@ansi-tools/parser 1.0.12 → 1.0.13

package/dist/parsers/dcs.d.ts

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

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

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

package/dist/parsers/dcs.js

@@ -0,0 +1,26 @@
+import { CODE_TYPES, PARAM_SEPARATOR } from "../constants.js";
+const DCS_PATTERNS = new Map([
+    ["$q", 2],
+    ["+q", 2],
+    ["+p", 2],
+    ["|", 1],
+    ["{", 1],
+]);
+export 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] };
+}

package/dist/parsers/esc.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"esc.d.ts","sourceRoot":"","sources":["../../src/parsers/esc.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,CAAC,EAAE,KAAK,GAAG,IAAI,CAMpF"}

package/dist/parsers/esc.js

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

package/dist/parsers/osc.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"osc.d.ts","sourceRoot":"","sources":["../../src/parsers/osc.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,CA2B/F"}

package/dist/parsers/osc.js

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

package/dist/parsers/pm.d.ts

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

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

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

package/dist/parsers/pm.js

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

package/dist/parsers/sos.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sos.d.ts","sourceRoot":"","sources":["../../src/parsers/sos.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/sos.js

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

package/dist/tokenize.d.ts

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

package/dist/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../src/tokenize.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAoBxC,wBAAiB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAsIjE;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CA8I/C"}

package/dist/tokenize.escaped.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.escaped.d.ts","sourceRoot":"","sources":["../src/tokenize.escaped.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAgDxC,wBAAiB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAsPjE;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CAE/C"}

package/dist/tokenize.escaped.js

@@ -0,0 +1,295 @@
+import { BACKSLASH, BACKSLASH_CODE, CSI, CSI_CODE, CSI_OPEN_CODE, ESC, ESC_CODE, OSC, OSC_CODE, OSC_OPEN_CODE, STRING_OPENERS, TOKEN_TYPES, } from "./constants.js";
+const debug = false;
+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 = 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 = new Map();
+const INTRODUCER_FIRST_CHAR_CACHE = 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) {
+    if (debug)
+        console.log("token", token);
+    return token;
+}
+export 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) {
+        if (debug)
+            console.log(`state ${state} → ${next}`);
+        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;
+                        const matched = input.startsWith(seq, backslashIndex);
+                        if (matched) {
+                            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;
+                        const isSeqMatch = input.startsWith(seq, i);
+                        if (isSeqMatch) {
+                            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) >= 0x20 && input.charCodeAt(j) <= 0x2f)
+                                        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 >= 0x40 && charCode <= 0x7e) {
+                        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");
+        }
+    }
+}
+export function tokenize(input) {
+    return Array.from(tokenizer(input));
+}