react-native-quick-crypto 0.6.1 → 0.7.0-rc.1

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["NativeQuickCrypto/pbkdf2.ts"],"mappings":"","ignoreList":[]}

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["NativeQuickCrypto/random.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/NativeQuickCrypto/sig.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["NativeQuickCrypto/sig.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/NativeQuickCrypto/webcrypto.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=webcrypto.js.map

package/lib/commonjs/NativeQuickCrypto/webcrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["NativeQuickCrypto/webcrypto.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/QuickCrypto.js

@@ -4,26 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.QuickCrypto = void 0;
-
 var pbkdf2 = _interopRequireWildcard(require("./pbkdf2"));
-
 var random = _interopRequireWildcard(require("./random"));
-
 var _Cipher = require("./Cipher");
-
 var _sig = require("./sig");
-
 var _Hmac = require("./Hmac");
-
 var _Hash = require("./Hash");
-
 var _constants = require("./constants");
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const QuickCrypto = {
+var _subtle = require("./subtle");
+var _Utils = require("./Utils");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const QuickCrypto = exports.QuickCrypto = {
   createHmac: _Hmac.createHmac,
   Hmac: _Hmac.createHmac,
   Hash: _Hash.createHash,
@@ -39,9 +31,11 @@ const QuickCrypto = {
   generateKeyPairSync: _Cipher.generateKeyPairSync,
   createSign: _sig.createSign,
   createVerify: _sig.createVerify,
+  subtle: _subtle.subtle,
   constants: _constants.constants,
   ...pbkdf2,
-  ...random
+  ...random,
+  getCiphers: _Utils.getCiphers,
+  getHashes: _Utils.getHashes
 };
-exports.QuickCrypto = QuickCrypto;
 //# sourceMappingURL=QuickCrypto.js.map

package/lib/commonjs/QuickCrypto.js.map

@@ -1 +1 @@
-{"version":3,"sources":["QuickCrypto.ts"],"names":["QuickCrypto","createHmac","Hmac","Hash","createHash","createCipher","createCipheriv","createDecipher","createDecipheriv","publicEncrypt","publicDecrypt","privateDecrypt","generateKeyPair","generateKeyPairSync","createSign","createVerify","constants","pbkdf2","random"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AAWA;;AACA;;AACA;;AACA;;;;;;AAEO,MAAMA,WAAW,GAAG;AACzBC,EAAAA,UAAU,EAAVA,gBADyB;AAEzBC,EAAAA,IAAI,EAAED,gBAFmB;AAGzBE,EAAAA,IAAI,EAAEC,gBAHmB;AAIzBA,EAAAA,UAAU,EAAVA,gBAJyB;AAKzBC,EAAAA,YAAY,EAAZA,oBALyB;AAMzBC,EAAAA,cAAc,EAAdA,sBANyB;AAOzBC,EAAAA,cAAc,EAAdA,sBAPyB;AAQzBC,EAAAA,gBAAgB,EAAhBA,wBARyB;AASzBC,EAAAA,aAAa,EAAbA,qBATyB;AAUzBC,EAAAA,aAAa,EAAbA,qBAVyB;AAWzBC,EAAAA,cAAc,EAAdA,sBAXyB;AAYzBC,EAAAA,eAAe,EAAfA,uBAZyB;AAazBC,EAAAA,mBAAmB,EAAnBA,2BAbyB;AAczBC,EAAAA,UAAU,EAAVA,eAdyB;AAezBC,EAAAA,YAAY,EAAZA,iBAfyB;AAgBzBC,EAAAA,SAAS,EAATA,oBAhByB;AAiBzB,KAAGC,MAjBsB;AAkBzB,KAAGC;AAlBsB,CAApB","sourcesContent":["import * as pbkdf2 from './pbkdf2';\nimport * as random from './random';\nimport {\n  createCipher,\n  createCipheriv,\n  createDecipher,\n  createDecipheriv,\n  publicEncrypt,\n  publicDecrypt,\n  privateDecrypt,\n  generateKeyPair,\n  generateKeyPairSync,\n} from './Cipher';\nimport { createSign, createVerify } from './sig';\nimport { createHmac } from './Hmac';\nimport { createHash } from './Hash';\nimport { constants } from './constants';\n\nexport const QuickCrypto = {\n  createHmac,\n  Hmac: createHmac,\n  Hash: createHash,\n  createHash,\n  createCipher,\n  createCipheriv,\n  createDecipher,\n  createDecipheriv,\n  publicEncrypt,\n  publicDecrypt,\n  privateDecrypt,\n  generateKeyPair,\n  generateKeyPairSync,\n  createSign,\n  createVerify,\n  constants,\n  ...pbkdf2,\n  ...random,\n};\n"]}
+{"version":3,"names":["pbkdf2","_interopRequireWildcard","require","random","_Cipher","_sig","_Hmac","_Hash","_constants","_subtle","_Utils","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","QuickCrypto","exports","createHmac","Hmac","Hash","createHash","createCipher","createCipheriv","createDecipher","createDecipheriv","publicEncrypt","publicDecrypt","privateDecrypt","generateKeyPair","generateKeyPairSync","createSign","createVerify","subtle","constants","getCiphers","getHashes"],"sourceRoot":"../../src","sources":["QuickCrypto.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,MAAA,GAAAF,uBAAA,CAAAC,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAWA,IAAAG,IAAA,GAAAH,OAAA;AACA,IAAAI,KAAA,GAAAJ,OAAA;AACA,IAAAK,KAAA,GAAAL,OAAA;AACA,IAAAM,UAAA,GAAAN,OAAA;AACA,IAAAO,OAAA,GAAAP,OAAA;AACA,IAAAQ,MAAA,GAAAR,OAAA;AAAgD,SAAAS,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAX,wBAAAW,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAI,UAAA,SAAAJ,CAAA,eAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,WAAAK,OAAA,EAAAL,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAG,GAAA,CAAAN,CAAA,UAAAG,CAAA,CAAAI,GAAA,CAAAP,CAAA,OAAAQ,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,CAAA,IAAAd,CAAA,oBAAAc,CAAA,OAAAC,cAAA,CAAAC,IAAA,CAAAhB,CAAA,EAAAc,CAAA,SAAAG,CAAA,GAAAP,CAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAb,CAAA,EAAAc,CAAA,UAAAG,CAAA,KAAAA,CAAA,CAAAV,GAAA,IAAAU,CAAA,CAAAC,GAAA,IAAAP,MAAA,CAAAC,cAAA,CAAAJ,CAAA,EAAAM,CAAA,EAAAG,CAAA,IAAAT,CAAA,CAAAM,CAAA,IAAAd,CAAA,CAAAc,CAAA,YAAAN,CAAA,CAAAH,OAAA,GAAAL,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAe,GAAA,CAAAlB,CAAA,EAAAQ,CAAA,GAAAA,CAAA;AAEzC,MAAMW,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzBE,UAAU,EAAVA,gBAAU;EACVC,IAAI,EAAED,gBAAU;EAChBE,IAAI,EAAEC,gBAAU;EAChBA,UAAU,EAAVA,gBAAU;EACVC,YAAY,EAAZA,oBAAY;EACZC,cAAc,EAAdA,sBAAc;EACdC,cAAc,EAAdA,sBAAc;EACdC,gBAAgB,EAAhBA,wBAAgB;EAChBC,aAAa,EAAbA,qBAAa;EACbC,aAAa,EAAbA,qBAAa;EACbC,cAAc,EAAdA,sBAAc;EACdC,eAAe,EAAfA,uBAAe;EACfC,mBAAmB,EAAnBA,2BAAmB;EACnBC,UAAU,EAAVA,eAAU;EACVC,YAAY,EAAZA,iBAAY;EACZC,MAAM,EAANA,cAAM;EACNC,SAAS,EAATA,oBAAS;EACT,GAAGjD,MAAM;EACT,GAAGG,MAAM;EACT+C,UAAU,EAAVA,iBAAU;EACVC,SAAS,EAATA;AACF,CAAC","ignoreList":[]}

package/lib/commonjs/Utils.js

@@ -3,33 +3,78 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  setDefaultEncoding: true,
+  getDefaultEncoding: true,
+  kEmptyObject: true,
+  toArrayBuffer: true,
+  bufferLikeToArrayBuffer: true,
+  binaryLikeToArrayBuffer: true,
+  ab2str: true,
+  validateString: true,
+  validateFunction: true,
+  isStringOrBuffer: true,
+  validateObject: true,
+  validateInt32: true,
+  validateUint32: true,
+  hasAnyNotIn: true,
+  lazyDOMException: true,
+  validateMaxBufferLength: true,
+  normalizeAlgorithm: true,
+  validateBitLength: true,
+  validateByteLength: true,
+  validateKeyOps: true,
+  getHashes: true,
+  getCiphers: true
+};
 exports.ab2str = ab2str;
 exports.binaryLikeToArrayBuffer = binaryLikeToArrayBuffer;
+exports.bufferLikeToArrayBuffer = bufferLikeToArrayBuffer;
+exports.getCiphers = void 0;
 exports.getDefaultEncoding = getDefaultEncoding;
+exports.getHashes = void 0;
+exports.hasAnyNotIn = hasAnyNotIn;
 exports.isStringOrBuffer = isStringOrBuffer;
 exports.kEmptyObject = void 0;
+exports.lazyDOMException = lazyDOMException;
+exports.normalizeAlgorithm = void 0;
 exports.setDefaultEncoding = setDefaultEncoding;
 exports.toArrayBuffer = toArrayBuffer;
+exports.validateByteLength = exports.validateBitLength = void 0;
 exports.validateFunction = validateFunction;
 exports.validateInt32 = validateInt32;
+exports.validateMaxBufferLength = exports.validateKeyOps = void 0;
 exports.validateObject = validateObject;
 exports.validateString = validateString;
 exports.validateUint32 = validateUint32;
-
 var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _Hashnames = require("./Hashnames");
+Object.keys(_Hashnames).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Hashnames[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Hashnames[key];
+    }
+  });
+});
+// @types/node
+
+// TODO(osp) should buffer be part of the Encoding type?
 
 // Mimics node behavior for default global encoding
 let defaultEncoding = 'buffer';
-
 function setDefaultEncoding(encoding) {
   defaultEncoding = encoding;
 }
-
 function getDefaultEncoding() {
   return defaultEncoding;
 }
+const kEmptyObject = exports.kEmptyObject = Object.freeze(Object.create(null));
 
-const kEmptyObject = Object.freeze(Object.create(null)); // Should be used by Cipher (or any other module that requires valid encodings)
+// Should be used by Cipher (or any other module that requires valid encodings)
 // function slowCases(enc: string) {
 //   switch (enc.length) {
 //     case 4:
@@ -91,6 +136,7 @@ const kEmptyObject = Object.freeze(Object.create(null)); // Should be used by Ci
 //       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.
@@ -99,128 +145,408 @@ const kEmptyObject = Object.freeze(Object.create(null)); // Should be used by Ci
 //   return slowCases(enc);
 // }
 
-exports.kEmptyObject = kEmptyObject;
-
 function toArrayBuffer(buf) {
-  var _buf$buffer;
-
-  if (buf !== null && buf !== void 0 && (_buf$buffer = buf.buffer) !== null && _buf$buffer !== void 0 && _buf$buffer.slice) {
+  if (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;
 }
-
-function binaryLikeToArrayBuffer(input) {
-  let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'utf-8';
-
+function bufferLikeToArrayBuffer(buf) {
+  return _reactNativeBuffer.Buffer.isBuffer(buf) ? buf.buffer : ArrayBuffer.isView(buf) ? buf.buffer : buf;
+}
+function binaryLikeToArrayBuffer(input,
+// CipherKey adds compat with node types
+encoding = 'utf-8') {
   if (typeof input === 'string') {
+    if (encoding === 'buffer') {
+      throw new Error('Cannot create a buffer from a string with a buffer encoding');
+    }
     const buffer = _reactNativeBuffer.Buffer.from(input, encoding);
-
     return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   }
-
   if (_reactNativeBuffer.Buffer.isBuffer(input)) {
     return toArrayBuffer(input);
-  } // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property
-
+  }
 
-  if (input.buffer) {
+  // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property
+  if (ArrayBuffer.isView(input)) {
     return input.buffer;
   }
-
   if (!(input instanceof ArrayBuffer)) {
     try {
+      // this is a strange fallback case and input is unknown at this point
+      // @ts-expect-error
       const buffer = _reactNativeBuffer.Buffer.from(input);
-
       return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
     } catch {
       throw 'error';
     }
   }
 
+  // TODO: handle if input is KeyObject?
+
   return input;
 }
-
-function ab2str(buf) {
-  let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'hex';
+function ab2str(buf, encoding = 'hex') {
   return _reactNativeBuffer.Buffer.from(buf).toString(encoding);
 }
-
 function validateString(str, name) {
   const isString = typeof str === 'string';
-
-  if (isString) {
+  if (!isString) {
     throw new Error(`${name} is not a string`);
   }
-
   return isString;
 }
-
 function validateFunction(f) {
   return f != null && typeof f === 'function';
 }
-
 function isStringOrBuffer(val) {
   return typeof val === 'string' || ArrayBuffer.isView(val);
 }
-
 function validateObject(value, name, options) {
   const useDefaultOptions = options == null;
   const allowArray = useDefaultOptions ? false : options.allowArray;
   const allowFunction = useDefaultOptions ? false : options.allowFunction;
   const nullable = useDefaultOptions ? false : options.nullable;
-
   if (!nullable && value === null || !allowArray && Array.isArray(value) || typeof value !== 'object' && (!allowFunction || typeof value !== 'function')) {
     throw new Error(`${name} is not a valid object $${value}`);
   }
-
   return true;
 }
-
-function validateInt32(value, name) {
-  let min = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -2147483648;
-  let max = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 2147483647;
-
+function validateInt32(value, name, min = -2147483648, max = 2147483647) {
   // The defaults for min and max correspond to the limits of 32-bit integers.
   if (typeof value !== 'number') {
     throw new Error(`Invalid argument - ${name} is not a number: ${value}`);
   }
-
   if (!Number.isInteger(value)) {
     throw new Error(`Argument out of range - ${name} out of integer range: ${value}`);
   }
-
   if (value < min || value > max) {
     throw new Error(`Invalid argument - ${name} out of range >= ${min} && <= ${max}: ${value}`);
   }
 }
-
 function validateUint32(value, name, positive) {
   if (typeof value !== 'number') {
     // throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
     throw new Error(`Invalid argument - ${name} is not a number: ${value}`);
   }
-
   if (!Number.isInteger(value)) {
     // throw new ERR_OUT_OF_RANGE(name, 'an integer', value);
     throw new Error(`Argument out of range - ${name} out of integer range: ${value}`);
   }
-
-  const min = positive ? 1 : 0; // 2 ** 32 === 4294967296
-
+  const min = positive ? 1 : 0;
+  // 2 ** 32 === 4294967296
   const max = 4294967295;
-
   if (value < min || value > max) {
     // throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
     throw new Error(`Invalid argument - ${name} out of range >= ${min} && <= ${max}: ${value}`);
   }
 }
+function hasAnyNotIn(set, checks) {
+  for (const s of set) {
+    if (!checks.includes(s)) {
+      return true;
+    }
+  }
+  return false;
+}
+function lazyDOMException(message, domName) {
+  let cause = '';
+  if (typeof domName !== 'string') {
+    cause = `\nCaused by: ${domName.cause}`;
+  }
+  return new Error(`[${domName}]: ${message}${cause}`);
+}
+
+// from lib/internal/crypto/util.js
+
+// The maximum buffer size that we'll support in the WebCrypto impl
+const kMaxBufferLength = 2 ** 31 - 1;
+
+// // The EC named curves that we currently support via the Web Crypto API.
+// const kNamedCurveAliases = {
+//   'P-256': 'prime256v1',
+//   'P-384': 'secp384r1',
+//   'P-521': 'secp521r1',
+// };
+
+// const kAesKeyLengths = [128, 192, 256];
+
+// // These are the only hash algorithms we currently support via
+// // the Web Crypto API.
+// const kHashTypes = ['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512'];
+
+const kSupportedAlgorithms = {
+  'digest': {
+    'SHA-1': null,
+    'SHA-256': null,
+    'SHA-384': null,
+    'SHA-512': null
+  },
+  'generateKey': {
+    'RSASSA-PKCS1-v1_5': 'RsaHashedKeyGenParams',
+    'RSA-PSS': 'RsaHashedKeyGenParams',
+    'RSA-OAEP': 'RsaHashedKeyGenParams',
+    'ECDSA': 'EcKeyGenParams',
+    'ECDH': 'EcKeyGenParams',
+    'AES-CTR': 'AesKeyGenParams',
+    'AES-CBC': 'AesKeyGenParams',
+    'AES-GCM': 'AesKeyGenParams',
+    'AES-KW': 'AesKeyGenParams',
+    'HMAC': 'HmacKeyGenParams',
+    'X25519': null,
+    'Ed25519': null,
+    'X448': null,
+    'Ed448': null
+  },
+  'sign': {
+    'RSASSA-PKCS1-v1_5': null,
+    'RSA-PSS': 'RsaPssParams',
+    'ECDSA': 'EcdsaParams',
+    'HMAC': null,
+    'Ed25519': null,
+    'Ed448': 'Ed448Params'
+  },
+  'verify': {
+    'RSASSA-PKCS1-v1_5': null,
+    'RSA-PSS': 'RsaPssParams',
+    'ECDSA': 'EcdsaParams',
+    'HMAC': null,
+    'Ed25519': null,
+    'Ed448': 'Ed448Params'
+  },
+  'importKey': {
+    'RSASSA-PKCS1-v1_5': 'RsaHashedImportParams',
+    'RSA-PSS': 'RsaHashedImportParams',
+    'RSA-OAEP': 'RsaHashedImportParams',
+    'ECDSA': 'EcKeyImportParams',
+    'ECDH': 'EcKeyImportParams',
+    'HMAC': 'HmacImportParams',
+    'HKDF': null,
+    'PBKDF2': null,
+    'AES-CTR': null,
+    'AES-CBC': null,
+    'AES-GCM': null,
+    'AES-KW': null,
+    'Ed25519': null,
+    'X25519': null,
+    'Ed448': null,
+    'X448': null
+  },
+  'deriveBits': {
+    HKDF: 'HkdfParams',
+    PBKDF2: 'Pbkdf2Params',
+    ECDH: 'EcdhKeyDeriveParams',
+    X25519: 'EcdhKeyDeriveParams',
+    X448: 'EcdhKeyDeriveParams'
+  },
+  'encrypt': {
+    'RSA-OAEP': 'RsaOaepParams',
+    'AES-CBC': 'AesCbcParams',
+    'AES-GCM': 'AesGcmParams',
+    'AES-CTR': 'AesCtrParams'
+  },
+  'decrypt': {
+    'RSA-OAEP': 'RsaOaepParams',
+    'AES-CBC': 'AesCbcParams',
+    'AES-GCM': 'AesGcmParams',
+    'AES-CTR': 'AesCtrParams'
+  },
+  'get key length': {
+    'AES-CBC': 'AesDerivedKeyParams',
+    'AES-CTR': 'AesDerivedKeyParams',
+    'AES-GCM': 'AesDerivedKeyParams',
+    'AES-KW': 'AesDerivedKeyParams',
+    'HMAC': 'HmacImportParams',
+    'HKDF': null,
+    'PBKDF2': null
+  },
+  'wrapKey': {
+    'AES-KW': null
+  },
+  'unwrapKey': {
+    'AES-KW': null
+  }
+};
+
+// const simpleAlgorithmDictionaries = {
+//   AesGcmParams: { iv: 'BufferSource', additionalData: 'BufferSource' },
+//   RsaHashedKeyGenParams: { hash: 'HashAlgorithmIdentifier' },
+//   EcKeyGenParams: {},
+//   HmacKeyGenParams: { hash: 'HashAlgorithmIdentifier' },
+//   RsaPssParams: {},
+//   EcdsaParams: { hash: 'HashAlgorithmIdentifier' },
+//   HmacImportParams: { hash: 'HashAlgorithmIdentifier' },
+//   HkdfParams: {
+//     hash: 'HashAlgorithmIdentifier',
+//     salt: 'BufferSource',
+//     info: 'BufferSource',
+//   },
+//   Ed448Params: { context: 'BufferSource' },
+//   Pbkdf2Params: { hash: 'HashAlgorithmIdentifier', salt: 'BufferSource' },
+//   RsaOaepParams: { label: 'BufferSource' },
+//   RsaHashedImportParams: { hash: 'HashAlgorithmIdentifier' },
+//   EcKeyImportParams: {},
+// };
+
+const validateMaxBufferLength = (data, name) => {
+  const length = typeof data === 'string' ? data.length : data.byteLength;
+  if (length > kMaxBufferLength) {
+    throw lazyDOMException(`${name} must be less than ${kMaxBufferLength + 1} bits`, 'OperationError');
+  }
+};
+
+// https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm
+// adapted for Node.js from Deno's implementation
+// https://github.com/denoland/deno/blob/v1.29.1/ext/crypto/00_crypto.js#L195
+exports.validateMaxBufferLength = validateMaxBufferLength;
+const normalizeAlgorithm = (algorithm, op) => {
+  if (typeof algorithm === 'string') return normalizeAlgorithm({
+    name: algorithm
+  }, op);
+
+  // 1.
+  const registeredAlgorithms = kSupportedAlgorithms[op];
+  // 2. 3.
+  // commented, because typescript takes care of this for us 🤞👀
+  // const initialAlg = webidl.converters.Algorithm(algorithm, {
+  //   prefix: 'Failed to normalize algorithm',
+  //   context: 'passed algorithm',
+  // });
+
+  // 4.
+  let algName = algorithm.name;
+
+  // 5.
+  let desiredType;
+  for (const key in registeredAlgorithms) {
+    if (!registeredAlgorithms.hasOwnProperty(key)) {
+      continue;
+    }
+    if (key.toUpperCase() === algName.toUpperCase()) {
+      algName = key;
+      // @ts-ignore
+      desiredType = registeredAlgorithms[algName];
+    }
+  }
+  if (desiredType === undefined) throw lazyDOMException('Unrecognized algorithm name', 'NotSupportedError');
+
+  // Fast path everything below if the registered dictionary is null
+  if (desiredType === null) return {
+    name: algName
+  };
+  throw lazyDOMException(`normalizeAlgorithm() not implemented for ${op} / ${algName} / ${desiredType}`, 'NotSupportedError');
+  // TODO: implement these below when needed
+
+  // // 8.
+  // const normalizedAlgorithm = webidl.converters[desiredType](algorithm, {
+  //   prefix: 'Failed to normalize algorithm',
+  //   context: 'passed algorithm',
+  // });
+  // // 9.
+  // normalizedAlgorithm.name = algName;
+
+  // // 9.
+  // const dict = simpleAlgorithmDictionaries[desiredType];
+  // // 10.
+  // const dictKeys = dict ? Object.keys(dict) : [];
+  // for (let i = 0; i < dictKeys.length; i++) {
+  //   const member = dictKeys[i];
+  //   if (!dict.hasOwnProperty(member)) continue;
+  //   const idlType = dict[member];
+  //   const idlValue = normalizedAlgorithm[member];
+  //   // 3.
+  //   if (idlType === 'BufferSource' && idlValue) {
+  //     const isView = ArrayBufferIsView(idlValue);
+  //     normalizedAlgorithm[member] = TypedArrayPrototypeSlice(
+  //       new Uint8Array(
+  //         isView ? getDataViewOrTypedArrayBuffer(idlValue) : idlValue,
+  //         isView ? getDataViewOrTypedArrayByteOffset(idlValue) : 0,
+  //         isView
+  //           ? getDataViewOrTypedArrayByteLength(idlValue)
+  //           : ArrayBufferPrototypeGetByteLength(idlValue)
+  //       )
+  //     );
+  //   } else if (idlType === 'HashAlgorithmIdentifier') {
+  //     normalizedAlgorithm[member] = normalizeAlgorithm(idlValue, 'digest');
+  //   } else if (idlType === 'AlgorithmIdentifier') {
+  //     // This extension point is not used by any supported algorithm (yet?)
+  //     throw lazyDOMException('Not implemented.', 'NotSupportedError');
+  //   }
+  // }
+
+  // return normalizedAlgorithm;
+};
+exports.normalizeAlgorithm = normalizeAlgorithm;
+const validateBitLength = (length, name, required = false) => {
+  if (length !== undefined || required) {
+    // validateNumber(length, name);
+    if (length < 0) throw new Error(`${name} > 0`);
+    if (length % 8) {
+      throw lazyDOMException(`${name}'s length (${length}) must be a multiple of 8`, 'InvalidArgument');
+    }
+  }
+};
+exports.validateBitLength = validateBitLength;
+const validateByteLength = (buf, name, target) => {
+  if (buf.byteLength !== target) {
+    throw lazyDOMException(`${name} must contain exactly ${target} bytes`, 'OperationError');
+  }
+};
+exports.validateByteLength = validateByteLength;
+const kKeyOps = {
+  sign: 1,
+  verify: 2,
+  encrypt: 3,
+  decrypt: 4,
+  wrapKey: 5,
+  unwrapKey: 6,
+  deriveKey: 7,
+  deriveBits: 8
+};
+const validateKeyOps = (keyOps, usagesSet) => {
+  if (keyOps === undefined) return;
+  if (!Array.isArray(keyOps)) {
+    throw lazyDOMException('keyData.key_ops', 'InvalidArgument');
+  }
+  let flags = 0;
+  for (let n = 0; n < keyOps.length; n++) {
+    const op = keyOps[n];
+    const op_flag = kKeyOps[op];
+    // Skipping unknown key ops
+    if (op_flag === undefined) continue;
+    // Have we seen it already? if so, error
+    // eslint-disable-next-line no-bitwise
+    if (flags & 1 << op_flag) throw lazyDOMException('Duplicate key operation', 'DataError');
+    // eslint-disable-next-line no-bitwise
+    flags |= 1 << op_flag;
+
+    // TODO(@jasnell): RFC7517 section 4.3 strong recommends validating
+    // key usage combinations. Specifically, it says that unrelated key
+    // ops SHOULD NOT be used together. We're not yet validating that here.
+  }
+  if (usagesSet !== undefined) {
+    for (const use of usagesSet) {
+      if (!keyOps.includes(use)) {
+        throw lazyDOMException('Key operations and usage mismatch', 'DataError');
+      }
+    }
+  }
+};
+
+// TODO: these used to be shipped by crypto-browserify in quickcrypto v0.6
+// could instead fetch from OpenSSL if needed and handle breaking changes
+exports.validateKeyOps = validateKeyOps;
+const getHashes = () => ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160', 'sha224WithRSAEncryption', 'RSA-SHA224', 'sha256WithRSAEncryption', 'RSA-SHA256', 'sha384WithRSAEncryption', 'RSA-SHA384', 'sha512WithRSAEncryption', 'RSA-SHA512', 'RSA-SHA1', 'ecdsa-with-SHA1', 'sha256', 'sha224', 'sha384', 'sha512', 'DSA-SHA', 'DSA-SHA1', 'DSA', 'DSA-WITH-SHA224', 'DSA-SHA224', 'DSA-WITH-SHA256', 'DSA-SHA256', 'DSA-WITH-SHA384', 'DSA-SHA384', 'DSA-WITH-SHA512', 'DSA-SHA512', 'DSA-RIPEMD160', 'ripemd160WithRSA', 'RSA-RIPEMD160', 'md5WithRSAEncryption', 'RSA-MD5'];
+
+// TODO: these used to be shipped by crypto-browserify in quickcrypto v0.6
+// could instead fetch from OpenSSL if needed and handle breaking changes
+exports.getHashes = getHashes;
+const getCiphers = () => ['des-ecb', 'des', 'des-cbc', 'des3', 'des-ede3-cbc', 'des-ede3', 'des-ede-cbc', 'des-ede', 'aes-128-ecb', 'aes-192-ecb', 'aes-256-ecb', 'aes-128-cbc', 'aes-192-cbc', 'aes-256-cbc', 'aes128', 'aes192', 'aes256', 'aes-128-cfb', 'aes-192-cfb', 'aes-256-cfb', 'aes-128-cfb8', 'aes-192-cfb8', 'aes-256-cfb8', 'aes-128-cfb1', 'aes-192-cfb1', 'aes-256-cfb1', 'aes-128-ofb', 'aes-192-ofb', 'aes-256-ofb', 'aes-128-ctr', 'aes-192-ctr', 'aes-256-ctr', 'aes-128-gcm', 'aes-192-gcm', 'aes-256-gcm'];
+exports.getCiphers = getCiphers;
 //# sourceMappingURL=Utils.js.map