@mavogel/awscdk-rootmail 0.1.34 → 0.1.35

package/node_modules/@aws-sdk/checksums/dist-es/submodules/sha/index.browser.js

@@ -1,4 +1,6 @@
 const no = Symbol.for("node-only");
 export { Sha1Js, Sha1Js as Sha1 } from "./sha1/Sha1Js";
 export const Sha1Node = no;
+export { Sha512WebCrypto, Sha512WebCrypto as Sha512 } from "./sha512/Sha512WebCrypto";
+export { Sha512Js } from "./sha512/Sha512Js";
 export { Sha256, Sha256Js, Sha256Node, Sha256WebCrypto } from "@smithy/core/checksum";

package/node_modules/@aws-sdk/checksums/dist-es/submodules/sha/index.js

@@ -1,4 +1,7 @@
 export { Sha1Js } from "./sha1/Sha1Js";
 export { Sha1Node, Sha1Node as Sha1 } from "./sha1/Sha1Node";
 export { Sha1WebCrypto } from "./sha1/Sha1WebCrypto";
+export { Sha512 } from "./sha512/Sha512";
+export { Sha512Js } from "./sha512/Sha512Js";
+export { Sha512WebCrypto } from "./sha512/Sha512WebCrypto";
 export { Sha256, Sha256Js, Sha256Node } from "@smithy/core/checksum";

package/node_modules/@aws-sdk/checksums/dist-es/submodules/sha/sha512/Sha512.js

@@ -0,0 +1,71 @@
+import { createHash, createHmac } from "node:crypto";
+import { Sha512Js } from "./Sha512Js";
+let nativeSupported;
+function detectNative() {
+    if (nativeSupported === undefined) {
+        try {
+            createHash("sha512");
+            nativeSupported = true;
+        }
+        catch {
+            nativeSupported = false;
+        }
+    }
+    return nativeSupported;
+}
+export class Sha512 extends Sha512Js {
+    native;
+    nativeSecret;
+    nativeFinished = false;
+    constructor(secret) {
+        super(secret);
+        this.nativeSecret = secret;
+        if (detectNative()) {
+            this.native = this.createNative();
+        }
+    }
+    update(data) {
+        if (!this.native) {
+            super.update(data);
+            return;
+        }
+        if (this.nativeFinished) {
+            throw new Error("Attempted to update an already finished hash.");
+        }
+        this.native.update(data);
+    }
+    async digest() {
+        if (!this.native) {
+            return super.digest();
+        }
+        let buf;
+        if (this.nativeSecret !== undefined) {
+            this.nativeFinished = true;
+            buf = this.native.digest();
+        }
+        else {
+            buf = this.native.copy().digest();
+        }
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    reset() {
+        if (!this.native) {
+            super.reset();
+            return;
+        }
+        this.native = this.createNative();
+        this.nativeFinished = false;
+    }
+    createNative() {
+        return this.nativeSecret !== undefined ? createHmac("sha512", toBuffer(this.nativeSecret)) : createHash("sha512");
+    }
+}
+function toBuffer(data) {
+    if (typeof data === "string") {
+        return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+        return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+}

package/node_modules/@aws-sdk/checksums/dist-es/submodules/sha/sha512/Sha512Js.js

@@ -0,0 +1,276 @@
+import { toUint8Array } from "@smithy/core/serde";
+const BLOCK = 128;
+const DIGEST_LENGTH = 64;
+const MAX_HASHABLE_LENGTH = 2 ** 53 - 1;
+const INIT = new Uint32Array([
+    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1, 0x510e527f,
+    0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
+]);
+const K = new Uint32Array([
+    0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
+    0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
+    0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
+    0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
+    0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
+    0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
+    0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
+    0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
+    0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
+    0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
+    0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
+    0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
+    0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
+    0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
+    0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
+    0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
+    0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
+    0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
+    0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
+    0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817,
+]);
+export class Sha512Js {
+    digestLength = DIGEST_LENGTH;
+    state = Uint32Array.from(INIT);
+    w;
+    buffer = new Uint8Array(BLOCK);
+    bufferLength = 0;
+    bytesHashed = 0;
+    finished = false;
+    key;
+    inner;
+    outer;
+    constructor(secret) {
+        if (secret !== undefined) {
+            this.key = Sha512Js.normalizeKey(secret);
+            this.initHmac();
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.inner) {
+            this.inner.update(data);
+            return;
+        }
+        const chunk = toUint8Array(data);
+        let position = 0;
+        let { byteLength } = chunk;
+        this.bytesHashed += byteLength;
+        if (this.bytesHashed * 8 > MAX_HASHABLE_LENGTH) {
+            throw new Error("Cannot hash more than 2^53 - 1 bits");
+        }
+        while (byteLength > 0) {
+            this.buffer[this.bufferLength++] = chunk[position++];
+            byteLength--;
+            if (this.bufferLength === BLOCK) {
+                this.hashBuffer();
+                this.bufferLength = 0;
+            }
+        }
+    }
+    async digest() {
+        if (this.inner && this.outer) {
+            if (this.finished) {
+                throw new Error("Attempted to digest an already finished HMAC.");
+            }
+            this.finished = true;
+            const innerDigest = this.inner.digestSync();
+            this.outer.update(innerDigest);
+            return this.outer.digestSync();
+        }
+        return this.digestSync();
+    }
+    reset() {
+        this.state = Uint32Array.from(INIT);
+        this.buffer = new Uint8Array(BLOCK);
+        this.bufferLength = 0;
+        this.bytesHashed = 0;
+        this.finished = false;
+        if (this.key) {
+            this.initHmac();
+        }
+    }
+    initHmac() {
+        const key = this.key;
+        this.inner = new Sha512Js();
+        this.outer = new Sha512Js();
+        const pad = new Uint8Array(BLOCK * 2);
+        for (let i = 0; i < BLOCK; ++i) {
+            pad[i] = 0x36 ^ key[i];
+            pad[i + BLOCK] = 0x5c ^ key[i];
+        }
+        this.inner.update(pad.subarray(0, BLOCK));
+        this.outer.update(pad.subarray(BLOCK));
+    }
+    digestSync() {
+        const state = this.state.slice();
+        const buffer = this.buffer.slice();
+        let bufferLength = this.bufferLength;
+        const bitsHashed = this.bytesHashed * 8;
+        const bitsHi = Math.floor(bitsHashed / 0x100000000);
+        const bitsLo = bitsHashed >>> 0;
+        buffer[bufferLength++] = 0x80;
+        if (bufferLength > BLOCK - 16) {
+            for (let i = bufferLength; i < BLOCK; ++i) {
+                buffer[i] = 0;
+            }
+            this.hashBufferWith(state, buffer);
+            bufferLength = 0;
+        }
+        for (let i = bufferLength; i < BLOCK - 8; ++i) {
+            buffer[i] = 0;
+        }
+        const v = new DataView(buffer.buffer, buffer.byteOffset, BLOCK);
+        v.setUint32(BLOCK - 8, bitsHi, false);
+        v.setUint32(BLOCK - 4, bitsLo, false);
+        this.hashBufferWith(state, buffer);
+        const out = new Uint8Array(DIGEST_LENGTH);
+        const dv = new DataView(out.buffer);
+        for (let i = 0; i < 16; ++i) {
+            dv.setUint32(i * 4, state[i], false);
+        }
+        return out;
+    }
+    static normalizeKey(secret) {
+        const key = toUint8Array(secret);
+        if (key.byteLength > BLOCK) {
+            const h = new Sha512Js();
+            h.update(key);
+            const padded = new Uint8Array(BLOCK);
+            padded.set(h.digestSync());
+            return padded;
+        }
+        const padded = new Uint8Array(BLOCK);
+        padded.set(key);
+        return padded;
+    }
+    hashBuffer() {
+        this.hashBufferWith(this.state, this.buffer);
+    }
+    hashBufferWith(state, buffer) {
+        const w = (this.w ??= new Uint32Array(160));
+        const v = new Uint32Array(16);
+        for (let i = 0; i < 16; ++i) {
+            v[i] = state[i];
+        }
+        for (let i = 0; i < 16; ++i) {
+            const o = i * 8;
+            w[i * 2] = ((buffer[o] << 24) | (buffer[o + 1] << 16) | (buffer[o + 2] << 8) | buffer[o + 3]) >>> 0;
+            w[i * 2 + 1] = ((buffer[o + 4] << 24) | (buffer[o + 5] << 16) | (buffer[o + 6] << 8) | buffer[o + 7]) >>> 0;
+        }
+        for (let i = 16; i < 80; ++i) {
+            const g15h = w[(i - 15) * 2];
+            const g15l = w[(i - 15) * 2 + 1];
+            const s0h = rotrH(g15h, g15l, 1) ^ rotrH(g15h, g15l, 8) ^ shrH(g15h, 7);
+            const s0l = rotrL(g15h, g15l, 1) ^ rotrL(g15h, g15l, 8) ^ shrL(g15h, g15l, 7);
+            const g2h = w[(i - 2) * 2];
+            const g2l = w[(i - 2) * 2 + 1];
+            const s1h = rotrH(g2h, g2l, 19) ^ rotrH(g2h, g2l, 61) ^ shrH(g2h, 6);
+            const s1l = rotrL(g2h, g2l, 19) ^ rotrL(g2h, g2l, 61) ^ shrL(g2h, g2l, 6);
+            const w7h = w[(i - 7) * 2];
+            const w7l = w[(i - 7) * 2 + 1];
+            const w16h = w[(i - 16) * 2];
+            const w16l = w[(i - 16) * 2 + 1];
+            let lo = (w16l >>> 0) + (s0l >>> 0);
+            let hi = (w16h >>> 0) + (s0h >>> 0) + (lo > 0xffffffff ? 1 : 0);
+            lo = (lo >>> 0) + (w7l >>> 0);
+            hi = (hi >>> 0) + (w7h >>> 0) + (lo > 0xffffffff ? 1 : 0);
+            lo = (lo >>> 0) + (s1l >>> 0);
+            hi = (hi >>> 0) + (s1h >>> 0) + (lo > 0xffffffff ? 1 : 0);
+            w[i * 2] = hi >>> 0;
+            w[i * 2 + 1] = lo >>> 0;
+        }
+        let ah = v[0], al = v[1], bh = v[2], bl = v[3], ch = v[4], cl = v[5], dh = v[6], dl = v[7], eh = v[8], el = v[9], fh = v[10], fl = v[11], gh = v[12], gl = v[13], hh = v[14], hl = v[15];
+        for (let i = 0; i < 80; ++i) {
+            const s1h = rotrH(eh, el, 14) ^ rotrH(eh, el, 18) ^ rotrH(eh, el, 41);
+            const s1l = rotrL(eh, el, 14) ^ rotrL(eh, el, 18) ^ rotrL(eh, el, 41);
+            const chh = (eh & fh) ^ (~eh & gh);
+            const chl = (el & fl) ^ (~el & gl);
+            let t1l = (hl >>> 0) + (s1l >>> 0);
+            let t1h = (hh >>> 0) + (s1h >>> 0) + (t1l > 0xffffffff ? 1 : 0);
+            t1l = (t1l >>> 0) + (chl >>> 0);
+            t1h = (t1h >>> 0) + (chh >>> 0) + (t1l > 0xffffffff ? 1 : 0);
+            t1l = (t1l >>> 0) + (K[i * 2 + 1] >>> 0);
+            t1h = (t1h >>> 0) + (K[i * 2] >>> 0) + (t1l > 0xffffffff ? 1 : 0);
+            t1l = (t1l >>> 0) + (w[i * 2 + 1] >>> 0);
+            t1h = (t1h >>> 0) + (w[i * 2] >>> 0) + (t1l > 0xffffffff ? 1 : 0);
+            const s0h = rotrH(ah, al, 28) ^ rotrH(ah, al, 34) ^ rotrH(ah, al, 39);
+            const s0l = rotrL(ah, al, 28) ^ rotrL(ah, al, 34) ^ rotrL(ah, al, 39);
+            const majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);
+            const majl = (al & bl) ^ (al & cl) ^ (bl & cl);
+            let t2l = (s0l >>> 0) + (majl >>> 0);
+            let t2h = (s0h >>> 0) + (majh >>> 0) + (t2l > 0xffffffff ? 1 : 0);
+            t2l = t2l >>> 0;
+            t2h = t2h >>> 0;
+            hh = gh;
+            hl = gl;
+            gh = fh;
+            gl = fl;
+            fh = eh;
+            fl = el;
+            let el2 = (dl >>> 0) + (t1l >>> 0);
+            let eh2 = (dh >>> 0) + (t1h >>> 0) + (el2 > 0xffffffff ? 1 : 0);
+            eh = eh2 >>> 0;
+            el = el2 >>> 0;
+            dh = ch;
+            dl = cl;
+            ch = bh;
+            cl = bl;
+            bh = ah;
+            bl = al;
+            let al2 = (t1l >>> 0) + (t2l >>> 0);
+            let ah2 = (t1h >>> 0) + (t2h >>> 0) + (al2 > 0xffffffff ? 1 : 0);
+            ah = ah2 >>> 0;
+            al = al2 >>> 0;
+        }
+        addInto(state, 0, ah, al);
+        addInto(state, 1, bh, bl);
+        addInto(state, 2, ch, cl);
+        addInto(state, 3, dh, dl);
+        addInto(state, 4, eh, el);
+        addInto(state, 5, fh, fl);
+        addInto(state, 6, gh, gl);
+        addInto(state, 7, hh, hl);
+    }
+}
+function addInto(state, slot, vh, vl) {
+    const i = slot * 2;
+    const lo = (state[i + 1] >>> 0) + (vl >>> 0);
+    const hi = (state[i] >>> 0) + (vh >>> 0) + (lo > 0xffffffff ? 1 : 0);
+    state[i] = hi >>> 0;
+    state[i + 1] = lo >>> 0;
+}
+function rotrH(hi, lo, n) {
+    if (n < 32) {
+        return ((hi >>> n) | (lo << (32 - n))) >>> 0;
+    }
+    if (n === 32) {
+        return lo >>> 0;
+    }
+    return ((lo >>> (n - 32)) | (hi << (64 - n))) >>> 0;
+}
+function rotrL(hi, lo, n) {
+    if (n < 32) {
+        return ((lo >>> n) | (hi << (32 - n))) >>> 0;
+    }
+    if (n === 32) {
+        return hi >>> 0;
+    }
+    return ((hi >>> (n - 32)) | (lo << (64 - n))) >>> 0;
+}
+function shrH(hi, n) {
+    if (n < 32) {
+        return hi >>> n;
+    }
+    return 0;
+}
+function shrL(hi, lo, n) {
+    if (n < 32) {
+        return ((lo >>> n) | (hi << (32 - n))) >>> 0;
+    }
+    if (n === 32) {
+        return hi >>> 0;
+    }
+    return hi >>> (n - 32);
+}

package/node_modules/@aws-sdk/checksums/dist-es/submodules/sha/sha512/Sha512WebCrypto.js

@@ -0,0 +1,76 @@
+import { concatBytes, toUint8Array } from "@smithy/core/serde";
+import { Sha512Js } from "./Sha512Js";
+const { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
+const subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function"
+    ? globalThis.crypto.subtle
+    : undefined;
+const MAX_PENDING_BYTES = 8 * 1024 * 1024;
+const BLOCK_SIZE = 128;
+export class Sha512WebCrypto {
+    digestLength = 64;
+    secret;
+    pending = [];
+    pendingBytes = 0;
+    fallback;
+    finished = false;
+    constructor(secret) {
+        if (secret !== undefined) {
+            const key = toUint8Array(secret);
+            this.secret = key.byteLength === 0 ? new Uint8Array(BLOCK_SIZE) : key;
+        }
+        if (!subtle) {
+            this.fallback = new Sha512Js(secret);
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.fallback) {
+            this.fallback.update(data);
+            return;
+        }
+        this.pending.push(data.slice());
+        this.pendingBytes += data.byteLength;
+        if (this.pendingBytes >= MAX_PENDING_BYTES) {
+            this.switchToFallback();
+        }
+    }
+    async digest() {
+        if (this.fallback) {
+            return this.fallback.digest();
+        }
+        if (this.secret && this.finished) {
+            throw new Error("Attempted to digest an already finished HMAC.");
+        }
+        const data = concatBytes(this.pending);
+        if (this.secret) {
+            this.finished = true;
+            const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-512" }, false, ["sign"]);
+            const sig = await subtle.sign("HMAC", key, data);
+            return new Uint8Array(sig);
+        }
+        const hash = await subtle.digest("SHA-512", data);
+        return new Uint8Array(hash);
+    }
+    reset() {
+        this.pending = [];
+        this.pendingBytes = 0;
+        this.finished = false;
+        if (subtle) {
+            this.fallback = undefined;
+        }
+        else {
+            this.fallback = new Sha512Js(this.secret);
+        }
+    }
+    switchToFallback() {
+        const sha512Js = new Sha512Js(this.secret);
+        for (const chunk of this.pending) {
+            sha512Js.update(chunk);
+        }
+        this.fallback = sha512Js;
+        this.pending = [];
+        this.pendingBytes = 0;
+    }
+}

package/node_modules/@aws-sdk/checksums/dist-es/submodules/xxh/U64.js

@@ -0,0 +1,190 @@
+const l16 = 0b1_0000_0000_0000_0000;
+export const m8 = 0b1111_1111;
+export const m16 = 0b1111_1111_1111_1111;
+export const m32 = 0b11111111_11111111_11111111_11111111;
+export class U64 extends Uint32Array {
+    constructor(buffer) {
+        super(buffer);
+    }
+    static create(size) {
+        return new U64(new ArrayBuffer(size * 2 * 4));
+    }
+    write(i, v0, v1) {
+        i *= 2;
+        this[i] = v0;
+        this[i + 1] = v1;
+        return this;
+    }
+    copy(source, target) {
+        source *= 2;
+        target *= 2;
+        this[target] = this[source];
+        this[target + 1] = this[source + 1];
+        return this;
+    }
+    add(i, v0, v1) {
+        i *= 2;
+        const j = i + 1;
+        const j0 = this[j];
+        const j1 = (j0 + v1) >>> 0;
+        this[i] = (this[i] + v0 + (j1 < j0 ? 1 : 0)) >>> 0;
+        this[j] = j1;
+        return this;
+    }
+    multiply(i, v0, v1) {
+        i *= 2;
+        const i0 = this[i];
+        const i1 = this[i + 1];
+        const a0 = i1 & m16;
+        const a1 = i1 >>> 16;
+        const a2 = i0 & m16;
+        const a3 = i0 >>> 16;
+        const b0 = v1 & m16;
+        const b1 = v1 >>> 16;
+        const b2 = v0 & m16;
+        const b3 = v0 >>> 16;
+        const c0 = a0 * b0;
+        const c1 = ((c0 / l16) | 0) + a1 * b0 + a0 * b1;
+        const c2 = ((c1 / l16) | 0) + a2 * b0 + a1 * b1 + a0 * b2;
+        const c3 = ((c2 / l16) | 0) + a3 * b0 + a2 * b1 + a1 * b2 + a0 * b3;
+        this[i] = (((c3 & m16) << 16) | (c2 & m16)) >>> 0;
+        this[i + 1] = (((c1 & m16) << 16) | (c0 & m16)) >>> 0;
+        return this;
+    }
+    addProduct(i, a, b) {
+        i *= 2;
+        const a0 = b & m16;
+        const a1 = b >>> 16;
+        const b0 = a & m16;
+        const b1 = a >>> 16;
+        const c0 = a0 * b0;
+        const c1 = ((c0 / l16) | 0) + a1 * b0 + a0 * b1;
+        const c2 = ((c1 / l16) | 0) + a1 * b1;
+        const lo = (((c1 & m16) << 16) | (c0 & m16)) >>> 0;
+        const hi = c2 >>> 0;
+        const prev = this[i + 1];
+        const newLo = (prev + lo) >>> 0;
+        this[i] = (this[i] + hi + (newLo < prev ? 1 : 0)) >>> 0;
+        this[i + 1] = newLo;
+        return this;
+    }
+    multiply128(i, j, t, u) {
+        i *= 2;
+        j *= 2;
+        t *= 2;
+        u *= 2;
+        const a0 = this[i + 1] & m16;
+        const a1 = this[i + 1] >>> 16;
+        const a2 = this[i] & m16;
+        const a3 = this[i] >>> 16;
+        const b0 = this[j + 1] & m16;
+        const b1 = this[j + 1] >>> 16;
+        const b2 = this[j] & m16;
+        const b3 = this[j] >>> 16;
+        const c0 = a0 * b0;
+        const c1 = ((c0 / l16) | 0) + a1 * b0 + a0 * b1;
+        const c2 = ((c1 / l16) | 0) + a2 * b0 + a1 * b1 + a0 * b2;
+        const c3 = ((c2 / l16) | 0) + a3 * b0 + a2 * b1 + a1 * b2 + a0 * b3;
+        const c4 = ((c3 / l16) | 0) + a3 * b1 + a2 * b2 + a1 * b3;
+        const c5 = ((c4 / l16) | 0) + a3 * b2 + a2 * b3;
+        const c6 = ((c5 / l16) | 0) + a3 * b3;
+        const c7 = (c6 / l16) | 0;
+        this[u] = (((c3 & m16) << 16) | (c2 & m16)) >>> 0;
+        this[u + 1] = (((c1 & m16) << 16) | (c0 & m16)) >>> 0;
+        this[t] = (((c7 & m16) << 16) | (c6 & m16)) >>> 0;
+        this[t + 1] = (((c5 & m16) << 16) | (c4 & m16)) >>> 0;
+        return this;
+    }
+    subtract(i, v0, v1) {
+        i *= 2;
+        const i1 = this[i + 1];
+        this[i] = (this[i] - v0 - (i1 < v1 ? 1 : 0)) >>> 0;
+        this[i + 1] = (i1 - v1) >>> 0;
+        return this;
+    }
+    left(i, places) {
+        i *= 2;
+        if (places <= 0) {
+        }
+        else if (places < 32) {
+            const v0 = this[i];
+            this[i] = ((v0 << places) >>> 0) | (this[i + 1] >>> (32 - places));
+            this[i + 1] = (this[i + 1] << places) >>> 0;
+        }
+        else if (places === 32) {
+            this[i] = this[i + 1];
+            this[i + 1] = 0;
+        }
+        else if (places > 32) {
+            this[i] = (this[i + 1] << (places - 32)) >>> 0;
+            this[i + 1] = 0;
+        }
+        return this;
+    }
+    rotateLeft(i, places) {
+        i *= 2;
+        const i0 = this[i];
+        const i1 = this[i + 1];
+        if (places === 0 || places === 64) {
+        }
+        else if (places < 32) {
+            this[i] = ((i0 << places) >>> 0) | (i1 >>> (32 - places));
+            this[i + 1] = ((i1 << places) >>> 0) | (i0 >>> (32 - places));
+        }
+        else if (places === 32) {
+            this[i] = i1;
+            this[i + 1] = i0;
+        }
+        else {
+            const p = places - 32;
+            this[i] = ((i1 << p) >>> 0) | (i0 >>> (32 - p));
+            this[i + 1] = ((i0 << p) >>> 0) | (i1 >>> (32 - p));
+        }
+        return this;
+    }
+    right(i, places) {
+        i *= 2;
+        if (places <= 0) {
+        }
+        else if (places < 32) {
+            this[i + 1] = (this[i + 1] >>> places) | ((this[i] << (32 - places)) >>> 0);
+            this[i] = this[i] >>> places;
+        }
+        else if (places === 32) {
+            this[i + 1] = this[i];
+            this[i] = 0;
+        }
+        else if (places > 32) {
+            this[i + 1] = this[i] >>> (places - 32);
+            this[i] = 0;
+        }
+        return this;
+    }
+    xor(i, v0, v1) {
+        i *= 2;
+        this[i] ^= v0;
+        this[i + 1] ^= v1;
+        return this;
+    }
+    toBytes(i) {
+        i *= 2;
+        const i0 = this[i];
+        const i1 = this[i + 1];
+        return new Uint8Array([
+            i0 >>> 24,
+            (i0 >>> 16) & m8,
+            (i0 >>> 8) & m8,
+            i0 & m8,
+            i1 >>> 24,
+            (i1 >>> 16) & m8,
+            (i1 >>> 8) & m8,
+            i1 & m8,
+        ]);
+    }
+    hi(i) {
+        return this[i * 2];
+    }
+    lo(i) {
+        return this[i * 2 + 1];
+    }
+}