ani-web 2.0.7

package/server/dist/repositories/watchlist.repository.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchlistRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.WatchlistRepository = {
+    getById: (db, id) => (0, db_utils_1.dbGet)(db, 'SELECT * FROM watchlist WHERE id = ?', [id]),
+    exists: (db, id) => {
+        const row = (0, db_utils_1.dbGet)(db, 'SELECT EXISTS(SELECT 1 FROM watchlist WHERE id = ?) as inWatchlist', [id]);
+        return !!(row && row.inWatchlist);
+    },
+    getAll: (db, status, limit, offset) => {
+        let query = 'SELECT * FROM watchlist';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY rowid DESC';
+        if (limit !== undefined && offset !== undefined) {
+            query += ' LIMIT ? OFFSET ?';
+            params.push(limit, offset);
+        }
+        return (0, db_utils_1.dbAll)(db, query, params);
+    },
+    getCount: (db, status) => {
+        let query = 'SELECT COUNT(*) as total FROM watchlist';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        const row = (0, db_utils_1.dbGet)(db, query, params);
+        return row?.total || 0;
+    },
+    upsert: (db, data) => (0, db_utils_1.dbRun)(db, 'INSERT OR REPLACE INTO watchlist (id, name, thumbnail, status, nativeName, englishName, type) VALUES (?, ?, ?, ?, ?, ?, ?)', [
+        data.id,
+        data.name,
+        data.thumbnail,
+        data.status,
+        data.nativeName,
+        data.englishName,
+        data.type,
+    ]),
+    updateStatus: (db, id, status) => (0, db_utils_1.dbRun)(db, 'UPDATE watchlist SET status = ? WHERE id = ?', [status, id]),
+    updateType: (db, id, type) => (0, db_utils_1.dbRun)(db, 'UPDATE watchlist SET type = ? WHERE id = ?', [type, id]),
+    updateThumbnail: (db, id, thumbnail) => (0, db_utils_1.dbRun)(db, 'UPDATE watchlist SET thumbnail = ? WHERE id = ?', [thumbnail, id]),
+    delete: (db, id) => (0, db_utils_1.dbRun)(db, 'DELETE FROM watchlist WHERE id = ?', [id]),
+    getWatchingShows: (db) => (0, db_utils_1.dbAll)(db, "SELECT id, name, thumbnail, nativeName, englishName FROM watchlist WHERE status = 'Watching'"),
+    getShowsWithNewEpisodes: (db) => (0, db_utils_1.dbAll)(db, `SELECT
+        w.id,
+        w.name,
+        w.thumbnail,
+        w.nativeName,
+        w.englishName,
+        w.type,
+        sm.episodeCount,
+        sm.type as smType,
+        sm.status as smStatus,
+        dn.episodeNumber as latestDiscoveredEpisode
+      FROM watchlist w
+      JOIN discovered_notifications dn ON w.id = dn.showId
+      LEFT JOIN shows_meta sm ON w.id = sm.id
+      WHERE w.status = 'Watching'
+        AND dn.discoveredAt >= date('now', '-7 days')
+        AND NOT EXISTS (
+          SELECT 1 FROM watched_episodes we
+          WHERE we.showId = w.id AND we.episodeNumber = dn.episodeNumber
+        )
+        AND dn.discoveredAt = (
+          SELECT MAX(dn2.discoveredAt)
+          FROM discovered_notifications dn2
+          WHERE dn2.showId = dn.showId
+            AND dn2.discoveredAt >= date('now', '-7 days')
+            AND NOT EXISTS (
+              SELECT 1 FROM watched_episodes we2
+              WHERE we2.showId = dn2.showId AND we2.episodeNumber = dn2.episodeNumber
+            )
+        )
+      ORDER BY dn.discoveredAt DESC`),
+};

package/server/dist/routes/auth.routes.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthRouter = createAuthRouter;
+const express_1 = require("express");
+const auth_controller_1 = require("../controllers/auth.controller");
+function createAuthRouter(runSyncSequence) {
+    const router = (0, express_1.Router)();
+    const controller = new auth_controller_1.AuthController(runSyncSequence);
+    router.get('/config-status', controller.getConfigStatus);
+    router.get('/google-auth', controller.getGoogleAuthSettings);
+    router.post('/google-auth', controller.updateGoogleAuthSettings);
+    router.get('/github/status', controller.getGitHubAuthStatus);
+    router.post('/github/start', controller.startGitHubDeviceAuth);
+    router.get('/github/poll', controller.pollGitHubDeviceAuth);
+    router.post('/github/logout', controller.logoutGitHub);
+    router.get('/settings/rclone', controller.getRcloneSettings);
+    router.post('/settings/rclone', controller.updateRcloneSettings);
+    router.get('/settings/sync', controller.getSyncSettings);
+    router.post('/settings/sync', controller.updateSyncProvider);
+    router.get('/google', controller.getAuthUrl);
+    router.post('/google/login', controller.loginGoogle);
+    router.get('/google/callback', controller.handleCallback);
+    router.get('/user', controller.getUserProfile);
+    router.post('/logout', controller.logout);
+    return router;
+}

package/server/dist/routes/data.routes.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDataRouter = createDataRouter;
+const express_1 = require("express");
+const data_controller_1 = require("../controllers/data.controller");
+function makeCacheMiddleware(cache, keyFn, ttl, validate = (d) => Array.isArray(d) && d.length > 0) {
+    return (req, res, next) => {
+        const cacheKey = keyFn(req);
+        const cached = cache.get(cacheKey);
+        if (cached)
+            return res.json(cached);
+        const originalJson = res.json.bind(res);
+        res.json = (data) => {
+            if (validate(data)) {
+                if (ttl !== undefined) {
+                    cache.set(cacheKey, data, ttl);
+                }
+                else {
+                    cache.set(cacheKey, data);
+                }
+            }
+            return originalJson(data);
+        };
+        next();
+    };
+}
+function createDataRouter(apiCache, providers) {
+    const router = (0, express_1.Router)();
+    const controller = new data_controller_1.DataController(providers);
+    router.get('/popular/:timeframe', makeCacheMiddleware(apiCache, (req) => `popular-${req.params.timeframe.toLowerCase()}-${req.query.page || 1}-${req.query.size || 10}`), controller.getPopular);
+    router.get('/schedule/:date', makeCacheMiddleware(apiCache, (req) => `schedule-${req.params.date}`), controller.getSchedule);
+    router.get('/latest-releases', makeCacheMiddleware(apiCache, (req) => `latest-releases-${req.query.page || 1}-${req.query.size || 14}`, 300), controller.getLatestReleases);
+    router.get('/search', makeCacheMiddleware(apiCache, (req) => `search-${JSON.stringify(req.query)}`, 1800), controller.search);
+    router.get('/skip-times/:showId/:episodeNumber', controller.getSkipTimes);
+    router.get('/video', controller.getVideo);
+    router.get('/episodes', controller.getEpisodes);
+    router.get('/seasonal', makeCacheMiddleware(apiCache, (req) => `seasonal-14-${req.query.page || 1}`, 1800), controller.getSeasonal);
+    router.get('/show-meta/:id', makeCacheMiddleware(apiCache, (req) => `meta-${req.params.id}-${req.query.provider || 'allanime'}`, 3600, (d) => !!d &&
+        (typeof d.bannerImage === 'string' || typeof d.description === 'string')), controller.getShowMeta);
+    router.get('/genres-and-tags', controller.getGenresAndTags);
+    return router;
+}

package/server/dist/routes/insights.routes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInsightsRouter = createInsightsRouter;
+const express_1 = require("express");
+const insights_controller_1 = require("../controllers/insights.controller");
+function createInsightsRouter(provider) {
+    const router = (0, express_1.Router)();
+    const controller = new insights_controller_1.InsightsController(provider);
+    router.get('/insights', controller.getWatchInsights);
+    router.get('/insights/genre-cards', controller.getGenreCards);
+    return router;
+}

package/server/dist/routes/proxy.routes.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxyRouter = createProxyRouter;
+const express_1 = require("express");
+const proxy_controller_1 = require("../controllers/proxy.controller");
+function createProxyRouter() {
+    const router = (0, express_1.Router)();
+    const controller = new proxy_controller_1.ProxyController();
+    router.get('/proxy', controller.handleProxy);
+    router.get('/embed-proxy', controller.handleEmbedProxy);
+    router.get('/subtitle-proxy', controller.handleSubtitleProxy);
+    router.get('/image-proxy', controller.handleImageProxy);
+    return router;
+}

package/server/dist/routes/settings.routes.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSettingsRouter = createSettingsRouter;
+const express_1 = require("express");
+const settings_controller_1 = require("../controllers/settings.controller");
+const multer_1 = __importDefault(require("multer"));
+const config_1 = require("../config");
+function createSettingsRouter(provider, getDb, initializeDatabase, setDb) {
+    const router = (0, express_1.Router)();
+    const controller = new settings_controller_1.SettingsController(provider);
+    router.get('/settings', controller.getSettings);
+    router.post('/settings', controller.updateSettings);
+    router.get('/backup-db', controller.backupDatabase);
+    router.get('/installation-id', controller.getInstallationId);
+    const restoreStorage = (0, multer_1.default)({
+        storage: multer_1.default.diskStorage({
+            destination: (_req, _f, cb) => cb(null, config_1.CONFIG.ROOT),
+            filename: (_r, _f, cb) => cb(null, `restore_temp.db`),
+        }),
+    });
+    router.post('/restore-db', restoreStorage.single('dbfile'), (req, res) => controller.restoreDatabase(req, res, getDb(), initializeDatabase, setDb));
+    router.post('/import/mal-xml', (0, multer_1.default)().single('xmlfile'), controller.importMalXml);
+    return router;
+}

package/server/dist/routes/watchlist.routes.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchlistRouter = createWatchlistRouter;
+const express_1 = require("express");
+const watchlist_controller_1 = require("../controllers/watchlist.controller");
+const discord_rpc_1 = require("../discord-rpc");
+function createWatchlistRouter(allAnime, animePahe) {
+    const router = (0, express_1.Router)();
+    const controller = new watchlist_controller_1.WatchlistController({ allAnime, animePahe });
+    router.get('/continue-watching', controller.getContinueWatching);
+    router.get('/continue-watching/fast', controller.getContinueWatchingFast);
+    router.get('/continue-watching/up-next', controller.getContinueWatchingUpNext);
+    router.get('/continue-watching/all', controller.getAllContinueWatching);
+    router.get('/continue-watching/this-week', controller.getThisWeekSchedule);
+    router.post('/continue-watching/remove', controller.removeContinueWatching);
+    router.post('/update-progress', controller.updateProgress);
+    router.get('/watchlist', controller.getWatchlist);
+    router.get('/watchlist/check/:showId', controller.checkWatchlist);
+    router.post('/watchlist/add', controller.addToWatchlist);
+    router.post('/watchlist/remove', controller.removeFromWatchlist);
+    router.post('/watchlist/status', controller.updateWatchlistStatus);
+    router.get('/queue', controller.getQueue);
+    router.get('/queue/suggested/:showId', controller.getSuggestedQueueEpisode);
+    router.post('/queue/add', controller.addToQueue);
+    router.post('/queue/remove', controller.removeFromQueue);
+    router.post('/queue/clear', controller.clearQueue);
+    router.post('/queue/reorder', controller.reorderQueue);
+    router.get('/episode-progress/:showId/:episodeNumber', controller.getEpisodeProgress);
+    router.get('/watched-episodes/:showId', controller.getWatchedEpisodes);
+    router.get('/notifications', controller.getNotifications);
+    router.post('/notifications/dismiss', controller.dismissNotification);
+    router.post('/notifications/clear-all', controller.clearAllNotifications);
+    router.post('/discord/clear', (req, res) => {
+        const { sessionId } = req.body;
+        discord_rpc_1.discordRPCService.clearPresence(sessionId);
+        res.json({ success: true });
+    });
+    router.post('/discord/status', (req, res) => {
+        const { page } = req.body;
+        if (typeof page === 'string') {
+            discord_rpc_1.discordRPCService.setIdleStatus(page);
+        }
+        res.json({ success: true });
+    });
+    return router;
+}

package/server/dist/server.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+process.setMaxListeners(100);
+const events_1 = require("events");
+events_1.EventEmitter.defaultMaxListeners = 100;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const cors_1 = __importDefault(require("cors"));
+const compression_1 = __importDefault(require("compression"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const fs_1 = __importDefault(require("fs"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const logger_1 = __importDefault(require("./logger"));
+const allanime_provider_1 = require("./providers/allanime.provider");
+const _123anime_provider_1 = require("./providers/123anime.provider");
+const animeya_provider_1 = require("./providers/animeya.provider");
+const megaplay_provider_1 = require("./providers/megaplay.provider");
+const animepahe_provider_1 = require("./providers/animepahe.provider");
+const config_1 = require("./config");
+const sync_1 = require("./sync");
+const auth_routes_1 = require("./routes/auth.routes");
+const watchlist_routes_1 = require("./routes/watchlist.routes");
+const data_routes_1 = require("./routes/data.routes");
+const proxy_routes_1 = require("./routes/proxy.routes");
+const settings_routes_1 = require("./routes/settings.routes");
+const insights_routes_1 = require("./routes/insights.routes");
+const discord_rpc_1 = require("./discord-rpc");
+const settings_repository_1 = require("./repositories/settings.repository");
+const request_context_1 = require("./utils/request-context");
+const app = (0, express_1.default)();
+app.use((req, res, next) => {
+    const store = new Map();
+    if (req.headers['x-animepahe-ua']) {
+        store.set('ua', req.headers['x-animepahe-ua']);
+    }
+    if (req.headers['x-animepahe-cookie']) {
+        store.set('cookie', req.headers['x-animepahe-cookie']);
+    }
+    request_context_1.requestContext.run(store, next);
+});
+const apiCache = new node_cache_1.default({ stdTTL: 3600 });
+const allAnimeProvider = new allanime_provider_1.AllAnimeProvider(apiCache);
+const _123AnimeProvider = new _123anime_provider_1._123AnimeProvider(apiCache);
+const animeyaProvider = new animeya_provider_1.AnimeyaProvider(apiCache);
+const megaPlayProvider = new megaplay_provider_1.MegaPlayProvider(apiCache);
+const animepaheProvider = new animepahe_provider_1.AnimePaheProvider(apiCache);
+const providers = {
+    allanime: allAnimeProvider,
+    '123anime': _123AnimeProvider,
+    animeya: animeyaProvider,
+    megaplay: megaPlayProvider,
+    animepahe: animepaheProvider,
+};
+let db;
+let isShuttingDown = false;
+async function runSyncSequence(database, preferredProvider) {
+    const dbName = config_1.CONFIG.IS_DEV ? config_1.CONFIG.DB_NAME_DEV : config_1.CONFIG.DB_NAME_PROD;
+    const dbPath = path_1.default.join(config_1.CONFIG.ROOT, dbName);
+    const remoteFolder = config_1.CONFIG.IS_DEV ? config_1.CONFIG.REMOTE_FOLDER_DEV : config_1.CONFIG.REMOTE_FOLDER_PROD;
+    await (0, sync_1.initSyncProvider)(preferredProvider);
+    const didDownload = await (0, sync_1.syncDownOnBoot)(database, dbPath, remoteFolder, () => {
+        return new Promise((resolve) => {
+            if (database && !database.isClosedCheck()) {
+                database.checkpoint();
+                database.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+    let currentDb = database;
+    if (didDownload) {
+        db = await (0, sync_1.initializeDatabase)(dbPath);
+        currentDb = db;
+        logger_1.default.info('Database re-initialized after sync.');
+    }
+    try {
+        await (0, sync_1.syncUp)(currentDb, dbPath, remoteFolder);
+    }
+    catch (err) {
+        logger_1.default.error({ err }, 'Sync up on boot failed');
+    }
+}
+app.use((req, res, next) => {
+    if (isShuttingDown) {
+        return res.status(503).send('Server is shutting down...');
+    }
+    if (!db) {
+        return res.status(503).send('Database initializing...');
+    }
+    req.db = db;
+    next();
+});
+app.use((0, compression_1.default)({
+    level: 2,
+    threshold: 1024,
+    filter: (req, res) => {
+        if (req.headers['x-no-compression']) {
+            return false;
+        }
+        return compression_1.default.filter(req, res);
+    },
+}));
+app.use((0, cors_1.default)());
+app.use(express_1.default.json({ limit: '10mb' }));
+app.use('/api/auth', (0, auth_routes_1.createAuthRouter)((database) => runSyncSequence(database)));
+app.use('/api', (0, watchlist_routes_1.createWatchlistRouter)(allAnimeProvider, animepaheProvider));
+app.use('/api', (0, data_routes_1.createDataRouter)(apiCache, providers));
+app.use('/api', (0, proxy_routes_1.createProxyRouter)());
+app.use('/api', (0, insights_routes_1.createInsightsRouter)(allAnimeProvider));
+app.use('/api', (0, settings_routes_1.createSettingsRouter)(allAnimeProvider, () => db, sync_1.initializeDatabase, (newDb) => {
+    db = newDb;
+}));
+if (!config_1.CONFIG.IS_DEV) {
+    const frontendPath = path_1.default.join(config_1.CONFIG.PACKAGE_ROOT, 'client', 'dist');
+    logger_1.default.info(`Serving frontend from: ${frontendPath}`);
+    app.use(express_1.default.static(frontendPath));
+    app.get(/^(?!\/api).+/, (req, res) => {
+        res.sendFile('index.html', { root: frontendPath }, (err) => {
+            if (err) {
+                logger_1.default.error({ err }, `Failed to serve index.html from ${frontendPath}`);
+                if (!res.headersSent) {
+                    res.status(500).send('Server Error: Frontend build not found.');
+                }
+            }
+        });
+    });
+}
+app.use((err, req, res, next) => {
+    logger_1.default.error({ err, url: req.url, method: req.method }, 'Unhandled error');
+    if (res.headersSent) {
+        return next(err);
+    }
+    res.status(err.status || 500).json({
+        error: err.message || 'Internal Server Error',
+        status: err.status || 500,
+    });
+});
+async function main() {
+    const dbName = config_1.CONFIG.IS_DEV ? config_1.CONFIG.DB_NAME_DEV : config_1.CONFIG.DB_NAME_PROD;
+    const dbPath = path_1.default.join(config_1.CONFIG.ROOT, dbName);
+    const remoteFolder = config_1.CONFIG.IS_DEV ? config_1.CONFIG.REMOTE_FOLDER_DEV : config_1.CONFIG.REMOTE_FOLDER_PROD;
+    db = await (0, sync_1.initializeDatabase)(dbPath);
+    logger_1.default.info(`Database initialized at ${dbPath}`);
+    const rpcEnabledSetting = await settings_repository_1.SettingsRepository.getByKey(db, 'discordRPCEnabled');
+    const isRpcEnabled = rpcEnabledSetting ? rpcEnabledSetting.value === 'true' : true;
+    discord_rpc_1.discordRPCService.setEnabled(isRpcEnabled);
+    await runSyncSequence(db);
+    if (!fs_1.default.existsSync(config_1.CONFIG.LOCAL_MANIFEST_PATH)) {
+        fs_1.default.writeFileSync(config_1.CONFIG.LOCAL_MANIFEST_PATH, JSON.stringify({ version: 0 }));
+    }
+    let hasUnsyncedChanges = false;
+    const watcher = chokidar_1.default.watch(config_1.CONFIG.LOCAL_MANIFEST_PATH, {
+        persistent: true,
+        ignoreInitial: true,
+    });
+    const expressServer = app.listen(config_1.CONFIG.PORT, () => {
+        logger_1.default.info(`Server running on http://localhost:${config_1.CONFIG.PORT}`);
+    });
+    watcher.on('change', () => {
+        hasUnsyncedChanges = true;
+    });
+    const syncInterval = setInterval(async () => {
+        if (hasUnsyncedChanges) {
+            logger_1.default.info('Uploading accumulated database changes...');
+            hasUnsyncedChanges = false;
+            try {
+                await (0, sync_1.syncUp)(db, dbPath, remoteFolder);
+            }
+            catch (err) {
+                logger_1.default.error({ err }, 'Failed to upload database changes');
+                hasUnsyncedChanges = true;
+            }
+        }
+    }, 300000);
+    const shutdown = async (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        clearInterval(syncInterval);
+        discord_rpc_1.discordRPCService.disconnect();
+        await watcher.close();
+        if (expressServer) {
+            expressServer.close();
+        }
+        if (hasUnsyncedChanges) {
+            logger_1.default.info('Sync on shutdown: uploading final database changes...');
+            hasUnsyncedChanges = false;
+            try {
+                await (0, sync_1.syncUp)(db, dbPath, remoteFolder);
+            }
+            catch (e) {
+                console.error('Final sync on shutdown failed:', e);
+            }
+        }
+        await (0, sync_1.waitForSync)();
+        db.close(() => {
+            console.log('[SERVER_EXIT]');
+            setTimeout(() => {
+                if (signal === 'SIGUSR2') {
+                    process.kill(process.pid, 'SIGUSR2');
+                }
+                else {
+                    process.exit(0);
+                }
+            }, 600);
+        });
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.once('SIGUSR2', () => shutdown('SIGUSR2'));
+    app.post('/api/internal/shutdown', (req, res) => {
+        if (req.ip === '::1' || req.ip === '127.0.0.1' || req.ip === '::ffff:127.0.0.1') {
+            res.status(200).json({ message: 'Shutting down' });
+            setTimeout(() => shutdown(), 500);
+        }
+        else {
+            res.status(403).send('Forbidden');
+        }
+    });
+}
+main().catch((err) => {
+    console.error('Server failed to start:', err);
+    process.exit(1);
+});

package/server/dist/sync-config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setActiveRemote = setActiveRemote;
+exports.getActiveRemote = getActiveRemote;
+exports.initialize = initialize;
+exports.getRemoteString = getRemoteString;
+const log = (message) => console.log(`[Sync Config] ${new Date().toISOString()} - ${message}`);
+let activeRemote;
+function setActiveRemote(remote) {
+    log(`Setting active sync remote to: ${remote}`);
+    activeRemote = remote;
+}
+function getActiveRemote() {
+    return activeRemote;
+}
+async function initialize() {
+    if (activeRemote !== 'gdrive') {
+        log('Active remote is not gdrive, skipping gdrive-specific initialization.');
+        return;
+    }
+    log('gdrive is the active remote.');
+}
+function getRemoteString(remoteDir) {
+    if (!activeRemote) {
+        throw new Error('Cannot get remote string: active remote is not set.');
+    }
+    return `${activeRemote}:${remoteDir}`;
+}