@openclaw/fs-safe 0.1.0

package/dist/root-paths.js

@@ -0,0 +1,338 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { isNotFoundPathError, isPathInside } from "./path.js";
+import { root as openRoot } from "./root.js";
+function invalidPath(scopeLabel) {
+    return {
+        ok: false,
+        error: `Invalid path: must stay within ${scopeLabel}`,
+    };
+}
+async function resolveRealPathIfExists(targetPath) {
+    try {
+        return await fs.realpath(targetPath);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveTrustedRootRealPath(rootDir) {
+    try {
+        const rootLstat = await fs.lstat(rootDir);
+        if (!rootLstat.isDirectory() || rootLstat.isSymbolicLink()) {
+            return undefined;
+        }
+        return await fs.realpath(rootDir);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function validateCanonicalPathWithinRoot(params) {
+    try {
+        const candidateLstat = await fs.lstat(params.candidatePath);
+        if (candidateLstat.isSymbolicLink()) {
+            return "invalid";
+        }
+        if (params.expect === "directory" && !candidateLstat.isDirectory()) {
+            return "invalid";
+        }
+        if (params.expect === "file" && !candidateLstat.isFile()) {
+            return "invalid";
+        }
+        if (params.expect === "file" && candidateLstat.nlink > 1) {
+            return "invalid";
+        }
+        const candidateRealPath = await fs.realpath(params.candidatePath);
+        return isPathInside(params.rootRealPath, candidateRealPath) ? "ok" : "invalid";
+    }
+    catch (err) {
+        return isNotFoundPathError(err) ? "not-found" : "invalid";
+    }
+}
+export function resolvePathWithinRoot(params) {
+    const root = path.resolve(params.rootDir);
+    const raw = params.requestedPath.trim();
+    if (!raw) {
+        if (!params.defaultFileName) {
+            return { ok: false, error: "path is required" };
+        }
+        return { ok: true, path: path.join(root, params.defaultFileName) };
+    }
+    const resolved = path.resolve(root, raw);
+    const rel = path.relative(root, resolved);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+        return { ok: false, error: `Invalid path: must stay within ${params.scopeLabel}` };
+    }
+    return { ok: true, path: resolved };
+}
+export async function resolveWritablePathWithinRoot(params) {
+    const lexical = resolvePathWithinRoot(params);
+    if (!lexical.ok) {
+        return lexical;
+    }
+    const rootDir = path.resolve(params.rootDir);
+    const rootRealPath = await resolveTrustedRootRealPath(rootDir);
+    if (!rootRealPath) {
+        return invalidPath(params.scopeLabel);
+    }
+    const requestedPath = lexical.path;
+    const parentDir = path.dirname(requestedPath);
+    const parentStatus = await validateCanonicalPathWithinRoot({
+        rootRealPath,
+        candidatePath: parentDir,
+        expect: "directory",
+    });
+    if (parentStatus !== "ok") {
+        return invalidPath(params.scopeLabel);
+    }
+    const targetStatus = await validateCanonicalPathWithinRoot({
+        rootRealPath,
+        candidatePath: requestedPath,
+        expect: "file",
+    });
+    if (targetStatus === "invalid") {
+        return invalidPath(params.scopeLabel);
+    }
+    return lexical;
+}
+async function resolveNearestExistingPath(targetPath) {
+    let current = path.resolve(targetPath);
+    while (true) {
+        try {
+            await fs.lstat(current);
+            return current;
+        }
+        catch (err) {
+            if (!isNotFoundPathError(err)) {
+                throw err;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error(`failed to resolve existing path for ${targetPath}`);
+        }
+        current = parent;
+    }
+}
+async function assertNoSymlinkSegments(params) {
+    const relative = path.relative(params.rootDir, params.targetPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Invalid path: must stay within ${params.scopeLabel}`);
+    }
+    let current = params.rootDir;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new Error(`Invalid path: must not traverse symlinks within ${params.scopeLabel}`);
+            }
+            if (!stat.isDirectory()) {
+                throw new Error(`Invalid path: existing segment must be a directory within ${params.scopeLabel}`);
+            }
+        }
+        catch (err) {
+            if (isNotFoundPathError(err)) {
+                return;
+            }
+            throw err;
+        }
+    }
+}
+export async function ensureDirectoryWithinRoot(params) {
+    const lexical = resolvePathWithinRoot({
+        rootDir: params.rootDir,
+        requestedPath: params.requestedPath,
+        scopeLabel: params.scopeLabel,
+        defaultFileName: params.defaultDirName,
+    });
+    if (!lexical.ok) {
+        return lexical;
+    }
+    const rootDir = path.resolve(params.rootDir);
+    const targetPath = path.resolve(lexical.path);
+    try {
+        const rootStat = await fs.lstat(rootDir);
+        if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+            return invalidPath(params.scopeLabel);
+        }
+        await assertNoSymlinkSegments({ rootDir, targetPath, scopeLabel: params.scopeLabel });
+        const rootReal = await fs.realpath(rootDir);
+        const nearestExistingPath = await resolveNearestExistingPath(targetPath);
+        const nearestExistingReal = await fs.realpath(nearestExistingPath);
+        if (!isPathInside(rootReal, nearestExistingReal)) {
+            return invalidPath(params.scopeLabel);
+        }
+        const relative = path.relative(rootDir, targetPath);
+        let current = rootDir;
+        for (const segment of relative.split(path.sep).filter(Boolean)) {
+            current = path.join(current, segment);
+            while (true) {
+                try {
+                    const stat = await fs.lstat(current);
+                    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+                        return invalidPath(params.scopeLabel);
+                    }
+                    break;
+                }
+                catch (err) {
+                    if (!isNotFoundPathError(err)) {
+                        throw err;
+                    }
+                    try {
+                        await fs.mkdir(current, { mode: params.mode });
+                    }
+                    catch (mkdirErr) {
+                        if (isNotFoundPathError(mkdirErr)) {
+                            throw mkdirErr;
+                        }
+                        if (mkdirErr.code === "EEXIST") {
+                            continue;
+                        }
+                        throw mkdirErr;
+                    }
+                }
+            }
+        }
+        const targetReal = await fs.realpath(targetPath);
+        if (!isPathInside(rootReal, targetReal)) {
+            return invalidPath(params.scopeLabel);
+        }
+        return { ok: true, path: targetPath };
+    }
+    catch {
+        return invalidPath(params.scopeLabel);
+    }
+}
+export function resolvePathsWithinRoot(params) {
+    const resolvedPaths = [];
+    for (const raw of params.requestedPaths) {
+        const pathResult = resolvePathWithinRoot({
+            rootDir: params.rootDir,
+            requestedPath: raw,
+            scopeLabel: params.scopeLabel,
+        });
+        if (!pathResult.ok) {
+            return { ok: false, error: pathResult.error };
+        }
+        resolvedPaths.push(pathResult.path);
+    }
+    return { ok: true, paths: resolvedPaths };
+}
+export async function resolveExistingPathsWithinRoot(params) {
+    return await resolveCheckedPathsWithinRoot(params, true);
+}
+export async function resolveStrictExistingPathsWithinRoot(params) {
+    return await resolveCheckedPathsWithinRoot(params, false);
+}
+export function pathScope(rootDir, options) {
+    const base = { rootDir, scopeLabel: options.label };
+    return {
+        rootDir,
+        label: options.label,
+        resolve: (requestedPath, pathOptions) => resolvePathWithinRoot({
+            ...base,
+            requestedPath,
+            defaultFileName: pathOptions?.defaultName,
+        }),
+        resolveAll: (requestedPaths) => resolvePathsWithinRoot({
+            ...base,
+            requestedPaths,
+        }),
+        existing: (requestedPaths) => resolveExistingPathsWithinRoot({
+            ...base,
+            requestedPaths,
+        }),
+        files: (requestedPaths) => resolveStrictExistingPathsWithinRoot({
+            ...base,
+            requestedPaths,
+        }),
+        writable: (requestedPath, pathOptions) => resolveWritablePathWithinRoot({
+            ...base,
+            requestedPath,
+            defaultFileName: pathOptions?.defaultName,
+        }),
+        ensureDir: (requestedPath, pathOptions) => ensureDirectoryWithinRoot({
+            ...base,
+            requestedPath,
+            defaultDirName: pathOptions?.defaultName,
+            mode: pathOptions?.mode,
+        }),
+    };
+}
+async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
+    const rootDir = path.resolve(params.rootDir);
+    const rootRealPath = await resolveRealPathIfExists(rootDir);
+    const root = rootRealPath ? await openRoot(rootDir) : undefined;
+    const isInRoot = (relativePath) => Boolean(relativePath) && !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+    const resolveExistingRelativePath = async (requestedPath) => {
+        const raw = requestedPath.trim();
+        const lexicalPathResult = resolvePathWithinRoot({
+            rootDir,
+            requestedPath,
+            scopeLabel: params.scopeLabel,
+        });
+        if (lexicalPathResult.ok) {
+            return {
+                ok: true,
+                relativePath: path.relative(rootDir, lexicalPathResult.path),
+                fallbackPath: lexicalPathResult.path,
+            };
+        }
+        if (!rootRealPath || !raw || !path.isAbsolute(raw)) {
+            return lexicalPathResult;
+        }
+        try {
+            const resolvedExistingPath = await fs.realpath(raw);
+            const relativePath = path.relative(rootRealPath, resolvedExistingPath);
+            if (!isInRoot(relativePath)) {
+                return lexicalPathResult;
+            }
+            return {
+                ok: true,
+                relativePath,
+                fallbackPath: resolvedExistingPath,
+            };
+        }
+        catch {
+            return lexicalPathResult;
+        }
+    };
+    const resolvedPaths = [];
+    for (const raw of params.requestedPaths) {
+        const pathResult = await resolveExistingRelativePath(raw);
+        if (!pathResult.ok) {
+            return { ok: false, error: pathResult.error };
+        }
+        let opened;
+        try {
+            if (!root) {
+                throw new FsSafeError("not-found", "root dir not found");
+            }
+            opened = await root.open(pathResult.relativePath);
+            resolvedPaths.push(opened.realPath);
+        }
+        catch (err) {
+            if (allowMissingFallback && err instanceof FsSafeError && err.code === "not-found") {
+                resolvedPaths.push(pathResult.fallbackPath);
+                continue;
+            }
+            if (err instanceof FsSafeError && err.code === "outside-workspace") {
+                return {
+                    ok: false,
+                    error: `File is outside ${params.scopeLabel}`,
+                };
+            }
+            return {
+                ok: false,
+                error: `Invalid path: must stay within ${params.scopeLabel} and be a regular non-symlink file`,
+            };
+        }
+        finally {
+            await opened?.handle.close().catch(() => { });
+        }
+    }
+    return { ok: true, paths: resolvedPaths };
+}

package/dist/root.d.ts

@@ -0,0 +1,108 @@
+import type { Stats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import type { DirEntry, PathStat } from "./types.js";
+export type OpenResult = {
+    handle: FileHandle;
+    realPath: string;
+    stat: Stats;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+export type ReadResult = {
+    buffer: Buffer;
+    realPath: string;
+    stat: Stats;
+};
+export type RootOptions = {
+    rootDir: string;
+    defaults?: RootDefaults;
+};
+export type SymlinkPolicy = "reject" | "follow-within-root";
+export type HardlinkPolicy = "reject" | "allow";
+export type WritableOpenMode = "replace" | "append" | "update";
+export type RootDefaults = {
+    hardlinks?: HardlinkPolicy;
+    maxBytes?: number;
+    mkdir?: boolean;
+    mode?: number;
+    nonBlockingRead?: boolean;
+    symlinks?: SymlinkPolicy;
+};
+export type RootReadOptions = Pick<RootDefaults, "hardlinks" | "maxBytes" | "nonBlockingRead" | "symlinks">;
+export type RootOpenOptions = Omit<RootReadOptions, "maxBytes">;
+export type RootWriteOptions = Pick<RootDefaults, "mkdir" | "mode"> & {
+    encoding?: BufferEncoding;
+    overwrite?: boolean;
+};
+export type RootOpenWritableOptions = Pick<RootDefaults, "mkdir" | "mode"> & {
+    writeMode?: WritableOpenMode;
+};
+export type RootCopyOptions = Pick<RootDefaults, "maxBytes" | "mkdir" | "mode"> & {
+    sourceHardlinks?: HardlinkPolicy;
+};
+export type RootWriteJsonOptions = RootWriteOptions & {
+    replacer?: Parameters<typeof JSON.stringify>[1];
+    space?: Parameters<typeof JSON.stringify>[2];
+    trailingNewline?: boolean;
+};
+export type RootCreateOptions = Omit<RootWriteOptions, "overwrite">;
+export type RootCreateJsonOptions = Omit<RootWriteJsonOptions, "overwrite">;
+export type RootAppendOptions = RootWriteOptions & {
+    prependNewlineIfNeeded?: boolean;
+};
+export declare const DEFAULT_ROOT_MAX_BYTES: number;
+export interface Root {
+    readonly rootDir: string;
+    readonly rootReal: string;
+    readonly rootWithSep: string;
+    readonly defaults: RootDefaults;
+    resolve(relativePath: string): Promise<string>;
+    open(relativePath: string, options?: RootOpenOptions): Promise<OpenResult>;
+    read(relativePath: string, options?: RootReadOptions): Promise<ReadResult>;
+    readBytes(relativePath: string, options?: RootReadOptions): Promise<Buffer>;
+    readText(relativePath: string, options?: RootReadOptions & {
+        encoding?: BufferEncoding;
+    }): Promise<string>;
+    readJson<T = unknown>(relativePath: string, options?: RootReadOptions & {
+        encoding?: BufferEncoding;
+    }): Promise<T>;
+    readAbsolute(filePath: string, options?: RootReadOptions): Promise<ReadResult>;
+    reader(options?: RootReadOptions): (filePath: string) => Promise<Buffer>;
+    openWritable(relativePath: string, options?: RootOpenWritableOptions): Promise<WritableOpenResult>;
+    append(relativePath: string, data: string | Buffer, options?: RootAppendOptions): Promise<void>;
+    remove(relativePath: string): Promise<void>;
+    mkdir(relativePath: string): Promise<void>;
+    ensureRoot(): Promise<void>;
+    write(relativePath: string, data: string | Buffer, options?: RootWriteOptions): Promise<void>;
+    create(relativePath: string, data: string | Buffer, options?: RootCreateOptions): Promise<void>;
+    writeJson(relativePath: string, data: unknown, options?: RootWriteJsonOptions): Promise<void>;
+    createJson(relativePath: string, data: unknown, options?: RootCreateJsonOptions): Promise<void>;
+    copyIn(relativePath: string, sourcePath: string, options?: RootCopyOptions): Promise<void>;
+    exists(relativePath: string): Promise<boolean>;
+    stat(relativePath: string): Promise<PathStat>;
+    list(relativePath: string, options?: {
+        withFileTypes?: false;
+    }): Promise<string[]>;
+    list(relativePath: string, options: {
+        withFileTypes: true;
+    }): Promise<DirEntry[]>;
+    move(fromRelative: string, toRelative: string, options?: {
+        overwrite?: boolean;
+    }): Promise<void>;
+}
+export declare function root(rootDir: string, defaults?: RootDefaults): Promise<Root>;
+export declare function readLocalFileSafely(params: {
+    filePath: string;
+    maxBytes?: number;
+}): Promise<ReadResult>;
+export declare function openLocalFileSafely(params: {
+    filePath: string;
+}): Promise<OpenResult>;
+export type WritableOpenResult = {
+    handle: FileHandle;
+    createdForWrite: boolean;
+    realPath: string;
+    stat: Stats;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+export declare function resolveOpenedFileRealPathForHandle(handle: FileHandle, ioPath: string): Promise<string>;
+//# sourceMappingURL=root.d.ts.map

package/dist/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../src/root.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AA0BnD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAIrD,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,CAAC;IACZ,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,CAAC;CACb,CAAC;AAQF,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,oBAAoB,CAAC;AAC5D,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,OAAO,CAAC;AAChD,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/D,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,aAAa,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,YAAY,EACZ,WAAW,GAAG,UAAU,GAAG,iBAAiB,GAAG,UAAU,CAC1D,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;AAEhE,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,MAAM,CAAC,GAAG;IACpE,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,MAAM,CAAC,GAAG;IAC3E,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,OAAO,GAAG,MAAM,CAAC,GAAG;IAChF,eAAe,CAAC,EAAE,cAAc,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG;IACpD,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,KAAK,CAAC,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;AACpE,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC;AAE5E,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG;IACjD,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAgCF,eAAO,MAAM,sBAAsB,QAAmB,CAAC;AAmLvD,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAEhC,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/C,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC3E,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC3E,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5E,QAAQ,CACN,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,eAAe,GAAG;QAAE,QAAQ,CAAC,EAAE,cAAc,CAAA;KAAE,GACxD,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAClB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,eAAe,GAAG;QAAE,QAAQ,CAAC,EAAE,cAAc,CAAA;KAAE,GACxD,OAAO,CAAC,CAAC,CAAC,CAAC;IACd,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/E,MAAM,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACzE,YAAY,CACV,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC/B,MAAM,CACJ,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,KAAK,CACH,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,MAAM,CACJ,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,SAAS,CACP,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,UAAU,CACR,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3F,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9C,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACnF,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAClF,IAAI,CACF,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAChC,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAsQD,wBAAsB,IAAI,CACxB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,YAAiB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAEf;AAiFD,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,UAAU,CAAC,CAOtB;AAED,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAE3F;AA0BD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,UAAU,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,CAAC;IACZ,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC,CAAC;AA8EF,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAoCjB"}