@alibaba-group/opensandbox 0.1.0-dev1

package/dist/adapters/filesystemAdapter.js

@@ -0,0 +1,398 @@
+// Copyright 2026 Alibaba Group Holding Ltd.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { throwOnOpenApiFetchError } from "./openapiError.js";
+import { SandboxApiException, SandboxError } from "../core/exceptions.js";
+function joinUrl(baseUrl, pathname) {
+    const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    return `${base}${path}`;
+}
+function toUploadBlob(data) {
+    if (typeof data === "string")
+        return new Blob([data]);
+    if (data instanceof Blob)
+        return data;
+    if (data instanceof ArrayBuffer)
+        return new Blob([data]);
+    // Copy into a new Uint8Array backed by ArrayBuffer (not SharedArrayBuffer)
+    const copied = Uint8Array.from(data);
+    return new Blob([copied.buffer]);
+}
+function isReadableStream(v) {
+    return !!v && typeof v.getReader === "function";
+}
+function isAsyncIterable(v) {
+    return !!v && typeof v[Symbol.asyncIterator] === "function";
+}
+function toReadableStream(it) {
+    const RS = ReadableStream;
+    if (typeof RS?.from === "function")
+        return RS.from(it);
+    const iterator = it[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const r = await iterator.next();
+            if (r.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(r.value);
+        },
+        async cancel() {
+            await iterator.return?.();
+        },
+    });
+}
+function basename(p) {
+    const parts = p.split("/").filter(Boolean);
+    return parts.length ? parts[parts.length - 1] : "file";
+}
+function encodeUtf8(s) {
+    return new TextEncoder().encode(s);
+}
+async function* multipartUploadBody(opts) {
+    const b = opts.boundary;
+    // Part 1: metadata (application/json)
+    yield encodeUtf8(`--${b}\r\n`);
+    yield encodeUtf8(`Content-Disposition: form-data; name="metadata"; filename="metadata"\r\n`);
+    yield encodeUtf8(`Content-Type: application/json\r\n\r\n`);
+    yield encodeUtf8(opts.metadataJson);
+    yield encodeUtf8(`\r\n`);
+    // Part 2: file
+    yield encodeUtf8(`--${b}\r\n`);
+    yield encodeUtf8(`Content-Disposition: form-data; name="file"; filename="${opts.fileName}"\r\n`);
+    yield encodeUtf8(`Content-Type: ${opts.fileContentType}\r\n\r\n`);
+    if (isReadableStream(opts.file)) {
+        const reader = opts.file.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    else {
+        for await (const chunk of opts.file) {
+            yield chunk;
+        }
+    }
+    yield encodeUtf8(`\r\n--${b}--\r\n`);
+}
+function toPermission(e) {
+    return {
+        mode: e.mode ?? 755,
+        owner: e.owner,
+        group: e.group,
+    };
+}
+/**
+ * Filesystem adapter that exposes user-facing file APIs (`sandbox.files`).
+ *
+ * This adapter owns all request/response conversions:
+ * - Maps friendly method shapes to API payloads
+ * - Parses timestamps into `Date`
+ * - Implements streaming upload/download helpers
+ */
+export class FilesystemAdapter {
+    client;
+    opts;
+    fetch;
+    static Api = {
+        // This is intentionally derived from OpenAPI schema types so API changes surface quickly.
+        SearchFilesOk: null,
+        FilesInfoOk: null,
+        MakeDirsRequest: null,
+        SetPermissionsRequest: null,
+        MoveFilesRequest: null,
+        ReplaceContentsRequest: null,
+    };
+    constructor(client, opts) {
+        this.client = client;
+        this.opts = opts;
+        this.fetch = opts.fetch ?? fetch;
+    }
+    parseIsoDate(field, v) {
+        if (typeof v !== "string" || !v) {
+            throw new Error(`Invalid ${field}: expected ISO string, got ${typeof v}`);
+        }
+        const d = new Date(v);
+        if (Number.isNaN(d.getTime())) {
+            throw new Error(`Invalid ${field}: ${v}`);
+        }
+        return d;
+    }
+    static _ApiFileInfo = null;
+    mapApiFileInfo(raw) {
+        const { path, size, created_at, modified_at, mode, owner, group, ...rest } = raw;
+        return {
+            ...rest,
+            path,
+            size,
+            mode,
+            owner,
+            group,
+            createdAt: created_at
+                ? this.parseIsoDate("createdAt", created_at)
+                : undefined,
+            modifiedAt: modified_at
+                ? this.parseIsoDate("modifiedAt", modified_at)
+                : undefined,
+        };
+    }
+    async getFileInfo(paths) {
+        const { data, error, response } = await this.client.GET("/files/info", {
+            params: { query: { path: paths } },
+        });
+        throwOnOpenApiFetchError({ error, response }, "Get file info failed");
+        const raw = data;
+        if (!raw)
+            return {};
+        if (typeof raw !== "object") {
+            throw new Error(`Get file info failed: unexpected response shape (got ${typeof raw})`);
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(raw)) {
+            if (!v || typeof v !== "object") {
+                throw new Error(`Get file info failed: invalid file info for path=${k}`);
+            }
+            out[k] = this.mapApiFileInfo(v);
+        }
+        return out;
+    }
+    async deleteFiles(paths) {
+        const { error, response } = await this.client.DELETE("/files", {
+            params: { query: { path: paths } },
+        });
+        throwOnOpenApiFetchError({ error, response }, "Delete files failed");
+    }
+    async createDirectories(entries) {
+        const map = {};
+        for (const e of entries) {
+            map[e.path] = toPermission(e);
+        }
+        const body = map;
+        const { error, response } = await this.client.POST("/directories", {
+            body,
+        });
+        throwOnOpenApiFetchError({ error, response }, "Create directories failed");
+    }
+    async deleteDirectories(paths) {
+        const { error, response } = await this.client.DELETE("/directories", {
+            params: { query: { path: paths } },
+        });
+        throwOnOpenApiFetchError({ error, response }, "Delete directories failed");
+    }
+    async setPermissions(entries) {
+        const req = {};
+        for (const e of entries) {
+            req[e.path] = toPermission(e);
+        }
+        const body = req;
+        const { error, response } = await this.client.POST("/files/permissions", {
+            body,
+        });
+        throwOnOpenApiFetchError({ error, response }, "Set permissions failed");
+    }
+    async moveFiles(entries) {
+        const req = entries.map((e) => ({
+            src: e.src,
+            dest: e.dest,
+        }));
+        const body = req;
+        const { error, response } = await this.client.POST("/files/mv", {
+            body,
+        });
+        throwOnOpenApiFetchError({ error, response }, "Move files failed");
+    }
+    async replaceContents(entries) {
+        const req = {};
+        for (const e of entries) {
+            req[e.path] = { old: e.oldContent, new: e.newContent };
+        }
+        const body = req;
+        const { error, response } = await this.client.POST("/files/replace", {
+            body,
+        });
+        throwOnOpenApiFetchError({ error, response }, "Replace contents failed");
+    }
+    async search(entry) {
+        const { data, error, response } = await this.client.GET("/files/search", {
+            params: { query: { path: entry.path, pattern: entry.pattern } },
+        });
+        throwOnOpenApiFetchError({ error, response }, "Search files failed");
+        // Make the OpenAPI contract explicit (and fail loudly on unexpected shapes).
+        const ok = data;
+        if (!ok)
+            return [];
+        if (!Array.isArray(ok)) {
+            throw new Error(`Search files failed: unexpected response shape (expected array, got ${typeof ok})`);
+        }
+        return ok.map((x) => this.mapApiFileInfo(x));
+    }
+    async uploadFile(meta, data) {
+        const url = joinUrl(this.opts.baseUrl, "/files/upload");
+        const fileName = basename(meta.path);
+        const metadataJson = JSON.stringify(meta);
+        // Streaming path (large files): build multipart body manually to avoid buffering.
+        if (isReadableStream(data) || isAsyncIterable(data)) {
+            const boundary = `opensandbox_${Math.random()
+                .toString(16)
+                .slice(2)}_${Date.now()}`;
+            const bodyIt = multipartUploadBody({
+                boundary,
+                metadataJson,
+                fileName,
+                fileContentType: "application/octet-stream",
+                file: data,
+            });
+            const stream = toReadableStream(bodyIt);
+            const res = await this.fetch(url, {
+                method: "POST",
+                headers: {
+                    "content-type": `multipart/form-data; boundary=${boundary}`,
+                    ...(this.opts.headers ?? {}),
+                },
+                body: stream,
+                // Node fetch (undici) requires duplex for streaming request bodies.
+                duplex: "half",
+            });
+            if (!res.ok) {
+                const requestId = res.headers.get("x-request-id") ?? undefined;
+                const rawBody = await res.text().catch(() => undefined);
+                throw new SandboxApiException({
+                    message: `Upload failed (status=${res.status})`,
+                    statusCode: res.status,
+                    requestId,
+                    error: new SandboxError(SandboxError.UNEXPECTED_RESPONSE, "Upload failed"),
+                    rawBody,
+                });
+            }
+            return;
+        }
+        // In-memory path (small files): use FormData.
+        const form = new FormData();
+        form.append("metadata", new Blob([metadataJson], { type: "application/json" }), "metadata");
+        if (typeof data === "string") {
+            const textBlob = new Blob([data], { type: "text/plain; charset=utf-8" });
+            form.append("file", textBlob, fileName);
+        }
+        else {
+            const blob = toUploadBlob(data);
+            const fileBlob = blob.type
+                ? blob
+                : new Blob([blob], { type: "application/octet-stream" });
+            form.append("file", fileBlob, fileName);
+        }
+        const res = await this.fetch(url, {
+            method: "POST",
+            headers: {
+                ...(this.opts.headers ?? {}),
+            },
+            body: form,
+        });
+        if (!res.ok) {
+            const requestId = res.headers.get("x-request-id") ?? undefined;
+            const rawBody = await res.text().catch(() => undefined);
+            throw new SandboxApiException({
+                message: `Upload failed (status=${res.status})`,
+                statusCode: res.status,
+                requestId,
+                error: new SandboxError(SandboxError.UNEXPECTED_RESPONSE, "Upload failed"),
+                rawBody,
+            });
+        }
+    }
+    async readBytes(path, opts) {
+        const url = joinUrl(this.opts.baseUrl, "/files/download") +
+            `?path=${encodeURIComponent(path)}`;
+        const res = await this.fetch(url, {
+            method: "GET",
+            headers: {
+                ...(this.opts.headers ?? {}),
+                ...(opts?.range ? { Range: opts.range } : {}),
+            },
+        });
+        if (!res.ok) {
+            const requestId = res.headers.get("x-request-id") ?? undefined;
+            const rawBody = await res.text().catch(() => undefined);
+            throw new SandboxApiException({
+                message: "Download failed",
+                statusCode: res.status,
+                requestId,
+                error: new SandboxError(SandboxError.UNEXPECTED_RESPONSE, "Download failed"),
+                rawBody,
+            });
+        }
+        const ab = await res.arrayBuffer();
+        return new Uint8Array(ab);
+    }
+    readBytesStream(path, opts) {
+        return this.downloadStream(path, opts);
+    }
+    async *downloadStream(path, opts) {
+        const url = joinUrl(this.opts.baseUrl, "/files/download") +
+            `?path=${encodeURIComponent(path)}`;
+        const res = await this.fetch(url, {
+            method: "GET",
+            headers: {
+                ...(this.opts.headers ?? {}),
+                ...(opts?.range ? { Range: opts.range } : {}),
+            },
+        });
+        if (!res.ok) {
+            const requestId = res.headers.get("x-request-id") ?? undefined;
+            const rawBody = await res.text().catch(() => undefined);
+            throw new SandboxApiException({
+                message: "Download stream failed",
+                statusCode: res.status,
+                requestId,
+                error: new SandboxError(SandboxError.UNEXPECTED_RESPONSE, "Download stream failed"),
+                rawBody,
+            });
+        }
+        const body = res.body;
+        if (!body)
+            return;
+        const reader = body.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            if (value)
+                yield value;
+        }
+    }
+    async readFile(path, opts) {
+        const bytes = await this.readBytes(path, { range: opts?.range });
+        const encoding = opts?.encoding ?? "utf-8";
+        return new TextDecoder(encoding).decode(bytes);
+    }
+    async writeFiles(entries) {
+        for (const e of entries) {
+            const meta = {
+                path: e.path,
+                owner: e.owner,
+                group: e.group,
+                mode: e.mode,
+            };
+            await this.uploadFile(meta, e.data ?? "");
+        }
+    }
+}

package/dist/adapters/healthAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { ExecdClient } from "../openapi/execdClient.js";
+import type { ExecdHealth } from "../services/execdHealth.js";
+export declare class HealthAdapter implements ExecdHealth {
+    private readonly client;
+    constructor(client: ExecdClient);
+    ping(): Promise<boolean>;
+}
+//# sourceMappingURL=healthAdapter.d.ts.map

package/dist/adapters/healthAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"healthAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/healthAdapter.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,qBAAa,aAAc,YAAW,WAAW;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,WAAW;IAE1C,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;CAK/B"}

package/dist/adapters/healthAdapter.js

@@ -0,0 +1,25 @@
+// Copyright 2026 Alibaba Group Holding Ltd.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { throwOnOpenApiFetchError } from "./openapiError.js";
+export class HealthAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async ping() {
+        const { error, response } = await this.client.GET("/ping");
+        throwOnOpenApiFetchError({ error, response }, "Execd ping failed");
+        return true;
+    }
+}

package/dist/adapters/metricsAdapter.d.ts

@@ -0,0 +1,9 @@
+import type { ExecdClient } from "../openapi/execdClient.js";
+import type { SandboxMetrics } from "../models/execd.js";
+import type { ExecdMetrics } from "../services/execdMetrics.js";
+export declare class MetricsAdapter implements ExecdMetrics {
+    private readonly client;
+    constructor(client: ExecdClient);
+    getMetrics(): Promise<SandboxMetrics>;
+}
+//# sourceMappingURL=metricsAdapter.d.ts.map

package/dist/adapters/metricsAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricsAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/metricsAdapter.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAG7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAoBhE,qBAAa,cAAe,YAAW,YAAY;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,WAAW;IAE1C,UAAU,IAAI,OAAO,CAAC,cAAc,CAAC;CAS5C"}

package/dist/adapters/metricsAdapter.js

@@ -0,0 +1,43 @@
+// Copyright 2026 Alibaba Group Holding Ltd.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { throwOnOpenApiFetchError } from "./openapiError.js";
+function normalizeMetrics(m) {
+    const cpuCount = m.cpu_count ?? 0;
+    const cpuUsedPercentage = m.cpu_used_pct ?? 0;
+    const memoryTotalMiB = m.mem_total_mib ?? 0;
+    const memoryUsedMiB = m.mem_used_mib ?? 0;
+    const timestamp = m.timestamp ?? 0;
+    return {
+        cpuCount: Number(cpuCount),
+        cpuUsedPercentage: Number(cpuUsedPercentage),
+        memoryTotalMiB: Number(memoryTotalMiB),
+        memoryUsedMiB: Number(memoryUsedMiB),
+        timestamp: Number(timestamp),
+    };
+}
+export class MetricsAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getMetrics() {
+        const { data, error, response } = await this.client.GET("/metrics");
+        throwOnOpenApiFetchError({ error, response }, "Get execd metrics failed");
+        const ok = data;
+        if (!ok || typeof ok !== "object") {
+            throw new Error("Get execd metrics failed: unexpected response shape");
+        }
+        return normalizeMetrics(ok);
+    }
+}

package/dist/adapters/openapiError.d.ts

@@ -0,0 +1,5 @@
+export declare function throwOnOpenApiFetchError(result: {
+    error?: unknown;
+    response: Response;
+}, fallbackMessage: string): void;
+//# sourceMappingURL=openapiError.d.ts.map

package/dist/adapters/openapiError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapiError.d.ts","sourceRoot":"","sources":["../../src/adapters/openapiError.ts"],"names":[],"mappings":"AAgBA,wBAAgB,wBAAwB,CACtC,MAAM,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,EAC/C,eAAe,EAAE,MAAM,GACtB,IAAI,CAsBN"}

package/dist/adapters/openapiError.js

@@ -0,0 +1,33 @@
+// Copyright 2026 Alibaba Group Holding Ltd.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { SandboxApiException, SandboxError } from "../core/exceptions.js";
+export function throwOnOpenApiFetchError(result, fallbackMessage) {
+    if (!result.error)
+        return;
+    const requestId = result.response.headers.get("x-request-id") ?? undefined;
+    const status = result.response.status ?? 0;
+    const err = result.error;
+    const message = err?.message ??
+        err?.error?.message ??
+        fallbackMessage;
+    const code = err?.code ?? err?.error?.code;
+    const msg = err?.message ?? err?.error?.message ?? message;
+    throw new SandboxApiException({
+        message: msg,
+        statusCode: status,
+        requestId,
+        error: code ? new SandboxError(String(code), String(msg ?? "")) : new SandboxError(SandboxError.UNEXPECTED_RESPONSE, String(msg ?? "")),
+        rawBody: result.error,
+    });
+}

package/dist/adapters/sandboxesAdapter.d.ts

@@ -0,0 +1,18 @@
+import type { LifecycleClient } from "../openapi/lifecycleClient.js";
+import type { Sandboxes } from "../services/sandboxes.js";
+import type { CreateSandboxRequest, CreateSandboxResponse, Endpoint, ListSandboxesParams, ListSandboxesResponse, RenewSandboxExpirationRequest, RenewSandboxExpirationResponse, SandboxId, SandboxInfo } from "../models/sandboxes.js";
+export declare class SandboxesAdapter implements Sandboxes {
+    private readonly client;
+    constructor(client: LifecycleClient);
+    private parseIsoDate;
+    private mapSandboxInfo;
+    createSandbox(req: CreateSandboxRequest): Promise<CreateSandboxResponse>;
+    getSandbox(sandboxId: SandboxId): Promise<SandboxInfo>;
+    listSandboxes(params?: ListSandboxesParams): Promise<ListSandboxesResponse>;
+    deleteSandbox(sandboxId: SandboxId): Promise<void>;
+    pauseSandbox(sandboxId: SandboxId): Promise<void>;
+    resumeSandbox(sandboxId: SandboxId): Promise<void>;
+    renewSandboxExpiration(sandboxId: SandboxId, req: RenewSandboxExpirationRequest): Promise<RenewSandboxExpirationResponse>;
+    getSandboxEndpoint(sandboxId: SandboxId, port: number): Promise<Endpoint>;
+}
+//# sourceMappingURL=sandboxesAdapter.d.ts.map

package/dist/adapters/sandboxesAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandboxesAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/sandboxesAdapter.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAGrE,OAAO,KAAK,EACV,SAAS,EACV,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACrB,QAAQ,EACR,mBAAmB,EACnB,qBAAqB,EACrB,6BAA6B,EAC7B,8BAA8B,EAC9B,SAAS,EACT,WAAW,EACZ,MAAM,wBAAwB,CAAC;AA2BhC,qBAAa,gBAAiB,YAAW,SAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,eAAe;IAEpD,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,cAAc;IAQhB,aAAa,CAAC,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAkBxE,UAAU,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IAYtD,aAAa,CAAC,MAAM,GAAE,mBAAwB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAyB/E,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAOlD,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAOjD,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAOlD,sBAAsB,CAC1B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,6BAA6B,GACjC,OAAO,CAAC,8BAA8B,CAAC;IAiBpC,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;CAWhF"}