@ohos-ports/crypto 0.0.0-stage → 0.3.1-beta.1

package/dist/noble/hmac.js

@@ -0,0 +1,101 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hmac = exports.HMAC = void 0;
+var _assert_1 = require("./_assert.js");
+var utils_1 = require("./utils.js");
+// HMAC (RFC 2104)
+var HMAC = /** @class */ (function (_super) {
+    __extends(HMAC, _super);
+    function HMAC(hash, _key) {
+        var _this = _super.call(this) || this;
+        _this.finished = false;
+        _this.destroyed = false;
+        (0, _assert_1.hash)(hash);
+        var key = (0, utils_1.toBytes)(_key);
+        _this.iHash = hash.create();
+        if (typeof _this.iHash.update !== 'function')
+            throw new Error('Expected instance of class which extends utils.Hash');
+        _this.blockLen = _this.iHash.blockLen;
+        _this.outputLen = _this.iHash.outputLen;
+        var blockLen = _this.blockLen;
+        var pad = new Uint8Array(blockLen);
+        // blockLen can be bigger than outputLen
+        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+        for (var i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36;
+        _this.iHash.update(pad);
+        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
+        _this.oHash = hash.create();
+        // Undo internal XOR && apply outer XOR
+        for (var i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36 ^ 0x5c;
+        _this.oHash.update(pad);
+        pad.fill(0);
+        return _this;
+    }
+    HMAC.prototype.update = function (buf) {
+        (0, _assert_1.exists)(this);
+        this.iHash.update(buf);
+        return this;
+    };
+    HMAC.prototype.digestInto = function (out) {
+        (0, _assert_1.exists)(this);
+        (0, _assert_1.bytes)(out, this.outputLen);
+        this.finished = true;
+        this.iHash.digestInto(out);
+        this.oHash.update(out);
+        this.oHash.digestInto(out);
+        this.destroy();
+    };
+    HMAC.prototype.digest = function () {
+        var out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+    };
+    HMAC.prototype._cloneInto = function (to) {
+        // Create new instance without calling constructor since key already in state and we don't know it.
+        to || (to = Object.create(Object.getPrototypeOf(this), {}));
+        var _a = this, oHash = _a.oHash, iHash = _a.iHash, finished = _a.finished, destroyed = _a.destroyed, blockLen = _a.blockLen, outputLen = _a.outputLen;
+        to = to;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        to.blockLen = blockLen;
+        to.outputLen = outputLen;
+        to.oHash = oHash._cloneInto(to.oHash);
+        to.iHash = iHash._cloneInto(to.iHash);
+        return to;
+    };
+    HMAC.prototype.destroy = function () {
+        this.destroyed = true;
+        this.oHash.destroy();
+        this.iHash.destroy();
+    };
+    return HMAC;
+}(utils_1.Hash));
+exports.HMAC = HMAC;
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - message key
+ * @param message - message data
+ */
+var hmac = function (hash, key, message) {
+    return new HMAC(hash, key).update(message).digest();
+};
+exports.hmac = hmac;
+exports.hmac.create = function (hash, key) { return new HMAC(hash, key); };

package/dist/noble/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./keccak.js";
+export * from "./bls12_381.js";

package/dist/noble/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./keccak.js"), exports);
+__exportStar(require("./bls12_381.js"), exports);
+// DO NOT export "./_u64";
+// DO NOT export "./utils";

package/dist/noble/keccak.d.ts

@@ -0,0 +1,58 @@
+import { Hash, Input, HashXOF } from './utils.js';
+export declare function keccakP(s: Uint32Array, rounds?: number): void;
+export declare class Keccak extends Hash<Keccak> implements HashXOF<Keccak> {
+    blockLen: number;
+    suffix: number;
+    outputLen: number;
+    protected enableXOF: boolean;
+    protected rounds: number;
+    protected state: Uint8Array;
+    protected pos: number;
+    protected posOut: number;
+    protected finished: boolean;
+    protected state32: Uint32Array;
+    protected destroyed: boolean;
+    constructor(blockLen: number, suffix: number, outputLen: number, enableXOF?: boolean, rounds?: number);
+    protected keccak(): void;
+    update(data: Input): this;
+    protected finish(): void;
+    protected writeInto(out: Uint8Array): Uint8Array;
+    xofInto(out: Uint8Array): Uint8Array;
+    xof(bytes: number): Uint8Array;
+    digestInto(out: Uint8Array): Uint8Array;
+    digest(): Uint8Array;
+    destroy(): void;
+    _cloneInto(to?: Keccak): Keccak;
+    assertExists(checkFinished?: boolean): void;
+}
+export declare const keccak_224: {
+    (msg: Input): Uint8Array;
+    outputLen: number;
+    blockLen: number;
+    create(): Hash<Keccak>;
+};
+/**
+ * keccak-256 hash function. Different from SHA3-256.
+ * @param message - that would be hashed
+ */
+export declare const keccak_256: {
+    (msg: Input): Uint8Array;
+    outputLen: number;
+    blockLen: number;
+    create(): Hash<Keccak>;
+};
+export declare const keccak_384: {
+    (msg: Input): Uint8Array;
+    outputLen: number;
+    blockLen: number;
+    create(): Hash<Keccak>;
+};
+export declare const keccak_512: {
+    (msg: Input): Uint8Array;
+    outputLen: number;
+    blockLen: number;
+    create(): Hash<Keccak>;
+};
+export type ShakeOpts = {
+    dkLen?: number;
+};

package/dist/noble/keccak.js

@@ -0,0 +1,289 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak_512 = exports.keccak_384 = exports.keccak_256 = exports.keccak_224 = exports.Keccak = exports.keccakP = void 0;
+/*
+THIS IMPLEMENTATION WAS TAKEN FROM `@noble/hashes`
+
+original source: https://github.com/paulmillr/noble-hashes/blob/6ae82e75d4c354d53a488e95b1bfe9cba90bd6ff/src/sha3.ts#L1
+
+it was modified and adapted to this repository to re-use already defined stuff
+
+the main reason for copying over and not using as dependency is because of different target in the `tsconfig.json`
+
+`@noble/hashes` targets es2020, which tends to cause problems with some other (older) packages sometimes
+
+this repo targets ES5+
+*/
+var _u64_1 = require("./_u64.js");
+var utils_1 = require("./utils.js");
+var assert_1 = require("../utils/assert.js");
+// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.
+// It's called a sponge function.
+// Various per round constants calculations
+var SHA3_PI = [];
+var SHA3_ROTL = [];
+var _SHA3_IOTA = [];
+var _0n = /** @__PURE__ */ BigInt(0);
+var _1n = /** @__PURE__ */ BigInt(1);
+var _2n = /** @__PURE__ */ BigInt(2);
+var _7n = /** @__PURE__ */ BigInt(7);
+var _256n = /** @__PURE__ */ BigInt(256);
+var _0x71n = /** @__PURE__ */ BigInt(0x71);
+for (var round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+    // Pi
+    _a = __read([y, (2 * x + 3 * y) % 5], 2), x = _a[0], y = _a[1];
+    SHA3_PI.push(2 * (5 * y + x));
+    // Rotational
+    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+    // Iota
+    var t = _0n;
+    for (var j = 0; j < 7; j++) {
+        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
+        if (R & _2n)
+            t ^= _1n << ((_1n << /** @__PURE__ */ BigInt(j)) - _1n);
+    }
+    _SHA3_IOTA.push(t);
+}
+var _b = __read(/** @__PURE__ */ (0, _u64_1.split)(_SHA3_IOTA, true), 2), SHA3_IOTA_H = _b[0], SHA3_IOTA_L = _b[1];
+// Left rotation (without 0, 32, 64)
+var rotlH = function (h, l, s) { return (s > 32 ? (0, _u64_1.rotlBH)(h, l, s) : (0, _u64_1.rotlSH)(h, l, s)); };
+var rotlL = function (h, l, s) { return (s > 32 ? (0, _u64_1.rotlBL)(h, l, s) : (0, _u64_1.rotlSL)(h, l, s)); };
+// Same as keccakf1600, but allows to skip some rounds
+function keccakP(s, rounds) {
+    if (rounds === void 0) { rounds = 24; }
+    var B = new Uint32Array(5 * 2);
+    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
+    for (var round = 24 - rounds; round < 24; round++) {
+        // Theta θ
+        for (var x = 0; x < 10; x++)
+            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+        for (var x = 0; x < 10; x += 2) {
+            var idx1 = (x + 8) % 10;
+            var idx0 = (x + 2) % 10;
+            var B0 = B[idx0];
+            var B1 = B[idx0 + 1];
+            var Th = rotlH(B0, B1, 1) ^ B[idx1];
+            var Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+            for (var y = 0; y < 50; y += 10) {
+                s[x + y] ^= Th;
+                s[x + y + 1] ^= Tl;
+            }
+        }
+        // Rho (ρ) and Pi (π)
+        var curH = s[2];
+        var curL = s[3];
+        for (var t = 0; t < 24; t++) {
+            var shift = SHA3_ROTL[t];
+            var Th = rotlH(curH, curL, shift);
+            var Tl = rotlL(curH, curL, shift);
+            var PI = SHA3_PI[t];
+            curH = s[PI];
+            curL = s[PI + 1];
+            s[PI] = Th;
+            s[PI + 1] = Tl;
+        }
+        // Chi (χ)
+        for (var y = 0; y < 50; y += 10) {
+            for (var x = 0; x < 10; x++)
+                B[x] = s[y + x];
+            for (var x = 0; x < 10; x++)
+                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+        }
+        // Iota (ι)
+        s[0] ^= SHA3_IOTA_H[round];
+        s[1] ^= SHA3_IOTA_L[round];
+    }
+    B.fill(0);
+}
+exports.keccakP = keccakP;
+var Keccak = /** @class */ (function (_super) {
+    __extends(Keccak, _super);
+    // NOTE: we accept arguments in bytes instead of bits here.
+    function Keccak(blockLen, suffix, outputLen, enableXOF, rounds) {
+        if (enableXOF === void 0) { enableXOF = false; }
+        if (rounds === void 0) { rounds = 24; }
+        var _this = _super.call(this) || this;
+        _this.blockLen = blockLen;
+        _this.suffix = suffix;
+        _this.outputLen = outputLen;
+        _this.enableXOF = enableXOF;
+        _this.rounds = rounds;
+        _this.pos = 0;
+        _this.posOut = 0;
+        _this.finished = false;
+        _this.destroyed = false;
+        // Can be passed from user as dkLen
+        (0, assert_1.assertPostiveInteger)(outputLen);
+        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
+        if (0 >= _this.blockLen || _this.blockLen >= 200)
+            throw new Error('Sha3 supports only keccak-f1600 function');
+        _this.state = new Uint8Array(200);
+        _this.state32 = (0, utils_1.u32)(_this.state);
+        return _this;
+    }
+    Keccak.prototype.keccak = function () {
+        if (!utils_1.isLE)
+            (0, utils_1.byteSwap32)(this.state32);
+        keccakP(this.state32, this.rounds);
+        if (!utils_1.isLE)
+            (0, utils_1.byteSwap32)(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+    };
+    Keccak.prototype.update = function (data) {
+        this.assertExists();
+        var _a = this, blockLen = _a.blockLen, state = _a.state;
+        data = (0, utils_1.toBytes)(data);
+        var len = data.length;
+        for (var pos = 0; pos < len;) {
+            var take = Math.min(blockLen - this.pos, len - pos);
+            for (var i = 0; i < take; i++)
+                state[this.pos++] ^= data[pos++];
+            if (this.pos === blockLen)
+                this.keccak();
+        }
+        return this;
+    };
+    Keccak.prototype.finish = function () {
+        if (this.finished)
+            return;
+        this.finished = true;
+        var _a = this, state = _a.state, suffix = _a.suffix, pos = _a.pos, blockLen = _a.blockLen;
+        // Do the padding
+        state[pos] ^= suffix;
+        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+            this.keccak();
+        state[blockLen - 1] ^= 0x80;
+        this.keccak();
+    };
+    Keccak.prototype.writeInto = function (out) {
+        this.assertExists(false);
+        if (!(out instanceof Uint8Array))
+            throw new Error("Uint8Array expected");
+        this.finish();
+        var bufferOut = this.state;
+        var blockLen = this.blockLen;
+        for (var pos = 0, len = out.length; pos < len;) {
+            if (this.posOut >= blockLen)
+                this.keccak();
+            var take = Math.min(blockLen - this.posOut, len - pos);
+            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+            this.posOut += take;
+            pos += take;
+        }
+        return out;
+    };
+    Keccak.prototype.xofInto = function (out) {
+        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
+        if (!this.enableXOF)
+            throw new Error('XOF is not possible for this instance');
+        return this.writeInto(out);
+    };
+    Keccak.prototype.xof = function (bytes) {
+        (0, assert_1.assertPostiveInteger)(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+    };
+    Keccak.prototype.digestInto = function (out) {
+        // output(out, this);
+        if (!(out instanceof Uint8Array))
+            throw new Error("Uint8Array expected");
+        var min = this.outputLen;
+        if (out.length < min)
+            throw new Error("digestInto() expects output buffer of length at least ".concat(min));
+        if (this.finished)
+            throw new Error('digest() was already called');
+        this.writeInto(out);
+        this.destroy();
+        return out;
+    };
+    Keccak.prototype.digest = function () {
+        return this.digestInto(new Uint8Array(this.outputLen));
+    };
+    Keccak.prototype.destroy = function () {
+        this.destroyed = true;
+        this.state.fill(0);
+    };
+    Keccak.prototype._cloneInto = function (to) {
+        var _a = this, blockLen = _a.blockLen, suffix = _a.suffix, outputLen = _a.outputLen, rounds = _a.rounds, enableXOF = _a.enableXOF;
+        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        // Suffix can change in cSHAKE
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+    };
+    Keccak.prototype.assertExists = function (checkFinished) {
+        if (checkFinished === void 0) { checkFinished = true; }
+        if (this.destroyed)
+            throw new Error('Hash instance has been destroyed');
+        if (checkFinished && this.finished)
+            throw new Error('Hash#digest() has already been called');
+    };
+    return Keccak;
+}(utils_1.Hash));
+exports.Keccak = Keccak;
+var gen = function (suffix, blockLen, outputLen) {
+    return (0, utils_1.wrapConstructor)(function () { return new Keccak(blockLen, suffix, outputLen); });
+};
+// export const sha3_224 = /** @__PURE__ */ gen(0x06, 144, 224 / 8);
+// /**
+//  * SHA3-256 hash function
+//  * @param message - that would be hashed
+//  */
+// export const sha3_256 = /** @__PURE__ */ gen(0x06, 136, 256 / 8);
+// export const sha3_384 = /** @__PURE__ */ gen(0x06, 104, 384 / 8);
+// export const sha3_512 = /** @__PURE__ */ gen(0x06, 72, 512 / 8);
+exports.keccak_224 = gen(0x01, 144, 224 / 8);
+/**
+ * keccak-256 hash function. Different from SHA3-256.
+ * @param message - that would be hashed
+ */
+exports.keccak_256 = gen(0x01, 136, 256 / 8);
+exports.keccak_384 = gen(0x01, 104, 384 / 8);
+exports.keccak_512 = gen(0x01, 72, 512 / 8);
+// const genShake = (suffix: number, blockLen: number, outputLen: number) =>
+//   wrapXOFConstructorWithOpts<HashXOF<Keccak>, ShakeOpts>(
+//     (opts: ShakeOpts = {}) =>
+//       new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true)
+//   );
+// 
+// export const shake128 = /** @__PURE__ */ genShake(0x1f, 168, 128 / 8);
+// export const shake256 = /** @__PURE__ */ genShake(0x1f, 136, 256 / 8);

package/dist/noble/ripemd_160.d.ts

@@ -0,0 +1,20 @@
+/**
+ * RIPEMD-160 legacy hash function.
+ * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+ * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
+ * @module
+ */
+import { HashMD } from './_md.js';
+export declare class RIPEMD160 extends HashMD<RIPEMD160> {
+    private h0;
+    private h1;
+    private h2;
+    private h3;
+    private h4;
+    constructor();
+    protected get(): [number, number, number, number, number];
+    protected set(h0: number, h1: number, h2: number, h3: number, h4: number): void;
+    protected process(view: DataView, offset: number): void;
+    protected roundClean(): void;
+    destroy(): void;
+}

package/dist/noble/ripemd_160.js

@@ -0,0 +1,147 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var e_1, _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RIPEMD160 = void 0;
+/**
+ * RIPEMD-160 legacy hash function.
+ * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+ * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
+ * @module
+ */
+var _md_1 = require("./_md.js");
+var utils_1 = require("./utils.js");
+var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
+var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map(function (_, i) { return i; }));
+var Pi = /* @__PURE__ */ Id.map(function (i) { return (9 * i + 5) % 16; });
+var idxL = [Id];
+var idxR = [Pi];
+for (var i = 0; i < 4; i++)
+    try {
+        for (var _b = (e_1 = void 0, __values([idxL, idxR])), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var j = _c.value;
+            j.push(j[i].map(function (k) { return Rho[k]; }));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+var shifts = /* @__PURE__ */ [
+    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
+    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
+    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
+    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
+    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],
+].map(function (i) { return new Uint8Array(i); });
+var shiftsL = /* @__PURE__ */ idxL.map(function (idx, i) { return idx.map(function (j) { return shifts[i][j]; }); });
+var shiftsR = /* @__PURE__ */ idxR.map(function (idx, i) { return idx.map(function (j) { return shifts[i][j]; }); });
+var Kl = /* @__PURE__ */ new Uint32Array([
+    0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,
+]);
+var Kr = /* @__PURE__ */ new Uint32Array([
+    0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,
+]);
+// It's called f() in spec.
+function f(group, x, y, z) {
+    if (group === 0)
+        return x ^ y ^ z;
+    else if (group === 1)
+        return (x & y) | (~x & z);
+    else if (group === 2)
+        return (x | ~y) ^ z;
+    else if (group === 3)
+        return (x & z) | (y & ~z);
+    else
+        return x ^ (y | ~z);
+}
+// Temporary buffer, not used to store anything between runs
+var R_BUF = /* @__PURE__ */ new Uint32Array(16);
+var RIPEMD160 = /** @class */ (function (_super) {
+    __extends(RIPEMD160, _super);
+    function RIPEMD160() {
+        var _this = _super.call(this, 64, 20, 8, true) || this;
+        _this.h0 = 0x67452301 | 0;
+        _this.h1 = 0xefcdab89 | 0;
+        _this.h2 = 0x98badcfe | 0;
+        _this.h3 = 0x10325476 | 0;
+        _this.h4 = 0xc3d2e1f0 | 0;
+        return _this;
+    }
+    RIPEMD160.prototype.get = function () {
+        var _a = this, h0 = _a.h0, h1 = _a.h1, h2 = _a.h2, h3 = _a.h3, h4 = _a.h4;
+        return [h0, h1, h2, h3, h4];
+    };
+    RIPEMD160.prototype.set = function (h0, h1, h2, h3, h4) {
+        this.h0 = h0 | 0;
+        this.h1 = h1 | 0;
+        this.h2 = h2 | 0;
+        this.h3 = h3 | 0;
+        this.h4 = h4 | 0;
+    };
+    RIPEMD160.prototype.process = function (view, offset) {
+        for (var i = 0; i < 16; i++, offset += 4)
+            R_BUF[i] = view.getUint32(offset, true);
+        // prettier-ignore
+        var al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
+        // Instead of iterating 0 to 80, we split it into 5 groups
+        // And use the groups in constants, functions, etc. Much simpler
+        for (var group = 0; group < 5; group++) {
+            var rGroup = 4 - group;
+            var hbl = Kl[group], hbr = Kr[group]; // prettier-ignore
+            var rl = idxL[group], rr = idxR[group]; // prettier-ignore
+            var sl = shiftsL[group], sr = shiftsR[group]; // prettier-ignore
+            for (var i = 0; i < 16; i++) {
+                var tl = ((0, utils_1.rotl)(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el) | 0;
+                al = el, el = dl, dl = (0, utils_1.rotl)(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
+            }
+            // 2 loops are 10% faster
+            for (var i = 0; i < 16; i++) {
+                var tr = ((0, utils_1.rotl)(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er) | 0;
+                ar = er, er = dr, dr = (0, utils_1.rotl)(cr, 10) | 0, cr = br, br = tr; // prettier-ignore
+            }
+        }
+        // Add the compressed chunk to the current hash value
+        this.set((this.h1 + cl + dr) | 0, (this.h2 + dl + er) | 0, (this.h3 + el + ar) | 0, (this.h4 + al + br) | 0, (this.h0 + bl + cr) | 0);
+    };
+    RIPEMD160.prototype.roundClean = function () {
+        R_BUF.fill(0);
+    };
+    RIPEMD160.prototype.destroy = function () {
+        this.destroyed = true;
+        this.buffer.fill(0);
+        this.set(0, 0, 0, 0, 0);
+    };
+    return RIPEMD160;
+}(_md_1.HashMD));
+exports.RIPEMD160 = RIPEMD160;
+/** RIPEMD-160 - a legacy hash function from 1990s. */
+var _ripemd160 = /* @__PURE__ */ (0, utils_1.wrapConstructor)(function () { return new RIPEMD160(); });