web-dc-api 0.0.58 → 0.0.59

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/rsa/der.js

@@ -0,0 +1,187 @@
+'use strict';
+
+var index = require('../../../../../../uint8arraylist/dist/src/index.js');
+
+const TAG_MASK = parseInt('11111', 2);
+const LONG_LENGTH_MASK = parseInt('10000000', 2);
+const LONG_LENGTH_BYTES_MASK = parseInt('01111111', 2);
+const decoders = {
+  0x0: readSequence,
+  0x1: readSequence,
+  0x2: readInteger,
+  0x3: readBitString,
+  0x4: readOctetString,
+  0x5: readNull,
+  0x6: readObjectIdentifier,
+  0x10: readSequence,
+  0x16: readSequence,
+  0x30: readSequence
+};
+function decodeDer(buf) {
+  let context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    offset: 0
+  };
+  const tag = buf[context.offset] & TAG_MASK;
+  context.offset++;
+  if (decoders[tag] != null) {
+    return decoders[tag](buf, context);
+  }
+  throw new Error('No decoder for tag ' + tag);
+}
+function readLength(buf, context) {
+  let length = 0;
+  if ((buf[context.offset] & LONG_LENGTH_MASK) === LONG_LENGTH_MASK) {
+    // long length
+    const count = buf[context.offset] & LONG_LENGTH_BYTES_MASK;
+    let str = '0x';
+    context.offset++;
+    for (let i = 0; i < count; i++, context.offset++) {
+      str += buf[context.offset].toString(16).padStart(2, '0');
+    }
+    length = parseInt(str, 16);
+  } else {
+    length = buf[context.offset];
+    context.offset++;
+  }
+  return length;
+}
+function readSequence(buf, context) {
+  readLength(buf, context);
+  const entries = [];
+  while (true) {
+    if (context.offset >= buf.byteLength) {
+      break;
+    }
+    const result = decodeDer(buf, context);
+    if (result === null) {
+      break;
+    }
+    entries.push(result);
+  }
+  return entries;
+}
+function readInteger(buf, context) {
+  const length = readLength(buf, context);
+  const start = context.offset;
+  const end = context.offset + length;
+  const vals = [];
+  for (let i = start; i < end; i++) {
+    if (i === start && buf[i] === 0) {
+      continue;
+    }
+    vals.push(buf[i]);
+  }
+  context.offset += length;
+  return Uint8Array.from(vals);
+}
+function readObjectIdentifier(buf, context) {
+  const count = readLength(buf, context);
+  const finalOffset = context.offset + count;
+  const byte = buf[context.offset];
+  context.offset++;
+  let val1 = 0;
+  let val2 = 0;
+  if (byte < 40) {
+    val1 = 0;
+    val2 = byte;
+  } else if (byte < 80) {
+    val1 = 1;
+    val2 = byte - 40;
+  } else {
+    val1 = 2;
+    val2 = byte - 80;
+  }
+  let oid = `${val1}.${val2}`;
+  let num = [];
+  while (context.offset < finalOffset) {
+    const byte = buf[context.offset];
+    context.offset++;
+    // remove msb
+    num.push(byte & 0b01111111);
+    if (byte < 128) {
+      num.reverse();
+      // reached the end of the encoding
+      let val = 0;
+      for (let i = 0; i < num.length; i++) {
+        val += num[i] << i * 7;
+      }
+      oid += `.${val}`;
+      num = [];
+    }
+  }
+  return oid;
+}
+function readNull(buf, context) {
+  context.offset++;
+  return null;
+}
+function readBitString(buf, context) {
+  const length = readLength(buf, context);
+  const unusedBits = buf[context.offset];
+  context.offset++;
+  const bytes = buf.subarray(context.offset, context.offset + length - 1);
+  context.offset += length;
+  if (unusedBits !== 0) {
+    // need to shift all bytes along by this many bits
+    throw new Error('Unused bits in bit string is unimplemented');
+  }
+  return bytes;
+}
+function readOctetString(buf, context) {
+  const length = readLength(buf, context);
+  const bytes = buf.subarray(context.offset, context.offset + length);
+  context.offset += length;
+  return bytes;
+}
+function encodeNumber(value) {
+  let number = value.toString(16);
+  if (number.length % 2 === 1) {
+    number = '0' + number;
+  }
+  const array = new index.Uint8ArrayList();
+  for (let i = 0; i < number.length; i += 2) {
+    array.append(Uint8Array.from([parseInt(`${number[i]}${number[i + 1]}`, 16)]));
+  }
+  return array;
+}
+function encodeLength(bytes) {
+  if (bytes.byteLength < 128) {
+    return Uint8Array.from([bytes.byteLength]);
+  }
+  // long length
+  const length = encodeNumber(bytes.byteLength);
+  return new index.Uint8ArrayList(Uint8Array.from([length.byteLength | LONG_LENGTH_MASK]), length);
+}
+function encodeInteger(value) {
+  const contents = new index.Uint8ArrayList();
+  const mask = 0b10000000;
+  const positive = (value.subarray()[0] & mask) === mask;
+  if (positive) {
+    contents.append(Uint8Array.from([0]));
+  }
+  contents.append(value);
+  return new index.Uint8ArrayList(Uint8Array.from([0x02]), encodeLength(contents), contents);
+}
+function encodeBitString(value) {
+  // unused bits is always 0 with full-byte-only values
+  const unusedBits = Uint8Array.from([0]);
+  const contents = new index.Uint8ArrayList(unusedBits, value);
+  return new index.Uint8ArrayList(Uint8Array.from([0x03]), encodeLength(contents), contents);
+}
+function encodeOctetString(value) {
+  return new index.Uint8ArrayList(Uint8Array.from([0x04]), encodeLength(value), value);
+}
+function encodeSequence(values) {
+  let tag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0x30;
+  const output = new index.Uint8ArrayList();
+  for (const buf of values) {
+    output.append(buf);
+  }
+  return new index.Uint8ArrayList(Uint8Array.from([tag]), encodeLength(output), output);
+}
+
+exports.decodeDer = decodeDer;
+exports.encodeBitString = encodeBitString;
+exports.encodeInteger = encodeInteger;
+exports.encodeOctetString = encodeOctetString;
+exports.encodeSequence = encodeSequence;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/rsa/index.browser.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var fromString = require('../../../../../../uint8arrays/dist/src/from-string.js');
+var webcrypto_browser = require('../../webcrypto/webcrypto.browser.js');
+
+const RSAES_PKCS1_V1_5_OID = '1.2.840.113549.1.1.1';
+async function hashAndSign(key, msg) {
+  const privateKey = await webcrypto_browser.default.get().subtle.importKey('jwk', key, {
+    name: 'RSASSA-PKCS1-v1_5',
+    hash: {
+      name: 'SHA-256'
+    }
+  }, false, ['sign']);
+  const sig = await webcrypto_browser.default.get().subtle.sign({
+    name: 'RSASSA-PKCS1-v1_5'
+  }, privateKey, msg instanceof Uint8Array ? msg : msg.subarray());
+  return new Uint8Array(sig, 0, sig.byteLength);
+}
+async function hashAndVerify(key, sig, msg) {
+  const publicKey = await webcrypto_browser.default.get().subtle.importKey('jwk', key, {
+    name: 'RSASSA-PKCS1-v1_5',
+    hash: {
+      name: 'SHA-256'
+    }
+  }, false, ['verify']);
+  return webcrypto_browser.default.get().subtle.verify({
+    name: 'RSASSA-PKCS1-v1_5'
+  }, publicKey, sig, msg instanceof Uint8Array ? msg : msg.subarray());
+}
+function rsaKeySize(jwk) {
+  if (jwk.kty !== 'RSA') {
+    throw new _interface.InvalidParametersError('invalid key type');
+  } else if (jwk.n == null) {
+    throw new _interface.InvalidParametersError('invalid key modulus');
+  }
+  const bytes = fromString.fromString(jwk.n, 'base64url');
+  return bytes.length * 8;
+}
+
+exports.RSAES_PKCS1_V1_5_OID = RSAES_PKCS1_V1_5_OID;
+exports.hashAndSign = hashAndSign;
+exports.hashAndVerify = hashAndVerify;
+exports.rsaKeySize = rsaKeySize;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/rsa/rsa.js

@@ -0,0 +1,70 @@
+'use strict';
+
+var base58 = require('../../../../../../multiformats/dist/src/bases/base58.js');
+var cid = require('../../../../../../multiformats/dist/src/cid.js');
+var equals = require('../../../../../../uint8arrays/dist/src/equals.js');
+var index_browser = require('./index.browser.js');
+var utils = require('./utils.js');
+
+class RSAPublicKey {
+  type = 'RSA';
+  jwk;
+  _raw;
+  _multihash;
+  constructor(jwk, digest) {
+    this.jwk = jwk;
+    this._multihash = digest;
+  }
+  get raw() {
+    if (this._raw == null) {
+      this._raw = utils.jwkToPkix(this.jwk);
+    }
+    return this._raw;
+  }
+  toMultihash() {
+    return this._multihash;
+  }
+  toCID() {
+    return cid.CID.createV1(114, this._multihash);
+  }
+  toString() {
+    return base58.base58btc.encode(this.toMultihash().bytes).substring(1);
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals.equals(this.raw, key.raw);
+  }
+  verify(data, sig) {
+    return index_browser.hashAndVerify(this.jwk, sig, data);
+  }
+}
+class RSAPrivateKey {
+  type = 'RSA';
+  jwk;
+  _raw;
+  publicKey;
+  constructor(jwk, publicKey) {
+    this.jwk = jwk;
+    this.publicKey = publicKey;
+  }
+  get raw() {
+    if (this._raw == null) {
+      this._raw = utils.jwkToPkcs1(this.jwk);
+    }
+    return this._raw;
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals.equals(this.raw, key.raw);
+  }
+  sign(message) {
+    return index_browser.hashAndSign(this.jwk, message);
+  }
+}
+
+exports.RSAPrivateKey = RSAPrivateKey;
+exports.RSAPublicKey = RSAPublicKey;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/rsa/utils.js

@@ -0,0 +1,132 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var sha256 = require('../../../../../../@noble/hashes/esm/sha256.js');
+var digest = require('../../../../../../multiformats/dist/src/hashes/digest.js');
+var fromString = require('../../../../../../uint8arrays/dist/src/from-string.js');
+var toString = require('../../../../../../uint8arrays/dist/src/to-string.js');
+var keys = require('../keys.js');
+var der = require('./der.js');
+var rsa = require('./rsa.js');
+var index_browser = require('./index.browser.js');
+
+const MAX_RSA_KEY_SIZE = 8192;
+const SHA2_256_CODE = 0x12;
+const MAX_RSA_JWK_SIZE = 1062;
+const RSA_ALGORITHM_IDENTIFIER = Uint8Array.from([0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00]);
+/**
+ * Convert a PKCS#1 in ASN1 DER format to a JWK private key
+ */
+function pkcs1MessageToJwk(message) {
+  return {
+    n: toString.toString(message[1], 'base64url'),
+    e: toString.toString(message[2], 'base64url'),
+    d: toString.toString(message[3], 'base64url'),
+    p: toString.toString(message[4], 'base64url'),
+    q: toString.toString(message[5], 'base64url'),
+    dp: toString.toString(message[6], 'base64url'),
+    dq: toString.toString(message[7], 'base64url'),
+    qi: toString.toString(message[8], 'base64url'),
+    kty: 'RSA'
+  };
+}
+/**
+ * Convert a JWK private key into PKCS#1 in ASN1 DER format
+ */
+function jwkToPkcs1(jwk) {
+  if (jwk.n == null || jwk.e == null || jwk.d == null || jwk.p == null || jwk.q == null || jwk.dp == null || jwk.dq == null || jwk.qi == null) {
+    throw new _interface.InvalidParametersError('JWK was missing components');
+  }
+  return der.encodeSequence([der.encodeInteger(Uint8Array.from([0])), der.encodeInteger(fromString.fromString(jwk.n, 'base64url')), der.encodeInteger(fromString.fromString(jwk.e, 'base64url')), der.encodeInteger(fromString.fromString(jwk.d, 'base64url')), der.encodeInteger(fromString.fromString(jwk.p, 'base64url')), der.encodeInteger(fromString.fromString(jwk.q, 'base64url')), der.encodeInteger(fromString.fromString(jwk.dp, 'base64url')), der.encodeInteger(fromString.fromString(jwk.dq, 'base64url')), der.encodeInteger(fromString.fromString(jwk.qi, 'base64url'))]).subarray();
+}
+function pkixMessageToJwk(message) {
+  const keys = der.decodeDer(message[1], {
+    offset: 0
+  });
+  // this looks fragile but DER is a canonical format so we are safe to have
+  // deeply property chains like this
+  return {
+    kty: 'RSA',
+    n: toString.toString(keys[0], 'base64url'),
+    e: toString.toString(keys[1], 'base64url')
+  };
+}
+/**
+ * Convert a JWK public key to PKIX in ASN1 DER format
+ */
+function jwkToPkix(jwk) {
+  if (jwk.n == null || jwk.e == null) {
+    throw new _interface.InvalidParametersError('JWK was missing components');
+  }
+  const subjectPublicKeyInfo = der.encodeSequence([RSA_ALGORITHM_IDENTIFIER, der.encodeBitString(der.encodeSequence([der.encodeInteger(fromString.fromString(jwk.n, 'base64url')), der.encodeInteger(fromString.fromString(jwk.e, 'base64url'))]))]);
+  return subjectPublicKeyInfo.subarray();
+}
+/**
+ * Turn PKCS#1 DER bytes into a PrivateKey
+ */
+function pkcs1MessageToRSAPrivateKey(message) {
+  const jwk = pkcs1MessageToJwk(message);
+  return jwkToRSAPrivateKey(jwk);
+}
+/**
+ * Turn a PKIX message into a PublicKey
+ */
+function pkixToRSAPublicKey(bytes, digest) {
+  if (bytes.byteLength >= MAX_RSA_JWK_SIZE) {
+    throw new _interface.InvalidPublicKeyError('Key size is too large');
+  }
+  const message = der.decodeDer(bytes, {
+    offset: 0
+  });
+  return pkixMessageToRSAPublicKey(message, bytes, digest);
+}
+function pkixMessageToRSAPublicKey(message, bytes, digest$1) {
+  const jwk = pkixMessageToJwk(message);
+  if (digest$1 == null) {
+    const hash = sha256.sha256(keys.PublicKey.encode({
+      Type: keys.KeyType.RSA,
+      Data: bytes
+    }));
+    digest$1 = digest.create(SHA2_256_CODE, hash);
+  }
+  return new rsa.RSAPublicKey(jwk, digest$1);
+}
+function jwkToRSAPrivateKey(jwk) {
+  if (index_browser.rsaKeySize(jwk) > MAX_RSA_KEY_SIZE) {
+    throw new _interface.InvalidParametersError('Key size is too large');
+  }
+  const keys$1 = jwkToJWKKeyPair(jwk);
+  const hash = sha256.sha256(keys.PublicKey.encode({
+    Type: keys.KeyType.RSA,
+    Data: jwkToPkix(keys$1.publicKey)
+  }));
+  const digest$1 = digest.create(SHA2_256_CODE, hash);
+  return new rsa.RSAPrivateKey(keys$1.privateKey, new rsa.RSAPublicKey(keys$1.publicKey, digest$1));
+}
+/**
+ * Takes a jwk key and returns a JWK KeyPair
+ */
+function jwkToJWKKeyPair(key) {
+  if (key == null) {
+    throw new _interface.InvalidParametersError('Missing key parameter');
+  }
+  return {
+    privateKey: key,
+    publicKey: {
+      kty: key.kty,
+      n: key.n,
+      e: key.e
+    }
+  };
+}
+
+exports.MAX_RSA_KEY_SIZE = MAX_RSA_KEY_SIZE;
+exports.jwkToJWKKeyPair = jwkToJWKKeyPair;
+exports.jwkToPkcs1 = jwkToPkcs1;
+exports.jwkToPkix = jwkToPkix;
+exports.jwkToRSAPrivateKey = jwkToRSAPrivateKey;
+exports.pkcs1MessageToJwk = pkcs1MessageToJwk;
+exports.pkcs1MessageToRSAPrivateKey = pkcs1MessageToRSAPrivateKey;
+exports.pkixMessageToJwk = pkixMessageToJwk;
+exports.pkixMessageToRSAPublicKey = pkixMessageToRSAPublicKey;
+exports.pkixToRSAPublicKey = pkixToRSAPublicKey;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/secp256k1/index.browser.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var secp256k1 = require('../../../../../../@noble/curves/esm/secp256k1.js');
+var sha2Browser = require('../../../../../../multiformats/dist/src/hashes/sha2-browser.js');
+var errors = require('../../errors.js');
+var util = require('../../util.js');
+
+const PUBLIC_KEY_BYTE_LENGTH = 33;
+const PRIVATE_KEY_BYTE_LENGTH = 32;
+/**
+ * Hash and sign message with private key
+ */
+function hashAndSign(key, msg) {
+  const p = sha2Browser.sha256.digest(msg instanceof Uint8Array ? msg : msg.subarray());
+  if (util.isPromise(p)) {
+    return p.then(_ref => {
+      let {
+        digest
+      } = _ref;
+      return secp256k1.secp256k1.sign(digest, key).toDERRawBytes();
+    }).catch(err => {
+      throw new errors.SigningError(String(err));
+    });
+  }
+  try {
+    return secp256k1.secp256k1.sign(p.digest, key).toDERRawBytes();
+  } catch (err) {
+    throw new errors.SigningError(String(err));
+  }
+}
+/**
+ * Hash message and verify signature with public key
+ */
+function hashAndVerify(key, sig, msg) {
+  const p = sha2Browser.sha256.digest(msg instanceof Uint8Array ? msg : msg.subarray());
+  if (util.isPromise(p)) {
+    return p.then(_ref2 => {
+      let {
+        digest
+      } = _ref2;
+      return secp256k1.secp256k1.verify(sig, digest, key);
+    }).catch(err => {
+      throw new errors.VerificationError(String(err));
+    });
+  }
+  try {
+    return secp256k1.secp256k1.verify(sig, p.digest, key);
+  } catch (err) {
+    throw new errors.VerificationError(String(err));
+  }
+}
+
+exports.hashAndSign = hashAndSign;
+exports.hashAndVerify = hashAndVerify;
+exports.privateKeyLength = PRIVATE_KEY_BYTE_LENGTH;
+exports.publicKeyLength = PUBLIC_KEY_BYTE_LENGTH;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/secp256k1/secp256k1.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var base58 = require('../../../../../../multiformats/dist/src/bases/base58.js');
+var cid = require('../../../../../../multiformats/dist/src/cid.js');
+var identity = require('../../../../../../multiformats/dist/src/hashes/identity.js');
+var equals = require('../../../../../../uint8arrays/dist/src/equals.js');
+var index = require('../index.js');
+var utils = require('./utils.js');
+var index_browser = require('./index.browser.js');
+
+class Secp256k1PublicKey {
+  type = 'secp256k1';
+  raw;
+  _key;
+  constructor(key) {
+    this._key = utils.validateSecp256k1PublicKey(key);
+    this.raw = utils.compressSecp256k1PublicKey(this._key);
+  }
+  toMultihash() {
+    return identity.identity.digest(index.publicKeyToProtobuf(this));
+  }
+  toCID() {
+    return cid.CID.createV1(114, this.toMultihash());
+  }
+  toString() {
+    return base58.base58btc.encode(this.toMultihash().bytes).substring(1);
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals.equals(this.raw, key.raw);
+  }
+  verify(data, sig) {
+    return index_browser.hashAndVerify(this._key, sig, data);
+  }
+}
+class Secp256k1PrivateKey {
+  type = 'secp256k1';
+  raw;
+  publicKey;
+  constructor(key, publicKey) {
+    this.raw = utils.validateSecp256k1PrivateKey(key);
+    this.publicKey = new Secp256k1PublicKey(publicKey ?? utils.computeSecp256k1PublicKey(key));
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals.equals(this.raw, key.raw);
+  }
+  sign(message) {
+    return index_browser.hashAndSign(this.raw, message);
+  }
+}
+
+exports.Secp256k1PrivateKey = Secp256k1PrivateKey;
+exports.Secp256k1PublicKey = Secp256k1PublicKey;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/secp256k1/utils.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var secp256k1$1 = require('../../../../../../@noble/curves/esm/secp256k1.js');
+var secp256k1 = require('./secp256k1.js');
+
+function unmarshalSecp256k1PrivateKey(bytes) {
+  return new secp256k1.Secp256k1PrivateKey(bytes);
+}
+function unmarshalSecp256k1PublicKey(bytes) {
+  return new secp256k1.Secp256k1PublicKey(bytes);
+}
+function compressSecp256k1PublicKey(key) {
+  const point = secp256k1$1.secp256k1.ProjectivePoint.fromHex(key).toRawBytes(true);
+  return point;
+}
+function validateSecp256k1PrivateKey(key) {
+  try {
+    secp256k1$1.secp256k1.getPublicKey(key, true);
+    return key;
+  } catch (err) {
+    throw new _interface.InvalidPrivateKeyError(String(err));
+  }
+}
+function validateSecp256k1PublicKey(key) {
+  try {
+    secp256k1$1.secp256k1.ProjectivePoint.fromHex(key);
+    return key;
+  } catch (err) {
+    throw new _interface.InvalidPublicKeyError(String(err));
+  }
+}
+function computeSecp256k1PublicKey(privateKey) {
+  try {
+    return secp256k1$1.secp256k1.getPublicKey(privateKey, true);
+  } catch (err) {
+    throw new _interface.InvalidPrivateKeyError(String(err));
+  }
+}
+
+exports.compressSecp256k1PublicKey = compressSecp256k1PublicKey;
+exports.computeSecp256k1PublicKey = computeSecp256k1PublicKey;
+exports.unmarshalSecp256k1PrivateKey = unmarshalSecp256k1PrivateKey;
+exports.unmarshalSecp256k1PublicKey = unmarshalSecp256k1PublicKey;
+exports.validateSecp256k1PrivateKey = validateSecp256k1PrivateKey;
+exports.validateSecp256k1PublicKey = validateSecp256k1PublicKey;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/util.js

@@ -0,0 +1,23 @@
+'use strict';
+
+require('../../../../multiformats/dist/src/bases/base10.js');
+require('../../../../multiformats/dist/src/bases/base16.js');
+require('../../../../multiformats/dist/src/bases/base2.js');
+require('../../../../multiformats/dist/src/bases/base256emoji.js');
+require('../../../../multiformats/dist/src/bases/base32.js');
+require('../../../../multiformats/dist/src/bases/base36.js');
+require('../../../../multiformats/dist/src/bases/base58.js');
+require('../../../../multiformats/dist/src/bases/base64.js');
+require('../../../../multiformats/dist/src/bases/base8.js');
+require('../../../../multiformats/dist/src/bases/identity.js');
+require('../../../../multiformats/dist/src/codecs/json.js');
+require('../../../../multiformats/dist/src/hashes/sha2-browser.js');
+
+function isPromise(thing) {
+  if (thing == null) {
+    return false;
+  }
+  return typeof thing.then === 'function' && typeof thing.catch === 'function' && typeof thing.finally === 'function';
+}
+
+exports.isPromise = isPromise;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/webcrypto/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var webcrypto_browser = require('./webcrypto.browser.js');
+
+
+
+exports.default = webcrypto_browser.default;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/webcrypto/webcrypto.browser.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('../errors.js');
+
+/* eslint-env browser */
+// Check native crypto exists and is enabled (In insecure context `self.crypto`
+// exists but `self.crypto.subtle` does not).
+var webcrypto = {
+  get() {
+    let win = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : globalThis;
+    const nativeCrypto = win.crypto;
+    if (nativeCrypto?.subtle == null) {
+      throw new errors.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;
+  }
+};
+
+exports.default = webcrypto;