react-native-quick-crypto 0.2.0

package/lib/module/Hash.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Hash.ts"],"names":["NativeQuickCrypto","toArrayBuffer","Stream","Buffer","global","process","nextTick","setImmediate","createInternalHash","createHash","algorithm","options","Hash","Transform","constructor","arg","undefined","internalHash","copy","outputLength","update","data","inputEncoding","ArrayBuffer","buffer","from","_transform","chunk","encoding","callback","_flush","push","digest","result","toString"],"mappings":";;AAAA;AACA,OAAO,cAAP;AACA,SAASA,iBAAT,QAAkC,uCAAlC;AAEA,SAAmBC,aAAnB,QAAwC,SAAxC;AACA,OAAOC,MAAP,MAAmB,QAAnB;AACA,SAASC,MAAT,QAAuB,gCAAvB;AAOAC,MAAM,CAACC,OAAP,CAAeC,QAAf,GAA0BC,YAA1B;AAEA,MAAMC,kBAAkB,GAAGR,iBAAiB,CAACS,UAA7C;AAIA,OAAO,SAASA,UAAT,CAAoBC,SAApB,EAAuCC,OAAvC,EAA8D;AACnE,SAAO,IAAIC,IAAJ,CAASF,SAAT,EAAoBC,OAApB,CAAP;AACD;;AAED,MAAMC,IAAN,SAAmBV,MAAM,CAACW,SAA1B,CAAoC;AAKlCC,EAAAA,WAAW,CAACC,GAAD,EAAqBJ,OAArB,EAA4C;AACrD,UAAMA,OAAN,aAAMA,OAAN,cAAMA,OAAN,GAAiBK,SAAjB;;AADqD;;AAErD,QAAID,GAAG,YAAYH,IAAnB,EAAyB;AACvB,WAAKK,YAAL,GAAoBF,GAAG,CAACE,YAAJ,CAAiBC,IAAjB,CAAsBP,OAAtB,aAAsBA,OAAtB,uBAAsBA,OAAO,CAAEQ,YAA/B,CAApB;AACD,KAFD,MAEO;AACL,WAAKF,YAAL,GAAoBT,kBAAkB,CAACO,GAAD,EAAMJ,OAAN,aAAMA,OAAN,uBAAMA,OAAO,CAAEQ,YAAf,CAAtC;AACD;AACF;;AAEDD,EAAAA,IAAI,CAACP,OAAD,EAAkC;AACpC,UAAMO,IAAI,GAAG,IAAIN,IAAJ,CAAS,IAAT,EAAeD,OAAf,CAAb;AACA,WAAOO,IAAP;AACD;AACD;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACEE,EAAAA,MAAM,CAACC,IAAD,EAA4BC,aAA5B,EAA4D;AAChE,QAAID,IAAI,YAAYE,WAApB,EAAiC;AAC/B,WAAKN,YAAL,CAAkBG,MAAlB,CAAyBC,IAAzB;AACA,aAAO,IAAP;AACD;;AACD,UAAMG,MAAM,GAAGrB,MAAM,CAACsB,IAAP,CAAYJ,IAAZ,EAAkBC,aAAlB,CAAf;AACA,SAAKL,YAAL,CAAkBG,MAAlB,CAAyBnB,aAAa,CAACuB,MAAD,CAAtC;AACA,WAAO,IAAP;AACD;;AAEDE,EAAAA,UAAU,CACRC,KADQ,EAERC,QAFQ,EAGRC,QAHQ,EAIR;AACA,SAAKT,MAAL,CAAYO,KAAZ,EAAmBC,QAAnB;AACAC,IAAAA,QAAQ;AACT;;AAEDC,EAAAA,MAAM,CAACD,QAAD,EAAuB;AAC3B,SAAKE,IAAL,CAAU,KAAKC,MAAL,EAAV;AACAH,IAAAA,QAAQ;AACT;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAIEG,EAAAA,MAAM,CAACJ,QAAD,EAAkD;AACtD,UAAMK,MAAmB,GAAG,KAAKhB,YAAL,CAAkBe,MAAlB,EAA5B;;AAEA,QAAIJ,QAAQ,IAAIA,QAAQ,KAAK,QAA7B,EAAuC;AACrC,aAAOzB,MAAM,CAACsB,IAAP,CAAYQ,MAAZ,EAAoBC,QAApB,CAA6BN,QAA7B,CAAP;AACD;;AAED,WAAOzB,MAAM,CAACsB,IAAP,CAAYQ,MAAZ,CAAP;AACD;;AAzEiC","sourcesContent":["/* eslint-disable no-dupe-class-members */\nimport 'react-native';\nimport { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';\nimport type { InternalHash } from './NativeQuickCrypto/hash';\nimport { Encoding, toArrayBuffer } from './Utils';\nimport Stream from 'stream';\nimport { Buffer } from '@craftzdog/react-native-buffer';\ninterface HashOptionsBase extends Stream.TransformOptions {\n  outputLength?: number | undefined;\n}\n\ntype HashOptions = null | undefined | HashOptionsBase;\n\nglobal.process.nextTick = setImmediate;\n\nconst createInternalHash = NativeQuickCrypto.createHash;\n\ntype BinaryLike = ArrayBuffer;\n\nexport function createHash(algorithm: string, options?: HashOptions) {\n  return new Hash(algorithm, options);\n}\n\nclass Hash extends Stream.Transform {\n  private internalHash: InternalHash;\n\n  constructor(other: Hash, options?: HashOptions);\n  constructor(algorithm: string, options?: HashOptions);\n  constructor(arg: string | Hash, options?: HashOptions) {\n    super(options ?? undefined);\n    if (arg instanceof Hash) {\n      this.internalHash = arg.internalHash.copy(options?.outputLength);\n    } else {\n      this.internalHash = createInternalHash(arg, options?.outputLength);\n    }\n  }\n\n  copy(options?: HashOptionsBase): Hash {\n    const copy = new Hash(this, options);\n    return copy;\n  }\n  /**\n   * Updates the hash content with the given `data`, the encoding of which\n   * is given in `inputEncoding`.\n   * If `encoding` is not provided, and the `data` is a string, an\n   * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.\n   *\n   * This can be called many times with new data as it is streamed.\n   * @since v0.1.92\n   * @param inputEncoding The `encoding` of the `data` string.\n   */\n  update(data: string | BinaryLike, inputEncoding?: Encoding): Hash {\n    if (data instanceof ArrayBuffer) {\n      this.internalHash.update(data);\n      return this;\n    }\n    const buffer = Buffer.from(data, inputEncoding);\n    this.internalHash.update(toArrayBuffer(buffer));\n    return this;\n  }\n\n  _transform(\n    chunk: string | BinaryLike,\n    encoding: Encoding,\n    callback: () => void\n  ) {\n    this.update(chunk, encoding);\n    callback();\n  }\n\n  _flush(callback: () => void) {\n    this.push(this.digest());\n    callback();\n  }\n\n  /**\n   * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).\n   * If `encoding` is provided a string will be returned; otherwise\n   * a `Buffer` is returned.\n   *\n   * The `Hash` object can not be used again after `hash.digest()` method has been\n   * called. Multiple calls will cause an error to be thrown.\n   * @since v0.1.92\n   * @param encoding The `encoding` of the return value.\n   */\n  digest(): Buffer;\n  digest(encoding: 'buffer'): Buffer;\n  digest(encoding: Encoding): string;\n  digest(encoding?: Encoding | 'buffer'): string | Buffer {\n    const result: ArrayBuffer = this.internalHash.digest();\n\n    if (encoding && encoding !== 'buffer') {\n      return Buffer.from(result).toString(encoding);\n    }\n\n    return Buffer.from(result);\n  }\n}\n"]}

package/lib/module/Hmac.js

@@ -0,0 +1,90 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* eslint-disable no-dupe-class-members */
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import { toArrayBuffer, binaryLikeToArrayBuffer } from './Utils';
+import Stream from 'stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+const createInternalHmac = NativeQuickCrypto.createHmac;
+export function createHmac(algorithm, key, options) {
+  return new Hmac(algorithm, key, options);
+}
+
+class Hmac extends Stream.Transform {
+  constructor(algorithm, key, _options) {
+    super();
+
+    _defineProperty(this, "internalHmac", void 0);
+
+    _defineProperty(this, "isFinalized", false);
+
+    let keyAsString = binaryLikeToArrayBuffer(key);
+
+    if (keyAsString === undefined) {
+      throw 'Wrong key type';
+    }
+
+    this.internalHmac = createInternalHmac(algorithm, keyAsString);
+  }
+  /**
+   * 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 v0.1.94
+   * @param inputEncoding The `encoding` of the `data` string.
+   */
+
+
+  update(data, inputEncoding) {
+    if (data instanceof ArrayBuffer) {
+      this.internalHmac.update(data);
+      return this;
+    }
+
+    if (typeof data === 'string') {
+      const buffer = Buffer.from(data, inputEncoding);
+      this.internalHmac.update(toArrayBuffer(buffer));
+      return this;
+    }
+
+    this.internalHmac.update(binaryLikeToArrayBuffer(data));
+    return this;
+  }
+
+  _transform(chunk, encoding, callback) {
+    this.update(chunk, encoding);
+    callback();
+  }
+
+  _flush(callback) {
+    this.push(this.digest());
+    callback();
+  }
+  /**
+   * 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 v0.1.94
+   * @param encoding The `encoding` of the return value.
+   */
+
+
+  digest(encoding) {
+    const result = this.isFinalized ? new ArrayBuffer(0) : this.internalHmac.digest();
+    this.isFinalized = true;
+
+    if (encoding && encoding !== 'buffer') {
+      return Buffer.from(result).toString(encoding);
+    }
+
+    return Buffer.from(result);
+  }
+
+}
+//# sourceMappingURL=Hmac.js.map

package/lib/module/Hmac.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Hmac.ts"],"names":["NativeQuickCrypto","toArrayBuffer","binaryLikeToArrayBuffer","Stream","Buffer","createInternalHmac","createHmac","algorithm","key","options","Hmac","Transform","constructor","_options","keyAsString","undefined","internalHmac","update","data","inputEncoding","ArrayBuffer","buffer","from","_transform","chunk","encoding","callback","_flush","push","digest","result","isFinalized","toString"],"mappings":";;AAAA;AACA,SAASA,iBAAT,QAAkC,uCAAlC;AAEA,SAEEC,aAFF,EAIEC,uBAJF,QAKO,SALP;AAMA,OAAOC,MAAP,MAAmB,QAAnB;AACA,SAASC,MAAT,QAAuB,gCAAvB;AAEA,MAAMC,kBAAkB,GAAGL,iBAAiB,CAACM,UAA7C;AAEA,OAAO,SAASA,UAAT,CACLC,SADK,EAELC,GAFK,EAGLC,OAHK,EAIL;AACA,SAAO,IAAIC,IAAJ,CAASH,SAAT,EAAoBC,GAApB,EAAyBC,OAAzB,CAAP;AACD;;AAED,MAAMC,IAAN,SAAmBP,MAAM,CAACQ,SAA1B,CAAoC;AAIlCC,EAAAA,WAAW,CACTL,SADS,EAETC,GAFS,EAGTK,QAHS,EAIT;AACA;;AADA;;AAAA,yCAN6B,KAM7B;;AAEA,QAAIC,WAAW,GAAGZ,uBAAuB,CAACM,GAAD,CAAzC;;AAEA,QAAIM,WAAW,KAAKC,SAApB,EAA+B;AAC7B,YAAM,gBAAN;AACD;;AAED,SAAKC,YAAL,GAAoBX,kBAAkB,CACpCE,SADoC,EAEpCO,WAFoC,CAAtC;AAID;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACEG,EAAAA,MAAM,CAACC,IAAD,EAA4BC,aAA5B,EAA4D;AAChE,QAAID,IAAI,YAAYE,WAApB,EAAiC;AAC/B,WAAKJ,YAAL,CAAkBC,MAAlB,CAAyBC,IAAzB;AACA,aAAO,IAAP;AACD;;AACD,QAAI,OAAOA,IAAP,KAAgB,QAApB,EAA8B;AAC5B,YAAMG,MAAM,GAAGjB,MAAM,CAACkB,IAAP,CAAYJ,IAAZ,EAAkBC,aAAlB,CAAf;AACA,WAAKH,YAAL,CAAkBC,MAAlB,CAAyBhB,aAAa,CAACoB,MAAD,CAAtC;AACA,aAAO,IAAP;AACD;;AAED,SAAKL,YAAL,CAAkBC,MAAlB,CAAyBf,uBAAuB,CAACgB,IAAD,CAAhD;AACA,WAAO,IAAP;AACD;;AAEDK,EAAAA,UAAU,CACRC,KADQ,EAERC,QAFQ,EAGRC,QAHQ,EAIR;AACA,SAAKT,MAAL,CAAYO,KAAZ,EAAmBC,QAAnB;AACAC,IAAAA,QAAQ;AACT;;AAEDC,EAAAA,MAAM,CAACD,QAAD,EAAuB;AAC3B,SAAKE,IAAL,CAAU,KAAKC,MAAL,EAAV;AACAH,IAAAA,QAAQ;AACT;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAIEG,EAAAA,MAAM,CAACJ,QAAD,EAAkD;AACtD,UAAMK,MAAmB,GAAG,KAAKC,WAAL,GACxB,IAAIX,WAAJ,CAAgB,CAAhB,CADwB,GAExB,KAAKJ,YAAL,CAAkBa,MAAlB,EAFJ;AAGA,SAAKE,WAAL,GAAmB,IAAnB;;AACA,QAAIN,QAAQ,IAAIA,QAAQ,KAAK,QAA7B,EAAuC;AACrC,aAAOrB,MAAM,CAACkB,IAAP,CAAYQ,MAAZ,EAAoBE,QAApB,CAA6BP,QAA7B,CAAP;AACD;;AACD,WAAOrB,MAAM,CAACkB,IAAP,CAAYQ,MAAZ,CAAP;AACD;;AAnFiC","sourcesContent":["/* eslint-disable no-dupe-class-members */\nimport { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';\nimport type { InternalHmac } from './NativeQuickCrypto/hmac';\nimport {\n  Encoding,\n  toArrayBuffer,\n  BinaryLike,\n  binaryLikeToArrayBuffer,\n} from './Utils';\nimport Stream from 'stream';\nimport { Buffer } from '@craftzdog/react-native-buffer';\n\nconst createInternalHmac = NativeQuickCrypto.createHmac;\n\nexport function createHmac(\n  algorithm: string,\n  key: BinaryLike,\n  options?: Stream.TransformOptions\n) {\n  return new Hmac(algorithm, key, options);\n}\n\nclass Hmac extends Stream.Transform {\n  private internalHmac: InternalHmac;\n  private isFinalized: boolean = false;\n\n  constructor(\n    algorithm: string,\n    key: BinaryLike,\n    _options?: Stream.TransformOptions\n  ) {\n    super();\n    let keyAsString = binaryLikeToArrayBuffer(key);\n\n    if (keyAsString === undefined) {\n      throw 'Wrong key type';\n    }\n\n    this.internalHmac = createInternalHmac(\n      algorithm,\n      keyAsString as ArrayBuffer\n    );\n  }\n\n  /**\n   * Updates the `Hmac` content with the given `data`, the encoding of which\n   * is given in `inputEncoding`.\n   * If `encoding` is not provided, and the `data` is a string, an\n   * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.\n   *\n   * This can be called many times with new data as it is streamed.\n   * @since v0.1.94\n   * @param inputEncoding The `encoding` of the `data` string.\n   */\n  update(data: string | BinaryLike, inputEncoding?: Encoding): Hmac {\n    if (data instanceof ArrayBuffer) {\n      this.internalHmac.update(data);\n      return this;\n    }\n    if (typeof data === 'string') {\n      const buffer = Buffer.from(data, inputEncoding);\n      this.internalHmac.update(toArrayBuffer(buffer));\n      return this;\n    }\n\n    this.internalHmac.update(binaryLikeToArrayBuffer(data));\n    return this;\n  }\n\n  _transform(\n    chunk: string | BinaryLike,\n    encoding: Encoding,\n    callback: () => void\n  ) {\n    this.update(chunk, encoding);\n    callback();\n  }\n\n  _flush(callback: () => void) {\n    this.push(this.digest());\n    callback();\n  }\n\n  /**\n   * Calculates the HMAC digest of all of the data passed using `hmac.update()`.\n   * If `encoding` is\n   * provided a string is returned; otherwise a `Buffer` is returned;\n   *\n   * The `Hmac` object can not be used again after `hmac.digest()` has been\n   * called. Multiple calls to `hmac.digest()` will result in an error being thrown.\n   * @since v0.1.94\n   * @param encoding The `encoding` of the return value.\n   */\n  digest(): Buffer;\n  digest(encoding: 'buffer'): Buffer;\n  digest(encoding: Encoding): string;\n  digest(encoding?: Encoding | 'buffer'): string | Buffer {\n    const result: ArrayBuffer = this.isFinalized\n      ? new ArrayBuffer(0)\n      : this.internalHmac.digest();\n    this.isFinalized = true;\n    if (encoding && encoding !== 'buffer') {\n      return Buffer.from(result).toString(encoding);\n    }\n    return Buffer.from(result);\n  }\n}\n"]}

package/lib/module/NativeQuickCrypto/Cipher.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Cipher.js.map

package/lib/module/NativeQuickCrypto/Cipher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/lib/module/NativeQuickCrypto/NativeQuickCrypto.js

@@ -0,0 +1,53 @@
+import { NativeModules, Platform } from 'react-native';
+
+// Check if the constructor exists. If not, try installing the JSI bindings.
+if (global.__QuickCryptoProxy == null) {
+  // Get the native QuickCrypto ReactModule
+  const QuickCryptoModule = NativeModules.QuickCrypto;
+
+  if (QuickCryptoModule == null) {
+    var _NativeModules$Native, _NativeModules$Native2;
+
+    let message = 'Failed to install react-native-quick-crypto: The native `QuickCrypto` Module could not be found.';
+    message += '\n* Make sure react-native-quick-crypto is correctly autolinked (run `npx react-native config` to verify)';
+
+    if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+      message += '\n* Make sure you ran `pod install` in the ios/ directory.';
+    }
+
+    if (Platform.OS === 'android') {
+      message += '\n* Make sure gradle is synced.';
+    } // check if Expo
+
+
+    const ExpoConstants = (_NativeModules$Native = NativeModules.NativeUnimoduleProxy) === null || _NativeModules$Native === void 0 ? void 0 : (_NativeModules$Native2 = _NativeModules$Native.modulesConstants) === null || _NativeModules$Native2 === void 0 ? void 0 : _NativeModules$Native2.ExponentConstants;
+
+    if (ExpoConstants != null) {
+      if (ExpoConstants.appOwnership === 'expo') {
+        // We're running Expo Go
+        throw new Error('react-native-quick-crypto is not supported in Expo Go! Use EAS (`expo prebuild`) or eject to a bare workflow instead.');
+      } else {
+        // We're running Expo bare / standalone
+        message += '\n* Make sure you ran `expo prebuild`.';
+      }
+    }
+
+    message += '\n* Make sure you rebuilt the app.';
+    throw new Error(message);
+  } // Check if we are running on-device (JSI)
+
+
+  if (global.nativeCallSyncHook == null || QuickCryptoModule.install == null) {
+    throw new Error('Failed to install react-native-quick-crypto: React Native is not running on-device. QuickCrypto can only be used when synchronous method invocations (JSI) are possible. If you are using a remote debugger (e.g. Chrome), switch to an on-device debugger (e.g. Flipper) instead.');
+  } // Call the synchronous blocking install() function
+
+
+  const result = QuickCryptoModule.install();
+  if (result !== true) throw new Error(`Failed to install react-native-quick-crypto: The native QuickCrypto Module could not be installed! Looks like something went wrong when installing JSI bindings: ${result}`); // Check again if the constructor now exists. If not, throw an error.
+
+  if (global.__QuickCryptoProxy == null) throw new Error('Failed to install react-native-quick-crypto, the native initializer function does not exist. Are you trying to use QuickCrypto from different JS Runtimes?');
+}
+
+const proxy = global.__QuickCryptoProxy;
+export const NativeQuickCrypto = proxy;
+//# sourceMappingURL=NativeQuickCrypto.js.map

package/lib/module/NativeQuickCrypto/NativeQuickCrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["NativeQuickCrypto.ts"],"names":["NativeModules","Platform","global","__QuickCryptoProxy","QuickCryptoModule","QuickCrypto","message","OS","ExpoConstants","NativeUnimoduleProxy","modulesConstants","ExponentConstants","appOwnership","Error","nativeCallSyncHook","install","result","proxy","NativeQuickCrypto"],"mappings":"AAAA,SAASA,aAAT,EAAwBC,QAAxB,QAAwC,cAAxC;;AAsBA;AACA,IAAIC,MAAM,CAACC,kBAAP,IAA6B,IAAjC,EAAuC;AACrC;AACA,QAAMC,iBAAiB,GAAGJ,aAAa,CAACK,WAAxC;;AACA,MAAID,iBAAiB,IAAI,IAAzB,EAA+B;AAAA;;AAC7B,QAAIE,OAAO,GACT,kGADF;AAEAA,IAAAA,OAAO,IACL,2GADF;;AAEA,QAAIL,QAAQ,CAACM,EAAT,KAAgB,KAAhB,IAAyBN,QAAQ,CAACM,EAAT,KAAgB,OAA7C,EAAsD;AACpDD,MAAAA,OAAO,IAAI,4DAAX;AACD;;AACD,QAAIL,QAAQ,CAACM,EAAT,KAAgB,SAApB,EAA+B;AAC7BD,MAAAA,OAAO,IAAI,iCAAX;AACD,KAV4B,CAW7B;;;AACA,UAAME,aAAa,4BACjBR,aAAa,CAACS,oBADG,oFACjB,sBAAoCC,gBADnB,2DACjB,uBAAsDC,iBADxD;;AAEA,QAAIH,aAAa,IAAI,IAArB,EAA2B;AACzB,UAAIA,aAAa,CAACI,YAAd,KAA+B,MAAnC,EAA2C;AACzC;AACA,cAAM,IAAIC,KAAJ,CACJ,uHADI,CAAN;AAGD,OALD,MAKO;AACL;AACAP,QAAAA,OAAO,IAAI,wCAAX;AACD;AACF;;AAEDA,IAAAA,OAAO,IAAI,oCAAX;AACA,UAAM,IAAIO,KAAJ,CAAUP,OAAV,CAAN;AACD,GA/BoC,CAiCrC;;;AACA,MAAIJ,MAAM,CAACY,kBAAP,IAA6B,IAA7B,IAAqCV,iBAAiB,CAACW,OAAlB,IAA6B,IAAtE,EAA4E;AAC1E,UAAM,IAAIF,KAAJ,CACJ,oRADI,CAAN;AAGD,GAtCoC,CAwCrC;;;AACA,QAAMG,MAAM,GAAGZ,iBAAiB,CAACW,OAAlB,EAAf;AACA,MAAIC,MAAM,KAAK,IAAf,EACE,MAAM,IAAIH,KAAJ,CACH,oKAAmKG,MAAO,EADvK,CAAN,CA3CmC,CA+CrC;;AACA,MAAId,MAAM,CAACC,kBAAP,IAA6B,IAAjC,EACE,MAAM,IAAIU,KAAJ,CACJ,4JADI,CAAN;AAGH;;AAED,MAAMI,KAAK,GAAGf,MAAM,CAACC,kBAArB;AACA,OAAO,MAAMe,iBAAiB,GAAGD,KAA1B","sourcesContent":["import { NativeModules, Platform } from 'react-native';\nimport type { CreateHmacMethod } from './hmac';\nimport type { CreateHashMethod } from './hash';\nimport type { Pbkdf2Object } from './pbkdf2';\nimport type { RandomObject } from './random';\nimport type { CreateCipherMethod, CreateDecipherMethod } from './Cipher';\n\ninterface NativeQuickCryptoSpec {\n  createHmac: CreateHmacMethod;\n  pbkdf2: Pbkdf2Object;\n  random: RandomObject;\n  createHash: CreateHashMethod;\n  createCipher: CreateCipherMethod;\n  createDecipher: CreateDecipherMethod;\n}\n\n// global func declaration for JSI functions\ndeclare global {\n  function nativeCallSyncHook(): unknown;\n  var __QuickCryptoProxy: object | undefined;\n}\n\n// Check if the constructor exists. If not, try installing the JSI bindings.\nif (global.__QuickCryptoProxy == null) {\n  // Get the native QuickCrypto ReactModule\n  const QuickCryptoModule = NativeModules.QuickCrypto;\n  if (QuickCryptoModule == null) {\n    let message =\n      'Failed to install react-native-quick-crypto: The native `QuickCrypto` Module could not be found.';\n    message +=\n      '\\n* Make sure react-native-quick-crypto is correctly autolinked (run `npx react-native config` to verify)';\n    if (Platform.OS === 'ios' || Platform.OS === 'macos') {\n      message += '\\n* Make sure you ran `pod install` in the ios/ directory.';\n    }\n    if (Platform.OS === 'android') {\n      message += '\\n* Make sure gradle is synced.';\n    }\n    // check if Expo\n    const ExpoConstants =\n      NativeModules.NativeUnimoduleProxy?.modulesConstants?.ExponentConstants;\n    if (ExpoConstants != null) {\n      if (ExpoConstants.appOwnership === 'expo') {\n        // We're running Expo Go\n        throw new Error(\n          'react-native-quick-crypto is not supported in Expo Go! Use EAS (`expo prebuild`) or eject to a bare workflow instead.'\n        );\n      } else {\n        // We're running Expo bare / standalone\n        message += '\\n* Make sure you ran `expo prebuild`.';\n      }\n    }\n\n    message += '\\n* Make sure you rebuilt the app.';\n    throw new Error(message);\n  }\n\n  // Check if we are running on-device (JSI)\n  if (global.nativeCallSyncHook == null || QuickCryptoModule.install == null) {\n    throw new Error(\n      'Failed to install react-native-quick-crypto: React Native is not running on-device. QuickCrypto can only be used when synchronous method invocations (JSI) are possible. If you are using a remote debugger (e.g. Chrome), switch to an on-device debugger (e.g. Flipper) instead.'\n    );\n  }\n\n  // Call the synchronous blocking install() function\n  const result = QuickCryptoModule.install();\n  if (result !== true)\n    throw new Error(\n      `Failed to install react-native-quick-crypto: The native QuickCrypto Module could not be installed! Looks like something went wrong when installing JSI bindings: ${result}`\n    );\n\n  // Check again if the constructor now exists. If not, throw an error.\n  if (global.__QuickCryptoProxy == null)\n    throw new Error(\n      'Failed to install react-native-quick-crypto, the native initializer function does not exist. Are you trying to use QuickCrypto from different JS Runtimes?'\n    );\n}\n\nconst proxy = global.__QuickCryptoProxy;\nexport const NativeQuickCrypto = proxy as any as NativeQuickCryptoSpec;\n"]}

package/lib/module/NativeQuickCrypto/hash.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=hash.js.map

package/lib/module/NativeQuickCrypto/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/lib/module/NativeQuickCrypto/hmac.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=hmac.js.map

package/lib/module/NativeQuickCrypto/hmac.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/lib/module/NativeQuickCrypto/pbkdf2.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=pbkdf2.js.map

package/lib/module/NativeQuickCrypto/pbkdf2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/lib/module/NativeQuickCrypto/random.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=random.js.map

package/lib/module/NativeQuickCrypto/random.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/lib/module/QuickCrypto.js

@@ -0,0 +1,18 @@
+import * as pbkdf2 from './pbkdf2';
+import * as random from './random';
+import { createCipher, createCipheriv, createDecipher, createDecipheriv } from './Cipher';
+import { createHmac } from './Hmac';
+import { createHash } from './Hash';
+export const QuickCrypto = {
+  createHmac,
+  Hmac: createHmac,
+  Hash: createHash,
+  createHash,
+  createCipher,
+  createCipheriv,
+  createDecipher,
+  createDecipheriv,
+  ...pbkdf2,
+  ...random
+};
+//# sourceMappingURL=QuickCrypto.js.map

package/lib/module/QuickCrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["QuickCrypto.ts"],"names":["pbkdf2","random","createCipher","createCipheriv","createDecipher","createDecipheriv","createHmac","createHash","QuickCrypto","Hmac","Hash"],"mappings":"AAAA,OAAO,KAAKA,MAAZ,MAAwB,UAAxB;AACA,OAAO,KAAKC,MAAZ,MAAwB,UAAxB;AACA,SACEC,YADF,EAEEC,cAFF,EAGEC,cAHF,EAIEC,gBAJF,QAKO,UALP;AAMA,SAASC,UAAT,QAA2B,QAA3B;AACA,SAASC,UAAT,QAA2B,QAA3B;AAEA,OAAO,MAAMC,WAAW,GAAG;AACzBF,EAAAA,UADyB;AAEzBG,EAAAA,IAAI,EAAEH,UAFmB;AAGzBI,EAAAA,IAAI,EAAEH,UAHmB;AAIzBA,EAAAA,UAJyB;AAKzBL,EAAAA,YALyB;AAMzBC,EAAAA,cANyB;AAOzBC,EAAAA,cAPyB;AAQzBC,EAAAA,gBARyB;AASzB,KAAGL,MATsB;AAUzB,KAAGC;AAVsB,CAApB","sourcesContent":["import * as pbkdf2 from './pbkdf2';\nimport * as random from './random';\nimport {\n  createCipher,\n  createCipheriv,\n  createDecipher,\n  createDecipheriv,\n} from './Cipher';\nimport { createHmac } from './Hmac';\nimport { createHash } from './Hash';\n\nexport const QuickCrypto = {\n  createHmac,\n  Hmac: createHmac,\n  Hash: createHash,\n  createHash,\n  createCipher,\n  createCipheriv,\n  createDecipher,\n  createDecipheriv,\n  ...pbkdf2,\n  ...random,\n};\n"]}

package/lib/module/Utils.js

@@ -0,0 +1,131 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+// Mimics node behavior for default global encoding
+let defaultEncoding = 'buffer';
+export function setDefaultEncoding(encoding) {
+  defaultEncoding = encoding;
+}
+export function getDefaultEncoding() {
+  return defaultEncoding;
+} // function slowCases(enc: string) {
+//   switch (enc.length) {
+//     case 4:
+//       if (enc === 'UTF8') return 'utf8';
+//       if (enc === 'ucs2' || enc === 'UCS2') return 'utf16le';
+//       enc = `${enc}`.toLowerCase();
+//       if (enc === 'utf8') return 'utf8';
+//       if (enc === 'ucs2') return 'utf16le';
+//       break;
+//     case 3:
+//       if (enc === 'hex' || enc === 'HEX' || `${enc}`.toLowerCase() === 'hex')
+//         return 'hex';
+//       break;
+//     case 5:
+//       if (enc === 'ascii') return 'ascii';
+//       if (enc === 'ucs-2') return 'utf16le';
+//       if (enc === 'UTF-8') return 'utf8';
+//       if (enc === 'ASCII') return 'ascii';
+//       if (enc === 'UCS-2') return 'utf16le';
+//       enc = `${enc}`.toLowerCase();
+//       if (enc === 'utf-8') return 'utf8';
+//       if (enc === 'ascii') return 'ascii';
+//       if (enc === 'ucs-2') return 'utf16le';
+//       break;
+//     case 6:
+//       if (enc === 'base64') return 'base64';
+//       if (enc === 'latin1' || enc === 'binary') return 'latin1';
+//       if (enc === 'BASE64') return 'base64';
+//       if (enc === 'LATIN1' || enc === 'BINARY') return 'latin1';
+//       enc = `${enc}`.toLowerCase();
+//       if (enc === 'base64') return 'base64';
+//       if (enc === 'latin1' || enc === 'binary') return 'latin1';
+//       break;
+//     case 7:
+//       if (
+//         enc === 'utf16le' ||
+//         enc === 'UTF16LE' ||
+//         `${enc}`.toLowerCase() === 'utf16le'
+//       )
+//         return 'utf16le';
+//       break;
+//     case 8:
+//       if (
+//         enc === 'utf-16le' ||
+//         enc === 'UTF-16LE' ||
+//         `${enc}`.toLowerCase() === 'utf-16le'
+//       )
+//         return 'utf16le';
+//       break;
+//     case 9:
+//       if (
+//         enc === 'base64url' ||
+//         enc === 'BASE64URL' ||
+//         `${enc}`.toLowerCase() === 'base64url'
+//       )
+//         return 'base64url';
+//       break;
+//     default:
+//       if (enc === '') return 'utf8';
+//   }
+// }
+// // Return undefined if there is no match.
+// // Move the "slow cases" to a separate function to make sure this function gets
+// // inlined properly. That prioritizes the common case.
+// export function normalizeEncoding(enc?: string) {
+//   if (enc == null || enc === 'utf8' || enc === 'utf-8') return 'utf8';
+//   return slowCases(enc);
+// }
+
+export function isBuffer(buf) {
+  var _buf$constructor;
+
+  return buf instanceof Buffer || (buf === null || buf === void 0 ? void 0 : (_buf$constructor = buf.constructor) === null || _buf$constructor === void 0 ? void 0 : _buf$constructor.name) === 'Buffer';
+}
+export function toArrayBuffer(buf) {
+  var _buf$buffer;
+
+  if (buf !== null && buf !== void 0 && (_buf$buffer = buf.buffer) !== null && _buf$buffer !== void 0 && _buf$buffer.slice) {
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+
+  const ab = new ArrayBuffer(buf.length);
+  const view = new Uint8Array(ab);
+
+  for (let i = 0; i < buf.length; ++i) {
+    view[i] = buf[i];
+  }
+
+  return ab;
+}
+export function binaryLikeToArrayBuffer(input) {
+  let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'utf-8';
+
+  if (typeof input === 'string') {
+    const buffer = Buffer.from(input, encoding);
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+
+  if (isBuffer(input)) {
+    return toArrayBuffer(input);
+  } // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property
+
+
+  if (input.buffer) {
+    return input.buffer;
+  }
+
+  if (!(input instanceof ArrayBuffer)) {
+    try {
+      const buffer = Buffer.from(input);
+      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    } catch {
+      throw 'error';
+    }
+  }
+
+  return input;
+}
+export function ab2str(buf) {
+  let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'hex';
+  return Buffer.from(buf).toString(encoding);
+}
+//# sourceMappingURL=Utils.js.map

package/lib/module/Utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Utils.ts"],"names":["Buffer","defaultEncoding","setDefaultEncoding","encoding","getDefaultEncoding","isBuffer","buf","constructor","name","toArrayBuffer","buffer","slice","byteOffset","byteLength","ab","ArrayBuffer","length","view","Uint8Array","i","binaryLikeToArrayBuffer","input","from","ab2str","toString"],"mappings":"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","sourcesContent":["import { Buffer } from '@craftzdog/react-native-buffer';\n\nexport type BinaryLike = string | ArrayBuffer | Buffer;\n\nexport type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex' | 'binary';\nexport type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';\nexport type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';\nexport type Encoding =\n  | BinaryToTextEncoding\n  | CharacterEncoding\n  | LegacyCharacterEncoding;\n\n// TODO(osp) should buffer be part of the Encoding type?\nexport type CipherEncoding = Encoding | 'buffer';\n\n// Mimics node behavior for default global encoding\nlet defaultEncoding: CipherEncoding = 'buffer';\n\nexport function setDefaultEncoding(encoding: CipherEncoding) {\n  defaultEncoding = encoding;\n}\n\nexport function getDefaultEncoding(): CipherEncoding {\n  return defaultEncoding;\n}\n\n// function slowCases(enc: string) {\n//   switch (enc.length) {\n//     case 4:\n//       if (enc === 'UTF8') return 'utf8';\n//       if (enc === 'ucs2' || enc === 'UCS2') return 'utf16le';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'utf8') return 'utf8';\n//       if (enc === 'ucs2') return 'utf16le';\n//       break;\n//     case 3:\n//       if (enc === 'hex' || enc === 'HEX' || `${enc}`.toLowerCase() === 'hex')\n//         return 'hex';\n//       break;\n//     case 5:\n//       if (enc === 'ascii') return 'ascii';\n//       if (enc === 'ucs-2') return 'utf16le';\n//       if (enc === 'UTF-8') return 'utf8';\n//       if (enc === 'ASCII') return 'ascii';\n//       if (enc === 'UCS-2') return 'utf16le';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'utf-8') return 'utf8';\n//       if (enc === 'ascii') return 'ascii';\n//       if (enc === 'ucs-2') return 'utf16le';\n//       break;\n//     case 6:\n//       if (enc === 'base64') return 'base64';\n//       if (enc === 'latin1' || enc === 'binary') return 'latin1';\n//       if (enc === 'BASE64') return 'base64';\n//       if (enc === 'LATIN1' || enc === 'BINARY') return 'latin1';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'base64') return 'base64';\n//       if (enc === 'latin1' || enc === 'binary') return 'latin1';\n//       break;\n//     case 7:\n//       if (\n//         enc === 'utf16le' ||\n//         enc === 'UTF16LE' ||\n//         `${enc}`.toLowerCase() === 'utf16le'\n//       )\n//         return 'utf16le';\n//       break;\n//     case 8:\n//       if (\n//         enc === 'utf-16le' ||\n//         enc === 'UTF-16LE' ||\n//         `${enc}`.toLowerCase() === 'utf-16le'\n//       )\n//         return 'utf16le';\n//       break;\n//     case 9:\n//       if (\n//         enc === 'base64url' ||\n//         enc === 'BASE64URL' ||\n//         `${enc}`.toLowerCase() === 'base64url'\n//       )\n//         return 'base64url';\n//       break;\n//     default:\n//       if (enc === '') return 'utf8';\n//   }\n// }\n\n// // Return undefined if there is no match.\n// // Move the \"slow cases\" to a separate function to make sure this function gets\n// // inlined properly. That prioritizes the common case.\n// export function normalizeEncoding(enc?: string) {\n//   if (enc == null || enc === 'utf8' || enc === 'utf-8') return 'utf8';\n//   return slowCases(enc);\n// }\n\nexport function isBuffer(buf: any): buf is Buffer {\n  return buf instanceof Buffer || buf?.constructor?.name === 'Buffer';\n}\n\nexport function toArrayBuffer(buf: Buffer): ArrayBuffer {\n  if (buf?.buffer?.slice) {\n    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);\n  }\n  const ab = new ArrayBuffer(buf.length);\n  const view = new Uint8Array(ab);\n  for (let i = 0; i < buf.length; ++i) {\n    view[i] = buf[i];\n  }\n  return ab;\n}\n\nexport function binaryLikeToArrayBuffer(\n  input: BinaryLike,\n  encoding: string = 'utf-8'\n): ArrayBuffer {\n  if (typeof input === 'string') {\n    const buffer = Buffer.from(input, encoding);\n\n    return buffer.buffer.slice(\n      buffer.byteOffset,\n      buffer.byteOffset + buffer.byteLength\n    );\n  }\n\n  if (isBuffer(input)) {\n    return toArrayBuffer(input);\n  }\n\n  // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property\n  if ((input as any).buffer) {\n    return (input as any).buffer;\n  }\n\n  if (!(input instanceof ArrayBuffer)) {\n    try {\n      const buffer = Buffer.from(input);\n      return buffer.buffer.slice(\n        buffer.byteOffset,\n        buffer.byteOffset + buffer.byteLength\n      );\n    } catch {\n      throw 'error';\n    }\n  }\n  return input;\n}\n\nexport function ab2str(buf: ArrayBuffer, encoding: string = 'hex') {\n  return Buffer.from(buf).toString(encoding);\n}\n"]}

package/lib/module/index.js

@@ -0,0 +1,2 @@
+export * from './QuickCrypto';
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAd","sourcesContent":["export * from './QuickCrypto';\n"]}

package/lib/module/pbkdf2.js

@@ -0,0 +1,51 @@
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { binaryLikeToArrayBuffer } from './Utils';
+const WRONG_PASS = 'Password must be a string, a Buffer, a typed array or a DataView';
+const WRON_SALT = `Salt must be a string, a Buffer, a typed array or a DataView`;
+
+function sanitizeInput(input, errorMsg) {
+  try {
+    return binaryLikeToArrayBuffer(input);
+  } catch (e) {
+    throw errorMsg;
+  }
+}
+
+const nativePbkdf2 = NativeQuickCrypto.pbkdf2;
+export function pbkdf2(password, salt, iterations, keylen, arg0, arg1) {
+  let digest = 'sha1';
+  let callback;
+
+  if (typeof arg0 === 'string') {
+    digest = arg0;
+
+    if (typeof arg1 === 'function') {
+      callback = arg1;
+    }
+  } else {
+    if (typeof arg0 === 'function') {
+      callback = arg0;
+    }
+  }
+
+  if (callback === undefined) {
+    throw new Error('No callback provided to pbkdf2');
+  }
+
+  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
+  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);
+  nativePbkdf2.pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, digest).then(res => {
+    callback(null, Buffer.from(res));
+  }, e => {
+    callback(e);
+  });
+}
+export function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
+  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);
+  const algo = digest ? digest : 'sha1';
+  let result = nativePbkdf2.pbkdf2Sync(sanitizedPassword, sanitizedSalt, iterations, keylen, algo);
+  return Buffer.from(result);
+}
+//# sourceMappingURL=pbkdf2.js.map

package/lib/module/pbkdf2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["pbkdf2.ts"],"names":["NativeQuickCrypto","Buffer","binaryLikeToArrayBuffer","WRONG_PASS","WRON_SALT","sanitizeInput","input","errorMsg","e","nativePbkdf2","pbkdf2","password","salt","iterations","keylen","arg0","arg1","digest","callback","undefined","Error","sanitizedPassword","sanitizedSalt","then","res","from","pbkdf2Sync","algo","result"],"mappings":"AAAA,SAASA,iBAAT,QAAkC,uCAAlC;AACA,SAASC,MAAT,QAAuB,gCAAvB;AACA,SAAqBC,uBAArB,QAAoD,SAApD;AAEA,MAAMC,UAAU,GACd,kEADF;AAEA,MAAMC,SAAS,GAAI,8DAAnB;;AAMA,SAASC,aAAT,CAAuBC,KAAvB,EAA0CC,QAA1C,EAAyE;AACvE,MAAI;AACF,WAAOL,uBAAuB,CAACI,KAAD,CAA9B;AACD,GAFD,CAEE,OAAOE,CAAP,EAAe;AACf,UAAMD,QAAN;AACD;AACF;;AAED,MAAME,YAAY,GAAGT,iBAAiB,CAACU,MAAvC;AAiBA,OAAO,SAASA,MAAT,CACLC,QADK,EAELC,IAFK,EAGLC,UAHK,EAILC,MAJK,EAKLC,IALK,EAMLC,IANK,EAOC;AACN,MAAIC,MAAM,GAAG,MAAb;AACA,MAAIC,QAAJ;;AACA,MAAI,OAAOH,IAAP,KAAgB,QAApB,EAA8B;AAC5BE,IAAAA,MAAM,GAAGF,IAAT;;AACA,QAAI,OAAOC,IAAP,KAAgB,UAApB,EAAgC;AAC9BE,MAAAA,QAAQ,GAAGF,IAAX;AACD;AACF,GALD,MAKO;AACL,QAAI,OAAOD,IAAP,KAAgB,UAApB,EAAgC;AAC9BG,MAAAA,QAAQ,GAAGH,IAAX;AACD;AACF;;AACD,MAAIG,QAAQ,KAAKC,SAAjB,EAA4B;AAC1B,UAAM,IAAIC,KAAJ,CAAU,gCAAV,CAAN;AACD;;AAED,QAAMC,iBAAiB,GAAGhB,aAAa,CAACM,QAAD,EAAWR,UAAX,CAAvC;AACA,QAAMmB,aAAa,GAAGjB,aAAa,CAACO,IAAD,EAAOR,SAAP,CAAnC;AAEAK,EAAAA,YAAY,CACTC,MADH,CACUW,iBADV,EAC6BC,aAD7B,EAC4CT,UAD5C,EACwDC,MADxD,EACgEG,MADhE,EAEGM,IAFH,CAGKC,GAAD,IAAsB;AACpBN,IAAAA,QAAQ,CAAE,IAAF,EAAQjB,MAAM,CAACwB,IAAP,CAAYD,GAAZ,CAAR,CAAR;AACD,GALL,EAMKhB,CAAD,IAAc;AACZU,IAAAA,QAAQ,CAAEV,CAAF,CAAR;AACD,GARL;AAUD;AACD,OAAO,SAASkB,UAAT,CACLf,QADK,EAELC,IAFK,EAGLC,UAHK,EAILC,MAJK,EAKLG,MALK,EAMG;AACR,QAAMI,iBAAiB,GAAGhB,aAAa,CAACM,QAAD,EAAWR,UAAX,CAAvC;AACA,QAAMmB,aAAa,GAAGjB,aAAa,CAACO,IAAD,EAAOR,SAAP,CAAnC;AAEA,QAAMuB,IAAI,GAAGV,MAAM,GAAGA,MAAH,GAAY,MAA/B;AACA,MAAIW,MAAmB,GAAGnB,YAAY,CAACiB,UAAb,CACxBL,iBADwB,EAExBC,aAFwB,EAGxBT,UAHwB,EAIxBC,MAJwB,EAKxBa,IALwB,CAA1B;AAQA,SAAO1B,MAAM,CAACwB,IAAP,CAAYG,MAAZ,CAAP;AACD","sourcesContent":["import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';\nimport { Buffer } from '@craftzdog/react-native-buffer';\nimport { BinaryLike, binaryLikeToArrayBuffer } from './Utils';\n\nconst WRONG_PASS =\n  'Password must be a string, a Buffer, a typed array or a DataView';\nconst WRON_SALT = `Salt must be a string, a Buffer, a typed array or a DataView`;\n\ntype Password = BinaryLike;\ntype Salt = BinaryLike;\ntype Pbkdf2Callback = (err: Error | null, derivedKey?: Buffer) => void;\n\nfunction sanitizeInput(input: BinaryLike, errorMsg: string): ArrayBuffer {\n  try {\n    return binaryLikeToArrayBuffer(input);\n  } catch (e: any) {\n    throw errorMsg;\n  }\n}\n\nconst nativePbkdf2 = NativeQuickCrypto.pbkdf2;\n\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  digest: string,\n  callback: Pbkdf2Callback\n): void;\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  callback: Pbkdf2Callback\n): void;\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  arg0?: unknown,\n  arg1?: unknown\n): void {\n  let digest = 'sha1';\n  let callback: undefined | Pbkdf2Callback;\n  if (typeof arg0 === 'string') {\n    digest = arg0;\n    if (typeof arg1 === 'function') {\n      callback = arg1 as Pbkdf2Callback;\n    }\n  } else {\n    if (typeof arg0 === 'function') {\n      callback = arg0 as Pbkdf2Callback;\n    }\n  }\n  if (callback === undefined) {\n    throw new Error('No callback provided to pbkdf2');\n  }\n\n  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);\n  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);\n\n  nativePbkdf2\n    .pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, digest)\n    .then(\n      (res: ArrayBuffer) => {\n        callback!(null, Buffer.from(res));\n      },\n      (e: Error) => {\n        callback!(e);\n      }\n    );\n}\nexport function pbkdf2Sync(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  digest?: string\n): Buffer {\n  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);\n  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);\n\n  const algo = digest ? digest : 'sha1';\n  let result: ArrayBuffer = nativePbkdf2.pbkdf2Sync(\n    sanitizedPassword,\n    sanitizedSalt,\n    iterations,\n    keylen,\n    algo\n  );\n\n  return Buffer.from(result);\n}\n"]}