mcp-for-i 0.1.0

package/dist/ibmi/Search.js

@@ -0,0 +1,135 @@
+import { Tools } from "./Tools.js";
+export var Search;
+(function (Search) {
+    function parseHitPath(hit) {
+        const parts = hit.path.split('/');
+        if (parts.length === 4) {
+            parts.shift();
+        }
+        return {
+            library: parts[0],
+            file: parts[1],
+            name: parts[2],
+            extension: ''
+        };
+    }
+    async function searchMembers(connection, library, sourceFile, searchTerm, members, readOnly) {
+        let detailedMembers;
+        let memberFilter;
+        const pfgrep = connection.remoteFeatures.pfgrep;
+        if (typeof members === `string`) {
+            if (!isSafeMemberToken(members)) {
+                throw new Error(`Invalid members filter: ${members}`);
+            }
+            memberFilter = `${members}.MBR`;
+        }
+        else if (Array.isArray(members)) {
+            if (members.length > 1000) {
+                detailedMembers = members;
+                memberFilter = "*.MBR";
+            }
+            else {
+                members.forEach(member => {
+                    if (!isSafeMemberToken(member.name)) {
+                        throw new Error(`Invalid member name in filter: ${member.name}`);
+                    }
+                });
+                memberFilter = members.map(member => `${member.name}.MBR`).join(` `);
+            }
+        }
+        const command = pfgrep
+            ? `${pfgrep} -inHr -F "${sanitizeSearchTerm(searchTerm)}" ${memberFilter}`
+            : `/usr/bin/grep -inHR -F "${sanitizeSearchTerm(searchTerm)}" ${memberFilter}`;
+        const result = await connection.sendCommand({
+            command,
+            directory: `/QSYS.LIB/${library}.LIB/${sourceFile}.FILE`
+        });
+        if (!result.stderr) {
+            let hits = parseGrepOutput(result.stdout || '', readOnly);
+            if (detailedMembers) {
+                hits = hits.filter(hit => {
+                    const hitMember = parseHitPath(hit);
+                    return detailedMembers.some(member => member.name === hitMember.name && member.library === hitMember.library && member.file === hitMember.file);
+                });
+            }
+            return { term: searchTerm, hits };
+        }
+        throw new Error(result.stderr || "Search failed");
+    }
+    Search.searchMembers = searchMembers;
+    async function searchIFS(connection, path, searchTerm) {
+        const grep = connection.remoteFeatures.grep;
+        if (!grep)
+            throw new Error("Grep must be installed on the remote system.");
+        const grepRes = await connection.sendCommand({
+            command: `${grep} -inr -F -f - ${Tools.escapePath(path)}`,
+            stdin: searchTerm
+        });
+        if (grepRes.code === 0) {
+            return { term: searchTerm, hits: parseGrepOutput(grepRes.stdout) };
+        }
+        // grep returns exit code 1 when no matches are found
+        if (grepRes.code === 1 && !grepRes.stderr) {
+            return { term: searchTerm, hits: [] };
+        }
+    }
+    Search.searchIFS = searchIFS;
+    async function findIFS(connection, path, findTerm) {
+        const find = connection.remoteFeatures.find;
+        if (!find)
+            throw new Error("Find must be installed on the remote system.");
+        const findRes = await connection.sendCommand({
+            command: `${find} ${Tools.escapePath(path)} -type f -iname ${Tools.shellQuote(`*${findTerm}*`)} -print`
+        });
+        if (findRes.code === 0) {
+            if (findRes.stdout) {
+                return { term: findTerm, hits: parseFindOutput(findRes.stdout) };
+            }
+            return { term: findTerm, hits: [] };
+        }
+    }
+    Search.findIFS = findIFS;
+    function parseFindOutput(output, readonly, pathTransformer) {
+        const results = [];
+        for (const line of output.split('\n')) {
+            const path = pathTransformer?.(line) || line;
+            results.push(results.find(r => r.path === path) || { path, readonly, lines: [] });
+        }
+        return results;
+    }
+    function parseGrepOutput(output, readonly, pathTransformer) {
+        const results = [];
+        for (const line of output.split('\n')) {
+            if (line && !line.startsWith(`Binary`)) {
+                const parts = line.split(`:`);
+                const path = pathTransformer?.(parts[0]) || parts[0];
+                let result = results.find(r => r.path === path);
+                if (!result) {
+                    result = { path, lines: [], readonly };
+                    results.push(result);
+                }
+                const contentIndex = nthIndex(line, `:`, 2);
+                if (contentIndex >= 0) {
+                    const curContent = line.substring(contentIndex + 1);
+                    result.lines.push({ number: Number(parts[1]), content: curContent });
+                }
+            }
+        }
+        return results;
+    }
+    function sanitizeSearchTerm(searchTerm) {
+        return searchTerm.replace(/\\/g, `\\\\`).replace(/"/g, `\\"`);
+    }
+    function isSafeMemberToken(name) {
+        return /^[A-Za-z0-9_*#]+$/.test(name);
+    }
+    function nthIndex(aString, pattern, n) {
+        let index = -1;
+        while (n-- && index++ < aString.length) {
+            index = aString.indexOf(pattern, index);
+            if (index < 0)
+                break;
+        }
+        return index;
+    }
+})(Search || (Search = {}));

package/dist/ibmi/Tools.js

@@ -0,0 +1,188 @@
+import path from "path";
+export var Tools;
+(function (Tools) {
+    class SqlError extends Error {
+        sqlstate = "0";
+        constructor(message) {
+            super(message);
+        }
+    }
+    Tools.SqlError = SqlError;
+    function db2Parse(output, input) {
+        let gotHeaders = false;
+        let figuredLengths = false;
+        let iiErrorMessage = false;
+        const data = output.split(`\n`).filter(line => {
+            const trimmed = line.trim();
+            return trimmed !== `DB2>` &&
+                !trimmed.startsWith(`DB20`) &&
+                !/COMMAND .+ COMPLETED WITH EXIT STATUS \d+/.test(trimmed) &&
+                trimmed !== `?>`;
+        });
+        if (!data[data.length - 1]) {
+            data.pop();
+        }
+        let headers = [];
+        let SQLSTATE = "";
+        const rows = [];
+        data.forEach((line, index) => {
+            const trimmed = line.trim();
+            if (trimmed.length === 0 && iiErrorMessage)
+                iiErrorMessage = false;
+            if (trimmed.length === 0 || index === data.length - 1)
+                return;
+            if (trimmed === `**** CLI ERROR *****`) {
+                iiErrorMessage = true;
+                if (data.length > index + 3) {
+                    SQLSTATE = data[index + 1].trim();
+                    if (SQLSTATE.includes(`:`)) {
+                        SQLSTATE = SQLSTATE.split(`:`)[1].trim();
+                    }
+                    if (!SQLSTATE.startsWith(`01`)) {
+                        const errorMessage = data[index + 3] ? data[index + 3].trim() : `Unknown error`;
+                        let sqlError = new SqlError(`${errorMessage} (${SQLSTATE})`);
+                        sqlError.sqlstate = SQLSTATE;
+                        sqlError.cause = input;
+                        throw sqlError;
+                    }
+                }
+                return;
+            }
+            if (iiErrorMessage)
+                return;
+            if (!gotHeaders) {
+                headers = line.split(` `)
+                    .filter(header => header.length > 0)
+                    .map(header => ({ name: header, from: 0, length: 0 }));
+                gotHeaders = true;
+            }
+            else if (!figuredLengths) {
+                let base = 0;
+                line.split(` `).forEach((header, idx) => {
+                    headers[idx].from = base;
+                    headers[idx].length = header.length;
+                    base += header.length + 1;
+                });
+                figuredLengths = true;
+            }
+            else {
+                let row = {};
+                let slideBytesBy = 0;
+                headers.forEach(header => {
+                    const fromPos = header.from - slideBytesBy;
+                    let strValue = line.substring(fromPos, fromPos + header.length);
+                    const extendedBytes = strValue
+                        .split(``)
+                        .map(c => (Buffer.byteLength(c) < 3 || c.charCodeAt(0) === 65533) ? 0 : 1)
+                        .reduce((a, b) => a + b, 0);
+                    slideBytesBy += extendedBytes;
+                    if (extendedBytes > 0) {
+                        strValue = strValue.substring(0, strValue.length - extendedBytes);
+                    }
+                    let realValue = strValue.trimEnd();
+                    if (realValue.startsWith(` `)) {
+                        const asNumber = Number(strValue.trim());
+                        if (!isNaN(asNumber))
+                            realValue = asNumber;
+                    }
+                    else if (realValue === `-`) {
+                        realValue = null;
+                    }
+                    row[header.name] = realValue;
+                });
+                rows.push(row);
+            }
+        });
+        return rows;
+    }
+    Tools.db2Parse = db2Parse;
+    function bufferToUx(input) {
+        const hexString = Array.from(input)
+            .map(char => char.charCodeAt(0).toString(16).padStart(4, '0').toUpperCase())
+            .join('');
+        return `UX'${hexString}'`;
+    }
+    Tools.bufferToUx = bufferToUx;
+    function makeid(length = 8) {
+        let text = `O_`;
+        const possible = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`;
+        for (let i = 0; i < length; i++)
+            text += possible.charAt(Math.floor(Math.random() * possible.length));
+        return text;
+    }
+    Tools.makeid = makeid;
+    function qualifyPath(library, object, member, iasp, noEscape) {
+        [library, object] = Tools.sanitizeObjNamesForPase([library, object]);
+        member = member ? Tools.sanitizeObjNamesForPase([member])[0] : undefined;
+        iasp = iasp ? Tools.sanitizeObjNamesForPase([iasp])[0] : undefined;
+        const libraryPath = library === `QSYS` ? `QSYS.LIB` : `QSYS.LIB/${library}.LIB`;
+        const filePath = object ? `${object}.FILE` : '';
+        const memberPath = member ? `/${member}.MBR` : '';
+        const fullPath = `${libraryPath}/${filePath}${memberPath}`;
+        const result = (iasp && iasp.length > 0 ? `/${iasp}` : ``) + `/${noEscape ? fullPath : Tools.escapePath(fullPath)}`;
+        return result;
+    }
+    Tools.qualifyPath = qualifyPath;
+    function escapePath(Path, alreadyQuoted = false) {
+        if (alreadyQuoted) {
+            return Path.replace(/"|\$|\\/g, matched => `\\`.concat(matched));
+        }
+        else {
+            return Path.replace(/'|"|\$|&|\\| /g, matched => `\\`.concat(matched));
+        }
+    }
+    Tools.escapePath = escapePath;
+    function shellQuote(value) {
+        return `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
+    }
+    Tools.shellQuote = shellQuote;
+    function sqlEscapeLiteral(value) {
+        return String(value).replace(/'/g, "''");
+    }
+    Tools.sqlEscapeLiteral = sqlEscapeLiteral;
+    function sqlString(value) {
+        return `'${sqlEscapeLiteral(value)}'`;
+    }
+    Tools.sqlString = sqlString;
+    function isSafeQshToken(value) {
+        return /^[A-Za-z0-9_./*-]+$/.test(value);
+    }
+    Tools.isSafeQshToken = isSafeQshToken;
+    function sanitizeObjNamesForPase(libraries) {
+        return libraries.map(library => library.startsWith(`#`) ? `"${library}"` : library);
+    }
+    Tools.sanitizeObjNamesForPase = sanitizeObjNamesForPase;
+    function distinct(value, index, array) {
+        return array.indexOf(value) === index;
+    }
+    Tools.distinct = distinct;
+    function parseQSysPath(pathStr) {
+        const parts = pathStr.split('/').filter(Boolean);
+        if (parts.length > 3) {
+            return { asp: parts[0], library: parts[1], name: parts[2] };
+        }
+        return { library: parts[0], name: parts[1] };
+    }
+    Tools.parseQSysPath = parseQSysPath;
+    function fixSQL(statement, removeComments = false) {
+        let statements = statement.split("\n").map(line => {
+            if (line.startsWith('@')) {
+                line = `Call QSYS2.QCMDEXC('${line.substring(1, line.endsWith(";") ? line.length - 1 : undefined).replaceAll("'", "''")}');`;
+            }
+            return line.replaceAll("--", "\n--");
+        }).join(`\n`);
+        if (removeComments) {
+            statements = statements.split(`\n`).filter(l => !l.trim().startsWith(`--`)).join(`\n`);
+        }
+        return statements;
+    }
+    Tools.fixSQL = fixSQL;
+    function upperCaseName(value) {
+        return value ? value.toUpperCase() : value;
+    }
+    Tools.upperCaseName = upperCaseName;
+    function pathJoinPosix(...parts) {
+        return path.posix.join(...parts);
+    }
+    Tools.pathJoinPosix = pathJoinPosix;
+})(Tools || (Tools = {}));

package/dist/ibmi/client.js

@@ -0,0 +1,213 @@
+import { NodeSSH } from "node-ssh";
+import fs from "fs/promises";
+import path from "path";
+import { Tools } from "./Tools.js";
+import { IBMiContent } from "./IBMiContent.js";
+const LOCALE = "LC_ALL=EN_US.UTF-8";
+export class IBMiClient {
+    client;
+    content;
+    remoteFeatures = {};
+    defaultUserLibraries = [];
+    currentHost = "";
+    currentPort = 22;
+    currentUser = "";
+    currentConnectionName = "";
+    config;
+    constructor(config) {
+        this.config = config;
+        this.content = new IBMiContent(this);
+    }
+    getConfig() {
+        return this.config;
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    getTempRemote(prefix = "mcpfori") {
+        const tempDir = this.config.tempDir || "/tmp";
+        const name = `${prefix}_${Tools.makeid(8)}`;
+        return path.posix.join(tempDir, name);
+    }
+    upperCaseName(value) {
+        return Tools.upperCaseName(value);
+    }
+    validQsysName(name) {
+        if (!name)
+            return false;
+        if (name.length > 10)
+            return false;
+        const upper = this.upperCaseName(name);
+        return /^[A-Z][A-Z0-9_.]{0,9}$/.test(upper);
+    }
+    async connect(connection) {
+        this.currentHost = connection.host;
+        this.currentPort = connection.port;
+        this.currentUser = connection.username;
+        this.currentConnectionName = connection.name;
+        this.client = new NodeSSH();
+        await this.client.connect({
+            host: connection.host,
+            port: connection.port,
+            username: connection.username,
+            password: connection.password,
+            privateKey: connection.privateKeyPath ? await fs.readFile(connection.privateKeyPath, "utf8") : undefined,
+            keepaliveInterval: connection.keepaliveInterval,
+            readyTimeout: connection.readyTimeout,
+            debug: connection.sshDebug ? (msg) => process.stderr.write(`[ssh] ${msg}\n`) : undefined
+        });
+        await this.detectRemoteFeatures();
+        await this.loadDefaultLibraryList();
+    }
+    async disconnect() {
+        if (this.client) {
+            this.client.dispose();
+            this.client = undefined;
+        }
+    }
+    static escapeForShell(command) {
+        return command.replace(/\$/g, `\\$`);
+    }
+    async sendQsh(options) {
+        const stdin = options.command;
+        return this.sendCommand({
+            ...options,
+            command: `${LOCALE} /QOpenSys/usr/bin/qsh`,
+            stdin
+        });
+    }
+    async sendCommand(options) {
+        if (!this.client)
+            throw new Error("Not connected");
+        let commands = [];
+        if (options.env) {
+            commands.push(...Object.entries(options.env).map(([key, value]) => {
+                if (!(/^[A-Za-z_]\w*$/).test(key)) {
+                    throw new Error(`Invalid environment variable name: ${key}`);
+                }
+                return `export ${key}=${Tools.shellQuote(value || "")}`;
+            }));
+        }
+        commands.push(options.command);
+        const command = commands.join(" && ");
+        const directory = options.directory || this.config.homeDirectory || ".";
+        const result = await this.client.execCommand(command, {
+            cwd: directory,
+            stdin: options.stdin,
+            onStdout: options.onStdout,
+            onStderr: options.onStderr
+        });
+        if (result.code === null)
+            result.code = 0;
+        if (result.signal === "SIGABRT")
+            result.code = 127;
+        return {
+            code: result.code ?? 0,
+            signal: result.signal,
+            stdout: result.stdout || "",
+            stderr: result.stderr || "",
+            command
+        };
+    }
+    async runSQL(statements) {
+        const input = Tools.fixSQL(statements, true);
+        const ccsid = this.config.sqlJobCcsid ?? 1208;
+        const command = `${LOCALE} system "CHGJOB CCSID(${ccsid})" ; ${LOCALE} system "call QSYS/QZDFMDB2 PARM('-d' '-i' '-t')"`;
+        const output = await this.sendCommand({ command, stdin: input, env: { QIBM_PASE_CCSID: String(ccsid) } });
+        if (output.stderr && output.stderr.trim()) {
+            // QZDFMDB2 tends to emit errors in stdout, but keep stderr for debugging
+        }
+        if (output.stdout) {
+            return Tools.db2Parse(output.stdout, input);
+        }
+        return [];
+    }
+    async loadDefaultLibraryList() {
+        let currentLibrary = "QGPL";
+        this.defaultUserLibraries = [];
+        const userLibraries = [];
+        try {
+            const liblResult = await this.sendQsh({ command: `liblist` });
+            if (liblResult.code === 0) {
+                const lines = (liblResult.stdout || "").split(`\n`);
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    const lib = line.substring(0, 10).trim();
+                    const type = line.substring(12).trim();
+                    switch (type) {
+                        case `USR`:
+                            if (lib) {
+                                userLibraries.push(lib);
+                                // QSYS cannot be removed from the library list
+                                if (lib !== `QSYS`)
+                                    this.defaultUserLibraries.push(lib);
+                            }
+                            break;
+                        case `CUR`:
+                            if (lib)
+                                currentLibrary = lib;
+                            break;
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore, leave defaults
+        }
+        this.defaultUserLibraries = this.defaultUserLibraries.filter(Tools.distinct);
+        if (!this.config.currentLibrary) {
+            this.config.currentLibrary = currentLibrary;
+        }
+        if (!this.config.libraryList || this.config.libraryList.length === 0) {
+            this.config.libraryList = this.defaultUserLibraries.length > 0 ? [...this.defaultUserLibraries] : userLibraries.filter(Tools.distinct);
+        }
+        await this.validateConfiguredLibraryList();
+    }
+    async validateConfiguredLibraryList() {
+        const libs = (this.config.libraryList || []).map(l => this.upperCaseName(l));
+        if (libs.length === 0)
+            return;
+        const defaultLibs = Tools.sanitizeObjNamesForPase(this.defaultUserLibraries);
+        const sanitized = Tools.sanitizeObjNamesForPase(libs);
+        const commands = [
+            `liblist -d ${IBMiClient.escapeForShell(defaultLibs.join(` `))}`,
+            ...sanitized.map(lib => `liblist -a ${IBMiClient.escapeForShell(lib)}`)
+        ].join(`; `);
+        const result = await this.sendQsh({ command: commands });
+        const output = [result.stderr, result.stdout].filter(Boolean).join("\n");
+        if (output) {
+            const bad = libs.filter(lib => {
+                const re = new RegExp(`\\b${lib}\\b`, `i`);
+                return re.test(output);
+            });
+            if (bad.length > 0) {
+                this.config.libraryList = libs.filter(lib => !bad.includes(lib));
+            }
+        }
+    }
+    async detectRemoteFeatures() {
+        const featurePaths = {
+            grep: ["/QOpenSys/pkgs/bin/grep", "/usr/bin/grep"],
+            pfgrep: ["/QOpenSys/pkgs/bin/pfgrep"],
+            find: ["/QOpenSys/pkgs/bin/find", "/usr/bin/find"],
+            tar: ["/QOpenSys/pkgs/bin/tar", "/usr/bin/tar"],
+            attr: ["/QOpenSys/pkgs/bin/attr"],
+            iconv: ["/usr/bin/iconv", "/QOpenSys/pkgs/bin/iconv"],
+            setccsid: ["/QOpenSys/pkgs/bin/setccsid"],
+            stat: ["/QOpenSys/pkgs/bin/stat", "/usr/bin/stat"],
+            ls: ["/QOpenSys/pkgs/bin/ls", "/usr/bin/ls"]
+        };
+        for (const [name, paths] of Object.entries(featurePaths)) {
+            for (const p of paths) {
+                const res = await this.sendCommand({ command: `test -x ${p} && echo ${p}` });
+                if (res.stdout.trim()) {
+                    this.remoteFeatures[name] = p;
+                    break;
+                }
+            }
+        }
+        // QZDFMDB2.PGM is in QSYS/QZDFMDB2 by default; treat as present
+        this.remoteFeatures["QZDFMDB2.PGM"] = "/QSYS.LIB/QZDFMDB2.PGM";
+    }
+}

package/dist/ibmi/sourceDates.js

@@ -0,0 +1,60 @@
+import Crypto from "crypto";
+import { diffArrays } from "diff";
+export class SourceDateStore {
+    baseDates = new Map();
+    baseSource = new Map();
+    recordLengths = new Map();
+    setBase(key, source, dates, recordLength) {
+        this.baseSource.set(key, source);
+        this.baseDates.set(key, dates);
+        this.recordLengths.set(key, recordLength);
+    }
+    getRecordLength(key) {
+        return this.recordLengths.get(key);
+    }
+    getBaseSource(key) {
+        return this.baseSource.get(key);
+    }
+    getBaseDates(key) {
+        return this.baseDates.get(key);
+    }
+    calcNewSourceDates(key, newSource) {
+        const oldSource = this.baseSource.get(key) || "";
+        const oldDates = this.baseDates.get(key) || [];
+        const oldLines = oldSource.split("\n");
+        const newLines = newSource.split("\n");
+        // Use diff to map unchanged lines to old dates
+        const diff = diffArrays(oldLines, newLines);
+        const newDates = [];
+        const today = currentStamp();
+        let oldIndex = 0;
+        for (const part of diff) {
+            if (part.added) {
+                for (let i = 0; i < part.value.length; i++) {
+                    newDates.push(today);
+                }
+            }
+            else if (part.removed) {
+                oldIndex += part.value.length;
+            }
+            else {
+                for (let i = 0; i < part.value.length; i++) {
+                    const date = oldDates[oldIndex + i] || today;
+                    newDates.push(date);
+                }
+                oldIndex += part.value.length;
+            }
+        }
+        return newDates;
+    }
+}
+export function makeAliasName(key) {
+    return `MCP_${Crypto.createHash("sha1").update(key).digest("hex")}`.toUpperCase();
+}
+export function currentStamp() {
+    const today = new Date();
+    const mm = today.getMonth() + 1;
+    const dd = today.getDate();
+    const yy = String(today.getFullYear()).substring(2);
+    return [yy, (mm > 9 ? `` : `0`) + mm, (dd > 9 ? `` : `0`) + dd].join(``);
+}

package/dist/ibmi/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ibmi/variables.js

@@ -0,0 +1,53 @@
+export class Variables extends Map {
+    constructor(connection, variables) {
+        super(variables instanceof Map ? variables : variables ? Object.entries(variables) : new Map());
+        if (connection) {
+            const config = connection.getConfig();
+            this.set(`&BUILDLIB`, this.get(`&CURLIB`) || config.currentLibrary || "");
+            if (!this.has(`&CURLIB`)) {
+                this.set(`&CURLIB`, config.currentLibrary || "");
+            }
+            if (!this.has(`\\*CURLIB`)) {
+                this.set(`\\*CURLIB`, config.currentLibrary || "");
+            }
+            this.set(`&USERNAME`, connection.currentUser)
+                .set(`{usrprf}`, connection.currentUser)
+                .set(`&HOST`, connection.currentHost)
+                .set(`{host}`, connection.currentHost)
+                .set(`&HOME`, config.homeDirectory || ".")
+                .set(`&WORKDIR`, config.homeDirectory || ".");
+            for (const variable of config.customVariables || []) {
+                this.set(`&${variable.name.toUpperCase()}`, variable.value || "");
+            }
+        }
+    }
+    set(key, value) {
+        super.set(key, value);
+        this.expandVariables();
+        return this;
+    }
+    expandVariables() {
+        for (const [key, value] of this.entries()) {
+            super.set(key, this.expand(value, [key]));
+        }
+    }
+    expand(input, keysToOmit = []) {
+        for (const [key, value] of this.entries()) {
+            if (!keysToOmit.includes(key)) {
+                const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                input = input.replace(new RegExp(escapedKey, `g`), value);
+            }
+        }
+        return input;
+    }
+    toPaseVariables() {
+        const variables = {};
+        for (const [key, value] of this.entries()) {
+            const cleanKey = key.startsWith('&') ? key.substring(1) : key;
+            if ((/^[a-z_]\w*$/i).test(cleanKey)) {
+                variables[cleanKey] = value;
+            }
+        }
+        return variables;
+    }
+}