Original dockerfile With wget V2

Dockerfile

@@ -1,4 +1,78 @@
-FROM openspeedtest/latest
+# By OpenSpeedTest
+# Dockerfile for https://hub.docker.com/r/openspeedtest/latest
+FROM nginxinc/nginx-unprivileged:stable-alpine
 
+LABEL maintainer "OpenSpeedTest.com <support@OpenSpeedTest.com>"
 
-CMD ["/entrypoint.sh"]
+ENV ENABLE_LETSENCRYPT=false
+ENV DOMAIN_NAME=false
+ENV USER_EMAIL=false
+ENV CONFIG=/etc/nginx/conf.d/OpenSpeedTest-Server.conf
+ENV INDEX_HTML=/usr/share/nginx/html/index.html
+
+ENV CHANGE_CONTAINER_PORTS=false
+ENV HTTP_PORT=3000
+ENV HTTPS_PORT=3001
+ENV SET_USER=101
+
+COPY /files/OpenSpeedTest-Server.conf ${CONFIG}
+COPY /files/entrypoint.sh /entrypoint.sh
+COPY /files/renew.sh /renew.sh
+RUN rm /etc/nginx/nginx.conf
+COPY /files/nginx.conf /etc/nginx/
+COPY /files/www/ /usr/share/nginx/html/
+RUN wget https://github.com/openspeedtest/Docker-Image/raw/main/files/www/downloading -O /usr/share/nginx/html/downloading
+COPY /files/nginx.crt /etc/ssl/
+COPY /files/nginx.key /etc/ssl/
+
+
+
+USER root
+VOLUME /var/log/letsencrypt
+RUN rm -rf /etc/nginx/conf.d/default.conf \
+	&& chown -R nginx /usr/share/nginx/html/ \
+	&& chmod 755 /usr/share/nginx/html/downloading \
+	&& chmod 755 /usr/share/nginx/html/upload \
+	&& chown nginx ${CONFIG} \
+	&& chmod 400 ${CONFIG} \
+	&& chown nginx /etc/nginx/nginx.conf \
+	&& chmod 400 /etc/nginx/nginx.conf \
+	&& chmod +x /entrypoint.sh \
+	&& chmod +x /renew.sh
+
+
+
+RUN mkdir -p /etc/letsencrypt && \
+    chown -R nginx /etc/letsencrypt && \
+    chmod 775 /etc/letsencrypt
+
+RUN mkdir -p /var/lib/letsencrypt && \
+    chown -R nginx /var/lib/letsencrypt && \
+    chmod 775 /var/lib/letsencrypt
+
+RUN mkdir -p /var/log/letsencrypt && \
+    chown -R nginx /var/log/letsencrypt && \
+    chmod 775 /var/log/letsencrypt
+
+RUN mkdir -p /usr/share/nginx/html/.well-known/acme-challenge && \
+    chown -R nginx /usr/share/nginx/html/.well-known/acme-challenge && \
+    chmod 775 /usr/share/nginx/html/.well-known/acme-challenge
+ 
+RUN apk update && apk add ca-certificates && rm -rf /var/cache/apk/* 
+RUN update-ca-certificates
+RUN apk add --no-cache certbot certbot-nginx
+RUN apk update && apk add --no-cache dcron libcap
+
+RUN chown nginx:nginx /usr/sbin/crond \
+    && setcap cap_setgid=ep /usr/sbin/crond
+
+RUN touch /etc/crontabs/nginx
+RUN chown -R nginx:nginx /etc/crontabs/nginx
+
+USER ${SET_USER}
+
+EXPOSE ${HTTP_PORT} ${HTTPS_PORT}
+
+STOPSIGNAL SIGQUIT
+
+CMD ["/entrypoint.sh"]

files/OpenSpeedTest-Server.conf

@@ -0,0 +1,106 @@
+# SpeedTest by OpenSpeedTest™ is a Free and Open-Source Network Speed Test Software.
+# Like this Project? Please Donate NOW & Keep us Alive -> https://go.openspeedtest.com/Donate
+# Thank you for your support! we greatly appreciate your donation.
+# Your contribution helps us continue to improve and maintain the tool for everyone to use. 
+# Official Website : https://OpenSpeedTest.com | Email: support@openspeedtest.com
+# Developed by : Vishnu | https://Vishnu.Pro | Email : me@vishnu.pro 
+
+server {
+        server_name _ localhost YOURDOMAIN;
+        listen 3000 reuseport;
+        listen 3001 ssl reuseport; 
+        listen [::]:3000 reuseport;
+        listen [::]:3001 ssl reuseport;
+        # If you like to Enable HTTP2 add "http2" to the above line.
+        # If HTTP2 Enabled. Upload location should Proxy_Pass to http 1.1 port.
+        # Otherwise you will see abnormal Upload Speeds.
+        # Nginx Server Windows SSL Performance was very poor! Better use Linux if you need SSL support.
+        ssl_certificate /etc/ssl/nginx.crt; # Use your own certificate & key
+        ssl_certificate_key /etc/ssl/nginx.key; # <-- key
+        ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
+	ssl_ciphers "ALL";
+        ssl_prefer_server_ciphers on;
+	ssl_session_cache shared:SSL:100m;
+	ssl_session_timeout 1d;
+	ssl_session_tickets on;
+        root /usr/share/nginx/html/;
+        index index.html;
+        client_max_body_size 35m;
+        error_page 405 =200 $uri;
+        access_log off;
+        gzip off; 
+        fastcgi_read_timeout 999;
+        log_not_found off;
+        server_tokens off;
+        error_log /dev/null; #Disable this for Windows Nginx.
+        tcp_nodelay on;
+        tcp_nopush on;
+        sendfile on;
+        open_file_cache max=200000 inactive=20s;
+        open_file_cache_valid 30s;
+        open_file_cache_min_uses 2;
+        open_file_cache_errors off;
+        
+        location ~ /\.well-known/acme-challenge/ {
+            allow all;
+            default_type "text/plain";
+            root /usr/share/nginx/html/;
+            try_files $uri =404;
+            break;
+        }
+
+        location / {            
+            add_header 'Access-Control-Allow-Origin' "*" always;
+            add_header 'Access-Control-Allow-Headers' 'Accept,Authorization,Cache-Control,Content-Type,DNT,If-Modified-Since,Keep-Alive,Origin,User-Agent,X-Mx-ReqToken,X-Requested-With' always;
+            add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS' always;
+            #Very Very Important! You SHOULD send no-store from server for Google Chrome.
+            add_header Cache-Control 'no-store, no-cache, max-age=0, no-transform';
+            add_header Last-Modified $date_gmt;
+            if_modified_since off;
+            expires off;
+            etag off;
+
+            if ($request_method = OPTIONS ) {
+                add_header 'Access-Control-Allow-Credentials' "true";
+                add_header 'Access-Control-Allow-Headers' 'Accept,Authorization,Cache-Control,Content-Type,DNT,If-Modified-Since,Keep-Alive,Origin,User-Agent,X-Mx-ReqToken,X-Requested-With' always;
+                add_header 'Access-Control-Allow-Origin' "$http_origin" always;        
+                add_header 'Access-Control-Allow-Methods' "GET, POST, OPTIONS" always;
+                return 200;
+            }
+        }
+
+       #HTTP2 & HTTP3 will not wait for the post body and return 200. We need to stop that behaviour.
+       #Otherwise, you will see abnormal upload speed. To fix this issue, Enable the following lines. (Only Applicable If you Enabled HTTP2 or HTTP3 in This Server.)
+        
+       #HTTP2 & HTTP3 -> UPLOAD FIX -- START
+
+       #location = /upload {
+       #    proxy_pass http://127.0.0.1:3000/dev-null;
+       #}
+       #location = /dev-null {
+       #    return 200;
+       #}
+
+       #HTTP2 & HTTP3 -> UPLOAD FIX -- END
+           
+      # Caching for Static Files,
+      location ~* ^.+\.(?:css|cur|js|jpe?g|gif|htc|ico|png|html|xml|otf|ttf|eot|woff|woff2|svg)$ {
+          access_log off;
+          expires 365d;
+          add_header Cache-Control public;
+          add_header Vary Accept-Encoding;
+          tcp_nodelay off;
+          open_file_cache max=3000 inactive=120s;
+          open_file_cache_valid 45s;
+          open_file_cache_min_uses 2;
+          open_file_cache_errors off;
+          gzip on; 
+          gzip_disable "msie6";
+          gzip_vary on;
+          gzip_proxied any;
+          gzip_comp_level 6;
+          gzip_buffers 16 8k;
+          gzip_http_version 1.1;
+          gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript application/javascript image/svg+xml;
+      }
+}

files/entrypoint.sh

@@ -0,0 +1,152 @@
+#!/bin/sh
+
+ip a | egrep -q 'inet6 '
+if [[ $? -ne 0 ]]; then
+  # IPv6 not enabled
+  sed -i '/listen \[::\]:300/d' ${CONFIG}
+fi
+
+ip a | egrep -q 'inet '
+if [[ $? -ne 0 ]]; then
+  # IPv4 not enabled
+  sed -i '/listen 300/d' ${CONFIG}
+fi
+
+
+if [ "$CHANGE_CONTAINER_PORTS" = True ]; then
+    if [ "$HTTP_PORT" ]; then
+        sed -i "s/3000/${HTTP_PORT}/g" ${CONFIG}
+        if [ $? -eq 0 ]; then
+        echo "Changed HTTP container port to " ${HTTP_PORT}
+        else
+        echo "Failed to change HTTP container port to " ${HTTP_PORT}
+        fi        
+         
+    fi
+
+    if [ "$HTTPS_PORT" ]; then
+        sed -i "s/3001/${HTTPS_PORT}/g" ${CONFIG}
+        if [ $? -eq 0 ]; then
+        echo "Changed HTTPS container port to " ${HTTPS_PORT}
+        else
+        echo "Failed to change HTTPS container port to " ${HTTPS_PORT}
+        fi    
+
+    fi
+fi
+
+
+Verify_TXT_path="/usr/share/nginx/html/Verify.txt"
+
+if [ "$VERIFY_OWNERSHIP" ]; then
+      if [ -f "$Verify_TXT_path" ]; then
+      echo "Verify.txt Found!"
+      else
+      echo ${VERIFY_OWNERSHIP} > /usr/share/nginx/html/Verify.txt
+      echo "Verify.txt Created!"
+      fi
+fi
+
+if [ "$SET_SERVER_NAME" ]; then
+      SERVER_NAME='<h1 style="display: inline;color: #7c888d; font-size: 22px;font-family: Roboto-Medium, Roboto;font-weight: 500;">'${SET_SERVER_NAME}'</h1>'
+      if ! grep -q "$SERVER_NAME" "$INDEX_HTML"; then
+      sed -i -e '/<body>/a\'$'\n'"$SERVER_NAME" ${INDEX_HTML}
+      fi
+fi
+
+if [ "$ALLOW_ONLY" ]; then
+
+allow_only=${ALLOW_ONLY}
+
+IFS=';' domains=$(echo "$allow_only" | tr ';' '\n')
+
+map_config="map \$http_origin \$allowed_origin {
+    default 0;
+"
+while IFS= read -r line; do
+    escaped_domain=$(echo "$line" | sed 's/\./\\./g')
+    map_config="$map_config    \"~^https?://(www\.)?($escaped_domain)\$\" 1;
+"
+done < <(printf '%s\n' "$domains")
+
+map_config="$map_config}"
+
+nginx_conf_path="/etc/nginx/nginx.conf"
+pattern="map \$http_origin \$allowed_origin {"
+nginx_block="if (\$allowed_origin = 0) { return 444; }"
+
+if grep -q "$pattern" "$nginx_conf_path"; then
+    echo "Map config found! nginx.conf not modified"
+else
+    while IFS= read -r line; do
+sed -i '/^\s*http\s*{/ {
+    :a;
+    N;
+    /\s*}\s*$/!ba;
+    s|\(}\)|'"$line"'\n\1|
+}' "$nginx_conf_path"
+    done < <(printf '%s\n' "$map_config")
+        if [ $? -eq 0 ]; then
+    echo "Map config added to nginx.conf"
+            if grep -q "$nginx_block" "$CONFIG"; then
+            echo "Block Config found! OpenSpeedTest-Server.conf not modified"
+            else
+            echo "Adding Block Config to OpenSpeedTest-Server.conf"
+                    sed -i '/location \/ {/ {
+                        a\
+                '"$nginx_block"'
+                    }' "$CONFIG"
+
+                    sed -i '/location ~\* \^.+\\.(?:css|cur|js|jpe?g|gif|htc|ico|png|html|xml|otf|ttf|eot|woff|woff2|svg)\$ {/ {
+                        a\
+                '"$nginx_block"'
+                    }' "$CONFIG"
+                    if [ $? -eq 0 ]; then
+                    echo "Added Block to OpenSpeedTest-Server.conf"
+                    else
+                    echo "Failed to Add Block to OpenSpeedTest-Server.conf"
+                    fi
+            fi
+    
+
+        else
+    echo "Failed to add map config to nginx.conf"
+fi
+fi
+
+fi
+
+
+if [ "$DOMAIN_NAME" ]; then
+sed -i "/\bYOURDOMAIN\b/c\ server_name _ localhost ${DOMAIN_NAME};" "${CONFIG}"
+fi
+
+nginx -g 'daemon off;' & sleep 5
+
+if [ "$ENABLE_LETSENCRYPT" = True ] && [ "$DOMAIN_NAME" ] && [ "$USER_EMAIL" ]; then
+
+fullchain_path="/var/log/letsencrypt/live/${DOMAIN_NAME}/fullchain.pem"
+
+certbot certonly -n --webroot --webroot-path /usr/share/nginx/html --no-redirect --agree-tos --email "$USER_EMAIL" -d "$DOMAIN_NAME" --config-dir /var/log/letsencrypt/ --work-dir /var/log/letsencrypt/work --logs-dir /var/log/letsencrypt/log 
+
+  if [ $? -eq 0 ]; then
+
+      if [ -f "$fullchain_path" ]; then
+      sed -i "/\bssl_certificate\b/c\ssl_certificate \/var\/log\/letsencrypt\/live\/${DOMAIN_NAME}\/fullchain.pem;" "${CONFIG}"
+      sed -i "/\bssl_certificate_key\b/c\ssl_certificate_key \/var\/log\/letsencrypt\/live\/${DOMAIN_NAME}\/privkey.pem;" "${CONFIG}"
+      nginx -s reload
+      echo "Let's Encrypt certificate obtained successfully."
+      random_minute=$(shuf -i 0-59 -n 1)
+      random_hour=$(shuf -i 0-23 -n 1)
+      echo "$random_minute $random_hour * * * /renew.sh > /proc/1/fd/1 2>&1" > /etc/crontabs/nginx
+      else
+      echo "letsencrypt Certificates Not Found!"
+      fi
+  else
+    echo "Failed to obtain Let's Encrypt certificate."
+  fi
+fi
+
+crond -b -l 5
+
+tail -f /dev/null

files/nginx.conf

@@ -0,0 +1,19 @@
+worker_processes  auto;
+#worker_rlimit_nofile 100000;
+events {
+     worker_connections 2048;
+     multi_accept on;
+}
+
+error_log  /var/log/nginx/error.log notice;                                                
+pid        /tmp/nginx.pid;
+
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+    include /etc/nginx/conf.d/*.conf;
+ 
+      
+ }
+ 
+ 

files/nginx.crt

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIID7jCCAtYCCQDL3zw96EIXRDANBgkqhkiG9w0BAQsFADCBuDELMAkGA1UEBhMC
+VVMxEzARBgNVBAgMCkNhbGlmb3JuaWExFzAVBgNVBAcMDlNpbGljb24gVmFsbGV5
+MRYwFAYDVQQKDA1PcGVuU3BlZWRUZXN0MR0wGwYDVQQLDBRPcGVuU3BlZWRUZXN0
+LVNlcnZlcjEaMBgGA1UEAwwRT3BlblNwZWVkVGVzdC5jb20xKDAmBgkqhkiG9w0B
+CQEWGXN1cHBvcnRAb3BlbnNwZWVkdGVzdC5jb20wHhcNMjIwNjI5MDY1NjI5WhcN
+MzAxMTE5MDY1NjI5WjCBuDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3Ju
+aWExFzAVBgNVBAcMDlNpbGljb24gVmFsbGV5MRYwFAYDVQQKDA1PcGVuU3BlZWRU
+ZXN0MR0wGwYDVQQLDBRPcGVuU3BlZWRUZXN0LVNlcnZlcjEaMBgGA1UEAwwRT3Bl
+blNwZWVkVGVzdC5jb20xKDAmBgkqhkiG9w0BCQEWGXN1cHBvcnRAb3BlbnNwZWVk
+dGVzdC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC4SfXrpg67
+qFG+ZPJq1HGzQfbWz5HhAA87VxmSPkntBx2L3qUhjHQvYyFtLqcnRz22LMEVR97w
+OgOg9QxUAJQPo9t10+Kc/xTydEufBGxcQPElwr9u9guBxY9FopRPzHcfFhDBCuHw
+IZug0RKGI8f0/4Di5mJlmceOT2KwRoILvXxbDjFEBwSHlILFgkPNX6yROOQ+m/3s
+yF7wOzKvcCL4wijpa/MAjPjPCfKkkV0hR26XENqn5X9AGlM+khXNG6qChlIptAHB
+tyawtlysaMljznp4NoveBmZVNfGcFBIpz2Xw/ddMRQL7tjCkXGtpvcAiFWXuxEpn
+BApDc//vIRXfAgMBAAEwDQYJKoZIhvcNAQELBQADggEBAHWGImuQ3eg+mYz7kGkQ
+LimojW9zuWbpBOsXQ/e66tsv7iffwa3bRNoFgGu4zSmTr8WV2lUcIFIfOoyPKZt/
+mBUaesv7HljVIyuZVDSuDiIh08IPHaUv4aDOa3fGY5R3aEacIfOUYNKAmb5q4Wyl
+tTDrselCkZienndg7+7zp2dQW3G6PIyZ4rIp+FYYScqx3RKKkbA3fvcdFQH/1PNM
+5NUCX/VJGal4Cs7gI/11i9bdeSLeUgMKyQ9f/F9NpoatKiTLJHNteHRtvIyxeuP9
+NktI/lotpVXSEerL9Y6BBW8KGA5meSFLBmCR0aPEGCIjD4SCRrOkFUfb97KyEpEf
+GdU=
+-----END CERTIFICATE-----

files/nginx.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAuEn166YOu6hRvmTyatRxs0H21s+R4QAPO1cZkj5J7Qcdi96l
+IYx0L2MhbS6nJ0c9tizBFUfe8DoDoPUMVACUD6PbddPinP8U8nRLnwRsXEDxJcK/
+bvYLgcWPRaKUT8x3HxYQwQrh8CGboNEShiPH9P+A4uZiZZnHjk9isEaCC718Ww4x
+RAcEh5SCxYJDzV+skTjkPpv97Mhe8Dsyr3Ai+MIo6WvzAIz4zwnypJFdIUdulxDa
+p+V/QBpTPpIVzRuqgoZSKbQBwbcmsLZcrGjJY856eDaL3gZmVTXxnBQSKc9l8P3X
+TEUC+7YwpFxrab3AIhVl7sRKZwQKQ3P/7yEV3wIDAQABAoIBADq/eSHyAehYtBZZ
+392mc8iNUr8P1JVBi5mDHqe8K5zgE88u3r1fJPqmQ1Wm9apTz5xvj+3Ux4EVPWrm
+M1PkC08hESjyrt8Vgfv4jtLWeiS+nyFGf/hDf0+TRyUPuu/lYmQKiLTBX11JmW8e
+tyUD6w5zFQdAIkX5S+BV9kPzdil/Z5SCW7KdzBX2cb3aTh2Q89eiv73rt6eQQkhA
+yi8qcaexWBAvyXEUrbn+5ozixLKZOpGBPCNzklCdc9EqtEXutg8BnXzZjKcvBLLq
+HUd15akZdDuX92I8cNbYb98tAqNOi4UixYwquxMQIT5iTf+JP7rymaCwZImKl+Fn
+EdJYPyECgYEA5ryo8e2t2TEUPpSRebt3eflXyUEUexU5+cvEGfjiGZIi1fNI3iqM
+cEXSUCyH/2TyWd+vyO8Qy1VUPZxhFbangmHVr4u5nZt4o1u702DC0kXOOT0Vg6jb
+wrgk15QvyY+0y/cuRNqfVk9kDuUnkefNuPz9Ruh+Otk1yAH24dTbbzsCgYEAzHdn
+17W2ERHAoBa3sD28p+zvknpsb6MpTj8j49PbhIv7t+lYojsK/OlTd8fEI5ad803n
+TGIg8mhZtZVFFBPeUjWsBZhacLAf4XbQFnxHvyfQjEIvQjaXEcG2r8X1Bi8kE1ad
+fvMKaFNexg9ZjnHSPITKOx5ECUGmDMgYD24cEa0CgYEAsovAi9zozw1cZgSfAbzf
++iHJHXHfwFKvly1nZNWjWDgt/rMQauIv5F0THnknD6j0pDkklG7x5vXzhu1wbtX1
+jz3XlcygaGY7FuXQVQQmHYJozwAGmufajjXiRHNl+ynZtI9kXWFzNN2gRqpqUUw3
+c/NIpksYCr+0Dz395cjJuKsCgYBa30rIpRr49SHeRJp4+sdI/tXvDPf6mdJ20zsZ
+O4RZoXlLYKsi1wjoJK8TEjbK9lrW0q3U1dv8wIH2YRQlezsY4H/GsNKpOK3Cn/KV
+u8CLZZ+bZqLoU6jKnIScFGf0yqjG63zt+giLG1qIvjO4Sj/846uZoLbuQj4RejCv
+UumotQKBgQCKHLNqMTzAaxKPaRUQwRcHzAXygyVQ3ekKFUtRRfMJW0xRCaG1rPRD
+gEAFs2R0DDavJooGbK79/oZAIv6Skq3wrNLraVaiuiobYHWxadgSZtv0+Lk3AYmE
+Xw6PT515uSmqWgMEp5hOVYIO+o+2LZzeeJ6BXoA6/y5Opxqa5G5sZA==
+-----END RSA PRIVATE KEY-----

files/renew.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+
+fullchain_path="/var/log/letsencrypt/live/${DOMAIN_NAME}/fullchain.pem"
+
+if [ "$ENABLE_LETSENCRYPT" = True ] && [ "$DOMAIN_NAME" ] && [ "$USER_EMAIL" ]; then
+
+certbot certonly -n --webroot --webroot-path /usr/share/nginx/html --no-redirect --agree-tos --email "$USER_EMAIL" -d "$DOMAIN_NAME" --config-dir /var/log/letsencrypt/ --work-dir /var/log/letsencrypt/work --logs-dir /var/log/letsencrypt/log
+    if [ $? -eq 0 ]; then
+        echo "certbot certonly -n... Executed."
+        if [ -f "$fullchain_path" ]; then
+        nginx -s reload
+        else
+        echo "letsencrypt Certificates Not Found!"
+        fi
+    else
+        echo "certbot certonly -n... Failed."
+    fi
+
+fi

files/www/.gitignore

@@ -0,0 +1 @@
+.DS_Store

files/www/License.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 OpenSpeedTest™
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

files/www/README.md

@@ -0,0 +1,421 @@
+#  **[SpeedTest by OpenSpeedTest™](https://openspeedtest.com?Run&ref=Github)** - Free & Open-Source HTML5 Network Performance Estimation Tool.
+
+  
+
+SpeedTest by OpenSpeedTest™ is a Free and Open-Source HTML5 Network Performance Estimation Tool Written in Vanilla Javascript and only uses built-in Web APIs like `XMLHttpRequest` `(XHR)`, `HTML`, `CSS`, `JS`, & `SVG`. No Third-Party frameworks or libraries are Required. All we need is a static web server like `NGINX`. I started this project in 2011 and moved to OpenSpeedTest.com dedicated Project/Domain Name in 2013.
+  
+
+[![Download OpenSpeedTest-Server V2.1](https://github.com/openspeedtest/v2-Test/raw/main/images/10G-S.gif)](https://go.openspeedtest.com/Server  "Download OpenSpeedTest-Server V2.1")
+ <a target="_blank"  href="https://go.openspeedtest.com/MicrosoftStore"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/Microsoft-Store-250x100.png"  alt="Download from the Microsoft Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="https://go.openspeedtest.com/MacAppStore"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/Mac-App-Store-250x100.png"  alt="Download from the Mac App Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="http://go.openspeedtest.com/iOS"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/App-Store-250x100.png"  alt="Download from the App Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="https://go.openspeedtest.com/Android"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/GooglePlay-250x100.png"  alt="Download from the Google Play Store" width="200"  height="80"  style=""></a> <a target="_blank"  href="https://go.openspeedtest.com/snapcraft"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/SnapStore-250x100.png"  alt="Download from the Snap Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="http://go.openspeedtest.com/docker"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/docker-250x100.png"  alt="Download from the Docker Hub"  width="200"  height="80"  style=""></a> <a target="_blank"  href="http://go.openspeedtest.com/helm"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/Helm-Charts-250x100.png"  alt="Download from the Helm Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="http://go.openspeedtest.com/Source"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/GitHub-250x100.png"  alt="Download from GitHub"  width="200"  height="80"  style=""></a>
+
+**No client-side software or plugin is required. You can run a network speed test from any device with a [Web Browser that is IE10 or new.](https://www.youtube.com/watch?v=9f-OM_WQ7Bw&list=PLt-deStxFJOMEAs2O1lJhscMNzcg9E3Po&index=1)**
+
+##  Why OpenSpeedTest
+
+  
+
+###  Secure by Design.
+
+  
+
+OpenSpeedTest contains Only `STATIC` Files like `HTML`,`CSS` & `JS`.
+
+So you don't need to worry about Security Updates or Hidden Exploits that may compromise your secure environments.
+
+  
+
+###  Lightweight, High Performance.
+
+  
+
+OpenSpeedTest is written in Vanilla JavaScript. No Third-Party frameworks or libraries were used. SpeedTest script file size is under 8kB gzip. The unexpected side effect of using Vanilla JavaScript is High Performance.
+
+  
+
+###  Run a speed test from Any Device.
+
+  
+
+OpenSpeedTest will run on Any Web Browser that is IE10 or new.
+
+  
+
+###  Ready for Any Display Size and Resolution.
+
+  
+
+OpenSpeedTest User interface is written in SVG.
+
+  
+
+#  Create Your Own SpeedTest Server.
+
+###  Server Requirements :
+
+`Nginx`, `Apache`, `IIS`, `Express`, or Any Web server that supports `HTTP/1.1` or new.
+
+- Accept, `GET`, `POST`, `HEAD` & `OPTIONS`, Response `200 OK`.
+
+- Accept, `POST` to Static Files, Response `200 OK`.
+
+- `client_max_body_size`, 35 Megabytes or more.
+
+- Timeout greater than `60 seconds`.
+
+- Disable `Access logs` for Increasing server performance.
+
+- Improve `Time to First Byte` (TTFB)
+
+- Warning! If you run it behind a **[Reverse Proxy](https://github.com/openspeedtest/Speed-Test/issues/4#issuecomment-1229157193)**, you should increase the `post-body content length` to 35 megabytes.
+- Supports `HTTP2` & `HTTP3`. Wait for POST-BODY and Discard the DATA for UPLOAD. 
+- **[You Should Follow our Nginx Config.](https://github.com/openspeedtest/Nginx-Configuration)**
+
+  
+
+#  Or, You can use OpenSpeedTest-Server.
+
+OpenSpeedTest-Server is available for  Windows, Mac, Linux, Android, iOS & Docker. 
+[![Download OpenSpeedTest-Server V2.1](https://open.cachefly.net/assets/images/OSTV2-SS.png)](https://go.openspeedtest.com/Server  "Download OpenSpeedTest-Server V2.1")
+#### Fully Optimized and ready to use applications. 
+ <a target="_blank"  href="https://go.openspeedtest.com/MicrosoftStore"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/Microsoft-Store-250x100.png"  alt="Download from the Microsoft Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="https://go.openspeedtest.com/MacAppStore"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/Mac-App-Store-250x100.png"  alt="Download from the Mac App Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="http://go.openspeedtest.com/iOS"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/App-Store-250x100.png"  alt="Download from the App Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="https://go.openspeedtest.com/Android"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/GooglePlay-250x100.png"  alt="Download from the Google Play Store" width="200"  height="80"  style=""></a> <a target="_blank"  href="https://go.openspeedtest.com/snapcraft"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/SnapStore-250x100.png"  alt="Download from the Snap Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="http://go.openspeedtest.com/docker"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/docker-250x100.png"  alt="Download from the Docker Hub"  width="200"  height="80"  style=""></a> <a target="_blank"  href="http://go.openspeedtest.com/helm"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/Helm-Charts-250x100.png"  alt="Download from the Helm Store"  width="200"  height="80"  style=""></a> <a target="_blank"  href="http://go.openspeedtest.com/Source"><img src="https://github.com/openspeedtest/v2-Test/raw/main/images/GitHub-250x100.png"  alt="Download from GitHub"  width="200"  height="80"  style=""></a>
+  
+
+###  New features:
+
+  
+
+1. Stress Test. (Continuous Speed Test)
+
+  
+
+To enable the stress test. Pass `Stress` or `S` keyword as a URL parameter.
+
+  
+
+````
+
+http://192.168.1.5?Stress=Low
+
+````
+
+After the `STRESS` or `S` keyword, you can specify the number of seconds you need to run the StressTest in seconds, or preset values such as `Low`, `Medium`, `High`, `VeryHigh`, `Extreme`, `Day`, and `Year`. Will run a speed test for `300`,`600`,`900`,`1800`,`3600`,`86400`,`31557600` seconds, respectively. Also, you can feed the first letter of each parameter and its values.
+  
+
+````
+
+http://192.168.1.5?S=L
+
+````
+
+`S=L` is the same as passing `Stress=low`
+
+Or you can specify the number of seconds eg:`5000` directly without any preset keywords.
+
+  
+
+````
+
+http://192.168.1.5?Stress=5000
+
+````
+
+  
+
+2. Run a speed test automatically
+
+  
+
+Run a speed test automatically on page load.
+
+````
+
+http://192.168.1.5?Run
+
+````
+
+Run a speed test automatically after a few seconds.
+
+````
+
+http://192.168.1.5?Run=10 or http://192.168.1.5?R=10
+
+````
+
+  
+
+You can pass multiple keywords, and it's not `Case-Sensitive`.
+
+  
+
+````
+
+http://192.168.1.5?Run&Stress=300 OR http://192.168.1.5?R&S=300
+
+````
+
+This will start a speed test immediately and run for `300 seconds` in each direction. That is 300 seconds for download and `300 seconds` for upload.
+
+  
+
+3. Save results to a Database
+
+  
+
+Edit `Index.html`
+
+````
+
+var saveData = true;
+
+var saveDataURL = "//yourDatabase.Server.com:4500/save?data=";
+
+````
+
+4. Add multiple servers. The app will choose one with the least latency automatically.
+
+  
+
+Edit `Index.html`
+
+````
+
+var openSpeedTestServerList = [
+
+{"ServerName":"Home-Earth", "Download":"/downloading", "Upload":"/upload", "ServerIcon":"DefaultIcon"},
+
+{"ServerName":"Home-Mars", "Download":"/downloading", "Upload":"/upload", "ServerIcon":"DefaultIcon"},
+
+{"ServerName":"Home-Moon", "Download":"/downloading", "Upload":"/upload", "ServerIcon":"DefaultIcon"}
+
+];
+
+````
+
+5. Disable or change Overhead Compensation factor.
+
+  
+
+````
+
+http://192.168.1.5?clean
+
+````
+
+Overhead Compensation factor, This is browser based test, Many Unknowns. Currently 4%. That is within the margin of error.
+
+You can pass `Clean` or `C` as a URL Parameter and reset Overhead Compensation factor to Zero or set any value between 0 and 4. 1 = 1% to 4 = 4%.
+
+`Clean` will not accept values above 4, so Compensation is limited to maximum 4%.
+
+  
+
+6. Change the default limit of 6 parallel HTTP connections to the Server.
+
+  
+
+````
+
+http://192.168.1.5?XHR=3 OR http://192.168.1.5?X=3
+
+````
+
+Allow the user to Change the default limit of 6 parallel HTTP connections to the Server. `XHR` will Accept values above 1 and max 32
+
+pass `XHR` or `X` as a URL Parameter.
+
+  
+
+7. Select a different server to run a speed test.
+
+  
+
+````
+
+http://192.168.1.5?Host=http://192.168.55.1:90 OR http://192.168.1.5?h=http://192.168.55.1:90
+
+````
+
+Pass `Host` or `H` as a URL Parameter.
+
+`HOST` will Accept only valid HTTP URLs like `http://192.168.1.10:3000` or `https://yourHost.com`.
+
+  
+
+8. Select and run one test at a time, `DOWNLOAD`, `UPLOAD`, or `PING`.
+
+  
+
+````
+
+http://192.168.1.5?Test=Upload OR http://192.168.1.5?T=U
+
+````
+
+`TEST` Allow the user to select and run one test at a time, Download, Upload, or Ping.
+
+Pass `Test` or `T` as a URL Parameter.
+
+  
+
+9. Set a PingTimeout dynamically by passing `Out` or `O` as a URL Parameter
+
+  
+
+````
+
+http://192.168.1.5?Out=7000 OR http://192.168.1.5?O=7000
+
+````
+
+If Server not responded within 5 Seconds for any requests we send ('pingSamples' times)
+
+We will show `Network Error`, You can change the limit here.
+
+In milliseconds, if you need to set `6 seconds`. Change the value to `6000`.
+
+  
+
+10. Set the Number of ping samples by adding `Ping` or `P` as a URL Parameter
+
+  
+
+````
+
+http://192.168.1.5?Ping=500 OR http://192.168.1.5?P=500
+
+````
+
+More samples = more accurate representation. `Ping = 500` will send `501` requests to server to find the accurate ping value.
+Take a look at index.html, you can set a custom ping sample size, threads, upload data size etc.
+
+## Self-hosted (On-Premise) / (Docker Image/Source Code)
+### For Headless large-scale deployments.
+You have two options here. If you need a custom deployment, use our source code along with a web server of your choice. I prefer Nginx, and you can find my [Nginx Configuration](https://github.com/openspeedtest/Nginx-Configuration) here. Or you can use our docker image. You can deploy it on your LAN/WAN with or without an active internet connection.
+
+**This is docker implementation using nginxinc/nginx-unprivileged:stable-alpine. uses significantly fewer resources.**
+
+- NGINX Docker image that runs NGINX as a non root, unprivileged user.
+ 
+ ###  Docker install instructions:
+
+ Install Docker and run the following command!
+
+````bash
+
+sudo docker run --restart=unless-stopped --name openspeedtest -d -p 3000:3000 -p 3001:3001 openspeedtest/latest
+
+````
+#### Or use docker-compose.yml 
+````
+version: '3.3'
+services:
+    speedtest:
+        restart: unless-stopped
+        container_name: openspeedtest
+        ports:
+            - '3000:3000'
+            - '3001:3001'
+        image: openspeedtest/latest
+````
+- Warning! If you run it behind a **[Reverse Proxy](https://github.com/openspeedtest/Speed-Test/issues/4#issuecomment-1229157193)**, you should increase the `post-body content length` to 35 megabytes.
+
+- **[Follow our Nginx Config.](https://github.com/openspeedtest/Nginx-Configuration)**
+
+Now open your browser and direct it to:
+
+A: For **HTTP** use: `http://YOUR-SERVER-IP:3000`
+
+B: For **HTTPS** use: `https://YOUR-SERVER-IP:3001`
+
+#### Container-Port for http is 3000
+If you need to run this image on a different port for `HTTP`, Eg: change to `80` = `-p 80:3000`
+#### Container-Port for https is 3001
+If you need to run this image on a different port for `HTTPS`, Eg: change to `443` =  `-p 443:3001`
+
+###  How to use your own SSL Certificate?
+
+You can mount a folder with your own SSL certificate to this docker container by adding the following line to the above command.
+
+  
+
+````bash
+
+-v /${PATH-TO-YOUR-OWN-SSL-CERTIFICATE}:/etc/ssl/
+
+````
+
+The folder needs to contain:
+
+- `nginx.crt`
+
+- `nginx.key`
+
+  
+
+I am adding a folder with nginx.crt and nginx.key from my desktop by using the following command.
+
+````bash
+
+sudo docker run -v /Users/vishnu/Desktop/docker/:/etc/ssl/ --restart=unless-stopped --name openspeedtest -d -p 3000:3000 -p 3001:3001 openspeedtest/latest
+
+````
+
+Docker images run better on Linux Platforms, including your NAS. But if you install docker on macOS or Windows, you may see poor performance. I asked this on Docker forums, and they told me macOS and Windows support is for Development purposes only. For Production, you need to use any Linux Platform.
+
+The same Story goes for Windows NGINX. Nginx uses only one worker even if you specify n number of worker processes. They will show in Task Manager, but the system will only use one. I got this information directly from the Nginx website.
+
+  
+  
+  
+
+##  Why do you need to Create Your Own SpeedTest Server? 
+
+You can run OpenSpeedTest Server in your Home Lab, Office Server or Cloud Server. So that you or employees who work from home can run a speed test to your office and make sure they can run everything smoothly.
+
+  
+
+**Choosing between ISP1 & ISP2.**
+
+  
+
+Sometimes your ISP2 is Faster than ISP1 when you test your speed on popular speed test sites. But when you connect to your Home/Office/Cloud, that slower connection may perform better. The only way to find out is to run a speed test against your infrastructure.
+
+  
+
+**Troubleshooting network issues.**
+
+  
+
+It is common even when your Internet connection is working fine, but some of the devices in your network may experience trouble getting decent connectivity to the internet. The issue might be the wrong VLAN ID or Faulty Switch. If you run a Local network speed test, you can find and fix these issues easily.
+
+  
+
+**Before you add a repeater.**
+
+  
+
+Most repeaters will reduce your network speed by 50%, so if you put it far away, it will perform worst, and if you put it too close, you will not get enough coverage if you run a Local Network speed test. Depending on the application requirements, you can decide exactly where you need to put your repeater.
+
+  
+
+**Browsing experience.**
+
+  
+
+Many useful browser extensions are out there that we all know and love. But some of them are really slowing you down for **few seconds per page you visit**. You may see good performance when you test your network performance via File Transfer or Command-line utilities, but you may experience poor performance when browsing the internet. This is due to a bad browser configuration that including unwanted extensions installed. From my experience, only keep the one you are going to use every single day. Extension that you may use once in a while should be removed or disabled for maximum performance. If you see poor performance, try OpenSpeedTest from Private Window or Incognito Window. **This tool can be used to check the browser performance and impact of Extensions on your browsing experience.**
+
+  
+
+**No client-side software or plugin is required. You can run a network speed test from any device with a [Web Browser that is IE10 or new.](https://www.youtube.com/watch?v=9f-OM_WQ7Bw&list=PLt-deStxFJOMEAs2O1lJhscMNzcg9E3Po&index=1)**
+
+- Like this Project? Please **Donate NOW & Keep us Alive** -> https://go.openspeedtest.com/Donate
+
+MIT License
+
+Copyright (c) 2013 - 2023 OpenSpeedTest™
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

files/www/assets/css/app.css

@@ -0,0 +1,382 @@
+/* roboto-regular - latin */
+@font-face {
+  font-family: "Roboto";
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url("..fonts/roboto-v30-latin-regular.eot"); /* IE9 Compat Modes */
+  src: local(""),
+    url("../fonts/roboto-v30-latin-regular.eot?#iefix")
+      format("embedded-opentype"),
+    /* IE6-IE8 */ url("../fonts/roboto-v30-latin-regular.woff2")
+      format("woff2"),
+    /* Super Modern Browsers */
+      url("../fonts/roboto-v30-latin-regular.woff") format("woff"),
+    /* Modern Browsers */ url("../fonts/roboto-v30-latin-regular.ttf")
+      format("truetype"),
+    /* Safari, Android, iOS */
+      url("../fonts/roboto-v30-latin-regular.svg#Roboto") format("svg"); /* Legacy iOS */
+}
+/* roboto-500 - latin */
+@font-face {
+  font-family: "Roboto";
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url("assets/fonts/roboto-v30-latin-500.eot"); /* IE9 Compat Modes */
+  src: local(""),
+    url("assets/fonts/roboto-v30-latin-500.eot?#iefix")
+      format("embedded-opentype"),
+    /* IE6-IE8 */ url("../fonts/roboto-v30-latin-500.woff2")
+      format("woff2"),
+    /* Super Modern Browsers */ url("../fonts/roboto-v30-latin-500.woff")
+      format("woff"),
+    /* Modern Browsers */ url("../fonts/roboto-v30-latin-500.ttf")
+      format("truetype"),
+    /* Safari, Android, iOS */
+      url("../fonts/roboto-v30-latin-500.svg#Roboto") format("svg"); /* Legacy iOS */
+}
+
+body {
+  margin: 0px;
+  padding: 0px;
+  display: block;
+}
+
+::-webkit-scrollbar {
+  display: none;
+}
+html {
+  -ms-overflow-style: none; 
+  scrollbar-width: none;
+}
+ 
+.Credits {
+color: rgb(125 119 119);
+text-align: center;
+font-size:14px;
+font-family: Roboto-Medium, Roboto;
+font-weight: 500;
+} 
+.Credits a {
+  text-decoration: none;
+  color: rgb(113, 113, 113);
+}
+.Credits a:hover {
+color: #14b0fe;
+}
+
+.ConnectError {
+  display: none;
+
+}
+
+.openSpeedtestApp {
+ 
+  height: 100vh;
+  width: 100vw;
+  display: none;
+  overflow: hidden;
+}
+.main-Gaugebg {
+  fill: none;
+  stroke: rgb(231, 231, 232);
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-width: 22px;
+  stroke-dasharray: 681;
+}
+.main-GaugeBlue {
+  fill: none;
+  stroke: url(#gradient);
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-width: 22px;
+  stroke-dasharray: 681;
+  stroke-opacity: 0;
+}
+.main-GaugeWhite {
+  fill: none;
+  stroke: rgb(255, 255, 255);
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-width: 15px;
+  stroke-dasharray: 0, 681;
+  stroke-dashoffset: 1;
+  stroke-opacity: 0;
+}
+.oDo-Meter {
+  font-size: 16.633283615112305px;
+  fill: gray;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+}
+.oDoLive-Speed {
+  font-size: 28px;
+  fill: #201e1e;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: middle;
+}
+
+.oDoLive-Status {
+  font-size: 10px;
+  fill: #d2d1d2;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: middle;
+}
+.uiBg {
+  fill: #d2d1d2;
+}
+.progressbg {
+  stroke: rgb(231, 231, 232);
+  stroke-width: 8px;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-dasharray: 400;
+  stroke-dashoffset: 0;
+}
+.Cards {
+  fill: #f2f2f2;
+}
+.Symbol {
+  fill: url(#gradient);
+}
+.rtext {
+  font-size: 12px;
+  fill: #333;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+}
+.rtextnum {
+  font-size: 23px;
+  fill: #201e1e;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: middle;
+}
+.rtextmbms {
+  font-size: 12px;
+  fill: #5f5f5f;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: middle;
+}
+.jitter-Mob {
+  font-size: 9px;
+  fill: #5f5f5f;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: middle;
+}
+.startButton {
+  fill: url(#RadialGradient1);
+  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+  -webkit-tap-highlight-color: transparent;
+  cursor: pointer;
+  pointer-events: visible;
+}
+.buttonTxt {
+  font-size: 40px;
+  fill: #ffffff;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: middle;
+}
+
+.intro-Progress {
+  stroke: #56c4fb;
+  stroke-width: 8px;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-dasharray: 400;
+  stroke-dashoffset: 0;
+}
+.progressElmstart {
+  stroke: #56c4fb;
+  stroke-width: 8px;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-dasharray: 400;
+  stroke-dashoffset: 0;
+  display: block;
+}
+.Startsettings {
+  fill: url(#RadialGradient1);
+  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+  -webkit-tap-highlight-color: transparent;
+  cursor: pointer;
+  pointer-events: visible;
+  opacity: 0.1;
+  transition: opacity 1s ease-in-out;
+}
+.Startsettings:hover {
+  opacity: 1;
+}
+
+.progressbg {
+  stroke: rgb(231, 231, 232);
+  stroke-width: 8px;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-dasharray: 400;
+  stroke-dashoffset: 0;
+}
+.deskStart {
+  fill: none;
+  stroke: rgb(231, 231, 232);
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-width: 22px;
+  stroke-dasharray: 681;
+  stroke: url(#gradient);
+}
+#UI-Desk {
+  display: none;
+}
+#UI-Mob {
+  display: none;
+}
+.oDoTop-Speed {
+  font-size: 16.96px;
+  fill: gray;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: end;
+}
+#upSymbolDesk {
+  fill: #14b0fe;
+  display: none;
+}
+#downSymbolDesk {
+  fill: #14b0fe;
+  display: none;
+}
+#upSymbolMob {
+  fill: #14b0fe;
+  display: none;
+}
+#downSymbolMob {
+  fill: #14b0fe;
+  display: none;
+}
+
+#ipMob {
+  font-size: 15px;
+  fill: #201e1e;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: middle;
+  display: none;
+}
+#ipDesk {
+  font-size: 15px;
+  fill: #201e1e;
+  font-family: Roboto-Medium, Roboto;
+  font-weight: 500;
+  text-anchor: middle;
+  display: none;
+}
+
+.spinner {
+  position: absolute;
+  z-index: 999;
+  top: 50vh;
+  left: 50vw;
+  text-align: center;
+}
+
+.spinner > div {
+  width: 20px;
+  height: 20px;
+  background-color: #2196f3;
+
+  border-radius: 100%;
+  display: inline-block;
+  -webkit-animation: sk-bouncedelay 1.4s infinite ease-in-out both;
+  animation: sk-bouncedelay 1.4s infinite ease-in-out both;
+}
+
+.spinner .bounce1 {
+  -webkit-animation-delay: -0.32s;
+  animation-delay: -0.32s;
+}
+
+.spinner .bounce2 {
+  -webkit-animation-delay: -0.16s;
+  animation-delay: -0.16s;
+}
+
+@-webkit-keyframes sk-bouncedelay {
+  0%,
+  80%,
+  100% {
+    -webkit-transform: scale(0);
+  }
+  40% {
+    -webkit-transform: scale(1);
+  }
+}
+
+@keyframes sk-bouncedelay {
+  0%,
+  80%,
+  100% {
+    -webkit-transform: scale(0);
+    transform: scale(0);
+  }
+  40% {
+    -webkit-transform: scale(1);
+    transform: scale(1);
+  }
+}
+
+.darkmode {
+  margin-bottom: -15px;
+  fill: #75757a99;
+  padding-top: 16px;
+  display: none;
+  cursor: pointer;
+  margin-right: 30px;
+}
+#daymode {
+  margin-right: 40px;
+}
+.darkmode:hover {
+  fill: #000000;
+}
+
+.Mobile,
+.Desktop {
+  visibility: hidden;
+  width: 100vw;
+  height: 100vh;
+}
+
+@media only screen and (orientation: landscape) {
+  .Mobile {
+    visibility: hidden;
+  }
+  .Desktop {
+    visibility: visible;
+  }
+}
+
+@media only screen and (orientation: portrait) {
+  .spinner {
+    top: 42vh;
+    left: 42vw;
+  }
+  .Mobile {
+    visibility: visible;
+  }
+  .Desktop {
+    visibility: hidden;
+  }
+}
+@media only screen and (max-width: 300px) {
+  .Credits{
+    display: none;
+  }
+}

files/www/assets/css/darkmode.css

@@ -0,0 +1,45 @@
+body {
+  background-color: #181818;
+}
+#ipDesk {
+  fill: aliceblue;
+}
+
+.oDoLive-Speed {
+  fill: #ffffff;
+}
+.oDoLive-Status {
+  fill: aliceblue;
+}
+#ipMob {
+  fill: aliceblue;
+}
+.rtextnum {
+  fill: #ffffff;
+}
+.rtextmbms {
+  fill: #ffffff;
+}
+.rtext {
+  fill: #ffffff;
+}
+.Cards {
+  fill: #000000;
+}
+
+.main-Gaugebg {
+  stroke: #000000;
+}
+.uiBg {
+  fill: #000000;
+}
+.progressbg {
+  stroke: #202020;
+}
+.jitter-Mob {
+  fill: #ffffff;
+}
+
+.ConnectError {
+  fill: #ffffff;
+}

files/www/assets/images/icons/browserconfig.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<browserconfig>
+    <msapplication>
+        <tile>
+            <square150x150logo src="/images/icons/mstile-150x150.png"/>
+            <TileColor>#ffc40d</TileColor>
+        </tile>
+    </msapplication>
+</browserconfig>

files/www/assets/images/icons/site.webmanifest

@@ -0,0 +1,22 @@
+{
+    "name": "OpenSpeedTest",
+    "short_name": "Speed Test",
+    "icons": [
+        {
+            "src": "/assets/images/icons/android-chrome-192x192.png",
+            "sizes": "192x192",
+            "type": "image/png"
+        },
+        {
+            "src": "/assets/images/icons/android-chrome-512x512.png",
+            "sizes": "512x512",
+            "type": "image/png"
+        }
+    ],
+    "theme_color": "#ffffff",
+    "background_color": "#ffffff",
+    "display": "standalone",
+    "start_url": "/"
+  
+ 
+}

files/www/assets/js/app-2.5.4.js

@@ -0,0 +1,1427 @@
+/*
+     Official Website : https://OpenSpeedTest.COM | Email: support@openspeedtest.com
+     Developed by : Vishnu | https://Vishnu.Pro | Email : me@vishnu.pro 
+     Like this Project? Please Donate NOW & Keep us Alive -> https://go.openspeedtest.com/Donate
+    Speed Test by OpenSpeedTest™️ is Free and Open-Source Software (FOSS) with MIT License.
+    Read full license terms @ http://go.openspeedtest.com/License
+    If you have any Questions, ideas or Comments Please Send it via -> https://go.openspeedtest.com/SendMessage
+*/ 
+window.onload = function() {
+  var appSVG = document.getElementById("OpenSpeedTest-UI");
+  appSVG.parentNode.replaceChild(appSVG.contentDocument.documentElement, appSVG);
+  ostOnload();
+  OpenSpeedTest.Start();
+};
+(function(OpenSpeedTest) {
+  var Status;
+  var ProG;
+  var Callback = function(callback) {
+    if (callback && typeof callback === "function") {
+      callback();
+    }
+  };
+  function _(el) {
+    if (!(this instanceof _)) {
+      return new _(el);
+    }
+    this.el = document.getElementById(el);
+  }
+  _.prototype.fade = function fade(type, ms, callback00) {
+    var isIn = type === "in", opacity = isIn ? 0 : 1, interval = 14, duration = ms, gap = interval / duration, self = this;
+    if (isIn) {
+      self.el.style.display = "block";
+      self.el.style.opacity = opacity;
+    }
+    function func() {
+      opacity = isIn ? opacity + gap : opacity - gap;
+      self.el.style.opacity = opacity;
+      if (opacity <= 0) {
+        self.el.style.display = "none";
+      }
+      if (opacity <= 0 || opacity >= 1) {
+        window.clearInterval(fading, Callback(callback00));
+      }
+    }
+    var fading = window.setInterval(func, interval);
+  };
+  var easeOutQuint = function(t, b, c, d) {
+    t /= d;
+    t--;
+    return c * (t * t * t * t * t + 1) + b;
+  };
+  var easeOutCubic = function(t, b, c, d) {
+    t /= d;
+    t--;
+    return c * (t * t * t + 1) + b;
+  };
+  var openSpeedtestShow = function() {
+    this.YourIP = _("YourIP");
+    this.ipDesk = _("ipDesk");
+    this.ipMob = _("ipMob");
+    this.downSymbolDesk = _("downSymbolDesk");
+    this.upSymbolDesk = _("upSymbolDesk");
+    this.upSymbolMob = _("upSymbolMob");
+    this.downSymbolMob = _("downSymbolMob");
+    this.settingsMob = _("settingsMob");
+    this.settingsDesk = _("settingsDesk");
+    this.oDoLiveStatus = _("oDoLiveStatus");
+    this.ConnectErrorMob = _("ConnectErrorMob");
+    this.ConnectErrorDesk = _("ConnectErrorDesk");
+    this.downResult = _("downResult");
+    this.upRestxt = _("upRestxt");
+    this.pingResult = _("pingResult");
+    this.jitterDesk = _("jitterDesk");
+    this.pingMobres = _("pingMobres");
+    this.JitterResultMon = _("JitterResultMon");
+    this.JitterResultms = _("JitterResultms");
+    this.UI_Desk = _("UI-Desk");
+    this.UI_Mob = _("UI-Mob");
+    this.oDoTopSpeed = _("oDoTopSpeed");
+    this.startButtonMob = _("startButtonMob");
+    this.startButtonDesk = _("startButtonDesk");
+    this.intro_Desk = _("intro-Desk");
+    this.intro_Mob = _("intro-Mob");
+    this.loader = _("loading_app");
+    this.OpenSpeedtest = _("OpenSpeedtest");
+    this.mainGaugebg_Desk = _("mainGaugebg-Desk");
+    this.mainGaugeBlue_Desk = _("mainGaugeBlue-Desk");
+    this.mainGaugeWhite_Desk = _("mainGaugeWhite-Desk");
+    this.mainGaugebg_Mob = _("mainGaugebg-Mob");
+    this.mainGaugeBlue_Mob = _("mainGaugeBlue-Mob");
+    this.mainGaugeWhite_Mob = _("mainGaugeWhite-Mob");
+    this.oDoLiveSpeed = _("oDoLiveSpeed");
+    this.progressStatus_Mob = _("progressStatus-Mob");
+    this.progressStatus_Desk = _("progressStatus-Desk");
+    this.graphc1 = _("graphc1");
+    this.graphc2 = _("graphc2");
+    this.graphMob2 = _("graphMob2");
+    this.graphMob1 = _("graphMob1");
+    this.text = _("text");
+    this.scale = [{degree:680, value:0}, {degree:570, value:0.5}, {degree:460, value:1}, {degree:337, value:10}, {degree:220, value:100}, {degree:115, value:500}, {degree:0, value:1000},];
+    this.element = "";
+    this.chart = "";
+    this.polygon = "";
+    this.width = 200;
+    this.height = 50;
+    this.maxValue = 0;
+    this.values = [];
+    this.points = [];
+    this.vSteps = 5;
+    this.measurements = [];
+    this.points = [];
+  };
+  openSpeedtestShow.prototype.reset = function() {
+    this.element = "";
+    this.chart = "";
+    this.polygon = "";
+    this.width = 200;
+    this.height = 50;
+    this.maxValue = 0;
+    this.values = [];
+    this.points = [];
+    this.vSteps = 5;
+    this.measurements = [];
+    this.points = [];
+  };
+  openSpeedtestShow.prototype.ip = function() {
+    var Self = this;
+    if (Self.ipDesk.el.style.display === "block") {
+      Self.ipDesk.el.style.display = "none";
+      Self.ipMob.el.style.display = "none";
+    } else {
+      Self.ipDesk.el.style.display = "block";
+      Self.ipMob.el.style.display = "block";
+    }
+  };
+  openSpeedtestShow.prototype.prePing = function() {
+    this.loader.fade("out", 500);
+    this.OpenSpeedtest.fade("in", 1000);
+  };
+  openSpeedtestShow.prototype.app = function() {
+    this.loader.fade("out", 500, this.ShowAppIntro());
+  };
+  openSpeedtestShow.prototype.ShowAppIntro = function() {
+    this.OpenSpeedtest.fade("in", 1000);
+  };
+  openSpeedtestShow.prototype.userInterface = function() {
+    var Self = this;
+    this.intro_Desk.fade("out", 1000);
+    this.intro_Mob.fade("out", 1000, this.ShowUI());
+  };
+  openSpeedtestShow.prototype.ShowUI = function() {
+    this.UI_Desk.fade("in", 1000);
+    this.UI_Mob.fade("in", 1000, uiLoaded);
+    function uiLoaded(argument) {
+      Status = "Loaded";
+      console.log("Developed by Vishnu. Email --\x3e me@vishnu.pro");
+    }
+  };
+  openSpeedtestShow.prototype.Symbol = function(dir) {
+    if (dir == 0) {
+      this.downSymbolMob.el.style.display = "block";
+      this.downSymbolDesk.el.style.display = "block";
+      this.upSymbolMob.el.style.display = "none";
+      this.upSymbolDesk.el.style.display = "none";
+    }
+    if (dir == 1) {
+      this.downSymbolMob.el.style.display = "none";
+      this.downSymbolDesk.el.style.display = "none";
+      this.upSymbolMob.el.style.display = "block";
+      this.upSymbolDesk.el.style.display = "block";
+    }
+    if (dir == 2) {
+      this.downSymbolMob.el.style.display = "none";
+      this.downSymbolDesk.el.style.display = "none";
+      this.upSymbolMob.el.style.display = "none";
+      this.upSymbolDesk.el.style.display = "none";
+    }
+  };
+  openSpeedtestShow.prototype.Graph = function(speed, select) {
+    if (!("remove" in Element.prototype)) {
+      Element.prototype.remove = function() {
+        if (this.parentNode) {
+          this.parentNode.removeChild(this);
+        }
+      };
+    }
+    var Self = this;
+    var Remove;
+    if (select === 0) {
+      var Graphelement = this.graphc1.el;
+      Remove = "line";
+      this.graphMob2.el.style.display = "none";
+      this.graphMob1.el.style.display = "block";
+    } else {
+      Graphelement = this.graphc2.el;
+      Remove = "line2";
+      this.graphMob1.el.style.display = "none";
+      this.graphMob2.el.style.display = "block";
+    }
+    if (!isNaN(speed)) {
+      this.values.push(speed);
+    } else {
+      this.values.push("");
+    }
+    function calcMeasure() {
+      for (x = 0; x < Self.vSteps; x++) {
+        var measurement = Math.ceil(Self.maxValue / Self.vSteps * (x + 1));
+        Self.measurements.push(measurement);
+      }
+      Self.measurements.reverse();
+    }
+    function createChart(element, values) {
+      calcMaxValue();
+      calcPoints();
+      calcMeasure();
+      var removeLine = document.getElementsByClassName(Remove);
+      while (removeLine.length > 0) {
+        removeLine[0].remove();
+      }
+      Self.polygon = document.createElementNS("http://www.w3.org/2000/svg", "polygon");
+      Self.polygon.setAttribute("points", Self.points);
+      Self.polygon.setAttribute("class", Remove);
+      if (Self.values.length > 1) {
+        Graphelement.appendChild(Self.polygon);
+      }
+    }
+    function calcPoints() {
+      if (Self.values.length > 1) {
+        var points = "0," + Self.height + " ";
+        for (x = 0; x < Self.values.length; x++) {
+          var perc = Self.values[x] / Self.maxValue;
+          var steps = 130 / (Self.values.length - 1);
+          var point = (steps * x).toFixed(2) + "," + (Self.height - Self.height * perc).toFixed(2) + " ";
+          points += point;
+        }
+        points += "130," + Self.height;
+        Self.points = points;
+      }
+    }
+    var x;
+    function calcMaxValue() {
+      Self.maxValue = 0;
+      for (x = 0; x < Self.values.length; x++) {
+        if (Self.values[x] > Self.maxValue) {
+          Self.maxValue = Self.values[x];
+        }
+      }
+      Self.maxValue = Math.ceil(Self.maxValue);
+    }
+    if (speed > 0) {
+      createChart(Graphelement, speed);
+    }
+  };
+  openSpeedtestShow.prototype.progress = function(Switch, duration) {
+    var Self = this;
+    var Stop = duration;
+    var Stage = Switch;
+    var currTime = Date.now();
+    var chan2 = 0 - 400;
+    var interval = setInterval(function() {
+      var timeNow = (Date.now() - currTime) / 1000;
+      var toLeft = easeOutCubic(timeNow, 400, 400, Stop);
+      var toRight = easeOutCubic(timeNow, 400, chan2, Stop);
+      if (Stage) {
+        Self.progressStatus_Desk.el.style.strokeDashoffset = toLeft;
+        Self.progressStatus_Mob.el.style.strokeDashoffset = toLeft;
+      } else {
+        Self.progressStatus_Desk.el.style.strokeDashoffset = toRight;
+        Self.progressStatus_Mob.el.style.strokeDashoffset = toRight;
+      }
+      if (timeNow >= Stop) {
+        clearInterval(interval);
+        ProG = "done";
+        Self.progressStatus_Desk.el.style.strokeDashoffset = 800;
+        Self.progressStatus_Mob.el.style.strokeDashoffset = 800;
+      }
+    }, 14);
+  };
+  openSpeedtestShow.prototype.mainGaugeProgress = function(currentSpeed) {
+    var Self = this;
+    var speed = currentSpeed;
+    if (speed < 0) {
+      speed = 0;
+    }
+    var mainGaugeOffset = Self.getNonlinearDegree(speed);
+    if (currentSpeed > 0) {
+      this.mainGaugeBlue_Desk.el.style.strokeOpacity = 1;
+      this.mainGaugeWhite_Desk.el.style.strokeOpacity = 1;
+      this.mainGaugeBlue_Mob.el.style.strokeOpacity = 1;
+      this.mainGaugeWhite_Mob.el.style.strokeOpacity = 1;
+      this.mainGaugeBlue_Desk.el.style.strokeDashoffset = mainGaugeOffset;
+      this.mainGaugeWhite_Desk.el.style.strokeDashoffset = mainGaugeOffset == 0 ? 1 : mainGaugeOffset + 1;
+      this.mainGaugeBlue_Mob.el.style.strokeDashoffset = mainGaugeOffset;
+      this.mainGaugeWhite_Mob.el.style.strokeDashoffset = mainGaugeOffset == 0 ? 1 : mainGaugeOffset + 1;
+    }
+    if (mainGaugeOffset == 0 && speed > 1000) {
+      this.mainGaugeBlue_Mob.el.style.strokeDashoffset = mainGaugeOffset >= 681 ? 681 : mainGaugeOffset;
+      this.mainGaugeWhite_Mob.el.style.strokeDashoffset = mainGaugeOffset == 0 ? 1 : mainGaugeOffset + 1;
+      this.mainGaugeWhite_Desk.el.style.strokeDashoffset = mainGaugeOffset == 0 ? 1 : mainGaugeOffset + 1;
+      this.mainGaugeBlue_Desk.el.style.strokeDashoffset = mainGaugeOffset >= 681 ? 681 : mainGaugeOffset;
+    } else if (mainGaugeOffset == 0 && speed <= 0) {
+      this.mainGaugeBlue_Mob.el.style.strokeDashoffset = 681.1;
+      this.mainGaugeWhite_Mob.el.style.strokeDashoffset = 0.1;
+      this.mainGaugeWhite_Desk.el.style.strokeDashoffset = 0.1;
+      this.mainGaugeBlue_Desk.el.style.strokeDashoffset = 681.1;
+    }
+  };
+  openSpeedtestShow.prototype.showStatus = function(e) {
+    this.oDoLiveStatus.el.textContent = e;
+  };
+  openSpeedtestShow.prototype.ConnectionError = function() {
+    this.ConnectErrorMob.el.style.display = "block";
+    this.ConnectErrorDesk.el.style.display = "block";
+  };
+  openSpeedtestShow.prototype.uploadResult = function(upload) {
+    if (upload < 1) {
+      this.upRestxt.el.textContent = upload.toFixed(3);
+    }
+    if (upload >= 1 && upload < 9999) {
+      this.upRestxt.el.textContent = upload.toFixed(1);
+    }
+    if (upload >= 10000 && upload < 99999) {
+      this.upRestxt.el.textContent = upload.toFixed(1);
+      this.upRestxt.el.style.fontSize = "20px";
+    }
+    if (upload >= 100000) {
+      this.upRestxt.el.textContent = upload.toFixed(1);
+      this.upRestxt.el.style.fontSize = "18px";
+    }
+  };
+  openSpeedtestShow.prototype.pingResults = function(data, Display) {
+    var ShowData = data;
+    if (Display === "Ping") {
+      if (ShowData >= 1 && ShowData < 10000) {
+        this.pingResult.el.textContent = Math.floor(ShowData);
+        this.pingMobres.el.textContent = Math.floor(ShowData);
+      } else if (ShowData >= 0 && ShowData < 1) {
+        if (ShowData == 0) {
+          ShowData = 0;
+        }
+        this.pingResult.el.textContent = ShowData;
+        this.pingMobres.el.textContent = ShowData;
+      }
+    }
+    if (Display === "Error") {
+      this.oDoLiveSpeed.el.textContent = ShowData;
+    }
+  };
+  openSpeedtestShow.prototype.downloadResult = function(download) {
+    if (download < 1) {
+      this.downResult.el.textContent = download.toFixed(3);
+    }
+    if (download >= 1 && download < 9999) {
+      this.downResult.el.textContent = download.toFixed(1);
+    }
+    if (download >= 10000 && download < 99999) {
+      this.downResult.el.textContent = download.toFixed(1);
+      this.downResult.el.style.fontSize = "20px";
+    }
+    if (download >= 100000) {
+      this.downResult.el.textContent = download.toFixed(1);
+      this.downResult.el.style.fontSize = "18px";
+    }
+  };
+  openSpeedtestShow.prototype.jitterResult = function(data, Display) {
+    var ShowData = data;
+    if (Display === "Jitter") {
+      if (ShowData >= 1 && ShowData < 10000) {
+        this.jitterDesk.el.textContent = Math.floor(ShowData);
+        if (ShowData >= 1 && ShowData < 100) {
+          this.JitterResultMon.el.textContent = Math.floor(ShowData);
+        }
+        if (ShowData >= 100) {
+          var kData = (ShowData / 1000).toFixed(1);
+          this.JitterResultMon.el.textContent = kData + "k";
+        }
+      } else if (ShowData >= 0 && ShowData < 1) {
+        if (ShowData == 0) {
+          ShowData = 0;
+        }
+        this.jitterDesk.el.textContent = ShowData;
+        this.JitterResultMon.el.textContent = ShowData;
+      }
+    }
+  };
+  openSpeedtestShow.prototype.LiveSpeed = function(data, Display) {
+    var ShowData = data;
+    if (Display === "countDown") {
+      var speed = ShowData.toFixed(0);
+      this.oDoLiveSpeed.el.textContent = speed;
+      return;
+    }
+    if (Display === "speedToZero") {
+      if (typeof ShowData == "number") {
+        ShowData = ShowData.toFixed(1);
+      }
+      if (ShowData <= 0) {
+        ShowData = 0;
+      }
+      this.oDoLiveSpeed.el.textContent = ShowData;
+      this.oDoTopSpeed.el.textContent = "1000+";
+      this.oDoTopSpeed.el.style.fontSize = "16.9px";
+      this.oDoTopSpeed.el.style.fill = "gray";
+      return;
+    }
+    if (Display === "Ping") {
+      if (ShowData >= 1 && ShowData < 10000) {
+        this.oDoLiveSpeed.el.textContent = Math.floor(ShowData);
+      } else if (ShowData >= 0 && ShowData < 1) {
+        if (ShowData == 0) {
+          ShowData = 0;
+        }
+        this.oDoLiveSpeed.el.textContent = ShowData;
+      }
+    } else {
+      if (ShowData == 0) {
+        var speed = ShowData.toFixed(0);
+        this.oDoLiveSpeed.el.textContent = speed;
+      }
+      if (ShowData <= 1 && ShowData > 0) {
+        var speed = ShowData.toFixed(3);
+        this.oDoLiveSpeed.el.textContent = speed;
+      }
+      if (ShowData > 1) {
+        var speed = ShowData.toFixed(1);
+        this.oDoLiveSpeed.el.textContent = speed;
+      }
+      if (ShowData <= 1000) {
+        this.oDoTopSpeed.el.textContent = "1000+";
+        this.oDoTopSpeed.el.style.fontSize = "16.9px";
+        this.oDoTopSpeed.el.style.fill = "gray";
+      }
+      if (ShowData >= 1010) {
+        this.oDoTopSpeed.el.textContent = Math.floor(ShowData / 1010) * 1000 + "+";
+        this.oDoTopSpeed.el.style.fill = "gray";
+        this.oDoTopSpeed.el.style.fontSize = "17.2px";
+      }
+    }
+  };
+  openSpeedtestShow.prototype.GaugeProgresstoZero = function(currentSpeed, status) {
+    var speed = currentSpeed;
+    var Self = this;
+    var duration = 3;
+    if (speed >= 0) {
+      var time = Date.now();
+      var SpeedtoZero = 0 - speed;
+      var interval = setInterval(function() {
+        var timeNow = (Date.now() - time) / 1000;
+        var speedToZero = easeOutQuint(timeNow, speed, SpeedtoZero, duration);
+        Self.LiveSpeed(speedToZero, "speedToZero");
+        Self.mainGaugeProgress(speedToZero);
+        if (timeNow >= duration || speedToZero <= 0) {
+          clearInterval(interval);
+          Self.LiveSpeed(0, "speedToZero");
+          Self.mainGaugeProgress(0);
+          Status = status;
+        }
+      }, 16);
+    }
+  };
+  openSpeedtestShow.prototype.getNonlinearDegree = function(mega_bps) {
+    var i = 0;
+    if (0 == mega_bps || mega_bps <= 0 || isNaN(mega_bps)) {
+      return 0;
+    }
+    while (i < this.scale.length) {
+      if (mega_bps > this.scale[i].value) {
+        i++;
+      } else {
+        return this.scale[i - 1].degree + (mega_bps - this.scale[i - 1].value) * (this.scale[i].degree - this.scale[i - 1].degree) / (this.scale[i].value - this.scale[i - 1].value);
+      }
+    }
+    return this.scale[this.scale.length - 1].degree;
+  };
+  var openSpeedtestGet = function() {
+    this.OverAllTimeAvg = window.performance.now();
+    this.SpeedSamples = [];
+    this.FinalSpeed;
+  };
+  openSpeedtestGet.prototype.reset = function() {
+    this.OverAllTimeAvg = window.performance.now();
+    this.SpeedSamples = [];
+    this.FinalSpeed = 0;
+  };
+  openSpeedtestGet.prototype.ArraySum = function(Arr) {
+    var array = Arr;
+    if (array) {
+      var sum = array.reduce(function(A, B) {
+        if (typeof A === "number" && typeof B === "number") {
+          return A + B;
+        }
+      }, 0);
+      return sum;
+    } else {
+      return 0;
+    }
+  };
+  openSpeedtestGet.prototype.AvgSpeed = function(Livespeed, Start, duration) {
+    var Self = this;
+    this.timeNow = (window.performance.now() - this.OverAllTimeAvg) / 1000;
+    this.FinalSpeed;
+    var StartRecoding = Start;
+    StartRecoding = duration - StartRecoding;
+    if (this.timeNow >= StartRecoding) {
+      if (Livespeed > 0) {
+        this.SpeedSamples.push(Livespeed);
+      }
+      Self.FinalSpeed = Self.ArraySum(Self.SpeedSamples) / Self.SpeedSamples.length;
+    }
+    return Self.FinalSpeed;
+  };
+  openSpeedtestGet.prototype.uRandom = function(size, callback) {
+    var size = size;
+    var randomValue = new Uint32Array(262144);
+    function getRandom() {
+      var n = randomValue.length;
+      for (var i = 0; i < n; i++) {
+        randomValue[i] = Math.random() * 4294967296;
+      }
+      return randomValue;
+    }
+    var randomData = [];
+    var genData = function(dataSize) {
+      var dataSize = dataSize;
+      for (var i = 0; i < dataSize; i++) {
+        randomData[i] = getRandom();
+      }
+      return randomData;
+    };
+    return new Blob(genData(size), {type:"application/octet-stream"}, Callback(callback));
+  };
+  openSpeedtestGet.prototype.addEvt = function(o, e, f) {
+    o.addEventListener(e, f);
+  };
+  openSpeedtestGet.prototype.remEvt = function(o, e, f) {
+    o.removeEventListener(e, f);
+  };
+  var openSpeedtestEngine = function() {
+    var Get = new openSpeedtestGet();
+    var Show = new openSpeedtestShow();
+    Show.app();
+    var SendData;
+    var myhostName = location.hostname;
+    var key;
+    var TestServerip;
+    var downloadSpeed;
+    var uploadSpeed;
+    var dataUsedfordl;
+    var dataUsedforul;
+    var pingEstimate;
+    var jitterEstimate;
+    var logData;
+    var return_data;
+    var ReQ = [];
+    var StartTime = [];
+    var CurrentTime = [];
+    var LiveSpeedArr;
+    var dLoaded = 0;
+    var uLoaded = 0;
+    var currentSpeed = 0;
+    var uploadTimeing;
+    var downloadTimeing;
+    var downloadTime;
+    var uploadTime;
+    var saveTestData;
+    var stop = 0;
+    function reSett() {
+      StartTime = 0;
+      CurrentTime = 0;
+      LiveSpeedArr = 0;
+      currentSpeed = 0;
+    }
+    var userAgentString;
+    if (window.navigator.userAgent) {
+      userAgentString = window.navigator.userAgent;
+    } else {
+      userAgentString = "Not Found";
+    }
+    var ulFinal = ulDuration * 0.6;
+    var dlFinal = dlDuration * 0.6;
+    function setFinal() {
+      if (ulDuration * 0.6 >= 7) {
+        ulFinal = 7;
+      }
+      if (dlDuration * 0.6 >= 7) {
+        dlFinal = 7;
+      }
+    }
+    setFinal();
+    var launch = true;
+    var init = true;
+    Get.addEvt(Show.settingsMob.el, "click", ShowIP);
+    Get.addEvt(Show.settingsDesk.el, "click", ShowIP);
+    Get.addEvt(Show.startButtonDesk.el, "click", runTasks);
+    Get.addEvt(Show.startButtonMob.el, "click", runTasks);
+    Get.addEvt(document, "keypress", hiEnter);
+    var addEvent = true;
+    var getParams = function(url) {
+      var params = {};
+      var parser = document.createElement("a");
+      parser.href = url;
+      var query = parser.search.substring(1);
+      var vars = query.split("&");
+      for (var i = 0; i < vars.length; i++) {
+        var pair = vars[i].split("=");
+        params[pair[0]] = decodeURIComponent(pair[1]);
+      }
+      return params;
+    };
+    var getCommand = getParams(window.location.href.toLowerCase());
+    if (setPingSamples) {
+      if (typeof getCommand.ping === "string" || typeof getCommand.p === "string") {
+        var setPing;
+        if (typeof getCommand.ping !== "undefined") {
+          setPing = getCommand.ping;
+        } else if (typeof getCommand.p !== "undefined") {
+          setPing = getCommand.p;
+        }
+        if (setPing > 0) {
+          pingSamples = setPing;
+          pingSamples = setPing;
+        }
+      }
+    }
+    if (setPingTimeout) {
+      if (typeof getCommand.out === "string" || typeof getCommand.o === "string") {
+        var setOut;
+        if (typeof getCommand.out !== "undefined") {
+          setOut = getCommand.out;
+        } else if (typeof getCommand.o !== "undefined") {
+          setOut = getCommand.o;
+        }
+        if (setOut > 1) {
+          pingTimeOut = setOut;
+          pingTimeOut = setOut;
+        }
+      }
+    }
+    if (setHTTPReq) {
+      if (typeof getCommand.xhr === "string" || typeof getCommand.x === "string") {
+        var setThreads;
+        if (typeof getCommand.xhr !== "undefined") {
+          setThreads = getCommand.xhr;
+        } else if (typeof getCommand.x !== "undefined") {
+          setThreads = getCommand.x;
+        }
+        if (setThreads > 0 && setThreads <= 32) {
+          dlThreads = setThreads;
+          ulThreads = setThreads;
+        }
+      }
+    }
+    function isValidHttpUrl(str) {
+      var regex = /(?:https?):\/\/(\w+:?\w*)?(\S+)(:\d+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
+      if (!regex.test(str)) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+    if (selectServer) {
+      if (typeof getCommand.host === "string" || typeof getCommand.h === "string") {
+        var severAddress;
+        if (typeof getCommand.host !== "undefined") {
+          severAddress = getCommand.host;
+        } else if (typeof getCommand.h !== "undefined") {
+          severAddress = getCommand.h;
+        }
+        if (isValidHttpUrl(severAddress)) {
+          openSpeedTestServerList = [{ServerName:"Home", Download:severAddress + "/downloading", Upload:severAddress + "/upload", ServerIcon:"DefaultIcon",},];
+        }
+      }
+    }
+    var custom = parseInt(getCommand.stress);
+    var customS = parseInt(getCommand.s);
+    var runStress;
+    var runStressCustom;
+    if (typeof getCommand.stress === "string") {
+      runStress = getCommand.stress;
+      runStressCustom = custom;
+    } else if (typeof getCommand.s === "string") {
+      runStress = getCommand.s;
+      runStressCustom = customS;
+    }
+    if (runStress && stressTest) {
+      if (runStress === "low" || runStress === "l") {
+        dlDuration = 300;
+        ulDuration = 300;
+      }
+      if (runStress === "medium" || runStress === "m") {
+        dlDuration = 600;
+        ulDuration = 600;
+      }
+      if (runStress === "high" || runStress === "h") {
+        dlDuration = 900;
+        ulDuration = 900;
+      }
+      if (runStress === "veryhigh" || runStress === "v") {
+        dlDuration = 1800;
+        ulDuration = 1800;
+      }
+      if (runStress === "extreme" || runStress === "e") {
+        dlDuration = 3600;
+        ulDuration = 3600;
+      }
+      if (runStress === "day" || runStress === "d") {
+        dlDuration = 86400;
+        ulDuration = 86400;
+      }
+      if (runStress === "year" || runStress === "y") {
+        dlDuration = 31557600;
+        ulDuration = 31557600;
+      }
+      if (custom > 12 || customS > 12) {
+        dlDuration = runStressCustom;
+        ulDuration = runStressCustom;
+      }
+    }
+    var overheadClean = parseInt(getCommand.clean);
+    var overheadCleanC = parseInt(getCommand.c);
+    var customOverHeadValue = 1;
+    if (overheadClean) {
+      customOverHeadValue = overheadClean;
+    } else if (overheadCleanC) {
+      customOverHeadValue = overheadCleanC;
+    }
+    if (enableClean) {
+      if (typeof getCommand.clean === "string" || typeof getCommand.c === "string") {
+        if (overheadClean >= 1 || overheadCleanC >= 1) {
+          if (overheadClean < 5 || overheadCleanC < 5) {
+            upAdjust = 1 + customOverHeadValue / 100;
+            dlAdjust = 1 + customOverHeadValue / 100;
+          }
+        } else {
+          upAdjust = 1;
+          dlAdjust = 1;
+        }
+      }
+    }
+    var OpenSpeedTestRun = parseInt(getCommand.run);
+    var OpenSpeedTestRunR = parseInt(getCommand.r);
+    var OpenSpeedTestStart;
+    if (enableRun) {
+      if (typeof getCommand.run === "string" || typeof getCommand.r === "string") {
+        if (OpenSpeedTestRun > 0) {
+          OpenSpeedTestStart = OpenSpeedTestRun;
+        } else if (OpenSpeedTestRunR > 0) {
+          OpenSpeedTestStart = OpenSpeedTestRunR;
+        } else {
+          OpenSpeedTestStart = 0;
+        }
+      }
+    }
+    if (OpenSpeedTestStart >= 0) {
+      if (launch) {
+        runTasks();
+      }
+    }
+    var runTest = getCommand.test;
+    var runTestT = getCommand.t;
+    var SelectTest = false;
+    if (selectTest) {
+      if (typeof runTest === "string" || typeof runTestT === "string") {
+        var runTestC;
+        if (runTest) {
+          runTestC = runTest;
+          SelectTest = runTest;
+        } else if (runTestT) {
+          runTestC = runTestT;
+          SelectTest = runTestT;
+        }
+        if (runTestC === "download" || runTestC === "d") {
+          uploadSpeed = 0;
+          dataUsedforul = 0;
+          SelectTest = "Download";
+          if (launch) {
+            runTasks();
+          }
+        } else if (runTestC === "upload" || runTestC === "u") {
+          downloadSpeed = 0;
+          dataUsedfordl = 0;
+          SelectTest = "Upload";
+          stop = 1;
+          if (launch) {
+            runTasks();
+          }
+        } else if (runTestC === "ping" || runTestC === "p") {
+          uploadSpeed = 0;
+          dataUsedforul = 0;
+          downloadSpeed = 0;
+          dataUsedfordl = 0;
+          SelectTest = "Ping";
+          if (launch) {
+            runTasks();
+          }
+        } else {
+          SelectTest = false;
+        }
+      }
+    }
+    var Startit = 0;
+    function removeEvts() {
+      Get.remEvt(Show.settingsMob.el, "click", ShowIP);
+      Get.remEvt(Show.settingsDesk.el, "click", ShowIP);
+      Get.remEvt(Show.startButtonDesk.el, "click", runTasks);
+      Get.remEvt(Show.startButtonMob.el, "click", runTasks);
+      Get.remEvt(document, "keypress", hiEnter);
+    }
+    var requestIP = false;
+    function ShowIP() {
+      if (requestIP) {
+        Show.YourIP.el.textContent = "Please wait..";
+        ServerConnect(7);
+        requestIP = false;
+      }
+      Show.ip();
+    }
+    function runTasks() {
+      if (addEvent) {
+        removeEvts();
+        addEvent = false;
+      }
+      if (OpenSpeedTestStart >= 0) {
+        launch = false;
+        Show.userInterface();
+        init = false;
+        var AutoTme = Math.ceil(Math.abs(OpenSpeedTestStart));
+        Show.showStatus("Automatic Test Starts in ...");
+        var autoTest = setInterval(countDownF, 1000);
+      }
+      function countDownF() {
+        if (AutoTme >= 1) {
+          AutoTme = AutoTme - 1;
+          Show.LiveSpeed(AutoTme, "countDown");
+        } else {
+          if (AutoTme <= 0) {
+            clearInterval(autoTest);
+            launch = true;
+            OpenSpeedTestStart = undefined;
+            runTasks();
+          }
+        }
+      }
+      if (openSpeedTestServerList === "fetch" && launch === true) {
+        launch = false;
+        Show.showStatus("Fetching Server Info..");
+        ServerConnect(6);
+      }
+      if (launch === true) {
+        if (SelectTest === "Ping") {
+          testRun();
+        } else if (SelectTest === "Download") {
+          testRun();
+        } else if (SelectTest === "Upload") {
+          testRun();
+        } else if (SelectTest === false) {
+          testRun();
+        }
+      }
+    }
+    var osttm = "\u2122";
+    var myname = "OpenSpeedTest";
+    var com = ".com";
+    var ost = myname + osttm;
+    function hiEnter(e) {
+      if (e.key === "Enter") {
+        runTasks();
+      }
+    }
+    var showResult = 0;
+    if (openChannel === "web") {
+      showResult = webRe;
+      requestIP = true;
+    }
+    if (openChannel === "widget") {
+      showResult = widgetRe;
+      requestIP = true;
+    }
+    if (openChannel === "selfwidget") {
+      showResult = widgetRe;
+      TestServerip = domainx;
+      myhostName = TestServerip;
+    }
+    if (openChannel === "dev") {
+    }
+    function testRun() {
+      if (init) {
+        Show.userInterface();
+        init = false;
+      }
+      OpenSpeedtest();
+    }
+    function OpenSpeedtest() {
+      if (openChannel === "widget" || openChannel === "web") {
+        ServerConnect(1);
+      }
+      function readyToUP() {
+        uploadTime = window.performance.now();
+        upReq();
+      }
+      var Engine = setInterval(function() {
+        if (Status === "Loaded") {
+          Status = "busy";
+          sendPing(0);
+        }
+        if (Status === "Ping") {
+          Status = "busy";
+          Show.showStatus("Milliseconds");
+        }
+        if (Status === "Download") {
+          Show.showStatus("Initializing..");
+          Get.reset();
+          reSett();
+          Show.reset();
+          downloadTime = window.performance.now();
+          downReq();
+          Status = "initDown";
+        }
+        if (Status === "Downloading") {
+          Show.Symbol(0);
+          if (Startit == 0) {
+            Startit = 1;
+            Show.showStatus("Testing download speed..");
+            var extraTime = (window.performance.now() - downloadTime) / 1000;
+            dReset = extraTime;
+            Show.progress(1, dlDuration + 2.5);
+            dlDuration += extraTime;
+          }
+          downloadTimeing = (window.performance.now() - downloadTime) / 1000;
+          reportCurrentSpeed("dl");
+          Show.showStatus("Mbps download");
+          Show.mainGaugeProgress(currentSpeed);
+          Show.LiveSpeed(currentSpeed);
+          Show.Graph(currentSpeed, 0);
+          downloadSpeed = Get.AvgSpeed(currentSpeed, dlFinal, dlDuration);
+          if (downloadTimeing >= dlDuration && ProG == "done") {
+            if (SelectTest) {
+              Show.GaugeProgresstoZero(currentSpeed, "SendR");
+              Show.showStatus("All done");
+              Show.Symbol(2);
+            } else {
+              Show.GaugeProgresstoZero(currentSpeed, "Upload");
+            }
+            Show.downloadResult(downloadSpeed);
+            dataUsedfordl = dLoaded;
+            stop = 1;
+            Status = "busy";
+            reSett();
+            Get.reset();
+          }
+        }
+        if (Status == "Upload") {
+          if (stop === 1) {
+            Show.Symbol(1);
+            Status = "initup";
+            Show.showStatus("Initializing..");
+            Show.LiveSpeed("...", "speedToZero");
+            SendData = Get.uRandom(ulDataSize, readyToUP);
+            if (SelectTest) {
+              Startit = 1;
+            }
+          }
+        }
+        if (Status === "Uploading") {
+          if (Startit == 1) {
+            Startit = 2;
+            Show.showStatus("Testing upload speed..");
+            currentSpeed = 0;
+            Get.reset();
+            Show.reset();
+            var extraUTime = (window.performance.now() - uploadTime) / 1000;
+            uReset = extraUTime;
+            Show.progress(false, ulDuration + 2.5);
+            ulDuration += extraUTime;
+          }
+          Show.showStatus("Mbps upload");
+          uploadTimeing = (window.performance.now() - uploadTime) / 1000;
+          reportCurrentSpeed("up");
+          Show.mainGaugeProgress(currentSpeed);
+          Show.LiveSpeed(currentSpeed);
+          Show.Graph(currentSpeed, 1);
+          uploadSpeed = Get.AvgSpeed(currentSpeed, ulFinal, ulDuration);
+          if (uploadTimeing >= ulDuration && stop == 1) {
+            dataUsedforul = uLoaded;
+            Show.uploadResult(uploadSpeed);
+            Show.GaugeProgresstoZero(currentSpeed, "SendR");
+            SendData = undefined;
+            Show.showStatus("All done");
+            Show.Symbol(2);
+            Status = "busy";
+            stop = 0;
+          }
+        }
+        if (Status === "Error") {
+          Show.showStatus("Check your network connection status.");
+          Show.ConnectionError();
+          Status = "busy";
+          clearInterval(Engine);
+          var dummyElement = document.createElement("div");
+          dummyElement.innerHTML = '<a xlink:href="https://openspeedtest.com/FAQ.php?ref=NetworkError" style="cursor: pointer" target="_blank"></a>';
+          var htmlAnchorElement = dummyElement.querySelector("a");
+          Show.oDoLiveSpeed.el.textContent = "Network Error";
+          var circleSVG = document.getElementById("oDoLiveSpeed");
+          htmlAnchorElement.innerHTML = circleSVG.innerHTML;
+          circleSVG.innerHTML = dummyElement.innerHTML;
+        }
+        if (Status === "SendR") {
+          Show.showStatus("All done");
+          var dummyElement = document.createElement("div");
+          dummyElement.innerHTML = '<a xlink:href="https://openspeedtest.com?ref=Self-Hosted-Outro&run=5" style="cursor: pointer" target="_blank"></a>';
+          var htmlAnchorElement = dummyElement.querySelector("a");
+          Show.oDoLiveSpeed.el.textContent = ost;
+          var circleSVG = document.getElementById("oDoLiveSpeed");
+          htmlAnchorElement.innerHTML = circleSVG.innerHTML;
+          circleSVG.innerHTML = dummyElement.innerHTML;
+          if (location.hostname != myname.toLowerCase() + com) {
+            saveTestData = "https://" + myname.toLowerCase() + com + "/results/show.php?" + "&d=" + downloadSpeed.toFixed(3) + "&u=" + uploadSpeed.toFixed(3) + "&p=" + pingEstimate + "&j=" + jitterEstimate + "&dd=" + (dataUsedfordl / 1048576).toFixed(3) + "&ud=" + (dataUsedforul / 1048576).toFixed(3) + "&ua=" + userAgentString;
+            saveTestData = encodeURI(saveTestData);
+            var circleSVG2 = document.getElementById("resultsData");
+            circleSVG2.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", saveTestData);
+            circleSVG2.setAttribute("target", "_blank");
+            if (saveData) {
+              ServerConnect(5);
+            }
+          } else {
+            ServerConnect(3);
+          }
+          Status = "busy";
+          clearInterval(Engine);
+        }
+      }, 100);
+    }
+    function downReq() {
+      for (var i = 0; i < dlThreads; i++) {
+        setTimeout(function(i) {
+          SendReQ(i);
+        }, dlDelay * i, i);
+      }
+    }
+    function upReq() {
+      for (var i = 0; i < ulThreads; i++) {
+        setTimeout(function(i) {
+          SendUpReq(i);
+        }, ulDelay * i, i);
+      }
+    }
+    var dLoad = 0;
+    var dDiff = 0;
+    var dTotal = 0;
+    var dtLoad = 0;
+    var dtDiff = 0;
+    var dtTotal = 0;
+    var dRest = 0;
+    var dReset;
+    var uReset;
+    var uLoad = 0;
+    var uDiff = 0;
+    var uTotal = 0;
+    var utLoad = 0;
+    var utDiff = 0;
+    var utTotal = 0;
+    var uRest = 0;
+    var dualReset;
+    var neXT = dlDuration * 1000 - 6000;
+    var dualupReset;
+    var neXTUp = ulDuration * 1000 - 6000;
+    function reportCurrentSpeed(now) {
+      if (now === "dl") {
+        var dTime = downloadTimeing * 1000;
+        if (dTime > dReset * 1000 + dlFinal / 2 * 1000 && dRest === 0) {
+          dRest = 1;
+          dtTotal = dtTotal * 0.01;
+          dTotal = dTotal * 0.01;
+          dualReset = dTime + 10000;
+        }
+        if (dTime >= dualReset && dualReset < neXT) {
+          dualReset += 10000;
+          dtTotal = dtTotal * 0.01;
+          dTotal = dTotal * 0.01;
+        }
+        dLoad = dLoaded <= 0 ? 0 : dLoaded - dDiff;
+        dDiff = dLoaded;
+        dTotal += dLoad;
+        dtLoad = dtDiff = 0 ? 0 : dTime - dtDiff;
+        dtDiff = dTime;
+        dtTotal += dtLoad;
+        if (dTotal > 0) {
+          LiveSpeedArr = dTotal / dtTotal / 125 * upAdjust;
+          currentSpeed = LiveSpeedArr;
+        }
+      }
+      if (now === "up") {
+        var Tym = uploadTimeing * 1000;
+        if (Tym > uReset * 1000 + ulFinal / 2 * 1000 && uRest === 0) {
+          uRest = 1;
+          utTotal = utTotal * 0.1;
+          uTotal = uTotal * 0.1;
+          dualupReset = Tym + 10000;
+        }
+        if (Tym >= dualupReset && dualupReset < neXTUp) {
+          dualupReset += 10000;
+          utTotal = utTotal * 0.1;
+          uTotal = uTotal * 0.1;
+        }
+        uLoad = uLoaded <= 0 ? 0 : uLoaded - uDiff;
+        uDiff = uLoaded;
+        uTotal += uLoad;
+        utLoad = utDiff = 0 ? 0 : Tym - utDiff;
+        utDiff = Tym;
+        utTotal += utLoad;
+        if (uTotal > 0) {
+          LiveSpeedArr = uTotal / utTotal / 125 * upAdjust;
+          currentSpeed = LiveSpeedArr;
+        }
+      }
+    }
+    function SendReQ(i) {
+      var lastLoaded = 0;
+      var OST = new XMLHttpRequest();
+      ReQ[i] = OST;
+      ReQ[i].open("GET", fianlPingServer.Download + "?n=" + Math.random(), true);
+      ReQ[i].onprogress = function(e) {
+        if (stop === 1) {
+          ReQ[i].abort();
+          ReQ[i] = null;
+          ReQ[i] = undefined;
+          delete ReQ[i];
+          return false;
+        }
+        if (Status == "initDown") {
+          Status = "Downloading";
+        }
+        var eLoaded = e.loaded <= 0 ? 0 : e.loaded - lastLoaded;
+        if (isNaN(eLoaded) || !isFinite(eLoaded) || eLoaded < 0) {
+          return false;
+        }
+        dLoaded += eLoaded;
+        lastLoaded = e.loaded;
+      };
+      ReQ[i].onload = function(e) {
+        if (lastLoaded === 0) {
+          dLoaded += e.total;
+        }
+        if (Status == "initDown") {
+          Status = "Downloading";
+        }
+        if (ReQ[i]) {
+          ReQ[i].abort();
+          ReQ[i] = null;
+          ReQ[i] = undefined;
+          delete ReQ[i];
+        }
+        if (stop === 0) {
+          SendReQ(i);
+        }
+      };
+      ReQ[i].onerror = function(e) {
+        if (stop === 0) {
+          SendReQ(i);
+        }
+      };
+      ReQ[i].responseType = "arraybuffer";
+      ReQ[i].send();
+    }
+    var uReQ = [];
+    function SendUpReq(i) {
+      var lastULoaded = 0;
+      var OST = new XMLHttpRequest();
+      uReQ[i] = OST;
+      uReQ[i].open("POST", fianlPingServer.Upload + "?n=" + Math.random(), true);
+      uReQ[i].upload.onprogress = function(e) {
+        if (Status == "initup" && some === undefined) {
+          var some;
+          Status = "Uploading";
+        }
+        if (uploadTimeing >= ulDuration) {
+          uReQ[i].abort();
+          uReQ[i] = null;
+          uReQ[i] = undefined;
+          delete uReQ[i];
+          return false;
+        }
+        var eLoaded = e.loaded <= 0 ? 0 : e.loaded - lastULoaded;
+        if (isNaN(eLoaded) || !isFinite(eLoaded) || eLoaded < 0) {
+          return false;
+        }
+        uLoaded += eLoaded;
+        lastULoaded = e.loaded;
+      };
+      uReQ[i].onload = function() {
+        if (lastULoaded === 0) {
+          uLoaded += ulDataSize * 1048576;
+          if (uploadTimeing >= ulDuration) {
+            uReQ[i].abort();
+            uReQ[i] = null;
+            uReQ[i] = undefined;
+            delete uReQ[i];
+            return false;
+          }
+        }
+        if (Status == "initup" && some === undefined) {
+          var some;
+          Status = "Uploading";
+        }
+        if (uReQ[i]) {
+          uReQ[i].abort();
+          uReQ[i] = null;
+          uReQ[i] = undefined;
+          delete uReQ[i];
+        }
+        if (stop === 1) {
+          SendUpReq(i);
+        }
+      };
+      uReQ[i].onerror = function(e) {
+        if (uploadTimeing <= ulDuration) {
+          SendUpReq(i);
+        }
+      };
+      uReQ[i].setRequestHeader("Content-Type", "application/octet-stream");
+      if (i > 0 && uLoaded <= 17000) {
+      } else {
+        uReQ[i].send(SendData);
+      }
+    }
+    function sendPing() {
+      readServerList();
+    }
+    var fianlPingServer;
+    var statusPing;
+    var statusPingFinal;
+    var statusJitter;
+    var statusJitterFinal;
+    var statusPingTest;
+    var pingSendStatus = -1;
+    var finalPing = [];
+    var pingServer = [];
+    var finalJitter = [];
+    var pingSendLength = openSpeedTestServerList.length;
+    function readServerList() {
+      pingSendLength = openSpeedTestServerList.length;
+      Status = "Ping";
+      performance.clearResourceTimings();
+      if (pingSendStatus < pingSendLength - 1) {
+        pingSendStatus++;
+        if (statusPingTest != "Stop") {
+          sendPingRequest(openSpeedTestServerList[pingSendStatus], readServerList);
+        }
+      } else {
+        if (pingServer.length >= 1) {
+          var finalLeastPingResult = Math.min.apply(Math, finalPing);
+          var finalLeastPingResultIndex = finalPing.indexOf(finalLeastPingResult);
+          fianlPingServer = pingServer[finalLeastPingResultIndex];
+          statusPingFinal = finalLeastPingResult;
+          statusJitterFinal = finalJitter[finalLeastPingResultIndex];
+          statusPingTest = "Busy";
+          Show.LiveSpeed(statusPingFinal, "Ping");
+          Show.pingResults(statusPingFinal, "Ping");
+          Show.jitterResult(statusJitterFinal, "Jitter");
+          pingEstimate = statusPingFinal;
+          jitterEstimate = statusJitterFinal;
+          if (SelectTest) {
+            if (SelectTest == "Ping") {
+              Status = "SendR";
+            } else {
+              Status = SelectTest;
+            }
+          } else {
+            Status = "Download";
+          }
+        } else {
+          if (pingServer.Download) {
+          } else {
+            Status = "Error";
+          }
+        }
+      }
+    }
+    function sendPingRequest(serverListElm, callback) {
+      var pingSamplesSend = 0;
+      var pingResult = [];
+      var jitterResult = [];
+      function sendNewPingReq() {
+        if (pingSamplesSend < pingSamples) {
+          pingSamplesSend++;
+          if (statusPingTest != "Stop") {
+            PingRequest();
+          }
+        } else {
+          if (pingResult.length > 1) {
+            jitterResult.sort(function(a, b) {
+              return a - b;
+            });
+            jitterResult = jitterResult.slice(0, jitterResult.length * jitterFinalSample);
+            jitterResult = jitterResult.reduce(function(acc, val) {
+              return acc + val;
+            }, 0) / jitterResult.length;
+            var leastJitter = jitterResult.toFixed(1);
+            var leastPing = Math.min.apply(Math, pingResult);
+            finalPing.push(leastPing);
+            pingServer.push(serverListElm);
+            finalJitter.push(leastJitter);
+            if (typeof callback === "function") {
+              callback();
+            }
+          } else {
+            if (typeof callback === "function") {
+              callback();
+            }
+          }
+        }
+      }
+      function PingRequest() {
+        var OST = new XMLHttpRequest();
+        var ReQ = OST;
+        if (statusPingTest != "Stop") {
+          ReQ.abort();
+        }
+        ReQ.open(pingMethod, serverListElm[pingFile] + "?n=" + Math.random(), true);
+        ReQ.timeout = pingTimeOut;
+        var startTime = window.performance.now();
+        ReQ.send();
+        ReQ.onload = function() {
+          if (this.status === 200 && this.readyState === 4) {
+            var endTime = Math.floor(window.performance.now() - startTime);
+            var perfNum = performance.getEntries();
+            perfNum = perfNum[perfNum.length - 1];
+            var perfPing;
+            if (perfNum.initiatorType === "xmlhttprequest") {
+              perfPing = parseFloat(perfNum.duration.toFixed(1));
+            } else {
+              perfPing = endTime;
+            }
+            if (pingSamplesSend > 250) {
+              perfPing = endTime;
+            }
+            if (perfPing <= 0) {
+              statusPing = 0.1;
+              pingResult.push(0.1);
+            } else {
+              statusPing = perfPing;
+              pingResult.push(perfPing);
+            }
+            if (pingResult.length > 1) {
+              var jitterCalc = Math.abs(pingResult[pingResult.length - 1] - pingResult[pingResult.length - 2]).toFixed(1);
+              jitterResult.push(parseFloat(jitterCalc));
+              statusJitter = jitterCalc;
+              Show.LiveSpeed(perfPing, "Ping");
+              Show.pingResults(perfPing, "Ping");
+              Show.jitterResult(jitterCalc, "Jitter");
+            }
+            sendNewPingReq();
+          }
+          if (this.status === 404 && this.readyState === 4) {
+            pingSamplesSend++;
+            sendNewPingReq();
+          }
+        };
+        ReQ.onerror = function(e) {
+          pingSamplesSend++;
+          sendNewPingReq();
+        };
+        ReQ.ontimeout = function(e) {
+          pingSamplesSend++;
+          sendNewPingReq();
+        };
+      }
+      PingRequest();
+    }
+    var ServerConnect = function(auth) {
+      var Self = this;
+      var xhr = new XMLHttpRequest();
+      var url = OpenSpeedTestdb;
+      if (auth == 1) {
+        url = webIP;
+      }
+      if (auth == 5) {
+        url = saveDataURL;
+      }
+      if (auth == 7) {
+        url = get_IP;
+      }
+      xhr.open("POST", url, true);
+      xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
+      xhr.onreadystatechange = function() {
+        if (xhr.readyState == 4 && xhr.status == 200) {
+          return_data = xhr.responseText.trim();
+          if (auth == 2) {
+            key = return_data;
+          }
+          if (auth == 1) {
+            TestServerip = return_data;
+          }
+          if (auth == 3) {
+            setTimeout(function() {
+              location.href = showResult + return_data;
+            }, 1500);
+          }
+          if (auth == 6) {
+            openSpeedTestServerList = JSON.parse(return_data);
+            launch = true;
+            runTasks();
+          }
+          if (auth == 7) {
+            Show.YourIP.el.textContent = return_data;
+          }
+        }
+      };
+      if (auth == 2) {
+        logData = "r=n";
+      }
+      if (auth == 3) {
+        logData = "r=l" + "&d=" + downloadSpeed + "&u=" + uploadSpeed + "&dd=" + dataUsedfordl / 1048576 + "&ud=" + dataUsedforul / 1048576 + "&p=" + pingEstimate + "&do=" + myhostName + "&S=" + key + "&sip=" + TestServerip + "&jit=" + jitterEstimate + "&ua=" + userAgentString;
+      }
+      if (auth == 5) {
+        logData = saveTestData;
+      }
+      if (auth == 6) {
+        logData = "r=s";
+      }
+      xhr.send(logData);
+    };
+  };
+  OpenSpeedTest.Start = function() {
+    new openSpeedtestEngine();
+  };
+})(window.OpenSpeedTest = window.OpenSpeedTest || {});

files/www/assets/js/app-2.5.4.min.js

@@ -0,0 +1,51 @@
+/*
+     Official Website : https://OpenSpeedTest.COM | Email: support@openspeedtest.com
+     Developed by : Vishnu | https://Vishnu.Pro | Email : me@vishnu.pro 
+     Like this Project? Please Donate NOW & Keep us Alive -> https://go.openspeedtest.com/Donate
+    Speed Test by OpenSpeedTest™️ is Free and Open-Source Software (FOSS) with MIT License.
+    Read full license terms @ http://go.openspeedtest.com/License
+    If you have any Questions, ideas or Comments Please Send it via -> https://go.openspeedtest.com/SendMessage
+*/       
+window.onload=function(){var X=document.getElementById("OpenSpeedTest-UI");X.parentNode.replaceChild(X.contentDocument.documentElement,X);ostOnload();OpenSpeedTest.Start()};
+(function(X){function h(c){if(!(this instanceof h))return new h(c);this.el=document.getElementById(c)}var m,Ma,Na=function(c){c&&"function"===typeof c&&c()};h.prototype.fade=function(c,d,a){var f="in"===c,t=f?0:1,w=14/d,n=this;f&&(n.el.style.display="block",n.el.style.opacity=t);var q=window.setInterval(function(){t=f?t+w:t-w;n.el.style.opacity=t;0>=t&&(n.el.style.display="none");(0>=t||1<=t)&&window.clearInterval(q,Na(a))},14)};var Oa=function(c,d,a,f){c/=f;c--;return a*(c*c*c+1)+d},r=function(){this.YourIP=
+h("YourIP");this.ipDesk=h("ipDesk");this.ipMob=h("ipMob");this.downSymbolDesk=h("downSymbolDesk");this.upSymbolDesk=h("upSymbolDesk");this.upSymbolMob=h("upSymbolMob");this.downSymbolMob=h("downSymbolMob");this.settingsMob=h("settingsMob");this.settingsDesk=h("settingsDesk");this.oDoLiveStatus=h("oDoLiveStatus");this.ConnectErrorMob=h("ConnectErrorMob");this.ConnectErrorDesk=h("ConnectErrorDesk");this.downResult=h("downResult");this.upRestxt=h("upRestxt");this.pingResult=h("pingResult");this.jitterDesk=
+h("jitterDesk");this.pingMobres=h("pingMobres");this.JitterResultMon=h("JitterResultMon");this.JitterResultms=h("JitterResultms");this.UI_Desk=h("UI-Desk");this.UI_Mob=h("UI-Mob");this.oDoTopSpeed=h("oDoTopSpeed");this.startButtonMob=h("startButtonMob");this.startButtonDesk=h("startButtonDesk");this.intro_Desk=h("intro-Desk");this.intro_Mob=h("intro-Mob");this.loader=h("loading_app");this.OpenSpeedtest=h("OpenSpeedtest");this.mainGaugebg_Desk=h("mainGaugebg-Desk");this.mainGaugeBlue_Desk=h("mainGaugeBlue-Desk");
+this.mainGaugeWhite_Desk=h("mainGaugeWhite-Desk");this.mainGaugebg_Mob=h("mainGaugebg-Mob");this.mainGaugeBlue_Mob=h("mainGaugeBlue-Mob");this.mainGaugeWhite_Mob=h("mainGaugeWhite-Mob");this.oDoLiveSpeed=h("oDoLiveSpeed");this.progressStatus_Mob=h("progressStatus-Mob");this.progressStatus_Desk=h("progressStatus-Desk");this.graphc1=h("graphc1");this.graphc2=h("graphc2");this.graphMob2=h("graphMob2");this.graphMob1=h("graphMob1");this.text=h("text");this.scale=[{degree:680,value:0},{degree:570,value:.5},
+{degree:460,value:1},{degree:337,value:10},{degree:220,value:100},{degree:115,value:500},{degree:0,value:1E3}];this.polygon=this.chart=this.element="";this.width=200;this.height=50;this.maxValue=0;this.values=[];this.points=[];this.vSteps=5;this.measurements=[];this.points=[]};r.prototype.reset=function(){this.polygon=this.chart=this.element="";this.width=200;this.height=50;this.maxValue=0;this.values=[];this.points=[];this.vSteps=5;this.measurements=[];this.points=[]};r.prototype.ip=function(){"block"===
+this.ipDesk.el.style.display?(this.ipDesk.el.style.display="none",this.ipMob.el.style.display="none"):(this.ipDesk.el.style.display="block",this.ipMob.el.style.display="block")};r.prototype.prePing=function(){this.loader.fade("out",500);this.OpenSpeedtest.fade("in",1E3)};r.prototype.app=function(){this.loader.fade("out",500,this.ShowAppIntro())};r.prototype.ShowAppIntro=function(){this.OpenSpeedtest.fade("in",1E3)};r.prototype.userInterface=function(){this.intro_Desk.fade("out",1E3);this.intro_Mob.fade("out",
+1E3,this.ShowUI())};r.prototype.ShowUI=function(){this.UI_Desk.fade("in",1E3);this.UI_Mob.fade("in",1E3,function(c){m="Loaded";console.log("Developed by Vishnu. Email --\x3e me@vishnu.pro")})};r.prototype.Symbol=function(c){0==c&&(this.downSymbolMob.el.style.display="block",this.downSymbolDesk.el.style.display="block",this.upSymbolMob.el.style.display="none",this.upSymbolDesk.el.style.display="none");1==c&&(this.downSymbolMob.el.style.display="none",this.downSymbolDesk.el.style.display="none",this.upSymbolMob.el.style.display=
+"block",this.upSymbolDesk.el.style.display="block");2==c&&(this.downSymbolMob.el.style.display="none",this.downSymbolDesk.el.style.display="none",this.upSymbolMob.el.style.display="none",this.upSymbolDesk.el.style.display="none")};r.prototype.Graph=function(c,d){function a(q,M){for(n=f.maxValue=0;n<f.values.length;n++)f.values[n]>f.maxValue&&(f.maxValue=f.values[n]);f.maxValue=Math.ceil(f.maxValue);if(1<f.values.length){var F="0,"+f.height+" ";for(n=0;n<f.values.length;n++){var Q=f.values[n]/f.maxValue;
+Q=(130/(f.values.length-1)*n).toFixed(2)+","+(f.height-f.height*Q).toFixed(2)+" ";F+=Q}F+="130,"+f.height;f.points=F}for(n=0;n<f.vSteps;n++)f.measurements.push(Math.ceil(f.maxValue/f.vSteps*(n+1)));f.measurements.reverse();for(F=document.getElementsByClassName(w);0<F.length;)F[0].remove();f.polygon=document.createElementNS("http://www.w3.org/2000/svg","polygon");f.polygon.setAttribute("points",f.points);f.polygon.setAttribute("class",w);1<f.values.length&&t.appendChild(f.polygon)}"remove"in Element.prototype||
+(Element.prototype.remove=function(){this.parentNode&&this.parentNode.removeChild(this)});var f=this;if(0===d){var t=this.graphc1.el;var w="line";this.graphMob2.el.style.display="none";this.graphMob1.el.style.display="block"}else t=this.graphc2.el,w="line2",this.graphMob1.el.style.display="none",this.graphMob2.el.style.display="block";isNaN(c)?this.values.push(""):this.values.push(c);var n;0<c&&a(t,c)};r.prototype.progress=function(c,d){var a=this,f=Date.now(),t=setInterval(function(){var w=(Date.now()-
+f)/1E3,n=Oa(w,400,400,d),q=Oa(w,400,-400,d);c?(a.progressStatus_Desk.el.style.strokeDashoffset=n,a.progressStatus_Mob.el.style.strokeDashoffset=n):(a.progressStatus_Desk.el.style.strokeDashoffset=q,a.progressStatus_Mob.el.style.strokeDashoffset=q);w>=d&&(clearInterval(t),Ma="done",a.progressStatus_Desk.el.style.strokeDashoffset=800,a.progressStatus_Mob.el.style.strokeDashoffset=800)},14)};r.prototype.mainGaugeProgress=function(c){var d=c;0>d&&(d=0);var a=this.getNonlinearDegree(d);0<c&&(this.mainGaugeBlue_Desk.el.style.strokeOpacity=
+1,this.mainGaugeWhite_Desk.el.style.strokeOpacity=1,this.mainGaugeBlue_Mob.el.style.strokeOpacity=1,this.mainGaugeWhite_Mob.el.style.strokeOpacity=1,this.mainGaugeBlue_Desk.el.style.strokeDashoffset=a,this.mainGaugeWhite_Desk.el.style.strokeDashoffset=0==a?1:a+1,this.mainGaugeBlue_Mob.el.style.strokeDashoffset=a,this.mainGaugeWhite_Mob.el.style.strokeDashoffset=0==a?1:a+1);0==a&&1E3<d?(this.mainGaugeBlue_Mob.el.style.strokeDashoffset=681<=a?681:a,this.mainGaugeWhite_Mob.el.style.strokeDashoffset=
+0==a?1:a+1,this.mainGaugeWhite_Desk.el.style.strokeDashoffset=0==a?1:a+1,this.mainGaugeBlue_Desk.el.style.strokeDashoffset=681<=a?681:a):0==a&&0>=d&&(this.mainGaugeBlue_Mob.el.style.strokeDashoffset=681.1,this.mainGaugeWhite_Mob.el.style.strokeDashoffset=.1,this.mainGaugeWhite_Desk.el.style.strokeDashoffset=.1,this.mainGaugeBlue_Desk.el.style.strokeDashoffset=681.1)};r.prototype.showStatus=function(c){this.oDoLiveStatus.el.textContent=c};r.prototype.ConnectionError=function(){this.ConnectErrorMob.el.style.display=
+"block";this.ConnectErrorDesk.el.style.display="block"};r.prototype.uploadResult=function(c){1>c&&(this.upRestxt.el.textContent=c.toFixed(3));1<=c&&9999>c&&(this.upRestxt.el.textContent=c.toFixed(1));1E4<=c&&99999>c&&(this.upRestxt.el.textContent=c.toFixed(1),this.upRestxt.el.style.fontSize="20px");1E5<=c&&(this.upRestxt.el.textContent=c.toFixed(1),this.upRestxt.el.style.fontSize="18px")};r.prototype.pingResults=function(c,d){var a=c;"Ping"===d&&(1<=a&&1E4>a?(this.pingResult.el.textContent=Math.floor(a),
+this.pingMobres.el.textContent=Math.floor(a)):0<=a&&1>a&&(0==a&&(a=0),this.pingResult.el.textContent=a,this.pingMobres.el.textContent=a));"Error"===d&&(this.oDoLiveSpeed.el.textContent=a)};r.prototype.downloadResult=function(c){1>c&&(this.downResult.el.textContent=c.toFixed(3));1<=c&&9999>c&&(this.downResult.el.textContent=c.toFixed(1));1E4<=c&&99999>c&&(this.downResult.el.textContent=c.toFixed(1),this.downResult.el.style.fontSize="20px");1E5<=c&&(this.downResult.el.textContent=c.toFixed(1),this.downResult.el.style.fontSize=
+"18px")};r.prototype.jitterResult=function(c,d){var a=c;"Jitter"===d&&(1<=a&&1E4>a?(this.jitterDesk.el.textContent=Math.floor(a),1<=a&&100>a&&(this.JitterResultMon.el.textContent=Math.floor(a)),100<=a&&(a=(a/1E3).toFixed(1),this.JitterResultMon.el.textContent=a+"k")):0<=a&&1>a&&(0==a&&(a=0),this.jitterDesk.el.textContent=a,this.JitterResultMon.el.textContent=a))};r.prototype.LiveSpeed=function(c,d){var a=c;if("countDown"===d){var f=a.toFixed(0);this.oDoLiveSpeed.el.textContent=f}else"speedToZero"===
+d?("number"==typeof a&&(a=a.toFixed(1)),0>=a&&(a=0),this.oDoLiveSpeed.el.textContent=a,this.oDoTopSpeed.el.textContent="1000+",this.oDoTopSpeed.el.style.fontSize="16.9px",this.oDoTopSpeed.el.style.fill="gray"):"Ping"===d?1<=a&&1E4>a?this.oDoLiveSpeed.el.textContent=Math.floor(a):0<=a&&1>a&&(0==a&&(a=0),this.oDoLiveSpeed.el.textContent=a):(0==a&&(f=a.toFixed(0),this.oDoLiveSpeed.el.textContent=f),1>=a&&0<a&&(f=a.toFixed(3),this.oDoLiveSpeed.el.textContent=f),1<a&&(f=a.toFixed(1),this.oDoLiveSpeed.el.textContent=
+f),1E3>=a&&(this.oDoTopSpeed.el.textContent="1000+",this.oDoTopSpeed.el.style.fontSize="16.9px",this.oDoTopSpeed.el.style.fill="gray"),1010<=a&&(this.oDoTopSpeed.el.textContent=1E3*Math.floor(a/1010)+"+",this.oDoTopSpeed.el.style.fill="gray",this.oDoTopSpeed.el.style.fontSize="17.2px"))};r.prototype.GaugeProgresstoZero=function(c,d){var a=this;if(0<=c)var f=Date.now(),t=0-c,w=setInterval(function(){var n=(Date.now()-f)/1E3;var q=n/3;q--;q=t*(q*q*q*q*q+1)+c;a.LiveSpeed(q,"speedToZero");a.mainGaugeProgress(q);
+if(3<=n||0>=q)clearInterval(w),a.LiveSpeed(0,"speedToZero"),a.mainGaugeProgress(0),m=d},16)};r.prototype.getNonlinearDegree=function(c){var d=0;if(0==c||0>=c||isNaN(c))return 0;for(;d<this.scale.length;)if(c>this.scale[d].value)d++;else return this.scale[d-1].degree+(c-this.scale[d-1].value)*(this.scale[d].degree-this.scale[d-1].degree)/(this.scale[d].value-this.scale[d-1].value);return this.scale[this.scale.length-1].degree};var O=function(){this.OverAllTimeAvg=window.performance.now();this.SpeedSamples=
+[];this.FinalSpeed};O.prototype.reset=function(){this.OverAllTimeAvg=window.performance.now();this.SpeedSamples=[];this.FinalSpeed=0};O.prototype.ArraySum=function(c){return c?c.reduce(function(d,a){if("number"===typeof d&&"number"===typeof a)return d+a},0):0};O.prototype.AvgSpeed=function(c,d,a){this.timeNow=(window.performance.now()-this.OverAllTimeAvg)/1E3;this.FinalSpeed;this.timeNow>=a-d&&(0<c&&this.SpeedSamples.push(c),this.FinalSpeed=this.ArraySum(this.SpeedSamples)/this.SpeedSamples.length);
+return this.FinalSpeed};O.prototype.uRandom=function(c,d){for(var a=new Uint32Array(262144),f=[],t=Blob,w=0;w<c;w++){for(var n=w,q=a.length,M=0;M<q;M++)a[M]=4294967296*Math.random();f[n]=a}return new t(f,{type:"application/octet-stream"},Na(d))};O.prototype.addEvt=function(c,d,a){c.addEventListener(d,a)};O.prototype.remEvt=function(c,d,a){c.removeEventListener(d,a)};var jb=function(){function c(){fa&&(e.YourIP.el.textContent="Please wait..",Y(7),fa=!1);e.ip()}function d(){function b(){1<=l?(--l,e.LiveSpeed(l,
+"countDown")):0>=l&&(clearInterval(g),G=!0,Z=void 0,d())}Pa&&(x.remEvt(e.settingsMob.el,"click",c),x.remEvt(e.settingsDesk.el,"click",c),x.remEvt(e.startButtonDesk.el,"click",d),x.remEvt(e.startButtonMob.el,"click",d),x.remEvt(document,"keypress",a),Pa=!1);if(0<=Z){G=!1;e.userInterface();ua=!1;var l=Math.ceil(Math.abs(Z));e.showStatus("Automatic Test Starts in ...");var g=setInterval(b,1E3)}"fetch"===openSpeedTestServerList&&!0===G&&(G=!1,e.showStatus("Fetching Server Info.."),Y(6));!0===G&&("Ping"===
+A?f():"Download"===A?f():"Upload"===A?f():!1===A&&f())}function a(b){"Enter"===b.key&&d()}function f(){ua&&(e.userInterface(),ua=!1);t()}function t(){function b(){va=window.performance.now();n()}"widget"!==openChannel&&"web"!==openChannel||Y(1);var l=setInterval(function(){"Loaded"===m&&(m="busy",Q());"Ping"===m&&(m="busy",e.showStatus("Milliseconds"));"Download"===m&&(e.showStatus("Initializing.."),x.reset(),y=ha=0,e.reset(),wa=window.performance.now(),w(),m="initDown");if("Downloading"===m){e.Symbol(0);
+if(0==aa){aa=1;e.showStatus("Testing download speed..");var g=(window.performance.now()-wa)/1E3;Qa=g;e.progress(1,dlDuration+2.5);dlDuration+=g}xa=(window.performance.now()-wa)/1E3;q("dl");e.showStatus("Mbps download");e.mainGaugeProgress(y);e.LiveSpeed(y);e.Graph(y,0);R=x.AvgSpeed(y,ya,dlDuration);xa>=dlDuration&&"done"==Ma&&(A?(e.GaugeProgresstoZero(y,"SendR"),e.showStatus("All done"),e.Symbol(2)):e.GaugeProgresstoZero(y,"Upload"),e.downloadResult(R),ia=S,I=1,m="busy",y=ha=0,x.reset())}"Upload"==
+m&&1===I&&(e.Symbol(1),m="initup",e.showStatus("Initializing.."),e.LiveSpeed("...","speedToZero"),za=x.uRandom(ulDataSize,b),A&&(aa=1));"Uploading"===m&&(1==aa&&(aa=2,e.showStatus("Testing upload speed.."),y=0,x.reset(),e.reset(),Ra=g=(window.performance.now()-va)/1E3,e.progress(!1,ulDuration+2.5),ulDuration+=g),e.showStatus("Mbps upload"),T=(window.performance.now()-va)/1E3,q("up"),e.mainGaugeProgress(y),e.LiveSpeed(y),e.Graph(y,1),U=x.AvgSpeed(y,Aa,ulDuration),T>=ulDuration&&1==I&&(ja=P,e.uploadResult(U),
+e.GaugeProgresstoZero(y,"SendR"),za=void 0,e.showStatus("All done"),e.Symbol(2),m="busy",I=0));if("Error"===m){e.showStatus("Check your network connection status.");e.ConnectionError();m="busy";clearInterval(l);g=document.createElement("div");g.innerHTML='<a xlink:href="https://openspeedtest.com/FAQ.php?ref=NetworkError" style="cursor: pointer" target="_blank"></a>';var u=g.querySelector("a");e.oDoLiveSpeed.el.textContent="Network Error";var C=document.getElementById("oDoLiveSpeed");u.innerHTML=C.innerHTML;
+C.innerHTML=g.innerHTML}"SendR"===m&&(e.showStatus("All done"),g=document.createElement("div"),g.innerHTML='<a xlink:href="https://openspeedtest.com?ref=Self-Hosted-Outro&run=5" style="cursor: pointer" target="_blank"></a>',u=g.querySelector("a"),e.oDoLiveSpeed.el.textContent=fb,C=document.getElementById("oDoLiveSpeed"),u.innerHTML=C.innerHTML,C.innerHTML=g.innerHTML,location.hostname!=Ba.toLowerCase()+Sa?(ba="https://"+Ba.toLowerCase()+Sa+"/results/show.php?&d="+R.toFixed(3)+"&u="+U.toFixed(3)+"&p="+
+Ca+"&j="+Da+"&dd="+(ia/1048576).toFixed(3)+"&ud="+(ja/1048576).toFixed(3)+"&ua="+Ta,ba=encodeURI(ba),g=document.getElementById("resultsData"),g.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",ba),g.setAttribute("target","_blank"),saveData&&Y(5)):Y(3),m="busy",clearInterval(l))},100)}function w(){for(var b=0;b<dlThreads;b++)setTimeout(function(l){M(l)},dlDelay*b,b)}function n(){for(var b=0;b<ulThreads;b++)setTimeout(function(l){F(l)},ulDelay*b,b)}function q(b){if("dl"===b){var l=1E3*xa;
+l>1E3*Qa+ya/2*1E3&&0===Ua&&(Ua=1,ka*=.01,ca*=.01,la=l+1E4);l>=la&&la<gb&&(la+=1E4,ka*=.01,ca*=.01);Va=0>=S?0:S-Wa;Wa=S;ca+=Va;Xa=Ea=l-Ea;Ea=l;ka+=Xa;0<ca&&(y=ha=ca/ka/125*upAdjust)}"up"===b&&(b=1E3*T,b>1E3*Ra+Aa/2*1E3&&0===Ya&&(Ya=1,ma*=.1,da*=.1,na=b+1E4),b>=na&&na<hb&&(na+=1E4,ma*=.1,da*=.1),Za=0>=P?0:P-$a,$a=P,da+=Za,ab=Fa=b-Fa,Fa=b,ma+=ab,0<da&&(y=ha=da/ma/125*upAdjust))}function M(b){var l=0;z[b]=new XMLHttpRequest;z[b].open("GET",Ga.Download+"?n="+Math.random(),!0);z[b].onprogress=function(g){if(1===
+I)return z[b].abort(),z[b]=null,z[b]=void 0,delete z[b],!1;"initDown"==m&&(m="Downloading");var u=0>=g.loaded?0:g.loaded-l;if(isNaN(u)||!isFinite(u)||0>u)return!1;S+=u;l=g.loaded};z[b].onload=function(g){0===l&&(S+=g.total);"initDown"==m&&(m="Downloading");z[b]&&(z[b].abort(),z[b]=null,z[b]=void 0,delete z[b]);0===I&&M(b)};z[b].onerror=function(g){0===I&&M(b)};z[b].responseType="arraybuffer";z[b].send()}function F(b){var l=0;v[b]=new XMLHttpRequest;v[b].open("POST",Ga.Upload+"?n="+Math.random(),!0);
+v[b].upload.onprogress=function(g){"initup"==m&&void 0===u&&(m="Uploading");if(T>=ulDuration)return v[b].abort(),v[b]=null,v[b]=void 0,delete v[b],!1;var u=0>=g.loaded?0:g.loaded-l;if(isNaN(u)||!isFinite(u)||0>u)return!1;P+=u;l=g.loaded};v[b].onload=function(){if(0===l&&(P+=1048576*ulDataSize,T>=ulDuration))return v[b].abort(),v[b]=null,v[b]=void 0,delete v[b],!1;if("initup"==m&&void 0===g){var g;m="Uploading"}v[b]&&(v[b].abort(),v[b]=null,v[b]=void 0,delete v[b]);1===I&&F(b)};v[b].onerror=function(g){T<=
+ulDuration&&F(b)};v[b].setRequestHeader("Content-Type","application/octet-stream");0<b&&17E3>=P||v[b].send(za)}function Q(){bb=openSpeedTestServerList.length;m="Ping";performance.clearResourceTimings();if(Ha<bb-1)Ha++,"Stop"!=oa&&ib(openSpeedTestServerList[Ha],Q);else if(1<=pa.length){var b=Math.min.apply(Math,Ia),l=Ia.indexOf(b);Ga=pa[l];qa=b;Ja=cb[l];oa="Busy";e.LiveSpeed(qa,"Ping");e.pingResults(qa,"Ping");e.jitterResult(Ja,"Jitter");Ca=qa;Da=Ja;m=A?"Ping"==A?"SendR":A:"Download"}else pa.Download||
+(m="Error")}function ib(b,l){function g(){if(C<pingSamples)C++,"Stop"!=oa&&u();else{if(1<J.length){K.sort(function(D,B){return D-B});K=K.slice(0,K.length*jitterFinalSample);K=K.reduce(function(D,B){return D+B},0)/K.length;var L=K.toFixed(1),Ka=Math.min.apply(Math,J);Ia.push(Ka);pa.push(b);cb.push(L)}"function"===typeof l&&l()}}function u(){var L=new XMLHttpRequest;"Stop"!=oa&&L.abort();L.open(pingMethod,b[pingFile]+"?n="+Math.random(),!0);L.timeout=pingTimeOut;var Ka=window.performance.now();L.send();
+L.onload=function(){if(200===this.status&&4===this.readyState){var D=Math.floor(window.performance.now()-Ka),B=performance.getEntries();B=B[B.length-1];B="xmlhttprequest"===B.initiatorType?parseFloat(B.duration.toFixed(1)):D;250<C&&(B=D);0>=B?J.push(.1):J.push(B);1<J.length&&(D=Math.abs(J[J.length-1]-J[J.length-2]).toFixed(1),K.push(parseFloat(D)),e.LiveSpeed(B,"Ping"),e.pingResults(B,"Ping"),e.jitterResult(D,"Jitter"));g()}404===this.status&&4===this.readyState&&(C++,g())};L.onerror=function(D){C++;
+g()};L.ontimeout=function(D){C++;g()}}var C=0,J=[],K=[];u()}var x=new O,e=new r;e.app();var za,db=location.hostname,eb,La,R,U,Ca,Da,ea,V,z=[],ha,S=0,P=0,y=0,T,xa,wa,va,ba,I=0;var Ta=window.navigator.userAgent?window.navigator.userAgent:"Not Found";var Aa=.6*ulDuration,ya=.6*dlDuration;7<=.6*ulDuration&&(Aa=7);7<=.6*dlDuration&&(ya=7);var G=!0,ua=!0;x.addEvt(e.settingsMob.el,"click",c);x.addEvt(e.settingsDesk.el,"click",c);x.addEvt(e.startButtonDesk.el,"click",d);x.addEvt(e.startButtonMob.el,"click",
+d);x.addEvt(document,"keypress",a);var Pa=!0,k=function(b){var l={},g=document.createElement("a");g.href=b;b=g.search.substring(1).split("&");for(g=0;g<b.length;g++){var u=b[g].split("=");l[u[0]]=decodeURIComponent(u[1])}return l}(window.location.href.toLowerCase());if(setPingSamples&&("string"===typeof k.ping||"string"===typeof k.p)){if("undefined"!==typeof k.ping)var E=k.ping;else"undefined"!==typeof k.p&&(E=k.p);0<E&&(pingSamples=pingSamples=E)}if(setPingTimeout&&("string"===typeof k.out||"string"===
+typeof k.o)){if("undefined"!==typeof k.out)var W=k.out;else"undefined"!==typeof k.o&&(W=k.o);1<W&&(pingTimeOut=pingTimeOut=W)}if(setHTTPReq&&("string"===typeof k.xhr||"string"===typeof k.x)){if("undefined"!==typeof k.xhr)var ra=k.xhr;else"undefined"!==typeof k.x&&(ra=k.x);0<ra&&32>=ra&&(ulThreads=dlThreads=ra)}if(selectServer&&("string"===typeof k.host||"string"===typeof k.h)){if("undefined"!==typeof k.host)var sa=k.host;else"undefined"!==typeof k.h&&(sa=k.h);/(?:https?):\/\/(\w+:?\w*)?(\S+)(:\d+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/.test(sa)&&
+(openSpeedTestServerList=[{ServerName:"Home",Download:sa+"/downloading",Upload:sa+"/upload",ServerIcon:"DefaultIcon"}])}E=parseInt(k.stress);W=parseInt(k.s);if("string"===typeof k.stress){var p=k.stress;var H=E}else"string"===typeof k.s&&(p=k.s,H=W);if(p&&stressTest){if("low"===p||"l"===p)ulDuration=dlDuration=300;if("medium"===p||"m"===p)ulDuration=dlDuration=600;if("high"===p||"h"===p)ulDuration=dlDuration=900;if("veryhigh"===p||"v"===p)ulDuration=dlDuration=1800;if("extreme"===p||"e"===p)ulDuration=
+dlDuration=3600;if("day"===p||"d"===p)ulDuration=dlDuration=86400;if("year"===p||"y"===p)ulDuration=dlDuration=31557600;if(12<E||12<W)ulDuration=dlDuration=H}p=parseInt(k.clean);H=parseInt(k.c);E=1;p?E=p:H&&(E=H);if(enableClean&&("string"===typeof k.clean||"string"===typeof k.c))if(1<=p||1<=H){if(5>p||5>H)upAdjust=1+E/100,dlAdjust=1+E/100}else dlAdjust=upAdjust=1;p=parseInt(k.run);H=parseInt(k.r);var Z;!enableRun||"string"!==typeof k.run&&"string"!==typeof k.r||(Z=0<p?p:0<H?H:0);0<=Z&&G&&d();p=k.test;
+k=k.t;var A=!1;if(selectTest&&("string"===typeof p||"string"===typeof k)){var N;p?A=N=p:k&&(A=N=k);if("download"===N||"d"===N){var ja=U=0;A="Download";G&&d()}else if("upload"===N||"u"===N){var ia=R=0;A="Upload";I=1;G&&d()}else"ping"===N||"p"===N?(ia=R=ja=U=0,A="Ping",G&&d()):A=!1}var aa=0,fa=!1,Ba="OpenSpeedTest",Sa=".com",fb=Ba+"\u2122",ta=0;"web"===openChannel&&(ta=webRe,fa=!0);"widget"===openChannel&&(ta=widgetRe,fa=!0);"selfwidget"===openChannel&&(ta=widgetRe,db=La=domainx);var Va=0,Wa=0,ca=0,
+Xa=0,Ea=0,ka=0,Ua=0,Qa,Ra,Za=0,$a=0,da=0,ab=0,Fa=0,ma=0,Ya=0,la,gb=1E3*dlDuration-6E3,na,hb=1E3*ulDuration-6E3,v=[],Ga,qa,Ja,oa,Ha=-1,Ia=[],pa=[],cb=[],bb=openSpeedTestServerList.length,Y=function(b){var l=new XMLHttpRequest,g=OpenSpeedTestdb;1==b&&(g=webIP);5==b&&(g=saveDataURL);7==b&&(g=get_IP);l.open("POST",g,!0);l.setRequestHeader("Content-type","application/x-www-form-urlencoded");l.onreadystatechange=function(){4==l.readyState&&200==l.status&&(V=l.responseText.trim(),2==b&&(eb=V),1==b&&(La=
+V),3==b&&setTimeout(function(){location.href=ta+V},1500),6==b&&(openSpeedTestServerList=JSON.parse(V),G=!0,d()),7==b&&(e.YourIP.el.textContent=V))};2==b&&(ea="r=n");3==b&&(ea="r=l&d="+R+"&u="+U+"&dd="+ia/1048576+"&ud="+ja/1048576+"&p="+Ca+"&do="+db+"&S="+eb+"&sip="+La+"&jit="+Da+"&ua="+Ta);5==b&&(ea=ba);6==b&&(ea="r=s");l.send(ea)}};X.Start=function(){new jb}})(window.OpenSpeedTest=window.OpenSpeedTest||{});

files/www/assets/js/darkmode.js

@@ -0,0 +1,6 @@
+var dayMode,nightMode,darkStyle;window.addEventListener("load",changeSkin);
+function changeSkin(){dayModeMob=document.getElementById("daymode-Mob");nightModeMob=document.getElementById("nightmode-Mob");dayMode=document.getElementById("daymode");nightMode=document.getElementById("nightmode");""===getCookieValue("mode")&&(nightMode.style.display="none",nightModeMob.style.display="none",dayMode.style.display="inline-block",dayModeMob.style.display="inline-block");"dark"===getCookieValue("mode")&&setSkin("dark");"light"===getCookieValue("mode")&&setSkin("light");window.matchMedia&&
+window.matchMedia("(prefers-color-scheme: dark)").matches&&""===getCookieValue("mode")&&setSkin("dark")}
+function setSkin(a){"dark"===a&&(dayModeMob.style.display="none",nightModeMob.style.display="inline-block",dayMode.style.display="none",nightMode.style.display="inline-block",darkStyle=document.getElementById("darkmode"),null==darkStyle&&(document.head.innerHTML+='<link id="darkmode" rel="stylesheet" href="assets/css/darkmode.css" type="text/css"/>',createCookie("mode","dark")));"light"===a&&(nightModeMob.style.display="none",dayModeMob.style.display="inline-block",nightMode.style.display="none",
+dayMode.style.display="inline-block",(darkStyle=document.getElementById("darkmode"))&&darkStyle.parentNode.removeChild(darkStyle),createCookie("mode","light"))}function toggleSkin(){(darkStyle=document.getElementById("darkmode"))?setSkin("light"):setSkin("dark")}function createCookie(a,c,b){if(b){var d=new Date;d.setTime(d.getTime()+864E5*b);b="; expires="+d.toGMTString()}else b="";document.cookie=a+"="+c+b+"; path=/"}
+function getCookieValue(a,c){return(c=document.cookie.match("(^|;)\\s*"+a+"\\s*=\\s*([^;]+)"))?c.pop():""};

files/www/hosted.html

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+   <head>
+      <meta charset="UTF-8">
+      <meta http-equiv="X-UA-Compatible" content="IE=edge">
+      <meta name="viewport" content="width=device-width, initial-scale=1.0">
+      <title>Speedtest by OpenSpeedtest.com</title>
+      <style>
+         ::-webkit-scrollbar {
+         display: none;
+         }
+         html {
+         -ms-overflow-style: none; 
+         scrollbar-width: none;
+         }
+         body{margin: 0px;}
+      </style>
+   </head>
+   <body>
+      <iframe id="OST-iFrame" src="//openspeedtest.com/selfhosted" style="width: 100vw;height: 100vh;" frameborder="0" allowfullscreen></iframe>
+      <div style="text-align: center; color: rgb(125 119 119); font-size:14px; ">
+         <a href="https://openspeedtest.com?ref=Self-Hosted-Widget&Run"  style="text-decoration:none;  color: rgb(125 119 119);"">Speed Test</a> by OpenSpeedTest™
+      </div>
+   </body>
+</html>

files/www/index.html

@@ -0,0 +1,167 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>SpeedTest by OpenSpeedTest™</title>
+  <meta name="description"
+    content="Test your network speed now. HTML5 Network Performance Estimation Tool. Self-Hosted SpeedTest by OpenSpeedTest™"/>
+  <link href="assets/css/app.css" rel="stylesheet" type="text/css" />
+  <script> window.matchMedia&&window.matchMedia("(prefers-color-scheme: dark)").matches&&(document.head.innerHTML+='<link id="darkmode" rel="stylesheet" href="assets/css/darkmode.css" type="text/css"/>');function getCookieValue(b,a){return(a=document.cookie.match("(^|;)\\s*"+b+"\\s*=\\s*([^;]+)"))?a.pop():""}if("light"===getCookieValue("mode")){var darkStyle=document.getElementById("darkmode");darkStyle&&darkStyle.parentNode.removeChild(darkStyle)}; </script>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta property="og:image" content="assets/images/img.png" />
+  <link rel='canonical' href='https://openspeedtest.com'/>
+  <link rel="apple-touch-icon" sizes="180x180" href="assets/images/icons/apple-touch-icon.png">
+  <link rel="icon" type="image/png" sizes="32x32" href="assets/images/icons/favicon-32x32.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="assets/images/icons/favicon-16x16.png">
+  <link rel="manifest" href="assets/images/icons/site.webmanifest">
+  <link rel="mask-icon" href="assets/images/icons/safari-pinned-tab.svg" color="#5bbad5">
+  <link rel="shortcut icon" href="assets/images/icons/favicon.ico">
+  <meta name="msapplication-TileColor" content="#ffc40d">
+  <meta name="msapplication-config" content="assets/images/icons/browserconfig.xml">
+  <meta name="theme-color" content="#ffffff">
+</head>
+<body>
+  <script type="text/javascript">
+/*
+     Official Website : https://OpenSpeedTest.COM | Email: support@openspeedtest.com
+     Developed by : Vishnu | https://Vishnu.Pro | Email : me@vishnu.pro 
+            
+     HTML5 Network Performance Estimation Tool -> [JS,XHR,SVG,HTML,CSS]
+     Started in 2011 and Moved to OpenSpeedTest.COM, Dedicated Project/Domain Name in 2013.
+     SpeedTest Script -> 2013 -> Beta | 2015 -> V1 | 2019 ->V2 | 2020 V2.1 | 2021 V2.12 | 2022 V2.5 & 2.5.3
+     Self-Hosted OpenSpeedTest-Server (iFrame/Nginx) -> 2014. (Managed SelfHosted SpeedTesT Widget)
+     OpenSpeedTest-Server (On-premises) (Fully SelfHosted Apps)
+     [OpenSpeedTest-Server Docker Image] -> V1 2019 | V2 2020 | V2.1 2021 | V2.2 & 2.2.2 2022
+     [Node.js/Electron JS  OpenSpeedTest-Server Desktop Apps] -> 2020 V1 | 2021 V2 & V2.1 | 2.1.1 to 2.1.8 2022
+     [Ionic Android and iOS OpenSpeedTest-Server Mobile Apps] V1.2 to 1.5 2022 
+
+     Download Now -> https://go.openspeedtest.com/Server
+
+     Like this Project? Please Donate NOW & Keep us Alive -> https://go.openspeedtest.com/Donate
+
+     Speed Test by OpenSpeedTest™️ is Free and Open-Source Software (FOSS) with MIT License.
+     Read full license terms @ http://go.openspeedtest.com/License
+
+     If you have any Questions, ideas or Comments Please Send it via -> https://go.openspeedtest.com/SendMessage
+*/
+
+     // Add or Remove Server --> Automatically choose the one with the least latency
+    var openSpeedTestServerList = [
+        {"ServerName":"Home", "Download":"downloading", "Upload":"upload", "ServerIcon":"DefaultIcon"}
+      ];
+          
+    // Send pings 'pingSamples' times to each Server URL.
+        var pingSamples = 10;
+
+    // 50% samples(Least)/length 1=100% 0.1 = 10%
+        var jitterFinalSample = 0.5; 
+
+    // Set a pingSample dynamically by passing "Ping" or "p" as a URL Parameter.
+        var setPingSamples = true;
+
+    // If Server has not responded within 5 Seconds for any requests we send ('pingSamples' times)
+    // We will show Network Error. You can change the limit here.
+    // In milliseconds, if you need to set 6 seconds. Change the value to 6000.
+        var pingTimeOut = 5000; 
+
+    // Set a PingTimeout dynamically by passing "Out" or "O" as a URL Parameter    
+        var setPingTimeout = true;
+
+    // GET or HEAD  // Other Methods may work. but why?
+        var pingMethod = "GET";
+
+    //Choose Download or Upload from the Server list. If you Prefer Download, change pingMethod to HEAD.
+        var pingFile = "Upload";
+
+    // The amount of garbage data sent to the server in Mb, 30 = 30Mb
+        var ulDataSize = 30;
+
+    // Don't touch it
+        var ulDelay = 300;
+        var dlDelay = 300;
+
+    // Overhead Compensation factor, This is a browser-dependent test, Many Unknowns. Currently, 4%. That is within the margin of error.
+        var upAdjust = 1.04;
+        var dlAdjust = 1.04;
+
+   // You can pass "Clean" or "C" as a URL Parameter and reset the Overhead Compensation factor to Zero or set any value between 0 and 4. 1 = 1% to 4 = 4% 
+   // "clean" will not accept values above 4, so Compensation is limited to a maximum of 4%.
+        var enableClean = true;
+
+    // Minimum 12 Seconds is Expected. 
+        var dlDuration = 12;
+        var ulDuration = 12;
+
+    // 6 is the common limit found on most browsers.
+    // Choose  Number for parallel HTTP connections to Server | Default is 6 
+        var dlThreads = 6;
+        var ulThreads = 6;
+
+    // Allow user to Change default limit of 6 parallel HTTP connections to Server  | Accept values above 1 and max 32
+    // pass "XHR" or "X" as a URL Parameter
+        var setHTTPReq = true;
+
+    // Save Data to a Database
+        var saveData = false;
+        var saveDataURL = "//yourDatabase.Server.com:4500/save?data=";
+
+    // Allow user to change the default 12 seconds test duration
+    // Pass "Stress" or "S" as a URL Parameter.
+        var stressTest = true;
+
+    // Allow user to select and run one test at a time, download, upload, or ping
+    // Pass "Test" or "T" as a URL Parameter.
+        var selectTest = true;
+
+    // Allow user to select a different server to run a test  
+    // Pass "Host" or "H" ad a  URL Parameter.
+    // Accept only valid HTTP URLs like "http://192.168.1.10:3000" or "https://yourHost.com"
+        var selectServer = true;
+
+    // Start a test Automatically without pressing the start button
+    // You can Delay the test for 'n' seconds by passing any number as a value for Run Keyword. e.g.: "Run=10" or "R=10" to delay the test by 10 Seconds.
+    // Pass "Run" or "R" as a URL Parameter to start a test instantly.
+        var enableRun = true;
+
+    // "Run" will not work if you are already using 'selectTest' "Test" or "T" Keyword.
+
+ 
+function ostOnload() {
+      console.log("OpenSpeedTest.com V2.5.4 Loaded!")
+      console.log("Now Press the Start Button or HIT Enter.")
+      console.log("The secret to living happy is giving happiness. Have a wonderful day.")
+      
+    }
+  
+  var openChannel = "dev";
+
+  </script>
+
+<!--
+Speed Test by OpenSpeedTest™️ is Free and Open-Source Software with MIT License.
+
+You can play with the CSS, HTML & SVG files to change the colors or add your support desk info to this page.
+Also, you can add your company logo anywhere on this page. It's FOSS. You can do whatever you see fit.
+
+If you like to make any other modification to this application or need a custom deployment for your organization, 
+please get in touch with support@openspeedtest.com.
+-->
+
+  <div id="loading_app" class="spinner">
+    <div class="bounce1"></div>
+    <div class="bounce2"></div>
+    <div class="bounce3"></div>
+  </div>
+  <object style="visibility:hidden" id="OpenSpeedTest-UI" data="assets/images/app.svg" type="image/svg+xml"></object>
+ 
+  <div class="Credits">
+    <a href="https://openspeedtest.com?ref=Self-Hosted&Run">SpeedTest by OpenSpeedTest™</a> is a Free and <a href="https://github.com/openspeedtest/Speed-Test">Open-Source HTML5 Network Speed Test</a> Software.
+    <p style="font-size: 12px;">© Copyright 2013-2023 OpenSpeedTest™ All Rights Reserved.</p>
+</div>
+  
+  <script src="assets/js/app-2.5.4.min.js"></script>
+  <script src="assets/js/darkmode.js"></script>
+
+</body>
+</html>