@aexol/spectral 0.9.81 → 0.9.83

package/dist/sdk/coding-agent/core/tools/apply-patch.js

@@ -0,0 +1,353 @@
+import { constants } from "fs";
+import { access as fsAccess, mkdir as fsMkdir, readFile as fsReadFile, rm as fsRm, writeFile as fsWriteFile } from "fs/promises";
+import { dirname } from "path";
+import { Type } from "typebox";
+import { detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeForFuzzyMatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveToCwd } from "./path-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+const applyPatchSchema = Type.Object({
+    patchText: Type.String({ description: "The full patch text that describes all changes to be made." }),
+}, { additionalProperties: false });
+const defaultApplyPatchOperations = {
+    readFile: (filePath) => fsReadFile(filePath),
+    writeFile: (filePath, content) => fsWriteFile(filePath, content, "utf-8"),
+    removeFile: (filePath) => fsRm(filePath, { force: false }),
+    mkdir: (filePath) => fsMkdir(filePath, { recursive: true }).then(() => { }),
+    access: (filePath) => fsAccess(filePath, constants.R_OK | constants.W_OK),
+};
+function stripHeredoc(input) {
+    const heredocMatch = input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/);
+    return heredocMatch ? heredocMatch[2] : input;
+}
+function parsePatchHeader(lines, startIndex) {
+    const line = lines[startIndex];
+    if (line.startsWith("*** Add File:")) {
+        const filePath = line.slice("*** Add File:".length).trim();
+        return filePath ? { path: filePath, nextIndex: startIndex + 1 } : null;
+    }
+    if (line.startsWith("*** Delete File:")) {
+        const filePath = line.slice("*** Delete File:".length).trim();
+        return filePath ? { path: filePath, nextIndex: startIndex + 1 } : null;
+    }
+    if (line.startsWith("*** Update File:")) {
+        const filePath = line.slice("*** Update File:".length).trim();
+        let movePath;
+        let nextIndex = startIndex + 1;
+        if (lines[nextIndex]?.startsWith("*** Move to:")) {
+            movePath = lines[nextIndex].slice("*** Move to:".length).trim();
+            nextIndex++;
+        }
+        return filePath ? { path: filePath, movePath, nextIndex } : null;
+    }
+    return null;
+}
+function parseAddFileContent(lines, startIndex) {
+    let content = "";
+    let index = startIndex;
+    while (index < lines.length && !lines[index].startsWith("***")) {
+        if (lines[index].startsWith("+"))
+            content += `${lines[index].slice(1)}\n`;
+        index++;
+    }
+    return { content: content.endsWith("\n") ? content.slice(0, -1) : content, nextIndex: index };
+}
+function parseUpdateChunks(lines, startIndex) {
+    const chunks = [];
+    let index = startIndex;
+    while (index < lines.length && !lines[index].startsWith("***")) {
+        if (!lines[index].startsWith("@@")) {
+            index++;
+            continue;
+        }
+        const header = parseUpdateHeader(lines[index]);
+        index++;
+        const oldLines = [];
+        const newLines = [];
+        let isEndOfFile = false;
+        while (index < lines.length && !lines[index].startsWith("@@") && !lines[index].startsWith("***")) {
+            const line = lines[index];
+            if (line === "*** End of File") {
+                isEndOfFile = true;
+                index++;
+                break;
+            }
+            if (line.startsWith(" ")) {
+                oldLines.push(line.slice(1));
+                newLines.push(line.slice(1));
+            }
+            else if (line.startsWith("-")) {
+                oldLines.push(line.slice(1));
+            }
+            else if (line.startsWith("+")) {
+                newLines.push(line.slice(1));
+            }
+            index++;
+        }
+        chunks.push({
+            oldLines,
+            newLines,
+            changeContext: header.changeContext,
+            oldStartLine: header.oldStartLine,
+            isEndOfFile: isEndOfFile || undefined,
+        });
+    }
+    return { chunks, nextIndex: index };
+}
+function parseUpdateHeader(line) {
+    const body = line.slice(2).trim();
+    if (!body)
+        return {};
+    const unifiedMatch = body.match(/^-([0-9]+)(?:,[0-9]+)?\s+\+[0-9]+(?:,[0-9]+)?\s*@@\s*(.*)$/);
+    if (!unifiedMatch)
+        return { changeContext: body };
+    const oldStartLine = Number.parseInt(unifiedMatch[1], 10);
+    const trailingContext = unifiedMatch[2]?.trim() || undefined;
+    return { oldStartLine: Number.isFinite(oldStartLine) ? oldStartLine : undefined, changeContext: trailingContext };
+}
+function parsePatch(patchText) {
+    const normalizedPatchText = patchText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const lines = stripHeredoc(normalizedPatchText.trim()).split("\n");
+    const beginIndex = lines.findIndex((line) => line.trim() === "*** Begin Patch");
+    const endIndex = lines.findIndex((line) => line.trim() === "*** End Patch");
+    if (beginIndex === -1 || endIndex === -1 || beginIndex >= endIndex) {
+        throw new Error("Invalid patch format: missing Begin/End markers.");
+    }
+    const hunks = [];
+    let index = beginIndex + 1;
+    while (index < endIndex) {
+        const header = parsePatchHeader(lines, index);
+        if (!header) {
+            index++;
+            continue;
+        }
+        if (lines[index].startsWith("*** Add File:")) {
+            const { content, nextIndex } = parseAddFileContent(lines, header.nextIndex);
+            hunks.push({ type: "add", path: header.path, contents: content });
+            index = nextIndex;
+        }
+        else if (lines[index].startsWith("*** Delete File:")) {
+            hunks.push({ type: "delete", path: header.path });
+            index = header.nextIndex;
+        }
+        else {
+            const { chunks, nextIndex } = parseUpdateChunks(lines, header.nextIndex);
+            hunks.push({ type: "update", path: header.path, movePath: header.movePath, chunks });
+            index = nextIndex;
+        }
+    }
+    return hunks;
+}
+function compareNormalized(a, b) {
+    return normalizeForFuzzyMatch(a.trim()) === normalizeForFuzzyMatch(b.trim());
+}
+function tryMatch(lines, pattern, startIndex, compare, eof = false) {
+    if (pattern.length === 0)
+        return -1;
+    if (eof) {
+        const fromEnd = lines.length - pattern.length;
+        if (fromEnd >= startIndex && pattern.every((line, offset) => compare(lines[fromEnd + offset], line)))
+            return fromEnd;
+    }
+    for (let index = startIndex; index <= lines.length - pattern.length; index++) {
+        if (pattern.every((line, offset) => compare(lines[index + offset], line)))
+            return index;
+    }
+    return -1;
+}
+function seekSequence(lines, pattern, startIndex, eof = false) {
+    return [
+        (a, b) => a === b,
+        (a, b) => a.trimEnd() === b.trimEnd(),
+        (a, b) => a.trim() === b.trim(),
+        compareNormalized,
+    ].reduce((found, compare) => found !== -1 ? found : tryMatch(lines, pattern, startIndex, compare, eof), -1);
+}
+function seekSequenceNearHint(lines, pattern, startIndex, hintLine, eof = false) {
+    if (!hintLine || hintLine < 1 || pattern.length === 0)
+        return seekSequence(lines, pattern, startIndex, eof);
+    const hintedIndex = Math.max(startIndex, Math.min(lines.length, hintLine - 1));
+    for (const radius of [0, 1, 3, 8, 20]) {
+        const windowStart = Math.max(startIndex, hintedIndex - radius);
+        const windowEnd = Math.min(lines.length - pattern.length, hintedIndex + radius);
+        if (windowEnd < windowStart)
+            continue;
+        for (const compare of [
+            (a, b) => a === b,
+            (a, b) => a.trimEnd() === b.trimEnd(),
+            (a, b) => a.trim() === b.trim(),
+            compareNormalized,
+        ]) {
+            for (let index = windowStart; index <= windowEnd; index++) {
+                if (pattern.every((line, offset) => compare(lines[index + offset], line)))
+                    return index;
+            }
+        }
+    }
+    return seekSequence(lines, pattern, startIndex, eof);
+}
+function computeReplacements(originalLines, filePath, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        if (chunk.changeContext) {
+            const contextIndex = seekSequence(originalLines, [chunk.changeContext], lineIndex);
+            if (contextIndex === -1)
+                throw new Error(`Failed to find context '${chunk.changeContext}' in ${filePath}.`);
+            lineIndex = contextIndex + 1;
+        }
+        if (chunk.oldLines.length === 0) {
+            const insertionIndex = originalLines.at(-1) === "" ? originalLines.length - 1 : originalLines.length;
+            replacements.push([insertionIndex, 0, chunk.newLines]);
+            continue;
+        }
+        let oldLines = chunk.oldLines;
+        let newLines = chunk.newLines;
+        let found = seekSequenceNearHint(originalLines, oldLines, lineIndex, chunk.oldStartLine, chunk.isEndOfFile);
+        if (found === -1 && oldLines.at(-1) === "") {
+            oldLines = oldLines.slice(0, -1);
+            newLines = newLines.at(-1) === "" ? newLines.slice(0, -1) : newLines;
+            found = seekSequenceNearHint(originalLines, oldLines, lineIndex, chunk.oldStartLine, chunk.isEndOfFile);
+        }
+        if (found === -1) {
+            throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.oldLines.join("\n")}`);
+        }
+        replacements.push([found, oldLines.length, newLines]);
+        lineIndex = found + oldLines.length;
+    }
+    return replacements.sort((a, b) => a[0] - b[0]);
+}
+function applyReplacements(lines, replacements) {
+    const result = [...lines];
+    for (let index = replacements.length - 1; index >= 0; index--) {
+        const [start, oldLength, newLines] = replacements[index];
+        result.splice(start, oldLength, ...newLines);
+    }
+    return result;
+}
+function deriveUpdatedContent(filePath, rawContent, chunks) {
+    const { bom, text } = stripBom(rawContent);
+    const lineEnding = detectLineEnding(text);
+    const normalized = normalizeToLF(text);
+    const originalLines = normalized.split("\n");
+    if (originalLines.at(-1) === "")
+        originalLines.pop();
+    const replacements = computeReplacements(originalLines, filePath, chunks);
+    const newLines = applyReplacements(originalLines, replacements);
+    if (newLines.length === 0 || newLines.at(-1) !== "")
+        newLines.push("");
+    return { bom, oldContent: normalized, newContent: newLines.join("\n"), lineEnding };
+}
+export function createApplyPatchToolDefinition(cwd, options) {
+    const ops = options?.operations ?? defaultApplyPatchOperations;
+    return {
+        name: "apply_patch",
+        label: "Apply Patch",
+        description: "Apply a file-oriented patch with explicit Add File, Update File, and Delete File sections.",
+        promptSnippet: "Apply multi-file patches using a structured patch envelope with Add/Update/Delete file sections.",
+        promptGuidelines: [
+            "Use apply_patch for manual code edits, especially with OpenAI/GPT/Codex models. It is safer than exact oldText replacement because each hunk carries explicit context and changed lines.",
+            "Before calling apply_patch, read the target file and build hunks from the current contents. Do not guess indentation, omitted blank lines, comments, or surrounding context.",
+            "Patch format: start with *** Begin Patch, include one or more *** Add File / *** Update File / *** Delete File sections, and finish with *** End Patch.",
+            "For Update File sections, use @@ context headers when helpful, prefix unchanged lines with a space, removed lines with -, and added lines with +.",
+            "Keep each Update File hunk small and local. If a patch fails to match, re-read the file and retry with a smaller hunk copied from the current file instead of reusing stale context.",
+        ],
+        parameters: applyPatchSchema,
+        async execute(_toolCallId, input, signal) {
+            if (!input.patchText?.trim())
+                throw new Error("patchText is required.");
+            const hunks = parsePatch(input.patchText);
+            if (hunks.length === 0)
+                throw new Error("apply_patch verification failed: no hunks found.");
+            const changes = [];
+            for (const hunk of hunks) {
+                if (signal?.aborted)
+                    throw new Error("Operation aborted");
+                const absolutePath = resolveToCwd(hunk.path, cwd);
+                if (hunk.type === "add") {
+                    const existing = await ops.readFile(absolutePath).then(() => true, () => false);
+                    if (existing)
+                        throw new Error(`Could not add file: ${hunk.path}. File already exists.`);
+                    const { bom, text } = stripBom(normalizeToLF(hunk.contents));
+                    changes.push({
+                        path: hunk.path,
+                        absolutePath,
+                        oldContent: "",
+                        newContent: text.endsWith("\n") ? text : `${text}\n`,
+                        type: "add",
+                        bom,
+                        lineEnding: "\n",
+                    });
+                    continue;
+                }
+                await ops.access(absolutePath).catch((error) => {
+                    const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
+                    throw new Error(`Could not patch file: ${hunk.path}. ${errorMessage}.`);
+                });
+                const rawContent = (await ops.readFile(absolutePath)).toString("utf-8");
+                if (hunk.type === "delete") {
+                    const { bom, text } = stripBom(rawContent);
+                    changes.push({
+                        path: hunk.path,
+                        absolutePath,
+                        oldContent: normalizeToLF(text),
+                        newContent: "",
+                        type: "delete",
+                        bom,
+                        lineEnding: detectLineEnding(text),
+                    });
+                    continue;
+                }
+                const updated = deriveUpdatedContent(hunk.path, rawContent, hunk.chunks);
+                const absoluteMovePath = hunk.movePath ? resolveToCwd(hunk.movePath, cwd) : undefined;
+                changes.push({
+                    path: hunk.path,
+                    absolutePath,
+                    oldContent: updated.oldContent,
+                    newContent: updated.newContent,
+                    type: "update",
+                    movePath: hunk.movePath,
+                    absoluteMovePath,
+                    bom: updated.bom,
+                    lineEnding: updated.lineEnding,
+                });
+            }
+            const mutatedFiles = changes.map((change) => change.absoluteMovePath ?? change.absolutePath);
+            return withFileMutationQueue(mutatedFiles.join("\0"), async () => {
+                let combinedDiff = "";
+                let combinedPatch = "";
+                let firstChangedLine;
+                for (const change of changes) {
+                    if (signal?.aborted)
+                        throw new Error("Operation aborted");
+                    if (change.oldContent === change.newContent && !change.movePath) {
+                        throw new Error(`No changes made to ${change.path}. The patch produced identical content.`);
+                    }
+                    if (change.type === "delete") {
+                        await ops.removeFile(change.absolutePath);
+                    }
+                    else {
+                        const targetPath = change.absoluteMovePath ?? change.absolutePath;
+                        await ops.mkdir(dirname(targetPath));
+                        await ops.writeFile(targetPath, change.bom + restoreLineEndings(change.newContent, change.lineEnding));
+                        if (change.movePath)
+                            await ops.removeFile(change.absolutePath);
+                    }
+                    const displayPath = change.movePath ? `${change.path} => ${change.movePath}` : change.path;
+                    const diffResult = generateDiffString(change.oldContent, change.newContent);
+                    combinedDiff += `${displayPath}\n${diffResult.diff}\n`;
+                    combinedPatch += `${generateUnifiedPatch(displayPath, change.oldContent, change.newContent)}\n`;
+                    firstChangedLine ??= diffResult.firstChangedLine;
+                }
+                const modifiedFiles = changes.map((change) => change.movePath ?? change.path);
+                return {
+                    content: [{ type: "text", text: `Successfully applied patch to ${modifiedFiles.length} file(s).` }],
+                    details: { diff: combinedDiff.trim(), patch: combinedPatch.trim(), firstChangedLine, modifiedFiles },
+                };
+            });
+        },
+    };
+}
+export function createApplyPatchTool(cwd, options) {
+    return wrapToolDefinition(createApplyPatchToolDefinition(cwd, options));
+}

package/dist/sdk/coding-agent/core/tools/edit-diff.d.ts

@@ -18,7 +18,7 @@ export interface FuzzyMatchResult {
     found: boolean;
     /** The index where the match starts in the original content */
     index: number;
-    /** Length of the matched text */
+    /** Length of the matched text in the original content */
     matchLength: number;
     /** Whether fuzzy matching was used (false = exact match) */
     usedFuzzyMatch: boolean;
@@ -33,11 +33,6 @@ export interface AppliedEditsResult {
     baseContent: string;
     newContent: string;
 }
-/**
- * Find oldText in content, trying exact match first, then tolerant whitespace matching.
- * Fuzzy matches still return indexes into the original content, so replacements preserve
- * untouched text outside the matched span.
- */
 export declare function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult;
 /** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
 export declare function stripBom(content: string): {

package/dist/sdk/coding-agent/core/tools/edit-diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit-diff.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/edit-diff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM/D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqB3D;AAmHD,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,cAAc,EAAE,OAAO,CAAC;IACxB,8DAA8D;IAC9D,qBAAqB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,IAAI;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AASD,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAkBhF;AAED,uFAAuF;AACvF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAEvE;AA4CD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC5C,iBAAiB,EAAE,MAAM,EACzB,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE,MAAM,GACV,kBAAkB,CA4DpB;AAED,yCAAyC;AACzC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,SAAI,GAAG,MAAM,CAKnH;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,YAAY,SAAI,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAuHxD;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,aAAa,CAAC,CAyBzC;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,aAAa,CAAC,CAEzC"}
+{"version":3,"file":"edit-diff.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/edit-diff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM/D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqB3D;AAED,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,cAAc,EAAE,OAAO,CAAC;IACxB,8DAA8D;IAC9D,qBAAqB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,IAAI;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAwBD,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACnB;AA8KD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAkBhF;AA6CD,uFAAuF;AACvF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAEvE;AA0CD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC5C,iBAAiB,EAAE,MAAM,EACzB,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE,MAAM,GACV,kBAAkB,CA0DpB;AAED,yCAAyC;AACzC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,SAAI,GAAG,MAAM,CAKnH;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,YAAY,SAAI,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAuHxD;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,aAAa,CAAC,CAyBzC;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,aAAa,CAAC,CAEzC"}