hexo-theme-redefine-x 2.8.5

package/source/js/main.js

@@ -0,0 +1,95 @@
+/* main function */
+import initUtils from "./utils.js";
+import initTyped from "./plugins/typed.js";
+import initModeToggle from "./tools/lightDarkSwitch.js";
+import initLazyLoad from "./layouts/lazyload.js";
+import initScrollTopBottom from "./tools/scrollTopBottom.js";
+import initLocalSearch from "./tools/localSearch.js";
+import initCopyCode from "./tools/codeBlock.js";
+import initBookmarkNav from "./layouts/bookmarkNav.js";
+
+export const main = {
+  themeInfo: {
+    theme: `Redefine v${theme.version}`,
+    author: "Jason-JP-Yang",
+    repository: "https://github.com/Jason-JP-Yang/hexo-theme-Redefine-X",
+  },
+  localStorageKey: "REDEFINE-X-STATUS",
+  styleStatus: {
+    isExpandPageWidth: false,
+    isDark: theme.colors.default_mode && theme.colors.default_mode === "dark",
+    fontSizeLevel: 0,
+    isOpenPageAside: true,
+  },
+  printThemeInfo: () => {
+    console.log(`
++=====================================================================================+
+|                                                                                     |
+|      ██████╗ ███████╗██████╗ ███████╗███████╗██╗███╗   ██╗███████╗   ██╗  ██╗       |
+|      ██╔══██╗██╔════╝██╔══██╗██╔════╝██╔════╝██║████╗  ██║██╔════╝   ╚██╗██╔╝       |
+|      ██████╔╝█████╗  ██║  ██║█████╗  █████╗  ██║██╔██╗ ██║█████╗█████╗╚███╔╝        |
+|      ██╔══██╗██╔══╝  ██║  ██║██╔══╝  ██╔══╝  ██║██║╚██╗██║██╔══╝╚════╝██╔██╗        |
+|      ██║  ██║███████╗██████╔╝███████╗██║     ██║██║ ╚████║███████╗   ██╔╝ ██╗       |
+|      ╚═╝  ╚═╝╚══════╝╚═════╝ ╚══════╝╚═╝     ╚═╝╚═╝  ╚═══╝╚══════╝   ╚═╝  ╚═╝       |
+|                                                                                     |
+|                 https://github.com/Jason-JP-Yang/hexo-theme-Redefine-X              |
++=====================================================================================+
+    `); // console log message
+  },
+  setStyleStatus: () => {
+    localStorage.setItem(
+      main.localStorageKey,
+      JSON.stringify(main.styleStatus),
+    );
+  },
+  getStyleStatus: () => {
+    let temp = localStorage.getItem(main.localStorageKey);
+    if (temp) {
+      temp = JSON.parse(temp);
+      for (let key in main.styleStatus) {
+        main.styleStatus[key] = temp[key];
+      }
+      return temp;
+    } else {
+      return null;
+    }
+  },
+  refresh: () => {
+    initUtils();
+    initModeToggle();
+    initScrollTopBottom();
+    initBookmarkNav();
+    
+    if (
+      theme.home_banner.subtitle.text.length !== 0 &&
+      location.pathname === config.root
+    ) {
+      initTyped("subtitle");
+    }
+
+    if (theme.navbar.search.enable === true) {
+      initLocalSearch();
+    }
+
+    if (theme.articles.code_block.copy === true) {
+      initCopyCode();
+    }
+
+    if (theme.articles.lazyload === true) {
+      initLazyLoad();
+    }
+  },
+};
+
+export function initMain() {
+  main.printThemeInfo();
+  main.refresh();
+}
+
+document.addEventListener("DOMContentLoaded", initMain);
+
+try {
+  swup.hooks.on("page:view", () => {
+    main.refresh();
+  });
+} catch (e) {}

package/source/js/plugins/aplayer.js

@@ -0,0 +1,33 @@
+(function() {
+  const audioList = [];
+  const isFixed = theme.plugins.aplayer.type === "fixed";
+  const isMini = theme.plugins.aplayer.type === "mini";
+
+  for (const audio of theme.plugins.aplayer.audios) {
+    const audioObj = {
+      name: audio.name,
+      artist: audio.artist,
+      url: audio.url,
+      cover: audio.cover,
+      lrc: audio.lrc,
+      theme: audio.theme,
+    };
+    audioList.push(audioObj);
+  }
+
+  if (isMini) {
+    new APlayer({
+      container: document.getElementById("aplayer"),
+      mini: true,
+      audio: audioList,
+    });
+  } else if (isFixed) {
+    const player = new APlayer({
+      container: document.getElementById("aplayer"),
+      fixed: true,
+      lrcType: 3,
+      audio: audioList,
+    });
+    document.querySelector(".aplayer-icon-lrc").click();
+  }
+})();

package/source/js/plugins/hbe.js

@@ -0,0 +1,350 @@
+import { main } from "../main.js";
+import { initTOC } from "../layouts/toc.js";
+
+export function initHBE() {
+  const cryptoObj = window.crypto || window.msCrypto;
+  const storage = window.localStorage;
+
+  const storageName = "hexo-blog-encrypt:#" + window.location.pathname;
+  const keySalt = textToArray("too young too simple");
+  const ivSalt = textToArray("sometimes naive!");
+
+  // As we can't detect the wrong password with AES-CBC,
+  // so adding an empty div and check it when decrption.
+  const knownPrefix = "<hbe-prefix></hbe-prefix>";
+
+  const mainElement = document.getElementById("hexo-blog-encrypt");
+  const wrongPassMessage = mainElement.dataset["wpm"];
+  const wrongHashMessage = mainElement.dataset["whm"];
+  const dataElement = mainElement.getElementsByTagName("script")["hbeData"];
+  const encryptedData = dataElement.innerText;
+  const HmacDigist = dataElement.dataset["hmacdigest"];
+
+  function hexToArray(s) {
+    return new Uint8Array(
+      s.match(/[\da-f]{2}/gi).map((h) => {
+        return parseInt(h, 16);
+      }),
+    );
+  }
+
+  function textToArray(s) {
+    var i = s.length;
+    var n = 0;
+    var ba = new Array();
+
+    for (var j = 0; j < i; ) {
+      var c = s.codePointAt(j);
+      if (c < 128) {
+        ba[n++] = c;
+        j++;
+      } else if (c > 127 && c < 2048) {
+        ba[n++] = (c >> 6) | 192;
+        ba[n++] = (c & 63) | 128;
+        j++;
+      } else if (c > 2047 && c < 65536) {
+        ba[n++] = (c >> 12) | 224;
+        ba[n++] = ((c >> 6) & 63) | 128;
+        ba[n++] = (c & 63) | 128;
+        j++;
+      } else {
+        ba[n++] = (c >> 18) | 240;
+        ba[n++] = ((c >> 12) & 63) | 128;
+        ba[n++] = ((c >> 6) & 63) | 128;
+        ba[n++] = (c & 63) | 128;
+        j += 2;
+      }
+    }
+    return new Uint8Array(ba);
+  }
+
+  function arrayBufferToHex(arrayBuffer) {
+    if (
+      typeof arrayBuffer !== "object" ||
+      arrayBuffer === null ||
+      typeof arrayBuffer.byteLength !== "number"
+    ) {
+      throw new TypeError("Expected input to be an ArrayBuffer");
+    }
+
+    var view = new Uint8Array(arrayBuffer);
+    var result = "";
+    var value;
+
+    for (var i = 0; i < view.length; i++) {
+      value = view[i].toString(16);
+      result += value.length === 1 ? "0" + value : value;
+    }
+
+    return result;
+  }
+
+  async function getExecutableScript(oldElem) {
+    let out = document.createElement("script");
+    const attList = [
+      "type",
+      "text",
+      "src",
+      "crossorigin",
+      "defer",
+      "referrerpolicy",
+    ];
+    attList.forEach((att) => {
+      if (oldElem[att]) out[att] = oldElem[att];
+    });
+
+    return out;
+  }
+
+  async function convertHTMLToElement(content) {
+    let out = document.createElement("div");
+    out.innerHTML = content;
+    out.querySelectorAll("script").forEach(async (elem) => {
+      elem.replaceWith(await getExecutableScript(elem));
+    });
+
+    return out;
+  }
+
+  function getKeyMaterial(password) {
+    let encoder = new TextEncoder();
+    return cryptoObj.subtle.importKey(
+      "raw",
+      encoder.encode(password),
+      {
+        name: "PBKDF2",
+      },
+      false,
+      ["deriveKey", "deriveBits"],
+    );
+  }
+
+  function getHmacKey(keyMaterial) {
+    return cryptoObj.subtle.deriveKey(
+      {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        salt: keySalt.buffer,
+        iterations: 1024,
+      },
+      keyMaterial,
+      {
+        name: "HMAC",
+        hash: "SHA-256",
+        length: 256,
+      },
+      true,
+      ["verify"],
+    );
+  }
+
+  function getDecryptKey(keyMaterial) {
+    return cryptoObj.subtle.deriveKey(
+      {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        salt: keySalt.buffer,
+        iterations: 1024,
+      },
+      keyMaterial,
+      {
+        name: "AES-CBC",
+        length: 256,
+      },
+      true,
+      ["decrypt"],
+    );
+  }
+
+  function getIv(keyMaterial) {
+    return cryptoObj.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        salt: ivSalt.buffer,
+        iterations: 512,
+      },
+      keyMaterial,
+      16 * 8,
+    );
+  }
+
+  async function verifyContent(key, content) {
+    const encoder = new TextEncoder();
+    const encoded = encoder.encode(content);
+
+    let signature = hexToArray(HmacDigist);
+
+    const result = await cryptoObj.subtle.verify(
+      {
+        name: "HMAC",
+        hash: "SHA-256",
+      },
+      key,
+      signature,
+      encoded,
+    );
+    console.log(`Verification result: ${result}`);
+    if (!result) {
+      alert(wrongHashMessage);
+      console.log(`${wrongHashMessage}, got `, signature, ` but proved wrong.`);
+    }
+    return result;
+  }
+
+  async function decrypt(decryptKey, iv, hmacKey) {
+    let typedArray = hexToArray(encryptedData);
+
+    const result = await cryptoObj.subtle
+      .decrypt(
+        {
+          name: "AES-CBC",
+          iv: iv,
+        },
+        decryptKey,
+        typedArray.buffer,
+      )
+      .then(async (result) => {
+        const decoder = new TextDecoder();
+        const decoded = decoder.decode(result);
+
+        // check the prefix, if not then we can sure here is wrong password.
+        if (!decoded.startsWith(knownPrefix)) {
+          throw "Decode successfully but not start with KnownPrefix.";
+        }
+
+        const hideButton = document.createElement("button");
+        hideButton.textContent = "Encrypt again";
+        hideButton.type = "button";
+        hideButton.classList.add("hbe-button");
+        hideButton.addEventListener("click", () => {
+          window.localStorage.removeItem(storageName);
+          window.location.reload();
+        });
+
+        document.getElementById("hexo-blog-encrypt").style.display = "inline";
+        document.getElementById("hexo-blog-encrypt").innerHTML = "";
+        document
+          .getElementById("hexo-blog-encrypt")
+          .appendChild(await convertHTMLToElement(decoded));
+        document.getElementById("hexo-blog-encrypt").appendChild(hideButton);
+
+        // Trigger lazy loading for any preloaders in decrypted content
+        import("../layouts/lazyload.js").then((module) => {
+          if (module.forceLoadAllPreloaders) {
+            module.forceLoadAllPreloaders();
+          }
+        }).catch(() => {
+          // Fallback: try to load preloaders directly
+          document.querySelectorAll(".img-preloader").forEach((preloader) => {
+            if (preloader.dataset.loaded !== "true") {
+              const src = preloader.dataset.src;
+              if (src) {
+                const img = document.createElement("img");
+                img.src = src;
+                img.alt = preloader.dataset.alt || "";
+                if (preloader.parentNode) {
+                  preloader.parentNode.replaceChild(img, preloader);
+                }
+              }
+            }
+          });
+        });
+
+        // // load Redefine Page components
+        main.refresh();
+        initTOC();
+
+        // trigger event
+        var event = new Event("hexo-blog-decrypt");
+        window.dispatchEvent(event);
+
+        return await verifyContent(hmacKey, decoded);
+      })
+      .catch((e) => {
+        alert(wrongPassMessage);
+        console.log(e);
+        return false;
+      });
+
+    return result;
+  }
+
+  function hbeLoader() {
+    const oldStorageData = JSON.parse(storage.getItem(storageName));
+
+    if (oldStorageData) {
+      console.log(
+        `Password got from localStorage(${storageName}): `,
+        oldStorageData,
+      );
+
+      const sIv = hexToArray(oldStorageData.iv).buffer;
+      const sDk = oldStorageData.dk;
+      const sHmk = oldStorageData.hmk;
+
+      cryptoObj.subtle
+        .importKey(
+          "jwk",
+          sDk,
+          {
+            name: "AES-CBC",
+            length: 256,
+          },
+          true,
+          ["decrypt"],
+        )
+        .then((dkCK) => {
+          cryptoObj.subtle
+            .importKey(
+              "jwk",
+              sHmk,
+              {
+                name: "HMAC",
+                hash: "SHA-256",
+                length: 256,
+              },
+              true,
+              ["verify"],
+            )
+            .then((hmkCK) => {
+              decrypt(dkCK, sIv, hmkCK).then((result) => {
+                if (!result) {
+                  storage.removeItem(storageName);
+                }
+              });
+            });
+        });
+    }
+
+    mainElement.addEventListener("keydown", async (event) => {
+      if (event.isComposing || event.key === "Enter") {
+        const password = document.getElementById("hbePass").value;
+        const keyMaterial = await getKeyMaterial(password);
+        const hmacKey = await getHmacKey(keyMaterial);
+        const decryptKey = await getDecryptKey(keyMaterial);
+        const iv = await getIv(keyMaterial);
+
+        decrypt(decryptKey, iv, hmacKey).then((result) => {
+          console.log(`Decrypt result: ${result}`);
+          if (result) {
+            cryptoObj.subtle.exportKey("jwk", decryptKey).then((dk) => {
+              cryptoObj.subtle.exportKey("jwk", hmacKey).then((hmk) => {
+                const newStorageData = {
+                  dk: dk,
+                  iv: arrayBufferToHex(iv),
+                  hmk: hmk,
+                };
+                storage.setItem(storageName, JSON.stringify(newStorageData));
+              });
+            });
+          }
+        });
+      }
+    });
+  }
+
+  hbeLoader();
+}
+
+// initHBE();

package/source/js/plugins/masonry.js

@@ -0,0 +1,115 @@
+export function initMasonry() {
+  var loadingPlaceholder = document.querySelector(".loading-placeholder");
+  var masonryContainer = document.querySelector("#masonry-container");
+  if (!loadingPlaceholder || !masonryContainer) return;
+
+  loadingPlaceholder.style.display = "block";
+  masonryContainer.style.display = "none";
+
+  // Get both regular images and preloader divs
+  var images = document.querySelectorAll(
+    "#masonry-container .masonry-item img",
+  );
+  var preloaders = document.querySelectorAll(
+    "#masonry-container .masonry-item .img-preloader",
+  );
+  
+  var totalCount = images.length + preloaders.length;
+  var loadedCount = 0;
+
+  function onItemReady() {
+    loadedCount++;
+    if (loadedCount === totalCount) {
+      initializeMasonryLayout();
+    }
+  }
+
+  // Handle regular images
+  for (var i = 0; i < images.length; i++) {
+    var img = images[i];
+    if (img.complete) {
+      onItemReady();
+    } else {
+      img.addEventListener("load", onItemReady);
+      img.addEventListener("error", onItemReady); // Also count errors to prevent blocking
+    }
+  }
+
+  // Handle preloaders - force load them and wait
+  if (preloaders.length > 0) {
+    import("../layouts/lazyload.js").then((module) => {
+      preloaders.forEach((preloader) => {
+        // If already loaded, count it
+        if (preloader.dataset.loaded === "true" || preloader.tagName === "IMG") {
+          onItemReady();
+        } else {
+          // Set up observer for when it gets replaced with an image
+          const observer = new MutationObserver((mutations, obs) => {
+            mutations.forEach((mutation) => {
+              mutation.addedNodes.forEach((node) => {
+                if (node.tagName === "IMG") {
+                  if (node.complete) {
+                    onItemReady();
+                  } else {
+                    node.addEventListener("load", onItemReady);
+                    node.addEventListener("error", onItemReady);
+                  }
+                  obs.disconnect();
+                }
+              });
+            });
+          });
+          
+          observer.observe(preloader.parentNode, { childList: true });
+          
+          // Force trigger the preloader to load
+          if (module.forceLoadAllPreloaders) {
+            module.forceLoadAllPreloaders();
+          }
+        }
+      });
+    }).catch(() => {
+      // Fallback: just count all preloaders as ready
+      preloaders.forEach(() => onItemReady());
+    });
+  }
+
+  // Handle case where there are no items
+  if (totalCount === 0) {
+    initializeMasonryLayout();
+  } else if (loadedCount === totalCount) {
+    initializeMasonryLayout();
+  }
+
+  function initializeMasonryLayout() {
+    loadingPlaceholder.style.opacity = 0;
+    setTimeout(() => {
+      loadingPlaceholder.style.display = "none";
+      masonryContainer.style.display = "block";
+      var screenWidth = window.innerWidth;
+      var baseWidth;
+      if (screenWidth >= 768) {
+        baseWidth = 255;
+      } else {
+        baseWidth = 150;
+      }
+      var masonry = new MiniMasonry({
+        baseWidth: baseWidth,
+        container: masonryContainer,
+        gutterX: 10,
+        gutterY: 10,
+        surroundingGutter: false,
+      });
+      masonry.layout();
+      masonryContainer.style.opacity = 1;
+    }, 100);
+  }
+}
+
+if (data.masonry) {
+  try {
+    swup.hooks.on("page:view", initMasonry);
+  } catch (e) {}
+
+  document.addEventListener("DOMContentLoaded", initMasonry);
+}

package/source/js/plugins/mermaid.js

@@ -0,0 +1,7 @@
+if (theme.plugins.mermaid.enable === true) {
+  try {
+    swup.hooks.on("page:view", () => {
+      mermaid.initialize();
+    });
+  } catch (e) {}
+}

package/source/js/plugins/pangu.js

@@ -0,0 +1,12 @@
+function initPanguJS() {
+  // Add space between Chinese and English
+  pangu.spacingElementByClassName("markdown-body");
+
+  pangu.autoSpacingPage();
+}
+
+document.addEventListener("DOMContentLoaded", initPanguJS);
+
+try {
+  swup.hooks.on("page:view", initPanguJS);
+} catch (e) {}

package/source/js/plugins/tabs.js

@@ -0,0 +1,29 @@
+function setTabs() {
+  let tabs = document.querySelectorAll(".tabs .nav-tabs");
+  if (!tabs) return;
+
+  tabs.forEach((tab) => {
+    tab.querySelectorAll("a").forEach((link) => {
+      link.addEventListener("click", (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+
+        const parentTab = e.target.parentElement.parentElement.parentElement;
+        parentTab.querySelector(".nav-tabs .active").classList.remove("active");
+        e.target.parentElement.classList.add("active");
+        parentTab
+          .querySelector(".tab-content .active")
+          .classList.remove("active");
+        parentTab.querySelector(e.target.className).classList.add("active");
+
+        return false;
+      });
+    });
+  });
+}
+
+try {
+  swup.hooks.on("page:view", setTabs);
+} catch (e) {}
+
+document.addEventListener("DOMContentLoaded", setTabs);

package/source/js/plugins/typed.js

@@ -0,0 +1,62 @@
+/*
+author: @jiangwen5945 & EvanNotFound
+*/
+export const config = {
+  usrTypeSpeed: theme.home_banner.subtitle.typing_speed,
+  usrBackSpeed: theme.home_banner.subtitle.backing_speed,
+  usrBackDelay: theme.home_banner.subtitle.backing_delay,
+  usrStartDelay: theme.home_banner.subtitle.starting_delay,
+  usrLoop: theme.home_banner.subtitle.loop,
+  usrSmartBackspace: theme.home_banner.subtitle.smart_backspace,
+  usrHitokotoAPI: theme.home_banner.subtitle.hitokoto.api,
+};
+
+export default function initTyped(id) {
+  const {
+    usrTypeSpeed,
+    usrBackSpeed,
+    usrBackDelay,
+    usrStartDelay,
+    usrLoop,
+    usrSmartBackspace,
+    usrHitokotoAPI,
+  } = config;
+
+  function typing(dataList) {
+    const st = new Typed("#" + id, {
+      strings: [dataList],
+      typeSpeed: usrTypeSpeed || 100,
+      smartBackspace: usrSmartBackspace || false,
+      backSpeed: usrBackSpeed || 80,
+      backDelay: usrBackDelay || 1500,
+      loop: usrLoop || false,
+      startDelay: usrStartDelay || 500,
+    });
+  }
+
+  if (theme.home_banner.subtitle.hitokoto.enable) {
+    fetch(usrHitokotoAPI)
+      .then((response) => response.json())
+      .then((data) => {
+        if (data.from_who && theme.home_banner.subtitle.hitokoto.show_author) {
+          typing(data.hitokoto + "——" + data.from_who);
+        } else {
+          typing(data.hitokoto);
+        }
+      })
+      .catch(console.error);
+  } else {
+    const sentenceList = [...theme.home_banner.subtitle.text];
+    if (document.getElementById(id)) {
+      const st = new Typed("#" + id, {
+        strings: sentenceList,
+        typeSpeed: usrTypeSpeed || 100,
+        smartBackspace: usrSmartBackspace || false,
+        backSpeed: usrBackSpeed || 80,
+        backDelay: usrBackDelay || 1500,
+        loop: usrLoop || false,
+        startDelay: usrStartDelay || 500,
+      });
+    }
+  }
+}