@openclaw/openshell-sandbox 2026.9.2 → 2026.9.4

package/node_modules/@openclaw/fs-safe/dist/json-durable-queue.js

@@ -0,0 +1,383 @@
+import fs, {} from "node:fs";
+import path from "node:path";
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { syncDirectory } from "./directory-durability.js";
+import { syncQueueDirectoryCreation } from "./json-durable-queue-directory.js";
+import { getErrorCode, acknowledgeDurableQueueEntry, claimDurableQueueEntry, completeDeliveredQueueEntry, moveDurableQueueEntryToFailed, } from "./json-durable-queue-ownership.js";
+import { stringifyJsonDocument } from "./json-stringify.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { replaceFileAtomicWithDirectorySync } from "./replace-file.js";
+import { assertSafePathSegment } from "./safe-path-segment.js";
+import { inspectFileIdentity } from "./strict-file-identity.js";
+export const DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES = 16 * 1024 * 1024;
+function assertSafeQueueEntryId(id) {
+    assertSafePathSegment(id, { label: "queue entry id" });
+}
+export async function unlinkBestEffort(filePath) {
+    await fs.promises.unlink(filePath).catch(() => undefined);
+}
+export async function jsonDurableQueueEntryExists(filePath) {
+    try {
+        const stat = await fs.promises.lstat(filePath);
+        return stat.isFile();
+    }
+    catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function unlinkStaleTmpBestEffort(filePath, now, maxAgeMs) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        if (stat.isFile() && now - stat.mtimeMs >= maxAgeMs) {
+            await unlinkBestEffort(filePath);
+        }
+    }
+    catch (error) {
+        if (getErrorCode(error) !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+export function resolveJsonDurableQueueEntryPaths(queueDir, id) {
+    assertSafeQueueEntryId(id);
+    return {
+        jsonPath: path.join(queueDir, `${id}.json`),
+        deliveredPath: path.join(queueDir, `${id}.delivered`),
+        processingPath: path.join(queueDir, `${id}.processing`),
+    };
+}
+export async function ensureJsonDurableQueueDirs(params) {
+    const roots = await queueValidationRoots(params.queueDir, params.failedDir);
+    await ensureJsonDurableQueueDir(params.queueDir, roots.queueRoot);
+    await ensureJsonDurableQueueDir(params.failedDir, roots.failedRoot);
+}
+async function ensureJsonDurableQueueDir(dir, validationRoot) {
+    const root = validationRoot
+        ? validationRoot
+        : queueValidationRoot(dir);
+    await assertNoSymlinkDirectorySegments(root, dir, true);
+    await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
+    await assertNoSymlinkDirectorySegments(root, dir, false);
+    await chmodQueueDirectory(dir);
+    await syncQueueDirectoryCreation(dir, root.path);
+}
+async function assertJsonDurableQueueDir(dir, validationRoot) {
+    const root = validationRoot
+        ? validationRoot
+        : queueValidationRoot(dir);
+    await assertNoSymlinkDirectorySegments(root, dir, false);
+}
+function commonPathAncestor(paths) {
+    const resolved = paths.map((entry) => path.resolve(entry));
+    const root = path.parse(resolved[0] ?? process.cwd()).root;
+    const parts = resolved.map((entry) => path.relative(root, entry).split(path.sep));
+    const common = [];
+    for (let index = 0; parts.every((part) => index < part.length); index++) {
+        const segment = parts[0]?.[index];
+        if (!segment || !parts.every((part) => part[index] === segment))
+            break;
+        common.push(segment);
+    }
+    return path.join(root, ...common);
+}
+function samePathRoot(paths) {
+    const roots = paths.map((entry) => path.parse(path.resolve(entry)).root);
+    const first = process.platform === "win32" ? roots[0]?.toLowerCase() : roots[0];
+    return roots.every((root) => (process.platform === "win32" ? root.toLowerCase() : root) === first);
+}
+async function queueValidationRoots(queueDir, failedDir) {
+    if (samePathRoot([queueDir, failedDir])) {
+        const common = commonPathAncestor([queueDir, failedDir]);
+        const root = queueValidationRoot(common);
+        return { failedRoot: root, queueRoot: root };
+    }
+    return {
+        failedRoot: queueValidationRoot(failedDir),
+        queueRoot: queueValidationRoot(queueDir),
+    };
+}
+function queueValidationRoot(dir) {
+    return {
+        path: path.parse(path.resolve(dir)).root,
+        allowSymlinkBase: process.platform === "darwin",
+    };
+}
+async function isDarwinSystemAlias(dir, stat) {
+    if (process.platform !== "darwin" || !stat.isSymbolicLink()) {
+        return false;
+    }
+    const resolved = path.resolve(dir);
+    if (resolved !== "/tmp" && resolved !== "/var") {
+        return false;
+    }
+    return await fs.promises.realpath(resolved).then((realPath) => realPath === `/private${resolved}`, () => false);
+}
+async function assertNoSymlinkDirectorySegments(validationRoot, dir, allowMissing) {
+    let base = path.resolve(validationRoot.path);
+    let target = path.resolve(dir);
+    let current = base;
+    let baseStat = await fs.promises.lstat(base);
+    if (baseStat.isSymbolicLink() && validationRoot.allowSymlinkBase) {
+        const relative = path.relative(base, target);
+        if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            throw new Error(`durable queue path is not a directory: ${dir}`);
+        }
+        base = await fs.promises.realpath(base);
+        target = path.join(base, ...relative.split(path.sep).filter(Boolean));
+        current = base;
+        baseStat = await fs.promises.lstat(base);
+    }
+    if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {
+        throw new Error(`durable queue path is not a directory: ${dir}`);
+    }
+    const segments = path.relative(base, target).split(path.sep).filter(Boolean);
+    for (let index = 0; index < segments.length; index++) {
+        const segment = segments[index];
+        if (segment === undefined) {
+            continue;
+        }
+        current = path.join(current, segment);
+        let stat;
+        try {
+            stat = await fs.promises.lstat(current);
+        }
+        catch (error) {
+            if (allowMissing && error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+        if (stat.isSymbolicLink() || !stat.isDirectory()) {
+            if (stat.isSymbolicLink() && validationRoot.allowSymlinkBase) {
+                if (await isDarwinSystemAlias(current, stat)) {
+                    current = await fs.promises.realpath(current);
+                    continue;
+                }
+            }
+            throw new Error(`durable queue path is not a directory: ${dir}`);
+        }
+    }
+}
+async function chmodQueueDirectory(dir) {
+    const noFollow = typeof fs.constants.O_NOFOLLOW === "number" && process.platform !== "win32"
+        ? fs.constants.O_NOFOLLOW
+        : 0;
+    const directoryFlag = typeof fs.constants.O_DIRECTORY === "number" && process.platform !== "win32"
+        ? fs.constants.O_DIRECTORY
+        : 0;
+    if (noFollow || directoryFlag) {
+        let handle;
+        try {
+            handle = await fs.promises.open(dir, fs.constants.O_RDONLY | noFollow | directoryFlag);
+            const stat = await handle.stat();
+            if (!stat.isDirectory()) {
+                throw new Error(`durable queue path is not a directory: ${dir}`);
+            }
+            try {
+                await handle.chmod(0o700);
+            }
+            catch {
+                // Best-effort on platforms that do not enforce POSIX modes.
+            }
+            return;
+        }
+        finally {
+            try {
+                await handle?.close();
+            }
+            catch {
+                // Best-effort cleanup after chmod/open failures.
+            }
+        }
+    }
+    const stat = await fs.promises.lstat(dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new Error(`durable queue path is not a directory: ${dir}`);
+    }
+    try {
+        await fs.promises.chmod(dir, 0o700);
+    }
+    catch {
+        // Best-effort on platforms that do not enforce POSIX modes.
+    }
+}
+export async function writeJsonDurableQueueEntry(params) {
+    await replaceFileAtomicWithDirectorySync({
+        filePath: params.filePath,
+        content: stringifyJsonDocument(params.entry, null, 2),
+        mode: 0o600,
+        tempPrefix: params.tempPrefix,
+        syncTempFile: true,
+    }, syncDirectory);
+}
+async function inspectQueueEntry(inspect, maxBytes, expected) {
+    let inspectionFailed = false;
+    try {
+        return await inspectFileIdentity(async () => {
+            try {
+                const stat = await inspect();
+                if (stat.isSymbolicLink() || !stat.isFile()) {
+                    throw new Error("queue entry is not a regular file");
+                }
+                if (stat.nlink > 1n)
+                    throw new Error("queue entry hardlinks are not allowed");
+                if (stat.size > maxBytes)
+                    throw new Error(`queue entry exceeds ${maxBytes} bytes`);
+                return stat;
+            }
+            catch (error) {
+                inspectionFailed = true;
+                throw error;
+            }
+        }, expected);
+    }
+    catch (error) {
+        // Translate only the identity helper's rejection, never inspection errors.
+        if (inspectionFailed)
+            throw error;
+        throw new Error("queue entry changed during read", { cause: error });
+    }
+}
+async function readBoundedUtf8File(params) {
+    const inspectPath = () => fs.promises.lstat(params.filePath, { bigint: true });
+    const initialStat = await inspectQueueEntry(inspectPath, params.maxBytes);
+    const handle = await fs.promises.open(params.filePath, resolveReadOpenFlags());
+    try {
+        const openedStat = await inspectQueueEntry(() => handle.stat({ bigint: true }), params.maxBytes, initialStat);
+        await inspectQueueEntry(inspectPath, params.maxBytes, openedStat);
+        const chunks = [];
+        const scratch = Buffer.allocUnsafe(Math.min(64 * 1024, params.maxBytes + 1));
+        let total = 0;
+        while (true) {
+            const { bytesRead } = await handle.read(scratch, 0, scratch.length, null);
+            if (bytesRead === 0) {
+                return Buffer.concat(chunks, total).toString("utf8");
+            }
+            total += bytesRead;
+            if (total > params.maxBytes) {
+                throw new Error(`queue entry exceeds ${params.maxBytes} bytes`);
+            }
+            chunks.push(Buffer.from(scratch.subarray(0, bytesRead)));
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readJsonDurableQueueEntry(filePath, options = {}) {
+    return JSON.parse(await readBoundedUtf8File({
+        filePath,
+        maxBytes: normalizeMaxBytes(options.maxBytes, {
+            defaultValue: DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES,
+        }),
+    }));
+}
+export async function ackJsonDurableQueueEntry(paths) {
+    await acknowledgeDurableQueueEntry(paths);
+}
+export async function loadJsonDurableQueueEntry(params) {
+    try {
+        const claimedPath = await claimDurableQueueEntry(params.paths);
+        if (!claimedPath)
+            return null;
+        const raw = await readJsonDurableQueueEntry(claimedPath, {
+            maxBytes: params.maxBytes,
+        });
+        const result = params.read ? await params.read(raw, params.paths.jsonPath) : { entry: raw };
+        if (result.migrated) {
+            await writeJsonDurableQueueEntry({
+                filePath: claimedPath,
+                entry: result.entry,
+                tempPrefix: params.tempPrefix,
+            });
+        }
+        return result.entry;
+    }
+    catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function loadPendingJsonDurableQueueEntries(options) {
+    let files;
+    try {
+        files = await fs.promises.readdir(options.queueDir);
+    }
+    catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const now = Date.now();
+    for (const file of files) {
+        if (file.endsWith(".delivered")) {
+            const id = file.slice(0, -".delivered".length);
+            await completeDeliveredQueueEntry(resolveJsonDurableQueueEntryPaths(options.queueDir, id));
+        }
+        else if (options.cleanupTmpMaxAgeMs !== undefined && file.endsWith(".tmp")) {
+            await unlinkStaleTmpBestEffort(path.join(options.queueDir, file), now, options.cleanupTmpMaxAgeMs);
+        }
+    }
+    const ids = [];
+    const seenIds = new Set();
+    for (const file of files) {
+        const suffix = file.endsWith(".processing")
+            ? ".processing"
+            : file.endsWith(".json")
+                ? ".json"
+                : null;
+        if (!suffix)
+            continue;
+        const id = file.slice(0, -suffix.length);
+        try {
+            assertSafeQueueEntryId(id);
+        }
+        catch {
+            continue;
+        }
+        if (seenIds.has(id))
+            continue;
+        seenIds.add(id);
+        ids.push(id);
+    }
+    const entries = [];
+    for (const id of ids) {
+        const paths = resolveJsonDurableQueueEntryPaths(options.queueDir, id);
+        const claimedPath = await claimDurableQueueEntry(paths, { skipUnowned: true });
+        if (!claimedPath)
+            continue;
+        let result;
+        try {
+            const raw = await readJsonDurableQueueEntry(claimedPath, { maxBytes: options.maxBytes });
+            result = options.read ? await options.read(raw, paths.jsonPath) : { entry: raw };
+        }
+        catch {
+            continue;
+        }
+        if (result.migrated) {
+            await writeJsonDurableQueueEntry({
+                filePath: claimedPath,
+                entry: result.entry,
+                tempPrefix: options.tempPrefix,
+            });
+        }
+        entries.push(result.entry);
+    }
+    return entries;
+}
+export async function moveJsonDurableQueueEntryToFailed(params) {
+    assertSafeQueueEntryId(params.id);
+    const roots = await queueValidationRoots(params.queueDir, params.failedDir);
+    await assertJsonDurableQueueDir(params.queueDir, roots.queueRoot);
+    await ensureJsonDurableQueueDir(params.failedDir, roots.failedRoot);
+    await moveDurableQueueEntryToFailed({
+        paths: resolveJsonDurableQueueEntryPaths(params.queueDir, params.id),
+        failedPath: path.join(params.failedDir, `${params.id}.json`),
+    });
+}

package/node_modules/@openclaw/fs-safe/dist/json-store.d.ts

@@ -0,0 +1,9 @@
+import { type JsonFileStoreOptions, type JsonStore, type JsonStoreLockOptions } from "./json-document-store.js";
+export type JsonStoreOptions<T> = JsonFileStoreOptions & {
+    filePath: string;
+    dirMode?: number;
+    mode?: number;
+};
+export type { JsonFileStoreOptions, JsonStore, JsonStoreLockOptions };
+export declare function jsonStore<T>(options: JsonStoreOptions<T>): JsonStore<T>;
+//# sourceMappingURL=json-store.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/json-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-store.d.ts","sourceRoot":"","sources":["../src/json-store.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAElC,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,oBAAoB,GAAG;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,YAAY,EAAE,oBAAoB,EAAE,SAAS,EAAE,oBAAoB,EAAE,CAAC;AAEtE,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAQvE"}

package/node_modules/@openclaw/fs-safe/dist/json-store.js

@@ -0,0 +1,12 @@
+import path from "node:path";
+import { fileStore } from "./file-store.js";
+import {} from "./json-document-store.js";
+export function jsonStore(options) {
+    const filePath = path.resolve(options.filePath);
+    return fileStore({
+        rootDir: path.dirname(filePath),
+        private: true,
+        mode: options.mode,
+        dirMode: options.dirMode,
+    }).json(path.basename(filePath), options);
+}

package/node_modules/@openclaw/fs-safe/dist/json-stringify.d.ts

@@ -0,0 +1,2 @@
+export declare function stringifyJsonDocument(value: unknown, replacer?: Parameters<typeof JSON.stringify>[1], space?: Parameters<typeof JSON.stringify>[2]): string;
+//# sourceMappingURL=json-stringify.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/json-stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-stringify.d.ts","sourceRoot":"","sources":["../src/json-stringify.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAC/C,KAAK,CAAC,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAC3C,MAAM,CAMR"}

package/node_modules/@openclaw/fs-safe/dist/json-stringify.js

@@ -0,0 +1,7 @@
+export function stringifyJsonDocument(value, replacer, space) {
+    const text = JSON.stringify(value, replacer, space);
+    if (typeof text !== "string") {
+        throw new TypeError("value is not representable as a JSON document");
+    }
+    return text;
+}

package/node_modules/@openclaw/fs-safe/dist/json.d.ts

@@ -0,0 +1,50 @@
+import fsSync from "node:fs";
+import { type RootFileOpenFailure } from "./root-file.js";
+import { type WriteTextAtomicOptions } from "./text-atomic.js";
+export type ReadJsonOptions = {
+    maxBytes?: number;
+};
+export declare function tryReadJsonSync<T = unknown>(pathname: string, options?: ReadJsonOptions): T | null;
+export declare function writeJsonSync(pathname: string, data: unknown): void;
+export declare class JsonFileReadError extends Error {
+    readonly filePath: string;
+    readonly reason: "read" | "parse";
+    constructor(filePath: string, reason: "read" | "parse", cause: unknown);
+}
+export type RootStructuredFileReadResult<T> = {
+    ok: true;
+    value: T;
+    stat: fsSync.Stats;
+    path: string;
+    rootRealPath: string;
+} | {
+    ok: false;
+    reason: "open";
+    failure: RootFileOpenFailure;
+} | {
+    ok: false;
+    reason: "invalid" | "parse";
+    error: string;
+};
+export type ReadRootStructuredFileSyncOptions<T> = {
+    rootDir: string;
+    rootRealPath?: string;
+    relativePath: string;
+    boundaryLabel: string;
+    rejectHardlinks?: boolean;
+    maxBytes?: number;
+    parse: (raw: string) => unknown;
+    validate?: (value: unknown) => value is T;
+    invalidMessage?: string | ((relativePath: string) => string);
+};
+export type ReadRootJsonSyncOptions = Omit<ReadRootStructuredFileSyncOptions<unknown>, "parse" | "validate" | "invalidMessage">;
+export declare function readRootStructuredFileSync<T>(options: ReadRootStructuredFileSyncOptions<T>): RootStructuredFileReadResult<T>;
+export declare function readRootJsonSync<T = unknown>(options: ReadRootJsonSyncOptions): RootStructuredFileReadResult<T>;
+export declare function readRootJsonObjectSync(options: ReadRootJsonSyncOptions): RootStructuredFileReadResult<Record<string, unknown>>;
+export declare function tryReadJson<T>(filePath: string, options?: ReadJsonOptions): Promise<T | null>;
+export declare function readJson<T>(filePath: string, options?: ReadJsonOptions): Promise<T>;
+export declare function readJsonIfExists<T>(filePath: string, options?: ReadJsonOptions): Promise<T | null>;
+export declare function readJsonSync<T = unknown>(filePath: string, options?: ReadJsonOptions): T;
+export type WriteJsonOptions = Pick<WriteTextAtomicOptions, "dirMode" | "durable" | "mode" | "trailingNewline">;
+export declare function writeJson(filePath: string, value: unknown, options?: WriteJsonOptions): Promise<void>;
+//# sourceMappingURL=json.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,SAAS,CAAC;AAO7B,OAAO,EAAoB,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE5E,OAAO,EAAmB,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AA8JhF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EACzC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,eAAoB,GAC5B,CAAC,GAAG,IAAI,CAUV;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,QAmB5D;AAED,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAElC,YAAY,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAKrE;CACF;AAED,MAAM,MAAM,4BAA4B,CAAC,CAAC,IACtC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC9E;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,mBAAmB,CAAA;CAAE,GAC3D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,iCAAiC,CAAC,CAAC,IAAI;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAChC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC;IAC1C,cAAc,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;CAC9D,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACxC,iCAAiC,CAAC,OAAO,CAAC,EAC1C,OAAO,GAAG,UAAU,GAAG,gBAAgB,CACxC,CAAC;AAgBF,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,OAAO,EAAE,iCAAiC,CAAC,CAAC,CAAC,GAC5C,4BAA4B,CAAC,CAAC,CAAC,CA4CjC;AAED,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,OAAO,EAAE,uBAAuB,GAC/B,4BAA4B,CAAC,CAAC,CAAC,CAKjC;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,4BAA4B,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAOvD;AAED,wBAAsB,WAAW,CAAC,CAAC,EACjC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAWnB;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,CAAC,CAAC,CAiB7F;AAED,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAmBnB;AAED,wBAAgB,YAAY,CAAC,CAAC,GAAG,OAAO,EACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,eAAoB,GAC5B,CAAC,CAYH;AAED,MAAM,MAAM,gBAAgB,GAAG,IAAI,CACjC,sBAAsB,EACtB,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,iBAAiB,CACnD,CAAC;AAEF,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,gBAAgB,iBAS3B"}