@openclaw/fs-safe 0.4.6 → 0.5.0

package/dist/archive.js

@@ -1,22 +1,30 @@
-import { constants as fsConstants } from "node:fs";
+import fsSync, { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 import { createPipelineTimeoutError, waitForDeadline, withExtractionDeadline, } from "./archive-deadline.js";
-import { writeFileHandleFully } from "./archive-file-io.js";
-import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, assertArchiveEntryCountWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, } from "./archive-limits.js";
+import { assertArchiveEntryCountWithinLimit, assertArchiveEntryPathComponentsWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, } from "./archive-limits.js";
 import { resolveArchiveKind } from "./archive-kind.js";
 import { mergeExtractedTreeIntoDestination, prepareArchiveDestinationDir, prepareArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
 import { createTarEntryPreflightChecker, readTarEntryInfo, } from "./archive-tar.js";
 import { loadZipArchiveWithPreflight } from "./archive-zip-preflight.js";
-import { sameFileIdentity } from "./file-identity.js";
+import { isZipSymlinkEntry, zipEntryDeclaredSize, zipEntryMode, } from "./archive-zip-entry.js";
+import { FsSafeError } from "./errors.js";
+import { ArchiveSecurityError } from "./archive-errors.js";
+import { extractNativeArchive } from "./archive-native.js";
+import { stageArchiveFileForExtraction } from "./archive-input.js";
+import { getNativeBinding } from "./native.js";
+import { resolveArchiveEntryMode, shouldExtractArchiveEntry, } from "./archive-policy.js";
+import { importOptionalTar } from "./archive-tar-runtime.js";
+import { preflightTarMetadata } from "./archive-tar-meta.js";
 import { writeSiblingTempFile } from "./sibling-temp.js";
-import { tempFile } from "./temp-target.js";
 export { isWindowsDrivePath, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 export { resolveArchiveKind, resolvePackedRootDir } from "./archive-kind.js";
-export { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, DEFAULT_MAX_ARCHIVE_BYTES_ZIP, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_EXTRACTED_BYTES, DEFAULT_MAX_ENTRY_BYTES, } from "./archive-limits.js";
+export { readArchiveEntry } from "./archive-read.js";
+export { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, DEFAULT_MAX_ARCHIVE_BYTES_ZIP, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_EXTRACTED_BYTES, DEFAULT_MAX_ENTRY_BYTES, DEFAULT_MAX_META_ENTRY_BYTES, DEFAULT_MAX_ENTRY_PATH_COMPONENTS, } from "./archive-limits.js";
+export { ArchiveFormatError } from "./archive-errors.js";
 export { ArchiveSecurityError } from "./archive-staging.js";
 export { createArchiveSymlinkTraversalError, mergeExtractedTreeIntoDestination, prepareArchiveDestinationDir, prepareArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
 export { createTarEntryPreflightChecker } from "./archive-tar.js";
@@ -26,91 +34,6 @@ const OPEN_WRITE_CREATE_FLAGS = fsConstants.O_WRONLY |
     fsConstants.O_CREAT |
     fsConstants.O_EXCL |
     (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0);
-const ZIP_UNIX_FILE_TYPE_MASK = 0o170000;
-const ZIP_UNIX_SYMLINK_TYPE = 0o120000;
-function isZipSymlinkEntry(entry) {
-    return (typeof entry.unixPermissions === "number" &&
-        (entry.unixPermissions & ZIP_UNIX_FILE_TYPE_MASK) === ZIP_UNIX_SYMLINK_TYPE);
-}
-function zipEntryFileMode(entry) {
-    if (typeof entry.unixPermissions !== "number") {
-        return undefined;
-    }
-    const mode = entry.unixPermissions & 0o777;
-    return mode === 0 ? undefined : mode;
-}
-async function cleanupStagedArchiveFile(staged) {
-    if (staged) {
-        await staged.cleanup().catch(() => undefined);
-    }
-}
-async function closeFileHandle(handle) {
-    if (handle) {
-        await handle.close().catch(() => undefined);
-    }
-}
-async function stageArchiveFileForExtraction(params) {
-    params.deadline.check();
-    const sourcePath = path.resolve(params.archivePath);
-    const initialStat = await fs.lstat(sourcePath);
-    if (initialStat.isSymbolicLink() || !initialStat.isFile()) {
-        throw new Error(`archive is not a regular file: ${params.archivePath}`);
-    }
-    if (initialStat.size > params.limits.maxArchiveBytes) {
-        throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT);
-    }
-    const noFollow = process.platform !== "win32" && "O_NOFOLLOW" in fsConstants ? fsConstants.O_NOFOLLOW : 0;
-    const handle = await fs.open(sourcePath, fsConstants.O_RDONLY | noFollow);
-    let staged;
-    let output;
-    try {
-        staged = await tempFile({
-            prefix: "fs-safe-archive-input",
-            fileName: path.basename(sourcePath),
-        });
-        const openedStat = await handle.stat();
-        const pathStat = await fs.lstat(sourcePath);
-        if (!openedStat.isFile() ||
-            pathStat.isSymbolicLink() ||
-            !pathStat.isFile() ||
-            !sameFileIdentity(initialStat, openedStat) ||
-            !sameFileIdentity(pathStat, openedStat)) {
-            throw new Error("archive changed during validation");
-        }
-        output = await fs.open(staged.path, OPEN_WRITE_CREATE_FLAGS, 0o600);
-        const buffer = Buffer.allocUnsafe(64 * 1024);
-        let written = 0;
-        while (true) {
-            params.deadline.check();
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
-            if (bytesRead === 0) {
-                break;
-            }
-            written += bytesRead;
-            if (written > params.limits.maxArchiveBytes) {
-                throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT);
-            }
-            await writeFileHandleFully({
-                handle: output,
-                buffer,
-                bytes: bytesRead,
-                deadline: params.deadline,
-            });
-            params.deadline.check();
-        }
-        await output.close();
-        output = undefined;
-        return staged;
-    }
-    catch (err) {
-        await closeFileHandle(output);
-        await cleanupStagedArchiveFile(staged);
-        throw err;
-    }
-    finally {
-        await closeFileHandle(handle);
-    }
-}
 async function readZipEntryStream(entry) {
     if (typeof entry.nodeStream === "function") {
         return entry.nodeStream();
@@ -150,7 +73,7 @@ async function writeZipFileEntry(params) {
             dir: path.dirname(destinationPath),
             tempPrefix: `.${path.basename(destinationPath)}.fs-safe-archive`,
             chmodDir: false,
-            mode: zipEntryFileMode(params.entry),
+            mode: params.mode,
             writeTemp: async (tempPath) => {
                 tempHandle = await fs.open(tempPath, OPEN_WRITE_CREATE_FLAGS, 0o666);
                 const writable = tempHandle.createWriteStream();
@@ -218,6 +141,18 @@ async function extractZip(params) {
                     if (!output) {
                         continue;
                     }
+                    assertArchiveEntryPathComponentsWithinLimit(output.relPath, limits);
+                    const isSymlink = isZipSymlinkEntry(entry);
+                    const entryKind = isSymlink ? "symlink" : entry.dir ? "directory" : "file";
+                    const entrySize = zipEntryDeclaredSize(entry);
+                    if (!shouldExtractArchiveEntry({
+                        filter: params.entryFilter,
+                        onFiltered: params.onFiltered,
+                        entry: { path: entry.name, kind: entryKind, size: entrySize },
+                    })) {
+                        continue;
+                    }
+                    const mode = zipEntryMode(entry, params.entryModes);
                     await prepareZipOutputPath({
                         destinationDir: stagingRealDir,
                         destinationRealDir: stagingRealDir,
@@ -227,16 +162,18 @@ async function extractZip(params) {
                         isDirectory: entry.dir,
                     });
                     if (entry.dir) {
+                        await fs.chmod(output.outPath, mode);
                         continue;
                     }
-                    if (isZipSymlinkEntry(entry)) {
-                        throw new Error(`zip entry is a link: ${entry.name}`);
+                    if (isSymlink) {
+                        throw new ArchiveSecurityError("entry-link", `zip entry is a link: ${entry.name}`);
                     }
                     await writeZipFileEntry({
                         entry,
                         outPath: output.outPath,
                         budget,
                         deadline: params.deadline,
+                        mode,
                     });
                 }
                 params.deadline.check();
@@ -259,6 +196,25 @@ export async function extractArchive(params) {
         throw new Error(`unsupported archive: ${params.archivePath}`);
     }
     const label = kind === "zip" ? "extract zip" : "extract tar";
+    const native = getNativeBinding();
+    if (native) {
+        await withExtractionDeadline(params.timeoutMs, label, async (deadline) => extractNativeArchive({
+            binding: native,
+            archivePath: params.archivePath,
+            destDir: params.destDir,
+            kind,
+            stripComponents: params.stripComponents,
+            limits: params.limits,
+            deadline,
+            entryModes: params.entryModes,
+            entryFilter: params.entryFilter,
+            onFiltered: params.onFiltered,
+        }));
+        return;
+    }
+    if (kind === "tar-zstd" || kind === "tar-bzip2") {
+        throw new FsSafeError("helper-unavailable", `${kind} archives require a supported bundled native binding`);
+    }
     if (kind === "tar") {
         await withExtractionDeadline(params.timeoutMs, label, async (deadline) => {
             const tar = await importOptionalTar();
@@ -269,6 +225,12 @@ export async function extractArchive(params) {
                 deadline,
             });
             try {
+                await preflightTarMetadata({
+                    archivePath: stagedArchive.path,
+                    maxMetaEntryBytes: limits.maxMetaEntryBytes,
+                    signal: deadline.signal,
+                });
+                deadline.check();
                 const destinationRealDir = await prepareArchiveDestinationDir(params.destDir);
                 await withStagedArchiveDestination({
                     destinationRealDir,
@@ -278,23 +240,56 @@ export async function extractArchive(params) {
                             rootDir: destinationRealDir,
                             stripComponents: params.stripComponents,
                             limits,
+                            entryFilter: params.entryFilter,
+                            onFiltered: params.onFiltered,
                         });
+                        const acceptedEntries = [];
                         // A canonical cwd is not enough here: tar can still follow
                         // pre-existing child symlinks in the live destination tree.
                         // Extract into a private staging dir first, then merge through
                         // the same safe-open boundary checks used by direct file writes.
-                        await tar.x({
-                            file: stagedArchive.path,
+                        const extractor = tar.x({
                             cwd: stagingDir,
                             strip: Math.max(0, Math.floor(params.stripComponents ?? 0)),
                             gzip: params.tarGzip,
                             signal: deadline.signal,
                             preservePaths: false,
+                            noChmod: true,
+                            preserveOwner: false,
                             strict: true,
+                            maxMetaEntrySize: limits.maxMetaEntryBytes,
+                            filter(_entryPath, entry) {
+                                try {
+                                    const info = readTarEntryInfo(entry);
+                                    const accepted = checkTarEntrySafety(info);
+                                    if (accepted) {
+                                        const relPath = stripArchivePath(info.path, Math.max(0, Math.floor(params.stripComponents ?? 0)));
+                                        if (relPath) {
+                                            acceptedEntries.push({
+                                                path: relPath,
+                                                mode: resolveArchiveEntryMode({
+                                                    kind: info.type === "Directory" || info.type === "GNUDumpDir"
+                                                        ? "directory"
+                                                        : "file",
+                                                    archivedMode: info.mode,
+                                                    policy: params.entryModes,
+                                                }),
+                                            });
+                                        }
+                                    }
+                                    return accepted;
+                                }
+                                catch (error) {
+                                    // Abort through the parser so pipeline tears down both the
+                                    // archive reader and unpacker instead of leaving a paused
+                                    // stream behind after a policy rejection.
+                                    this.abort(error instanceof Error ? error : new Error(String(error)));
+                                    return false;
+                                }
+                            },
                             onReadEntry(entry) {
                                 try {
                                     deadline.check();
-                                    checkTarEntrySafety(readTarEntryInfo(entry));
                                 }
                                 catch (err) {
                                     const error = err instanceof Error ? err : new Error(String(err));
@@ -305,6 +300,22 @@ export async function extractArchive(params) {
                                 }
                             },
                         });
+                        try {
+                            await pipeline(fsSync.createReadStream(stagedArchive.path), extractor, {
+                                signal: deadline.signal,
+                            });
+                        }
+                        catch (error) {
+                            throw createPipelineTimeoutError(error, deadline);
+                        }
+                        for (const accepted of acceptedEntries) {
+                            const outputPath = resolveArchiveOutputPath({
+                                rootDir: stagingDir,
+                                relPath: accepted.path,
+                                originalPath: accepted.path,
+                            });
+                            await fs.chmod(outputPath, accepted.mode);
+                        }
                         deadline.check();
                         await mergeExtractedTreeIntoDestination({
                             sourceDir: stagingDir,
@@ -327,16 +338,8 @@ export async function extractArchive(params) {
         stripComponents: params.stripComponents,
         limits: params.limits,
         deadline,
+        entryModes: params.entryModes,
+        entryFilter: params.entryFilter,
+        onFiltered: params.onFiltered,
     }));
 }
-async function importOptionalTar() {
-    try {
-        return await import("tar");
-    }
-    catch (err) {
-        throw missingOptionalArchiveDependencyError("tar", err);
-    }
-}
-function missingOptionalArchiveDependencyError(packageName, cause) {
-    return new Error(`Optional archive dependency "${packageName}" is not installed. Install it to use TAR archive helpers from @openclaw/fs-safe/archive.`, { cause });
-}

package/dist/atomic.d.ts

@@ -1,4 +1,4 @@
-export { replaceFileAtomic, replaceFileAtomicSync, type ReplaceFileAtomicFileSystem, type ReplaceFileAtomicOptions, type ReplaceFileAtomicResult, type ReplaceFileAtomicSyncFileSystem, type ReplaceFileAtomicSyncOptions, } from "./replace-file.js";
+export { replaceFileAtomic, replaceFileAtomicSync, type ReplaceFileAtomicFileSystem, type ReplaceFileAtomicOptions, type ReplaceFileAtomicRestoreCleanup, type ReplaceFileAtomicRestoreFailureDetails, type ReplaceFileAtomicResult, type ReplaceFileCopyFallbackRestorePolicy, type ReplaceFileDestinationHardlinkPolicy, type ReplaceFileAtomicSyncFileSystem, type ReplaceFileAtomicSyncOptions, } from "./replace-file.js";
 export { writeTextAtomic, type WriteTextAtomicOptions } from "./text-atomic.js";
 export { replaceDirectoryAtomic, type ReplaceDirectoryAtomicOptions } from "./replace-directory.js";
 export { movePathWithCopyFallback, type MovePathWithCopyFallbackOptions } from "./move-path.js";

package/dist/atomic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,KAAK,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAAE,KAAK,+BAA+B,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../src/atomic.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,KAAK,sCAAsC,EAC3C,KAAK,uBAAuB,EAC5B,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,KAAK,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACpG,OAAO,EAAE,wBAAwB,EAAE,KAAK,+BAA+B,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/config.d.ts

@@ -1,3 +1,3 @@
-export { configureFsSafePython, getFsSafePythonConfig, type FsSafePythonConfig, type FsSafePythonMode, } from "./pinned-python-config.js";
+export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, type FsSafePythonConfig, type FsSafeNativeConfig, type FsSafeNativeMode, } from "./native-config.js";
 export { configureFsSafeLocks, getFsSafeLockConfig, type FsSafeLockConfig, } from "./lock-config.js";
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,GACtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC"}

package/dist/config.js

@@ -1,2 +1,2 @@
-export { configureFsSafePython, getFsSafePythonConfig, } from "./pinned-python-config.js";
+export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
 export { configureFsSafeLocks, getFsSafeLockConfig, } from "./lock-config.js";

package/dist/containment.d.ts

@@ -0,0 +1,2 @@
+export type ContainmentGuarantee = "kernel-atomic" | "best-effort";
+//# sourceMappingURL=containment.d.ts.map

package/dist/containment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"containment.d.ts","sourceRoot":"","sources":["../src/containment.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG,aAAa,CAAC"}

package/dist/containment.js

@@ -0,0 +1 @@
+export {};

package/dist/directory-durability.d.ts

@@ -0,0 +1,44 @@
+import { type Stats } from "node:fs";
+import { type FileIdentityStat } from "./file-identity.js";
+export type DirectorySyncOutcome = {
+    status: "synced";
+} | {
+    status: "unsupported";
+    code?: string;
+};
+export type DirectoryReceipt = {
+    path: string;
+    realPath: string;
+    identity: Stats;
+};
+export type DurableDirectoryReceipt = DirectoryReceipt & {
+    parentSync: DirectorySyncOutcome | {
+        status: "not-needed";
+    };
+};
+export type PinnedDirectory = {
+    readonly receipt: DirectoryReceipt;
+    assertCurrent(): Promise<void>;
+    sync(): Promise<DirectorySyncOutcome>;
+    close(): Promise<void>;
+};
+export type EnsureDurableDirectoryOptions = {
+    directoryPath: string;
+    label?: string;
+    mode?: number;
+    expectedExistingIdentity?: FileIdentityStat;
+    create?: (directoryPath: string) => Promise<void>;
+};
+export declare function pinDirectory(directory: string | DirectoryReceipt, options?: {
+    label?: string;
+}): Promise<PinnedDirectory>;
+export declare function syncDirectory(directory: string | DirectoryReceipt, options?: {
+    label?: string;
+}): Promise<DirectorySyncOutcome>;
+export declare function syncDirectorySync(directory: string | DirectoryReceipt, options?: {
+    label?: string;
+}): DirectorySyncOutcome;
+export declare function syncDirectoryBestEffort(directoryPath: string): Promise<void>;
+export declare function syncDirectoryBestEffortSync(directoryPath: string): void;
+export declare function ensureDurableDirectory(options: EnsureDurableDirectoryOptions): Promise<DurableDirectoryReceipt>;
+//# sourceMappingURL=directory-durability.d.ts.map

package/dist/directory-durability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-durability.d.ts","sourceRoot":"","sources":["../src/directory-durability.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAM7C,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE7E,MAAM,MAAM,oBAAoB,GAC5B;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,GAAG;IACvD,UAAU,EAAE,oBAAoB,GAAG;QAAE,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC;CAC7D,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wBAAwB,CAAC,EAAE,gBAAgB,CAAC;IAC5C,MAAM,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD,CAAC;AAgKF,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,eAAe,CAAC,CAa1B;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAmB/B;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,oBAAoB,CAuCtB;AAED,wBAAsB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;AAED,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAMvE;AAuBD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,uBAAuB,CAAC,CA8ElC"}