wip:milestone 0 fixes

control-plane-ui/tests/integration/node_modules/@noble/hashes/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Paul Miller (https://paulmillr.com)
+
+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.

control-plane-ui/tests/integration/node_modules/@noble/hashes/README.md

@@ -0,0 +1,575 @@
+# noble-hashes
+
+Audited & minimal JS implementation of hash functions, MACs and KDFs.
+
+- 🔒 [**Audited**](#security) by an independent security firm
+- 🔻 Tree-shakeable: unused code is excluded from your builds
+- 🏎 Fast: hand-optimized for caveats of JS engines
+- 🔍 Reliable: chained / sliding window / DoS / ACVP tests and fuzzing
+- 🔁 No unrolled loops: makes it easier to verify and reduces source code size up to 5x
+- 🦘 Includes SHA, RIPEMD, BLAKE, HMAC, HKDF, PBKDF, Scrypt, Argon2
+- 🥈 Optional, friendly wrapper over native WebCrypto
+- 🪶 21KB (gzipped) for everything, 2.4KB for single-hash build
+
+Check out [Upgrading](#upgrading) for information about upgrading from previous versions.
+Take a glance at [GitHub Discussions](https://github.com/paulmillr/noble-hashes/discussions) for questions and support.
+The library's initial development was funded by [Ethereum Foundation](https://ethereum.org/).
+
+### This library belongs to _noble_ cryptography
+
+> **noble cryptography** — high-security, easily auditable set of contained cryptographic libraries and tools.
+
+- Zero or minimal dependencies
+- Highly readable TypeScript / JS code
+- PGP-signed releases and transparent NPM builds
+- All libraries:
+  [ciphers](https://github.com/paulmillr/noble-ciphers),
+  [curves](https://github.com/paulmillr/noble-curves),
+  [hashes](https://github.com/paulmillr/noble-hashes),
+  [post-quantum](https://github.com/paulmillr/noble-post-quantum),
+  5kb [secp256k1](https://github.com/paulmillr/noble-secp256k1) /
+  [ed25519](https://github.com/paulmillr/noble-ed25519)
+- [Check out homepage](https://paulmillr.com/noble/)
+  for reading resources, documentation and apps built with noble
+
+## Usage
+
+> `npm install @noble/hashes`
+
+> `deno add jsr:@noble/hashes`
+
+We support all major platforms and runtimes.
+For React Native, you may need a [polyfill for getRandomValues](https://github.com/LinusU/react-native-get-random-values).
+A standalone file [noble-hashes.js](https://github.com/paulmillr/noble-hashes/releases) is also available.
+
+```js
+// import * from '@noble/hashes'; // Error: use sub-imports, to ensure small app size
+import { sha256 } from '@noble/hashes/sha2.js';
+const hash = sha256(Uint8Array.from([0xca, 0xfe, 0x01, 0x23]));
+
+// Available modules
+import { sha256, sha384, sha512, sha224, sha512_224, sha512_256 } from '@noble/hashes/sha2.js';
+import {
+  sha3_256, sha3_512,
+  keccak_256, keccak_512,
+  shake128, shake256,
+} from '@noble/hashes/sha3.js';
+import {
+  cshake256, turboshake256, kmac256, tuplehash256,
+  kt128, kt256, keccakprg,
+} from '@noble/hashes/sha3-addons.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { blake2b, blake2s } from '@noble/hashes/blake2.js';
+import { blake256, blake512 } from '@noble/hashes/blake1.js';
+import { sha1, md5, ripemd160 } from '@noble/hashes/legacy.js';
+import { hmac } from '@noble/hashes/hmac.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2.js';
+import { scrypt, scryptAsync } from '@noble/hashes/scrypt.js';
+import { argon2d, argon2i, argon2id } from '@noble/hashes/argon2.js';
+import * as webcrypto from '@noble/hashes/webcrypto.js';
+// const { sha256, sha384, sha512, hmac, hkdf, pbkdf2 } = webcrypto;
+import * as utils from '@noble/hashes/utils.js';
+const { bytesToHex, concatBytes, equalBytes, hexToBytes } = utils;
+```
+
+- [sha2: sha256, sha384, sha512](#sha2-sha256-sha384-sha512-and-others)
+- [sha3: FIPS, SHAKE, Keccak](#sha3-fips-shake-keccak)
+- [sha3-addons: cSHAKE, KMAC, KT128, TurboSHAKE](#sha3-addons-cshake-kmac-kt128-turboshake)
+- [blake1, blake2, blake3](#blake1-blake2-blake3)
+- [legacy: sha1, md5, ripemd160](#legacy-sha1-md5-ripemd160)
+- MACs: [hmac](#hmac) | [kmac](#sha3-addons-cshake-kmac-kt128-turboshake) | [blake3 key mode](#blake1-blake2-blake3)
+- KDFs: [hkdf](#hkdf) | [pbkdf2](#pbkdf2) | [scrypt](#scrypt) | [argon2](#argon2)
+- [webcrypto: friendly wrapper](#webcrypto-friendly-wrapper)
+- [utils](#utils)
+- [Security](#security) | [Speed](#speed) | [Contributing & testing](#contributing--testing) | [License](#license)
+
+### Implementations
+
+Hash functions:
+
+- `sha256()`: receive & return `Uint8Array`
+- `sha256.create().update(a).update(b).digest()`: support partial updates
+- `blake3.create({ context: 'e', dkLen: 32 })`: can have options
+- support little-endian architecture; also experimentally big-endian
+- can hash up to 4GB per chunk, with any amount of chunks
+
+#### sha2: sha256, sha384, sha512 and others
+
+```typescript
+import { sha224, sha256, sha384, sha512, sha512_224, sha512_256 } from '@noble/hashes/sha2.js';
+const res = sha256(Uint8Array.from([0xbc])); // basic
+for (let hash of [sha256, sha384, sha512, sha224, sha512_224, sha512_256]) {
+  const arr = Uint8Array.from([0x10, 0x20, 0x30]);
+  const a = hash(arr);
+  const b = hash.create().update(arr).digest();
+}
+```
+
+Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+[the paper on truncated SHA512/256](https://eprint.iacr.org/2010/548.pdf).
+
+#### sha3: FIPS, SHAKE, Keccak
+
+```typescript
+import {
+  sha3_224, sha3_256, sha3_384, sha3_512,
+  keccak_224, keccak_256, keccak_384, keccak_512,
+  shake128, shake256,
+} from '@noble/hashes/sha3.js';
+for (let hash of [
+  sha3_224, sha3_256, sha3_384, sha3_512,
+  keccak_224, keccak_256, keccak_384, keccak_512,
+]) {
+  const arr = Uint8Array.from([0x10, 0x20, 0x30]);
+  const a = hash(arr);
+  const b = hash.create().update(arr).digest();
+}
+const shka = shake128(Uint8Array.from([0x10]), { dkLen: 512 });
+const shkb = shake256(Uint8Array.from([0x30]), { dkLen: 512 });
+```
+
+Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+[Website](https://keccak.team/keccak.html).
+
+Check out [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub)
+
+#### sha3-addons: cSHAKE, KMAC, K12, TurboSHAKE
+
+```typescript
+import {
+  cshake128, cshake256, kt128, kt256,
+  keccakprg, kmac128, kmac256,
+  parallelhash256, tuplehash256,
+  turboshake128, turboshake256,
+} from '@noble/hashes/sha3-addons.js';
+const data = Uint8Array.from([0x10, 0x20, 0x30]);
+const ec1 = cshake128(data, { personalization: 'def' });
+const ec2 = cshake256(data, { personalization: 'def' });
+const et1 = turboshake128(data);
+const et2 = turboshake256(data, { D: 0x05 });
+// tuplehash(['ab', 'c']) !== tuplehash(['a', 'bc']) !== tuplehash([data])
+const et3 = tuplehash256([new TextEncoder().encode('ab'), new TextEncoder().encode('c')]);
+// Not parallel in JS (similar to blake3 / kt128), added for compat
+const ep1 = parallelhash256(data, { blockLen: 8 });
+const kk = Uint8Array.from([0xca]);
+const ek10 = kmac128(kk, data);
+const ek11 = kmac256(kk, data);
+const ek12 = kt128(data); // kangarootwelve 128-bit
+const ek13 = kt256(data); // kangarootwelve 256-bit
+// pseudo-random generator, first argument is capacity. XKCP recommends 254 bits capacity for 128-bit security strength.
+// * with a capacity of 254 bits.
+const p = keccakprg(254);
+p.feed('test');
+const rand1b = p.fetch(1);
+```
+
+- cSHAKE, KMAC, TupleHash, ParallelHash + XOF are available, matching
+  [NIST SP 800-185](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-185.pdf)
+- Reduced-round Keccak KT128 (KangarooTwelve 🦘, K12) and TurboSHAKE are available, matching
+  [kangaroo-draft-17](https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/).
+- [KeccakPRG](https://keccak.team/files/CSF-0.1.pdf): pseudo-random generator based on Keccak
+
+#### blake1, blake2, blake3
+
+```typescript
+import { blake224, blake256, blake384, blake512 } from '@noble/hashes/blake1.js';
+import { blake2b, blake2s } from '@noble/hashes/blake2.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+
+for (let hash of [blake224, blake256, blake384, blake512, blake2b, blake2s, blake3]) {
+  const arr = Uint8Array.from([0x10, 0x20, 0x30]);
+  const a = hash(arr);
+  const b = hash.create().update(arr).digest();
+}
+
+// blake2 advanced usage
+const ab = Uint8Array.from([0x01]);
+blake2s(ab);
+blake2s(ab, { key: new Uint8Array(32) });
+blake2s(ab, { personalization: 'pers1234' });
+blake2s(ab, { salt: 'salt1234' });
+blake2b(ab);
+blake2b(ab, { key: new Uint8Array(64) });
+blake2b(ab, { personalization: 'pers1234pers1234' });
+blake2b(ab, { salt: 'salt1234salt1234' });
+
+// blake3 advanced usage
+blake3(ab);
+blake3(ab, { dkLen: 256 });
+blake3(ab, { key: new Uint8Array(32) });
+blake3(ab, { context: 'application-name' });
+```
+
+- Blake1 is legacy hash, one of SHA3 proposals. It is rarely used anywhere. See [pdf](https://www.aumasson.jp/blake/blake.pdf).
+- Blake2 is popular fast hash. blake2b focuses on 64-bit platforms while blake2s is for 8-bit to 32-bit ones. See [RFC 7693](https://datatracker.ietf.org/doc/html/rfc7693), [Website](https://www.blake2.net)
+- Blake3 is faster, reduced-round blake2. See [Website & specs](https://blake3.io)
+
+#### legacy: sha1, md5, ripemd160
+
+SHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.
+Don't use them in a new protocol. What "weak" means:
+
+- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
+- No practical pre-image attacks (only theoretical, 2^123.4)
+- HMAC seems kinda ok: https://datatracker.ietf.org/doc/html/rfc6151
+
+```typescript
+import { md5, ripemd160, sha1 } from '@noble/hashes/legacy.js';
+for (let hash of [md5, ripemd160, sha1]) {
+  const arr = Uint8Array.from([0x10, 0x20, 0x30]);
+  const a = hash(arr);
+  const b = hash.create().update(arr).digest();
+}
+```
+
+#### hmac
+
+```typescript
+import { hmac } from '@noble/hashes/hmac.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+const key = new Uint8Array(32).fill(1);
+const msg = new Uint8Array(32).fill(2);
+const mac1 = hmac(sha256, key, msg);
+const mac2 = hmac.create(sha256, key).update(msg).digest();
+```
+
+Conforms to [RFC 2104](https://datatracker.ietf.org/doc/html/rfc2104).
+
+#### hkdf
+
+```typescript
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { randomBytes } from '@noble/hashes/utils.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+const inputKey = randomBytes(32);
+const salt = randomBytes(32);
+const info = 'application-key';
+const hk1 = hkdf(sha256, inputKey, salt, info, 32);
+
+// == same as
+import { extract, expand } from '@noble/hashes/hkdf.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+const prk = extract(sha256, inputKey, salt);
+const hk2 = expand(sha256, prk, info, 32);
+```
+
+Conforms to [RFC 5869](https://datatracker.ietf.org/doc/html/rfc5869).
+
+#### pbkdf2
+
+```typescript
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+const pbkey1 = pbkdf2(sha256, 'password', 'salt', { c: 524288, dkLen: 32 });
+const pbkey2 = await pbkdf2Async(sha256, 'password', 'salt', { c: 524288, dkLen: 32 });
+const pbkey3 = await pbkdf2Async(sha256, Uint8Array.from([1, 2, 3]), Uint8Array.from([4, 5, 6]), {
+  c: 524288,
+  dkLen: 32,
+});
+```
+
+Conforms to [RFC 2898](https://datatracker.ietf.org/doc/html/rfc2898).
+
+#### scrypt
+
+```typescript
+import { scrypt, scryptAsync } from '@noble/hashes/scrypt.js';
+const scr1 = scrypt('password', 'salt', { N: 2 ** 16, r: 8, p: 1, dkLen: 32 });
+const scr2 = await scryptAsync('password', 'salt', { N: 2 ** 16, r: 8, p: 1, dkLen: 32 });
+const scr3 = await scryptAsync(Uint8Array.from([1, 2, 3]), Uint8Array.from([4, 5, 6]), {
+  N: 2 ** 17,
+  r: 8,
+  p: 1,
+  dkLen: 32,
+  onProgress(percentage) {
+    console.log('progress', percentage);
+  },
+  maxmem: 2 ** 32 + 128 * 8 * 1, // N * r * p * 128 + (128*r*p)
+});
+```
+
+Conforms to [RFC 7914](https://datatracker.ietf.org/doc/html/rfc7914),
+[Website](https://www.tarsnap.com/scrypt.html)
+
+- `N, r, p` are work factors. It is common to only adjust N, while keeping `r: 8, p: 1`.
+  See [the blog post](https://blog.filippo.io/the-scrypt-parameters/).
+  JS doesn't support parallelization, making increasing `p` meaningless.
+- `dkLen` is the length of output bytes e.g. `32` or `64`
+- `onProgress` can be used with async version of the function to report progress to a user.
+- `maxmem` prevents DoS and is limited to `1GB + 1KB` (`2**30 + 2**10`), but can be adjusted using formula: `N * r * p * 128 + (128 * r * p)`
+
+Time it takes to derive Scrypt key under different values of N (2\*\*N) on Apple M4 (mobile phones can be 1x-4x slower):
+
+| N pow | Time | RAM   |
+| ----- | ---- | ----- |
+| 16    | 0.1s | 64MB  |
+| 17    | 0.2s | 128MB |
+| 18    | 0.4s | 256MB |
+| 19    | 0.8s | 512MB |
+| 20    | 1.5s | 1GB   |
+| 21    | 3.1s | 2GB   |
+| 22    | 6.2s | 4GB   |
+| 23    | 13s  | 8GB   |
+| 24    | 27s  | 16GB  |
+
+> [!NOTE]
+> We support N larger than `2**20` where available, however,
+> not all JS engines support >= 2GB ArrayBuffer-s.
+> When using such N, you'll need to manually adjust `maxmem`, using formula above.
+> Other JS implementations don't support large N-s.
+
+#### argon2
+
+```ts
+import { argon2d, argon2i, argon2id } from '@noble/hashes/argon2.js';
+const arg1 = argon2id('password', 'saltsalt', { t: 2, m: 65536, p: 1, maxmem: 2 ** 32 - 1 });
+```
+
+Argon2 [RFC 9106](https://datatracker.ietf.org/doc/html/rfc9106) implementation.
+
+> [!WARNING]
+> Argon2 can't be fast in JS, because there is no fast Uint64Array.
+> It is suggested to use [Scrypt](#scrypt) instead.
+> Being 5x slower than native code means brute-forcing attackers have bigger advantage.
+
+#### webcrypto: friendly wrapper
+
+```js
+import { sha256, sha384, sha512, hmac, hkdf, pbkdf2 } from '@noble/hashes/webcrypto.js';
+const whash = await sha256(Uint8Array.from([0xca, 0xfe, 0x01, 0x23]));
+
+const key = new Uint8Array(32).fill(1);
+const msg = new Uint8Array(32).fill(2);
+const wmac = await hmac(sha256, key, msg);
+
+const inputKey = randomBytes(32);
+const salt = randomBytes(32);
+const info = 'application-key';
+const hk1 = await hkdf(sha256, inputKey, salt, info, 32);
+
+const pbkey1 = await pbkdf2(sha256, 'password', 'salt', { c: 524288, dkLen: 32 });
+```
+
+Sometimes people want to use built-in `crypto.subtle` instead of pure JS implementation.
+However, it has terrible API.
+
+We simplify access to built-ins with API which mirrors noble-hashes.
+The overhead is minimal - just 30+ lines of code, which verify input correctness.
+
+> [!NOTE]
+> Webcrypto methods are always async.
+
+#### utils
+
+```typescript
+import { bytesToHex as toHex, randomBytes } from '@noble/hashes/utils.js';
+console.log(toHex(randomBytes(32)));
+```
+
+- `bytesToHex` will convert `Uint8Array` to a hex string
+- `randomBytes(bytes)` will produce cryptographically secure random `Uint8Array` of length `bytes`
+
+## Security
+
+The library has been independently audited:
+
+- at version 1.0.0, in Jan 2022, by [Cure53](https://cure53.de)
+  - PDFs: [website](https://cure53.de/pentest-report_hashing-libs.pdf), [in-repo](./audit/2022-01-05-cure53-audit-nbl2.pdf)
+  - [Changes since audit](https://github.com/paulmillr/noble-hashes/compare/1.0.0..main).
+  - Scope: everything, besides `blake3`, `sha3-addons`, `sha1` and `argon2`, which have not been audited
+  - The audit has been funded by [Ethereum Foundation](https://ethereum.org/en/) with help of [Nomic Labs](https://nomiclabs.io)
+
+It is tested against property-based, cross-library and Wycheproof vectors,
+and is being fuzzed in [the separate repo](https://github.com/paulmillr/fuzzing).
+
+If you see anything unusual: investigate and report.
+
+### Constant-timeness
+
+We're targetting algorithmic constant time. _JIT-compiler_ and _Garbage Collector_ make "constant time"
+extremely hard to achieve [timing attack](https://en.wikipedia.org/wiki/Timing_attack) resistance
+in a scripting language. Which means _any other JS library can't have
+constant-timeness_. Even statically typed Rust, a language without GC,
+[makes it harder to achieve constant-time](https://www.chosenplaintext.ca/open-source/rust-timing-shield/security)
+for some cases. If your goal is absolute security, don't use any JS lib — including bindings to native ones.
+Use low-level libraries & languages.
+
+### Memory dumping
+
+The library shares state buffers between hash
+function calls. The buffers are zeroed-out after each call. However, if an attacker
+can read application memory, you are doomed in any case:
+
+- At some point, input will be a string and strings are immutable in JS:
+  there is no way to overwrite them with zeros. For example: deriving
+  key from `scrypt(password, salt)` where password and salt are strings
+- Input from a file will stay in file buffers
+- Input / output will be re-used multiple times in application which means it could stay in memory
+- `await anything()` will always write all internal variables (including numbers)
+  to memory. With async functions / Promises there are no guarantees when the code
+  chunk would be executed. Which means attacker can have plenty of time to read data from memory
+- There is no way to guarantee anything about zeroing sensitive data without
+  complex tests-suite which will dump process memory and verify that there is
+  no sensitive data left. For JS it means testing all browsers (incl. mobile),
+  which is complex. And of course it will be useless without using the same
+  test-suite in the actual application that consumes the library
+
+### Supply chain security
+
+- **Commits** are signed with PGP keys, to prevent forgery. Make sure to verify commit signatures
+- **Releases** are transparent and built on GitHub CI.
+  Check out [attested checksums of single-file builds](https://github.com/paulmillr/noble-hashes/attestations)
+  and [provenance logs](https://github.com/paulmillr/noble-hashes/actions/workflows/release.yml)
+- **Rare releasing** is followed to ensure less re-audit need for end-users
+- **Dependencies** are minimized and locked-down: any dependency could get hacked and users will be downloading malware with every install.
+  - We make sure to use as few dependencies as possible
+  - Automatic dep updates are prevented by locking-down version ranges; diffs are checked with `npm-diff`
+- **Dev Dependencies** are disabled for end-users; they are only used to develop / build the source code
+
+For this package, there are 0 dependencies; and a few dev dependencies:
+
+- jsbt contains helpers for building, benchmarking & testing secure JS apps. It is developed by the same author
+- prettier, fast-check and typescript are used for code quality / test generation / ts compilation. It's hard to audit their source code thoroughly and fully because of their size
+
+### Randomness
+
+We're deferring to built-in
+[crypto.getRandomValues](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues)
+which is considered cryptographically secure (CSPRNG).
+
+In the past, browsers had bugs that made it weak: it may happen again.
+Implementing a userspace CSPRNG to get resilient to the weakness
+is even worse: there is no reliable userspace source of quality entropy.
+
+### Quantum computers
+
+Cryptographically relevant quantum computer, if built, will allow to
+utilize Grover's algorithm to break hashes in 2^n/2 operations, instead of 2^n.
+
+This means SHA256 should be replaced with SHA512, SHA3-256 with SHA3-512, SHAKE128 with SHAKE256 etc.
+
+Australian ASD prohibits SHA256 and similar hashes [after 2030](https://www.cyber.gov.au/resources-business-and-government/essential-cyber-security/ism/cyber-security-guidelines/guidelines-cryptography).
+
+## Speed
+
+```sh
+npm run bench
+```
+
+Benchmarks measured on Apple M4.
+
+```
+# 32B
+sha256 x 2,016,129 ops/sec @ 496ns/op
+sha512 x 740,740 ops/sec @ 1μs/op
+sha3_256 x 287,686 ops/sec @ 3μs/op
+sha3_512 x 288,267 ops/sec @ 3μs/op
+k12 x 476,190 ops/sec @ 2μs/op
+blake2b x 464,252 ops/sec @ 2μs/op
+blake2s x 766,871 ops/sec @ 1μs/op
+blake3 x 879,507 ops/sec @ 1μs/op
+
+# 1MB
+sha256 x 331 ops/sec @ 3ms/op
+sha512 x 129 ops/sec @ 7ms/op
+sha3_256 x 38 ops/sec @ 25ms/op
+sha3_512 x 20 ops/sec @ 47ms/op
+k12 x 88 ops/sec @ 11ms/op
+blake2b x 69 ops/sec @ 14ms/op
+blake2s x 57 ops/sec @ 17ms/op
+blake3 x 72 ops/sec @ 13ms/op
+
+# MAC
+hmac(sha256) x 599,880 ops/sec @ 1μs/op
+hmac(sha512) x 197,122 ops/sec @ 5μs/op
+kmac256 x 87,981 ops/sec @ 11μs/op
+blake3(key) x 796,812 ops/sec @ 1μs/op
+
+# KDF
+hkdf(sha256) x 259,942 ops/sec @ 3μs/op
+blake3(context) x 424,808 ops/sec @ 2μs/op
+pbkdf2(sha256, c: 2 ** 18) x 5 ops/sec @ 197ms/op
+pbkdf2(sha512, c: 2 ** 18) x 1 ops/sec @ 630ms/op
+scrypt(n: 2 ** 18, r: 8, p: 1) x 2 ops/sec @ 400ms/op
+argon2id(t: 1, m: 256MB) 2881ms
+```
+
+Compare to native node.js implementation that uses C bindings instead of pure-js code:
+
+```
+# native (node) 32B
+sha256 x 2,267,573 ops/sec
+sha512 x 983,284 ops/sec
+sha3_256 x 1,522,070 ops/sec
+blake2b x 1,512,859 ops/sec
+blake2s x 1,821,493 ops/sec
+hmac(sha256) x 1,085,776 ops/sec
+hkdf(sha256) x 312,109 ops/sec
+# native (node) KDF
+pbkdf2(sha256, c: 2 ** 18) x 5 ops/sec @ 197ms/op
+pbkdf2(sha512, c: 2 ** 18) x 1 ops/sec @ 630ms/op
+scrypt(n: 2 ** 18, r: 8, p: 1) x 2 ops/sec @ 378ms/op
+```
+
+It is possible to [make this library 3x+ faster](./test/benchmark/README.md) by
+_doing code generation of full loop unrolls_. We've decided against it. Reasons:
+
+- current perf is good enough, even compared to other libraries - SHA256 only takes 500 nanoseconds
+- the library must be auditable, with minimum amount of code, and zero dependencies
+- most method invocations with the lib are going to be something like hashing 32b to 64kb of data
+- hashing big inputs is 10x faster with low-level languages, which means you should probably pick 'em instead
+
+## Upgrading
+
+Supported node.js versions:
+
+- v2: v20.19+ (ESM-only)
+- v1: v14.21+ (ESM & CJS)
+
+v2.0 changelog:
+
+- The package is now ESM-only. ESM can finally be loaded from common.js on node v20.19+
+- `.js` extension must be used for all modules
+    - Old: `@noble/hashes/sha3`
+    - New: `@noble/hashes/sha3.js`
+    - This simplifies working in browsers natively without transpilers
+- Only allow Uint8Array as hash inputs, prohibit `string`
+    - Strict validation checks improve security
+    - To replicate previous behavior, use `utils.utf8ToBytes`
+- Rename / remove some modules for consistency. Previously, sha384 resided in sha512, which was weird
+    - `sha256`, `sha512` => `sha2.js` (consistent with `sha3.js`)
+    - `blake2b`, `blake2s` => `blake2.js` (consistent with `blake3.js`, `blake1.js`)
+    - `ripemd160`, `sha1`, `md5` => `legacy.js` (all low-security hashes are there)
+    - `_assert` => `utils.js`
+    - `crypto` internal module got removed: use built-in WebCrypto instead
+- Improve typescript types & option autocomplete
+- Bump compilation target from es2020 to es2022
+
+## Contributing & testing
+
+`test/misc` directory contains implementations of loop unrolling and md5.
+
+- `npm install && npm run build && npm test` will build the code and run tests.
+- `npm run lint` / `npm run format` will run linter / fix linter issues.
+- `npm run bench` will run benchmarks
+- `npm run build:release` will build single file
+- There is **additional** 20-min DoS test `npm run test:dos` and 2-hour "big" multicore test `npm run test:big`.
+  See [our approach to testing](./test/README.md)
+
+Additional resources:
+
+- NTT hashes are outside of scope of the library. They depend on some math which is not available in noble-hashes, it doesn't make sense to add it here. You can view some of them in different repos:
+    - [Pedersen in micro-zk-proofs](https://github.com/paulmillr/micro-zk-proofs/blob/1ed5ce1253583b2e540eef7f3477fb52bf5344ff/src/pedersen.ts)
+    - [Poseidon in noble-curves](https://github.com/paulmillr/noble-curves/blob/3d124dd3ecec8b6634cc0b2ba1c183aded5304f9/src/abstract/poseidon.ts)
+- Polynomial MACs are also outside of scope of the library. They are rarely used outside of encryption. Check out [Poly1305 & GHash in noble-ciphers](https://github.com/paulmillr/noble-ciphers).
+- See [paulmillr.com/noble](https://paulmillr.com/noble/) for useful resources, articles, documentation and demos
+  related to the library.
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Paul Miller [(https://paulmillr.com)](https://paulmillr.com)
+
+See LICENSE file.

control-plane-ui/tests/integration/node_modules/@noble/hashes/_blake.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Internal blake variable.
+ * For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
+ */
+export declare const BSIGMA: Uint8Array;
+export type Num4 = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+export declare function G1s(a: number, b: number, c: number, d: number, x: number): Num4;
+export declare function G2s(a: number, b: number, c: number, d: number, x: number): Num4;
+//# sourceMappingURL=_blake.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/_blake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_blake.d.ts","sourceRoot":"","sources":["src/_blake.ts"],"names":[],"mappings":"AAMA;;;GAGG;AAEH,eAAO,MAAM,MAAM,EAAE,UAkBnB,CAAC;AAGH,MAAM,MAAM,IAAI,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;CAAE,CAAC;AAGnE,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAM/E;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAM/E"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/_blake.js

@@ -0,0 +1,45 @@
+/**
+ * Internal helpers for blake hash.
+ * @module
+ */
+import { rotr } from "./utils.js";
+/**
+ * Internal blake variable.
+ * For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
+ */
+// prettier-ignore
+export const BSIGMA = /* @__PURE__ */ Uint8Array.from([
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    // Blake1, unused in others
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+]);
+// Mixing function G splitted in two halfs
+export function G1s(a, b, c, d, x) {
+    a = (a + b + x) | 0;
+    d = rotr(d ^ a, 16);
+    c = (c + d) | 0;
+    b = rotr(b ^ c, 12);
+    return { a, b, c, d };
+}
+export function G2s(a, b, c, d, x) {
+    a = (a + b + x) | 0;
+    d = rotr(d ^ a, 8);
+    c = (c + d) | 0;
+    b = rotr(b ^ c, 7);
+    return { a, b, c, d };
+}
+//# sourceMappingURL=_blake.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/_blake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_blake.js","sourceRoot":"","sources":["src/_blake.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC;;;GAGG;AACH,kBAAkB;AAClB,MAAM,CAAC,MAAM,MAAM,GAAe,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC;IAChE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;IACpD,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACpD,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACpD,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;IACpD,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;IACpD,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;IACpD,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;IACpD,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;IACpD,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;IACpD,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;IACpD,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;IACpD,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACpD,2BAA2B;IAC3B,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACpD,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;IACpD,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;IACpD,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;CACrD,CAAC,CAAC;AAKH,0CAA0C;AAC1C,MAAM,UAAU,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;IACvE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;IACpB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS;IACvE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACnB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACnB,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACxB,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/_md.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Internal Merkle-Damgard hash utils.
+ * @module
+ */
+import { type Hash } from './utils.ts';
+/** Choice: a ? b : c */
+export declare function Chi(a: number, b: number, c: number): number;
+/** Majority function, true if any two inputs is true. */
+export declare function Maj(a: number, b: number, c: number): number;
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+export declare abstract class HashMD<T extends HashMD<T>> implements Hash<T> {
+    protected abstract process(buf: DataView, offset: number): void;
+    protected abstract get(): number[];
+    protected abstract set(...args: number[]): void;
+    abstract destroy(): void;
+    protected abstract roundClean(): void;
+    readonly blockLen: number;
+    readonly outputLen: number;
+    readonly padOffset: number;
+    readonly isLE: boolean;
+    protected buffer: Uint8Array;
+    protected view: DataView;
+    protected finished: boolean;
+    protected length: number;
+    protected pos: number;
+    protected destroyed: boolean;
+    constructor(blockLen: number, outputLen: number, padOffset: number, isLE: boolean);
+    update(data: Uint8Array): this;
+    digestInto(out: Uint8Array): void;
+    digest(): Uint8Array;
+    _cloneInto(to?: T): T;
+    clone(): T;
+}
+/**
+ * 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. Bits 0..32 of frac part of sqrt of primes 2..19 */
+export declare const SHA256_IV: Uint32Array;
+/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */
+export declare const SHA224_IV: Uint32Array;
+/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */
+export declare const SHA384_IV: Uint32Array;
+/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
+export declare const SHA512_IV: Uint32Array;
+//# sourceMappingURL=_md.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/_md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_md.d.ts","sourceRoot":"","sources":["src/_md.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAA+C,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAEpF,wBAAwB;AACxB,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,yDAAyD;AACzD,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;GAGG;AACH,8BAAsB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,CAAC,CAAE,YAAW,IAAI,CAAC,CAAC,CAAC;IAClE,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAC/D,SAAS,CAAC,QAAQ,CAAC,GAAG,IAAI,MAAM,EAAE;IAClC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI;IAC/C,QAAQ,CAAC,OAAO,IAAI,IAAI;IACxB,SAAS,CAAC,QAAQ,CAAC,UAAU,IAAI,IAAI;IAErC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAGvB,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC;IAC7B,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC;IACzB,SAAS,CAAC,QAAQ,UAAS;IAC3B,SAAS,CAAC,MAAM,SAAK;IACrB,SAAS,CAAC,GAAG,SAAK;IAClB,SAAS,CAAC,SAAS,UAAS;gBAEhB,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;IAQjF,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAyB9B,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IAkCjC,MAAM,IAAI,UAAU;IAOpB,UAAU,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC;IAWrB,KAAK,IAAI,CAAC;CAGX;AAED;;;GAGG;AAEH,4EAA4E;AAC5E,eAAO,MAAM,SAAS,EAAE,WAEtB,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,SAAS,EAAE,WAEtB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,SAAS,EAAE,WAGtB,CAAC;AAEH,4EAA4E;AAC5E,eAAO,MAAM,SAAS,EAAE,WAGtB,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/_md.js

@@ -0,0 +1,147 @@
+/**
+ * Internal Merkle-Damgard hash utils.
+ * @module
+ */
+import { abytes, aexists, aoutput, clean, createView } from "./utils.js";
+/** Choice: a ? b : c */
+export function Chi(a, b, c) {
+    return (a & b) ^ (~a & c);
+}
+/** Majority function, true if any two inputs is true. */
+export 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.
+ */
+export class HashMD {
+    blockLen;
+    outputLen;
+    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);
+    }
+    update(data) {
+        aexists(this);
+        abytes(data);
+        const { view, buffer, blockLen } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                const dataView = createView(data);
+                for (; blockLen <= len - pos; pos += blockLen)
+                    this.process(dataView, pos);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            pos += take;
+            if (this.pos === blockLen) {
+                this.process(view, 0);
+                this.pos = 0;
+            }
+        }
+        this.length += data.length;
+        this.roundClean();
+        return this;
+    }
+    digestInto(out) {
+        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;
+        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;
+        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+        // So we just write lowest 64 bits of that value.
+        view.setBigUint64(blockLen - 8, BigInt(this.length * 8), 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');
+        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);
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        to ||= new this.constructor();
+        to.set(...this.get());
+        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.destroyed = destroyed;
+        to.finished = finished;
+        to.length = length;
+        to.pos = pos;
+        if (length % blockLen)
+            to.buffer.set(buffer);
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+/**
+ * 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. Bits 0..32 of frac part of sqrt of primes 2..19 */
+export const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */
+export const SHA224_IV = /* @__PURE__ */ Uint32Array.from([
+    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
+]);
+/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */
+export 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. Bits 0..64 of frac part of sqrt of primes 2..19 */
+export const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
+    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
+]);
+//# sourceMappingURL=_md.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/_u64.d.ts

@@ -0,0 +1,55 @@
+declare function fromBig(n: bigint, le?: boolean): {
+    h: number;
+    l: number;
+};
+declare function split(lst: bigint[], le?: boolean): Uint32Array[];
+declare const toBig: (h: number, l: number) => bigint;
+declare const shrSH: (h: number, _l: number, s: number) => number;
+declare const shrSL: (h: number, l: number, s: number) => number;
+declare const rotrSH: (h: number, l: number, s: number) => number;
+declare const rotrSL: (h: number, l: number, s: number) => number;
+declare const rotrBH: (h: number, l: number, s: number) => number;
+declare const rotrBL: (h: number, l: number, s: number) => number;
+declare const rotr32H: (_h: number, l: number) => number;
+declare const rotr32L: (h: number, _l: number) => number;
+declare const rotlSH: (h: number, l: number, s: number) => number;
+declare const rotlSL: (h: number, l: number, s: number) => number;
+declare const rotlBH: (h: number, l: number, s: number) => number;
+declare const rotlBL: (h: number, l: number, s: number) => number;
+declare function add(Ah: number, Al: number, Bh: number, Bl: number): {
+    h: number;
+    l: number;
+};
+declare const add3L: (Al: number, Bl: number, Cl: number) => number;
+declare const add3H: (low: number, Ah: number, Bh: number, Ch: number) => number;
+declare const add4L: (Al: number, Bl: number, Cl: number, Dl: number) => number;
+declare const add4H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number) => number;
+declare const add5L: (Al: number, Bl: number, Cl: number, Dl: number, El: number) => number;
+declare const add5H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number) => number;
+export { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };
+declare const u64: {
+    fromBig: typeof fromBig;
+    split: typeof split;
+    toBig: (h: number, l: number) => bigint;
+    shrSH: (h: number, _l: number, s: number) => number;
+    shrSL: (h: number, l: number, s: number) => number;
+    rotrSH: (h: number, l: number, s: number) => number;
+    rotrSL: (h: number, l: number, s: number) => number;
+    rotrBH: (h: number, l: number, s: number) => number;
+    rotrBL: (h: number, l: number, s: number) => number;
+    rotr32H: (_h: number, l: number) => number;
+    rotr32L: (h: number, _l: number) => number;
+    rotlSH: (h: number, l: number, s: number) => number;
+    rotlSL: (h: number, l: number, s: number) => number;
+    rotlBH: (h: number, l: number, s: number) => number;
+    rotlBL: (h: number, l: number, s: number) => number;
+    add: typeof add;
+    add3L: (Al: number, Bl: number, Cl: number) => number;
+    add3H: (low: number, Ah: number, Bh: number, Ch: number) => number;
+    add4L: (Al: number, Bl: number, Cl: number, Dl: number) => number;
+    add4H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number) => number;
+    add5H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number) => number;
+    add5L: (Al: number, Bl: number, Cl: number, Dl: number, El: number) => number;
+};
+export default u64;
+//# sourceMappingURL=_u64.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/_u64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_u64.d.ts","sourceRoot":"","sources":["src/_u64.ts"],"names":[],"mappings":"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AAK,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,GAAG,CAAC;IAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;CAOrpC,CAAC;AACF,eAAe,GAAG,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/_u64.js

@@ -0,0 +1,67 @@
+/**
+ * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+ * @todo re-check https://issues.chromium.org/issues/42212588
+ * @module
+ */
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+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 };
+}
+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++) {
+        const { h, l } = fromBig(lst[i], le);
+        [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+}
+const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
+// for Shift in [0, 32)
+const shrSH = (h, _l, s) => h >>> s;
+const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+// Right rotate for Shift in [1, 32)
+const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+// Right rotate for shift===32 (just swaps l&h)
+const rotr32H = (_h, l) => l;
+const rotr32L = (h, _l) => h;
+// Left rotate for Shift in [1, 32)
+const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+// JS uses 32-bit signed integers for bitwise operations which means we cannot
+// simple take carry out of low bit sum by shift, we need to use division.
+function add(Ah, Al, Bh, Bl) {
+    const l = (Al >>> 0) + (Bl >>> 0);
+    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+}
+// Addition with more than 2 elements
+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;
+// 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 };
+// prettier-ignore
+const u64 = {
+    fromBig, split, toBig,
+    shrSH, shrSL,
+    rotrSH, rotrSL, rotrBH, rotrBL,
+    rotr32H, rotr32L,
+    rotlSH, rotlSL, rotlBH, rotlBL,
+    add, add3L, add3H, add4L, add4H, add5H, add5L,
+};
+export default u64;
+//# sourceMappingURL=_u64.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/argon2.d.ts

@@ -0,0 +1,32 @@
+import { type KDFInput } from './utils.ts';
+/**
+ * Argon2 options.
+ * * t: time cost, m: mem cost in kb, p: parallelization.
+ * * key: optional key. personalization: arbitrary extra data.
+ * * dkLen: desired number of output bytes.
+ */
+export type ArgonOpts = {
+    t: number;
+    m: number;
+    p: number;
+    version?: number;
+    key?: KDFInput;
+    personalization?: KDFInput;
+    dkLen?: number;
+    asyncTick?: number;
+    maxmem?: number;
+    onProgress?: (progress: number) => void;
+};
+/** argon2d GPU-resistant version. */
+export declare const argon2d: (password: KDFInput, salt: KDFInput, opts: ArgonOpts) => Uint8Array;
+/** argon2i side-channel-resistant version. */
+export declare const argon2i: (password: KDFInput, salt: KDFInput, opts: ArgonOpts) => Uint8Array;
+/** argon2id, combining i+d, the most popular version from RFC 9106 */
+export declare const argon2id: (password: KDFInput, salt: KDFInput, opts: ArgonOpts) => Uint8Array;
+/** argon2d async GPU-resistant version. */
+export declare const argon2dAsync: (password: KDFInput, salt: KDFInput, opts: ArgonOpts) => Promise<Uint8Array>;
+/** argon2i async side-channel-resistant version. */
+export declare const argon2iAsync: (password: KDFInput, salt: KDFInput, opts: ArgonOpts) => Promise<Uint8Array>;
+/** argon2id async, combining i+d, the most popular version from RFC 9106 */
+export declare const argon2idAsync: (password: KDFInput, salt: KDFInput, opts: ArgonOpts) => Promise<Uint8Array>;
+//# sourceMappingURL=argon2.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/argon2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argon2.d.ts","sourceRoot":"","sources":["src/argon2.ts"],"names":[],"mappings":"AAYA,OAAO,EAAsD,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAkK/F;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,eAAe,CAAC,EAAE,QAAQ,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC,CAAC;AAmNF,qCAAqC;AACrC,eAAO,MAAM,OAAO,GAAI,UAAU,QAAQ,EAAE,MAAM,QAAQ,EAAE,MAAM,SAAS,KAAG,UACnC,CAAC;AAC5C,8CAA8C;AAC9C,eAAO,MAAM,OAAO,GAAI,UAAU,QAAQ,EAAE,MAAM,QAAQ,EAAE,MAAM,SAAS,KAAG,UACpC,CAAC;AAC3C,sEAAsE;AACtE,eAAO,MAAM,QAAQ,GAAI,UAAU,QAAQ,EAAE,MAAM,QAAQ,EAAE,MAAM,SAAS,KAAG,UACpC,CAAC;AAiE5C,2CAA2C;AAC3C,eAAO,MAAM,YAAY,GACvB,UAAU,QAAQ,EAClB,MAAM,QAAQ,EACd,MAAM,SAAS,KACd,OAAO,CAAC,UAAU,CAAmD,CAAC;AACzE,oDAAoD;AACpD,eAAO,MAAM,YAAY,GACvB,UAAU,QAAQ,EAClB,MAAM,QAAQ,EACd,MAAM,SAAS,KACd,OAAO,CAAC,UAAU,CAAkD,CAAC;AACxE,4EAA4E;AAC5E,eAAO,MAAM,aAAa,GACxB,UAAU,QAAQ,EAClB,MAAM,QAAQ,EACd,MAAM,SAAS,KACd,OAAO,CAAC,UAAU,CAAmD,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/argon2.js

@@ -0,0 +1,391 @@
+/**
+ * Argon2 KDF from RFC 9106. Can be used to create a key from password and salt.
+ * We suggest to use Scrypt. JS Argon is 2-10x slower than native code because of 64-bitness:
+ * * argon uses uint64, but JS doesn't have fast uint64array
+ * * uint64 multiplication is 1/3 of time
+ * * `P` function would be very nice with u64, because most of value will be in registers,
+ *   hovewer with u32 it will require 32 registers, which is too much.
+ * * JS arrays do slow bound checks, so reading from `A2_BUF` slows it down
+ * @module
+ */
+import { add3H, add3L, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL } from "./_u64.js";
+import { blake2b } from "./blake2.js";
+import { anumber, clean, kdfInputToBytes, nextTick, u32, u8 } from "./utils.js";
+const AT = { Argond2d: 0, Argon2i: 1, Argon2id: 2 };
+const ARGON2_SYNC_POINTS = 4;
+const abytesOrZero = (buf, errorTitle = '') => {
+    if (buf === undefined)
+        return Uint8Array.of();
+    return kdfInputToBytes(buf, errorTitle);
+};
+// u32 * u32 = u64
+function mul(a, b) {
+    const aL = a & 0xffff;
+    const aH = a >>> 16;
+    const bL = b & 0xffff;
+    const bH = b >>> 16;
+    const ll = Math.imul(aL, bL);
+    const hl = Math.imul(aH, bL);
+    const lh = Math.imul(aL, bH);
+    const hh = Math.imul(aH, bH);
+    const carry = (ll >>> 16) + (hl & 0xffff) + lh;
+    const high = (hh + (hl >>> 16) + (carry >>> 16)) | 0;
+    const low = (carry << 16) | (ll & 0xffff);
+    return { h: high, l: low };
+}
+function mul2(a, b) {
+    // 2 * a * b (via shifts)
+    const { h, l } = mul(a, b);
+    return { h: ((h << 1) | (l >>> 31)) & 0xffff_ffff, l: (l << 1) & 0xffff_ffff };
+}
+// BlaMka permutation for Argon2
+// A + B + (2 * u32(A) * u32(B))
+function blamka(Ah, Al, Bh, Bl) {
+    const { h: Ch, l: Cl } = mul2(Al, Bl);
+    // A + B + (2 * A * B)
+    const Rll = add3L(Al, Bl, Cl);
+    return { h: add3H(Rll, Ah, Bh, Ch), l: Rll | 0 };
+}
+// Temporary block buffer
+const A2_BUF = new Uint32Array(256); // 1024 bytes (matrix 16x16)
+function G(a, b, c, d) {
+    let Al = A2_BUF[2 * a], Ah = A2_BUF[2 * a + 1]; // prettier-ignore
+    let Bl = A2_BUF[2 * b], Bh = A2_BUF[2 * b + 1]; // prettier-ignore
+    let Cl = A2_BUF[2 * c], Ch = A2_BUF[2 * c + 1]; // prettier-ignore
+    let Dl = A2_BUF[2 * d], Dh = A2_BUF[2 * d + 1]; // prettier-ignore
+    ({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
+    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+    ({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh, Dl) });
+    ({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
+    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+    ({ Bh, Bl } = { Bh: rotrSH(Bh, Bl, 24), Bl: rotrSL(Bh, Bl, 24) });
+    ({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
+    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+    ({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
+    ({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
+    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+    ({ Bh, Bl } = { Bh: rotrBH(Bh, Bl, 63), Bl: rotrBL(Bh, Bl, 63) });
+    ((A2_BUF[2 * a] = Al), (A2_BUF[2 * a + 1] = Ah));
+    ((A2_BUF[2 * b] = Bl), (A2_BUF[2 * b + 1] = Bh));
+    ((A2_BUF[2 * c] = Cl), (A2_BUF[2 * c + 1] = Ch));
+    ((A2_BUF[2 * d] = Dl), (A2_BUF[2 * d + 1] = Dh));
+}
+// prettier-ignore
+function P(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14, v15) {
+    G(v00, v04, v08, v12);
+    G(v01, v05, v09, v13);
+    G(v02, v06, v10, v14);
+    G(v03, v07, v11, v15);
+    G(v00, v05, v10, v15);
+    G(v01, v06, v11, v12);
+    G(v02, v07, v08, v13);
+    G(v03, v04, v09, v14);
+}
+function block(x, xPos, yPos, outPos, needXor) {
+    for (let i = 0; i < 256; i++)
+        A2_BUF[i] = x[xPos + i] ^ x[yPos + i];
+    // columns (8)
+    for (let i = 0; i < 128; i += 16) {
+        // prettier-ignore
+        P(i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9, i + 10, i + 11, i + 12, i + 13, i + 14, i + 15);
+    }
+    // rows (8)
+    for (let i = 0; i < 16; i += 2) {
+        // prettier-ignore
+        P(i, i + 1, i + 16, i + 17, i + 32, i + 33, i + 48, i + 49, i + 64, i + 65, i + 80, i + 81, i + 96, i + 97, i + 112, i + 113);
+    }
+    if (needXor)
+        for (let i = 0; i < 256; i++)
+            x[outPos + i] ^= A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+    else
+        for (let i = 0; i < 256; i++)
+            x[outPos + i] = A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+    clean(A2_BUF);
+}
+// Variable-Length Hash Function H'
+function Hp(A, dkLen) {
+    const A8 = u8(A);
+    const T = new Uint32Array(1);
+    const T8 = u8(T);
+    T[0] = dkLen;
+    // Fast path
+    if (dkLen <= 64)
+        return blake2b.create({ dkLen }).update(T8).update(A8).digest();
+    const out = new Uint8Array(dkLen);
+    let V = blake2b.create({}).update(T8).update(A8).digest();
+    let pos = 0;
+    // First block
+    out.set(V.subarray(0, 32));
+    pos += 32;
+    // Rest blocks
+    for (; dkLen - pos > 64; pos += 32) {
+        const Vh = blake2b.create({}).update(V);
+        Vh.digestInto(V);
+        Vh.destroy();
+        out.set(V.subarray(0, 32), pos);
+    }
+    // Last block
+    out.set(blake2b(V, { dkLen: dkLen - pos }), pos);
+    clean(V, T);
+    return u32(out);
+}
+// Used only inside process block!
+function indexAlpha(r, s, laneLen, segmentLen, index, randL, sameLane = false) {
+    // This is ugly, but close enough to reference implementation.
+    let area;
+    if (r === 0) {
+        if (s === 0)
+            area = index - 1;
+        else if (sameLane)
+            area = s * segmentLen + index - 1;
+        else
+            area = s * segmentLen + (index == 0 ? -1 : 0);
+    }
+    else if (sameLane)
+        area = laneLen - segmentLen + index - 1;
+    else
+        area = laneLen - segmentLen + (index == 0 ? -1 : 0);
+    const startPos = r !== 0 && s !== ARGON2_SYNC_POINTS - 1 ? (s + 1) * segmentLen : 0;
+    const rel = area - 1 - mul(area, mul(randL, randL).h).h;
+    return (startPos + rel) % laneLen;
+}
+const maxUint32 = Math.pow(2, 32);
+function isU32(num) {
+    return Number.isSafeInteger(num) && num >= 0 && num < maxUint32;
+}
+function argon2Opts(opts) {
+    const merged = {
+        version: 0x13,
+        dkLen: 32,
+        maxmem: maxUint32 - 1,
+        asyncTick: 10,
+    };
+    for (let [k, v] of Object.entries(opts))
+        if (v !== undefined)
+            merged[k] = v;
+    const { dkLen, p, m, t, version, onProgress, asyncTick } = merged;
+    if (!isU32(dkLen) || dkLen < 4)
+        throw new Error('"dkLen" must be 4..');
+    if (!isU32(p) || p < 1 || p >= Math.pow(2, 24))
+        throw new Error('"p" must be 1..2^24');
+    if (!isU32(m))
+        throw new Error('"m" must be 0..2^32');
+    if (!isU32(t) || t < 1)
+        throw new Error('"t" (iterations) must be 1..2^32');
+    if (onProgress !== undefined && typeof onProgress !== 'function')
+        throw new Error('"progressCb" must be a function');
+    anumber(asyncTick, 'asyncTick');
+    /*
+    Memory size m MUST be an integer number of kibibytes from 8*p to 2^(32)-1. The actual number of blocks is m', which is m rounded down to the nearest multiple of 4*p.
+    */
+    if (!isU32(m) || m < 8 * p)
+        throw new Error('"m" (memory) must be at least 8*p bytes');
+    if (version !== 0x10 && version !== 0x13)
+        throw new Error('"version" must be 0x10 or 0x13, got ' + version);
+    return merged;
+}
+function argon2Init(password, salt, type, opts) {
+    password = kdfInputToBytes(password, 'password');
+    salt = kdfInputToBytes(salt, 'salt');
+    if (!isU32(password.length))
+        throw new Error('"password" must be less of length 1..4Gb');
+    if (!isU32(salt.length) || salt.length < 8)
+        throw new Error('"salt" must be of length 8..4Gb');
+    if (!Object.values(AT).includes(type))
+        throw new Error('"type" was invalid');
+    let { p, dkLen, m, t, version, key, personalization, maxmem, onProgress, asyncTick } = argon2Opts(opts);
+    // Validation
+    key = abytesOrZero(key, 'key');
+    personalization = abytesOrZero(personalization, 'personalization');
+    // H_0 = H^(64)(LE32(p) || LE32(T) || LE32(m) || LE32(t) ||
+    //       LE32(v) || LE32(y) || LE32(length(P)) || P ||
+    //       LE32(length(S)) || S ||  LE32(length(K)) || K ||
+    //       LE32(length(X)) || X)
+    const h = blake2b.create();
+    const BUF = new Uint32Array(1);
+    const BUF8 = u8(BUF);
+    for (let item of [p, dkLen, m, t, version, type]) {
+        BUF[0] = item;
+        h.update(BUF8);
+    }
+    for (let i of [password, salt, key, personalization]) {
+        BUF[0] = i.length; // BUF is u32 array, this is valid
+        h.update(BUF8).update(i);
+    }
+    const H0 = new Uint32Array(18);
+    const H0_8 = u8(H0);
+    h.digestInto(H0_8);
+    // 256 u32 = 1024 (BLOCK_SIZE), fills A2_BUF on processing
+    // Params
+    const lanes = p;
+    // m' = 4 * p * floor (m / 4p)
+    const mP = 4 * p * Math.floor(m / (ARGON2_SYNC_POINTS * p));
+    //q = m' / p columns
+    const laneLen = Math.floor(mP / p);
+    const segmentLen = Math.floor(laneLen / ARGON2_SYNC_POINTS);
+    const memUsed = mP * 256;
+    if (!isU32(maxmem) || memUsed > maxmem)
+        throw new Error('"maxmem" expected <2**32, got: maxmem=' + maxmem + ', memused=' + memUsed);
+    const B = new Uint32Array(memUsed);
+    // Fill first blocks
+    for (let l = 0; l < p; l++) {
+        const i = 256 * laneLen * l;
+        // B[i][0] = H'^(1024)(H_0 || LE32(0) || LE32(i))
+        H0[17] = l;
+        H0[16] = 0;
+        B.set(Hp(H0, 1024), i);
+        // B[i][1] = H'^(1024)(H_0 || LE32(1) || LE32(i))
+        H0[16] = 1;
+        B.set(Hp(H0, 1024), i + 256);
+    }
+    let perBlock = () => { };
+    if (onProgress) {
+        const totalBlock = t * ARGON2_SYNC_POINTS * p * segmentLen;
+        // Invoke callback if progress changes from 10.01 to 10.02
+        // Allows to draw smooth progress bar on up to 8K screen
+        const callbackPer = Math.max(Math.floor(totalBlock / 10000), 1);
+        let blockCnt = 0;
+        perBlock = () => {
+            blockCnt++;
+            if (onProgress && (!(blockCnt % callbackPer) || blockCnt === totalBlock))
+                onProgress(blockCnt / totalBlock);
+        };
+    }
+    clean(BUF, H0);
+    return { type, mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick };
+}
+function argon2Output(B, p, laneLen, dkLen) {
+    const B_final = new Uint32Array(256);
+    for (let l = 0; l < p; l++)
+        for (let j = 0; j < 256; j++)
+            B_final[j] ^= B[256 * (laneLen * l + laneLen - 1) + j];
+    const res = u8(Hp(B_final, dkLen));
+    clean(B_final);
+    return res;
+}
+function processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor) {
+    if (offset % laneLen)
+        prev = offset - 1;
+    let randL, randH;
+    if (dataIndependent) {
+        let i128 = index % 128;
+        if (i128 === 0) {
+            address[256 + 12]++;
+            block(address, 256, 2 * 256, 0, false);
+            block(address, 0, 2 * 256, 0, false);
+        }
+        randL = address[2 * i128];
+        randH = address[2 * i128 + 1];
+    }
+    else {
+        const T = 256 * prev;
+        randL = B[T];
+        randH = B[T + 1];
+    }
+    // address block
+    const refLane = r === 0 && s === 0 ? l : randH % lanes;
+    const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane == l);
+    const refBlock = laneLen * refLane + refPos;
+    // B[i][j] = G(B[i][j-1], B[l][z])
+    block(B, 256 * prev, 256 * refBlock, offset * 256, needXor);
+}
+function argon2(type, password, salt, opts) {
+    const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock } = argon2Init(password, salt, type, opts);
+    // Pre-loop setup
+    // [address, input, zero_block] format so we can pass single U32 to block function
+    const address = new Uint32Array(3 * 256);
+    address[256 + 6] = mP;
+    address[256 + 8] = t;
+    address[256 + 10] = type;
+    for (let r = 0; r < t; r++) {
+        const needXor = r !== 0 && version === 0x13;
+        address[256 + 0] = r;
+        for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
+            address[256 + 4] = s;
+            const dataIndependent = type == AT.Argon2i || (type == AT.Argon2id && r === 0 && s < 2);
+            for (let l = 0; l < p; l++) {
+                address[256 + 2] = l;
+                address[256 + 12] = 0;
+                let startPos = 0;
+                if (r === 0 && s === 0) {
+                    startPos = 2;
+                    if (dataIndependent) {
+                        address[256 + 12]++;
+                        block(address, 256, 2 * 256, 0, false);
+                        block(address, 0, 2 * 256, 0, false);
+                    }
+                }
+                // current block postion
+                let offset = l * laneLen + s * segmentLen + startPos;
+                // previous block position
+                let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
+                for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
+                    perBlock();
+                    processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor);
+                }
+            }
+        }
+    }
+    clean(address);
+    return argon2Output(B, p, laneLen, dkLen);
+}
+/** argon2d GPU-resistant version. */
+export const argon2d = (password, salt, opts) => argon2(AT.Argond2d, password, salt, opts);
+/** argon2i side-channel-resistant version. */
+export const argon2i = (password, salt, opts) => argon2(AT.Argon2i, password, salt, opts);
+/** argon2id, combining i+d, the most popular version from RFC 9106 */
+export const argon2id = (password, salt, opts) => argon2(AT.Argon2id, password, salt, opts);
+async function argon2Async(type, password, salt, opts) {
+    const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick } = argon2Init(password, salt, type, opts);
+    // Pre-loop setup
+    // [address, input, zero_block] format so we can pass single U32 to block function
+    const address = new Uint32Array(3 * 256);
+    address[256 + 6] = mP;
+    address[256 + 8] = t;
+    address[256 + 10] = type;
+    let ts = Date.now();
+    for (let r = 0; r < t; r++) {
+        const needXor = r !== 0 && version === 0x13;
+        address[256 + 0] = r;
+        for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
+            address[256 + 4] = s;
+            const dataIndependent = type == AT.Argon2i || (type == AT.Argon2id && r === 0 && s < 2);
+            for (let l = 0; l < p; l++) {
+                address[256 + 2] = l;
+                address[256 + 12] = 0;
+                let startPos = 0;
+                if (r === 0 && s === 0) {
+                    startPos = 2;
+                    if (dataIndependent) {
+                        address[256 + 12]++;
+                        block(address, 256, 2 * 256, 0, false);
+                        block(address, 0, 2 * 256, 0, false);
+                    }
+                }
+                // current block postion
+                let offset = l * laneLen + s * segmentLen + startPos;
+                // previous block position
+                let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
+                for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
+                    perBlock();
+                    processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor);
+                    // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+                    const diff = Date.now() - ts;
+                    if (!(diff >= 0 && diff < asyncTick)) {
+                        await nextTick();
+                        ts += diff;
+                    }
+                }
+            }
+        }
+    }
+    clean(address);
+    return argon2Output(B, p, laneLen, dkLen);
+}
+/** argon2d async GPU-resistant version. */
+export const argon2dAsync = (password, salt, opts) => argon2Async(AT.Argond2d, password, salt, opts);
+/** argon2i async side-channel-resistant version. */
+export const argon2iAsync = (password, salt, opts) => argon2Async(AT.Argon2i, password, salt, opts);
+/** argon2id async, combining i+d, the most popular version from RFC 9106 */
+export const argon2idAsync = (password, salt, opts) => argon2Async(AT.Argon2id, password, salt, opts);
+//# sourceMappingURL=argon2.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake1.d.ts

@@ -0,0 +1,110 @@
+import { type CHash, type Hash } from './utils.ts';
+/** Blake1 options. Basically just "salt" */
+export type BlakeOpts = {
+    salt?: Uint8Array;
+};
+declare abstract class BLAKE1<T extends BLAKE1<T>> implements Hash<T> {
+    protected finished: boolean;
+    protected length: number;
+    protected pos: number;
+    protected destroyed: boolean;
+    protected buffer: Uint8Array;
+    protected view: DataView;
+    protected salt: Uint32Array;
+    abstract compress(view: DataView, offset: number, withLength?: boolean): void;
+    protected abstract get(): number[];
+    protected abstract set(...args: number[]): void;
+    readonly blockLen: number;
+    readonly outputLen: number;
+    private lengthFlag;
+    private counterLen;
+    protected constants: Uint32Array;
+    constructor(blockLen: number, outputLen: number, lengthFlag: number, counterLen: number, saltLen: number, constants: Uint32Array, opts?: BlakeOpts);
+    update(data: Uint8Array): this;
+    destroy(): void;
+    _cloneInto(to?: T): T;
+    clone(): T;
+    digestInto(out: Uint8Array): void;
+    digest(): Uint8Array;
+}
+declare class BLAKE1_32B extends BLAKE1<BLAKE1_32B> {
+    private v0;
+    private v1;
+    private v2;
+    private v3;
+    private v4;
+    private v5;
+    private v6;
+    private v7;
+    constructor(outputLen: number, IV: Uint32Array, lengthFlag: number, opts?: BlakeOpts);
+    protected get(): [number, number, number, number, number, number, number, number];
+    protected set(v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number): void;
+    destroy(): void;
+    compress(view: DataView, offset: number, withLength?: boolean): void;
+}
+declare class BLAKE1_64B extends BLAKE1<BLAKE1_64B> {
+    private v0l;
+    private v0h;
+    private v1l;
+    private v1h;
+    private v2l;
+    private v2h;
+    private v3l;
+    private v3h;
+    private v4l;
+    private v4h;
+    private v5l;
+    private v5h;
+    private v6l;
+    private v6h;
+    private v7l;
+    private v7h;
+    constructor(outputLen: number, IV: Uint32Array, lengthFlag: number, opts?: BlakeOpts);
+    protected get(): [
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number
+    ];
+    protected set(v0l: number, v0h: number, v1l: number, v1h: number, v2l: number, v2h: number, v3l: number, v3h: number, v4l: number, v4h: number, v5l: number, v5h: number, v6l: number, v6h: number, v7l: number, v7h: number): void;
+    destroy(): void;
+    compress(view: DataView, offset: number, withLength?: boolean): void;
+}
+/** Internal blake1-224 hash class. */
+export declare class _BLAKE224 extends BLAKE1_32B {
+    constructor(opts?: BlakeOpts);
+}
+/** Internal blake1-256 hash class. */
+export declare class _BLAKE256 extends BLAKE1_32B {
+    constructor(opts?: BlakeOpts);
+}
+/** Internal blake1-384 hash class. */
+export declare class _BLAKE384 extends BLAKE1_64B {
+    constructor(opts?: BlakeOpts);
+}
+/** Internal blake1-512 hash class. */
+export declare class _BLAKE512 extends BLAKE1_64B {
+    constructor(opts?: BlakeOpts);
+}
+/** blake1-224 hash function */
+export declare const blake224: CHash<_BLAKE224, BlakeOpts>;
+/** blake1-256 hash function */
+export declare const blake256: CHash<_BLAKE256, BlakeOpts>;
+/** blake1-384 hash function */
+export declare const blake384: CHash<_BLAKE384, BlakeOpts>;
+/** blake1-512 hash function */
+export declare const blake512: CHash<_BLAKE512, BlakeOpts>;
+export {};
+//# sourceMappingURL=blake1.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blake1.d.ts","sourceRoot":"","sources":["src/blake1.ts"],"names":[],"mappings":"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"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake1.js

@@ -0,0 +1,485 @@
+/**
+ * Blake1 legacy hash function, one of SHA3 proposals.
+ * Rarely used. Check out blake2 or blake3 instead.
+ * https://www.aumasson.jp/blake/blake.pdf
+ *
+ * In the best case, there are 0 allocations.
+ *
+ * Differences from blake2:
+ *
+ * - BE instead of LE
+ * - Paddings, similar to MD5, RIPEMD, SHA1, SHA2, but:
+ *     - length flag is located before actual length
+ *     - padding block is compressed differently (no lengths)
+ * Instead of msg[sigma[k]], we have `msg[sigma[k]] ^ constants[sigma[k-1]]`
+ * (-1 for g1, g2 without -1)
+ * - Salt is XOR-ed into constants instead of state
+ * - Salt is XOR-ed with output in `compress`
+ * - Additional rows (+64 bytes) in SIGMA for new rounds
+ * - Different round count:
+ *     - 14 / 10 rounds in blake256 / blake2s
+ *     - 16 / 12 rounds in blake512 / blake2b
+ * - blake512: G1b: rotr 24 -> 25, G2b: rotr 63 -> 11
+ * @module
+ */
+import { BSIGMA, G1s, G2s } from "./_blake.js";
+import { SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from "./_md.js";
+import * as u64 from "./_u64.js";
+// prettier-ignore
+import { abytes, aexists, aoutput, clean, createHasher, createView } from "./utils.js";
+// Empty zero-filled salt
+const EMPTY_SALT = /* @__PURE__ */ new Uint32Array(8);
+class BLAKE1 {
+    finished = false;
+    length = 0;
+    pos = 0;
+    destroyed = false;
+    // For partial updates less than block size
+    buffer;
+    view;
+    salt;
+    blockLen;
+    outputLen;
+    lengthFlag;
+    counterLen;
+    constants;
+    constructor(blockLen, outputLen, lengthFlag, counterLen, saltLen, constants, opts = {}) {
+        const { salt } = opts;
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.lengthFlag = lengthFlag;
+        this.counterLen = counterLen;
+        this.buffer = new Uint8Array(blockLen);
+        this.view = createView(this.buffer);
+        if (salt !== undefined) {
+            let slt = salt;
+            abytes(slt, 4 * saltLen, 'salt');
+            // if (slt.length !== 4 * saltLen) throw new Error('wrong salt length');
+            const salt32 = (this.salt = new Uint32Array(saltLen));
+            const sv = createView(slt);
+            this.constants = constants.slice();
+            for (let i = 0, offset = 0; i < salt32.length; i++, offset += 4) {
+                salt32[i] = sv.getUint32(offset, false);
+                this.constants[i] ^= salt32[i];
+            }
+        }
+        else {
+            this.salt = EMPTY_SALT;
+            this.constants = constants;
+        }
+    }
+    update(data) {
+        aexists(this);
+        abytes(data);
+        // From _md, but update length before each compress
+        const { view, buffer, blockLen } = this;
+        const len = data.length;
+        let dataView;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                if (!dataView)
+                    dataView = createView(data);
+                for (; blockLen <= len - pos; pos += blockLen) {
+                    this.length += blockLen;
+                    this.compress(dataView, pos);
+                }
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            pos += take;
+            if (this.pos === blockLen) {
+                this.length += blockLen;
+                this.compress(view, 0, true);
+                this.pos = 0;
+            }
+        }
+        return this;
+    }
+    destroy() {
+        this.destroyed = true;
+        if (this.salt !== EMPTY_SALT) {
+            clean(this.salt, this.constants);
+        }
+    }
+    _cloneInto(to) {
+        to ||= new this.constructor();
+        to.set(...this.get());
+        const { buffer, length, finished, destroyed, constants, salt, pos } = this;
+        to.buffer.set(buffer);
+        to.constants = constants.slice();
+        to.destroyed = destroyed;
+        to.finished = finished;
+        to.length = length;
+        to.pos = pos;
+        to.salt = salt.slice();
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+    digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        this.finished = true;
+        // Padding
+        const { buffer, blockLen, counterLen, lengthFlag, view } = this;
+        clean(buffer.subarray(this.pos)); // clean buf
+        const counter = BigInt((this.length + this.pos) * 8);
+        const counterPos = blockLen - counterLen - 1;
+        buffer[this.pos] |= 0b1000_0000; // End block flag
+        this.length += this.pos; // add unwritten length
+        // Not enough in buffer for length: write what we have.
+        if (this.pos > counterPos) {
+            this.compress(view, 0);
+            clean(buffer);
+            this.pos = 0;
+        }
+        // Difference with md: here we have lengthFlag!
+        buffer[counterPos] |= lengthFlag; // Length flag
+        // We always set 8 byte length flag. Because length will overflow significantly sooner.
+        view.setBigUint64(blockLen - 8, counter, false);
+        this.compress(view, 0, this.pos !== 0); // don't add length if length is not empty block?
+        // Write output
+        clean(buffer);
+        const v = createView(out);
+        const state = this.get();
+        for (let i = 0; i < this.outputLen / 4; ++i)
+            v.setUint32(i * 4, state[i]);
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+}
+// Constants
+const B64C = /* @__PURE__ */ Uint32Array.from([
+    0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+    0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+    0x9216d5d9, 0x8979fb1b, 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96,
+    0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 0x636920d8, 0x71574e69,
+]);
+// first half of C512
+const B32C = B64C.slice(0, 16);
+const B256_IV = /* @__PURE__ */ SHA256_IV.slice();
+const B224_IV = /* @__PURE__ */ SHA224_IV.slice();
+const B384_IV = /* @__PURE__ */ SHA384_IV.slice();
+const B512_IV = /* @__PURE__ */ SHA512_IV.slice();
+function generateTBL256() {
+    const TBL = [];
+    for (let i = 0, j = 0; i < 14; i++, j += 16) {
+        for (let offset = 1; offset < 16; offset += 2) {
+            TBL.push(B32C[BSIGMA[j + offset]]);
+            TBL.push(B32C[BSIGMA[j + offset - 1]]);
+        }
+    }
+    return new Uint32Array(TBL);
+}
+const TBL256 = /* @__PURE__ */ generateTBL256(); // C256[SIGMA[X]] precompute
+// Reusable temporary buffer
+const BLAKE256_W = /* @__PURE__ */ new Uint32Array(16);
+class BLAKE1_32B extends BLAKE1 {
+    v0;
+    v1;
+    v2;
+    v3;
+    v4;
+    v5;
+    v6;
+    v7;
+    constructor(outputLen, IV, lengthFlag, opts = {}) {
+        super(64, outputLen, lengthFlag, 8, 4, B32C, opts);
+        this.v0 = IV[0] | 0;
+        this.v1 = IV[1] | 0;
+        this.v2 = IV[2] | 0;
+        this.v3 = IV[3] | 0;
+        this.v4 = IV[4] | 0;
+        this.v5 = IV[5] | 0;
+        this.v6 = IV[6] | 0;
+        this.v7 = IV[7] | 0;
+    }
+    get() {
+        const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
+        return [v0, v1, v2, v3, v4, v5, v6, v7];
+    }
+    // prettier-ignore
+    set(v0, v1, v2, v3, v4, v5, v6, v7) {
+        this.v0 = v0 | 0;
+        this.v1 = v1 | 0;
+        this.v2 = v2 | 0;
+        this.v3 = v3 | 0;
+        this.v4 = v4 | 0;
+        this.v5 = v5 | 0;
+        this.v6 = v6 | 0;
+        this.v7 = v7 | 0;
+    }
+    destroy() {
+        super.destroy();
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    }
+    compress(view, offset, withLength = true) {
+        for (let i = 0; i < 16; i++, offset += 4)
+            BLAKE256_W[i] = view.getUint32(offset, false);
+        // NOTE: we cannot re-use compress from blake2s, since there is additional xor over u256[SIGMA[e]]
+        let v00 = this.v0 | 0;
+        let v01 = this.v1 | 0;
+        let v02 = this.v2 | 0;
+        let v03 = this.v3 | 0;
+        let v04 = this.v4 | 0;
+        let v05 = this.v5 | 0;
+        let v06 = this.v6 | 0;
+        let v07 = this.v7 | 0;
+        let v08 = this.constants[0] | 0;
+        let v09 = this.constants[1] | 0;
+        let v10 = this.constants[2] | 0;
+        let v11 = this.constants[3] | 0;
+        const { h, l } = u64.fromBig(BigInt(withLength ? this.length * 8 : 0));
+        let v12 = (this.constants[4] ^ l) >>> 0;
+        let v13 = (this.constants[5] ^ l) >>> 0;
+        let v14 = (this.constants[6] ^ h) >>> 0;
+        let v15 = (this.constants[7] ^ h) >>> 0;
+        // prettier-ignore
+        for (let i = 0, k = 0, j = 0; i < 14; i++) {
+            ({ a: v00, b: v04, c: v08, d: v12 } = G1s(v00, v04, v08, v12, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v00, b: v04, c: v08, d: v12 } = G2s(v00, v04, v08, v12, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v01, b: v05, c: v09, d: v13 } = G1s(v01, v05, v09, v13, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v01, b: v05, c: v09, d: v13 } = G2s(v01, v05, v09, v13, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v02, b: v06, c: v10, d: v14 } = G1s(v02, v06, v10, v14, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v02, b: v06, c: v10, d: v14 } = G2s(v02, v06, v10, v14, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v03, b: v07, c: v11, d: v15 } = G1s(v03, v07, v11, v15, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v03, b: v07, c: v11, d: v15 } = G2s(v03, v07, v11, v15, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v00, b: v05, c: v10, d: v15 } = G1s(v00, v05, v10, v15, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v00, b: v05, c: v10, d: v15 } = G2s(v00, v05, v10, v15, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v01, b: v06, c: v11, d: v12 } = G1s(v01, v06, v11, v12, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v01, b: v06, c: v11, d: v12 } = G2s(v01, v06, v11, v12, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v02, b: v07, c: v08, d: v13 } = G1s(v02, v07, v08, v13, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v02, b: v07, c: v08, d: v13 } = G2s(v02, v07, v08, v13, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v03, b: v04, c: v09, d: v14 } = G1s(v03, v04, v09, v14, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+            ({ a: v03, b: v04, c: v09, d: v14 } = G2s(v03, v04, v09, v14, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+        }
+        this.v0 = (this.v0 ^ v00 ^ v08 ^ this.salt[0]) >>> 0;
+        this.v1 = (this.v1 ^ v01 ^ v09 ^ this.salt[1]) >>> 0;
+        this.v2 = (this.v2 ^ v02 ^ v10 ^ this.salt[2]) >>> 0;
+        this.v3 = (this.v3 ^ v03 ^ v11 ^ this.salt[3]) >>> 0;
+        this.v4 = (this.v4 ^ v04 ^ v12 ^ this.salt[0]) >>> 0;
+        this.v5 = (this.v5 ^ v05 ^ v13 ^ this.salt[1]) >>> 0;
+        this.v6 = (this.v6 ^ v06 ^ v14 ^ this.salt[2]) >>> 0;
+        this.v7 = (this.v7 ^ v07 ^ v15 ^ this.salt[3]) >>> 0;
+        clean(BLAKE256_W);
+    }
+}
+const BBUF = /* @__PURE__ */ new Uint32Array(32);
+const BLAKE512_W = /* @__PURE__ */ new Uint32Array(32);
+function generateTBL512() {
+    const TBL = [];
+    for (let r = 0, k = 0; r < 16; r++, k += 16) {
+        for (let offset = 1; offset < 16; offset += 2) {
+            TBL.push(B64C[BSIGMA[k + offset] * 2 + 0]);
+            TBL.push(B64C[BSIGMA[k + offset] * 2 + 1]);
+            TBL.push(B64C[BSIGMA[k + offset - 1] * 2 + 0]);
+            TBL.push(B64C[BSIGMA[k + offset - 1] * 2 + 1]);
+        }
+    }
+    return new Uint32Array(TBL);
+}
+const TBL512 = /* @__PURE__ */ generateTBL512(); // C512[SIGMA[X]] precompute
+// Mixing function G splitted in two halfs
+function G1b(a, b, c, d, msg, k) {
+    const Xpos = 2 * BSIGMA[k];
+    const Xl = msg[Xpos + 1] ^ TBL512[k * 2 + 1], Xh = msg[Xpos] ^ TBL512[k * 2]; // prettier-ignore
+    let Al = BBUF[2 * a + 1], Ah = BBUF[2 * a]; // prettier-ignore
+    let Bl = BBUF[2 * b + 1], Bh = BBUF[2 * b]; // prettier-ignore
+    let Cl = BBUF[2 * c + 1], Ch = BBUF[2 * c]; // prettier-ignore
+    let Dl = BBUF[2 * d + 1], Dh = BBUF[2 * d]; // prettier-ignore
+    // v[a] = (v[a] + v[b] + x) | 0;
+    let ll = u64.add3L(Al, Bl, Xl);
+    Ah = u64.add3H(ll, Ah, Bh, Xh) >>> 0;
+    Al = (ll | 0) >>> 0;
+    // v[d] = rotr(v[d] ^ v[a], 32)
+    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+    ({ Dh, Dl } = { Dh: u64.rotr32H(Dh, Dl), Dl: u64.rotr32L(Dh, Dl) });
+    // v[c] = (v[c] + v[d]) | 0;
+    ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+    // v[b] = rotr(v[b] ^ v[c], 25)
+    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+    ({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 25), Bl: u64.rotrSL(Bh, Bl, 25) });
+    ((BBUF[2 * a + 1] = Al), (BBUF[2 * a] = Ah));
+    ((BBUF[2 * b + 1] = Bl), (BBUF[2 * b] = Bh));
+    ((BBUF[2 * c + 1] = Cl), (BBUF[2 * c] = Ch));
+    ((BBUF[2 * d + 1] = Dl), (BBUF[2 * d] = Dh));
+}
+function G2b(a, b, c, d, msg, k) {
+    const Xpos = 2 * BSIGMA[k];
+    const Xl = msg[Xpos + 1] ^ TBL512[k * 2 + 1], Xh = msg[Xpos] ^ TBL512[k * 2]; // prettier-ignore
+    let Al = BBUF[2 * a + 1], Ah = BBUF[2 * a]; // prettier-ignore
+    let Bl = BBUF[2 * b + 1], Bh = BBUF[2 * b]; // prettier-ignore
+    let Cl = BBUF[2 * c + 1], Ch = BBUF[2 * c]; // prettier-ignore
+    let Dl = BBUF[2 * d + 1], Dh = BBUF[2 * d]; // prettier-ignore
+    // v[a] = (v[a] + v[b] + x) | 0;
+    let ll = u64.add3L(Al, Bl, Xl);
+    Ah = u64.add3H(ll, Ah, Bh, Xh);
+    Al = ll | 0;
+    // v[d] = rotr(v[d] ^ v[a], 16)
+    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+    ({ Dh, Dl } = { Dh: u64.rotrSH(Dh, Dl, 16), Dl: u64.rotrSL(Dh, Dl, 16) });
+    // v[c] = (v[c] + v[d]) | 0;
+    ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+    // v[b] = rotr(v[b] ^ v[c], 11)
+    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+    ({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 11), Bl: u64.rotrSL(Bh, Bl, 11) });
+    ((BBUF[2 * a + 1] = Al), (BBUF[2 * a] = Ah));
+    ((BBUF[2 * b + 1] = Bl), (BBUF[2 * b] = Bh));
+    ((BBUF[2 * c + 1] = Cl), (BBUF[2 * c] = Ch));
+    ((BBUF[2 * d + 1] = Dl), (BBUF[2 * d] = Dh));
+}
+class BLAKE1_64B extends BLAKE1 {
+    v0l;
+    v0h;
+    v1l;
+    v1h;
+    v2l;
+    v2h;
+    v3l;
+    v3h;
+    v4l;
+    v4h;
+    v5l;
+    v5h;
+    v6l;
+    v6h;
+    v7l;
+    v7h;
+    constructor(outputLen, IV, lengthFlag, opts = {}) {
+        super(128, outputLen, lengthFlag, 16, 8, B64C, opts);
+        this.v0l = IV[0] | 0;
+        this.v0h = IV[1] | 0;
+        this.v1l = IV[2] | 0;
+        this.v1h = IV[3] | 0;
+        this.v2l = IV[4] | 0;
+        this.v2h = IV[5] | 0;
+        this.v3l = IV[6] | 0;
+        this.v3h = IV[7] | 0;
+        this.v4l = IV[8] | 0;
+        this.v4h = IV[9] | 0;
+        this.v5l = IV[10] | 0;
+        this.v5h = IV[11] | 0;
+        this.v6l = IV[12] | 0;
+        this.v6h = IV[13] | 0;
+        this.v7l = IV[14] | 0;
+        this.v7h = IV[15] | 0;
+    }
+    // prettier-ignore
+    get() {
+        let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+        return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+    }
+    // prettier-ignore
+    set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+        this.v0l = v0l | 0;
+        this.v0h = v0h | 0;
+        this.v1l = v1l | 0;
+        this.v1h = v1h | 0;
+        this.v2l = v2l | 0;
+        this.v2h = v2h | 0;
+        this.v3l = v3l | 0;
+        this.v3h = v3h | 0;
+        this.v4l = v4l | 0;
+        this.v4h = v4h | 0;
+        this.v5l = v5l | 0;
+        this.v5h = v5h | 0;
+        this.v6l = v6l | 0;
+        this.v6h = v6h | 0;
+        this.v7l = v7l | 0;
+        this.v7h = v7h | 0;
+    }
+    destroy() {
+        super.destroy();
+        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+    compress(view, offset, withLength = true) {
+        for (let i = 0; i < 32; i++, offset += 4)
+            BLAKE512_W[i] = view.getUint32(offset, false);
+        this.get().forEach((v, i) => (BBUF[i] = v)); // First half from state.
+        BBUF.set(this.constants.subarray(0, 16), 16);
+        if (withLength) {
+            const { h, l } = u64.fromBig(BigInt(this.length * 8));
+            BBUF[24] = (BBUF[24] ^ h) >>> 0;
+            BBUF[25] = (BBUF[25] ^ l) >>> 0;
+            BBUF[26] = (BBUF[26] ^ h) >>> 0;
+            BBUF[27] = (BBUF[27] ^ l) >>> 0;
+        }
+        for (let i = 0, k = 0; i < 16; i++) {
+            G1b(0, 4, 8, 12, BLAKE512_W, k++);
+            G2b(0, 4, 8, 12, BLAKE512_W, k++);
+            G1b(1, 5, 9, 13, BLAKE512_W, k++);
+            G2b(1, 5, 9, 13, BLAKE512_W, k++);
+            G1b(2, 6, 10, 14, BLAKE512_W, k++);
+            G2b(2, 6, 10, 14, BLAKE512_W, k++);
+            G1b(3, 7, 11, 15, BLAKE512_W, k++);
+            G2b(3, 7, 11, 15, BLAKE512_W, k++);
+            G1b(0, 5, 10, 15, BLAKE512_W, k++);
+            G2b(0, 5, 10, 15, BLAKE512_W, k++);
+            G1b(1, 6, 11, 12, BLAKE512_W, k++);
+            G2b(1, 6, 11, 12, BLAKE512_W, k++);
+            G1b(2, 7, 8, 13, BLAKE512_W, k++);
+            G2b(2, 7, 8, 13, BLAKE512_W, k++);
+            G1b(3, 4, 9, 14, BLAKE512_W, k++);
+            G2b(3, 4, 9, 14, BLAKE512_W, k++);
+        }
+        this.v0l ^= BBUF[0] ^ BBUF[16] ^ this.salt[0];
+        this.v0h ^= BBUF[1] ^ BBUF[17] ^ this.salt[1];
+        this.v1l ^= BBUF[2] ^ BBUF[18] ^ this.salt[2];
+        this.v1h ^= BBUF[3] ^ BBUF[19] ^ this.salt[3];
+        this.v2l ^= BBUF[4] ^ BBUF[20] ^ this.salt[4];
+        this.v2h ^= BBUF[5] ^ BBUF[21] ^ this.salt[5];
+        this.v3l ^= BBUF[6] ^ BBUF[22] ^ this.salt[6];
+        this.v3h ^= BBUF[7] ^ BBUF[23] ^ this.salt[7];
+        this.v4l ^= BBUF[8] ^ BBUF[24] ^ this.salt[0];
+        this.v4h ^= BBUF[9] ^ BBUF[25] ^ this.salt[1];
+        this.v5l ^= BBUF[10] ^ BBUF[26] ^ this.salt[2];
+        this.v5h ^= BBUF[11] ^ BBUF[27] ^ this.salt[3];
+        this.v6l ^= BBUF[12] ^ BBUF[28] ^ this.salt[4];
+        this.v6h ^= BBUF[13] ^ BBUF[29] ^ this.salt[5];
+        this.v7l ^= BBUF[14] ^ BBUF[30] ^ this.salt[6];
+        this.v7h ^= BBUF[15] ^ BBUF[31] ^ this.salt[7];
+        clean(BBUF, BLAKE512_W);
+    }
+}
+/** Internal blake1-224 hash class. */
+export class _BLAKE224 extends BLAKE1_32B {
+    constructor(opts = {}) {
+        super(28, B224_IV, 0b0000_0000, opts);
+    }
+}
+/** Internal blake1-256 hash class. */
+export class _BLAKE256 extends BLAKE1_32B {
+    constructor(opts = {}) {
+        super(32, B256_IV, 0b0000_0001, opts);
+    }
+}
+/** Internal blake1-384 hash class. */
+export class _BLAKE384 extends BLAKE1_64B {
+    constructor(opts = {}) {
+        super(48, B384_IV, 0b0000_0000, opts);
+    }
+}
+/** Internal blake1-512 hash class. */
+export class _BLAKE512 extends BLAKE1_64B {
+    constructor(opts = {}) {
+        super(64, B512_IV, 0b0000_0001, opts);
+    }
+}
+/** blake1-224 hash function */
+export const blake224 = /* @__PURE__ */ createHasher((opts) => new _BLAKE224(opts));
+/** blake1-256 hash function */
+export const blake256 = /* @__PURE__ */ createHasher((opts) => new _BLAKE256(opts));
+/** blake1-384 hash function */
+export const blake384 = /* @__PURE__ */ createHasher((opts) => new _BLAKE384(opts));
+/** blake1-512 hash function */
+export const blake512 = /* @__PURE__ */ createHasher((opts) => new _BLAKE512(opts));
+//# sourceMappingURL=blake1.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake2.d.ts

@@ -0,0 +1,120 @@
+import { type CHash, type Hash } from './utils.ts';
+/** Blake hash options. dkLen is output length. key is used in MAC mode. salt is used in KDF mode. */
+export type Blake2Opts = {
+    dkLen?: number;
+    key?: Uint8Array;
+    salt?: Uint8Array;
+    personalization?: Uint8Array;
+};
+/** Internal base class for BLAKE2. */
+export declare abstract class _BLAKE2<T extends _BLAKE2<T>> implements Hash<T> {
+    protected abstract compress(msg: Uint32Array, offset: number, isLast: boolean): void;
+    protected abstract get(): number[];
+    protected abstract set(...args: number[]): void;
+    abstract destroy(): void;
+    protected buffer: Uint8Array;
+    protected buffer32: Uint32Array;
+    protected finished: boolean;
+    protected destroyed: boolean;
+    protected length: number;
+    protected pos: number;
+    readonly blockLen: number;
+    readonly outputLen: number;
+    constructor(blockLen: number, outputLen: number);
+    update(data: Uint8Array): this;
+    digestInto(out: Uint8Array): void;
+    digest(): Uint8Array;
+    _cloneInto(to?: T): T;
+    clone(): T;
+}
+/** Internal blake2b hash class. */
+export declare class _BLAKE2b extends _BLAKE2<_BLAKE2b> {
+    private v0l;
+    private v0h;
+    private v1l;
+    private v1h;
+    private v2l;
+    private v2h;
+    private v3l;
+    private v3h;
+    private v4l;
+    private v4h;
+    private v5l;
+    private v5h;
+    private v6l;
+    private v6h;
+    private v7l;
+    private v7h;
+    constructor(opts?: Blake2Opts);
+    protected get(): [
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number
+    ];
+    protected set(v0l: number, v0h: number, v1l: number, v1h: number, v2l: number, v2h: number, v3l: number, v3h: number, v4l: number, v4h: number, v5l: number, v5h: number, v6l: number, v6h: number, v7l: number, v7h: number): void;
+    protected compress(msg: Uint32Array, offset: number, isLast: boolean): void;
+    destroy(): void;
+}
+/**
+ * Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen output length, key for MAC mode, salt, personalization
+ */
+export declare const blake2b: CHash<_BLAKE2b, Blake2Opts>;
+/** Internal type, 16 numbers. */
+export type Num16 = {
+    v0: number;
+    v1: number;
+    v2: number;
+    v3: number;
+    v4: number;
+    v5: number;
+    v6: number;
+    v7: number;
+    v8: number;
+    v9: number;
+    v10: number;
+    v11: number;
+    v12: number;
+    v13: number;
+    v14: number;
+    v15: number;
+};
+/** BLAKE2-compress core method. */
+export declare function compress(s: Uint8Array, offset: number, msg: Uint32Array, rounds: number, v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number, v8: number, v9: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number): Num16;
+/** Internal blake2s hash class. */
+export declare class _BLAKE2s extends _BLAKE2<_BLAKE2s> {
+    private v0;
+    private v1;
+    private v2;
+    private v3;
+    private v4;
+    private v5;
+    private v6;
+    private v7;
+    constructor(opts?: Blake2Opts);
+    protected get(): [number, number, number, number, number, number, number, number];
+    protected set(v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number): void;
+    protected compress(msg: Uint32Array, offset: number, isLast: boolean): void;
+    destroy(): void;
+}
+/**
+ * Blake2s hash function. Focuses on 8-bit to 32-bit platforms. 1.5x faster than blake2b in JS.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen output length, key for MAC mode, salt, personalization
+ */
+export declare const blake2s: CHash<_BLAKE2s, Blake2Opts>;
+//# sourceMappingURL=blake2.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blake2.d.ts","sourceRoot":"","sources":["src/blake2.ts"],"names":[],"mappings":"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"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake2.js

@@ -0,0 +1,417 @@
+/**
+ * blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.
+ * b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.
+ * @module
+ */
+import { BSIGMA, G1s, G2s } from "./_blake.js";
+import { SHA256_IV } from "./_md.js";
+import * as u64 from "./_u64.js";
+// prettier-ignore
+import { abytes, aexists, anumber, aoutput, clean, createHasher, swap32IfBE, swap8IfBE, u32 } from "./utils.js";
+// Same as SHA512_IV, but swapped endianness: LE instead of BE. iv[1] is iv[0], etc.
+const B2B_IV = /* @__PURE__ */ Uint32Array.from([
+    0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,
+    0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,
+]);
+// Temporary buffer
+const BBUF = /* @__PURE__ */ new Uint32Array(32);
+// Mixing function G splitted in two halfs
+function G1b(a, b, c, d, msg, x) {
+    // NOTE: V is LE here
+    const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore
+    let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore
+    let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore
+    let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore
+    let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore
+    // v[a] = (v[a] + v[b] + x) | 0;
+    let ll = u64.add3L(Al, Bl, Xl);
+    Ah = u64.add3H(ll, Ah, Bh, Xh);
+    Al = ll | 0;
+    // v[d] = rotr(v[d] ^ v[a], 32)
+    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+    ({ Dh, Dl } = { Dh: u64.rotr32H(Dh, Dl), Dl: u64.rotr32L(Dh, Dl) });
+    // v[c] = (v[c] + v[d]) | 0;
+    ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+    // v[b] = rotr(v[b] ^ v[c], 24)
+    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+    ({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 24), Bl: u64.rotrSL(Bh, Bl, 24) });
+    ((BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah));
+    ((BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh));
+    ((BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch));
+    ((BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh));
+}
+function G2b(a, b, c, d, msg, x) {
+    // NOTE: V is LE here
+    const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore
+    let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore
+    let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore
+    let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore
+    let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore
+    // v[a] = (v[a] + v[b] + x) | 0;
+    let ll = u64.add3L(Al, Bl, Xl);
+    Ah = u64.add3H(ll, Ah, Bh, Xh);
+    Al = ll | 0;
+    // v[d] = rotr(v[d] ^ v[a], 16)
+    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+    ({ Dh, Dl } = { Dh: u64.rotrSH(Dh, Dl, 16), Dl: u64.rotrSL(Dh, Dl, 16) });
+    // v[c] = (v[c] + v[d]) | 0;
+    ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+    // v[b] = rotr(v[b] ^ v[c], 63)
+    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+    ({ Bh, Bl } = { Bh: u64.rotrBH(Bh, Bl, 63), Bl: u64.rotrBL(Bh, Bl, 63) });
+    ((BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah));
+    ((BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh));
+    ((BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch));
+    ((BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh));
+}
+function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
+    anumber(keyLen);
+    if (outputLen < 0 || outputLen > keyLen)
+        throw new Error('outputLen bigger than keyLen');
+    const { key, salt, personalization } = opts;
+    if (key !== undefined && (key.length < 1 || key.length > keyLen))
+        throw new Error('"key" expected to be undefined or of length=1..' + keyLen);
+    if (salt !== undefined)
+        abytes(salt, saltLen, 'salt');
+    if (personalization !== undefined)
+        abytes(personalization, persLen, 'personalization');
+}
+/** Internal base class for BLAKE2. */
+export class _BLAKE2 {
+    buffer;
+    buffer32;
+    finished = false;
+    destroyed = false;
+    length = 0;
+    pos = 0;
+    blockLen;
+    outputLen;
+    constructor(blockLen, outputLen) {
+        anumber(blockLen);
+        anumber(outputLen);
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.buffer = new Uint8Array(blockLen);
+        this.buffer32 = u32(this.buffer);
+    }
+    update(data) {
+        aexists(this);
+        abytes(data);
+        // Main difference with other hashes: there is flag for last block,
+        // so we cannot process current block before we know that there
+        // is the next one. This significantly complicates logic and reduces ability
+        // to do zero-copy processing
+        const { blockLen, buffer, buffer32 } = this;
+        const len = data.length;
+        const offset = data.byteOffset;
+        const buf = data.buffer;
+        for (let pos = 0; pos < len;) {
+            // If buffer is full and we still have input (don't process last block, same as blake2s)
+            if (this.pos === blockLen) {
+                swap32IfBE(buffer32);
+                this.compress(buffer32, 0, false);
+                swap32IfBE(buffer32);
+                this.pos = 0;
+            }
+            const take = Math.min(blockLen - this.pos, len - pos);
+            const dataOffset = offset + pos;
+            // full block && aligned to 4 bytes && not last in input
+            if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+                const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+                swap32IfBE(data32);
+                for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+                    this.length += blockLen;
+                    this.compress(data32, pos32, false);
+                }
+                swap32IfBE(data32);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            this.length += take;
+            pos += take;
+        }
+        return this;
+    }
+    digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        const { pos, buffer32 } = this;
+        this.finished = true;
+        // Padding
+        clean(this.buffer.subarray(pos));
+        swap32IfBE(buffer32);
+        this.compress(buffer32, 0, true);
+        swap32IfBE(buffer32);
+        const out32 = u32(out);
+        this.get().forEach((v, i) => (out32[i] = swap8IfBE(v)));
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        const { buffer, length, finished, destroyed, outputLen, pos } = this;
+        to ||= new this.constructor({ dkLen: outputLen });
+        to.set(...this.get());
+        to.buffer.set(buffer);
+        to.destroyed = destroyed;
+        to.finished = finished;
+        to.length = length;
+        to.pos = pos;
+        // @ts-ignore
+        to.outputLen = outputLen;
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+/** Internal blake2b hash class. */
+export class _BLAKE2b extends _BLAKE2 {
+    // Same as SHA-512, but LE
+    v0l = B2B_IV[0] | 0;
+    v0h = B2B_IV[1] | 0;
+    v1l = B2B_IV[2] | 0;
+    v1h = B2B_IV[3] | 0;
+    v2l = B2B_IV[4] | 0;
+    v2h = B2B_IV[5] | 0;
+    v3l = B2B_IV[6] | 0;
+    v3h = B2B_IV[7] | 0;
+    v4l = B2B_IV[8] | 0;
+    v4h = B2B_IV[9] | 0;
+    v5l = B2B_IV[10] | 0;
+    v5h = B2B_IV[11] | 0;
+    v6l = B2B_IV[12] | 0;
+    v6h = B2B_IV[13] | 0;
+    v7l = B2B_IV[14] | 0;
+    v7h = B2B_IV[15] | 0;
+    constructor(opts = {}) {
+        const olen = opts.dkLen === undefined ? 64 : opts.dkLen;
+        super(128, olen);
+        checkBlake2Opts(olen, opts, 64, 16, 16);
+        let { key, personalization, salt } = opts;
+        let keyLength = 0;
+        if (key !== undefined) {
+            abytes(key, undefined, 'key');
+            keyLength = key.length;
+        }
+        this.v0l ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+        if (salt !== undefined) {
+            abytes(salt, undefined, 'salt');
+            const slt = u32(salt);
+            this.v4l ^= swap8IfBE(slt[0]);
+            this.v4h ^= swap8IfBE(slt[1]);
+            this.v5l ^= swap8IfBE(slt[2]);
+            this.v5h ^= swap8IfBE(slt[3]);
+        }
+        if (personalization !== undefined) {
+            abytes(personalization, undefined, 'personalization');
+            const pers = u32(personalization);
+            this.v6l ^= swap8IfBE(pers[0]);
+            this.v6h ^= swap8IfBE(pers[1]);
+            this.v7l ^= swap8IfBE(pers[2]);
+            this.v7h ^= swap8IfBE(pers[3]);
+        }
+        if (key !== undefined) {
+            // Pad to blockLen and update
+            const tmp = new Uint8Array(this.blockLen);
+            tmp.set(key);
+            this.update(tmp);
+        }
+    }
+    // prettier-ignore
+    get() {
+        let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+        return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+    }
+    // prettier-ignore
+    set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+        this.v0l = v0l | 0;
+        this.v0h = v0h | 0;
+        this.v1l = v1l | 0;
+        this.v1h = v1h | 0;
+        this.v2l = v2l | 0;
+        this.v2h = v2h | 0;
+        this.v3l = v3l | 0;
+        this.v3h = v3h | 0;
+        this.v4l = v4l | 0;
+        this.v4h = v4h | 0;
+        this.v5l = v5l | 0;
+        this.v5h = v5h | 0;
+        this.v6l = v6l | 0;
+        this.v6h = v6h | 0;
+        this.v7l = v7l | 0;
+        this.v7h = v7h | 0;
+    }
+    compress(msg, offset, isLast) {
+        this.get().forEach((v, i) => (BBUF[i] = v)); // First half from state.
+        BBUF.set(B2B_IV, 16); // Second half from IV.
+        let { h, l } = u64.fromBig(BigInt(this.length));
+        BBUF[24] = B2B_IV[8] ^ l; // Low word of the offset.
+        BBUF[25] = B2B_IV[9] ^ h; // High word.
+        // Invert all bits for last block
+        if (isLast) {
+            BBUF[28] = ~BBUF[28];
+            BBUF[29] = ~BBUF[29];
+        }
+        let j = 0;
+        const s = BSIGMA;
+        for (let i = 0; i < 12; i++) {
+            G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+            G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+            G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+            G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+            G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+            G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+            G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+            G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+            G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+            G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+            G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+            G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+            G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+            G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+            G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+            G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+        }
+        this.v0l ^= BBUF[0] ^ BBUF[16];
+        this.v0h ^= BBUF[1] ^ BBUF[17];
+        this.v1l ^= BBUF[2] ^ BBUF[18];
+        this.v1h ^= BBUF[3] ^ BBUF[19];
+        this.v2l ^= BBUF[4] ^ BBUF[20];
+        this.v2h ^= BBUF[5] ^ BBUF[21];
+        this.v3l ^= BBUF[6] ^ BBUF[22];
+        this.v3h ^= BBUF[7] ^ BBUF[23];
+        this.v4l ^= BBUF[8] ^ BBUF[24];
+        this.v4h ^= BBUF[9] ^ BBUF[25];
+        this.v5l ^= BBUF[10] ^ BBUF[26];
+        this.v5h ^= BBUF[11] ^ BBUF[27];
+        this.v6l ^= BBUF[12] ^ BBUF[28];
+        this.v6h ^= BBUF[13] ^ BBUF[29];
+        this.v7l ^= BBUF[14] ^ BBUF[30];
+        this.v7h ^= BBUF[15] ^ BBUF[31];
+        clean(BBUF);
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.buffer32);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+}
+/**
+ * Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen output length, key for MAC mode, salt, personalization
+ */
+export const blake2b = /* @__PURE__ */ createHasher((opts) => new _BLAKE2b(opts));
+/** BLAKE2-compress core method. */
+// prettier-ignore
+export function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+    let j = 0;
+    for (let i = 0; i < rounds; i++) {
+        ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+        ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+        ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+        ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+        ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+        ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+        ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+        ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+        ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+        ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+        ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+        ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+        ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+        ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+        ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+        ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
+    }
+    return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+}
+const B2S_IV = /* @__PURE__ */ SHA256_IV.slice();
+/** Internal blake2s hash class. */
+export class _BLAKE2s extends _BLAKE2 {
+    // Internal state, same as SHA-256
+    v0 = B2S_IV[0] | 0;
+    v1 = B2S_IV[1] | 0;
+    v2 = B2S_IV[2] | 0;
+    v3 = B2S_IV[3] | 0;
+    v4 = B2S_IV[4] | 0;
+    v5 = B2S_IV[5] | 0;
+    v6 = B2S_IV[6] | 0;
+    v7 = B2S_IV[7] | 0;
+    constructor(opts = {}) {
+        const olen = opts.dkLen === undefined ? 32 : opts.dkLen;
+        super(64, olen);
+        checkBlake2Opts(olen, opts, 32, 8, 8);
+        let { key, personalization, salt } = opts;
+        let keyLength = 0;
+        if (key !== undefined) {
+            abytes(key, undefined, 'key');
+            keyLength = key.length;
+        }
+        this.v0 ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+        if (salt !== undefined) {
+            abytes(salt, undefined, 'salt');
+            const slt = u32(salt);
+            this.v4 ^= swap8IfBE(slt[0]);
+            this.v5 ^= swap8IfBE(slt[1]);
+        }
+        if (personalization !== undefined) {
+            abytes(personalization, undefined, 'personalization');
+            const pers = u32(personalization);
+            this.v6 ^= swap8IfBE(pers[0]);
+            this.v7 ^= swap8IfBE(pers[1]);
+        }
+        if (key !== undefined) {
+            // Pad to blockLen and update
+            const tmp = new Uint8Array(this.blockLen);
+            tmp.set(key);
+            this.update(tmp);
+        }
+    }
+    get() {
+        const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
+        return [v0, v1, v2, v3, v4, v5, v6, v7];
+    }
+    // prettier-ignore
+    set(v0, v1, v2, v3, v4, v5, v6, v7) {
+        this.v0 = v0 | 0;
+        this.v1 = v1 | 0;
+        this.v2 = v2 | 0;
+        this.v3 = v3 | 0;
+        this.v4 = v4 | 0;
+        this.v5 = v5 | 0;
+        this.v6 = v6 | 0;
+        this.v7 = v7 | 0;
+    }
+    compress(msg, offset, isLast) {
+        const { h, l } = u64.fromBig(BigInt(this.length));
+        // prettier-ignore
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(BSIGMA, offset, msg, 10, this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7, B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l ^ B2S_IV[4], h ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]);
+        this.v0 ^= v0 ^ v8;
+        this.v1 ^= v1 ^ v9;
+        this.v2 ^= v2 ^ v10;
+        this.v3 ^= v3 ^ v11;
+        this.v4 ^= v4 ^ v12;
+        this.v5 ^= v5 ^ v13;
+        this.v6 ^= v6 ^ v14;
+        this.v7 ^= v7 ^ v15;
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.buffer32);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    }
+}
+/**
+ * Blake2s hash function. Focuses on 8-bit to 32-bit platforms. 1.5x faster than blake2b in JS.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen output length, key for MAC mode, salt, personalization
+ */
+export const blake2s = /* @__PURE__ */ createHasher((opts) => new _BLAKE2s(opts));
+//# sourceMappingURL=blake2.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake3.d.ts

@@ -0,0 +1,54 @@
+import { _BLAKE2 } from './blake2.ts';
+import { type CHashXOF, type HashXOF } from './utils.ts';
+/**
+ * Ensure to use EITHER `key` OR `context`, not both.
+ *
+ * * `key`: 32-byte MAC key.
+ * * `context`: string for KDF. must be hardcoded, globally unique, and application - specific.
+ *   A good default format for the context string is "[application] [commit timestamp] [purpose]".
+ */
+export type Blake3Opts = {
+    dkLen?: number;
+    key?: Uint8Array;
+    context?: Uint8Array;
+};
+/** Blake3 hash. Can be used as MAC and KDF. */
+export declare class _BLAKE3 extends _BLAKE2<_BLAKE3> implements HashXOF<_BLAKE3> {
+    private chunkPos;
+    private chunksDone;
+    private flags;
+    private IV;
+    private state;
+    private stack;
+    private posOut;
+    private bufferOut32;
+    private bufferOut;
+    private chunkOut;
+    private enableXOF;
+    constructor(opts?: Blake3Opts, flags?: number);
+    protected get(): [];
+    protected set(): void;
+    private b2Compress;
+    protected compress(buf: Uint32Array, bufPos?: number, isLast?: boolean): void;
+    _cloneInto(to?: _BLAKE3): _BLAKE3;
+    destroy(): void;
+    private b2CompressOut;
+    protected finish(): void;
+    private writeInto;
+    xofInto(out: Uint8Array): Uint8Array;
+    xof(bytes: number): Uint8Array;
+    digestInto(out: Uint8Array): Uint8Array;
+    digest(): Uint8Array;
+}
+/**
+ * BLAKE3 hash function. Can be used as MAC and KDF.
+ * @param msg - message that would be hashed
+ * @param opts - `dkLen` for output length, `key` for MAC mode, `context` for KDF mode
+ * @example
+ * const data = new Uint8Array(32);
+ * const hash = blake3(data);
+ * const mac = blake3(data, { key: new Uint8Array(32) });
+ * const kdf = blake3(data, { context: 'application name' });
+ */
+export declare const blake3: CHashXOF<_BLAKE3, Blake3Opts>;
+//# sourceMappingURL=blake3.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blake3.d.ts","sourceRoot":"","sources":["src/blake3.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,OAAO,EAAY,MAAM,aAAa,CAAC;AAEhD,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,OAAO,EACb,MAAM,YAAY,CAAC;AAwBpB;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,UAAU,CAAA;CAAE,CAAC;AAEpF,+CAA+C;AAC/C,qBAAa,OAAQ,SAAQ,OAAO,CAAC,OAAO,CAAE,YAAW,OAAO,CAAC,OAAO,CAAC;IACvE,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,EAAE,CAAc;IACxB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,KAAK,CAAqB;IAElC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,SAAS,CAAQ;gBAEb,IAAI,GAAE,UAAe,EAAE,KAAK,SAAI;IA4B5C,SAAS,CAAC,GAAG,IAAI,EAAE;IAGnB,SAAS,CAAC,GAAG,IAAI,IAAI;IACrB,OAAO,CAAC,UAAU;IAmBlB,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,GAAE,MAAU,EAAE,MAAM,GAAE,OAAe,GAAG,IAAI;IAiCvF,UAAU,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO;IAejC,OAAO,IAAI,IAAI;IAMf,OAAO,CAAC,aAAa;IA+BrB,SAAS,CAAC,MAAM,IAAI,IAAI;IAoBxB,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;IAIpC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAI9B,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;IAQvC,MAAM,IAAI,UAAU;CAGrB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAEhD,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/blake3.js

@@ -0,0 +1,255 @@
+/**
+ * Blake3 fast hash is Blake2 with reduced security (round count). Can also be used as MAC & KDF.
+ *
+ * It is advertised as "the fastest cryptographic hash". However, it isn't true in JS.
+ * Why is this so slow? While it must be 6x faster than blake2b, perf diff is only 20%:
+ *
+ * * There is only 30% reduction in number of rounds from blake2s
+ * * Speed-up comes from tree structure, which is parallelized using SIMD & threading.
+ *   These features are not present in JS, so we only get overhead from trees.
+ * * Parallelization only happens on 1024-byte chunks: there is no benefit for small inputs.
+ * * It is still possible to make it faster using: a) loop unrolling b) web workers c) wasm
+ * @module
+ */
+import { SHA256_IV } from "./_md.js";
+import { fromBig } from "./_u64.js";
+import { _BLAKE2, compress } from "./blake2.js";
+// prettier-ignore
+import { abytes, aexists, anumber, aoutput, clean, createHasher, swap32IfBE, u32, u8 } from "./utils.js";
+// Flag bitset
+const B3_Flags = {
+    CHUNK_START: 0b1,
+    CHUNK_END: 0b10,
+    PARENT: 0b100,
+    ROOT: 0b1000,
+    KEYED_HASH: 0b10000,
+    DERIVE_KEY_CONTEXT: 0b100000,
+    DERIVE_KEY_MATERIAL: 0b1000000,
+};
+const B3_IV = /* @__PURE__ */ SHA256_IV.slice();
+const B3_SIGMA = /* @__PURE__ */ (() => {
+    const Id = Array.from({ length: 16 }, (_, i) => i);
+    const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
+    const res = [];
+    for (let i = 0, v = Id; i < 7; i++, v = permute(v))
+        res.push(...v);
+    return Uint8Array.from(res);
+})();
+/** Blake3 hash. Can be used as MAC and KDF. */
+export class _BLAKE3 extends _BLAKE2 {
+    chunkPos = 0; // Position of current block in chunk
+    chunksDone = 0; // How many chunks we already have
+    flags = 0 | 0;
+    IV;
+    state;
+    stack = [];
+    // Output
+    posOut = 0;
+    bufferOut32 = new Uint32Array(16);
+    bufferOut;
+    chunkOut = 0; // index of output chunk
+    enableXOF = true;
+    constructor(opts = {}, flags = 0) {
+        super(64, opts.dkLen === undefined ? 32 : opts.dkLen);
+        const { key, context } = opts;
+        const hasContext = context !== undefined;
+        if (key !== undefined) {
+            if (hasContext)
+                throw new Error('Only "key" or "context" can be specified at same time');
+            abytes(key, 32, 'key');
+            const k = key.slice();
+            this.IV = u32(k);
+            swap32IfBE(this.IV);
+            this.flags = flags | B3_Flags.KEYED_HASH;
+        }
+        else if (hasContext) {
+            abytes(context, undefined, 'context');
+            const ctx = context;
+            const contextKey = new _BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT)
+                .update(ctx)
+                .digest();
+            this.IV = u32(contextKey);
+            swap32IfBE(this.IV);
+            this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
+        }
+        else {
+            this.IV = B3_IV.slice();
+            this.flags = flags;
+        }
+        this.state = this.IV.slice();
+        this.bufferOut = u8(this.bufferOut32);
+    }
+    // Unused
+    get() {
+        return [];
+    }
+    set() { }
+    b2Compress(counter, flags, buf, bufPos = 0) {
+        const { state: s, pos } = this;
+        const { h, l } = fromBig(BigInt(counter), true);
+        // prettier-ignore
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags);
+        s[0] = v0 ^ v8;
+        s[1] = v1 ^ v9;
+        s[2] = v2 ^ v10;
+        s[3] = v3 ^ v11;
+        s[4] = v4 ^ v12;
+        s[5] = v5 ^ v13;
+        s[6] = v6 ^ v14;
+        s[7] = v7 ^ v15;
+    }
+    compress(buf, bufPos = 0, isLast = false) {
+        // Compress last block
+        let flags = this.flags;
+        if (!this.chunkPos)
+            flags |= B3_Flags.CHUNK_START;
+        if (this.chunkPos === 15 || isLast)
+            flags |= B3_Flags.CHUNK_END;
+        if (!isLast)
+            this.pos = this.blockLen;
+        this.b2Compress(this.chunksDone, flags, buf, bufPos);
+        this.chunkPos += 1;
+        // If current block is last in chunk (16 blocks), then compress chunks
+        if (this.chunkPos === 16 || isLast) {
+            let chunk = this.state;
+            this.state = this.IV.slice();
+            // If not the last one, compress only when there are trailing zeros in chunk counter
+            // chunks used as binary tree where current stack is path. Zero means current leaf is finished and can be compressed.
+            // 1 (001) - leaf not finished (just push current chunk to stack)
+            // 2 (010) - leaf finished at depth=1 (merge with last elm on stack and push back)
+            // 3 (011) - last leaf not finished
+            // 4 (100) - leafs finished at depth=1 and depth=2
+            for (let last, chunks = this.chunksDone + 1; isLast || !(chunks & 1); chunks >>= 1) {
+                if (!(last = this.stack.pop()))
+                    break;
+                this.buffer32.set(last, 0);
+                this.buffer32.set(chunk, 8);
+                this.pos = this.blockLen;
+                this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
+                chunk = this.state;
+                this.state = this.IV.slice();
+            }
+            this.chunksDone++;
+            this.chunkPos = 0;
+            this.stack.push(chunk);
+        }
+        this.pos = 0;
+    }
+    _cloneInto(to) {
+        to = super._cloneInto(to);
+        const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
+        to.state.set(state.slice());
+        to.stack = stack.map((i) => Uint32Array.from(i));
+        to.IV.set(IV);
+        to.flags = flags;
+        to.chunkPos = chunkPos;
+        to.chunksDone = chunksDone;
+        to.posOut = posOut;
+        to.chunkOut = chunkOut;
+        to.enableXOF = this.enableXOF;
+        to.bufferOut32.set(this.bufferOut32);
+        return to;
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.state, this.buffer32, this.IV, this.bufferOut32);
+        clean(...this.stack);
+    }
+    // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)
+    b2CompressOut() {
+        const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
+        const { h, l } = fromBig(BigInt(this.chunkOut++));
+        swap32IfBE(buffer32);
+        // prettier-ignore
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags);
+        out32[0] = v0 ^ v8;
+        out32[1] = v1 ^ v9;
+        out32[2] = v2 ^ v10;
+        out32[3] = v3 ^ v11;
+        out32[4] = v4 ^ v12;
+        out32[5] = v5 ^ v13;
+        out32[6] = v6 ^ v14;
+        out32[7] = v7 ^ v15;
+        out32[8] = s[0] ^ v8;
+        out32[9] = s[1] ^ v9;
+        out32[10] = s[2] ^ v10;
+        out32[11] = s[3] ^ v11;
+        out32[12] = s[4] ^ v12;
+        out32[13] = s[5] ^ v13;
+        out32[14] = s[6] ^ v14;
+        out32[15] = s[7] ^ v15;
+        swap32IfBE(buffer32);
+        swap32IfBE(out32);
+        this.posOut = 0;
+    }
+    finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        // Padding
+        clean(this.buffer.subarray(this.pos));
+        // Process last chunk
+        let flags = this.flags | B3_Flags.ROOT;
+        if (this.stack.length) {
+            flags |= B3_Flags.PARENT;
+            swap32IfBE(this.buffer32);
+            this.compress(this.buffer32, 0, true);
+            swap32IfBE(this.buffer32);
+            this.chunksDone = 0;
+            this.pos = this.blockLen;
+        }
+        else {
+            flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
+        }
+        this.flags = flags;
+        this.b2CompressOut();
+    }
+    writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const { blockLen, bufferOut } = this;
+        for (let pos = 0, len = out.length; pos < len;) {
+            if (this.posOut >= blockLen)
+                this.b2CompressOut();
+            const 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;
+    }
+    xofInto(out) {
+        if (!this.enableXOF)
+            throw new Error('XOF is not possible after digest call');
+        return this.writeInto(out);
+    }
+    xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+            throw new Error('digest() was already called');
+        this.enableXOF = false;
+        this.writeInto(out);
+        this.destroy();
+        return out;
+    }
+    digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+    }
+}
+/**
+ * BLAKE3 hash function. Can be used as MAC and KDF.
+ * @param msg - message that would be hashed
+ * @param opts - `dkLen` for output length, `key` for MAC mode, `context` for KDF mode
+ * @example
+ * const data = new Uint8Array(32);
+ * const hash = blake3(data);
+ * const mac = blake3(data, { key: new Uint8Array(32) });
+ * const kdf = blake3(data, { context: 'application name' });
+ */
+export const blake3 = /* @__PURE__ */ createHasher((opts = {}) => new _BLAKE3(opts));
+//# sourceMappingURL=blake3.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/eskdf.d.ts

@@ -0,0 +1,50 @@
+/** Scrypt KDF */
+export declare function scrypt(password: string, salt: string): Uint8Array;
+/** PBKDF2-HMAC-SHA256 */
+export declare function pbkdf2(password: string, salt: string): Uint8Array;
+/**
+ * Derives main seed. Takes a lot of time. Prefer `eskdf` method instead.
+ */
+export declare function deriveMainSeed(username: string, password: string): Uint8Array;
+type AccountID = number | string;
+type OptsLength = {
+    keyLength: number;
+};
+type OptsMod = {
+    modulus: bigint;
+};
+type KeyOpts = undefined | OptsLength | OptsMod;
+/** Not using classes because constructor cannot be async */
+export interface ESKDF {
+    /**
+     * Derives a child key. Child key will not be associated with any
+     * other child key because of properties of underlying KDF.
+     *
+     * @param protocol - 3-15 character protocol name
+     * @param accountId - numeric identifier of account
+     * @param options - `keyLength: 64` or `modulus: 41920438n`
+     * @example deriveChildKey('aes', 0)
+     */
+    deriveChildKey: (protocol: string, accountId: AccountID, options?: KeyOpts) => Uint8Array;
+    /**
+     * Deletes the main seed from eskdf instance
+     */
+    expire: () => void;
+    /**
+     * Account fingerprint
+     */
+    fingerprint: string;
+}
+/**
+ * ESKDF
+ * @param username - username, email, or identifier, min: 8 characters, should have enough entropy
+ * @param password - password, min: 8 characters, should have enough entropy
+ * @example
+ * const kdf = await eskdf('example-university', 'beginning-new-example');
+ * const key = kdf.deriveChildKey('aes', 0);
+ * console.log(kdf.fingerprint);
+ * kdf.expire();
+ */
+export declare function eskdf(username: string, password: string): Promise<ESKDF>;
+export {};
+//# sourceMappingURL=eskdf.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/eskdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eskdf.d.ts","sourceRoot":"","sources":["src/eskdf.ts"],"names":[],"mappings":"AAiBA,iBAAiB;AACjB,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAEjE;AAED,yBAAyB;AACzB,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAEjE;AAiBD;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CAY7E;AAED,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAgCjC,KAAK,UAAU,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AACxC,KAAK,OAAO,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AACnC,KAAK,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;AAuChD,4DAA4D;AAC5D,MAAM,WAAW,KAAK;IACpB;;;;;;;;OAQG;IACH,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,UAAU,CAAC;IAC1F;;OAEG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAsB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAuB9E"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/eskdf.js

@@ -0,0 +1,161 @@
+/**
+ * Experimental KDF for AES.
+ * @module
+ */
+import { hkdf } from "./hkdf.js";
+import { pbkdf2 as _pbkdf2 } from "./pbkdf2.js";
+import { scrypt as _scrypt } from "./scrypt.js";
+import { sha256 } from "./sha2.js";
+import { abytes, bytesToHex, clean, createView, hexToBytes, kdfInputToBytes } from "./utils.js";
+// A tiny KDF for various applications like AES key-gen.
+// Uses HKDF in a non-standard way, so it's not "KDF-secure", only "PRF-secure".
+// Which is good enough: assume sha2-256 retained preimage resistance.
+const SCRYPT_FACTOR = 2 ** 19;
+const PBKDF2_FACTOR = 2 ** 17;
+/** Scrypt KDF */
+export function scrypt(password, salt) {
+    return _scrypt(password, salt, { N: SCRYPT_FACTOR, r: 8, p: 1, dkLen: 32 });
+}
+/** PBKDF2-HMAC-SHA256 */
+export function pbkdf2(password, salt) {
+    return _pbkdf2(sha256, password, salt, { c: PBKDF2_FACTOR, dkLen: 32 });
+}
+// Combines two 32-byte byte arrays
+function xor32(a, b) {
+    abytes(a, 32);
+    abytes(b, 32);
+    const arr = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+        arr[i] = a[i] ^ b[i];
+    }
+    return arr;
+}
+function strHasLength(str, min, max) {
+    return typeof str === 'string' && str.length >= min && str.length <= max;
+}
+/**
+ * Derives main seed. Takes a lot of time. Prefer `eskdf` method instead.
+ */
+export function deriveMainSeed(username, password) {
+    if (!strHasLength(username, 8, 255))
+        throw new Error('invalid username');
+    if (!strHasLength(password, 8, 255))
+        throw new Error('invalid password');
+    // Declared like this to throw off minifiers which auto-convert .fromCharCode(1) to actual string.
+    // String with non-ascii may be problematic in some envs
+    const codes = { _1: 1, _2: 2 };
+    const sep = { s: String.fromCharCode(codes._1), p: String.fromCharCode(codes._2) };
+    const scr = scrypt(password + sep.s, username + sep.s);
+    const pbk = pbkdf2(password + sep.p, username + sep.p);
+    const res = xor32(scr, pbk);
+    clean(scr, pbk);
+    return res;
+}
+/**
+ * Converts protocol & accountId pair to HKDF salt & info params.
+ */
+function getSaltInfo(protocol, accountId = 0) {
+    // Note that length here also repeats two lines below
+    // We do an additional length check here to reduce the scope of DoS attacks
+    if (!(strHasLength(protocol, 3, 15) && /^[a-z0-9]{3,15}$/.test(protocol))) {
+        throw new Error('invalid protocol');
+    }
+    // Allow string account ids for some protocols
+    const allowsStr = /^password\d{0,3}|ssh|tor|file$/.test(protocol);
+    let salt; // Extract salt. Default is undefined.
+    if (typeof accountId === 'string') {
+        if (!allowsStr)
+            throw new Error('accountId must be a number');
+        if (!strHasLength(accountId, 1, 255))
+            throw new Error('accountId must be string of length 1..255');
+        salt = kdfInputToBytes(accountId);
+    }
+    else if (Number.isSafeInteger(accountId)) {
+        if (accountId < 0 || accountId > Math.pow(2, 32) - 1)
+            throw new Error('invalid accountId');
+        // Convert to Big Endian Uint32
+        salt = new Uint8Array(4);
+        createView(salt).setUint32(0, accountId, false);
+    }
+    else {
+        throw new Error('accountId must be a number' + (allowsStr ? ' or string' : ''));
+    }
+    const info = kdfInputToBytes(protocol);
+    return { salt, info };
+}
+function countBytes(num) {
+    if (typeof num !== 'bigint' || num <= BigInt(128))
+        throw new Error('invalid number');
+    return Math.ceil(num.toString(2).length / 8);
+}
+/**
+ * Parses keyLength and modulus options to extract length of result key.
+ * If modulus is used, adds 64 bits to it as per FIPS 186 B.4.1 to combat modulo bias.
+ */
+function getKeyLength(options) {
+    if (!options || typeof options !== 'object')
+        return 32;
+    const hasLen = 'keyLength' in options;
+    const hasMod = 'modulus' in options;
+    if (hasLen && hasMod)
+        throw new Error('cannot combine keyLength and modulus options');
+    if (!hasLen && !hasMod)
+        throw new Error('must have either keyLength or modulus option');
+    // FIPS 186 B.4.1 requires at least 64 more bits
+    const l = hasMod ? countBytes(options.modulus) + 8 : options.keyLength;
+    if (!(typeof l === 'number' && l >= 16 && l <= 8192))
+        throw new Error('invalid keyLength');
+    return l;
+}
+/**
+ * Converts key to bigint and divides it by modulus. Big Endian.
+ * Implements FIPS 186 B.4.1, which removes 0 and modulo bias from output.
+ */
+function modReduceKey(key, modulus) {
+    const _1 = BigInt(1);
+    const num = BigInt('0x' + bytesToHex(key)); // check for ui8a, then bytesToNumber()
+    const res = (num % (modulus - _1)) + _1; // Remove 0 from output
+    if (res < _1)
+        throw new Error('expected positive number'); // Guard against bad values
+    const len = key.length - 8; // FIPS requires 64 more bits = 8 bytes
+    const hex = res.toString(16).padStart(len * 2, '0'); // numberToHex()
+    const bytes = hexToBytes(hex);
+    if (bytes.length !== len)
+        throw new Error('invalid length of result key');
+    return bytes;
+}
+/**
+ * ESKDF
+ * @param username - username, email, or identifier, min: 8 characters, should have enough entropy
+ * @param password - password, min: 8 characters, should have enough entropy
+ * @example
+ * const kdf = await eskdf('example-university', 'beginning-new-example');
+ * const key = kdf.deriveChildKey('aes', 0);
+ * console.log(kdf.fingerprint);
+ * kdf.expire();
+ */
+export async function eskdf(username, password) {
+    // We are using closure + object instead of class because
+    // we want to make `seed` non-accessible for any external function.
+    let seed = deriveMainSeed(username, password);
+    function deriveCK(protocol, accountId = 0, options) {
+        abytes(seed, 32);
+        const { salt, info } = getSaltInfo(protocol, accountId); // validate protocol & accountId
+        const keyLength = getKeyLength(options); // validate options
+        const key = hkdf(sha256, seed, salt, info, keyLength);
+        // Modulus has already been validated
+        return options && 'modulus' in options ? modReduceKey(key, options.modulus) : key;
+    }
+    function expire() {
+        if (seed)
+            seed.fill(1);
+        seed = undefined;
+    }
+    // prettier-ignore
+    const fingerprint = Array.from(deriveCK('fingerprint', 0))
+        .slice(0, 6)
+        .map((char) => char.toString(16).padStart(2, '0').toUpperCase())
+        .join(':');
+    return Object.freeze({ deriveChildKey: deriveCK, expire, fingerprint });
+}
+//# sourceMappingURL=eskdf.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/hkdf.d.ts

@@ -0,0 +1,36 @@
+import { type CHash } from './utils.ts';
+/**
+ * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
+ * Arguments position differs from spec (IKM is first one, since it is not optional)
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ */
+export declare function extract(hash: CHash, ikm: Uint8Array, salt?: Uint8Array): Uint8Array;
+/**
+ * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ */
+export declare function expand(hash: CHash, prk: Uint8Array, info?: Uint8Array, length?: number): Uint8Array;
+/**
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ * @example
+ * import { hkdf } from '@noble/hashes/hkdf';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * import { randomBytes } from '@noble/hashes/utils';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = 'application-key';
+ * const hk1 = hkdf(sha256, inputKey, salt, info, 32);
+ */
+export declare const hkdf: (hash: CHash, ikm: Uint8Array, salt: Uint8Array | undefined, info: Uint8Array | undefined, length: number) => Uint8Array;
+//# sourceMappingURL=hkdf.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/hkdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hkdf.d.ts","sourceRoot":"","sources":["src/hkdf.ts"],"names":[],"mappings":"AAMA,OAAO,EAA0B,KAAK,KAAK,EAAS,MAAM,YAAY,CAAC;AAEvE;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,CAOnF;AAKD;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,KAAK,EACX,GAAG,EAAE,UAAU,EACf,IAAI,CAAC,EAAE,UAAU,EACjB,MAAM,GAAE,MAAW,GAClB,UAAU,CA6BZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,GACf,MAAM,KAAK,EACX,KAAK,UAAU,EACf,MAAM,UAAU,GAAG,SAAS,EAC5B,MAAM,UAAU,GAAG,SAAS,EAC5B,QAAQ,MAAM,KACb,UAAkE,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/hkdf.js

@@ -0,0 +1,84 @@
+/**
+ * HKDF (RFC 5869): extract + expand in one step.
+ * See https://soatok.blog/2021/11/17/understanding-hkdf/.
+ * @module
+ */
+import { hmac } from "./hmac.js";
+import { abytes, ahash, anumber, clean } from "./utils.js";
+/**
+ * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
+ * Arguments position differs from spec (IKM is first one, since it is not optional)
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ */
+export function extract(hash, ikm, salt) {
+    ahash(hash);
+    // NOTE: some libraries treat zero-length array as 'not provided';
+    // we don't, since we have undefined as 'not provided'
+    // https://github.com/RustCrypto/KDFs/issues/15
+    if (salt === undefined)
+        salt = new Uint8Array(hash.outputLen);
+    return hmac(hash, salt, ikm);
+}
+const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0);
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+/**
+ * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ */
+export function expand(hash, prk, info, length = 32) {
+    ahash(hash);
+    anumber(length, 'length');
+    const olen = hash.outputLen;
+    if (length > 255 * olen)
+        throw new Error('Length must be <= 255*HashLen');
+    const blocks = Math.ceil(length / olen);
+    if (info === undefined)
+        info = EMPTY_BUFFER;
+    else
+        abytes(info, undefined, 'info');
+    // first L(ength) octets of T
+    const okm = new Uint8Array(blocks * olen);
+    // Re-use HMAC instance between blocks
+    const HMAC = hmac.create(hash, prk);
+    const HMACTmp = HMAC._cloneInto();
+    const T = new Uint8Array(HMAC.outputLen);
+    for (let counter = 0; counter < blocks; counter++) {
+        HKDF_COUNTER[0] = counter + 1;
+        // T(0) = empty string (zero length)
+        // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
+        HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T)
+            .update(info)
+            .update(HKDF_COUNTER)
+            .digestInto(T);
+        okm.set(T, olen * counter);
+        HMAC._cloneInto(HMACTmp);
+    }
+    HMAC.destroy();
+    HMACTmp.destroy();
+    clean(T, HKDF_COUNTER);
+    return okm.slice(0, length);
+}
+/**
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ * @example
+ * import { hkdf } from '@noble/hashes/hkdf';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * import { randomBytes } from '@noble/hashes/utils';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = 'application-key';
+ * const hk1 = hkdf(sha256, inputKey, salt, info, 32);
+ */
+export const hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
+//# sourceMappingURL=hkdf.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/hkdf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hkdf.js","sourceRoot":"","sources":["src/hkdf.ts"],"names":[],"mappings":"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"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/hmac.d.ts

@@ -0,0 +1,36 @@
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @module
+ */
+import { type CHash, type Hash } from './utils.ts';
+/** Internal class for HMAC. */
+export declare class _HMAC<T extends Hash<T>> implements Hash<_HMAC<T>> {
+    oHash: T;
+    iHash: T;
+    blockLen: number;
+    outputLen: number;
+    private finished;
+    private destroyed;
+    constructor(hash: CHash, key: Uint8Array);
+    update(buf: Uint8Array): this;
+    digestInto(out: Uint8Array): void;
+    digest(): Uint8Array;
+    _cloneInto(to?: _HMAC<T>): _HMAC<T>;
+    clone(): _HMAC<T>;
+    destroy(): void;
+}
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - message key
+ * @param message - message data
+ * @example
+ * import { hmac } from '@noble/hashes/hmac';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * const mac1 = hmac(sha256, 'key', 'message');
+ */
+export declare const hmac: {
+    (hash: CHash, key: Uint8Array, message: Uint8Array): Uint8Array;
+    create(hash: CHash, key: Uint8Array): _HMAC<any>;
+};
+//# sourceMappingURL=hmac.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/hmac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["src/hmac.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAiC,KAAK,KAAK,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAElF,+BAA+B;AAC/B,qBAAa,KAAK,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,CAAC,CAAE,YAAW,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC7D,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;gBAEd,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU;IAqBxC,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IAK7B,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IASjC,MAAM,IAAI,UAAU;IAKpB,UAAU,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAanC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC;IAGjB,OAAO,IAAI,IAAI;CAKhB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,GAAG,UAAU,CAAC;IAChE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;CAEC,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/hmac.js

@@ -0,0 +1,90 @@
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @module
+ */
+import { abytes, aexists, ahash, clean } from "./utils.js";
+/** Internal class for HMAC. */
+export class _HMAC {
+    oHash;
+    iHash;
+    blockLen;
+    outputLen;
+    finished = false;
+    destroyed = false;
+    constructor(hash, key) {
+        ahash(hash);
+        abytes(key, undefined, '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;
+        const blockLen = this.blockLen;
+        const pad = new Uint8Array(blockLen);
+        // blockLen can be bigger than outputLen
+        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+        for (let 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 (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36 ^ 0x5c;
+        this.oHash.update(pad);
+        clean(pad);
+    }
+    update(buf) {
+        aexists(this);
+        this.iHash.update(buf);
+        return this;
+    }
+    digestInto(out) {
+        aexists(this);
+        abytes(out, this.outputLen, 'output');
+        this.finished = true;
+        this.iHash.digestInto(out);
+        this.oHash.update(out);
+        this.oHash.digestInto(out);
+        this.destroy();
+    }
+    digest() {
+        const out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+    }
+    _cloneInto(to) {
+        // Create new instance without calling constructor since key already in state and we don't know it.
+        to ||= Object.create(Object.getPrototypeOf(this), {});
+        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+        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;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+    destroy() {
+        this.destroyed = true;
+        this.oHash.destroy();
+        this.iHash.destroy();
+    }
+}
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - message key
+ * @param message - message data
+ * @example
+ * import { hmac } from '@noble/hashes/hmac';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * const mac1 = hmac(sha256, 'key', 'message');
+ */
+export const hmac = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new _HMAC(hash, key);
+//# sourceMappingURL=hmac.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/hmac.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.js","sourceRoot":"","sources":["src/hmac.ts"],"names":[],"mappings":"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"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":""}

control-plane-ui/tests/integration/node_modules/@noble/hashes/index.js

@@ -0,0 +1,34 @@
+/**
+ * Audited & minimal JS implementation of hash functions, MACs and KDFs. Check out individual modules.
+ * @module
+ * @example
+```js
+import {
+  sha256, sha384, sha512, sha224, sha512_224, sha512_256
+} from '@noble/hashes/sha2.js';
+import {
+  sha3_224, sha3_256, sha3_384, sha3_512,
+  keccak_224, keccak_256, keccak_384, keccak_512,
+  shake128, shake256
+} from '@noble/hashes/sha3.js';
+import {
+  cshake128, cshake256,
+  turboshake128, turboshake256,
+  kt128, kt256,
+  kmac128, kmac256,
+  tuplehash256, parallelhash256,
+  keccakprg
+} from '@noble/hashes/sha3-addons.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { blake2b, blake2s } from '@noble/hashes/blake2.js';
+import { hmac } from '@noble/hashes/hmac.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2.js';
+import { scrypt, scryptAsync } from '@noble/hashes/scrypt.js';
+import { md5, ripemd160, sha1 } from '@noble/hashes/legacy.js';
+import * as utils from '@noble/hashes/utils.js';
+```
+ */
+throw new Error('root module cannot be imported: import submodules instead. Check out README');
+export {};
+//# sourceMappingURL=index.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/legacy.d.ts

@@ -0,0 +1,71 @@
+/**
+
+SHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.
+Don't use them in a new protocol. What "weak" means:
+
+- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
+- No practical pre-image attacks (only theoretical, 2^123.4)
+- HMAC seems kinda ok: https://www.rfc-editor.org/rfc/rfc6151
+ * @module
+ */
+import { HashMD } from './_md.ts';
+import { type CHash } from './utils.ts';
+/** Internal SHA1 legacy hash class. */
+export declare class _SHA1 extends HashMD<_SHA1> {
+    private A;
+    private B;
+    private C;
+    private D;
+    private E;
+    constructor();
+    protected get(): [number, number, number, number, number];
+    protected set(A: number, B: number, C: number, D: number, E: number): void;
+    protected process(view: DataView, offset: number): void;
+    protected roundClean(): void;
+    destroy(): void;
+}
+/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+export declare const sha1: CHash;
+/** Internal MD5 legacy hash class. */
+export declare class _MD5 extends HashMD<_MD5> {
+    private A;
+    private B;
+    private C;
+    private D;
+    constructor();
+    protected get(): [number, number, number, number];
+    protected set(A: number, B: number, C: number, D: number): void;
+    protected process(view: DataView, offset: number): void;
+    protected roundClean(): void;
+    destroy(): void;
+}
+/**
+ * MD5 (RFC 1321) legacy hash function. It was cryptographically broken.
+ * MD5 architecture is similar to SHA1, with some differences:
+ * - Reduced output length: 16 bytes (128 bit) instead of 20
+ * - 64 rounds, instead of 80
+ * - Little-endian: could be faster, but will require more code
+ * - Non-linear index selection: huge speed-up for unroll
+ * - Per round constants: more memory accesses, additional speed-up for unroll
+ */
+export declare const md5: CHash;
+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;
+}
+/**
+ * RIPEMD-160 - a legacy hash function from 1990s.
+ * * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+ * * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
+ */
+export declare const ripemd160: CHash;
+//# sourceMappingURL=legacy.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/legacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy.d.ts","sourceRoot":"","sources":["src/legacy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAO,MAAM,EAAO,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,KAAK,KAAK,EAA6B,MAAM,YAAY,CAAC;AAUnE,uCAAuC;AACvC,qBAAa,KAAM,SAAQ,MAAM,CAAC,KAAK,CAAC;IACtC,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;IAC3B,OAAO,CAAC,CAAC,CAAkB;;IAK3B,SAAS,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAIzD,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAO1E,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAoCvD,SAAS,CAAC,UAAU,IAAI,IAAI;IAG5B,OAAO,IAAI,IAAI;CAIhB;AAED,6EAA6E;AAC7E,eAAO,MAAM,IAAI,EAAE,KAAuD,CAAC;AAa3E,sCAAsC;AACtC,qBAAa,IAAK,SAAQ,MAAM,CAAC,IAAI,CAAC;IACpC,OAAO,CAAC,CAAC,CAAiB;IAC1B,OAAO,CAAC,CAAC,CAAiB;IAC1B,OAAO,CAAC,CAAC,CAAiB;IAC1B,OAAO,CAAC,CAAC,CAAiB;;IAK1B,SAAS,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAIjD,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAM/D,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAoCvD,SAAS,CAAC,UAAU,IAAI,IAAI;IAG5B,OAAO,IAAI,IAAI;CAIhB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG,EAAE,KAAsD,CAAC;AA6CzE,qBAAa,UAAW,SAAQ,MAAM,CAAC,UAAU,CAAC;IAChD,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,EAAE,CAAkB;IAC5B,OAAO,CAAC,EAAE,CAAkB;;IAK5B,SAAS,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAIzD,SAAS,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAO/E,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAmCvD,SAAS,CAAC,UAAU,IAAI,IAAI;IAG5B,OAAO,IAAI,IAAI;CAKhB;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,KAA4D,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/legacy.js

@@ -0,0 +1,281 @@
+/**
+
+SHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.
+Don't use them in a new protocol. What "weak" means:
+
+- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
+- No practical pre-image attacks (only theoretical, 2^123.4)
+- HMAC seems kinda ok: https://www.rfc-editor.org/rfc/rfc6151
+ * @module
+ */
+import { Chi, HashMD, Maj } from "./_md.js";
+import { clean, createHasher, rotl } from "./utils.js";
+/** Initial SHA1 state */
+const SHA1_IV = /* @__PURE__ */ Uint32Array.from([
+    0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0,
+]);
+// Reusable temporary buffer
+const SHA1_W = /* @__PURE__ */ new Uint32Array(80);
+/** Internal SHA1 legacy hash class. */
+export class _SHA1 extends HashMD {
+    A = SHA1_IV[0] | 0;
+    B = SHA1_IV[1] | 0;
+    C = SHA1_IV[2] | 0;
+    D = SHA1_IV[3] | 0;
+    E = SHA1_IV[4] | 0;
+    constructor() {
+        super(64, 20, 8, false);
+    }
+    get() {
+        const { A, B, C, D, E } = this;
+        return [A, B, C, D, E];
+    }
+    set(A, B, C, D, E) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+        this.E = E | 0;
+    }
+    process(view, offset) {
+        for (let i = 0; i < 16; i++, offset += 4)
+            SHA1_W[i] = view.getUint32(offset, false);
+        for (let i = 16; i < 80; i++)
+            SHA1_W[i] = rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);
+        // Compression function main loop, 80 rounds
+        let { A, B, C, D, E } = this;
+        for (let i = 0; i < 80; i++) {
+            let F, K;
+            if (i < 20) {
+                F = Chi(B, C, D);
+                K = 0x5a827999;
+            }
+            else if (i < 40) {
+                F = B ^ C ^ D;
+                K = 0x6ed9eba1;
+            }
+            else if (i < 60) {
+                F = Maj(B, C, D);
+                K = 0x8f1bbcdc;
+            }
+            else {
+                F = B ^ C ^ D;
+                K = 0xca62c1d6;
+            }
+            const T = (rotl(A, 5) + F + E + K + SHA1_W[i]) | 0;
+            E = D;
+            D = C;
+            C = rotl(B, 30);
+            B = A;
+            A = T;
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        E = (E + this.E) | 0;
+        this.set(A, B, C, D, E);
+    }
+    roundClean() {
+        clean(SHA1_W);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0);
+        clean(this.buffer);
+    }
+}
+/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+export const sha1 = /* @__PURE__ */ createHasher(() => new _SHA1());
+/** Per-round constants */
+const p32 = /* @__PURE__ */ Math.pow(2, 32);
+const K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));
+/** md5 initial state: same as sha1, but 4 u32 instead of 5. */
+const MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);
+// Reusable temporary buffer
+const MD5_W = /* @__PURE__ */ new Uint32Array(16);
+/** Internal MD5 legacy hash class. */
+export class _MD5 extends HashMD {
+    A = MD5_IV[0] | 0;
+    B = MD5_IV[1] | 0;
+    C = MD5_IV[2] | 0;
+    D = MD5_IV[3] | 0;
+    constructor() {
+        super(64, 16, 8, true);
+    }
+    get() {
+        const { A, B, C, D } = this;
+        return [A, B, C, D];
+    }
+    set(A, B, C, D) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+    }
+    process(view, offset) {
+        for (let i = 0; i < 16; i++, offset += 4)
+            MD5_W[i] = view.getUint32(offset, true);
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D } = this;
+        for (let i = 0; i < 64; i++) {
+            let F, g, s;
+            if (i < 16) {
+                F = Chi(B, C, D);
+                g = i;
+                s = [7, 12, 17, 22];
+            }
+            else if (i < 32) {
+                F = Chi(D, B, C);
+                g = (5 * i + 1) % 16;
+                s = [5, 9, 14, 20];
+            }
+            else if (i < 48) {
+                F = B ^ C ^ D;
+                g = (3 * i + 5) % 16;
+                s = [4, 11, 16, 23];
+            }
+            else {
+                F = C ^ (B | ~D);
+                g = (7 * i) % 16;
+                s = [6, 10, 15, 21];
+            }
+            F = F + A + K[i] + MD5_W[g];
+            A = D;
+            D = C;
+            C = B;
+            B = B + rotl(F, s[i % 4]);
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        this.set(A, B, C, D);
+    }
+    roundClean() {
+        clean(MD5_W);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0);
+        clean(this.buffer);
+    }
+}
+/**
+ * MD5 (RFC 1321) legacy hash function. It was cryptographically broken.
+ * MD5 architecture is similar to SHA1, with some differences:
+ * - Reduced output length: 16 bytes (128 bit) instead of 20
+ * - 64 rounds, instead of 80
+ * - Little-endian: could be faster, but will require more code
+ * - Non-linear index selection: huge speed-up for unroll
+ * - Per round constants: more memory accesses, additional speed-up for unroll
+ */
+export const md5 = /* @__PURE__ */ createHasher(() => new _MD5());
+// RIPEMD-160
+const Rho160 = /* @__PURE__ */ Uint8Array.from([
+    7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+]);
+const Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
+const Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();
+const idxLR = /* @__PURE__ */ (() => {
+    const L = [Id160];
+    const R = [Pi160];
+    const res = [L, R];
+    for (let i = 0; i < 4; i++)
+        for (let j of res)
+            j.push(j[i].map((k) => Rho160[k]));
+    return res;
+})();
+const idxL = /* @__PURE__ */ (() => idxLR[0])();
+const idxR = /* @__PURE__ */ (() => idxLR[1])();
+// const [idxL, idxR] = idxLR;
+const shifts160 = /* @__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((i) => Uint8Array.from(i));
+const shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));
+const shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));
+const Kl160 = /* @__PURE__ */ Uint32Array.from([
+    0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,
+]);
+const Kr160 = /* @__PURE__ */ Uint32Array.from([
+    0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,
+]);
+// It's called f() in spec.
+function ripemd_f(group, x, y, z) {
+    if (group === 0)
+        return x ^ y ^ z;
+    if (group === 1)
+        return (x & y) | (~x & z);
+    if (group === 2)
+        return (x | ~y) ^ z;
+    if (group === 3)
+        return (x & z) | (y & ~z);
+    return x ^ (y | ~z);
+}
+// Reusable temporary buffer
+const BUF_160 = /* @__PURE__ */ new Uint32Array(16);
+export class _RIPEMD160 extends HashMD {
+    h0 = 0x67452301 | 0;
+    h1 = 0xefcdab89 | 0;
+    h2 = 0x98badcfe | 0;
+    h3 = 0x10325476 | 0;
+    h4 = 0xc3d2e1f0 | 0;
+    constructor() {
+        super(64, 20, 8, true);
+    }
+    get() {
+        const { h0, h1, h2, h3, h4 } = this;
+        return [h0, h1, h2, h3, h4];
+    }
+    set(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;
+    }
+    process(view, offset) {
+        for (let i = 0; i < 16; i++, offset += 4)
+            BUF_160[i] = view.getUint32(offset, true);
+        // prettier-ignore
+        let 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 (let group = 0; group < 5; group++) {
+            const rGroup = 4 - group;
+            const hbl = Kl160[group], hbr = Kr160[group]; // prettier-ignore
+            const rl = idxL[group], rr = idxR[group]; // prettier-ignore
+            const sl = shiftsL160[group], sr = shiftsR160[group]; // prettier-ignore
+            for (let i = 0; i < 16; i++) {
+                const tl = (rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el) | 0;
+                al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
+            }
+            // 2 loops are 10% faster
+            for (let i = 0; i < 16; i++) {
+                const tr = (rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er) | 0;
+                ar = er, er = dr, dr = 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);
+    }
+    roundClean() {
+        clean(BUF_160);
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.buffer);
+        this.set(0, 0, 0, 0, 0);
+    }
+}
+/**
+ * RIPEMD-160 - a legacy hash function from 1990s.
+ * * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+ * * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
+ */
+export const ripemd160 = /* @__PURE__ */ createHasher(() => new _RIPEMD160());
+//# sourceMappingURL=legacy.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@noble/hashes",
+  "version": "2.0.1",
+  "description": "Audited & minimal 0-dependency JS implementation of SHA, RIPEMD, BLAKE, HMAC, HKDF, PBKDF & Scrypt",
+  "files": [
+    "*.js",
+    "*.js.map",
+    "*.d.ts",
+    "*.d.ts.map",
+    "src"
+  ],
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.4.4",
+    "@types/node": "24.2.1",
+    "fast-check": "4.2.0",
+    "prettier": "3.6.2",
+    "typescript": "5.9.2"
+  },
+  "scripts": {
+    "bench": "node test/benchmark/noble.ts",
+    "bench:compare": "MBENCH_DIMS='algorithm,buffer,library' node test/benchmark/hashes.ts",
+    "bench:compare-scrypt": "MBENCH_DIMS='iters,library' MBENCH_FILTER='async' node test/benchmark/scrypt.ts",
+    "bench:install": "cd test/benchmark; npm install",
+    "build": "tsc",
+    "build:release": "npx --no @paulmillr/jsbt esbuild test/build",
+    "build:clean": "rm *.{js,js.map,d.ts,d.ts.map} 2> /dev/null",
+    "format": "prettier --write 'src/**/*.{js,ts}' 'test/**/*.{js,ts}'",
+    "test": "node --experimental-strip-types --no-warnings test/index.ts",
+    "test:bun": "bun test/index.ts",
+    "test:deno": "deno --allow-env --allow-read test/index.ts",
+    "test:node20": "cd test; npx tsc; node compiled/test/index.js",
+    "test:dos": "node --experimental-strip-types test/slow-dos.test.ts",
+    "test:big": "node --experimental-strip-types test/slow-big.test.ts",
+    "test:acvp": "node --experimental-strip-types test/slow-acvp.test.ts",
+    "test:kdf": "node --experimental-strip-types test/slow-kdf.test.ts"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./_md.js": "./_md.js",
+    "./argon2.js": "./argon2.js",
+    "./blake1.js": "./blake1.js",
+    "./blake2.js": "./blake2.js",
+    "./blake3.js": "./blake3.js",
+    "./eskdf.js": "./eskdf.js",
+    "./hkdf.js": "./hkdf.js",
+    "./hmac.js": "./hmac.js",
+    "./legacy.js": "./legacy.js",
+    "./pbkdf2.js": "./pbkdf2.js",
+    "./scrypt.js": "./scrypt.js",
+    "./sha2.js": "./sha2.js",
+    "./sha3-addons.js": "./sha3-addons.js",
+    "./sha3.js": "./sha3.js",
+    "./webcrypto.js": "./webcrypto.js",
+    "./utils.js": "./utils.js"
+  },
+  "engines": {
+    "node": ">= 20.19.0"
+  },
+  "keywords": [
+    "sha1",
+    "sha2",
+    "sha3",
+    "blake",
+    "blake2",
+    "blake3",
+    "hmac",
+    "hkdf",
+    "pbkdf2",
+    "scrypt",
+    "sha256",
+    "sha512",
+    "keccak",
+    "ripemd160",
+    "kdf",
+    "hash",
+    "cryptography",
+    "security",
+    "noble"
+  ],
+  "homepage": "https://paulmillr.com/noble/",
+  "funding": "https://paulmillr.com/funding/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paulmillr/noble-hashes.git"
+  },
+  "type": "module",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "author": "Paul Miller (https://paulmillr.com)",
+  "license": "MIT"
+}

control-plane-ui/tests/integration/node_modules/@noble/hashes/pbkdf2.d.ts

@@ -0,0 +1,29 @@
+import { type CHash, type KDFInput } from './utils.ts';
+/**
+ * PBKDF2 options:
+ * * c: iterations, should probably be higher than 100_000
+ * * dkLen: desired length of derived key in bytes
+ * * asyncTick: max time in ms for which async function can block execution
+ */
+export type Pbkdf2Opt = {
+    c: number;
+    dkLen?: number;
+    asyncTick?: number;
+};
+/**
+ * PBKDF2-HMAC: RFC 2898 key derivation function
+ * @param hash - hash function that would be used e.g. sha256
+ * @param password - password from which a derived key is generated
+ * @param salt - cryptographic salt
+ * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
+ * @example
+ * const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ */
+export declare function pbkdf2(hash: CHash, password: KDFInput, salt: KDFInput, opts: Pbkdf2Opt): Uint8Array;
+/**
+ * PBKDF2-HMAC: RFC 2898 key derivation function. Async version.
+ * @example
+ * await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });
+ */
+export declare function pbkdf2Async(hash: CHash, password: KDFInput, salt: KDFInput, opts: Pbkdf2Opt): Promise<Uint8Array>;
+//# sourceMappingURL=pbkdf2.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/pbkdf2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.d.ts","sourceRoot":"","sources":["src/pbkdf2.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,KAAK,EAEV,KAAK,QAAQ,EACd,MAAM,YAAY,CAAC;AAEpB;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAkCF;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,SAAS,GACd,UAAU,CAsBZ;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,UAAU,CAAC,CAsBrB"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/pbkdf2.js

@@ -0,0 +1,97 @@
+/**
+ * PBKDF (RFC 2898). Can be used to create a key from password and salt.
+ * @module
+ */
+import { hmac } from "./hmac.js";
+// prettier-ignore
+import { ahash, anumber, asyncLoop, checkOpts, clean, createView, kdfInputToBytes } from "./utils.js";
+// Common start and end for sync/async functions
+function pbkdf2Init(hash, _password, _salt, _opts) {
+    ahash(hash);
+    const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+    const { c, dkLen, asyncTick } = opts;
+    anumber(c, 'c');
+    anumber(dkLen, 'dkLen');
+    anumber(asyncTick, 'asyncTick');
+    if (c < 1)
+        throw new Error('iterations (c) must be >= 1');
+    const password = kdfInputToBytes(_password, 'password');
+    const salt = kdfInputToBytes(_salt, 'salt');
+    // DK = PBKDF2(PRF, Password, Salt, c, dkLen);
+    const DK = new Uint8Array(dkLen);
+    // U1 = PRF(Password, Salt + INT_32_BE(i))
+    const PRF = hmac.create(hash, password);
+    const PRFSalt = PRF._cloneInto().update(salt);
+    return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+    PRF.destroy();
+    PRFSalt.destroy();
+    if (prfW)
+        prfW.destroy();
+    clean(u);
+    return DK;
+}
+/**
+ * PBKDF2-HMAC: RFC 2898 key derivation function
+ * @param hash - hash function that would be used e.g. sha256
+ * @param password - password from which a derived key is generated
+ * @param salt - cryptographic salt
+ * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
+ * @example
+ * const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ */
+export function pbkdf2(hash, password, salt, opts) {
+    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+    let prfW; // Working copy
+    const arr = new Uint8Array(4);
+    const view = createView(arr);
+    const u = new Uint8Array(PRF.outputLen);
+    // DK = T1 + T2 + ⋯ + Tdklen/hlen
+    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+        // Ti = F(Password, Salt, c, i)
+        const Ti = DK.subarray(pos, pos + PRF.outputLen);
+        view.setInt32(0, ti, false);
+        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
+        // U1 = PRF(Password, Salt + INT_32_BE(i))
+        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+        Ti.set(u.subarray(0, Ti.length));
+        for (let ui = 1; ui < c; ui++) {
+            // Uc = PRF(Password, Uc−1)
+            PRF._cloneInto(prfW).update(u).digestInto(u);
+            for (let i = 0; i < Ti.length; i++)
+                Ti[i] ^= u[i];
+        }
+    }
+    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+/**
+ * PBKDF2-HMAC: RFC 2898 key derivation function. Async version.
+ * @example
+ * await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });
+ */
+export async function pbkdf2Async(hash, password, salt, opts) {
+    const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+    let prfW; // Working copy
+    const arr = new Uint8Array(4);
+    const view = createView(arr);
+    const u = new Uint8Array(PRF.outputLen);
+    // DK = T1 + T2 + ⋯ + Tdklen/hlen
+    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+        // Ti = F(Password, Salt, c, i)
+        const Ti = DK.subarray(pos, pos + PRF.outputLen);
+        view.setInt32(0, ti, false);
+        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
+        // U1 = PRF(Password, Salt + INT_32_BE(i))
+        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+        Ti.set(u.subarray(0, Ti.length));
+        await asyncLoop(c - 1, asyncTick, () => {
+            // Uc = PRF(Password, Uc−1)
+            PRF._cloneInto(prfW).update(u).digestInto(u);
+            for (let i = 0; i < Ti.length; i++)
+                Ti[i] ^= u[i];
+        });
+    }
+    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+//# sourceMappingURL=pbkdf2.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/pbkdf2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.js","sourceRoot":"","sources":["src/pbkdf2.ts"],"names":[],"mappings":"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"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/scrypt.d.ts

@@ -0,0 +1,33 @@
+import { type KDFInput } from './utils.ts';
+/**
+ * Scrypt options:
+ * - `N` is cpu/mem work factor (power of 2 e.g. `2**18`)
+ * - `r` is block size (8 is common), fine-tunes sequential memory read size and performance
+ * - `p` is parallelization factor (1 is common)
+ * - `dkLen` is output key length in bytes e.g. 32.
+ * - `asyncTick` - (default: 10) max time in ms for which async function can block execution
+ * - `maxmem` - (default: `1024 ** 3 + 1024` aka 1GB+1KB). A limit that the app could use for scrypt
+ * - `onProgress` - callback function that would be executed for progress report
+ */
+export type ScryptOpts = {
+    N: number;
+    r: number;
+    p: number;
+    dkLen?: number;
+    asyncTick?: number;
+    maxmem?: number;
+    onProgress?: (progress: number) => void;
+};
+/**
+ * Scrypt KDF from RFC 7914. See {@link ScryptOpts}.
+ * @example
+ * scrypt('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });
+ */
+export declare function scrypt(password: KDFInput, salt: KDFInput, opts: ScryptOpts): Uint8Array;
+/**
+ * Scrypt KDF from RFC 7914. Async version. See {@link ScryptOpts}.
+ * @example
+ * await scryptAsync('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });
+ */
+export declare function scryptAsync(password: KDFInput, salt: KDFInput, opts: ScryptOpts): Promise<Uint8Array>;
+//# sourceMappingURL=scrypt.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/scrypt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrypt.d.ts","sourceRoot":"","sources":["src/scrypt.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,QAAQ,EAGd,MAAM,YAAY,CAAC;AAuEpB;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC,CAAC;AA2EF;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CA2BvF;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CA4BrB"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/scrypt.js

@@ -0,0 +1,216 @@
+/**
+ * RFC 7914 Scrypt KDF. Can be used to create a key from password and salt.
+ * @module
+ */
+import { pbkdf2 } from "./pbkdf2.js";
+import { sha256 } from "./sha2.js";
+// prettier-ignore
+import { anumber, asyncLoop, checkOpts, clean, rotl, swap32IfBE, u32 } from "./utils.js";
+// The main Scrypt loop: uses Salsa extensively.
+// Six versions of the function were tried, this is the fastest one.
+// prettier-ignore
+function XorAndSalsa(prev, pi, input, ii, out, oi) {
+    // Based on https://cr.yp.to/salsa20.html
+    // Xor blocks
+    let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
+    let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
+    let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
+    let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
+    let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
+    let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
+    let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
+    let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
+    // Save state to temporary variables (salsa)
+    let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+    // Main loop (salsa)
+    for (let i = 0; i < 8; i += 2) {
+        x04 ^= rotl(x00 + x12 | 0, 7);
+        x08 ^= rotl(x04 + x00 | 0, 9);
+        x12 ^= rotl(x08 + x04 | 0, 13);
+        x00 ^= rotl(x12 + x08 | 0, 18);
+        x09 ^= rotl(x05 + x01 | 0, 7);
+        x13 ^= rotl(x09 + x05 | 0, 9);
+        x01 ^= rotl(x13 + x09 | 0, 13);
+        x05 ^= rotl(x01 + x13 | 0, 18);
+        x14 ^= rotl(x10 + x06 | 0, 7);
+        x02 ^= rotl(x14 + x10 | 0, 9);
+        x06 ^= rotl(x02 + x14 | 0, 13);
+        x10 ^= rotl(x06 + x02 | 0, 18);
+        x03 ^= rotl(x15 + x11 | 0, 7);
+        x07 ^= rotl(x03 + x15 | 0, 9);
+        x11 ^= rotl(x07 + x03 | 0, 13);
+        x15 ^= rotl(x11 + x07 | 0, 18);
+        x01 ^= rotl(x00 + x03 | 0, 7);
+        x02 ^= rotl(x01 + x00 | 0, 9);
+        x03 ^= rotl(x02 + x01 | 0, 13);
+        x00 ^= rotl(x03 + x02 | 0, 18);
+        x06 ^= rotl(x05 + x04 | 0, 7);
+        x07 ^= rotl(x06 + x05 | 0, 9);
+        x04 ^= rotl(x07 + x06 | 0, 13);
+        x05 ^= rotl(x04 + x07 | 0, 18);
+        x11 ^= rotl(x10 + x09 | 0, 7);
+        x08 ^= rotl(x11 + x10 | 0, 9);
+        x09 ^= rotl(x08 + x11 | 0, 13);
+        x10 ^= rotl(x09 + x08 | 0, 18);
+        x12 ^= rotl(x15 + x14 | 0, 7);
+        x13 ^= rotl(x12 + x15 | 0, 9);
+        x14 ^= rotl(x13 + x12 | 0, 13);
+        x15 ^= rotl(x14 + x13 | 0, 18);
+    }
+    // Write output (salsa)
+    out[oi++] = (y00 + x00) | 0;
+    out[oi++] = (y01 + x01) | 0;
+    out[oi++] = (y02 + x02) | 0;
+    out[oi++] = (y03 + x03) | 0;
+    out[oi++] = (y04 + x04) | 0;
+    out[oi++] = (y05 + x05) | 0;
+    out[oi++] = (y06 + x06) | 0;
+    out[oi++] = (y07 + x07) | 0;
+    out[oi++] = (y08 + x08) | 0;
+    out[oi++] = (y09 + x09) | 0;
+    out[oi++] = (y10 + x10) | 0;
+    out[oi++] = (y11 + x11) | 0;
+    out[oi++] = (y12 + x12) | 0;
+    out[oi++] = (y13 + x13) | 0;
+    out[oi++] = (y14 + x14) | 0;
+    out[oi++] = (y15 + x15) | 0;
+}
+function BlockMix(input, ii, out, oi, r) {
+    // The block B is r 128-byte chunks (which is equivalent of 2r 64-byte chunks)
+    let head = oi + 0;
+    let tail = oi + 16 * r;
+    for (let i = 0; i < 16; i++)
+        out[tail + i] = input[ii + (2 * r - 1) * 16 + i]; // X ← B[2r−1]
+    for (let i = 0; i < r; i++, head += 16, ii += 16) {
+        // We write odd & even Yi at same time. Even: 0bXXXXX0 Odd:  0bXXXXX1
+        XorAndSalsa(out, tail, input, ii, out, head); // head[i] = Salsa(blockIn[2*i] ^ tail[i-1])
+        if (i > 0)
+            tail += 16; // First iteration overwrites tmp value in tail
+        XorAndSalsa(out, head, input, (ii += 16), out, tail); // tail[i] = Salsa(blockIn[2*i+1] ^ head[i])
+    }
+}
+// Common prologue and epilogue for sync/async functions
+function scryptInit(password, salt, _opts) {
+    // Maxmem - 1GB+1KB by default
+    const opts = checkOpts({
+        dkLen: 32,
+        asyncTick: 10,
+        maxmem: 1024 ** 3 + 1024,
+    }, _opts);
+    const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;
+    anumber(N, 'N');
+    anumber(r, 'r');
+    anumber(p, 'p');
+    anumber(dkLen, 'dkLen');
+    anumber(asyncTick, 'asyncTick');
+    anumber(maxmem, 'maxmem');
+    if (onProgress !== undefined && typeof onProgress !== 'function')
+        throw new Error('progressCb must be a function');
+    const blockSize = 128 * r;
+    const blockSize32 = blockSize / 4;
+    // Max N is 2^32 (Integrify is 32-bit).
+    // Real limit can be 2^22: some JS engines limit Uint8Array to 4GB.
+    // Spec check `N >= 2^(blockSize / 8)` is not done for compat with popular libs,
+    // which used incorrect r: 1, p: 8. Also, the check seems to be a spec error:
+    // https://www.rfc-editor.org/errata_search.php?rfc=7914
+    const pow32 = Math.pow(2, 32);
+    if (N <= 1 || (N & (N - 1)) !== 0 || N > pow32)
+        throw new Error('"N" expected a power of 2, and 2^1 <= N <= 2^32');
+    if (p < 1 || p > ((pow32 - 1) * 32) / blockSize)
+        throw new Error('"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)');
+    if (dkLen < 1 || dkLen > (pow32 - 1) * 32)
+        throw new Error('"dkLen" expected integer 1..(2^32 - 1) * 32');
+    const memUsed = blockSize * (N + p);
+    if (memUsed > maxmem)
+        throw new Error('"maxmem" limit was hit, expected 128*r*(N+p) <= "maxmem"=' + maxmem);
+    // [B0...Bp−1] ← PBKDF2HMAC-SHA256(Passphrase, Salt, 1, blockSize*ParallelizationFactor)
+    // Since it has only one iteration there is no reason to use async variant
+    const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });
+    const B32 = u32(B);
+    // Re-used between parallel iterations. Array(iterations) of B
+    const V = u32(new Uint8Array(blockSize * N));
+    const tmp = u32(new Uint8Array(blockSize));
+    let blockMixCb = () => { };
+    if (onProgress) {
+        const totalBlockMix = 2 * N * p;
+        // Invoke callback if progress changes from 10.01 to 10.02
+        // Allows to draw smooth progress bar on up to 8K screen
+        const callbackPer = Math.max(Math.floor(totalBlockMix / 10000), 1);
+        let blockMixCnt = 0;
+        blockMixCb = () => {
+            blockMixCnt++;
+            if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))
+                onProgress(blockMixCnt / totalBlockMix);
+        };
+    }
+    return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };
+}
+function scryptOutput(password, dkLen, B, V, tmp) {
+    const res = pbkdf2(sha256, password, B, { c: 1, dkLen });
+    clean(B, V, tmp);
+    return res;
+}
+/**
+ * Scrypt KDF from RFC 7914. See {@link ScryptOpts}.
+ * @example
+ * scrypt('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });
+ */
+export function scrypt(password, salt, opts) {
+    const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
+    swap32IfBE(B32);
+    for (let pi = 0; pi < p; pi++) {
+        const Pi = blockSize32 * pi;
+        for (let i = 0; i < blockSize32; i++)
+            V[i] = B32[Pi + i]; // V[0] = B[i]
+        for (let i = 0, pos = 0; i < N - 1; i++) {
+            BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);
+            blockMixCb();
+        }
+        BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element
+        blockMixCb();
+        for (let i = 0; i < N; i++) {
+            // First u32 of the last 64-byte block (u32 is LE)
+            // & (N - 1) is % N as N is a power of 2, N & (N - 1) = 0 is checked above; >>> 0 for unsigned, input fits in u32
+            const j = (B32[Pi + blockSize32 - 16] & (N - 1)) >>> 0; // j = Integrify(X) % iterations
+            for (let k = 0; k < blockSize32; k++)
+                tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]
+            BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])
+            blockMixCb();
+        }
+    }
+    swap32IfBE(B32);
+    return scryptOutput(password, dkLen, B, V, tmp);
+}
+/**
+ * Scrypt KDF from RFC 7914. Async version. See {@link ScryptOpts}.
+ * @example
+ * await scryptAsync('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });
+ */
+export async function scryptAsync(password, salt, opts) {
+    const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick } = scryptInit(password, salt, opts);
+    swap32IfBE(B32);
+    for (let pi = 0; pi < p; pi++) {
+        const Pi = blockSize32 * pi;
+        for (let i = 0; i < blockSize32; i++)
+            V[i] = B32[Pi + i]; // V[0] = B[i]
+        let pos = 0;
+        await asyncLoop(N - 1, asyncTick, () => {
+            BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);
+            blockMixCb();
+        });
+        BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element
+        blockMixCb();
+        await asyncLoop(N, asyncTick, () => {
+            // First u32 of the last 64-byte block (u32 is LE)
+            // & (N - 1) is % N as N is a power of 2, N & (N - 1) = 0 is checked above; >>> 0 for unsigned, input fits in u32
+            const j = (B32[Pi + blockSize32 - 16] & (N - 1)) >>> 0; // j = Integrify(X) % iterations
+            for (let k = 0; k < blockSize32; k++)
+                tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]
+            BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])
+            blockMixCb();
+        });
+    }
+    swap32IfBE(B32);
+    return scryptOutput(password, dkLen, B, V, tmp);
+}
+//# sourceMappingURL=scrypt.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/sha2.d.ts

@@ -0,0 +1,199 @@
+/**
+ * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+ * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+ * Check out [RFC 4634](https://www.rfc-editor.org/rfc/rfc4634) and
+ * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ */
+import { HashMD } from './_md.ts';
+import { type CHash } from './utils.ts';
+/** Internal 32-byte base SHA2 hash class. */
+declare abstract class SHA2_32B<T extends SHA2_32B<T>> extends HashMD<T> {
+    protected abstract A: number;
+    protected abstract B: number;
+    protected abstract C: number;
+    protected abstract D: number;
+    protected abstract E: number;
+    protected abstract F: number;
+    protected abstract G: number;
+    protected abstract H: number;
+    constructor(outputLen: number);
+    protected get(): [number, number, number, number, number, number, number, number];
+    protected set(A: number, B: number, C: number, D: number, E: number, F: number, G: number, H: number): void;
+    protected process(view: DataView, offset: number): void;
+    protected roundClean(): void;
+    destroy(): void;
+}
+/** Internal SHA2-256 hash class. */
+export declare class _SHA256 extends SHA2_32B<_SHA256> {
+    protected A: number;
+    protected B: number;
+    protected C: number;
+    protected D: number;
+    protected E: number;
+    protected F: number;
+    protected G: number;
+    protected H: number;
+    constructor();
+}
+/** Internal SHA2-224 hash class. */
+export declare class _SHA224 extends SHA2_32B<_SHA224> {
+    protected A: number;
+    protected B: number;
+    protected C: number;
+    protected D: number;
+    protected E: number;
+    protected F: number;
+    protected G: number;
+    protected H: number;
+    constructor();
+}
+/** Internal 64-byte base SHA2 hash class. */
+declare abstract class SHA2_64B<T extends SHA2_64B<T>> extends HashMD<T> {
+    protected abstract Ah: number;
+    protected abstract Al: number;
+    protected abstract Bh: number;
+    protected abstract Bl: number;
+    protected abstract Ch: number;
+    protected abstract Cl: number;
+    protected abstract Dh: number;
+    protected abstract Dl: number;
+    protected abstract Eh: number;
+    protected abstract El: number;
+    protected abstract Fh: number;
+    protected abstract Fl: number;
+    protected abstract Gh: number;
+    protected abstract Gl: number;
+    protected abstract Hh: number;
+    protected abstract Hl: number;
+    constructor(outputLen: number);
+    protected get(): [
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number
+    ];
+    protected set(Ah: number, Al: number, Bh: number, Bl: number, Ch: number, Cl: number, Dh: number, Dl: number, Eh: number, El: number, Fh: number, Fl: number, Gh: number, Gl: number, Hh: number, Hl: number): void;
+    protected process(view: DataView, offset: number): void;
+    protected roundClean(): void;
+    destroy(): void;
+}
+/** Internal SHA2-512 hash class. */
+export declare class _SHA512 extends SHA2_64B<_SHA512> {
+    protected Ah: number;
+    protected Al: number;
+    protected Bh: number;
+    protected Bl: number;
+    protected Ch: number;
+    protected Cl: number;
+    protected Dh: number;
+    protected Dl: number;
+    protected Eh: number;
+    protected El: number;
+    protected Fh: number;
+    protected Fl: number;
+    protected Gh: number;
+    protected Gl: number;
+    protected Hh: number;
+    protected Hl: number;
+    constructor();
+}
+/** Internal SHA2-384 hash class. */
+export declare class _SHA384 extends SHA2_64B<_SHA384> {
+    protected Ah: number;
+    protected Al: number;
+    protected Bh: number;
+    protected Bl: number;
+    protected Ch: number;
+    protected Cl: number;
+    protected Dh: number;
+    protected Dl: number;
+    protected Eh: number;
+    protected El: number;
+    protected Fh: number;
+    protected Fl: number;
+    protected Gh: number;
+    protected Gl: number;
+    protected Hh: number;
+    protected Hl: number;
+    constructor();
+}
+/** Internal SHA2-512/224 hash class. */
+export declare class _SHA512_224 extends SHA2_64B<_SHA512_224> {
+    protected Ah: number;
+    protected Al: number;
+    protected Bh: number;
+    protected Bl: number;
+    protected Ch: number;
+    protected Cl: number;
+    protected Dh: number;
+    protected Dl: number;
+    protected Eh: number;
+    protected El: number;
+    protected Fh: number;
+    protected Fl: number;
+    protected Gh: number;
+    protected Gl: number;
+    protected Hh: number;
+    protected Hl: number;
+    constructor();
+}
+/** Internal SHA2-512/256 hash class. */
+export declare class _SHA512_256 extends SHA2_64B<_SHA512_256> {
+    protected Ah: number;
+    protected Al: number;
+    protected Bh: number;
+    protected Bl: number;
+    protected Ch: number;
+    protected Cl: number;
+    protected Dh: number;
+    protected Dl: number;
+    protected Eh: number;
+    protected El: number;
+    protected Fh: number;
+    protected Fl: number;
+    protected Gh: number;
+    protected Gl: number;
+    protected Hh: number;
+    protected Hl: number;
+    constructor();
+}
+/**
+ * SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:
+ *
+ * - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.
+ * - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ * - Each sha256 hash is executing 2^18 bit operations.
+ * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.
+ */
+export declare const sha256: CHash<_SHA256>;
+/** SHA2-224 hash function from RFC 4634 */
+export declare const sha224: CHash<_SHA224>;
+/** SHA2-512 hash function from RFC 4634. */
+export declare const sha512: CHash<_SHA512>;
+/** SHA2-384 hash function from RFC 4634. */
+export declare const sha384: CHash<_SHA384>;
+/**
+ * SHA2-512/256 "truncated" hash function, with improved resistance to length extension attacks.
+ * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
+ */
+export declare const sha512_256: CHash<_SHA512_256>;
+/**
+ * SHA2-512/224 "truncated" hash function, with improved resistance to length extension attacks.
+ * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
+ */
+export declare const sha512_224: CHash<_SHA512_224>;
+export {};
+//# sourceMappingURL=sha2.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/sha2.js

@@ -0,0 +1,397 @@
+/**
+ * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+ * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+ * Check out [RFC 4634](https://www.rfc-editor.org/rfc/rfc4634) and
+ * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ */
+import { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from "./_md.js";
+import * as u64 from "./_u64.js";
+import { clean, createHasher, oidNist, rotr } from "./utils.js";
+/**
+ * Round constants:
+ * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+ */
+// prettier-ignore
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+/** Reusable temporary buffer. "W" comes straight from spec. */
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+/** Internal 32-byte base SHA2 hash class. */
+class SHA2_32B extends HashMD {
+    constructor(outputLen) {
+        super(64, outputLen, 8, false);
+    }
+    get() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+        this.E = E | 0;
+        this.F = F | 0;
+        this.G = G | 0;
+        this.H = H | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4)
+            SHA256_W[i] = view.getUint32(offset, false);
+        for (let i = 16; i < 64; i++) {
+            const W15 = SHA256_W[i - 15];
+            const W2 = SHA256_W[i - 2];
+            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+        }
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D, E, F, G, H } = this;
+        for (let i = 0; i < 64; i++) {
+            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+            const T2 = (sigma0 + Maj(A, B, C)) | 0;
+            H = G;
+            G = F;
+            F = E;
+            E = (D + T1) | 0;
+            D = C;
+            C = B;
+            B = A;
+            A = (T1 + T2) | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        E = (E + this.E) | 0;
+        F = (F + this.F) | 0;
+        G = (G + this.G) | 0;
+        H = (H + this.H) | 0;
+        this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+        clean(SHA256_W);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        clean(this.buffer);
+    }
+}
+/** Internal SHA2-256 hash class. */
+export class _SHA256 extends SHA2_32B {
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    A = SHA256_IV[0] | 0;
+    B = SHA256_IV[1] | 0;
+    C = SHA256_IV[2] | 0;
+    D = SHA256_IV[3] | 0;
+    E = SHA256_IV[4] | 0;
+    F = SHA256_IV[5] | 0;
+    G = SHA256_IV[6] | 0;
+    H = SHA256_IV[7] | 0;
+    constructor() {
+        super(32);
+    }
+}
+/** Internal SHA2-224 hash class. */
+export class _SHA224 extends SHA2_32B {
+    A = SHA224_IV[0] | 0;
+    B = SHA224_IV[1] | 0;
+    C = SHA224_IV[2] | 0;
+    D = SHA224_IV[3] | 0;
+    E = SHA224_IV[4] | 0;
+    F = SHA224_IV[5] | 0;
+    G = SHA224_IV[6] | 0;
+    H = SHA224_IV[7] | 0;
+    constructor() {
+        super(28);
+    }
+}
+// SHA2-512 is slower than sha256 in js because u64 operations are slow.
+// Round contants
+// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409
+// prettier-ignore
+const K512 = /* @__PURE__ */ (() => u64.split([
+    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+].map(n => BigInt(n))))();
+const SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+const SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+// Reusable temporary buffers
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+/** Internal 64-byte base SHA2 hash class. */
+class SHA2_64B extends HashMD {
+    constructor(outputLen) {
+        super(128, outputLen, 16, false);
+    }
+    // prettier-ignore
+    get() {
+        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+    }
+    // prettier-ignore
+    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+        this.Ah = Ah | 0;
+        this.Al = Al | 0;
+        this.Bh = Bh | 0;
+        this.Bl = Bl | 0;
+        this.Ch = Ch | 0;
+        this.Cl = Cl | 0;
+        this.Dh = Dh | 0;
+        this.Dl = Dl | 0;
+        this.Eh = Eh | 0;
+        this.El = El | 0;
+        this.Fh = Fh | 0;
+        this.Fl = Fl | 0;
+        this.Gh = Gh | 0;
+        this.Gl = Gl | 0;
+        this.Hh = Hh | 0;
+        this.Hl = Hl | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4) {
+            SHA512_W_H[i] = view.getUint32(offset);
+            SHA512_W_L[i] = view.getUint32((offset += 4));
+        }
+        for (let i = 16; i < 80; i++) {
+            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
+            const W15h = SHA512_W_H[i - 15] | 0;
+            const W15l = SHA512_W_L[i - 15] | 0;
+            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
+            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
+            const W2h = SHA512_W_H[i - 2] | 0;
+            const W2l = SHA512_W_L[i - 2] | 0;
+            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
+            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
+            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+            SHA512_W_H[i] = SUMh | 0;
+            SHA512_W_L[i] = SUMl | 0;
+        }
+        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+        // Compression function main loop, 80 rounds
+        for (let i = 0; i < 80; i++) {
+            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
+            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
+            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const CHIh = (Eh & Fh) ^ (~Eh & Gh);
+            const CHIl = (El & Fl) ^ (~El & Gl);
+            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
+            // prettier-ignore
+            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+            const T1l = T1ll | 0;
+            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
+            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
+            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
+            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+            Hh = Gh | 0;
+            Hl = Gl | 0;
+            Gh = Fh | 0;
+            Gl = Fl | 0;
+            Fh = Eh | 0;
+            Fl = El | 0;
+            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+            Dh = Ch | 0;
+            Dl = Cl | 0;
+            Ch = Bh | 0;
+            Cl = Bl | 0;
+            Bh = Ah | 0;
+            Bl = Al | 0;
+            const All = u64.add3L(T1l, sigma0l, MAJl);
+            Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+            Al = All | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+    }
+    roundClean() {
+        clean(SHA512_W_H, SHA512_W_L);
+    }
+    destroy() {
+        clean(this.buffer);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+}
+/** Internal SHA2-512 hash class. */
+export class _SHA512 extends SHA2_64B {
+    Ah = SHA512_IV[0] | 0;
+    Al = SHA512_IV[1] | 0;
+    Bh = SHA512_IV[2] | 0;
+    Bl = SHA512_IV[3] | 0;
+    Ch = SHA512_IV[4] | 0;
+    Cl = SHA512_IV[5] | 0;
+    Dh = SHA512_IV[6] | 0;
+    Dl = SHA512_IV[7] | 0;
+    Eh = SHA512_IV[8] | 0;
+    El = SHA512_IV[9] | 0;
+    Fh = SHA512_IV[10] | 0;
+    Fl = SHA512_IV[11] | 0;
+    Gh = SHA512_IV[12] | 0;
+    Gl = SHA512_IV[13] | 0;
+    Hh = SHA512_IV[14] | 0;
+    Hl = SHA512_IV[15] | 0;
+    constructor() {
+        super(64);
+    }
+}
+/** Internal SHA2-384 hash class. */
+export class _SHA384 extends SHA2_64B {
+    Ah = SHA384_IV[0] | 0;
+    Al = SHA384_IV[1] | 0;
+    Bh = SHA384_IV[2] | 0;
+    Bl = SHA384_IV[3] | 0;
+    Ch = SHA384_IV[4] | 0;
+    Cl = SHA384_IV[5] | 0;
+    Dh = SHA384_IV[6] | 0;
+    Dl = SHA384_IV[7] | 0;
+    Eh = SHA384_IV[8] | 0;
+    El = SHA384_IV[9] | 0;
+    Fh = SHA384_IV[10] | 0;
+    Fl = SHA384_IV[11] | 0;
+    Gh = SHA384_IV[12] | 0;
+    Gl = SHA384_IV[13] | 0;
+    Hh = SHA384_IV[14] | 0;
+    Hl = SHA384_IV[15] | 0;
+    constructor() {
+        super(48);
+    }
+}
+/**
+ * Truncated SHA512/256 and SHA512/224.
+ * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as "intermediary" IV of SHA512/t.
+ * Then t hashes string to produce result IV.
+ * See `test/misc/sha2-gen-iv.js`.
+ */
+/** SHA512/224 IV */
+const T224_IV = /* @__PURE__ */ Uint32Array.from([
+    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,
+    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,
+]);
+/** SHA512/256 IV */
+const T256_IV = /* @__PURE__ */ Uint32Array.from([
+    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,
+    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,
+]);
+/** Internal SHA2-512/224 hash class. */
+export class _SHA512_224 extends SHA2_64B {
+    Ah = T224_IV[0] | 0;
+    Al = T224_IV[1] | 0;
+    Bh = T224_IV[2] | 0;
+    Bl = T224_IV[3] | 0;
+    Ch = T224_IV[4] | 0;
+    Cl = T224_IV[5] | 0;
+    Dh = T224_IV[6] | 0;
+    Dl = T224_IV[7] | 0;
+    Eh = T224_IV[8] | 0;
+    El = T224_IV[9] | 0;
+    Fh = T224_IV[10] | 0;
+    Fl = T224_IV[11] | 0;
+    Gh = T224_IV[12] | 0;
+    Gl = T224_IV[13] | 0;
+    Hh = T224_IV[14] | 0;
+    Hl = T224_IV[15] | 0;
+    constructor() {
+        super(28);
+    }
+}
+/** Internal SHA2-512/256 hash class. */
+export class _SHA512_256 extends SHA2_64B {
+    Ah = T256_IV[0] | 0;
+    Al = T256_IV[1] | 0;
+    Bh = T256_IV[2] | 0;
+    Bl = T256_IV[3] | 0;
+    Ch = T256_IV[4] | 0;
+    Cl = T256_IV[5] | 0;
+    Dh = T256_IV[6] | 0;
+    Dl = T256_IV[7] | 0;
+    Eh = T256_IV[8] | 0;
+    El = T256_IV[9] | 0;
+    Fh = T256_IV[10] | 0;
+    Fl = T256_IV[11] | 0;
+    Gh = T256_IV[12] | 0;
+    Gl = T256_IV[13] | 0;
+    Hh = T256_IV[14] | 0;
+    Hl = T256_IV[15] | 0;
+    constructor() {
+        super(32);
+    }
+}
+/**
+ * SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:
+ *
+ * - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.
+ * - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ * - Each sha256 hash is executing 2^18 bit operations.
+ * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.
+ */
+export const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), 
+/* @__PURE__ */ oidNist(0x01));
+/** SHA2-224 hash function from RFC 4634 */
+export const sha224 = /* @__PURE__ */ createHasher(() => new _SHA224(), 
+/* @__PURE__ */ oidNist(0x04));
+/** SHA2-512 hash function from RFC 4634. */
+export const sha512 = /* @__PURE__ */ createHasher(() => new _SHA512(), 
+/* @__PURE__ */ oidNist(0x03));
+/** SHA2-384 hash function from RFC 4634. */
+export const sha384 = /* @__PURE__ */ createHasher(() => new _SHA384(), 
+/* @__PURE__ */ oidNist(0x02));
+/**
+ * SHA2-512/256 "truncated" hash function, with improved resistance to length extension attacks.
+ * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
+ */
+export const sha512_256 = /* @__PURE__ */ createHasher(() => new _SHA512_256(), 
+/* @__PURE__ */ oidNist(0x06));
+/**
+ * SHA2-512/224 "truncated" hash function, with improved resistance to length extension attacks.
+ * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
+ */
+export const sha512_224 = /* @__PURE__ */ createHasher(() => new _SHA512_224(), 
+/* @__PURE__ */ oidNist(0x05));
+//# sourceMappingURL=sha2.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/sha3-addons.d.ts

@@ -0,0 +1,149 @@
+/**
+ * SHA3 (keccak) addons.
+ *
+ * * cSHAKE, KMAC, TupleHash, ParallelHash + XOF variants from
+ *   [NIST SP 800-185](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-185.pdf)
+ * * KangarooTwelve 🦘 and TurboSHAKE - reduced-round keccak from
+ *   [k12-draft-17](https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/17/)
+ * * KeccakPRG: Pseudo-random generator based on Keccak [(pdf)](https://keccak.team/files/CSF-0.1.pdf)
+ * @module
+ */
+import { Keccak, type ShakeOpts } from './sha3.ts';
+import { type CHash, type CHashXOF, type Hash, type HashXOF, type KDFInput, type PRG } from './utils.ts';
+export type cShakeOpts = ShakeOpts & {
+    personalization?: Uint8Array;
+    NISTfn?: KDFInput;
+};
+export type ITupleHash = {
+    (messages: Uint8Array[], opts?: cShakeOpts): Uint8Array;
+    create(opts?: cShakeOpts): _TupleHash;
+};
+/** 128-bit NIST cSHAKE XOF. */
+export declare const cshake128: CHashXOF<Keccak, cShakeOpts>;
+/** 256-bit NIST cSHAKE XOF. */
+export declare const cshake256: CHashXOF<Keccak, cShakeOpts>;
+/** Internal KMAC mac class. */
+export declare class _KMAC extends Keccak implements HashXOF<_KMAC> {
+    constructor(blockLen: number, outputLen: number, enableXOF: boolean, key: Uint8Array, opts?: cShakeOpts);
+    protected finish(): void;
+    _cloneInto(to?: _KMAC): _KMAC;
+    clone(): _KMAC;
+}
+export type IKMAC = {
+    (key: Uint8Array, message: Uint8Array, opts?: KangarooOpts): Uint8Array;
+    create(key: Uint8Array, opts?: cShakeOpts): _KMAC;
+};
+/** 128-bit Keccak MAC. */
+export declare const kmac128: IKMAC;
+/** 256-bit Keccak MAC. */
+export declare const kmac256: IKMAC;
+/** 128-bit Keccak-MAC XOF. */
+export declare const kmac128xof: IKMAC;
+/** 256-bit Keccak-MAC XOF. */
+export declare const kmac256xof: IKMAC;
+/** Internal TupleHash class. */
+export declare class _TupleHash extends Keccak implements HashXOF<_TupleHash> {
+    constructor(blockLen: number, outputLen: number, enableXOF: boolean, opts?: cShakeOpts);
+    protected finish(): void;
+    _cloneInto(to?: _TupleHash): _TupleHash;
+    clone(): _TupleHash;
+}
+/** 128-bit TupleHASH. tuple(['ab', 'cd']) != tuple(['a', 'bcd']) */
+export declare const tuplehash128: ITupleHash;
+/** 256-bit TupleHASH. tuple(['ab', 'cd']) != tuple(['a', 'bcd']) */
+export declare const tuplehash256: ITupleHash;
+/** 128-bit TupleHASH XOF. */
+export declare const tuplehash128xof: ITupleHash;
+/** 256-bit TupleHASH XOF. */
+export declare const tuplehash256xof: ITupleHash;
+type ParallelOpts = KangarooOpts & {
+    blockLen?: number;
+};
+/** Internal Parallel Keccak Hash class. */
+export declare class _ParallelHash extends Keccak implements HashXOF<_ParallelHash> {
+    private leafHash?;
+    protected leafCons: () => Hash<Keccak>;
+    private chunkPos;
+    private chunksDone;
+    private chunkLen;
+    constructor(blockLen: number, outputLen: number, leafCons: () => Hash<Keccak>, enableXOF: boolean, opts?: ParallelOpts);
+    protected finish(): void;
+    _cloneInto(to?: _ParallelHash): _ParallelHash;
+    destroy(): void;
+    clone(): _ParallelHash;
+}
+/** 128-bit ParallelHash. In JS, it is not parallel. */
+export declare const parallelhash128: CHash<Keccak, ParallelOpts>;
+/** 256-bit ParallelHash. In JS, it is not parallel. */
+export declare const parallelhash256: CHash<Keccak, ParallelOpts>;
+/** 128-bit ParallelHash XOF. In JS, it is not parallel. */
+export declare const parallelhash128xof: CHashXOF<Keccak, ParallelOpts>;
+/** 256-bit ParallelHash. In JS, it is not parallel. */
+export declare const parallelhash256xof: CHashXOF<Keccak, ParallelOpts>;
+/** D means Domain separation byte */
+export type TurboshakeOpts = ShakeOpts & {
+    D?: number;
+};
+/**
+ * TurboSHAKE 128-bit: reduced 12-round keccak.
+ * Should've been a simple "shake with 12 rounds", but we got a whole new spec about Turbo SHAKE Pro MAX.
+ */
+export declare const turboshake128: CHashXOF<Keccak, TurboshakeOpts>;
+/** TurboSHAKE 256-bit: reduced 12-round keccak. */
+export declare const turboshake256: CHashXOF<Keccak, TurboshakeOpts>;
+/** K12 options. */
+export type KangarooOpts = {
+    dkLen?: number;
+    personalization?: Uint8Array;
+};
+/** Internal K12 hash class. */
+export declare class _KangarooTwelve extends Keccak implements HashXOF<_KangarooTwelve> {
+    readonly chunkLen = 8192;
+    private leafHash?;
+    protected leafLen: number;
+    private personalization;
+    private chunkPos;
+    private chunksDone;
+    constructor(blockLen: number, leafLen: number, outputLen: number, rounds: number, opts: KangarooOpts);
+    update(data: Uint8Array): this;
+    protected finish(): void;
+    destroy(): void;
+    _cloneInto(to?: _KangarooTwelve): _KangarooTwelve;
+    clone(): _KangarooTwelve;
+}
+/** 128-bit KangarooTwelve (k12): reduced 12-round keccak. */
+export declare const kt128: CHash<_KangarooTwelve, KangarooOpts>;
+/** 256-bit KangarooTwelve (k12): reduced 12-round keccak. */
+export declare const kt256: CHash<_KangarooTwelve, KangarooOpts>;
+/** KangarooTwelve-based MAC options. */
+export type HopMAC = (key: Uint8Array, message: Uint8Array, personalization: Uint8Array, dkLen?: number) => Uint8Array;
+/**
+ * 128-bit KangarooTwelve-based MAC.
+ *
+ * These untested (there is no test vectors or implementation available). Use at your own risk.
+ * HopMAC128(Key, M, C, L) = KT128(Key, KT128(M, C, 32), L)
+ * HopMAC256(Key, M, C, L) = KT256(Key, KT256(M, C, 64), L)
+ */
+export declare const HopMAC128: HopMAC;
+/** 256-bit KangarooTwelve-based MAC. */
+export declare const HopMAC256: HopMAC;
+/**
+ * More at https://github.com/XKCP/XKCP/tree/master/lib/high/Keccak/PRG.
+ */
+export declare class _KeccakPRG extends Keccak implements PRG {
+    protected rate: number;
+    constructor(capacity: number);
+    protected keccak(): void;
+    update(data: Uint8Array): this;
+    protected finish(): void;
+    digestInto(_out: Uint8Array): Uint8Array;
+    addEntropy(seed: Uint8Array): void;
+    randomBytes(length: number): Uint8Array;
+    clean(): void;
+    _cloneInto(to?: _KeccakPRG): _KeccakPRG;
+    clone(): _KeccakPRG;
+}
+/** KeccakPRG: Pseudo-random generator based on Keccak. https://keccak.team/files/CSF-0.1.pdf */
+export declare const keccakprg: (capacity?: number) => _KeccakPRG;
+export {};
+//# sourceMappingURL=sha3-addons.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/sha3-addons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha3-addons.d.ts","sourceRoot":"","sources":["src/sha3-addons.ts"],"names":[],"mappings":"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"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/sha3-addons.js

@@ -0,0 +1,420 @@
+/**
+ * SHA3 (keccak) addons.
+ *
+ * * cSHAKE, KMAC, TupleHash, ParallelHash + XOF variants from
+ *   [NIST SP 800-185](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-185.pdf)
+ * * KangarooTwelve 🦘 and TurboSHAKE - reduced-round keccak from
+ *   [k12-draft-17](https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/17/)
+ * * KeccakPRG: Pseudo-random generator based on Keccak [(pdf)](https://keccak.team/files/CSF-0.1.pdf)
+ * @module
+ */
+import { Keccak } from "./sha3.js";
+import { abytes, anumber, createHasher, kdfInputToBytes, u32, } from "./utils.js";
+// cSHAKE && KMAC (NIST SP800-185)
+const _8n = /* @__PURE__ */ BigInt(8);
+const _ffn = /* @__PURE__ */ BigInt(0xff);
+// It is safe to use bigints here, since they used only for length encoding (not actual data).
+// We use bigints in sha256 for lengths too.
+function leftEncode(n) {
+    n = BigInt(n);
+    const res = [Number(n & _ffn)];
+    n >>= _8n;
+    for (; n > 0; n >>= _8n)
+        res.unshift(Number(n & _ffn));
+    res.unshift(res.length);
+    return new Uint8Array(res);
+}
+function rightEncode(n) {
+    n = BigInt(n);
+    const res = [Number(n & _ffn)];
+    n >>= _8n;
+    for (; n > 0; n >>= _8n)
+        res.unshift(Number(n & _ffn));
+    res.push(res.length);
+    return new Uint8Array(res);
+}
+function chooseLen(opts, outputLen) {
+    return opts.dkLen === undefined ? outputLen : opts.dkLen;
+}
+const abytesOrZero = (buf, title = '') => {
+    if (buf === undefined)
+        return EMPTY_BUFFER;
+    abytes(buf, undefined, title);
+    return buf;
+};
+// NOTE: second modulo is necessary since we don't need to add padding if current element takes whole block
+const getPadding = (len, block) => new Uint8Array((block - (len % block)) % block);
+// Personalization
+function cshakePers(hash, opts = {}) {
+    if (!opts || (opts.personalization === undefined && opts.NISTfn === undefined))
+        return hash;
+    // Encode and pad inplace to avoid unneccesary memory copies/slices (so we don't need to zero them later)
+    // bytepad(encode_string(N) || encode_string(S), 168)
+    const blockLenBytes = leftEncode(hash.blockLen);
+    const fn = opts.NISTfn === undefined ? EMPTY_BUFFER : kdfInputToBytes(opts.NISTfn);
+    const fnLen = leftEncode(_8n * BigInt(fn.length)); // length in bits
+    const pers = abytesOrZero(opts.personalization, 'personalization');
+    const persLen = leftEncode(_8n * BigInt(pers.length)); // length in bits
+    if (!fn.length && !pers.length)
+        return hash;
+    hash.suffix = 0x04;
+    hash.update(blockLenBytes).update(fnLen).update(fn).update(persLen).update(pers);
+    let totalLen = blockLenBytes.length + fnLen.length + fn.length + persLen.length + pers.length;
+    hash.update(getPadding(totalLen, hash.blockLen));
+    return hash;
+}
+const gencShake = (suffix, blockLen, outputLen) => createHasher((opts = {}) => cshakePers(new Keccak(blockLen, suffix, chooseLen(opts, outputLen), true), opts));
+/** 128-bit NIST cSHAKE XOF. */
+export const cshake128 = /* @__PURE__ */ gencShake(0x1f, 168, 16);
+/** 256-bit NIST cSHAKE XOF. */
+export const cshake256 = /* @__PURE__ */ gencShake(0x1f, 136, 32);
+/** Internal KMAC mac class. */
+export class _KMAC extends Keccak {
+    constructor(blockLen, outputLen, enableXOF, key, opts = {}) {
+        super(blockLen, 0x1f, outputLen, enableXOF);
+        cshakePers(this, { NISTfn: 'KMAC', personalization: opts.personalization });
+        abytes(key, undefined, 'key');
+        // 1. newX = bytepad(encode_string(K), 168) || X || right_encode(L).
+        const blockLenBytes = leftEncode(this.blockLen);
+        const keyLen = leftEncode(_8n * BigInt(key.length));
+        this.update(blockLenBytes).update(keyLen).update(key);
+        const totalLen = blockLenBytes.length + keyLen.length + key.length;
+        this.update(getPadding(totalLen, this.blockLen));
+    }
+    finish() {
+        if (!this.finished)
+            this.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
+        super.finish();
+    }
+    _cloneInto(to) {
+        // Create new instance without calling constructor since key already in state and we don't know it.
+        // Force "to" to be instance of KMAC instead of Sha3.
+        if (!to) {
+            to = Object.create(Object.getPrototypeOf(this), {});
+            to.state = this.state.slice();
+            to.blockLen = this.blockLen;
+            to.state32 = u32(to.state);
+        }
+        return super._cloneInto(to);
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+function genKmac(blockLen, outputLen, xof = false) {
+    const kmac = (key, message, opts) => kmac.create(key, opts).update(message).digest();
+    kmac.create = (key, opts = {}) => new _KMAC(blockLen, chooseLen(opts, outputLen), xof, key, opts);
+    return kmac;
+}
+/** 128-bit Keccak MAC. */
+export const kmac128 = /* @__PURE__ */ genKmac(168, 16);
+/** 256-bit Keccak MAC. */
+export const kmac256 = /* @__PURE__ */ genKmac(136, 32);
+/** 128-bit Keccak-MAC XOF. */
+export const kmac128xof = /* @__PURE__ */ genKmac(168, 16, true);
+/** 256-bit Keccak-MAC XOF. */
+export const kmac256xof = /* @__PURE__ */ genKmac(136, 32, true);
+/** Internal TupleHash class. */
+export class _TupleHash extends Keccak {
+    constructor(blockLen, outputLen, enableXOF, opts = {}) {
+        super(blockLen, 0x1f, outputLen, enableXOF);
+        cshakePers(this, { NISTfn: 'TupleHash', personalization: opts.personalization });
+        // Change update after cshake processed
+        this.update = (data) => {
+            abytes(data);
+            super.update(leftEncode(_8n * BigInt(data.length)));
+            super.update(data);
+            return this;
+        };
+    }
+    finish() {
+        if (!this.finished)
+            super.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
+        super.finish();
+    }
+    _cloneInto(to) {
+        to ||= new _TupleHash(this.blockLen, this.outputLen, this.enableXOF);
+        return super._cloneInto(to);
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+function genTuple(blockLen, outputLen, xof = false) {
+    const tuple = (messages, opts) => {
+        const h = tuple.create(opts);
+        if (!Array.isArray(messages))
+            throw new Error('expected array of messages');
+        for (const msg of messages)
+            h.update(msg);
+        return h.digest();
+    };
+    tuple.create = (opts = {}) => new _TupleHash(blockLen, chooseLen(opts, outputLen), xof, opts);
+    return tuple;
+}
+/** 128-bit TupleHASH. tuple(['ab', 'cd']) != tuple(['a', 'bcd']) */
+export const tuplehash128 = /* @__PURE__ */ genTuple(168, 16);
+/** 256-bit TupleHASH. tuple(['ab', 'cd']) != tuple(['a', 'bcd']) */
+export const tuplehash256 = /* @__PURE__ */ genTuple(136, 32);
+/** 128-bit TupleHASH XOF. */
+export const tuplehash128xof = /* @__PURE__ */ genTuple(168, 16, true);
+/** 256-bit TupleHASH XOF. */
+export const tuplehash256xof = /* @__PURE__ */ genTuple(136, 32, true);
+/** Internal Parallel Keccak Hash class. */
+export class _ParallelHash extends Keccak {
+    leafHash;
+    leafCons;
+    chunkPos = 0; // Position of current block in chunk
+    chunksDone = 0; // How many chunks we already have
+    chunkLen;
+    constructor(blockLen, outputLen, leafCons, enableXOF, opts = {}) {
+        super(blockLen, 0x1f, outputLen, enableXOF);
+        cshakePers(this, { NISTfn: 'ParallelHash', personalization: opts.personalization });
+        this.leafCons = leafCons;
+        let { blockLen: B = 8 } = opts;
+        anumber(B);
+        this.chunkLen = B;
+        super.update(leftEncode(B));
+        // Change update after cshake processed
+        this.update = (data) => {
+            abytes(data);
+            const { chunkLen, leafCons } = this;
+            for (let pos = 0, len = data.length; pos < len;) {
+                if (this.chunkPos == chunkLen || !this.leafHash) {
+                    if (this.leafHash) {
+                        super.update(this.leafHash.digest());
+                        this.chunksDone++;
+                    }
+                    this.leafHash = leafCons();
+                    this.chunkPos = 0;
+                }
+                const take = Math.min(chunkLen - this.chunkPos, len - pos);
+                this.leafHash.update(data.subarray(pos, pos + take));
+                this.chunkPos += take;
+                pos += take;
+            }
+            return this;
+        };
+    }
+    finish() {
+        if (this.finished)
+            return;
+        if (this.leafHash) {
+            super.update(this.leafHash.digest());
+            this.chunksDone++;
+        }
+        super.update(rightEncode(this.chunksDone));
+        super.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
+        super.finish();
+    }
+    _cloneInto(to) {
+        to ||= new _ParallelHash(this.blockLen, this.outputLen, this.leafCons, this.enableXOF);
+        if (this.leafHash)
+            to.leafHash = this.leafHash._cloneInto(to.leafHash);
+        to.chunkPos = this.chunkPos;
+        to.chunkLen = this.chunkLen;
+        to.chunksDone = this.chunksDone;
+        return super._cloneInto(to);
+    }
+    destroy() {
+        super.destroy.call(this);
+        if (this.leafHash)
+            this.leafHash.destroy();
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+function genPrl(blockLen, outputLen, leaf, xof = false) {
+    const parallel = (message, opts) => parallel.create(opts).update(message).digest();
+    parallel.create = (opts = {}) => new _ParallelHash(blockLen, chooseLen(opts, outputLen), () => leaf.create({ dkLen: 2 * outputLen }), xof, opts);
+    parallel.outputLen = outputLen;
+    parallel.blockLen = blockLen;
+    return parallel;
+}
+/** 128-bit ParallelHash. In JS, it is not parallel. */
+export const parallelhash128 = /* @__PURE__ */ genPrl(168, 16, cshake128);
+/** 256-bit ParallelHash. In JS, it is not parallel. */
+export const parallelhash256 = /* @__PURE__ */ genPrl(136, 32, cshake256);
+/** 128-bit ParallelHash XOF. In JS, it is not parallel. */
+export const parallelhash128xof = /* @__PURE__ */ genPrl(168, 16, cshake128, true);
+/** 256-bit ParallelHash. In JS, it is not parallel. */
+export const parallelhash256xof = /* @__PURE__ */ genPrl(136, 32, cshake256, true);
+const genTurbo = (blockLen, outputLen) => createHasher((opts = {}) => {
+    const D = opts.D === undefined ? 0x1f : opts.D;
+    // Section 2.1 of https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/17/
+    if (!Number.isSafeInteger(D) || D < 0x01 || D > 0x7f)
+        throw new Error('"D" (domain separation byte) must be 0x01..0x7f, got: ' + D);
+    return new Keccak(blockLen, D, opts.dkLen === undefined ? outputLen : opts.dkLen, true, 12);
+});
+/**
+ * TurboSHAKE 128-bit: reduced 12-round keccak.
+ * Should've been a simple "shake with 12 rounds", but we got a whole new spec about Turbo SHAKE Pro MAX.
+ */
+export const turboshake128 = /* @__PURE__ */ genTurbo(168, 32);
+/** TurboSHAKE 256-bit: reduced 12-round keccak. */
+export const turboshake256 = /* @__PURE__ */ genTurbo(136, 64);
+// Same as NIST rightEncode, but returns [0] for zero string
+function rightEncodeK12(n) {
+    n = BigInt(n);
+    const res = [];
+    for (; n > 0; n >>= _8n)
+        res.unshift(Number(n & _ffn));
+    res.push(res.length);
+    return Uint8Array.from(res);
+}
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+/** Internal K12 hash class. */
+export class _KangarooTwelve extends Keccak {
+    chunkLen = 8192;
+    leafHash;
+    leafLen;
+    personalization;
+    chunkPos = 0; // Position of current block in chunk
+    chunksDone = 0; // How many chunks we already have
+    constructor(blockLen, leafLen, outputLen, rounds, opts) {
+        super(blockLen, 0x07, outputLen, true, rounds);
+        this.leafLen = leafLen;
+        this.personalization = abytesOrZero(opts.personalization, 'personalization');
+    }
+    update(data) {
+        abytes(data);
+        const { chunkLen, blockLen, leafLen, rounds } = this;
+        for (let pos = 0, len = data.length; pos < len;) {
+            if (this.chunkPos == chunkLen) {
+                if (this.leafHash)
+                    super.update(this.leafHash.digest());
+                else {
+                    this.suffix = 0x06; // Its safe to change suffix here since its used only in digest()
+                    super.update(Uint8Array.from([3, 0, 0, 0, 0, 0, 0, 0]));
+                }
+                this.leafHash = new Keccak(blockLen, 0x0b, leafLen, false, rounds);
+                this.chunksDone++;
+                this.chunkPos = 0;
+            }
+            const take = Math.min(chunkLen - this.chunkPos, len - pos);
+            const chunk = data.subarray(pos, pos + take);
+            if (this.leafHash)
+                this.leafHash.update(chunk);
+            else
+                super.update(chunk);
+            this.chunkPos += take;
+            pos += take;
+        }
+        return this;
+    }
+    finish() {
+        if (this.finished)
+            return;
+        const { personalization } = this;
+        this.update(personalization).update(rightEncodeK12(personalization.length));
+        // Leaf hash
+        if (this.leafHash) {
+            super.update(this.leafHash.digest());
+            super.update(rightEncodeK12(this.chunksDone));
+            super.update(Uint8Array.from([0xff, 0xff]));
+        }
+        super.finish.call(this);
+    }
+    destroy() {
+        super.destroy.call(this);
+        if (this.leafHash)
+            this.leafHash.destroy();
+        // We cannot zero personalization buffer since it is user provided and we don't want to mutate user input
+        this.personalization = EMPTY_BUFFER;
+    }
+    _cloneInto(to) {
+        const { blockLen, leafLen, leafHash, outputLen, rounds } = this;
+        to ||= new _KangarooTwelve(blockLen, leafLen, outputLen, rounds, {});
+        super._cloneInto(to);
+        if (leafHash)
+            to.leafHash = leafHash._cloneInto(to.leafHash);
+        to.personalization.set(this.personalization);
+        to.leafLen = this.leafLen;
+        to.chunkPos = this.chunkPos;
+        to.chunksDone = this.chunksDone;
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+/** 128-bit KangarooTwelve (k12): reduced 12-round keccak. */
+export const kt128 = /* @__PURE__ */ createHasher((opts = {}) => new _KangarooTwelve(168, 32, chooseLen(opts, 32), 12, opts));
+/** 256-bit KangarooTwelve (k12): reduced 12-round keccak. */
+export const kt256 = /* @__PURE__ */ createHasher((opts = {}) => new _KangarooTwelve(136, 64, chooseLen(opts, 64), 12, opts));
+const genHopMAC = (hash) => (key, message, personalization, dkLen) => hash(key, { personalization: hash(message, { personalization }), dkLen });
+/**
+ * 128-bit KangarooTwelve-based MAC.
+ *
+ * These untested (there is no test vectors or implementation available). Use at your own risk.
+ * HopMAC128(Key, M, C, L) = KT128(Key, KT128(M, C, 32), L)
+ * HopMAC256(Key, M, C, L) = KT256(Key, KT256(M, C, 64), L)
+ */
+export const HopMAC128 = /* @__PURE__ */ genHopMAC(kt128);
+/** 256-bit KangarooTwelve-based MAC. */
+export const HopMAC256 = /* @__PURE__ */ genHopMAC(kt256);
+/**
+ * More at https://github.com/XKCP/XKCP/tree/master/lib/high/Keccak/PRG.
+ */
+export class _KeccakPRG extends Keccak {
+    rate;
+    constructor(capacity) {
+        anumber(capacity);
+        const rate = 1600 - capacity;
+        const rho = rate - 2;
+        // Rho must be full bytes
+        if (capacity < 0 || capacity > 1600 - 10 || rho % 8)
+            throw new Error('invalid capacity');
+        // blockLen = rho in bytes
+        super(rho / 8, 0, 0, true);
+        this.rate = rate;
+        this.posOut = Math.floor((rate + 7) / 8);
+    }
+    keccak() {
+        // Duplex padding
+        this.state[this.pos] ^= 0x01;
+        this.state[this.blockLen] ^= 0x02; // Rho is full bytes
+        super.keccak();
+        this.pos = 0;
+        this.posOut = 0;
+    }
+    update(data) {
+        super.update(data);
+        this.posOut = this.blockLen;
+        return this;
+    }
+    finish() { }
+    digestInto(_out) {
+        throw new Error('digest is not allowed, use .fetch instead');
+    }
+    addEntropy(seed) {
+        this.update(seed);
+    }
+    randomBytes(length) {
+        return this.xof(length);
+    }
+    clean() {
+        if (this.rate < 1600 / 2 + 1)
+            throw new Error('rate is too low to use .forget()');
+        this.keccak();
+        for (let i = 0; i < this.blockLen; i++)
+            this.state[i] = 0;
+        this.pos = this.blockLen;
+        this.keccak();
+        this.posOut = this.blockLen;
+    }
+    _cloneInto(to) {
+        const { rate } = this;
+        to ||= new _KeccakPRG(1600 - rate);
+        super._cloneInto(to);
+        to.rate = rate;
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+/** KeccakPRG: Pseudo-random generator based on Keccak. https://keccak.team/files/CSF-0.1.pdf */
+export const keccakprg = (capacity = 254) => new _KeccakPRG(capacity);
+//# sourceMappingURL=sha3-addons.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/sha3.d.ts

@@ -0,0 +1,58 @@
+import { type CHash, type CHashXOF, type Hash, type HashXOF } from './utils.ts';
+/** `keccakf1600` internal function, additionally allows to adjust round count. */
+export declare function keccakP(s: Uint32Array, rounds?: number): void;
+/** Keccak sponge function. */
+export declare class Keccak implements Hash<Keccak>, HashXOF<Keccak> {
+    protected state: Uint8Array;
+    protected pos: number;
+    protected posOut: number;
+    protected finished: boolean;
+    protected state32: Uint32Array;
+    protected destroyed: boolean;
+    blockLen: number;
+    suffix: number;
+    outputLen: number;
+    protected enableXOF: boolean;
+    protected rounds: number;
+    constructor(blockLen: number, suffix: number, outputLen: number, enableXOF?: boolean, rounds?: number);
+    clone(): Keccak;
+    protected keccak(): void;
+    update(data: Uint8Array): 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;
+}
+/** SHA3-224 hash function. */
+export declare const sha3_224: CHash;
+/** SHA3-256 hash function. Different from keccak-256. */
+export declare const sha3_256: CHash;
+/** SHA3-384 hash function. */
+export declare const sha3_384: CHash;
+/** SHA3-512 hash function. */
+export declare const sha3_512: CHash;
+/** keccak-224 hash function. */
+export declare const keccak_224: CHash;
+/** keccak-256 hash function. Different from SHA3-256. */
+export declare const keccak_256: CHash;
+/** keccak-384 hash function. */
+export declare const keccak_384: CHash;
+/** keccak-512 hash function. */
+export declare const keccak_512: CHash;
+/** Options for SHAKE XOF. */
+export type ShakeOpts = {
+    dkLen?: number;
+};
+/** SHAKE128 XOF with 128-bit security. */
+export declare const shake128: CHashXOF<Keccak, ShakeOpts>;
+/** SHAKE256 XOF with 256-bit security. */
+export declare const shake256: CHashXOF<Keccak, ShakeOpts>;
+/** SHAKE128 XOF with 256-bit output (NIST version). */
+export declare const shake128_32: CHashXOF<Keccak, ShakeOpts>;
+/** SHAKE256 XOF with 512-bit output (NIST version). */
+export declare const shake256_64: CHashXOF<Keccak, ShakeOpts>;
+//# sourceMappingURL=sha3.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/sha3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha3.d.ts","sourceRoot":"","sources":["src/sha3.ts"],"names":[],"mappings":"AAaA,OAAO,EAML,KAAK,KAAK,EAAE,KAAK,QAAQ,EACzB,KAAK,IAAI,EAET,KAAK,OAAO,EACb,MAAM,YAAY,CAAC;AAoCpB,kFAAkF;AAClF,wBAAgB,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,GAAE,MAAW,GAAG,IAAI,CAyCjE;AAED,8BAA8B;AAC9B,qBAAa,MAAO,YAAW,IAAI,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC;IAC1D,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC;IAC5B,SAAS,CAAC,GAAG,SAAK;IAClB,SAAS,CAAC,MAAM,SAAK;IACrB,SAAS,CAAC,QAAQ,UAAS;IAC3B,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC;IAC/B,SAAS,CAAC,SAAS,UAAS;IAErB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,SAAS,UAAS;IAC5B,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;gBAIvB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,UAAQ,EACjB,MAAM,GAAE,MAAW;IAgBrB,KAAK,IAAI,MAAM;IAGf,SAAS,CAAC,MAAM,IAAI,IAAI;IAOxB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAY9B,SAAS,CAAC,MAAM,IAAI,IAAI;IAUxB,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;IAehD,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;IAKpC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAI9B,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;IAOvC,MAAM,IAAI,UAAU;IAGpB,OAAO,IAAI,IAAI;IAIf,UAAU,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;CAehC;AAKD,8BAA8B;AAC9B,eAAO,MAAM,QAAQ,EAAE,KAKtB,CAAC;AACF,yDAAyD;AACzD,eAAO,MAAM,QAAQ,EAAE,KAKtB,CAAC;AACF,8BAA8B;AAC9B,eAAO,MAAM,QAAQ,EAAE,KAKtB,CAAC;AACF,8BAA8B;AAC9B,eAAO,MAAM,QAAQ,EAAE,KAKtB,CAAC;AAEF,gCAAgC;AAChC,eAAO,MAAM,UAAU,EAAE,KAAgD,CAAC;AAC1E,yDAAyD;AACzD,eAAO,MAAM,UAAU,EAAE,KAAgD,CAAC;AAC1E,gCAAgC;AAChC,eAAO,MAAM,UAAU,EAAE,KAAgD,CAAC;AAC1E,gCAAgC;AAChC,eAAO,MAAM,UAAU,EAAE,KAA+C,CAAC;AAEzE,6BAA6B;AAC7B,MAAM,MAAM,SAAS,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAS3C,0CAA0C;AAC1C,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAEO,CAAC;AACzD,0CAA0C;AAC1C,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAEO,CAAC;AAEzD,uDAAuD;AACvD,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAEI,CAAC;AACzD,uDAAuD;AACvD,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAEI,CAAC"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/sha3.js

@@ -0,0 +1,254 @@
+/**
+ * SHA3 (keccak) hash function, based on a new "Sponge function" design.
+ * Different from older hashes, the internal state is bigger than output size.
+ *
+ * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+ * [Website](https://keccak.team/keccak.html),
+ * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+ *
+ * Check out `sha3-addons` module for cSHAKE, k12, and others.
+ * @module
+ */
+import { rotlBH, rotlBL, rotlSH, rotlSL, split } from "./_u64.js";
+// prettier-ignore
+import { abytes, aexists, anumber, aoutput, clean, createHasher, oidNist, swap32IfBE, u32 } from "./utils.js";
+// No __PURE__ annotations in sha3 header:
+// EVERYTHING is in fact used on every export.
+// Various per round constants calculations
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+const _7n = BigInt(7);
+const _256n = BigInt(256);
+const _0x71n = BigInt(0x71);
+const SHA3_PI = [];
+const SHA3_ROTL = [];
+const _SHA3_IOTA = []; // no pure annotation: var is always used
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+    // Pi
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI.push(2 * (5 * y + x));
+    // Rotational
+    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+    // Iota
+    let t = _0n;
+    for (let j = 0; j < 7; j++) {
+        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
+        if (R & _2n)
+            t ^= _1n << ((_1n << BigInt(j)) - _1n);
+    }
+    _SHA3_IOTA.push(t);
+}
+const IOTAS = split(_SHA3_IOTA, true);
+const SHA3_IOTA_H = IOTAS[0];
+const SHA3_IOTA_L = IOTAS[1];
+// Left rotation (without 0, 32, 64)
+const rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
+const rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
+/** `keccakf1600` internal function, additionally allows to adjust round count. */
+export function keccakP(s, rounds = 24) {
+    const 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 (let round = 24 - rounds; round < 24; round++) {
+        // Theta θ
+        for (let x = 0; x < 10; x++)
+            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+        for (let x = 0; x < 10; x += 2) {
+            const idx1 = (x + 8) % 10;
+            const idx0 = (x + 2) % 10;
+            const B0 = B[idx0];
+            const B1 = B[idx0 + 1];
+            const Th = rotlH(B0, B1, 1) ^ B[idx1];
+            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+            for (let y = 0; y < 50; y += 10) {
+                s[x + y] ^= Th;
+                s[x + y + 1] ^= Tl;
+            }
+        }
+        // Rho (ρ) and Pi (π)
+        let curH = s[2];
+        let curL = s[3];
+        for (let t = 0; t < 24; t++) {
+            const shift = SHA3_ROTL[t];
+            const Th = rotlH(curH, curL, shift);
+            const Tl = rotlL(curH, curL, shift);
+            const PI = SHA3_PI[t];
+            curH = s[PI];
+            curL = s[PI + 1];
+            s[PI] = Th;
+            s[PI + 1] = Tl;
+        }
+        // Chi (χ)
+        for (let y = 0; y < 50; y += 10) {
+            for (let x = 0; x < 10; x++)
+                B[x] = s[y + x];
+            for (let 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];
+    }
+    clean(B);
+}
+/** Keccak sponge function. */
+export class Keccak {
+    state;
+    pos = 0;
+    posOut = 0;
+    finished = false;
+    state32;
+    destroyed = false;
+    blockLen;
+    suffix;
+    outputLen;
+    enableXOF = false;
+    rounds;
+    // NOTE: we accept arguments in bytes instead of bits here.
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        // Can be passed from user as dkLen
+        anumber(outputLen, 'outputLen');
+        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
+        // 0 < blockLen < 200
+        if (!(0 < blockLen && blockLen < 200))
+            throw new Error('only keccak-f1600 function is supported');
+        this.state = new Uint8Array(200);
+        this.state32 = u32(this.state);
+    }
+    clone() {
+        return this._cloneInto();
+    }
+    keccak() {
+        swap32IfBE(this.state32);
+        keccakP(this.state32, this.rounds);
+        swap32IfBE(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+    }
+    update(data) {
+        aexists(this);
+        abytes(data);
+        const { blockLen, state } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            for (let i = 0; i < take; i++)
+                state[this.pos++] ^= data[pos++];
+            if (this.pos === blockLen)
+                this.keccak();
+        }
+        return this;
+    }
+    finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        // Do the padding
+        state[pos] ^= suffix;
+        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+            this.keccak();
+        state[blockLen - 1] ^= 0x80;
+        this.keccak();
+    }
+    writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len;) {
+            if (this.posOut >= blockLen)
+                this.keccak();
+            const 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;
+    }
+    xofInto(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);
+    }
+    xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+            throw new Error('digest() was already called');
+        this.writeInto(out);
+        this.destroy();
+        return out;
+    }
+    digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.state);
+    }
+    _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        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;
+    }
+}
+const genKeccak = (suffix, blockLen, outputLen, info = {}) => createHasher(() => new Keccak(blockLen, suffix, outputLen), info);
+/** SHA3-224 hash function. */
+export const sha3_224 = /* @__PURE__ */ genKeccak(0x06, 144, 28, 
+/* @__PURE__ */ oidNist(0x07));
+/** SHA3-256 hash function. Different from keccak-256. */
+export const sha3_256 = /* @__PURE__ */ genKeccak(0x06, 136, 32, 
+/* @__PURE__ */ oidNist(0x08));
+/** SHA3-384 hash function. */
+export const sha3_384 = /* @__PURE__ */ genKeccak(0x06, 104, 48, 
+/* @__PURE__ */ oidNist(0x09));
+/** SHA3-512 hash function. */
+export const sha3_512 = /* @__PURE__ */ genKeccak(0x06, 72, 64, 
+/* @__PURE__ */ oidNist(0x0a));
+/** keccak-224 hash function. */
+export const keccak_224 = /* @__PURE__ */ genKeccak(0x01, 144, 28);
+/** keccak-256 hash function. Different from SHA3-256. */
+export const keccak_256 = /* @__PURE__ */ genKeccak(0x01, 136, 32);
+/** keccak-384 hash function. */
+export const keccak_384 = /* @__PURE__ */ genKeccak(0x01, 104, 48);
+/** keccak-512 hash function. */
+export const keccak_512 = /* @__PURE__ */ genKeccak(0x01, 72, 64);
+const genShake = (suffix, blockLen, outputLen, info = {}) => createHasher((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true), info);
+/** SHAKE128 XOF with 128-bit security. */
+export const shake128 = 
+/* @__PURE__ */
+genShake(0x1f, 168, 16, /* @__PURE__ */ oidNist(0x0b));
+/** SHAKE256 XOF with 256-bit security. */
+export const shake256 = 
+/* @__PURE__ */
+genShake(0x1f, 136, 32, /* @__PURE__ */ oidNist(0x0c));
+/** SHAKE128 XOF with 256-bit output (NIST version). */
+export const shake128_32 = 
+/* @__PURE__ */
+genShake(0x1f, 168, 32, /* @__PURE__ */ oidNist(0x0b));
+/** SHAKE256 XOF with 512-bit output (NIST version). */
+export const shake256_64 = 
+/* @__PURE__ */
+genShake(0x1f, 136, 64, /* @__PURE__ */ oidNist(0x0c));
+//# sourceMappingURL=sha3.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/_blake.ts

@@ -0,0 +1,50 @@
+/**
+ * Internal helpers for blake hash.
+ * @module
+ */
+import { rotr } from './utils.ts';
+
+/**
+ * Internal blake variable.
+ * For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
+ */
+// prettier-ignore
+export const BSIGMA: Uint8Array = /* @__PURE__ */ Uint8Array.from([
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+  14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+  11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+  7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+  9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+  2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+  12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+  13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+  6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+  10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+  14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+  // Blake1, unused in others
+  11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+  7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+  9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+  2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+]);
+
+// prettier-ignore
+export type Num4 = { a: number; b: number; c: number; d: number; };
+
+// Mixing function G splitted in two halfs
+export function G1s(a: number, b: number, c: number, d: number, x: number): Num4 {
+  a = (a + b + x) | 0;
+  d = rotr(d ^ a, 16);
+  c = (c + d) | 0;
+  b = rotr(b ^ c, 12);
+  return { a, b, c, d };
+}
+
+export function G2s(a: number, b: number, c: number, d: number, x: number): Num4 {
+  a = (a + b + x) | 0;
+  d = rotr(d ^ a, 8);
+  c = (c + d) | 0;
+  b = rotr(b ^ c, 7);
+  return { a, b, c, d };
+}

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/_md.ts

@@ -0,0 +1,156 @@
+/**
+ * Internal Merkle-Damgard hash utils.
+ * @module
+ */
+import { abytes, aexists, aoutput, clean, createView, type Hash } from './utils.ts';
+
+/** Choice: a ? b : c */
+export function Chi(a: number, b: number, c: number): number {
+  return (a & b) ^ (~a & c);
+}
+
+/** Majority function, true if any two inputs is true. */
+export function Maj(a: number, b: number, c: number): number {
+  return (a & b) ^ (a & c) ^ (b & c);
+}
+
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+export abstract class HashMD<T extends HashMD<T>> implements Hash<T> {
+  protected abstract process(buf: DataView, offset: number): void;
+  protected abstract get(): number[];
+  protected abstract set(...args: number[]): void;
+  abstract destroy(): void;
+  protected abstract roundClean(): void;
+
+  readonly blockLen: number;
+  readonly outputLen: number;
+  readonly padOffset: number;
+  readonly isLE: boolean;
+
+  // For partial updates less than block size
+  protected buffer: Uint8Array;
+  protected view: DataView;
+  protected finished = false;
+  protected length = 0;
+  protected pos = 0;
+  protected destroyed = false;
+
+  constructor(blockLen: number, outputLen: number, padOffset: number, isLE: boolean) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data: Uint8Array): this {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      // Fast path: we have at least one block in input, cast it to view and process
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out: Uint8Array): void {
+    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;
+    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;
+    // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+    // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+    // So we just write lowest 64 bits of that value.
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), 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');
+    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);
+  }
+  digest(): Uint8Array {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to?: T): T {
+    to ||= new (this.constructor as any)() as T;
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen) to.buffer.set(buffer);
+    return to as unknown as any;
+  }
+  clone(): T {
+    return this._cloneInto();
+  }
+}
+
+/**
+ * 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. Bits 0..32 of frac part of sqrt of primes 2..19 */
+export const SHA256_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+
+/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */
+export const SHA224_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([
+  0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
+]);
+
+/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */
+export const SHA384_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([
+  0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,
+  0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,
+]);
+
+/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
+export const SHA512_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([
+  0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
+  0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
+]);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/_u64.ts

@@ -0,0 +1,91 @@
+/**
+ * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+ * @todo re-check https://issues.chromium.org/issues/42212588
+ * @module
+ */
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+
+function fromBig(
+  n: bigint,
+  le = false
+): {
+  h: number;
+  l: number;
+} {
+  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 };
+}
+
+function split(lst: bigint[], le = false): Uint32Array[] {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+
+const toBig = (h: number, l: number): bigint => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
+// for Shift in [0, 32)
+const shrSH = (h: number, _l: number, s: number): number => h >>> s;
+const shrSL = (h: number, l: number, s: number): number => (h << (32 - s)) | (l >>> s);
+// Right rotate for Shift in [1, 32)
+const rotrSH = (h: number, l: number, s: number): number => (h >>> s) | (l << (32 - s));
+const rotrSL = (h: number, l: number, s: number): number => (h << (32 - s)) | (l >>> s);
+// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotrBH = (h: number, l: number, s: number): number => (h << (64 - s)) | (l >>> (s - 32));
+const rotrBL = (h: number, l: number, s: number): number => (h >>> (s - 32)) | (l << (64 - s));
+// Right rotate for shift===32 (just swaps l&h)
+const rotr32H = (_h: number, l: number): number => l;
+const rotr32L = (h: number, _l: number): number => h;
+// Left rotate for Shift in [1, 32)
+const rotlSH = (h: number, l: number, s: number): number => (h << s) | (l >>> (32 - s));
+const rotlSL = (h: number, l: number, s: number): number => (l << s) | (h >>> (32 - s));
+// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotlBH = (h: number, l: number, s: number): number => (l << (s - 32)) | (h >>> (64 - s));
+const rotlBL = (h: number, l: number, s: number): number => (h << (s - 32)) | (l >>> (64 - s));
+
+// JS uses 32-bit signed integers for bitwise operations which means we cannot
+// simple take carry out of low bit sum by shift, we need to use division.
+function add(
+  Ah: number,
+  Al: number,
+  Bh: number,
+  Bl: number
+): {
+  h: number;
+  l: number;
+} {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+}
+// Addition with more than 2 elements
+const add3L = (Al: number, Bl: number, Cl: number): number => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low: number, Ah: number, Bh: number, Ch: number): number =>
+  (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+const add4L = (Al: number, Bl: number, Cl: number, Dl: number): number =>
+  (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low: number, Ah: number, Bh: number, Ch: number, Dh: number): number =>
+  (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+const add5L = (Al: number, Bl: number, Cl: number, Dl: number, El: number): number =>
+  (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number): number =>
+  (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
+};
+// prettier-ignore
+const u64: { fromBig: typeof fromBig; split: typeof split; toBig: (h: number, l: number) => bigint; shrSH: (h: number, _l: number, s: number) => number; shrSL: (h: number, l: number, s: number) => number; rotrSH: (h: number, l: number, s: number) => number; rotrSL: (h: number, l: number, s: number) => number; rotrBH: (h: number, l: number, s: number) => number; rotrBL: (h: number, l: number, s: number) => number; rotr32H: (_h: number, l: number) => number; rotr32L: (h: number, _l: number) => number; rotlSH: (h: number, l: number, s: number) => number; rotlSL: (h: number, l: number, s: number) => number; rotlBH: (h: number, l: number, s: number) => number; rotlBL: (h: number, l: number, s: number) => number; add: typeof add; add3L: (Al: number, Bl: number, Cl: number) => number; add3H: (low: number, Ah: number, Bh: number, Ch: number) => number; add4L: (Al: number, Bl: number, Cl: number, Dl: number) => number; add4H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number) => number; add5H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number) => number; add5L: (Al: number, Bl: number, Cl: number, Dl: number, El: number) => number; } = {
+  fromBig, split, toBig,
+  shrSH, shrSL,
+  rotrSH, rotrSL, rotrBH, rotrBL,
+  rotr32H, rotr32L,
+  rotlSH, rotlSL, rotlBH, rotlBL,
+  add, add3L, add3H, add4L, add4H, add5H, add5L,
+};
+export default u64;

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/argon2.ts

@@ -0,0 +1,493 @@
+/**
+ * Argon2 KDF from RFC 9106. Can be used to create a key from password and salt.
+ * We suggest to use Scrypt. JS Argon is 2-10x slower than native code because of 64-bitness:
+ * * argon uses uint64, but JS doesn't have fast uint64array
+ * * uint64 multiplication is 1/3 of time
+ * * `P` function would be very nice with u64, because most of value will be in registers,
+ *   hovewer with u32 it will require 32 registers, which is too much.
+ * * JS arrays do slow bound checks, so reading from `A2_BUF` slows it down
+ * @module
+ */
+import { add3H, add3L, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL } from './_u64.ts';
+import { blake2b } from './blake2.ts';
+import { anumber, clean, kdfInputToBytes, nextTick, u32, u8, type KDFInput } from './utils.ts';
+
+const AT = { Argond2d: 0, Argon2i: 1, Argon2id: 2 } as const;
+type Types = (typeof AT)[keyof typeof AT];
+
+const ARGON2_SYNC_POINTS = 4;
+const abytesOrZero = (buf?: KDFInput, errorTitle = '') => {
+  if (buf === undefined) return Uint8Array.of();
+  return kdfInputToBytes(buf, errorTitle);
+};
+
+// u32 * u32 = u64
+function mul(a: number, b: number) {
+  const aL = a & 0xffff;
+  const aH = a >>> 16;
+  const bL = b & 0xffff;
+  const bH = b >>> 16;
+  const ll = Math.imul(aL, bL);
+  const hl = Math.imul(aH, bL);
+  const lh = Math.imul(aL, bH);
+  const hh = Math.imul(aH, bH);
+  const carry = (ll >>> 16) + (hl & 0xffff) + lh;
+  const high = (hh + (hl >>> 16) + (carry >>> 16)) | 0;
+  const low = (carry << 16) | (ll & 0xffff);
+  return { h: high, l: low };
+}
+
+function mul2(a: number, b: number) {
+  // 2 * a * b (via shifts)
+  const { h, l } = mul(a, b);
+  return { h: ((h << 1) | (l >>> 31)) & 0xffff_ffff, l: (l << 1) & 0xffff_ffff };
+}
+
+// BlaMka permutation for Argon2
+// A + B + (2 * u32(A) * u32(B))
+function blamka(Ah: number, Al: number, Bh: number, Bl: number) {
+  const { h: Ch, l: Cl } = mul2(Al, Bl);
+  // A + B + (2 * A * B)
+  const Rll = add3L(Al, Bl, Cl);
+  return { h: add3H(Rll, Ah, Bh, Ch), l: Rll | 0 };
+}
+
+// Temporary block buffer
+const A2_BUF = new Uint32Array(256); // 1024 bytes (matrix 16x16)
+
+function G(a: number, b: number, c: number, d: number) {
+  let Al = A2_BUF[2*a], Ah = A2_BUF[2*a + 1]; // prettier-ignore
+  let Bl = A2_BUF[2*b], Bh = A2_BUF[2*b + 1]; // prettier-ignore
+  let Cl = A2_BUF[2*c], Ch = A2_BUF[2*c + 1]; // prettier-ignore
+  let Dl = A2_BUF[2*d], Dh = A2_BUF[2*d + 1]; // prettier-ignore
+
+  ({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh, Dl) });
+
+  ({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: rotrSH(Bh, Bl, 24), Bl: rotrSL(Bh, Bl, 24) });
+
+  ({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
+
+  ({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: rotrBH(Bh, Bl, 63), Bl: rotrBL(Bh, Bl, 63) });
+
+  ((A2_BUF[2 * a] = Al), (A2_BUF[2 * a + 1] = Ah));
+  ((A2_BUF[2 * b] = Bl), (A2_BUF[2 * b + 1] = Bh));
+  ((A2_BUF[2 * c] = Cl), (A2_BUF[2 * c + 1] = Ch));
+  ((A2_BUF[2 * d] = Dl), (A2_BUF[2 * d + 1] = Dh));
+}
+
+// prettier-ignore
+function P(
+  v00: number, v01: number, v02: number, v03: number, v04: number, v05: number, v06: number, v07: number,
+  v08: number, v09: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number,
+) {
+  G(v00, v04, v08, v12);
+  G(v01, v05, v09, v13);
+  G(v02, v06, v10, v14);
+  G(v03, v07, v11, v15);
+  G(v00, v05, v10, v15);
+  G(v01, v06, v11, v12);
+  G(v02, v07, v08, v13);
+  G(v03, v04, v09, v14);
+}
+
+function block(x: Uint32Array, xPos: number, yPos: number, outPos: number, needXor: boolean) {
+  for (let i = 0; i < 256; i++) A2_BUF[i] = x[xPos + i] ^ x[yPos + i];
+  // columns (8)
+  for (let i = 0; i < 128; i += 16) {
+    // prettier-ignore
+    P(
+      i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7,
+      i + 8, i + 9, i + 10, i + 11, i + 12, i + 13, i + 14, i + 15
+    );
+  }
+  // rows (8)
+  for (let i = 0; i < 16; i += 2) {
+    // prettier-ignore
+    P(
+      i, i + 1, i + 16, i + 17, i + 32, i + 33, i + 48, i + 49,
+      i + 64, i + 65, i + 80, i + 81, i + 96, i + 97, i + 112, i + 113
+    );
+  }
+
+  if (needXor) for (let i = 0; i < 256; i++) x[outPos + i] ^= A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+  else for (let i = 0; i < 256; i++) x[outPos + i] = A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
+  clean(A2_BUF);
+}
+
+// Variable-Length Hash Function H'
+function Hp(A: Uint32Array, dkLen: number) {
+  const A8 = u8(A);
+  const T = new Uint32Array(1);
+  const T8 = u8(T);
+  T[0] = dkLen;
+  // Fast path
+  if (dkLen <= 64) return blake2b.create({ dkLen }).update(T8).update(A8).digest();
+  const out = new Uint8Array(dkLen);
+  let V = blake2b.create({}).update(T8).update(A8).digest();
+  let pos = 0;
+  // First block
+  out.set(V.subarray(0, 32));
+  pos += 32;
+  // Rest blocks
+  for (; dkLen - pos > 64; pos += 32) {
+    const Vh = blake2b.create({}).update(V);
+    Vh.digestInto(V);
+    Vh.destroy();
+    out.set(V.subarray(0, 32), pos);
+  }
+  // Last block
+  out.set(blake2b(V, { dkLen: dkLen - pos }), pos);
+  clean(V, T);
+  return u32(out);
+}
+
+// Used only inside process block!
+function indexAlpha(
+  r: number,
+  s: number,
+  laneLen: number,
+  segmentLen: number,
+  index: number,
+  randL: number,
+  sameLane: boolean = false
+) {
+  // This is ugly, but close enough to reference implementation.
+  let area: number;
+  if (r === 0) {
+    if (s === 0) area = index - 1;
+    else if (sameLane) area = s * segmentLen + index - 1;
+    else area = s * segmentLen + (index == 0 ? -1 : 0);
+  } else if (sameLane) area = laneLen - segmentLen + index - 1;
+  else area = laneLen - segmentLen + (index == 0 ? -1 : 0);
+  const startPos = r !== 0 && s !== ARGON2_SYNC_POINTS - 1 ? (s + 1) * segmentLen : 0;
+  const rel = area - 1 - mul(area, mul(randL, randL).h).h;
+  return (startPos + rel) % laneLen;
+}
+
+/**
+ * Argon2 options.
+ * * t: time cost, m: mem cost in kb, p: parallelization.
+ * * key: optional key. personalization: arbitrary extra data.
+ * * dkLen: desired number of output bytes.
+ */
+export type ArgonOpts = {
+  t: number; // Time cost, iterations count
+  m: number; // Memory cost (in KB)
+  p: number; // Parallelization parameter
+  version?: number; // Default: 0x13 (19)
+  key?: KDFInput; // Optional key
+  personalization?: KDFInput; // Optional arbitrary extra data
+  dkLen?: number; // Desired number of returned bytes
+  asyncTick?: number; // Maximum time in ms for which async function can block execution
+  maxmem?: number;
+  onProgress?: (progress: number) => void;
+};
+
+const maxUint32 = Math.pow(2, 32);
+function isU32(num: number) {
+  return Number.isSafeInteger(num) && num >= 0 && num < maxUint32;
+}
+
+function argon2Opts(opts: ArgonOpts) {
+  const merged: any = {
+    version: 0x13,
+    dkLen: 32,
+    maxmem: maxUint32 - 1,
+    asyncTick: 10,
+  };
+  for (let [k, v] of Object.entries(opts)) if (v !== undefined) merged[k] = v;
+
+  const { dkLen, p, m, t, version, onProgress, asyncTick } = merged;
+  if (!isU32(dkLen) || dkLen < 4) throw new Error('"dkLen" must be 4..');
+  if (!isU32(p) || p < 1 || p >= Math.pow(2, 24)) throw new Error('"p" must be 1..2^24');
+  if (!isU32(m)) throw new Error('"m" must be 0..2^32');
+  if (!isU32(t) || t < 1) throw new Error('"t" (iterations) must be 1..2^32');
+  if (onProgress !== undefined && typeof onProgress !== 'function')
+    throw new Error('"progressCb" must be a function');
+  anumber(asyncTick, 'asyncTick');
+  /*
+  Memory size m MUST be an integer number of kibibytes from 8*p to 2^(32)-1. The actual number of blocks is m', which is m rounded down to the nearest multiple of 4*p.
+  */
+  if (!isU32(m) || m < 8 * p) throw new Error('"m" (memory) must be at least 8*p bytes');
+  if (version !== 0x10 && version !== 0x13)
+    throw new Error('"version" must be 0x10 or 0x13, got ' + version);
+  return merged;
+}
+
+function argon2Init(password: KDFInput, salt: KDFInput, type: Types, opts: ArgonOpts) {
+  password = kdfInputToBytes(password, 'password');
+  salt = kdfInputToBytes(salt, 'salt');
+  if (!isU32(password.length)) throw new Error('"password" must be less of length 1..4Gb');
+  if (!isU32(salt.length) || salt.length < 8) throw new Error('"salt" must be of length 8..4Gb');
+  if (!Object.values(AT).includes(type)) throw new Error('"type" was invalid');
+  let { p, dkLen, m, t, version, key, personalization, maxmem, onProgress, asyncTick } =
+    argon2Opts(opts);
+  // Validation
+  key = abytesOrZero(key, 'key');
+  personalization = abytesOrZero(personalization, 'personalization');
+  // H_0 = H^(64)(LE32(p) || LE32(T) || LE32(m) || LE32(t) ||
+  //       LE32(v) || LE32(y) || LE32(length(P)) || P ||
+  //       LE32(length(S)) || S ||  LE32(length(K)) || K ||
+  //       LE32(length(X)) || X)
+  const h = blake2b.create();
+  const BUF = new Uint32Array(1);
+  const BUF8 = u8(BUF);
+  for (let item of [p, dkLen, m, t, version, type]) {
+    BUF[0] = item;
+    h.update(BUF8);
+  }
+  for (let i of [password, salt, key, personalization]) {
+    BUF[0] = i.length; // BUF is u32 array, this is valid
+    h.update(BUF8).update(i);
+  }
+  const H0 = new Uint32Array(18);
+  const H0_8 = u8(H0);
+  h.digestInto(H0_8);
+  // 256 u32 = 1024 (BLOCK_SIZE), fills A2_BUF on processing
+
+  // Params
+  const lanes = p;
+  // m' = 4 * p * floor (m / 4p)
+  const mP = 4 * p * Math.floor(m / (ARGON2_SYNC_POINTS * p));
+  //q = m' / p columns
+  const laneLen = Math.floor(mP / p);
+  const segmentLen = Math.floor(laneLen / ARGON2_SYNC_POINTS);
+  const memUsed = mP * 256;
+  if (!isU32(maxmem) || memUsed > maxmem)
+    throw new Error('"maxmem" expected <2**32, got: maxmem=' + maxmem + ', memused=' + memUsed);
+  const B = new Uint32Array(memUsed);
+  // Fill first blocks
+  for (let l = 0; l < p; l++) {
+    const i = 256 * laneLen * l;
+    // B[i][0] = H'^(1024)(H_0 || LE32(0) || LE32(i))
+    H0[17] = l;
+    H0[16] = 0;
+    B.set(Hp(H0, 1024), i);
+    // B[i][1] = H'^(1024)(H_0 || LE32(1) || LE32(i))
+    H0[16] = 1;
+    B.set(Hp(H0, 1024), i + 256);
+  }
+  let perBlock = () => {};
+  if (onProgress) {
+    const totalBlock = t * ARGON2_SYNC_POINTS * p * segmentLen;
+    // Invoke callback if progress changes from 10.01 to 10.02
+    // Allows to draw smooth progress bar on up to 8K screen
+    const callbackPer = Math.max(Math.floor(totalBlock / 10000), 1);
+    let blockCnt = 0;
+    perBlock = () => {
+      blockCnt++;
+      if (onProgress && (!(blockCnt % callbackPer) || blockCnt === totalBlock))
+        onProgress(blockCnt / totalBlock);
+    };
+  }
+  clean(BUF, H0);
+  return { type, mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick };
+}
+
+function argon2Output(B: Uint32Array, p: number, laneLen: number, dkLen: number) {
+  const B_final = new Uint32Array(256);
+  for (let l = 0; l < p; l++)
+    for (let j = 0; j < 256; j++) B_final[j] ^= B[256 * (laneLen * l + laneLen - 1) + j];
+  const res = u8(Hp(B_final, dkLen));
+  clean(B_final);
+  return res;
+}
+
+function processBlock(
+  B: Uint32Array,
+  address: Uint32Array,
+  l: number,
+  r: number,
+  s: number,
+  index: number,
+  laneLen: number,
+  segmentLen: number,
+  lanes: number,
+  offset: number,
+  prev: number,
+  dataIndependent: boolean,
+  needXor: boolean
+) {
+  if (offset % laneLen) prev = offset - 1;
+  let randL, randH;
+  if (dataIndependent) {
+    let i128 = index % 128;
+    if (i128 === 0) {
+      address[256 + 12]++;
+      block(address, 256, 2 * 256, 0, false);
+      block(address, 0, 2 * 256, 0, false);
+    }
+    randL = address[2 * i128];
+    randH = address[2 * i128 + 1];
+  } else {
+    const T = 256 * prev;
+    randL = B[T];
+    randH = B[T + 1];
+  }
+  // address block
+  const refLane = r === 0 && s === 0 ? l : randH % lanes;
+  const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane == l);
+  const refBlock = laneLen * refLane + refPos;
+  // B[i][j] = G(B[i][j-1], B[l][z])
+  block(B, 256 * prev, 256 * refBlock, offset * 256, needXor);
+}
+
+function argon2(type: Types, password: KDFInput, salt: KDFInput, opts: ArgonOpts) {
+  const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock } = argon2Init(
+    password,
+    salt,
+    type,
+    opts
+  );
+  // Pre-loop setup
+  // [address, input, zero_block] format so we can pass single U32 to block function
+  const address = new Uint32Array(3 * 256);
+  address[256 + 6] = mP;
+  address[256 + 8] = t;
+  address[256 + 10] = type;
+  for (let r = 0; r < t; r++) {
+    const needXor = r !== 0 && version === 0x13;
+    address[256 + 0] = r;
+    for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
+      address[256 + 4] = s;
+      const dataIndependent = type == AT.Argon2i || (type == AT.Argon2id && r === 0 && s < 2);
+      for (let l = 0; l < p; l++) {
+        address[256 + 2] = l;
+        address[256 + 12] = 0;
+        let startPos = 0;
+        if (r === 0 && s === 0) {
+          startPos = 2;
+          if (dataIndependent) {
+            address[256 + 12]++;
+            block(address, 256, 2 * 256, 0, false);
+            block(address, 0, 2 * 256, 0, false);
+          }
+        }
+        // current block postion
+        let offset = l * laneLen + s * segmentLen + startPos;
+        // previous block position
+        let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
+        for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
+          perBlock();
+          processBlock(
+            B,
+            address,
+            l,
+            r,
+            s,
+            index,
+            laneLen,
+            segmentLen,
+            lanes,
+            offset,
+            prev,
+            dataIndependent,
+            needXor
+          );
+        }
+      }
+    }
+  }
+  clean(address);
+  return argon2Output(B, p, laneLen, dkLen);
+}
+
+/** argon2d GPU-resistant version. */
+export const argon2d = (password: KDFInput, salt: KDFInput, opts: ArgonOpts): Uint8Array =>
+  argon2(AT.Argond2d, password, salt, opts);
+/** argon2i side-channel-resistant version. */
+export const argon2i = (password: KDFInput, salt: KDFInput, opts: ArgonOpts): Uint8Array =>
+  argon2(AT.Argon2i, password, salt, opts);
+/** argon2id, combining i+d, the most popular version from RFC 9106 */
+export const argon2id = (password: KDFInput, salt: KDFInput, opts: ArgonOpts): Uint8Array =>
+  argon2(AT.Argon2id, password, salt, opts);
+
+async function argon2Async(type: Types, password: KDFInput, salt: KDFInput, opts: ArgonOpts) {
+  const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick } =
+    argon2Init(password, salt, type, opts);
+  // Pre-loop setup
+  // [address, input, zero_block] format so we can pass single U32 to block function
+  const address = new Uint32Array(3 * 256);
+  address[256 + 6] = mP;
+  address[256 + 8] = t;
+  address[256 + 10] = type;
+  let ts = Date.now();
+  for (let r = 0; r < t; r++) {
+    const needXor = r !== 0 && version === 0x13;
+    address[256 + 0] = r;
+    for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
+      address[256 + 4] = s;
+      const dataIndependent = type == AT.Argon2i || (type == AT.Argon2id && r === 0 && s < 2);
+      for (let l = 0; l < p; l++) {
+        address[256 + 2] = l;
+        address[256 + 12] = 0;
+        let startPos = 0;
+        if (r === 0 && s === 0) {
+          startPos = 2;
+          if (dataIndependent) {
+            address[256 + 12]++;
+            block(address, 256, 2 * 256, 0, false);
+            block(address, 0, 2 * 256, 0, false);
+          }
+        }
+        // current block postion
+        let offset = l * laneLen + s * segmentLen + startPos;
+        // previous block position
+        let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
+        for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
+          perBlock();
+          processBlock(
+            B,
+            address,
+            l,
+            r,
+            s,
+            index,
+            laneLen,
+            segmentLen,
+            lanes,
+            offset,
+            prev,
+            dataIndependent,
+            needXor
+          );
+          // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+          const diff = Date.now() - ts;
+          if (!(diff >= 0 && diff < asyncTick)) {
+            await nextTick();
+            ts += diff;
+          }
+        }
+      }
+    }
+  }
+  clean(address);
+  return argon2Output(B, p, laneLen, dkLen);
+}
+
+/** argon2d async GPU-resistant version. */
+export const argon2dAsync = (
+  password: KDFInput,
+  salt: KDFInput,
+  opts: ArgonOpts
+): Promise<Uint8Array> => argon2Async(AT.Argond2d, password, salt, opts);
+/** argon2i async side-channel-resistant version. */
+export const argon2iAsync = (
+  password: KDFInput,
+  salt: KDFInput,
+  opts: ArgonOpts
+): Promise<Uint8Array> => argon2Async(AT.Argon2i, password, salt, opts);
+/** argon2id async, combining i+d, the most popular version from RFC 9106 */
+export const argon2idAsync = (
+  password: KDFInput,
+  salt: KDFInput,
+  opts: ArgonOpts
+): Promise<Uint8Array> => argon2Async(AT.Argon2id, password, salt, opts);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/blake1.ts

@@ -0,0 +1,536 @@
+/**
+ * Blake1 legacy hash function, one of SHA3 proposals.
+ * Rarely used. Check out blake2 or blake3 instead.
+ * https://www.aumasson.jp/blake/blake.pdf
+ *
+ * In the best case, there are 0 allocations.
+ *
+ * Differences from blake2:
+ *
+ * - BE instead of LE
+ * - Paddings, similar to MD5, RIPEMD, SHA1, SHA2, but:
+ *     - length flag is located before actual length
+ *     - padding block is compressed differently (no lengths)
+ * Instead of msg[sigma[k]], we have `msg[sigma[k]] ^ constants[sigma[k-1]]`
+ * (-1 for g1, g2 without -1)
+ * - Salt is XOR-ed into constants instead of state
+ * - Salt is XOR-ed with output in `compress`
+ * - Additional rows (+64 bytes) in SIGMA for new rounds
+ * - Different round count:
+ *     - 14 / 10 rounds in blake256 / blake2s
+ *     - 16 / 12 rounds in blake512 / blake2b
+ * - blake512: G1b: rotr 24 -> 25, G2b: rotr 63 -> 11
+ * @module
+ */
+import { BSIGMA, G1s, G2s } from './_blake.ts';
+import { SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from './_md.ts';
+import * as u64 from './_u64.ts';
+// prettier-ignore
+import {
+  abytes, aexists, aoutput,
+  clean, createHasher,
+  createView,
+  type CHash,
+  type Hash
+} from './utils.ts';
+
+/** Blake1 options. Basically just "salt" */
+export type BlakeOpts = {
+  salt?: Uint8Array;
+};
+
+// Empty zero-filled salt
+const EMPTY_SALT = /* @__PURE__ */ new Uint32Array(8);
+
+abstract class BLAKE1<T extends BLAKE1<T>> implements Hash<T> {
+  protected finished = false;
+  protected length = 0;
+  protected pos = 0;
+  protected destroyed = false;
+  // For partial updates less than block size
+  protected buffer: Uint8Array;
+  protected view: DataView;
+  protected salt: Uint32Array;
+  abstract compress(view: DataView, offset: number, withLength?: boolean): void;
+  protected abstract get(): number[];
+  protected abstract set(...args: number[]): void;
+
+  readonly blockLen: number;
+  readonly outputLen: number;
+  private lengthFlag: number;
+  private counterLen: number;
+  protected constants: Uint32Array;
+
+  constructor(
+    blockLen: number,
+    outputLen: number,
+    lengthFlag: number,
+    counterLen: number,
+    saltLen: number,
+    constants: Uint32Array,
+    opts: BlakeOpts = {}
+  ) {
+    const { salt } = opts;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.lengthFlag = lengthFlag;
+    this.counterLen = counterLen;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+    if (salt !== undefined) {
+      let slt = salt;
+      abytes(slt, 4 * saltLen, 'salt');
+      // if (slt.length !== 4 * saltLen) throw new Error('wrong salt length');
+      const salt32 = (this.salt = new Uint32Array(saltLen));
+      const sv = createView(slt);
+      this.constants = constants.slice();
+      for (let i = 0, offset = 0; i < salt32.length; i++, offset += 4) {
+        salt32[i] = sv.getUint32(offset, false);
+        this.constants[i] ^= salt32[i];
+      }
+    } else {
+      this.salt = EMPTY_SALT;
+      this.constants = constants;
+    }
+  }
+  update(data: Uint8Array): this {
+    aexists(this);
+    abytes(data);
+    // From _md, but update length before each compress
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    let dataView;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      // Fast path: we have at least one block in input, cast it to view and process
+      if (take === blockLen) {
+        if (!dataView) dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen) {
+          this.length += blockLen;
+          this.compress(dataView, pos);
+        }
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.length += blockLen;
+        this.compress(view, 0, true);
+        this.pos = 0;
+      }
+    }
+    return this;
+  }
+  destroy(): void {
+    this.destroyed = true;
+    if (this.salt !== EMPTY_SALT) {
+      clean(this.salt, this.constants);
+    }
+  }
+  _cloneInto(to?: T): T {
+    to ||= new (this.constructor as any)() as T;
+    to.set(...this.get());
+    const { buffer, length, finished, destroyed, constants, salt, pos } = this;
+    to.buffer.set(buffer);
+    to.constants = constants.slice();
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    to.salt = salt.slice();
+    return to;
+  }
+  clone(): T {
+    return this._cloneInto();
+  }
+  digestInto(out: Uint8Array): void {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    // Padding
+    const { buffer, blockLen, counterLen, lengthFlag, view } = this;
+    clean(buffer.subarray(this.pos)); // clean buf
+    const counter = BigInt((this.length + this.pos) * 8);
+    const counterPos = blockLen - counterLen - 1;
+    buffer[this.pos] |= 0b1000_0000; // End block flag
+    this.length += this.pos; // add unwritten length
+    // Not enough in buffer for length: write what we have.
+    if (this.pos > counterPos) {
+      this.compress(view, 0);
+      clean(buffer);
+      this.pos = 0;
+    }
+    // Difference with md: here we have lengthFlag!
+    buffer[counterPos] |= lengthFlag; // Length flag
+    // We always set 8 byte length flag. Because length will overflow significantly sooner.
+    view.setBigUint64(blockLen - 8, counter, false);
+    this.compress(view, 0, this.pos !== 0); // don't add length if length is not empty block?
+    // Write output
+    clean(buffer);
+    const v = createView(out);
+    const state = this.get();
+    for (let i = 0; i < this.outputLen / 4; ++i) v.setUint32(i * 4, state[i]);
+  }
+  digest(): Uint8Array {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+}
+
+// Constants
+const B64C = /* @__PURE__ */ Uint32Array.from([
+  0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+  0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+  0x9216d5d9, 0x8979fb1b, 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96,
+  0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 0x636920d8, 0x71574e69,
+]);
+// first half of C512
+const B32C = B64C.slice(0, 16);
+
+const B256_IV = /* @__PURE__ */ SHA256_IV.slice();
+const B224_IV = /* @__PURE__ */ SHA224_IV.slice();
+const B384_IV = /* @__PURE__ */ SHA384_IV.slice();
+const B512_IV = /* @__PURE__ */ SHA512_IV.slice();
+
+function generateTBL256() {
+  const TBL = [];
+  for (let i = 0, j = 0; i < 14; i++, j += 16) {
+    for (let offset = 1; offset < 16; offset += 2) {
+      TBL.push(B32C[BSIGMA[j + offset]]);
+      TBL.push(B32C[BSIGMA[j + offset - 1]]);
+    }
+  }
+  return new Uint32Array(TBL);
+}
+const TBL256 = /* @__PURE__ */ generateTBL256(); // C256[SIGMA[X]] precompute
+
+// Reusable temporary buffer
+const BLAKE256_W = /* @__PURE__ */ new Uint32Array(16);
+
+class BLAKE1_32B extends BLAKE1<BLAKE1_32B> {
+  private v0: number;
+  private v1: number;
+  private v2: number;
+  private v3: number;
+  private v4: number;
+  private v5: number;
+  private v6: number;
+  private v7: number;
+  constructor(outputLen: number, IV: Uint32Array, lengthFlag: number, opts: BlakeOpts = {}) {
+    super(64, outputLen, lengthFlag, 8, 4, B32C, opts);
+    this.v0 = IV[0] | 0;
+    this.v1 = IV[1] | 0;
+    this.v2 = IV[2] | 0;
+    this.v3 = IV[3] | 0;
+    this.v4 = IV[4] | 0;
+    this.v5 = IV[5] | 0;
+    this.v6 = IV[6] | 0;
+    this.v7 = IV[7] | 0;
+  }
+  protected get(): [number, number, number, number, number, number, number, number] {
+    const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
+    return [v0, v1, v2, v3, v4, v5, v6, v7];
+  }
+  // prettier-ignore
+  protected set(
+    v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number
+  ): void {
+    this.v0 = v0 | 0;
+    this.v1 = v1 | 0;
+    this.v2 = v2 | 0;
+    this.v3 = v3 | 0;
+    this.v4 = v4 | 0;
+    this.v5 = v5 | 0;
+    this.v6 = v6 | 0;
+    this.v7 = v7 | 0;
+  }
+  destroy(): void {
+    super.destroy();
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+  }
+  compress(view: DataView, offset: number, withLength = true): void {
+    for (let i = 0; i < 16; i++, offset += 4) BLAKE256_W[i] = view.getUint32(offset, false);
+    // NOTE: we cannot re-use compress from blake2s, since there is additional xor over u256[SIGMA[e]]
+    let v00 = this.v0 | 0;
+    let v01 = this.v1 | 0;
+    let v02 = this.v2 | 0;
+    let v03 = this.v3 | 0;
+    let v04 = this.v4 | 0;
+    let v05 = this.v5 | 0;
+    let v06 = this.v6 | 0;
+    let v07 = this.v7 | 0;
+    let v08 = this.constants[0] | 0;
+    let v09 = this.constants[1] | 0;
+    let v10 = this.constants[2] | 0;
+    let v11 = this.constants[3] | 0;
+    const { h, l } = u64.fromBig(BigInt(withLength ? this.length * 8 : 0));
+    let v12 = (this.constants[4] ^ l) >>> 0;
+    let v13 = (this.constants[5] ^ l) >>> 0;
+    let v14 = (this.constants[6] ^ h) >>> 0;
+    let v15 = (this.constants[7] ^ h) >>> 0;
+    // prettier-ignore
+    for (let i = 0, k = 0, j = 0; i < 14; i++) {
+      ({ a: v00, b: v04, c: v08, d: v12 } = G1s(v00, v04, v08, v12, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v00, b: v04, c: v08, d: v12 } = G2s(v00, v04, v08, v12, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v01, b: v05, c: v09, d: v13 } = G1s(v01, v05, v09, v13, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v01, b: v05, c: v09, d: v13 } = G2s(v01, v05, v09, v13, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v02, b: v06, c: v10, d: v14 } = G1s(v02, v06, v10, v14, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v02, b: v06, c: v10, d: v14 } = G2s(v02, v06, v10, v14, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v03, b: v07, c: v11, d: v15 } = G1s(v03, v07, v11, v15, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v03, b: v07, c: v11, d: v15 } = G2s(v03, v07, v11, v15, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v00, b: v05, c: v10, d: v15 } = G1s(v00, v05, v10, v15, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v00, b: v05, c: v10, d: v15 } = G2s(v00, v05, v10, v15, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v01, b: v06, c: v11, d: v12 } = G1s(v01, v06, v11, v12, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v01, b: v06, c: v11, d: v12 } = G2s(v01, v06, v11, v12, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v02, b: v07, c: v08, d: v13 } = G1s(v02, v07, v08, v13, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v02, b: v07, c: v08, d: v13 } = G2s(v02, v07, v08, v13, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v03, b: v04, c: v09, d: v14 } = G1s(v03, v04, v09, v14, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+      ({ a: v03, b: v04, c: v09, d: v14 } = G2s(v03, v04, v09, v14, BLAKE256_W[BSIGMA[k++]] ^ TBL256[j++]));
+    }
+    this.v0 = (this.v0 ^ v00 ^ v08 ^ this.salt[0]) >>> 0;
+    this.v1 = (this.v1 ^ v01 ^ v09 ^ this.salt[1]) >>> 0;
+    this.v2 = (this.v2 ^ v02 ^ v10 ^ this.salt[2]) >>> 0;
+    this.v3 = (this.v3 ^ v03 ^ v11 ^ this.salt[3]) >>> 0;
+    this.v4 = (this.v4 ^ v04 ^ v12 ^ this.salt[0]) >>> 0;
+    this.v5 = (this.v5 ^ v05 ^ v13 ^ this.salt[1]) >>> 0;
+    this.v6 = (this.v6 ^ v06 ^ v14 ^ this.salt[2]) >>> 0;
+    this.v7 = (this.v7 ^ v07 ^ v15 ^ this.salt[3]) >>> 0;
+    clean(BLAKE256_W);
+  }
+}
+
+const BBUF = /* @__PURE__ */ new Uint32Array(32);
+const BLAKE512_W = /* @__PURE__ */ new Uint32Array(32);
+
+function generateTBL512() {
+  const TBL = [];
+  for (let r = 0, k = 0; r < 16; r++, k += 16) {
+    for (let offset = 1; offset < 16; offset += 2) {
+      TBL.push(B64C[BSIGMA[k + offset] * 2 + 0]);
+      TBL.push(B64C[BSIGMA[k + offset] * 2 + 1]);
+      TBL.push(B64C[BSIGMA[k + offset - 1] * 2 + 0]);
+      TBL.push(B64C[BSIGMA[k + offset - 1] * 2 + 1]);
+    }
+  }
+  return new Uint32Array(TBL);
+}
+const TBL512 = /* @__PURE__ */ generateTBL512(); // C512[SIGMA[X]] precompute
+
+// Mixing function G splitted in two halfs
+function G1b(a: number, b: number, c: number, d: number, msg: Uint32Array, k: number) {
+  const Xpos = 2 * BSIGMA[k];
+  const Xl = msg[Xpos + 1] ^ TBL512[k * 2 + 1], Xh = msg[Xpos] ^ TBL512[k * 2]; // prettier-ignore
+  let Al = BBUF[2 * a + 1], Ah = BBUF[2 * a]; // prettier-ignore
+  let Bl = BBUF[2 * b + 1], Bh = BBUF[2 * b]; // prettier-ignore
+  let Cl = BBUF[2 * c + 1], Ch = BBUF[2 * c]; // prettier-ignore
+  let Dl = BBUF[2 * d + 1], Dh = BBUF[2 * d]; // prettier-ignore
+  // v[a] = (v[a] + v[b] + x) | 0;
+  let ll = u64.add3L(Al, Bl, Xl);
+  Ah = u64.add3H(ll, Ah, Bh, Xh) >>> 0;
+  Al = (ll | 0) >>> 0;
+  // v[d] = rotr(v[d] ^ v[a], 32)
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: u64.rotr32H(Dh, Dl), Dl: u64.rotr32L(Dh, Dl) });
+  // v[c] = (v[c] + v[d]) | 0;
+  ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+  // v[b] = rotr(v[b] ^ v[c], 25)
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 25), Bl: u64.rotrSL(Bh, Bl, 25) });
+  ((BBUF[2 * a + 1] = Al), (BBUF[2 * a] = Ah));
+  ((BBUF[2 * b + 1] = Bl), (BBUF[2 * b] = Bh));
+  ((BBUF[2 * c + 1] = Cl), (BBUF[2 * c] = Ch));
+  ((BBUF[2 * d + 1] = Dl), (BBUF[2 * d] = Dh));
+}
+
+function G2b(a: number, b: number, c: number, d: number, msg: Uint32Array, k: number) {
+  const Xpos = 2 * BSIGMA[k];
+  const Xl = msg[Xpos + 1] ^ TBL512[k * 2 + 1], Xh = msg[Xpos] ^ TBL512[k * 2]; // prettier-ignore
+  let Al = BBUF[2 * a + 1], Ah = BBUF[2 * a]; // prettier-ignore
+  let Bl = BBUF[2 * b + 1], Bh = BBUF[2 * b]; // prettier-ignore
+  let Cl = BBUF[2 * c + 1], Ch = BBUF[2 * c]; // prettier-ignore
+  let Dl = BBUF[2 * d + 1], Dh = BBUF[2 * d]; // prettier-ignore
+  // v[a] = (v[a] + v[b] + x) | 0;
+  let ll = u64.add3L(Al, Bl, Xl);
+  Ah = u64.add3H(ll, Ah, Bh, Xh);
+  Al = ll | 0;
+  // v[d] = rotr(v[d] ^ v[a], 16)
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: u64.rotrSH(Dh, Dl, 16), Dl: u64.rotrSL(Dh, Dl, 16) });
+  // v[c] = (v[c] + v[d]) | 0;
+  ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+  // v[b] = rotr(v[b] ^ v[c], 11)
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 11), Bl: u64.rotrSL(Bh, Bl, 11) });
+  ((BBUF[2 * a + 1] = Al), (BBUF[2 * a] = Ah));
+  ((BBUF[2 * b + 1] = Bl), (BBUF[2 * b] = Bh));
+  ((BBUF[2 * c + 1] = Cl), (BBUF[2 * c] = Ch));
+  ((BBUF[2 * d + 1] = Dl), (BBUF[2 * d] = Dh));
+}
+
+class BLAKE1_64B extends BLAKE1<BLAKE1_64B> {
+  private v0l: number;
+  private v0h: number;
+  private v1l: number;
+  private v1h: number;
+  private v2l: number;
+  private v2h: number;
+  private v3l: number;
+  private v3h: number;
+  private v4l: number;
+  private v4h: number;
+  private v5l: number;
+  private v5h: number;
+  private v6l: number;
+  private v6h: number;
+  private v7l: number;
+  private v7h: number;
+  constructor(outputLen: number, IV: Uint32Array, lengthFlag: number, opts: BlakeOpts = {}) {
+    super(128, outputLen, lengthFlag, 16, 8, B64C, opts);
+    this.v0l = IV[0] | 0;
+    this.v0h = IV[1] | 0;
+    this.v1l = IV[2] | 0;
+    this.v1h = IV[3] | 0;
+    this.v2l = IV[4] | 0;
+    this.v2h = IV[5] | 0;
+    this.v3l = IV[6] | 0;
+    this.v3h = IV[7] | 0;
+    this.v4l = IV[8] | 0;
+    this.v4h = IV[9] | 0;
+    this.v5l = IV[10] | 0;
+    this.v5h = IV[11] | 0;
+    this.v6l = IV[12] | 0;
+    this.v6h = IV[13] | 0;
+    this.v7l = IV[14] | 0;
+    this.v7h = IV[15] | 0;
+  }
+  // prettier-ignore
+  protected get(): [
+    number, number, number, number, number, number, number, number,
+    number, number, number, number, number, number, number, number
+  ] {
+    let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+    return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+  }
+  // prettier-ignore
+  protected set(
+    v0l: number, v0h: number, v1l: number, v1h: number,
+    v2l: number, v2h: number, v3l: number, v3h: number,
+    v4l: number, v4h: number, v5l: number, v5h: number,
+    v6l: number, v6h: number, v7l: number, v7h: number
+  ): void {
+    this.v0l = v0l | 0;
+    this.v0h = v0h | 0;
+    this.v1l = v1l | 0;
+    this.v1h = v1h | 0;
+    this.v2l = v2l | 0;
+    this.v2h = v2h | 0;
+    this.v3l = v3l | 0;
+    this.v3h = v3h | 0;
+    this.v4l = v4l | 0;
+    this.v4h = v4h | 0;
+    this.v5l = v5l | 0;
+    this.v5h = v5h | 0;
+    this.v6l = v6l | 0;
+    this.v6h = v6h | 0;
+    this.v7l = v7l | 0;
+    this.v7h = v7h | 0;
+  }
+  destroy(): void {
+    super.destroy();
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+  compress(view: DataView, offset: number, withLength = true): void {
+    for (let i = 0; i < 32; i++, offset += 4) BLAKE512_W[i] = view.getUint32(offset, false);
+
+    this.get().forEach((v, i) => (BBUF[i] = v)); // First half from state.
+    BBUF.set(this.constants.subarray(0, 16), 16);
+    if (withLength) {
+      const { h, l } = u64.fromBig(BigInt(this.length * 8));
+      BBUF[24] = (BBUF[24] ^ h) >>> 0;
+      BBUF[25] = (BBUF[25] ^ l) >>> 0;
+      BBUF[26] = (BBUF[26] ^ h) >>> 0;
+      BBUF[27] = (BBUF[27] ^ l) >>> 0;
+    }
+    for (let i = 0, k = 0; i < 16; i++) {
+      G1b(0, 4, 8, 12, BLAKE512_W, k++);
+      G2b(0, 4, 8, 12, BLAKE512_W, k++);
+      G1b(1, 5, 9, 13, BLAKE512_W, k++);
+      G2b(1, 5, 9, 13, BLAKE512_W, k++);
+      G1b(2, 6, 10, 14, BLAKE512_W, k++);
+      G2b(2, 6, 10, 14, BLAKE512_W, k++);
+      G1b(3, 7, 11, 15, BLAKE512_W, k++);
+      G2b(3, 7, 11, 15, BLAKE512_W, k++);
+
+      G1b(0, 5, 10, 15, BLAKE512_W, k++);
+      G2b(0, 5, 10, 15, BLAKE512_W, k++);
+      G1b(1, 6, 11, 12, BLAKE512_W, k++);
+      G2b(1, 6, 11, 12, BLAKE512_W, k++);
+      G1b(2, 7, 8, 13, BLAKE512_W, k++);
+      G2b(2, 7, 8, 13, BLAKE512_W, k++);
+      G1b(3, 4, 9, 14, BLAKE512_W, k++);
+      G2b(3, 4, 9, 14, BLAKE512_W, k++);
+    }
+    this.v0l ^= BBUF[0] ^ BBUF[16] ^ this.salt[0];
+    this.v0h ^= BBUF[1] ^ BBUF[17] ^ this.salt[1];
+    this.v1l ^= BBUF[2] ^ BBUF[18] ^ this.salt[2];
+    this.v1h ^= BBUF[3] ^ BBUF[19] ^ this.salt[3];
+    this.v2l ^= BBUF[4] ^ BBUF[20] ^ this.salt[4];
+    this.v2h ^= BBUF[5] ^ BBUF[21] ^ this.salt[5];
+    this.v3l ^= BBUF[6] ^ BBUF[22] ^ this.salt[6];
+    this.v3h ^= BBUF[7] ^ BBUF[23] ^ this.salt[7];
+    this.v4l ^= BBUF[8] ^ BBUF[24] ^ this.salt[0];
+    this.v4h ^= BBUF[9] ^ BBUF[25] ^ this.salt[1];
+    this.v5l ^= BBUF[10] ^ BBUF[26] ^ this.salt[2];
+    this.v5h ^= BBUF[11] ^ BBUF[27] ^ this.salt[3];
+    this.v6l ^= BBUF[12] ^ BBUF[28] ^ this.salt[4];
+    this.v6h ^= BBUF[13] ^ BBUF[29] ^ this.salt[5];
+    this.v7l ^= BBUF[14] ^ BBUF[30] ^ this.salt[6];
+    this.v7h ^= BBUF[15] ^ BBUF[31] ^ this.salt[7];
+    clean(BBUF, BLAKE512_W);
+  }
+}
+
+/** Internal blake1-224 hash class. */
+export class _BLAKE224 extends BLAKE1_32B {
+  constructor(opts: BlakeOpts = {}) {
+    super(28, B224_IV, 0b0000_0000, opts);
+  }
+}
+/** Internal blake1-256 hash class. */
+export class _BLAKE256 extends BLAKE1_32B {
+  constructor(opts: BlakeOpts = {}) {
+    super(32, B256_IV, 0b0000_0001, opts);
+  }
+}
+/** Internal blake1-384 hash class. */
+export class _BLAKE384 extends BLAKE1_64B {
+  constructor(opts: BlakeOpts = {}) {
+    super(48, B384_IV, 0b0000_0000, opts);
+  }
+}
+/** Internal blake1-512 hash class. */
+export class _BLAKE512 extends BLAKE1_64B {
+  constructor(opts: BlakeOpts = {}) {
+    super(64, B512_IV, 0b0000_0001, opts);
+  }
+}
+/** blake1-224 hash function */
+export const blake224: CHash<_BLAKE224, BlakeOpts> = /* @__PURE__ */ createHasher(
+  (opts) => new _BLAKE224(opts)
+);
+/** blake1-256 hash function */
+export const blake256: CHash<_BLAKE256, BlakeOpts> = /* @__PURE__ */ createHasher(
+  (opts) => new _BLAKE256(opts)
+);
+/** blake1-384 hash function */
+export const blake384: CHash<_BLAKE384, BlakeOpts> = /* @__PURE__ */ createHasher(
+  (opts) => new _BLAKE384(opts)
+);
+/** blake1-512 hash function */
+export const blake512: CHash<_BLAKE512, BlakeOpts> = /* @__PURE__ */ createHasher(
+  (opts) => new _BLAKE512(opts)
+);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/blake2.ts

@@ -0,0 +1,489 @@
+/**
+ * blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.
+ * b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.
+ * @module
+ */
+import { BSIGMA, G1s, G2s } from './_blake.ts';
+import { SHA256_IV } from './_md.ts';
+import * as u64 from './_u64.ts';
+// prettier-ignore
+import {
+  abytes, aexists, anumber, aoutput,
+  clean, createHasher,
+  swap32IfBE, swap8IfBE,
+  u32,
+  type CHash,
+  type Hash
+} from './utils.ts';
+
+/** Blake hash options. dkLen is output length. key is used in MAC mode. salt is used in KDF mode. */
+export type Blake2Opts = {
+  dkLen?: number;
+  key?: Uint8Array;
+  salt?: Uint8Array;
+  personalization?: Uint8Array;
+};
+
+// Same as SHA512_IV, but swapped endianness: LE instead of BE. iv[1] is iv[0], etc.
+const B2B_IV = /* @__PURE__ */ Uint32Array.from([
+  0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,
+  0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,
+]);
+// Temporary buffer
+const BBUF = /* @__PURE__ */ new Uint32Array(32);
+
+// Mixing function G splitted in two halfs
+function G1b(a: number, b: number, c: number, d: number, msg: Uint32Array, x: number) {
+  // NOTE: V is LE here
+  const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore
+  let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore
+  let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore
+  let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore
+  let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore
+  // v[a] = (v[a] + v[b] + x) | 0;
+  let ll = u64.add3L(Al, Bl, Xl);
+  Ah = u64.add3H(ll, Ah, Bh, Xh);
+  Al = ll | 0;
+  // v[d] = rotr(v[d] ^ v[a], 32)
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: u64.rotr32H(Dh, Dl), Dl: u64.rotr32L(Dh, Dl) });
+  // v[c] = (v[c] + v[d]) | 0;
+  ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+  // v[b] = rotr(v[b] ^ v[c], 24)
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 24), Bl: u64.rotrSL(Bh, Bl, 24) });
+  ((BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah));
+  ((BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh));
+  ((BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch));
+  ((BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh));
+}
+
+function G2b(a: number, b: number, c: number, d: number, msg: Uint32Array, x: number) {
+  // NOTE: V is LE here
+  const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore
+  let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore
+  let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore
+  let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore
+  let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore
+  // v[a] = (v[a] + v[b] + x) | 0;
+  let ll = u64.add3L(Al, Bl, Xl);
+  Ah = u64.add3H(ll, Ah, Bh, Xh);
+  Al = ll | 0;
+  // v[d] = rotr(v[d] ^ v[a], 16)
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+  ({ Dh, Dl } = { Dh: u64.rotrSH(Dh, Dl, 16), Dl: u64.rotrSL(Dh, Dl, 16) });
+  // v[c] = (v[c] + v[d]) | 0;
+  ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+  // v[b] = rotr(v[b] ^ v[c], 63)
+  ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+  ({ Bh, Bl } = { Bh: u64.rotrBH(Bh, Bl, 63), Bl: u64.rotrBL(Bh, Bl, 63) });
+  ((BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah));
+  ((BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh));
+  ((BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch));
+  ((BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh));
+}
+
+function checkBlake2Opts(
+  outputLen: number,
+  opts: Blake2Opts | undefined = {},
+  keyLen: number,
+  saltLen: number,
+  persLen: number
+) {
+  anumber(keyLen);
+  if (outputLen < 0 || outputLen > keyLen) throw new Error('outputLen bigger than keyLen');
+  const { key, salt, personalization } = opts;
+  if (key !== undefined && (key.length < 1 || key.length > keyLen))
+    throw new Error('"key" expected to be undefined or of length=1..' + keyLen);
+  if (salt !== undefined) abytes(salt, saltLen, 'salt');
+  if (personalization !== undefined) abytes(personalization, persLen, 'personalization');
+}
+
+/** Internal base class for BLAKE2. */
+export abstract class _BLAKE2<T extends _BLAKE2<T>> implements Hash<T> {
+  protected abstract compress(msg: Uint32Array, offset: number, isLast: boolean): void;
+  protected abstract get(): number[];
+  protected abstract set(...args: number[]): void;
+  abstract destroy(): void;
+  protected buffer: Uint8Array;
+  protected buffer32: Uint32Array;
+  protected finished = false;
+  protected destroyed = false;
+  protected length: number = 0;
+  protected pos: number = 0;
+  readonly blockLen: number;
+  readonly outputLen: number;
+
+  constructor(blockLen: number, outputLen: number) {
+    anumber(blockLen);
+    anumber(outputLen);
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.buffer = new Uint8Array(blockLen);
+    this.buffer32 = u32(this.buffer);
+  }
+  update(data: Uint8Array): this {
+    aexists(this);
+    abytes(data);
+    // Main difference with other hashes: there is flag for last block,
+    // so we cannot process current block before we know that there
+    // is the next one. This significantly complicates logic and reduces ability
+    // to do zero-copy processing
+    const { blockLen, buffer, buffer32 } = this;
+    const len = data.length;
+    const offset = data.byteOffset;
+    const buf = data.buffer;
+    for (let pos = 0; pos < len; ) {
+      // If buffer is full and we still have input (don't process last block, same as blake2s)
+      if (this.pos === blockLen) {
+        swap32IfBE(buffer32);
+        this.compress(buffer32, 0, false);
+        swap32IfBE(buffer32);
+        this.pos = 0;
+      }
+      const take = Math.min(blockLen - this.pos, len - pos);
+      const dataOffset = offset + pos;
+      // full block && aligned to 4 bytes && not last in input
+      if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+        const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+        swap32IfBE(data32);
+        for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+          this.length += blockLen;
+          this.compress(data32, pos32, false);
+        }
+        swap32IfBE(data32);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      this.length += take;
+      pos += take;
+    }
+    return this;
+  }
+  digestInto(out: Uint8Array): void {
+    aexists(this);
+    aoutput(out, this);
+    const { pos, buffer32 } = this;
+    this.finished = true;
+    // Padding
+    clean(this.buffer.subarray(pos));
+    swap32IfBE(buffer32);
+    this.compress(buffer32, 0, true);
+    swap32IfBE(buffer32);
+    const out32 = u32(out);
+    this.get().forEach((v, i) => (out32[i] = swap8IfBE(v)));
+  }
+  digest(): Uint8Array {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to?: T): T {
+    const { buffer, length, finished, destroyed, outputLen, pos } = this;
+    to ||= new (this.constructor as any)({ dkLen: outputLen }) as T;
+    to.set(...this.get());
+    to.buffer.set(buffer);
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    // @ts-ignore
+    to.outputLen = outputLen;
+    return to;
+  }
+  clone(): T {
+    return this._cloneInto();
+  }
+}
+
+/** Internal blake2b hash class. */
+export class _BLAKE2b extends _BLAKE2<_BLAKE2b> {
+  // Same as SHA-512, but LE
+  private v0l = B2B_IV[0] | 0;
+  private v0h = B2B_IV[1] | 0;
+  private v1l = B2B_IV[2] | 0;
+  private v1h = B2B_IV[3] | 0;
+  private v2l = B2B_IV[4] | 0;
+  private v2h = B2B_IV[5] | 0;
+  private v3l = B2B_IV[6] | 0;
+  private v3h = B2B_IV[7] | 0;
+  private v4l = B2B_IV[8] | 0;
+  private v4h = B2B_IV[9] | 0;
+  private v5l = B2B_IV[10] | 0;
+  private v5h = B2B_IV[11] | 0;
+  private v6l = B2B_IV[12] | 0;
+  private v6h = B2B_IV[13] | 0;
+  private v7l = B2B_IV[14] | 0;
+  private v7h = B2B_IV[15] | 0;
+
+  constructor(opts: Blake2Opts = {}) {
+    const olen = opts.dkLen === undefined ? 64 : opts.dkLen;
+    super(128, olen);
+    checkBlake2Opts(olen, opts, 64, 16, 16);
+    let { key, personalization, salt } = opts;
+    let keyLength = 0;
+    if (key !== undefined) {
+      abytes(key, undefined, 'key');
+      keyLength = key.length;
+    }
+    this.v0l ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+    if (salt !== undefined) {
+      abytes(salt, undefined, 'salt');
+      const slt = u32(salt);
+      this.v4l ^= swap8IfBE(slt[0]);
+      this.v4h ^= swap8IfBE(slt[1]);
+      this.v5l ^= swap8IfBE(slt[2]);
+      this.v5h ^= swap8IfBE(slt[3]);
+    }
+    if (personalization !== undefined) {
+      abytes(personalization, undefined, 'personalization');
+      const pers = u32(personalization);
+      this.v6l ^= swap8IfBE(pers[0]);
+      this.v6h ^= swap8IfBE(pers[1]);
+      this.v7l ^= swap8IfBE(pers[2]);
+      this.v7h ^= swap8IfBE(pers[3]);
+    }
+    if (key !== undefined) {
+      // Pad to blockLen and update
+      const tmp = new Uint8Array(this.blockLen);
+      tmp.set(key);
+      this.update(tmp);
+    }
+  }
+  // prettier-ignore
+  protected get(): [
+    number, number, number, number, number, number, number, number,
+    number, number, number, number, number, number, number, number
+  ] {
+    let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+    return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+  }
+  // prettier-ignore
+  protected set(
+    v0l: number, v0h: number, v1l: number, v1h: number,
+    v2l: number, v2h: number, v3l: number, v3h: number,
+    v4l: number, v4h: number, v5l: number, v5h: number,
+    v6l: number, v6h: number, v7l: number, v7h: number
+  ): void {
+    this.v0l = v0l | 0;
+    this.v0h = v0h | 0;
+    this.v1l = v1l | 0;
+    this.v1h = v1h | 0;
+    this.v2l = v2l | 0;
+    this.v2h = v2h | 0;
+    this.v3l = v3l | 0;
+    this.v3h = v3h | 0;
+    this.v4l = v4l | 0;
+    this.v4h = v4h | 0;
+    this.v5l = v5l | 0;
+    this.v5h = v5h | 0;
+    this.v6l = v6l | 0;
+    this.v6h = v6h | 0;
+    this.v7l = v7l | 0;
+    this.v7h = v7h | 0;
+  }
+  protected compress(msg: Uint32Array, offset: number, isLast: boolean): void {
+    this.get().forEach((v, i) => (BBUF[i] = v)); // First half from state.
+    BBUF.set(B2B_IV, 16); // Second half from IV.
+    let { h, l } = u64.fromBig(BigInt(this.length));
+    BBUF[24] = B2B_IV[8] ^ l; // Low word of the offset.
+    BBUF[25] = B2B_IV[9] ^ h; // High word.
+    // Invert all bits for last block
+    if (isLast) {
+      BBUF[28] = ~BBUF[28];
+      BBUF[29] = ~BBUF[29];
+    }
+    let j = 0;
+    const s = BSIGMA;
+    for (let i = 0; i < 12; i++) {
+      G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+      G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+      G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+      G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+      G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+      G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+      G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+      G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+
+      G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+      G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+      G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+      G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+      G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+      G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+      G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+      G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+    }
+    this.v0l ^= BBUF[0] ^ BBUF[16];
+    this.v0h ^= BBUF[1] ^ BBUF[17];
+    this.v1l ^= BBUF[2] ^ BBUF[18];
+    this.v1h ^= BBUF[3] ^ BBUF[19];
+    this.v2l ^= BBUF[4] ^ BBUF[20];
+    this.v2h ^= BBUF[5] ^ BBUF[21];
+    this.v3l ^= BBUF[6] ^ BBUF[22];
+    this.v3h ^= BBUF[7] ^ BBUF[23];
+    this.v4l ^= BBUF[8] ^ BBUF[24];
+    this.v4h ^= BBUF[9] ^ BBUF[25];
+    this.v5l ^= BBUF[10] ^ BBUF[26];
+    this.v5h ^= BBUF[11] ^ BBUF[27];
+    this.v6l ^= BBUF[12] ^ BBUF[28];
+    this.v6h ^= BBUF[13] ^ BBUF[29];
+    this.v7l ^= BBUF[14] ^ BBUF[30];
+    this.v7h ^= BBUF[15] ^ BBUF[31];
+    clean(BBUF);
+  }
+  destroy(): void {
+    this.destroyed = true;
+    clean(this.buffer32);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+
+/**
+ * Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen output length, key for MAC mode, salt, personalization
+ */
+export const blake2b: CHash<_BLAKE2b, Blake2Opts> = /* @__PURE__ */ createHasher(
+  (opts) => new _BLAKE2b(opts)
+);
+
+// =================
+// Blake2S
+// =================
+
+/** Internal type, 16 numbers. */
+// prettier-ignore
+export type Num16 = {
+  v0: number; v1: number; v2: number; v3: number;
+  v4: number; v5: number; v6: number; v7: number;
+  v8: number; v9: number; v10: number; v11: number;
+  v12: number; v13: number; v14: number; v15: number;
+};
+
+/** BLAKE2-compress core method. */
+// prettier-ignore
+export function compress(s: Uint8Array, offset: number, msg: Uint32Array, rounds: number,
+  v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number,
+  v8: number, v9: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number,
+): Num16 {
+  let j = 0;
+  for (let i = 0; i < rounds; i++) {
+    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+
+    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
+  }
+  return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+}
+
+const B2S_IV = /* @__PURE__ */ SHA256_IV.slice();
+
+/** Internal blake2s hash class. */
+export class _BLAKE2s extends _BLAKE2<_BLAKE2s> {
+  // Internal state, same as SHA-256
+  private v0 = B2S_IV[0] | 0;
+  private v1 = B2S_IV[1] | 0;
+  private v2 = B2S_IV[2] | 0;
+  private v3 = B2S_IV[3] | 0;
+  private v4 = B2S_IV[4] | 0;
+  private v5 = B2S_IV[5] | 0;
+  private v6 = B2S_IV[6] | 0;
+  private v7 = B2S_IV[7] | 0;
+
+  constructor(opts: Blake2Opts = {}) {
+    const olen = opts.dkLen === undefined ? 32 : opts.dkLen;
+    super(64, olen);
+    checkBlake2Opts(olen, opts, 32, 8, 8);
+    let { key, personalization, salt } = opts;
+    let keyLength = 0;
+    if (key !== undefined) {
+      abytes(key, undefined, 'key');
+      keyLength = key.length;
+    }
+    this.v0 ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+    if (salt !== undefined) {
+      abytes(salt, undefined, 'salt');
+      const slt = u32(salt as Uint8Array);
+      this.v4 ^= swap8IfBE(slt[0]);
+      this.v5 ^= swap8IfBE(slt[1]);
+    }
+    if (personalization !== undefined) {
+      abytes(personalization, undefined, 'personalization');
+      const pers = u32(personalization as Uint8Array);
+      this.v6 ^= swap8IfBE(pers[0]);
+      this.v7 ^= swap8IfBE(pers[1]);
+    }
+    if (key !== undefined) {
+      // Pad to blockLen and update
+      const tmp = new Uint8Array(this.blockLen);
+      tmp.set(key);
+      this.update(tmp);
+    }
+  }
+  protected get(): [number, number, number, number, number, number, number, number] {
+    const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
+    return [v0, v1, v2, v3, v4, v5, v6, v7];
+  }
+  // prettier-ignore
+  protected set(
+    v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number
+  ): void {
+    this.v0 = v0 | 0;
+    this.v1 = v1 | 0;
+    this.v2 = v2 | 0;
+    this.v3 = v3 | 0;
+    this.v4 = v4 | 0;
+    this.v5 = v5 | 0;
+    this.v6 = v6 | 0;
+    this.v7 = v7 | 0;
+  }
+  protected compress(msg: Uint32Array, offset: number, isLast: boolean): void {
+    const { h, l } = u64.fromBig(BigInt(this.length));
+    // prettier-ignore
+    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } =
+      compress(
+        BSIGMA, offset, msg, 10,
+        this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7,
+        B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l ^ B2S_IV[4], h ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]
+      );
+    this.v0 ^= v0 ^ v8;
+    this.v1 ^= v1 ^ v9;
+    this.v2 ^= v2 ^ v10;
+    this.v3 ^= v3 ^ v11;
+    this.v4 ^= v4 ^ v12;
+    this.v5 ^= v5 ^ v13;
+    this.v6 ^= v6 ^ v14;
+    this.v7 ^= v7 ^ v15;
+  }
+  destroy(): void {
+    this.destroyed = true;
+    clean(this.buffer32);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+
+/**
+ * Blake2s hash function. Focuses on 8-bit to 32-bit platforms. 1.5x faster than blake2b in JS.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen output length, key for MAC mode, salt, personalization
+ */
+export const blake2s: CHash<_BLAKE2s, Blake2Opts> = /* @__PURE__ */ createHasher(
+  (opts) => new _BLAKE2s(opts)
+);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/blake3.ts

@@ -0,0 +1,275 @@
+/**
+ * Blake3 fast hash is Blake2 with reduced security (round count). Can also be used as MAC & KDF.
+ *
+ * It is advertised as "the fastest cryptographic hash". However, it isn't true in JS.
+ * Why is this so slow? While it must be 6x faster than blake2b, perf diff is only 20%:
+ *
+ * * There is only 30% reduction in number of rounds from blake2s
+ * * Speed-up comes from tree structure, which is parallelized using SIMD & threading.
+ *   These features are not present in JS, so we only get overhead from trees.
+ * * Parallelization only happens on 1024-byte chunks: there is no benefit for small inputs.
+ * * It is still possible to make it faster using: a) loop unrolling b) web workers c) wasm
+ * @module
+ */
+import { SHA256_IV } from './_md.ts';
+import { fromBig } from './_u64.ts';
+import { _BLAKE2, compress } from './blake2.ts';
+// prettier-ignore
+import {
+  abytes, aexists, anumber, aoutput,
+  clean, createHasher, swap32IfBE,
+  u32, u8,
+  type CHashXOF,
+  type HashXOF
+} from './utils.ts';
+
+// Flag bitset
+const B3_Flags = {
+  CHUNK_START: 0b1,
+  CHUNK_END: 0b10,
+  PARENT: 0b100,
+  ROOT: 0b1000,
+  KEYED_HASH: 0b10000,
+  DERIVE_KEY_CONTEXT: 0b100000,
+  DERIVE_KEY_MATERIAL: 0b1000000,
+} as const;
+
+const B3_IV = /* @__PURE__ */ SHA256_IV.slice();
+
+const B3_SIGMA: Uint8Array = /* @__PURE__ */ (() => {
+  const Id = Array.from({ length: 16 }, (_, i) => i);
+  const permute = (arr: number[]) =>
+    [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
+  const res: number[] = [];
+  for (let i = 0, v = Id; i < 7; i++, v = permute(v)) res.push(...v);
+  return Uint8Array.from(res);
+})();
+
+/**
+ * Ensure to use EITHER `key` OR `context`, not both.
+ *
+ * * `key`: 32-byte MAC key.
+ * * `context`: string for KDF. must be hardcoded, globally unique, and application - specific.
+ *   A good default format for the context string is "[application] [commit timestamp] [purpose]".
+ */
+export type Blake3Opts = { dkLen?: number; key?: Uint8Array; context?: Uint8Array };
+
+/** Blake3 hash. Can be used as MAC and KDF. */
+export class _BLAKE3 extends _BLAKE2<_BLAKE3> implements HashXOF<_BLAKE3> {
+  private chunkPos = 0; // Position of current block in chunk
+  private chunksDone = 0; // How many chunks we already have
+  private flags = 0 | 0;
+  private IV: Uint32Array;
+  private state: Uint32Array;
+  private stack: Uint32Array[] = [];
+  // Output
+  private posOut = 0;
+  private bufferOut32 = new Uint32Array(16);
+  private bufferOut: Uint8Array;
+  private chunkOut = 0; // index of output chunk
+  private enableXOF = true;
+
+  constructor(opts: Blake3Opts = {}, flags = 0) {
+    super(64, opts.dkLen === undefined ? 32 : opts.dkLen);
+    const { key, context } = opts;
+    const hasContext = context !== undefined;
+    if (key !== undefined) {
+      if (hasContext) throw new Error('Only "key" or "context" can be specified at same time');
+      abytes(key, 32, 'key');
+      const k = key.slice();
+      this.IV = u32(k);
+      swap32IfBE(this.IV);
+      this.flags = flags | B3_Flags.KEYED_HASH;
+    } else if (hasContext) {
+      abytes(context, undefined, 'context');
+      const ctx = context;
+      const contextKey = new _BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT)
+        .update(ctx)
+        .digest();
+      this.IV = u32(contextKey);
+      swap32IfBE(this.IV);
+      this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
+    } else {
+      this.IV = B3_IV.slice();
+      this.flags = flags;
+    }
+    this.state = this.IV.slice();
+    this.bufferOut = u8(this.bufferOut32);
+  }
+  // Unused
+  protected get(): [] {
+    return [];
+  }
+  protected set(): void {}
+  private b2Compress(counter: number, flags: number, buf: Uint32Array, bufPos: number = 0) {
+    const { state: s, pos } = this;
+    const { h, l } = fromBig(BigInt(counter), true);
+    // prettier-ignore
+    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } =
+      compress(
+        B3_SIGMA, bufPos, buf, 7,
+        s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
+        B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags
+      );
+    s[0] = v0 ^ v8;
+    s[1] = v1 ^ v9;
+    s[2] = v2 ^ v10;
+    s[3] = v3 ^ v11;
+    s[4] = v4 ^ v12;
+    s[5] = v5 ^ v13;
+    s[6] = v6 ^ v14;
+    s[7] = v7 ^ v15;
+  }
+  protected compress(buf: Uint32Array, bufPos: number = 0, isLast: boolean = false): void {
+    // Compress last block
+    let flags = this.flags;
+    if (!this.chunkPos) flags |= B3_Flags.CHUNK_START;
+    if (this.chunkPos === 15 || isLast) flags |= B3_Flags.CHUNK_END;
+    if (!isLast) this.pos = this.blockLen;
+    this.b2Compress(this.chunksDone, flags, buf, bufPos);
+    this.chunkPos += 1;
+    // If current block is last in chunk (16 blocks), then compress chunks
+    if (this.chunkPos === 16 || isLast) {
+      let chunk = this.state;
+      this.state = this.IV.slice();
+      // If not the last one, compress only when there are trailing zeros in chunk counter
+      // chunks used as binary tree where current stack is path. Zero means current leaf is finished and can be compressed.
+      // 1 (001) - leaf not finished (just push current chunk to stack)
+      // 2 (010) - leaf finished at depth=1 (merge with last elm on stack and push back)
+      // 3 (011) - last leaf not finished
+      // 4 (100) - leafs finished at depth=1 and depth=2
+      for (let last, chunks = this.chunksDone + 1; isLast || !(chunks & 1); chunks >>= 1) {
+        if (!(last = this.stack.pop())) break;
+        this.buffer32.set(last, 0);
+        this.buffer32.set(chunk, 8);
+        this.pos = this.blockLen;
+        this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
+        chunk = this.state;
+        this.state = this.IV.slice();
+      }
+      this.chunksDone++;
+      this.chunkPos = 0;
+      this.stack.push(chunk);
+    }
+    this.pos = 0;
+  }
+  _cloneInto(to?: _BLAKE3): _BLAKE3 {
+    to = super._cloneInto(to) as _BLAKE3;
+    const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
+    to.state.set(state.slice());
+    to.stack = stack.map((i) => Uint32Array.from(i));
+    to.IV.set(IV);
+    to.flags = flags;
+    to.chunkPos = chunkPos;
+    to.chunksDone = chunksDone;
+    to.posOut = posOut;
+    to.chunkOut = chunkOut;
+    to.enableXOF = this.enableXOF;
+    to.bufferOut32.set(this.bufferOut32);
+    return to;
+  }
+  destroy(): void {
+    this.destroyed = true;
+    clean(this.state, this.buffer32, this.IV, this.bufferOut32);
+    clean(...this.stack);
+  }
+  // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)
+  private b2CompressOut() {
+    const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
+    const { h, l } = fromBig(BigInt(this.chunkOut++));
+    swap32IfBE(buffer32);
+    // prettier-ignore
+    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } =
+      compress(
+        B3_SIGMA, 0, buffer32, 7,
+        s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
+        B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags
+      );
+    out32[0] = v0 ^ v8;
+    out32[1] = v1 ^ v9;
+    out32[2] = v2 ^ v10;
+    out32[3] = v3 ^ v11;
+    out32[4] = v4 ^ v12;
+    out32[5] = v5 ^ v13;
+    out32[6] = v6 ^ v14;
+    out32[7] = v7 ^ v15;
+    out32[8] = s[0] ^ v8;
+    out32[9] = s[1] ^ v9;
+    out32[10] = s[2] ^ v10;
+    out32[11] = s[3] ^ v11;
+    out32[12] = s[4] ^ v12;
+    out32[13] = s[5] ^ v13;
+    out32[14] = s[6] ^ v14;
+    out32[15] = s[7] ^ v15;
+    swap32IfBE(buffer32);
+    swap32IfBE(out32);
+    this.posOut = 0;
+  }
+  protected finish(): void {
+    if (this.finished) return;
+    this.finished = true;
+    // Padding
+    clean(this.buffer.subarray(this.pos));
+    // Process last chunk
+    let flags = this.flags | B3_Flags.ROOT;
+    if (this.stack.length) {
+      flags |= B3_Flags.PARENT;
+      swap32IfBE(this.buffer32);
+      this.compress(this.buffer32, 0, true);
+      swap32IfBE(this.buffer32);
+      this.chunksDone = 0;
+      this.pos = this.blockLen;
+    } else {
+      flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
+    }
+    this.flags = flags;
+    this.b2CompressOut();
+  }
+  private writeInto(out: Uint8Array) {
+    aexists(this, false);
+    abytes(out);
+    this.finish();
+    const { blockLen, bufferOut } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen) this.b2CompressOut();
+      const 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;
+  }
+  xofInto(out: Uint8Array): Uint8Array {
+    if (!this.enableXOF) throw new Error('XOF is not possible after digest call');
+    return this.writeInto(out);
+  }
+  xof(bytes: number): Uint8Array {
+    anumber(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out: Uint8Array): Uint8Array {
+    aoutput(out, this);
+    if (this.finished) throw new Error('digest() was already called');
+    this.enableXOF = false;
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest(): Uint8Array {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+}
+
+/**
+ * BLAKE3 hash function. Can be used as MAC and KDF.
+ * @param msg - message that would be hashed
+ * @param opts - `dkLen` for output length, `key` for MAC mode, `context` for KDF mode
+ * @example
+ * const data = new Uint8Array(32);
+ * const hash = blake3(data);
+ * const mac = blake3(data, { key: new Uint8Array(32) });
+ * const kdf = blake3(data, { context: 'application name' });
+ */
+export const blake3: CHashXOF<_BLAKE3, Blake3Opts> = /* @__PURE__ */ createHasher(
+  (opts = {}) => new _BLAKE3(opts)
+);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/eskdf.ts

@@ -0,0 +1,188 @@
+/**
+ * Experimental KDF for AES.
+ * @module
+ */
+import { hkdf } from './hkdf.ts';
+import { pbkdf2 as _pbkdf2 } from './pbkdf2.ts';
+import { scrypt as _scrypt } from './scrypt.ts';
+import { sha256 } from './sha2.ts';
+import { abytes, bytesToHex, clean, createView, hexToBytes, kdfInputToBytes } from './utils.ts';
+
+// A tiny KDF for various applications like AES key-gen.
+// Uses HKDF in a non-standard way, so it's not "KDF-secure", only "PRF-secure".
+// Which is good enough: assume sha2-256 retained preimage resistance.
+
+const SCRYPT_FACTOR = 2 ** 19;
+const PBKDF2_FACTOR = 2 ** 17;
+
+/** Scrypt KDF */
+export function scrypt(password: string, salt: string): Uint8Array {
+  return _scrypt(password, salt, { N: SCRYPT_FACTOR, r: 8, p: 1, dkLen: 32 });
+}
+
+/** PBKDF2-HMAC-SHA256 */
+export function pbkdf2(password: string, salt: string): Uint8Array {
+  return _pbkdf2(sha256, password, salt, { c: PBKDF2_FACTOR, dkLen: 32 });
+}
+
+// Combines two 32-byte byte arrays
+function xor32(a: Uint8Array, b: Uint8Array): Uint8Array {
+  abytes(a, 32);
+  abytes(b, 32);
+  const arr = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    arr[i] = a[i] ^ b[i];
+  }
+  return arr;
+}
+
+function strHasLength(str: string, min: number, max: number): boolean {
+  return typeof str === 'string' && str.length >= min && str.length <= max;
+}
+
+/**
+ * Derives main seed. Takes a lot of time. Prefer `eskdf` method instead.
+ */
+export function deriveMainSeed(username: string, password: string): Uint8Array {
+  if (!strHasLength(username, 8, 255)) throw new Error('invalid username');
+  if (!strHasLength(password, 8, 255)) throw new Error('invalid password');
+  // Declared like this to throw off minifiers which auto-convert .fromCharCode(1) to actual string.
+  // String with non-ascii may be problematic in some envs
+  const codes = { _1: 1, _2: 2 };
+  const sep = { s: String.fromCharCode(codes._1), p: String.fromCharCode(codes._2) };
+  const scr = scrypt(password + sep.s, username + sep.s);
+  const pbk = pbkdf2(password + sep.p, username + sep.p);
+  const res = xor32(scr, pbk);
+  clean(scr, pbk);
+  return res;
+}
+
+type AccountID = number | string;
+
+/**
+ * Converts protocol & accountId pair to HKDF salt & info params.
+ */
+function getSaltInfo(protocol: string, accountId: AccountID = 0) {
+  // Note that length here also repeats two lines below
+  // We do an additional length check here to reduce the scope of DoS attacks
+  if (!(strHasLength(protocol, 3, 15) && /^[a-z0-9]{3,15}$/.test(protocol))) {
+    throw new Error('invalid protocol');
+  }
+
+  // Allow string account ids for some protocols
+  const allowsStr = /^password\d{0,3}|ssh|tor|file$/.test(protocol);
+  let salt: Uint8Array; // Extract salt. Default is undefined.
+  if (typeof accountId === 'string') {
+    if (!allowsStr) throw new Error('accountId must be a number');
+    if (!strHasLength(accountId, 1, 255))
+      throw new Error('accountId must be string of length 1..255');
+    salt = kdfInputToBytes(accountId);
+  } else if (Number.isSafeInteger(accountId)) {
+    if (accountId < 0 || accountId > Math.pow(2, 32) - 1) throw new Error('invalid accountId');
+    // Convert to Big Endian Uint32
+    salt = new Uint8Array(4);
+    createView(salt).setUint32(0, accountId, false);
+  } else {
+    throw new Error('accountId must be a number' + (allowsStr ? ' or string' : ''));
+  }
+  const info = kdfInputToBytes(protocol);
+  return { salt, info };
+}
+
+type OptsLength = { keyLength: number };
+type OptsMod = { modulus: bigint };
+type KeyOpts = undefined | OptsLength | OptsMod;
+
+function countBytes(num: bigint): number {
+  if (typeof num !== 'bigint' || num <= BigInt(128)) throw new Error('invalid number');
+  return Math.ceil(num.toString(2).length / 8);
+}
+
+/**
+ * Parses keyLength and modulus options to extract length of result key.
+ * If modulus is used, adds 64 bits to it as per FIPS 186 B.4.1 to combat modulo bias.
+ */
+function getKeyLength(options: KeyOpts): number {
+  if (!options || typeof options !== 'object') return 32;
+  const hasLen = 'keyLength' in options;
+  const hasMod = 'modulus' in options;
+  if (hasLen && hasMod) throw new Error('cannot combine keyLength and modulus options');
+  if (!hasLen && !hasMod) throw new Error('must have either keyLength or modulus option');
+  // FIPS 186 B.4.1 requires at least 64 more bits
+  const l = hasMod ? countBytes(options.modulus) + 8 : options.keyLength;
+  if (!(typeof l === 'number' && l >= 16 && l <= 8192)) throw new Error('invalid keyLength');
+  return l;
+}
+
+/**
+ * Converts key to bigint and divides it by modulus. Big Endian.
+ * Implements FIPS 186 B.4.1, which removes 0 and modulo bias from output.
+ */
+function modReduceKey(key: Uint8Array, modulus: bigint): Uint8Array {
+  const _1 = BigInt(1);
+  const num = BigInt('0x' + bytesToHex(key)); // check for ui8a, then bytesToNumber()
+  const res = (num % (modulus - _1)) + _1; // Remove 0 from output
+  if (res < _1) throw new Error('expected positive number'); // Guard against bad values
+  const len = key.length - 8; // FIPS requires 64 more bits = 8 bytes
+  const hex = res.toString(16).padStart(len * 2, '0'); // numberToHex()
+  const bytes = hexToBytes(hex);
+  if (bytes.length !== len) throw new Error('invalid length of result key');
+  return bytes;
+}
+
+/** Not using classes because constructor cannot be async */
+export interface ESKDF {
+  /**
+   * Derives a child key. Child key will not be associated with any
+   * other child key because of properties of underlying KDF.
+   *
+   * @param protocol - 3-15 character protocol name
+   * @param accountId - numeric identifier of account
+   * @param options - `keyLength: 64` or `modulus: 41920438n`
+   * @example deriveChildKey('aes', 0)
+   */
+  deriveChildKey: (protocol: string, accountId: AccountID, options?: KeyOpts) => Uint8Array;
+  /**
+   * Deletes the main seed from eskdf instance
+   */
+  expire: () => void;
+  /**
+   * Account fingerprint
+   */
+  fingerprint: string;
+}
+
+/**
+ * ESKDF
+ * @param username - username, email, or identifier, min: 8 characters, should have enough entropy
+ * @param password - password, min: 8 characters, should have enough entropy
+ * @example
+ * const kdf = await eskdf('example-university', 'beginning-new-example');
+ * const key = kdf.deriveChildKey('aes', 0);
+ * console.log(kdf.fingerprint);
+ * kdf.expire();
+ */
+export async function eskdf(username: string, password: string): Promise<ESKDF> {
+  // We are using closure + object instead of class because
+  // we want to make `seed` non-accessible for any external function.
+  let seed: Uint8Array | undefined = deriveMainSeed(username, password);
+
+  function deriveCK(protocol: string, accountId: AccountID = 0, options?: KeyOpts): Uint8Array {
+    abytes(seed!, 32);
+    const { salt, info } = getSaltInfo(protocol, accountId); // validate protocol & accountId
+    const keyLength = getKeyLength(options); // validate options
+    const key = hkdf(sha256, seed!, salt, info, keyLength);
+    // Modulus has already been validated
+    return options && 'modulus' in options ? modReduceKey(key, options.modulus) : key;
+  }
+  function expire() {
+    if (seed) seed.fill(1);
+    seed = undefined;
+  }
+  // prettier-ignore
+  const fingerprint = Array.from(deriveCK('fingerprint', 0))
+    .slice(0, 6)
+    .map((char) => char.toString(16).padStart(2, '0').toUpperCase())
+    .join(':');
+  return Object.freeze({ deriveChildKey: deriveCK, expire, fingerprint });
+}

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/hkdf.ts

@@ -0,0 +1,94 @@
+/**
+ * HKDF (RFC 5869): extract + expand in one step.
+ * See https://soatok.blog/2021/11/17/understanding-hkdf/.
+ * @module
+ */
+import { hmac } from './hmac.ts';
+import { abytes, ahash, anumber, type CHash, clean } from './utils.ts';
+
+/**
+ * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
+ * Arguments position differs from spec (IKM is first one, since it is not optional)
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ */
+export function extract(hash: CHash, ikm: Uint8Array, salt?: Uint8Array): Uint8Array {
+  ahash(hash);
+  // NOTE: some libraries treat zero-length array as 'not provided';
+  // we don't, since we have undefined as 'not provided'
+  // https://github.com/RustCrypto/KDFs/issues/15
+  if (salt === undefined) salt = new Uint8Array(hash.outputLen);
+  return hmac(hash, salt, ikm);
+}
+
+const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0);
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+
+/**
+ * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ */
+export function expand(
+  hash: CHash,
+  prk: Uint8Array,
+  info?: Uint8Array,
+  length: number = 32
+): Uint8Array {
+  ahash(hash);
+  anumber(length, 'length');
+  const olen = hash.outputLen;
+  if (length > 255 * olen) throw new Error('Length must be <= 255*HashLen');
+  const blocks = Math.ceil(length / olen);
+  if (info === undefined) info = EMPTY_BUFFER;
+  else abytes(info, undefined, 'info');
+  // first L(ength) octets of T
+  const okm = new Uint8Array(blocks * olen);
+  // Re-use HMAC instance between blocks
+  const HMAC = hmac.create(hash, prk);
+  const HMACTmp = HMAC._cloneInto();
+  const T = new Uint8Array(HMAC.outputLen);
+  for (let counter = 0; counter < blocks; counter++) {
+    HKDF_COUNTER[0] = counter + 1;
+    // T(0) = empty string (zero length)
+    // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
+    HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T)
+      .update(info)
+      .update(HKDF_COUNTER)
+      .digestInto(T);
+    okm.set(T, olen * counter);
+    HMAC._cloneInto(HMACTmp);
+  }
+  HMAC.destroy();
+  HMACTmp.destroy();
+  clean(T, HKDF_COUNTER);
+  return okm.slice(0, length);
+}
+
+/**
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ * @example
+ * import { hkdf } from '@noble/hashes/hkdf';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * import { randomBytes } from '@noble/hashes/utils';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = 'application-key';
+ * const hk1 = hkdf(sha256, inputKey, salt, info, 32);
+ */
+export const hkdf = (
+  hash: CHash,
+  ikm: Uint8Array,
+  salt: Uint8Array | undefined,
+  info: Uint8Array | undefined,
+  length: number
+): Uint8Array => expand(hash, extract(hash, ikm, salt), info, length);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/hmac.ts

@@ -0,0 +1,94 @@
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @module
+ */
+import { abytes, aexists, ahash, clean, type CHash, type Hash } from './utils.ts';
+
+/** Internal class for HMAC. */
+export class _HMAC<T extends Hash<T>> implements Hash<_HMAC<T>> {
+  oHash: T;
+  iHash: T;
+  blockLen: number;
+  outputLen: number;
+  private finished = false;
+  private destroyed = false;
+
+  constructor(hash: CHash, key: Uint8Array) {
+    ahash(hash);
+    abytes(key, undefined, 'key');
+    this.iHash = hash.create() as T;
+    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;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    // blockLen can be bigger than outputLen
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let 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() as T;
+    // Undo internal XOR && apply outer XOR
+    for (let i = 0; i < pad.length; i++) pad[i] ^= 0x36 ^ 0x5c;
+    this.oHash.update(pad);
+    clean(pad);
+  }
+  update(buf: Uint8Array): this {
+    aexists(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out: Uint8Array): void {
+    aexists(this);
+    abytes(out, this.outputLen, 'output');
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest(): Uint8Array {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to?: _HMAC<T>): _HMAC<T> {
+    // Create new instance without calling constructor since key already in state and we don't know it.
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to as this;
+    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;
+  }
+  clone(): _HMAC<T> {
+    return this._cloneInto();
+  }
+  destroy(): void {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+}
+
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - message key
+ * @param message - message data
+ * @example
+ * import { hmac } from '@noble/hashes/hmac';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * const mac1 = hmac(sha256, 'key', 'message');
+ */
+export const hmac: {
+  (hash: CHash, key: Uint8Array, message: Uint8Array): Uint8Array;
+  create(hash: CHash, key: Uint8Array): _HMAC<any>;
+} = (hash: CHash, key: Uint8Array, message: Uint8Array): Uint8Array =>
+  new _HMAC<any>(hash, key).update(message).digest();
+hmac.create = (hash: CHash, key: Uint8Array) => new _HMAC<any>(hash, key);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Audited & minimal JS implementation of hash functions, MACs and KDFs. Check out individual modules.
+ * @module
+ * @example
+```js
+import {
+  sha256, sha384, sha512, sha224, sha512_224, sha512_256
+} from '@noble/hashes/sha2.js';
+import {
+  sha3_224, sha3_256, sha3_384, sha3_512,
+  keccak_224, keccak_256, keccak_384, keccak_512,
+  shake128, shake256
+} from '@noble/hashes/sha3.js';
+import {
+  cshake128, cshake256,
+  turboshake128, turboshake256,
+  kt128, kt256,
+  kmac128, kmac256,
+  tuplehash256, parallelhash256,
+  keccakprg
+} from '@noble/hashes/sha3-addons.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { blake2b, blake2s } from '@noble/hashes/blake2.js';
+import { hmac } from '@noble/hashes/hmac.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2.js';
+import { scrypt, scryptAsync } from '@noble/hashes/scrypt.js';
+import { md5, ripemd160, sha1 } from '@noble/hashes/legacy.js';
+import * as utils from '@noble/hashes/utils.js';
+```
+ */
+throw new Error('root module cannot be imported: import submodules instead. Check out README');

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/legacy.ts

@@ -0,0 +1,293 @@
+/**
+
+SHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.
+Don't use them in a new protocol. What "weak" means:
+
+- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
+- No practical pre-image attacks (only theoretical, 2^123.4)
+- HMAC seems kinda ok: https://www.rfc-editor.org/rfc/rfc6151
+ * @module
+ */
+import { Chi, HashMD, Maj } from './_md.ts';
+import { type CHash, clean, createHasher, rotl } from './utils.ts';
+
+/** Initial SHA1 state */
+const SHA1_IV = /* @__PURE__ */ Uint32Array.from([
+  0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0,
+]);
+
+// Reusable temporary buffer
+const SHA1_W = /* @__PURE__ */ new Uint32Array(80);
+
+/** Internal SHA1 legacy hash class. */
+export class _SHA1 extends HashMD<_SHA1> {
+  private A = SHA1_IV[0] | 0;
+  private B = SHA1_IV[1] | 0;
+  private C = SHA1_IV[2] | 0;
+  private D = SHA1_IV[3] | 0;
+  private E = SHA1_IV[4] | 0;
+
+  constructor() {
+    super(64, 20, 8, false);
+  }
+  protected get(): [number, number, number, number, number] {
+    const { A, B, C, D, E } = this;
+    return [A, B, C, D, E];
+  }
+  protected set(A: number, B: number, C: number, D: number, E: number): void {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+  }
+  protected process(view: DataView, offset: number): void {
+    for (let i = 0; i < 16; i++, offset += 4) SHA1_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 80; i++)
+      SHA1_W[i] = rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);
+    // Compression function main loop, 80 rounds
+    let { A, B, C, D, E } = this;
+    for (let i = 0; i < 80; i++) {
+      let F, K;
+      if (i < 20) {
+        F = Chi(B, C, D);
+        K = 0x5a827999;
+      } else if (i < 40) {
+        F = B ^ C ^ D;
+        K = 0x6ed9eba1;
+      } else if (i < 60) {
+        F = Maj(B, C, D);
+        K = 0x8f1bbcdc;
+      } else {
+        F = B ^ C ^ D;
+        K = 0xca62c1d6;
+      }
+      const T = (rotl(A, 5) + F + E + K + SHA1_W[i]) | 0;
+      E = D;
+      D = C;
+      C = rotl(B, 30);
+      B = A;
+      A = T;
+    }
+    // Add the compressed chunk to the current hash value
+    A = (A + this.A) | 0;
+    B = (B + this.B) | 0;
+    C = (C + this.C) | 0;
+    D = (D + this.D) | 0;
+    E = (E + this.E) | 0;
+    this.set(A, B, C, D, E);
+  }
+  protected roundClean(): void {
+    clean(SHA1_W);
+  }
+  destroy(): void {
+    this.set(0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+
+/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+export const sha1: CHash = /* @__PURE__ */ createHasher(() => new _SHA1());
+
+/** Per-round constants */
+const p32 = /* @__PURE__ */ Math.pow(2, 32);
+const K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) =>
+  Math.floor(p32 * Math.abs(Math.sin(i + 1)))
+);
+
+/** md5 initial state: same as sha1, but 4 u32 instead of 5. */
+const MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);
+
+// Reusable temporary buffer
+const MD5_W = /* @__PURE__ */ new Uint32Array(16);
+/** Internal MD5 legacy hash class. */
+export class _MD5 extends HashMD<_MD5> {
+  private A = MD5_IV[0] | 0;
+  private B = MD5_IV[1] | 0;
+  private C = MD5_IV[2] | 0;
+  private D = MD5_IV[3] | 0;
+
+  constructor() {
+    super(64, 16, 8, true);
+  }
+  protected get(): [number, number, number, number] {
+    const { A, B, C, D } = this;
+    return [A, B, C, D];
+  }
+  protected set(A: number, B: number, C: number, D: number): void {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+  }
+  protected process(view: DataView, offset: number): void {
+    for (let i = 0; i < 16; i++, offset += 4) MD5_W[i] = view.getUint32(offset, true);
+    // Compression function main loop, 64 rounds
+    let { A, B, C, D } = this;
+    for (let i = 0; i < 64; i++) {
+      let F, g, s;
+      if (i < 16) {
+        F = Chi(B, C, D);
+        g = i;
+        s = [7, 12, 17, 22];
+      } else if (i < 32) {
+        F = Chi(D, B, C);
+        g = (5 * i + 1) % 16;
+        s = [5, 9, 14, 20];
+      } else if (i < 48) {
+        F = B ^ C ^ D;
+        g = (3 * i + 5) % 16;
+        s = [4, 11, 16, 23];
+      } else {
+        F = C ^ (B | ~D);
+        g = (7 * i) % 16;
+        s = [6, 10, 15, 21];
+      }
+      F = F + A + K[i] + MD5_W[g];
+      A = D;
+      D = C;
+      C = B;
+      B = B + rotl(F, s[i % 4]);
+    }
+    // Add the compressed chunk to the current hash value
+    A = (A + this.A) | 0;
+    B = (B + this.B) | 0;
+    C = (C + this.C) | 0;
+    D = (D + this.D) | 0;
+    this.set(A, B, C, D);
+  }
+  protected roundClean(): void {
+    clean(MD5_W);
+  }
+  destroy(): void {
+    this.set(0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+
+/**
+ * MD5 (RFC 1321) legacy hash function. It was cryptographically broken.
+ * MD5 architecture is similar to SHA1, with some differences:
+ * - Reduced output length: 16 bytes (128 bit) instead of 20
+ * - 64 rounds, instead of 80
+ * - Little-endian: could be faster, but will require more code
+ * - Non-linear index selection: huge speed-up for unroll
+ * - Per round constants: more memory accesses, additional speed-up for unroll
+ */
+export const md5: CHash = /* @__PURE__ */ createHasher(() => new _MD5());
+
+// RIPEMD-160
+
+const Rho160 = /* @__PURE__ */ Uint8Array.from([
+  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+]);
+const Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
+const Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();
+const idxLR = /* @__PURE__ */ (() => {
+  const L = [Id160];
+  const R = [Pi160];
+  const res = [L, R];
+  for (let i = 0; i < 4; i++) for (let j of res) j.push(j[i].map((k) => Rho160[k]));
+  return res;
+})();
+const idxL = /* @__PURE__ */ (() => idxLR[0])();
+const idxR = /* @__PURE__ */ (() => idxLR[1])();
+// const [idxL, idxR] = idxLR;
+
+const shifts160 = /* @__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((i) => Uint8Array.from(i));
+const shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));
+const shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));
+const Kl160 = /* @__PURE__ */ Uint32Array.from([
+  0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,
+]);
+const Kr160 = /* @__PURE__ */ Uint32Array.from([
+  0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,
+]);
+// It's called f() in spec.
+function ripemd_f(group: number, x: number, y: number, z: number): number {
+  if (group === 0) return x ^ y ^ z;
+  if (group === 1) return (x & y) | (~x & z);
+  if (group === 2) return (x | ~y) ^ z;
+  if (group === 3) return (x & z) | (y & ~z);
+  return x ^ (y | ~z);
+}
+// Reusable temporary buffer
+const BUF_160 = /* @__PURE__ */ new Uint32Array(16);
+export class _RIPEMD160 extends HashMD<_RIPEMD160> {
+  private h0 = 0x67452301 | 0;
+  private h1 = 0xefcdab89 | 0;
+  private h2 = 0x98badcfe | 0;
+  private h3 = 0x10325476 | 0;
+  private h4 = 0xc3d2e1f0 | 0;
+
+  constructor() {
+    super(64, 20, 8, true);
+  }
+  protected get(): [number, number, number, number, number] {
+    const { h0, h1, h2, h3, h4 } = this;
+    return [h0, h1, h2, h3, h4];
+  }
+  protected set(h0: number, h1: number, h2: number, h3: number, h4: number): void {
+    this.h0 = h0 | 0;
+    this.h1 = h1 | 0;
+    this.h2 = h2 | 0;
+    this.h3 = h3 | 0;
+    this.h4 = h4 | 0;
+  }
+  protected process(view: DataView, offset: number): void {
+    for (let i = 0; i < 16; i++, offset += 4) BUF_160[i] = view.getUint32(offset, true);
+    // prettier-ignore
+    let 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 (let group = 0; group < 5; group++) {
+      const rGroup = 4 - group;
+      const hbl = Kl160[group], hbr = Kr160[group]; // prettier-ignore
+      const rl = idxL[group], rr = idxR[group]; // prettier-ignore
+      const sl = shiftsL160[group], sr = shiftsR160[group]; // prettier-ignore
+      for (let i = 0; i < 16; i++) {
+        const tl = (rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el) | 0;
+        al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
+      }
+      // 2 loops are 10% faster
+      for (let i = 0; i < 16; i++) {
+        const tr = (rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er) | 0;
+        ar = er, er = dr, dr = 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
+    );
+  }
+  protected roundClean(): void {
+    clean(BUF_160);
+  }
+  destroy(): void {
+    this.destroyed = true;
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0);
+  }
+}
+
+/**
+ * RIPEMD-160 - a legacy hash function from 1990s.
+ * * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+ * * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
+ */
+export const ripemd160: CHash = /* @__PURE__ */ createHasher(() => new _RIPEMD160());

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/pbkdf2.ts

@@ -0,0 +1,129 @@
+/**
+ * PBKDF (RFC 2898). Can be used to create a key from password and salt.
+ * @module
+ */
+import { hmac } from './hmac.ts';
+// prettier-ignore
+import {
+  ahash, anumber,
+  asyncLoop, checkOpts, clean, createView, kdfInputToBytes,
+  type CHash,
+  type Hash,
+  type KDFInput
+} from './utils.ts';
+
+/**
+ * PBKDF2 options:
+ * * c: iterations, should probably be higher than 100_000
+ * * dkLen: desired length of derived key in bytes
+ * * asyncTick: max time in ms for which async function can block execution
+ */
+export type Pbkdf2Opt = {
+  c: number;
+  dkLen?: number;
+  asyncTick?: number;
+};
+// Common start and end for sync/async functions
+function pbkdf2Init(hash: CHash, _password: KDFInput, _salt: KDFInput, _opts: Pbkdf2Opt) {
+  ahash(hash);
+  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+  const { c, dkLen, asyncTick } = opts;
+  anumber(c, 'c');
+  anumber(dkLen, 'dkLen');
+  anumber(asyncTick, 'asyncTick');
+  if (c < 1) throw new Error('iterations (c) must be >= 1');
+  const password = kdfInputToBytes(_password, 'password');
+  const salt = kdfInputToBytes(_salt, 'salt');
+  // DK = PBKDF2(PRF, Password, Salt, c, dkLen);
+  const DK = new Uint8Array(dkLen);
+  // U1 = PRF(Password, Salt + INT_32_BE(i))
+  const PRF = hmac.create(hash, password);
+  const PRFSalt = PRF._cloneInto().update(salt);
+  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+}
+
+function pbkdf2Output<T extends Hash<T>>(
+  PRF: Hash<T>,
+  PRFSalt: Hash<T>,
+  DK: Uint8Array,
+  prfW: Hash<T>,
+  u: Uint8Array
+) {
+  PRF.destroy();
+  PRFSalt.destroy();
+  if (prfW) prfW.destroy();
+  clean(u);
+  return DK;
+}
+
+/**
+ * PBKDF2-HMAC: RFC 2898 key derivation function
+ * @param hash - hash function that would be used e.g. sha256
+ * @param password - password from which a derived key is generated
+ * @param salt - cryptographic salt
+ * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
+ * @example
+ * const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ */
+export function pbkdf2(
+  hash: CHash,
+  password: KDFInput,
+  salt: KDFInput,
+  opts: Pbkdf2Opt
+): Uint8Array {
+  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+  let prfW: any; // Working copy
+  const arr = new Uint8Array(4);
+  const view = createView(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  // DK = T1 + T2 + ⋯ + Tdklen/hlen
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    // Ti = F(Password, Salt, c, i)
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
+    // U1 = PRF(Password, Salt + INT_32_BE(i))
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    for (let ui = 1; ui < c; ui++) {
+      // Uc = PRF(Password, Uc−1)
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
+    }
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+
+/**
+ * PBKDF2-HMAC: RFC 2898 key derivation function. Async version.
+ * @example
+ * await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });
+ */
+export async function pbkdf2Async(
+  hash: CHash,
+  password: KDFInput,
+  salt: KDFInput,
+  opts: Pbkdf2Opt
+): Promise<Uint8Array> {
+  const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+  let prfW: any; // Working copy
+  const arr = new Uint8Array(4);
+  const view = createView(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  // DK = T1 + T2 + ⋯ + Tdklen/hlen
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    // Ti = F(Password, Salt, c, i)
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
+    // U1 = PRF(Password, Salt + INT_32_BE(i))
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    await asyncLoop(c - 1, asyncTick, () => {
+      // Uc = PRF(Password, Uc−1)
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
+    });
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/scrypt.ts

@@ -0,0 +1,249 @@
+/**
+ * RFC 7914 Scrypt KDF. Can be used to create a key from password and salt.
+ * @module
+ */
+import { pbkdf2 } from './pbkdf2.ts';
+import { sha256 } from './sha2.ts';
+// prettier-ignore
+import {
+  anumber, asyncLoop,
+  checkOpts, clean,
+  type KDFInput, rotl,
+  swap32IfBE,
+  u32
+} from './utils.ts';
+
+// The main Scrypt loop: uses Salsa extensively.
+// Six versions of the function were tried, this is the fastest one.
+// prettier-ignore
+function XorAndSalsa(
+  prev: Uint32Array,
+  pi: number,
+  input: Uint32Array,
+  ii: number,
+  out: Uint32Array,
+  oi: number
+) {
+  // Based on https://cr.yp.to/salsa20.html
+  // Xor blocks
+  let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
+  let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
+  let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
+  let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
+  let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
+  let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
+  let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
+  let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
+  // Save state to temporary variables (salsa)
+  let x00 = y00, x01 = y01, x02 = y02, x03 = y03,
+      x04 = y04, x05 = y05, x06 = y06, x07 = y07,
+      x08 = y08, x09 = y09, x10 = y10, x11 = y11,
+      x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+  // Main loop (salsa)
+  for (let i = 0; i < 8; i += 2) {
+    x04 ^= rotl(x00 + x12 | 0,  7); x08 ^= rotl(x04 + x00 | 0,  9);
+    x12 ^= rotl(x08 + x04 | 0, 13); x00 ^= rotl(x12 + x08 | 0, 18);
+    x09 ^= rotl(x05 + x01 | 0,  7); x13 ^= rotl(x09 + x05 | 0,  9);
+    x01 ^= rotl(x13 + x09 | 0, 13); x05 ^= rotl(x01 + x13 | 0, 18);
+    x14 ^= rotl(x10 + x06 | 0,  7); x02 ^= rotl(x14 + x10 | 0,  9);
+    x06 ^= rotl(x02 + x14 | 0, 13); x10 ^= rotl(x06 + x02 | 0, 18);
+    x03 ^= rotl(x15 + x11 | 0,  7); x07 ^= rotl(x03 + x15 | 0,  9);
+    x11 ^= rotl(x07 + x03 | 0, 13); x15 ^= rotl(x11 + x07 | 0, 18);
+    x01 ^= rotl(x00 + x03 | 0,  7); x02 ^= rotl(x01 + x00 | 0,  9);
+    x03 ^= rotl(x02 + x01 | 0, 13); x00 ^= rotl(x03 + x02 | 0, 18);
+    x06 ^= rotl(x05 + x04 | 0,  7); x07 ^= rotl(x06 + x05 | 0,  9);
+    x04 ^= rotl(x07 + x06 | 0, 13); x05 ^= rotl(x04 + x07 | 0, 18);
+    x11 ^= rotl(x10 + x09 | 0,  7); x08 ^= rotl(x11 + x10 | 0,  9);
+    x09 ^= rotl(x08 + x11 | 0, 13); x10 ^= rotl(x09 + x08 | 0, 18);
+    x12 ^= rotl(x15 + x14 | 0,  7); x13 ^= rotl(x12 + x15 | 0,  9);
+    x14 ^= rotl(x13 + x12 | 0, 13); x15 ^= rotl(x14 + x13 | 0, 18);
+  }
+  // Write output (salsa)
+  out[oi++] = (y00 + x00) | 0; out[oi++] = (y01 + x01) | 0;
+  out[oi++] = (y02 + x02) | 0; out[oi++] = (y03 + x03) | 0;
+  out[oi++] = (y04 + x04) | 0; out[oi++] = (y05 + x05) | 0;
+  out[oi++] = (y06 + x06) | 0; out[oi++] = (y07 + x07) | 0;
+  out[oi++] = (y08 + x08) | 0; out[oi++] = (y09 + x09) | 0;
+  out[oi++] = (y10 + x10) | 0; out[oi++] = (y11 + x11) | 0;
+  out[oi++] = (y12 + x12) | 0; out[oi++] = (y13 + x13) | 0;
+  out[oi++] = (y14 + x14) | 0; out[oi++] = (y15 + x15) | 0;
+}
+
+function BlockMix(input: Uint32Array, ii: number, out: Uint32Array, oi: number, r: number) {
+  // The block B is r 128-byte chunks (which is equivalent of 2r 64-byte chunks)
+  let head = oi + 0;
+  let tail = oi + 16 * r;
+  for (let i = 0; i < 16; i++) out[tail + i] = input[ii + (2 * r - 1) * 16 + i]; // X ← B[2r−1]
+  for (let i = 0; i < r; i++, head += 16, ii += 16) {
+    // We write odd & even Yi at same time. Even: 0bXXXXX0 Odd:  0bXXXXX1
+    XorAndSalsa(out, tail, input, ii, out, head); // head[i] = Salsa(blockIn[2*i] ^ tail[i-1])
+    if (i > 0) tail += 16; // First iteration overwrites tmp value in tail
+    XorAndSalsa(out, head, input, (ii += 16), out, tail); // tail[i] = Salsa(blockIn[2*i+1] ^ head[i])
+  }
+}
+
+/**
+ * Scrypt options:
+ * - `N` is cpu/mem work factor (power of 2 e.g. `2**18`)
+ * - `r` is block size (8 is common), fine-tunes sequential memory read size and performance
+ * - `p` is parallelization factor (1 is common)
+ * - `dkLen` is output key length in bytes e.g. 32.
+ * - `asyncTick` - (default: 10) max time in ms for which async function can block execution
+ * - `maxmem` - (default: `1024 ** 3 + 1024` aka 1GB+1KB). A limit that the app could use for scrypt
+ * - `onProgress` - callback function that would be executed for progress report
+ */
+export type ScryptOpts = {
+  N: number; // cost factor
+  r: number; // block size
+  p: number; // parallelization
+  dkLen?: number; // key length
+  asyncTick?: number; // block execution max time
+  maxmem?: number;
+  onProgress?: (progress: number) => void;
+};
+
+// Common prologue and epilogue for sync/async functions
+function scryptInit(password: KDFInput, salt: KDFInput, _opts?: ScryptOpts) {
+  // Maxmem - 1GB+1KB by default
+  const opts = checkOpts(
+    {
+      dkLen: 32,
+      asyncTick: 10,
+      maxmem: 1024 ** 3 + 1024,
+    },
+    _opts
+  );
+  const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;
+  anumber(N, 'N');
+  anumber(r, 'r');
+  anumber(p, 'p');
+  anumber(dkLen, 'dkLen');
+  anumber(asyncTick, 'asyncTick');
+  anumber(maxmem, 'maxmem');
+  if (onProgress !== undefined && typeof onProgress !== 'function')
+    throw new Error('progressCb must be a function');
+  const blockSize = 128 * r;
+  const blockSize32 = blockSize / 4;
+
+  // Max N is 2^32 (Integrify is 32-bit).
+  // Real limit can be 2^22: some JS engines limit Uint8Array to 4GB.
+  // Spec check `N >= 2^(blockSize / 8)` is not done for compat with popular libs,
+  // which used incorrect r: 1, p: 8. Also, the check seems to be a spec error:
+  // https://www.rfc-editor.org/errata_search.php?rfc=7914
+  const pow32 = Math.pow(2, 32);
+  if (N <= 1 || (N & (N - 1)) !== 0 || N > pow32)
+    throw new Error('"N" expected a power of 2, and 2^1 <= N <= 2^32');
+  if (p < 1 || p > ((pow32 - 1) * 32) / blockSize)
+    throw new Error('"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)');
+  if (dkLen < 1 || dkLen > (pow32 - 1) * 32)
+    throw new Error('"dkLen" expected integer 1..(2^32 - 1) * 32');
+  const memUsed = blockSize * (N + p);
+  if (memUsed > maxmem)
+    throw new Error('"maxmem" limit was hit, expected 128*r*(N+p) <= "maxmem"=' + maxmem);
+  // [B0...Bp−1] ← PBKDF2HMAC-SHA256(Passphrase, Salt, 1, blockSize*ParallelizationFactor)
+  // Since it has only one iteration there is no reason to use async variant
+  const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });
+  const B32 = u32(B);
+  // Re-used between parallel iterations. Array(iterations) of B
+  const V = u32(new Uint8Array(blockSize * N));
+  const tmp = u32(new Uint8Array(blockSize));
+  let blockMixCb = () => {};
+  if (onProgress) {
+    const totalBlockMix = 2 * N * p;
+    // Invoke callback if progress changes from 10.01 to 10.02
+    // Allows to draw smooth progress bar on up to 8K screen
+    const callbackPer = Math.max(Math.floor(totalBlockMix / 10000), 1);
+    let blockMixCnt = 0;
+    blockMixCb = () => {
+      blockMixCnt++;
+      if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))
+        onProgress(blockMixCnt / totalBlockMix);
+    };
+  }
+  return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };
+}
+
+function scryptOutput(
+  password: KDFInput,
+  dkLen: number,
+  B: Uint8Array,
+  V: Uint32Array,
+  tmp: Uint32Array
+) {
+  const res = pbkdf2(sha256, password, B, { c: 1, dkLen });
+  clean(B, V, tmp);
+  return res;
+}
+
+/**
+ * Scrypt KDF from RFC 7914. See {@link ScryptOpts}.
+ * @example
+ * scrypt('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });
+ */
+export function scrypt(password: KDFInput, salt: KDFInput, opts: ScryptOpts): Uint8Array {
+  const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(
+    password,
+    salt,
+    opts
+  );
+  swap32IfBE(B32);
+  for (let pi = 0; pi < p; pi++) {
+    const Pi = blockSize32 * pi;
+    for (let i = 0; i < blockSize32; i++) V[i] = B32[Pi + i]; // V[0] = B[i]
+    for (let i = 0, pos = 0; i < N - 1; i++) {
+      BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);
+      blockMixCb();
+    }
+    BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element
+    blockMixCb();
+    for (let i = 0; i < N; i++) {
+      // First u32 of the last 64-byte block (u32 is LE)
+      // & (N - 1) is % N as N is a power of 2, N & (N - 1) = 0 is checked above; >>> 0 for unsigned, input fits in u32
+      const j = (B32[Pi + blockSize32 - 16] & (N - 1)) >>> 0; // j = Integrify(X) % iterations
+      for (let k = 0; k < blockSize32; k++) tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]
+      BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])
+      blockMixCb();
+    }
+  }
+  swap32IfBE(B32);
+  return scryptOutput(password, dkLen, B, V, tmp);
+}
+
+/**
+ * Scrypt KDF from RFC 7914. Async version. See {@link ScryptOpts}.
+ * @example
+ * await scryptAsync('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });
+ */
+export async function scryptAsync(
+  password: KDFInput,
+  salt: KDFInput,
+  opts: ScryptOpts
+): Promise<Uint8Array> {
+  const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick } = scryptInit(
+    password,
+    salt,
+    opts
+  );
+  swap32IfBE(B32);
+  for (let pi = 0; pi < p; pi++) {
+    const Pi = blockSize32 * pi;
+    for (let i = 0; i < blockSize32; i++) V[i] = B32[Pi + i]; // V[0] = B[i]
+    let pos = 0;
+    await asyncLoop(N - 1, asyncTick, () => {
+      BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);
+      blockMixCb();
+    });
+    BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element
+    blockMixCb();
+    await asyncLoop(N, asyncTick, () => {
+      // First u32 of the last 64-byte block (u32 is LE)
+      // & (N - 1) is % N as N is a power of 2, N & (N - 1) = 0 is checked above; >>> 0 for unsigned, input fits in u32
+      const j = (B32[Pi + blockSize32 - 16] & (N - 1)) >>> 0; // j = Integrify(X) % iterations
+      for (let k = 0; k < blockSize32; k++) tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]
+      BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])
+      blockMixCb();
+    });
+  }
+  swap32IfBE(B32);
+  return scryptOutput(password, dkLen, B, V, tmp);
+}

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/sha2.ts

@@ -0,0 +1,469 @@
+/**
+ * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+ * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+ * Check out [RFC 4634](https://www.rfc-editor.org/rfc/rfc4634) and
+ * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ */
+import { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from './_md.ts';
+import * as u64 from './_u64.ts';
+import { type CHash, clean, createHasher, oidNist, rotr } from './utils.ts';
+
+/**
+ * Round constants:
+ * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+ */
+// prettier-ignore
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+
+/** Reusable temporary buffer. "W" comes straight from spec. */
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+
+/** Internal 32-byte base SHA2 hash class. */
+abstract class SHA2_32B<T extends SHA2_32B<T>> extends HashMD<T> {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  protected abstract A: number;
+  protected abstract B: number;
+  protected abstract C: number;
+  protected abstract D: number;
+  protected abstract E: number;
+  protected abstract F: number;
+  protected abstract G: number;
+  protected abstract H: number;
+
+  constructor(outputLen: number) {
+    super(64, outputLen, 8, false);
+  }
+  protected get(): [number, number, number, number, number, number, number, number] {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  protected set(
+    A: number, B: number, C: number, D: number, E: number, F: number, G: number, H: number
+  ): void {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  protected process(view: DataView, offset: number): void {
+    // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+    for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+      SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+    }
+    // Compression function main loop, 64 rounds
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = (sigma0 + Maj(A, B, C)) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = (D + T1) | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = (T1 + T2) | 0;
+    }
+    // Add the compressed chunk to the current hash value
+    A = (A + this.A) | 0;
+    B = (B + this.B) | 0;
+    C = (C + this.C) | 0;
+    D = (D + this.D) | 0;
+    E = (E + this.E) | 0;
+    F = (F + this.F) | 0;
+    G = (G + this.G) | 0;
+    H = (H + this.H) | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  protected roundClean(): void {
+    clean(SHA256_W);
+  }
+  destroy(): void {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+
+/** Internal SHA2-256 hash class. */
+export class _SHA256 extends SHA2_32B<_SHA256> {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  protected A: number = SHA256_IV[0] | 0;
+  protected B: number = SHA256_IV[1] | 0;
+  protected C: number = SHA256_IV[2] | 0;
+  protected D: number = SHA256_IV[3] | 0;
+  protected E: number = SHA256_IV[4] | 0;
+  protected F: number = SHA256_IV[5] | 0;
+  protected G: number = SHA256_IV[6] | 0;
+  protected H: number = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+}
+
+/** Internal SHA2-224 hash class. */
+export class _SHA224 extends SHA2_32B<_SHA224> {
+  protected A: number = SHA224_IV[0] | 0;
+  protected B: number = SHA224_IV[1] | 0;
+  protected C: number = SHA224_IV[2] | 0;
+  protected D: number = SHA224_IV[3] | 0;
+  protected E: number = SHA224_IV[4] | 0;
+  protected F: number = SHA224_IV[5] | 0;
+  protected G: number = SHA224_IV[6] | 0;
+  protected H: number = SHA224_IV[7] | 0;
+  constructor() {
+    super(28);
+  }
+}
+
+// SHA2-512 is slower than sha256 in js because u64 operations are slow.
+
+// Round contants
+// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409
+// prettier-ignore
+const K512 = /* @__PURE__ */ (() => u64.split([
+  '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+  '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+  '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+  '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+  '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+  '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+  '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+  '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+  '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+  '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+  '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+  '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+  '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+  '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+  '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+  '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+  '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+  '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+  '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+  '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+].map(n => BigInt(n))))();
+const SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+const SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+
+// Reusable temporary buffers
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+
+/** Internal 64-byte base SHA2 hash class. */
+abstract class SHA2_64B<T extends SHA2_64B<T>> extends HashMD<T> {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  // h -- high 32 bits, l -- low 32 bits
+  protected abstract Ah: number;
+  protected abstract Al: number;
+  protected abstract Bh: number;
+  protected abstract Bl: number;
+  protected abstract Ch: number;
+  protected abstract Cl: number;
+  protected abstract Dh: number;
+  protected abstract Dl: number;
+  protected abstract Eh: number;
+  protected abstract El: number;
+  protected abstract Fh: number;
+  protected abstract Fl: number;
+  protected abstract Gh: number;
+  protected abstract Gl: number;
+  protected abstract Hh: number;
+  protected abstract Hl: number;
+
+  constructor(outputLen: number) {
+    super(128, outputLen, 16, false);
+  }
+  // prettier-ignore
+  protected get(): [
+    number, number, number, number, number, number, number, number,
+    number, number, number, number, number, number, number, number
+  ] {
+    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+  }
+  // prettier-ignore
+  protected set(
+    Ah: number, Al: number, Bh: number, Bl: number, Ch: number, Cl: number, Dh: number, Dl: number,
+    Eh: number, El: number, Fh: number, Fl: number, Gh: number, Gl: number, Hh: number, Hl: number
+  ): void {
+    this.Ah = Ah | 0;
+    this.Al = Al | 0;
+    this.Bh = Bh | 0;
+    this.Bl = Bl | 0;
+    this.Ch = Ch | 0;
+    this.Cl = Cl | 0;
+    this.Dh = Dh | 0;
+    this.Dl = Dl | 0;
+    this.Eh = Eh | 0;
+    this.El = El | 0;
+    this.Fh = Fh | 0;
+    this.Fl = Fl | 0;
+    this.Gh = Gh | 0;
+    this.Gl = Gl | 0;
+    this.Hh = Hh | 0;
+    this.Hl = Hl | 0;
+  }
+  protected process(view: DataView, offset: number): void {
+    // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
+    for (let i = 0; i < 16; i++, offset += 4) {
+      SHA512_W_H[i] = view.getUint32(offset);
+      SHA512_W_L[i] = view.getUint32((offset += 4));
+    }
+    for (let i = 16; i < 80; i++) {
+      // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
+      const W15h = SHA512_W_H[i - 15] | 0;
+      const W15l = SHA512_W_L[i - 15] | 0;
+      const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
+      const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+      // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
+      const W2h = SHA512_W_H[i - 2] | 0;
+      const W2l = SHA512_W_L[i - 2] | 0;
+      const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
+      const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+      // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
+      const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+      const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+      SHA512_W_H[i] = SUMh | 0;
+      SHA512_W_L[i] = SUMl | 0;
+    }
+    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    // Compression function main loop, 80 rounds
+    for (let i = 0; i < 80; i++) {
+      // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
+      const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
+      const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+      //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+      const CHIh = (Eh & Fh) ^ (~Eh & Gh);
+      const CHIl = (El & Fl) ^ (~El & Gl);
+      // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
+      // prettier-ignore
+      const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+      const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+      const T1l = T1ll | 0;
+      // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
+      const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
+      const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
+      const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+      const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+      Hh = Gh | 0;
+      Hl = Gl | 0;
+      Gh = Fh | 0;
+      Gl = Fl | 0;
+      Fh = Eh | 0;
+      Fl = El | 0;
+      ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+      Dh = Ch | 0;
+      Dl = Cl | 0;
+      Ch = Bh | 0;
+      Cl = Bl | 0;
+      Bh = Ah | 0;
+      Bl = Al | 0;
+      const All = u64.add3L(T1l, sigma0l, MAJl);
+      Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+      Al = All | 0;
+    }
+    // Add the compressed chunk to the current hash value
+    ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+    ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+    ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+    ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+    ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+    ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+    ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+    ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+  }
+  protected roundClean(): void {
+    clean(SHA512_W_H, SHA512_W_L);
+  }
+  destroy(): void {
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+
+/** Internal SHA2-512 hash class. */
+export class _SHA512 extends SHA2_64B<_SHA512> {
+  protected Ah: number = SHA512_IV[0] | 0;
+  protected Al: number = SHA512_IV[1] | 0;
+  protected Bh: number = SHA512_IV[2] | 0;
+  protected Bl: number = SHA512_IV[3] | 0;
+  protected Ch: number = SHA512_IV[4] | 0;
+  protected Cl: number = SHA512_IV[5] | 0;
+  protected Dh: number = SHA512_IV[6] | 0;
+  protected Dl: number = SHA512_IV[7] | 0;
+  protected Eh: number = SHA512_IV[8] | 0;
+  protected El: number = SHA512_IV[9] | 0;
+  protected Fh: number = SHA512_IV[10] | 0;
+  protected Fl: number = SHA512_IV[11] | 0;
+  protected Gh: number = SHA512_IV[12] | 0;
+  protected Gl: number = SHA512_IV[13] | 0;
+  protected Hh: number = SHA512_IV[14] | 0;
+  protected Hl: number = SHA512_IV[15] | 0;
+
+  constructor() {
+    super(64);
+  }
+}
+
+/** Internal SHA2-384 hash class. */
+export class _SHA384 extends SHA2_64B<_SHA384> {
+  protected Ah: number = SHA384_IV[0] | 0;
+  protected Al: number = SHA384_IV[1] | 0;
+  protected Bh: number = SHA384_IV[2] | 0;
+  protected Bl: number = SHA384_IV[3] | 0;
+  protected Ch: number = SHA384_IV[4] | 0;
+  protected Cl: number = SHA384_IV[5] | 0;
+  protected Dh: number = SHA384_IV[6] | 0;
+  protected Dl: number = SHA384_IV[7] | 0;
+  protected Eh: number = SHA384_IV[8] | 0;
+  protected El: number = SHA384_IV[9] | 0;
+  protected Fh: number = SHA384_IV[10] | 0;
+  protected Fl: number = SHA384_IV[11] | 0;
+  protected Gh: number = SHA384_IV[12] | 0;
+  protected Gl: number = SHA384_IV[13] | 0;
+  protected Hh: number = SHA384_IV[14] | 0;
+  protected Hl: number = SHA384_IV[15] | 0;
+
+  constructor() {
+    super(48);
+  }
+}
+
+/**
+ * Truncated SHA512/256 and SHA512/224.
+ * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as "intermediary" IV of SHA512/t.
+ * Then t hashes string to produce result IV.
+ * See `test/misc/sha2-gen-iv.js`.
+ */
+
+/** SHA512/224 IV */
+const T224_IV = /* @__PURE__ */ Uint32Array.from([
+  0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,
+  0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,
+]);
+
+/** SHA512/256 IV */
+const T256_IV = /* @__PURE__ */ Uint32Array.from([
+  0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,
+  0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,
+]);
+
+/** Internal SHA2-512/224 hash class. */
+export class _SHA512_224 extends SHA2_64B<_SHA512_224> {
+  protected Ah: number = T224_IV[0] | 0;
+  protected Al: number = T224_IV[1] | 0;
+  protected Bh: number = T224_IV[2] | 0;
+  protected Bl: number = T224_IV[3] | 0;
+  protected Ch: number = T224_IV[4] | 0;
+  protected Cl: number = T224_IV[5] | 0;
+  protected Dh: number = T224_IV[6] | 0;
+  protected Dl: number = T224_IV[7] | 0;
+  protected Eh: number = T224_IV[8] | 0;
+  protected El: number = T224_IV[9] | 0;
+  protected Fh: number = T224_IV[10] | 0;
+  protected Fl: number = T224_IV[11] | 0;
+  protected Gh: number = T224_IV[12] | 0;
+  protected Gl: number = T224_IV[13] | 0;
+  protected Hh: number = T224_IV[14] | 0;
+  protected Hl: number = T224_IV[15] | 0;
+
+  constructor() {
+    super(28);
+  }
+}
+
+/** Internal SHA2-512/256 hash class. */
+export class _SHA512_256 extends SHA2_64B<_SHA512_256> {
+  protected Ah: number = T256_IV[0] | 0;
+  protected Al: number = T256_IV[1] | 0;
+  protected Bh: number = T256_IV[2] | 0;
+  protected Bl: number = T256_IV[3] | 0;
+  protected Ch: number = T256_IV[4] | 0;
+  protected Cl: number = T256_IV[5] | 0;
+  protected Dh: number = T256_IV[6] | 0;
+  protected Dl: number = T256_IV[7] | 0;
+  protected Eh: number = T256_IV[8] | 0;
+  protected El: number = T256_IV[9] | 0;
+  protected Fh: number = T256_IV[10] | 0;
+  protected Fl: number = T256_IV[11] | 0;
+  protected Gh: number = T256_IV[12] | 0;
+  protected Gl: number = T256_IV[13] | 0;
+  protected Hh: number = T256_IV[14] | 0;
+  protected Hl: number = T256_IV[15] | 0;
+
+  constructor() {
+    super(32);
+  }
+}
+
+/**
+ * SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:
+ *
+ * - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.
+ * - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ * - Each sha256 hash is executing 2^18 bit operations.
+ * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.
+ */
+export const sha256: CHash<_SHA256> = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(0x01)
+);
+/** SHA2-224 hash function from RFC 4634 */
+export const sha224: CHash<_SHA224> = /* @__PURE__ */ createHasher(
+  () => new _SHA224(),
+  /* @__PURE__ */ oidNist(0x04)
+);
+
+/** SHA2-512 hash function from RFC 4634. */
+export const sha512: CHash<_SHA512> = /* @__PURE__ */ createHasher(
+  () => new _SHA512(),
+  /* @__PURE__ */ oidNist(0x03)
+);
+/** SHA2-384 hash function from RFC 4634. */
+export const sha384: CHash<_SHA384> = /* @__PURE__ */ createHasher(
+  () => new _SHA384(),
+  /* @__PURE__ */ oidNist(0x02)
+);
+
+/**
+ * SHA2-512/256 "truncated" hash function, with improved resistance to length extension attacks.
+ * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
+ */
+export const sha512_256: CHash<_SHA512_256> = /* @__PURE__ */ createHasher(
+  () => new _SHA512_256(),
+  /* @__PURE__ */ oidNist(0x06)
+);
+/**
+ * SHA2-512/224 "truncated" hash function, with improved resistance to length extension attacks.
+ * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
+ */
+export const sha512_224: CHash<_SHA512_224> = /* @__PURE__ */ createHasher(
+  () => new _SHA512_224(),
+  /* @__PURE__ */ oidNist(0x05)
+);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/sha3-addons.ts

@@ -0,0 +1,530 @@
+/**
+ * SHA3 (keccak) addons.
+ *
+ * * cSHAKE, KMAC, TupleHash, ParallelHash + XOF variants from
+ *   [NIST SP 800-185](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-185.pdf)
+ * * KangarooTwelve 🦘 and TurboSHAKE - reduced-round keccak from
+ *   [k12-draft-17](https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/17/)
+ * * KeccakPRG: Pseudo-random generator based on Keccak [(pdf)](https://keccak.team/files/CSF-0.1.pdf)
+ * @module
+ */
+import { Keccak, type ShakeOpts } from './sha3.ts';
+import {
+  abytes,
+  anumber,
+  type CHash,
+  type CHashXOF,
+  createHasher,
+  type Hash,
+  type HashXOF,
+  type KDFInput,
+  kdfInputToBytes,
+  type PRG,
+  u32,
+} from './utils.ts';
+
+// cSHAKE && KMAC (NIST SP800-185)
+const _8n = /* @__PURE__ */ BigInt(8);
+const _ffn = /* @__PURE__ */ BigInt(0xff);
+
+// It is safe to use bigints here, since they used only for length encoding (not actual data).
+// We use bigints in sha256 for lengths too.
+function leftEncode(n: number | bigint): Uint8Array {
+  n = BigInt(n);
+  const res = [Number(n & _ffn)];
+  n >>= _8n;
+  for (; n > 0; n >>= _8n) res.unshift(Number(n & _ffn));
+  res.unshift(res.length);
+  return new Uint8Array(res);
+}
+
+function rightEncode(n: number | bigint): Uint8Array {
+  n = BigInt(n);
+  const res = [Number(n & _ffn)];
+  n >>= _8n;
+  for (; n > 0; n >>= _8n) res.unshift(Number(n & _ffn));
+  res.push(res.length);
+  return new Uint8Array(res);
+}
+
+function chooseLen(opts: ShakeOpts, outputLen: number): number {
+  return opts.dkLen === undefined ? outputLen : opts.dkLen;
+}
+
+const abytesOrZero = (buf?: Uint8Array, title = '') => {
+  if (buf === undefined) return EMPTY_BUFFER;
+  abytes(buf, undefined, title);
+  return buf;
+};
+// NOTE: second modulo is necessary since we don't need to add padding if current element takes whole block
+const getPadding = (len: number, block: number) => new Uint8Array((block - (len % block)) % block);
+export type cShakeOpts = ShakeOpts & { personalization?: Uint8Array; NISTfn?: KDFInput };
+
+// Personalization
+function cshakePers(hash: Keccak, opts: cShakeOpts = {}): Keccak {
+  if (!opts || (opts.personalization === undefined && opts.NISTfn === undefined)) return hash;
+  // Encode and pad inplace to avoid unneccesary memory copies/slices (so we don't need to zero them later)
+  // bytepad(encode_string(N) || encode_string(S), 168)
+  const blockLenBytes = leftEncode(hash.blockLen);
+  const fn = opts.NISTfn === undefined ? EMPTY_BUFFER : kdfInputToBytes(opts.NISTfn);
+  const fnLen = leftEncode(_8n * BigInt(fn.length)); // length in bits
+  const pers = abytesOrZero(opts.personalization, 'personalization');
+  const persLen = leftEncode(_8n * BigInt(pers.length)); // length in bits
+  if (!fn.length && !pers.length) return hash;
+  hash.suffix = 0x04;
+  hash.update(blockLenBytes).update(fnLen).update(fn).update(persLen).update(pers);
+  let totalLen = blockLenBytes.length + fnLen.length + fn.length + persLen.length + pers.length;
+  hash.update(getPadding(totalLen, hash.blockLen));
+  return hash;
+}
+
+const gencShake = (suffix: number, blockLen: number, outputLen: number) =>
+  createHasher<Keccak, cShakeOpts>((opts: cShakeOpts = {}) =>
+    cshakePers(new Keccak(blockLen, suffix, chooseLen(opts, outputLen), true), opts)
+  );
+
+export type ITupleHash = {
+  (messages: Uint8Array[], opts?: cShakeOpts): Uint8Array;
+  create(opts?: cShakeOpts): _TupleHash;
+};
+/** 128-bit NIST cSHAKE XOF. */
+export const cshake128: CHashXOF<Keccak, cShakeOpts> = /* @__PURE__ */ gencShake(0x1f, 168, 16);
+/** 256-bit NIST cSHAKE XOF. */
+export const cshake256: CHashXOF<Keccak, cShakeOpts> = /* @__PURE__ */ gencShake(0x1f, 136, 32);
+
+/** Internal KMAC mac class. */
+export class _KMAC extends Keccak implements HashXOF<_KMAC> {
+  constructor(
+    blockLen: number,
+    outputLen: number,
+    enableXOF: boolean,
+    key: Uint8Array,
+    opts: cShakeOpts = {}
+  ) {
+    super(blockLen, 0x1f, outputLen, enableXOF);
+    cshakePers(this, { NISTfn: 'KMAC', personalization: opts.personalization });
+    abytes(key, undefined, 'key');
+    // 1. newX = bytepad(encode_string(K), 168) || X || right_encode(L).
+    const blockLenBytes = leftEncode(this.blockLen);
+    const keyLen = leftEncode(_8n * BigInt(key.length));
+    this.update(blockLenBytes).update(keyLen).update(key);
+    const totalLen = blockLenBytes.length + keyLen.length + key.length;
+    this.update(getPadding(totalLen, this.blockLen));
+  }
+  protected finish(): void {
+    if (!this.finished) this.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
+    super.finish();
+  }
+  _cloneInto(to?: _KMAC): _KMAC {
+    // Create new instance without calling constructor since key already in state and we don't know it.
+    // Force "to" to be instance of KMAC instead of Sha3.
+    if (!to) {
+      to = Object.create(Object.getPrototypeOf(this), {}) as _KMAC;
+      to.state = this.state.slice();
+      to.blockLen = this.blockLen;
+      to.state32 = u32(to.state);
+    }
+    return super._cloneInto(to) as _KMAC;
+  }
+  clone(): _KMAC {
+    return this._cloneInto();
+  }
+}
+
+function genKmac(blockLen: number, outputLen: number, xof = false) {
+  const kmac = (key: Uint8Array, message: Uint8Array, opts?: cShakeOpts): Uint8Array =>
+    kmac.create(key, opts).update(message).digest();
+  kmac.create = (key: Uint8Array, opts: cShakeOpts = {}) =>
+    new _KMAC(blockLen, chooseLen(opts, outputLen), xof, key, opts);
+  return kmac;
+}
+
+export type IKMAC = {
+  (key: Uint8Array, message: Uint8Array, opts?: KangarooOpts): Uint8Array;
+  create(key: Uint8Array, opts?: cShakeOpts): _KMAC;
+};
+/** 128-bit Keccak MAC. */
+export const kmac128: IKMAC = /* @__PURE__ */ genKmac(168, 16);
+/** 256-bit Keccak MAC. */
+export const kmac256: IKMAC = /* @__PURE__ */ genKmac(136, 32);
+/** 128-bit Keccak-MAC XOF. */
+export const kmac128xof: IKMAC = /* @__PURE__ */ genKmac(168, 16, true);
+/** 256-bit Keccak-MAC XOF. */
+export const kmac256xof: IKMAC = /* @__PURE__ */ genKmac(136, 32, true);
+
+/** Internal TupleHash class. */
+export class _TupleHash extends Keccak implements HashXOF<_TupleHash> {
+  constructor(blockLen: number, outputLen: number, enableXOF: boolean, opts: cShakeOpts = {}) {
+    super(blockLen, 0x1f, outputLen, enableXOF);
+    cshakePers(this, { NISTfn: 'TupleHash', personalization: opts.personalization });
+    // Change update after cshake processed
+    this.update = (data: Uint8Array) => {
+      abytes(data);
+      super.update(leftEncode(_8n * BigInt(data.length)));
+      super.update(data);
+      return this;
+    };
+  }
+  protected finish(): void {
+    if (!this.finished)
+      super.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
+    super.finish();
+  }
+  _cloneInto(to?: _TupleHash): _TupleHash {
+    to ||= new _TupleHash(this.blockLen, this.outputLen, this.enableXOF);
+    return super._cloneInto(to) as _TupleHash;
+  }
+  clone(): _TupleHash {
+    return this._cloneInto();
+  }
+}
+
+function genTuple(blockLen: number, outputLen: number, xof = false) {
+  const tuple = (messages: Uint8Array[], opts?: cShakeOpts): Uint8Array => {
+    const h = tuple.create(opts);
+    if (!Array.isArray(messages)) throw new Error('expected array of messages');
+    for (const msg of messages) h.update(msg);
+    return h.digest();
+  };
+  tuple.create = (opts: cShakeOpts = {}) =>
+    new _TupleHash(blockLen, chooseLen(opts, outputLen), xof, opts);
+  return tuple;
+}
+
+/** 128-bit TupleHASH. tuple(['ab', 'cd']) != tuple(['a', 'bcd']) */
+export const tuplehash128: ITupleHash = /* @__PURE__ */ genTuple(168, 16);
+/** 256-bit TupleHASH. tuple(['ab', 'cd']) != tuple(['a', 'bcd']) */
+export const tuplehash256: ITupleHash = /* @__PURE__ */ genTuple(136, 32);
+/** 128-bit TupleHASH XOF. */
+export const tuplehash128xof: ITupleHash = /* @__PURE__ */ genTuple(168, 16, true);
+/** 256-bit TupleHASH XOF. */
+export const tuplehash256xof: ITupleHash = /* @__PURE__ */ genTuple(136, 32, true);
+
+// Same as K12/M14, but without speedup for inputs less 8kb,
+// reduced number of rounds and simpler.
+type ParallelOpts = KangarooOpts & { blockLen?: number };
+
+/** Internal Parallel Keccak Hash class. */
+export class _ParallelHash extends Keccak implements HashXOF<_ParallelHash> {
+  private leafHash?: Hash<Keccak>;
+  protected leafCons: () => Hash<Keccak>;
+  private chunkPos = 0; // Position of current block in chunk
+  private chunksDone = 0; // How many chunks we already have
+  private chunkLen: number;
+  constructor(
+    blockLen: number,
+    outputLen: number,
+    leafCons: () => Hash<Keccak>,
+    enableXOF: boolean,
+    opts: ParallelOpts = {}
+  ) {
+    super(blockLen, 0x1f, outputLen, enableXOF);
+    cshakePers(this, { NISTfn: 'ParallelHash', personalization: opts.personalization });
+    this.leafCons = leafCons;
+    let { blockLen: B = 8 } = opts;
+    anumber(B);
+    this.chunkLen = B;
+    super.update(leftEncode(B));
+    // Change update after cshake processed
+    this.update = (data: Uint8Array) => {
+      abytes(data);
+      const { chunkLen, leafCons } = this;
+      for (let pos = 0, len = data.length; pos < len; ) {
+        if (this.chunkPos == chunkLen || !this.leafHash) {
+          if (this.leafHash) {
+            super.update(this.leafHash.digest());
+            this.chunksDone++;
+          }
+          this.leafHash = leafCons();
+          this.chunkPos = 0;
+        }
+        const take = Math.min(chunkLen - this.chunkPos, len - pos);
+        this.leafHash.update(data.subarray(pos, pos + take));
+        this.chunkPos += take;
+        pos += take;
+      }
+      return this;
+    };
+  }
+  protected finish(): void {
+    if (this.finished) return;
+    if (this.leafHash) {
+      super.update(this.leafHash.digest());
+      this.chunksDone++;
+    }
+    super.update(rightEncode(this.chunksDone));
+    super.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
+    super.finish();
+  }
+  _cloneInto(to?: _ParallelHash): _ParallelHash {
+    to ||= new _ParallelHash(this.blockLen, this.outputLen, this.leafCons, this.enableXOF);
+    if (this.leafHash) to.leafHash = this.leafHash._cloneInto(to.leafHash as Keccak);
+    to.chunkPos = this.chunkPos;
+    to.chunkLen = this.chunkLen;
+    to.chunksDone = this.chunksDone;
+    return super._cloneInto(to) as _ParallelHash;
+  }
+  destroy(): void {
+    super.destroy.call(this);
+    if (this.leafHash) this.leafHash.destroy();
+  }
+  clone(): _ParallelHash {
+    return this._cloneInto();
+  }
+}
+
+function genPrl(
+  blockLen: number,
+  outputLen: number,
+  leaf: ReturnType<typeof gencShake>,
+  xof = false
+) {
+  const parallel = (message: Uint8Array, opts?: ParallelOpts): Uint8Array =>
+    parallel.create(opts).update(message).digest();
+  parallel.create = (opts: ParallelOpts = {}) =>
+    new _ParallelHash(
+      blockLen,
+      chooseLen(opts, outputLen),
+      () => leaf.create({ dkLen: 2 * outputLen }),
+      xof,
+      opts
+    );
+  parallel.outputLen = outputLen;
+  parallel.blockLen = blockLen;
+  return parallel;
+}
+
+/** 128-bit ParallelHash. In JS, it is not parallel. */
+export const parallelhash128: CHash<Keccak, ParallelOpts> = /* @__PURE__ */ genPrl(
+  168,
+  16,
+  cshake128
+);
+/** 256-bit ParallelHash. In JS, it is not parallel. */
+export const parallelhash256: CHash<Keccak, ParallelOpts> = /* @__PURE__ */ genPrl(
+  136,
+  32,
+  cshake256
+);
+/** 128-bit ParallelHash XOF. In JS, it is not parallel. */
+export const parallelhash128xof: CHashXOF<Keccak, ParallelOpts> = /* @__PURE__ */ genPrl(
+  168,
+  16,
+  cshake128,
+  true
+);
+/** 256-bit ParallelHash. In JS, it is not parallel. */
+export const parallelhash256xof: CHashXOF<Keccak, ParallelOpts> = /* @__PURE__ */ genPrl(
+  136,
+  32,
+  cshake256,
+  true
+);
+
+/** D means Domain separation byte */
+export type TurboshakeOpts = ShakeOpts & {
+  D?: number;
+};
+
+const genTurbo = (blockLen: number, outputLen: number) =>
+  createHasher<Keccak, TurboshakeOpts>((opts: TurboshakeOpts = {}) => {
+    const D = opts.D === undefined ? 0x1f : opts.D;
+    // Section 2.1 of https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/17/
+    if (!Number.isSafeInteger(D) || D < 0x01 || D > 0x7f)
+      throw new Error('"D" (domain separation byte) must be 0x01..0x7f, got: ' + D);
+    return new Keccak(blockLen, D, opts.dkLen === undefined ? outputLen : opts.dkLen, true, 12);
+  });
+
+/**
+ * TurboSHAKE 128-bit: reduced 12-round keccak.
+ * Should've been a simple "shake with 12 rounds", but we got a whole new spec about Turbo SHAKE Pro MAX.
+ */
+export const turboshake128: CHashXOF<Keccak, TurboshakeOpts> = /* @__PURE__ */ genTurbo(168, 32);
+/** TurboSHAKE 256-bit: reduced 12-round keccak. */
+export const turboshake256: CHashXOF<Keccak, TurboshakeOpts> = /* @__PURE__ */ genTurbo(136, 64);
+
+// Same as NIST rightEncode, but returns [0] for zero string
+function rightEncodeK12(n: number | bigint): Uint8Array {
+  n = BigInt(n);
+  const res: number[] = [];
+  for (; n > 0; n >>= _8n) res.unshift(Number(n & _ffn));
+  res.push(res.length);
+  return Uint8Array.from(res);
+}
+
+/** K12 options. */
+export type KangarooOpts = { dkLen?: number; personalization?: Uint8Array };
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+
+/** Internal K12 hash class. */
+export class _KangarooTwelve extends Keccak implements HashXOF<_KangarooTwelve> {
+  readonly chunkLen = 8192;
+  private leafHash?: Keccak;
+  protected leafLen: number;
+  private personalization: Uint8Array;
+  private chunkPos = 0; // Position of current block in chunk
+  private chunksDone = 0; // How many chunks we already have
+  constructor(
+    blockLen: number,
+    leafLen: number,
+    outputLen: number,
+    rounds: number,
+    opts: KangarooOpts
+  ) {
+    super(blockLen, 0x07, outputLen, true, rounds);
+    this.leafLen = leafLen;
+    this.personalization = abytesOrZero(opts.personalization, 'personalization');
+  }
+  update(data: Uint8Array): this {
+    abytes(data);
+    const { chunkLen, blockLen, leafLen, rounds } = this;
+    for (let pos = 0, len = data.length; pos < len; ) {
+      if (this.chunkPos == chunkLen) {
+        if (this.leafHash) super.update(this.leafHash.digest());
+        else {
+          this.suffix = 0x06; // Its safe to change suffix here since its used only in digest()
+          super.update(Uint8Array.from([3, 0, 0, 0, 0, 0, 0, 0]));
+        }
+        this.leafHash = new Keccak(blockLen, 0x0b, leafLen, false, rounds);
+        this.chunksDone++;
+        this.chunkPos = 0;
+      }
+      const take = Math.min(chunkLen - this.chunkPos, len - pos);
+      const chunk = data.subarray(pos, pos + take);
+      if (this.leafHash) this.leafHash.update(chunk);
+      else super.update(chunk);
+      this.chunkPos += take;
+      pos += take;
+    }
+    return this;
+  }
+  protected finish(): void {
+    if (this.finished) return;
+    const { personalization } = this;
+    this.update(personalization).update(rightEncodeK12(personalization.length));
+    // Leaf hash
+    if (this.leafHash) {
+      super.update(this.leafHash.digest());
+      super.update(rightEncodeK12(this.chunksDone));
+      super.update(Uint8Array.from([0xff, 0xff]));
+    }
+    super.finish.call(this);
+  }
+  destroy(): void {
+    super.destroy.call(this);
+    if (this.leafHash) this.leafHash.destroy();
+    // We cannot zero personalization buffer since it is user provided and we don't want to mutate user input
+    this.personalization = EMPTY_BUFFER;
+  }
+  _cloneInto(to?: _KangarooTwelve): _KangarooTwelve {
+    const { blockLen, leafLen, leafHash, outputLen, rounds } = this;
+    to ||= new _KangarooTwelve(blockLen, leafLen, outputLen, rounds, {});
+    super._cloneInto(to);
+    if (leafHash) to.leafHash = leafHash._cloneInto(to.leafHash);
+    to.personalization.set(this.personalization);
+    to.leafLen = this.leafLen;
+    to.chunkPos = this.chunkPos;
+    to.chunksDone = this.chunksDone;
+    return to;
+  }
+  clone(): _KangarooTwelve {
+    return this._cloneInto();
+  }
+}
+
+/** 128-bit KangarooTwelve (k12): reduced 12-round keccak. */
+export const kt128: CHash<_KangarooTwelve, KangarooOpts> = /* @__PURE__ */ createHasher(
+  (opts: KangarooOpts = {}) => new _KangarooTwelve(168, 32, chooseLen(opts, 32), 12, opts)
+);
+/** 256-bit KangarooTwelve (k12): reduced 12-round keccak. */
+export const kt256: CHash<_KangarooTwelve, KangarooOpts> = /* @__PURE__ */ createHasher(
+  (opts: KangarooOpts = {}) => new _KangarooTwelve(136, 64, chooseLen(opts, 64), 12, opts)
+);
+
+// MarsupilamiFourteen (14-rounds) can be defined as:
+// `new KangarooTwelve(136, 64, chooseLen(opts, 64), 14, opts)`
+
+/** KangarooTwelve-based MAC options. */
+export type HopMAC = (
+  key: Uint8Array,
+  message: Uint8Array,
+  personalization: Uint8Array,
+  dkLen?: number
+) => Uint8Array;
+const genHopMAC =
+  (hash: CHash<_KangarooTwelve, KangarooOpts>) =>
+  (key: Uint8Array, message: Uint8Array, personalization: Uint8Array, dkLen?: number): Uint8Array =>
+    hash(key, { personalization: hash(message, { personalization }), dkLen });
+
+/**
+ * 128-bit KangarooTwelve-based MAC.
+ *
+ * These untested (there is no test vectors or implementation available). Use at your own risk.
+ * HopMAC128(Key, M, C, L) = KT128(Key, KT128(M, C, 32), L)
+ * HopMAC256(Key, M, C, L) = KT256(Key, KT256(M, C, 64), L)
+ */
+export const HopMAC128: HopMAC = /* @__PURE__ */ genHopMAC(kt128);
+/** 256-bit KangarooTwelve-based MAC. */
+export const HopMAC256: HopMAC = /* @__PURE__ */ genHopMAC(kt256);
+
+/**
+ * More at https://github.com/XKCP/XKCP/tree/master/lib/high/Keccak/PRG.
+ */
+export class _KeccakPRG extends Keccak implements PRG {
+  protected rate: number;
+  constructor(capacity: number) {
+    anumber(capacity);
+    const rate = 1600 - capacity;
+    const rho = rate - 2;
+    // Rho must be full bytes
+    if (capacity < 0 || capacity > 1600 - 10 || rho % 8) throw new Error('invalid capacity');
+    // blockLen = rho in bytes
+    super(rho / 8, 0, 0, true);
+    this.rate = rate;
+    this.posOut = Math.floor((rate + 7) / 8);
+  }
+  protected keccak(): void {
+    // Duplex padding
+    this.state[this.pos] ^= 0x01;
+    this.state[this.blockLen] ^= 0x02; // Rho is full bytes
+    super.keccak();
+    this.pos = 0;
+    this.posOut = 0;
+  }
+  update(data: Uint8Array): this {
+    super.update(data);
+    this.posOut = this.blockLen;
+    return this;
+  }
+  protected finish(): void {}
+  digestInto(_out: Uint8Array): Uint8Array {
+    throw new Error('digest is not allowed, use .fetch instead');
+  }
+  addEntropy(seed: Uint8Array): void {
+    this.update(seed);
+  }
+  randomBytes(length: number): Uint8Array {
+    return this.xof(length);
+  }
+  clean(): void {
+    if (this.rate < 1600 / 2 + 1) throw new Error('rate is too low to use .forget()');
+    this.keccak();
+    for (let i = 0; i < this.blockLen; i++) this.state[i] = 0;
+    this.pos = this.blockLen;
+    this.keccak();
+    this.posOut = this.blockLen;
+  }
+  _cloneInto(to?: _KeccakPRG): _KeccakPRG {
+    const { rate } = this;
+    to ||= new _KeccakPRG(1600 - rate);
+    super._cloneInto(to);
+    to.rate = rate;
+    return to;
+  }
+  clone(): _KeccakPRG {
+    return this._cloneInto();
+  }
+}
+
+/** KeccakPRG: Pseudo-random generator based on Keccak. https://keccak.team/files/CSF-0.1.pdf */
+export const keccakprg = (capacity = 254): _KeccakPRG => new _KeccakPRG(capacity);

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/sha3.ts

@@ -0,0 +1,295 @@
+/**
+ * SHA3 (keccak) hash function, based on a new "Sponge function" design.
+ * Different from older hashes, the internal state is bigger than output size.
+ *
+ * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+ * [Website](https://keccak.team/keccak.html),
+ * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+ *
+ * Check out `sha3-addons` module for cSHAKE, k12, and others.
+ * @module
+ */
+import { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.ts';
+// prettier-ignore
+import {
+  abytes, aexists, anumber, aoutput,
+  clean, createHasher,
+  oidNist,
+  swap32IfBE,
+  u32,
+  type CHash, type CHashXOF,
+  type Hash,
+  type HashInfo,
+  type HashXOF
+} from './utils.ts';
+
+// No __PURE__ annotations in sha3 header:
+// EVERYTHING is in fact used on every export.
+// Various per round constants calculations
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+const _7n = BigInt(7);
+const _256n = BigInt(256);
+const _0x71n = BigInt(0x71);
+const SHA3_PI: number[] = [];
+const SHA3_ROTL: number[] = [];
+const _SHA3_IOTA: bigint[] = []; // no pure annotation: var is always used
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+  // Pi
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI.push(2 * (5 * y + x));
+  // Rotational
+  SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+  // Iota
+  let t = _0n;
+  for (let j = 0; j < 7; j++) {
+    R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
+    if (R & _2n) t ^= _1n << ((_1n << BigInt(j)) - _1n);
+  }
+  _SHA3_IOTA.push(t);
+}
+const IOTAS = split(_SHA3_IOTA, true);
+const SHA3_IOTA_H = IOTAS[0];
+const SHA3_IOTA_L = IOTAS[1];
+
+// Left rotation (without 0, 32, 64)
+const rotlH = (h: number, l: number, s: number) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
+const rotlL = (h: number, l: number, s: number) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
+
+/** `keccakf1600` internal function, additionally allows to adjust round count. */
+export function keccakP(s: Uint32Array, rounds: number = 24): void {
+  const 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 (let round = 24 - rounds; round < 24; round++) {
+    // Theta θ
+    for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    // Rho (ρ) and Pi (π)
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    // Chi (χ)
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++) B[x] = s[y + x];
+      for (let 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];
+  }
+  clean(B);
+}
+
+/** Keccak sponge function. */
+export class Keccak implements Hash<Keccak>, HashXOF<Keccak> {
+  protected state: Uint8Array;
+  protected pos = 0;
+  protected posOut = 0;
+  protected finished = false;
+  protected state32: Uint32Array;
+  protected destroyed = false;
+
+  public blockLen: number;
+  public suffix: number;
+  public outputLen: number;
+  protected enableXOF = false;
+  protected rounds: number;
+
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(
+    blockLen: number,
+    suffix: number,
+    outputLen: number,
+    enableXOF = false,
+    rounds: number = 24
+  ) {
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.rounds = rounds;
+    // Can be passed from user as dkLen
+    anumber(outputLen, 'outputLen');
+    // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
+    // 0 < blockLen < 200
+    if (!(0 < blockLen && blockLen < 200))
+      throw new Error('only keccak-f1600 function is supported');
+    this.state = new Uint8Array(200);
+    this.state32 = u32(this.state);
+  }
+  clone(): Keccak {
+    return this._cloneInto();
+  }
+  protected keccak(): void {
+    swap32IfBE(this.state32);
+    keccakP(this.state32, this.rounds);
+    swap32IfBE(this.state32);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data: Uint8Array): this {
+    aexists(this);
+    abytes(data);
+    const { blockLen, state } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      for (let i = 0; i < take; i++) state[this.pos++] ^= data[pos++];
+      if (this.pos === blockLen) this.keccak();
+    }
+    return this;
+  }
+  protected finish(): void {
+    if (this.finished) return;
+    this.finished = true;
+    const { state, suffix, pos, blockLen } = this;
+    // Do the padding
+    state[pos] ^= suffix;
+    if ((suffix & 0x80) !== 0 && pos === blockLen - 1) this.keccak();
+    state[blockLen - 1] ^= 0x80;
+    this.keccak();
+  }
+  protected writeInto(out: Uint8Array): Uint8Array {
+    aexists(this, false);
+    abytes(out);
+    this.finish();
+    const bufferOut = this.state;
+    const { blockLen } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen) this.keccak();
+      const 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;
+  }
+  xofInto(out: Uint8Array): Uint8Array {
+    // 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);
+  }
+  xof(bytes: number): Uint8Array {
+    anumber(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out: Uint8Array): Uint8Array {
+    aoutput(out, this);
+    if (this.finished) throw new Error('digest() was already called');
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest(): Uint8Array {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy(): void {
+    this.destroyed = true;
+    clean(this.state);
+  }
+  _cloneInto(to?: Keccak): Keccak {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    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;
+  }
+}
+
+const genKeccak = (suffix: number, blockLen: number, outputLen: number, info: HashInfo = {}) =>
+  createHasher(() => new Keccak(blockLen, suffix, outputLen), info);
+
+/** SHA3-224 hash function. */
+export const sha3_224: CHash = /* @__PURE__ */ genKeccak(
+  0x06,
+  144,
+  28,
+  /* @__PURE__ */ oidNist(0x07)
+);
+/** SHA3-256 hash function. Different from keccak-256. */
+export const sha3_256: CHash = /* @__PURE__ */ genKeccak(
+  0x06,
+  136,
+  32,
+  /* @__PURE__ */ oidNist(0x08)
+);
+/** SHA3-384 hash function. */
+export const sha3_384: CHash = /* @__PURE__ */ genKeccak(
+  0x06,
+  104,
+  48,
+  /* @__PURE__ */ oidNist(0x09)
+);
+/** SHA3-512 hash function. */
+export const sha3_512: CHash = /* @__PURE__ */ genKeccak(
+  0x06,
+  72,
+  64,
+  /* @__PURE__ */ oidNist(0x0a)
+);
+
+/** keccak-224 hash function. */
+export const keccak_224: CHash = /* @__PURE__ */ genKeccak(0x01, 144, 28);
+/** keccak-256 hash function. Different from SHA3-256. */
+export const keccak_256: CHash = /* @__PURE__ */ genKeccak(0x01, 136, 32);
+/** keccak-384 hash function. */
+export const keccak_384: CHash = /* @__PURE__ */ genKeccak(0x01, 104, 48);
+/** keccak-512 hash function. */
+export const keccak_512: CHash = /* @__PURE__ */ genKeccak(0x01, 72, 64);
+
+/** Options for SHAKE XOF. */
+export type ShakeOpts = { dkLen?: number };
+
+const genShake = (suffix: number, blockLen: number, outputLen: number, info: HashInfo = {}) =>
+  createHasher<Keccak, ShakeOpts>(
+    (opts: ShakeOpts = {}) =>
+      new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true),
+    info
+  );
+
+/** SHAKE128 XOF with 128-bit security. */
+export const shake128: CHashXOF<Keccak, ShakeOpts> =
+  /* @__PURE__ */
+  genShake(0x1f, 168, 16, /* @__PURE__ */ oidNist(0x0b));
+/** SHAKE256 XOF with 256-bit security. */
+export const shake256: CHashXOF<Keccak, ShakeOpts> =
+  /* @__PURE__ */
+  genShake(0x1f, 136, 32, /* @__PURE__ */ oidNist(0x0c));
+
+/** SHAKE128 XOF with 256-bit output (NIST version). */
+export const shake128_32: CHashXOF<Keccak, ShakeOpts> =
+  /* @__PURE__ */
+  genShake(0x1f, 168, 32, /* @__PURE__ */ oidNist(0x0b));
+/** SHAKE256 XOF with 512-bit output (NIST version). */
+export const shake256_64: CHashXOF<Keccak, ShakeOpts> =
+  /* @__PURE__ */
+  genShake(0x1f, 136, 64, /* @__PURE__ */ oidNist(0x0c));

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/utils.ts

@@ -0,0 +1,338 @@
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+export function isBytes(a: unknown): a is Uint8Array {
+  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+
+/** Asserts something is positive integer. */
+export function anumber(n: number, title: string = ''): void {
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
+
+/** Asserts something is Uint8Array. */
+export function abytes(value: Uint8Array, length?: number, title: string = ''): Uint8Array {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== undefined;
+  if (!bytes || (needsLen && len !== length)) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : '';
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);
+  }
+  return value;
+}
+
+/** Asserts something is hash */
+export function ahash(h: CHash): void {
+  if (typeof h !== 'function' || typeof h.create !== 'function')
+    throw new Error('Hash must wrapped by utils.createHasher');
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+}
+
+/** Asserts a hash instance has not been destroyed / finished */
+export function aexists(instance: any, checkFinished = true): void {
+  if (instance.destroyed) throw new Error('Hash instance has been destroyed');
+  if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');
+}
+
+/** Asserts output is properly-sized byte array */
+export function aoutput(out: any, instance: any): void {
+  abytes(out, undefined, 'digestInto() output');
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+
+/** Generic type encompassing 8/16/32-byte arrays - but not 64-byte. */
+// prettier-ignore
+export type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array |
+  Uint16Array | Int16Array | Uint32Array | Int32Array;
+
+/** Cast u8 / u16 / u32 to u8. */
+export function u8(arr: TypedArray): Uint8Array {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+
+/** Cast u8 / u16 / u32 to u32. */
+export function u32(arr: TypedArray): Uint32Array {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+export function clean(...arrays: TypedArray[]): void {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+
+/** Create DataView of an array for easy byte-level manipulation. */
+export function createView(arr: TypedArray): DataView {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+
+/** The rotate right (circular right shift) operation for uint32 */
+export function rotr(word: number, shift: number): number {
+  return (word << (32 - shift)) | (word >>> shift);
+}
+
+/** The rotate left (circular left shift) operation for uint32 */
+export function rotl(word: number, shift: number): number {
+  return (word << shift) | ((word >>> (32 - shift)) >>> 0);
+}
+
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+export const isLE: boolean = /* @__PURE__ */ (() =>
+  new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+
+/** The byte swap operation for uint32 */
+export function byteSwap(word: number): number {
+  return (
+    ((word << 24) & 0xff000000) |
+    ((word << 8) & 0xff0000) |
+    ((word >>> 8) & 0xff00) |
+    ((word >>> 24) & 0xff)
+  );
+}
+/** Conditionally byte swap if on a big-endian platform */
+export const swap8IfBE: (n: number) => number = isLE
+  ? (n: number) => n
+  : (n: number) => byteSwap(n);
+
+/** In place byte swap for Uint32Array */
+export function byteSwap32(arr: Uint32Array): Uint32Array {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+
+export const swap32IfBE: (u: Uint32Array) => Uint32Array = isLE
+  ? (u: Uint32Array) => u
+  : byteSwap32;
+
+// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+const hasHexBuiltin: boolean = /* @__PURE__ */ (() =>
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+
+// Array where index 0xf0 (240) is mapped to string 'f0'
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>
+  i.toString(16).padStart(2, '0')
+);
+
+/**
+ * Convert byte array to hex string. Uses built-in function, when available.
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+export function bytesToHex(bytes: Uint8Array): string {
+  abytes(bytes);
+  // @ts-ignore
+  if (hasHexBuiltin) return bytes.toHex();
+  // pre-caching improves the speed 6x
+  let hex = '';
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+
+// We use optimized technique to convert hex string to byte array
+const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;
+function asciiToBase16(ch: number): number | undefined {
+  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48
+  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)
+  return;
+}
+
+/**
+ * Convert hex string to byte array. Uses built-in function, when available.
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+export function hexToBytes(hex: string): Uint8Array {
+  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
+  // @ts-ignore
+  if (hasHexBuiltin) return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);
+  const array = new Uint8Array(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === undefined || n2 === undefined) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+  }
+  return array;
+}
+
+/**
+ * There is no setImmediate in browser and setTimeout is slow.
+ * Call of async fn will return Promise, which will be fullfiled only on
+ * next scheduler queue processing step and this is exactly what we need.
+ */
+export const nextTick = async (): Promise<void> => {};
+
+/** Returns control to thread each 'tick' ms to avoid blocking. */
+export async function asyncLoop(
+  iters: number,
+  tick: number,
+  cb: (i: number) => void
+): Promise<void> {
+  let ts = Date.now();
+  for (let i = 0; i < iters; i++) {
+    cb(i);
+    // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+    const diff = Date.now() - ts;
+    if (diff >= 0 && diff < tick) continue;
+    await nextTick();
+    ts += diff;
+  }
+}
+
+// Global symbols, but ts doesn't see them: https://github.com/microsoft/TypeScript/issues/31535
+declare const TextEncoder: any;
+
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * Built-in doesn't validate input to be string: we do the check.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ */
+export function utf8ToBytes(str: string): Uint8Array {
+  if (typeof str !== 'string') throw new Error('string expected');
+  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+
+/** KDFs can accept string or Uint8Array for user convenience. */
+export type KDFInput = string | Uint8Array;
+
+/**
+ * Helper for KDFs: consumes uint8array or string.
+ * When string is passed, does utf8 decoding, using TextDecoder.
+ */
+export function kdfInputToBytes(data: KDFInput, errorTitle = ''): Uint8Array {
+  if (typeof data === 'string') return utf8ToBytes(data);
+  return abytes(data, undefined, errorTitle);
+}
+
+/** Copies several Uint8Arrays into one. */
+export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
+  let sum = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    abytes(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+}
+
+type EmptyObj = {};
+/** Merges default options and passed options. */
+export function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(
+  defaults: T1,
+  opts?: T2
+): T1 & T2 {
+  if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
+    throw new Error('options must be object or undefined');
+  const merged = Object.assign(defaults, opts);
+  return merged as T1 & T2;
+}
+
+/** Common interface for all hashes. */
+export interface Hash<T> {
+  blockLen: number; // Bytes per block
+  outputLen: number; // Bytes in output
+  update(buf: Uint8Array): this;
+  digestInto(buf: Uint8Array): void;
+  digest(): Uint8Array;
+  destroy(): void;
+  _cloneInto(to?: T): T;
+  clone(): T;
+}
+
+/** PseudoRandom (number) Generator */
+export interface PRG {
+  addEntropy(seed: Uint8Array): void;
+  randomBytes(length: number): Uint8Array;
+  clean(): void;
+}
+
+/**
+ * XOF: streaming API to read digest in chunks.
+ * Same as 'squeeze' in keccak/k12 and 'seek' in blake3, but more generic name.
+ * When hash used in XOF mode it is up to user to call '.destroy' afterwards, since we cannot
+ * destroy state, next call can require more bytes.
+ */
+export type HashXOF<T extends Hash<T>> = Hash<T> & {
+  xof(bytes: number): Uint8Array; // Read 'bytes' bytes from digest stream
+  xofInto(buf: Uint8Array): Uint8Array; // read buf.length bytes from digest stream into buf
+};
+
+/** Hash constructor */
+export type HasherCons<T, Opts = undefined> = Opts extends undefined ? () => T : (opts?: Opts) => T;
+/** Optional hash params. */
+export type HashInfo = {
+  oid?: Uint8Array; // DER encoded OID in bytes
+};
+/** Hash function */
+export type CHash<T extends Hash<T> = Hash<any>, Opts = undefined> = {
+  outputLen: number;
+  blockLen: number;
+} & HashInfo &
+  (Opts extends undefined
+    ? {
+        (msg: Uint8Array): Uint8Array;
+        create(): T;
+      }
+    : {
+        (msg: Uint8Array, opts?: Opts): Uint8Array;
+        create(opts?: Opts): T;
+      });
+/** XOF with output */
+export type CHashXOF<T extends HashXOF<T> = HashXOF<any>, Opts = undefined> = CHash<T, Opts>;
+
+/** Creates function with outputLen, blockLen, create properties from a class constructor. */
+export function createHasher<T extends Hash<T>, Opts = undefined>(
+  hashCons: HasherCons<T, Opts>,
+  info: HashInfo = {}
+): CHash<T, Opts> {
+  const hashC: any = (msg: Uint8Array, opts?: Opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(undefined);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts?: Opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+
+/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+export function randomBytes(bytesLength = 32): Uint8Array {
+  const cr = typeof globalThis === 'object' ? (globalThis as any).crypto : null;
+  if (typeof cr?.getRandomValues !== 'function')
+    throw new Error('crypto.getRandomValues must be defined');
+  return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+
+/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */
+export const oidNist = (suffix: number): Required<HashInfo> => ({
+  oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),
+});

control-plane-ui/tests/integration/node_modules/@noble/hashes/src/webcrypto.ts

@@ -0,0 +1,168 @@
+import { type Pbkdf2Opt } from './pbkdf2.ts';
+import {
+  abytes,
+  ahash,
+  anumber,
+  checkOpts,
+  kdfInputToBytes,
+  type CHash,
+  type KDFInput,
+} from './utils.ts';
+
+function _subtle(): typeof crypto.subtle {
+  const cr = typeof globalThis === 'object' ? (globalThis as any).crypto : null;
+  const sb = cr?.subtle;
+  if (typeof sb === 'object' && sb != null) return sb;
+  throw new Error('crypto.subtle must be defined');
+}
+
+export type WebHash = {
+  (msg: Uint8Array): Promise<Uint8Array>;
+  webCryptoName: string;
+  outputLen: number;
+  blockLen: number;
+};
+
+function createWebHash(name: string, blockLen: number, outputLen: number): WebHash {
+  const hashC: any = async (msg: Uint8Array) => {
+    abytes(msg);
+    const crypto = _subtle();
+    return new Uint8Array(await crypto.digest(name, msg as BufferSource));
+  };
+  hashC.webCryptoName = name; // make sure it won't interfere with function name
+  hashC.outputLen = outputLen;
+  hashC.blockLen = blockLen;
+  hashC.create = () => {
+    throw new Error('not implemented');
+  };
+  return hashC;
+}
+
+function ahashWeb(hash: WebHash) {
+  ahash(hash as any as CHash);
+  if (typeof hash.webCryptoName !== 'string') throw new Error('non-web hash');
+}
+
+/** WebCrypto SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+// export const sha1: WebHash = createHash('SHA-1', 64, 20);
+
+/** WebCrypto SHA2-256 hash function from RFC 4634. */
+export const sha256: WebHash = /* @__PURE__ */ createWebHash('SHA-256', 64, 32);
+/** WebCrypto SHA2-384 hash function from RFC 4634. */
+export const sha384: WebHash = /* @__PURE__ */ createWebHash('SHA-384', 128, 48);
+/** WebCrypto SHA2-512 hash function from RFC 4634. */
+export const sha512: WebHash = /* @__PURE__ */ createWebHash('SHA-512', 128, 64);
+
+/**
+ * WebCrypto HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256. Webcrypto version.
+ * @param key - key which would be used to authenticate message
+ * @param message - message
+ * @example
+ * ```js
+ * import { hmac, sha256 } from '@noble/hashes/webcrypto.js';
+ * const mac1 = await hmac(sha256, 'key', 'message');
+ * ```
+ */
+export const hmac: {
+  (hash: WebHash, key: Uint8Array, message: Uint8Array): Promise<Uint8Array>;
+  create(hash: WebHash, key: Uint8Array): any;
+} = /* @__PURE__ */ (() => {
+  const hmac_ = async (
+    hash: WebHash,
+    key: Uint8Array,
+    message: Uint8Array
+  ): Promise<Uint8Array> => {
+    const crypto = _subtle();
+    abytes(key, undefined, 'key');
+    abytes(message, undefined, 'message');
+    ahashWeb(hash);
+    // WebCrypto keys can't be zeroized
+    // prettier-ignore
+    const wkey = await crypto.importKey(
+      'raw',
+      key as BufferSource,
+      { name: 'HMAC', hash: hash.webCryptoName },
+      false,
+      ['sign']
+    );
+    return new Uint8Array(await crypto.sign('HMAC', wkey, message as BufferSource));
+  };
+  hmac_.create = (_hash: WebHash, _key: Uint8Array) => {
+    throw new Error('not implemented');
+  };
+  return hmac_;
+})();
+
+/**
+ * WebCrypto HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256). Webcrypto version.
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ * @example
+ * ```js
+ * import { hkdf, sha256 } from '@noble/hashes/webcrypto.js';
+ * import { randomBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = 'application-key';
+ * const hk1w = await hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+export async function hkdf(
+  hash: WebHash,
+  ikm: Uint8Array,
+  salt: Uint8Array | undefined,
+  info: Uint8Array | undefined,
+  length: number
+): Promise<Uint8Array> {
+  const crypto = _subtle();
+  ahashWeb(hash);
+  abytes(ikm, undefined, 'ikm');
+  anumber(length, 'length');
+  if (salt !== undefined) abytes(salt, undefined, 'salt');
+  if (info !== undefined) abytes(info, undefined, 'info');
+  const wkey = await crypto.importKey('raw', ikm as BufferSource, 'HKDF', false, ['deriveBits']);
+  const opts = {
+    name: 'HKDF',
+    hash: hash.webCryptoName,
+    salt: salt === undefined ? new Uint8Array(0) : salt,
+    info: info === undefined ? new Uint8Array(0) : info,
+  };
+  return new Uint8Array(await crypto.deriveBits(opts, wkey, 8 * length));
+}
+
+/**
+ * WebCrypto PBKDF2-HMAC: RFC 2898 key derivation function
+ * @param hash - hash function that would be used e.g. sha256. Webcrypto version.
+ * @param password - password from which a derived key is generated
+ * @param salt - cryptographic salt
+ * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
+ * @example
+ * ```js
+ * const key = await pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ * ```
+ */
+export async function pbkdf2(
+  hash: WebHash,
+  password: KDFInput,
+  salt: KDFInput,
+  opts: Pbkdf2Opt
+): Promise<Uint8Array> {
+  const crypto = _subtle();
+  ahashWeb(hash);
+  const _opts = checkOpts({ dkLen: 32 }, opts);
+  const { c, dkLen } = _opts;
+  anumber(c, 'c');
+  anumber(dkLen, 'dkLen');
+  const _password = kdfInputToBytes(password, 'password');
+  const _salt = kdfInputToBytes(salt, 'salt');
+  const key = await crypto.importKey('raw', _password as BufferSource, 'PBKDF2', false, [
+    'deriveBits',
+  ]);
+  const deriveOpts = { name: 'PBKDF2', salt: _salt, iterations: c, hash: hash.webCryptoName };
+  return new Uint8Array(await crypto.deriveBits(deriveOpts, key, 8 * dkLen));
+}

control-plane-ui/tests/integration/node_modules/@noble/hashes/utils.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+export declare function isBytes(a: unknown): a is Uint8Array;
+/** Asserts something is positive integer. */
+export declare function anumber(n: number, title?: string): void;
+/** Asserts something is Uint8Array. */
+export declare function abytes(value: Uint8Array, length?: number, title?: string): Uint8Array;
+/** Asserts something is hash */
+export declare function ahash(h: CHash): void;
+/** Asserts a hash instance has not been destroyed / finished */
+export declare function aexists(instance: any, checkFinished?: boolean): void;
+/** Asserts output is properly-sized byte array */
+export declare function aoutput(out: any, instance: any): void;
+/** Generic type encompassing 8/16/32-byte arrays - but not 64-byte. */
+export type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array | Uint16Array | Int16Array | Uint32Array | Int32Array;
+/** Cast u8 / u16 / u32 to u8. */
+export declare function u8(arr: TypedArray): Uint8Array;
+/** Cast u8 / u16 / u32 to u32. */
+export declare function u32(arr: TypedArray): Uint32Array;
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+export declare function clean(...arrays: TypedArray[]): void;
+/** Create DataView of an array for easy byte-level manipulation. */
+export declare function createView(arr: TypedArray): DataView;
+/** The rotate right (circular right shift) operation for uint32 */
+export declare function rotr(word: number, shift: number): number;
+/** The rotate left (circular left shift) operation for uint32 */
+export declare function rotl(word: number, shift: number): number;
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+export declare const isLE: boolean;
+/** The byte swap operation for uint32 */
+export declare function byteSwap(word: number): number;
+/** Conditionally byte swap if on a big-endian platform */
+export declare const swap8IfBE: (n: number) => number;
+/** In place byte swap for Uint32Array */
+export declare function byteSwap32(arr: Uint32Array): Uint32Array;
+export declare const swap32IfBE: (u: Uint32Array) => Uint32Array;
+/**
+ * Convert byte array to hex string. Uses built-in function, when available.
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * Convert hex string to byte array. Uses built-in function, when available.
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+export declare function hexToBytes(hex: string): Uint8Array;
+/**
+ * There is no setImmediate in browser and setTimeout is slow.
+ * Call of async fn will return Promise, which will be fullfiled only on
+ * next scheduler queue processing step and this is exactly what we need.
+ */
+export declare const nextTick: () => Promise<void>;
+/** Returns control to thread each 'tick' ms to avoid blocking. */
+export declare function asyncLoop(iters: number, tick: number, cb: (i: number) => void): Promise<void>;
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * Built-in doesn't validate input to be string: we do the check.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ */
+export declare function utf8ToBytes(str: string): Uint8Array;
+/** KDFs can accept string or Uint8Array for user convenience. */
+export type KDFInput = string | Uint8Array;
+/**
+ * Helper for KDFs: consumes uint8array or string.
+ * When string is passed, does utf8 decoding, using TextDecoder.
+ */
+export declare function kdfInputToBytes(data: KDFInput, errorTitle?: string): Uint8Array;
+/** Copies several Uint8Arrays into one. */
+export declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+type EmptyObj = {};
+/** Merges default options and passed options. */
+export declare function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(defaults: T1, opts?: T2): T1 & T2;
+/** Common interface for all hashes. */
+export interface Hash<T> {
+    blockLen: number;
+    outputLen: number;
+    update(buf: Uint8Array): this;
+    digestInto(buf: Uint8Array): void;
+    digest(): Uint8Array;
+    destroy(): void;
+    _cloneInto(to?: T): T;
+    clone(): T;
+}
+/** PseudoRandom (number) Generator */
+export interface PRG {
+    addEntropy(seed: Uint8Array): void;
+    randomBytes(length: number): Uint8Array;
+    clean(): void;
+}
+/**
+ * XOF: streaming API to read digest in chunks.
+ * Same as 'squeeze' in keccak/k12 and 'seek' in blake3, but more generic name.
+ * When hash used in XOF mode it is up to user to call '.destroy' afterwards, since we cannot
+ * destroy state, next call can require more bytes.
+ */
+export type HashXOF<T extends Hash<T>> = Hash<T> & {
+    xof(bytes: number): Uint8Array;
+    xofInto(buf: Uint8Array): Uint8Array;
+};
+/** Hash constructor */
+export type HasherCons<T, Opts = undefined> = Opts extends undefined ? () => T : (opts?: Opts) => T;
+/** Optional hash params. */
+export type HashInfo = {
+    oid?: Uint8Array;
+};
+/** Hash function */
+export type CHash<T extends Hash<T> = Hash<any>, Opts = undefined> = {
+    outputLen: number;
+    blockLen: number;
+} & HashInfo & (Opts extends undefined ? {
+    (msg: Uint8Array): Uint8Array;
+    create(): T;
+} : {
+    (msg: Uint8Array, opts?: Opts): Uint8Array;
+    create(opts?: Opts): T;
+});
+/** XOF with output */
+export type CHashXOF<T extends HashXOF<T> = HashXOF<any>, Opts = undefined> = CHash<T, Opts>;
+/** Creates function with outputLen, blockLen, create properties from a class constructor. */
+export declare function createHasher<T extends Hash<T>, Opts = undefined>(hashCons: HasherCons<T, Opts>, info?: HashInfo): CHash<T, Opts>;
+/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+export declare function randomBytes(bytesLength?: number): Uint8Array;
+/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */
+export declare const oidNist: (suffix: number) => Required<HashInfo>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["src/utils.ts"],"names":[],"mappings":"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"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/utils.js

@@ -0,0 +1,242 @@
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+export function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+/** Asserts something is positive integer. */
+export function anumber(n, title = '') {
+    if (!Number.isSafeInteger(n) || n < 0) {
+        const prefix = title && `"${title}" `;
+        throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+    }
+}
+/** Asserts something is Uint8Array. */
+export function abytes(value, length, title = '') {
+    const bytes = isBytes(value);
+    const len = value?.length;
+    const needsLen = length !== undefined;
+    if (!bytes || (needsLen && len !== length)) {
+        const prefix = title && `"${title}" `;
+        const ofLen = needsLen ? ` of length ${length}` : '';
+        const got = bytes ? `length=${len}` : `type=${typeof value}`;
+        throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);
+    }
+    return value;
+}
+/** Asserts something is hash */
+export function ahash(h) {
+    if (typeof h !== 'function' || typeof h.create !== 'function')
+        throw new Error('Hash must wrapped by utils.createHasher');
+    anumber(h.outputLen);
+    anumber(h.blockLen);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+export function aexists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+export function aoutput(out, instance) {
+    abytes(out, undefined, 'digestInto() output');
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('"digestInto() output" expected to be of length >=' + min);
+    }
+}
+/** Cast u8 / u16 / u32 to u8. */
+export function u8(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** Cast u8 / u16 / u32 to u32. */
+export function u32(arr) {
+    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+export function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+    }
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+export function createView(arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+export function rotr(word, shift) {
+    return (word << (32 - shift)) | (word >>> shift);
+}
+/** The rotate left (circular left shift) operation for uint32 */
+export function rotl(word, shift) {
+    return (word << shift) | ((word >>> (32 - shift)) >>> 0);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+export const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+/** The byte swap operation for uint32 */
+export function byteSwap(word) {
+    return (((word << 24) & 0xff000000) |
+        ((word << 8) & 0xff0000) |
+        ((word >>> 8) & 0xff00) |
+        ((word >>> 24) & 0xff));
+}
+/** Conditionally byte swap if on a big-endian platform */
+export const swap8IfBE = isLE
+    ? (n) => n
+    : (n) => byteSwap(n);
+/** In place byte swap for Uint32Array */
+export function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+    }
+    return arr;
+}
+export const swap32IfBE = isLE
+    ? (u) => u
+    : byteSwap32;
+// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+const hasHexBuiltin = /* @__PURE__ */ (() => 
+// @ts-ignore
+typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+// Array where index 0xf0 (240) is mapped to string 'f0'
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/**
+ * Convert byte array to hex string. Uses built-in function, when available.
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+export function bytesToHex(bytes) {
+    abytes(bytes);
+    // @ts-ignore
+    if (hasHexBuiltin)
+        return bytes.toHex();
+    // pre-caching improves the speed 6x
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+// We use optimized technique to convert hex string to byte array
+const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+    if (ch >= asciis._0 && ch <= asciis._9)
+        return ch - asciis._0; // '2' => 50-48
+    if (ch >= asciis.A && ch <= asciis.F)
+        return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+    if (ch >= asciis.a && ch <= asciis.f)
+        return ch - (asciis.a - 10); // 'b' => 98-(97-10)
+    return;
+}
+/**
+ * Convert hex string to byte array. Uses built-in function, when available.
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+export function hexToBytes(hex) {
+    if (typeof hex !== 'string')
+        throw new Error('hex string expected, got ' + typeof hex);
+    // @ts-ignore
+    if (hasHexBuiltin)
+        return Uint8Array.fromHex(hex);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+        throw new Error('hex string expected, got unpadded hex of length ' + hl);
+    const array = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        const n1 = asciiToBase16(hex.charCodeAt(hi));
+        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === undefined || n2 === undefined) {
+            const char = hex[hi] + hex[hi + 1];
+            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+    }
+    return array;
+}
+/**
+ * There is no setImmediate in browser and setTimeout is slow.
+ * Call of async fn will return Promise, which will be fullfiled only on
+ * next scheduler queue processing step and this is exactly what we need.
+ */
+export const nextTick = async () => { };
+/** Returns control to thread each 'tick' ms to avoid blocking. */
+export async function asyncLoop(iters, tick, cb) {
+    let ts = Date.now();
+    for (let i = 0; i < iters; i++) {
+        cb(i);
+        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+        const diff = Date.now() - ts;
+        if (diff >= 0 && diff < tick)
+            continue;
+        await nextTick();
+        ts += diff;
+    }
+}
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * Built-in doesn't validate input to be string: we do the check.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ */
+export function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error('string expected');
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * Helper for KDFs: consumes uint8array or string.
+ * When string is passed, does utf8 decoding, using TextDecoder.
+ */
+export function kdfInputToBytes(data, errorTitle = '') {
+    if (typeof data === 'string')
+        return utf8ToBytes(data);
+    return abytes(data, undefined, errorTitle);
+}
+/** Copies several Uint8Arrays into one. */
+export function concatBytes(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        abytes(a);
+        sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+    }
+    return res;
+}
+/** Merges default options and passed options. */
+export function checkOpts(defaults, opts) {
+    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
+        throw new Error('options must be object or undefined');
+    const merged = Object.assign(defaults, opts);
+    return merged;
+}
+/** Creates function with outputLen, blockLen, create properties from a class constructor. */
+export function createHasher(hashCons, info = {}) {
+    const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+    const tmp = hashCons(undefined);
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    Object.assign(hashC, info);
+    return Object.freeze(hashC);
+}
+/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+export function randomBytes(bytesLength = 32) {
+    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;
+    if (typeof cr?.getRandomValues !== 'function')
+        throw new Error('crypto.getRandomValues must be defined');
+    return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */
+export const oidNist = (suffix) => ({
+    oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),
+});
+//# sourceMappingURL=utils.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/webcrypto.d.ts

@@ -0,0 +1,62 @@
+import { type Pbkdf2Opt } from './pbkdf2.ts';
+import { type KDFInput } from './utils.ts';
+export type WebHash = {
+    (msg: Uint8Array): Promise<Uint8Array>;
+    webCryptoName: string;
+    outputLen: number;
+    blockLen: number;
+};
+/** WebCrypto SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+/** WebCrypto SHA2-256 hash function from RFC 4634. */
+export declare const sha256: WebHash;
+/** WebCrypto SHA2-384 hash function from RFC 4634. */
+export declare const sha384: WebHash;
+/** WebCrypto SHA2-512 hash function from RFC 4634. */
+export declare const sha512: WebHash;
+/**
+ * WebCrypto HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256. Webcrypto version.
+ * @param key - key which would be used to authenticate message
+ * @param message - message
+ * @example
+ * ```js
+ * import { hmac, sha256 } from '@noble/hashes/webcrypto.js';
+ * const mac1 = await hmac(sha256, 'key', 'message');
+ * ```
+ */
+export declare const hmac: {
+    (hash: WebHash, key: Uint8Array, message: Uint8Array): Promise<Uint8Array>;
+    create(hash: WebHash, key: Uint8Array): any;
+};
+/**
+ * WebCrypto HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256). Webcrypto version.
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ * @example
+ * ```js
+ * import { hkdf, sha256 } from '@noble/hashes/webcrypto.js';
+ * import { randomBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = 'application-key';
+ * const hk1w = await hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+export declare function hkdf(hash: WebHash, ikm: Uint8Array, salt: Uint8Array | undefined, info: Uint8Array | undefined, length: number): Promise<Uint8Array>;
+/**
+ * WebCrypto PBKDF2-HMAC: RFC 2898 key derivation function
+ * @param hash - hash function that would be used e.g. sha256. Webcrypto version.
+ * @param password - password from which a derived key is generated
+ * @param salt - cryptographic salt
+ * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
+ * @example
+ * ```js
+ * const key = await pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ * ```
+ */
+export declare function pbkdf2(hash: WebHash, password: KDFInput, salt: KDFInput, opts: Pbkdf2Opt): Promise<Uint8Array>;
+//# sourceMappingURL=webcrypto.d.ts.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/webcrypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.d.ts","sourceRoot":"","sources":["src/webcrypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAOL,KAAK,QAAQ,EACd,MAAM,YAAY,CAAC;AASpB,MAAM,MAAM,OAAO,GAAG;IACpB,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAsBF,uFAAuF;AAGvF,sDAAsD;AACtD,eAAO,MAAM,MAAM,EAAE,OAA0D,CAAC;AAChF,sDAAsD;AACtD,eAAO,MAAM,MAAM,EAAE,OAA2D,CAAC;AACjF,sDAAsD;AACtD,eAAO,MAAM,MAAM,EAAE,OAA2D,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC3E,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,GAAG,GAAG,CAAC;CA0B1C,CAAC;AAEL;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,IAAI,CACxB,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,UAAU,GAAG,SAAS,EAC5B,IAAI,EAAE,UAAU,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,UAAU,CAAC,CAerB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,UAAU,CAAC,CAcrB"}

control-plane-ui/tests/integration/node_modules/@noble/hashes/webcrypto.js

@@ -0,0 +1,126 @@
+import {} from "./pbkdf2.js";
+import { abytes, ahash, anumber, checkOpts, kdfInputToBytes, } from "./utils.js";
+function _subtle() {
+    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;
+    const sb = cr?.subtle;
+    if (typeof sb === 'object' && sb != null)
+        return sb;
+    throw new Error('crypto.subtle must be defined');
+}
+function createWebHash(name, blockLen, outputLen) {
+    const hashC = async (msg) => {
+        abytes(msg);
+        const crypto = _subtle();
+        return new Uint8Array(await crypto.digest(name, msg));
+    };
+    hashC.webCryptoName = name; // make sure it won't interfere with function name
+    hashC.outputLen = outputLen;
+    hashC.blockLen = blockLen;
+    hashC.create = () => {
+        throw new Error('not implemented');
+    };
+    return hashC;
+}
+function ahashWeb(hash) {
+    ahash(hash);
+    if (typeof hash.webCryptoName !== 'string')
+        throw new Error('non-web hash');
+}
+/** WebCrypto SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+// export const sha1: WebHash = createHash('SHA-1', 64, 20);
+/** WebCrypto SHA2-256 hash function from RFC 4634. */
+export const sha256 = /* @__PURE__ */ createWebHash('SHA-256', 64, 32);
+/** WebCrypto SHA2-384 hash function from RFC 4634. */
+export const sha384 = /* @__PURE__ */ createWebHash('SHA-384', 128, 48);
+/** WebCrypto SHA2-512 hash function from RFC 4634. */
+export const sha512 = /* @__PURE__ */ createWebHash('SHA-512', 128, 64);
+/**
+ * WebCrypto HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256. Webcrypto version.
+ * @param key - key which would be used to authenticate message
+ * @param message - message
+ * @example
+ * ```js
+ * import { hmac, sha256 } from '@noble/hashes/webcrypto.js';
+ * const mac1 = await hmac(sha256, 'key', 'message');
+ * ```
+ */
+export const hmac = /* @__PURE__ */ (() => {
+    const hmac_ = async (hash, key, message) => {
+        const crypto = _subtle();
+        abytes(key, undefined, 'key');
+        abytes(message, undefined, 'message');
+        ahashWeb(hash);
+        // WebCrypto keys can't be zeroized
+        // prettier-ignore
+        const wkey = await crypto.importKey('raw', key, { name: 'HMAC', hash: hash.webCryptoName }, false, ['sign']);
+        return new Uint8Array(await crypto.sign('HMAC', wkey, message));
+    };
+    hmac_.create = (_hash, _key) => {
+        throw new Error('not implemented');
+    };
+    return hmac_;
+})();
+/**
+ * WebCrypto HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256). Webcrypto version.
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes
+ * @example
+ * ```js
+ * import { hkdf, sha256 } from '@noble/hashes/webcrypto.js';
+ * import { randomBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = 'application-key';
+ * const hk1w = await hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+export async function hkdf(hash, ikm, salt, info, length) {
+    const crypto = _subtle();
+    ahashWeb(hash);
+    abytes(ikm, undefined, 'ikm');
+    anumber(length, 'length');
+    if (salt !== undefined)
+        abytes(salt, undefined, 'salt');
+    if (info !== undefined)
+        abytes(info, undefined, 'info');
+    const wkey = await crypto.importKey('raw', ikm, 'HKDF', false, ['deriveBits']);
+    const opts = {
+        name: 'HKDF',
+        hash: hash.webCryptoName,
+        salt: salt === undefined ? new Uint8Array(0) : salt,
+        info: info === undefined ? new Uint8Array(0) : info,
+    };
+    return new Uint8Array(await crypto.deriveBits(opts, wkey, 8 * length));
+}
+/**
+ * WebCrypto PBKDF2-HMAC: RFC 2898 key derivation function
+ * @param hash - hash function that would be used e.g. sha256. Webcrypto version.
+ * @param password - password from which a derived key is generated
+ * @param salt - cryptographic salt
+ * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
+ * @example
+ * ```js
+ * const key = await pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ * ```
+ */
+export async function pbkdf2(hash, password, salt, opts) {
+    const crypto = _subtle();
+    ahashWeb(hash);
+    const _opts = checkOpts({ dkLen: 32 }, opts);
+    const { c, dkLen } = _opts;
+    anumber(c, 'c');
+    anumber(dkLen, 'dkLen');
+    const _password = kdfInputToBytes(password, 'password');
+    const _salt = kdfInputToBytes(salt, 'salt');
+    const key = await crypto.importKey('raw', _password, 'PBKDF2', false, [
+        'deriveBits',
+    ]);
+    const deriveOpts = { name: 'PBKDF2', salt: _salt, iterations: c, hash: hash.webCryptoName };
+    return new Uint8Array(await crypto.deriveBits(deriveOpts, key, 8 * dkLen));
+}
+//# sourceMappingURL=webcrypto.js.map

control-plane-ui/tests/integration/node_modules/@noble/hashes/webcrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.js","sourceRoot":"","sources":["src/webcrypto.ts"],"names":[],"mappings":"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"}