Update endpoints/antibot.js

endpoints/antibot.js

@@ -1,89 +1,112 @@
-const Tesseract = require('tesseract.js');
-const { Jimp } = require('jimp');
-const fs = require('fs');
+const Tesseract = require("tesseract.js");
+const fs = require("fs");
+const path = require("path");
+
+async function loadJimp() {
+  const jimp = await import("jimp");
+  return jimp.default;
+}
 
 function buf(b64) {
-  if (!b64) return null;
-  if (b64.startsWith("data:image")) b64 = b64.replace(/^data:image\/\w+;base64,/, "");
-  return Buffer.from(b64, "base64");
+  return Buffer.from(b64.replace(/^data:image\/\w+;base64,/, ""), "base64");
 }
 
-function levenshtein(a, b) {
-  const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
-    Array(b.length + 1).fill(0)
-  );
-  for (let i = 0; i <= a.length; i++) matrix[i][0] = i;
-  for (let j = 0; j <= b.length; j++) matrix[0][j] = j;
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(
-        matrix[i - 1][j] + 1,
-        matrix[i][j - 1] + 1,
-        matrix[i - 1][j - 1] + cost
-      );
-    }
+const SMALL = {
+  zero:0, one:1, two:2, three:3, four:4,
+  five:5, six:6, seven:7, eight:8, nine:9,
+  ten:10, eleven:11, twelve:12, thirteen:13, fourteen:14,
+  fifteen:15, sixteen:16, seventeen:17, eighteen:18, nineteen:19
+};
+
+const TENS = {
+  twenty:20, thirty:30, forty:40, fifty:50,
+  sixty:60, seventy:70, eighty:80, ninety:90
+};
+
+function wordsToNumber(words) {
+  let total = 0, current = 0;
+  for (let w of words) {
+    if (SMALL[w] !== undefined) current += SMALL[w];
+    else if (TENS[w] !== undefined) current += TENS[w];
+    else if (w === "hundred") current *= 100;
+    else if (w === "thousand") { total += current * 1000; current = 0; }
+    else if (w === "million") { total += current * 1000000; current = 0; }
   }
-  return matrix[a.length][b.length];
+  return total + current;
 }
 
-function similarity(a, b) {
-  a = a.toLowerCase();
-  b = b.toLowerCase();
-  const distance = levenshtein(a, b);
-  return 1 - distance / Math.max(a.length, b.length);
+function solveMath(tokens) {
+  const expr = tokens.join(" ")
+    .replace(/x/g, "*")
+    .replace(/times/g, "*")
+    .replace(/plus/g, "+")
+    .replace(/minus/g, "-")
+    .replace(/divide/g, "/")
+    .replace(/divided/g, "/");
+
+  try { return Function("return " + expr)(); }
+  catch { return null; }
 }
 
-async function readTextFromImageBase64(b64) {
-  const buffer = buf(b64);
-  const image = await Jimp.read(buffer);
-  image
-    .greyscale()
-    .contrast(0.5)
-    .normalize()
-    .resize({ w: 400 });
+function normalizeWords(t) {
+  return t.replace(/[^a-z0-9 ]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .split(" ")
+    .filter(Boolean);
+}
 
-  const tempFile = `./temp_${Date.now()}.png`;
-  await image.write(tempFile);
+function convertSmart(tokens) {
+  if (tokens.every(x => /^[0-9]+$/.test(x)))
+    return parseInt(tokens.join(""));
 
-  const result = await Tesseract.recognize(tempFile, 'eng', {
-    logger: m => {}
-  });
+  if (tokens.every(x =>
+    SMALL[x] !== undefined ||
+    TENS[x] !== undefined ||
+    x === "hundred" ||
+    x === "thousand" ||
+    x === "million"
+  )) return wordsToNumber(tokens);
 
-  const text = result.data.text
-    .replace(/\n/g, ' ')
-    .replace(/[^a-zA-Z0-9 ]/g, '')
-    .trim()
-    .toLowerCase();
+  return solveMath(tokens);
+}
+
+async function readTextFromBase64(b64) {
+  const Jimp = await loadJimp();
+  const img = await Jimp.read(buf(b64));
+
+  img.greyscale().contrast(0.7).normalize().resize(500, Jimp.AUTO);
+
+  const tmp = path.join(__dirname, "tmp_" + Date.now() + ".png");
+  await img.write(tmp);
 
-  fs.unlinkSync(tempFile);
-  return text;
+  const res = await Tesseract.recognize(tmp, "eng", { logger: () => {} });
+  fs.unlinkSync(tmp);
+
+  return res.data.text.toLowerCase().replace(/[^a-z0-9 ]/g, " ").trim();
 }
 
 module.exports = async function (data) {
-  const mainText = await readTextFromImageBase64(data.main || "");
-  const mainWords = mainText.split(' ').filter(Boolean);
+  const mainText = await readTextFromBase64(data.main);
+  const tokens = normalizeWords(mainText);
+  const orderVal = convertSmart(tokens);
+
+  let orderNumbers = [];
+  if (typeof orderVal === "number" && !Number.isNaN(orderVal))
+    orderNumbers = [orderVal];
 
   const botResults = [];
-  for (let i = 0; i < (data.bots || []).length; i++) {
-    const bot = data.bots[i];
-    const text = await readTextFromImageBase64(bot.img || "");
-    botResults.push({ id: bot.id, text });
+  for (let b of data.bots) {
+    const raw = await readTextFromBase64(b.img);
+    const t = normalizeWords(raw);
+    const val = convertSmart(t);
+    botResults.push({ id: b.id, number: Number.isNaN(val) ? null : val });
   }
 
-  const order = [];
-  for (const word of mainWords) {
-    let bestMatch = { id: null, score: 0 };
-    for (const bot of botResults) {
-      const score = similarity(word, bot.text);
-      if (score > bestMatch.score) bestMatch = { id: bot.id, score };
-    }
-    order.push(bestMatch.score > 0.5 ? bestMatch.id : null);
-  }
+  const finalOrder = orderNumbers.map(n => {
+    const f = botResults.find(x => x.number === n);
+    return f ? f.id : null;
+  });
 
-  return { 
-    soal: mainWords, 
-    botResults, 
-    order: order.filter(id => id !== null)
-  };
+  return { tokens, orderNumbers, botResults, result: finalOrder };
 };