@phosart/common 0.4.22

package/dist/server/character.js

@@ -0,0 +1,76 @@
+import { $DATA } from "./directories.js";
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as yaml from 'yaml';
+import { FullCharacter, RawCharacter } from "./models/Character.js";
+import { processImageFastcache } from "./imageprocess.js";
+import { cacheVersion, getCache, fullPath, relPath } from "./util.js";
+import { flushFastCache, readFastCache } from "./fastcache.js";
+import { galleries } from "./gallery.js";
+import { normalizeCharacter } from "../util/art.js";
+const CHARACTER_PATH = path.join('characters', 'characters.yaml');
+async function doResolveImage(filename, character, fc) {
+    const full = processImageFastcache(fc, fullPath(filename, character.picture.image), relPath(filename, character.picture.image));
+    const thumb = character.thumbnail
+        ? processImageFastcache(fc, fullPath(filename, character.thumbnail.image), relPath(filename, character.thumbnail.image))
+        : undefined;
+    return {
+        ...character,
+        picture: { ...(await full), alt: character.picture.alt },
+        thumbnail: thumb
+            ? {
+                ...(await thumb),
+                alt: character.thumbnail.alt
+            }
+            : undefined
+    };
+}
+export async function rawCharacters() {
+    const cached = getCache().rawCharacterCache;
+    const nextVersion = await cacheVersion();
+    if (cached.cache && cached.version === nextVersion) {
+        return cached.cache;
+    }
+    const document = yaml.parse(await fs.readFile(path.join($DATA(), CHARACTER_PATH), { encoding: 'utf-8' }));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const characters = document
+        .flatMap((obj, idx) => {
+        const ch = RawCharacter.parse({ ...obj, index: idx++ });
+        return ch;
+    })
+        .reduce((acc, cur) => ({ ...acc, [cur.name]: cur }), {});
+    getCache().rawCharacterCache.cache = characters;
+    getCache().rawCharacterCache.version = nextVersion;
+    return characters;
+}
+export async function characters() {
+    const cached = getCache().characterCache;
+    const nextVersion = await cacheVersion();
+    if (cached.cache && cached.version === nextVersion) {
+        return cached.cache;
+    }
+    const characters = await rawCharacters();
+    const fc = await readFastCache();
+    const resolved = Object.fromEntries(await Promise.all(Object.entries(characters).map(async ([k, v]) => {
+        const resolved = await doResolveImage(CHARACTER_PATH, v, fc);
+        return [k, resolved];
+    })));
+    await flushFastCache(fc);
+    getCache().characterCache.cache = resolved;
+    getCache().characterCache.version = nextVersion;
+    return resolved;
+}
+export async function getAllCharacters() {
+    const all = await characters();
+    const mapped = Object.values(await galleries())
+        .flatMap((g) => g.pieces)
+        .flatMap((p) => p.characters)
+        .flatMap((ch) => normalizeCharacter(ch, all))
+        .concat(Object.values(all).map((ch) => normalizeCharacter(ch.name, all)));
+    // Collapse by name, from pair
+    const record = {};
+    for (const m of mapped) {
+        record[`${m.name}\x00${m.from}`] = m;
+    }
+    return Object.values(record);
+}

package/dist/server/directories.d.ts

@@ -0,0 +1,4 @@
+export declare const $ROOT: () => string;
+export declare const $DATA: () => string;
+export declare const $PUBLIC: () => string;
+//# sourceMappingURL=directories.d.ts.map

package/dist/server/directories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directories.d.ts","sourceRoot":"","sources":["../../src/lib/server/directories.ts"],"names":[],"mappings":"AA0CA,eAAO,MAAM,KAAK,cAAgC,CAAC;AACnD,eAAO,MAAM,KAAK,cAA8B,CAAC;AACjD,eAAO,MAAM,OAAO,cAA2C,CAAC"}

package/dist/server/directories.js

@@ -0,0 +1,39 @@
+import { join, dirname } from 'node:path';
+import * as fs from 'node:fs';
+function tryFindRoot(start) {
+    let cur = dirname(start);
+    while (cur.length > 1) {
+        if (cur.includes('node_modules')) {
+            cur = join(cur, '..');
+            continue;
+        }
+        try {
+            // If package.json parses correctly...
+            JSON.parse(fs.readFileSync(join(cur, 'package.json'), { encoding: 'utf-8' }));
+            return cur;
+        }
+        catch {
+            cur = join(cur, '..');
+        }
+    }
+    return null;
+}
+let cachedRoot = null;
+function findRoot() {
+    if (cachedRoot) {
+        return cachedRoot;
+    }
+    let root = null;
+    if (process.env.PROJECT_ROOT) {
+        root = tryFindRoot(process.env.PROJECT_ROOT);
+    }
+    root = root ?? tryFindRoot(process.argv[1]) ?? tryFindRoot(process.cwd());
+    if (!root) {
+        throw new Error('Failed to find root');
+    }
+    cachedRoot = root;
+    return root;
+}
+export const $ROOT = () => join(findRoot(), 'src');
+export const $DATA = () => join($ROOT(), 'data');
+export const $PUBLIC = () => join($ROOT(), '..', 'static', '_');

package/dist/server/fastcache.d.ts

@@ -0,0 +1,11 @@
+export interface FastCache {
+    [relpath: string]: {
+        mtime: number;
+        hash: string;
+    };
+}
+export declare function getFastHash(fc: FastCache, fullpath: string, relpath: string): Promise<[string | null, number | null]>;
+export declare function updateFastCache(fc: FastCache, fullpath: string, relpath: string, hash: string, premtime?: number | null): Promise<void>;
+export declare function flushFastCache(fc: FastCache): Promise<void>;
+export declare function readFastCache(): Promise<FastCache>;
+//# sourceMappingURL=fastcache.d.ts.map

package/dist/server/fastcache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastcache.d.ts","sourceRoot":"","sources":["../../src/lib/server/fastcache.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,SAAS;IACzB,CAAC,OAAO,EAAE,MAAM,GAAG;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;KACb,CAAC;CACF;AAED,wBAAsB,WAAW,CAChC,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAYzC;AAED,wBAAsB,eAAe,CACpC,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,iBAQxB;AAED,wBAAsB,cAAc,CAAC,EAAE,EAAE,SAAS,iBAMjD;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,SAAS,CAAC,CAOxD"}

package/dist/server/fastcache.js

@@ -0,0 +1,43 @@
+import { stat } from 'node:fs/promises';
+import { $DATA } from "./directories.js";
+import path from 'node:path';
+import { Logger } from 'tslog';
+import { getLogLevel } from "./util.js";
+import { readPack, writePack } from "./pack.js";
+const FastcacheLogger = new Logger({ minLevel: getLogLevel() });
+const $FASTCACHEPATH = () => path.join($DATA(), '.fastcache.pack.gz');
+export async function getFastHash(fc, fullpath, relpath) {
+    const cacheinfo = fc[relpath];
+    if (!cacheinfo)
+        return [null, null];
+    const fstat = await stat(fullpath);
+    const mtime = fstat.mtimeMs;
+    if (mtime !== cacheinfo.mtime) {
+        return [null, mtime];
+    }
+    return [cacheinfo.hash, mtime];
+}
+export async function updateFastCache(fc, fullpath, relpath, hash, premtime) {
+    const mtime = premtime ?? (await stat(fullpath)).mtimeMs;
+    fc[relpath] = {
+        mtime,
+        hash
+    };
+}
+export async function flushFastCache(fc) {
+    try {
+        await writePack($FASTCACHEPATH(), fc);
+    }
+    catch (err) {
+        FastcacheLogger.warn('Failed to write fastcache', err);
+    }
+}
+export async function readFastCache() {
+    try {
+        return await readPack($FASTCACHEPATH());
+    }
+    catch (err) {
+        FastcacheLogger.warn('Failed to read fastcache', err);
+        return {};
+    }
+}

package/dist/server/filter.d.ts

@@ -0,0 +1,6 @@
+import { type ArtPiece, type ResourceRef } from '../util/art.ts';
+export declare function filter(gallery: ArtPiece[] | Record<string, ArtPiece>, by?: ResourceRef, { negated, sorted }?: {
+    negated?: boolean;
+    sorted?: boolean;
+}): ArtPiece[];
+//# sourceMappingURL=filter.d.ts.map

package/dist/server/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/lib/server/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,MAAM,gBAAgB,CAAC;AAgDxB,wBAAgB,MAAM,CACrB,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC9C,EAAE,CAAC,EAAE,WAAW,EAChB,EAAE,OAAO,EAAE,MAAM,EAAE,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAC/D,QAAQ,EAAE,CAaZ"}

package/dist/server/filter.js

@@ -0,0 +1,53 @@
+import { normalizeArtist, normalizeCharacter } from "../util/art.js";
+function filterOne(piece, by, negated) {
+    if (!by.type || !by.resource) {
+        return false;
+    }
+    switch (by.type) {
+        case 'artist': {
+            const artists = normalizeArtist(piece.artist);
+            let hasArtist = artists.some((artist) => artist.name.toLowerCase() === by.resource.name.toLowerCase());
+            if (negated) {
+                hasArtist = !hasArtist;
+            }
+            return hasArtist;
+        }
+        case 'character': {
+            const characters = normalizeCharacter(piece.characters);
+            let hasCharacter = characters.some((ch) => ch.name.toLowerCase() === by.resource.name.toLowerCase() &&
+                (ch.from?.toLowerCase() === by.resource.from?.toLowerCase() ||
+                    (!ch.from && !by.resource.from)));
+            if (negated) {
+                hasCharacter = !hasCharacter;
+            }
+            return hasCharacter;
+        }
+        case 'piece': {
+            let isPiece = by.resource.slug === piece.slug;
+            if (negated) {
+                isPiece = !isPiece;
+            }
+            return isPiece;
+        }
+        case 'tag': {
+            let hasTag = piece.tags.map((t) => t.toLowerCase()).includes(by.resource.toLowerCase());
+            if (negated) {
+                hasTag = !hasTag;
+            }
+            return hasTag;
+        }
+    }
+}
+export function filter(gallery, by, { negated, sorted } = {}) {
+    if (!Array.isArray(gallery))
+        gallery = Object.values(gallery);
+    const results = by
+        ? gallery.filter((piece) => {
+            return filterOne(piece, by, negated ?? false);
+        })
+        : gallery;
+    if (!sorted) {
+        return results;
+    }
+    return results.sort((a, b) => b.date.getTime() - a.date.getTime());
+}

package/dist/server/gallery.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { FullGallery, RawGallery } from './models/Gallery.ts';
+import type { ArtPiece } from '../util/art.ts';
+type FileName = string;
+type RawGalleryT = z.infer<typeof RawGallery>;
+type FullGalleryT = z.infer<typeof FullGallery>;
+type GalleryListing<T> = Record<FileName, T>;
+export type GalleryCache = GalleryListing<FullGalleryT>;
+export type RawGalleryCache = GalleryListing<RawGalleryT>;
+export declare function rawGalleries(): Promise<RawGalleryCache>;
+export declare function galleries(doRetry?: boolean): Promise<GalleryCache>;
+export declare function allPieces(): Promise<Record<string, ArtPiece>>;
+export declare function getPieceBySlug(slug: string): Promise<ArtPiece | null>;
+export declare function hasNsfw(gallery: ArtPiece[]): boolean;
+export {};
+//# sourceMappingURL=gallery.d.ts.map

package/dist/server/gallery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gallery.d.ts","sourceRoot":"","sources":["../../src/lib/server/gallery.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAIN,WAAW,EACX,UAAU,EACV,MAAM,qBAAqB,CAAC;AAa7B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,KAAK,QAAQ,GAAG,MAAM,CAAC;AAEvB,KAAK,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,KAAK,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAChD,KAAK,cAAc,CAAC,CAAC,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;AAE7C,MAAM,MAAM,YAAY,GAAG,cAAc,CAAC,YAAY,CAAC,CAAC;AACxD,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC;AAmH1D,wBAAsB,YAAY,IAAI,OAAO,CAAC,eAAe,CAAC,CAgC7D;AAED,wBAAsB,SAAS,CAAC,OAAO,GAAE,OAAc,yBAsDtD;AAMD,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAKnE;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAE3E;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,OAAO,CAEpD"}

package/dist/server/gallery.js

@@ -0,0 +1,162 @@
+import { glob } from 'glob';
+import * as yaml from 'yaml';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import { z } from 'zod';
+import { Logger } from 'tslog';
+import { BaseArtPiece, BaseGallery, FullArtPiece, FullGallery, RawGallery } from "./models/Gallery.js";
+import { $DATA } from "./directories.js";
+import { processImageFastcache, processVideoFastcache } from "./imageprocess.js";
+import { cacheVersion, clearCache, getCache, hash, fullPath, relPath, getLogLevel } from "./util.js";
+import { flushFastCache, readFastCache } from "./fastcache.js";
+import { asRecord } from "../util/util.js";
+const GalleryLogger = new Logger({ minLevel: getLogLevel() });
+async function resolveExtendsRec(fname, gallery, rec, fc) {
+    if (!('$extends' in gallery)) {
+        return await resolveReferences(gallery, fname, fc);
+    }
+    const full = { pieces: [] };
+    for (const relative of gallery.$extends) {
+        const base = path.dirname(fname);
+        const target = path.join(base, relative);
+        if (rec[target]) {
+            const result = await resolveExtendsRec(target, rec[target], rec, fc);
+            if ('$extends' in result) {
+                throw new Error('Impossible');
+            }
+            full.pieces.push(...result.pieces);
+        }
+        else {
+            GalleryLogger.warn('[GALLERY] Could not find target for', target, 'when parsing', fname);
+        }
+    }
+    return full;
+}
+async function resolveExtends(rec, fc) {
+    const listing = {};
+    for (const [fname, gallery] of Object.entries(rec)) {
+        if ('$extends' in gallery) {
+            listing[fname] = await resolveExtendsRec(fname, gallery, rec, fc);
+        }
+        else {
+            listing[fname] = await resolveReferences(gallery, fname, fc);
+        }
+    }
+    return listing;
+}
+async function resolvePieceReferences(piece, filename, fc) {
+    const relpath = relPath(filename, piece.image);
+    const fullpath = fullPath(filename, piece.image);
+    const image = await processImageFastcache(fc, fullpath, relpath, { position: piece.position });
+    const alts = await Promise.all(piece.alts?.map(async (alt) => ({
+        ...alt,
+        image: await processImageFastcache(fc, fullPath(filename, alt.image), relPath(filename, alt.image), { position: piece.position }),
+        video: alt.video
+            ? {
+                full: await processVideoFastcache(fc, fullPath(filename, alt.video.full), relPath(filename, alt.video.full), 'full'),
+                thumb: await processVideoFastcache(fc, fullPath(filename, alt.video.thumb), relPath(filename, alt.video.thumb), 'thumb')
+            }
+            : undefined
+    })) ?? []);
+    const video = piece.video
+        ? {
+            full: await processVideoFastcache(fc, fullPath(filename, piece.video.full), relPath(filename, piece.video.full), 'full'),
+            thumb: await processVideoFastcache(fc, fullPath(filename, piece.video.thumb), relPath(filename, piece.video.thumb), 'thumb')
+        }
+        : undefined;
+    return { ...piece, image, alts, video };
+}
+async function resolveReferences(gallery, fname, fc) {
+    return {
+        pieces: await Promise.all(gallery.pieces.map((piece) => resolvePieceReferences(piece, fname, fc)))
+    };
+}
+export async function rawGalleries() {
+    const cached = getCache().rawGalleryCache;
+    const nextVersion = await cacheVersion();
+    if (cached.cache && cached.version === nextVersion) {
+        return cached.cache;
+    }
+    const allGalleries = await glob('./**/*.gallery', { cwd: $DATA() });
+    const documents = (await Promise.all(allGalleries.map((fn) => fs
+        .readFile(path.join($DATA(), fn), { encoding: 'utf-8' })
+        .then((text) => ({ filename: fn, text })))))
+        .map(({ filename, text }) => ({ filename, obj: yaml.parse(text) }))
+        .map(({ filename, obj }) => {
+        GalleryLogger.silly('[GALLERY] Parsing', filename);
+        obj.pieces = obj.pieces
+            ? obj.pieces.map((p) => ({ ...p, slug: p.id ?? hash(p) }))
+            : undefined;
+        return { filename, obj: RawGallery.parse(obj) };
+    })
+        .reduce((rec, { filename, obj }) => ({ ...rec, [filename.replaceAll(path.sep, '/')]: obj }), {});
+    getCache().rawGalleryCache.cache = documents;
+    getCache().rawGalleryCache.version = nextVersion;
+    return documents;
+}
+export async function galleries(doRetry = true) {
+    const cached = getCache().galleryCache;
+    const nextVersion = await cacheVersion();
+    if (cached.cache && cached.version === nextVersion) {
+        return cached.cache;
+    }
+    const documents = Object.fromEntries(Object.entries(await rawGalleries())
+        .map(([path, g]) => {
+        if ('pieces' in g) {
+            g = {
+                pieces: g.pieces
+                    .map((p) => {
+                    if (p.deindexed) {
+                        return null;
+                    }
+                    if (p.alts) {
+                        p = { ...p, alts: p.alts.filter((a) => !a.deindexed) };
+                    }
+                    return p;
+                })
+                    .filter(truthy)
+            };
+            if (g.pieces.length === 0) {
+                return null;
+            }
+            return [path, g];
+        }
+        else {
+            if (g.$extends.length === 0) {
+                return null;
+            }
+            return [path, g];
+        }
+    })
+        .filter(truthy));
+    try {
+        const fc = await readFastCache();
+        const out = await resolveExtends(documents, fc);
+        await flushFastCache(fc);
+        getCache().galleryCache.cache = out;
+        getCache().galleryCache.version = nextVersion;
+        return out;
+    }
+    catch (e) {
+        if (doRetry) {
+            GalleryLogger.warn('Encountered error, clearing cache and trying again', e);
+            clearCache();
+            return await galleries(/* doRetry = */ false);
+        }
+        else {
+            throw e;
+        }
+    }
+}
+function truthy(t) {
+    return !!t;
+}
+export async function allPieces() {
+    return asRecord(Object.values(await galleries()).flatMap((p) => p.pieces), (p) => p.slug);
+}
+export async function getPieceBySlug(slug) {
+    return (await allPieces())[slug] ?? null;
+}
+export function hasNsfw(gallery) {
+    return gallery.some((p) => p.nsfw);
+}

package/dist/server/imageprocess.d.ts

@@ -0,0 +1,18 @@
+import type { z } from 'zod';
+import type { Picture } from './models/image.ts';
+import { type FastCache } from './fastcache.ts';
+interface ProcessOptions {
+    forceKeep?: boolean;
+    position?: string;
+}
+export declare function getProcessedHashes(): ReadonlySet<string>;
+export declare function clearProcessedHashes(): void;
+export declare function getUnusedHashes(): Promise<ReadonlySet<string>>;
+export declare function deleteHashes(unused: ReadonlySet<string>): Promise<void>;
+export declare function cleanUnusedHashes(): Promise<void>;
+export declare function processVideoFastcache(fc: FastCache, fullpath: string, relpath: string, name: string, processOptions?: ProcessOptions): Promise<string>;
+export declare function processVideo(url: string, name: string): Promise<string>;
+export declare function processImageFastcache(fc: FastCache, fullpath: string, relpath: string, processOptions?: ProcessOptions): Promise<z.infer<typeof Picture>>;
+export declare function processImage(url: string, processOptions?: ProcessOptions): Promise<z.infer<typeof Picture>>;
+export {};
+//# sourceMappingURL=imageprocess.d.ts.map

package/dist/server/imageprocess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageprocess.d.ts","sourceRoot":"","sources":["../../src/lib/server/imageprocess.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAgC,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AA0B9E,UAAU,cAAc;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAOD,wBAAgB,kBAAkB,IAAI,WAAW,CAAC,MAAM,CAAC,CAExD;AACD,wBAAgB,oBAAoB,SAEnC;AACD,wBAAsB,eAAe,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAiBpE;AACD,wBAAsB,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,iBAsB7D;AACD,wBAAsB,iBAAiB,kBAEtC;AAYD,wBAAsB,qBAAqB,CAC1C,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,cAAc,GAAE,cAAmB,GACjC,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAE7E;AAsBD,wBAAsB,qBAAqB,CAC1C,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,cAAc,GAAE,cAAmB,GACjC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC,CAQlC;AAED,wBAAsB,YAAY,CACjC,GAAG,EAAE,MAAM,EACX,cAAc,GAAE,cAAmB,GACjC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC,CAElC"}