@openclaw/fs-safe 0.12.0 → 0.13.0

package/dist/root-path-observation.js

@@ -0,0 +1,180 @@
+import fs, {} from "node:fs";
+import { extendDirectoryObservationGuard, } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { extendNativeDirectoryObservationGuard, inspectNativeDirectoryObservation, isNativeDirectoryObservationGuard, } from "./native-directory-observation.js";
+import { admitPathInsideRoot, } from "./root-boundary.js";
+import { realpathSync } from "./realpath.js";
+import { inspectStatObservationSync } from "./stat-observation.js";
+// Observation-only failures happen after ordinary traversal has admitted the
+// name. Keep them distinguishable so Root preserves existing error precedence.
+export class RootPathObservationError extends Error {
+    error;
+    parentReceipt;
+    traversalFailure;
+    constructor(error, parentReceipt, traversalFailure = false) {
+        super("root path observation failed", { cause: error });
+        this.error = error;
+        this.parentReceipt = parentReceipt;
+        this.traversalFailure = traversalFailure;
+        this.name = "RootPathObservationError";
+    }
+}
+function straightTraversalPath(value) {
+    if (value.length === 0)
+        return false;
+    const windows = process.platform === "win32";
+    let segmentStart = 0;
+    for (let index = 0; index <= value.length; index += 1) {
+        const separator = index === value.length || value[index] === "/" ||
+            (windows && value[index] === "\\");
+        if (!separator)
+            continue;
+        const segmentLength = index - segmentStart;
+        if (segmentLength === 0 ||
+            (segmentLength === 1 && value.charCodeAt(segmentStart) === 0x2e) ||
+            (segmentLength === 2 && value.charCodeAt(segmentStart) === 0x2e &&
+                value.charCodeAt(segmentStart + 1) === 0x2e))
+            return false;
+        segmentStart = index + 1;
+    }
+    return true;
+}
+export function createRootPathTraversalObservation(context, request) {
+    const { state } = context;
+    const rootTraversal = state.finalComponentIndex < 0 &&
+        (state.relativePath === "" || state.relativePath === ".");
+    if (!request || !context.observationEligible ||
+        request.rootGuard.dir !== context.rootCanonicalPath ||
+        request.rootGuard.realPath !== context.rootCanonicalPath ||
+        context.rootPath !== context.rootCanonicalPath ||
+        (!rootTraversal && !straightTraversalPath(state.relativePath)) ||
+        (!rootTraversal && state.finalComponentIndex !== state.segments.length - 1))
+        return undefined;
+    if (state.finalComponentIndex >= 0) {
+        const directoryIndex = request.kind === "stat"
+            ? state.finalComponentIndex - 1
+            : state.finalComponentIndex;
+        return {
+            enabled: true,
+            request,
+            targetIndex: state.finalComponentIndex,
+            directoryIndex,
+            directoryGuard: directoryIndex < 0 ? request.rootGuard : undefined,
+            // A direct-child stat has no selected-directory slot at which the
+            // optional helper can establish a receipt. Keep its final Root fence on
+            // the established JavaScript path so helper unavailability cannot first
+            // appear after the target has been admitted.
+            directoryObserver: directoryIndex < 0 ? undefined : request.directoryObserver,
+        };
+    }
+    if (!rootTraversal)
+        return undefined;
+    let directoryGuard = request.rootGuard;
+    // Root-only stat likewise has no pre-admission helper observation. Root
+    // listing below does establish one and may safely retain the backend.
+    let directoryObserver = request.kind === "stat" ? undefined : request.directoryObserver;
+    if (request.kind === "directory") {
+        if (directoryObserver) {
+            try {
+                const observed = inspectNativeDirectoryObservation(directoryObserver, request.rootGuard.dir, request.rootGuard.identity);
+                const admitted = admitPathInsideRoot({
+                    rootPath: context.rootCanonicalPath,
+                    candidatePath: observed.realPath,
+                    rootIdentity: context.resolveParams.rootIdentity,
+                });
+                if (!admitted || admitted.relativePath !== "") {
+                    throw new FsSafeError("path-mismatch", "root path changed during operation");
+                }
+                observed.realPath = admitted.path;
+                directoryGuard = extendNativeDirectoryObservationGuard(observed, request.rootGuard.dir);
+            }
+            catch (error) {
+                if (error instanceof FsSafeError && error.code === "path-mismatch") {
+                    throw new RootPathObservationError(error);
+                }
+                directoryObserver = undefined;
+            }
+        }
+        if (!directoryObserver) {
+            try {
+                const admitted = admitPathInsideRoot({
+                    rootPath: context.rootCanonicalPath,
+                    candidatePath: realpathSync.native(request.rootGuard.dir),
+                    rootIdentity: context.resolveParams.rootIdentity,
+                });
+                if (!admitted || admitted.relativePath !== "") {
+                    throw new FsSafeError("path-mismatch", "root path changed during operation");
+                }
+            }
+            catch (error) {
+                throw new RootPathObservationError(error);
+            }
+        }
+    }
+    return {
+        enabled: true,
+        request,
+        targetIndex: -1,
+        directoryIndex: -1,
+        directoryGuard,
+        directoryObserver,
+        targetPath: context.rootCanonicalPath,
+        target: directoryGuard,
+    };
+}
+export function inspectRootPathTraversalEntry(pathname, directorySlot, observation) {
+    if (directorySlot && observation.directoryObserver) {
+        try {
+            return extendNativeDirectoryObservationGuard(inspectNativeDirectoryObservation(observation.directoryObserver, pathname), pathname);
+        }
+        catch {
+            // This directory has not been admitted yet. Preserve the established
+            // resolver and error ordering when the optional observation is unusable.
+            observation.directoryObserver = undefined;
+        }
+    }
+    const first = process.platform === "win32"
+        ? fs.lstatSync(pathname, { bigint: true }) : fs.lstatSync(pathname);
+    if (first.isSymbolicLink() || (directorySlot && !first.isDirectory()))
+        return { stat: first };
+    try {
+        return inspectStatObservationSync(bigint => bigint
+            ? fs.lstatSync(pathname, { bigint: true }) : fs.lstatSync(pathname), undefined, first);
+    }
+    catch (error) {
+        if (error instanceof FsSafeError && error.code === "path-mismatch") {
+            throw new RootPathObservationError(error);
+        }
+        throw error;
+    }
+}
+export function captureRootPathObservedDirectory(observation, observed, publicPath, canonicalPath, rootCanonicalPath, rootIdentity) {
+    if (!isNativeDirectoryObservationGuard(observed) && !observed.stat.isDirectory())
+        return false;
+    let realPath;
+    try {
+        realPath = isNativeDirectoryObservationGuard(observed)
+            ? observed.realPath
+            : realpathSync.native(canonicalPath);
+    }
+    catch (error) {
+        throw new RootPathObservationError(error);
+    }
+    const admitted = admitPathInsideRoot({
+        rootPath: rootCanonicalPath,
+        candidatePath: realPath,
+        rootIdentity,
+    });
+    if (!admitted) {
+        throw new RootPathObservationError(new FsSafeError("outside-workspace", "directory is outside workspace root"));
+    }
+    if (isNativeDirectoryObservationGuard(observed)) {
+        observed.dir = publicPath;
+        observed.realPath = admitted.path;
+        observation.directoryGuard = observed;
+    }
+    else {
+        observation.directoryGuard = extendDirectoryObservationGuard(observed, publicPath, admitted.path);
+    }
+    return true;
+}

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

@@ -0,0 +1,5 @@
+import type { RootContext } from "./root-context.js";
+import type { RootPathObservationReceipt } from "./root-path.js";
+import type { PathStat } from "./types.js";
+export declare function statResolvedPathInRoot(root: RootContext, resolvedPath: string, receipt?: RootPathObservationReceipt): Promise<PathStat>;
+//# sourceMappingURL=root-path-stat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root-path-stat.d.ts","sourceRoot":"","sources":["../src/root-path-stat.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAIjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAwB3C,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,WAAW,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,QAAQ,CAAC,CA8EnB"}

package/dist/root-path-stat.js

@@ -0,0 +1,101 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { recordFileObservationFailure } from "./file-observation.js";
+import { hasNodeErrorCode, isNotFoundPathError } from "./path.js";
+import { assertRootDirectoryObservationGuard, assertRootPathObservationReceiptCurrent, createRootDirectoryObservationGuard, pathStatFromStats, } from "./root-directory-list.js";
+import { fileNotFoundError } from "./root-errors.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { assertStatObservationSync } from "./stat-observation.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+async function missingObservedFileError(cause, pathname, before, assertParents) {
+    const failure = new FsSafeError("path-mismatch", "file changed during operation", {
+        cause: cause instanceof Error ? cause : undefined,
+    });
+    if (hasNodeErrorCode(cause, "ENOENT") && before?.isFile() && !before.isSymbolicLink() &&
+        (before.nlink === 1 || before.nlink === 1n)) {
+        try {
+            await assertParents();
+            // Metadata loss permits discarding a probe, never reading or owning a file.
+            recordFileObservationFailure(failure, `stat-leaf-missing:${pathname}`);
+        }
+        catch {
+            // Keep the public mismatch and withhold provenance when ancestry changed.
+        }
+    }
+    return failure;
+}
+export async function statResolvedPathInRoot(root, resolvedPath, receipt) {
+    let admittedTarget = false;
+    try {
+        if (receipt) {
+            if (receipt.kind !== "stat" || receipt.targetPath !== resolvedPath) {
+                throw new FsSafeError("path-mismatch", "file observation receipt does not match target");
+            }
+            admittedTarget = true;
+            const beforeObservation = getFsSafeTestHooks()?.beforeRootStatObservation;
+            if (beforeObservation)
+                await beforeObservation(resolvedPath);
+            let observed;
+            try {
+                observed = assertStatObservationSync(bigint => bigint ? fsSync.lstatSync(resolvedPath, { bigint: true }) : fsSync.lstatSync(resolvedPath), receipt.target.identity);
+            }
+            catch (error) {
+                if (isNotFoundPathError(error)) {
+                    throw await missingObservedFileError(error, resolvedPath, "stat" in receipt.target ? receipt.target.stat : undefined, () => assertRootPathObservationReceiptCurrent(root, receipt));
+                }
+                throw error;
+            }
+            if (observed.isSymbolicLink()) {
+                throw new FsSafeError("path-mismatch", "file changed during operation");
+            }
+            assertRootPathObservationReceiptCurrent(root, receipt, observed);
+            return pathStatFromStats(observed);
+        }
+        const guardPath = resolvedPath === root.rootReal ? root.rootReal : path.dirname(resolvedPath);
+        const parentGuard = guardPath === root.rootReal && root.rootGuard
+            ? root.rootGuard
+            : await createRootDirectoryObservationGuard(root, guardPath);
+        let expected;
+        try {
+            const beforeInitialObservation = getFsSafeTestHooks()?.beforeRootStatInitialObservation;
+            if (beforeInitialObservation)
+                await beforeInitialObservation(resolvedPath);
+            expected = inspectFileIdentitySync(() => fsSync.lstatSync(resolvedPath, { bigint: true }));
+            if (expected.isSymbolicLink()) {
+                throw new FsSafeError("path-mismatch", "file changed during operation");
+            }
+        }
+        catch (error) {
+            // No initial target error is safe to expose until the admitted parent is
+            // proven current; a redirect must win over an ordinary lookup failure.
+            await assertRootDirectoryObservationGuard(root, parentGuard);
+            throw error;
+        }
+        admittedTarget = true;
+        const beforeObservation = getFsSafeTestHooks()?.beforeRootStatObservation;
+        if (beforeObservation)
+            await beforeObservation(resolvedPath);
+        let observed;
+        try {
+            observed = inspectFileIdentitySync(() => fsSync.lstatSync(resolvedPath, { bigint: true }), expected);
+        }
+        catch (error) {
+            if (isNotFoundPathError(error)) {
+                throw await missingObservedFileError(error, resolvedPath, expected, () => assertRootDirectoryObservationGuard(root, parentGuard));
+            }
+            throw error;
+        }
+        if (observed.isSymbolicLink()) {
+            throw new FsSafeError("path-mismatch", "file changed during operation");
+        }
+        await assertRootDirectoryObservationGuard(root, parentGuard);
+        return pathStatFromStats(observed);
+    }
+    catch (error) {
+        if (!admittedTarget && isNotFoundPathError(error)) {
+            throw fileNotFoundError(error instanceof Error ? error : undefined);
+        }
+        throw error;
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"root-path-symlink.d.ts","sourceRoot":"","sources":["../src/root-path-symlink.ts"],"names":[],"mappings":"AAUA,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAiBF,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAQR"}
+{"version":3,"file":"root-path-symlink.d.ts","sourceRoot":"","sources":["../src/root-path-symlink.ts"],"names":[],"mappings":"AAeA,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAsBF,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAeR"}

package/dist/root-path-symlink.js

@@ -4,6 +4,7 @@ import { FsSafeError } from "./errors.js";
 import { isNotFoundPathError, isSymlinkOpenError } from "./path.js";
 import { realpathSync } from "./realpath.js";
 import { resolvePathViaExistingAncestor, resolvePathViaExistingAncestorSync, } from "./root-path-existing.js";
+import { assertNoWindowsPathAlias, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 function normalizeSymlinkResolutionError(error, options) {
     if (isSymlinkOpenError(error) ||
         (options.rejectUnresolved && isNotFoundPathError(error))) {
@@ -14,23 +15,41 @@ function normalizeSymlinkResolutionError(error, options) {
     if (!isNotFoundPathError(error))
         throw error;
 }
+function resolveSymlinkTargetPath(symlinkPath, linkTarget) {
+    const linkDir = resolvePathPreservingWindowsRoot(path.dirname(symlinkPath));
+    return resolvePathFromBasePreservingWindowsRoot(linkDir, linkTarget);
+}
 export async function resolveSymlinkHopPath(symlinkPath, options = {}) {
     try {
-        return path.resolve(realpathSync.native(symlinkPath));
+        const rawRealPath = realpathSync.native(symlinkPath);
+        assertNoWindowsPathAlias(rawRealPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        const realPath = resolvePathPreservingWindowsRoot(rawRealPath);
+        assertNoWindowsPathAlias(realPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        return realPath;
     }
     catch (error) {
         normalizeSymlinkResolutionError(error, options);
         const linkTarget = fs.readlinkSync(symlinkPath);
-        return resolvePathViaExistingAncestor(path.resolve(path.dirname(symlinkPath), linkTarget));
+        assertNoWindowsPathAlias(linkTarget, "filesystem", "symlink target uses a Windows filesystem namespace alias");
+        const resolved = await resolvePathViaExistingAncestor(resolveSymlinkTargetPath(symlinkPath, linkTarget));
+        assertNoWindowsPathAlias(resolved, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        return resolved;
     }
 }
 export function resolveSymlinkHopPathSync(symlinkPath, options = {}) {
     try {
-        return path.resolve(realpathSync(symlinkPath));
+        const rawRealPath = realpathSync(symlinkPath);
+        assertNoWindowsPathAlias(rawRealPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        const realPath = resolvePathPreservingWindowsRoot(rawRealPath);
+        assertNoWindowsPathAlias(realPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        return realPath;
     }
     catch (error) {
         normalizeSymlinkResolutionError(error, options);
         const linkTarget = fs.readlinkSync(symlinkPath);
-        return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
+        assertNoWindowsPathAlias(linkTarget, "filesystem", "symlink target uses a Windows filesystem namespace alias");
+        const resolved = resolvePathViaExistingAncestorSync(resolveSymlinkTargetPath(symlinkPath, linkTarget));
+        assertNoWindowsPathAlias(resolved, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
+        return resolved;
     }
 }

package/dist/root-path.d.ts

@@ -1,5 +1,8 @@
 import { type RootBoundaryIdentity } from "./root-boundary.js";
+import { type RootPathObservationReceipt, type RootPathObservationRequest } from "./root-path-observation.js";
+import type { RemovalPathReceipts } from "./root-remove-receipt.js";
 export { resolvePathViaExistingAncestorSync } from "./root-path-existing.js";
+export { RootPathObservationError, type RootPathDirectoryObservationGuard, type RootPathObservationKind, type RootPathObservationReceipt, type RootPathParentObservationReceipt, type RootPathObservationRequest, type RootPathTargetObservation, } from "./root-path-observation.js";
 type RootPathIntent = "read" | "write" | "create" | "delete" | "stat";
 export type RootPathAliasPolicy = {
     allowFinalSymlinkForUnlink?: boolean;
@@ -38,6 +41,14 @@ export type ResolvedRootPath = {
     exists: boolean;
     kind: ResolvedRootPathKind;
 };
+export type ObservedRootPath = {
+    resolved: ResolvedRootPath;
+    receipt?: RootPathObservationReceipt;
+};
 export declare function resolveRootPath(params: ResolveRootPathParams): Promise<ResolvedRootPath>;
+export declare function resolveRootPathWithCanonicalRootObservation(params: ResolveRootPathParams, observeRoot: (rootCanonicalPath: string) => void): Promise<ResolvedRootPath>;
+export declare function resolveRootPathWithObservation(params: ResolveRootPathParams, request: RootPathObservationRequest): Promise<ObservedRootPath>;
+export declare function resolveRootPathForRemoval(params: ResolveRootPathParams, receipts: RemovalPathReceipts): Promise<ResolvedRootPath>;
 export declare function resolveRootPathSync(params: ResolveRootPathParams): ResolvedRootPath;
+export declare function resolveRootPathSyncWithCanonicalRootObservation(params: ResolveRootPathParams, observeRoot: (rootCanonicalPath: string) => void): ResolvedRootPath;
 //# sourceMappingURL=root-path.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAeA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E,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;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,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,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC,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,CAM3B;AAcD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}
+{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAiBA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAKL,KAAK,0BAA0B,EAE/B,KAAK,0BAA0B,EAEhC,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAQpE,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EACL,wBAAwB,EACxB,KAAK,iCAAiC,EACtC,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,GAC/B,MAAM,4BAA4B,CAAC;AAEpC,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;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,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,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC,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,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,CAAC,EAAE,0BAA0B,CAAC;CACtC,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAED,wBAAsB,2CAA2C,CAC/D,MAAM,EAAE,qBAAqB,EAC7B,WAAW,EAAE,CAAC,iBAAiB,EAAE,MAAM,KAAK,IAAI,GAC/C,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AA4BD,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAQ3B;AAID,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF;AAED,wBAAgB,+CAA+C,CAC7D,MAAM,EAAE,qBAAqB,EAC7B,WAAW,EAAE,CAAC,iBAAiB,EAAE,MAAM,KAAK,IAAI,GAC/C,gBAAgB,CAMlB"}