@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/src/patch/plan.ts

@@ -1,317 +0,0 @@
-import { closeSync, constants as fsConstants, lstatSync, openSync, readFileSync } from "node:fs";
-import { basename } from "node:path";
-import { sandboxPath } from "../agent/tools/paths.js";
-import { parsePatch, type PatchHunk, type PatchOp } from "./parse.js";
-
-export interface PlannedFile {
-    kind: "add" | "delete" | "update";
-    relPath: string;
-    path: string;
-    moveRel?: string;
-    moveTo?: string;
-    existed: boolean;
-    origMode: number;
-    eol: "\n" | "\r\n";
-    oldContent?: string;
-    newContent?: string;
-    diff: string;
-    changedLines: number;
-}
-
-export interface PatchPlan {
-    files: PlannedFile[];
-    warnings: string[];
-}
-
-export type PlanResult = { ok: true; plan: PatchPlan } | { ok: false; output: string };
-
-export type PatchReview =
-    | { kind: "allow" }
-    | { kind: "deny"; reason: string }
-    | { kind: "pending"; reason: string; changedLines: number };
-
-export function planPatch(patch: string, cwd: string): PlanResult {
-    const parsed = parsePatch(patch);
-    if (parsed.ok === false)
-        return { ok: false, output: parsed.output };
-    const files: PlannedFile[] = [];
-    const warnings: string[] = [];
-    for (const op of parsed.ops) {
-        const planned = planOp(op, cwd, warnings);
-        if (planned.ok === false)
-            return { ok: false, output: planned.output };
-        files.push(planned.file);
-    }
-    return { ok: true, plan: { files, warnings } };
-}
-
-function planOp(op: PatchOp, cwd: string, warnings: string[]): { ok: true; file: PlannedFile } | { ok: false; output: string } {
-    try {
-        const path = sandboxPath(cwd, op.path);
-        if (op.kind === "add") {
-            if (lexists(path))
-                return { ok: false, output: `Add File target already exists: ${op.path}` };
-            const newContent = op.lines.length > 0 ? op.lines.join("\n") + "\n" : "";
-            return {
-                ok: true,
-                file: {
-                    kind: "add",
-                    relPath: op.path,
-                    path,
-                    existed: false,
-                    origMode: 0o644,
-                    eol: "\n",
-                    newContent,
-                    diff: makeDiff(null, op.path, "", newContent, "add"),
-                    changedLines: newContent.split("\n").filter(Boolean).length,
-                },
-            };
-        }
-        if (!lexists(path))
-            return { ok: false, output: `file not found: ${op.path}` };
-        const info = lstatSync(path);
-        if (info.isSymbolicLink())
-            return { ok: false, output: `refusing to patch a symbolic link: ${op.path}` };
-        if (!info.isFile())
-            return { ok: false, output: `not a regular file: ${op.path}` };
-        const oldContent = readNoFollow(path);
-        if (op.kind === "delete") {
-            return {
-                ok: true,
-                file: {
-                    kind: "delete",
-                    relPath: op.path,
-                    path,
-                    existed: true,
-                    origMode: info.mode & 0o777,
-                    eol: detectEol(oldContent),
-                    oldContent,
-                    diff: makeDiff(op.path, null, oldContent, "", "delete"),
-                    changedLines: oldContent.split(/\r?\n/).length,
-                },
-            };
-        }
-        const eol = detectEol(oldContent);
-        if (eol === "\n" && /\r\n/.test(oldContent))
-            warnings.push(`mixed line endings in ${op.path}; writing LF`);
-        let newContent = oldContent;
-        if (op.hunks.length > 0) {
-            const applied = applyHunks(oldContent, op.hunks);
-            if (applied.ok === false)
-                return applied;
-            newContent = applied.content;
-            if (eol === "\r\n")
-                newContent = newContent.replace(/\n/g, "\r\n");
-        }
-        let moveTo: string | undefined;
-        let moveRel: string | undefined;
-        if (op.moveTo) {
-            moveTo = sandboxPath(cwd, op.moveTo);
-            if (lexists(moveTo))
-                return { ok: false, output: `Move target already exists: ${op.moveTo}` };
-            moveRel = op.moveTo;
-        }
-        const diff = makeDiff(op.path, op.moveTo ?? op.path, oldContent, newContent, "update");
-        return {
-            ok: true,
-            file: {
-                kind: "update",
-                relPath: op.path,
-                path,
-                moveRel,
-                moveTo,
-                existed: true,
-                origMode: info.mode & 0o777,
-                eol,
-                oldContent,
-                newContent,
-                diff,
-                changedLines: countChangedLines(oldContent, newContent),
-            },
-        };
-    }
-    catch (err: any) {
-        return { ok: false, output: err?.message ?? String(err) };
-    }
-}
-
-export function reviewPatchPlan(plan: PatchPlan): PatchReview {
-    let changed = 0;
-    for (const file of plan.files) {
-        changed += file.changedLines;
-        if (isHardDenied(file.path))
-            return { kind: "deny", reason: `patch targets a protected path: ${file.relPath}` };
-        if (isSensitivePath(file.path))
-            return { kind: "pending", reason: `patch targets a sensitive path: ${file.relPath}`, changedLines: changed };
-    }
-    if (changed > 200)
-        return { kind: "pending", reason: `patch changes ${changed} lines (limit 200)`, changedLines: changed };
-    return { kind: "allow" };
-}
-
-function isHardDenied(path: string): boolean {
-    const normalized = path.replace(/\\/g, "/").toLowerCase();
-    const segments = normalized.split("/");
-    if (segments.includes(".ssh") || segments.includes(".gnupg"))
-        return true;
-    if (normalized.includes("/.git/hooks/"))
-        return true;
-    if (normalized.includes("/android/data/"))
-        return true;
-    const name = basename(normalized);
-    return name === "auth.json" || name === "trust.json";
-}
-
-function isSensitivePath(path: string): boolean {
-    const normalized = path.replace(/\\/g, "/").toLowerCase();
-    const name = basename(normalized);
-    return name === ".env" || name.startsWith(".env.") || /[.](pem|key|p12|pfx)$/.test(name) || normalized.includes("/.git/hooks/");
-}
-
-function lexists(path: string): boolean {
-    try {
-        lstatSync(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-
-function readNoFollow(path: string): string {
-    const flags = fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0);
-    const fd = openSync(path, flags);
-    try {
-        return readFileSync(fd, "utf8");
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-
-export function detectEol(content: string): "\n" | "\r\n" {
-    const crlf = (content.match(/\r\n/g) ?? []).length;
-    const lf = (content.match(/\n/g) ?? []).length;
-    return crlf > 0 && crlf === lf ? "\r\n" : "\n";
-}
-
-type ApplyHunksResult = { ok: true; content: string } | { ok: false; output: string };
-
-export function applyHunks(oldContent: string, hunks: PatchHunk[]): ApplyHunksResult {
-    const lines = oldContent.split(/\r?\n/);
-    let changed = false;
-    for (const hunk of hunks) {
-        const needle = hunk.lines.filter((line) => line.type !== "+").map((line) => line.text);
-        const replacement = hunk.lines.filter((line) => line.type !== "-").map((line) => line.text);
-        if (needle.length === 0) {
-            const at = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
-            lines.splice(at, 0, ...replacement);
-            changed = true;
-            continue;
-        }
-        const verdict = findHunk(lines, needle);
-        if (verdict.ok === false)
-            return verdict;
-        lines.splice(verdict.index, needle.length, ...replacement);
-        changed = true;
-    }
-    if (!changed)
-        return { ok: false, output: "patch made no changes" };
-    return { ok: true, content: lines.join("\n") };
-}
-
-function findHunk(lines: string[], needle: string[]): { ok: true; index: number } | { ok: false; output: string } {
-    for (let level = 0; level < 3; level += 1) {
-        const matches = matchAll(lines, needle, level);
-        if (matches.length === 0)
-            continue;
-        if (matches.length > 1) {
-            return {
-                ok: false,
-                output: `ambiguous patch context (${matches.length} candidates at lines ${matches.map((index) => index + 1).join(", ")}); add surrounding context`,
-            };
-        }
-        return { ok: true, index: matches[0] };
-    }
-    return { ok: false, output: `patch context not found: ${JSON.stringify(needle.slice(0, 4))}` };
-}
-
-function matchAll(lines: string[], needle: string[], level: number): number[] {
-    const found: number[] = [];
-    const wanted = needle.map((line) => normalizeLine(line, level));
-    for (let i = 0; i + needle.length <= lines.length; i += 1) {
-        let match = true;
-        for (let j = 0; j < needle.length; j += 1) {
-            if (normalizeLine(lines[i + j], level) !== wanted[j]) {
-                match = false;
-                break;
-            }
-        }
-        if (match)
-            found.push(i);
-    }
-    return found;
-}
-
-function normalizeLine(line: string, level: number): string {
-    if (level === 0)
-        return line;
-    if (level === 1)
-        return line.replace(/\s+$/, "");
-    return line.replace(/\s+/g, " ").trim();
-}
-
-export function makeDiff(oldPath: string | null, newPath: string | null, oldContent: string, newContent: string, kind: "add" | "delete" | "update"): string {
-    const oldLines = splitDiffLines(oldContent);
-    const newLines = splitDiffLines(newContent);
-    let prefix = 0;
-    while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
-        prefix += 1;
-    let suffix = 0;
-    while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix &&
-        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
-        suffix += 1;
-    const oldMiddle = oldLines.slice(prefix, oldLines.length - suffix);
-    const newMiddle = newLines.slice(prefix, newLines.length - suffix);
-    const oldStart = prefix + 1;
-    const newStart = prefix + 1;
-    const header = kind === "add"
-        ? `--- /dev/null\n+++ b/${newPath ?? ""}`
-        : kind === "delete"
-            ? `--- a/${oldPath ?? ""}\n+++ /dev/null`
-            : `--- a/${oldPath ?? ""}\n+++ b/${newPath ?? oldPath ?? ""}`;
-    const body = [
-        `@@ -${oldStart},${oldMiddle.length} +${newStart},${newMiddle.length} @@`,
-        ...oldMiddle.map((line) => "-" + line),
-        ...newMiddle.map((line) => "+" + line),
-    ];
-    return [header, ...body].join("\n");
-}
-
-function splitDiffLines(content: string): string[] {
-    if (content === "")
-        return [];
-    const lines = content.split(/\r?\n/);
-    if (lines.length > 0 && lines[lines.length - 1] === "")
-        lines.pop();
-    return lines;
-}
-
-function countChangedLines(oldContent: string, newContent: string): number {
-    const oldLines = oldContent.split(/\r?\n/);
-    const newLines = newContent.split(/\r?\n/);
-    let changed = 0;
-    let i = 0;
-    let j = 0;
-    while (i < oldLines.length && j < newLines.length) {
-        if (oldLines[i] === newLines[j]) {
-            i += 1;
-            j += 1;
-            continue;
-        }
-        changed += 1;
-        i += 1;
-        j += 1;
-    }
-    return changed + Math.abs(oldLines.length - newLines.length);
-}

package/src/session/projection.ts

@@ -1,308 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import type { ChatMessage } from "../types.js";
-import { formatToolResults } from "../agent/protocol.js";
-import { toolCatalogHash } from "../agent/registry.js";
-import { projectionPath, readSession, type ActiveFile } from "./log.js";
-
-export interface SessionMeta {
-    cwd: string;
-    providerId: string;
-    model: string;
-}
-
-export interface ProjectionFingerprint {
-    toolCatalogHash: string;
-    modelId: string;
-    cwdDigest: string;
-    compactionSource: "local" | "server" | "none";
-}
-
-export interface Projection {
-    version: 1;
-    kind: "projection";
-    cwd: string;
-    providerId: string;
-    model: string;
-    fingerprint: ProjectionFingerprint;
-    messages: ChatMessage[];
-    activeFiles: ActiveFile[];
-    lastFactSeq: number;
-}
-
-export interface ResumeState {
-    projection: Projection;
-    messages: ChatMessage[];
-    meta: SessionMeta;
-    warnings: string[];
-    rebuilt: boolean;
-}
-
-const READ_ONLY_TOOLS = new Set(["read_file", "read_many", "grep", "list_files", "stat_path", "pwd"]);
-const IDEMPOTENT_TOOLS = new Set(["write_file"]);
-const MAX_MESSAGE_CHARS = 4000;
-const MAX_PROJECTION_BYTES = 19_000;
-
-export function unpairedToolNotice(tool: string): string {
-    if (READ_ONLY_TOOLS.has(tool))
-        return "执行中断（只读工具，可安全重试）。";
-    if (IDEMPOTENT_TOOLS.has(tool))
-        return "执行中断，可安全重试（write_file 为全量写）。";
-    return "执行状态未知：进程中断时命令可能已完成。请先验证再操作（stat / git status / git diff），不要直接重做。";
-}
-
-export function cwdDigest(cwd: string): string {
-    return createHash("sha1").update(cwd).digest("hex").slice(0, 8);
-}
-
-export function projectionFingerprint(meta: SessionMeta, compactionSource: ProjectionFingerprint["compactionSource"] = "none"): ProjectionFingerprint {
-    return {
-        toolCatalogHash: toolCatalogHash(),
-        modelId: `${meta.providerId}::${meta.model}`,
-        cwdDigest: cwdDigest(meta.cwd),
-        compactionSource,
-    };
-}
-
-export function sameFingerprint(a: ProjectionFingerprint | undefined, b: ProjectionFingerprint): boolean {
-    return Boolean(a) && a!.toolCatalogHash === b.toolCatalogHash && a!.modelId === b.modelId &&
-        a!.cwdDigest === b.cwdDigest && a!.compactionSource === b.compactionSource;
-}
-
-export function sessionMetaFromFacts(facts: any[]): SessionMeta {
-    let cwd = "";
-    let providerId = "";
-    let model = "";
-    for (const fact of facts) {
-        if (fact?.type === "session_start" || fact?.type === "checkpoint") {
-            if (typeof fact.cwd === "string" && fact.cwd)
-                cwd = fact.cwd;
-            if (typeof fact.providerId === "string" && fact.providerId)
-                providerId = fact.providerId;
-            if (typeof fact.model === "string" && fact.model)
-                model = fact.model;
-        }
-    }
-    return { cwd, providerId, model };
-}
-
-export function sessionMetaFromFile(file: string): SessionMeta {
-    return sessionMetaFromFacts(readSession(file));
-}
-
-function legacyMessages(facts: any[]): ChatMessage[] {
-    return facts
-        .filter((fact) => fact?.type === "message" && typeof fact.content === "string")
-        .map((fact) => ({ role: fact.role, content: fact.content }));
-}
-
-export function factsToMessages(facts: any[]): ChatMessage[] {
-    const calls = new Map<string, any>();
-    const pending: Array<{ call: any; ok: boolean; output: string }> = [];
-    const messages: ChatMessage[] = [];
-    let nativeTurn = false;
-    const flush = () => {
-        for (const [id, call] of calls) {
-            const output = unpairedToolNotice(String(call?.tool ?? "unknown"));
-            if (nativeTurn)
-                messages.push({ role: "tool", toolCallId: id, content: output });
-            else
-                pending.push({ call, ok: false, output });
-        }
-        calls.clear();
-        if (pending.length > 0)
-            messages.push({ role: "user", content: formatToolResults(pending.splice(0)) });
-    };
-    for (const fact of facts) {
-        if (!fact)
-            continue;
-        if (fact.type === "user") {
-            flush();
-            nativeTurn = false;
-            if (typeof fact.content === "string" && fact.content)
-                messages.push({ role: "user", content: fact.content });
-        }
-        else if (fact.type === "assistant_raw") {
-            flush();
-            const nativeCalls = Array.isArray(fact.toolCalls) ? fact.toolCalls : undefined;
-            nativeTurn = Boolean(nativeCalls && nativeCalls.length > 0);
-            if (typeof fact.content === "string")
-                messages.push({ role: "assistant", content: fact.content, ...(nativeTurn ? { toolCalls: nativeCalls } : {}) });
-        }
-        else if (fact.type === "tool_call") {
-            calls.set(String(fact.id ?? ""), fact.args ?? { tool: fact.tool });
-        }
-        else if (fact.type === "tool_result") {
-            const id = String(fact.id ?? "");
-            const call = calls.get(id) ?? { tool: fact.tool ?? "unknown" };
-            calls.delete(id);
-            if (nativeTurn) {
-                messages.push({ role: "tool", toolCallId: id, content: String(fact.output ?? "") });
-            }
-            else {
-                pending.push({
-                    call,
-                    ok: Boolean(fact.ok),
-                    output: String(fact.output ?? ""),
-                });
-            }
-        }
-    }
-    flush();
-    if (messages.length === 0)
-        return legacyMessages(facts);
-    return messages;
-}
-
-export function compactionSourceFromFacts(facts: any[]): ProjectionFingerprint["compactionSource"] {
-    let source: ProjectionFingerprint["compactionSource"] = "none";
-    for (const fact of facts) {
-        if (fact?.type === "compacted" && (fact.source === "local" || fact.source === "server"))
-            source = fact.source;
-    }
-    return source;
-}
-
-function latestCompaction(facts: any[]): any | undefined {
-    for (let i = facts.length - 1; i >= 0; i -= 1) {
-        if (facts[i]?.type === "compacted")
-            return facts[i];
-    }
-    return undefined;
-}
-
-function applySummary(messages: ChatMessage[], facts: any[]): ChatMessage[] {
-    const latest = latestCompaction(facts);
-    if (!latest || latest.source !== "local" || typeof latest.summaryRef !== "string")
-        return messages;
-    try {
-        const summary = readFileSync(latest.summaryRef, "utf8");
-        const keep = Number(latest.keepMessages);
-        const tail = Number.isFinite(keep) && keep > 0 ? messages.slice(-keep) : messages;
-        const first = messages[0]?.role === "user" ? messages[0] : undefined;
-        const marker: ChatMessage = { role: "system", content: `[context summary]\n${summary}` };
-        if (first && tail[0] !== first)
-            return [first, marker, ...tail];
-        return [marker, ...tail];
-    }
-    catch {
-        return messages;
-    }
-}
-
-export function buildProjection(facts: any[], metaOverride?: Partial<SessionMeta>): Projection {
-    const detected = sessionMetaFromFacts(facts);
-    const meta: SessionMeta = {
-        cwd: metaOverride?.cwd || detected.cwd || process.cwd(),
-        providerId: metaOverride?.providerId || detected.providerId,
-        model: metaOverride?.model || detected.model,
-    };
-    const messages = clampMessages(applySummary(factsToMessages(facts), facts));
-    const source = compactionSourceFromFacts(facts);
-    let activeFiles: ActiveFile[] = [];
-    let lastFactSeq = 0;
-    for (const fact of facts) {
-        if (typeof fact?.seq === "number" && fact.seq > lastFactSeq)
-            lastFactSeq = fact.seq;
-        if (fact?.type === "checkpoint" && Array.isArray(fact.activeFiles))
-            activeFiles = fact.activeFiles;
-    }
-    const projection: Projection = {
-        version: 1,
-        kind: "projection",
-        cwd: meta.cwd,
-        providerId: meta.providerId,
-        model: meta.model,
-        fingerprint: projectionFingerprint(meta, source),
-        messages,
-        activeFiles: activeFiles.slice(0, 200),
-        lastFactSeq,
-    };
-    return projection;
-}
-
-function clampMessages(messages: ChatMessage[]): ChatMessage[] {
-    const list = messages.map((message) => {
-        const content = message.content.length > MAX_MESSAGE_CHARS
-            ? message.content.slice(0, MAX_MESSAGE_CHARS) + "\n[...truncated in projection...]"
-            : message.content;
-        return {
-            role: message.role,
-            content,
-            ...(message.toolCalls ? { toolCalls: message.toolCalls } : {}),
-            ...(message.toolCallId ? { toolCallId: message.toolCallId } : {}),
-        };
-    });
-    while (list.length > 1 && Buffer.byteLength(JSON.stringify(list), "utf8") > MAX_PROJECTION_BYTES) {
-        if (list.length > 2 && list[0].role === "user")
-            list.splice(1, 1);
-        else
-            list.shift();
-    }
-    return list;
-}
-
-export function readProjection(file: string): Projection | undefined {
-    try {
-        const raw = JSON.parse(readFileSync(projectionPath(file), "utf8"));
-        if (!raw || raw.version !== 1 || !Array.isArray(raw.messages) || !raw.fingerprint)
-            return undefined;
-        return raw as Projection;
-    }
-    catch {
-        return undefined;
-    }
-}
-
-export function writeProjection(file: string, projection: Projection): void {
-    const target = projectionPath(file);
-    const tmp = target + "." + process.pid + ".tmp";
-    try {
-        writeFileSync(tmp, JSON.stringify(projection, null, 2), "utf8");
-        renameSync(tmp, target);
-    }
-    catch (err) {
-        try {
-            rmSync(tmp, { force: true });
-        }
-        catch {
-            // best effort
-        }
-        throw err;
-    }
-}
-
-export function resumeSession(file: string, currentCwd = process.cwd()): ResumeState {
-    const facts = readSession(file);
-    const detected = sessionMetaFromFacts(facts);
-    const meta: SessionMeta = {
-        cwd: detected.cwd || currentCwd,
-        providerId: detected.providerId,
-        model: detected.model,
-    };
-    const expected = projectionFingerprint(meta, compactionSourceFromFacts(facts));
-    const stored = readProjection(file);
-    const warnings: string[] = [];
-    let projection: Projection;
-    let rebuilt = false;
-    if (stored && sameFingerprint(stored.fingerprint, expected)) {
-        projection = stored;
-    }
-    else {
-        projection = buildProjection(facts, meta);
-        rebuilt = true;
-        if (stored)
-            warnings.push("Projection fingerprint changed (tools/model/cwd); rebuilt from facts.");
-        else
-            warnings.push("No projection found; rebuilt from facts.");
-        try {
-            writeProjection(file, projection);
-        }
-        catch {
-            warnings.push("Could not write the projection (filesystem is read-only?); using the in-memory rebuild.");
-        }
-    }
-    if (detected.cwd && detected.cwd !== currentCwd)
-        warnings.push(`Session was recorded in ${detected.cwd}; current directory is ${currentCwd}.`);
-    return { projection, messages: projection.messages, meta, warnings, rebuilt };
-}

package/src/ui/Picker.ts

@@ -1,24 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-/**
- * Presentational picker used by /model, /provider, and /effort.
- *
- * Keyboard handling lives in App so it can suspend the normal prompt input and
- * so every picker behaves the same. This component only renders the window of
- * items around the active index.
- */
-import { Box, Text } from "ink";
-const WINDOW = 10;
-export const Picker = ({ theme, title, items, index, current, hint }) => {
-    const max = Math.max(0, items.length - 1);
-    const active = Math.max(0, Math.min(index, max));
-    const start = Math.max(0, Math.min(active - Math.floor(WINDOW / 2), Math.max(0, items.length - WINDOW)));
-    const visible = items.slice(start, start + WINDOW);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: title }), ...visible.map((item, offset) => {
-                const itemIndex = start + offset;
-                const selected = itemIndex === active;
-                const marker = selected ? "\u276F" : " ";
-                const number = itemIndex < 9 ? String(itemIndex + 1) : " ";
-                const isCurrent = current !== undefined && item.value === current;
-                return (_jsxs(Text, { color: selected ? theme.accent : theme.muted, children: [marker, " ", number, ". ", isCurrent ? "\u25CF " : "  ", item.label, item.hint ? _jsxs(Text, { color: theme.muted, children: ["  ", item.hint] }) : null] }, item.value));
-            }), items.length > WINDOW ? (_jsx(Text, { color: theme.muted, children: `  … ${start + 1}-${start + visible.length} of ${items.length}` })) : null, _jsx(Text, { color: theme.muted, children: hint ?? "  \u2191/\u2193 select \u00B7 1-9 jump \u00B7 Enter confirm \u00B7 Esc cancel" })] }));
-};