tmux-agent 0.1.0

package/dist/lib/tmux/sendKeys.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKeyExpression = parseKeyExpression;
+exports.classifySendInput = classifySendInput;
+exports.sendKeys = sendKeys;
+const exec_1 = require("./exec");
+const paste_1 = require("./paste");
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseKeyExpression(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (trimmed.toLowerCase() === "enter") {
+        return "Enter";
+    }
+    const ctrlMatch = trimmed.match(/^Ctrl\+([A-Za-z])$/);
+    if (ctrlMatch) {
+        return `C-${ctrlMatch[1].toLowerCase()}`;
+    }
+    return null;
+}
+function classifySendInput(input, noEnter) {
+    const tmuxKey = parseKeyExpression(input);
+    if (tmuxKey) {
+        return { mode: "keys", tmuxKey, enter: false };
+    }
+    return { mode: "text", enter: !noEnter };
+}
+async function sendKeys(paneId, input, options = {}) {
+    const { mode, tmuxKey, enter } = classifySendInput(input, options.noEnter ?? false);
+    if (mode === "keys" && tmuxKey) {
+        await (0, exec_1.tmuxExec)(["send-keys", "-t", paneId, tmuxKey]);
+        return { mode, text: input, enter };
+    }
+    await (0, paste_1.pasteText)(paneId, input);
+    if (enter) {
+        const enterDelayMs = options.enterDelayMs ?? 0;
+        if (enterDelayMs > 0) {
+            await sleep(enterDelayMs);
+        }
+        await (0, exec_1.tmuxExec)(["send-keys", "-t", paneId, "Enter"]);
+    }
+    return { mode: "text", text: input, enter };
+}

package/dist/lib/tmux/session.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSessionId = resolveSessionId;
+const exec_1 = require("./exec");
+async function resolveSessionId(sessionName) {
+    const result = await (0, exec_1.tmuxExec)([
+        "list-sessions",
+        "-F",
+        "#{session_name}\t#{session_id}"
+    ]);
+    const lines = result.stdout.trim().split(/\r?\n/).filter(Boolean);
+    let fallbackId;
+    for (const line of lines) {
+        const [name, id] = line.split("\t");
+        if (name === sessionName && id) {
+            return id;
+        }
+        if (!fallbackId && id && name.endsWith(sessionName)) {
+            const prefix = name.slice(0, name.length - sessionName.length);
+            if (/^\d+-$/.test(prefix)) {
+                fallbackId = id;
+            }
+        }
+    }
+    if (fallbackId) {
+        return fallbackId;
+    }
+    throw new Error(`can't find session: ${sessionName}`);
+}

package/dist/lib/tmux/snapshotPanes.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotPanes = snapshotPanes;
+const exec_1 = require("./exec");
+const session_1 = require("./session");
+async function snapshotPanes(options) {
+    const sessionId = options.session
+        ? await (0, session_1.resolveSessionId)(options.session)
+        : undefined;
+    const args = ["list-panes"];
+    if (options.windowId) {
+        args.push("-t", options.windowId);
+    }
+    else {
+        args.push("-a");
+    }
+    args.push("-F", "#{session_id}\t#{pane_index}\t#{pane_id}\t#{pane_pid}\t#{pane_current_command}\t#{pane_title}\t#{pane_active}\t#{pane_dead}\t#{window_id}");
+    const result = await (0, exec_1.tmuxExec)(args);
+    const lines = result.stdout.trim().split(/\r?\n/).filter(Boolean);
+    return lines
+        .map((line) => {
+        const [lineSessionId, idxRaw, id, pidRaw, command, title, activeRaw, deadRaw, windowId] = line.split("\t");
+        const idx = Number(idxRaw);
+        const pidValue = Number(pidRaw);
+        const pid = Number.isFinite(pidValue) ? pidValue : undefined;
+        let status = "idle";
+        if (deadRaw === "1") {
+            status = "dead";
+        }
+        else if (activeRaw === "1") {
+            status = "active";
+        }
+        return {
+            sessionId: lineSessionId,
+            idx,
+            id,
+            pid,
+            command,
+            title,
+            status,
+            windowId
+        };
+    })
+        .filter((pane) => (sessionId ? pane.sessionId === sessionId : true))
+        .map(({ sessionId: _sessionId, ...pane }) => pane);
+}

package/dist/lib/tmux/snapshotWindows.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotWindows = snapshotWindows;
+const exec_1 = require("./exec");
+const session_1 = require("./session");
+async function snapshotWindows(session) {
+    const sessionId = await (0, session_1.resolveSessionId)(session);
+    const result = await (0, exec_1.tmuxExec)([
+        "list-windows",
+        "-a",
+        "-F",
+        "#{session_id}\t#{window_index}\t#{window_id}\t#{window_name}\t#{window_active}"
+    ]);
+    const lines = result.stdout.trim().split(/\r?\n/).filter(Boolean);
+    return lines
+        .map((line) => {
+        const [lineSessionId, widxRaw, wid, name, activeRaw] = line.split("\t");
+        const widx = Number(widxRaw);
+        const status = activeRaw === "1" ? "active" : "inactive";
+        return { sessionId: lineSessionId, widx, wid, name, status };
+    })
+        .filter((window) => window.sessionId === sessionId)
+        .map(({ sessionId: _sessionId, ...window }) => window);
+}

package/dist/lib/tmux/windowOps.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.windowNew = windowNew;
+exports.windowRename = windowRename;
+exports.windowKill = windowKill;
+const exec_1 = require("./exec");
+async function windowNew(session, name) {
+    const args = [
+        "new-window",
+        "-P",
+        "-F",
+        "#{window_id}\t#{window_index}\t#{window_name}\t#{pane_id}",
+        "-t",
+        session,
+        "-n",
+        name
+    ];
+    const result = await (0, exec_1.tmuxExec)(args);
+    const [wid, widxRaw, windowName, paneId] = result.stdout.trim().split("\t");
+    return {
+        wid,
+        widx: Number(widxRaw),
+        name: windowName || name,
+        paneId
+    };
+}
+async function windowRename(windowId, name) {
+    await (0, exec_1.tmuxExec)(["rename-window", "-t", windowId, name]);
+}
+async function windowKill(windowId) {
+    await (0, exec_1.tmuxExec)(["kill-window", "-t", windowId]);
+}

package/dist/lib/ui/popupSelect.js

@@ -0,0 +1,432 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePopupSelectSpec = normalizePopupSelectSpec;
+exports.popupSelect = popupSelect;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const exec_1 = require("../tmux/exec");
+const popupSupport_1 = require("./popupSupport");
+function parseNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const num = Number(value.trim());
+        return Number.isFinite(num) ? num : null;
+    }
+    return null;
+}
+function parseBool(value, defaultValue) {
+    if (value === undefined || value === null) {
+        return defaultValue;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value !== 0;
+    }
+    if (typeof value === "string") {
+        const v = value.trim().toLowerCase();
+        if (["1", "true", "yes", "y", "on"].includes(v)) {
+            return true;
+        }
+        if (["0", "false", "no", "n", "off"].includes(v)) {
+            return false;
+        }
+    }
+    return defaultValue;
+}
+function normalizeTimeout(value, defaultMs) {
+    const raw = parseNumber(value);
+    const timeoutMs = raw === null ? defaultMs : Math.floor(raw);
+    if (timeoutMs <= 0) {
+        return null;
+    }
+    return timeoutMs;
+}
+function normalizeTimeoutFallback(value, fallback) {
+    const raw = parseNumber(value);
+    if (raw === null) {
+        return fallback;
+    }
+    const timeoutMs = Math.floor(raw);
+    if (timeoutMs <= 0) {
+        return null;
+    }
+    return timeoutMs;
+}
+function normalizePollInterval(value, defaultMs) {
+    const raw = parseNumber(value);
+    const interval = Math.floor(raw ?? defaultMs);
+    if (!Number.isFinite(interval)) {
+        return defaultMs;
+    }
+    return Math.max(50, Math.min(interval, 2000));
+}
+function parseSize(axis, value) {
+    if (value === undefined || value === null || value === "") {
+        return undefined;
+    }
+    if (typeof value === "number") {
+        const n = Math.floor(value);
+        return n > 0 ? n : undefined;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        if (trimmed.toLowerCase() === "auto") {
+            return undefined;
+        }
+        if (trimmed.endsWith("%")) {
+            const pctRaw = trimmed.slice(0, -1).trim();
+            const pct = Number(pctRaw);
+            if (!Number.isFinite(pct) || pct <= 0) {
+                throw new Error(`invalid ${axis}`);
+            }
+            return `${pct}%`;
+        }
+        const n = Number(trimmed);
+        if (!Number.isFinite(n) || n <= 0) {
+            throw new Error(`invalid ${axis}`);
+        }
+        return Math.floor(n);
+    }
+    return undefined;
+}
+function parseMode(value) {
+    const raw = typeof value === "string" ? value.trim().toLowerCase() : "";
+    if (raw === "multi") {
+        return "multi";
+    }
+    return "single";
+}
+function parseOutput(value) {
+    const raw = typeof value === "string" ? value.trim().toLowerCase() : "";
+    if (raw === "verbose") {
+        return "verbose";
+    }
+    return "minimal";
+}
+function parseChoices(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error("choices is required");
+    }
+    const out = [];
+    for (let i = 0; i < value.length; i += 1) {
+        const raw = value[i];
+        if (typeof raw === "string") {
+            const label = raw.trim();
+            if (!label) {
+                continue;
+            }
+            out.push({ label, value: label, detail: "" });
+            continue;
+        }
+        if (raw && typeof raw === "object") {
+            const label = String(raw.label ?? raw.value ?? "").trim();
+            const val = String(raw.value ?? raw.label ?? "").trim();
+            const detail = String(raw.detail ?? "").trim();
+            if (!label || !val) {
+                continue;
+            }
+            out.push({ label, value: val, detail });
+            continue;
+        }
+    }
+    if (out.length === 0) {
+        throw new Error("choices is empty");
+    }
+    return out;
+}
+function normalizePopupSelectSpec(spec) {
+    const mode = parseMode(spec.mode);
+    const timeoutMs = normalizeTimeout(spec.timeout_ms, 3600000);
+    const minSelectedRaw = parseNumber(spec.min_selected);
+    const minSelected = Math.max(0, Math.floor(minSelectedRaw ?? (mode === "multi" ? 0 : 1)));
+    const maxSelectedRaw = parseNumber(spec.max_selected);
+    const maxSelected = maxSelectedRaw === null ? null : Math.max(0, Math.floor(maxSelectedRaw));
+    const allowCustomInput = parseBool(spec.allow_custom_input, false);
+    const customInputKey = (spec.custom_input_key ?? "ctrl-e").trim() || "ctrl-e";
+    return {
+        mode,
+        title: String(spec.title ?? "Select").trim() || "Select",
+        message: String(spec.message ?? "").trim(),
+        prompt: String(spec.prompt ?? "> ").trim() || "> ",
+        preview: String(spec.preview ?? "").trim(),
+        width: parseSize("width", spec.width),
+        height: parseSize("height", spec.height),
+        timeoutMs,
+        waitForFocusTimeoutMs: normalizeTimeoutFallback(spec.wait_for_focus_timeout_ms, timeoutMs),
+        waitForResultTimeoutMs: normalizeTimeoutFallback(spec.wait_for_result_timeout_ms, timeoutMs),
+        focusPollIntervalMs: normalizePollInterval(spec.focus_poll_interval_ms, 250),
+        output: parseOutput(spec.output),
+        minSelected,
+        maxSelected,
+        allowCustomInput,
+        customInputKey,
+        deferIfUnfocused: parseBool(spec.defer_if_unfocused, true),
+        deferUntilPaneActive: parseBool(spec.defer_until_pane_active, true),
+        startDelayMs: Math.max(0, Math.floor(parseNumber(spec.start_delay_ms) ?? 0)),
+        choices: parseChoices(spec.choices)
+    };
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function parseClientFlags(raw) {
+    return new Set(raw
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean));
+}
+async function listClients() {
+    const fmt = "#{client_name}\t#{client_tty}\t#{client_flags}\t#{session_id}\t#{session_name}\t#{window_id}\t#{pane_id}";
+    const result = await (0, exec_1.tmuxExec)(["list-clients", "-F", fmt]);
+    const lines = result.stdout.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const clients = [];
+    for (const line of lines) {
+        const parts = line.split("\t");
+        if (parts.length !== 7) {
+            continue;
+        }
+        const [name, tty, flagsRaw, sessionId, sessionName, windowId, paneId] = parts.map((part) => part.trim());
+        if (!name) {
+            continue;
+        }
+        clients.push({
+            name,
+            tty,
+            flags: parseClientFlags(flagsRaw),
+            sessionId,
+            sessionName,
+            windowId,
+            paneId
+        });
+    }
+    return clients;
+}
+function pickFrontClient(clients) {
+    const focused = clients.find((c) => c.flags.has("focused"));
+    if (focused) {
+        return focused;
+    }
+    if (clients.length === 1) {
+        return clients[0];
+    }
+    return null;
+}
+function pickClientForOrigin(clients, origin, options) {
+    const front = pickFrontClient(clients);
+    if (options.requirePaneActive) {
+        if (front && front.paneId === origin.paneId) {
+            return front;
+        }
+        for (const client of clients) {
+            if (client.paneId === origin.paneId) {
+                return client;
+            }
+        }
+        return null;
+    }
+    if (front && front.windowId === origin.windowId) {
+        return front;
+    }
+    for (const client of clients) {
+        if (client.windowId === origin.windowId) {
+            return client;
+        }
+    }
+    return null;
+}
+async function getPaneWindowId(paneId) {
+    const result = await (0, exec_1.tmuxExec)(["display-message", "-p", "-t", paneId, "#{window_id}"]);
+    const windowId = result.stdout.trim();
+    if (!windowId) {
+        throw new Error("failed to resolve origin window");
+    }
+    return windowId;
+}
+async function resolvePopupClientTarget(origin, spec) {
+    const started = Date.now();
+    const requirePaneActive = spec.deferUntilPaneActive;
+    while (true) {
+        const clients = await listClients();
+        const candidate = pickClientForOrigin(clients, origin, { requirePaneActive });
+        if (candidate) {
+            return candidate.name;
+        }
+        if (!spec.deferIfUnfocused) {
+            return pickFrontClient(clients)?.name;
+        }
+        if (spec.waitForFocusTimeoutMs !== null && Date.now() - started >= spec.waitForFocusTimeoutMs) {
+            throw new Error("ui select timed out waiting for focus");
+        }
+        await sleep(spec.focusPollIntervalMs);
+    }
+}
+function splitChoiceLine(line) {
+    const [label, value, detail] = line.split("\t");
+    if (!label || !value) {
+        return null;
+    }
+    return { label, value, detail: detail ?? "" };
+}
+function parseFzfOutput(raw, spec) {
+    const lines = raw
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length > 0);
+    if (!spec.allowCustomInput) {
+        const values = [];
+        for (const line of lines) {
+            const parsed = splitChoiceLine(line);
+            if (!parsed) {
+                continue;
+            }
+            values.push(parsed.value);
+        }
+        return { selected: values };
+    }
+    const query = lines[0] ?? "";
+    const key = lines[1] ?? "";
+    const selectedLines = lines.slice(2);
+    if (key && key.toLowerCase() === spec.customInputKey.toLowerCase()) {
+        const trimmed = query.trim();
+        if (!trimmed) {
+            throw new Error("custom input is empty");
+        }
+        return { selected: [], customInput: trimmed, via: spec.customInputKey };
+    }
+    const values = [];
+    for (const line of selectedLines) {
+        const parsed = splitChoiceLine(line);
+        if (!parsed) {
+            continue;
+        }
+        values.push(parsed.value);
+    }
+    return { selected: values, ...(query ? { query } : {}) };
+}
+async function popupSelect(spec) {
+    const support = await (0, popupSupport_1.checkPopupSupport)();
+    if (!support.ok) {
+        throw new Error(support.reason || "popup is not supported");
+    }
+    const paneId = String(process.env.TMUX_PANE || "").trim();
+    if (!paneId) {
+        throw new Error("ui select requires tmux client context; run inside tmux");
+    }
+    const normalized = normalizePopupSelectSpec(spec);
+    const originWindowId = await getPaneWindowId(paneId);
+    const clientTarget = await resolvePopupClientTarget({ windowId: originWindowId, paneId }, normalized);
+    if (normalized.startDelayMs > 0) {
+        await sleep(normalized.startDelayMs);
+    }
+    const tmpDir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), "agent-tmux-ui-"));
+    const inputPath = node_path_1.default.join(tmpDir, "choices.txt");
+    const outPath = node_path_1.default.join(tmpDir, "out.txt");
+    const codePath = node_path_1.default.join(tmpDir, "exit_code.txt");
+    const scriptPath = node_path_1.default.join(tmpDir, "popup.sh");
+    try {
+        const lines = normalized.choices
+            .map((choice) => `${choice.label}\t${choice.value}\t${choice.detail || ""}`)
+            .join("\n");
+        await node_fs_1.promises.writeFile(inputPath, `${lines}\n`, "utf8");
+        const fzfArgs = [];
+        fzfArgs.push("--delimiter=\t", "--with-nth=1,3", `--prompt=${normalized.prompt}`);
+        if (normalized.mode === "multi") {
+            fzfArgs.push("--multi");
+        }
+        if (normalized.allowCustomInput) {
+            fzfArgs.push("--print-query", `--expect=${normalized.customInputKey}`);
+        }
+        if (normalized.preview) {
+            fzfArgs.push(`--preview=${normalized.preview}`);
+        }
+        const script = `#!/usr/bin/env bash
+set -euo pipefail
+INPUT=${JSON.stringify(inputPath)}
+OUT=${JSON.stringify(outPath)}
+CODE=${JSON.stringify(codePath)}
+set +e
+cat "$INPUT" | fzf ${fzfArgs.map((arg) => JSON.stringify(arg)).join(" ")} > "$OUT"
+EC=$?
+set -e
+printf '%s' "$EC" > "$CODE"
+exit 0
+`;
+        await node_fs_1.promises.writeFile(scriptPath, script, { encoding: "utf8", mode: 0o700 });
+        const popupArgs = ["display-popup", "-E"];
+        if (clientTarget) {
+            popupArgs.push("-c", clientTarget);
+        }
+        popupArgs.push("-t", paneId, "-T", normalized.title);
+        if (normalized.width) {
+            popupArgs.push("-w", String(normalized.width));
+        }
+        if (normalized.height) {
+            popupArgs.push("-h", String(normalized.height));
+        }
+        popupArgs.push(`bash ${shellQuote(scriptPath)}`);
+        const popupPromise = (0, exec_1.tmuxExec)(popupArgs);
+        const timeoutMs = normalized.waitForResultTimeoutMs;
+        if (timeoutMs !== null) {
+            await Promise.race([
+                popupPromise,
+                (async () => {
+                    await sleep(timeoutMs);
+                    throw new Error("ui select timed out");
+                })()
+            ]);
+        }
+        else {
+            await popupPromise;
+        }
+        const exitCodeRaw = (await node_fs_1.promises.readFile(codePath, "utf8")).trim();
+        const exitCode = Number(exitCodeRaw);
+        if (!Number.isFinite(exitCode) || exitCode !== 0) {
+            throw new Error("ui select cancelled");
+        }
+        const rawOut = await node_fs_1.promises.readFile(outPath, "utf8");
+        const parsed = parseFzfOutput(rawOut, normalized);
+        const selectedValues = parsed.selected;
+        if (normalized.mode === "single" && selectedValues.length > 1) {
+            throw new Error("ui select returned multiple values for single mode");
+        }
+        if (normalized.mode === "single" && selectedValues.length === 0 && !parsed.customInput) {
+            throw new Error("no selection");
+        }
+        const count = parsed.customInput ? 1 : selectedValues.length;
+        if (normalized.mode === "multi") {
+            if (count < normalized.minSelected) {
+                throw new Error(`min_selected not satisfied: ${count} < ${normalized.minSelected}`);
+            }
+            if (normalized.maxSelected !== null && count > normalized.maxSelected) {
+                throw new Error(`max_selected exceeded: ${count} > ${normalized.maxSelected}`);
+            }
+        }
+        return {
+            mode: normalized.mode,
+            selectedValues,
+            ...(parsed.customInput ? { customInput: parsed.customInput, customInputVia: parsed.via } : {})
+        };
+    }
+    finally {
+        try {
+            await node_fs_1.promises.rm(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+}

package/dist/lib/ui/popupSupport.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPopupSupport = checkPopupSupport;
+const node_child_process_1 = require("node:child_process");
+function hasTmuxEnv() {
+    return Boolean(process.env.TMUX && process.env.TMUX_PANE);
+}
+async function runCommand(command, args) {
+    return await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args);
+        let stdout = "";
+        let stderr = "";
+        if (child.stdout) {
+            child.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+        }
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("close", (code) => {
+            const exitCode = code ?? 0;
+            if (exitCode !== 0) {
+                reject(new Error(stderr.trim() || stdout.trim() || `${command} failed`));
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+async function supportsDisplayPopup() {
+    try {
+        const output = await runCommand("tmux", ["list-commands"]);
+        return output.includes("display-popup");
+    }
+    catch {
+        return false;
+    }
+}
+async function hasFzf() {
+    try {
+        await runCommand("fzf", ["--version"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkPopupSupport() {
+    if (!hasTmuxEnv()) {
+        return {
+            ok: false,
+            reason: "ui select must run inside tmux (missing TMUX env)"
+        };
+    }
+    const popupSupported = await supportsDisplayPopup();
+    if (!popupSupported) {
+        return {
+            ok: false,
+            reason: "tmux does not support display-popup"
+        };
+    }
+    const fzfOk = await hasFzf();
+    if (!fzfOk) {
+        return {
+            ok: false,
+            reason: "fzf is required for ui select"
+        };
+    }
+    return { ok: true };
+}