@tstdl/base 0.93.36 → 0.93.38

package/source/utils/comparison.ts

@@ -1,112 +0,0 @@
-import { isNullOrUndefined } from './type-guards.js';
-import { typeOf } from './type-of.js';
-
-export function compareByValueSelection<T, C extends string | number>(...selectors: ((item: T) => C)[]): (a: T, b: T) => number {
-  return (a: T, b: T) => {
-    for (const selector of selectors) {
-      const selectedA = selector(a);
-      const selectedB = selector(b);
-      const comparison = compareByValue(selectedA, selectedB);
-
-      if (comparison != 0) {
-        return comparison;
-      }
-    }
-
-    return 0;
-  };
-}
-
-export function compareByValueSelectionDescending<T, C extends string | number>(...selectors: ((item: T) => C)[]): (a: T, b: T) => number {
-  return (a: T, b: T) => {
-    for (const selector of selectors) {
-      const selectedA = selector(a);
-      const selectedB = selector(b);
-      const comparison = compareByValueDescending(selectedA, selectedB);
-
-      if (comparison != 0) {
-        return comparison;
-      }
-    }
-
-    return 0;
-  };
-}
-
-export function compareByValueSelectionOrdered<T, C extends string | number>(...selectors: (readonly [(item: T) => C, 1 | -1])[]): (a: T, b: T) => number {
-  return (a: T, b: T) => {
-    for (const [selector, order] of selectors) {
-      const selectedA = selector(a);
-      const selectedB = selector(b);
-      const comparison = (order == 1)
-        ? compareByValue(selectedA, selectedB)
-        : compareByValueDescending(selectedA, selectedB);
-
-      if (comparison != 0) {
-        return comparison;
-      }
-    }
-
-    return 0;
-  };
-}
-
-export function compareByValueToOrder<T>(order: T[]): (a: T, b: T) => number {
-  return compareByValueSelectionToOrder(order, (item) => item);
-}
-
-export const orderRest = Symbol('Order rest');
-
-export function compareByValueSelectionToOrder<T, TSelect>(order: (TSelect | typeof orderRest)[], selector: (item: T) => TSelect): (a: T, b: T) => number {
-  const indexMapEntries = order.map((orderItem, index) => [orderItem, index] as const);
-  const indexMap = new Map(indexMapEntries);
-
-  return function compareByValueSelectionToOrder(a: T, b: T): number {
-    const selectedA = selector(a);
-    const selectedB = selector(b);
-    const indexA = indexMap.get(selectedA) ?? indexMap.get(orderRest);
-    const indexB = indexMap.get(selectedB) ?? indexMap.get(orderRest);
-
-    if (isNullOrUndefined(indexA) || isNullOrUndefined(indexB)) {
-      throw new Error('Value not defined in order.');
-    }
-
-    return compareByValue(indexA, indexB);
-  };
-}
-
-export function compareByValue<T>(a: T, b: NoInfer<T>, strict: boolean = true): number {
-  if (a === b) {
-    return 0;
-  }
-  else if (a > b) {
-    return 1;
-  }
-  else if (b > a) {
-    return -1;
-  }
-
-  if (!strict) {
-    return 0;
-  }
-
-  throw new Error(`Values of type ${typeOf(a)} and ${typeOf(b)} are not comparable.`);
-}
-
-export function compareByValueDescending<T>(a: T, b: NoInfer<T>, strict: boolean = true): number {
-  if (a === b) {
-    return 0;
-  }
-  else if (a > b) {
-    return -1;
-  }
-  else if (b > a) {
-    return 1;
-  }
-
-  if (!strict) {
-    return 0;
-  }
-
-  throw new Error(`Values of type ${typeOf(a)} and ${typeOf(b)} are not comparable.`);
-}

package/source/utils/compression.ts

@@ -1,163 +0,0 @@
-import type * as NodeStream from 'node:stream';
-import type * as NodeZlib from 'node:zlib';
-
-import { dynamicImport } from '#/import.js';
-import { encodeBase64, encodeBase64Url } from './base64.js';
-import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
-import { readableStreamFromPromise } from './stream/from-promise.js';
-import { assertDefined, isNotNullOrUndefined } from './type-guards.js';
-import { zBase32Encode } from './z-base32.js';
-
-export interface CompressionResult {
-  toBuffer(): Promise<Uint8Array<ArrayBuffer>>;
-  toHex(): Promise<string>;
-  toBase64(): Promise<string>;
-  toBase64Url(): Promise<string>;
-  toZBase32(): Promise<string>;
-}
-
-export interface DecompressionResult extends CompressionResult {
-  toUtf8(): Promise<string>;
-}
-
-export type CompressionAlgorithm = 'gzip' | 'brotli' | 'deflate' | 'deflate-raw';
-
-export function compressString(input: string, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): CompressionResult;
-export function compressString(input: string, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): CompressionResult;
-export function compressString(input: string, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): CompressionResult;
-export function compressString(input: string, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): CompressionResult {
-  const inputBuffer = encodeUtf8(input);
-  return compress(inputBuffer, algorithm, options);
-}
-
-export function compress(buffer: NodeZlib.InputType, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): CompressionResult;
-export function compress(buffer: NodeZlib.InputType, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): CompressionResult;
-export function compress(buffer: NodeZlib.InputType, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): CompressionResult;
-export function compress(buffer: NodeZlib.InputType, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): CompressionResult {
-  const compressedBuffer = _compress(buffer, algorithm, options);
-
-  return {
-    toBuffer: async () => await compressedBuffer,
-    toHex: async () => encodeHex(await compressedBuffer),
-    toBase64: async () => encodeBase64(await compressedBuffer),
-    toBase64Url: async () => encodeBase64Url(await compressedBuffer),
-    toZBase32: async () => zBase32Encode(await compressedBuffer),
-  };
-}
-
-const compressFunction = {
-  'gzip': 'gzip' satisfies keyof typeof NodeZlib,
-  'brotli': 'brotliCompress' satisfies keyof typeof NodeZlib,
-  'deflate': 'deflate' satisfies keyof typeof NodeZlib,
-  'deflate-raw': 'deflateRaw' satisfies keyof typeof NodeZlib,
-} as const;
-
-async function _compress(buffer: NodeZlib.InputType, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): Promise<Uint8Array<ArrayBuffer>> {
-  const zlib = await dynamicImport<typeof NodeZlib>('zlib');
-  const compressor = zlib[compressFunction[algorithm]];
-  assertDefined(compressor, `Unsupported algorithm ${algorithm}`);
-
-  return await new Promise<Uint8Array<ArrayBuffer>>((resolve, reject) => {
-    const callback: NodeZlib.CompressCallback = (error, result) => {
-      if (isNotNullOrUndefined(error)) {
-        reject(error);
-      }
-      else {
-        resolve(result as Uint8Array<ArrayBuffer>);
-      }
-    };
-
-    if (options == undefined) {
-      (compressor as (buffer: NodeZlib.InputType, callback: NodeZlib.CompressCallback) => void)(buffer, callback);
-    }
-    else {
-      (compressor as (buffer: NodeZlib.InputType, options: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions, callback: NodeZlib.CompressCallback) => void)(buffer, options, callback);
-    }
-  });
-}
-
-export function decompressString(input: string, encoding: BufferEncoding, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): DecompressionResult;
-export function decompressString(input: string, encoding: BufferEncoding, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): DecompressionResult;
-export function decompressString(input: string, encoding: BufferEncoding, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): DecompressionResult;
-export function decompressString(input: string, encoding: BufferEncoding, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): DecompressionResult {
-  const inputBuffer = Buffer.from(input, encoding);
-  return decompress(inputBuffer, algorithm, options);
-}
-
-export function decompress(buffer: NodeZlib.InputType, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): DecompressionResult;
-export function decompress(buffer: NodeZlib.InputType, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): DecompressionResult;
-export function decompress(buffer: NodeZlib.InputType, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): DecompressionResult;
-export function decompress(buffer: NodeZlib.InputType, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): DecompressionResult {
-  const decompressedBuffer = _decompress(buffer, algorithm, options);
-
-  return {
-    toBuffer: async () => await decompressedBuffer,
-    toHex: async () => encodeHex(await decompressedBuffer),
-    toBase64: async () => encodeBase64(await decompressedBuffer),
-    toBase64Url: async () => encodeBase64Url(await decompressedBuffer),
-    toZBase32: async () => zBase32Encode(await decompressedBuffer),
-    toUtf8: async () => decodeText(await decompressedBuffer),
-  };
-}
-
-export function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
-export function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
-export function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
-export function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): ReadableStream<Uint8Array<ArrayBuffer>> {
-  const streamPromise = _decompressStream(stream, algorithm, options);
-  return readableStreamFromPromise(streamPromise);
-}
-
-const decompressFunction = {
-  'gzip': 'gunzip' satisfies keyof typeof NodeZlib,
-  'brotli': 'brotliDecompress' satisfies keyof typeof NodeZlib,
-  'deflate': 'inflate' satisfies keyof typeof NodeZlib,
-  'deflate-raw': 'inflateRaw' satisfies keyof typeof NodeZlib,
-} as const;
-
-async function _decompress(buffer: NodeZlib.InputType, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): Promise<Uint8Array<ArrayBuffer>> {
-  const zlib = await dynamicImport<typeof NodeZlib>('zlib');
-  const decompressor = zlib[decompressFunction[algorithm]];
-  assertDefined(decompressor, `Unsupported algorithm ${algorithm}`);
-
-  return await new Promise<Uint8Array<ArrayBuffer>>((resolve, reject) => {
-    const callback: NodeZlib.CompressCallback = (error, result) => {
-      if (isNotNullOrUndefined(error)) {
-        reject(error);
-      }
-      else {
-        resolve(result as Uint8Array<ArrayBuffer>);
-      }
-    };
-
-    if (options == undefined) {
-      (decompressor as (buffer: NodeZlib.InputType, callback: NodeZlib.CompressCallback) => void)(buffer, callback);
-    }
-    else {
-      (decompressor as (buffer: NodeZlib.InputType, options: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions, callback: NodeZlib.CompressCallback) => void)(buffer, options, callback);
-    }
-  });
-}
-
-const decompressStreamFunction = {
-  'gzip': 'createGunzip' satisfies keyof typeof NodeZlib,
-  'brotli': 'createBrotliDecompress' satisfies keyof typeof NodeZlib,
-  'deflate': 'createInflate' satisfies keyof typeof NodeZlib,
-  'deflate-raw': 'createInflateRaw' satisfies keyof typeof NodeZlib,
-} as const;
-
-async function _decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): Promise<ReadableStream<Uint8Array<ArrayBuffer>>> {
-  const zlib = await dynamicImport<typeof NodeZlib>('zlib');
-  const nodeStream = await dynamicImport<typeof NodeStream>('stream');
-
-  const nodeDecompressor = zlib[decompressStreamFunction[algorithm]](options);
-  assertDefined(nodeDecompressor, `Unsupported algorithm ${algorithm}`);
-
-  const decompressor = nodeStream.Transform.toWeb(nodeDecompressor) as TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
-
-  if (stream instanceof nodeStream.Readable) {
-    return (nodeStream.Readable.toWeb(stream) as ReadableStream<Uint8Array>).pipeThrough(decompressor);
-  }
-
-  return stream.pipeThrough(decompressor);
-}

package/source/utils/config-parser.ts

@@ -1,37 +0,0 @@
-import { isUndefined } from './type-guards.js';
-
-export const configValidators = {
-  integer: /^-?\d+$/u,
-  positiveInteger: /^[1-9]\d*$/u,
-  boolean: /true|false|yes|no|0|1/ui
-};
-
-export function boolean<T>(variable: string, defaultValue: T): boolean | T {
-  return string(variable, defaultValue, configValidators.boolean, (value) => ['true', 'yes', '1'].includes(value.toLowerCase()));
-}
-
-export function integer<T>(variable: string, defaultValue: T): number | T {
-  return string(variable, defaultValue, configValidators.integer, (value) => parseInt(value, 10));
-}
-
-export function positiveInteger<T>(variable: string, defaultValue: T): number | T {
-  return string(variable, defaultValue, configValidators.positiveInteger, (value) => parseInt(value, 10));
-}
-
-export function string<T>(variable: string, defaultValue: T, validator?: RegExp): string | T;
-export function string<T, U>(variable: string, defaultValue: T, validator: RegExp, transformer: (value: string) => U): T | U;
-export function string<T, U>(variable: string, defaultValue: T, validator?: RegExp, transformer: (value: string) => U = (value) => value as any as U): string | T | U {
-  const environmentValue = process.env[variable];
-
-  if (isUndefined(environmentValue)) {
-    return defaultValue;
-  }
-
-  const valid = isUndefined(validator) ? true : validator.test(environmentValue);
-
-  if (!valid) {
-    throw new Error(`invalid value for ${variable}`);
-  }
-
-  return transformer(environmentValue);
-}

package/source/utils/crc32.ts

@@ -1,38 +0,0 @@
-/* eslint-disable no-bitwise */
-
-let crcTable: Uint32Array | undefined;
-
-export function crc32b(bytes: Uint8Array): Uint8Array {
-  crcTable ??= generateCrc32Table();
-
-  let crc = 0 ^ (-1);
-
-  for (let i = 0; i < bytes.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
-    crc = (crc >>> 8) ^ crcTable[(crc & 0xff) ^ bytes[i]!]!;
-  }
-
-  crc = (crc ^ (-1)) >>> 0;
-
-  const buffer = new ArrayBuffer(4);
-  const dataView = new DataView(buffer);
-
-  dataView.setUint32(0, crc, false);
-
-  return new Uint8Array(buffer);
-}
-
-function generateCrc32Table(): Uint32Array {
-  const table = new Uint32Array(256);
-
-  for (let i = 0; i < 256; i++) {
-    let c = i;
-
-    for (let k = 0; k < 8; k++) {
-      c = ((c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1));
-    }
-
-    table[i] = c;
-  }
-
-  return table;
-}

package/source/utils/cryptography.ts

@@ -1,259 +0,0 @@
-import type { BinaryData, TypedExtract } from '#/types/index.js';
-import type { ReadonlyTuple } from 'type-fest';
-import { createArray } from './array/array.js';
-import { encodeBase64, encodeBase64Url } from './base64.js';
-import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
-import { getRandomBytes } from './random.js';
-import { isArray, isDefined, isString } from './type-guards.js';
-import { zBase32Encode } from './z-base32.js';
-
-export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
-export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';
-export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
-export type SymmetricAlgorithm = `AES-${AesMode}`;
-export type AsymmetricAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP' | 'ECDSA' | 'ECDH' | 'NODE-DSA' | 'NODE-DH' | 'NODE-ED25519' | 'NODE-ED448';
-
-export type CryptionAlgorithm = Parameters<typeof globalThis.crypto.subtle.encrypt>[0];
-export type SignAlgorithm = Parameters<typeof globalThis.crypto.subtle.sign>[0];
-export type KeyAlgorithm = Parameters<typeof globalThis.crypto.subtle.generateKey>[0];
-export type DeriveAlgorithm = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
-
-export type KeyType = 'raw' | 'pkcs8' | 'spki' | 'jwk';
-export type Key = JsonWebKey | BinaryData<ArrayBuffer>;
-
-export type ScryptOptions = {
-  cost?: number,
-  blockSize?: number,
-  parallelization?: number,
-  maximumMemory?: number,
-};
-
-export interface CryptionResult {
-  toBuffer(): Promise<ArrayBuffer>;
-  toHex(): Promise<string>;
-  toBase64(): Promise<string>;
-  toBase64Url(): Promise<string>;
-  toZBase32(): Promise<string>;
-}
-
-export interface DecryptionResult extends CryptionResult {
-  toUtf8(): Promise<string>;
-}
-
-export type DigestResult = CryptionResult;
-
-export type SignResult = CryptionResult;
-
-/**
- * Encrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to encrypt. Encodes string to utf8
- */
-export function encrypt(algorithm: CryptionAlgorithm, key: CryptoKey, data: BinaryData<ArrayBuffer> | string): CryptionResult {
-  const bytes = isString(data) ? encodeUtf8(data) : data;
-  const encryptedBuffer = globalThis.crypto.subtle.encrypt(algorithm, key, bytes);
-
-  return {
-    toBuffer: async () => await encryptedBuffer,
-    toHex: async () => encodeHex(await encryptedBuffer),
-    toBase64: async () => encodeBase64(await encryptedBuffer),
-    toBase64Url: async () => encodeBase64Url(await encryptedBuffer),
-    toZBase32: async () => zBase32Encode(await encryptedBuffer),
-  };
-}
-
-/**
- * Decrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to decrypt
- */
-export function decrypt(algorithm: CryptionAlgorithm, key: CryptoKey, bytes: BinaryData<ArrayBuffer>): DecryptionResult {
-  const decryptedBuffer = globalThis.crypto.subtle.decrypt(algorithm, key, bytes);
-
-  return {
-    toBuffer: async () => await decryptedBuffer,
-    toHex: async () => encodeHex(await decryptedBuffer),
-    toBase64: async () => encodeBase64(await decryptedBuffer),
-    toBase64Url: async () => encodeBase64Url(await decryptedBuffer),
-    toZBase32: async () => zBase32Encode(await decryptedBuffer),
-    toUtf8: async () => decodeText(await decryptedBuffer),
-  };
-}
-
-/**
- * Hashes data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param data data to encrypt. Encodes string to utf8
- */
-export function digest(algorithm: HashAlgorithmIdentifier, data: BinaryData<ArrayBuffer> | string): DigestResult {
-  const bytes = isString(data) ? encodeUtf8(data) : data;
-  const arrayBufferPromise = globalThis.crypto.subtle.digest(algorithm, bytes);
-
-  const result: DigestResult = {
-    toBuffer: async () => await arrayBufferPromise,
-    toHex: async () => encodeHex(await arrayBufferPromise),
-    toBase64: async () => encodeBase64(await arrayBufferPromise),
-    toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
-    toZBase32: async () => zBase32Encode(await arrayBufferPromise),
-  };
-
-  return result;
-}
-
-/**
- * Signs data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to sign
- */
-export function sign(algorithm: SignAlgorithm, key: CryptoKey, data: BinaryData<ArrayBuffer> | string): SignResult {
-  const bytes = isString(data) ? encodeUtf8(data) : data;
-
-  const arrayBufferPromise = globalThis.crypto.subtle.sign(algorithm, key, bytes);
-
-  const result: SignResult = {
-    toBuffer: async () => await arrayBufferPromise,
-    toHex: async () => encodeHex(await arrayBufferPromise),
-    toBase64: async () => encodeBase64(await arrayBufferPromise),
-    toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
-    toZBase32: async () => zBase32Encode(await arrayBufferPromise),
-  };
-
-  return result;
-}
-
-/**
- * Verifies data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param signature signature
- * @param data data to verify using provided signature
- */
-export async function verify(algorithm: SignAlgorithm, key: CryptoKey, signature: BinaryData<ArrayBuffer> | string, data: BinaryData<ArrayBuffer> | string): Promise<boolean> {
-  const signatureBytes = isString(signature) ? encodeUtf8(signature) : signature;
-  const dataBytes = isString(data) ? encodeUtf8(data) : data;
-
-  return await globalThis.crypto.subtle.verify(algorithm, key, signatureBytes, dataBytes);
-}
-
-/**
- * Imports a HMAC CryptoKey
- * @param algorithm hash algorithm
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importHmacKey(algorithm: HashAlgorithmIdentifier, key: Key | string, extractable: boolean = false): Promise<CryptoKey> {
-  const binaryKey = isString(key) ? encodeUtf8(key) : key;
-
-  if (isBinaryKey(binaryKey)) {
-    return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
-  }
-
-  return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
-}
-
-/**
- * Imports a CryptoKey for symmetric encryption
- * @param algorithm symmetric algorithm
- * @param length key length
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importSymmetricKey(algorithm: SymmetricAlgorithm, length: 128 | 192 | 256, key: Key | string, extractable: boolean = false): Promise<CryptoKey> {
-  const binaryKey = isString(key) ? encodeUtf8(key) : key;
-
-  if (isBinaryKey(binaryKey)) {
-    return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
-  }
-
-  return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
-}
-
-/**
- * Imports an ECDSA CryptoKey
- * @param curve ECDSA curve
- * @param key JWK or DER encoded key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importEcdsaKey(curve: EcdsaCurve, key: Key | string, extractable: boolean = false): Promise<CryptoKey> {
-  const binaryKey = isString(key) ? encodeUtf8(key) : key;
-
-  if (isBinaryKey(binaryKey)) {
-    return await globalThis.crypto.subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
-  }
-
-  return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
-}
-
-/**
- * Import a pbkdf2 CryptoKey
- * @param key binary key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importPbkdf2Key(key: BinaryData<ArrayBuffer> | string, extractable: boolean = false): Promise<CryptoKey> {
-  const binaryKey = isString(key) ? encodeUtf8(key) : key;
-  return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'PBKDF2' }, extractable, ['deriveKey', 'deriveBits']);
-}
-
-/**
- * Generates a new ECDSA CryptoKeyPair
- * @param curve ECDSA cruve to use
- * @param extractable whether the key can be used for exportKey
- * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
- */
-export async function generateEcdsaKey(curve: EcdsaCurve, extractable: boolean = false, usages: TypedExtract<KeyUsage, 'sign' | 'verify'>[] = ['sign', 'verify']): Promise<CryptoKeyPair> {
-  return await globalThis.crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
-}
-
-/**
- * Generates a pbkdf2 CryptoKey
- * @param extractable whether the key can be used for exportKey
- */
-export async function generatePbkdf2Key(extractable: boolean = false): Promise<CryptoKey> {
-  const key = getRandomBytes(16);
-  return await importPbkdf2Key(key, extractable);
-}
-
-/**
- * Derive byte array from key
- * @param length length in bytes
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- */
-export async function deriveBytes(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: number): Promise<Uint8Array> {
-  const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, length * 8);
-  return new Uint8Array(bytes);
-}
-
-/**
- * Derive multiply byte arrays from key
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- * @param length length of each Uint8Array in bytes, if single number is provided, it is used for every array
- * @param count how many Uint8Arrays to derive
- */
-export async function deriveBytesMultiple<const Lengths extends readonly number[]>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, lengths: Lengths): Promise<ReadonlyTuple<Uint8Array<ArrayBuffer>, Lengths['length']>>;
-export async function deriveBytesMultiple<const C extends number>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: C, count: number): Promise<ReadonlyTuple<Uint8Array<ArrayBuffer>, C>>;
-export async function deriveBytesMultiple(algorithm: DeriveAlgorithm, baseKey: CryptoKey, lengthOrLengths: number | number[], countOrNothing?: number): Promise<Uint8Array<ArrayBuffer>[]> {
-  const lengths = isArray(lengthOrLengths) ? lengthOrLengths : createArray(countOrNothing!, () => lengthOrLengths);
-  const totalBits = lengths.reduce((sum, length) => sum + length, 0) * 8;
-  const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, totalBits);
-
-  const arrays: Uint8Array<ArrayBuffer>[] = [];
-
-  for (let i = 0; i < bytes.byteLength;) {
-    const slice = bytes.slice(i, i + lengths[arrays.length]!);
-    const array = new Uint8Array(slice);
-    arrays.push(array);
-
-    i += slice.byteLength;
-  }
-
-  return arrays;
-}
-
-function isBinaryKey(key: Key): key is BinaryData<ArrayBuffer> {
-  return isDefined((key as Partial<BinaryData<ArrayBuffer> & JsonWebKey>).byteLength);
-}