@effect-vfs/core 0.7.1 → 0.8.0

package/dist/internal/resolution.js

@@ -0,0 +1,277 @@
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as Hex from "effect/encoding/Hex";
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import { isEntry, isTarget } from "../Target.js";
+import { DOT_DOT_HEX, DOT_HEX, isAttachedBytes, isDotComponent, isWellFormed, MAX_NAME_BYTES, MAX_SYMLINK_TRAVERSALS, nameBytes, ownedPath, preparePath, SLASH_BYTE } from "./path.js";
+import * as TokenRegistry from "./tokenRegistry.js";
+import { ROOT_INO } from "./volumeState.js";
+const encoder = new TextEncoder();
+/** @internal */
+export const inGroup = (identity, gid) => identity.gid === gid || identity.groups.includes(gid);
+/** @internal */
+export const permitted = (node, identity) => {
+    const shift = identity.uid === node.metadata.uid ? 6 : inGroup(identity, node.metadata.gid) ? 3 : 0;
+    return (node.metadata.mode >> shift) & 0o7;
+};
+/** @internal */
+export const authorize = (node, identity, bits, op) => identity.privileged || (permitted(node, identity) & bits) === bits
+    ? Effect.void
+    : Effect.fail(op.fail("AccessDenied"));
+/** @internal */
+export const entryName = (input, op) => {
+    if (Predicate.isString(input) && !isWellFormed(input))
+        return Result.fail(op.fail("InvalidPathEncoding"));
+    const bytes = Predicate.isString(input) ? encoder.encode(input) : input;
+    if (!isAttachedBytes(bytes) || bytes.length === 0 || bytes.length > MAX_NAME_BYTES || bytes.includes(0) ||
+        bytes.includes(SLASH_BYTE))
+        return Result.fail(op.fail("InvalidArgument"));
+    return Result.succeed(Hex.encode(new Uint8Array(bytes)));
+};
+/** @internal */
+export const make = ({ caller, get, identity, maxPathBytes, registry }) => {
+    const prepare = (input, op) => preparePath(input, op.operation, maxPathBytes);
+    const prepareEntry = (input, op) => isEntry(input)
+        ? Result.map(entryName(input.name, op), (name) => ({ kind: "entry", directory: input.directory, name }))
+        : isTarget(input)
+            ? Result.map(prepare(input.path, op), (path) => ({ kind: "path", path, base: input.relativeTo }))
+            : Result.map(prepare(input, op), (path) => ({ kind: "path", path, base: undefined }));
+    const nodeAt = Effect.fnUntraced(function* (ino) {
+        const node = yield* get(ino);
+        return node === undefined ? yield* Effect.die("Inode left the table during resolution") : node;
+    });
+    const directoryAt = Effect.fnUntraced(function* (ino) {
+        const node = yield* nodeAt(ino);
+        return node.kind !== "directory" ? yield* Effect.die("Directory left the table during resolution") : node;
+    });
+    const callerDirectory = Effect.fnUntraced(function* (op) {
+        const ino = TokenRegistry.inode(caller);
+        const node = ino === undefined ? undefined : yield* get(ino);
+        return node?.kind !== "directory" ? yield* op.fail("ClosedCaller") : node;
+    });
+    const walk = Effect.fnUntraced(function* (path, base, op, mode, referencedBase) {
+        const pathOp = op.at(path.input);
+        const parentOnly = mode.kind === "Parent";
+        const allowMissing = mode.kind === "OrCreate" && mode.create !== "never";
+        const followFinalSymlink = mode.kind === "Node"
+            ? mode.followFinalSymlink !== false
+            : mode.kind === "Parent" || mode.finalSymlink === "follow";
+        const createMissing = mode.kind === "Node" ? mode.createMissing : undefined;
+        if (!TokenRegistry.isOpen(caller)) {
+            return yield* pathOp.fail("ClosedCaller");
+        }
+        let current = path.absolute ? (yield* nodeAt(ROOT_INO)) : yield* callerDirectory(pathOp);
+        if (!path.absolute && referencedBase !== undefined) {
+            current = referencedBase;
+            yield* authorize(current, identity, 0o1, op);
+        }
+        else if (!path.absolute && base !== undefined) {
+            const directory = yield* TokenRegistry.nodeOrFail(yield* registry.resolve(base, "directory"), "handle", pathOp);
+            if (directory.kind !== "directory")
+                return yield* pathOp.fail("InvalidHandle");
+            current = directory;
+            yield* authorize(current, identity, 0o1, pathOp);
+        }
+        if (current.metadata.nlink === 0) {
+            return yield* pathOp.fail("NotFound");
+        }
+        let work = path;
+        let parent;
+        let name;
+        let traversals = 0;
+        // Leading components that came from a symbolic link's target. Only the components the caller wrote are
+        // created, so a dangling link stays missing, as it does for mkdir -p.
+        let linked = 0;
+        for (let index = 0; index < work.components.length - (parentOnly ? 1 : 0); index++) {
+            if (current.kind !== "directory") {
+                return yield* pathOp.fail("NotDirectory");
+            }
+            yield* authorize(current, identity, 0o1, pathOp);
+            const component = work.components[index];
+            if (component === undefined)
+                break;
+            if (component === DOT_HEX)
+                continue;
+            if (component === DOT_DOT_HEX) {
+                current = yield* directoryAt(current.parent);
+                parent = undefined;
+                name = undefined;
+                continue;
+            }
+            parent = current;
+            name = component;
+            const childIno = current.entries.get(component);
+            const child = childIno === undefined ? undefined : (yield* get(childIno));
+            if (child === undefined) {
+                if (allowMissing && index === work.components.length - 1) {
+                    return { kind: "missing", parent, name, op: pathOp };
+                }
+                if (createMissing !== undefined && index >= linked) {
+                    current = yield* createMissing(current, component, index === work.components.length - 1);
+                    continue;
+                }
+                return yield* pathOp.fail("NotFound");
+            }
+            if (child.kind === "symlink" && (followFinalSymlink || index < work.components.length - 1 || work.trailingSlash)) {
+                if (child.target.length === 0) {
+                    return yield* pathOp.fail("NotFound");
+                }
+                if (++traversals > MAX_SYMLINK_TRAVERSALS) {
+                    return yield* pathOp.fail("SymlinkLoop");
+                }
+                const suffix = work.suffixes[index] ?? new Uint8Array(0);
+                const remaining = work.components.length - index - 1;
+                if (maxPathBytes !== undefined &&
+                    ByteSize.isGreaterThan(ByteSize.bytes(child.target.length + suffix.length), maxPathBytes)) {
+                    return yield* pathOp.fail("PathTooLong");
+                }
+                const expansion = new Uint8Array(child.target.length + suffix.length);
+                expansion.set(child.target);
+                expansion.set(suffix, child.target.length);
+                const expanded = preparePath(ownedPath(expansion), op.operation, maxPathBytes);
+                // The expansion is synthetic: its per-component limits are the caller's to hear about,
+                // but the path in the error has to be the one the caller passed in, so the
+                // expansion's own failure is not kept as the cause.
+                if (Result.isFailure(expanded)) {
+                    return yield* pathOp.fail(expanded.failure.code);
+                }
+                work = expanded.success;
+                linked = work.components.length - remaining + Math.max(0, linked - index - 1);
+                if (work.absolute)
+                    current = yield* nodeAt(ROOT_INO);
+                index = -1;
+            }
+            else
+                current = child;
+        }
+        if (!parentOnly && work.trailingSlash && current.kind !== "directory") {
+            return yield* pathOp.fail("NotDirectory");
+        }
+        return parent === undefined || name === undefined
+            ? { kind: "node", node: current, op: pathOp }
+            : { kind: "entry", node: current, parent, name, op: pathOp };
+    });
+    const resolveNode = Effect.fnUntraced(function* (target, mode, op) {
+        if (Predicate.isTagged(target, "Path")) {
+            const path = yield* Effect.fromResult(prepare(target.path, op));
+            const result = yield* walk(path, target.relativeTo, op, {
+                ...mode,
+                followFinalSymlink: mode.final === true
+                    ? mode.followFinalSymlink ?? true
+                    : target.followFinalSymlink ?? mode.followFinalSymlink ?? true
+            });
+            return result.kind === "missing" ? yield* result.op.fail("NotFound") : result;
+        }
+        if (!TokenRegistry.isOpen(caller))
+            return yield* op.fail("ClosedCaller");
+        const node = yield* TokenRegistry.nodeOrFail(yield* (Predicate.isTagged(target, "Reference")
+            ? registry.resolve(target.reference, "reference")
+            : registry.resolve(target.handle, "handle")), Predicate.isTagged(target, "Reference") ? "reference" : "handle", op);
+        return { kind: "node", node, op };
+    });
+    const directory = Effect.fnUntraced(function* (target, op) {
+        const resolved = yield* resolveNode(target, { kind: "Node" }, op);
+        if (resolved.node.kind !== "directory")
+            return yield* resolved.op.fail("NotDirectory");
+        return { node: resolved.node, op: resolved.op };
+    });
+    const entryDirectory = Effect.fnUntraced(function* (target, op) {
+        const resolved = yield* directory(target, op);
+        if (resolved.node.metadata.nlink === 0)
+            return yield* resolved.op.fail("NotFound");
+        return resolved;
+    });
+    const parent = Effect.fnUntraced(function* (prepared, op) {
+        if (prepared.kind === "entry") {
+            const resolved = yield* entryDirectory(prepared.directory, op);
+            return {
+                kind: "parent",
+                parent: resolved.node.ino,
+                name: prepared.name,
+                trailingSlash: false,
+                addressing: "entry",
+                op
+            };
+        }
+        const resolved = yield* walk(prepared.path, prepared.base, op, { kind: "Parent" });
+        if (resolved.kind === "missing")
+            return yield* resolved.op.fail("NotFound");
+        if (resolved.node.kind !== "directory")
+            return yield* resolved.op.fail("NotDirectory");
+        return {
+            kind: "parent",
+            parent: resolved.node.ino,
+            name: prepared.path.components.at(-1),
+            trailingSlash: prepared.path.trailingSlash,
+            addressing: "path",
+            op: resolved.op
+        };
+    });
+    const creationResult = (result, trailingSlash, addressing, op, origin) => {
+        if (result.kind === "node")
+            return Effect.fail(op.fail("IsDirectory"));
+        const entry = {
+            parent: result.parent,
+            name: result.name,
+            trailingSlash,
+            addressing,
+            op,
+            origin: origin ?? { parent: result.parent, name: result.name }
+        };
+        return Effect.succeed(result.kind === "missing" ? { ...entry, kind: "missing" } : { ...entry, kind: "existing", node: result.node });
+    };
+    const orCreate = Effect.fnUntraced(function* (prepared, mode, op) {
+        if (prepared.kind === "path") {
+            const pathOp = op.at(prepared.path.input);
+            if (mode.create === "exclusive") {
+                const exists = yield* Effect.result(walk(prepared.path, prepared.base, op, { kind: "Node", followFinalSymlink: false }));
+                if (Result.isSuccess(exists))
+                    return yield* pathOp.fail("AlreadyExists");
+                if (exists.failure.code !== "NotFound")
+                    return yield* exists.failure;
+            }
+            return yield* creationResult(yield* walk(prepared.path, prepared.base, op, mode), prepared.path.trailingSlash, "path", pathOp);
+        }
+        const { node: parent } = yield* entryDirectory(prepared.directory, op);
+        if (isDotComponent(prepared.name))
+            return yield* op.fail("InvalidArgument");
+        yield* authorize(parent, identity, 0o1, op);
+        const directIno = parent.entries.get(prepared.name);
+        const direct = directIno === undefined ? undefined : yield* get(directIno);
+        if (mode.beforeFollow !== undefined)
+            yield* mode.beforeFollow(parent, direct);
+        if (mode.create === "exclusive" && mode.entryExclusive !== "afterSymlink" && direct !== undefined) {
+            return yield* op.fail("AlreadyExists");
+        }
+        let result = direct === undefined
+            ? { kind: "missing", parent, name: prepared.name, op }
+            : { kind: "entry", node: direct, parent, name: prepared.name, op };
+        if (direct?.kind === "symlink" && mode.finalSymlink === "follow") {
+            const path = yield* Effect.fromResult(preparePath(ownedPath(nameBytes(prepared.name)), op.operation, undefined));
+            result = yield* walk(path, undefined, op, mode, parent);
+            // Entry writeFile rejects a followed directory before checking exclusive creation.
+            if (mode.create === "exclusive" && mode.entryExclusive === "afterSymlink" &&
+                (result.kind === "node" || (result.kind === "entry" && result.node.kind === "directory"))) {
+                return yield* op.fail("IsDirectory");
+            }
+        }
+        if (result.kind === "missing" && mode.create === "never")
+            return yield* op.fail("NotFound");
+        if (mode.create === "exclusive" && mode.entryExclusive === "afterSymlink" && result.kind !== "missing") {
+            return yield* op.fail("AlreadyExists");
+        }
+        return yield* creationResult(result, false, "entry", op, { parent, name: prepared.name });
+    });
+    function resolve(input, mode, op) {
+        if (isTarget(input)) {
+            return mode.kind === "Node" ? resolveNode(input, mode, op) : Effect.die("A node target requires Node resolution");
+        }
+        return mode.kind === "Parent"
+            ? parent(input, op)
+            : mode.kind === "OrCreate"
+                ? orCreate(input, mode, op)
+                : Effect.die("An entry requires Parent or OrCreate resolution");
+    }
+    return { prepare, prepareEntry, resolve, directory, entryDirectory };
+};

package/dist/internal/search.d.ts

@@ -0,0 +1,24 @@
+import * as Effect from "effect/Effect";
+import type { Snapshot } from "../Snapshot.js";
+import type { FsFailure, ImageFailure } from "../VfsError.js";
+import type { PathInput } from "../VirtualFileSystem.js";
+import { BudgetExceeded, type Kind, type Meter } from "./searchModel.js";
+import { type Node } from "./volumeState.js";
+/** @internal */
+export interface Entry {
+    readonly path: string;
+    readonly pathBytes: number;
+    readonly parts: ReadonlyArray<string>;
+    readonly kind: Kind;
+    readonly node: Node;
+}
+/** @internal */
+export interface Visitor {
+    readonly next: (select: (entry: Entry) => Effect.Effect<{
+        readonly selected: boolean;
+        readonly prune: boolean;
+    }, BudgetExceeded>) => Effect.Effect<Entry | undefined, BudgetExceeded>;
+}
+/** @internal */
+export declare const makeVisitor: (snapshot: Snapshot, root: PathInput, meter: Meter) => Effect.Effect<Visitor, FsFailure | ImageFailure, never>;
+//# sourceMappingURL=search.d.ts.map

package/dist/internal/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/internal/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAIxD,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,EAAE,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxE,OAAO,EAAkD,KAAK,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAE5F,gBAAgB;AAChB,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB;AAED,gBAAgB;AAChB,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,CACb,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC;QAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,cAAc,CAAC,KAC7G,MAAM,CAAC,MAAM,CAAC,KAAK,GAAG,SAAS,EAAE,cAAc,CAAC,CAAA;CACtD;AAeD,gBAAgB;AAChB,eAAO,MAAM,WAAW,gHAyFtB,CAAA"}

package/dist/internal/search.js

@@ -0,0 +1,78 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { decodeOption } from "../BytePath.js";
+import { fsFailure } from "./errors.js";
+import * as Image from "./image.js";
+import { nameBytes } from "./path.js";
+import { BudgetExceeded } from "./searchModel.js";
+import { byEntryName, getNode } from "./volumeState.js";
+/** @internal */
+export const makeVisitor = Effect.fnUntraced(function* (snapshot, root, meter) {
+    const value = yield* Image.valueOf(snapshot);
+    const node = yield* Effect.fromResult(Image.resolve(value, root, { operation: "search", followFinalSymlink: true }));
+    if (node.kind !== "directory")
+        return yield* fsFailure("NotDirectory", "search", { path: root });
+    const frames = [];
+    let deferred = { node, path: "", pathBytes: 0, parts: [], depth: 0 };
+    let pending = 0;
+    const prepare = Effect.fnUntraced(function* (directory) {
+        const width = directory.node.entries.size;
+        // Reserve prepared siblings too, before allocating this directory's sorted list.
+        if (width > meter.limits.maxEntries - meter.work.entries - pending) {
+            return yield* new BudgetExceeded({ limit: "maxEntries", path: directory.path });
+        }
+        if (width === 0)
+            return;
+        const children = [...directory.node.entries].sort(byEntryName);
+        frames.push({ ...directory, children, index: 0 });
+        pending += width;
+    });
+    const next = Effect.fnUntraced(function* (select) {
+        while (true) {
+            if (deferred !== undefined) {
+                const directory = deferred;
+                deferred = undefined;
+                yield* prepare(directory);
+            }
+            let frame = frames[frames.length - 1];
+            while (frame !== undefined && frame.index === frame.children.length) {
+                frames.pop();
+                frame = frames[frames.length - 1];
+            }
+            if (frame === undefined)
+                return undefined;
+            const [hex, ino] = frame.children[frame.index++];
+            pending--;
+            meter.work.entries++;
+            if (meter.work.entries % 128 === 0)
+                yield* Effect.yieldNow;
+            const depth = frame.depth + 1;
+            if (depth > meter.limits.maxDepth) {
+                return yield* new BudgetExceeded({ limit: "maxDepth", path: frame.path });
+            }
+            const pathBytes = frame.pathBytes + (frame.depth === 0 ? 0 : 1) + hex.length / 2;
+            if (BigInt(pathBytes) > meter.limits.maxPathBytes) {
+                return yield* new BudgetExceeded({ limit: "maxPathBytes", path: frame.path });
+            }
+            const child = getNode(value, ino);
+            const name = decodeOption(nameBytes(hex));
+            if (Option.isNone(name)) {
+                meter.skips.invalidNames++;
+                if (child.kind === "directory")
+                    meter.skips.invalidNameSubtrees++;
+                continue;
+            }
+            const path = frame.depth === 0 ? name.value : `${frame.path}/${name.value}`;
+            const parts = [...frame.parts, name.value];
+            const entry = { path, pathBytes, parts, kind: child.kind, node: child };
+            const selection = yield* select(entry);
+            // Delay children until the following pull, so a row cap needs no lookahead work.
+            if (child.kind === "directory" && !selection.prune) {
+                deferred = { node: child, path, pathBytes, parts, depth };
+            }
+            if (selection.selected)
+                return entry;
+        }
+    });
+    return { next };
+});

package/dist/internal/searchContent.d.ts

@@ -0,0 +1,77 @@
+import * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import { BudgetExceeded, type CountResult, type LineResult, QueryFailure } from "../Search.js";
+import type { Snapshot } from "../Snapshot.js";
+/** @internal */
+export interface ContentRows {
+    readonly lines: LineResult;
+    readonly files: string;
+    readonly countLines: CountResult;
+}
+/** @internal */
+export type Mode = keyof ContentRows;
+/** @internal */
+export declare const evaluate: <M extends Mode>(snapshot: Snapshot, input: {
+    readonly root: string | import("../BytePath.js").BytePath;
+    readonly include: readonly [string, ...string[]];
+    readonly exclude?: readonly string[];
+    readonly pattern: {
+        readonly _tag: "Literal";
+        readonly pattern: string;
+    } | {
+        readonly _tag: "Regex";
+        readonly pattern: string;
+    };
+    readonly ignoreCase?: boolean;
+    readonly limits?: {
+        readonly maxEntries?: number;
+        readonly maxDepth?: number;
+        readonly maxPathBytes?: ByteSize.ByteSize;
+        readonly maxResults?: number;
+        readonly maxResultBytes?: ByteSize.ByteSize;
+        readonly maxPatternBytes?: ByteSize.ByteSize;
+        readonly maxPatterns?: number;
+        readonly maxPatternListBytes?: ByteSize.ByteSize;
+        readonly maxExpansions?: number;
+        readonly maxTokens?: number;
+        readonly maxMatchingWork?: number;
+        readonly maxScannedBytes?: ByteSize.ByteSize;
+        readonly maxFileBytes?: ByteSize.ByteSize;
+        readonly maxLineEvaluations?: number;
+        readonly maxExcerptBytes?: ByteSize.ByteSize;
+    };
+}, mode: M) => Effect.Effect<{
+    query: {
+        readonly root: string | import("../BytePath.js").BytePath;
+        readonly include: readonly [string, ...string[]];
+        readonly exclude?: readonly string[];
+        readonly pattern: {
+            readonly _tag: "Literal";
+            readonly pattern: string;
+        } | {
+            readonly _tag: "Regex";
+            readonly pattern: string;
+        };
+        readonly ignoreCase?: boolean;
+        readonly limits?: {
+            readonly maxEntries?: number;
+            readonly maxDepth?: number;
+            readonly maxPathBytes?: ByteSize.ByteSize;
+            readonly maxResults?: number;
+            readonly maxResultBytes?: ByteSize.ByteSize;
+            readonly maxPatternBytes?: ByteSize.ByteSize;
+            readonly maxPatterns?: number;
+            readonly maxPatternListBytes?: ByteSize.ByteSize;
+            readonly maxExpansions?: number;
+            readonly maxTokens?: number;
+            readonly maxMatchingWork?: number;
+            readonly maxScannedBytes?: ByteSize.ByteSize;
+            readonly maxFileBytes?: ByteSize.ByteSize;
+            readonly maxLineEvaluations?: number;
+            readonly maxExcerptBytes?: ByteSize.ByteSize;
+        };
+    };
+    meter: import("./searchModel.js").Meter;
+    next: () => Effect.Effect<ContentRows[M] | undefined, BudgetExceeded, never>;
+}, QueryFailure | import("../VfsError.js").FsFailure | import("../VfsError.js").ImageFailure, never>;
+//# sourceMappingURL=searchContent.d.ts.map

package/dist/internal/searchContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchContent.d.ts","sourceRoot":"","sources":["../../src/internal/searchContent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EACL,cAAc,EAEd,KAAK,WAAW,EAEhB,KAAK,UAAU,EAEf,YAAY,EACb,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAK9C,gBAAgB;AAChB,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAA;CACjC;AAED,gBAAgB;AAChB,MAAM,MAAM,IAAI,GAAG,MAAM,WAAW,CAAA;AAkFpC,gBAAgB;AAChB,eAAO,MAAM,QAAQ,GAA+B,CAAC,SAAS,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAsMhE,CAAA"}