Upload 11 files

.env.example

@@ -0,0 +1,11 @@
+# ── Required ──────────────────────────────────────────────────
+# Get your BOT_TOKEN from @BotFather on Telegram
+BOT_TOKEN=your_bot_token_here
+
+# Get API_ID and API_HASH from https://my.telegram.org/apps
+API_ID=12345678
+API_HASH=your_api_hash_here
+
+# ── Optional ───────────────────────────────────────────────────
+# Dashboard port (default 7860 for Hugging Face Spaces)
+PORT=7860

.gitignore

@@ -1,10 +1,6 @@
 node_modules/
 .env
 *.jpg
-photo_*.jpg
-exampleimgs/
-test.js
-test_ocr.js
-test_ocr.py
-test_symbols.js
-eng.traineddata
+*.jpeg
+*.png
+*.log

Dockerfile

@@ -1,38 +1,32 @@
-FROM node:18-slim
+FROM node:20-slim
 
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    python3 \
-    python3-pip \
-    python3-venv \
+# Install system dependencies for Tesseract OCR and Sharp
+RUN apt-get update && apt-get install -y --no-install-recommends \
     tesseract-ocr \
+    tesseract-ocr-eng \
     libtesseract-dev \
     libgl1-mesa-glx \
-    git \
+    libvips42 \
+    python3 \
+    python3-pip \
+    ca-certificates \
     && rm -rf /var/lib/apt/lists/*
 
-# Set up the app directory with correct permissions for the 'node' user
+# Set up app directory with correct ownership
 WORKDIR /home/node/app
 RUN chown -R node:node /home/node/app
 
-# Switch to non-root user
 USER node
 ENV HOME=/home/node \
-    PATH="/home/node/.local/bin:/opt/venv/bin:$PATH"
+    PORT=7860
 
-# Set up Python virtual environment (if allowed in home)
-# For simplicity in this container, we'll install python libs in the node home if needed
-# but let's stick to the previous venv logic if possible, adjusted for permissions
-# Actually, let's keep it simple: install node deps first
+# Install Node dependencies first (layer caching)
 COPY --chown=node:node package*.json ./
-RUN npm install
+RUN npm install --omit=dev
 
-# Copy the rest
+# Copy source files
 COPY --chown=node:node . .
 
-# Environment variables
-ENV PORT=7860
 EXPOSE 7860
 
-# Start the application
 CMD ["node", "bot.js"]

bot.js

@@ -1,302 +1,353 @@
-const { Telegraf } = require('telegraf');
-const axios = require('axios');
-const fs = require('fs');
-const path = require('path');
-const { finished } = require('stream/promises');
+/**
+ * bot.js — Word Grid Solver Bot (GramJS / pure MTProto)
+ *
+ * Uses the `telegram` npm package (GramJS) with a BOT_TOKEN for pure MTProto,
+ * no webhooks, no HTTP polling through Bot API JSON layer.
+ *
+ * Required env vars:
+ *   BOT_TOKEN          – Telegram bot token (from @BotFather)
+ *   API_ID             – Telegram API ID (from my.telegram.org)
+ *   API_HASH           – Telegram API hash (from my.telegram.org)
+ *
+ * Optional:
+ *   PORT               – HTTP dashboard port (default 7860)
+ */
+
+'use strict';
+
+require('dotenv').config();
+
+const { TelegramClient } = require('telegram');
+const { StringSession }  = require('telegram/sessions');
+const { NewMessage }     = require('telegram/events');
+const { Api }            = require('telegram');
+
 const express = require('express');
-const https = require('https');
-const { HttpsProxyAgent } = require('https-proxy-agent');
+const fs      = require('fs');
+const path    = require('path');
+const axios   = require('axios');
 
 const { extractGrid } = require('./ocr');
-const { solve } = require('./solver');
-require('dotenv').config();
+const { solve }       = require('./solver');
 
-// Stats tracking
-const stats = {
-    imagesProcessed: 0,
-    wordsFound: 0,
-    startTime: Date.now(),
-    botUsername: 'Loading...'
-};
+// ─── Environment ──────────────────────────────────────────────────────────────
+const BOT_TOKEN = process.env.BOT_TOKEN;
+const API_ID    = parseInt(process.env.API_ID  || '0', 10);
+const API_HASH  = process.env.API_HASH || '';
 
+if (!BOT_TOKEN) {
+  console.error('[FATAL] BOT_TOKEN is required.');
+  process.exit(1);
+}
+if (!API_ID || !API_HASH) {
+  console.error('[FATAL] API_ID and API_HASH are required for GramJS MTProto.');
+  process.exit(1);
+}
 
-// Load dictionary into memory for safety and speed
+// ─── Dictionary ───────────────────────────────────────────────────────────────
 const dictionaryPath = path.join(__dirname, 'node_modules/check-word/words/en.txt');
 const dictionary = new Set();
 try {
-    const data = fs.readFileSync(dictionaryPath, 'utf8');
-    data.split('\n').forEach(line => {
-        const w = line.trim().toLowerCase();
-        if (w) dictionary.add(w);
-    });
-    console.log(`Dictionary loaded with ${dictionary.size} words.`);
+  const data = fs.readFileSync(dictionaryPath, 'utf8');
+  data.split('\n').forEach(line => {
+    const w = line.trim().toLowerCase();
+    if (w.length >= 3) dictionary.add(w);
+  });
+  console.log(`[Dict] Loaded ${dictionary.size} words.`);
 } catch (err) {
-    console.error('Failed to load dictionary:', err);
+  console.error('[Dict] Failed to load dictionary:', err.message);
 }
 
 function isWord(w) {
-    return dictionary.has((w || '').toLowerCase());
-}
-
-const BOT_TOKEN = process.env.BOT_TOKEN;
-if (!BOT_TOKEN) {
-    console.error('BOT_TOKEN is required in process.env.BOT_TOKEN');
+  return dictionary.has((w || '').toLowerCase());
 }
 
-// --- Connectivity Diagnostic Test ---
-(async function testConnectivity() {
-    if (!BOT_TOKEN || BOT_TOKEN === 'DUMMY_TOKEN') return;
-    console.log('--- Connectivity Test ---');
-
-    // Log environment info
-    console.log('Proxy Environment:', {
-        HTTPS_PROXY: process.env.HTTPS_PROXY,
-        HTTP_PROXY: process.env.HTTP_PROXY,
-        npm_config_proxy: process.env.npm_config_proxy
-    });
+// ─── Stats ────────────────────────────────────────────────────────────────────
+const stats = {
+  imagesProcessed: 0,
+  wordsFound:      0,
+  startTime:       Date.now(),
+  botUsername:     'loading...',
+};
 
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+async function deleteFile(filePath) {
+  for (let i = 0; i < 5; i++) {
     try {
-        // Log current IP (using a public service)
-        const ipRes = await axios.get('https://api.ipify.org?format=json', { timeout: 5000 });
-        console.log('Current Outbound IP:', ipRes.data.ip);
+      if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+      return;
     } catch (e) {
-        console.log('Could not detect Outbound IP:', e.message);
+      await sleep(800);
     }
+  }
+}
 
-    try {
-        const config = { timeout: 30000 }; // Increased to 30s
-        const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
-        if (proxyUrl) {
-            console.log(`Using Proxy: ${proxyUrl}`);
-            config.httpsAgent = new HttpsProxyAgent(proxyUrl);
-        }
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
 
-        const response = await axios.get(`https://api.telegram.org/bot${BOT_TOKEN}/getMe`, config);
-        console.log('✅ Connectivity Test (Axios): SUCCESS');
-        console.log('Bot Username from Axios:', response.data.result.username);
-    } catch (err) {
-        console.error('❌ Connectivity Test (Axios): FAILED');
-        console.error('Error Code:', err.code);
-        console.error('Error Message:', err.message);
-    }
-    console.log('-------------------------');
-})();
-
-// Windows EPERM Fix: Retry-based file deletion
-async function deleteFileWithRetry(filePath, retries = 5, delay = 1000) {
-    for (let i = 0; i < retries; i++) {
-        try {
-            if (fs.existsSync(filePath)) {
-                fs.unlinkSync(filePath);
-                return;
-            }
-        } catch (err) {
-            if (i === retries - 1) console.error(`Cleanup error: ${err.message}`);
-            await new Promise(resolve => setTimeout(resolve, delay));
-        }
+/**
+ * Parse word patterns from caption text.
+ * Accepts formats like:  M--- (4)   or   M----   or   MATRIX (6)
+ */
+function parsePatterns(text) {
+  const results = [];
+
+  // Format 1: M--- (4)  — pattern with explicit length
+  const re1 = /([A-Z])(-+)\s*\(\d+\)/gi;
+  let m;
+  while ((m = re1.exec(text)) !== null) {
+    const pattern = (m[1] + m[2]).toUpperCase();
+    results.push({ pattern });
+  }
+
+  // Format 2: standalone pattern like M---  (3+ dashes, capital start)
+  const re2 = /\b([A-Z])(-{2,})\b/g;
+  while ((m = re2.exec(text)) !== null) {
+    const pattern = (m[1] + m[2]).toUpperCase();
+    if (!results.find(r => r.pattern === pattern)) {
+      results.push({ pattern });
     }
+  }
+
+  return results;
 }
 
-const bot = new Telegraf(BOT_TOKEN || 'DUMMY_TOKEN');
+/**
+ * Detect grid size from caption text heuristics or explicit NxN.
+ */
+function detectGridSizeFromCaption(text) {
+  const upper = text.toUpperCase();
+
+  // Explicit NxN override
+  const sizeMatch = text.match(/\b(\d+)\s*[xX×]\s*\1\b/);
+  if (sizeMatch) {
+    const n = parseInt(sizeMatch[1], 10);
+    if (n >= 4 && n <= 15) {
+      console.log(`[Grid] Explicit size override: ${n}×${n}`);
+      return n;
+    }
+  }
 
+  if (upper.includes('HARD MODE') || upper.includes('10X10') || upper.includes('10 X 10')) {
+    console.log('[Grid] Detected 10×10 from caption phrase.');
+    return 10;
+  }
 
-bot.start((ctx) => ctx.reply('Send me a word grid image and the word patterns (e.g., M--- (4)) to solve it!'));
+  // Let OCR auto-detect — return null
+  return null;
+}
 
-bot.on('photo', async (ctx) => {
-    let imagePath = null;
-    try {
-        const photo = ctx.message.photo[ctx.message.photo.length - 1];
-        const fileLink = await ctx.telegram.getFileLink(photo.file_id);
-        imagePath = path.join(__dirname, `photo_${Date.now()}.jpg`);
-
-        // Retry-based download for flaky networks
-        let response;
-        for (let i = 0; i < 3; i++) {
-            try {
-                response = await axios({
-                    url: fileLink.href,
-                    responseType: 'stream',
-                    timeout: 20000
-                });
-                break;
-            } catch (e) {
-                if (i === 2) throw e;
-                console.log(`Download attempt ${i + 1} failed, retrying...`);
-                await new Promise(r => setTimeout(r, 2000));
-            }
-        }
+/**
+ * Format results into a Telegram HTML message.
+ */
+function formatResults(results, grid, patterns) {
+  let msg = '🎯 <b>WORD GRID RESULTS</b>\n\n';
+  let foundAny = false;
 
-        const writer = fs.createWriteStream(imagePath);
-        response.data.pipe(writer);
-        await finished(writer);
+  for (const p of patterns) {
+    const key = p.pattern || p.word;
+    if (!key) continue;
 
-        ctx.reply('🔍 Processing image...');
+    const resultEntry = results[key];
+    if (!resultEntry) continue;
 
-        const text = ctx.message.caption || '';
-        const upperText = text.toUpperCase();
+    if (Array.isArray(resultEntry)) {
+      // Pattern search — validate against dictionary
+      const startChar = key[0].toUpperCase();
+      const wordMatches = [];
 
-        // Detect grid dimension based on phrases or explicit NxN format
-        let gridSize = 8;
-        if (upperText.includes('HARD MODE CHALLENGE')) {
-            gridSize = 10;
-        } else if (upperText.includes('WORD GRID CHALLENGE')) {
-            gridSize = 8;
-        }
+      for (const hit of resultEntry) {
+        const raw  = hit.match.toUpperCase();
 
-        // Explicit override still has highest priority (e.g., "12x12" in caption)
-        const sizeMatch = text.match(/\b(\d+)\s*[xX*]\s*\1\b/);
-        if (sizeMatch) {
-            gridSize = parseInt(sizeMatch[1], 10);
-            console.log(`Explicit grid size override: ${gridSize}x${gridSize}`);
-        } else {
-            console.log(`Detected grid size from phrase/level: ${gridSize}x${gridSize}`);
+        // Exact word?
+        if (isWord(raw)) {
+          wordMatches.push(raw);
+          continue;
         }
 
-        const grid = await extractGrid(imagePath, gridSize);
-        if (!grid || grid.length === 0) {
-            fs.unlinkSync(imagePath);
-            return ctx.reply('❌ Could not extract grid from image.');
+        // Try forcing the known start character (OCR may have mis-read first char)
+        const forced = startChar + raw.slice(1);
+        if (isWord(forced)) {
+          wordMatches.push(forced);
+          continue;
         }
 
-        stats.imagesProcessed++;
-        const patterns = parsePatterns(text);
+        // Try looking at all lookalike combos for first char
+        // (already handled by charMatch in solver, just log for debug)
+        console.log(`[Solver] Rejected non-word for ${key}: ${raw}`);
+      }
+
+      // Deduplicate
+      const unique = [...new Set(wordMatches)];
+      if (unique.length > 0) {
+        msg += `✅ ${key}: ${unique.map(w => `<code>${w}</code>`).join(', ')}\n`;
+        stats.wordsFound += unique.length;
+        foundAny = true;
+      } else {
+        msg += `❓ ${key}: no valid words found\n`;
+      }
+    } else {
+      // Exact word found
+      msg += `✅ <code>${resultEntry.match}</code> at [${resultEntry.r},${resultEntry.c}] dir:${resultEntry.dir}\n`;
+      foundAny = true;
+    }
+  }
 
-        if (patterns.length === 0) {
-            fs.unlinkSync(imagePath);
-            return ctx.reply('❓ No word patterns found in caption. Please provide patterns like M--- (4).');
-        }
+  if (!foundAny) {
+    msg += '😔 No real word matches found for these patterns.\n';
+  }
 
-        const results = solve(grid, patterns);
-
-        let responseText = '🎯 WORD GRID RESULTS 🎯\n\n';
-        let foundAny = false;
-
-        for (const p in results) {
-            foundAny = true;
-            const targetStart = p[0].toUpperCase();
-
-            if (Array.isArray(results[p])) {
-                const wordMatches = results[p]
-                    .map(m => {
-                        const match = m.match.toUpperCase();
-                        // 1. Perfect Match?
-                        if (isWord(match) && match[0] === targetStart) return match;
-
-                        // 2. OCR Error on first letter? (Try forcing target start)
-                        const forced = targetStart + match.slice(1);
-                        if (isWord(forced)) return forced;
-
-                        // Log candidates that are NOT words for debugging
-                        if (match[0] === targetStart) {
-                            console.log(`[Pattern Debug] Rejected non-word candidate for ${p}: ${match}`);
-                        }
-
-                        return null;
-                    })
-                    .filter(w => w !== null)
-                    // Remove duplicates
-                    .filter((value, index, self) => self.indexOf(value) === index);
-
-                if (wordMatches.length > 0) {
-                    responseText += `✅ ${p}: ${wordMatches.map(w => `<code>${w}</code>`).join(', ')}\n`;
-                    stats.wordsFound += wordMatches.length;
-                }
-            }
-        }
+  // Append grid debug
+  msg += '\n🔍 <b>Extracted Grid:</b>\n';
+  msg += '<pre>' + grid.map(row => row.join(' ')).join('\n') + '</pre>';
 
-        if (responseText === '🎯 WORD GRID RESULTS 🎯\n\n') {
-            responseText += '😔 No real word matches found for these patterns.\n\n';
-        }
+  return msg;
+}
 
-        responseText += '\n🔍 <b>Extracted Grid (Debug):</b>\n';
-        responseText += '<pre>' + grid.map(row => row.join(' ')).join('\n') + '</pre>';
+// ─── GramJS Bot Setup ─────────────────────────────────────────────────────────
+async function startBot() {
+  // For bots, we use an empty StringSession — GramJS handles the rest
+  const session = new StringSession('');
+
+  const client = new TelegramClient(session, API_ID, API_HASH, {
+    connectionRetries: 10,
+    retryDelay: 2000,
+    useWSS: false,
+  });
+
+  console.log('[GramJS] Connecting via MTProto...');
+
+  // Login as a bot using the token
+  await client.start({
+    botAuthToken: BOT_TOKEN,
+  });
+
+  console.log('[GramJS] Connected successfully.');
+
+  const me = await client.getMe();
+  stats.botUsername = me.username || 'unknown';
+  console.log(`[Bot] Running as @${stats.botUsername}`);
+
+  // ─── Handle new messages ───────────────────────────────────────────────────
+  client.addEventHandler(async (event) => {
+    const msg = event.message;
+    if (!msg) return;
+
+    const chatId  = msg.peerId;
+    const caption = msg.message || '';
+
+    // /start command
+    if (caption.trim() === '/start') {
+      await client.sendMessage(chatId, {
+        message: '👋 Welcome to the Word Grid Solver!\n\nSend me a word grid image with your word patterns in the caption.\n\nExample caption: <code>M--- (4) P------- (8)</code>\n\nI support 8×8 and 10×10 grids and auto-detect the size!',
+        parseMode: 'html',
+      });
+      return;
+    }
 
-        ctx.reply(responseText, { parse_mode: 'HTML' });
+    // Check if message has a photo
+    const hasPhoto = msg.media && (
+      msg.media.className === 'MessageMediaPhoto' ||
+      (msg.media.document && msg.media.document.mimeType && msg.media.document.mimeType.startsWith('image/'))
+    );
 
-        // Cleanup
-        await deleteFileWithRetry(imagePath);
+    if (!hasPhoto) return;
 
-    } catch (err) {
-        console.error(err);
-        ctx.reply('🚨 Error processing image.');
-    }
-});
+    // ── Download image ────────────────────────────────────────────────────────
+    const imagePath = path.join(__dirname, `photo_${Date.now()}_${Math.random().toString(36).slice(2)}.jpg`);
+    let downloadedOk = false;
 
-function parsePatterns(text) {
-    const regex = /([A-Z]\-+)\s*\((\d+)\)/g;
-    const matches = [];
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        matches.push({ pattern: match[1] });
+    try {
+      await client.sendMessage(chatId, { message: '🔍 Processing your grid image...' });
+
+      const buffer = await client.downloadMedia(msg.media, { outputFile: Buffer });
+      if (!buffer || buffer.length === 0) throw new Error('Empty download buffer');
+      fs.writeFileSync(imagePath, buffer);
+      downloadedOk = true;
+    } catch (dlErr) {
+      console.error('[Download] Failed:', dlErr.message);
+      await client.sendMessage(chatId, { message: '❌ Failed to download the image. Please try again.' });
+      await deleteFile(imagePath);
+      return;
     }
-    return matches;
-}
 
-if (BOT_TOKEN) {
-    bot.telegram.getMe().then((me) => {
-        stats.botUsername = me.username;
-        console.log(`Bot is running as @${me.username}`);
-    }).catch(err => {
-        console.error('Failed to get bot info:', err.message);
-    });
-
-    // Retry-based launch to handle transient network issues on Hugging Face
-    const launchBot = async (retries = 5) => {
-        const options = {};
-        const proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
-        if (proxyUrl) {
-            options.telegram = {
-                agent: new HttpsProxyAgent(proxyUrl)
-            };
-            console.log('Telegraf will use proxy:', proxyUrl);
-        }
+    try {
+      stats.imagesProcessed++;
 
-        for (let i = 0; i < retries; i++) {
-            try {
-                await bot.launch(options);
-                console.log('Bot launched and polling.');
-                return;
-            } catch (err) {
-                console.error(`Bot launch attempt ${i + 1} failed:`, err.message);
-                if (i < retries - 1) {
-                    const delay = Math.pow(2, i) * 1000;
-                    console.log(`Retrying in ${delay}ms...`);
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                } else {
-                    console.error('Max retries reached. Bot failed to launch.');
-                }
-            }
-        }
-    };
+      // ── Detect grid size ────────────────────────────────────────────────────
+      const forcedSize = detectGridSizeFromCaption(caption);
 
-    launchBot();
-} else {
-    console.log('Bot is ready but BOT_TOKEN is missing. Please set it to start the bot.');
+      // ── Extract grid via OCR ────────────────────────────────────────────────
+      const grid = await extractGrid(imagePath, forcedSize);
+
+      if (!grid || grid.length === 0) {
+        await client.sendMessage(chatId, { message: '❌ Could not extract grid from the image. Make sure the grid is clearly visible.' });
+        await deleteFile(imagePath);
+        return;
+      }
+
+      // ── Parse patterns ──────────────────────────────────────────────────────
+      const patterns = parsePatterns(caption);
+
+      if (patterns.length === 0) {
+        // No patterns → just show the grid
+        let noPatternMsg = '📋 <b>Grid extracted</b> (no patterns found in caption):\n\n';
+        noPatternMsg += '<pre>' + grid.map(r => r.join(' ')).join('\n') + '</pre>';
+        noPatternMsg += '\n\nAdd patterns like <code>M--- (4)</code> to the caption to search for words!';
+        await client.sendMessage(chatId, { message: noPatternMsg, parseMode: 'html' });
+        await deleteFile(imagePath);
+        return;
+      }
+
+      // ── Solve ───────────────────────────────────────────────────────────────
+      const results = solve(grid, patterns);
+
+      // ── Format and reply ────────────────────────────────────────────────────
+      const reply = formatResults(results, grid, patterns);
+
+      await client.sendMessage(chatId, { message: reply, parseMode: 'html' });
+
+    } catch (err) {
+      console.error('[Handler] Error:', err);
+      await client.sendMessage(chatId, { message: '🚨 An error occurred while processing. Please try again.' });
+    } finally {
+      await deleteFile(imagePath);
+    }
+  }, new NewMessage({}));
+
+  // Keep alive
+  console.log('[Bot] Listening for messages...');
+
+  // Graceful shutdown
+  const shutdown = async (signal) => {
+    console.log(`[Bot] Received ${signal}, disconnecting...`);
+    await client.disconnect();
+    process.exit(0);
+  };
+  process.once('SIGINT',  () => shutdown('SIGINT'));
+  process.once('SIGTERM', () => shutdown('SIGTERM'));
 }
 
-// Express Server for Hugging Face / Dashboard
-const app = express();
-const port = process.env.PORT || 7860;
+// ─── Express Dashboard ────────────────────────────────────────────────────────
+const app  = express();
+const PORT = process.env.PORT || 7860;
 
 app.use(express.static(path.join(__dirname, 'public')));
 
-app.get('/api/stats', (req, res) => {
-    res.json({
-        ...stats,
-        uptime: Math.floor((Date.now() - stats.startTime) / 1000)
-    });
+app.get('/api/stats', (_req, res) => {
+  res.json({
+    ...stats,
+    uptime: Math.floor((Date.now() - stats.startTime) / 1000),
+  });
 });
 
-app.listen(port, () => {
-    console.log(`Dashboard running on port ${port}`);
+app.listen(PORT, () => {
+  console.log(`[Dashboard] Running on port ${PORT}`);
 });
 
-// Enable graceful stop
-process.once('SIGINT', () => {
-    bot.stop('SIGINT');
-    process.exit(0);
-});
-process.once('SIGTERM', () => {
-    bot.stop('SIGTERM');
-    process.exit(0);
+// ─── Launch ───────────────────────────────────────────────────────────────────
+startBot().catch(err => {
+  console.error('[FATAL] Bot startup failed:', err);
+  process.exit(1);
 });

ocr.js

@@ -1,106 +1,267 @@
+/**
+ * ocr.js — Advanced multi-pass Tesseract OCR with auto-detecting grid size
+ *
+ * Key improvements over v1:
+ *  • Auto-detect grid size (8×8 vs 10×10 vs other NxN) via symbol clustering
+ *  • Multi-threshold voting (5 passes) for better letter accuracy
+ *  • K-means-style column/row centroid detection instead of fixed bucket math
+ *  • Lookalike-aware majority voting per cell (I/L, O/0, B/8, etc.)
+ *  • No magic assumption of exactly N symbols – works with noise/gaps
+ */
+
 const sharp = require('sharp');
 sharp.cache(false);
 const { createWorker } = require('tesseract.js');
 
+// ─── OCR lookalike corrections (applied at voting time) ───────────────────────
+const LOOKALIKE_GROUPS = [
+  ['I', 'L', '1', '|', 'J'],
+  ['O', '0', 'Q', 'D'],
+  ['B', '8', '3'],
+  ['S', '5'],
+  ['G', '6', 'C'],
+  ['Z', '2'],
+  ['E', 'F'],
+  ['U', 'V'],
+];
+
+// Build canonical map: non-alpha → preferred alpha
+const CANONICAL = {};
+for (const group of LOOKALIKE_GROUPS) {
+  const alpha = group.find(c => /^[A-Z]$/.test(c));
+  if (!alpha) continue;
+  for (const c of group) {
+    if (!/^[A-Z]$/.test(c)) CANONICAL[c] = alpha;
+  }
+}
+
+function canonicalise(char) {
+  return CANONICAL[char.toUpperCase()] || char.toUpperCase();
+}
+
+// ─── Simple 1-D k-means-style centroid finder ─────────────────────────────────
 /**
- * Ultimate Mathematical + Multi-Pass Voting OCR (Dynamic N x N)
+ * Given a sorted list of values and a target cluster count,
+ * iteratively refine cluster centroids until stable.
+ * Returns sorted list of centroids.
  */
-async function extractGrid(imagePath, gridSize = 8) {
-    let worker = null;
-    try {
-        console.log(`Starting Mathematical Voting OCR (${gridSize}x${gridSize})...`);
-        
-        worker = await createWorker('eng');
-        await worker.setParameters({
-            tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
-        });
-
-        const thresholds = [80, 110, 140, 170, 200];
-        const allSymbols = [];
-
-        for (const th of thresholds) {
-            const processedImageBuffer = await sharp(imagePath)
-                .grayscale()
-                .negate() // Black on white
-                .normalize()
-                .sharpen()
-                .threshold(th)
-                .toBuffer();
-
-            const res = await worker.recognize(processedImageBuffer);
-            
-            if (res.data.symbols && res.data.symbols.length > 0) {
-                for (const s of res.data.symbols) {
-                    const text = s.text.replace(/[^A-Z]/gi, '').toUpperCase();
-                    if (text && text.length === 1) {
-                        const midX = (s.bbox.x0 + s.bbox.x1) / 2;
-                        const midY = (s.bbox.y0 + s.bbox.y1) / 2;
-                        allSymbols.push({ char: text, x: midX, y: midY });
-                    }
-                }
-            }
-        }
+function findCentroids(values, k) {
+  if (values.length === 0) return [];
+  const sorted = [...values].sort((a, b) => a - b);
+  const min = sorted[0], max = sorted[sorted.length - 1];
 
-        if (allSymbols.length === 0) {
-             await worker.terminate();
-             return null;
-        }
+  if (k <= 1) return [(min + max) / 2];
 
-        let minX = Infinity, minY = Infinity;
-        let maxX = -Infinity, maxY = -Infinity;
-        
-        for (const s of allSymbols) {
-            if (s.x < minX) minX = s.x;
-            if (s.y < minY) minY = s.y;
-            if (s.x > maxX) maxX = s.x;
-            if (s.y > maxY) maxY = s.y;
-        }
+  // Initialise centroids evenly spaced
+  let centroids = Array.from({ length: k }, (_, i) => min + (i / (k - 1)) * (max - min));
 
-        const padX = (maxX - minX) * 0.05;
-        const padY = (maxY - minY) * 0.05;
-        minX -= padX;
-        maxX += padX;
-        minY -= padY;
-        maxY += padY;
-
-        const cellW = (maxX - minX) / gridSize;
-        const cellH = (maxY - minY) / gridSize;
-
-        const cellMap = Array.from({ length: gridSize }, () => Array.from({ length: gridSize }, () => ({})));
-
-        for (const s of allSymbols) {
-            let c = Math.floor((s.x - minX) / cellW);
-            let r = Math.floor((s.y - minY) / cellH);
-            
-            c = Math.max(0, Math.min(gridSize - 1, c));
-            r = Math.max(0, Math.min(gridSize - 1, r));
-            
-            cellMap[r][c][s.char] = (cellMap[r][c][s.char] || 0) + 1;
-        }
+  for (let iter = 0; iter < 30; iter++) {
+    // Assign each value to nearest centroid
+    const clusters = Array.from({ length: k }, () => []);
+    for (const v of sorted) {
+      let best = 0, bestDist = Infinity;
+      for (let i = 0; i < k; i++) {
+        const d = Math.abs(v - centroids[i]);
+        if (d < bestDist) { bestDist = d; best = i; }
+      }
+      clusters[best].push(v);
+    }
+
+    // Recompute centroids
+    const newCentroids = centroids.map((c, i) => {
+      if (clusters[i].length === 0) return c;
+      return clusters[i].reduce((a, b) => a + b, 0) / clusters[i].length;
+    });
 
-        const grid = Array.from({ length: gridSize }, () => Array(gridSize).fill(' '));
-        for (let r = 0; r < gridSize; r++) {
-            for (let c = 0; c < gridSize; c++) {
-                const votes = cellMap[r][c];
-                let bestChar = ' ';
-                let maxVotes = 0;
-                for (const char in votes) {
-                    if (votes[char] > maxVotes) {
-                        maxVotes = votes[char];
-                        bestChar = char;
-                    }
-                }
-                grid[r][c] = bestChar;
-            }
+    // Check convergence
+    const moved = newCentroids.some((nc, i) => Math.abs(nc - centroids[i]) > 0.01);
+    centroids = newCentroids;
+    if (!moved) break;
+  }
+
+  return centroids.sort((a, b) => a - b);
+}
+
+// ─── Auto-detect grid size from symbol cloud ──────────────────────────────────
+/**
+ * Try k=8 and k=10 clusterings on the X coordinates.
+ * Pick whichever produces tighter within-cluster variance.
+ */
+function detectGridSize(xs) {
+  if (xs.length === 0) return 8;
+
+  const tryK = (k) => {
+    const cents = findCentroids(xs, k);
+    let totalVar = 0;
+    const clusters = Array.from({ length: k }, () => []);
+    for (const x of xs) {
+      let best = 0, bestDist = Infinity;
+      for (let i = 0; i < k; i++) {
+        const d = Math.abs(x - cents[i]);
+        if (d < bestDist) { bestDist = d; best = i; }
+      }
+      clusters[best].push(x);
+    }
+    for (const cl of clusters) {
+      if (cl.length === 0) continue;
+      const mean = cl.reduce((a, b) => a + b, 0) / cl.length;
+      totalVar += cl.reduce((s, v) => s + (v - mean) ** 2, 0);
+    }
+    // Normalise by k so we compare fairly
+    return totalVar / k;
+  };
+
+  // If very few symbols, default to 8
+  if (xs.length < 30) return 8;
+
+  const v8  = tryK(8);
+  const v10 = tryK(10);
+
+  // Heuristic: also check symbol density
+  // A 10×10 grid should have ~100 symbols; an 8×8 ~ 64
+  const symbolCount = xs.length;
+  if (symbolCount > 350) return 10; // many multi-pass hits → likely 10×10
+
+  // Use variance ratio to decide
+  // If v10 is significantly better (lower) than v8, go with 10
+  return (v10 < v8 * 0.85) ? 10 : 8;
+}
+
+// ─── Main extractGrid function ────────────────────────────────────────────────
+/**
+ * @param {string} imagePath
+ * @param {number|null} forcedSize  - if null, auto-detect
+ * @returns {string[][]|null}
+ */
+async function extractGrid(imagePath, forcedSize = null) {
+  let worker = null;
+  try {
+    const THRESHOLDS = [70, 100, 130, 160, 190, 210];
+    const allSymbols = []; // { char, x, y }
+
+    worker = await createWorker('eng');
+    await worker.setParameters({
+      tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      tessedit_pageseg_mode: '6', // Assume uniform block of text
+    });
+
+    for (const th of THRESHOLDS) {
+      let buf;
+      try {
+        buf = await sharp(imagePath)
+          .grayscale()
+          .normalize()
+          .sharpen({ sigma: 1.5 })
+          .threshold(th)
+          .toBuffer();
+      } catch (e) {
+        console.warn(`Sharp preprocessing failed at threshold ${th}:`, e.message);
+        continue;
+      }
+
+      let res;
+      try {
+        res = await worker.recognize(buf);
+      } catch (e) {
+        console.warn(`Tesseract failed at threshold ${th}:`, e.message);
+        continue;
+      }
+
+      if (!res.data.symbols) continue;
+
+      for (const s of res.data.symbols) {
+        const raw = (s.text || '').replace(/[^A-Za-z0-9|]/g, '').toUpperCase();
+        if (!raw || raw.length !== 1) continue;
+        const ch = canonicalise(raw);
+        if (!/^[A-Z]$/.test(ch)) continue;
+
+        const midX = (s.bbox.x0 + s.bbox.x1) / 2;
+        const midY = (s.bbox.y0 + s.bbox.y1) / 2;
+        allSymbols.push({ char: ch, x: midX, y: midY });
+      }
+    }
+
+    await worker.terminate();
+    worker = null;
+
+    if (allSymbols.length === 0) {
+      console.warn('No symbols detected from OCR.');
+      return null;
+    }
+
+    console.log(`Total symbol observations (all passes): ${allSymbols.length}`);
+
+    // ── Detect or use forced grid size ──
+    const xs = allSymbols.map(s => s.x);
+    const ys = allSymbols.map(s => s.y);
+
+    const gridSize = forcedSize !== null ? forcedSize : detectGridSize(xs);
+    console.log(`Using grid size: ${gridSize}×${gridSize}`);
+
+    // ── Cluster columns and rows ──
+    const colCentroids = findCentroids(xs, gridSize);
+    const rowCentroids = findCentroids(ys, gridSize);
+
+    // ── Vote per cell ──
+    // cellVotes[r][c] = { char: count }
+    const cellVotes = Array.from({ length: gridSize }, () =>
+      Array.from({ length: gridSize }, () => ({}))
+    );
+
+    const colSpan = colCentroids.length > 1
+      ? (colCentroids[colCentroids.length - 1] - colCentroids[0]) / (gridSize - 1)
+      : 50;
+    const rowSpan = rowCentroids.length > 1
+      ? (rowCentroids[rowCentroids.length - 1] - rowCentroids[0]) / (gridSize - 1)
+      : 50;
+    const colTol = colSpan * 0.5;
+    const rowTol = rowSpan * 0.5;
+
+    for (const s of allSymbols) {
+      // Assign to nearest column centroid within tolerance
+      let bestC = -1, bestCDist = Infinity;
+      for (let i = 0; i < colCentroids.length; i++) {
+        const d = Math.abs(s.x - colCentroids[i]);
+        if (d < bestCDist) { bestCDist = d; bestC = i; }
+      }
+      if (bestCDist > colTol * 2) continue; // too far from any centroid → noise
+
+      let bestR = -1, bestRDist = Infinity;
+      for (let i = 0; i < rowCentroids.length; i++) {
+        const d = Math.abs(s.y - rowCentroids[i]);
+        if (d < bestRDist) { bestRDist = d; bestR = i; }
+      }
+      if (bestRDist > rowTol * 2) continue;
+
+      cellVotes[bestR][bestC][s.char] = (cellVotes[bestR][bestC][s.char] || 0) + 1;
+    }
+
+    // ── Build final grid ──
+    const grid = Array.from({ length: gridSize }, (_, r) =>
+      Array.from({ length: gridSize }, (_, c) => {
+        const votes = cellVotes[r][c];
+        let best = '?', maxV = 0;
+        for (const [ch, v] of Object.entries(votes)) {
+          if (v > maxV) { maxV = v; best = ch; }
         }
+        return best;
+      })
+    );
+
+    // Log the extracted grid for debugging
+    console.log('Extracted grid:');
+    for (const row of grid) {
+      console.log(row.join(' '));
+    }
 
-        await worker.terminate();
-        return grid;
-    } catch (err) {
-        console.error('OCR Error:', err);
-        if (worker) try { await worker.terminate(); } catch(e) {}
-        return null;
+    return grid;
+  } catch (err) {
+    console.error('OCR Error:', err);
+    if (worker) {
+      try { await worker.terminate(); } catch (_) {}
     }
+    return null;
+  }
 }
 
 module.exports = { extractGrid };

package-lock.json

@@ -1,22 +1,30 @@
 {
   "name": "wordgridsolver",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "wordgridsolver",
-      "version": "1.0.0",
+      "version": "2.0.0",
       "dependencies": {
         "axios": "^1.6.0",
+        "big-integer": "^1.6.52",
         "check-word": "^1.1.0",
         "dotenv": "^17.4.2",
         "express": "^5.2.1",
+        "input": "^1.0.1",
         "sharp": "^0.34.5",
-        "telegraf": "^4.14.0",
+        "telegram": "^2.26.0",
         "tesseract.js": "^5.0.0"
       }
     },
+    "node_modules/@cryptography/aes": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/@cryptography/aes/-/aes-0.1.1.tgz",
+      "integrity": "sha512-PcYz4FDGblO6tM2kSC+VzhhK62vml6k6/YAkiWtyPvrgJVfnDRoHGDtKn5UiaRRUrvUTTocBpvc2rRgTCqxjsg==",
+      "license": "GPL-3.0-or-later"
+    },
     "node_modules/@emnapi/runtime": {
       "version": "1.9.2",
       "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.2.tgz",
@@ -492,24 +500,6 @@
         "url": "https://opencollective.com/libvips"
       }
     },
-    "node_modules/@telegraf/types": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/@telegraf/types/-/types-7.1.0.tgz",
-      "integrity": "sha512-kGevOIbpMcIlCDeorKGpwZmdH7kHbqlk/Yj6dEpJMKEQw5lk0KVQY0OLXaCswy8GqlIVLd5625OB+rAntP9xVw==",
-      "license": "MIT"
-    },
-    "node_modules/abort-controller": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
-      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
-      "license": "MIT",
-      "dependencies": {
-        "event-target-shim": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=6.5"
-      }
-    },
     "node_modules/accepts": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
@@ -548,6 +538,42 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/ansi-escapes": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-1.4.0.tgz",
+      "integrity": "sha512-wiXutNjDUlNEDWHcYH3jtZUhd3c4/VojassD8zHdHCY13xbZy2XbW+NKQwA0tWGBVzDA9qEzYwfoSsWmviidhw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
+      "integrity": "sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
+      "integrity": "sha512-kmCevFghRiWM7HB5zTPULl4r9bVFSWjz62MhqizDGUrq2NWuNMQyuv4tHHoKJHs69M/MF64lEcHdYIocrdWQYA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/async-mutex": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/async-mutex/-/async-mutex-0.3.2.tgz",
+      "integrity": "sha512-HuTK7E7MT7jZEh1P9GtRW9+aTWiDWWi9InbZ5hjxrnRa39KS4BW04+xLBhYNS2aXhHUIKZSw3gj4Pn1pj+qGAA==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.3.1"
+      }
+    },
     "node_modules/asynckit": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
@@ -565,6 +591,51 @@
         "proxy-from-env": "^2.1.0"
       }
     },
+    "node_modules/babel-runtime": {
+      "version": "6.26.0",
+      "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz",
+      "integrity": "sha512-ITKNuq2wKlW1fJg9sSW52eepoYgZBggvOAHC0u/CYu/qxQ9EVzThCgR69BnSXLHjy2f7SY5zaQ4yt7H9ZVxY2g==",
+      "license": "MIT",
+      "dependencies": {
+        "core-js": "^2.4.0",
+        "regenerator-runtime": "^0.11.0"
+      }
+    },
+    "node_modules/babel-runtime/node_modules/regenerator-runtime": {
+      "version": "0.11.1",
+      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz",
+      "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==",
+      "license": "MIT"
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/big-integer": {
+      "version": "1.6.52",
+      "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.52.tgz",
+      "integrity": "sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==",
+      "license": "Unlicense",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
     "node_modules/bmp-js": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/bmp-js/-/bmp-js-0.1.0.tgz",
@@ -595,27 +666,42 @@
         "url": "https://opencollective.com/express"
       }
     },
-    "node_modules/buffer-alloc": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz",
-      "integrity": "sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==",
+    "node_modules/buffer": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz",
+      "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
-        "buffer-alloc-unsafe": "^1.1.0",
-        "buffer-fill": "^1.0.0"
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.2.1"
       }
     },
-    "node_modules/buffer-alloc-unsafe": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz",
-      "integrity": "sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==",
-      "license": "MIT"
-    },
-    "node_modules/buffer-fill": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz",
-      "integrity": "sha512-T7zexNBwiiaCOGDg9xNX9PBmjrubblRkENuptryuI64URkXDFum9il/JGL8Lm8wYfAXpredVXXZz7eMHilimiQ==",
-      "license": "MIT"
+    "node_modules/bufferutil": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/bufferutil/-/bufferutil-4.1.0.tgz",
+      "integrity": "sha512-ZMANVnAixE6AWWnPzlW2KpUrxhm9woycYvPOo67jWHyFowASTEd9s+QN1EIMsSDtwhIxN4sWE1jotpuDUIgyIw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "node-gyp-build": "^4.3.0"
+      },
+      "engines": {
+        "node": ">=6.14.2"
+      }
     },
     "node_modules/bytes": {
       "version": "3.1.2",
@@ -655,12 +741,55 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/chalk": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
+      "integrity": "sha512-U3lRVLMSlsCfjqYPbLyVv11M9CPW4I728d6TCKMAOJueEeB9/8o+eSsMnxPJD+Q+K909sdESg7C+tIkoH6on1A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^2.2.1",
+        "escape-string-regexp": "^1.0.2",
+        "has-ansi": "^2.0.0",
+        "strip-ansi": "^3.0.0",
+        "supports-color": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/check-word": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/check-word/-/check-word-1.1.0.tgz",
       "integrity": "sha512-lkPjTvHn+3gPQ+sA2Z3QrV9fNqX2NXpvxQIxiG7pQaPQ8NhPR4dUmpHLRlCbqrP5Wo0oAzVVh7MKhwGECcvhyQ==",
       "license": "GPL 2.0"
     },
+    "node_modules/cli-cursor": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-1.0.2.tgz",
+      "integrity": "sha512-25tABq090YNKkF6JH7lcwO0zFJTRke4Jcq9iX2nr/Sz0Cjjv4gckmwlW6Ty/aoyFd6z3ysR2hMGC2GFugmBo6A==",
+      "license": "MIT",
+      "dependencies": {
+        "restore-cursor": "^1.0.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/cli-width": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.1.tgz",
+      "integrity": "sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==",
+      "license": "ISC"
+    },
+    "node_modules/code-point-at": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz",
+      "integrity": "sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/combined-stream": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
@@ -713,6 +842,27 @@
         "node": ">=6.6.0"
       }
     },
+    "node_modules/core-js": {
+      "version": "2.6.12",
+      "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.12.tgz",
+      "integrity": "sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==",
+      "deprecated": "core-js@<3.23.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Some versions have web compatibility issues. Please, upgrade your dependencies to the actual version of core-js.",
+      "hasInstallScript": true,
+      "license": "MIT"
+    },
+    "node_modules/d": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/d/-/d-1.0.2.tgz",
+      "integrity": "sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==",
+      "license": "ISC",
+      "dependencies": {
+        "es5-ext": "^0.10.64",
+        "type": "^2.7.2"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
     "node_modules/debug": {
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -757,6 +907,61 @@
         "node": ">=8"
       }
     },
+    "node_modules/dom-serializer": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz",
+      "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==",
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.0.1",
+        "domhandler": "^4.2.0",
+        "entities": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+      }
+    },
+    "node_modules/domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/domhandler": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz",
+      "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "domelementtype": "^2.2.0"
+      },
+      "engines": {
+        "node": ">= 4"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domhandler?sponsor=1"
+      }
+    },
+    "node_modules/domutils": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz",
+      "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "dom-serializer": "^1.0.1",
+        "domelementtype": "^2.2.0",
+        "domhandler": "^4.2.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domutils?sponsor=1"
+      }
+    },
     "node_modules/dotenv": {
       "version": "17.4.2",
       "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.4.2.tgz",
@@ -798,6 +1003,15 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/entities": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz",
+      "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==",
+      "license": "BSD-2-Clause",
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/es-define-property": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
@@ -843,12 +1057,76 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es5-ext": {
+      "version": "0.10.64",
+      "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.64.tgz",
+      "integrity": "sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==",
+      "hasInstallScript": true,
+      "license": "ISC",
+      "dependencies": {
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.3",
+        "esniff": "^2.0.1",
+        "next-tick": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/es6-iterator": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz",
+      "integrity": "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==",
+      "license": "MIT",
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "^0.10.35",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "node_modules/es6-symbol": {
+      "version": "3.1.4",
+      "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.4.tgz",
+      "integrity": "sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==",
+      "license": "ISC",
+      "dependencies": {
+        "d": "^1.0.2",
+        "ext": "^1.7.0"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
     "node_modules/escape-html": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
       "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
       "license": "MIT"
     },
+    "node_modules/escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/esniff": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/esniff/-/esniff-2.0.1.tgz",
+      "integrity": "sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==",
+      "license": "ISC",
+      "dependencies": {
+        "d": "^1.0.1",
+        "es5-ext": "^0.10.62",
+        "event-emitter": "^0.3.5",
+        "type": "^2.7.2"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
     "node_modules/etag": {
       "version": "1.8.1",
       "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
@@ -858,13 +1136,23 @@
         "node": ">= 0.6"
       }
     },
-    "node_modules/event-target-shim": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
-      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
+    "node_modules/event-emitter": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz",
+      "integrity": "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==",
+      "license": "MIT",
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "~0.10.14"
+      }
+    },
+    "node_modules/exit-hook": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/exit-hook/-/exit-hook-1.1.1.tgz",
+      "integrity": "sha512-MsG3prOVw1WtLXAZbM3KiYtooKR1LvxHh3VHsVtIy0uiUu8usxgB/94DP2HxtD/661lLdB6yzQ09lGJSQr6nkg==",
       "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">=0.10.0"
       }
     },
     "node_modules/express": {
@@ -935,6 +1223,28 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/ext": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz",
+      "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==",
+      "license": "ISC",
+      "dependencies": {
+        "type": "^2.7.2"
+      }
+    },
+    "node_modules/figures": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz",
+      "integrity": "sha512-UxKlfCRuCBxSXU4C6t9scbDyWZ4VlaFFdojKtzJuSkuOBQ5CNFum+zZXFwHjo+CxBC1t6zlYPgHIgFjL8ggoEQ==",
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "^1.0.5",
+        "object-assign": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/finalhandler": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz",
@@ -1068,6 +1378,24 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "license": "ISC"
+    },
+    "node_modules/has-ansi": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz",
+      "integrity": "sha512-C8vBJ8DwUCx19vhm7urhTuUsr4/IyP6l4VzNQDv+ryHQObW3TTTp9yB68WpYgRe2bbaGuZ/se74IqFeVnMnLZg==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/has-symbols": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
@@ -1107,6 +1435,25 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/htmlparser2": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz",
+      "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==",
+      "funding": [
+        "https://github.com/fb55/htmlparser2?sponsor=1",
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.0.1",
+        "domhandler": "^4.0.0",
+        "domutils": "^2.5.2",
+        "entities": "^2.0.0"
+      }
+    },
     "node_modules/http-errors": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
@@ -1149,12 +1496,86 @@
       "integrity": "sha512-yjD9nARJ/jb1g+CvD0tlhUHOrJ9Sy0P8T9MF3YaLlHnSRpwPfpTX0XIvpmw3gAJUmEu3FiICLBDPXVwyEvrleg==",
       "license": "Apache-2.0"
     },
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
     "node_modules/inherits": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
+    "node_modules/input": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/input/-/input-1.0.1.tgz",
+      "integrity": "sha512-5DKQKQ7Nm/CaPGYKF74uUvk5ftC3S04fLYWcDrNG2rOVhhRgB4E2J8JNb7AAh+RlQ/954ukas4bEbrRQ3/kPGA==",
+      "license": "MIT",
+      "dependencies": {
+        "babel-runtime": "^6.6.1",
+        "chalk": "^1.1.1",
+        "inquirer": "^0.12.0",
+        "lodash": "^4.6.1"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
+    "node_modules/inquirer": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-0.12.0.tgz",
+      "integrity": "sha512-bOetEz5+/WpgaW4D1NYOk1aD+JCqRjqu/FwRFgnIfiP7FC/zinsrfyO1vlS3nyH/R7S0IH3BIHBu4DBIDSqiGQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-escapes": "^1.1.0",
+        "ansi-regex": "^2.0.0",
+        "chalk": "^1.0.0",
+        "cli-cursor": "^1.0.1",
+        "cli-width": "^2.0.0",
+        "figures": "^1.3.5",
+        "lodash": "^4.3.0",
+        "readline2": "^1.0.1",
+        "run-async": "^0.1.0",
+        "rx-lite": "^3.1.2",
+        "string-width": "^1.0.1",
+        "strip-ansi": "^3.0.0",
+        "through": "^2.3.6"
+      }
+    },
+    "node_modules/ip-address": {
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.2.0.tgz",
+      "integrity": "sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
     "node_modules/ipaddr.js": {
       "version": "1.9.1",
       "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
@@ -1170,18 +1591,42 @@
       "integrity": "sha512-FO/Rhvz5tuw4MCWkpMzHFKWD2LsfHzIb7i6MdPYZ/KW7AlxawyLkqdy+jPZP1WubqEADE3O4FUENlJHDfQASRg==",
       "license": "MIT"
     },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz",
+      "integrity": "sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==",
+      "license": "MIT",
+      "dependencies": {
+        "number-is-nan": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/is-promise": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
       "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
       "license": "MIT"
     },
+    "node_modules/is-typedarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz",
+      "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==",
+      "license": "MIT"
+    },
     "node_modules/is-url": {
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/is-url/-/is-url-1.2.4.tgz",
       "integrity": "sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==",
       "license": "MIT"
     },
+    "node_modules/lodash": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+      "license": "MIT"
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -1212,6 +1657,18 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/mime": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-3.0.0.tgz",
+      "integrity": "sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
     "node_modules/mime-db": {
       "version": "1.52.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
@@ -1233,21 +1690,18 @@
         "node": ">= 0.6"
       }
     },
-    "node_modules/mri": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
-      "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "license": "MIT"
     },
+    "node_modules/mute-stream": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.5.tgz",
+      "integrity": "sha512-EbrziT4s8cWPmzr47eYVW3wimS4HsvlnV5ri1xw1aR6JQo/OrJX5rkl32K/QQHdxeabJETtfeaROGhd8W7uBgg==",
+      "license": "ISC"
+    },
     "node_modules/negotiator": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
@@ -1257,6 +1711,12 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/next-tick": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz",
+      "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==",
+      "license": "ISC"
+    },
     "node_modules/node-fetch": {
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
@@ -1277,6 +1737,47 @@
         }
       }
     },
+    "node_modules/node-gyp-build": {
+      "version": "4.8.4",
+      "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.4.tgz",
+      "integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==",
+      "license": "MIT",
+      "bin": {
+        "node-gyp-build": "bin.js",
+        "node-gyp-build-optional": "optional.js",
+        "node-gyp-build-test": "build-test.js"
+      }
+    },
+    "node_modules/node-localstorage": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/node-localstorage/-/node-localstorage-2.2.1.tgz",
+      "integrity": "sha512-vv8fJuOUCCvSPjDjBLlMqYMHob4aGjkmrkaE42/mZr0VT+ZAU10jRF8oTnX9+pgU9/vYJ8P7YT3Vd6ajkmzSCw==",
+      "license": "MIT",
+      "dependencies": {
+        "write-file-atomic": "^1.1.4"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
+    "node_modules/number-is-nan": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz",
+      "integrity": "sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/object-inspect": {
       "version": "1.13.4",
       "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
@@ -1310,6 +1811,15 @@
         "wrappy": "1"
       }
     },
+    "node_modules/onetime": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/onetime/-/onetime-1.1.0.tgz",
+      "integrity": "sha512-GZ+g4jayMqzCRMgB2sol7GiCLjKfS1PINkjmx8spcKce1LiVqcbQreXwqs2YAFXC6R03VIG28ZS31t8M866v6A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/opencollective-postinstall": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/opencollective-postinstall/-/opencollective-postinstall-2.0.3.tgz",
@@ -1319,14 +1829,11 @@
         "opencollective-postinstall": "index.js"
       }
     },
-    "node_modules/p-timeout": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-4.1.0.tgz",
-      "integrity": "sha512-+/wmHtzJuWii1sXn3HCuH/FTwGhrp4tmJTxSKJbfS+vkipci6osxXM5mY0jUiRzWKMTgUT8l7HFbeSwZAynqHw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
+    "node_modules/pako": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz",
+      "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==",
+      "license": "(MIT AND Zlib)"
     },
     "node_modules/parseurl": {
       "version": "1.3.3",
@@ -1337,6 +1844,12 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/path-browserify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
+      "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
+      "license": "MIT"
+    },
     "node_modules/path-to-regexp": {
       "version": "8.4.2",
       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz",
@@ -1408,12 +1921,42 @@
         "node": ">= 0.10"
       }
     },
+    "node_modules/readline2": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/readline2/-/readline2-1.0.1.tgz",
+      "integrity": "sha512-8/td4MmwUB6PkZUbV25uKz7dfrmjYWxsW8DVfibWdlHRk/l/DfHKn4pU+dfcoGLFgWOdyGCzINRQD7jn+Bv+/g==",
+      "license": "MIT",
+      "dependencies": {
+        "code-point-at": "^1.0.0",
+        "is-fullwidth-code-point": "^1.0.0",
+        "mute-stream": "0.0.5"
+      }
+    },
+    "node_modules/real-cancellable-promise": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/real-cancellable-promise/-/real-cancellable-promise-1.2.3.tgz",
+      "integrity": "sha512-hBI5Gy/55VEeeMtImMgEirD7eq5UmqJf1J8dFZtbJZA/3rB0pYFZ7PayMGueb6v4UtUtpKpP+05L0VwyE1hI9Q==",
+      "license": "MIT"
+    },
     "node_modules/regenerator-runtime": {
       "version": "0.13.11",
       "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz",
       "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==",
       "license": "MIT"
     },
+    "node_modules/restore-cursor": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-1.0.1.tgz",
+      "integrity": "sha512-reSjH4HuiFlxlaBaFCiS6O76ZGG2ygKoSlCsipKdaZuKSPx/+bt9mULkn4l0asVzbEfQQmXRg6Wp6gv6m0wElw==",
+      "license": "MIT",
+      "dependencies": {
+        "exit-hook": "^1.0.0",
+        "onetime": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/router": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
@@ -1430,30 +1973,26 @@
         "node": ">= 18"
       }
     },
-    "node_modules/safe-compare": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/safe-compare/-/safe-compare-1.1.4.tgz",
-      "integrity": "sha512-b9wZ986HHCo/HbKrRpBJb2kqXMK9CEWIE1egeEvZsYn69ay3kdfl9nG3RyOcR+jInTDf7a86WQ1d4VJX7goSSQ==",
+    "node_modules/run-async": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/run-async/-/run-async-0.1.0.tgz",
+      "integrity": "sha512-qOX+w+IxFgpUpJfkv2oGN0+ExPs68F4sZHfaRRx4dDexAQkG83atugKVEylyT5ARees3HBbfmuvnjbrd8j9Wjw==",
       "license": "MIT",
       "dependencies": {
-        "buffer-alloc": "^1.2.0"
+        "once": "^1.3.0"
       }
     },
+    "node_modules/rx-lite": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/rx-lite/-/rx-lite-3.1.2.tgz",
+      "integrity": "sha512-1I1+G2gteLB8Tkt8YI1sJvSIfa0lWuRtC8GjvtyPBcLSF5jBCCJJqKrpER5JU5r6Bhe+i9/pK3VMuUcXu0kdwQ=="
+    },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "license": "MIT"
     },
-    "node_modules/sandwich-stream": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/sandwich-stream/-/sandwich-stream-2.0.2.tgz",
-      "integrity": "sha512-jLYV0DORrzY3xaz/S9ydJL6Iz7essZeAfnAavsJ+zsJGZ1MOnsS52yRjU3uF3pJa/lla7+wisp//fxOwOH8SKQ==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
     "node_modules/semver": {
       "version": "7.7.4",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
@@ -1658,6 +2197,39 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/slide": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/slide/-/slide-1.1.6.tgz",
+      "integrity": "sha512-NwrtjCg+lZoqhFU8fOwl4ay2ei8PaqCBOUV3/ektPY9trO1yQ1oXEfmHAhKArUVUr/hOHvy5f6AdP17dCM0zMw==",
+      "license": "ISC",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks": {
+      "version": "2.8.9",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.9.tgz",
+      "integrity": "sha512-LJhUYUvItdQ0LkJTmPeaEObWXAqFyfmP85x0tch/ez9cahmhlBBLbIqDFnvBnUJGagb0JbIQrkBs1wJ+yRYpEw==",
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^10.1.1",
+        "smart-buffer": "^4.2.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
     "node_modules/statuses": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
@@ -1667,26 +2239,71 @@
         "node": ">= 0.8"
       }
     },
-    "node_modules/telegraf": {
-      "version": "4.16.3",
-      "resolved": "https://registry.npmjs.org/telegraf/-/telegraf-4.16.3.tgz",
-      "integrity": "sha512-yjEu2NwkHlXu0OARWoNhJlIjX09dRktiMQFsM678BAH/PEPVwctzL67+tvXqLCRQQvm3SDtki2saGO9hLlz68w==",
+    "node_modules/store2": {
+      "version": "2.14.4",
+      "resolved": "https://registry.npmjs.org/store2/-/store2-2.14.4.tgz",
+      "integrity": "sha512-srTItn1GOvyvOycgxjAnPA63FZNwy0PTyUBFMHRM+hVFltAeoh0LmNBz9SZqUS9mMqGk8rfyWyXn3GH5ReJ8Zw==",
+      "license": "MIT"
+    },
+    "node_modules/string-width": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
+      "integrity": "sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==",
       "license": "MIT",
       "dependencies": {
-        "@telegraf/types": "^7.1.0",
-        "abort-controller": "^3.0.0",
-        "debug": "^4.3.4",
-        "mri": "^1.2.0",
-        "node-fetch": "^2.7.0",
-        "p-timeout": "^4.1.0",
-        "safe-compare": "^1.1.4",
-        "sandwich-stream": "^2.0.2"
+        "code-point-at": "^1.0.0",
+        "is-fullwidth-code-point": "^1.0.0",
+        "strip-ansi": "^3.0.0"
       },
-      "bin": {
-        "telegraf": "lib/cli.mjs"
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
+      "integrity": "sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^2.0.0"
       },
       "engines": {
-        "node": "^12.20.0 || >=14.13.1"
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
+      "integrity": "sha512-KKNVtd6pCYgPIKU4cp2733HWYCpplQhddZLBUryaAHou723x+FRzQ5Df824Fj+IyyuiQTRoub4SnIFfIcrp70g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/telegram": {
+      "version": "2.26.22",
+      "resolved": "https://registry.npmjs.org/telegram/-/telegram-2.26.22.tgz",
+      "integrity": "sha512-EIj7Yrjiu0Yosa3FZ/7EyPg9s6UiTi/zDQrFmR/2Mg7pIUU+XjAit1n1u9OU9h2oRnRM5M+67/fxzQluZpaJJg==",
+      "license": "MIT",
+      "dependencies": {
+        "@cryptography/aes": "^0.1.1",
+        "async-mutex": "^0.3.0",
+        "big-integer": "^1.6.48",
+        "buffer": "^6.0.3",
+        "htmlparser2": "^6.1.0",
+        "mime": "^3.0.0",
+        "node-localstorage": "^2.2.1",
+        "pako": "^2.0.3",
+        "path-browserify": "^1.0.1",
+        "real-cancellable-promise": "^1.1.1",
+        "socks": "^2.6.2",
+        "store2": "^2.13.0",
+        "ts-custom-error": "^3.2.0",
+        "websocket": "^1.0.34"
+      },
+      "optionalDependencies": {
+        "bufferutil": "^4.0.3",
+        "utf-8-validate": "^5.0.5"
       }
     },
     "node_modules/tesseract.js": {
@@ -1714,6 +2331,12 @@
       "integrity": "sha512-KX3bYSU5iGcO1XJa+QGPbi+Zjo2qq6eBhNjSGR5E5q0JtzkoipJKOUQD7ph8kFyteCEfEQ0maWLu8MCXtvX5uQ==",
       "license": "Apache-2.0"
     },
+    "node_modules/through": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
+      "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
+      "license": "MIT"
+    },
     "node_modules/toidentifier": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
@@ -1729,12 +2352,26 @@
       "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
       "license": "MIT"
     },
+    "node_modules/ts-custom-error": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/ts-custom-error/-/ts-custom-error-3.3.1.tgz",
+      "integrity": "sha512-5OX1tzOjxWEgsr/YEUWSuPrQ00deKLh6D7OTWcvNHm12/7QPyRh8SYpyWvA4IZv8H/+GQWQEh/kwo95Q9OVW1A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
     "node_modules/tslib": {
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
       "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-      "license": "0BSD",
-      "optional": true
+      "license": "0BSD"
+    },
+    "node_modules/type": {
+      "version": "2.7.3",
+      "resolved": "https://registry.npmjs.org/type/-/type-2.7.3.tgz",
+      "integrity": "sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==",
+      "license": "ISC"
     },
     "node_modules/type-is": {
       "version": "2.0.1",
@@ -1775,6 +2412,15 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/typedarray-to-buffer": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
+      "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
+      "license": "MIT",
+      "dependencies": {
+        "is-typedarray": "^1.0.0"
+      }
+    },
     "node_modules/unpipe": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
@@ -1784,6 +2430,19 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/utf-8-validate": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.10.tgz",
+      "integrity": "sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "node-gyp-build": "^4.3.0"
+      },
+      "engines": {
+        "node": ">=6.14.2"
+      }
+    },
     "node_modules/vary": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
@@ -1805,6 +2464,38 @@
       "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
       "license": "BSD-2-Clause"
     },
+    "node_modules/websocket": {
+      "version": "1.0.35",
+      "resolved": "https://registry.npmjs.org/websocket/-/websocket-1.0.35.tgz",
+      "integrity": "sha512-/REy6amwPZl44DDzvRCkaI1q1bIiQB0mEFQLUrhz3z2EK91cp3n72rAjUlrTP0zV22HJIUOVHQGPxhFRjxjt+Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bufferutil": "^4.0.1",
+        "debug": "^2.2.0",
+        "es5-ext": "^0.10.63",
+        "typedarray-to-buffer": "^3.1.5",
+        "utf-8-validate": "^5.0.2",
+        "yaeti": "^0.0.6"
+      },
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/websocket/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/websocket/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
     "node_modules/whatwg-url": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
@@ -1821,6 +2512,27 @@
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
       "license": "ISC"
     },
+    "node_modules/write-file-atomic": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-1.3.4.tgz",
+      "integrity": "sha512-SdrHoC/yVBPpV0Xq/mUZQIpW2sWXAShb/V4pomcJXh92RuaO+f3UTWItiR3Px+pLnV2PvC2/bfn5cwr5X6Vfxw==",
+      "license": "ISC",
+      "dependencies": {
+        "graceful-fs": "^4.1.11",
+        "imurmurhash": "^0.1.4",
+        "slide": "^1.1.5"
+      }
+    },
+    "node_modules/yaeti": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/yaeti/-/yaeti-0.0.6.tgz",
+      "integrity": "sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==",
+      "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.32"
+      }
+    },
     "node_modules/zlibjs": {
       "version": "0.3.1",
       "resolved": "https://registry.npmjs.org/zlibjs/-/zlibjs-0.3.1.tgz",

package.json

@@ -1,20 +1,21 @@
 {
   "name": "wordgridsolver",
-  "version": "1.0.0",
-  "description": "Telegram bot to solve word grid puzzles",
-  "main": "index.js",
+  "version": "2.0.0",
+  "description": "Telegram bot (GramJS MTProto) to solve 8x8 and 10x10 word grid puzzles",
+  "main": "bot.js",
   "scripts": {
     "start": "node bot.js",
-    "test": "node solver.js"
+    "test": "node -e \"const {solve}=require('./solver'); console.log('Solver OK');\""
   },
   "dependencies": {
     "axios": "^1.6.0",
     "check-word": "^1.1.0",
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
-    "https-proxy-agent": "^7.0.5",
     "sharp": "^0.34.5",
-    "telegraf": "^4.16.3",
-    "tesseract.js": "^5.0.0"
+    "telegram": "^2.26.0",
+    "tesseract.js": "^5.0.0",
+    "input": "^1.0.1",
+    "big-integer": "^1.6.52"
   }
 }

solver.js

@@ -1,129 +1,212 @@
-const directions = [
-    { r: 0, c: 1, name: 'LtoR' },
-    { r: 0, c: -1, name: 'RtoL' },
-    { r: 1, c: 0, name: 'UtoD' },
-    { r: -1, c: 0, name: 'DtoU' },
-    { r: 1, c: 1, name: 'diagDR' },
-    { r: -1, c: -1, name: 'diagUL' },
-    { r: 1, c: -1, name: 'diagDL' },
-    { r: -1, c: 1, name: 'diagUR' }
+/**
+ * solver.js — Word Grid solver with comprehensive lookalike tolerance
+ *
+ * Improvements over v1:
+ *  • Symmetric LOOKALIKES map (A→B implies B can match A)
+ *  • Wildcard (-) pattern matching ignores only dashes, not all unknowns
+ *  • Pattern matching collects ALL candidates with their actual grid characters
+ *  • charMatch is stricter: only matches confirmed lookalike pairs, not random guesses
+ *  • Grid boundary checks are consolidated in one place (no off-by-one)
+ *  • Deduplication of candidates by match string
+ */
+
+// ─── Directions ───────────────────────────────────────────────────────────────
+const DIRECTIONS = [
+  { r: 0,  c:  1, name: 'LtoR'  },
+  { r: 0,  c: -1, name: 'RtoL'  },
+  { r: 1,  c:  0, name: 'UtoD'  },
+  { r: -1, c:  0, name: 'DtoU'  },
+  { r: 1,  c:  1, name: 'diagDR'},
+  { r: -1, c: -1, name: 'diagUL'},
+  { r: 1,  c: -1, name: 'diagDL'},
+  { r: -1, c:  1, name: 'diagUR'},
 ];
 
-const LOOKALIKES = {
-    'G': ['C', 'O', '6', 'Q'],
-    'C': ['G', 'O', 'Q', '(', 'L'],
-    'I': ['L', '1', 'T', 'J', '|'],
-    'L': ['I', '1', 'T', '|', '['],
-    'O': ['0', 'Q', 'G', 'C', 'D', 'U'],
-    'S': ['5', '8', 'B', '6'],
-    'B': ['8', 'S', 'R', '3', 'E'],
-    'R': ['B', 'P', 'K', 'I', 'A'],
-    'T': ['I', 'L', '7', '+'],
-    'E': ['F', 'B', '3', 'L'],
-    'U': ['V', 'W', 'O', 'Y'],
-    'V': ['U', 'Y', 'V'],
-    'D': ['0', 'O', 'B'],
+// ─── Lookalike table (symmetric) ─────────────────────────────────────────────
+// Each entry lists chars that can be confused FOR the key char by OCR.
+const LOOKALIKES_RAW = {
+  'A': ['4', 'R'],
+  'B': ['8', '3', 'R', 'S', 'E'],
+  'C': ['G', 'O', 'Q', '(', 'L'],
+  'D': ['O', 'Q', 'B', '0'],
+  'E': ['F', 'B', '3', 'L'],
+  'F': ['E', 'P'],
+  'G': ['C', 'O', '6', 'Q', 'D'],
+  'H': ['N', 'M'],
+  'I': ['L', '1', 'T', 'J', '|'],
+  'J': ['I', 'L', '1'],
+  'K': ['R', 'X'],
+  'L': ['I', '1', 'T', '|', '[', 'J'],
+  'M': ['N', 'H', 'W'],
+  'N': ['M', 'H', 'R'],
+  'O': ['0', 'Q', 'G', 'C', 'D', 'U'],
+  'P': ['F', 'B', 'R'],
+  'Q': ['O', 'G', 'C', '0'],
+  'R': ['B', 'P', 'K', 'I', 'A', 'N'],
+  'S': ['5', '8', 'B', '6'],
+  'T': ['I', 'L', '7', '+'],
+  'U': ['V', 'W', 'O', 'Y'],
+  'V': ['U', 'Y', 'W'],
+  'W': ['M', 'V', 'U'],
+  'X': ['K', 'Y'],
+  'Y': ['V', 'U', 'X'],
+  'Z': ['2', '7'],
 };
 
-function charMatch(target, grid) {
-    if (!grid || grid === ' ') return false;
-    if (target === grid) return true;
-    const lookalikes = LOOKALIKES[target];
-    return lookalikes && lookalikes.includes(grid);
+// Build symmetric version: if A can be confused as B, then B can be confused as A
+const LOOKALIKES = {};
+for (const [key, alts] of Object.entries(LOOKALIKES_RAW)) {
+  if (!LOOKALIKES[key]) LOOKALIKES[key] = new Set();
+  for (const alt of alts) {
+    LOOKALIKES[key].add(alt);
+    // symmetric
+    if (/^[A-Z]$/.test(alt)) {
+      if (!LOOKALIKES[alt]) LOOKALIKES[alt] = new Set();
+      LOOKALIKES[alt].add(key);
+    }
+  }
+}
+
+/**
+ * Does `gridChar` match `targetChar` considering OCR lookalikes?
+ * Both must be non-empty, non-space.
+ */
+function charMatch(target, gridChar) {
+  if (!gridChar || gridChar === ' ' || gridChar === '?') return false;
+  const t = target.toUpperCase();
+  const g = gridChar.toUpperCase();
+  if (t === g) return true;
+  const alts = LOOKALIKES[t];
+  return !!(alts && alts.has(g));
 }
 
+/**
+ * Check all cells are in bounds on a grid
+ */
+function inBounds(grid, r, c) {
+  return r >= 0 && r < grid.length && c >= 0 && c < (grid[r] ? grid[r].length : 0);
+}
+
+/**
+ * Solve the grid for a list of word/pattern objects.
+ *
+ * Each item in `words` is one of:
+ *   { word: 'MATRIX' }           → exact word search
+ *   { pattern: 'M---' }          → pattern search (first char + length)
+ *
+ * Returns an object:
+ *   { 'M---': [ { r, c, dir, match, reliable } ], ... }
+ *   { 'MATRIX': { r, c, dir, match } }
+ */
 function solve(grid, words) {
-    const results = {};
-    const rows = grid.length;
-    const cols = grid[0].length;
-
-    for (let wordObj of words) {
-        const word = wordObj.word;
-        const pattern = wordObj.pattern; // e.g., "M---"
-        let found = false;
-        
-        // If word is explicitly given
-        if (word && !word.includes('-')) {
-            const target = word.toUpperCase();
-            for (let r = 0; r < rows; r++) {
-                for (let c = 0; c < cols; c++) {
-                    if (charMatch(target[0], grid[r][c])) {
-                        for (const dir of directions) {
-                            let match = true;
-                            for (let i = 1; i < target.length; i++) {
-                                const nr = r + dir.r * i;
-                                const nc = c + dir.c * i;
-                                if (nr < 0 || nr >= rows || !grid[nr] || nc < 0 || nc >= grid[nr].length || !charMatch(target[i], grid[nr][nc])) {
-                                    match = false;
-                                    break;
-                                }
-                            }
-                            if (match) {
-                                results[word] = { r, c, dir: dir.name, match: target }; 
-                                found = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (found) break;
-                }
-                if (found) break;
+  const results = {};
+  const rows = grid.length;
+  if (rows === 0) return results;
+
+  for (const wordObj of words) {
+    const isExact = wordObj.word && !wordObj.word.includes('-');
+    const isPattern = !!wordObj.pattern;
+
+    if (isExact) {
+      const target = wordObj.word.toUpperCase();
+      const len = target.length;
+      let found = false;
+
+      outer:
+      for (let r = 0; r < rows && !found; r++) {
+        const cols = grid[r].length;
+        for (let c = 0; c < cols && !found; c++) {
+          if (!charMatch(target[0], grid[r][c])) continue;
+          for (const dir of DIRECTIONS) {
+            // Quick bounds check for last character
+            const er = r + dir.r * (len - 1);
+            const ec = c + dir.c * (len - 1);
+            if (!inBounds(grid, er, ec)) continue;
+
+            let match = true;
+            let candidate = '';
+            for (let i = 0; i < len; i++) {
+              const nr = r + dir.r * i;
+              const nc = c + dir.c * i;
+              if (!inBounds(grid, nr, nc) || !charMatch(target[i], grid[nr][nc])) {
+                match = false;
+                break;
+              }
+              candidate += grid[nr][nc];
             }
-        } else if (pattern) {
-            const startChar = pattern[0].toUpperCase();
-            const length = pattern.length;
-            
-            for (let r = 0; r < rows; r++) {
-                for (let c = 0; c < cols; c++) {
-                    if (charMatch(startChar, grid[r][c])) {
-                        for (const dir of directions) {
-                            let candidate = grid[r][c];
-                            let possible = true;
-                            for (let i = 1; i < length; i++) {
-                                const nr = r + dir.r * i;
-                                const nc = c + dir.c * i;
-                                if (nr < 0 || nr >= rows || !grid[nr] || nc < 0 || nc >= grid[nr].length) {
-                                    possible = false;
-                                    break;
-                                }
-                                const char = grid[nr][nc];
-                                if (char === undefined || char === ' ') {
-                                    possible = false;
-                                    break;
-                                }
-                                candidate += char;
-                            }
-                            if (possible) {
-                                if (!results[pattern]) results[pattern] = [];
-                                results[pattern].push({ r, c, dir: dir.name, match: candidate });
-                            }
-                        }
-                    }
-                }
+            if (match) {
+              results[wordObj.word] = { r, c, dir: dir.name, match: candidate };
+              found = true;
+              break;
             }
+          }
         }
+      }
+    } else if (isPattern) {
+      const pattern = wordObj.pattern.toUpperCase(); // e.g. "M---"
+      const startChar = pattern[0];
+      const len = pattern.length;
+      const hits = [];
+
+      for (let r = 0; r < rows; r++) {
+        const cols = grid[r].length;
+        for (let c = 0; c < cols; c++) {
+          if (!charMatch(startChar, grid[r][c])) continue;
+
+          for (const dir of DIRECTIONS) {
+            // Bounds check for last char
+            const er = r + dir.r * (len - 1);
+            const ec = c + dir.c * (len - 1);
+            if (!inBounds(grid, er, ec)) continue;
+
+            let possible = true;
+            let candidate = '';
+            for (let i = 0; i < len; i++) {
+              const nr = r + dir.r * i;
+              const nc = c + dir.c * i;
+              if (!inBounds(grid, nr, nc)) { possible = false; break; }
+              const ch = grid[nr][nc];
+              if (!ch || ch === ' ') { possible = false; break; }
+              candidate += ch;
+            }
+
+            if (possible && candidate.length === len) {
+              hits.push({ r, c, dir: dir.name, match: candidate });
+            }
+          }
+        }
+      }
+
+      // Deduplicate by match string
+      const seen = new Set();
+      const unique = hits.filter(h => {
+        if (seen.has(h.match)) return false;
+        seen.add(h.match);
+        return true;
+      });
+
+      if (unique.length > 0) results[pattern] = unique;
     }
-    return results;
+  }
+
+  return results;
 }
 
-/**
- * Scoring System
- */
+// ─── Leaderboard ──────────────────────────────────────────────────────────────
 let leaderboard = [];
 
 function getWordScore(word) {
-    // Length based scoring
-    return word.length * 10;
+  return word.length * 10;
 }
 
 function recordScore(userName, score) {
-    leaderboard.push({ name: userName, score, date: new Date().toISOString() });
-    leaderboard.sort((a, b) => b.score - a.score);
-    leaderboard = leaderboard.slice(0, 10);
+  leaderboard.push({ name: userName, score, date: new Date().toISOString() });
+  leaderboard.sort((a, b) => b.score - a.score);
+  leaderboard = leaderboard.slice(0, 10);
 }
 
 function getLeaderboard() {
-    return leaderboard;
+  return leaderboard;
 }
 
-module.exports = { solve, getWordScore, recordScore, getLeaderboard };
+module.exports = { solve, charMatch, getWordScore, recordScore, getLeaderboard };