jekyll-zeta 0.10.4 → 0.10.5

data/_includes/js_source/encrypt_page.js

@@ -0,0 +1,229 @@
+function _InitEnc(
+  preFix,
+  contentEnc,
+  keyData,
+  TestData,
+  forbid_cache_password
+) {
+  function uint8ArrayToHex(uint8Array) {
+    return Array.from(uint8Array)
+      .map((byte) => byte.toString(16).padStart(2, "0")) // 转换每个字节为2位16进制
+      .join(""); // 连接成字符串
+  }
+
+  !(function () {
+    const substl = crypto.subtle;
+
+    const encid = preFix;
+    const encryptedContent = contentEnc;
+    const base64str = encryptedContent.substring(3);
+    const bfMsg = base64js.decode(base64str);
+    const bfIv = bfMsg.subarray(0, 12);
+    const bfCipher = bfMsg.subarray(12);
+
+    async function genKey(psw) {
+      var keyRaw = new TextEncoder().encode(psw);
+      var key = await substl.importKey("raw", keyRaw, "PBKDF2", false, [
+        "deriveBits",
+      ]);
+      const salt = "this is a salt string 20221019";
+      let pbkdf2 = {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        iterations: 12345,
+        salt: new TextEncoder().encode(salt),
+      };
+      return await substl.deriveBits(pbkdf2, key, 256);
+    }
+
+    async function decryptRaw(bf, key, outV) {
+      if (bf.length < 8) {
+        if (outV) {
+          outV.count = bf.length;
+        }
+        throw "err";
+      }
+      let count = 0;
+      for (let i = 0; i < 4; i++) {
+        count |= (bf[i] ^ bf[i + 4] ^ i) << ((3 - i) * 8);
+      }
+
+      if (outV) {
+        outV.count = count;
+      }
+      if (bf.length < count) {
+        return;
+      }
+
+      let bfIv = bf.slice(4, 20);
+      let bfCipher = bf.slice(20, count);
+
+      var aeskey = {
+        name: "AES-CTR",
+      };
+      var keyObj = await substl.importKey("raw", key, aeskey, false, [
+        "decrypt",
+      ]);
+      var aesDec = { name: "AES-CTR", counter: bfIv, length: 64 };
+      try {
+        let bfDec = await substl.decrypt(aesDec, keyObj, bfCipher);
+        return new Uint8Array(bfDec);
+      } catch (error) {
+        throw error;
+      }
+    }
+
+    async function decryptBase64Msg(msg64, key) {
+      const base64str = msg64;
+      const bfMsg = base64js.decode(base64str);
+      return await decryptRaw(bfMsg, key);
+    }
+    async function checkKey(key) {
+      const arrTest = TestData.split(".");
+      const testData = arrTest[0];
+      const testDataEnc = arrTest[1];
+      const bfTestData = base64js.decode(testDataEnc);
+
+      const bfKeyData = base64js.decode(keyData);
+      let keyBf = null;
+      let C = 0;
+      let sum = 0;
+      while (C++ < 400) {
+        if (sum >= bfKeyData.length) {
+          break;
+        }
+        let bfSub = bfKeyData.slice(sum);
+
+        try {
+          let outV = { count: 0 };
+          let d = await decryptRaw(bfSub, key, outV);
+
+          sum += outV.count;
+          if (d) {
+            let dec = await decryptRaw(bfTestData, d);
+            let s = new TextDecoder().decode(dec);
+            if (s == testData) {
+              keyBf = d;
+              break;
+            }
+          } else {
+          }
+        } catch (error) {}
+      }
+
+      return keyBf;
+    }
+
+    async function decrypt(key0, isCached) {
+      // const key = Uint8Array([...]); // 32 bytes key
+      var key = "";
+      if (isCached) {
+        key = readKey();
+      } else {
+        var keyS = preFix + key0 + preFix;
+        key = await genKey(keyS);
+      }
+      if (key.length == 0) {
+        return;
+      }
+      try {
+        let keyBf = await checkKey(key);
+        if (!keyBf) {
+          throw "error psw";
+        }
+        var bfDec = await decryptBase64Msg(contentEnc, keyBf);
+        var plain = new TextDecoder().decode(bfDec);
+        setKey(key);
+        document.getElementById("encrypted").style.display = "none";
+        // / show decrypted
+
+        document.getElementById("decrypted").style.display = "block";
+        document.getElementById("decryptContent").innerHTML = plain;
+
+        const DECFUN = window["_after_dec_fun"];
+
+        if (DECFUN && typeof DECFUN == "function") {
+          DECFUN();
+        }
+        setTimeout(function () {
+          var loadevent = document.createEvent("Event");
+          loadevent.initEvent("load", true, true);
+
+          var DOMContentLoaded_event = document.createEvent("Event");
+          DOMContentLoaded_event.initEvent("DOMContentLoaded", true, true);
+
+          window.dispatchEvent(loadevent);
+          window.dispatchEvent(DOMContentLoaded_event);
+        }, 100);
+      } catch (error) {
+        console.log(error);
+        // alert("wrong password.")
+        document.getElementById("passwordinput").classList.add("errPsw");
+        setTimeout(() => {
+          document.getElementById("passwordinput").classList.remove("errPsw");
+        }, 500);
+      }
+    }
+
+    document.getElementById("DecryptBtn").onclick = function () {
+      var key = document.getElementById("passwordinput").value;
+      decrypt(key);
+    };
+
+    document.getElementById("EncryptBtn").onclick = function () {
+      /// hide input
+      document.getElementById("encrypted").style.display = "block";
+      // / show decrypted
+      document.getElementById("decrypted").style.display = "none";
+      document.getElementById("decryptContent").innerHTML = ":)";
+
+      clearKey();
+
+      const ENCFUN = window["_after_enc_fun"];
+      if (ENCFUN && typeof ENCFUN == "function") {
+        ENCFUN();
+      }
+    };
+
+    document.getElementById("ClearBtn1").onclick = function () {
+      localStorage.clear();
+      document.getElementById("passwordinput").value = "";
+    };
+    document.getElementById("ClearBtn2").onclick = function () {
+      localStorage.clear();
+    };
+
+    function readKey0() {}
+    function setKey0(value) {}
+    function clearKey0() {}
+
+    function readKey1() {
+      var key = encid;
+      var v = localStorage.getItem(key);
+      if (v) {
+        return base64js.decode(v);
+      } else {
+        return null;
+      }
+    }
+    function setKey1(value) {
+      var key = encid;
+      var arr = new Uint8Array(value);
+      var b64 = base64js.encode(arr);
+      return localStorage.setItem(key, b64);
+    }
+    function clearKey1() {
+      var key = encid;
+      localStorage.removeItem(key);
+    }
+
+    const readKey = forbid_cache_password ? readKey0 : readKey1;
+    const setKey = forbid_cache_password ? setKey0 : setKey1;
+    const clearKey = forbid_cache_password ? clearKey0 : clearKey1;
+
+    var cachekey = readKey();
+    if (cachekey) {
+      decrypt(cachekey, true);
+    }
+  })();
+}

data/_includes/js_source/getPostData.js

@@ -0,0 +1,128 @@
+;function hm_getPostData( endYear ,_allyearurl) {
+  endYear = ('' + endYear).substring(0,4)
+
+  let arr = _allyearurl.split("/");
+  arr.pop();
+  const jsonUrlBase = arr.join("/");
+
+  var GDATA = window['__GDATA__'] 
+  if (!GDATA) {
+    GDATA = {}
+    window['__GDATA__'] 
+  }
+
+
+  let queue  = window._y_queue || []
+  window._y_queue = queue;
+
+ 
+  function getAllYearCfg(){
+ 
+    
+    if (GDATA['_allYear']) {
+      return GDATA['_allYear'];
+    }
+
+    if (window._isFetchAllYearData == 1) {
+      return new Promise(r=>{
+        queue.push(r);
+      })
+    }
+
+    
+    window._isFetchAllYearData = 1;
+    return fetch(_allyearurl)
+      .then((r) => r.json())
+      .then(d => { 
+        window._isFetchAllYearData = 0;
+        if (queue.length) {
+          queue.forEach(calback=>{calback(d)});
+          queue.length = 0;
+        }
+        GDATA['_allYear'] = d ;return d ;})
+  }
+
+  function getYearData(year) {
+    year = '' + year
+
+    if(GDATA[year]){
+      return GDATA[year]
+    }
+
+    let queueFlgKey = '_singleyearFlg' + year
+    let queueArrKey = '_singleyearQueue' + year
+    if (GDATA[queueFlgKey] == 1) {
+      // console.log('put in queue',year,Math.random())
+      let arrQueue = GDATA[queueArrKey]
+      if (!arrQueue) {
+        arrQueue = []
+        GDATA[queueArrKey] = arrQueue;
+      }
+      
+      return  new Promise(r=>{
+        arrQueue.push(r);
+      });
+    }
+
+
+    GDATA[queueFlgKey] = 1;
+    // console.log('RealQuery',year,Math.random())
+    return fetch(`${jsonUrlBase}/${year}.json`)
+      .then((r) => r.json())
+      .then(d=>{
+        GDATA[queueFlgKey] = 0 ;GDATA[year] = d; 
+        let queue = GDATA[queueArrKey];
+        // console.log('queryFinish',year)
+        if(queue && queue.length){
+          queue.forEach(cb=>{
+            // console.log('queryFinishQueue',year,queue.length,Math.random());
+            cb(d);})
+          queue.length = 0;
+          GDATA[queueArrKey] = undefined
+        }
+
+        return d})
+      .catch((e) => {
+        return null;
+      });
+  }
+
+  function _getAllData() {
+    let year = "" +  endYear
+    let preYear = "" + (Number(year) - 1);
+    return getAllYearCfg()
+      .then((d) => {
+        let yearCfg = d;
+       
+        let arr = [];
+        if (yearCfg[year]) {
+          arr.push(getYearData(year));
+        }
+
+        if (yearCfg[preYear]) {
+          arr.push(getYearData(preYear));
+        }
+        return Promise.all(arr).then((alldata) => {
+          let combineData = {};
+          let d1 = alldata[0];
+          let d2 = alldata[1];
+ 
+ 
+
+          if(d1 && d1.year){
+            combineData[d1.year] = d1
+          }
+
+          if(d2 && d2.year){
+            combineData[d2.year] = d2
+          }
+
+          return Promise.resolve(combineData)
+        });
+      });
+  }
+
+
+  return _getAllData()
+ 
+};

data/_includes/js_source/getmapdata.js

@@ -0,0 +1,280 @@
+
+(function () {
+  var g_id = 100;
+
+  function ymd2Date(ymd) {
+    const parts = ymd.split('-').map(Number);
+    if (parts.length !== 3) {
+      throw new Error(`Invalid date format: ${ymd}`);
+    }
+    const [year, month, day] = parts;
+    return new Date(year, month - 1, day); // month 从 0 开始
+  };
+
+  function normalizeYmd(ymd){
+    if (ymd) {
+      const arr = ymd.split('-')
+      return `${arr[0]}-${arr[1].padStart(2,'0')}-${arr[2].padStart(2,'0')}`
+    }
+
+    return ymd
+  }
+
+
+  function getConfigFromStr(str,obj){
+    if (str && str.startsWith('#')) {
+      // #color #121212
+      // #title 123
+      let arr = str.split(' ')
+      if(arr.length >= 2){
+        let key = arr[0].substring(1)
+        if(key ){
+          obj[key] = str.substring(key.length + 2).trim()
+          return 1
+        }
+      }
+    }
+    return 0
+  }
+
+
+
+  function date2ymd(t) {
+    let m = t.getMonth() + 1;
+    let d = t.getDate();
+    return `${t.getFullYear()}-${m < 10 ? "0" + m : m}-${d < 10 ? "0" + d : d}`;
+  }
+  /// 2025-01-01 描述，日期格式yyyy-mm-dd，空格后跟上 描述
+  function getDataFromSignleLine(str0,gData) {
+    if(!str0) return null
+    let str = str0.trim()
+    if (!str) return null
+
+    if(gData && getConfigFromStr(str,gData)) return null
+
+
+    var arr = str.split(" ")
+    var date0 = arr[0]
+    date0 = date0.replace('～','~')
+    if (gData && date0.indexOf("~") > 0) {
+      let arrRg = date0.split('~')
+      let beginYmd = arrRg[0]
+      let endYmd = arrRg[1]
+      let dateBegin = ymd2Date(normalizeYmd(beginYmd))
+      if (!dateBegin || isNaN(dateBegin)) {
+        
+        return
+      }
+      let rangCount = 7
+      if(endYmd){
+         let dend = ymd2Date(normalizeYmd(endYmd))
+         if (dend && !isNaN(dend)) {
+          rangCount = Math.floor((dend.getTime() - dateBegin.getTime())/ 86400000) + 1
+         }
+         
+      }else{
+        rangCount =  Math.floor((Date.now() - dateBegin.getTime())/ 86400000) + 1;
+        if(rangCount > 7) rangCount =7
+      }
+ 
+      const desc = arr.slice(1).join(' ')
+      
+      let resultArr = []
+      const timeStampBegin =  dateBegin.getTime()
+      for (let i  = 0; i  < rangCount; i ++) {
+        const ymd = date2ymd(new Date(timeStampBegin + i * 86400000))
+        const newStr = ymd + ' ' + desc
+        const newEle = getDataFromSignleLine(newStr)
+        if(newEle){
+          resultArr.push(newEle)
+        }
+      }
+      return resultArr.length ? resultArr : null
+
+    }
+
+
+
+    let date = ''
+    if (date0) {
+      let ymd = date0.split("-")
+      if (ymd.length == 3) {
+        let year = ymd[0]
+        let month = ymd[1]
+        let day = ymd[2]
+
+        let nY = Number(year)
+        let nM = Number(month)
+        let nD = Number(month)
+        if (isNaN(nY) || isNaN(nD) || isNaN(nM) || nY < 1900 || nY > 2100 || nM < 1 || nM > 12 || nD < 1 || nD > 31) {
+          return null
+        }
+        date = year + "-" + month.padStart(2, '0') + "-" + day.padStart(2, '0')
+      }
+    }
+    else {
+      return null
+    }
+
+    if (!date) {
+      return null
+    }
+    var title = ""
+    let color = undefined
+    if (arr.length > 1) {
+      title = arr.slice(1).join(" ")
+
+      const regColor = /#[0-9a-fA-F]{6}/
+      let colorScaned = regColor.exec(title)
+      if (colorScaned && colorScaned.length) {
+        color = colorScaned[0]
+        title = title.replace(regColor,'')
+      }
+
+    }
+    return { date: date, title: title ,color}
+  }
+
+  function fillDataObj(data, item) {
+    if (!item) return
+    let y = item.date.substring(0, 4);
+    let m = item.date.substring(5, 7);
+    let c = data.allYear[y];
+    data.allYear[y] = c ? c + 1 : 1;
+
+    let yObj = data[y]
+    if (!yObj) {
+      yObj = {}
+      data[y] = yObj;
+    }
+
+    let arr = yObj[m]
+    if (!arr) {
+      arr = []
+      yObj[m] = arr
+    }
+    arr.push(item)
+
+  }
+
+
+  async function wait (t ) {
+    return new Promise(function(r){
+      setTimeout(() => {
+         r()
+      }, t );
+    })
+  }
+  
+  function parseDataAndCeateMap(strData,node) {
+   
+
+    let allYear = {}
+    let dataObj = { allYear: allYear };
+ 
+    let Recent365Count = 0;
+    let nowDate = new Date
+    let Recent365YMD = `${nowDate.getFullYear() - 1}-${(nowDate.getMonth() + 1).toString().padStart(2, '0')}-${nowDate.getDate().toString().padStart(2, '0')}`
+ 
+
+    strData.split("\n").forEach(function (str,idx) {
+      if(idx == 0) return 
+      let item = getDataFromSignleLine(str,dataObj)
+      if (item && Array.isArray(item)) {
+        item.forEach(e=>{
+          fillDataObj(dataObj, e)
+          if (e) {
+            if (e.date >= Recent365YMD) {
+              Recent365Count++
+            }
+          }
+        })
+      }else{
+        fillDataObj(dataObj, item)
+        if (item) {
+          if (item.date >= Recent365YMD) {
+            Recent365Count++
+          }
+        }
+      }
+      
+    })
+
+
+    if (dataObj.title ) {
+
+
+      let divTitle = document.createElement('div')
+      divTitle.className = 'custom-map-title'  
+      divTitle.innerText = dataObj.title || ''
+
+      let codeHolder = node.parentNode
+      codeHolder.insertBefore(divTitle,node)
+      
+    }
+    
+
+    let allYearArr = Object.keys(allYear).sort().reverse()
+
+
+    let RCT = dataObj['recent'];
+    let showRct = true
+    if (!RCT) {
+      showRct = Recent365Count && allYearArr.length > 1
+    }else{
+      showRct = RCT == '1'
+    }
+    if(showRct){
+      create_heatmap_lv('lmpRecent365' + g_id ++, '', dataObj, "Last 1Y", Recent365Count,node)
+    }
+    
+    for (let i = 0; i < allYearArr.length; i++) {
+      let y = allYearArr[i]
+      create_heatmap_lv('lmp' + y + g_id ++ , y, dataObj,undefined,undefined,node)
+    }
+
+    node.style.display = 'none'
+
+  
+
+  };
+
+  async function initData(){
+    let arrCodes = document.querySelectorAll('pre > code')
+    if (!arrCodes || arrCodes.length == 0) return
+
+    if (arrCodes.length > 0) {
+      for (let i  = 0; i  < arrCodes.length; i ++) {
+        const code = arrCodes[i ];
+        var strAll = code.textContent
+        if (!strAll.startsWith("#mapdata")) {
+          return 
+        }
+
+        parseDataAndCeateMap(strAll,code.parentNode.parentNode.parentNode)
+ 
+        
+      }
+   
+    }
+  }
+
+  initData()
+
+  window['_after_dec_fun'] = function () {
+    let con = document.getElementById('loveiContainer')
+    if (!con) {
+      let decryptContent = document.getElementById('decryptContent')
+      if (!decryptContent) return
+      con = document.createElement('div')
+      con.id = 'loveiContainer'
+      decryptContent.insertBefore(con, decryptContent.firstChild)
+
+    }
+
+    initData()
+  }
+  window['_after_enc_fun'] = function () {
+    document.getElementById('loveiContainer').innerHTML = ''
+  }
+})();