create-expresss 1.0.0

package/template/srms/Sangano_Ineza_Davina_National_Practical_Exam_2026/backend-project/node_modules/bcryptjs/src/bcrypt/prng/accum.js

@@ -0,0 +1,133 @@
+/* basic entropy accumulator */
+var accum = (function() {
+
+    var pool,    // randomness pool
+        time,    // start timestamp
+        last;    // last step timestamp
+
+    /* initialize with default pool */
+    function init() {
+        pool = [];
+        time = new Date().getTime();
+        last = time;
+        // use Math.random
+        pool.push((Math.random() * 0xffffffff)|0);
+        // use current time
+        pool.push(time|0);
+    }
+
+    /* perform one step */
+    function step() {
+        if (!to)
+            return;
+        if (pool.length >= 255) { // stop at 255 values (1 more is added on fetch)
+            stop();
+            return;
+        }
+        var now = new Date().getTime();
+        // use actual time difference
+        pool.push(now-last);
+        // always compute, occasionally use Math.random
+        var rnd = (Math.random() * 0xffffffff)|0;
+        if (now % 2)
+            pool[pool.length-1] += rnd;
+        last = now;
+        to = setTimeout(step, 100+Math.random()*512); // use hypothetical time difference
+    }
+
+    var to = null;
+
+    /* starts accumulating */
+    function start() {
+        if (to) return;
+        to = setTimeout(step, 100+Math.random()*512);
+        if (console.log)
+            console.log("bcrypt-isaac: collecting entropy...");
+        // install collectors
+        if (typeof window !== 'undefined' && window && window.addEventListener)
+            window.addEventListener("load", loadCollector, false),
+            window.addEventListener("mousemove", mouseCollector, false),
+            window.addEventListener("touchmove", touchCollector, false);
+        else if (typeof document !== 'undefined' && document && document.attachEvent)
+            document.attachEvent("onload", loadCollector),
+            document.attachEvent("onmousemove", mouseCollector);
+    }
+
+    /* stops accumulating */
+    function stop() {
+        if (!to) return;
+        clearTimeout(to); to = null;
+        // uninstall collectors
+        if (typeof window !== 'undefined' && window && window.removeEventListener)
+            window.removeEventListener("load", loadCollector, false),
+            window.removeEventListener("mousemove", mouseCollector, false),
+            window.removeEventListener("touchmove", touchCollector, false);
+        else if (typeof document !== 'undefined' && document && document.detachEvent)
+            document.detachEvent("onload", loadCollector),
+            document.detachEvent("onmousemove", mouseCollector);
+    }
+
+    /* fetches the randomness pool */
+    function fetch() {
+        // add overall time difference
+        pool.push((new Date().getTime()-time)|0);
+        var res = pool;
+        init();
+        if (console.log)
+            console.log("bcrypt-isaac: using "+res.length+"/256 samples of entropy");
+        // console.log(res);
+        return res;
+    }
+
+    /* adds the current time to the top of the pool */
+    function addTime() {
+        pool[pool.length-1] += new Date().getTime() - time;
+    }
+
+    /* page load collector */
+    function loadCollector() {
+        if (!to || pool.length >= 255)
+            return;
+        pool.push(0);
+        addTime();
+    }
+
+    /* mouse events collector */
+    function mouseCollector(ev) {
+        if (!to || pool.length >= 255)
+            return;
+        try {
+            var x = ev.x || ev.clientX || ev.offsetX || 0,
+                y = ev.y || ev.clientY || ev.offsetY || 0;
+            if (x != 0 || y != 0)
+                pool[pool.length-1] += ((x-mouseCollector.last[0]) ^ (y-mouseCollector.last[1])),
+                addTime(),
+                mouseCollector.last = [x,y];
+        } catch (e) {}
+    }
+    mouseCollector.last = [0,0];
+
+    /* touch events collector */
+    function touchCollector(ev) {
+        if (!to || pool.length >= 255)
+            return;
+        try {
+            var touch = ev.touches[0] || ev.changedTouches[0];
+            var x = touch.pageX || touch.clientX || 0,
+                y = touch.pageY || touch.clientY || 0;
+            if (x != 0 || y != 0)
+                pool[pool.length-1] += (x-touchCollector.last[0]) ^ (y-touchCollector.last[1]),
+                addTime(),
+                touchCollector.last = [x,y];
+        } catch (e) {}
+    }
+    touchCollector.last = [0,0];
+
+    init();
+    return {
+        "start": start,
+        "stop": stop,
+        "fetch": fetch
+    }
+
+})();

package/template/srms/Sangano_Ineza_Davina_National_Practical_Exam_2026/backend-project/node_modules/bcryptjs/src/bcrypt/prng/isaac.js

@@ -0,0 +1,140 @@
+/*
+ isaac.js Copyright (c) 2012 Yves-Marie K. Rinquin
+ 
+ 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.
+ */
+
+/* isaac module pattern */
+var isaac = (function(){
+
+    /* internal states */
+    var m = Array(256), // internal memory
+        acc = 0,        // accumulator
+        brs = 0,        // last result
+        cnt = 0,        // counter
+        r = Array(256), // result array
+        gnt = 0,        // generation counter
+        isd = false;    // initially seeded
+
+
+    /* 32-bit integer safe adder */
+    function add(x, y) {
+        var lsb = (x & 0xffff) + (y & 0xffff),
+            msb = (x >>>   16) + (y >>>   16) + (lsb >>> 16);
+        return (msb << 16) | (lsb & 0xffff);
+    }
+
+    /* initialisation */
+    function reset() {
+        acc = brs = cnt = 0;
+        for (var i = 0; i < 256; ++i)
+            m[i] = r[i] = 0;
+        gnt = 0;
+    }
+
+    /* seeding function */
+    function seed(s) {
+        var a, b, c, d, e, f, g, h, i;
+
+        /* seeding the seeds of love */
+        a = b = c = d = e = f = g = h = 0x9e3779b9; /* the golden ratio */
+
+        if (s && typeof(s) === 'number')
+            s = [s];
+
+        if (s instanceof Array) {
+            reset();
+            for (i = 0; i < s.length; ++i)
+                r[i & 0xff] += typeof(s[i]) === 'number' ? s[i] : 0;
+        }
+
+        /* private: seed mixer */
+        function seed_mix() {
+            a ^= b <<  11; d = add(d, a); b = add(b, c);
+            b ^= c >>>  2; e = add(e, b); c = add(c, d);
+            c ^= d <<   8; f = add(f, c); d = add(d, e);
+            d ^= e >>> 16; g = add(g, d); e = add(e, f);
+            e ^= f <<  10; h = add(h, e); f = add(f, g);
+            f ^= g >>>  4; a = add(a, f); g = add(g, h);
+            g ^= h <<   8; b = add(b, g); h = add(h, a);
+            h ^= a >>>  9; c = add(c, h); a = add(a, b);
+        }
+
+        for (i = 0; i < 4; i++) /* scramble it */
+            seed_mix();
+
+        for (i = 0; i < 256; i += 8) {
+            if (s) /* use all the information in the seed */
+                a = add(a, r[i + 0]), b = add(b, r[i + 1]),
+                c = add(c, r[i + 2]), d = add(d, r[i + 3]),
+                e = add(e, r[i + 4]), f = add(f, r[i + 5]),
+                g = add(g, r[i + 6]), h = add(h, r[i + 7]);
+            seed_mix();
+            /* fill in m[] with messy stuff */
+            m[i + 0] = a; m[i + 1] = b; m[i + 2] = c; m[i + 3] = d;
+            m[i + 4] = e; m[i + 5] = f; m[i + 6] = g; m[i + 7] = h;
+        }
+        if (s)
+            /* do a second pass to make all of the seed affect all of m[] */
+            for (i = 0; i < 256; i += 8)
+                a = add(a, m[i + 0]), b = add(b, m[i + 1]),
+                c = add(c, m[i + 2]), d = add(d, m[i + 3]),
+                e = add(e, m[i + 4]), f = add(f, m[i + 5]),
+                g = add(g, m[i + 6]), h = add(h, m[i + 7]),
+                seed_mix(),
+                /* fill in m[] with messy stuff (again) */
+                m[i + 0] = a, m[i + 1] = b, m[i + 2] = c, m[i + 3] = d,
+                m[i + 4] = e, m[i + 5] = f, m[i + 6] = g, m[i + 7] = h;
+        prng(); /* fill in the first set of results */
+        gnt = 256;  /* prepare to use the first set of results */;
+    }
+
+    /* isaac generator, n = number of run */
+    function prng(n) {
+        var i, x, y;
+        n = n && typeof(n) === 'number' ? Math.abs(Math.floor(n)) : 1;
+        while (n--) {
+            cnt = add(cnt,   1);
+            brs = add(brs, cnt);
+            for(i = 0; i < 256; i++) {
+                switch(i & 3) {
+                    case 0: acc ^= acc <<  13; break;
+                    case 1: acc ^= acc >>>  6; break;
+                    case 2: acc ^= acc <<   2; break;
+                    case 3: acc ^= acc >>> 16; break;
+                }
+                acc        = add(m[(i +  128) & 0xff], acc); x = m[i];
+                m[i] =   y = add(m[(x >>>  2) & 0xff], add(acc, brs));
+                r[i] = brs = add(m[(y >>> 10) & 0xff], x);
+            }
+        }
+    }
+
+    /* return a random number between */
+    return function() {
+        if (!isd) // seed from accumulator
+            isd = true,
+            accum.stop(),
+            seed(accum.fetch());
+        if (!gnt--)
+            prng(), gnt = 255;
+        return r[gnt];
+    };
+})();

package/template/srms/Sangano_Ineza_Davina_National_Practical_Exam_2026/backend-project/node_modules/bcryptjs/src/bcrypt/util/base64.js

@@ -0,0 +1,115 @@
+// A base64 implementation for the bcrypt algorithm. This is partly non-standard.
+
+/**
+ * bcrypt's own non-standard base64 dictionary.
+ * @type {!Array.<string>}
+ * @const
+ * @inner
+ **/
+var BASE64_CODE = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split('');
+
+/**
+ * @type {!Array.<number>}
+ * @const
+ * @inner
+ **/
+var BASE64_INDEX = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,
+    1, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, -1, -1, -1, -1, -1, -1,
+    -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+    20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, 28, 29, 30,
+    31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+    48, 49, 50, 51, 52, 53, -1, -1, -1, -1, -1];
+
+/**
+ * @type {!function(...number):string}
+ * @inner
+ */
+var stringFromCharCode = String.fromCharCode;
+
+/**
+ * Encodes a byte array to base64 with up to len bytes of input.
+ * @param {!Array.<number>} b Byte array
+ * @param {number} len Maximum input length
+ * @returns {string}
+ * @inner
+ */
+function base64_encode(b, len) {
+    var off = 0,
+        rs = [],
+        c1, c2;
+    if (len <= 0 || len > b.length)
+        throw Error("Illegal len: "+len);
+    while (off < len) {
+        c1 = b[off++] & 0xff;
+        rs.push(BASE64_CODE[(c1 >> 2) & 0x3f]);
+        c1 = (c1 & 0x03) << 4;
+        if (off >= len) {
+            rs.push(BASE64_CODE[c1 & 0x3f]);
+            break;
+        }
+        c2 = b[off++] & 0xff;
+        c1 |= (c2 >> 4) & 0x0f;
+        rs.push(BASE64_CODE[c1 & 0x3f]);
+        c1 = (c2 & 0x0f) << 2;
+        if (off >= len) {
+            rs.push(BASE64_CODE[c1 & 0x3f]);
+            break;
+        }
+        c2 = b[off++] & 0xff;
+        c1 |= (c2 >> 6) & 0x03;
+        rs.push(BASE64_CODE[c1 & 0x3f]);
+        rs.push(BASE64_CODE[c2 & 0x3f]);
+    }
+    return rs.join('');
+}
+
+/**
+ * Decodes a base64 encoded string to up to len bytes of output.
+ * @param {string} s String to decode
+ * @param {number} len Maximum output length
+ * @returns {!Array.<number>}
+ * @inner
+ */
+function base64_decode(s, len) {
+    var off = 0,
+        slen = s.length,
+        olen = 0,
+        rs = [],
+        c1, c2, c3, c4, o, code;
+    if (len <= 0)
+        throw Error("Illegal len: "+len);
+    while (off < slen - 1 && olen < len) {
+        code = s.charCodeAt(off++);
+        c1 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
+        code = s.charCodeAt(off++);
+        c2 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
+        if (c1 == -1 || c2 == -1)
+            break;
+        o = (c1 << 2) >>> 0;
+        o |= (c2 & 0x30) >> 4;
+        rs.push(stringFromCharCode(o));
+        if (++olen >= len || off >= slen)
+            break;
+        code = s.charCodeAt(off++);
+        c3 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
+        if (c3 == -1)
+            break;
+        o = ((c2 & 0x0f) << 4) >>> 0;
+        o |= (c3 & 0x3c) >> 2;
+        rs.push(stringFromCharCode(o));
+        if (++olen >= len || off >= slen)
+            break;
+        code = s.charCodeAt(off++);
+        c4 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
+        o = ((c3 & 0x03) << 6) >>> 0;
+        o |= c4;
+        rs.push(stringFromCharCode(o));
+        ++olen;
+    }
+    var res = [];
+    for (off = 0; off<olen; off++)
+        res.push(rs[off].charCodeAt(0));
+    return res;
+}

package/template/srms/Sangano_Ineza_Davina_National_Practical_Exam_2026/backend-project/node_modules/bcryptjs/src/bcrypt/util.js

@@ -0,0 +1,33 @@
+/**
+ * Continues with the callback on the next tick.
+ * @function
+ * @param {function(...[*])} callback Callback to execute
+ * @inner
+ */
+var nextTick = typeof process !== 'undefined' && process && typeof process.nextTick === 'function'
+    ? (typeof setImmediate === 'function' ? setImmediate : process.nextTick)
+    : setTimeout;
+
+/**
+ * Converts a JavaScript string to UTF8 bytes.
+ * @param {string} str String
+ * @returns {!Array.<number>} UTF8 bytes
+ * @inner
+ */
+function stringToBytes(str) {
+    var out = [],
+        i = 0;
+    utfx.encodeUTF16toUTF8(function() {
+        if (i >= str.length) return null;
+        return str.charCodeAt(i++);
+    }, function(b) {
+        out.push(b);
+    });
+    return out;
+}
+
+//? include("util/base64.js");
+
+//? include("../../node_modules/utfx/dist/utfx-embeddable.js");
+
+Date.now = Date.now || function() { return +new Date; };