@openclaw/fs-safe 0.1.0

package/dist/replace-file.js

@@ -0,0 +1,325 @@
+import { randomUUID } from "node:crypto";
+import syncFs from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { registerTempPathForExit } from "./temp-cleanup.js";
+import { serializePathWrite } from "./write-queue.js";
+function isRetryableRenameError(error) {
+    return error.code === "EBUSY";
+}
+function isPermissionRenameError(error) {
+    const code = error.code;
+    return code === "EPERM" || code === "EEXIST";
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function renameWithRetry(params) {
+    for (let attempt = 0; attempt <= params.maxRetries; attempt++) {
+        try {
+            await params.fsModule.rename(params.src, params.dest);
+            return { method: "rename" };
+        }
+        catch (error) {
+            if (isRetryableRenameError(error) && attempt < params.maxRetries) {
+                await sleep(params.baseDelayMs * 2 ** attempt);
+                continue;
+            }
+            if (params.copyFallbackOnPermissionError && isPermissionRenameError(error)) {
+                const stat = await params.fsModule.lstat(params.dest).catch((lstatError) => {
+                    if (lstatError.code === "ENOENT") {
+                        return null;
+                    }
+                    throw lstatError;
+                });
+                if (stat?.isSymbolicLink()) {
+                    throw new Error(`Refusing copy fallback through symlink destination: ${params.dest}`);
+                }
+                await params.fsModule.copyFile(params.src, params.dest);
+                await params.fsModule.unlink(params.src).catch(() => undefined);
+                return { method: "copy-fallback" };
+            }
+            throw error;
+        }
+    }
+    throw new Error("Atomic rename retry loop exhausted.");
+}
+function sleepSync(ms) {
+    if (ms <= 0) {
+        return;
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function renameWithRetrySync(params) {
+    for (let attempt = 0; attempt <= params.maxRetries; attempt++) {
+        try {
+            params.fsModule.renameSync(params.src, params.dest);
+            return { method: "rename" };
+        }
+        catch (error) {
+            if (isRetryableRenameError(error) && attempt < params.maxRetries) {
+                sleepSync(params.baseDelayMs * 2 ** attempt);
+                continue;
+            }
+            if (params.copyFallbackOnPermissionError && isPermissionRenameError(error)) {
+                let stat = null;
+                try {
+                    stat = params.fsModule.lstatSync(params.dest);
+                }
+                catch (lstatError) {
+                    if (lstatError.code !== "ENOENT") {
+                        throw lstatError;
+                    }
+                }
+                if (stat?.isSymbolicLink()) {
+                    throw new Error(`Refusing copy fallback through symlink destination: ${params.dest}`);
+                }
+                params.fsModule.copyFileSync(params.src, params.dest);
+                try {
+                    params.fsModule.unlinkSync(params.src);
+                }
+                catch {
+                    // Best-effort cleanup after fallback replacement.
+                }
+                return { method: "copy-fallback" };
+            }
+            throw error;
+        }
+    }
+    throw new Error("Atomic rename retry loop exhausted.");
+}
+function validateReplaceFilePath(filePath) {
+    if (!filePath || filePath.includes("\0")) {
+        throw new Error("Atomic replace file path must be non-empty.");
+    }
+}
+function buildReplaceTempPath(filePath, tempPrefix) {
+    const dir = path.dirname(filePath);
+    return path.join(dir, `${tempPrefix ?? ".fs-safe-replace"}.${process.pid}.${randomUUID()}.tmp`);
+}
+async function resolveMode(options) {
+    const defaultMode = options.mode ?? 0o600;
+    if (!options.preserveExistingMode) {
+        return defaultMode;
+    }
+    const stat = await (options.fileSystem?.promises ?? fs).stat(options.filePath).catch((error) => {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    });
+    return stat ? stat.mode : defaultMode;
+}
+function resolveModeSync(options) {
+    const defaultMode = options.mode ?? 0o600;
+    if (!options.preserveExistingMode) {
+        return defaultMode;
+    }
+    const fsModule = options.fileSystem ?? syncFs;
+    let stat;
+    try {
+        stat = fsModule.statSync(options.filePath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return stat ? stat.mode : defaultMode;
+}
+async function syncTempFile(fsModule, tempPath) {
+    const handle = await fsModule.open(tempPath, "r+");
+    try {
+        await handle.sync();
+    }
+    catch (error) {
+        if (error.code !== "EPERM") {
+            throw error;
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+function syncTempFileSync(fsModule, tempPath) {
+    const fd = fsModule.openSync(tempPath, "r+");
+    try {
+        fsModule.fsyncSync(fd);
+    }
+    catch (error) {
+        if (error.code !== "EPERM") {
+            throw error;
+        }
+    }
+    finally {
+        fsModule.closeSync(fd);
+    }
+}
+async function syncDirectoryBestEffort(fsModule, dirPath) {
+    let handle;
+    try {
+        handle = await fsModule.open(dirPath, "r");
+        await handle.sync();
+    }
+    catch {
+        // Best-effort on platforms/filesystems that do not support directory fsync.
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function syncDirectoryBestEffortSync(fsModule, dirPath) {
+    let fd;
+    try {
+        fd = fsModule.openSync(dirPath, "r");
+        fsModule.fsyncSync(fd);
+    }
+    catch {
+        // Best-effort on platforms/filesystems that do not support directory fsync.
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fsModule.closeSync(fd);
+            }
+            catch {
+                // Best-effort close after directory fsync.
+            }
+        }
+    }
+}
+async function cleanupTempFile(params) {
+    const cleanupError = await params.fsModule
+        .rm(params.tempPath, { force: true })
+        .catch((error) => error);
+    if (cleanupError && params.throwOnCleanupError && params.originalError !== undefined) {
+        throw new Error(`Atomic file replace failed (${String(params.originalError)}); cleanup also failed (${String(cleanupError)})`, { cause: params.originalError });
+    }
+}
+export async function replaceFileAtomic(options) {
+    const filePath = options.filePath;
+    validateReplaceFilePath(filePath);
+    return await serializePathWrite(path.resolve(filePath), async () => {
+        return await replaceFileAtomicUnserialized(options);
+    });
+}
+async function replaceFileAtomicUnserialized(options) {
+    const filePath = options.filePath;
+    const fsModule = options.fileSystem?.promises ?? fs;
+    const dir = path.dirname(filePath);
+    const dirMode = options.dirMode ?? 0o700;
+    const mode = await resolveMode(options);
+    const tempPath = buildReplaceTempPath(filePath, options.tempPrefix);
+    const unregisterTempPath = registerTempPathForExit(tempPath);
+    let tempExists = false;
+    let originalError;
+    await fsModule.mkdir(dir, { recursive: true, mode: dirMode });
+    await fsModule.chmod(dir, dirMode).catch(() => undefined);
+    try {
+        tempExists = true;
+        await fsModule.writeFile(tempPath, options.content, { mode, flag: "wx" });
+        if (options.syncTempFile) {
+            await syncTempFile(fsModule, tempPath);
+        }
+        if (options.beforeRename) {
+            await options.beforeRename({ filePath, tempPath });
+        }
+        const result = await renameWithRetry({
+            fsModule,
+            src: tempPath,
+            dest: filePath,
+            maxRetries: options.renameMaxRetries ?? 0,
+            baseDelayMs: options.renameRetryBaseDelayMs ?? 50,
+            copyFallbackOnPermissionError: options.copyFallbackOnPermissionError === true,
+        });
+        tempExists = false;
+        unregisterTempPath();
+        await fsModule.chmod(filePath, mode).catch(() => undefined);
+        if (options.syncParentDir) {
+            await syncDirectoryBestEffort(fsModule, dir);
+        }
+        return result;
+    }
+    catch (error) {
+        originalError = error;
+        throw error;
+    }
+    finally {
+        if (tempExists) {
+            await cleanupTempFile({
+                fsModule,
+                tempPath,
+                originalError,
+                throwOnCleanupError: options.throwOnCleanupError === true,
+            });
+        }
+        unregisterTempPath();
+    }
+}
+export function replaceFileAtomicSync(options) {
+    const filePath = options.filePath;
+    validateReplaceFilePath(filePath);
+    const fsModule = options.fileSystem ?? syncFs;
+    const dir = path.dirname(filePath);
+    const dirMode = options.dirMode ?? 0o700;
+    const mode = resolveModeSync(options);
+    const tempPath = buildReplaceTempPath(filePath, options.tempPrefix);
+    const unregisterTempPath = registerTempPathForExit(tempPath);
+    let tempExists = false;
+    let originalError;
+    fsModule.mkdirSync(dir, { recursive: true, mode: dirMode });
+    try {
+        fsModule.chmodSync(dir, dirMode);
+    }
+    catch {
+        // Best-effort on platforms that do not enforce POSIX modes.
+    }
+    try {
+        tempExists = true;
+        fsModule.writeFileSync(tempPath, options.content, { mode, flag: "wx" });
+        if (options.syncTempFile) {
+            syncTempFileSync(fsModule, tempPath);
+        }
+        if (options.beforeRename) {
+            options.beforeRename({ filePath, tempPath });
+        }
+        const result = renameWithRetrySync({
+            fsModule,
+            src: tempPath,
+            dest: filePath,
+            maxRetries: options.renameMaxRetries ?? 0,
+            baseDelayMs: options.renameRetryBaseDelayMs ?? 50,
+            copyFallbackOnPermissionError: options.copyFallbackOnPermissionError === true,
+        });
+        tempExists = false;
+        unregisterTempPath();
+        try {
+            fsModule.chmodSync(filePath, mode);
+        }
+        catch {
+            // Best-effort on platforms that do not enforce POSIX modes.
+        }
+        if (options.syncParentDir) {
+            syncDirectoryBestEffortSync(fsModule, dir);
+        }
+        return result;
+    }
+    catch (error) {
+        originalError = error;
+        throw error;
+    }
+    finally {
+        if (tempExists) {
+            try {
+                fsModule.rmSync(tempPath, { force: true });
+            }
+            catch (cleanupError) {
+                if (options.throwOnCleanupError && originalError !== undefined) {
+                    throw new Error(`Atomic file replace failed (${String(originalError)}); cleanup also failed (${String(cleanupError)})`, { cause: originalError });
+                }
+                // The temp file is best-effort cleanup after write failure.
+            }
+        }
+        unregisterTempPath();
+    }
+}

package/dist/root-file.d.ts

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import type { PathAliasPolicy } from "./path-policy.js";
+import { type PinnedOpenSyncAllowedType, type PinnedOpenSyncFailureReason } from "./pinned-open.js";
+type BoundaryReadFs = Pick<typeof fs, "closeSync" | "constants" | "fstatSync" | "lstatSync" | "openSync" | "readFileSync" | "realpathSync">;
+export type RootFileOpenFailureReason = PinnedOpenSyncFailureReason | "validation";
+export type RootFileOpenResult = {
+    ok: true;
+    path: string;
+    fd: number;
+    stat: fs.Stats;
+    rootRealPath: string;
+} | {
+    ok: false;
+    reason: RootFileOpenFailureReason;
+    error?: unknown;
+};
+export type RootFileOpenFailure = Extract<RootFileOpenResult, {
+    ok: false;
+}>;
+export type OpenRootFileSyncParams = {
+    absolutePath: string;
+    rootPath: string;
+    boundaryLabel: string;
+    rootRealPath?: string;
+    maxBytes?: number;
+    rejectHardlinks?: boolean;
+    allowedType?: PinnedOpenSyncAllowedType;
+    skipLexicalRootCheck?: boolean;
+    ioFs?: BoundaryReadFs;
+};
+export type OpenRootFileParams = OpenRootFileSyncParams & {
+    aliasPolicy?: PathAliasPolicy;
+};
+export declare function canUseRootFileOpen(ioFs: typeof fs): boolean;
+export declare function openRootFileSync(params: OpenRootFileSyncParams): RootFileOpenResult;
+export declare function matchRootFileOpenFailure<T>(failure: RootFileOpenFailure, handlers: {
+    path?: (failure: RootFileOpenFailure) => T;
+    validation?: (failure: RootFileOpenFailure) => T;
+    io?: (failure: RootFileOpenFailure) => T;
+    fallback: (failure: RootFileOpenFailure) => T;
+}): T;
+export declare function openRootFile(params: OpenRootFileParams): Promise<RootFileOpenResult>;
+export {};
+//# sourceMappingURL=root-file.d.ts.map

package/dist/root-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-file.d.ts","sourceRoot":"","sources":["../src/root-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AAOzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EACjC,MAAM,kBAAkB,CAAC;AAE1B,KAAK,cAAc,GAAG,IAAI,CACxB,OAAO,EAAE,EACP,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,UAAU,GACV,cAAc,GACd,cAAc,CACjB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,2BAA2B,GAAG,YAAY,CAAC;AAEnF,MAAM,MAAM,kBAAkB,GAC1B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,yBAAyB,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,EAAE;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAE7E,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,GAAG;IACxD,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B,CAAC;AAQF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAW3D;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,kBAAkB,CAuBnF;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE;IACR,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,CAAC,CAAC;IAC3C,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,CAAC,CAAC;IACjD,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,CAAC,CAAC;IACzC,QAAQ,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,CAAC,CAAC;CAC/C,GACA,CAAC,CAUH;AAoDD,wBAAsB,YAAY,CAChC,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,kBAAkB,CAAC,CAsB7B"}

package/dist/root-file.js

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveRootPath, resolveRootPathSync, } from "./root-path.js";
+import { openPinnedFileSync, } from "./pinned-open.js";
+export function canUseRootFileOpen(ioFs) {
+    return (typeof ioFs.openSync === "function" &&
+        typeof ioFs.closeSync === "function" &&
+        typeof ioFs.fstatSync === "function" &&
+        typeof ioFs.lstatSync === "function" &&
+        typeof ioFs.realpathSync === "function" &&
+        typeof ioFs.readFileSync === "function" &&
+        typeof ioFs.constants === "object" &&
+        ioFs.constants !== null);
+}
+export function openRootFileSync(params) {
+    const ioFs = params.ioFs ?? fs;
+    const resolved = resolveRootFilePathGeneric({
+        absolutePath: params.absolutePath,
+        resolve: (absolutePath) => resolveRootPathSync({
+            absolutePath,
+            rootPath: params.rootPath,
+            rootCanonicalPath: params.rootRealPath,
+            boundaryLabel: params.boundaryLabel,
+            skipLexicalRootCheck: params.skipLexicalRootCheck,
+        }),
+    });
+    if (resolved instanceof Promise) {
+        return toBoundaryValidationError(new Error("Unexpected async boundary resolution"));
+    }
+    return finalizeRootFileOpen({
+        resolved,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs,
+    });
+}
+export function matchRootFileOpenFailure(failure, handlers) {
+    switch (failure.reason) {
+        case "path":
+            return handlers.path ? handlers.path(failure) : handlers.fallback(failure);
+        case "validation":
+            return handlers.validation ? handlers.validation(failure) : handlers.fallback(failure);
+        case "io":
+            return handlers.io ? handlers.io(failure) : handlers.fallback(failure);
+    }
+    return handlers.fallback(failure);
+}
+function openRootFileResolved(params) {
+    const opened = openPinnedFileSync({
+        filePath: params.absolutePath,
+        resolvedPath: params.resolvedPath,
+        rejectHardlinks: params.rejectHardlinks ?? true,
+        maxBytes: params.maxBytes,
+        allowedType: params.allowedType,
+        ioFs: params.ioFs,
+    });
+    if (!opened.ok) {
+        return opened;
+    }
+    return {
+        ok: true,
+        path: opened.path,
+        fd: opened.fd,
+        stat: opened.stat,
+        rootRealPath: params.rootRealPath,
+    };
+}
+function finalizeRootFileOpen(params) {
+    if ("ok" in params.resolved) {
+        return params.resolved;
+    }
+    return openRootFileResolved({
+        absolutePath: params.resolved.absolutePath,
+        resolvedPath: params.resolved.resolvedPath,
+        rootRealPath: params.resolved.rootRealPath,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs: params.ioFs,
+    });
+}
+export async function openRootFile(params) {
+    const ioFs = params.ioFs ?? fs;
+    const maybeResolved = resolveRootFilePathGeneric({
+        absolutePath: params.absolutePath,
+        resolve: (absolutePath) => resolveRootPath({
+            absolutePath,
+            rootPath: params.rootPath,
+            rootCanonicalPath: params.rootRealPath,
+            boundaryLabel: params.boundaryLabel,
+            policy: params.aliasPolicy,
+            skipLexicalRootCheck: params.skipLexicalRootCheck,
+        }),
+    });
+    const resolved = maybeResolved instanceof Promise ? await maybeResolved : maybeResolved;
+    return finalizeRootFileOpen({
+        resolved,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs,
+    });
+}
+function toBoundaryValidationError(error) {
+    return { ok: false, reason: "validation", error };
+}
+function mapResolvedRootPath(absolutePath, resolved) {
+    return {
+        absolutePath,
+        resolvedPath: resolved.canonicalPath,
+        rootRealPath: resolved.rootCanonicalPath,
+    };
+}
+function resolveRootFilePathGeneric(params) {
+    const absolutePath = path.resolve(params.absolutePath);
+    try {
+        const resolved = params.resolve(absolutePath);
+        if (resolved instanceof Promise) {
+            return resolved
+                .then((value) => mapResolvedRootPath(absolutePath, value))
+                .catch((error) => toBoundaryValidationError(error));
+        }
+        return mapResolvedRootPath(absolutePath, resolved);
+    }
+    catch (error) {
+        return toBoundaryValidationError(error);
+    }
+}

package/dist/root-path.d.ts

@@ -0,0 +1,39 @@
+type RootPathIntent = "read" | "write" | "create" | "delete" | "stat";
+export type RootPathAliasPolicy = {
+    allowFinalSymlinkForUnlink?: boolean;
+    allowFinalHardlinkForUnlink?: boolean;
+};
+export declare const ROOT_PATH_ALIAS_POLICIES: {
+    readonly strict: Readonly<{
+        allowFinalSymlinkForUnlink: false;
+        allowFinalHardlinkForUnlink: false;
+    }>;
+    readonly unlinkTarget: Readonly<{
+        allowFinalSymlinkForUnlink: true;
+        allowFinalHardlinkForUnlink: true;
+    }>;
+};
+type ResolveRootPathParams = {
+    absolutePath: string;
+    rootPath: string;
+    boundaryLabel: string;
+    intent?: RootPathIntent;
+    policy?: RootPathAliasPolicy;
+    skipLexicalRootCheck?: boolean;
+    rootCanonicalPath?: string;
+};
+type ResolvedRootPathKind = "missing" | "file" | "directory" | "symlink" | "other";
+export type ResolvedRootPath = {
+    absolutePath: string;
+    canonicalPath: string;
+    rootPath: string;
+    rootCanonicalPath: string;
+    relativePath: string;
+    exists: boolean;
+    kind: ResolvedRootPathKind;
+};
+export declare function resolveRootPath(params: ResolveRootPathParams): Promise<ResolvedRootPath>;
+export declare function resolveRootPathSync(params: ResolveRootPathParams): ResolvedRootPath;
+export declare function resolvePathViaExistingAncestorSync(targetPath: string): string;
+export {};
+//# sourceMappingURL=root-path.d.ts.map

package/dist/root-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAMA,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;CAS3B,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CA+B3B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CA+BnF;AAmkBD,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA6B7E"}