web-dc-api 0.0.60 → 0.0.62

package/dist/cjs/node_modules/@multiformats/multiaddr-matcher/dist/src/index.js

@@ -50,7 +50,7 @@ var utils = require('./utils.js');
  * ```
  */
 const _PEER_ID = utils.peerId();
-utils.fmt(_PEER_ID);
+const PEER_ID = utils.fmt(_PEER_ID);
 /**
  * DNS matchers
  */
@@ -156,7 +156,7 @@ const IP_OR_DOMAIN = utils.fmt(utils.or(_IP, utils.and(utils.or(_DNS, _DNSADDR,
  * IP4.matches(ma) // true
  * ```
  */
-utils.fmt(_IP4);
+const IP4 = utils.fmt(_IP4);
 /**
  * Matches ip6 addresses.
  *
@@ -173,7 +173,7 @@ utils.fmt(_IP4);
  * IP6.matches(ma) // true
  * ```
  */
-utils.fmt(_IP6);
+const IP6 = utils.fmt(_IP6);
 /**
  * Matches ip4 or ip6 addresses.
  *
@@ -244,7 +244,7 @@ utils.fmt(_QUIC);
  * QUICV1.matches(multiaddr('/ip4/123.123.123.123/udp/1234/quic-v1')) // true
  * ```
  */
-utils.fmt(_QUICV1);
+const QUICV1 = utils.fmt(_QUICV1);
 const _WEB = utils.or(_IP_OR_DOMAIN, _TCP, _UDP, _QUIC, _QUICV1);
 const _WebSockets = utils.or(utils.and(_WEB, utils.literal('ws'), utils.optional(utils.peerId())));
 /**
@@ -259,7 +259,7 @@ const _WebSockets = utils.or(utils.and(_WEB, utils.literal('ws'), utils.optional
  * WebSockets.matches(multiaddr('/ip4/123.123.123.123/tcp/1234/ws')) // true
  * ```
  */
-utils.fmt(_WebSockets);
+const WebSockets = utils.fmt(_WebSockets);
 const _WebSocketsSecure = utils.or(utils.and(_WEB, utils.literal('wss'), utils.optional(utils.peerId())), utils.and(_WEB, utils.literal('tls'), utils.optional(utils.and(utils.literal('sni'), utils.string())), utils.literal('ws'), utils.optional(utils.peerId())));
 /**
  * Matches secure WebSocket addresses.
@@ -273,7 +273,7 @@ const _WebSocketsSecure = utils.or(utils.and(_WEB, utils.literal('wss'), utils.o
  * WebSocketsSecure.matches(multiaddr('/ip4/123.123.123.123/tcp/1234/wss')) // true
  * ```
  */
-utils.fmt(_WebSocketsSecure);
+const WebSocketsSecure = utils.fmt(_WebSocketsSecure);
 const _WebRTCDirect = utils.and(_UDP, utils.literal('webrtc-direct'), utils.optional(utils.certhash()), utils.optional(utils.certhash()), utils.optional(utils.peerId()));
 /**
  * Matches WebRTC-direct addresses.
@@ -301,7 +301,7 @@ const _WebTransport = utils.and(_QUICV1, utils.literal('webtransport'), utils.op
  * WebRTCDirect.matches(multiaddr('/ip4/123.123.123.123/udp/1234/quic-v1/webtransport/certhash/u..../certhash/u..../p2p/QmFoo')) // true
  * ```
  */
-utils.fmt(_WebTransport);
+const WebTransport = utils.fmt(_WebTransport);
 const _P2P = utils.or(_WebSockets, _WebSocketsSecure, utils.and(_TCP, utils.optional(utils.peerId())), utils.and(QUIC_V0_OR_V1, utils.optional(utils.peerId())), utils.and(_IP_OR_DOMAIN, utils.optional(utils.peerId())), _WebRTCDirect, _WebTransport, utils.peerId());
 /**
  * Matches peer addresses
@@ -357,7 +357,7 @@ const _HTTP = utils.or(utils.and(_IP_OR_DOMAIN, utils.literal('tcp'), utils.numb
  * HTTP.matches(multiaddr('/dns/example.org/http')) // true
  * ```
  */
-utils.fmt(_HTTP);
+const HTTP = utils.fmt(_HTTP);
 const _HTTPS = utils.or(utils.and(_IP_OR_DOMAIN, utils.literal('tcp'), utils.or(utils.and(utils.literal('443'), utils.literal('http')), utils.and(utils.number(), utils.literal('https')), utils.and(utils.number(), utils.literal('tls'), utils.literal('http'))), utils.optional(utils.peerId())), utils.and(_IP_OR_DOMAIN, utils.literal('tls'), utils.literal('http'), utils.optional(utils.peerId())), utils.and(_IP_OR_DOMAIN, utils.literal('https'), utils.optional(utils.peerId())));
 /**
  * Matches HTTPS addresses
@@ -371,7 +371,7 @@ const _HTTPS = utils.or(utils.and(_IP_OR_DOMAIN, utils.literal('tcp'), utils.or(
  * HTTP.matches(multiaddr('/dns/example.org/tls/http')) // true
  * ```
  */
-utils.fmt(_HTTPS);
+const HTTPS = utils.fmt(_HTTPS);
 const _Memory = utils.or(utils.and(utils.literal('memory'), utils.string(), utils.optional(utils.peerId())));
 /**
  * Matches Memory addresses
@@ -389,9 +389,18 @@ utils.fmt(_Memory);
 
 exports.Circuit = Circuit;
 exports.DNS = DNS;
+exports.HTTP = HTTP;
+exports.HTTPS = HTTPS;
 exports.IP = IP;
+exports.IP4 = IP4;
+exports.IP6 = IP6;
 exports.IP_OR_DOMAIN = IP_OR_DOMAIN;
 exports.P2P = P2P;
+exports.PEER_ID = PEER_ID;
+exports.QUICV1 = QUICV1;
 exports.TCP = TCP;
 exports.WebRTC = WebRTC;
 exports.WebRTCDirect = WebRTCDirect;
+exports.WebSockets = WebSockets;
+exports.WebSocketsSecure = WebSocketsSecure;
+exports.WebTransport = WebTransport;

package/dist/cjs/node_modules/@multiformats/multiaddr-to-uri/dist/src/index.js

@@ -0,0 +1,233 @@
+'use strict';
+
+var index = require('../../../multiaddr/dist/src/index.js');
+var protocolsTable = require('../../../multiaddr/dist/src/protocols-table.js');
+
+/**
+ * @packageDocumentation
+ *
+ * This module allows easy conversion of Multiaddrs to string URIs.
+ *
+ * @example Converting multiaddrs to string URIs
+ *
+ * ```js
+ * import { multiaddrToUri } from '@multiformats/multiaddr-to-uri'
+ *
+ * console.log(multiaddrToUri('/dnsaddr/protocol.ai/https'))
+ * // -> https://protocol.ai
+ *
+ * console.log(multiaddrToUri('/ip4/127.0.0.1/tcp/8080'))
+ * // -> http://127.0.0.1:8080
+ *
+ * console.log(multiaddrToUri('/ip4/127.0.0.1/tcp/8080', { assumeHttp: false }))
+ * // -> tcp://127.0.0.1:8080
+ * ```
+ *
+ * Note:
+ *
+ * - When `/tcp` is the last (terminating) protocol HTTP is assumed by default (implicit `assumeHttp: true`)
+ *   - this means produced URIs will start with `http://` instead of `tcp://`
+ *   - passing `{ assumeHttp: false }` disables this behavior
+ * - Might be lossy - e.g. a DNSv6 multiaddr
+ * - Can throw if the passed multiaddr:
+ *   - is not a valid multiaddr
+ *   - is not supported as a URI e.g. circuit
+ */
+const ASSUME_HTTP_CODES = [protocolsTable.getProtocol('tcp').code, protocolsTable.getProtocol('dns').code, protocolsTable.getProtocol('dnsaddr').code, protocolsTable.getProtocol('dns4').code, protocolsTable.getProtocol('dns6').code];
+function extractSNI(ma) {
+  return extractTuple('sni', ma)?.[1];
+}
+function extractPort(ma) {
+  const port = extractTuple('tcp', ma)?.[1];
+  if (port == null) {
+    return '';
+  }
+  return `:${port}`;
+}
+function extractTuple(name, ma) {
+  let code;
+  try {
+    code = protocolsTable.getProtocol(name).code;
+  } catch (e) {
+    // No support for protocol in multiaddr
+    return;
+  }
+  for (const [proto, value] of ma) {
+    if (proto === code && value != null) {
+      return [proto, value];
+    }
+  }
+}
+function hasTLS(ma) {
+  return ma.some(_ref => {
+    let [proto, _] = _ref;
+    return proto === protocolsTable.getProtocol('tls').code;
+  });
+}
+function interpretNext(headProtoCode, headProtoVal, restMa) {
+  const interpreter = interpreters[protocolsTable.getProtocol(headProtoCode).name];
+  if (interpreter == null) {
+    throw new Error(`Can't interpret protocol ${protocolsTable.getProtocol(headProtoCode).name}`);
+  }
+  const restVal = interpreter(headProtoVal, restMa);
+  if (headProtoCode === protocolsTable.getProtocol('ip6').code) {
+    return `[${restVal}]`;
+  }
+  return restVal;
+}
+const interpreters = {
+  ip4: (value, restMa) => value,
+  ip6: (value, restMa) => {
+    if (restMa.length === 0) {
+      return value;
+    }
+    return `[${value}]`;
+  },
+  tcp: (value, restMa) => {
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    return `tcp://${interpretNext(tailProto[0], tailProto[1] ?? '', restMa)}:${value}`;
+  },
+  udp: (value, restMa) => {
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    return `udp://${interpretNext(tailProto[0], tailProto[1] ?? '', restMa)}:${value}`;
+  },
+  dnsaddr: (value, restMa) => value,
+  dns4: (value, restMa) => value,
+  dns6: (value, restMa) => value,
+  dns: (value, restMa) => value,
+  ipfs: (value, restMa) => {
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    return `${interpretNext(tailProto[0], tailProto[1] ?? '', restMa)}`;
+  },
+  p2p: (value, restMa) => {
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    return `${interpretNext(tailProto[0], tailProto[1] ?? '', restMa)}`;
+  },
+  http: (value, restMa) => {
+    const maHasTLS = hasTLS(restMa);
+    const sni = extractSNI(restMa);
+    const port = extractPort(restMa);
+    if (maHasTLS && sni != null) {
+      return `https://${sni}${port}`;
+    }
+    const protocol = maHasTLS ? 'https://' : 'http://';
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    let baseVal = interpretNext(tailProto[0], tailProto[1] ?? '', restMa);
+    // We are reinterpreting the base as http, so we need to remove the tcp:// if it's there
+    baseVal = baseVal.replace('tcp://', '');
+    return `${protocol}${baseVal}`;
+  },
+  'http-path': (value, restMa) => {
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    const baseVal = interpretNext(tailProto[0], tailProto[1] ?? '', restMa);
+    const decodedValue = decodeURIComponent(value);
+    return `${baseVal}/${decodedValue}`;
+  },
+  tls: (value, restMa) => {
+    // Noop, the parent context knows that it's tls. We don't need to do
+    // anything here
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    return interpretNext(tailProto[0], tailProto[1] ?? '', restMa);
+  },
+  sni: (value, restMa) => {
+    // Noop, the parent context uses the sni information, we don't need to do
+    // anything here
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    return interpretNext(tailProto[0], tailProto[1] ?? '', restMa);
+  },
+  https: (value, restMa) => {
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    let baseVal = interpretNext(tailProto[0], tailProto[1] ?? '', restMa);
+    // We are reinterpreting the base as http, so we need to remove the tcp:// if it's there
+    baseVal = baseVal.replace('tcp://', '');
+    return `https://${baseVal}`;
+  },
+  ws: (value, restMa) => {
+    const maHasTLS = hasTLS(restMa);
+    const sni = extractSNI(restMa);
+    const port = extractPort(restMa);
+    if (maHasTLS && sni != null) {
+      return `wss://${sni}${port}`;
+    }
+    const protocol = maHasTLS ? 'wss://' : 'ws://';
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    let baseVal = interpretNext(tailProto[0], tailProto[1] ?? '', restMa);
+    // We are reinterpreting the base, so we need to remove the tcp:// if it's there
+    baseVal = baseVal.replace('tcp://', '');
+    return `${protocol}${baseVal}`;
+  },
+  wss: (value, restMa) => {
+    const tailProto = restMa.pop();
+    if (tailProto == null) {
+      throw new Error('Unexpected end of multiaddr');
+    }
+    let baseVal = interpretNext(tailProto[0], tailProto[1] ?? '', restMa);
+    // We are reinterpreting the base as http, so we need to remove the tcp:// if it's there
+    baseVal = baseVal.replace('tcp://', '');
+    return `wss://${baseVal}`;
+  }
+};
+function multiaddrToUri(input, opts) {
+  const ma = index.multiaddr(input);
+  const parts = ma.stringTuples();
+  const head = parts.pop();
+  if (head == null) {
+    throw new Error('Unexpected end of multiaddr');
+  }
+  const protocol = protocolsTable.getProtocol(head[0]);
+  const interpreter = interpreters[protocol.name];
+  if (interpreter == null) {
+    throw new Error(`No interpreter found for ${protocol.name}`);
+  }
+  let uri = interpreter(head[1] ?? '', parts);
+  if (ASSUME_HTTP_CODES.includes(head[0])) {
+    // strip any declared protocol
+    uri = uri.replace(/^.*:\/\//, '');
+    if (head[1] === '443') {
+      uri = `https://${uri}`;
+    } else {
+      uri = `http://${uri}`;
+    }
+  }
+  if (uri.startsWith('http://') || uri.startsWith('https://') || uri.startsWith('ws://') || uri.startsWith('wss://')) {
+    // this will strip default ports while keeping paths intact
+    uri = new URL(uri).toString();
+    // strip trailing slash, e.g. http://127.0.0.1/ -> http://127.0.0.1
+    if (uri.endsWith('/')) {
+      uri = uri.substring(0, uri.length - 1);
+    }
+  }
+  return uri;
+}
+
+exports.multiaddrToUri = multiaddrToUri;

package/dist/cjs/node_modules/@multiformats/murmur3/src/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var bytes = require('../../../multiformats/dist/src/bytes.js');
+require('../../../multiformats/dist/src/bases/base32.js');
+require('../../../multiformats/dist/src/bases/base36.js');
+require('../../../multiformats/dist/src/bases/base58.js');
+var hasher = require('../../../multiformats/dist/src/hashes/hasher.js');
+var index = require('../../../../_virtual/index34.js');
+
+/**
+ * @param {number} number
+ * @returns {Uint8Array}
+ */
+function fromNumberTo32BitBuf(number) {
+  const bytes = new Array(4);
+  for (let i = 0; i < 4; i++) {
+    bytes[i] = number & 0xff;
+    number = number >> 8;
+  }
+  return new Uint8Array(bytes);
+}
+hasher.from({
+  name: 'murmur3-32',
+  code: 0x23,
+  encode: input => fromNumberTo32BitBuf(index.default.x86.hash32(input))
+});
+const murmur3128 = hasher.from({
+  name: 'murmur3-128',
+  code: 0x22,
+  encode: input => bytes.fromHex(index.default.x64.hash128(input))
+});
+
+// A special-use 0x22 that truncates 64 bits, specifically for use in the UnixFS HAMT
+hasher.from({
+  name: 'murmur3-x64-64',
+  code: 0x22,
+  encode: input => bytes.fromHex(index.default.x64.hash128(input)).subarray(0, 8)
+});
+
+exports.murmur3128 = murmur3128;

package/dist/cjs/node_modules/@multiformats/uri-to-multiaddr/dist/src/index.js

@@ -0,0 +1,178 @@
+'use strict';
+
+var index = require('../../../multiaddr/dist/src/index.js');
+var index$1 = require('../../../../is-ip/index.js');
+
+/**
+ * @packageDocumentation
+ *
+ * ```typescript
+ * import { uriToMultiaddr } from '@multiformats/uri-to-multiaddr'
+ *
+ * console.log(uriToMultiaddr('https://protocol.ai'))
+ * // -> /dns4/protocol.ai/tcp/443/https
+ * ```
+ *
+ * Domain names can represent one of
+ *
+ * - `/dns4` - domain resolves to an ipv4 address (**default**)
+ * - `/dns6` - domain resolves to an ipv6 address
+ * - `/dnsaddr` - domain has a [DNSLink](https://docs.ipfs.io/guides/concepts/dnslink/) TXT record pointing to an IPFS CID
+ *
+ * This library assumes `/dns4` when it finds a domain name in the input string.
+ * It makes no attempt query DNS. To override the default assumption, you can pass
+ * in an options object as the second parameter to override it:
+ *
+ * ```typescript
+ * import { uriToMultiaddr } from '@multiformats/uri-to-multiaddr'
+ *
+ * console.log(uriToMultiaddr('https://protocol.ai'), { defaultDnsType: 'dns6' })
+ * // -> /dns6/protocol.ai/tcp/443/https
+ * ```
+ *
+ * See [test.js](./test.js) for the currently supported conversions.
+ *
+ * **Note**: `uri-to-multiaddr` will throw if the passed URI:
+ *
+ * - is not a valid, according the WHATWG URL spec implementation used.
+ * - is not supported yet
+ *
+ * ## Related
+ *
+ * - [@multiformats/multiaddr-to-uri](https://github.com/multiformats/js-multiaddr-to-uri) - convert it back again
+ */
+const portFor = {
+  http: '80',
+  https: '443',
+  ws: '80',
+  wss: '443'
+};
+const BROWSER_SCHEMES = ['http', 'https', 'ws', 'wss'];
+/**
+ * Convert a URI to a multiaddr
+ *
+ * http://foobar.com => /dns/foobar.com/tcp/80/http
+ * https://foobar.com => /dns/foobar.com/tcp/443/https
+ * https://foobar.com:5001 => /dns/foobar.com/tcp/5001/https
+ * https://127.0.0.1:8080 => /ip4/127.0.0.1/tcp/8080/https
+ * http://[::1]:8080 => /ip6/::1/tcp/8080/http
+ * tcp://foobar.com:8080 => /dns/foobar.com/tcp/8080
+ * udp://foobar.com:8080 => /dns/foobar.com/udp/8080
+ */
+function uriToMultiaddr(uriStr, opts) {
+  opts = opts ?? {};
+  const defaultDnsType = opts.defaultDnsType ?? 'dns';
+  const {
+    scheme,
+    hostname,
+    port,
+    path
+  } = parseUri(uriStr);
+  const parts = [tupleForHostname(hostname, defaultDnsType), tupleForPort(port, scheme), tupleForScheme(scheme)];
+  if (path != null) {
+    parts.push(tupleForPath(path));
+  }
+  const multiaddrStr = '/' + parts.filter(x => Boolean(x))
+  // @ts-expect-error ts cannot see we filter falsy values
+  .reduce((a, b) => a.concat(b), []).join('/');
+  return index.multiaddr(multiaddrStr);
+}
+function parseUri(uriStr) {
+  const [scheme] = uriStr.split(':');
+  // browsers will only parse URLs with schemes they understand
+  if (!BROWSER_SCHEMES.includes(scheme)) {
+    uriStr = 'http' + uriStr.substring(scheme.length);
+  }
+  // Use the WHATWG URL global, in node >= 10 and the browser
+  let {
+    protocol,
+    hostname,
+    port,
+    pathname,
+    search
+  } = new URL(uriStr);
+  if (port == null || port === '') {
+    const protocolPort = portForProtocol(scheme);
+    if (protocolPort != null) {
+      port = protocolPort;
+    }
+    // browsers will omit the port when it's common
+    if (protocolPort == null && protocol === 'http:') {
+      // we overrode the protocol with http, set the port to 80
+      port = '80';
+    }
+  }
+  let path;
+  if (pathname != null && pathname !== '' && pathname !== '/') {
+    if (pathname.startsWith('/')) {
+      pathname = pathname.substring(1);
+    }
+    path = pathname;
+  }
+  if (search != null && search !== '') {
+    path = path ?? '';
+    path += search;
+  }
+  return {
+    scheme,
+    hostname,
+    port,
+    path
+  };
+}
+function tupleForHostname(hostname, defaultDnsType) {
+  if (hostname == null || hostname === '') {
+    return undefined;
+  }
+  if (index$1.isIPv4(hostname)) {
+    return ['ip4', hostname];
+  }
+  if (index$1.isIPv6(hostname)) {
+    return ['ip6', hostname];
+  }
+  // literal ipv6 in url should be wrapped in square brackets [x:y:z]
+  // https://www.ietf.org/rfc/rfc2732.txt
+  if (hostname[0] === '[') {
+    const trimmed = hostname.substring(1, hostname.length - 1);
+    if (index$1.isIPv6(trimmed)) {
+      return ['ip6', trimmed];
+    }
+  }
+  // assumes that any non-ip hostname is a dns4 address.
+  return [defaultDnsType, hostname];
+}
+function tupleForPort(port, scheme) {
+  if (port == null || port === '') {
+    return undefined;
+  }
+  if (scheme === 'udp') {
+    return ['udp', port];
+  }
+  return ['tcp', port];
+}
+function tupleForScheme(scheme) {
+  if (scheme.match(/^tcp$|^udp$/) != null) {
+    return undefined;
+  }
+  if (scheme === 'https') {
+    return ['/tls/http'];
+  }
+  if (scheme === 'wss') {
+    return ['/tls/ws'];
+  }
+  return [scheme];
+}
+function tupleForPath(path) {
+  if (path == null || path === '') {
+    return undefined;
+  }
+  return ['http-path', encodeURIComponent(path)];
+}
+function portForProtocol(protocol) {
+  if (protocol == null || protocol === '' || portFor[protocol] == null) {
+    return undefined;
+  }
+  return portFor[protocol];
+}
+
+exports.uriToMultiaddr = uriToMultiaddr;

package/dist/cjs/node_modules/@noble/hashes/esm/_blake.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Internal helpers for blake hash.
+ * @module
+ */
+/**
+ * Internal blake variable.
+ * For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
+ */
+// prettier-ignore
+const BSIGMA = /* @__PURE__ */Uint8Array.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3, 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11, 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5, 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+// Blake1, unused in others
+11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9]);
+
+exports.BSIGMA = BSIGMA;

package/dist/cjs/node_modules/@noble/hashes/esm/_u64.js

@@ -41,6 +41,15 @@ const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
 // Right rotate for Shift in (32, 64), NOTE: 32 is special case.
 const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
 const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+// Right rotate for shift===32 (just swaps l&h)
+const rotr32H = (_h, l) => l;
+const rotr32L = (h, _l) => h;
+// Left rotate for Shift in [1, 32)
+const rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+const rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
 // JS uses 32-bit signed integers for bitwise operations which means we cannot
 // simple take carry out of low bit sum by shift, we need to use division.
 function add(Ah, Al, Bh, Bl) {
@@ -66,6 +75,12 @@ exports.add4L = add4L;
 exports.add5H = add5H;
 exports.add5L = add5L;
 exports.fromBig = fromBig;
+exports.rotlBH = rotlBH;
+exports.rotlBL = rotlBL;
+exports.rotlSH = rotlSH;
+exports.rotlSL = rotlSL;
+exports.rotr32H = rotr32H;
+exports.rotr32L = rotr32L;
 exports.rotrBH = rotrBH;
 exports.rotrBL = rotrBL;
 exports.rotrSH = rotrSH;