@imenam/simple-scraper 1.0.24 → 1.0.28

package/dist/index.js

@@ -9,10 +9,12 @@ import { fileURLToPath } from 'url';
 import { z } from 'zod';
 import { setupLogging } from './logger.js';
 import { getBrowser, closeBrowser, getDefaultTimeout } from './browser.js';
-import { loadAllCookies } from './cookies.js';
+import { scheduleJarSync, startPeriodicJarSync } from './cookie-sync.js';
+import { getDataDir } from './data-dir.js';
+import { startKeepAlive } from './keep-alive.js';
 import { GuiLauncher, reconnectGuiToolDefinition } from '@imenam/mcp-gui-interface';
 import { createSession, getSession, closeSession, closeAllSessions, listSessions, getSessionLogs, clearSessionLogs, resolveViewport } from './sessions.js';
-import { registerSessionRpc } from './session-rpc.js';
+import { registerRpc } from './rpc.js';
 import { deliverFile, RELAY_SHAPE_DESCRIPTIONS } from './relay.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.resolve(__dirname, '..');
@@ -62,22 +64,6 @@ function toViewportOverride(v) {
         return undefined;
     return { width: v.width, height: v.height, deviceScaleFactor: v.device_scale_factor };
 }
-// ─── One-shot helpers ─────────────────────────────────────────────────────────
-async function setCookies(page, cookies, pageUrl) {
-    const prepared = cookies.map(c => {
-        if (!c.domain) {
-            return { ...c, url: pageUrl };
-        }
-        return c;
-    });
-    await page.setCookie(...prepared);
-}
-async function applyCookies(page, pageUrl) {
-    const cookies = await loadAllCookies();
-    if (cookies.length) {
-        await setCookies(page, cookies, pageUrl);
-    }
-}
 // ─── Page-level helpers (shared between one-shot and session tools) ───────────
 async function extractInputs(page, opts) {
     return page.evaluate(({ selector: sel, showHidden }) => {
@@ -211,7 +197,6 @@ server.tool('scrape_page', 'Navigate to a URL using a headless browser and retur
     const browser = await getBrowser();
     const page = await browser.newPage();
     try {
-        await applyCookies(page, url);
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -225,6 +210,7 @@ server.tool('scrape_page', 'Navigate to a URL using a headless browser and retur
     }
     finally {
         await page.close();
+        scheduleJarSync();
     }
 });
 // ─── reconnect_gui ──────────────────────────────────────────────────────────────
@@ -250,7 +236,6 @@ server.tool('execute_js', 'Navigate to a URL and execute custom JavaScript in th
     const browser = await getBrowser();
     const page = await browser.newPage();
     try {
-        await applyCookies(page, url);
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -269,6 +254,7 @@ server.tool('execute_js', 'Navigate to a URL and execute custom JavaScript in th
     }
     finally {
         await page.close();
+        scheduleJarSync();
     }
 });
 // ─── get_page_inputs ──────────────────────────────────────────────────────────
@@ -286,7 +272,7 @@ server.tool('get_page_inputs', 'Return a structured JSON object of all form inpu
     }
     if (session_id) {
         try {
-            const page = getSession(session_id);
+            const page = getSession(session_id, 'get_page_inputs');
             const result = await extractInputs(page, { selector, showHidden: show_hidden ?? false });
             return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
@@ -298,7 +284,6 @@ server.tool('get_page_inputs', 'Return a structured JSON object of all form inpu
     const browser = await getBrowser();
     const page = await browser.newPage();
     try {
-        await applyCookies(page, url);
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -312,6 +297,7 @@ server.tool('get_page_inputs', 'Return a structured JSON object of all form inpu
     }
     finally {
         await page.close();
+        scheduleJarSync();
     }
 });
 // ─── get_show_page ────────────────────────────────────────────────────────────
@@ -333,7 +319,6 @@ server.tool('get_show_page', 'Navigate to a URL and automatically parse a show/d
     const browser = await getBrowser();
     const page = await browser.newPage();
     try {
-        await applyCookies(page, url);
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -351,6 +336,7 @@ server.tool('get_show_page', 'Navigate to a URL and automatically parse a show/d
     }
     finally {
         await page.close();
+        scheduleJarSync();
     }
 });
 // ─── open_session ─────────────────────────────────────────────────────────────
@@ -400,7 +386,7 @@ server.tool('session_goto', 'Navigate the browser session to a new URL without c
 }, async ({ session_id, url, wait_for, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_goto');
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -420,7 +406,7 @@ server.tool('session_click', 'Click on an element in the browser session identif
 }, async ({ session_id, selector, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_click');
         await page.waitForSelector(selector, { timeout: effectiveTimeout });
         await page.click(selector);
         return { content: [{ type: 'text', text: `Clicked "${selector}"` }] };
@@ -440,7 +426,7 @@ server.tool('session_type', 'Type text into an input element in the browser sess
 }, async ({ session_id, selector, text, clear, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_type');
         await page.waitForSelector(selector, { timeout: effectiveTimeout });
         if (clear) {
             await page.click(selector, { clickCount: 3 });
@@ -461,7 +447,7 @@ server.tool('session_wait_for', 'Wait for a CSS selector to appear in the active
 }, async ({ session_id, selector, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_wait_for');
         await page.waitForSelector(selector, { timeout: effectiveTimeout });
         return { content: [{ type: 'text', text: `Selector "${selector}" found.` }] };
     }
@@ -479,7 +465,7 @@ server.tool('session_evaluate', 'Execute custom JavaScript in the context of an
 }, async ({ session_id, script, wait_for, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_evaluate');
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
         }
@@ -501,7 +487,7 @@ server.tool('session_html', 'Return the current full rendered HTML of an active
     session_id: z.string().describe('Session ID returned by open_session'),
 }, async ({ session_id }) => {
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_html');
         const html = await page.content();
         return { content: [{ type: 'text', text: html }] };
     }
@@ -517,7 +503,7 @@ server.tool('session_query_selector', 'Query the active session page with a CSS
     limit: z.number().optional().describe('Max number of elements to return (default: 10)'),
 }, async ({ session_id, selector, limit }) => {
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_query_selector');
         const results = await page.$$eval(selector, (elements, maxItems) => elements.slice(0, maxItems).map(el => {
             const text = (el.textContent ?? '').trim().slice(0, 100);
             return {
@@ -566,7 +552,7 @@ server.tool('session_scroll', 'Scroll the active session page. Use selector to s
         return { content: [{ type: 'text', text: 'Error: provide at least one of selector, to_bottom, x, or y.' }], isError: true };
     }
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_scroll');
         if (selector) {
             await page.$eval(selector, el => el.scrollIntoView());
             return { content: [{ type: 'text', text: `Scrolled "${selector}" into view.` }] };
@@ -606,7 +592,7 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
     destination_path: z
         .string()
         .optional()
-        .describe(`${RELAY_SHAPE_DESCRIPTIONS.destination_path}. Required when output is "file" or "both"`),
+        .describe(`${RELAY_SHAPE_DESCRIPTIONS.destination_path}. Required when output is "file" or "both", except behind the mcp-http-gateway relay, which keeps it on the agent side`),
     filename: z
         .string()
         .optional()
@@ -623,10 +609,17 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
     // Écrire un fichier suppose de savoir où, et sur quelle machine. Il n'y a pas de
     // destination par défaut : elle atterrirait sur le disque de ce serveur, qui n'est
     // pas forcément celui de l'agent — un fichier introuvable plutôt qu'une erreur.
+    // Derrière le relais, la destination reste côté agent : seul le nom du fichier arrive ici.
     const wantsFile = output === 'file' || output === 'both';
-    if (wantsFile && (!destination_path || !filename)) {
+    if (wantsFile && !filename) {
+        return {
+            content: [{ type: 'text', text: 'Error: filename is required when output is "file" or "both".' }],
+            isError: true,
+        };
+    }
+    if (wantsFile && !destination_relay && !destination_path) {
         return {
-            content: [{ type: 'text', text: 'Error: destination_path and filename are required when output is "file" or "both".' }],
+            content: [{ type: 'text', text: 'Error: destination_path is required when output is "file" or "both".' }],
             isError: true,
         };
     }
@@ -636,7 +629,7 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
     let previousViewport;
     try {
         if (session_id) {
-            page = getSession(session_id);
+            page = getSession(session_id, 'screenshot');
             if (viewport) {
                 previousViewport = page.viewport();
                 await page.setViewport(resolveViewport(toViewportOverride(viewport)));
@@ -652,7 +645,6 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
             if (viewport) {
                 await page.setViewport(resolveViewport(toViewportOverride(viewport)));
             }
-            await applyCookies(page, url);
             await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
             if (wait_for) {
                 await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -681,7 +673,7 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
         }
         if (wantsFile) {
             resultContent.push(...deliverFile(imageBuffer, mimeType, {
-                destination_path: destination_path,
+                destination_path,
                 filename: filename,
                 destination_overwrite,
                 destination_relay,
@@ -696,6 +688,7 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
     finally {
         if (ownedPage && page) {
             await page.close();
+            scheduleJarSync();
         }
         else if (page && previousViewport) {
             await page.setViewport(previousViewport).catch(() => undefined);
@@ -708,15 +701,20 @@ function launchGUI() {
         return;
     }
     launcher.start();
-    registerSessionRpc(launcher);
+    registerRpc(launcher);
 }
 async function main() {
+    // Un dossier de données mal configuré arrête le serveur avant qu'aucun outil ne serve.
+    const dataDir = getDataDir();
+    console.error(`[MCP] Dossier des sites : ${dataDir ?? 'non configuré (sites désactivés)'}`);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('[MCP] Simple Scraper MCP server started');
     // Après le connect, comme mcp-documentor : au redémarrage du serveur par le
     // client, le master sortant a alors eu le temps de libérer la route.
     launchGUI();
+    startKeepAlive();
+    startPeriodicJarSync();
 }
 main().catch(async (err) => {
     console.error('[MCP] Fatal error:', err);

package/dist/keep-alive.js

@@ -0,0 +1,51 @@
+import { checkSite } from './site-check.js';
+import { getStore } from './site-store.js';
+const TICK_MS = 60_000;
+/** Le maintien visite ce site : activé, avec une page de vérification, et pas déjà déconnecté. */
+function isMaintained(site) {
+    return site.keepAlive.enabled && !!site.keepAlive.pageUrl && site.state.status !== 'disconnected';
+}
+/** Prochaine visite du maintien pour ce site, ou null s'il n'en fait pas. */
+export function nextVisitAt(site, now = Date.now()) {
+    if (!isMaintained(site))
+        return null;
+    const { lastCheckAt } = site.state;
+    return lastCheckAt ? Math.max(now, lastCheckAt + site.keepAlive.intervalMin * 60_000) : now;
+}
+/** Prochaine visite du maintien, tous sites confondus. */
+export function nextKeepAliveAt(now = Date.now()) {
+    const store = getStore();
+    if (!store)
+        return null;
+    const times = store.list().map(s => nextVisitAt(s, now)).filter((t) => t !== null);
+    return times.length ? Math.min(...times) : null;
+}
+let ticking = false;
+async function tick() {
+    if (ticking)
+        return;
+    ticking = true;
+    try {
+        const store = getStore();
+        if (!store)
+            return;
+        const now = Date.now();
+        for (const site of store.list()) {
+            const next = nextVisitAt(site, now);
+            if (next === null || next > now)
+                continue;
+            await checkSite(site.id);
+        }
+    }
+    catch (err) {
+        console.error(`[KeepAlive] ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        ticking = false;
+    }
+}
+/** Démarre le maintien : chaque minute, visite les sites dont le passage est dû. */
+export function startKeepAlive() {
+    setInterval(() => void tick(), TICK_MS).unref();
+    setTimeout(() => void tick(), 10_000).unref();
+}

package/dist/login.js

@@ -0,0 +1,157 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import puppeteer from 'puppeteer';
+import { BROWSER_LAUNCH_ARGS, getDefaultViewport } from './browser.js';
+import { replaceSiteCookies } from './cookie-sync.js';
+import { applyRemoteAction } from './remote-input.js';
+import { pageShowsSignal } from './site-check.js';
+import { cookieCountLabel, requireStore } from './site-store.js';
+const POLL_MS = 1_000;
+let active = null;
+let last = null;
+/** Onglet le plus récent du navigateur de connexion. */
+async function currentPage(browser) {
+    const pages = (await browser.pages()).filter(p => !p.isClosed());
+    return pages.length ? pages[pages.length - 1] : null;
+}
+async function requirePage() {
+    if (!active)
+        throw new Error('Aucune connexion en cours.');
+    const page = await currentPage(active.browser);
+    if (!page)
+        throw new Error('Le navigateur de connexion n\'a aucun onglet.');
+    return page;
+}
+/** Ferme le navigateur de connexion et supprime son profil temporaire. */
+async function teardown(login) {
+    clearInterval(login.timer);
+    await login.browser.close().catch(() => undefined);
+    fs.rmSync(login.profileDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+}
+function settle(login, patch) {
+    login.status = { ...login.status, ...patch };
+    last = login.status;
+    if (active === login)
+        active = null;
+}
+/** Récupère les cookies du navigateur de connexion et les enregistre pour le site. */
+async function finish(login) {
+    if (login.status.phase !== 'waiting')
+        return;
+    login.status.phase = 'saving';
+    clearInterval(login.timer);
+    try {
+        const cookies = await login.browser.cookies();
+        if (!cookies.length)
+            throw new Error('Le navigateur de connexion ne contient aucun cookie.');
+        const count = await replaceSiteCookies(login.status.siteId, cookies);
+        const store = requireStore();
+        const now = Date.now();
+        store.setState(login.status.siteId, {
+            status: 'connected',
+            sessionOpenedAt: now,
+            lostAt: null,
+            lastCheckAt: now,
+            lastCheckError: null,
+        });
+        store.addEvent(login.status.siteId, 'login', cookieCountLabel(count, 'enregistré'));
+        settle(login, { phase: 'done', cookieCount: count });
+    }
+    catch (err) {
+        settle(login, { phase: 'error', error: err instanceof Error ? err.message : String(err) });
+    }
+    await teardown(login);
+}
+/** Surveille la page : connexion terminée quand le signe du site apparaît. */
+async function poll(login) {
+    if (login.status.phase !== 'waiting')
+        return;
+    if (!login.browser.connected) {
+        settle(login, { phase: 'cancelled' });
+        await teardown(login);
+        return;
+    }
+    const page = await currentPage(login.browser).catch(() => null);
+    if (!page)
+        return;
+    login.status.url = page.url();
+    const site = requireStore().get(login.status.siteId);
+    const signalled = await pageShowsSignal(page, site.signal).catch(() => false);
+    if (signalled)
+        await finish(login);
+}
+/**
+ * Ouvre un navigateur sans fenêtre, sur un profil vierge, à la page de connexion
+ * du site. L'utilisateur s'y connecte depuis l'interface, qui affiche la page et
+ * lui relaie ses clics et sa frappe ; aucun écran n'est nécessaire. Les cookies
+ * sont enregistrés pour le site dès que le signe de connexion apparaît.
+ */
+export async function startLogin(siteId) {
+    if (active)
+        throw new Error('Une connexion est déjà en cours.');
+    const site = requireStore().get(siteId);
+    if (!site.loginUrl)
+        throw new Error(`Le site "${site.name}" n'a pas de page de connexion.`);
+    const profileDir = fs.mkdtempSync(path.join(os.tmpdir(), 'simple-scraper-login-'));
+    const browser = await puppeteer.launch({
+        headless: true,
+        defaultViewport: getDefaultViewport(),
+        userDataDir: profileDir,
+        args: BROWSER_LAUNCH_ARGS,
+    });
+    const page = (await browser.pages())[0] ?? (await browser.newPage());
+    const login = {
+        status: { siteId, phase: 'waiting', url: site.loginUrl, error: null, cookieCount: null, startedAt: Date.now() },
+        browser,
+        profileDir,
+        timer: setInterval(() => void poll(login), POLL_MS),
+    };
+    active = login;
+    last = login.status;
+    browser.on('disconnected', () => {
+        if (login.status.phase === 'waiting') {
+            settle(login, { phase: 'cancelled' });
+            void teardown(login);
+        }
+    });
+    page.goto(site.loginUrl).catch(err => {
+        if (login.status.phase !== 'waiting')
+            return;
+        settle(login, { phase: 'error', error: err instanceof Error ? err.message : String(err) });
+        void teardown(login);
+    });
+    return login.status;
+}
+/** Connexion en cours, ou la dernière terminée. */
+export function getLoginStatus() {
+    return active?.status ?? last;
+}
+/** Enregistre la connexion sans attendre le signe du site. */
+export async function confirmLogin() {
+    if (!active)
+        throw new Error('Aucune connexion en cours.');
+    const login = active;
+    await finish(login);
+    return login.status;
+}
+export async function cancelLogin() {
+    if (!active)
+        return;
+    const login = active;
+    settle(login, { phase: 'cancelled' });
+    await teardown(login);
+}
+/** Rejoue dans la page de connexion un clic, une frappe ou une navigation de l'utilisateur. */
+export async function loginInput(action) {
+    const page = await requirePage();
+    await applyRemoteAction(page, action);
+    if (active)
+        active.status.url = page.url();
+}
+/** Capture JPEG de l'onglet courant du navigateur de connexion. */
+export async function loginScreenshot() {
+    const page = await requirePage();
+    const buffer = await page.screenshot({ type: 'jpeg', quality: 70 });
+    return Buffer.from(buffer).toString('base64');
+}

package/dist/relay.js

@@ -50,18 +50,22 @@ export function deliverFile(data, mimeType, target) {
         ];
     }
     // Pas de relais : le MCP tourne à côté de l'agent, son disque est le bon.
-    if (!path.isAbsolute(target.destination_path)) {
-        throw new Error(`destination_path must be an absolute directory path: ${target.destination_path}`);
+    if (!target.destination_path) {
+        throw new Error('destination_path is required when no relay delivers the file.');
     }
-    if (fs.existsSync(target.destination_path) &&
-        !fs.statSync(target.destination_path).isDirectory()) {
-        throw new Error(`destination_path must be a directory, but a file already exists there: ${target.destination_path}`);
+    const destination = target.destination_path;
+    if (!path.isAbsolute(destination)) {
+        throw new Error(`destination_path must be an absolute directory path: ${destination}`);
     }
-    const written = path.join(target.destination_path, name);
+    if (fs.existsSync(destination) &&
+        !fs.statSync(destination).isDirectory()) {
+        throw new Error(`destination_path must be a directory, but a file already exists there: ${destination}`);
+    }
+    const written = path.join(destination, name);
     if (!target.destination_overwrite && fs.existsSync(written)) {
         throw new Error(`Destination already exists: ${written}. Pass destination_overwrite to replace it.`);
     }
-    fs.mkdirSync(target.destination_path, { recursive: true });
+    fs.mkdirSync(destination, { recursive: true });
     fs.writeFileSync(written, data);
     return [{ type: "text", text: `File written to ${written} (${data.length} bytes).` }];
 }

package/dist/remote-input.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { getDefaultTimeout } from './browser.js';
+/**
+ * Action de l'utilisateur sur une page affichée dans l'interface. Les
+ * coordonnées d'un clic sont des fractions (0 à 1) de la capture, donc
+ * indépendantes de la taille à laquelle l'interface l'affiche.
+ */
+export const remoteActionSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('click'), x: z.number().min(0).max(1), y: z.number().min(0).max(1) }),
+    z.object({ type: z.literal('scroll'), dy: z.number().min(-5000).max(5000) }),
+    z.object({ type: z.literal('text'), text: z.string().min(1).max(2000) }),
+    z.object({
+        type: z.literal('key'),
+        key: z.string().min(1).max(32),
+        modifiers: z.array(z.enum(['Control', 'Shift', 'Alt', 'Meta'])).optional(),
+    }),
+    z.object({ type: z.literal('navigate'), url: z.url() }),
+    z.object({ type: z.literal('back') }),
+]);
+export function parseRemoteAction(data) {
+    const result = remoteActionSchema.safeParse(data);
+    if (!result.success)
+        throw new Error(`Action invalide : ${result.error.issues.map(i => i.message).join(' ')}`);
+    return result.data;
+}
+/** Point de la page, en pixels CSS, désigné par des fractions de sa capture. */
+export function pointOf(page, x, y) {
+    const viewport = page.viewport();
+    if (!viewport)
+        throw new Error('La page n\'a pas de taille d\'affichage fixe.');
+    return { x: x * viewport.width, y: y * viewport.height };
+}
+/** Rejoue l'action dans la page. */
+export async function applyRemoteAction(page, action) {
+    switch (action.type) {
+        case 'click': {
+            const point = pointOf(page, action.x, action.y);
+            await page.mouse.click(point.x, point.y);
+            return;
+        }
+        case 'scroll':
+            await page.mouse.wheel({ deltaY: action.dy });
+            return;
+        case 'text':
+            await page.keyboard.type(action.text);
+            return;
+        case 'key': {
+            const modifiers = action.modifiers ?? [];
+            for (const m of modifiers)
+                await page.keyboard.down(m);
+            try {
+                await page.keyboard.press(action.key);
+            }
+            finally {
+                for (const m of modifiers.slice().reverse())
+                    await page.keyboard.up(m);
+            }
+            return;
+        }
+        case 'navigate':
+            await page.goto(action.url, { waitUntil: 'domcontentloaded', timeout: getDefaultTimeout() });
+            return;
+        case 'back':
+            await page.goBack({ waitUntil: 'domcontentloaded', timeout: getDefaultTimeout() });
+            return;
+    }
+}