@libp2p/crypto 5.1.17 → 5.1.18-160a24585

package/src/ciphers/aes-gcm.browser.ts

@@ -1,6 +1,7 @@
 import { concat } from 'uint8arrays/concat'
 import { fromString } from 'uint8arrays/from-string'
-import webcrypto from '../webcrypto/index.js'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
+import webcrypto from '../webcrypto/index.ts'
 import type { CreateAESCipherOptions, AESCipher } from './interface.ts'
 
 // WebKit on Linux does not support deriving a key from an empty PBKDF2 key.
@@ -53,7 +54,7 @@ export function create (opts?: CreateAESCipherOptions): AESCipher {
       cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['encrypt'])
       try {
         const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
-        const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey'])
+        const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', withArrayBuffer(password), { name: 'PBKDF2' }, false, ['deriveKey'])
         cryptoKey = await crypto.subtle.deriveKey(deriveParams, runtimeDerivedEmptyPassword, { name: algorithm, length: keyLength }, true, ['encrypt'])
       } catch {
         cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['encrypt'])
@@ -61,12 +62,12 @@ export function create (opts?: CreateAESCipherOptions): AESCipher {
     } else {
       // Derive a key using PBKDF2.
       const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
-      const rawKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey'])
+      const rawKey = await crypto.subtle.importKey('raw', withArrayBuffer(password), { name: 'PBKDF2' }, false, ['deriveKey'])
       cryptoKey = await crypto.subtle.deriveKey(deriveParams, rawKey, { name: algorithm, length: keyLength }, true, ['encrypt'])
     }
 
     // Encrypt the string.
-    const ciphertext = await crypto.subtle.encrypt(aesGcm, cryptoKey, data)
+    const ciphertext = await crypto.subtle.encrypt(aesGcm, cryptoKey, withArrayBuffer(data))
     return concat([salt, aesGcm.iv, new Uint8Array(ciphertext)])
   }
 
@@ -90,7 +91,7 @@ export function create (opts?: CreateAESCipherOptions): AESCipher {
     if (password.length === 0) {
       try {
         const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
-        const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey'])
+        const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', withArrayBuffer(password), { name: 'PBKDF2' }, false, ['deriveKey'])
         cryptoKey = await crypto.subtle.deriveKey(deriveParams, runtimeDerivedEmptyPassword, { name: algorithm, length: keyLength }, true, ['decrypt'])
       } catch {
         cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['decrypt'])
@@ -98,12 +99,12 @@ export function create (opts?: CreateAESCipherOptions): AESCipher {
     } else {
       // Derive the key using PBKDF2.
       const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
-      const rawKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey'])
+      const rawKey = await crypto.subtle.importKey('raw', withArrayBuffer(password), { name: 'PBKDF2' }, false, ['deriveKey'])
       cryptoKey = await crypto.subtle.deriveKey(deriveParams, rawKey, { name: algorithm, length: keyLength }, true, ['decrypt'])
     }
 
     // Decrypt the string.
-    const plaintext = await crypto.subtle.decrypt(aesGcm, cryptoKey, ciphertext)
+    const plaintext = await crypto.subtle.decrypt(aesGcm, cryptoKey, withArrayBuffer(ciphertext))
     return new Uint8Array(plaintext)
   }
 

package/src/hmac/index.browser.ts

@@ -1,4 +1,5 @@
-import webcrypto from '../webcrypto/index.js'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
+import webcrypto from '../webcrypto/index.ts'
 import lengths from './lengths.ts'
 
 const hashTypes = {
@@ -8,7 +9,7 @@ const hashTypes = {
 }
 
 const sign = async (key: CryptoKey, data: Uint8Array): Promise<Uint8Array> => {
-  const buf = await webcrypto.get().subtle.sign({ name: 'HMAC' }, key, data)
+  const buf = await webcrypto.get().subtle.sign({ name: 'HMAC' }, key, withArrayBuffer(data))
   return new Uint8Array(buf, 0, buf.byteLength)
 }
 
@@ -17,7 +18,7 @@ export async function create (hashType: 'SHA1' | 'SHA256' | 'SHA512', secret: Ui
 
   const key = await webcrypto.get().subtle.importKey(
     'raw',
-    secret,
+    withArrayBuffer(secret),
     {
       name: 'HMAC',
       hash: { name: hash }

package/src/keys/ecdh/index.browser.ts

@@ -2,10 +2,10 @@ import { InvalidParametersError } from '@libp2p/interface'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { base64urlToBuffer } from '../../util.js'
-import webcrypto from '../../webcrypto/index.js'
+import { base64urlToBuffer } from '../../util.ts'
+import webcrypto from '../../webcrypto/index.ts'
 import type { Curve } from './index.ts'
-import type { ECDHKey, ECDHKeyPair, JWKEncodedPrivateKey, JWKEncodedPublicKey } from '../interface.js'
+import type { ECDHKey, ECDHKeyPair, JWKEncodedPrivateKey, JWKEncodedPublicKey } from '../interface.ts'
 
 const curveLengths = {
   'P-256': 32,

package/src/keys/ecdh/index.ts

@@ -1,6 +1,6 @@
 import crypto from 'crypto'
 import { InvalidParametersError } from '@libp2p/interface'
-import type { ECDHKey, ECDHKeyPair } from '../interface.js'
+import type { ECDHKey, ECDHKeyPair } from '../interface.ts'
 
 export type Curve = 'P-256' | 'P-384' | 'P-521'
 

package/src/keys/ecdsa/ecdsa.ts

@@ -2,7 +2,7 @@ import { base58btc } from 'multiformats/bases/base58'
 import { CID } from 'multiformats/cid'
 import { identity } from 'multiformats/hashes/identity'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { publicKeyToProtobuf } from '../index.js'
+import { publicKeyToProtobuf } from '../index.ts'
 import { hashAndVerify, hashAndSign } from './index.ts'
 import { privateKeyToPKIMessage, publicKeyToPKIMessage } from './utils.ts'
 import type { ECDSAPublicKey as ECDSAPublicKeyInterface, ECDSAPrivateKey as ECDSAPrivateKeyInterface, AbortOptions } from '@libp2p/interface'

package/src/keys/ecdsa/index.ts

@@ -1,4 +1,5 @@
-import type { JWKKeyPair } from '../interface.js'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
+import type { JWKKeyPair } from '../interface.ts'
 import type { AbortOptions } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -32,7 +33,7 @@ export async function hashAndSign (key: JsonWebKey, msg: Uint8Array | Uint8Array
     hash: {
       name: 'SHA-256'
     }
-  }, privateKey, msg.subarray())
+  }, privateKey, withArrayBuffer(msg.subarray()))
   options?.signal?.throwIfAborted()
 
   return new Uint8Array(signature, 0, signature.byteLength)
@@ -50,7 +51,7 @@ export async function hashAndVerify (key: JsonWebKey, sig: Uint8Array, msg: Uint
     hash: {
       name: 'SHA-256'
     }
-  }, publicKey, sig, msg.subarray())
+  }, publicKey, withArrayBuffer(sig), withArrayBuffer(msg.subarray()))
   options?.signal?.throwIfAborted()
 
   return result

package/src/keys/ecdsa/utils.ts

@@ -2,10 +2,10 @@ import { InvalidParametersError } from '@libp2p/interface'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { decodeDer, encodeBitString, encodeInteger, encodeOctetString, encodeSequence } from '../rsa/der.js'
+import { decodeDer, encodeBitString, encodeInteger, encodeOctetString, encodeSequence } from '../rsa/der.ts'
 import { ECDSAPrivateKey as ECDSAPrivateKeyClass, ECDSAPublicKey as ECDSAPublicKeyClass } from './ecdsa.ts'
 import { generateECDSAKey } from './index.ts'
-import type { Curve } from '../ecdh/index.js'
+import type { Curve } from '../ecdh/index.ts'
 import type { ECDSAPublicKey, ECDSAPrivateKey } from '@libp2p/interface'
 
 // 1.2.840.10045.3.1.7 prime256v1 (ANSI X9.62 named elliptic curve)

package/src/keys/ed25519/ed25519.ts

@@ -3,7 +3,7 @@ import { CID } from 'multiformats/cid'
 import { identity } from 'multiformats/hashes/identity'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { isPromise } from '../../util.ts'
-import { publicKeyToProtobuf } from '../index.js'
+import { publicKeyToProtobuf } from '../index.ts'
 import * as crypto from './index.ts'
 import { ensureEd25519Key } from './utils.ts'
 import type { Ed25519PublicKey as Ed25519PublicKeyInterface, Ed25519PrivateKey as Ed25519PrivateKeyInterface, AbortOptions } from '@libp2p/interface'

package/src/keys/ed25519/index.browser.ts

@@ -1,7 +1,8 @@
 import { ed25519 as ed } from '@noble/curves/ed25519.js'
 import { toString as uint8arrayToString } from 'uint8arrays/to-string'
-import crypto from '../../webcrypto/index.js'
-import type { Uint8ArrayKeyPair } from '../interface.js'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
+import crypto from '../../webcrypto/index.ts'
+import type { Uint8ArrayKeyPair } from '../interface.ts'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const PUBLIC_KEY_BYTE_LENGTH = 32
@@ -73,7 +74,7 @@ async function hashAndSignWebCrypto (privateKey: Uint8Array, msg: Uint8Array | U
   }
 
   const key = await crypto.get().subtle.importKey('jwk', jwk, { name: 'Ed25519' }, true, ['sign'])
-  const sig = await crypto.get().subtle.sign({ name: 'Ed25519' }, key, msg instanceof Uint8Array ? msg : msg.subarray())
+  const sig = await crypto.get().subtle.sign({ name: 'Ed25519' }, key, withArrayBuffer(msg instanceof Uint8Array ? msg : msg.subarray()))
 
   return new Uint8Array(sig, 0, sig.byteLength)
 }
@@ -99,7 +100,7 @@ export async function hashAndSign (privateKey: Uint8Array, msg: Uint8Array | Uin
 async function hashAndVerifyWebCrypto (publicKey: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): Promise<boolean> {
   if (publicKey.buffer instanceof ArrayBuffer) {
     const key = await crypto.get().subtle.importKey('raw', publicKey.buffer, { name: 'Ed25519' }, false, ['verify'])
-    const isValid = await crypto.get().subtle.verify({ name: 'Ed25519' }, key, sig, msg instanceof Uint8Array ? msg : msg.subarray())
+    const isValid = await crypto.get().subtle.verify({ name: 'Ed25519' }, key, withArrayBuffer(sig), withArrayBuffer(msg instanceof Uint8Array ? msg : msg.subarray()))
     return isValid
   }
 

package/src/keys/ed25519/index.ts

@@ -1,8 +1,9 @@
 import crypto from 'crypto'
+import { ed25519 as ed } from '@noble/curves/ed25519.js'
 import { concat as uint8arrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8arrayToString } from 'uint8arrays/to-string'
-import type { Uint8ArrayKeyPair } from '../interface.js'
+import type { Uint8ArrayKeyPair } from '../interface.ts'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const keypair = crypto.generateKeyPairSync
@@ -16,24 +17,7 @@ export { PUBLIC_KEY_BYTE_LENGTH as publicKeyLength }
 export { PRIVATE_KEY_BYTE_LENGTH as privateKeyLength }
 
 function derivePublicKey (privateKey: Uint8Array): Uint8Array {
-  const keyObject = crypto.createPrivateKey({
-    format: 'jwk',
-    key: {
-      crv: 'Ed25519',
-      x: '',
-      d: uint8arrayToString(privateKey, 'base64url'),
-      kty: 'OKP'
-    }
-  })
-  const jwk = keyObject.export({
-    format: 'jwk'
-  })
-
-  if (jwk.x == null || jwk.x === '') {
-    throw new Error('Could not export JWK public key')
-  }
-
-  return uint8arrayFromString(jwk.x, 'base64url')
+  return ed.getPublicKey(privateKey)
 }
 
 export function generateKey (): Uint8ArrayKeyPair {

package/src/keys/key-stretcher.ts

@@ -1,7 +1,7 @@
 import { InvalidParametersError } from '@libp2p/interface'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import * as hmac from '../hmac/index.js'
+import * as hmac from '../hmac/index.ts'
 import type { EnhancedKey, EnhancedKeyPair } from './interface.ts'
 
 interface Cipher {

package/src/keys/rsa/index.browser.ts

@@ -1,9 +1,10 @@
 import { InvalidParametersError } from '@libp2p/interface'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import randomBytes from '../../random-bytes.js'
-import webcrypto from '../../webcrypto/index.js'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
+import randomBytes from '../../random-bytes.ts'
+import webcrypto from '../../webcrypto/index.ts'
 import * as utils from './utils.ts'
-import type { JWKKeyPair } from '../interface.js'
+import type { JWKKeyPair } from '../interface.ts'
 import type { AbortOptions } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -49,7 +50,7 @@ export async function hashAndSign (key: JsonWebKey, msg: Uint8Array | Uint8Array
   const sig = await webcrypto.get().subtle.sign(
     { name: 'RSASSA-PKCS1-v1_5' },
     privateKey,
-    msg instanceof Uint8Array ? msg : msg.subarray()
+    withArrayBuffer(msg instanceof Uint8Array ? msg : msg.subarray())
   )
   options?.signal?.throwIfAborted()
 
@@ -72,8 +73,8 @@ export async function hashAndVerify (key: JsonWebKey, sig: Uint8Array, msg: Uint
   const result = await webcrypto.get().subtle.verify(
     { name: 'RSASSA-PKCS1-v1_5' },
     publicKey,
-    sig,
-    msg instanceof Uint8Array ? msg : msg.subarray()
+    withArrayBuffer(sig),
+    withArrayBuffer(msg instanceof Uint8Array ? msg : msg.subarray())
   )
   options?.signal?.throwIfAborted()
 

package/src/keys/rsa/index.ts

@@ -2,9 +2,9 @@ import crypto from 'node:crypto'
 import { promisify } from 'node:util'
 import { InvalidParametersError } from '@libp2p/interface'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import randomBytes from '../../random-bytes.js'
+import randomBytes from '../../random-bytes.ts'
 import * as utils from './utils.ts'
-import type { JWKKeyPair } from '../interface.js'
+import type { JWKKeyPair } from '../interface.ts'
 import type { AbortOptions } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 

package/src/keys/rsa/utils.ts

@@ -3,11 +3,11 @@ import { sha256 } from '@noble/hashes/sha2.js'
 import { create } from 'multiformats/hashes/digest'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import * as pb from '../keys.js'
+import * as pb from '../keys.ts'
 import { decodeDer, encodeBitString, encodeInteger, encodeSequence } from './der.ts'
 import { generateRSAKey, rsaKeySize } from './index.ts'
 import { RSAPrivateKey as RSAPrivateKeyClass, RSAPublicKey as RSAPublicKeyClass } from './rsa.ts'
-import type { JWKKeyPair } from '../interface.js'
+import type { JWKKeyPair } from '../interface.ts'
 import type { RSAPrivateKey, RSAPublicKey } from '@libp2p/interface'
 import type { Digest } from 'multiformats/hashes/digest'
 

package/src/keys/secp256k1/index.browser.ts

@@ -1,7 +1,7 @@
 import { secp256k1 as secp } from '@noble/curves/secp256k1.js'
 import { sha256 } from 'multiformats/hashes/sha2'
-import { SigningError, VerificationError } from '../../errors.js'
-import { isPromise } from '../../util.js'
+import { SigningError, VerificationError } from '../../errors.ts'
+import { isPromise } from '../../util.ts'
 import type { AbortOptions } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 

package/src/keys/secp256k1/index.ts

@@ -1,6 +1,6 @@
 import crypto from 'node:crypto'
 import { secp256k1 as secp } from '@noble/curves/secp256k1.js'
-import { SigningError, VerificationError } from '../../errors.js'
+import { SigningError, VerificationError } from '../../errors.ts'
 import type { AbortOptions } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 

package/src/keys/secp256k1/secp256k1.ts

@@ -2,7 +2,7 @@ import { base58btc } from 'multiformats/bases/base58'
 import { CID } from 'multiformats/cid'
 import { identity } from 'multiformats/hashes/identity'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { publicKeyToProtobuf } from '../index.js'
+import { publicKeyToProtobuf } from '../index.ts'
 import { hashAndVerify, hashAndSign } from './index.ts'
 import { validateSecp256k1PublicKey, compressSecp256k1PublicKey, computeSecp256k1PublicKey, validateSecp256k1PrivateKey } from './utils.ts'
 import type { Secp256k1PublicKey as Secp256k1PublicKeyInterface, Secp256k1PrivateKey as Secp256k1PrivateKeyInterface, AbortOptions } from '@libp2p/interface'

package/src/webcrypto/index.ts

@@ -1,3 +1,21 @@
-import webcrypto from './webcrypto.ts'
+import { WebCryptoMissingError } from '../errors.ts'
 
-export default webcrypto
+// Check native crypto exists and is enabled (in insecure browser contexts
+// `globalThis.crypto` exists but `globalThis.crypto.subtle` does not).
+export default {
+  get (win = globalThis): Crypto {
+    const nativeCrypto = win.crypto
+
+    if (nativeCrypto?.subtle == null) {
+      throw new WebCryptoMissingError(
+        'Missing Web Crypto API. ' +
+        'The most likely cause of this error is that this page is being accessed ' +
+        'from an insecure context (i.e. not HTTPS). For more information and ' +
+        'possible resolutions see ' +
+        'https://github.com/libp2p/js-libp2p/blob/main/packages/crypto/README.md#web-crypto-api'
+      )
+    }
+
+    return nativeCrypto
+  }
+}

package/dist/src/webcrypto/webcrypto.browser.d.ts

@@ -1,5 +0,0 @@
-declare const _default: {
-    get(win?: typeof globalThis): Crypto;
-};
-export default _default;
-//# sourceMappingURL=webcrypto.browser.d.ts.map

package/dist/src/webcrypto/webcrypto.browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webcrypto.browser.d.ts","sourceRoot":"","sources":["../../../src/webcrypto/webcrypto.browser.ts"],"names":[],"mappings":";;;AAMA,wBAgBC"}

package/dist/src/webcrypto/webcrypto.browser.js

@@ -1,18 +0,0 @@
-/* eslint-env browser */
-import { WebCryptoMissingError } from '../errors.js';
-// Check native crypto exists and is enabled (In insecure context `self.crypto`
-// exists but `self.crypto.subtle` does not).
-export default {
-    get(win = globalThis) {
-        const nativeCrypto = win.crypto;
-        if (nativeCrypto?.subtle == null) {
-            throw new WebCryptoMissingError('Missing Web Crypto API. ' +
-                'The most likely cause of this error is that this page is being accessed ' +
-                'from an insecure context (i.e. not HTTPS). For more information and ' +
-                'possible resolutions see ' +
-                'https://github.com/libp2p/js-libp2p/blob/main/packages/crypto/README.md#web-crypto-api');
-        }
-        return nativeCrypto;
-    }
-};
-//# sourceMappingURL=webcrypto.browser.js.map

package/dist/src/webcrypto/webcrypto.browser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"webcrypto.browser.js","sourceRoot":"","sources":["../../../src/webcrypto/webcrypto.browser.ts"],"names":[],"mappings":"AAAA,wBAAwB;AAExB,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAEpD,+EAA+E;AAC/E,6CAA6C;AAC7C,eAAe;IACb,GAAG,CAAE,GAAG,GAAG,UAAU;QACnB,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAA;QAE/B,IAAI,YAAY,EAAE,MAAM,IAAI,IAAI,EAAE,CAAC;YACjC,MAAM,IAAI,qBAAqB,CAC7B,0BAA0B;gBAC1B,0EAA0E;gBAC1E,sEAAsE;gBACtE,2BAA2B;gBAC3B,wFAAwF,CACzF,CAAA;QACH,CAAC;QAED,OAAO,YAAY,CAAA;IACrB,CAAC;CACF,CAAA"}

package/dist/src/webcrypto/webcrypto.d.ts

@@ -1,6 +0,0 @@
-import { webcrypto } from 'crypto';
-declare const _default: {
-    get(win?: typeof globalThis): webcrypto.Crypto;
-};
-export default _default;
-//# sourceMappingURL=webcrypto.d.ts.map

package/dist/src/webcrypto/webcrypto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webcrypto.d.ts","sourceRoot":"","sources":["../../../src/webcrypto/webcrypto.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;;;;AAIlC,wBAIC"}

package/dist/src/webcrypto/webcrypto.js

@@ -1,10 +0,0 @@
-/* eslint-env browser */
-import { webcrypto } from 'crypto';
-// globalThis `SubtleCrypto` shipped in node.js 19.x, Electron currently uses
-// v18.x so this override file is necessary until Electron updates
-export default {
-    get(win = globalThis) {
-        return webcrypto;
-    }
-};
-//# sourceMappingURL=webcrypto.js.map

package/dist/src/webcrypto/webcrypto.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"webcrypto.js","sourceRoot":"","sources":["../../../src/webcrypto/webcrypto.ts"],"names":[],"mappings":"AAAA,wBAAwB;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAElC,6EAA6E;AAC7E,kEAAkE;AAClE,eAAe;IACb,GAAG,CAAE,GAAG,GAAG,UAAU;QACnB,OAAO,SAAS,CAAA;IAClB,CAAC;CACF,CAAA"}

package/dist/typedoc-urls.json

@@ -1,40 +0,0 @@
-{
-  "AESCipher": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_crypto.ciphers.AES_GCM.AESCipher.html",
-  "CreateAESCipherOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_crypto.ciphers.AES_GCM.CreateAESCipherOptions.html",
-  "create": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.ciphers.AES_GCM.create.html",
-  "HMAC": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_crypto.hmac.HMAC.html",
-  "./hmac:HMAC": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_crypto.hmac.HMAC.html",
-  "./hmac:create": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.hmac.create.html",
-  "pbkdf2": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.index.pbkdf2.html",
-  "randomBytes": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.index.randomBytes.html",
-  "ECDHKey": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_crypto.keys.ECDHKey.html",
-  "ECDHKeyPair": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_crypto.keys.ECDHKeyPair.html",
-  "EnhancedKey": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_crypto.keys.EnhancedKey.html",
-  "EnhancedKeyPair": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_crypto.keys.EnhancedKeyPair.html",
-  "Curve": "https://libp2p.github.io/js-libp2p/types/_libp2p_crypto.keys.Curve.html",
-  "generateEphemeralKeyPair": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.generateEphemeralKeyPair.html",
-  "generateKeyPair": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.generateKeyPair.html",
-  "./keys:generateKeyPair": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.generateKeyPair.html",
-  "generateKeyPairFromSeed": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.generateKeyPairFromSeed.html",
-  "./keys:generateKeyPairFromSeed": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.generateKeyPairFromSeed.html",
-  "keyStretcher": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.keyStretcher.html",
-  "privateKeyFromCryptoKeyPair": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyFromCryptoKeyPair.html",
-  "./keys:privateKeyFromCryptoKeyPair": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyFromCryptoKeyPair.html",
-  "privateKeyFromProtobuf": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyFromProtobuf.html",
-  "./keys:privateKeyFromProtobuf": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyFromProtobuf.html",
-  "privateKeyFromRaw": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyFromRaw.html",
-  "./keys:privateKeyFromRaw": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyFromRaw.html",
-  "privateKeyToCryptoKeyPair": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyToCryptoKeyPair.html",
-  "./keys:privateKeyToCryptoKeyPair": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyToCryptoKeyPair.html",
-  "privateKeyToProtobuf": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyToProtobuf.html",
-  "./keys:privateKeyToProtobuf": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.privateKeyToProtobuf.html",
-  "publicKeyFromMultihash": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.publicKeyFromMultihash.html",
-  "./keys:publicKeyFromMultihash": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.publicKeyFromMultihash.html",
-  "publicKeyFromProtobuf": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.publicKeyFromProtobuf.html",
-  "./keys:publicKeyFromProtobuf": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.publicKeyFromProtobuf.html",
-  "publicKeyFromRaw": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.publicKeyFromRaw.html",
-  "./keys:publicKeyFromRaw": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.publicKeyFromRaw.html",
-  "publicKeyToProtobuf": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.publicKeyToProtobuf.html",
-  "./keys:publicKeyToProtobuf": "https://libp2p.github.io/js-libp2p/functions/_libp2p_crypto.keys.publicKeyToProtobuf.html",
-  "default": "https://libp2p.github.io/js-libp2p/variables/_libp2p_crypto.webcrypto.default.html"
-}

package/src/webcrypto/webcrypto.browser.ts

@@ -1,23 +0,0 @@
-/* eslint-env browser */
-
-import { WebCryptoMissingError } from '../errors.js'
-
-// Check native crypto exists and is enabled (In insecure context `self.crypto`
-// exists but `self.crypto.subtle` does not).
-export default {
-  get (win = globalThis) {
-    const nativeCrypto = win.crypto
-
-    if (nativeCrypto?.subtle == null) {
-      throw new WebCryptoMissingError(
-        'Missing Web Crypto API. ' +
-        'The most likely cause of this error is that this page is being accessed ' +
-        'from an insecure context (i.e. not HTTPS). For more information and ' +
-        'possible resolutions see ' +
-        'https://github.com/libp2p/js-libp2p/blob/main/packages/crypto/README.md#web-crypto-api'
-      )
-    }
-
-    return nativeCrypto
-  }
-}

package/src/webcrypto/webcrypto.ts

@@ -1,11 +0,0 @@
-/* eslint-env browser */
-
-import { webcrypto } from 'crypto'
-
-// globalThis `SubtleCrypto` shipped in node.js 19.x, Electron currently uses
-// v18.x so this override file is necessary until Electron updates
-export default {
-  get (win = globalThis) {
-    return webcrypto
-  }
-}