@byline/admin 2.3.3 → 2.4.1

package/dist/vendor/noble-argon2/_md.js

@@ -1,95 +1,21 @@
-// @ts-nocheck — vendored from noble-hashes; see ./README.md
-/**
- * Internal Merkle-Damgard hash utils.
- * @module
- */
-import { abytes, aexists, aoutput, clean, createView, } from './utils.js';
-/**
- * Shared 32-bit conditional boolean primitive reused by SHA-256, SHA-1, and MD5 `F`.
- * Returns bits from `b` when `a` is set, otherwise from `c`.
- * The XOR form is equivalent to MD5's `F(X,Y,Z) = XY v not(X)Z` because the masked terms never
- * set the same bit.
- * @param a - selector word
- * @param b - word chosen when selector bit is set
- * @param c - word chosen when selector bit is clear
- * @returns Mixed 32-bit word.
- * @example
- * Combine three words with the shared 32-bit choice primitive.
- * ```ts
- * Chi(0xffffffff, 0x12345678, 0x87654321);
- * ```
- */
-export function Chi(a, b, c) {
-    return (a & b) ^ (~a & c);
+import { abytes, aexists, aoutput, clean, createView } from "./utils.js";
+function Chi(a, b, c) {
+    return a & b ^ ~a & c;
 }
-/**
- * Shared 32-bit majority primitive reused by SHA-256 and SHA-1.
- * Returns bits shared by at least two inputs.
- * @param a - first input word
- * @param b - second input word
- * @param c - third input word
- * @returns Mixed 32-bit word.
- * @example
- * Combine three words with the shared 32-bit majority primitive.
- * ```ts
- * Maj(0xffffffff, 0x12345678, 0x87654321);
- * ```
- */
-export function Maj(a, b, c) {
-    return (a & b) ^ (a & c) ^ (b & c);
+function Maj(a, b, c) {
+    return a & b ^ a & c ^ b & c;
 }
-/**
- * Merkle-Damgard hash construction base class.
- * Could be used to create MD5, RIPEMD, SHA1, SHA2.
- * Accepts only byte-aligned `Uint8Array` input, even when the underlying spec describes bit
- * strings with partial-byte tails.
- * @param blockLen - internal block size in bytes
- * @param outputLen - digest size in bytes
- * @param padOffset - trailing length field size in bytes
- * @param isLE - whether length and state words are encoded in little-endian
- * @example
- * Use a concrete subclass to get the shared Merkle-Damgard update/digest flow.
- * ```ts
- * import { _SHA1 } from '@noble/hashes/legacy.js';
- * const hash = new _SHA1();
- * hash.update(new Uint8Array([97, 98, 99]));
- * hash.digest();
- * ```
- */
-export class HashMD {
-    blockLen;
-    outputLen;
-    canXOF = false;
-    padOffset;
-    isLE;
-    // For partial updates less than block size
-    buffer;
-    view;
-    finished = false;
-    length = 0;
-    pos = 0;
-    destroyed = false;
-    constructor(blockLen, outputLen, padOffset, isLE) {
-        this.blockLen = blockLen;
-        this.outputLen = outputLen;
-        this.padOffset = padOffset;
-        this.isLE = isLE;
-        this.buffer = new Uint8Array(blockLen);
-        this.view = createView(this.buffer);
-    }
+class HashMD {
     update(data) {
         aexists(this);
         abytes(data);
         const { view, buffer, blockLen } = this;
         const len = data.length;
-        for (let pos = 0; pos < len;) {
+        for(let pos = 0; pos < len;){
             const take = Math.min(blockLen - this.pos, len - pos);
-            // Fast path only when there is no buffered partial block: `take === blockLen` implies
-            // `this.pos === 0`, so we can process full blocks directly from the input view.
             if (take === blockLen) {
                 const dataView = createView(data);
-                for (; blockLen <= len - pos; pos += blockLen)
-                    this.process(dataView, pos);
+                for(; blockLen <= len - pos; pos += blockLen)this.process(dataView, pos);
                 continue;
             }
             buffer.set(data.subarray(pos, pos + take), this.pos);
@@ -108,45 +34,28 @@ export class HashMD {
         aexists(this);
         aoutput(out, this);
         this.finished = true;
-        // Padding
-        // We can avoid allocation of buffer for padding completely if it
-        // was previously not allocated here. But it won't change performance.
         const { buffer, view, blockLen, isLE } = this;
         let { pos } = this;
-        // append the bit '1' to the message
-        buffer[pos++] = 0b10000000;
+        buffer[pos++] = 128;
         clean(this.buffer.subarray(pos));
-        // we have less than padOffset left in buffer, so we cannot put length in
-        // current block, need process it and pad again
         if (this.padOffset > blockLen - pos) {
             this.process(view, 0);
             pos = 0;
         }
-        // Pad until full block byte with zeros
-        for (let i = pos; i < blockLen; i++)
-            buffer[i] = 0;
-        // `padOffset` reserves the whole length field. For SHA-384/512 the high 64 bits stay zero from
-        // the padding fill above, and JS will overflow before user input can make that half non-zero.
-        // So we only need to write the low 64 bits here.
-        view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+        for(let i = pos; i < blockLen; i++)buffer[i] = 0;
+        view.setBigUint64(blockLen - 8, BigInt(8 * this.length), isLE);
         this.process(view, 0);
         const oview = createView(out);
         const len = this.outputLen;
-        // NOTE: we do division by 4 later, which must be fused in single op with modulo by JIT
-        if (len % 4)
-            throw new Error('_sha2: outputLen must be aligned to 32bit');
+        if (len % 4) throw new Error('_sha2: outputLen must be aligned to 32bit');
         const outLen = len / 4;
         const state = this.get();
-        if (outLen > state.length)
-            throw new Error('_sha2: outputLen bigger than state');
-        for (let i = 0; i < outLen; i++)
-            oview.setUint32(4 * i, state[i], isLE);
+        if (outLen > state.length) throw new Error('_sha2: outputLen bigger than state');
+        for(let i = 0; i < outLen; i++)oview.setUint32(4 * i, state[i], isLE);
     }
     digest() {
         const { buffer, outputLen } = this;
         this.digestInto(buffer);
-        // Copy before destroy(): subclasses wipe `buffer` during cleanup, but `digest()` must return
-        // fresh bytes to the caller.
         const res = buffer.slice(0, outputLen);
         this.destroy();
         return res;
@@ -159,44 +68,80 @@ export class HashMD {
         to.finished = finished;
         to.length = length;
         to.pos = pos;
-        // Only partial-block bytes need copying: when `length % blockLen === 0`, `pos === 0` and
-        // later `update()` / `digestInto()` overwrite `to.buffer` from the start before reading it.
-        if (length % blockLen)
-            to.buffer.set(buffer);
+        if (length % blockLen) to.buffer.set(buffer);
         return to;
     }
     clone() {
         return this._cloneInto();
     }
+    constructor(blockLen, outputLen, padOffset, isLE){
+        this.canXOF = false;
+        this.finished = false;
+        this.length = 0;
+        this.pos = 0;
+        this.destroyed = false;
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
+        this.buffer = new Uint8Array(blockLen);
+        this.view = createView(this.buffer);
+    }
 }
-/**
- * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
- * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
- */
-/** Initial SHA256 state from RFC 6234 §6.1: the first 32 bits of the fractional parts of the
- * square roots of the first eight prime numbers. Exported as a shared table; callers must treat
- * it as read-only because constructors copy words from it by index. */
-export const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667,
+    0xbb67ae85,
+    0x3c6ef372,
+    0xa54ff53a,
+    0x510e527f,
+    0x9b05688c,
+    0x1f83d9ab,
+    0x5be0cd19
 ]);
-/** Initial SHA224 state `H(0)` from RFC 6234 §6.1. Exported as a shared table; callers must
- * treat it as read-only because constructors copy words from it by index. */
-export const SHA224_IV = /* @__PURE__ */ Uint32Array.from([
-    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
+const SHA224_IV = /* @__PURE__ */ Uint32Array.from([
+    0xc1059ed8,
+    0x367cd507,
+    0x3070dd17,
+    0xf70e5939,
+    0xffc00b31,
+    0x68581511,
+    0x64f98fa7,
+    0xbefa4fa4
 ]);
-/** Initial SHA384 state from RFC 6234 §6.3: eight RFC 64-bit `H(0)` words stored as sixteen
- * big-endian 32-bit halves. Derived from the fractional parts of the square roots of the ninth
- * through sixteenth prime numbers. Exported as a shared table; callers must treat it as read-only
- * because constructors copy halves from it by index. */
-export const SHA384_IV = /* @__PURE__ */ Uint32Array.from([
-    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,
-    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,
+const SHA384_IV = /* @__PURE__ */ Uint32Array.from([
+    0xcbbb9d5d,
+    0xc1059ed8,
+    0x629a292a,
+    0x367cd507,
+    0x9159015a,
+    0x3070dd17,
+    0x152fecd8,
+    0xf70e5939,
+    0x67332667,
+    0xffc00b31,
+    0x8eb44a87,
+    0x68581511,
+    0xdb0c2e0d,
+    0x64f98fa7,
+    0x47b5481d,
+    0xbefa4fa4
 ]);
-/** Initial SHA512 state from RFC 6234 §6.3: eight RFC 64-bit `H(0)` words stored as sixteen
- * big-endian 32-bit halves. Derived from the fractional parts of the square roots of the first
- * eight prime numbers. Exported as a shared table; callers must treat it as read-only because
- * constructors copy halves from it by index. */
-export const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
-    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
-    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
+const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667,
+    0xf3bcc908,
+    0xbb67ae85,
+    0x84caa73b,
+    0x3c6ef372,
+    0xfe94f82b,
+    0xa54ff53a,
+    0x5f1d36f1,
+    0x510e527f,
+    0xade682d1,
+    0x9b05688c,
+    0x2b3e6c1f,
+    0x1f83d9ab,
+    0xfb41bd6b,
+    0x5be0cd19,
+    0x137e2179
 ]);
+export { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV };

package/dist/vendor/noble-argon2/_u64.js

@@ -1,83 +1,81 @@
 const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 const _32n = /* @__PURE__ */ BigInt(32);
-// Split bigint into two 32-bit halves. With `le=true`, returned fields become `{ h: low, l: high
-// }` to match little-endian word order rather than the property names.
 function fromBig(n, le = false) {
-    if (le)
-        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
-    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+    if (le) return {
+        h: Number(n & U32_MASK64),
+        l: Number(n >> _32n & U32_MASK64)
+    };
+    return {
+        h: 0 | Number(n >> _32n & U32_MASK64),
+        l: 0 | Number(n & U32_MASK64)
+    };
 }
-// Split bigint list into `[highWords, lowWords]` when `le=false`; with `le=true`, the first array
-// holds the low halves because `fromBig(...)` swaps the semantic meaning of `h` and `l`.
 function split(lst, le = false) {
     const len = lst.length;
     let Ah = new Uint32Array(len);
     let Al = new Uint32Array(len);
-    for (let i = 0; i < len; i++) {
+    for(let i = 0; i < len; i++){
         const { h, l } = fromBig(lst[i], le);
-        [Ah[i], Al[i]] = [h, l];
+        [Ah[i], Al[i]] = [
+            h,
+            l
+        ];
     }
-    return [Ah, Al];
+    return [
+        Ah,
+        Al
+    ];
 }
-// Combine explicit `(high, low)` 32-bit halves into a bigint; `>>> 0` normalizes signed JS
-// bitwise results back to uint32 first, and little-endian callers must swap.
-const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
-// High 32-bit half of a 64-bit logical right shift for `s` in `0..31`.
-const shrSH = (h, _l, s) => h >>> s;
-// Low 32-bit half of a 64-bit logical right shift, valid for `s` in `1..31`.
-const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
-// High 32-bit half of a 64-bit right rotate, valid for `s` in `1..31`.
-const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
-// Low 32-bit half of a 64-bit right rotate, valid for `s` in `1..31`.
-const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
-// High 32-bit half of a 64-bit right rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.
-const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
-// Low 32-bit half of a 64-bit right rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.
-const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
-// High 32-bit half of a 64-bit right rotate for `s === 32`; this is just the swapped low half.
-const rotr32H = (_h, l) => l;
-// Low 32-bit half of a 64-bit right rotate for `s === 32`; this is just the swapped high half.
-const rotr32L = (h, _l) => h;
-// High 32-bit half of a 64-bit left rotate, valid for `s` in `1..31`.
-const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
-// Low 32-bit half of a 64-bit left rotate, valid for `s` in `1..31`.
-const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
-// High 32-bit half of a 64-bit left rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.
-const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
-// Low 32-bit half of a 64-bit left rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.
-const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
-// Add two split 64-bit words and return the split `{ h, l }` sum.
-// JS uses 32-bit signed integers for bitwise operations, so we cannot simply shift the carry out
-// of the low sum and instead use division.
+const toBig = (h, l)=>BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
+const shrSH = (h, _l, s)=>h >>> s;
+const shrSL = (h, l, s)=>h << 32 - s | l >>> s;
+const rotrSH = (h, l, s)=>h >>> s | l << 32 - s;
+const rotrSL = (h, l, s)=>h << 32 - s | l >>> s;
+const rotrBH = (h, l, s)=>h << 64 - s | l >>> s - 32;
+const rotrBL = (h, l, s)=>h >>> s - 32 | l << 64 - s;
+const rotr32H = (_h, l)=>l;
+const rotr32L = (h, _l)=>h;
+const rotlSH = (h, l, s)=>h << s | l >>> 32 - s;
+const rotlSL = (h, l, s)=>l << s | h >>> 32 - s;
+const rotlBH = (h, l, s)=>l << s - 32 | h >>> 64 - s;
+const rotlBL = (h, l, s)=>h << s - 32 | l >>> 64 - s;
 function add(Ah, Al, Bh, Bl) {
     const l = (Al >>> 0) + (Bl >>> 0);
-    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+    return {
+        h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
+        l: 0 | l
+    };
 }
-// Addition with more than 2 elements
-// Unmasked low-word accumulator for 3-way addition; pass the raw result into `add3H(...)`.
-const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
-// High-word finalize step for 3-way addition; `low` must be the untruncated output of `add3L(...)`.
-const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
-// Unmasked low-word accumulator for 4-way addition; pass the raw result into `add4H(...)`.
-const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
-// High-word finalize step for 4-way addition; `low` must be the untruncated output of `add4L(...)`.
-const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
-// Unmasked low-word accumulator for 5-way addition; pass the raw result into `add5H(...)`.
-const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
-// High-word finalize step for 5-way addition; `low` must be the untruncated output of `add5L(...)`.
-const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
-// prettier-ignore
-export { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };
-// Canonical grouped namespace for callers that prefer one object.
-// Named exports stay for direct imports.
-// prettier-ignore
+const add3L = (Al, Bl, Cl)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch)=>Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+const add4L = (Al, Bl, Cl, Dl)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh)=>Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+const add5L = (Al, Bl, Cl, Dl, El)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh)=>Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
 const u64 = {
-    fromBig, split, toBig,
-    shrSH, shrSL,
-    rotrSH, rotrSL, rotrBH, rotrBL,
-    rotr32H, rotr32L,
-    rotlSH, rotlSL, rotlBH, rotlBL,
-    add, add3L, add3H, add4L, add4H, add5H, add5L,
+    fromBig: fromBig,
+    split: split,
+    toBig: toBig,
+    shrSH: shrSH,
+    shrSL: shrSL,
+    rotrSH: rotrSH,
+    rotrSL: rotrSL,
+    rotrBH: rotrBH,
+    rotrBL: rotrBL,
+    rotr32H: rotr32H,
+    rotr32L: rotr32L,
+    rotlSH: rotlSH,
+    rotlSL: rotlSL,
+    rotlBH: rotlBH,
+    rotlBL: rotlBL,
+    add: add,
+    add3L: add3L,
+    add3H: add3H,
+    add4L: add4L,
+    add4H: add4H,
+    add5H: add5H,
+    add5L: add5L
 };
-// Default export mirrors named `u64` for compatibility with object-style imports.
-export default u64;
+const _u64 = u64;
+export default _u64;
+export { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };