@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/dist/module/hash.js

@@ -0,0 +1,230 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Stream } from 'readable-stream';
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { ab2str, binaryLikeToArrayBuffer, bufferLikeToArrayBuffer } from './utils';
+import { validateMaxBufferLength } from './utils/validation';
+import { lazyDOMException } from './utils/errors';
+import { normalizeHashName } from './utils/hashnames';
+class HashUtils {
+  static getSupportedHashAlgorithms() {
+    return this.native.getSupportedHashAlgorithms();
+  }
+}
+_defineProperty(HashUtils, "native", NitroModules.createHybridObject('Hash'));
+export function getHashes() {
+  return HashUtils.getSupportedHashAlgorithms();
+}
+class Hash extends Stream.Transform {
+  validate(args) {
+    var _args$options, _args$options2;
+    if (typeof args.algorithm !== 'string' || args.algorithm.length === 0) throw new Error('Algorithm must be a non-empty string');
+    if (((_args$options = args.options) === null || _args$options === void 0 ? void 0 : _args$options.outputLength) !== undefined && args.options.outputLength < 0) throw new Error('Output length must be a non-negative number');
+    if (((_args$options2 = args.options) === null || _args$options2 === void 0 ? void 0 : _args$options2.outputLength) !== undefined && typeof args.options.outputLength !== 'number') throw new Error('Output length must be a number');
+  }
+
+  /**
+   * @internal use `createHash()` instead
+   */
+  constructor(args) {
+    super(args.options);
+    _defineProperty(this, "algorithm", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "native", void 0);
+    this.validate(args);
+    this.algorithm = args.algorithm;
+    this.options = args.options ?? {};
+    if (args.native) {
+      this.native = args.native;
+      return;
+    }
+    this.native = NitroModules.createHybridObject('Hash');
+    this.native.createHash(this.algorithm, this.options.outputLength);
+  }
+
+  /**
+   * Updates the hash content with the given `data`, the encoding of which
+   * is given in `inputEncoding`.
+   * If `encoding` is not provided, and the `data` is a string, an
+   * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+   *
+   * This can be called many times with new data as it is streamed.
+   * @since v1.0.0
+   * @param inputEncoding The `encoding` of the `data` string.
+   */
+
+  update(data, inputEncoding) {
+    const defaultEncoding = 'utf8';
+    inputEncoding = inputEncoding ?? defaultEncoding;
+
+    // OPTIMIZED PATH: Pass UTF-8 strings directly to native without conversion
+    if (typeof data === 'string' && inputEncoding === 'utf8') {
+      this.native.update(data);
+    } else {
+      this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));
+    }
+    return this; // to support chaining syntax createHash().update().digest()
+  }
+
+  /**
+   * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).
+   * If `encoding` is provided a string will be returned; otherwise
+   * a `Buffer` is returned.
+   *
+   * The `Hash` object can not be used again after `hash.digest()` method has been
+   * called. Multiple calls will cause an error to be thrown.
+   * @since v1.0.0
+   * @param encoding The `encoding` of the return value.
+   */
+
+  digest(encoding) {
+    const nativeDigest = this.native.digest(encoding);
+    if (encoding && encoding !== 'buffer') {
+      return ab2str(nativeDigest, encoding);
+    }
+    return Buffer.from(nativeDigest);
+  }
+
+  /**
+   * Creates a new `Hash` object that contains a deep copy of the internal state
+   * of the current `Hash` object.
+   *
+   * The optional `options` argument controls stream behavior. For XOF hash
+   * functions such as `'shake256'`, the `outputLength` option can be used to
+   * specify the desired output length in bytes.
+   *
+   * An error is thrown when an attempt is made to copy the `Hash` object after
+   * its `hash.digest()` method has been called.
+   *
+   * ```js
+   * // Calculate a rolling hash.
+   * import { createHash } from 'react-native-quick-crypto';
+   *
+   * const hash = createHash('sha256');
+   *
+   * hash.update('one');
+   * console.log(hash.copy().digest('hex'));
+   *
+   * hash.update('two');
+   * console.log(hash.copy().digest('hex'));
+   *
+   * hash.update('three');
+   * console.log(hash.copy().digest('hex'));
+   *
+   * // Etc.
+   * ```
+   * @since v1.0.0
+   * @param options `stream.transform` options
+   */
+
+  copy(options) {
+    const newOptions = options ?? this.options;
+    const newNativeHash = this.native.copy(newOptions.outputLength);
+    const hash = new Hash({
+      algorithm: this.algorithm,
+      options: newOptions,
+      native: newNativeHash
+    });
+    return hash;
+  }
+
+  /**
+   * Returns the OpenSSL version string
+   * @since v1.0.0
+   */
+  getOpenSSLVersion() {
+    return this.native.getOpenSSLVersion();
+  }
+
+  // stream interface
+  _transform(chunk, encoding, callback) {
+    this.update(chunk, encoding);
+    callback();
+  }
+  _flush(callback) {
+    this.push(this.digest());
+    callback();
+  }
+}
+
+/**
+ * Creates and returns a `Hash` object that can be used to generate hash digests
+ * using the given `algorithm`. Optional `options` argument controls stream
+ * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option
+ * can be used to specify the desired output length in bytes.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 sum of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hash = crypto.createHash('sha256').update('Test123').digest('hex');
+ * console.log('SHA-256 of "Test123":', hash);
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export function createHash(algorithm, options) {
+  // @ts-expect-error private constructor
+  return new Hash({
+    algorithm,
+    options
+  });
+}
+
+// Implementation for WebCrypto subtle.digest()
+
+/**
+ * Asynchronous digest function for WebCrypto SubtleCrypto API
+ * @param algorithm The hash algorithm to use
+ * @param data The data to hash
+ * @returns Promise resolving to the hash digest as ArrayBuffer
+ */
+export const asyncDigest = async (algorithm, data) => {
+  validateMaxBufferLength(data, 'data');
+  const name = algorithm.name;
+  if (name === 'SHA-1' || name === 'SHA-256' || name === 'SHA-384' || name === 'SHA-512' || name === 'SHA3-256' || name === 'SHA3-384' || name === 'SHA3-512') {
+    return internalDigest(algorithm, data);
+  }
+  if (name === 'cSHAKE128' || name === 'cSHAKE256') {
+    if (typeof algorithm.length !== 'number' || algorithm.length <= 0) {
+      throw lazyDOMException('cSHAKE requires a length parameter', 'OperationError');
+    }
+    if (algorithm.length % 8) {
+      throw lazyDOMException('Unsupported CShakeParams length', 'NotSupportedError');
+    }
+    return internalDigest(algorithm, data, algorithm.length);
+  }
+  throw lazyDOMException(`Unrecognized algorithm name: ${name}`, 'NotSupportedError');
+};
+const internalDigest = (algorithm, data, outputLength) => {
+  const normalizedHashName = normalizeHashName(algorithm.name);
+  const hash = createHash(normalizedHashName, outputLength ? {
+    outputLength
+  } : undefined);
+  hash.update(bufferLikeToArrayBuffer(data));
+  const result = hash.digest();
+  const arrayBuffer = new ArrayBuffer(result.length);
+  const view = new Uint8Array(arrayBuffer);
+  view.set(result);
+  return arrayBuffer;
+};
+export function hash(algorithm, data, outputEncoding) {
+  const h = createHash(algorithm);
+  h.update(data);
+  return outputEncoding ? h.digest(outputEncoding) : h.digest();
+}
+export const hashExports = {
+  createHash,
+  getHashes,
+  hash,
+  asyncDigest
+};
+//# sourceMappingURL=hash.js.map

package/dist/module/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Stream","NitroModules","Buffer","ab2str","binaryLikeToArrayBuffer","bufferLikeToArrayBuffer","validateMaxBufferLength","lazyDOMException","normalizeHashName","HashUtils","getSupportedHashAlgorithms","native","_defineProperty","createHybridObject","getHashes","Hash","Transform","validate","args","_args$options","_args$options2","algorithm","length","Error","options","outputLength","undefined","constructor","createHash","update","data","inputEncoding","defaultEncoding","digest","encoding","nativeDigest","from","copy","newOptions","newNativeHash","hash","getOpenSSLVersion","_transform","chunk","callback","_flush","push","asyncDigest","name","internalDigest","normalizedHashName","result","arrayBuffer","ArrayBuffer","view","Uint8Array","set","outputEncoding","h","hashExports"],"sources":["hash.ts"],"sourcesContent":["import { Stream } from 'readable-stream';\r\nimport { NitroModules } from 'react-native-nitro-modules';\r\nimport type { TransformOptions } from 'readable-stream';\r\nimport { Buffer } from '@craftzdog/react-native-buffer';\r\nimport type { Hash as NativeHash } from './specs/v1/hash.nitro';\r\nimport type {\r\n  BinaryLike,\r\n  Encoding,\r\n  BufferLike,\r\n  SubtleAlgorithm,\r\n} from './utils';\r\nimport {\r\n  ab2str,\r\n  binaryLikeToArrayBuffer,\r\n  bufferLikeToArrayBuffer,\r\n} from './utils';\r\nimport { validateMaxBufferLength } from './utils/validation';\r\nimport { lazyDOMException } from './utils/errors';\r\nimport { normalizeHashName } from './utils/hashnames';\r\n\r\nclass HashUtils {\r\n  private static native = NitroModules.createHybridObject<NativeHash>('Hash');\r\n  public static getSupportedHashAlgorithms(): string[] {\r\n    return this.native.getSupportedHashAlgorithms();\r\n  }\r\n}\r\n\r\nexport function getHashes() {\r\n  return HashUtils.getSupportedHashAlgorithms();\r\n}\r\n\r\ninterface HashOptions extends TransformOptions {\r\n  /**\r\n   * For XOF hash functions such as `shake256`, the\r\n   * outputLength option can be used to specify the desired output length in bytes.\r\n   */\r\n  outputLength?: number | undefined;\r\n}\r\n\r\ninterface HashArgs {\r\n  algorithm: string;\r\n  options?: HashOptions;\r\n  native?: NativeHash;\r\n}\r\n\r\nclass Hash extends Stream.Transform {\r\n  private algorithm: string;\r\n  private options: HashOptions;\r\n  private native: NativeHash;\r\n\r\n  private validate(args: HashArgs) {\r\n    if (typeof args.algorithm !== 'string' || args.algorithm.length === 0)\r\n      throw new Error('Algorithm must be a non-empty string');\r\n    if (\r\n      args.options?.outputLength !== undefined &&\r\n      args.options.outputLength < 0\r\n    )\r\n      throw new Error('Output length must be a non-negative number');\r\n    if (\r\n      args.options?.outputLength !== undefined &&\r\n      typeof args.options.outputLength !== 'number'\r\n    )\r\n      throw new Error('Output length must be a number');\r\n  }\r\n\r\n  /**\r\n   * @internal use `createHash()` instead\r\n   */\r\n  private constructor(args: HashArgs) {\r\n    super(args.options);\r\n\r\n    this.validate(args);\r\n\r\n    this.algorithm = args.algorithm;\r\n    this.options = args.options ?? {};\r\n\r\n    if (args.native) {\r\n      this.native = args.native;\r\n      return;\r\n    }\r\n\r\n    this.native = NitroModules.createHybridObject<NativeHash>('Hash');\r\n    this.native.createHash(this.algorithm, this.options.outputLength);\r\n  }\r\n\r\n  /**\r\n   * Updates the hash content with the given `data`, the encoding of which\r\n   * is given in `inputEncoding`.\r\n   * If `encoding` is not provided, and the `data` is a string, an\r\n   * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.\r\n   *\r\n   * This can be called many times with new data as it is streamed.\r\n   * @since v1.0.0\r\n   * @param inputEncoding The `encoding` of the `data` string.\r\n   */\r\n  update(data: BinaryLike): Hash;\r\n  update(data: BinaryLike, inputEncoding: Encoding): Buffer;\r\n  update(data: BinaryLike, inputEncoding?: Encoding): Hash | Buffer {\r\n    const defaultEncoding: Encoding = 'utf8';\r\n    inputEncoding = inputEncoding ?? defaultEncoding;\r\n\r\n    // OPTIMIZED PATH: Pass UTF-8 strings directly to native without conversion\r\n    if (typeof data === 'string' && inputEncoding === 'utf8') {\r\n      this.native.update(data);\r\n    } else {\r\n      this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));\r\n    }\r\n\r\n    return this; // to support chaining syntax createHash().update().digest()\r\n  }\r\n\r\n  /**\r\n   * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).\r\n   * If `encoding` is provided a string will be returned; otherwise\r\n   * a `Buffer` is returned.\r\n   *\r\n   * The `Hash` object can not be used again after `hash.digest()` method has been\r\n   * called. Multiple calls will cause an error to be thrown.\r\n   * @since v1.0.0\r\n   * @param encoding The `encoding` of the return value.\r\n   */\r\n  digest(): Buffer;\r\n  digest(encoding: Encoding): string;\r\n  digest(encoding?: Encoding): Buffer | string {\r\n    const nativeDigest = this.native.digest(encoding);\r\n\r\n    if (encoding && encoding !== 'buffer') {\r\n      return ab2str(nativeDigest, encoding);\r\n    }\r\n\r\n    return Buffer.from(nativeDigest);\r\n  }\r\n\r\n  /**\r\n   * Creates a new `Hash` object that contains a deep copy of the internal state\r\n   * of the current `Hash` object.\r\n   *\r\n   * The optional `options` argument controls stream behavior. For XOF hash\r\n   * functions such as `'shake256'`, the `outputLength` option can be used to\r\n   * specify the desired output length in bytes.\r\n   *\r\n   * An error is thrown when an attempt is made to copy the `Hash` object after\r\n   * its `hash.digest()` method has been called.\r\n   *\r\n   * ```js\r\n   * // Calculate a rolling hash.\r\n   * import { createHash } from 'react-native-quick-crypto';\r\n   *\r\n   * const hash = createHash('sha256');\r\n   *\r\n   * hash.update('one');\r\n   * console.log(hash.copy().digest('hex'));\r\n   *\r\n   * hash.update('two');\r\n   * console.log(hash.copy().digest('hex'));\r\n   *\r\n   * hash.update('three');\r\n   * console.log(hash.copy().digest('hex'));\r\n   *\r\n   * // Etc.\r\n   * ```\r\n   * @since v1.0.0\r\n   * @param options `stream.transform` options\r\n   */\r\n  copy(): Hash;\r\n  copy(options: HashOptions): Hash;\r\n  copy(options?: HashOptions): Hash {\r\n    const newOptions = options ?? this.options;\r\n    const newNativeHash = this.native.copy(newOptions.outputLength);\r\n    const hash = new Hash({\r\n      algorithm: this.algorithm,\r\n      options: newOptions,\r\n      native: newNativeHash,\r\n    });\r\n    return hash;\r\n  }\r\n\r\n  /**\r\n   * Returns the OpenSSL version string\r\n   * @since v1.0.0\r\n   */\r\n  getOpenSSLVersion(): string {\r\n    return this.native.getOpenSSLVersion();\r\n  }\r\n\r\n  // stream interface\r\n  _transform(\r\n    chunk: BinaryLike,\r\n    encoding: BufferEncoding,\r\n    callback: () => void,\r\n  ) {\r\n    this.update(chunk, encoding as Encoding);\r\n    callback();\r\n  }\r\n  _flush(callback: () => void) {\r\n    this.push(this.digest());\r\n    callback();\r\n  }\r\n}\r\n\r\n/**\r\n * Creates and returns a `Hash` object that can be used to generate hash digests\r\n * using the given `algorithm`. Optional `options` argument controls stream\r\n * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option\r\n * can be used to specify the desired output length in bytes.\r\n *\r\n * The `algorithm` is dependent on the available algorithms supported by the\r\n * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.\r\n * On recent releases of OpenSSL, `openssl list -digest-algorithms` will\r\n * display the available digest algorithms.\r\n *\r\n * Example: generating the sha256 sum of a file\r\n *\r\n * ```js\r\n * import crypto from 'react-native-quick-crypto';\r\n *\r\n * const hash = crypto.createHash('sha256').update('Test123').digest('hex');\r\n * console.log('SHA-256 of \"Test123\":', hash);\r\n * ```\r\n * @since v1.0.0\r\n * @param options `stream.transform` options\r\n */\r\nexport function createHash(algorithm: string, options?: HashOptions): Hash {\r\n  // @ts-expect-error private constructor\r\n  return new Hash({\r\n    algorithm,\r\n    options,\r\n  });\r\n}\r\n\r\n// Implementation for WebCrypto subtle.digest()\r\n\r\n/**\r\n * Asynchronous digest function for WebCrypto SubtleCrypto API\r\n * @param algorithm The hash algorithm to use\r\n * @param data The data to hash\r\n * @returns Promise resolving to the hash digest as ArrayBuffer\r\n */\r\nexport const asyncDigest = async (\r\n  algorithm: SubtleAlgorithm,\r\n  data: BufferLike,\r\n): Promise<ArrayBuffer> => {\r\n  validateMaxBufferLength(data, 'data');\r\n\r\n  const name = algorithm.name;\r\n\r\n  if (\r\n    name === 'SHA-1' ||\r\n    name === 'SHA-256' ||\r\n    name === 'SHA-384' ||\r\n    name === 'SHA-512' ||\r\n    name === 'SHA3-256' ||\r\n    name === 'SHA3-384' ||\r\n    name === 'SHA3-512'\r\n  ) {\r\n    return internalDigest(algorithm, data);\r\n  }\r\n\r\n  if (name === 'cSHAKE128' || name === 'cSHAKE256') {\r\n    if (typeof algorithm.length !== 'number' || algorithm.length <= 0) {\r\n      throw lazyDOMException(\r\n        'cSHAKE requires a length parameter',\r\n        'OperationError',\r\n      );\r\n    }\r\n    if (algorithm.length % 8) {\r\n      throw lazyDOMException(\r\n        'Unsupported CShakeParams length',\r\n        'NotSupportedError',\r\n      );\r\n    }\r\n    return internalDigest(algorithm, data, algorithm.length);\r\n  }\r\n\r\n  throw lazyDOMException(\r\n    `Unrecognized algorithm name: ${name}`,\r\n    'NotSupportedError',\r\n  );\r\n};\r\n\r\nconst internalDigest = (\r\n  algorithm: SubtleAlgorithm,\r\n  data: BufferLike,\r\n  outputLength?: number,\r\n): ArrayBuffer => {\r\n  const normalizedHashName = normalizeHashName(algorithm.name);\r\n  const hash = createHash(\r\n    normalizedHashName,\r\n    outputLength ? { outputLength } : undefined,\r\n  );\r\n  hash.update(bufferLikeToArrayBuffer(data));\r\n  const result = hash.digest();\r\n  const arrayBuffer = new ArrayBuffer(result.length);\r\n  const view = new Uint8Array(arrayBuffer);\r\n  view.set(result);\r\n  return arrayBuffer;\r\n};\r\n\r\nexport function hash(\r\n  algorithm: string,\r\n  data: BinaryLike,\r\n  outputEncoding: Encoding,\r\n): string;\r\nexport function hash(algorithm: string, data: BinaryLike): Buffer;\r\nexport function hash(\r\n  algorithm: string,\r\n  data: BinaryLike,\r\n  outputEncoding?: Encoding,\r\n): string | Buffer {\r\n  const h = createHash(algorithm);\r\n  h.update(data);\r\n  return outputEncoding ? h.digest(outputEncoding) : h.digest();\r\n}\r\n\r\nexport const hashExports = {\r\n  createHash,\r\n  getHashes,\r\n  hash,\r\n  asyncDigest,\r\n};\r\n"],"mappings":"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","ignoreList":[]}

package/dist/module/hkdf.js

@@ -0,0 +1,73 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { NitroModules } from 'react-native-nitro-modules';
+import { binaryLikeToArrayBuffer, normalizeHashName } from './utils';
+// Lazy load native module
+let native;
+function getNative() {
+  if (native == null) {
+    native = NitroModules.createHybridObject('Hkdf');
+  }
+  return native;
+}
+function validateCallback(callback) {
+  if (callback === undefined || typeof callback !== 'function') {
+    throw new Error('No callback provided to hkdf');
+  }
+}
+function sanitizeInput(input, name) {
+  try {
+    return binaryLikeToArrayBuffer(input);
+  } catch {
+    throw new Error(`${name} must be a string, a Buffer, a typed array, or a DataView`);
+  }
+}
+export function hkdf(digest, key, salt, info, keylen, callback) {
+  validateCallback(callback);
+  try {
+    const normalizedDigest = normalizeHashName(digest);
+    const sanitizedKey = sanitizeInput(key, 'Key');
+    const sanitizedSalt = sanitizeInput(salt, 'Salt');
+    const sanitizedInfo = sanitizeInput(info, 'Info');
+    if (keylen < 0) {
+      throw new TypeError('Bad key length');
+    }
+    const nativeMod = getNative();
+    nativeMod.deriveKey(normalizedDigest, sanitizedKey, sanitizedSalt, sanitizedInfo, keylen).then(res => {
+      callback(null, Buffer.from(res));
+    }, err => {
+      callback(err);
+    });
+  } catch (err) {
+    callback(err);
+  }
+}
+export function hkdfSync(digest, key, salt, info, keylen) {
+  const normalizedDigest = normalizeHashName(digest);
+  const sanitizedKey = sanitizeInput(key, 'Key');
+  const sanitizedSalt = sanitizeInput(salt, 'Salt');
+  const sanitizedInfo = sanitizeInput(info, 'Info');
+  if (keylen < 0) {
+    throw new TypeError('Bad key length');
+  }
+  const nativeMod = getNative();
+  const result = nativeMod.deriveKeySync(normalizedDigest, sanitizedKey, sanitizedSalt, sanitizedInfo, keylen);
+  return Buffer.from(result);
+}
+export function hkdfDeriveBits(algorithm, baseKey, length) {
+  const hash = algorithm.hash;
+  const salt = algorithm.salt;
+  const info = algorithm.info;
+
+  // Check if key is extractable or we can access its handle/buffer
+  // For raw keys, we can export.
+  const keyBuffer = baseKey.keyObject.export();
+
+  // length is in bits, native expects bytes
+  const keylen = Math.ceil(length / 8);
+  const hashName = typeof hash === 'string' ? hash : hash.name;
+  const normalizedDigest = normalizeHashName(hashName);
+  const nativeMod = getNative();
+  const result = nativeMod.deriveKeySync(normalizedDigest, binaryLikeToArrayBuffer(keyBuffer), binaryLikeToArrayBuffer(salt), binaryLikeToArrayBuffer(info), keylen);
+  return result;
+}
+//# sourceMappingURL=hkdf.js.map

package/dist/module/hkdf.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Buffer","NitroModules","binaryLikeToArrayBuffer","normalizeHashName","native","getNative","createHybridObject","validateCallback","callback","undefined","Error","sanitizeInput","input","name","hkdf","digest","key","salt","info","keylen","normalizedDigest","sanitizedKey","sanitizedSalt","sanitizedInfo","TypeError","nativeMod","deriveKey","then","res","from","err","hkdfSync","result","deriveKeySync","hkdfDeriveBits","algorithm","baseKey","length","hash","keyBuffer","keyObject","export","Math","ceil","hashName"],"sources":["hkdf.ts"],"sourcesContent":["import { Buffer } from '@craftzdog/react-native-buffer';\r\nimport { NitroModules } from 'react-native-nitro-modules';\r\nimport type { Hkdf as HkdfNative } from './specs/v1/hkdf.nitro';\r\nimport { binaryLikeToArrayBuffer, normalizeHashName } from './utils';\r\nimport type { BinaryLike } from './utils';\r\nimport type { CryptoKey } from './keys';\r\n\r\ntype KeyMaterial = BinaryLike;\r\ntype Salt = BinaryLike;\r\ntype Info = BinaryLike;\r\n\r\nexport interface HkdfAlgorithm {\r\n  name: string;\r\n  hash: string | { name: string };\r\n  salt: BinaryLike;\r\n  info: BinaryLike;\r\n}\r\n\r\nexport interface HkdfCallback {\r\n  (err: Error | null, derivedKey?: Buffer): void;\r\n}\r\n\r\n// Lazy load native module\r\nlet native: HkdfNative;\r\nfunction getNative(): HkdfNative {\r\n  if (native == null) {\r\n    native = NitroModules.createHybridObject<HkdfNative>('Hkdf');\r\n  }\r\n  return native;\r\n}\r\n\r\nfunction validateCallback(callback: HkdfCallback) {\r\n  if (callback === undefined || typeof callback !== 'function') {\r\n    throw new Error('No callback provided to hkdf');\r\n  }\r\n}\r\n\r\nfunction sanitizeInput(input: BinaryLike, name: string): ArrayBuffer {\r\n  try {\r\n    return binaryLikeToArrayBuffer(input);\r\n  } catch {\r\n    throw new Error(\r\n      `${name} must be a string, a Buffer, a typed array, or a DataView`,\r\n    );\r\n  }\r\n}\r\n\r\nexport function hkdf(\r\n  digest: string,\r\n  key: KeyMaterial,\r\n  salt: Salt,\r\n  info: Info,\r\n  keylen: number,\r\n  callback: HkdfCallback,\r\n): void {\r\n  validateCallback(callback);\r\n\r\n  try {\r\n    const normalizedDigest = normalizeHashName(digest);\r\n    const sanitizedKey = sanitizeInput(key, 'Key');\r\n    const sanitizedSalt = sanitizeInput(salt, 'Salt');\r\n    const sanitizedInfo = sanitizeInput(info, 'Info');\r\n\r\n    if (keylen < 0) {\r\n      throw new TypeError('Bad key length');\r\n    }\r\n\r\n    const nativeMod = getNative();\r\n    nativeMod\r\n      .deriveKey(\r\n        normalizedDigest,\r\n        sanitizedKey,\r\n        sanitizedSalt,\r\n        sanitizedInfo,\r\n        keylen,\r\n      )\r\n      .then(\r\n        res => {\r\n          callback(null, Buffer.from(res));\r\n        },\r\n        err => {\r\n          callback(err);\r\n        },\r\n      );\r\n  } catch (err) {\r\n    callback(err as Error);\r\n  }\r\n}\r\n\r\nexport function hkdfSync(\r\n  digest: string,\r\n  key: KeyMaterial,\r\n  salt: Salt,\r\n  info: Info,\r\n  keylen: number,\r\n): Buffer {\r\n  const normalizedDigest = normalizeHashName(digest);\r\n  const sanitizedKey = sanitizeInput(key, 'Key');\r\n  const sanitizedSalt = sanitizeInput(salt, 'Salt');\r\n  const sanitizedInfo = sanitizeInput(info, 'Info');\r\n\r\n  if (keylen < 0) {\r\n    throw new TypeError('Bad key length');\r\n  }\r\n\r\n  const nativeMod = getNative();\r\n  const result = nativeMod.deriveKeySync(\r\n    normalizedDigest,\r\n    sanitizedKey,\r\n    sanitizedSalt,\r\n    sanitizedInfo,\r\n    keylen,\r\n  );\r\n\r\n  return Buffer.from(result);\r\n}\r\n\r\nexport function hkdfDeriveBits(\r\n  algorithm: HkdfAlgorithm,\r\n  baseKey: CryptoKey,\r\n  length: number,\r\n): ArrayBuffer {\r\n  const hash = algorithm.hash;\r\n  const salt = algorithm.salt;\r\n  const info = algorithm.info;\r\n\r\n  // Check if key is extractable or we can access its handle/buffer\r\n  // For raw keys, we can export.\r\n  const keyBuffer = baseKey.keyObject.export();\r\n\r\n  // length is in bits, native expects bytes\r\n  const keylen = Math.ceil(length / 8);\r\n\r\n  const hashName = typeof hash === 'string' ? hash : hash.name;\r\n  const normalizedDigest = normalizeHashName(hashName);\r\n\r\n  const nativeMod = getNative();\r\n  const result = nativeMod.deriveKeySync(\r\n    normalizedDigest,\r\n    binaryLikeToArrayBuffer(keyBuffer),\r\n    binaryLikeToArrayBuffer(salt),\r\n    binaryLikeToArrayBuffer(info),\r\n    keylen,\r\n  );\r\n\r\n  return result;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/module/hmac.js

@@ -0,0 +1,114 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { Stream } from 'readable-stream';
+import { NitroModules } from 'react-native-nitro-modules';
+import { ab2str, binaryLikeToArrayBuffer } from './utils/conversion';
+class Hmac extends Stream.Transform {
+  validate(args) {
+    if (typeof args.algorithm !== 'string' || args.algorithm.length === 0) throw new Error('Algorithm must be a non-empty string');
+    if (args.key === null || args.key === undefined) throw new Error('Key must not be null or undefined');
+  }
+
+  /**
+   * @internal use `createHmac()` instead
+   */
+  constructor(args) {
+    super(args.options);
+    _defineProperty(this, "algorithm", void 0);
+    _defineProperty(this, "key", void 0);
+    _defineProperty(this, "native", void 0);
+    this.validate(args);
+    this.algorithm = args.algorithm;
+    this.key = args.key;
+    this.native = NitroModules.createHybridObject('Hmac');
+    this.native.createHmac(this.algorithm, binaryLikeToArrayBuffer(this.key));
+  }
+
+  /**
+   * Updates the `Hmac` content with the given `data`, the encoding of which is given in `inputEncoding`.
+   * If `encoding` is not provided, and the `data` is a string, an encoding of `'utf8'` is enforced.
+   * If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+   *
+   * This can be called many times with new data as it is streamed.
+   * @since v1.0.0
+   * @param inputEncoding The `encoding` of the `data` string.
+   */
+
+  update(data, inputEncoding) {
+    const defaultEncoding = 'utf8';
+    inputEncoding = inputEncoding ?? defaultEncoding;
+
+    // Optimize: pass UTF-8 strings directly to C++ without conversion
+    if (typeof data === 'string' && inputEncoding === 'utf8') {
+      this.native.update(data);
+    } else {
+      this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));
+    }
+    return this; // to support chaining syntax createHmac().update().digest()
+  }
+
+  /**
+   * Calculates the HMAC digest of all of the data passed using `hmac.update()`.
+   * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned;
+   *
+   * The `Hmac` object can not be used again after `hmac.digest()` has been
+   * called. Multiple calls to `hmac.digest()` will result in an error being thrown.
+   * @since v1.0.0
+   * @param encoding The `encoding` of the return value.
+   */
+
+  digest(encoding) {
+    const nativeDigest = this.native.digest();
+    if (encoding && encoding !== 'buffer') {
+      return ab2str(nativeDigest, encoding);
+    }
+    return Buffer.from(nativeDigest);
+  }
+
+  // stream interface
+  _transform(chunk, encoding, callback) {
+    this.update(chunk, encoding);
+    callback();
+  }
+  _flush(callback) {
+    this.push(this.digest());
+    callback();
+  }
+}
+
+/**
+ * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.
+ * Optional `options` argument controls stream behavior.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 HMAC of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hmac = crypto.createHmac('sha256', 'secret-key');
+ * hmac.update('message to hash');
+ * const digest = hmac.digest('hex');
+ * console.log(digest); // prints HMAC digest in hexadecimal format
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export function createHmac(algorithm, key, options) {
+  // @ts-expect-error private constructor
+  return new Hmac({
+    algorithm,
+    key,
+    options
+  });
+}
+export const hmacExports = {
+  createHmac
+};
+//# sourceMappingURL=hmac.js.map

package/dist/module/hmac.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Buffer","Stream","NitroModules","ab2str","binaryLikeToArrayBuffer","Hmac","Transform","validate","args","algorithm","length","Error","key","undefined","constructor","options","_defineProperty","native","createHybridObject","createHmac","update","data","inputEncoding","defaultEncoding","digest","encoding","nativeDigest","from","_transform","chunk","callback","_flush","push","hmacExports"],"sources":["hmac.ts"],"sourcesContent":["import { Buffer } from '@craftzdog/react-native-buffer';\r\nimport { Stream } from 'readable-stream';\r\nimport { NitroModules } from 'react-native-nitro-modules';\r\nimport type { TransformOptions } from 'readable-stream';\r\nimport type { Hmac as NativeHmac } from './specs/v1/hmac.nitro';\r\nimport type { BinaryLike, Encoding } from './utils/types';\r\nimport { ab2str, binaryLikeToArrayBuffer } from './utils/conversion';\r\n\r\ninterface HmacArgs {\r\n  algorithm: string;\r\n  key: BinaryLike;\r\n  options?: TransformOptions;\r\n}\r\n\r\nclass Hmac extends Stream.Transform {\r\n  private algorithm: string;\r\n  private key: BinaryLike;\r\n  private native: NativeHmac;\r\n\r\n  private validate(args: HmacArgs) {\r\n    if (typeof args.algorithm !== 'string' || args.algorithm.length === 0)\r\n      throw new Error('Algorithm must be a non-empty string');\r\n    if (args.key === null || args.key === undefined)\r\n      throw new Error('Key must not be null or undefined');\r\n  }\r\n\r\n  /**\r\n   * @internal use `createHmac()` instead\r\n   */\r\n  private constructor(args: HmacArgs) {\r\n    super(args.options);\r\n\r\n    this.validate(args);\r\n\r\n    this.algorithm = args.algorithm;\r\n    this.key = args.key;\r\n\r\n    this.native = NitroModules.createHybridObject<NativeHmac>('Hmac');\r\n    this.native.createHmac(this.algorithm, binaryLikeToArrayBuffer(this.key));\r\n  }\r\n\r\n  /**\r\n   * Updates the `Hmac` content with the given `data`, the encoding of which is given in `inputEncoding`.\r\n   * If `encoding` is not provided, and the `data` is a string, an encoding of `'utf8'` is enforced.\r\n   * If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.\r\n   *\r\n   * This can be called many times with new data as it is streamed.\r\n   * @since v1.0.0\r\n   * @param inputEncoding The `encoding` of the `data` string.\r\n   */\r\n  update(data: BinaryLike): Hmac;\r\n  update(data: BinaryLike, inputEncoding: Encoding): Hmac;\r\n  update(data: BinaryLike, inputEncoding?: Encoding): Hmac {\r\n    const defaultEncoding: Encoding = 'utf8';\r\n    inputEncoding = inputEncoding ?? defaultEncoding;\r\n\r\n    // Optimize: pass UTF-8 strings directly to C++ without conversion\r\n    if (typeof data === 'string' && inputEncoding === 'utf8') {\r\n      this.native.update(data);\r\n    } else {\r\n      this.native.update(binaryLikeToArrayBuffer(data, inputEncoding));\r\n    }\r\n\r\n    return this; // to support chaining syntax createHmac().update().digest()\r\n  }\r\n\r\n  /**\r\n   * Calculates the HMAC digest of all of the data passed using `hmac.update()`.\r\n   * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned;\r\n   *\r\n   * The `Hmac` object can not be used again after `hmac.digest()` has been\r\n   * called. Multiple calls to `hmac.digest()` will result in an error being thrown.\r\n   * @since v1.0.0\r\n   * @param encoding The `encoding` of the return value.\r\n   */\r\n  digest(): Buffer;\r\n  digest(encoding: Encoding): string;\r\n  digest(encoding?: Encoding): Buffer | string {\r\n    const nativeDigest = this.native.digest();\r\n\r\n    if (encoding && encoding !== 'buffer') {\r\n      return ab2str(nativeDigest, encoding);\r\n    }\r\n\r\n    return Buffer.from(nativeDigest);\r\n  }\r\n\r\n  // stream interface\r\n  _transform(\r\n    chunk: BinaryLike,\r\n    encoding: BufferEncoding,\r\n    callback: () => void,\r\n  ) {\r\n    this.update(chunk, encoding as Encoding);\r\n    callback();\r\n  }\r\n  _flush(callback: () => void) {\r\n    this.push(this.digest());\r\n    callback();\r\n  }\r\n}\r\n\r\n/**\r\n * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.\r\n * Optional `options` argument controls stream behavior.\r\n *\r\n * The `algorithm` is dependent on the available algorithms supported by the\r\n * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.\r\n * On recent releases of OpenSSL, `openssl list -digest-algorithms` will\r\n * display the available digest algorithms.\r\n *\r\n * Example: generating the sha256 HMAC of a file\r\n *\r\n * ```js\r\n * import crypto from 'react-native-quick-crypto';\r\n *\r\n * const hmac = crypto.createHmac('sha256', 'secret-key');\r\n * hmac.update('message to hash');\r\n * const digest = hmac.digest('hex');\r\n * console.log(digest); // prints HMAC digest in hexadecimal format\r\n * ```\r\n * @since v1.0.0\r\n * @param options `stream.transform` options\r\n */\r\nexport function createHmac(\r\n  algorithm: string,\r\n  key: BinaryLike,\r\n  options?: TransformOptions,\r\n): Hmac {\r\n  // @ts-expect-error private constructor\r\n  return new Hmac({\r\n    algorithm,\r\n    key,\r\n    options,\r\n  });\r\n}\r\n\r\nexport const hmacExports = {\r\n  createHmac,\r\n};\r\n"],"mappings":"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","ignoreList":[]}

package/dist/module/index.js

@@ -0,0 +1,134 @@
+// polyfill imports
+import { Buffer } from '@craftzdog/react-native-buffer';
+
+// API imports
+import * as argon2Module from './argon2';
+import * as keys from './keys';
+import * as blake3 from './blake3';
+import * as cipher from './cipher';
+import * as ed from './ed';
+import { hashExports as hash } from './hash';
+import { hmacExports as hmac } from './hmac';
+import * as hkdf from './hkdf';
+import * as pbkdf2 from './pbkdf2';
+import * as prime from './prime';
+import * as scrypt from './scrypt';
+import * as random from './random';
+import * as ecdh from './ecdh';
+import * as dh from './diffie-hellman';
+import * as mlkem from './mlkem';
+import { Certificate } from './certificate';
+import { X509Certificate } from './x509certificate';
+import { getCurves } from './ec';
+import { constants } from './constants';
+
+// utils import
+import * as utils from './utils';
+import * as subtle from './subtle';
+
+/**
+ * Loosely matches Node.js {crypto} with some unimplemented functionality.
+ * See `docs/implementation-coverage.md` for status.
+ */
+const QuickCrypto = {
+  ...argon2Module,
+  ...keys,
+  ...blake3,
+  ...cipher,
+  ...ed,
+  ...hash,
+  ...hmac,
+  ...hkdf,
+  ...pbkdf2,
+  ...prime,
+  ...scrypt,
+  ...random,
+  ...ecdh,
+  ...dh,
+  ...mlkem,
+  ...utils,
+  ...subtle,
+  Certificate,
+  X509Certificate,
+  getCurves,
+  constants,
+  Buffer
+};
+/**
+ * HarmonyOS has no QuickBase64 native module; Buffer.toString/from('base64')
+ * still needs these globals. Fall back to Nitro HybridUtils when missing.
+ */
+const installBase64GlobalsFallback = () => {
+  const g = global;
+  if (typeof g.base64FromArrayBuffer === 'function') {
+    return;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const {
+    bufferToString,
+    stringToBuffer
+  } = require('./utils/conversion');
+  g.base64FromArrayBuffer = (buffer, urlSafe) => bufferToString(buffer, urlSafe ? 'base64url' : 'base64');
+  g.base64ToArrayBuffer = (b64, removeLinebreaks) => {
+    const input = removeLinebreaks ? b64.replace(/[\r\n]/g, '') : b64;
+    return stringToBuffer(input, 'base64');
+  };
+};
+
+/**
+ * Optional. Patch global.crypto with react-native-quick-crypto and
+ * global.Buffer with react-native-buffer.
+ */
+export const install = () => {
+  // @ts-expect-error copyBytesFrom and poolSizets are missing from react-native-buffer
+  global.Buffer = Buffer;
+
+  // @ts-expect-error subtle isn't fully implemented and Cryptokey is missing
+  global.crypto = QuickCrypto;
+
+  // Install base64 globals (base64ToArrayBuffer, base64FromArrayBuffer)
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require('react-native-quick-base64');
+  installBase64GlobalsFallback();
+};
+
+// random, cipher, hash use nextTick
+if (global.process == null) {
+  // @ts-expect-error - process is not defined
+  global.process = {};
+}
+if (global.process.nextTick == null) {
+  global.process.nextTick = setImmediate;
+}
+
+// exports
+export default QuickCrypto;
+export * from './argon2';
+export * from './blake3';
+export { Certificate } from './certificate';
+export { X509Certificate } from './x509certificate';
+export * from './cipher';
+export * from './ed';
+export * from './keys';
+export * from './hash';
+export * from './hmac';
+export * from './hkdf';
+export * from './pbkdf2';
+export * from './prime';
+export * from './scrypt';
+export * from './random';
+export * from './ecdh';
+export { getCurves } from './ec';
+export * from './diffie-hellman';
+export * from './mlkem';
+export * from './utils';
+export * from './subtle';
+export { subtle, isCryptoKeyPair } from './subtle';
+export { constants } from './constants';
+export { Buffer } from '@craftzdog/react-native-buffer';
+
+// Additional exports for CommonJS compatibility
+module.exports = QuickCrypto;
+module.exports.default = QuickCrypto;
+module.exports.install = install;
+//# sourceMappingURL=index.js.map

package/dist/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Buffer","argon2Module","keys","blake3","cipher","ed","hashExports","hash","hmacExports","hmac","hkdf","pbkdf2","prime","scrypt","random","ecdh","dh","mlkem","Certificate","X509Certificate","getCurves","constants","utils","subtle","QuickCrypto","installBase64GlobalsFallback","g","global","base64FromArrayBuffer","bufferToString","stringToBuffer","require","buffer","urlSafe","base64ToArrayBuffer","b64","removeLinebreaks","input","replace","install","crypto","process","nextTick","setImmediate","isCryptoKeyPair","module","exports","default"],"sources":["index.ts"],"sourcesContent":["// polyfill imports\r\nimport { Buffer } from '@craftzdog/react-native-buffer';\r\n\r\n// API imports\r\nimport * as argon2Module from './argon2';\r\nimport * as keys from './keys';\r\nimport * as blake3 from './blake3';\r\nimport * as cipher from './cipher';\r\nimport * as ed from './ed';\r\nimport { hashExports as hash } from './hash';\r\nimport { hmacExports as hmac } from './hmac';\r\nimport * as hkdf from './hkdf';\r\nimport * as pbkdf2 from './pbkdf2';\r\nimport * as prime from './prime';\r\nimport * as scrypt from './scrypt';\r\nimport * as random from './random';\r\nimport * as ecdh from './ecdh';\r\nimport * as dh from './diffie-hellman';\r\nimport * as mlkem from './mlkem';\r\nimport { Certificate } from './certificate';\r\nimport { X509Certificate } from './x509certificate';\r\nimport { getCurves } from './ec';\r\nimport { constants } from './constants';\r\n\r\n// utils import\r\nimport * as utils from './utils';\r\nimport * as subtle from './subtle';\r\n\r\n/**\r\n * Loosely matches Node.js {crypto} with some unimplemented functionality.\r\n * See `docs/implementation-coverage.md` for status.\r\n */\r\nconst QuickCrypto = {\r\n  ...argon2Module,\r\n  ...keys,\r\n  ...blake3,\r\n  ...cipher,\r\n  ...ed,\r\n  ...hash,\r\n  ...hmac,\r\n  ...hkdf,\r\n  ...pbkdf2,\r\n  ...prime,\r\n  ...scrypt,\r\n  ...random,\r\n  ...ecdh,\r\n  ...dh,\r\n  ...mlkem,\r\n  ...utils,\r\n  ...subtle,\r\n  Certificate,\r\n  X509Certificate,\r\n  getCurves,\r\n  constants,\r\n  Buffer,\r\n};\r\n\r\ntype Base64Globals = typeof globalThis & {\r\n  base64FromArrayBuffer?: (buffer: ArrayBuffer, urlSafe?: boolean) => string;\r\n  base64ToArrayBuffer?: (\r\n    b64: string,\r\n    removeLinebreaks?: boolean,\r\n  ) => ArrayBuffer;\r\n};\r\n\r\n/**\r\n * HarmonyOS has no QuickBase64 native module; Buffer.toString/from('base64')\r\n * still needs these globals. Fall back to Nitro HybridUtils when missing.\r\n */\r\nconst installBase64GlobalsFallback = () => {\r\n  const g = global as Base64Globals;\r\n  if (typeof g.base64FromArrayBuffer === 'function') {\r\n    return;\r\n  }\r\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\r\n  const { bufferToString, stringToBuffer } = require('./utils/conversion') as {\r\n    bufferToString: (buf: ArrayBuffer, encoding?: string) => string;\r\n    stringToBuffer: (str: string, encoding?: string) => ArrayBuffer;\r\n  };\r\n  g.base64FromArrayBuffer = (buffer: ArrayBuffer, urlSafe?: boolean) =>\r\n    bufferToString(buffer, urlSafe ? 'base64url' : 'base64');\r\n  g.base64ToArrayBuffer = (b64: string, removeLinebreaks?: boolean) => {\r\n    const input = removeLinebreaks ? b64.replace(/[\\r\\n]/g, '') : b64;\r\n    return stringToBuffer(input, 'base64');\r\n  };\r\n};\r\n\r\n/**\r\n * Optional. Patch global.crypto with react-native-quick-crypto and\r\n * global.Buffer with react-native-buffer.\r\n */\r\nexport const install = () => {\r\n  // @ts-expect-error copyBytesFrom and poolSizets are missing from react-native-buffer\r\n  global.Buffer = Buffer;\r\n\r\n  // @ts-expect-error subtle isn't fully implemented and Cryptokey is missing\r\n  global.crypto = QuickCrypto;\r\n\r\n  // Install base64 globals (base64ToArrayBuffer, base64FromArrayBuffer)\r\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\r\n  require('react-native-quick-base64');\r\n  installBase64GlobalsFallback();\r\n};\r\n\r\n// random, cipher, hash use nextTick\r\nif (global.process == null) {\r\n  // @ts-expect-error - process is not defined\r\n  global.process = {};\r\n}\r\nif (global.process.nextTick == null) {\r\n  global.process.nextTick = setImmediate;\r\n}\r\n\r\n// exports\r\nexport default QuickCrypto;\r\nexport * from './argon2';\r\nexport * from './blake3';\r\nexport { Certificate } from './certificate';\r\nexport { X509Certificate } from './x509certificate';\r\nexport type { CheckOptions, X509LegacyObject } from './x509certificate';\r\nexport * from './cipher';\r\nexport * from './ed';\r\nexport * from './keys';\r\nexport * from './hash';\r\nexport * from './hmac';\r\nexport * from './hkdf';\r\nexport * from './pbkdf2';\r\nexport * from './prime';\r\nexport * from './scrypt';\r\nexport * from './random';\r\nexport * from './ecdh';\r\nexport { getCurves } from './ec';\r\nexport * from './diffie-hellman';\r\nexport * from './mlkem';\r\nexport * from './utils';\r\nexport * from './subtle';\r\nexport { subtle, isCryptoKeyPair } from './subtle';\r\nexport { constants } from './constants';\r\nexport { Buffer } from '@craftzdog/react-native-buffer';\r\n\r\n// Additional exports for CommonJS compatibility\r\nmodule.exports = QuickCrypto;\r\nmodule.exports.default = QuickCrypto;\r\nmodule.exports.install = install;\r\n"],"mappings":"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","ignoreList":[]}