typescript-virtual-container 1.1.1-b → 1.1.1-c

package/dist/commands/curl.js

@@ -0,0 +1,44 @@
+import { parseArgs } from "./command-helpers";
+import { assertPathAccess, normalizeTerminalOutput, resolvePath, runHostCommand, } from "./helpers";
+export const curlCommand = {
+    name: "curl",
+    params: ["[-o file] <url>"],
+    run: async ({ authUser, cwd, args, shell }) => {
+        const { flagsWithValues, positionals } = parseArgs(args, {
+            flagsWithValue: ["-o", "--output"],
+        });
+        const outputPath = flagsWithValues.get("-o") || flagsWithValues.get("--output") || null;
+        const url = positionals[0];
+        if (!url) {
+            return { stderr: "curl: missing URL", exitCode: 1 };
+        }
+        const passthroughArgs = outputPath
+            ? [...positionals, "-o", "-"]
+            : positionals;
+        const result = await runHostCommand("curl", passthroughArgs);
+        if (result.exitCode !== 0) {
+            return {
+                stderr: normalizeTerminalOutput(result.stderr || `curl: exited with code ${result.exitCode}`),
+                exitCode: result.exitCode,
+            };
+        }
+        if (outputPath) {
+            const target = resolvePath(cwd, outputPath);
+            assertPathAccess(authUser, target, "curl");
+            shell.writeFileAsUser(authUser, target, result.stdout);
+            return {
+                stderr: result.stderr
+                    ? normalizeTerminalOutput(result.stderr)
+                    : undefined,
+                exitCode: 0,
+            };
+        }
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr
+                ? normalizeTerminalOutput(result.stderr)
+                : undefined,
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/deluser.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const deluserCommand: ShellModule;
+//# sourceMappingURL=deluser.d.ts.map

package/dist/commands/deluser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deluser.d.ts","sourceRoot":"","sources":["../../src/commands/deluser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,cAAc,EAAE,WAgB5B,CAAC"}

package/dist/commands/deluser.js

@@ -0,0 +1,15 @@
+export const deluserCommand = {
+    name: "deluser",
+    params: ["<username>"],
+    run: async ({ authUser, args, shell }) => {
+        if (authUser !== "root") {
+            return { stderr: "deluser: permission denied", exitCode: 1 };
+        }
+        const [username] = args;
+        if (!username) {
+            return { stderr: "deluser: usage: deluser <username>", exitCode: 1 };
+        }
+        await shell.users.deleteUser(username);
+        return { stdout: `deluser: user '${username}' deleted`, exitCode: 0 };
+    },
+};

package/dist/commands/echo.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const echoCommand: ShellModule;
+//# sourceMappingURL=echo.d.ts.map

package/dist/commands/echo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echo.d.ts","sourceRoot":"","sources":["../../src/commands/echo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAUrD,eAAO,MAAM,WAAW,EAAE,WAgBzB,CAAC"}

package/dist/commands/echo.js

@@ -0,0 +1,22 @@
+import { parseArgs } from "./command-helpers";
+import { getAllEnvVars } from "./set";
+function expandEnvVars(input, env) {
+    return input.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, name) => {
+        return env[name] ?? "";
+    });
+}
+export const echoCommand = {
+    name: "echo",
+    params: ["[options] [text...]"],
+    run: ({ args, authUser, stdin }) => {
+        const { flags, positionals } = parseArgs(args, { flags: ["-n"] });
+        const newline = !flags.has("-n");
+        const rawText = positionals.length > 0 ? positionals.join(" ") : (stdin ?? "");
+        const env = getAllEnvVars(authUser);
+        const text = expandEnvVars(rawText, env);
+        return {
+            stdout: newline ? text : text.trimEnd(),
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/env.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const envCommand: ShellModule;
+//# sourceMappingURL=env.d.ts.map

package/dist/commands/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/commands/env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,UAAU,EAAE,WAkBxB,CAAC"}

package/dist/commands/env.js

@@ -0,0 +1,18 @@
+import { getAllEnvVars } from "./set";
+export const envCommand = {
+    name: "env",
+    params: ["[VAR=value...] [command]"],
+    run: ({ authUser }) => {
+        // For now, just display all environment variables
+        // In a full implementation, this would also handle running commands with modified env
+        const allVars = getAllEnvVars(authUser);
+        const envVarsOutput = Object.entries(allVars)
+            .map(([key, value]) => `${key}=${value}`)
+            .sort()
+            .join("\n");
+        return {
+            stdout: envVarsOutput,
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/exit.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const exitCommand: ShellModule;
+//# sourceMappingURL=exit.d.ts.map

package/dist/commands/exit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.d.ts","sourceRoot":"","sources":["../../src/commands/exit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,WAAW,EAAE,WAIzB,CAAC"}

package/dist/commands/exit.js

@@ -0,0 +1,5 @@
+export const exitCommand = {
+    name: "exit",
+    params: [],
+    run: () => ({ closeSession: true, exitCode: 0 }),
+};

package/dist/commands/export.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const exportCommand: ShellModule;
+//# sourceMappingURL=export.d.ts.map

package/dist/commands/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/commands/export.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,aAAa,EAAE,WAiC3B,CAAC"}

package/dist/commands/export.js

@@ -0,0 +1,34 @@
+import { getArg } from "./command-helpers";
+import { getEnvVar, setEnvVar } from "./set";
+export const exportCommand = {
+    name: "export",
+    params: ["[VAR=value]"],
+    run: ({ args }) => {
+        // export VAR=value or export VAR (to make it available to child processes)
+        if (args.length === 0) {
+            // List all exported variables
+            return {
+                stdout: "# export command - sets variables for child processes",
+                exitCode: 0,
+            };
+        }
+        // Parse VAR=value format
+        for (let index = 0;; index += 1) {
+            const arg = getArg(args, index);
+            if (!arg) {
+                break;
+            }
+            if (arg.includes("=")) {
+                const [varName, varValue] = arg.split("=", 2);
+                if (varName && varValue !== undefined) {
+                    setEnvVar(varName, varValue);
+                }
+            }
+            else {
+                // export VAR_NAME makes it available but we just set it
+                setEnvVar(arg, getEnvVar(arg) || "");
+            }
+        }
+        return { exitCode: 0 };
+    },
+};

package/dist/commands/grep.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const grepCommand: ShellModule;
+//# sourceMappingURL=grep.d.ts.map

package/dist/commands/grep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../src/commands/grep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,WAAW,EAAE,WA2EzB,CAAC"}

package/dist/commands/grep.js

@@ -0,0 +1,69 @@
+import { parseArgs } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+export const grepCommand = {
+    name: "grep",
+    params: ["[-i] [-v] <pattern> [file...]"],
+    run: ({ authUser, shell, cwd, args, stdin }) => {
+        const { flags, positionals } = parseArgs(args, { flags: ["-i", "-v"] });
+        const caseInsensitive = flags.has("-i");
+        const invertMatch = flags.has("-v");
+        const pattern = positionals[0];
+        const files = positionals.slice(1);
+        if (!pattern) {
+            return { stderr: "grep: no pattern specified", exitCode: 1 };
+        }
+        let regex;
+        try {
+            const flags = caseInsensitive ? "gmi" : "gm";
+            regex = new RegExp(pattern, flags);
+        }
+        catch {
+            return { stderr: `grep: invalid regex: ${pattern}`, exitCode: 1 };
+        }
+        const results = [];
+        if (files.length === 0) {
+            if (!stdin) {
+                return { stdout: "", exitCode: 1 };
+            }
+            const lines = stdin.split("\n");
+            for (const line of lines) {
+                regex.lastIndex = 0;
+                const matches = regex.test(line);
+                const shouldInclude = invertMatch ? !matches : matches;
+                if (shouldInclude) {
+                    results.push(line);
+                }
+            }
+            return {
+                stdout: results.length > 0 ? results.join("\n") : "",
+                exitCode: results.length > 0 ? 0 : 1,
+            };
+        }
+        for (const file of files) {
+            const target = resolvePath(cwd, file);
+            try {
+                assertPathAccess(authUser, target, "grep");
+                const content = shell.vfs.readFile(target);
+                const lines = content.split("\n");
+                for (const line of lines) {
+                    regex.lastIndex = 0;
+                    const matches = regex.test(line);
+                    const shouldInclude = invertMatch ? !matches : matches;
+                    if (shouldInclude) {
+                        results.push(line);
+                    }
+                }
+            }
+            catch {
+                return {
+                    stderr: `grep: ${file}: No such file or directory`,
+                    exitCode: 1,
+                };
+            }
+        }
+        return {
+            stdout: results.length > 0 ? results.join("\n") : "",
+            exitCode: results.length > 0 ? 0 : 1,
+        };
+    },
+};

package/dist/commands/help.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare function createHelpCommand(getNames: () => string[]): ShellModule;
+//# sourceMappingURL=help.d.ts.map

package/dist/commands/help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../src/commands/help.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,MAAM,EAAE,GAAG,WAAW,CAMvE"}

package/dist/commands/help.js

@@ -0,0 +1,7 @@
+export function createHelpCommand(getNames) {
+    return {
+        name: "help",
+        params: [],
+        run: () => ({ stdout: `Builtins: ${getNames().join(" ")}`, exitCode: 0 }),
+    };
+}

package/dist/commands/helpers.d.ts

@@ -0,0 +1,26 @@
+import type VirtualFileSystem from "../VirtualFileSystem";
+export declare function normalizeTerminalOutput(text: string): string;
+export declare function resolvePath(cwd: string, inputPath: string): string;
+export declare function assertPathAccess(authUser: string, targetPath: string, operation: string): void;
+export declare function stripUrlFilename(url: string): string;
+export declare function fetchResource(url: string): Promise<{
+    text: string;
+    status: number;
+    contentType: string | null;
+}>;
+/**
+ * Run a host command like curl or wget and capture its output.
+ * @param binary - The binary to execute (e.g., "curl", "wget").
+ * @param args - Arguments to pass to the binary.
+ * @returns Promise resolving with stdout, stderr, and exit code.
+ */
+export declare function runHostCommand(binary: string, args: string[]): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+export declare function resolveReadablePath(vfs: VirtualFileSystem, cwd: string, inputPath: string): string;
+export declare function joinListWithType(cwd: string, items: string[], statAt: (p: string) => {
+    type: "file" | "directory";
+}): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/commands/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/commands/helpers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,iBAAiB,MAAM,sBAAsB,CAAC;AAY1D,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAY5D;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAOlE;AAYD,wBAAgB,gBAAgB,CAC/B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GACf,IAAI,CAQN;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIpD;AAED,wBAAsB,aAAa,CAClC,GAAG,EAAE,MAAM,GACT,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAQvE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EAAE,GACZ,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA8D/D;AA4BD,wBAAgB,mBAAmB,CAClC,GAAG,EAAE,iBAAiB,EACtB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,GACf,MAAM,CAyBR;AAED,wBAAgB,gBAAgB,CAC/B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK;IAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;CAAE,GACnD,MAAM,CAQR"}

package/dist/commands/helpers.js

@@ -0,0 +1,160 @@
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+const PROTECTED_PREFIXES = ["/virtual-env-js/.auth"];
+function normalizeFetchUrl(input) {
+    if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input)) {
+        return input;
+    }
+    return `http://${input}`;
+}
+export function normalizeTerminalOutput(text) {
+    return text
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        .replace(/\t/g, "  ")
+        .split("\n")
+        .map((line) => line.replace(/^[ \u00A0]{8,}/, "  ").replace(/[ \u00A0]{3,}/g, "  "))
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trimEnd();
+}
+export function resolvePath(cwd, inputPath) {
+    if (!inputPath || inputPath.trim() === "") {
+        return cwd;
+    }
+    return inputPath.startsWith("/")
+        ? path.posix.normalize(inputPath)
+        : path.posix.normalize(path.posix.join(cwd, inputPath));
+}
+function isProtectedPath(targetPath) {
+    const normalized = targetPath.startsWith("/")
+        ? path.posix.normalize(targetPath)
+        : path.posix.normalize(`/${targetPath}`);
+    return PROTECTED_PREFIXES.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`));
+}
+export function assertPathAccess(authUser, targetPath, operation) {
+    if (authUser === "root") {
+        return;
+    }
+    if (isProtectedPath(targetPath)) {
+        throw new Error(`${operation}: permission denied: ${targetPath}`);
+    }
+}
+export function stripUrlFilename(url) {
+    const cleaned = url.split("?")[0]?.split("#")[0] ?? url;
+    const lastPart = cleaned.split("/").filter(Boolean).pop();
+    return lastPart && lastPart.length > 0 ? lastPart : "index.html";
+}
+export async function fetchResource(url) {
+    const response = await fetch(normalizeFetchUrl(url));
+    const contentType = response.headers.get("content-type");
+    return {
+        text: await response.text(),
+        status: response.status,
+        contentType,
+    };
+}
+/**
+ * Run a host command like curl or wget and capture its output.
+ * @param binary - The binary to execute (e.g., "curl", "wget").
+ * @param args - Arguments to pass to the binary.
+ * @returns Promise resolving with stdout, stderr, and exit code.
+ */
+export function runHostCommand(binary, args) {
+    return new Promise((resolve) => {
+        let childProcess;
+        try {
+            childProcess = spawn(binary, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            resolve({
+                stdout: "",
+                stderr: `${binary}: ${error instanceof Error ? error.message : String(error)}`,
+                exitCode: 1,
+            });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        const stdoutStream = childProcess.stdout;
+        const stderrStream = childProcess.stderr;
+        if (!stdoutStream || !stderrStream) {
+            resolve({
+                stdout: "",
+                stderr: `${binary}: failed to capture process output`,
+                exitCode: 1,
+            });
+            return;
+        }
+        stdoutStream.setEncoding("utf8");
+        stderrStream.setEncoding("utf8");
+        stdoutStream.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        stderrStream.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        childProcess.on("error", (error) => {
+            const errorCode = error instanceof Error && "code" in error
+                ? String(error.code ?? "")
+                : "";
+            resolve({
+                stdout: "",
+                stderr: `${binary}: ${error.message}`,
+                exitCode: errorCode === "ENOENT" ? 127 : 1,
+            });
+        });
+        childProcess.on("close", (code) => {
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code ?? 1,
+            });
+        });
+    });
+}
+function levenshtein(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+    for (let i = 0; i <= a.length; i += 1) {
+        dp[i][0] = i;
+    }
+    for (let j = 0; j <= b.length; j += 1) {
+        dp[0][j] = j;
+    }
+    for (let i = 1; i <= a.length; i += 1) {
+        for (let j = 1; j <= b.length; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp[a.length][b.length];
+}
+export function resolveReadablePath(vfs, cwd, inputPath) {
+    const exactPath = resolvePath(cwd, inputPath);
+    if (vfs.exists(exactPath)) {
+        return exactPath;
+    }
+    const parent = path.posix.dirname(exactPath);
+    const fileName = path.posix.basename(exactPath);
+    const siblings = vfs.list(parent);
+    const caseInsensitive = siblings.filter((name) => name.toLowerCase() === fileName.toLowerCase());
+    if (caseInsensitive.length === 1) {
+        return path.posix.join(parent, caseInsensitive[0]);
+    }
+    const near = siblings.filter((name) => levenshtein(name.toLowerCase(), fileName.toLowerCase()) <= 1);
+    if (near.length === 1) {
+        return path.posix.join(parent, near[0]);
+    }
+    return exactPath;
+}
+export function joinListWithType(cwd, items, statAt) {
+    return items
+        .map((name) => {
+        const childPath = resolvePath(cwd, name);
+        const stats = statAt(childPath);
+        return stats.type === "directory" ? `${name}/` : name;
+    })
+        .join("  ");
+}

package/dist/commands/hostname.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const hostnameCommand: ShellModule;
+//# sourceMappingURL=hostname.d.ts.map

package/dist/commands/hostname.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostname.d.ts","sourceRoot":"","sources":["../../src/commands/hostname.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,eAAe,EAAE,WAI7B,CAAC"}

package/dist/commands/hostname.js

@@ -0,0 +1,5 @@
+export const hostnameCommand = {
+    name: "hostname",
+    params: [],
+    run: ({ hostname }) => ({ stdout: hostname, exitCode: 0 }),
+};

package/dist/commands/htop.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const htopCommand: ShellModule;
+//# sourceMappingURL=htop.d.ts.map

package/dist/commands/htop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htop.d.ts","sourceRoot":"","sources":["../../src/commands/htop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,WAAW,EAAE,WAUzB,CAAC"}

package/dist/commands/htop.js

@@ -0,0 +1,10 @@
+export const htopCommand = {
+    name: "htop",
+    params: [],
+    run: ({ mode }) => {
+        if (mode === "exec") {
+            return { stderr: "htop: interactive terminal required", exitCode: 1 };
+        }
+        return { openHtop: true, exitCode: 0 };
+    },
+};

package/dist/commands/index.d.ts

@@ -0,0 +1,8 @@
+import type { VirtualShell } from "../VirtualShell";
+import type { CommandContext, CommandMode, CommandResult, ShellModule } from "../types/commands";
+export declare function registerCommand(module: ShellModule): void;
+export declare function createCustomCommand(name: string, params: string[], run: (ctx: CommandContext) => CommandResult | Promise<CommandResult>): ShellModule;
+export declare function getCommandNames(): string[];
+export declare function resolveModule(name: string): ShellModule | undefined;
+export declare function runCommand(rawInput: string, authUser: string, hostname: string, mode: CommandMode, cwd: string, shell: VirtualShell, stdin?: string): Promise<CommandResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EACX,cAAc,EACd,WAAW,EACX,aAAa,EACb,WAAW,EACX,MAAM,mBAAmB,CAAC;AA8F3B,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAsBzD;AAED,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,EAChB,GAAG,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,GAClE,WAAW,CAMb;AAED,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAK1C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAKnE;AAsDD,wBAAsB,UAAU,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,YAAY,EACnB,KAAK,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,CAAC,CA6DxB"}