@dotenvx/next-env 1.74.3 → 2.0.1

package/node_modules/@noble/ciphers/src/salsa.ts

@@ -1,189 +0,0 @@
-/**
- * [Salsa20](https://cr.yp.to/snuffle.html) stream cipher, released in 2005.
- *
- * Salsa's goal was to implement AES replacement that does not rely on S-Boxes,
- * which are hard to implement in a constant-time manner.
- * Salsa20 is usually faster than AES, a big deal on slow, budget mobile phones.
- *
- * [XSalsa20](https://cr.yp.to/snuffle/xsalsa-20110204.pdf), extended-nonce
- * variant was released in 2008. It switched nonces from 96-bit to 192-bit,
- * and became safe to be picked at random.
- *
- * Check out [PDF](https://cr.yp.to/snuffle/salsafamily-20071225.pdf) and
- * [wiki](https://en.wikipedia.org/wiki/Salsa20).
- * @module
- */
-import { createCipher, rotl } from './_arx.ts';
-import { poly1305 } from './_poly1305.ts';
-import {
-  abytes,
-  type ARXCipher,
-  type CipherWithOutput,
-  clean,
-  equalBytes,
-  getOutput,
-  wrapCipher,
-  type XorStream,
-} from './utils.ts';
-
-/** Salsa20 core function. */
-// prettier-ignore
-function salsaCore(
-  s: Uint32Array, k: Uint32Array, n: Uint32Array, out: Uint32Array, cnt: number, rounds = 20
-): void {
-  // Based on https://cr.yp.to/salsa20.html
-  let y00 = s[0], y01 = k[0], y02 = k[1], y03 = k[2], // "expa" Key     Key     Key
-      y04 = k[3], y05 = s[1], y06 = n[0], y07 = n[1], // Key    "nd 3"  Nonce   Nonce
-      y08 = cnt,  y09 = 0,    y10 = s[2], y11 = k[4], // Pos.   Pos.    "2-by"	Key
-      y12 = k[5], y13 = k[6], y14 = k[7], y15 = s[3]; // Key    Key     Key     "te k"
-  // Save state to temporary variables
-  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;
-  for (let r = 0; r < rounds; r += 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
-  let oi = 0;
-  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;
-}
-
-/**
- * hsalsa hashing function, used primarily in xsalsa, to hash
- * key and nonce into key' and nonce'.
- * Same as salsaCore, but there doesn't seem to be a way to move the block
- * out without 25% performance hit.
- */
-// prettier-ignore
-export function hsalsa(
-  s: Uint32Array, k: Uint32Array, i: Uint32Array, o32: Uint32Array
-): void {
-  let x00 = s[0], x01 = k[0], x02 = k[1], x03 = k[2],
-      x04 = k[3], x05 = s[1], x06 = i[0], x07 = i[1],
-      x08 = i[2], x09 = i[3], x10 = s[2], x11 = k[4],
-      x12 = k[5], x13 = k[6], x14 = k[7], x15 = s[3];
-  for (let r = 0; r < 20; r += 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);
-  }
-  let oi = 0;
-  o32[oi++] = x00; o32[oi++] = x05;
-  o32[oi++] = x10; o32[oi++] = x15;
-  o32[oi++] = x06; o32[oi++] = x07;
-  o32[oi++] = x08; o32[oi++] = x09;
-}
-
-/**
- * Salsa20 from original paper.
- * Unsafe to use random nonces under the same key, due to collision chance.
- * Prefer XSalsa instead.
- */
-export const salsa20: XorStream = /* @__PURE__ */ createCipher(salsaCore, {
-  allowShortKeys: true,
-  counterRight: true,
-});
-
-/**
- * xsalsa20 eXtended-nonce salsa.
- * Can be safely used with random 24-byte nonces (CSPRNG).
- */
-export const xsalsa20: XorStream = /* @__PURE__ */ createCipher(salsaCore, {
-  counterRight: true,
-  extendNonceFn: hsalsa,
-});
-
-/**
- * xsalsa20-poly1305 eXtended-nonce salsa.
- * Can be safely used with random 24-byte nonces (CSPRNG).
- * Also known as secretbox from libsodium / nacl.
- */
-export const xsalsa20poly1305: ARXCipher = /* @__PURE__ */ wrapCipher(
-  { blockSize: 64, nonceLength: 24, tagLength: 16 },
-  (key: Uint8Array, nonce: Uint8Array): CipherWithOutput => {
-    return {
-      encrypt(plaintext: Uint8Array, output?: Uint8Array) {
-        // xsalsa20poly1305 optimizes by calculating auth key during the same call as encryption.
-        // Unfortunately, makes it hard to separate tag calculation & encryption itself,
-        // because 32 bytes is half-block of 64-byte salsa.
-        output = getOutput(plaintext.length + 32, output, false); // need 32 additional bytes, see above
-        const authKey = output.subarray(0, 32); // output[0..32] = poly1305 auth key
-        const ciphPlaintext = output.subarray(32); // output[32..] = plaintext, then ciphertext
-        output.set(plaintext, 32);
-        clean(authKey); // authKey is produced by xoring with zeros
-        xsalsa20(key, nonce, output, output); // output = stream ^ output; authKey = stream ^ zeros(32)
-        const tag = poly1305(ciphPlaintext, authKey); // calculate tag over ciphertext
-        output.set(tag, 16); // output[16..32] = tag
-        clean(output.subarray(0, 16), tag); // clean-up authKey remnants & copy of tag
-        return output.subarray(16); // return output[16..]
-      },
-      decrypt(ciphertext: Uint8Array, output?: Uint8Array) {
-        // tmp part     passed tag    ciphertext
-        // [0..32]      [32..48]      [48..]
-        abytes(ciphertext);
-        output = getOutput(ciphertext.length + 32, output, false);
-        const tmp = output.subarray(0, 32); // output[0..32] is used to calc authKey
-        const passedTag = output.subarray(32, 48); // output[32..48] = passed tag
-        const ciphPlaintext = output.subarray(48); // output[48..] = ciphertext, then plaintext
-        output.set(ciphertext, 32); // copy ciphertext into output
-        clean(tmp); // authKey is produced by xoring with zeros
-        const authKey = xsalsa20(key, nonce, tmp, tmp); // authKey = stream ^ zeros(32)
-        const tag = poly1305(ciphPlaintext, authKey); // calculate tag over ciphertext
-        if (!equalBytes(passedTag, tag)) throw new Error('invalid tag');
-        xsalsa20(key, nonce, output.subarray(16), output.subarray(16)); // output = stream ^ output[16..]
-        clean(tmp, passedTag, tag);
-        return ciphPlaintext; // return output[48..], skipping zeroized output[0..48]
-      },
-    };
-  }
-);
-
-/**
- * Alias to `xsalsa20poly1305`, for compatibility with libsodium / nacl
- */
-export function secretbox(
-  key: Uint8Array,
-  nonce: Uint8Array
-): {
-  seal: (plaintext: Uint8Array, output?: Uint8Array) => Uint8Array;
-  open: (ciphertext: Uint8Array, output?: Uint8Array) => Uint8Array;
-} {
-  const xs = xsalsa20poly1305(key, nonce);
-  return { seal: xs.encrypt, open: xs.decrypt };
-}

package/node_modules/@noble/ciphers/src/utils.ts

@@ -1,453 +0,0 @@
-/**
- * Utilities for hex, bytes, CSPRNG.
- * @module
- */
-/*! noble-ciphers - MIT License (c) 2023 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 boolean. */
-export function abool(b: boolean): void {
-  if (typeof b !== 'boolean') throw new Error(`boolean expected, not ${b}`);
-}
-
-/** Asserts something is positive integer. */
-export function anumber(n: number): void {
-  if (!Number.isSafeInteger(n) || n < 0) throw new Error('positive integer expected, got ' + n);
-}
-
-/** Asserts something is Uint8Array. */
-export function abytes(b: Uint8Array | undefined, ...lengths: number[]): void {
-  if (!isBytes(b)) throw new Error('Uint8Array expected');
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
-}
-
-/**
- * Asserts something is hash
- * TODO: remove
- * @deprecated
- */
-export function ahash(h: IHash): void {
-  if (typeof h !== 'function' || typeof h.create !== 'function')
-    throw new Error('Hash should be 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);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error('digestInto() expects output buffer of length at least ' + min);
-  }
-}
-
-export type IHash = {
-  (data: string | Uint8Array): Uint8Array;
-  blockLen: number;
-  outputLen: number;
-  create: any;
-};
-
-/** 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);
-}
-
-/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
-export const isLE: boolean = /* @__PURE__ */ (() =>
-  new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
-
-// 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;
-}
-
-// Used in micro
-export function hexToNumber(hex: string): bigint {
-  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
-  return BigInt(hex === '' ? '0' : '0x' + hex); // Big Endian
-}
-
-// Used in ff1
-// BE: Big Endian, LE: Little Endian
-export function bytesToNumberBE(bytes: Uint8Array): bigint {
-  return hexToNumber(bytesToHex(bytes));
-}
-
-// Used in micro, ff1
-export function numberToBytesBE(n: number | bigint, len: number): Uint8Array {
-  return hexToBytes(n.toString(16).padStart(len * 2, '0'));
-}
-
-// TODO: remove
-// 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> => {};
-
-// Global symbols, but ts doesn't see them: https://github.com/microsoft/TypeScript/issues/31535
-declare const TextEncoder: any;
-declare const TextDecoder: any;
-
-/**
- * Converts string to bytes using UTF8 encoding.
- * @example utf8ToBytes('abc') // new Uint8Array([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
-}
-
-/**
- * Converts bytes to string using UTF8 encoding.
- * @example bytesToUtf8(new Uint8Array([97, 98, 99])) // 'abc'
- */
-export function bytesToUtf8(bytes: Uint8Array): string {
-  return new TextDecoder().decode(bytes);
-}
-
-// TODO: remove
-export type Input = Uint8Array | string;
-/**
- * Normalizes (non-hex) string or Uint8Array to Uint8Array.
- * Warning: when Uint8Array is passed, it would NOT get copied.
- * Keep in mind for future mutable operations.
- */
-export function toBytes(data: string | Uint8Array): Uint8Array {
-  if (typeof data === 'string') data = utf8ToBytes(data);
-  else if (isBytes(data)) data = copyBytes(data);
-  else throw new Error('Uint8Array expected, got ' + typeof data);
-  return data;
-}
-
-/**
- * Checks if two U8A use same underlying buffer and overlaps.
- * This is invalid and can corrupt data.
- */
-export function overlapBytes(a: Uint8Array, b: Uint8Array): boolean {
-  return (
-    a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy
-    a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end
-    b.byteOffset < a.byteOffset + a.byteLength // b starts before a end
-  );
-}
-
-/**
- * If input and output overlap and input starts before output, we will overwrite end of input before
- * we start processing it, so this is not supported for most ciphers (except chacha/salse, which designed with this)
- */
-export function complexOverlapBytes(input: Uint8Array, output: Uint8Array): void {
-  // This is very cursed. It works somehow, but I'm completely unsure,
-  // reasoning about overlapping aligned windows is very hard.
-  if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)
-    throw new Error('complex overlap of input and output is not supported');
-}
-
-/**
- * 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;
-}
-
-// Used in ARX only
-type EmptyObj = {};
-export function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(
-  defaults: T1,
-  opts: T2
-): T1 & T2 {
-  if (opts == null || typeof opts !== 'object') throw new Error('options must be defined');
-  const merged = Object.assign(defaults, opts);
-  return merged as T1 & T2;
-}
-
-/** Compares 2 uint8array-s in kinda constant time. */
-export function equalBytes(a: Uint8Array, b: Uint8Array): boolean {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
-  return diff === 0;
-}
-
-// TODO: remove
-/** For runtime check if class implements interface. */
-export abstract class Hash<T extends Hash<T>> {
-  abstract blockLen: number; // Bytes per block
-  abstract outputLen: number; // Bytes in output
-  abstract update(buf: string | Uint8Array): this;
-  // Writes digest into buf
-  abstract digestInto(buf: Uint8Array): void;
-  abstract digest(): Uint8Array;
-  /**
-   * Resets internal state. Makes Hash instance unusable.
-   * Reset is impossible for keyed hashes if key is consumed into state. If digest is not consumed
-   * by user, they will need to manually call `destroy()` when zeroing is necessary.
-   */
-  abstract destroy(): void;
-}
-
-// This will allow to re-use with composable things like packed & base encoders
-// Also, we probably can make tags composable
-
-/** Sync cipher: takes byte array and returns byte array. */
-export type Cipher = {
-  encrypt(plaintext: Uint8Array): Uint8Array;
-  decrypt(ciphertext: Uint8Array): Uint8Array;
-};
-
-/** Async cipher e.g. from built-in WebCrypto. */
-export type AsyncCipher = {
-  encrypt(plaintext: Uint8Array): Promise<Uint8Array>;
-  decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
-};
-
-/** Cipher with `output` argument which can optimize by doing 1 less allocation. */
-export type CipherWithOutput = Cipher & {
-  encrypt(plaintext: Uint8Array, output?: Uint8Array): Uint8Array;
-  decrypt(ciphertext: Uint8Array, output?: Uint8Array): Uint8Array;
-};
-
-/**
- * Params are outside of return type, so it is accessible before calling constructor.
- * If function support multiple nonceLength's, we return the best one.
- */
-export type CipherParams = {
-  blockSize: number;
-  nonceLength?: number;
-  tagLength?: number;
-  varSizeNonce?: boolean;
-};
-/** ARX cipher, like salsa or chacha. */
-export type ARXCipher = ((
-  key: Uint8Array,
-  nonce: Uint8Array,
-  AAD?: Uint8Array
-) => CipherWithOutput) & {
-  blockSize: number;
-  nonceLength: number;
-  tagLength: number;
-};
-export type CipherCons<T extends any[]> = (key: Uint8Array, ...args: T) => Cipher;
-/**
- * Wraps a cipher: validates args, ensures encrypt() can only be called once.
- * @__NO_SIDE_EFFECTS__
- */
-export const wrapCipher = <C extends CipherCons<any>, P extends CipherParams>(
-  params: P,
-  constructor: C
-): C & P => {
-  function wrappedCipher(key: Uint8Array, ...args: any[]): CipherWithOutput {
-    // Validate key
-    abytes(key);
-
-    // Big-Endian hardware is rare. Just in case someone still decides to run ciphers:
-    if (!isLE) throw new Error('Non little-endian hardware is not yet supported');
-
-    // Validate nonce if nonceLength is present
-    if (params.nonceLength !== undefined) {
-      const nonce = args[0];
-      if (!nonce) throw new Error('nonce / iv required');
-      if (params.varSizeNonce) abytes(nonce);
-      else abytes(nonce, params.nonceLength);
-    }
-
-    // Validate AAD if tagLength present
-    const tagl = params.tagLength;
-    if (tagl && args[1] !== undefined) {
-      abytes(args[1]);
-    }
-
-    const cipher = constructor(key, ...args);
-    const checkOutput = (fnLength: number, output?: Uint8Array) => {
-      if (output !== undefined) {
-        if (fnLength !== 2) throw new Error('cipher output not supported');
-        abytes(output);
-      }
-    };
-    // Create wrapped cipher with validation and single-use encryption
-    let called = false;
-    const wrCipher = {
-      encrypt(data: Uint8Array, output?: Uint8Array) {
-        if (called) throw new Error('cannot encrypt() twice with same key + nonce');
-        called = true;
-        abytes(data);
-        checkOutput(cipher.encrypt.length, output);
-        return (cipher as CipherWithOutput).encrypt(data, output);
-      },
-      decrypt(data: Uint8Array, output?: Uint8Array) {
-        abytes(data);
-        if (tagl && data.length < tagl)
-          throw new Error('invalid ciphertext length: smaller than tagLength=' + tagl);
-        checkOutput(cipher.decrypt.length, output);
-        return (cipher as CipherWithOutput).decrypt(data, output);
-      },
-    };
-
-    return wrCipher;
-  }
-
-  Object.assign(wrappedCipher, params);
-  return wrappedCipher as C & P;
-};
-
-/** Represents salsa / chacha stream. */
-export type XorStream = (
-  key: Uint8Array,
-  nonce: Uint8Array,
-  data: Uint8Array,
-  output?: Uint8Array,
-  counter?: number
-) => Uint8Array;
-
-/**
- * By default, returns u8a of length.
- * When out is available, it checks it for validity and uses it.
- */
-export function getOutput(
-  expectedLength: number,
-  out?: Uint8Array,
-  onlyAligned = true
-): Uint8Array {
-  if (out === undefined) return new Uint8Array(expectedLength);
-  if (out.length !== expectedLength)
-    throw new Error('invalid output length, expected ' + expectedLength + ', got: ' + out.length);
-  if (onlyAligned && !isAligned32(out)) throw new Error('invalid output, must be aligned');
-  return out;
-}
-
-/** Polyfill for Safari 14. */
-export function setBigUint64(
-  view: DataView,
-  byteOffset: number,
-  value: bigint,
-  isLE: boolean
-): void {
-  if (typeof view.setBigUint64 === 'function') return view.setBigUint64(byteOffset, value, isLE);
-  const _32n = BigInt(32);
-  const _u32_max = BigInt(0xffffffff);
-  const wh = Number((value >> _32n) & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h = isLE ? 4 : 0;
-  const l = isLE ? 0 : 4;
-  view.setUint32(byteOffset + h, wh, isLE);
-  view.setUint32(byteOffset + l, wl, isLE);
-}
-
-export function u64Lengths(dataLength: number, aadLength: number, isLE: boolean): Uint8Array {
-  abool(isLE);
-  const num = new Uint8Array(16);
-  const view = createView(num);
-  setBigUint64(view, 0, BigInt(aadLength), isLE);
-  setBigUint64(view, 8, BigInt(dataLength), isLE);
-  return num;
-}
-
-// Is byte array aligned to 4 byte offset (u32)?
-export function isAligned32(bytes: Uint8Array): boolean {
-  return bytes.byteOffset % 4 === 0;
-}
-
-// copy bytes to new u8a (aligned). Because Buffer.slice is broken.
-export function copyBytes(bytes: Uint8Array): Uint8Array {
-  return Uint8Array.from(bytes);
-}