Update _config.yml UTC 2024-05-14 Tuesday 10:58:48 Updated By Github …

…Actions

js/activate-power-mode.js

@@ -0,0 +1,349 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === "object" && typeof module === "object")
+    module.exports = factory();
+  else if (typeof define === "function" && define.amd) define([], factory);
+  else if (typeof exports === "object") exports["POWERMODE"] = factory();
+  else root["POWERMODE"] = factory();
+})(this, function () {
+  return /******/ (function (modules) {
+    // webpackBootstrap
+    /******/ // The module cache
+    /******/ var installedModules = {};
+
+    /******/ // The require function
+    /******/ function __webpack_require__(moduleId) {
+      /******/ // Check if module is in cache
+      /******/ if (installedModules[moduleId])
+        /******/ return installedModules[moduleId].exports;
+
+      /******/ // Create a new module (and put it into the cache)
+      /******/ var module = (installedModules[moduleId] = {
+        /******/ exports: {},
+        /******/ id: moduleId,
+        /******/ loaded: false,
+        /******/
+      });
+
+      /******/ // Execute the module function
+      /******/ modules[moduleId].call(
+        module.exports,
+        module,
+        module.exports,
+        __webpack_require__
+      );
+
+      /******/ // Flag the module as loaded
+      /******/ module.loaded = true;
+
+      /******/ // Return the exports of the module
+      /******/ return module.exports;
+      /******/
+    }
+
+    /******/ // expose the modules object (__webpack_modules__)
+    /******/ __webpack_require__.m = modules;
+
+    /******/ // expose the module cache
+    /******/ __webpack_require__.c = installedModules;
+
+    /******/ // __webpack_public_path__
+    /******/ __webpack_require__.p = "";
+
+    /******/ // Load entry module and return exports
+    /******/ return __webpack_require__(0);
+    /******/
+  })(
+    /************************************************************************/
+    /******/ [
+      /* 0 */
+      /***/ function (module, exports, __webpack_require__) {
+        "use strict";
+
+        var canvas = document.createElement("canvas");
+        canvas.width = window.innerWidth;
+        canvas.height = window.innerHeight;
+        canvas.style.cssText =
+          "position:fixed;top:0;left:0;pointer-events:none;z-index:999999";
+        window.addEventListener("resize", function () {
+          canvas.width = window.innerWidth;
+          canvas.height = window.innerHeight;
+        });
+        document.body.appendChild(canvas);
+        var context = canvas.getContext("2d");
+        var particles = [];
+        var particlePointer = 0;
+        var rendering = false;
+
+        POWERMODE.shake = true;
+
+        function getRandom(min, max) {
+          return Math.random() * (max - min) + min;
+        }
+
+        function getColor(el) {
+          if (POWERMODE.colorful) {
+            var u = getRandom(0, 360);
+            return (
+              "hsla(" +
+              getRandom(u - 10, u + 10) +
+              ", 100%, " +
+              getRandom(50, 80) +
+              "%, " +
+              1 +
+              ")"
+            );
+          } else {
+            return window.getComputedStyle(el).color;
+          }
+        }
+
+        function getCaret() {
+          var el = document.activeElement;
+          var bcr;
+          if (
+            el.tagName === "TEXTAREA" ||
+            (el.tagName === "INPUT" && el.getAttribute("type") === "text")
+          ) {
+            var offset = __webpack_require__(1)(el, el.selectionEnd);
+            bcr = el.getBoundingClientRect();
+            return {
+              x: offset.left + bcr.left,
+              y: offset.top + bcr.top,
+              color: getColor(el),
+            };
+          }
+          var selection = window.getSelection();
+          if (selection.rangeCount) {
+            var range = selection.getRangeAt(0);
+            var startNode = range.startContainer;
+            if (startNode.nodeType === document.TEXT_NODE) {
+              startNode = startNode.parentNode;
+            }
+            bcr = range.getBoundingClientRect();
+            return {
+              x: bcr.left,
+              y: bcr.top,
+              color: getColor(startNode),
+            };
+          }
+          return { x: 0, y: 0, color: "transparent" };
+        }
+
+        function createParticle(x, y, color) {
+          return {
+            x: x,
+            y: y,
+            alpha: 1,
+            color: color,
+            velocity: {
+              x: -1 + Math.random() * 2,
+              y: -3.5 + Math.random() * 2,
+            },
+          };
+        }
+
+        function POWERMODE() {
+          {
+            // spawn particles
+            var caret = getCaret();
+            var numParticles = 5 + Math.round(Math.random() * 10);
+            while (numParticles--) {
+              particles[particlePointer] = createParticle(
+                caret.x,
+                caret.y,
+                caret.color
+              );
+              particlePointer = (particlePointer + 1) % 500;
+            }
+          }
+          {
+            // shake screen
+            if (POWERMODE.shake) {
+              var intensity = 1 + 2 * Math.random();
+              var x = intensity * (Math.random() > 0.5 ? -1 : 1);
+              var y = intensity * (Math.random() > 0.5 ? -1 : 1);
+              document.body.style.marginLeft = x + "px";
+              document.body.style.marginTop = y + "px";
+              setTimeout(function () {
+                document.body.style.marginLeft = "";
+                document.body.style.marginTop = "";
+              }, 75);
+            }
+          }
+          if (!rendering) {
+            requestAnimationFrame(loop);
+          }
+        }
+        POWERMODE.colorful = false;
+
+        function loop() {
+          rendering = true;
+          context.clearRect(0, 0, canvas.width, canvas.height);
+          var rendered = false;
+          var rect = canvas.getBoundingClientRect();
+          for (var i = 0; i < particles.length; ++i) {
+            var particle = particles[i];
+            if (particle.alpha <= 0.1) continue;
+            particle.velocity.y += 0.075;
+            particle.x += particle.velocity.x;
+            particle.y += particle.velocity.y;
+            particle.alpha *= 0.96;
+            context.globalAlpha = particle.alpha;
+            context.fillStyle = particle.color;
+            context.fillRect(
+              Math.round(particle.x - 1.5) - rect.left,
+              Math.round(particle.y - 1.5) - rect.top,
+              3,
+              3
+            );
+            rendered = true;
+          }
+          if (rendered) {
+            requestAnimationFrame(loop);
+          } else {
+            rendering = false;
+          }
+        }
+
+        module.exports = POWERMODE;
+
+        /***/
+      },
+      /* 1 */
+      /***/ function (module, exports) {
+        /* jshint browser: true */
+
+        (function () {
+          // The properties that we copy into a mirrored div.
+          // Note that some browsers, such as Firefox,
+          // do not concatenate properties, i.e. padding-top, bottom etc. -> padding,
+          // so we have to do every single property specifically.
+          var properties = [
+            "direction", // RTL support
+            "boxSizing",
+            "width", // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does
+            "height",
+            "overflowX",
+            "overflowY", // copy the scrollbar for IE
+
+            "borderTopWidth",
+            "borderRightWidth",
+            "borderBottomWidth",
+            "borderLeftWidth",
+            "borderStyle",
+
+            "paddingTop",
+            "paddingRight",
+            "paddingBottom",
+            "paddingLeft",
+
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/font
+            "fontStyle",
+            "fontVariant",
+            "fontWeight",
+            "fontStretch",
+            "fontSize",
+            "fontSizeAdjust",
+            "lineHeight",
+            "fontFamily",
+
+            "textAlign",
+            "textTransform",
+            "textIndent",
+            "textDecoration", // might not make a difference, but better be safe
+
+            "letterSpacing",
+            "wordSpacing",
+
+            "tabSize",
+            "MozTabSize",
+          ];
+
+          var isFirefox = window.mozInnerScreenX != null;
+
+          function getCaretCoordinates(element, position, options) {
+            var debug = (options && options.debug) || false;
+            if (debug) {
+              var el = document.querySelector(
+                "#input-textarea-caret-position-mirror-div"
+              );
+              if (el) {
+                el.parentNode.removeChild(el);
+              }
+            }
+
+            // mirrored div
+            var div = document.createElement("div");
+            div.id = "input-textarea-caret-position-mirror-div";
+            document.body.appendChild(div);
+
+            var style = div.style;
+            var computed = window.getComputedStyle
+              ? getComputedStyle(element)
+              : element.currentStyle; // currentStyle for IE < 9
+
+            // default textarea styles
+            style.whiteSpace = "pre-wrap";
+            if (element.nodeName !== "INPUT") style.wordWrap = "break-word"; // only for textarea-s
+
+            // position off-screen
+            style.position = "absolute"; // required to return coordinates properly
+            if (!debug) style.visibility = "hidden"; // not 'display: none' because we want rendering
+
+            // transfer the element's properties to the div
+            properties.forEach(function (prop) {
+              style[prop] = computed[prop];
+            });
+
+            if (isFirefox) {
+              // Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275
+              if (element.scrollHeight > parseInt(computed.height))
+                style.overflowY = "scroll";
+            } else {
+              style.overflow = "hidden"; // for Chrome to not render a scrollbar; IE keeps overflowY = 'scroll'
+            }
+
+            div.textContent = element.value.substring(0, position);
+            // the second special handling for input type="text" vs textarea: spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037
+            if (element.nodeName === "INPUT")
+              div.textContent = div.textContent.replace(/\s/g, "\u00a0");
+
+            var span = document.createElement("span");
+            // Wrapping must be replicated *exactly*, including when a long word gets
+            // onto the next line, with whitespace at the end of the line before (#7).
+            // The  *only* reliable way to do that is to copy the *entire* rest of the
+            // textarea's content into the <span> created at the caret position.
+            // for inputs, just '.' would be enough, but why bother?
+            span.textContent = element.value.substring(position) || "."; // || because a completely empty faux span doesn't render at all
+            div.appendChild(span);
+
+            var coordinates = {
+              top: span.offsetTop + parseInt(computed["borderTopWidth"]),
+              left: span.offsetLeft + parseInt(computed["borderLeftWidth"]),
+            };
+
+            if (debug) {
+              span.style.backgroundColor = "#aaa";
+            } else {
+              document.body.removeChild(div);
+            }
+
+            return coordinates;
+          }
+
+          if (
+            typeof module != "undefined" &&
+            typeof module.exports != "undefined"
+          ) {
+            module.exports = getCaretCoordinates;
+          } else {
+            window.getCaretCoordinates = getCaretCoordinates;
+          }
+        })();
+
+        /***/
+      },
+      /******/
+    ]
+  );
+});