From 9349a97fbcef7e6d43120470b8bb20b71764e228 Mon Sep 17 00:00:00 2001
From: overflowerror <mail@overflowerror.com>
Date: Sat, 17 Aug 2024 00:50:37 +0200
Subject: [PATCH] optimize ts code for minimization

---
 src/main.ts | 71 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 42 insertions(+), 29 deletions(-)

diff --git a/src/main.ts b/src/main.ts
index 63249a7..06244bc 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -13,36 +13,47 @@ const DATA_SUCCESS_CALLBACK = "data-success-callback";
 const DATA_INPUT_SELECTOR = "data-input-selector";
 const DATA_TEXT = "data-text";
 
+const DEFAULT_TEXT = "I am not a robot";
+
+const _document = document; // for optimization
+const classList = "classList"; // for optimization
+const querySelectorAll = "querySelectorAll"; // for optimization
+const createElement = "createElement"; // for optimization
+const getAttribute = "getAttribute"; // for optimization
+
 const findHashWithPrefix = async (algo: string, hashPrefixBits: number, inputPrefix: string): Promise<string> => {
     const hashPrefix = new Uint8Array(Array(Math.ceil(hashPrefixBits / 8)).map(_ => 0));
     let iteration = 0;
+
+    let message: string;
+    let hash: Uint8Array;
     
     do {
-        var message = inputPrefix + (iteration++).toString(36);
-        var hash = await digest(algo, message);
+        message = inputPrefix + (iteration++).toString(36);
+        hash = await digest(algo, message);
     } while (!hash.hasPrefix(hashPrefix, hashPrefixBits));
     
     return message;
 }
 
-function initCaptchaContentAndGetCheckbox(captcha: Element): Element {
+const initCaptchaContentAndGetCheckbox = (captcha: Element): Element => {
+    const checkbox = _document[createElement]("div");
+    const text = _document[createElement]("span");
+
+    checkbox[classList].add(CLASS_CHECKBOX, CLASS_LOADING);
+    text.innerText = captcha[getAttribute](DATA_TEXT) || DEFAULT_TEXT;
+
     captcha.textContent = ""; // clear node
-    const checkbox = document.createElement("div");
-    checkbox.classList.add(CLASS_CHECKBOX, CLASS_LOADING);
-
-    const text = document.createElement("span");
-    text.innerText = captcha.getAttribute(DATA_TEXT) || "I am not a robot";
-
     captcha.append(checkbox, text);
 
     return checkbox;
 }
 
 const toggleChecked = (checkbox: Element) =>
-    checkbox.classList.toggle(CLASS_CHECKED);
+    checkbox[classList].toggle(CLASS_CHECKED);
 
 const toggleLoading = (checkbox: Element) =>
-    checkbox.classList.toggle(CLASS_LOADING);
+    checkbox[classList].toggle(CLASS_LOADING);
 
 const executeChallenge = async (challenge: Challenge, challengeCompletedCallback: (response: string) => void): Promise<void> => {
     challengeCompletedCallback(await findHashWithPrefix(challenge.algo, challenge.prefixBits, challenge.input));
@@ -57,41 +68,43 @@ const prepareInputCaptcha = (captcha: Element, challengeCompletedCallback: (resp
 
     return async (challenge: Challenge) => {
         checkbox.addEventListener("click", async function() {
-            if (this.classList.contains(CLASS_LOADING) || this.classList.contains(CLASS_CHECKED)) {
+            const _this = this; // for optimization
+
+            if (_this[classList].contains(CLASS_LOADING) || _this[classList].contains(CLASS_CHECKED)) {
                 return;
             }
 
-            toggleLoading(this);
+            toggleLoading(_this);
             await executeChallenge(challenge, challengeCompletedCallback);
-            toggleLoading(this);
-            toggleChecked(this);
+            toggleLoading(_this);
+            toggleChecked(_this);
         });
         toggleLoading(checkbox);
     }
 }
 
 const prepareCaptcha = async (captcha: Element) => {
-    const challengeUrl = captcha.getAttribute(DATA_CHALLENGE_URL);
-    const successCallback = captcha.getAttribute(DATA_SUCCESS_CALLBACK);
-    const inputSelector = captcha.getAttribute(DATA_INPUT_SELECTOR);
-
-    if (!challengeUrl) {
-        throw "No challenge URL found.";
-    }
+    const challengeUrl = captcha[getAttribute](DATA_CHALLENGE_URL);
+    const successCallback = captcha[getAttribute](DATA_SUCCESS_CALLBACK);
+    const inputSelector = captcha[getAttribute](DATA_INPUT_SELECTOR);
 
     const setInputValue = (response: string) => {
-        if (inputSelector) [...document.querySelectorAll(inputSelector)].forEach((input: HTMLInputElement) => input.value = response)
+        if (inputSelector) [..._document[querySelectorAll](inputSelector)].forEach((input: HTMLInputElement) => input.value = response)
     }
 
-    // reset form input value
-    setInputValue("");
-
     const challengeCompletesCallback = (response: string) => {
         if (successCallback) [eval][0](successCallback)(response);
         setInputValue(response);
     };
 
-    const initDoneCallback = (captcha.classList.contains(CLASS_SILENT)
+    if (!challengeUrl) {
+        throw "No challenge";
+    }
+
+    // reset form input value
+    setInputValue("");
+
+    const initDoneCallback = (captcha[classList].contains(CLASS_SILENT)
             ? prepareSilentCaptcha
             : prepareInputCaptcha)
         (captcha, challengeCompletesCallback);
@@ -100,14 +113,14 @@ const prepareCaptcha = async (captcha: Element) => {
     const challenge = await challengeResponse.json() as Challenge;
 
     if (!validateChallenge(challenge)) {
-        throw "Challenge is invalid.";
+        throw "Bad challenge";
     }
 
     await initDoneCallback(challenge);
 }
 
 window.addEventListener("load", () =>
-    [...document.getElementsByClassName("captcha")].forEach(prepareCaptcha)
+    [..._document[querySelectorAll](".captcha")].forEach(prepareCaptcha)
 );
 
 declare global {