@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/trpc/routers/discord.js

@@ -1,285 +0,0 @@
-import { protectedProcedure, router } from '../index.js';
-import { badRequest, defineSchema, failed, optStr, reqObj } from '../validation.js';
-import { discordRPCService } from '../../discord-rpc.js';
-import { discordGatewayService } from '../../discord-gateway.js';
-import { getDlsitePoster, getMangadexCover } from '../../hono/watchlist.js';
-import { updateEnvFile } from '../../utils/env.utils.js';
-import logger from '../../logger.js';
-function maskToken(t) {
-    if (!t)
-        return 'none';
-    return t.slice(0, 8) + '...' + t.slice(-4);
-}
-const gatewayLog = logger.child({ module: 'DiscordGatewayRoutes' });
-function optUnknown(obj, name) {
-    return obj[name];
-}
-function cleanProxyThumb(value) {
-    let thumb = String(value || '');
-    if (thumb.includes('/api/proxy') || thumb.includes('/api/image-proxy')) {
-        const match = thumb.match(/url=([^&]+)/);
-        if (match) {
-            try {
-                thumb = decodeURIComponent(match[1]);
-            }
-            catch {
-                return '';
-            }
-        }
-    }
-    if (!thumb.startsWith('https://'))
-        return '';
-    if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
-        return '';
-    return thumb;
-}
-const presenceInput = () => defineSchema((value) => {
-    if (value === undefined || value === null)
-        return {};
-    return { ...reqObj(value) };
-});
-export const discordRouter = router({
-    pageStatus: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
-        const page = optUnknown(input, 'page');
-        if (typeof page !== 'string' || !discordRPCService.isServiceEnabled) {
-            return { success: true };
-        }
-        discordRPCService.setIdleStatus(page);
-        return { success: true };
-    }),
-    heartbeat: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
-        const sessionId = optUnknown(input, 'sessionId');
-        const bye = optUnknown(input, 'bye');
-        if (typeof sessionId !== 'string' || !discordRPCService.isServiceEnabled) {
-            return { success: true };
-        }
-        if (bye) {
-            discordRPCService.removeHeartbeat(sessionId);
-        }
-        else {
-            discordRPCService.heartbeat(sessionId);
-        }
-        return { success: true };
-    }),
-    clear: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
-        const sessionId = optUnknown(input, 'sessionId');
-        if (!discordRPCService.isServiceEnabled) {
-            return { success: true };
-        }
-        discordRPCService.clearPresence(typeof sessionId === 'string' ? sessionId : undefined);
-        return { success: true };
-    }),
-    asmrPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
-        if (!discordRPCService.isServiceEnabled)
-            return { success: true };
-        const sessionId = optUnknown(input, 'sessionId');
-        if (typeof sessionId === 'string')
-            discordRPCService.heartbeat(sessionId);
-        const thumbnail = optUnknown(input, 'thumbnail');
-        const thumbnails = optUnknown(input, 'thumbnails');
-        const rjCode = optUnknown(input, 'rjCode');
-        let thumb = String(thumbnail || '');
-        const thumbs = Array.isArray(thumbnails) ? thumbnails.map(String).filter(Boolean) : undefined;
-        const needsDlsite = !thumb || thumb.includes('weeabo0.xyz') || thumb.includes('japaneseasmr.com');
-        if (needsDlsite && rjCode) {
-            const dlsiteThumb = await getDlsitePoster(String(rjCode));
-            if (dlsiteThumb)
-                thumb = dlsiteThumb;
-        }
-        if (thumb.includes('/api/image-proxy') || thumb.includes('weeabo0.xyz'))
-            thumb = '';
-        discordRPCService.updatePresence({
-            title: String(optUnknown(input, 'title') || 'ASMR').slice(0, 128),
-            episode: String(optUnknown(input, 'trackLabel') || '').slice(0, 64),
-            totalEpisodes: '',
-            currentTime: Number(optUnknown(input, 'currentTime')) || 0,
-            duration: Number(optUnknown(input, 'duration')) || 0,
-            thumbnail: thumb,
-            thumbnails: thumbs,
-            isPlaying: !!optUnknown(input, 'isPlaying'),
-            providerName: 'ASMR',
-            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
-            isAdult: !!optUnknown(input, 'isAdult'),
-        });
-        return { success: true };
-    }),
-    radioPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
-        if (!discordRPCService.isServiceEnabled)
-            return { success: true };
-        const sessionId = optUnknown(input, 'sessionId');
-        if (typeof sessionId === 'string')
-            discordRPCService.heartbeat(sessionId);
-        let thumb = String(optUnknown(input, 'thumbnail') || '');
-        if (thumb.includes('/api/image-proxy')) {
-            const match = thumb.match(/url=([^&]+)/);
-            if (match)
-                thumb = decodeURIComponent(match[1]);
-        }
-        if (thumb && !thumb.startsWith('https://'))
-            thumb = '';
-        if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
-            thumb = '';
-        const stationLabel = String(optUnknown(input, 'stationLabel') || '');
-        discordRPCService.updatePresence({
-            title: String(optUnknown(input, 'title') || 'Radio').slice(0, 128),
-            episode: stationLabel.slice(0, 64),
-            totalEpisodes: '',
-            stateLine: (stationLabel || 'Radio').slice(0, 64),
-            currentTime: Number(optUnknown(input, 'currentTime')) || 0,
-            duration: 0,
-            thumbnail: thumb,
-            isPlaying: !!optUnknown(input, 'isPlaying'),
-            providerName: 'Radio',
-            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
-            isAdult: false,
-        });
-        return { success: true };
-    }),
-    musicPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
-        if (!discordRPCService.isServiceEnabled)
-            return { success: true };
-        const sessionId = optUnknown(input, 'sessionId');
-        if (typeof sessionId === 'string')
-            discordRPCService.heartbeat(sessionId);
-        let thumb = String(optUnknown(input, 'thumbnail') || '');
-        if (thumb.includes('/api/image-proxy')) {
-            const match = thumb.match(/url=([^&]+)/);
-            if (match)
-                thumb = decodeURIComponent(match[1]);
-        }
-        if (thumb && !thumb.startsWith('https://'))
-            thumb = '';
-        if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
-            thumb = '';
-        const artistLabel = String(optUnknown(input, 'artistLabel') || '');
-        discordRPCService.updatePresence({
-            title: String(optUnknown(input, 'title') || 'Music').slice(0, 128),
-            episode: artistLabel.slice(0, 64),
-            totalEpisodes: '',
-            stateLine: (artistLabel || 'Music').slice(0, 64),
-            currentTime: Number(optUnknown(input, 'currentTime')) || 0,
-            duration: Number(optUnknown(input, 'duration')) || 0,
-            thumbnail: thumb,
-            isPlaying: !!optUnknown(input, 'isPlaying'),
-            providerName: 'Music',
-            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
-            isAdult: false,
-        });
-        return { success: true };
-    }),
-    mangaPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
-        if (!discordRPCService.isServiceEnabled)
-            return { success: true };
-        const sessionId = optUnknown(input, 'sessionId');
-        if (typeof sessionId === 'string')
-            discordRPCService.heartbeat(sessionId);
-        const thumbnails = optUnknown(input, 'thumbnails');
-        const title = optUnknown(input, 'title');
-        let thumb = cleanProxyThumb(optUnknown(input, 'thumbnail'));
-        let thumbs = Array.isArray(thumbnails)
-            ? thumbnails.map(cleanProxyThumb).filter(Boolean)
-            : undefined;
-        if (!thumb && title) {
-            const fallback = await getMangadexCover(String(title));
-            if (fallback) {
-                thumb = fallback;
-                thumbs = [fallback, ...(thumbs || [])];
-            }
-        }
-        const chapterLabel = String(optUnknown(input, 'chapterLabel') || '');
-        discordRPCService.updatePresence({
-            title: String(title || 'Manga').slice(0, 128),
-            episode: chapterLabel.slice(0, 64),
-            totalEpisodes: '',
-            stateLine: (chapterLabel ? `Reading ${chapterLabel}` : 'Reading').slice(0, 64),
-            currentTime: 0,
-            duration: 0,
-            thumbnail: thumb,
-            thumbnails: thumbs,
-            isPlaying: optUnknown(input, 'isPlaying') !== false,
-            providerName: 'Manga',
-            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
-            isAdult: optUnknown(input, 'isAdult') === true,
-        });
-        return { success: true };
-    }),
-    tvPresence: protectedProcedure.input(presenceInput()).mutation(async ({ input }) => {
-        if (!discordRPCService.isServiceEnabled)
-            return { success: true };
-        const sessionId = optUnknown(input, 'sessionId');
-        if (typeof sessionId === 'string')
-            discordRPCService.heartbeat(sessionId);
-        const thumbnail = optUnknown(input, 'thumbnail');
-        let thumb = String(thumbnail || '');
-        if (thumb.includes('/api/image-proxy')) {
-            const match = thumb.match(/url=([^&]+)/);
-            if (match)
-                thumb = decodeURIComponent(match[1]);
-        }
-        if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
-            thumb = '';
-        const episodeLabel = String(optUnknown(input, 'episodeLabel') || '');
-        discordRPCService.updatePresence({
-            title: String(optUnknown(input, 'title') || 'TV').slice(0, 128),
-            episode: episodeLabel.slice(0, 64),
-            totalEpisodes: '',
-            stateLine: (episodeLabel || 'Movie').slice(0, 64),
-            currentTime: Number(optUnknown(input, 'currentTime')) || 0,
-            duration: Number(optUnknown(input, 'duration')) || 0,
-            thumbnail: thumb,
-            isPlaying: !!optUnknown(input, 'isPlaying'),
-            providerName: 'TV',
-            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
-            isAdult: optUnknown(input, 'isAdult') === true,
-        });
-        return { success: true };
-    }),
-    gatewayStatus: protectedProcedure.query(() => {
-        const hasToken = discordGatewayService.hasToken();
-        return {
-            hasToken,
-            masked: hasToken ? maskToken(process.env.DISCORD_GATEWAY_TOKEN) : null,
-            enabled: discordGatewayService.serviceEnabled,
-        };
-    }),
-    gatewaySave: protectedProcedure
-        .input(defineSchema((value) => {
-        if (value === undefined || value === null)
-            return {};
-        const obj = reqObj(value);
-        const out = {};
-        const token = optStr(obj, 'token');
-        if (token !== undefined)
-            out.token = token;
-        return out;
-    }))
-        .mutation(async ({ input }) => {
-        let token = (input.token || '').trim();
-        if (token.startsWith('"') && token.endsWith('"'))
-            token = token.slice(1, -1);
-        if (token.length < 30)
-            throw badRequest('Token too short');
-        try {
-            await updateEnvFile({ DISCORD_GATEWAY_TOKEN: token });
-            discordGatewayService.reloadToken();
-            gatewayLog.info(`Discord Gateway token saved ${maskToken(token)} (not logged)`);
-            return { ok: true, masked: maskToken(token) };
-        }
-        catch (e) {
-            gatewayLog.error({ err: e }, 'Failed to save Discord Gateway token');
-            throw failed('Failed to save token');
-        }
-    }),
-    gatewayRemove: protectedProcedure.mutation(async () => {
-        try {
-            await updateEnvFile({ DISCORD_GATEWAY_TOKEN: '' });
-            discordGatewayService.reloadToken();
-            gatewayLog.info('Discord Gateway token removed');
-            return { ok: true };
-        }
-        catch (e) {
-            gatewayLog.error({ err: e }, 'Failed to remove Discord Gateway token');
-            throw failed('Failed to remove token');
-        }
-    }),
-});

package/server/dist/trpc/routers/discovery.js

@@ -1,11 +0,0 @@
-import { protectedProcedure, router } from '../index.js';
-import { getWatchlistDiscoveryStatus, triggerWatchlistDiscovery } from '../../hono/watchlist.js';
-export const discoveryRouter = router({
-    status: protectedProcedure.query(() => {
-        return getWatchlistDiscoveryStatus();
-    }),
-    refresh: protectedProcedure.mutation(() => {
-        const started = triggerWatchlistDiscovery();
-        return { success: true, started, ...getWatchlistDiscoveryStatus() };
-    }),
-});

package/server/dist/trpc/routers/insights.js

@@ -1,14 +0,0 @@
-import { protectedProcedure, router } from '../index.js';
-import { getWatchInsights, getGenreCards } from '../../lib/insights.js';
-import { getCachedRecommendations } from '../../lib/recommendations.service.js';
-export const insightsRouter = router({
-    summary: protectedProcedure.query(async ({ ctx }) => {
-        return getWatchInsights(ctx.db);
-    }),
-    genreCards: protectedProcedure.query(async ({ ctx }) => {
-        return getGenreCards(ctx.db);
-    }),
-    recommendations: protectedProcedure.query(async ({ ctx }) => {
-        return { candidates: await getCachedRecommendations(ctx.db) };
-    }),
-});

package/server/dist/trpc/routers/manga-library.js

@@ -1,263 +0,0 @@
-import { TRPCError } from '@trpc/server';
-import { protectedProcedure, router } from '../index.js';
-import { performMangaWriteTransactionAsync } from '../../sync.js';
-import { buildMangaId, MANGA_STATUSES, MangaLibraryRepository, MangaProgressRepository, } from '../../repositories/manga.repository.js';
-import { badRequest, defineSchema, failed, optStr, readCount, reqObj, reqStr, } from '../validation.js';
-function mangaDb(ctx) {
-    const db = ctx.mangaDb;
-    if (!db || db.isClosedCheck())
-        throw new Error('Manga database is not ready');
-    return db;
-}
-function normalizeId(provider, mangaId, idRaw) {
-    if (idRaw && idRaw.includes(':'))
-        return idRaw;
-    return buildMangaId(provider, mangaId || idRaw || '');
-}
-const mangaLibraryListInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    const status = optStr(obj, 'status');
-    const page = Math.max(readCount(obj, 'page', 1), 1);
-    const limit = Math.min(Math.max(readCount(obj, 'limit', 24), 1), 100);
-    return { status, page, limit };
-});
-const mangaLibraryIdInput = () => defineSchema((value) => ({
-    id: reqStr(reqObj(value), 'id'),
-}));
-const mangaLibraryAddInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    const out = {
-        provider: optStr(obj, 'provider'),
-        mangaId: optStr(obj, 'mangaId'),
-        id: optStr(obj, 'id'),
-        title: optStr(obj, 'title'),
-        cover: optStr(obj, 'cover'),
-        status: optStr(obj, 'status'),
-        author: optStr(obj, 'author'),
-        altTitle: optStr(obj, 'altTitle'),
-        contentRating: optStr(obj, 'contentRating'),
-    };
-    if (typeof obj.silent === 'boolean')
-        out.silent = obj.silent;
-    return out;
-});
-const mangaLibraryRemoveInput = () => defineSchema((value) => {
-    if (typeof value !== 'string')
-        throw new Error('id must be a string');
-    return value;
-});
-const mangaLibraryStatusInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return { id: optStr(obj, 'id'), status: optStr(obj, 'status') };
-});
-const mangaLibraryLinkInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    return { id: optStr(obj, 'id'), anilistId: obj.anilistId };
-});
-const mangaLibraryBatchStatusInput = () => defineSchema((value) => {
-    const obj = reqObj(value);
-    const idsRaw = obj.ids;
-    const ids = Array.isArray(idsRaw) ? idsRaw.map((id) => String(id)) : [];
-    return { ids, status: optStr(obj, 'status') };
-});
-const mangaLibraryRemoveManyInput = () => defineSchema((value) => {
-    if (!Array.isArray(value))
-        throw new Error('ids must be a non-empty array');
-    return value.map((id) => String(id));
-});
-export const mangaLibraryRouter = router({
-    list: protectedProcedure.input(mangaLibraryListInput()).query(async ({ ctx, input }) => {
-        try {
-            const offset = (input.page - 1) * input.limit;
-            const db = mangaDb(ctx);
-            const rows = await MangaLibraryRepository.getAll(db, input.status, input.limit, offset);
-            const total = await MangaLibraryRepository.getCount(db, input.status);
-            return { data: rows, total, page: input.page, limit: input.limit };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed('Failed to load manga library');
-        }
-    }),
-    ids: protectedProcedure.query(async ({ ctx }) => {
-        try {
-            return { ids: await MangaLibraryRepository.getIds(mangaDb(ctx)) };
-        }
-        catch {
-            return { ids: [] };
-        }
-    }),
-    check: protectedProcedure.input(mangaLibraryIdInput()).query(async ({ ctx, input }) => {
-        try {
-            const item = await MangaLibraryRepository.getById(mangaDb(ctx), input.id);
-            return { inLibrary: !!item, status: item?.status ?? null };
-        }
-        catch {
-            return { inLibrary: false, status: null };
-        }
-    }),
-    entry: protectedProcedure.input(mangaLibraryIdInput()).query(async ({ ctx, input }) => {
-        try {
-            const item = await MangaLibraryRepository.getById(mangaDb(ctx), input.id);
-            if (!item)
-                throw new TRPCError({ code: 'NOT_FOUND', message: 'Not in library' });
-            return { item };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed('Failed to load entry');
-        }
-    }),
-    add: protectedProcedure.input(mangaLibraryAddInput()).mutation(async ({ ctx, input }) => {
-        const provider = input.provider || '';
-        const mangaId = input.mangaId || '';
-        const idRaw = input.id || '';
-        if (!provider || (!mangaId && !idRaw)) {
-            throw badRequest('provider and mangaId are required');
-        }
-        const id = normalizeId(String(provider), String(mangaId || ''), idRaw ? String(idRaw) : undefined);
-        const cleanStatus = typeof input.status === 'string' && MANGA_STATUSES.includes(input.status)
-            ? input.status
-            : 'Reading';
-        try {
-            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
-                await MangaLibraryRepository.upsert(tx, {
-                    id,
-                    provider: String(provider).toLowerCase(),
-                    mangaId: String(mangaId || idRaw || ''),
-                    title: String(input.title || ''),
-                    cover: String(input.cover || ''),
-                    status: cleanStatus,
-                    author: input.author ? String(input.author) : undefined,
-                    altTitle: input.altTitle ? String(input.altTitle) : undefined,
-                    contentRating: input.contentRating ? String(input.contentRating) : undefined,
-                });
-            });
-            return { success: true, id };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed('Failed to bookmark manga');
-        }
-    }),
-    remove: protectedProcedure.input(mangaLibraryRemoveInput()).mutation(async ({ ctx, input }) => {
-        if (!input)
-            throw badRequest('id is required');
-        try {
-            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
-                await MangaLibraryRepository.delete(tx, String(input));
-                await MangaProgressRepository.deleteByManga(tx, String(input));
-            });
-            return { success: true };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed('Failed to remove bookmark');
-        }
-    }),
-    setStatus: protectedProcedure
-        .input(mangaLibraryStatusInput())
-        .mutation(async ({ ctx, input }) => {
-        if (!input.id || !input.status || !MANGA_STATUSES.includes(input.status)) {
-            throw badRequest('id and a valid status are required');
-        }
-        try {
-            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
-                await MangaLibraryRepository.updateStatus(tx, String(input.id), String(input.status));
-            });
-            return { success: true };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed('Failed to update status');
-        }
-    }),
-    link: protectedProcedure.input(mangaLibraryLinkInput()).mutation(async ({ ctx, input }) => {
-        const targetId = typeof input.id === 'string' ? input.id : '';
-        const mediaId = Number(input.anilistId);
-        if (!targetId || !Number.isInteger(mediaId) || mediaId <= 0) {
-            throw badRequest('id and a numeric anilistId are required');
-        }
-        try {
-            const db = mangaDb(ctx);
-            const row = await MangaLibraryRepository.getById(db, targetId);
-            if (!row)
-                throw new TRPCError({ code: 'NOT_FOUND', message: 'Library entry not found' });
-            if (String(row.provider).toLowerCase() === 'anilist') {
-                throw badRequest('Link a provider bookmark to the AniList entry, not the reverse');
-            }
-            let progressMigrated = false;
-            await performMangaWriteTransactionAsync(db, async (tx) => {
-                await MangaLibraryRepository.setAnilistId(tx, targetId, mediaId, 'manual');
-                const orphanId = `anilist:${mediaId}`;
-                if (orphanId !== targetId) {
-                    const orphan = await MangaLibraryRepository.getById(tx, orphanId);
-                    const target = await MangaLibraryRepository.getById(tx, targetId);
-                    const targetProgress = await MangaProgressRepository.getByManga(tx, targetId);
-                    if (orphan?.lastChapterNumber &&
-                        !target?.lastChapterNumber &&
-                        targetProgress.length === 0) {
-                        await MangaLibraryRepository.setProgressPointer(tx, targetId, orphan.lastChapterNumber);
-                        await MangaProgressRepository.moveSyntheticChapters(tx, orphanId, targetId);
-                        progressMigrated = true;
-                    }
-                    await MangaLibraryRepository.delete(tx, orphanId);
-                    await MangaProgressRepository.deleteByManga(tx, orphanId);
-                }
-            });
-            return { success: true, id: targetId, progressMigrated };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed('Failed to link entry');
-        }
-    }),
-    batchStatus: protectedProcedure
-        .input(mangaLibraryBatchStatusInput())
-        .mutation(async ({ ctx, input }) => {
-        if (!Array.isArray(input.ids) || input.ids.length === 0) {
-            throw badRequest('ids must be a non-empty array');
-        }
-        if (!input.status || !MANGA_STATUSES.includes(input.status)) {
-            throw badRequest('a valid status is required');
-        }
-        const ids = input.ids.map((id) => String(id));
-        try {
-            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
-                await MangaLibraryRepository.updateStatusMany(tx, ids, String(input.status));
-            });
-            return { success: true, updated: ids.length };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed('Failed to update statuses');
-        }
-    }),
-    removeMany: protectedProcedure
-        .input(mangaLibraryRemoveManyInput())
-        .mutation(async ({ ctx, input }) => {
-        if (!Array.isArray(input) || input.length === 0) {
-            throw badRequest('ids must be a non-empty array');
-        }
-        const ids = input.map((id) => String(id));
-        try {
-            await performMangaWriteTransactionAsync(mangaDb(ctx), async (tx) => {
-                await MangaLibraryRepository.deleteMany(tx, ids);
-                await MangaProgressRepository.deleteMany(tx, ids);
-            });
-            return { success: true, removed: ids.length };
-        }
-        catch (err) {
-            if (err instanceof TRPCError)
-                throw err;
-            throw failed('Failed to remove bookmarks');
-        }
-    }),
-});