word-games-theme 2.1.6 → 2.1.8

data/assets/js/wordgames-result.js

@@ -0,0 +1,885 @@
+/***************
+ SCRABBLER_JS
+***************/
+const getScript = document.currentScript;
+let form = document.querySelector("#form");
+let wordCount = document.querySelector(".wordCount");
+let main = document.querySelector(".main");
+// let loader = document.querySelector(".main-loader")
+let errorMsg = document.querySelector(".errorMsg");
+let script = document.currentScript;
+
+// getqueryUrl from form
+const params = new URLSearchParams(window.location.search);
+let serachValue = params.get("search").toLowerCase();
+let prefixValue = params.get("prefix");
+let containsValue = params.get("contains");
+let suffixValue = params.get("suffix");
+let exculdeValue = params.get("exculde");
+let includeValue = params.get("include");
+let lengthValue = params.get("length");
+let dictonary = params.get("dictionary");
+
+// advanced filter element grabs
+let tick;
+let startsWith = document.getElementById("startsWith");
+let mustInclude = document.getElementById("mustInclude");
+console.log(mustInclude);
+let endsWith = document.getElementById("endsWith");
+let exculdeWith = document.getElementById("exculdeWith");
+let inculdeWith = document.getElementById("inculdeWith");
+let wordLength = document.getElementById("wordLength");
+
+
+let ok = true;
+
+let tab_container = document.querySelector(".tab_container");
+let lengthSelect = document.querySelector(".length-select");
+const siteUrl = getScript.dataset.url;
+var sortValue;
+var sortBool = false;
+
+let letterCloseButton = document.querySelector(
+    ".letter-close-button-commonPage"
+);
+if (serachValue) {
+    letterCloseButton.classList.add("ltr-cls-btn-commonPage");
+}
+letterCloseButton.addEventListener("click", () => {
+    txtBox.value = "";
+    letterCloseButton.classList.remove("ltr-cls-btn-commonPage");
+});
+
+let txtBox = document.querySelector(".txtBox");
+txtBox.focus();
+txtBox.value = serachValue;
+
+txtBox.addEventListener("input", (e) => {
+    if (e.target.value === "") {
+        letterCloseButton.classList.remove("ltr-cls-btn-commonPage");
+    } else {
+        letterCloseButton.classList.add("ltr-cls-btn-commonPage");
+    }
+    let rangeOfBlankTile = script.dataset.range;
+    e.target.value = e.target.value.replace(/[^a-zA-Z? ]/g, "");
+    if (rangeOfBlankTile === "") {
+        rangeOfBlankTile = 3;
+    }
+    e.target.value = e.target.value.replace(/ /g, "?");
+    let data = [];
+    data = e.target.value.split("").filter((i) => i === "?");
+    if (data.length > rangeOfBlankTile) {
+        e.target.value = e.target.value.replace(/\?$/, "");
+    }
+});
+
+function mobileScrollTop(x) {
+    if (x.matches) {
+        console.log(x.matches);
+        txtBox.addEventListener("click", () => {
+            document.documentElement.scrollTop = 350;
+            setTimeout(() => {
+                document.documentElement.scrollTop = 350;
+            }, 300);
+        });
+    } else {
+        console.log("false");
+    }
+}
+var x = window.matchMedia("(max-width: 768px)");
+// mobileScrollTop(x);
+// x.addListener(mobileScrollTop);
+
+let rangeOfBlankTile = script.dataset.range;
+let quesMark = "?";
+
+if (rangeOfBlankTile) {
+    if (!serachValue.includes("?")) {
+        serachValue = serachValue + quesMark.repeat(rangeOfBlankTile); //
+        txtBox.value = serachValue;
+    }
+}
+
+const filterInputs = document.querySelectorAll('.filter_val');
+Array.from(filterInputs).forEach((item) => {
+    item.addEventListener("input", (e) => {
+        const inputValue = e.target.value;
+        const parentElement = e.target.parentElement;
+        const imgElement = parentElement.querySelector('img');
+        const tooltipElement = parentElement.querySelector('.filter-tooltip');
+
+        if(inputValue == ""){
+            imgElement.src = "/assets/images/questionmark.svg"
+            item.nextElementSibling.setAttribute("data-tip", item.nextElementSibling.id)
+            tooltipElement.style.setProperty('--tooltip-padding', '0.5rem');
+            tooltipElement.style.setProperty('--tooltip-border-style', 'soild');
+            
+        }else{
+            item.nextElementSibling.removeAttribute("data-tip")
+            imgElement.src = "/assets/images/close-btn.svg"
+            tooltipElement.style.setProperty('--tooltip-padding', '0');
+            tooltipElement.style.setProperty('--tooltip-border-style', 'none');
+        }
+        item.nextElementSibling.addEventListener("click", () => {
+            e.target.value = ""
+            imgElement.src = "/assets/images/questionmark.svg"
+            item.nextElementSibling.setAttribute("data-tip", item.nextElementSibling.id)
+            tooltipElement.style.setProperty('--tooltip-padding', '0.5rem');
+            tooltipElement.style.setProperty('--tooltip-border-style', 'soild');
+        })
+    })
+  })
+
+let theSelect = document.getElementById("select_dropDown");
+
+const sortup = document.querySelector(".sortup-icon");
+let bool = false;
+sortup.addEventListener("click", () => {
+    if (bool) {
+        theSelect.size = 0;
+        bool = false;
+        theSelect.style.display = "none";
+    } else {
+        bool = true;
+        theSelect.size = 3;
+        theSelect.style.display = "block";
+    }
+});
+document.querySelector(".select_dropDown2").value = dictonary;
+const getDiff = (text1, text2) => {
+    var diffRange = [];
+    var currentRange = undefined;
+    for (var i = 0; i < text1.length; i++) {
+        if (text1[i] != text2[i]) {
+            if (currentRange == undefined) {
+                currentRange = [i];
+            }
+        }
+        if (currentRange != undefined && text1[i] == text2[i]) {
+            currentRange.push(i);
+            diffRange.push(currentRange);
+            currentRange = undefined;
+        }
+    }
+    if (currentRange != undefined) {
+        currentRange.push(i);
+        diffRange.push(currentRange);
+    }
+    return diffRange;
+};
+
+// getWords define...
+const getData = async (serachValue) => {
+    try {
+        errorMsg.innerHTML = "";
+        wordCount.innerHTML = "";
+        let selectedDictionary = document.querySelector(".select_dropDown2").value;
+        main.innerHTML = `<div class="loader">
+    <img src='/assets/images/loading.gif'>
+    <div style="font-weight:900;font-size:14px" >Finding words - Powered by ${siteUrl.replace(
+            /^https?:\/\//,
+            ""
+        )}</div>
+    </div>`;
+        /// loader
+        const response = await fetch(
+            `/.netlify/functions/getWords?name=${serachValue}&selecteddictionary=${selectedDictionary}`
+        );
+        const data = await response.json();
+        main.innerHTML = "";
+        getWords(data);
+        //getWords calling...
+    } catch (error) {
+        console.log(error);
+    }
+};
+//getData calling...
+if (lengthValue === "1") {
+    errorMsg.innerHTML = "words length should be more than 1";
+} else {
+    getData(serachValue.toLowerCase());
+    function logSubmit(event) {
+        document.querySelector(".fillterWrapper").classList.add("hide")
+
+
+        const scrollingElement = document.scrollingElement || document.body;
+        scrollingElement.scroll({ top: 0, behavior: "smooth" });
+        if (rangeOfBlankTile) {
+            if (!txtBox.value.includes("?")) {
+                txtBox.value = txtBox.value + quesMark.repeat(rangeOfBlankTile); //
+            }
+        }
+
+        let selectedDictionary = document.querySelector(".select_dropDown2").value;
+        event.preventDefault();
+        if (history.pushState) {
+            var newurl =
+                window.location.protocol +
+                "//" +
+                window.location.host +
+                window.location.pathname +
+                "?" +
+                "search" +
+                "=" +
+                txtBox.value.toLowerCase() +
+                "&" +
+                "dictionary" +
+                "=" +
+                selectedDictionary +
+                "&" +
+                "prefix" +
+                "=" +
+                startsWith.value +
+                "&" +
+                "contains" +
+                "=" +
+                mustInclude.value +
+                "&" +
+                "suffix" +
+                "=" +
+                endsWith.value +
+                "&" +
+                "exculde" +
+                "=" +
+                exculdeWith.value +
+                "&" +
+                "include" +
+                "=" +
+                inculdeWith.value +
+                "&" +
+                "length" +
+                "=" +
+                wordLength.value;
+            window.history.pushState({ path: newurl }, "", newurl);
+
+            const params = new URLSearchParams(window.location.search);
+            serachValue = params.get("search");
+            prefixValue = params.get("prefix");
+            containsValue = params.get("contains");
+            suffixValue = params.get("suffix");
+            exculdeValue = params.get("exculde");
+            includeValue = params.get("include");
+            lengthValue = params.get("length");
+            dictonary = params.get("dictionary");
+
+            gtag("event", "page_view", {
+                page_location: window.location.pathname + location.search,
+            });
+        }
+        getData(txtBox.value.toLowerCase());
+        // addFilterCount();
+    }
+
+    let selectedDictionary = document.querySelector(".select_dropDown2");
+    selectedDictionary.addEventListener("change", (e) => {
+        logSubmit(e);
+    });
+    // applyBtn.addEventListener("submit", logSubmit);
+    form.addEventListener("submit", logSubmit);
+}
+
+// getWords function define...
+function getWords(data) {
+    main.innerHTML = "";
+    tab_container.innerHTML = "";
+    if (typeof data === "string") {
+        errorMsg.innerHTML = "no words found";
+        wordCount.innerHTML = `<strong>Found 0 words with letters ${serachValue.split(
+            ""
+        )}</strong>`;
+    } else {
+        let newWordsLength = 0;
+        let dataArr = [];
+        for (let i = serachValue.length; i >= 1; i--) {
+            let newdata = data.filter((item) => item.length === i);
+            if (prefixValue) {
+                newdata = newdata.filter((item2) =>
+                    item2.startsWith(prefixValue.toLowerCase())
+                );
+                startsWith.nextElementSibling.querySelector("img").src = "/assets/images/close-btn.svg"
+                startsWith.classList.add("tick");
+                startsWith.value = prefixValue;
+            } else {
+                startsWith.classList.remove("tick");
+            }
+            if (containsValue) {
+                newdata = newdata.filter((item) =>
+                    item.includes(containsValue.toLowerCase())
+                );
+                mustInclude.classList.add("tick");
+                mustInclude.value = containsValue;
+            } else {
+                mustInclude.classList.remove("tick");
+            }
+            if (suffixValue) {
+                newdata = newdata.filter((item) =>
+                    item.endsWith(suffixValue.toLowerCase())
+                );
+                endsWith.classList.add("tick");
+                endsWith.value = suffixValue;
+            } else {
+                endsWith.classList.remove("tick");
+            }
+            if (exculdeValue) {
+                let data = [];
+                newdata.map((item) => {
+                    let check = false;
+                    for (let e = 0; e < exculdeValue.length; e++) {
+                        const element = exculdeValue[e].toLowerCase();
+                        if (item.includes(element)) {
+                            check = true;
+                            break;
+                        } else {
+                            check = false;
+                        }
+                    }
+                    if (check === false) {
+                        data.push(item);
+                    }
+                });
+                exculdeWith.classList.add("tick");
+                exculdeWith.value = exculdeValue;
+                newdata = data;
+            } else {
+                exculdeWith.classList.remove("tick");
+            }
+            if (includeValue) {
+                let data = [];
+                newdata.map((item) => {
+                    let check = false;
+                    for (let e = 0; e < includeValue.length; e++) {
+                        const element = includeValue[e].toLowerCase();
+                        if (!item.includes(element)) {
+                            check = true;
+                            break;
+                        } else {
+                            check = false;
+                        }
+                    }
+                    if (check === false) {
+                        data.push(item);
+                    }
+                });
+                inculdeWith.classList.add("tick");
+                inculdeWith.value = includeValue;
+                newdata = data;
+            } else {
+                inculdeWith.classList.remove("tick");
+            }
+            if (lengthValue) {
+                newdata = newdata.filter((item) => item.length == lengthValue);
+                wordLength.classList.add("tick");
+                wordLength.value = lengthValue;
+            } else {
+                wordLength.classList.remove("tick");
+            }
+            if (newdata.length === 0) {
+                main.innerHTML += "";
+            } else {
+                newWordsLength += newdata.length;
+                const result = newdata.map((item) => {
+                    var text1 = serachValue.replace("?", "");
+                    var text2 = item;
+                    var text3 = item;
+                    let chars = text1.split("");
+
+                    let indexs = [];
+                    chars.map((i) => {
+                        let findIndexes = findIndex(text3, i);
+                        if (findIndexes.length > 0) {
+                            text3 = text3.split("");
+                            text3[findIndexes] = "$";
+                            text3 = text3.join("");
+
+                            indexs = [...indexs, ...findIndexes];
+                        }
+                    });
+                    let itemHtml = "";
+                    text2.split("").map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index);
+
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`;
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`;
+                        }
+                    });
+
+                    if (item.length === 1) {
+                        ok = false;
+                        newWordsLength = newWordsLength - 1;
+                    } else {
+                        let ScrabbleLetterScore = ScrabbleScore();
+                        sum = 0;
+                        item = item.toLowerCase();
+                        for (let i = 0; i < item.length; i++) {
+                            sum += ScrabbleLetterScore[item[i]] || 0; // for unknown characters
+                        }
+                        dataArr.push(item);
+                        return `<a class="anchor__style" title="Lookup ${item} in Dictionary" target="_blank" href="/word-meaning?search=${item.toLowerCase()}">
+            <li>${itemHtml}
+          <span class="points" value="${sum}" style="position:relative; top:4px; font-size:12px"> ${sum}</span>
+            </li></a>`;
+                    }
+                });
+
+                if (result[0] !== undefined) {
+                    var option = document.createElement("option");
+                    option.text = `${i} Letter`;
+                    option.value = i;
+                    lengthSelect.setAttribute("onchange",`Filtering(${i})`)
+                    lengthSelect.add(option);
+
+        //             tab_container.innerHTML += `
+        //   <input type="button" id="Tab_${i}" onclick="Filtering(${i})" value="${i} Letter"
+        //   class="tab_link  cursorPointer" />
+        //   `;
+        //             let tabs = document.getElementsByClassName("tab_link");
+        //             tabs[0] ? tabs[0].classList.add("active-tab") : "";
+                    main.innerHTML += `
+          <div class="allGroupWords wordlistContainer" id="alpha_${i}">
+              <div class="wordListHeading">
+                  <h3 class="lead">${i} Letter Words</h3>
+              </div>
+              <div class="wordList">
+                  <ul class="ul list-unstyled">
+                   ${result.join("")}
+                  </ul>
+              </div>
+          </div>
+          `;
+                }
+            }
+        }
+        theSelect.addEventListener("change", () => {
+            sortValue = theSelect[theSelect.selectedIndex].text;
+            if (sortValue == "Z-A") {
+                sortBool = true;
+                sortby(sortBool, dataArr);
+            } else {
+                sortBool = false;
+                sortby(sortBool, dataArr);
+            }
+            if (sortValue == "Points") {
+                sortBool = true;
+                sortPointsby(sortBool, dataArr);
+            }
+        });
+        sortValue = theSelect[theSelect.selectedIndex].text;
+        if (sortValue == "Z-A") {
+            sortby(sortBool, dataArr);
+        }
+        if (sortValue == "Points") {
+            sortPointsby(sortBool, dataArr);
+        }
+        if (newWordsLength === 0) {
+            errorMsg.innerHTML = "no words found";
+        } else {
+            wordCount.innerHTML = `<strong>Found ${newWordsLength} words with letters with ${serachValue.split(
+                ""
+            )}</strong>`;
+        }
+    }
+}
+
+// sorting by points
+function sortPointsby(sortValue, data) {
+    main.innerHTML = "";
+    if (sortValue) {
+        let newWordsLength = 0;
+        for (let i = serachValue.length; i >= 1; i--) {
+            var newdata = data.filter((item) => item.length === i);
+            if (newdata.length === 0) {
+                main.innerHTML += "";
+            } else {
+                newWordsLength += newdata.length;
+                var newArray = [];
+                newdata.map((item) => {
+                    if (item.length === 1) {
+                        ok = false;
+                        newWordsLength = newWordsLength - 1;
+                    } else {
+                        let ScrabbleLetterScore = ScrabbleScore();
+                        let points = 0;
+                        item = item.toLowerCase();
+                        for (let i = 0; i < item.length; i++) {
+                            points += ScrabbleLetterScore[item[i]] || 0; // for unknown characters
+                        }
+                        const value = {
+                            words: item,
+                            points: points,
+                        };
+                        newArray.push(value);
+                    }
+                });
+
+                newArray.sort(function (a, b) {
+                    return b.points - a.points;
+                });
+                const result = newArray.map((item) => {
+                    var text1 = serachValue.replace("?", "");
+                    var text2 = item.words;
+                    var text3 = item.words;
+                    function findIndex(str, char) {
+                        const strLength = str.length;
+                        const indexes = [];
+                        let newStr = str;
+                        while (newStr && newStr.indexOf(char) > -1) {
+                            indexes.push(newStr.indexOf(char) + strLength - newStr.length);
+                            newStr = newStr.substring(newStr.indexOf(char) + 1);
+                            newStr = newStr.substring(newStr.indexOf(char) + 1);
+                        }
+                        return indexes;
+                    }
+                    let chars = text1.split("");
+                    let indexs = [];
+                    chars.map((i) => {
+                        let findIndexes = findIndex(text3, i);
+                        if (findIndexes.length > 0) {
+                            text3 = text3.split("");
+                            text3[findIndexes] = "$";
+                            text3 = text3.join("");
+                            indexs = [...indexs, ...findIndexes];
+                        }
+                    });
+                    let itemHtml = "";
+                    text2.split("").map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index);
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`;
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`;
+                        }
+                    });
+                    return `<a class="anchor__style" title="Lookup ${item} in Dictionary" target="_blank" href="/word-meaning?search=${item.words}">
+          <li>${itemHtml}
+        <span class="points" value="${item.points}" style="position:relative; top:4px; font-size:12px"> ${item.points}</span>
+          </li></a>`;
+                });
+
+                main.innerHTML += `
+        <div class="allGroupWords wordlistContainer" id="alpha_${i}">
+            <div class="wordListHeading">
+                <h3 class="lead">${i} Letter Words</h3>
+            </div>
+            <div class="wordList">
+                <ul class="ul list-unstyled">
+                 ${result.join("")}
+                </ul>
+            </div>
+        </div>
+        `;
+            }
+        }
+    }
+}
+// sort by aplhabets
+function sortby(sortBool, data) {
+    if (sortBool) {
+        main.innerHTML = "";
+        data.reverse();
+        let newWordsLength = 0;
+        for (let i = serachValue.length; i >= 1; i--) {
+            var newdata = data.filter((item) => item.length === i);
+
+            if (newdata.length === 0) {
+                main.innerHTML += "";
+            } else {
+                newWordsLength += newdata.length;
+
+                const result = newdata.map((item) => {
+                    var text1 = serachValue.replace("?", "");
+                    var text2 = item;
+                    var text3 = item;
+                    let chars = text1.split("");
+                    let indexs = [];
+                    chars.map((i) => {
+                        let findIndexes = findIndex(text3, i);
+                        if (findIndexes.length > 0) {
+                            text3 = text3.split("");
+                            text3[findIndexes] = "$";
+                            text3 = text3.join("");
+                            indexs = [...indexs, ...findIndexes];
+                        }
+                    });
+                    let itemHtml = "";
+                    text2.split("").map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index);
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`;
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`;
+                        }
+                    });
+                    if (item.length === 1) {
+                        ok = false;
+                        newWordsLength = newWordsLength - 1;
+                    } else {
+                        let ScrabbleLetterScore = ScrabbleScore();
+                        let sum = 0;
+                        item = item.toLowerCase();
+                        for (let i = 0; i < item.length; i++) {
+                            sum += ScrabbleLetterScore[item[i]] || 0; // for unknown characters
+                        }
+
+                        return `<a class="anchor__style" title="Lookup ${item} in Dictionary" target="_blank" href="/word-meaning?search=${item.toLowerCase()}">
+            <li>${itemHtml}
+        <span class="points" value="${sum}" style="position:relative; top:4px; font-size:12px"> ${sum}</span>
+          </li></a>`;
+                    }
+                });
+
+                main.innerHTML += `
+        <div class="allGroupWords wordlistContainer" id="alpha_${i}">
+            <div class="wordListHeading">
+                <h3 class="lead">${i} Letter Words</h3>
+            </div>
+            <div class="wordList">
+                <ul class="ul list-unstyled">
+                 ${result.join("")}
+                </ul>
+            </div>
+        </div>
+        `;
+            }
+        }
+    } else {
+        main.innerHTML = "";
+        data.sort();
+        for (let i = serachValue.length; i >= 1; i--) {
+            var newdata = data.filter((item) => item.length === i);
+            if (newdata.length === 0) {
+                main.innerHTML += "";
+            } else {
+                const result = newdata.map((item) => {
+                    var text1 = serachValue.replace("?", "");
+                    var text2 = item;
+                    var text3 = item;
+                    let chars = text1.split("");
+                    let indexs = [];
+                    chars.map((i) => {
+                        let findIndexes = findIndex(text3, i);
+                        if (findIndexes.length > 0) {
+                            text3 = text3.split("");
+                            text3[findIndexes] = "$";
+                            text3 = text3.join("");
+                            indexs = [...indexs, ...findIndexes];
+                        }
+                    });
+                    let itemHtml = "";
+                    text2.split("").map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index);
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`;
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`;
+                        }
+                    });
+                    if (item.length === 1) {
+                        ok = false;
+                    } else {
+                        let ScrabbleLetterScore = ScrabbleScore();
+                        let sum = 0;
+                        item = item.toLowerCase();
+                        for (let i = 0; i < item.length; i++) {
+                            sum += ScrabbleLetterScore[item[i]] || 0; // for unknown characters
+                        }
+
+                        return `<a class="anchor__style" title="Lookup ${item} in Dictionary" target="_blank" href="/word-meaning?search=${item.toLowerCase()}">
+            <li>${itemHtml}
+        <span class="points" value="${sum}" style="position:relative; top:4px; font-size:12px"> ${sum}</span>
+          </li></a>`;
+                    }
+                });
+                main.innerHTML += `
+        <div class="allGroupWords wordlistContainer" id="alpha_${i}">
+            <div class="wordListHeading">
+                <h3 class="lead">${i} Letter Words</h3>
+            </div>
+            <div class="wordList">
+                <ul class="ul list-unstyled">
+                 ${result.join("")}
+                </ul>
+            </div>
+        </div>
+        `;
+            }
+        }
+    }
+}
+
+// Scrabble Point Array
+const ScrabbleScore = () => {
+    let twl06_sowpods = {
+        a: 1,
+        e: 1,
+        i: 1,
+        o: 1,
+        u: 1,
+        l: 1,
+        n: 1,
+        r: 1,
+        s: 1,
+        t: 1,
+        d: 2,
+        g: 2,
+        b: 3,
+        c: 3,
+        m: 3,
+        p: 3,
+        f: 4,
+        h: 4,
+        v: 4,
+        w: 4,
+        y: 4,
+        k: 5,
+        j: 8,
+        x: 8,
+        q: 10,
+        z: 10,
+    };
+
+    let wwfScore = {
+        a: 1,
+        b: 4,
+        c: 4,
+        d: 2,
+        e: 1,
+        f: 4,
+        g: 3,
+        h: 3,
+        i: 1,
+        j: 10,
+        k: 5,
+        l: 2,
+        m: 4,
+        n: 2,
+        o: 1,
+        p: 4,
+        q: 10,
+        r: 1,
+        s: 1,
+        t: 1,
+        u: 2,
+        v: 5,
+        w: 4,
+        x: 8,
+        y: 3,
+        z: 10,
+    };
+
+    if (dictonary === "wwf") {
+        return wwfScore;
+    } else {
+        return twl06_sowpods;
+    }
+};
+
+// handling of filter on scroll
+window.onscroll = function () {
+    var section = document.querySelectorAll(".wordlistContainer");
+    let new_sections = {};
+    Array.prototype.forEach.call(section, function (e) {
+        if (document.body.clientWidth > 991) {
+            new_sections[e.id] = e.offsetTop - 10;
+        } else {
+            new_sections[e.id] = e.offsetTop - 10;
+        }
+    });
+    var scrollPosition =
+        document.documentElement.scrollTop || document.body.scrollTop;
+    for (i in new_sections) {
+        let sort_val = document.querySelector(".sort-select").value;
+        if (
+            i.split("_")[0] == sort_val &&
+            new_sections[i] &&
+            new_sections[i] <= scrollPosition
+        ) {
+            // document.querySelector(".active-tab").classList.remove("active-tab");
+            // var active_now = document.querySelector("#Tab_" + i.split("_")[1]);
+            // active_now.classList.add("active-tab");
+            // active_now.scrollIntoView({ block: "nearest" });
+        }
+    }
+};
+
+// Add Filtering
+let sections = {};
+function Filtering(id) {
+    id = lengthSelect.value
+
+    let tabs = document.getElementsByClassName("tab_link");
+    tabs[0] ? tabs[0].classList.add("active-tab") : "";
+
+    Array.from(tabs).map((item) => {
+        item.classList.remove("active-tab");
+    });
+    main.innerHTML += ``;
+    let activeLetter = event.target;
+    activeLetter.classList.add("active-tab");
+
+    var section = document.querySelectorAll(".allGroupWords");
+    var sort_val = "alpha";
+    Array.prototype.forEach.call(section, function (e) {
+        if (document.body.clientWidth > 991) {
+            sections[e.id] = e.offsetTop - 10;
+        } else {
+            sections[e.id] = e.offsetTop - 10;
+        }
+    });
+    document.documentElement.scrollTop = sections[sort_val + "_" + id] + 5;
+
+    setTimeout(() => {
+        document.documentElement.scrollTop = sections[sort_val + "_" + id] + 5;
+    }, 150);
+}
+
+// next && previous functionality
+let prev = document.getElementById("prev");
+let next = document.getElementById("next");
+
+if (prev) {
+    prev.onclick = scroll_Right;
+}
+if (next) {
+    next.onclick = scroll_Left;
+}
+window.addEventListener("resize", function () {
+    scroll_visible();
+});
+window.addEventListener("scroll", function () {
+    scroll_visible();
+});
+function scroll_visible() {
+    let tab_container = document.querySelector("#tab-container");
+    if (tab_container) {
+        if (tab_container.clientWidth === tab_container.scrollWidth) {
+            prev.style.display = "none";
+            next.style.display = "none";
+        } else {
+            prev.style.display = "block";
+            next.style.display = "block";
+        }
+    }
+}
+scroll_visible();
+
+function scroll_Left() {
+    tab_container.scrollLeft += 130;
+}
+function scroll_Right() {
+    tab_container.scrollLeft -= 130;
+}
+function findIndex(str, char) {
+    const strLength = str.length;
+    const indexes = [];
+    let newStr = str;
+
+    while (newStr && newStr.indexOf(char) > -1) {
+        indexes.push(newStr.indexOf(char) + strLength - newStr.length);
+        newStr = newStr.substring(newStr.indexOf(char) + 5);
+        newStr = newStr.substring(newStr.indexOf(char) + 5);
+    }
+
+    return indexes;
+}