@travisennis/acai 0.0.12 → 0.0.14

package/dist/tui/utils.js

@@ -123,6 +123,20 @@ function truncateSimple(text, targetWidth, maxWidth) {
         visibleSoFar: state.visibleSoFar,
     };
 }
+/**
+ * Find the end of the current text segment (until tab or ANSI code).
+ */
+function findSegmentEnd(text, start) {
+    let end = start;
+    while (end < text.length && text[end] !== "\t") {
+        const nextAnsi = extractAnsiCode(text, end);
+        if (nextAnsi) {
+            return end;
+        }
+        end++;
+    }
+    return end;
+}
 function truncateComplex(text, targetWidth, maxWidth) {
     const state = createInitialState();
     let i = 0;
@@ -140,14 +154,7 @@ function truncateComplex(text, targetWidth, maxWidth) {
             continue;
         }
         // Find end of current text segment (until tab or ANSI)
-        let end = i;
-        while (end < text.length && text[end] !== "\t") {
-            const nextAnsi = extractAnsiCode(text, end);
-            if (nextAnsi) {
-                break;
-            }
-            end++;
-        }
+        const end = findSegmentEnd(text, i);
         // Process graphemes in this segment
         for (const { segment } of getSegmenter().segment(text.slice(i, end))) {
             if (processGraphemeSegment(state, segment, targetWidth, maxWidth)) {
@@ -192,12 +199,24 @@ export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
     }
     // Fast path: pure ASCII printable
     if (isPrintableAscii(text)) {
-        if (text.length <= maxWidth) {
-            return pad ? text + " ".repeat(maxWidth - text.length) : text;
-        }
-        const targetWidth = maxWidth - ellipsisWidth;
-        return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+        return truncateAscii(text, maxWidth, ellipsis, ellipsisWidth, pad);
+    }
+    return truncateNonAscii(text, maxWidth, ellipsis, ellipsisWidth, pad);
+}
+/**
+ * Truncate ASCII-only text with ellipsis.
+ */
+function truncateAscii(text, maxWidth, ellipsis, ellipsisWidth, pad) {
+    if (text.length <= maxWidth) {
+        return pad ? text + " ".repeat(maxWidth - text.length) : text;
     }
+    const targetWidth = maxWidth - ellipsisWidth;
+    return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+}
+/**
+ * Truncate text that may contain ANSI codes, tabs, or Unicode wide characters.
+ */
+function truncateNonAscii(text, maxWidth, ellipsis, ellipsisWidth, pad) {
     const targetWidth = maxWidth - ellipsisWidth;
     const hasAnsi = text.includes("\x1b");
     const hasTabs = text.includes("\t");
@@ -221,31 +240,71 @@ export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
     return finalizeTruncatedResult(truncatedResult.result, truncatedResult.keptWidth, ellipsis, ellipsisWidth, maxWidth, pad);
 }
 /**
- * Truncate a single fragment to a maximum width.
+ * Truncate text that contains only graphemes (no ANSI, no tabs) by
+ * iterating grapheme clusters up to maxWidth.
  */
-function truncateFragmentToWidth(text, maxWidth) {
-    if (maxWidth <= 0 || text.length === 0) {
-        return { text: "", width: 0 };
+function truncateGraphemesOnly(text, maxWidth) {
+    let result = "";
+    let width = 0;
+    for (const { segment } of getSegmenter().segment(text)) {
+        const w = graphemeWidth(segment);
+        if (width + w > maxWidth) {
+            break;
+        }
+        result += segment;
+        width += w;
     }
-    if (isPrintableAscii(text)) {
-        const clipped = text.slice(0, maxWidth);
-        return { text: clipped, width: clipped.length };
+    return { text: result, width };
+}
+/**
+ * Process a contiguous text segment (no tabs, no ANSI codes) within the
+ * larger ANSI/tab-aware truncation loop. Returns the consumed portion and
+ * updated state.
+ */
+function processTextSegment(text, start, maxWidth, currentWidth, pendingAnsi) {
+    // Find end of current text segment (until tab or ANSI code)
+    let end = start;
+    while (end < text.length && text[end] !== "\t") {
+        const nextAnsi = extractAnsiCode(text, end);
+        if (nextAnsi) {
+            break;
+        }
+        end++;
     }
-    const hasAnsi = text.includes("\x1b");
-    const hasTabs = text.includes("\t");
-    if (!hasAnsi && !hasTabs) {
-        let result = "";
-        let width = 0;
-        for (const { segment } of getSegmenter().segment(text)) {
-            const w = graphemeWidth(segment);
-            if (width + w > maxWidth) {
-                break;
-            }
-            result += segment;
-            width += w;
+    let result = "";
+    let width = currentWidth;
+    let pending = pendingAnsi;
+    for (const { segment } of getSegmenter().segment(text.slice(start, end))) {
+        const w = graphemeWidth(segment);
+        if (width + w > maxWidth) {
+            return {
+                text: result,
+                width,
+                pendingAnsi: pending,
+                nextIndex: end,
+                exhausted: true,
+            };
+        }
+        if (pending) {
+            result += pending;
+            pending = "";
         }
-        return { text: result, width };
+        result += segment;
+        width += w;
     }
+    return {
+        text: result,
+        width,
+        pendingAnsi: pending,
+        nextIndex: end,
+        exhausted: false,
+    };
+}
+/**
+ * Truncate text that contains ANSI codes and/or tab characters,
+ * correctly measuring visible width.
+ */
+function truncateWithAnsiAndTabs(text, maxWidth) {
     let result = "";
     let width = 0;
     let i = 0;
@@ -270,30 +329,35 @@ function truncateFragmentToWidth(text, maxWidth) {
             i++;
             continue;
         }
-        let end = i;
-        while (end < text.length && text[end] !== "\t") {
-            const nextAnsi = extractAnsiCode(text, end);
-            if (nextAnsi) {
-                break;
-            }
-            end++;
-        }
-        for (const { segment } of getSegmenter().segment(text.slice(i, end))) {
-            const w = graphemeWidth(segment);
-            if (width + w > maxWidth) {
-                return { text: result, width };
-            }
-            if (pendingAnsi) {
-                result += pendingAnsi;
-                pendingAnsi = "";
-            }
-            result += segment;
-            width += w;
+        const segmentResult = processTextSegment(text, i, maxWidth, width, pendingAnsi);
+        result += segmentResult.text;
+        width = segmentResult.width;
+        pendingAnsi = segmentResult.pendingAnsi;
+        i = segmentResult.nextIndex;
+        if (segmentResult.exhausted) {
+            break;
         }
-        i = end;
     }
     return { text: result, width };
 }
+/**
+ * Truncate a single fragment to a maximum width.
+ */
+export function truncateFragmentToWidth(text, maxWidth) {
+    if (maxWidth <= 0 || text.length === 0) {
+        return { text: "", width: 0 };
+    }
+    if (isPrintableAscii(text)) {
+        const clipped = text.slice(0, maxWidth);
+        return { text: clipped, width: clipped.length };
+    }
+    const hasAnsi = text.includes("\x1b");
+    const hasTabs = text.includes("\t");
+    if (!hasAnsi && !hasTabs) {
+        return truncateGraphemesOnly(text, maxWidth);
+    }
+    return truncateWithAnsiAndTabs(text, maxWidth);
+}
 /**
  * Finalize a truncated result with proper ANSI reset codes.
  * Only adds reset codes if the prefix contains ANSI sequences.

package/dist/utils/bash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAuJA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiDtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAkEF,CAAC;AA6FF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAetD,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/utils/bash.ts"],"names":[],"mappings":"AAgQA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBtC;AAiFD,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,MAaF,CAAC;AA8EF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAetD,CAAC"}

package/dist/utils/bash.js

@@ -81,6 +81,33 @@ function isFullyQuoted(token) {
     const last = token[token.length - 1];
     return (first === '"' && last === '"') || (first === "'" && last === "'");
 }
+// Process a single git message flag token and update skip mask
+// Returns true if the token was recognized as a message flag
+function processGitMessageToken(tokens, i, t, skip) {
+    // --message=<msg> - skip this entire token
+    if (t.startsWith("--message=")) {
+        skip[i] = true;
+        return true;
+    }
+    // -m<msg> (attached message) - skip this entire token
+    if (/^-m.+/.test(t)) {
+        skip[i] = true;
+        return true;
+    }
+    // -m or --message consumes next token
+    if (t === "-m" || t === "--message") {
+        if (i + 1 < tokens.length)
+            skip[i + 1] = true;
+        return true;
+    }
+    // Combined short opts containing m, e.g. -am, -avm
+    if (/^-[^-]+$/.test(t) && t.includes("m")) {
+        if (i + 1 < tokens.length)
+            skip[i + 1] = true;
+        return true;
+    }
+    return false;
+}
 // Compute which tokens should be skipped from path validation
 function computeSkipTokenMask(tokens) {
     const skip = new Array(tokens.length).fill(false);
@@ -88,41 +115,87 @@ function computeSkipTokenMask(tokens) {
     const sub = stripQuotes(tokens[1] ?? "");
     // Commands where -m/--message is a string argument (not a path)
     const gitMessageSubs = new Set(["commit", "merge", "tag", "revert", "notes"]);
-    if (bin === "git" && gitMessageSubs.has(sub)) {
-        let seenDoubleDash = false;
-        for (let i = 2; i < tokens.length; i++) {
-            const t = stripQuotes(tokens[i] ?? "");
-            if (t === "--") {
-                seenDoubleDash = true;
-                continue;
-            }
-            if (seenDoubleDash)
-                continue;
-            // --message=<msg> - skip this entire token
-            if (t.startsWith("--message=")) {
-                skip[i] = true;
-                continue;
-            }
-            // -m<msg> (attached message) - skip this entire token
-            if (/^-m.+/.test(t)) {
-                skip[i] = true;
-                continue;
-            }
-            // -m or --message consumes next token
-            if (t === "-m" || t === "--message") {
-                if (i + 1 < tokens.length)
-                    skip[i + 1] = true;
-                continue;
-            }
-            // Combined short opts containing m, e.g. -am, -avm
-            if (/^-[^-]+$/.test(t) && t.includes("m")) {
-                if (i + 1 < tokens.length)
-                    skip[i + 1] = true;
-            }
+    if (bin !== "git" || !gitMessageSubs.has(sub)) {
+        return skip;
+    }
+    let seenDoubleDash = false;
+    for (let i = 2; i < tokens.length; i++) {
+        const t = stripQuotes(tokens[i] ?? "");
+        if (t === "--") {
+            seenDoubleDash = true;
+            continue;
         }
+        if (seenDoubleDash)
+            continue;
+        processGitMessageToken(tokens, i, t, skip);
     }
     return skip;
 }
+// Extract a path embedded in a flag-style argument (--key=value or -X/path).
+// Returns null if no path-like segment is found.
+function extractPathFromFlag(flag) {
+    // --key=value style: extract and de-quote the value side
+    const eqIndex = flag.indexOf("=");
+    if (eqIndex !== -1) {
+        const value = stripQuotes(flag.slice(eqIndex + 1));
+        // Only treat as a path if it starts with a path-identifying prefix
+        // to avoid validating string arguments that happen to contain "/"
+        if (value.startsWith("/") ||
+            value.startsWith("~") ||
+            value.startsWith("./") ||
+            value.startsWith("../")) {
+            return value;
+        }
+        return null;
+    }
+    // -X/path style: single letter flag directly attached to a path
+    if (/^-[a-zA-Z]\//.test(flag)) {
+        return flag.slice(2);
+    }
+    return null;
+}
+function validatePathValue(rawPath, allowedDirs, cwd) {
+    try {
+        // Expand ~ to home directory for proper validation
+        const expandedPath = rawPath.startsWith("~/") || rawPath === "~"
+            ? path.join(os.homedir(), rawPath.slice(1))
+            : rawPath;
+        const resolvedPath = path.resolve(cwd, expandedPath);
+        if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
+            return {
+                isValid: false,
+                error: `Path '${rawPath}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
+            };
+        }
+    }
+    catch (_e) { }
+    return { isValid: true };
+}
+function validateToken(token, allowedDirs, cwd) {
+    // Skip fully quoted tokens - they're string arguments, not paths
+    // (paths are typically unquoted or only quoted to handle spaces)
+    if (isFullyQuoted(token)) {
+        return { isValid: true };
+    }
+    // Remove quotes for path checking
+    const cleanToken = stripQuotes(token);
+    // Skip URLs and non-path tokens
+    if (cleanToken.includes("://") ||
+        (!cleanToken.includes("/") && cleanToken !== "~")) {
+        return { isValid: true };
+    }
+    // For flag-style tokens that embed paths (e.g., --file=/etc/passwd, -o/tmp/x),
+    // extract the embedded path for validation.
+    if (cleanToken.startsWith("-")) {
+        const embeddedPath = extractPathFromFlag(cleanToken);
+        if (!embeddedPath) {
+            // No embedded path found — just a flag
+            return { isValid: true };
+        }
+        return validatePathValue(embeddedPath, allowedDirs, cwd);
+    }
+    return validatePathValue(cleanToken, allowedDirs, cwd);
+}
 // Validate path arguments to ensure they're within the project
 export function validatePaths(command, allowedDirs, cwd) {
     const tokens = tokenizeShellWords(command);
@@ -135,75 +208,52 @@ export function validatePaths(command, allowedDirs, cwd) {
         // Skip tokens marked by command-aware logic
         if (skip[i])
             continue;
-        // Skip fully quoted tokens - they're string arguments, not paths
-        // (paths are typically unquoted or only quoted to handle spaces)
-        if (isFullyQuoted(token) && token.includes("\n")) {
-            continue;
-        }
-        // Remove quotes for path checking
-        const cleanToken = stripQuotes(token);
-        // Skip if it's clearly not a path
-        if (cleanToken.startsWith("-") ||
-            cleanToken.includes("://") ||
-            (!cleanToken.includes("/") && cleanToken !== "~")) {
-            continue;
-        }
-        try {
-            // Expand ~ to home directory for proper validation
-            const expandedToken = cleanToken.startsWith("~/") || cleanToken === "~"
-                ? path.join(os.homedir(), cleanToken.slice(1))
-                : cleanToken;
-            const resolvedPath = path.resolve(cwd, expandedToken);
-            if (!isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
-                return {
-                    isValid: false,
-                    error: `Path '${cleanToken}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
-                };
-            }
-        }
-        catch (_e) { }
+        const result = validateToken(token, allowedDirs, cwd);
+        if (!result.isValid)
+            return result;
     }
     return { isValid: true };
 }
-export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
-    // Determine which directory to use as the base for resolving relative paths
-    // If allowedDirs is provided and non-empty, use the first allowed directory
-    // Otherwise use the workingDir parameter (backward compatibility)
+function resolveBaseDir(allowedDirs, workingDir) {
     const baseDirForResolution = allowedDirs && allowedDirs.length > 0 ? allowedDirs[0] : workingDir;
     const projectRootAbs = path.resolve(baseDirForResolution);
-    let projectRoot = projectRootAbs;
     try {
-        projectRoot = fs.realpathSync(projectRootAbs);
+        return fs.realpathSync(projectRootAbs);
     }
     catch {
-        // Fallback to resolved path
+        return projectRootAbs;
     }
-    const raw = typeof cwdInput === "string" && cwdInput.trim() !== ""
-        ? cwdInput.trim()
-        : projectRoot;
-    const abs = path.isAbsolute(raw) ? raw : path.resolve(projectRoot, raw);
-    let target = abs;
+}
+function resolveRawCwd(cwdInput, projectRoot) {
+    if (typeof cwdInput === "string" && cwdInput.trim() !== "") {
+        const trimmed = cwdInput.trim();
+        return path.isAbsolute(trimmed)
+            ? trimmed
+            : path.resolve(projectRoot, trimmed);
+    }
+    return projectRoot;
+}
+function resolveRealTarget(raw) {
     try {
-        target = fs.realpathSync(abs);
+        return fs.realpathSync(raw);
     }
     catch {
-        // If the path doesn't exist entirely, validate intended path
+        return raw;
     }
-    // Check if within allowed directories if provided, otherwise check project root
-    if (allowedDirs && allowedDirs.length > 0) {
-        if (!isPathWithinAllowedDirs(target, allowedDirs)) {
-            throw new Error(`Working directory must be within the allowed directories: ${allowedDirs.join(", ")}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
-        }
+}
+function assertWithinAllowedDirs(target, allowedDirs, cwdInput) {
+    if (!isPathWithinAllowedDirs(target, allowedDirs)) {
+        throw new Error(`Working directory must be within the allowed directories: ${allowedDirs.join(", ")}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
     }
-    else {
-        // Fallback to original behavior: check within project root
-        const rel = path.relative(projectRoot, target);
-        const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-        if (!inside) {
-            throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
-        }
+}
+function assertWithinProjectRoot(target, projectRoot, cwdInput) {
+    const rel = path.relative(projectRoot, target);
+    const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+    if (!inside) {
+        throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
     }
-    // Check existence and that it's a directory
+}
+function assertDirectoryExists(target) {
     let stats;
     try {
         stats = fs.statSync(target);
@@ -211,13 +261,26 @@ export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
     catch (err) {
         const error = err;
         if (error.code === "ENOENT") {
-            throw new Error(`Working directory does not exist: ${target} (from ${cwdInput ?? "<default>"})`);
+            throw new Error(`Working directory does not exist: ${target}`);
         }
         throw error;
     }
     if (!stats.isDirectory()) {
         throw new Error(`Working directory is not a directory: ${target}`);
     }
+    return stats;
+}
+export const resolveCwd = (cwdInput, workingDir, allowedDirs) => {
+    const projectRoot = resolveBaseDir(allowedDirs, workingDir);
+    const raw = resolveRawCwd(cwdInput, projectRoot);
+    const target = resolveRealTarget(raw);
+    if (allowedDirs && allowedDirs.length > 0) {
+        assertWithinAllowedDirs(target, allowedDirs, cwdInput);
+    }
+    else {
+        assertWithinProjectRoot(target, projectRoot, cwdInput);
+    }
+    assertDirectoryExists(target);
     return target;
 };
 const mutatingBinaries = new Set([
@@ -278,27 +341,16 @@ function isSegmentMutating(seg) {
     const bin = tokens[0];
     if (!bin)
         return false;
-    if (tokens.some((t) => actionMutating.has(t))) {
+    if (tokens.some((t) => actionMutating.has(t)))
         return true;
-    }
-    if (bin === "sed" && tokens.some((t) => /^-i/.test(t))) {
+    if (bin === "sed" && tokens.some((t) => /^-i/.test(t)))
         return true;
-    }
-    if (mutatingBinaries.has(bin)) {
+    if (mutatingBinaries.has(bin))
+        return true;
+    if (bin === "git" && tokens[1] && gitMutating.has(tokens[1]))
+        return true;
+    if (packageManagers.has(bin) && tokens[1] && npmMutating.has(tokens[1]))
         return true;
-    }
-    if (bin === "git" && tokens.length > 1) {
-        const sub = tokens[1];
-        if (typeof sub === "string" && gitMutating.has(sub)) {
-            return true;
-        }
-    }
-    if (packageManagers.has(bin) && tokens.length > 1) {
-        const sub = tokens[1];
-        if (typeof sub === "string" && npmMutating.has(sub)) {
-            return true;
-        }
-    }
     return false;
 }
 export const isMutatingCommand = (rawCommand) => {

package/dist/utils/command-protection.d.ts

@@ -1,20 +1,16 @@
-/**
- * Command Protection Module
- * Detects and blocks destructive commands that could cause data loss
- */
 export interface BlockedCommandResult {
     blocked: true;
     reason: string;
     command: string;
     tip: string;
 }
-export interface SafeCommandResult {
+interface SafeCommandResult {
     blocked: false;
 }
 /**
  * Result type for command safety check
  */
-export type CommandSafetyResult = BlockedCommandResult | SafeCommandResult;
+type CommandSafetyResult = BlockedCommandResult | SafeCommandResult;
 /**
  * Detects if a command is destructive and should be blocked
  * @param command - The full command string to check
@@ -25,4 +21,5 @@ export declare function detectDestructiveCommand(command: string): CommandSafety
  * Generate a user-friendly blocked command message
  */
 export declare function formatBlockedCommandMessage(result: BlockedCommandResult): string;
+export {};
 //# sourceMappingURL=command-protection.d.ts.map

package/dist/utils/command-protection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-protection.d.ts","sourceRoot":"","sources":["../../source/utils/command-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,KAAK,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,GAAG,iBAAiB,CAAC;AA0E3E;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,CA4B7E;AA8WD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,oBAAoB,GAC3B,MAAM,CAQR"}
+{"version":3,"file":"command-protection.d.ts","sourceRoot":"","sources":["../../source/utils/command-protection.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,UAAU,iBAAiB;IACzB,OAAO,EAAE,KAAK,CAAC;CAChB;AAoBD;;GAEG;AACH,KAAK,mBAAmB,GAAG,oBAAoB,GAAG,iBAAiB,CAAC;AA0EpE;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,CA4B7E;AA0fD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,oBAAoB,GAC3B,MAAM,CAQR"}