shogun-core 3.3.2 → 3.3.4

package/dist/browser/defaultVendors-node_modules_shogun-ipfs_node_modules_is-ipfs_dist_src_index_js.shogun-core.js

@@ -0,0 +1,4908 @@
+"use strict";
+(this["webpackChunkShogunCore"] = this["webpackChunkShogunCore"] || []).push([["defaultVendors-node_modules_shogun-ipfs_node_modules_is-ipfs_dist_src_index_js"],{
+
+/***/ "./node_modules/shogun-ipfs/node_modules/is-ipfs/dist/src/index.js":
+/*!**************************************************************************************!*\
+  !*** ./node_modules/shogun-ipfs/node_modules/is-ipfs/dist/src/index.js + 57 modules ***!
+  \**************************************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  base32cid: () => (/* binding */ base32cid),
+  cid: () => (/* binding */ isCID),
+  cidPath: () => (/* binding */ cidPath),
+  ipfsPath: () => (/* binding */ ipfsPath),
+  ipfsSubdomain: () => (/* binding */ ipfsSubdomain),
+  ipfsUrl: () => (/* binding */ ipfsUrl),
+  ipnsPath: () => (/* binding */ ipnsPath),
+  ipnsSubdomain: () => (/* binding */ ipnsSubdomain),
+  ipnsUrl: () => (/* binding */ ipnsUrl),
+  multiaddr: () => (/* binding */ src_isMultiaddr),
+  multihash: () => (/* binding */ isMultihash),
+  path: () => (/* binding */ path),
+  pathGatewayPattern: () => (/* binding */ pathGatewayPattern),
+  pathPattern: () => (/* binding */ pathPattern),
+  peerMultiaddr: () => (/* binding */ isPeerMultiaddr),
+  subdomain: () => (/* binding */ subdomain),
+  subdomainGatewayPattern: () => (/* binding */ subdomainGatewayPattern),
+  url: () => (/* binding */ url),
+  urlOrPath: () => (/* binding */ urlOrPath)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base32.js
+var base32_namespaceObject = {};
+__webpack_require__.r(base32_namespaceObject);
+__webpack_require__.d(base32_namespaceObject, {
+  base32: () => (base32),
+  base32hex: () => (base32hex),
+  base32hexpad: () => (base32hexpad),
+  base32hexpadupper: () => (base32hexpadupper),
+  base32hexupper: () => (base32hexupper),
+  base32pad: () => (base32pad),
+  base32padupper: () => (base32padupper),
+  base32upper: () => (base32upper),
+  base32z: () => (base32z)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base58.js
+var base58_namespaceObject = {};
+__webpack_require__.r(base58_namespaceObject);
+__webpack_require__.d(base58_namespaceObject, {
+  base58btc: () => (base58btc),
+  base58flickr: () => (base58flickr)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base10.js
+var base10_namespaceObject = {};
+__webpack_require__.r(base10_namespaceObject);
+__webpack_require__.d(base10_namespaceObject, {
+  base10: () => (base10)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base16.js
+var base16_namespaceObject = {};
+__webpack_require__.r(base16_namespaceObject);
+__webpack_require__.d(base16_namespaceObject, {
+  base16: () => (base16),
+  base16upper: () => (base16upper)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base2.js
+var base2_namespaceObject = {};
+__webpack_require__.r(base2_namespaceObject);
+__webpack_require__.d(base2_namespaceObject, {
+  base2: () => (base2)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base256emoji.js
+var base256emoji_namespaceObject = {};
+__webpack_require__.r(base256emoji_namespaceObject);
+__webpack_require__.d(base256emoji_namespaceObject, {
+  base256emoji: () => (base256emoji)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base36.js
+var base36_namespaceObject = {};
+__webpack_require__.r(base36_namespaceObject);
+__webpack_require__.d(base36_namespaceObject, {
+  base36: () => (base36),
+  base36upper: () => (base36upper)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base64.js
+var base64_namespaceObject = {};
+__webpack_require__.r(base64_namespaceObject);
+__webpack_require__.d(base64_namespaceObject, {
+  base64: () => (base64),
+  base64pad: () => (base64pad),
+  base64url: () => (base64url),
+  base64urlpad: () => (base64urlpad)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base8.js
+var base8_namespaceObject = {};
+__webpack_require__.r(base8_namespaceObject);
+__webpack_require__.d(base8_namespaceObject, {
+  base8: () => (base8)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/identity.js
+var identity_namespaceObject = {};
+__webpack_require__.r(identity_namespaceObject);
+__webpack_require__.d(identity_namespaceObject, {
+  identity: () => (identity)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/codecs/json.js
+var json_namespaceObject = {};
+__webpack_require__.r(json_namespaceObject);
+__webpack_require__.d(json_namespaceObject, {
+  code: () => (code),
+  decode: () => (json_decode),
+  encode: () => (json_encode),
+  name: () => (json_name)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/codecs/raw.js
+var raw_namespaceObject = {};
+__webpack_require__.r(raw_namespaceObject);
+__webpack_require__.d(raw_namespaceObject, {
+  code: () => (raw_code),
+  decode: () => (raw_decode),
+  encode: () => (raw_encode),
+  name: () => (raw_name)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/hashes/identity.js
+var hashes_identity_namespaceObject = {};
+__webpack_require__.r(hashes_identity_namespaceObject);
+__webpack_require__.d(hashes_identity_namespaceObject, {
+  identity: () => (identity_identity)
+});
+
+// NAMESPACE OBJECT: ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/hashes/sha2-browser.js
+var sha2_browser_namespaceObject = {};
+__webpack_require__.r(sha2_browser_namespaceObject);
+__webpack_require__.d(sha2_browser_namespaceObject, {
+  sha256: () => (sha256),
+  sha512: () => (sha512)
+});
+
+// EXTERNAL MODULE: ./node_modules/shogun-ipfs/node_modules/uint8-varint/dist/src/index.js
+var src = __webpack_require__("./node_modules/shogun-ipfs/node_modules/uint8-varint/dist/src/index.js");
+// EXTERNAL MODULE: ./node_modules/shogun-ipfs/node_modules/uint8arrays/dist/src/concat.js + 1 modules
+var concat = __webpack_require__("./node_modules/shogun-ipfs/node_modules/uint8arrays/dist/src/concat.js");
+// EXTERNAL MODULE: ./node_modules/shogun-ipfs/node_modules/uint8arrays/dist/src/to-string.js
+var to_string = __webpack_require__("./node_modules/shogun-ipfs/node_modules/uint8arrays/dist/src/to-string.js");
+;// ./node_modules/shogun-ipfs/node_modules/@chainsafe/is-ip/lib/parser.js
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+class Parser {
+    index = 0;
+    input = "";
+    new(input) {
+        this.index = 0;
+        this.input = input;
+        return this;
+    }
+    /** Run a parser, and restore the pre-parse state if it fails. */
+    readAtomically(fn) {
+        const index = this.index;
+        const result = fn();
+        if (result === undefined) {
+            this.index = index;
+        }
+        return result;
+    }
+    /** Run a parser, but fail if the entire input wasn't consumed. Doesn't run atomically. */
+    parseWith(fn) {
+        const result = fn();
+        if (this.index !== this.input.length) {
+            return undefined;
+        }
+        return result;
+    }
+    /** Peek the next character from the input */
+    peekChar() {
+        if (this.index >= this.input.length) {
+            return undefined;
+        }
+        return this.input[this.index];
+    }
+    /** Read the next character from the input */
+    readChar() {
+        if (this.index >= this.input.length) {
+            return undefined;
+        }
+        return this.input[this.index++];
+    }
+    /** Read the next character from the input if it matches the target. */
+    readGivenChar(target) {
+        return this.readAtomically(() => {
+            const char = this.readChar();
+            if (char !== target) {
+                return undefined;
+            }
+            return char;
+        });
+    }
+    /**
+     * Helper for reading separators in an indexed loop. Reads the separator
+     * character iff index > 0, then runs the parser. When used in a loop,
+     * the separator character will only be read on index > 0 (see
+     * readIPv4Addr for an example)
+     */
+    readSeparator(sep, index, inner) {
+        return this.readAtomically(() => {
+            if (index > 0) {
+                if (this.readGivenChar(sep) === undefined) {
+                    return undefined;
+                }
+            }
+            return inner();
+        });
+    }
+    /**
+     * Read a number off the front of the input in the given radix, stopping
+     * at the first non-digit character or eof. Fails if the number has more
+     * digits than max_digits or if there is no number.
+     */
+    readNumber(radix, maxDigits, allowZeroPrefix, maxBytes) {
+        return this.readAtomically(() => {
+            let result = 0;
+            let digitCount = 0;
+            const leadingChar = this.peekChar();
+            if (leadingChar === undefined) {
+                return undefined;
+            }
+            const hasLeadingZero = leadingChar === "0";
+            const maxValue = 2 ** (8 * maxBytes) - 1;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const digit = this.readAtomically(() => {
+                    const char = this.readChar();
+                    if (char === undefined) {
+                        return undefined;
+                    }
+                    const num = Number.parseInt(char, radix);
+                    if (Number.isNaN(num)) {
+                        return undefined;
+                    }
+                    return num;
+                });
+                if (digit === undefined) {
+                    break;
+                }
+                result *= radix;
+                result += digit;
+                if (result > maxValue) {
+                    return undefined;
+                }
+                digitCount += 1;
+                if (maxDigits !== undefined) {
+                    if (digitCount > maxDigits) {
+                        return undefined;
+                    }
+                }
+            }
+            if (digitCount === 0) {
+                return undefined;
+            }
+            else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
+                return undefined;
+            }
+            else {
+                return result;
+            }
+        });
+    }
+    /** Read an IPv4 address. */
+    readIPv4Addr() {
+        return this.readAtomically(() => {
+            const out = new Uint8Array(4);
+            for (let i = 0; i < out.length; i++) {
+                const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+                if (ix === undefined) {
+                    return undefined;
+                }
+                out[i] = ix;
+            }
+            return out;
+        });
+    }
+    /** Read an IPv6 Address. */
+    readIPv6Addr() {
+        /**
+         * Read a chunk of an IPv6 address into `groups`. Returns the number
+         * of groups read, along with a bool indicating if an embedded
+         * trailing IPv4 address was read. Specifically, read a series of
+         * colon-separated IPv6 groups (0x0000 - 0xFFFF), with an optional
+         * trailing embedded IPv4 address.
+         */
+        const readGroups = (groups) => {
+            for (let i = 0; i < groups.length / 2; i++) {
+                const ix = i * 2;
+                // Try to read a trailing embedded IPv4 address. There must be at least 4 groups left.
+                if (i < groups.length - 3) {
+                    const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+                    if (ipv4 !== undefined) {
+                        groups[ix] = ipv4[0];
+                        groups[ix + 1] = ipv4[1];
+                        groups[ix + 2] = ipv4[2];
+                        groups[ix + 3] = ipv4[3];
+                        return [ix + 4, true];
+                    }
+                }
+                const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
+                if (group === undefined) {
+                    return [ix, false];
+                }
+                groups[ix] = group >> 8;
+                groups[ix + 1] = group & 255;
+            }
+            return [groups.length, false];
+        };
+        return this.readAtomically(() => {
+            // Read the front part of the address; either the whole thing, or up to the first ::
+            const head = new Uint8Array(16);
+            const [headSize, headIp4] = readGroups(head);
+            if (headSize === 16) {
+                return head;
+            }
+            // IPv4 part is not allowed before `::`
+            if (headIp4) {
+                return undefined;
+            }
+            // Read `::` if previous code parsed less than 8 groups.
+            // `::` indicates one or more groups of 16 bits of zeros.
+            if (this.readGivenChar(":") === undefined) {
+                return undefined;
+            }
+            if (this.readGivenChar(":") === undefined) {
+                return undefined;
+            }
+            // Read the back part of the address. The :: must contain at least one
+            // set of zeroes, so our max length is 7.
+            const tail = new Uint8Array(14);
+            const limit = 16 - (headSize + 2);
+            const [tailSize] = readGroups(tail.subarray(0, limit));
+            // Concat the head and tail of the IP address
+            head.set(tail.subarray(0, tailSize), 16 - tailSize);
+            return head;
+        });
+    }
+    /** Read an IP Address, either IPv4 or IPv6. */
+    readIPAddr() {
+        return this.readIPv4Addr() ?? this.readIPv6Addr();
+    }
+}
+//# sourceMappingURL=parser.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@chainsafe/is-ip/lib/parse.js
+
+// See https://stackoverflow.com/questions/166132/maximum-length-of-the-textual-representation-of-an-ipv6-address
+const MAX_IPV6_LENGTH = 45;
+const MAX_IPV4_LENGTH = 15;
+const parser = new Parser();
+/** Parse `input` into IPv4 bytes. */
+function parseIPv4(input) {
+    if (input.length > MAX_IPV4_LENGTH) {
+        return undefined;
+    }
+    return parser.new(input).parseWith(() => parser.readIPv4Addr());
+}
+/** Parse IPv4 `input` into IPv6 with IPv4-mapped bytes, eg ::ffff:1.2.3.4 */
+function parseIPv4Mapped(input) {
+    if (input.length > MAX_IPV4_LENGTH) {
+        return undefined;
+    }
+    const ipv4 = parser.new(input).parseWith(() => parser.readIPv4Addr());
+    if (ipv4 === undefined) {
+        return undefined;
+    }
+    return Uint8Array.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, ipv4[0], ipv4[1], ipv4[2], ipv4[3]]);
+}
+/** Parse `input` into IPv6 bytes. */
+function parseIPv6(input) {
+    // strip zone index if it is present
+    if (input.includes("%")) {
+        input = input.split("%")[0];
+    }
+    if (input.length > MAX_IPV6_LENGTH) {
+        return undefined;
+    }
+    return parser.new(input).parseWith(() => parser.readIPv6Addr());
+}
+/** Parse `input` into IPv4 or IPv6 bytes. */
+function parseIP(input, mapIPv4ToIPv6 = false) {
+    // strip zone index if it is present
+    if (input.includes("%")) {
+        input = input.split("%")[0];
+    }
+    if (input.length > MAX_IPV6_LENGTH) {
+        return undefined;
+    }
+    const addr = parser.new(input).parseWith(() => parser.readIPAddr());
+    if (!addr) {
+        return undefined;
+    }
+    if (mapIPv4ToIPv6 && addr.length === 4) {
+        return Uint8Array.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, addr[0], addr[1], addr[2], addr[3]]);
+    }
+    return addr;
+}
+//# sourceMappingURL=parse.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@chainsafe/netmask/dist/src/util.js
+
+function allFF(a, from, to) {
+    let i = 0;
+    for (const e of a) {
+        if (i < from)
+            continue;
+        if (i > to)
+            break;
+        if (e !== 0xff)
+            return false;
+        i++;
+    }
+    return true;
+}
+function deepEqual(a, b, from, to) {
+    let i = 0;
+    for (const e of a) {
+        if (i < from)
+            continue;
+        if (i > to)
+            break;
+        if (e !== b[i])
+            return false;
+        i++;
+    }
+    return true;
+}
+/***
+ * Returns long ip format
+ */
+function ipToString(ip) {
+    switch (ip.length) {
+        case IPv4Len: {
+            return ip.join(".");
+        }
+        case IPv6Len: {
+            const result = [];
+            for (let i = 0; i < ip.length; i++) {
+                if (i % 2 === 0) {
+                    result.push(ip[i].toString(16).padStart(2, "0") +
+                        ip[i + 1].toString(16).padStart(2, "0"));
+                }
+            }
+            return result.join(":");
+        }
+        default: {
+            throw new Error("Invalid ip length");
+        }
+    }
+}
+/**
+ * If mask is a sequence of 1 bits followed by 0 bits, return number of 1 bits else -1
+ */
+function simpleMaskLength(mask) {
+    let ones = 0;
+    // eslint-disable-next-line prefer-const
+    for (let [index, byte] of mask.entries()) {
+        if (byte === 0xff) {
+            ones += 8;
+            continue;
+        }
+        while ((byte & 0x80) != 0) {
+            ones++;
+            byte = byte << 1;
+        }
+        if ((byte & 0x80) != 0) {
+            return -1;
+        }
+        for (let i = index + 1; i < mask.length; i++) {
+            if (mask[i] != 0) {
+                return -1;
+            }
+        }
+        break;
+    }
+    return ones;
+}
+function maskToHex(mask) {
+    let hex = "0x";
+    for (const byte of mask) {
+        hex += (byte >> 4).toString(16) + (byte & 0x0f).toString(16);
+    }
+    return hex;
+}
+//# sourceMappingURL=util.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@chainsafe/netmask/dist/src/ip.js
+
+
+const IPv4Len = 4;
+const IPv6Len = 16;
+const maxIPv6Octet = parseInt("0xFFFF", 16);
+const ipv4Prefix = new Uint8Array([
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255,
+]);
+function maskIp(ip, mask) {
+    if (mask.length === IPv6Len && ip.length === IPv4Len && allFF(mask, 0, 11)) {
+        mask = mask.slice(12);
+    }
+    if (mask.length === IPv4Len &&
+        ip.length === IPv6Len &&
+        deepEqual(ip, ipv4Prefix, 0, 11)) {
+        ip = ip.slice(12);
+    }
+    const n = ip.length;
+    if (n != mask.length) {
+        throw new Error("Failed to mask ip");
+    }
+    const out = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+        out[i] = ip[i] & mask[i];
+    }
+    return out;
+}
+function containsIp(net, ip) {
+    if (typeof ip === "string") {
+        ip = parseIP(ip);
+    }
+    if (ip == null)
+        throw new Error("Invalid ip");
+    if (ip.length !== net.network.length) {
+        return false;
+    }
+    for (let i = 0; i < ip.length; i++) {
+        if ((net.network[i] & net.mask[i]) !== (ip[i] & net.mask[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function iPv4FromIPv6(ip) {
+    if (!isIPv4mappedIPv6(ip)) {
+        throw new Error("Must have 0xffff prefix");
+    }
+    return ip.slice(12);
+}
+function isIPv4mappedIPv6(ip) {
+    return deepEqual(ip, ipv4Prefix, 0, 11);
+}
+//# sourceMappingURL=ip.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@chainsafe/netmask/dist/src/cidr.js
+
+
+function parseCidr(s) {
+    const [address, maskString] = s.split("/");
+    if (!address || !maskString)
+        throw new Error("Failed to parse given CIDR: " + s);
+    let ipLength = IPv4Len;
+    let ip = parseIPv4(address);
+    if (ip == null) {
+        ipLength = IPv6Len;
+        ip = parseIPv6(address);
+        if (ip == null)
+            throw new Error("Failed to parse given CIDR: " + s);
+    }
+    const m = parseInt(maskString, 10);
+    if (Number.isNaN(m) ||
+        String(m).length !== maskString.length ||
+        m < 0 ||
+        m > ipLength * 8) {
+        throw new Error("Failed to parse given CIDR: " + s);
+    }
+    const mask = cidrMask(m, 8 * ipLength);
+    return {
+        network: maskIp(ip, mask),
+        mask,
+    };
+}
+function cidrMask(ones, bits) {
+    if (bits !== 8 * IPv4Len && bits !== 8 * IPv6Len)
+        throw new Error("Invalid CIDR mask");
+    if (ones < 0 || ones > bits)
+        throw new Error("Invalid CIDR mask");
+    const l = bits / 8;
+    const m = new Uint8Array(l);
+    for (let i = 0; i < l; i++) {
+        if (ones >= 8) {
+            m[i] = 0xff;
+            ones -= 8;
+            continue;
+        }
+        m[i] = 255 - (0xff >> ones);
+        ones = 0;
+    }
+    return m;
+}
+//# sourceMappingURL=cidr.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@chainsafe/netmask/dist/src/ipnet.js
+
+
+
+
+class IpNet {
+    /**
+     *
+     * @param ipOrCidr either network ip or full cidr address
+     * @param mask in case ipOrCidr is network this can be either mask in decimal format or as ip address
+     */
+    constructor(ipOrCidr, mask) {
+        if (mask == null) {
+            ({ network: this.network, mask: this.mask } = parseCidr(ipOrCidr));
+        }
+        else {
+            const ipResult = parseIP(ipOrCidr);
+            if (ipResult == null) {
+                throw new Error("Failed to parse network");
+            }
+            mask = String(mask);
+            const m = parseInt(mask, 10);
+            if (Number.isNaN(m) ||
+                String(m).length !== mask.length ||
+                m < 0 ||
+                m > ipResult.length * 8) {
+                const maskResult = parseIP(mask);
+                if (maskResult == null) {
+                    throw new Error("Failed to parse mask");
+                }
+                this.mask = maskResult;
+            }
+            else {
+                this.mask = cidrMask(m, 8 * ipResult.length);
+            }
+            this.network = maskIp(ipResult, this.mask);
+        }
+    }
+    /**
+     * Checks if netmask contains ip address
+     * @param ip
+     * @returns
+     */
+    contains(ip) {
+        return containsIp({ network: this.network, mask: this.mask }, ip);
+    }
+    /**Serializes back to string format */
+    toString() {
+        const l = simpleMaskLength(this.mask);
+        const mask = l !== -1 ? String(l) : maskToHex(this.mask);
+        return ipToString(this.network) + "/" + mask;
+    }
+}
+//# sourceMappingURL=ipnet.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@chainsafe/netmask/dist/src/index.js
+
+
+
+
+
+/**
+ * Checks if cidr block contains ip address
+ * @param cidr ipv4 or ipv6 formatted cidr . Example 198.51.100.14/24 or 2001:db8::/48
+ * @param ip ipv4 or ipv6 address Example 198.51.100.14 or 2001:db8::
+ *
+ */
+function cidrContains(cidr, ip) {
+    const ipnet = new IpNet(cidr);
+    return ipnet.contains(ip);
+}
+//# sourceMappingURL=index.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bytes.js
+const empty = new Uint8Array(0);
+function toHex(d) {
+    return d.reduce((hex, byte) => hex + byte.toString(16).padStart(2, '0'), '');
+}
+function fromHex(hex) {
+    const hexes = hex.match(/../g);
+    return hexes != null ? new Uint8Array(hexes.map(b => parseInt(b, 16))) : empty;
+}
+function equals(aa, bb) {
+    if (aa === bb)
+        return true;
+    if (aa.byteLength !== bb.byteLength) {
+        return false;
+    }
+    for (let ii = 0; ii < aa.byteLength; ii++) {
+        if (aa[ii] !== bb[ii]) {
+            return false;
+        }
+    }
+    return true;
+}
+function coerce(o) {
+    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
+        return o;
+    if (o instanceof ArrayBuffer)
+        return new Uint8Array(o);
+    if (ArrayBuffer.isView(o)) {
+        return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+    }
+    throw new Error('Unknown type, must be binary type');
+}
+function isBinary(o) {
+    return o instanceof ArrayBuffer || ArrayBuffer.isView(o);
+}
+function fromString(str) {
+    return new TextEncoder().encode(str);
+}
+function bytes_toString(b) {
+    return new TextDecoder().decode(b);
+}
+//# sourceMappingURL=bytes.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/vendor/base-x.js
+/* eslint-disable */
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+/**
+ * @param {string} ALPHABET
+ * @param {any} name
+ */
+function base(ALPHABET, name) {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError('Alphabet too long');
+    }
+    var BASE_MAP = new Uint8Array(256);
+    for (var j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (var i = 0; i < ALPHABET.length; i++) {
+        var x = ALPHABET.charAt(i);
+        var xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + ' is ambiguous');
+        }
+        BASE_MAP[xc] = i;
+    }
+    var BASE = ALPHABET.length;
+    var LEADER = ALPHABET.charAt(0);
+    var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    /**
+     * @param {any[] | Iterable<number>} source
+     */
+    function encode(source) {
+        // @ts-ignore
+        if (source instanceof Uint8Array)
+            ;
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+            throw new TypeError('Expected Uint8Array');
+        }
+        if (source.length === 0) {
+            return '';
+        }
+        // Skip & count leading zeroes.
+        var zeroes = 0;
+        var length = 0;
+        var pbegin = 0;
+        var pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        var b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            var carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            var i = 0;
+            for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+                carry += (256 * b58[it1]) >>> 0;
+                b58[it1] = (carry % BASE) >>> 0;
+                carry = (carry / BASE) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            pbegin++;
+        }
+        // Skip leading zeroes in base58 result.
+        var it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
+        // Translate the result into a string.
+        var str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    }
+    /**
+     * @param {string | string[]} source
+     */
+    function decodeUnsafe(source) {
+        if (typeof source !== 'string') {
+            throw new TypeError('Expected String');
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        var psz = 0;
+        // Skip leading spaces.
+        if (source[psz] === ' ') {
+            return;
+        }
+        // Skip and count leading '1's.
+        var zeroes = 0;
+        var length = 0;
+        while (source[psz] === LEADER) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+        var b256 = new Uint8Array(size);
+        // Process the characters.
+        while (source[psz]) {
+            // Decode character
+            var carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255) {
+                return;
+            }
+            var i = 0;
+            for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+                carry += (BASE * b256[it3]) >>> 0;
+                b256[it3] = (carry % 256) >>> 0;
+                carry = (carry / 256) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            psz++;
+        }
+        // Skip trailing spaces.
+        if (source[psz] === ' ') {
+            return;
+        }
+        // Skip leading zeroes in b256.
+        var it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        var vch = new Uint8Array(zeroes + (size - it4));
+        var j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
+    }
+    /**
+     * @param {string | string[]} string
+     */
+    function decode(string) {
+        var buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error(`Non-${name} character`);
+    }
+    return {
+        encode: encode,
+        decodeUnsafe: decodeUnsafe,
+        decode: decode
+    };
+}
+var base_x_src = base;
+var _brrp__multiformats_scope_baseX = base_x_src;
+/* harmony default export */ const base_x = (_brrp__multiformats_scope_baseX);
+//# sourceMappingURL=base-x.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base.js
+
+
+/**
+ * Class represents both BaseEncoder and MultibaseEncoder meaning it
+ * can be used to encode to multibase or base encode without multibase
+ * prefix.
+ */
+class Encoder {
+    name;
+    prefix;
+    baseEncode;
+    constructor(name, prefix, baseEncode) {
+        this.name = name;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+    }
+    encode(bytes) {
+        if (bytes instanceof Uint8Array) {
+            return `${this.prefix}${this.baseEncode(bytes)}`;
+        }
+        else {
+            throw Error('Unknown type, must be binary type');
+        }
+    }
+}
+/**
+ * Class represents both BaseDecoder and MultibaseDecoder so it could be used
+ * to decode multibases (with matching prefix) or just base decode strings
+ * with corresponding base encoding.
+ */
+class Decoder {
+    name;
+    prefix;
+    baseDecode;
+    prefixCodePoint;
+    constructor(name, prefix, baseDecode) {
+        this.name = name;
+        this.prefix = prefix;
+        const prefixCodePoint = prefix.codePointAt(0);
+        /* c8 ignore next 3 */
+        if (prefixCodePoint === undefined) {
+            throw new Error('Invalid prefix character');
+        }
+        this.prefixCodePoint = prefixCodePoint;
+        this.baseDecode = baseDecode;
+    }
+    decode(text) {
+        if (typeof text === 'string') {
+            if (text.codePointAt(0) !== this.prefixCodePoint) {
+                throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+            }
+            return this.baseDecode(text.slice(this.prefix.length));
+        }
+        else {
+            throw Error('Can only multibase decode strings');
+        }
+    }
+    or(decoder) {
+        return or(this, decoder);
+    }
+}
+class ComposedDecoder {
+    decoders;
+    constructor(decoders) {
+        this.decoders = decoders;
+    }
+    or(decoder) {
+        return or(this, decoder);
+    }
+    decode(input) {
+        const prefix = input[0];
+        const decoder = this.decoders[prefix];
+        if (decoder != null) {
+            return decoder.decode(input);
+        }
+        else {
+            throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+        }
+    }
+}
+function or(left, right) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return new ComposedDecoder({
+        ...(left.decoders ?? { [left.prefix]: left }),
+        ...(right.decoders ?? { [right.prefix]: right })
+    });
+}
+class Codec {
+    name;
+    prefix;
+    baseEncode;
+    baseDecode;
+    encoder;
+    decoder;
+    constructor(name, prefix, baseEncode, baseDecode) {
+        this.name = name;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+        this.baseDecode = baseDecode;
+        this.encoder = new Encoder(name, prefix, baseEncode);
+        this.decoder = new Decoder(name, prefix, baseDecode);
+    }
+    encode(input) {
+        return this.encoder.encode(input);
+    }
+    decode(input) {
+        return this.decoder.decode(input);
+    }
+}
+function from({ name, prefix, encode, decode }) {
+    return new Codec(name, prefix, encode, decode);
+}
+function baseX({ name, prefix, alphabet }) {
+    const { encode, decode } = base_x(alphabet, name);
+    return from({
+        prefix,
+        name,
+        encode,
+        decode: (text) => coerce(decode(text))
+    });
+}
+function decode(string, alphabet, bitsPerChar, name) {
+    // Build the character lookup table:
+    const codes = {};
+    for (let i = 0; i < alphabet.length; ++i) {
+        codes[alphabet[i]] = i;
+    }
+    // Count the padding bytes:
+    let end = string.length;
+    while (string[end - 1] === '=') {
+        --end;
+    }
+    // Allocate the output:
+    const out = new Uint8Array((end * bitsPerChar / 8) | 0);
+    // Parse the data:
+    let bits = 0; // Number of bits currently in the buffer
+    let buffer = 0; // Bits waiting to be written out, MSB first
+    let written = 0; // Next byte to write
+    for (let i = 0; i < end; ++i) {
+        // Read one character from the string:
+        const value = codes[string[i]];
+        if (value === undefined) {
+            throw new SyntaxError(`Non-${name} character`);
+        }
+        // Append the bits to the buffer:
+        buffer = (buffer << bitsPerChar) | value;
+        bits += bitsPerChar;
+        // Write out some bits if the buffer has a byte's worth:
+        if (bits >= 8) {
+            bits -= 8;
+            out[written++] = 0xff & (buffer >> bits);
+        }
+    }
+    // Verify that we have received just enough bits:
+    if (bits >= bitsPerChar || (0xff & (buffer << (8 - bits))) !== 0) {
+        throw new SyntaxError('Unexpected end of data');
+    }
+    return out;
+}
+function encode(data, alphabet, bitsPerChar) {
+    const pad = alphabet[alphabet.length - 1] === '=';
+    const mask = (1 << bitsPerChar) - 1;
+    let out = '';
+    let bits = 0; // Number of bits currently in the buffer
+    let buffer = 0; // Bits waiting to be written out, MSB first
+    for (let i = 0; i < data.length; ++i) {
+        // Slurp data into the buffer:
+        buffer = (buffer << 8) | data[i];
+        bits += 8;
+        // Write out as much as we can:
+        while (bits > bitsPerChar) {
+            bits -= bitsPerChar;
+            out += alphabet[mask & (buffer >> bits)];
+        }
+    }
+    // Partial character:
+    if (bits !== 0) {
+        out += alphabet[mask & (buffer << (bitsPerChar - bits))];
+    }
+    // Add padding characters until we hit a byte boundary:
+    if (pad) {
+        while (((out.length * bitsPerChar) & 7) !== 0) {
+            out += '=';
+        }
+    }
+    return out;
+}
+/**
+ * RFC4648 Factory
+ */
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+    return from({
+        prefix,
+        name,
+        encode(input) {
+            return encode(input, alphabet, bitsPerChar);
+        },
+        decode(input) {
+            return decode(input, alphabet, bitsPerChar, name);
+        }
+    });
+}
+//# sourceMappingURL=base.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base32.js
+
+const base32 = rfc4648({
+    prefix: 'b',
+    name: 'base32',
+    alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
+    bitsPerChar: 5
+});
+const base32upper = rfc4648({
+    prefix: 'B',
+    name: 'base32upper',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+    bitsPerChar: 5
+});
+const base32pad = rfc4648({
+    prefix: 'c',
+    name: 'base32pad',
+    alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
+    bitsPerChar: 5
+});
+const base32padupper = rfc4648({
+    prefix: 'C',
+    name: 'base32padupper',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
+    bitsPerChar: 5
+});
+const base32hex = rfc4648({
+    prefix: 'v',
+    name: 'base32hex',
+    alphabet: '0123456789abcdefghijklmnopqrstuv',
+    bitsPerChar: 5
+});
+const base32hexupper = rfc4648({
+    prefix: 'V',
+    name: 'base32hexupper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+    bitsPerChar: 5
+});
+const base32hexpad = rfc4648({
+    prefix: 't',
+    name: 'base32hexpad',
+    alphabet: '0123456789abcdefghijklmnopqrstuv=',
+    bitsPerChar: 5
+});
+const base32hexpadupper = rfc4648({
+    prefix: 'T',
+    name: 'base32hexpadupper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
+    bitsPerChar: 5
+});
+const base32z = rfc4648({
+    prefix: 'h',
+    name: 'base32z',
+    alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+    bitsPerChar: 5
+});
+//# sourceMappingURL=base32.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base58.js
+
+const base58btc = baseX({
+    name: 'base58btc',
+    prefix: 'z',
+    alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+});
+const base58flickr = baseX({
+    name: 'base58flickr',
+    prefix: 'Z',
+    alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+});
+//# sourceMappingURL=base58.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base10.js
+
+const base10 = baseX({
+    prefix: '9',
+    name: 'base10',
+    alphabet: '0123456789'
+});
+//# sourceMappingURL=base10.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base16.js
+
+const base16 = rfc4648({
+    prefix: 'f',
+    name: 'base16',
+    alphabet: '0123456789abcdef',
+    bitsPerChar: 4
+});
+const base16upper = rfc4648({
+    prefix: 'F',
+    name: 'base16upper',
+    alphabet: '0123456789ABCDEF',
+    bitsPerChar: 4
+});
+//# sourceMappingURL=base16.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base2.js
+
+const base2 = rfc4648({
+    prefix: '0',
+    name: 'base2',
+    alphabet: '01',
+    bitsPerChar: 1
+});
+//# sourceMappingURL=base2.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base256emoji.js
+
+const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
+const alphabetBytesToChars = (alphabet.reduce((p, c, i) => { p[i] = c; return p; }, ([])));
+const alphabetCharsToBytes = (alphabet.reduce((p, c, i) => {
+    const codePoint = c.codePointAt(0);
+    if (codePoint == null) {
+        throw new Error(`Invalid character: ${c}`);
+    }
+    p[codePoint] = i;
+    return p;
+}, ([])));
+function base256emoji_encode(data) {
+    return data.reduce((p, c) => {
+        p += alphabetBytesToChars[c];
+        return p;
+    }, '');
+}
+function base256emoji_decode(str) {
+    const byts = [];
+    for (const char of str) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint == null) {
+            throw new Error(`Invalid character: ${char}`);
+        }
+        const byt = alphabetCharsToBytes[codePoint];
+        if (byt == null) {
+            throw new Error(`Non-base256emoji character: ${char}`);
+        }
+        byts.push(byt);
+    }
+    return new Uint8Array(byts);
+}
+const base256emoji = from({
+    prefix: '🚀',
+    name: 'base256emoji',
+    encode: base256emoji_encode,
+    decode: base256emoji_decode
+});
+//# sourceMappingURL=base256emoji.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base36.js
+
+const base36 = baseX({
+    prefix: 'k',
+    name: 'base36',
+    alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+});
+const base36upper = baseX({
+    prefix: 'K',
+    name: 'base36upper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+});
+//# sourceMappingURL=base36.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base64.js
+
+const base64 = rfc4648({
+    prefix: 'm',
+    name: 'base64',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+    bitsPerChar: 6
+});
+const base64pad = rfc4648({
+    prefix: 'M',
+    name: 'base64pad',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+    bitsPerChar: 6
+});
+const base64url = rfc4648({
+    prefix: 'u',
+    name: 'base64url',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+    bitsPerChar: 6
+});
+const base64urlpad = rfc4648({
+    prefix: 'U',
+    name: 'base64urlpad',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
+    bitsPerChar: 6
+});
+//# sourceMappingURL=base64.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/base8.js
+
+const base8 = rfc4648({
+    prefix: '7',
+    name: 'base8',
+    alphabet: '01234567',
+    bitsPerChar: 3
+});
+//# sourceMappingURL=base8.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/identity.js
+
+
+const identity = from({
+    prefix: '\x00',
+    name: 'identity',
+    encode: (buf) => bytes_toString(buf),
+    decode: (str) => fromString(str)
+});
+//# sourceMappingURL=identity.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/codecs/json.js
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const json_name = 'json';
+const code = 0x0200;
+function json_encode(node) {
+    return textEncoder.encode(JSON.stringify(node));
+}
+function json_decode(data) {
+    return JSON.parse(textDecoder.decode(data));
+}
+//# sourceMappingURL=json.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/codecs/raw.js
+
+const raw_name = 'raw';
+const raw_code = 0x55;
+function raw_encode(node) {
+    return coerce(node);
+}
+function raw_decode(data) {
+    return coerce(data);
+}
+//# sourceMappingURL=raw.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/vendor/varint.js
+/* eslint-disable */
+var encode_1 = varint_encode;
+var MSB = 0x80, REST = 0x7F, MSBALL = ~REST, INT = Math.pow(2, 31);
+/**
+ * @param {number} num
+ * @param {number[]} out
+ * @param {number} offset
+ */
+function varint_encode(num, out, offset) {
+    out = out || [];
+    offset = offset || 0;
+    var oldOffset = offset;
+    while (num >= INT) {
+        out[offset++] = (num & 0xFF) | MSB;
+        num /= 128;
+    }
+    while (num & MSBALL) {
+        out[offset++] = (num & 0xFF) | MSB;
+        num >>>= 7;
+    }
+    out[offset] = num | 0;
+    // @ts-ignore
+    varint_encode.bytes = offset - oldOffset + 1;
+    return out;
+}
+var varint_decode = read;
+var MSB$1 = 0x80, REST$1 = 0x7F;
+/**
+ * @param {string | any[]} buf
+ * @param {number} offset
+ */
+function read(buf, offset) {
+    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+    do {
+        if (counter >= l) {
+            // @ts-ignore
+            read.bytes = 0;
+            throw new RangeError('Could not decode varint');
+        }
+        b = buf[counter++];
+        res += shift < 28
+            ? (b & REST$1) << shift
+            : (b & REST$1) * Math.pow(2, shift);
+        shift += 7;
+    } while (b >= MSB$1);
+    // @ts-ignore
+    read.bytes = counter - offset;
+    return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var varint_length = function (/** @type {number} */ value) {
+    return (value < N1 ? 1
+        : value < N2 ? 2
+            : value < N3 ? 3
+                : value < N4 ? 4
+                    : value < N5 ? 5
+                        : value < N6 ? 6
+                            : value < N7 ? 7
+                                : value < N8 ? 8
+                                    : value < N9 ? 9
+                                        : 10);
+};
+var varint = {
+    encode: encode_1,
+    decode: varint_decode,
+    encodingLength: varint_length
+};
+var _brrp_varint = varint;
+/* harmony default export */ const vendor_varint = (_brrp_varint);
+//# sourceMappingURL=varint.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/varint.js
+
+function src_varint_decode(data, offset = 0) {
+    const code = vendor_varint.decode(data, offset);
+    return [code, vendor_varint.decode.bytes];
+}
+function encodeTo(int, target, offset = 0) {
+    vendor_varint.encode(int, target, offset);
+    return target;
+}
+function encodingLength(int) {
+    return vendor_varint.encodingLength(int);
+}
+//# sourceMappingURL=varint.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/hashes/digest.js
+
+
+/**
+ * Creates a multihash digest.
+ */
+function create(code, digest) {
+    const size = digest.byteLength;
+    const sizeOffset = encodingLength(code);
+    const digestOffset = sizeOffset + encodingLength(size);
+    const bytes = new Uint8Array(digestOffset + size);
+    encodeTo(code, bytes, 0);
+    encodeTo(size, bytes, sizeOffset);
+    bytes.set(digest, digestOffset);
+    return new Digest(code, size, digest, bytes);
+}
+/**
+ * Turns bytes representation of multihash digest into an instance.
+ */
+function digest_decode(multihash) {
+    const bytes = coerce(multihash);
+    const [code, sizeOffset] = src_varint_decode(bytes);
+    const [size, digestOffset] = src_varint_decode(bytes.subarray(sizeOffset));
+    const digest = bytes.subarray(sizeOffset + digestOffset);
+    if (digest.byteLength !== size) {
+        throw new Error('Incorrect length');
+    }
+    return new Digest(code, size, digest, bytes);
+}
+function digest_equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    else {
+        const data = b;
+        return (a.code === data.code &&
+            a.size === data.size &&
+            data.bytes instanceof Uint8Array &&
+            equals(a.bytes, data.bytes));
+    }
+}
+/**
+ * Represents a multihash digest which carries information about the
+ * hashing algorithm and an actual hash digest.
+ */
+class Digest {
+    code;
+    size;
+    digest;
+    bytes;
+    /**
+     * Creates a multihash digest.
+     */
+    constructor(code, size, digest, bytes) {
+        this.code = code;
+        this.size = size;
+        this.digest = digest;
+        this.bytes = bytes;
+    }
+}
+/**
+ * Used to check that the passed multihash has the passed code
+ */
+function hasCode(digest, code) {
+    return digest.code === code;
+}
+//# sourceMappingURL=digest.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/hashes/identity.js
+
+
+const identity_code = 0x0;
+const identity_name = 'identity';
+const identity_encode = coerce;
+function digest(input) {
+    return create(identity_code, identity_encode(input));
+}
+const identity_identity = { code: identity_code, name: identity_name, encode: identity_encode, digest };
+//# sourceMappingURL=identity.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/hashes/hasher.js
+
+function hasher_from({ name, code, encode }) {
+    return new Hasher(name, code, encode);
+}
+/**
+ * Hasher represents a hashing algorithm implementation that produces as
+ * `MultihashDigest`.
+ */
+class Hasher {
+    name;
+    code;
+    encode;
+    constructor(name, code, encode) {
+        this.name = name;
+        this.code = code;
+        this.encode = encode;
+    }
+    digest(input) {
+        if (input instanceof Uint8Array) {
+            const result = this.encode(input);
+            return result instanceof Uint8Array
+                ? create(this.code, result)
+                /* c8 ignore next 1 */
+                : result.then(digest => create(this.code, digest));
+        }
+        else {
+            throw Error('Unknown type, must be binary type');
+            /* c8 ignore next 1 */
+        }
+    }
+}
+//# sourceMappingURL=hasher.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/hashes/sha2-browser.js
+/* global crypto */
+
+function sha(name) {
+    return async (data) => new Uint8Array(await crypto.subtle.digest(name, data));
+}
+const sha256 = hasher_from({
+    name: 'sha2-256',
+    code: 0x12,
+    encode: sha('SHA-256')
+});
+const sha512 = hasher_from({
+    name: 'sha2-512',
+    code: 0x13,
+    encode: sha('SHA-512')
+});
+//# sourceMappingURL=sha2-browser.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/link/interface.js
+/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
+/* eslint-disable no-use-before-define */
+
+//# sourceMappingURL=interface.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/cid.js
+
+
+
+
+
+
+// This way TS will also expose all the types from module
+
+function format(link, base) {
+    const { bytes, version } = link;
+    switch (version) {
+        case 0:
+            return toStringV0(bytes, baseCache(link), base ?? base58btc.encoder);
+        default:
+            return toStringV1(bytes, baseCache(link), (base ?? base32.encoder));
+    }
+}
+function toJSON(link) {
+    return {
+        '/': format(link)
+    };
+}
+function fromJSON(json) {
+    return CID.parse(json['/']);
+}
+const cache = new WeakMap();
+function baseCache(cid) {
+    const baseCache = cache.get(cid);
+    if (baseCache == null) {
+        const baseCache = new Map();
+        cache.set(cid, baseCache);
+        return baseCache;
+    }
+    return baseCache;
+}
+class CID {
+    code;
+    version;
+    multihash;
+    bytes;
+    '/';
+    /**
+     * @param version - Version of the CID
+     * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+     * @param multihash - (Multi)hash of the of the content.
+     */
+    constructor(version, code, multihash, bytes) {
+        this.code = code;
+        this.version = version;
+        this.multihash = multihash;
+        this.bytes = bytes;
+        // flag to serializers that this is a CID and
+        // should be treated specially
+        this['/'] = bytes;
+    }
+    /**
+     * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+     * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+     *
+     * @deprecated
+     */
+    get asCID() {
+        return this;
+    }
+    // ArrayBufferView
+    get byteOffset() {
+        return this.bytes.byteOffset;
+    }
+    // ArrayBufferView
+    get byteLength() {
+        return this.bytes.byteLength;
+    }
+    toV0() {
+        switch (this.version) {
+            case 0: {
+                return this;
+            }
+            case 1: {
+                const { code, multihash } = this;
+                if (code !== DAG_PB_CODE) {
+                    throw new Error('Cannot convert a non dag-pb CID to CIDv0');
+                }
+                // sha2-256
+                if (multihash.code !== SHA_256_CODE) {
+                    throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0');
+                }
+                return (CID.createV0(multihash));
+            }
+            default: {
+                throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+            }
+        }
+    }
+    toV1() {
+        switch (this.version) {
+            case 0: {
+                const { code, digest } = this.multihash;
+                const multihash = create(code, digest);
+                return (CID.createV1(this.code, multihash));
+            }
+            case 1: {
+                return this;
+            }
+            default: {
+                throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+            }
+        }
+    }
+    equals(other) {
+        return CID.equals(this, other);
+    }
+    static equals(self, other) {
+        const unknown = other;
+        return (unknown != null &&
+            self.code === unknown.code &&
+            self.version === unknown.version &&
+            digest_equals(self.multihash, unknown.multihash));
+    }
+    toString(base) {
+        return format(this, base);
+    }
+    toJSON() {
+        return { '/': format(this) };
+    }
+    link() {
+        return this;
+    }
+    [Symbol.toStringTag] = 'CID';
+    // Legacy
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `CID(${this.toString()})`;
+    }
+    /**
+     * Takes any input `value` and returns a `CID` instance if it was
+     * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+     * it will return value back. If `value` is not instance of this CID
+     * class, but is compatible CID it will return new instance of this
+     * `CID` class. Otherwise returns null.
+     *
+     * This allows two different incompatible versions of CID library to
+     * co-exist and interop as long as binary interface is compatible.
+     */
+    static asCID(input) {
+        if (input == null) {
+            return null;
+        }
+        const value = input;
+        if (value instanceof CID) {
+            // If value is instance of CID then we're all set.
+            return value;
+        }
+        else if ((value['/'] != null && value['/'] === value.bytes) || value.asCID === value) {
+            // If value isn't instance of this CID class but `this.asCID === this` or
+            // `value['/'] === value.bytes` is true it is CID instance coming from a
+            // different implementation (diff version or duplicate). In that case we
+            // rebase it to this `CID` implementation so caller is guaranteed to get
+            // instance with expected API.
+            const { version, code, multihash, bytes } = value;
+            return new CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
+        }
+        else if (value[cidSymbol] === true) {
+            // If value is a CID from older implementation that used to be tagged via
+            // symbol we still rebase it to the this `CID` implementation by
+            // delegating that to a constructor.
+            const { version, multihash, code } = value;
+            const digest = digest_decode(multihash);
+            return CID.create(version, code, digest);
+        }
+        else {
+            // Otherwise value is not a CID (or an incompatible version of it) in
+            // which case we return `null`.
+            return null;
+        }
+    }
+    /**
+     * @param version - Version of the CID
+     * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+     * @param digest - (Multi)hash of the of the content.
+     */
+    static create(version, code, digest) {
+        if (typeof code !== 'number') {
+            throw new Error('String codecs are no longer supported');
+        }
+        if (!(digest.bytes instanceof Uint8Array)) {
+            throw new Error('Invalid digest');
+        }
+        switch (version) {
+            case 0: {
+                if (code !== DAG_PB_CODE) {
+                    throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+                }
+                else {
+                    return new CID(version, code, digest, digest.bytes);
+                }
+            }
+            case 1: {
+                const bytes = encodeCID(version, code, digest.bytes);
+                return new CID(version, code, digest, bytes);
+            }
+            default: {
+                throw new Error('Invalid version');
+            }
+        }
+    }
+    /**
+     * Simplified version of `create` for CIDv0.
+     */
+    static createV0(digest) {
+        return CID.create(0, DAG_PB_CODE, digest);
+    }
+    /**
+     * Simplified version of `create` for CIDv1.
+     *
+     * @param code - Content encoding format code.
+     * @param digest - Multihash of the content.
+     */
+    static createV1(code, digest) {
+        return CID.create(1, code, digest);
+    }
+    /**
+     * Decoded a CID from its binary representation. The byte array must contain
+     * only the CID with no additional bytes.
+     *
+     * An error will be thrown if the bytes provided do not contain a valid
+     * binary representation of a CID.
+     */
+    static decode(bytes) {
+        const [cid, remainder] = CID.decodeFirst(bytes);
+        if (remainder.length !== 0) {
+            throw new Error('Incorrect length');
+        }
+        return cid;
+    }
+    /**
+     * Decoded a CID from its binary representation at the beginning of a byte
+     * array.
+     *
+     * Returns an array with the first element containing the CID and the second
+     * element containing the remainder of the original byte array. The remainder
+     * will be a zero-length byte array if the provided bytes only contained a
+     * binary CID representation.
+     */
+    static decodeFirst(bytes) {
+        const specs = CID.inspectBytes(bytes);
+        const prefixSize = specs.size - specs.multihashSize;
+        const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+        if (multihashBytes.byteLength !== specs.multihashSize) {
+            throw new Error('Incorrect length');
+        }
+        const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+        const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+        const cid = specs.version === 0
+            ? CID.createV0(digest)
+            : CID.createV1(specs.codec, digest);
+        return [cid, bytes.subarray(specs.size)];
+    }
+    /**
+     * Inspect the initial bytes of a CID to determine its properties.
+     *
+     * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+     * bytes but for larger multicodec code values and larger multihash digest
+     * lengths these varints can be quite large. It is recommended that at least
+     * 10 bytes be made available in the `initialBytes` argument for a complete
+     * inspection.
+     */
+    static inspectBytes(initialBytes) {
+        let offset = 0;
+        const next = () => {
+            const [i, length] = src_varint_decode(initialBytes.subarray(offset));
+            offset += length;
+            return i;
+        };
+        let version = next();
+        let codec = DAG_PB_CODE;
+        if (version === 18) {
+            // CIDv0
+            version = 0;
+            offset = 0;
+        }
+        else {
+            codec = next();
+        }
+        if (version !== 0 && version !== 1) {
+            throw new RangeError(`Invalid CID version ${version}`);
+        }
+        const prefixSize = offset;
+        const multihashCode = next(); // multihash code
+        const digestSize = next(); // multihash length
+        const size = offset + digestSize;
+        const multihashSize = size - prefixSize;
+        return { version, codec, multihashCode, digestSize, multihashSize, size };
+    }
+    /**
+     * Takes cid in a string representation and creates an instance. If `base`
+     * decoder is not provided will use a default from the configuration. It will
+     * throw an error if encoding of the CID is not compatible with supplied (or
+     * a default decoder).
+     */
+    static parse(source, base) {
+        const [prefix, bytes] = parseCIDtoBytes(source, base);
+        const cid = CID.decode(bytes);
+        if (cid.version === 0 && source[0] !== 'Q') {
+            throw Error('Version 0 CID string must not include multibase prefix');
+        }
+        // Cache string representation to avoid computing it on `this.toString()`
+        baseCache(cid).set(prefix, source);
+        return cid;
+    }
+}
+function parseCIDtoBytes(source, base) {
+    switch (source[0]) {
+        // CIDv0 is parsed differently
+        case 'Q': {
+            const decoder = base ?? base58btc;
+            return [
+                base58btc.prefix,
+                decoder.decode(`${base58btc.prefix}${source}`)
+            ];
+        }
+        case base58btc.prefix: {
+            const decoder = base ?? base58btc;
+            return [base58btc.prefix, decoder.decode(source)];
+        }
+        case base32.prefix: {
+            const decoder = base ?? base32;
+            return [base32.prefix, decoder.decode(source)];
+        }
+        case base36.prefix: {
+            const decoder = base ?? base36;
+            return [base36.prefix, decoder.decode(source)];
+        }
+        default: {
+            if (base == null) {
+                throw Error('To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided');
+            }
+            return [source[0], base.decode(source)];
+        }
+    }
+}
+function toStringV0(bytes, cache, base) {
+    const { prefix } = base;
+    if (prefix !== base58btc.prefix) {
+        throw Error(`Cannot string encode V0 in ${base.name} encoding`);
+    }
+    const cid = cache.get(prefix);
+    if (cid == null) {
+        const cid = base.encode(bytes).slice(1);
+        cache.set(prefix, cid);
+        return cid;
+    }
+    else {
+        return cid;
+    }
+}
+function toStringV1(bytes, cache, base) {
+    const { prefix } = base;
+    const cid = cache.get(prefix);
+    if (cid == null) {
+        const cid = base.encode(bytes);
+        cache.set(prefix, cid);
+        return cid;
+    }
+    else {
+        return cid;
+    }
+}
+const DAG_PB_CODE = 0x70;
+const SHA_256_CODE = 0x12;
+function encodeCID(version, code, multihash) {
+    const codeOffset = encodingLength(version);
+    const hashOffset = codeOffset + encodingLength(code);
+    const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+    encodeTo(version, bytes, 0);
+    encodeTo(code, bytes, codeOffset);
+    bytes.set(multihash, hashOffset);
+    return bytes;
+}
+const cidSymbol = Symbol.for('@ipld/js-cid/CID');
+//# sourceMappingURL=cid.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/bases/interface.js
+// Base encoders / decoders just base encode / decode between binary and
+// textual representation. They are unaware of multibase.
+
+//# sourceMappingURL=interface.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/hashes/interface.js
+// # Multihash
+
+//# sourceMappingURL=interface.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/codecs/interface.js
+
+//# sourceMappingURL=interface.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/block/interface.js
+
+//# sourceMappingURL=interface.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/interface.js
+
+
+
+
+
+//# sourceMappingURL=interface.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/index.js
+/**
+ * @packageDocumentation
+ *
+ * This library defines common interfaces and low level building blocks for various interrelated multiformat technologies (multicodec, multihash, multibase, and CID). They can be used to implement custom base encoders / decoders / codecs, codec encoders /decoders and multihash hashers that comply to the interface that layers above assume.
+ *
+ * This library provides implementations for most basics and many others can be found in linked repositories.
+ *
+ * ```TypeScript
+ * import { CID } from 'multiformats/cid'
+ * import * as json from 'multiformats/codecs/json'
+ * import { sha256 } from 'multiformats/hashes/sha2'
+ *
+ * const bytes = json.encode({ hello: 'world' })
+ *
+ * const hash = await sha256.digest(bytes)
+ * const cid = CID.create(1, json.code, hash)
+ * //> CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)
+ * ```
+ *
+ * ## Creating Blocks
+ *
+ * ```TypeScript
+ * import * as Block from 'multiformats/block'
+ * import * as codec from '@ipld/dag-cbor'
+ * import { sha256 as hasher } from 'multiformats/hashes/sha2'
+ *
+ * const value = { hello: 'world' }
+ *
+ * // encode a block
+ * let block = await Block.encode({ value, codec, hasher })
+ *
+ * block.value // { hello: 'world' }
+ * block.bytes // Uint8Array
+ * block.cid   // CID() w/ sha2-256 hash address and dag-cbor codec
+ *
+ * // you can also decode blocks from their binary state
+ * block = await Block.decode({ bytes: block.bytes, codec, hasher })
+ *
+ * // if you have the cid you can also verify the hash on decode
+ * block = await Block.create({ bytes: block.bytes, cid: block.cid, codec, hasher })
+ * ```
+ *
+ * ## Multibase Encoders / Decoders / Codecs
+ *
+ * CIDs can be serialized to string representation using multibase encoders that implement [`MultibaseEncoder`](https://github.com/multiformats/js-multiformats/blob/master/src/bases/interface.ts) interface. This library provides quite a few implementations that can be imported:
+ *
+ * ```TypeScript
+ * import { base64 } from "multiformats/bases/base64"
+ * cid.toString(base64.encoder)
+ * //> 'mAYAEEiCTojlxqRTl6svwqNJRVM2jCcPBxy+7mRTUfGDzy2gViA'
+ * ```
+ *
+ * Parsing CID string serialized CIDs requires multibase decoder that implements [`MultibaseDecoder`](https://github.com/multiformats/js-multiformats/blob/master/src/bases/interface.ts) interface. This library provides a decoder for every encoder it provides:
+ *
+ * ```TypeScript
+ * CID.parse('mAYAEEiCTojlxqRTl6svwqNJRVM2jCcPBxy+7mRTUfGDzy2gViA', base64.decoder)
+ * //> CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)
+ * ```
+ *
+ * Dual of multibase encoder & decoder is defined as multibase codec and it exposes
+ * them as `encoder` and `decoder` properties. For added convenience codecs also
+ * implement `MultibaseEncoder` and `MultibaseDecoder` interfaces so they could be
+ * used as either or both:
+ *
+ * ```TypeScript
+ * cid.toString(base64)
+ * CID.parse(cid.toString(base64), base64)
+ * ```
+ *
+ * **Note:** CID implementation comes bundled with `base32` and `base58btc`
+ * multibase codecs so that CIDs can be base serialized to (version specific)
+ * default base encoding and parsed without having to supply base encoders/decoders:
+ *
+ * ```TypeScript
+ * const v1 = CID.parse('bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea')
+ * v1.toString()
+ * //> 'bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea'
+ *
+ * const v0 = CID.parse('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')
+ * v0.toString()
+ * //> 'QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n'
+ * v0.toV1().toString()
+ * //> 'bafybeihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku'
+ * ```
+ *
+ * ## Multicodec Encoders / Decoders / Codecs
+ *
+ * This library defines [`BlockEncoder`, `BlockDecoder` and `BlockCodec` interfaces](https://github.com/multiformats/js-multiformats/blob/master/src/codecs/interface.ts).
+ * Codec implementations should conform to the `BlockCodec` interface which implements both `BlockEncoder` and `BlockDecoder`.
+ * Here is an example implementation of JSON `BlockCodec`.
+ *
+ * ```TypeScript
+ * export const { name, code, encode, decode } = {
+ *   name: 'json',
+ *   code: 0x0200,
+ *   encode: json => new TextEncoder().encode(JSON.stringify(json)),
+ *   decode: bytes => JSON.parse(new TextDecoder().decode(bytes))
+ * }
+ * ```
+ *
+ * ## Multihash Hashers
+ *
+ * This library defines [`MultihashHasher` and `MultihashDigest` interfaces](https://github.com/multiformats/js-multiformats/blob/master/src/hashes/interface.ts) and convinient function for implementing them:
+ *
+ * ```TypeScript
+ * import * as hasher from 'multiformats/hashes/hasher'
+ *
+ * const sha256 = hasher.from({
+ *   // As per multiformats table
+ *   // https://github.com/multiformats/multicodec/blob/master/table.csv#L9
+ *   name: 'sha2-256',
+ *   code: 0x12,
+ *
+ *   encode: (input) => new Uint8Array(crypto.createHash('sha256').update(input).digest())
+ * })
+ *
+ * const hash = await sha256.digest(json.encode({ hello: 'world' }))
+ * CID.create(1, json.code, hash)
+ *
+ * //> CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)
+ * ```
+ *
+ * ## Traversal
+ *
+ * This library contains higher-order functions for traversing graphs of data easily.
+ *
+ * `walk()` walks through the links in each block of a DAG calling a user-supplied loader function for each one, in depth-first order with no duplicate block visits. The loader should return a `Block` object and can be used to inspect and collect block ordering for a full DAG walk. The loader should `throw` on error, and return `null` if a block should be skipped by `walk()`.
+ *
+ * ```TypeScript
+ * import { walk } from 'multiformats/traversal'
+ * import * as Block from 'multiformats/block'
+ * import * as codec from 'multiformats/codecs/json'
+ * import { sha256 as hasher } from 'multiformats/hashes/sha2'
+ *
+ * // build a DAG (a single block for this simple example)
+ * const value = { hello: 'world' }
+ * const block = await Block.encode({ value, codec, hasher })
+ * const { cid } = block
+ * console.log(cid)
+ * //> CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)
+ *
+ * // create a loader function that also collects CIDs of blocks in
+ * // their traversal order
+ * const load = (cid, blocks) => async (cid) => {
+ *   // fetch a block using its cid
+ *   // e.g.: const block = await fetchBlockByCID(cid)
+ *   blocks.push(cid)
+ *   return block
+ * }
+ *
+ * // collect blocks in this DAG starting from the root `cid`
+ * const blocks = []
+ * await walk({ cid, load: load(cid, blocks) })
+ *
+ * console.log(blocks)
+ * //> [CID(bagaaierasords4njcts6vs7qvdjfcvgnume4hqohf65zsfguprqphs3icwea)]
+ * ```
+ *
+ * ## Legacy interface
+ *
+ * [`blockcodec-to-ipld-format`](https://github.com/ipld/js-blockcodec-to-ipld-format) converts a multiformats [`BlockCodec`](https://github.com/multiformats/js-multiformats/blob/master/src/codecs/interface.ts#L21) into an
+ * [`interface-ipld-format`](https://github.com/ipld/interface-ipld-format) for use with the [`ipld`](https://github.com/ipld/ipld) package. This can help bridge IPLD codecs implemented using the structure and interfaces defined here to existing code that assumes, or requires `interface-ipld-format`. This bridge also includes the relevant TypeScript definitions.
+ *
+ * ## Implementations
+ *
+ * By default, no base encodings (other than base32 & base58btc), hash functions,
+ * or codec implementations are exposed by `multiformats`, you need to
+ * import the ones you need yourself.
+ *
+ * ### Multibase codecs
+ *
+ * | bases                                                         | import                      | repo                                                                                              |
+ * | ------------------------------------------------------------- | --------------------------- | ------------------------------------------------------------------------------------------------- |
+ * | `base16`                                                      | `multiformats/bases/base16` | [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/bases) |
+ * | `base32`, `base32pad`, `base32hex`, `base32hexpad`, `base32z` | `multiformats/bases/base32` | [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/bases) |
+ * | `base64`, `base64pad`, `base64url`, `base64urlpad`            | `multiformats/bases/base64` | [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/bases) |
+ * | `base58btc`, `base58flick4`                                   | `multiformats/bases/base58` | [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/bases) |
+ *
+ * Other (less useful) bases implemented in [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/bases) include: `base2`, `base8`, `base10`, `base36` and `base256emoji`.
+ *
+ * ### Multihash hashers
+ *
+ * | hashes                                                                                                                          | import                         | repo                                                                                                               |
+ * | ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------ |
+ * | `sha2-256`, `sha2-512`                                                                                                          | `multiformats/hashes/sha2`     | [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/src/hashes)             |
+ * | `sha3-224`, `sha3-256`, `sha3-384`,`sha3-512`, `shake-128`, `shake-256`, `keccak-224`, `keccak-256`, `keccak-384`, `keccak-512` | `@multiformats/sha3`           | [multiformats/js-sha3](https://github.com/multiformats/js-sha3)                                                    |
+ * | `identity`                                                                                                                      | `multiformats/hashes/identity` | [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/src/hashes/identity.js) |
+ * | `murmur3-128`, `murmur3-32`                                                                                                     | `@multiformats/murmur3`        | [multiformats/js-murmur3](https://github.com/multiformats/js-murmur3)                                              |
+ * | `blake2b-*`, `blake2s-*`                                                                                                        | `@multiformats/blake2`         | [multiformats/js-blake2](https://github.com/multiformats/js-blake2)                                                |
+ *
+ * ### IPLD codecs (multicodec)
+ *
+ * | codec      | import                     | repo                                                                                                   |
+ * | ---------- | -------------------------- | ------------------------------------------------------------------------------------------------------ |
+ * | `raw`      | `multiformats/codecs/raw`  | [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/src/codecs) |
+ * | `json`     | `multiformats/codecs/json` | [multiformats/js-multiformats](https://github.com/multiformats/js-multiformats/tree/master/src/codecs) |
+ * | `dag-cbor` | `@ipld/dag-cbor`           | [ipld/js-dag-cbor](https://github.com/ipld/js-dag-cbor)                                                |
+ * | `dag-json` | `@ipld/dag-json`           | [ipld/js-dag-json](https://github.com/ipld/js-dag-json)                                                |
+ * | `dag-pb`   | `@ipld/dag-pb`             | [ipld/js-dag-pb](https://github.com/ipld/js-dag-pb)                                                    |
+ * | `dag-jose` | `dag-jose`                 | [ceramicnetwork/js-dag-jose](https://github.com/ceramicnetwork/js-dag-jose)                            |
+ */
+
+
+
+
+
+// This way TS will also expose all the types from module
+
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/node_modules/multiformats/dist/src/basics.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const bases = { ...identity_namespaceObject, ...base2_namespaceObject, ...base8_namespaceObject, ...base10_namespaceObject, ...base16_namespaceObject, ...base32_namespaceObject, ...base36_namespaceObject, ...base58_namespaceObject, ...base64_namespaceObject, ...base256emoji_namespaceObject };
+const hashes = { ...sha2_browser_namespaceObject, ...hashes_identity_namespaceObject };
+const codecs = { raw: raw_namespaceObject, json: json_namespaceObject };
+
+//# sourceMappingURL=basics.js.map
+// EXTERNAL MODULE: ./node_modules/shogun-ipfs/node_modules/uint8arrays/dist/src/from-string.js
+var from_string = __webpack_require__("./node_modules/shogun-ipfs/node_modules/uint8arrays/dist/src/from-string.js");
+;// ./node_modules/shogun-ipfs/node_modules/@chainsafe/is-ip/lib/is-ip.js
+
+/** Check if `input` is IPv4. */
+function isIPv4(input) {
+    return Boolean(parseIPv4(input));
+}
+/** Check if `input` is IPv6. */
+function isIPv6(input) {
+    return Boolean(parseIPv6(input));
+}
+/** Check if `input` is IPv4 or IPv6. */
+function isIP(input) {
+    return Boolean(parseIP(input));
+}
+/**
+ * @returns `6` if `input` is IPv6, `4` if `input` is IPv4, or `undefined` if `input` is neither.
+ */
+function ipVersion(input) {
+    if (isIPv4(input)) {
+        return 4;
+    }
+    else if (isIPv6(input)) {
+        return 6;
+    }
+    else {
+        return undefined;
+    }
+}
+//# sourceMappingURL=is-ip.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/dist/src/ip.js
+
+
+
+const isV4 = isIPv4;
+const isV6 = isIPv6;
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
+// but with buf/offset args removed because we don't use them
+const toBytes = function (ip) {
+    let offset = 0;
+    ip = ip.toString().trim();
+    if (isV4(ip)) {
+        const bytes = new Uint8Array(offset + 4);
+        ip.split(/\./g).forEach((byte) => {
+            bytes[offset++] = parseInt(byte, 10) & 0xff;
+        });
+        return bytes;
+    }
+    if (isV6(ip)) {
+        const sections = ip.split(':', 8);
+        let i;
+        for (i = 0; i < sections.length; i++) {
+            const isv4 = isV4(sections[i]);
+            let v4Buffer;
+            if (isv4) {
+                v4Buffer = toBytes(sections[i]);
+                sections[i] = (0,to_string.toString)(v4Buffer.slice(0, 2), 'base16');
+            }
+            if (v4Buffer != null && ++i < 8) {
+                sections.splice(i, 0, (0,to_string.toString)(v4Buffer.slice(2, 4), 'base16'));
+            }
+        }
+        if (sections[0] === '') {
+            while (sections.length < 8)
+                sections.unshift('0');
+        }
+        else if (sections[sections.length - 1] === '') {
+            while (sections.length < 8)
+                sections.push('0');
+        }
+        else if (sections.length < 8) {
+            for (i = 0; i < sections.length && sections[i] !== ''; i++)
+                ;
+            const argv = [i, 1];
+            for (i = 9 - sections.length; i > 0; i--) {
+                argv.push('0');
+            }
+            sections.splice.apply(sections, argv);
+        }
+        const bytes = new Uint8Array(offset + 16);
+        for (i = 0; i < sections.length; i++) {
+            const word = parseInt(sections[i], 16);
+            bytes[offset++] = (word >> 8) & 0xff;
+            bytes[offset++] = word & 0xff;
+        }
+        return bytes;
+    }
+    throw new Error('invalid ip address');
+};
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L63
+const ip_toString = function (buf, offset = 0, length) {
+    offset = ~~offset;
+    length = length ?? (buf.length - offset);
+    const view = new DataView(buf.buffer);
+    if (length === 4) {
+        const result = [];
+        // IPv4
+        for (let i = 0; i < length; i++) {
+            result.push(buf[offset + i]);
+        }
+        return result.join('.');
+    }
+    if (length === 16) {
+        const result = [];
+        // IPv6
+        for (let i = 0; i < length; i += 2) {
+            result.push(view.getUint16(offset + i).toString(16));
+        }
+        return result.join(':')
+            .replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3')
+            .replace(/:{3,4}/, '::');
+    }
+    return '';
+};
+//# sourceMappingURL=ip.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/dist/src/protocols-table.js
+const V = -1;
+const names = {};
+const codes = {};
+const table = [
+    [4, 32, 'ip4'],
+    [6, 16, 'tcp'],
+    [33, 16, 'dccp'],
+    [41, 128, 'ip6'],
+    [42, V, 'ip6zone'],
+    [43, 8, 'ipcidr'],
+    [53, V, 'dns', true],
+    [54, V, 'dns4', true],
+    [55, V, 'dns6', true],
+    [56, V, 'dnsaddr', true],
+    [132, 16, 'sctp'],
+    [273, 16, 'udp'],
+    [275, 0, 'p2p-webrtc-star'],
+    [276, 0, 'p2p-webrtc-direct'],
+    [277, 0, 'p2p-stardust'],
+    [280, 0, 'webrtc-direct'],
+    [281, 0, 'webrtc'],
+    [290, 0, 'p2p-circuit'],
+    [301, 0, 'udt'],
+    [302, 0, 'utp'],
+    [400, V, 'unix', false, true],
+    // `ipfs` is added before `p2p` for legacy support.
+    // All text representations will default to `p2p`, but `ipfs` will
+    // still be supported
+    [421, V, 'ipfs'],
+    // `p2p` is the preferred name for 421, and is now the default
+    [421, V, 'p2p'],
+    [443, 0, 'https'],
+    [444, 96, 'onion'],
+    [445, 296, 'onion3'],
+    [446, V, 'garlic64'],
+    [448, 0, 'tls'],
+    [449, V, 'sni'],
+    [460, 0, 'quic'],
+    [461, 0, 'quic-v1'],
+    [465, 0, 'webtransport'],
+    [466, V, 'certhash'],
+    [477, 0, 'ws'],
+    [478, 0, 'wss'],
+    [479, 0, 'p2p-websocket-star'],
+    [480, 0, 'http'],
+    [481, V, 'http-path'],
+    [777, V, 'memory']
+];
+// populate tables
+table.forEach(row => {
+    const proto = createProtocol(...row);
+    codes[proto.code] = proto;
+    names[proto.name] = proto;
+});
+function createProtocol(code, size, name, resolvable, path) {
+    return {
+        code,
+        size,
+        name,
+        resolvable: Boolean(resolvable),
+        path: Boolean(path)
+    };
+}
+/**
+ * For the passed proto string or number, return a {@link Protocol}
+ *
+ * @example
+ *
+ * ```js
+ * import { protocol } from '@multiformats/multiaddr'
+ *
+ * console.info(protocol(4))
+ * // { code: 4, size: 32, name: 'ip4', resolvable: false, path: false }
+ * ```
+ */
+function getProtocol(proto) {
+    if (typeof proto === 'number') {
+        if (codes[proto] != null) {
+            return codes[proto];
+        }
+        throw new Error(`no protocol with code: ${proto}`);
+    }
+    else if (typeof proto === 'string') {
+        if (names[proto] != null) {
+            return names[proto];
+        }
+        throw new Error(`no protocol with name: ${proto}`);
+    }
+    throw new Error(`invalid protocol id type: ${typeof proto}`);
+}
+//# sourceMappingURL=protocols-table.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/dist/src/convert.js
+
+
+
+
+
+
+
+
+
+
+
+
+const ip4Protocol = getProtocol('ip4');
+const ip6Protocol = getProtocol('ip6');
+const ipcidrProtocol = getProtocol('ipcidr');
+function convert(proto, a) {
+    if (a instanceof Uint8Array) {
+        return convertToString(proto, a);
+    }
+    else {
+        return convertToBytes(proto, a);
+    }
+}
+/**
+ * Convert [code,Uint8Array] to string
+ */
+// eslint-disable-next-line complexity
+function convertToString(proto, buf) {
+    const protocol = getProtocol(proto);
+    switch (protocol.code) {
+        case 4: // ipv4
+        case 41: // ipv6
+            return bytes2ip(buf);
+        case 42: // ipv6zone
+            return bytes2str(buf);
+        case 43: // ipcidr
+            return (0,to_string.toString)(buf, 'base10');
+        case 6: // tcp
+        case 273: // udp
+        case 33: // dccp
+        case 132: // sctp
+            return bytes2port(buf).toString();
+        case 53: // dns
+        case 54: // dns4
+        case 55: // dns6
+        case 56: // dnsaddr
+        case 400: // unix
+        case 449: // sni
+        case 777: // memory
+            return bytes2str(buf);
+        case 421: // ipfs
+            return bytes2mh(buf);
+        case 444: // onion
+            return bytes2onion(buf);
+        case 445: // onion3
+            return bytes2onion(buf);
+        case 466: // certhash
+            return bytes2mb(buf);
+        case 481: // http-path
+            return globalThis.encodeURIComponent(bytes2str(buf));
+        default:
+            return (0,to_string.toString)(buf, 'base16'); // no clue. convert to hex
+    }
+}
+// eslint-disable-next-line complexity
+function convertToBytes(proto, str) {
+    const protocol = getProtocol(proto);
+    switch (protocol.code) {
+        case 4: // ipv4
+            return ip2bytes(str);
+        case 41: // ipv6
+            return ip2bytes(str);
+        case 42: // ipv6zone
+            return str2bytes(str);
+        case 43: // ipcidr
+            return (0,from_string.fromString)(str, 'base10');
+        case 6: // tcp
+        case 273: // udp
+        case 33: // dccp
+        case 132: // sctp
+            return port2bytes(parseInt(str, 10));
+        case 53: // dns
+        case 54: // dns4
+        case 55: // dns6
+        case 56: // dnsaddr
+        case 400: // unix
+        case 449: // sni
+        case 777: // memory
+            return str2bytes(str);
+        case 421: // ipfs
+            return mh2bytes(str);
+        case 444: // onion
+            return onion2bytes(str);
+        case 445: // onion3
+            return onion32bytes(str);
+        case 466: // certhash
+            return mb2bytes(str);
+        case 481: // http-path
+            return str2bytes(globalThis.decodeURIComponent(str));
+        default:
+            return (0,from_string.fromString)(str, 'base16'); // no clue. convert from hex
+    }
+}
+function convertToIpNet(multiaddr) {
+    let mask;
+    let addr;
+    multiaddr.stringTuples().forEach(([code, value]) => {
+        if (code === ip4Protocol.code || code === ip6Protocol.code) {
+            addr = value;
+        }
+        if (code === ipcidrProtocol.code) {
+            mask = value;
+        }
+    });
+    if (mask == null || addr == null) {
+        throw new Error('Invalid multiaddr');
+    }
+    return new IpNet(addr, mask);
+}
+const decoders = Object.values(bases).map((c) => c.decoder);
+const anybaseDecoder = (function () {
+    let acc = decoders[0].or(decoders[1]);
+    decoders.slice(2).forEach((d) => (acc = acc.or(d)));
+    return acc;
+})();
+function ip2bytes(ipString) {
+    if (!isIP(ipString)) {
+        throw new Error('invalid ip address');
+    }
+    return toBytes(ipString);
+}
+function bytes2ip(ipBuff) {
+    const ipString = ip_toString(ipBuff, 0, ipBuff.length);
+    if (ipString == null) {
+        throw new Error('ipBuff is required');
+    }
+    if (!isIP(ipString)) {
+        throw new Error('invalid ip address');
+    }
+    return ipString;
+}
+function port2bytes(port) {
+    const buf = new ArrayBuffer(2);
+    const view = new DataView(buf);
+    view.setUint16(0, port);
+    return new Uint8Array(buf);
+}
+function bytes2port(buf) {
+    const view = new DataView(buf.buffer);
+    return view.getUint16(buf.byteOffset);
+}
+function str2bytes(str) {
+    const buf = (0,from_string.fromString)(str);
+    const size = Uint8Array.from(src.encode(buf.length));
+    return (0,concat.concat)([size, buf], size.length + buf.length);
+}
+function bytes2str(buf) {
+    const size = src.decode(buf);
+    buf = buf.slice(src.encodingLength(size));
+    if (buf.length !== size) {
+        throw new Error('inconsistent lengths');
+    }
+    return (0,to_string.toString)(buf);
+}
+function mh2bytes(hash) {
+    let mh;
+    if (hash[0] === 'Q' || hash[0] === '1') {
+        mh = digest_decode(base58btc.decode(`z${hash}`)).bytes;
+    }
+    else {
+        mh = CID.parse(hash).multihash.bytes;
+    }
+    // the address is a varint prefixed multihash string representation
+    const size = Uint8Array.from(src.encode(mh.length));
+    return (0,concat.concat)([size, mh], size.length + mh.length);
+}
+function mb2bytes(mbstr) {
+    const mb = anybaseDecoder.decode(mbstr);
+    const size = Uint8Array.from(src.encode(mb.length));
+    return (0,concat.concat)([size, mb], size.length + mb.length);
+}
+function bytes2mb(buf) {
+    const size = src.decode(buf);
+    const hash = buf.slice(src.encodingLength(size));
+    if (hash.length !== size) {
+        throw new Error('inconsistent lengths');
+    }
+    return 'u' + (0,to_string.toString)(hash, 'base64url');
+}
+/**
+ * Converts bytes to bas58btc string
+ */
+function bytes2mh(buf) {
+    const size = src.decode(buf);
+    const address = buf.slice(src.encodingLength(size));
+    if (address.length !== size) {
+        throw new Error('inconsistent lengths');
+    }
+    return (0,to_string.toString)(address, 'base58btc');
+}
+function onion2bytes(str) {
+    const addr = str.split(':');
+    if (addr.length !== 2) {
+        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
+    }
+    if (addr[0].length !== 16) {
+        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion address.`);
+    }
+    // onion addresses do not include the multibase prefix, add it before decoding
+    const buf = base32.decode('b' + addr[0]);
+    // onion port number
+    const port = parseInt(addr[1], 10);
+    if (port < 1 || port > 65536) {
+        throw new Error('Port number is not in range(1, 65536)');
+    }
+    const portBuf = port2bytes(port);
+    return (0,concat.concat)([buf, portBuf], buf.length + portBuf.length);
+}
+function onion32bytes(str) {
+    const addr = str.split(':');
+    if (addr.length !== 2) {
+        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
+    }
+    if (addr[0].length !== 56) {
+        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion3 address.`);
+    }
+    // onion addresses do not include the multibase prefix, add it before decoding
+    const buf = base32.decode(`b${addr[0]}`);
+    // onion port number
+    const port = parseInt(addr[1], 10);
+    if (port < 1 || port > 65536) {
+        throw new Error('Port number is not in range(1, 65536)');
+    }
+    const portBuf = port2bytes(port);
+    return (0,concat.concat)([buf, portBuf], buf.length + portBuf.length);
+}
+function bytes2onion(buf) {
+    const addrBytes = buf.slice(0, buf.length - 2);
+    const portBytes = buf.slice(buf.length - 2);
+    const addr = (0,to_string.toString)(addrBytes, 'base32');
+    const port = bytes2port(portBytes);
+    return `${addr}:${port}`;
+}
+//# sourceMappingURL=convert.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/dist/src/codec.js
+
+
+
+
+
+function stringToMultiaddrParts(str) {
+    str = cleanPath(str);
+    const tuples = [];
+    const stringTuples = [];
+    let path = null;
+    const parts = str.split('/').slice(1);
+    if (parts.length === 1 && parts[0] === '') {
+        return {
+            bytes: new Uint8Array(),
+            string: '/',
+            tuples: [],
+            stringTuples: [],
+            path: null
+        };
+    }
+    for (let p = 0; p < parts.length; p++) {
+        const part = parts[p];
+        const proto = getProtocol(part);
+        if (proto.size === 0) {
+            tuples.push([proto.code]);
+            stringTuples.push([proto.code]);
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        p++; // advance addr part
+        if (p >= parts.length) {
+            throw new ParseError('invalid address: ' + str);
+        }
+        // if it's a path proto, take the rest
+        if (proto.path === true) {
+            // should we need to check each path part to see if it's a proto?
+            // This would allow for other protocols to be added after a unix path,
+            // however it would have issues if the path had a protocol name in the path
+            path = cleanPath(parts.slice(p).join('/'));
+            tuples.push([proto.code, convertToBytes(proto.code, path)]);
+            stringTuples.push([proto.code, path]);
+            break;
+        }
+        const bytes = convertToBytes(proto.code, parts[p]);
+        tuples.push([proto.code, bytes]);
+        stringTuples.push([proto.code, convertToString(proto.code, bytes)]);
+    }
+    return {
+        string: stringTuplesToString(stringTuples),
+        bytes: tuplesToBytes(tuples),
+        tuples,
+        stringTuples,
+        path
+    };
+}
+function bytesToMultiaddrParts(bytes) {
+    const tuples = [];
+    const stringTuples = [];
+    let path = null;
+    let i = 0;
+    while (i < bytes.length) {
+        const code = src.decode(bytes, i);
+        const n = src.encodingLength(code);
+        const p = getProtocol(code);
+        const size = sizeForAddr(p, bytes.slice(i + n));
+        if (size === 0) {
+            tuples.push([code]);
+            stringTuples.push([code]);
+            i += n;
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        const addr = bytes.slice(i + n, i + n + size);
+        i += (size + n);
+        if (i > bytes.length) { // did not end _exactly_ at buffer.length
+            throw new ParseError('Invalid address Uint8Array: ' + (0,to_string.toString)(bytes, 'base16'));
+        }
+        // ok, tuple seems good.
+        tuples.push([code, addr]);
+        const stringAddr = convertToString(code, addr);
+        stringTuples.push([code, stringAddr]);
+        if (p.path === true) {
+            // should we need to check each path part to see if it's a proto?
+            // This would allow for other protocols to be added after a unix path,
+            // however it would have issues if the path had a protocol name in the path
+            path = stringAddr;
+            break;
+        }
+    }
+    return {
+        bytes: Uint8Array.from(bytes),
+        string: stringTuplesToString(stringTuples),
+        tuples,
+        stringTuples,
+        path
+    };
+}
+/**
+ * [[num code, str value?]... ] -> Tuple[]
+ */
+function stringTuplesToTuples(stringTuples) {
+    const tuples = [];
+    stringTuples.forEach(([code, value]) => {
+        const tuple = [code];
+        if (value != null) {
+            tuple[1] = convertToBytes(code, value);
+        }
+        tuples.push(tuple);
+    });
+    return tuples;
+}
+/**
+ * [[num code, str value?]... ] -> string
+ */
+function stringTuplesToString(tuples) {
+    const parts = [];
+    tuples.map((tup) => {
+        const proto = getProtocol(tup[0]);
+        parts.push(proto.name);
+        if (tup.length > 1 && tup[1] != null) {
+            parts.push(tup[1]);
+        }
+        return null;
+    });
+    return cleanPath(parts.join('/'));
+}
+/**
+ * [[int code, Uint8Array ]... ] -> Uint8Array
+ */
+function tuplesToBytes(tuples) {
+    return (0,concat.concat)(tuples.map((tup) => {
+        const proto = getProtocol(tup[0]);
+        let buf = Uint8Array.from(src.encode(proto.code));
+        if (tup.length > 1 && tup[1] != null) {
+            buf = (0,concat.concat)([buf, tup[1]]); // add address buffer
+        }
+        return buf;
+    }));
+}
+/**
+ * For the passed address, return the serialized size
+ */
+function sizeForAddr(p, addr) {
+    if (p.size > 0) {
+        return p.size / 8;
+    }
+    else if (p.size === 0) {
+        return 0;
+    }
+    else {
+        const size = src.decode(addr instanceof Uint8Array ? addr : Uint8Array.from(addr));
+        return size + src.encodingLength(size);
+    }
+}
+function bytesToTuples(buf) {
+    const tuples = [];
+    let i = 0;
+    while (i < buf.length) {
+        const code = src.decode(buf, i);
+        const n = src.encodingLength(code);
+        const p = getProtocol(code);
+        const size = sizeForAddr(p, buf.slice(i + n));
+        if (size === 0) {
+            tuples.push([code]);
+            i += n;
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        const addr = buf.slice(i + n, i + n + size);
+        i += (size + n);
+        if (i > buf.length) { // did not end _exactly_ at buffer.length
+            throw new ParseError('Invalid address Uint8Array: ' + (0,to_string.toString)(buf, 'base16'));
+        }
+        // ok, tuple seems good.
+        tuples.push([code, addr]);
+    }
+    return tuples;
+}
+function cleanPath(str) {
+    return '/' + str.trim().split('/').filter((a) => a).join('/');
+}
+class ParseError extends Error {
+    static name = 'ParseError';
+    name = 'ParseError';
+    constructor(str) {
+        super(`Error parsing address: ${str}`);
+    }
+}
+//# sourceMappingURL=codec.js.map
+// EXTERNAL MODULE: ./node_modules/shogun-ipfs/node_modules/uint8arrays/dist/src/equals.js
+var src_equals = __webpack_require__("./node_modules/shogun-ipfs/node_modules/uint8arrays/dist/src/equals.js");
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/dist/src/multiaddr.js
+/* eslint-disable complexity */
+
+
+
+
+
+
+
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const symbol = Symbol.for('@multiformats/js-multiaddr/multiaddr');
+const DNS_CODES = [
+    getProtocol('dns').code,
+    getProtocol('dns4').code,
+    getProtocol('dns6').code,
+    getProtocol('dnsaddr').code
+];
+class NoAvailableResolverError extends Error {
+    constructor(message = 'No available resolver') {
+        super(message);
+        this.name = 'NoAvailableResolverError';
+    }
+}
+/**
+ * Creates a {@link Multiaddr} from a {@link MultiaddrInput}
+ */
+class Multiaddr {
+    bytes;
+    #string;
+    #tuples;
+    #stringTuples;
+    #path;
+    [symbol] = true;
+    constructor(addr) {
+        // default
+        if (addr == null) {
+            addr = '';
+        }
+        let parts;
+        if (addr instanceof Uint8Array) {
+            parts = bytesToMultiaddrParts(addr);
+        }
+        else if (typeof addr === 'string') {
+            if (addr.length > 0 && addr.charAt(0) !== '/') {
+                throw new Error(`multiaddr "${addr}" must start with a "/"`);
+            }
+            parts = stringToMultiaddrParts(addr);
+        }
+        else if (isMultiaddr(addr)) { // Multiaddr
+            parts = bytesToMultiaddrParts(addr.bytes);
+        }
+        else {
+            throw new Error('addr must be a string, Buffer, or another Multiaddr');
+        }
+        this.bytes = parts.bytes;
+        this.#string = parts.string;
+        this.#tuples = parts.tuples;
+        this.#stringTuples = parts.stringTuples;
+        this.#path = parts.path;
+    }
+    toString() {
+        return this.#string;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    toOptions() {
+        let family;
+        let transport;
+        let host;
+        let port;
+        let zone = '';
+        const tcp = getProtocol('tcp');
+        const udp = getProtocol('udp');
+        const ip4 = getProtocol('ip4');
+        const ip6 = getProtocol('ip6');
+        const dns6 = getProtocol('dns6');
+        const ip6zone = getProtocol('ip6zone');
+        for (const [code, value] of this.stringTuples()) {
+            if (code === ip6zone.code) {
+                zone = `%${value ?? ''}`;
+            }
+            // default to https when protocol & port are omitted from DNS addrs
+            if (DNS_CODES.includes(code)) {
+                transport = tcp.name === 'tcp' ? 'tcp' : 'udp';
+                port = 443;
+                host = `${value ?? ''}${zone}`;
+                family = code === dns6.code ? 6 : 4;
+            }
+            if (code === tcp.code || code === udp.code) {
+                transport = getProtocol(code).name === 'tcp' ? 'tcp' : 'udp';
+                port = parseInt(value ?? '');
+            }
+            if (code === ip4.code || code === ip6.code) {
+                transport = getProtocol(code).name === 'tcp' ? 'tcp' : 'udp';
+                host = `${value ?? ''}${zone}`;
+                family = code === ip6.code ? 6 : 4;
+            }
+        }
+        if (family == null || transport == null || host == null || port == null) {
+            throw new Error('multiaddr must have a valid format: "/{ip4, ip6, dns4, dns6, dnsaddr}/{address}/{tcp, udp}/{port}".');
+        }
+        const opts = {
+            family,
+            host,
+            transport,
+            port
+        };
+        return opts;
+    }
+    protos() {
+        return this.#tuples.map(([code]) => Object.assign({}, getProtocol(code)));
+    }
+    protoCodes() {
+        return this.#tuples.map(([code]) => code);
+    }
+    protoNames() {
+        return this.#tuples.map(([code]) => getProtocol(code).name);
+    }
+    tuples() {
+        return this.#tuples.map(([code, value]) => {
+            if (value == null) {
+                return [code];
+            }
+            return [code, value];
+        });
+    }
+    stringTuples() {
+        return this.#stringTuples.map(([code, value]) => {
+            if (value == null) {
+                return [code];
+            }
+            return [code, value];
+        });
+    }
+    encapsulate(addr) {
+        addr = new Multiaddr(addr);
+        return new Multiaddr(this.toString() + addr.toString());
+    }
+    decapsulate(addr) {
+        const addrString = addr.toString();
+        const s = this.toString();
+        const i = s.lastIndexOf(addrString);
+        if (i < 0) {
+            throw new Error(`Address ${this.toString()} does not contain subaddress: ${addr.toString()}`);
+        }
+        return new Multiaddr(s.slice(0, i));
+    }
+    decapsulateCode(code) {
+        const tuples = this.tuples();
+        for (let i = tuples.length - 1; i >= 0; i--) {
+            if (tuples[i][0] === code) {
+                return new Multiaddr(tuplesToBytes(tuples.slice(0, i)));
+            }
+        }
+        return this;
+    }
+    getPeerId() {
+        try {
+            let tuples = [];
+            this.stringTuples().forEach(([code, name]) => {
+                if (code === names.p2p.code) {
+                    tuples.push([code, name]);
+                }
+                // if this is a p2p-circuit address, return the target peer id if present
+                // not the peer id of the relay
+                if (code === names['p2p-circuit'].code) {
+                    tuples = [];
+                }
+            });
+            // Get the last ipfs tuple ['p2p', 'peerid string']
+            const tuple = tuples.pop();
+            if (tuple?.[1] != null) {
+                const peerIdStr = tuple[1];
+                // peer id is base58btc encoded string but not multibase encoded so add the `z`
+                // prefix so we can validate that it is correctly encoded
+                if (peerIdStr[0] === 'Q' || peerIdStr[0] === '1') {
+                    return (0,to_string.toString)(base58btc.decode(`z${peerIdStr}`), 'base58btc');
+                }
+                // try to parse peer id as CID
+                return (0,to_string.toString)(CID.parse(peerIdStr).multihash.bytes, 'base58btc');
+            }
+            return null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    getPath() {
+        return this.#path;
+    }
+    equals(addr) {
+        return (0,src_equals.equals)(this.bytes, addr.bytes);
+    }
+    async resolve(options) {
+        const resolvableProto = this.protos().find((p) => p.resolvable);
+        // Multiaddr is not resolvable?
+        if (resolvableProto == null) {
+            return [this];
+        }
+        const resolver = resolvers.get(resolvableProto.name);
+        if (resolver == null) {
+            throw new NoAvailableResolverError(`no available resolver for ${resolvableProto.name}`);
+        }
+        const result = await resolver(this, options);
+        return result.map(str => multiaddr(str));
+    }
+    nodeAddress() {
+        const options = this.toOptions();
+        if (options.transport !== 'tcp' && options.transport !== 'udp') {
+            throw new Error(`multiaddr must have a valid format - no protocol with name: "${options.transport}". Must have a valid transport protocol: "{tcp, udp}"`);
+        }
+        return {
+            family: options.family,
+            address: options.host,
+            port: options.port
+        };
+    }
+    isThinWaistAddress(addr) {
+        const protos = (addr ?? this).protos();
+        if (protos.length !== 2) {
+            return false;
+        }
+        if (protos[0].code !== 4 && protos[0].code !== 41) {
+            return false;
+        }
+        if (protos[1].code !== 6 && protos[1].code !== 273) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Returns Multiaddr as a human-readable string
+     * https://nodejs.org/api/util.html#utilinspectcustom
+     *
+     * @example
+     * ```js
+     * import { multiaddr } from '@multiformats/multiaddr'
+     *
+     * console.info(multiaddr('/ip4/127.0.0.1/tcp/4001'))
+     * // 'Multiaddr(/ip4/127.0.0.1/tcp/4001)'
+     * ```
+     */
+    [inspect]() {
+        return `Multiaddr(${this.#string})`;
+    }
+}
+//# sourceMappingURL=multiaddr.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/dist/src/filter/multiaddr-filter.js
+
+
+/**
+ * A utility class to determine if a Multiaddr contains another
+ * multiaddr.
+ *
+ * This can be used with ipcidr ranges to determine if a given
+ * multiaddr is in a ipcidr range.
+ *
+ * @example
+ *
+ * ```js
+ * import { multiaddr, MultiaddrFilter } from '@multiformats/multiaddr'
+ *
+ * const range = multiaddr('/ip4/192.168.10.10/ipcidr/24')
+ * const filter = new MultiaddrFilter(range)
+ *
+ * const input = multiaddr('/ip4/192.168.10.2/udp/60')
+ * console.info(filter.contains(input)) // true
+ * ```
+ */
+class MultiaddrFilter {
+    multiaddr;
+    netmask;
+    constructor(input) {
+        this.multiaddr = multiaddr(input);
+        this.netmask = convertToIpNet(this.multiaddr);
+    }
+    contains(input) {
+        if (input == null)
+            return false;
+        const m = multiaddr(input);
+        let ip;
+        for (const [code, value] of m.stringTuples()) {
+            if (code === 4 || code === 41) {
+                ip = value;
+                break;
+            }
+        }
+        if (ip === undefined)
+            return false;
+        return this.netmask.contains(ip);
+    }
+}
+//# sourceMappingURL=multiaddr-filter.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/multiaddr/dist/src/index.js
+/**
+ * @packageDocumentation
+ *
+ * A standard way to represent addresses that
+ *
+ * - support any standard network protocol
+ * - are self-describing
+ * - have a binary packed format
+ * - have a nice string representation
+ * - encapsulate well
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const addr = multiaddr('/ip4/127.0.0.1/udp/1234')
+ * // Multiaddr(/ip4/127.0.0.1/udp/1234)
+ *
+ * addr.bytes
+ * // <Uint8Array 04 7f 00 00 01 11 04 d2>
+ *
+ * addr.toString()
+ * // '/ip4/127.0.0.1/udp/1234'
+ *
+ * addr.protos()
+ * // [
+ * //   {code: 4, name: 'ip4', size: 32},
+ * //   {code: 273, name: 'udp', size: 16}
+ * // ]
+ *
+ * // gives you an object that is friendly with what Node.js core modules expect for addresses
+ * addr.nodeAddress()
+ * // {
+ * //   family: 4,
+ * //   port: 1234,
+ * //   address: "127.0.0.1"
+ * // }
+ *
+ * addr.encapsulate('/sctp/5678')
+ * // Multiaddr(/ip4/127.0.0.1/udp/1234/sctp/5678)
+ * ```
+ *
+ * ## Resolving DNSADDR addresses
+ *
+ * [DNSADDR](https://github.com/multiformats/multiaddr/blob/master/protocols/DNSADDR.md) is a spec that allows storing a TXT DNS record that contains a Multiaddr.
+ *
+ * To resolve DNSADDR addresses, call the `.resolve()` function the multiaddr, optionally passing a `DNS` resolver.
+ *
+ * DNSADDR addresses can resolve to multiple multiaddrs, since there is no limit to the number of TXT records that can be stored.
+ *
+ * @example Resolving DNSADDR Multiaddrs
+ *
+ * ```TypeScript
+ * import { multiaddr, resolvers } from '@multiformats/multiaddr'
+ * import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
+ *
+ * resolvers.set('dnsaddr', dnsaddrResolver)
+ *
+ * const ma = multiaddr('/dnsaddr/bootstrap.libp2p.io')
+ *
+ * // resolve with a 5s timeout
+ * const resolved = await ma.resolve({
+ *   signal: AbortSignal.timeout(5000)
+ * })
+ *
+ * console.info(resolved)
+ * // [Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...')...]
+ * ```
+ *
+ * @example Using a custom DNS resolver to resolve DNSADDR Multiaddrs
+ *
+ * See the docs for [@multiformats/dns](https://www.npmjs.com/package/@multiformats/dns) for a full breakdown of how to specify multiple resolvers or resolvers that can be used for specific TLDs.
+ *
+ * ```TypeScript
+ * import { multiaddr } from '@multiformats/multiaddr'
+ * import { dns } from '@multiformats/dns'
+ * import { dnsJsonOverHttps } from '@multiformats/dns/resolvers'
+ *
+ * const resolver = dns({
+ *   resolvers: {
+ *     '.': dnsJsonOverHttps('https://cloudflare-dns.com/dns-query')
+ *   }
+ * })
+ *
+ * const ma = multiaddr('/dnsaddr/bootstrap.libp2p.io')
+ * const resolved = await ma.resolve({
+ *  dns: resolver
+ * })
+ *
+ * console.info(resolved)
+ * // [Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...')...]
+ * ```
+ */
+
+
+
+/**
+ * All configured {@link Resolver}s
+ */
+const resolvers = new Map();
+
+/**
+ * Creates a Multiaddr from a node-friendly address object
+ *
+ * @example
+ * ```js
+ * import { fromNodeAddress } from '@multiformats/multiaddr'
+ *
+ * fromNodeAddress({address: '127.0.0.1', port: '4001'}, 'tcp')
+ * // Multiaddr(/ip4/127.0.0.1/tcp/4001)
+ * ```
+ */
+function fromNodeAddress(addr, transport) {
+    if (addr == null) {
+        throw new Error('requires node address object');
+    }
+    if (transport == null) {
+        throw new Error('requires transport protocol');
+    }
+    let ip;
+    let host = addr.address;
+    switch (addr.family) {
+        case 4:
+            ip = 'ip4';
+            break;
+        case 6:
+            ip = 'ip6';
+            if (host.includes('%')) {
+                const parts = host.split('%');
+                if (parts.length !== 2) {
+                    throw Error('Multiple ip6 zones in multiaddr');
+                }
+                host = parts[0];
+                const zone = parts[1];
+                ip = `/ip6zone/${zone}/ip6`;
+            }
+            break;
+        default:
+            throw Error('Invalid addr family, should be 4 or 6.');
+    }
+    return new Multiaddr('/' + [ip, host, transport, addr.port].join('/'));
+}
+/**
+ * Create a {@link Multiaddr} from an array of {@link Tuple}s
+ *
+ * @example
+ *
+ * ```ts
+ * import { fromTuples, multiaddr } from '@multiformats/multiaddr'
+ *
+ * const ma = multiaddr('/ip4/127.0.0.1')
+ * const tuples = ma.tuples()
+ *
+ * const ma2 = fromTuples(tuples)
+ *
+ * console.info(ma2)
+ * // '/ip4/127.0.0.1'
+ * ```
+ */
+function fromTuples(tuples) {
+    return multiaddr(tuplesToBytes(tuples));
+}
+/**
+ * Create a {@link Multiaddr} from an array of {@link StringTuple}s
+ *
+ * @example
+ *
+ * ```ts
+ * import { fromStringTuples, multiaddr } from '@multiformats/multiaddr'
+ *
+ * const ma = multiaddr('/ip4/127.0.0.1')
+ * const tuples = ma.stringTuples()
+ *
+ * const ma2 = fromStringTuples(tuples)
+ *
+ * console.info(ma2)
+ * // '/ip4/127.0.0.1'
+ * ```
+ */
+function fromStringTuples(tuples) {
+    return fromTuples(stringTuplesToTuples(tuples));
+}
+/**
+ * Returns if something is a {@link Multiaddr} that is a resolvable name
+ *
+ * @example
+ *
+ * ```js
+ * import { isName, multiaddr } from '@multiformats/multiaddr'
+ *
+ * isName(multiaddr('/ip4/127.0.0.1'))
+ * // false
+ * isName(multiaddr('/dns/ipfs.io'))
+ * // true
+ * ```
+ */
+function isName(addr) {
+    if (!isMultiaddr(addr)) {
+        return false;
+    }
+    // if a part of the multiaddr is resolvable, then return true
+    return addr.protos().some((proto) => proto.resolvable);
+}
+/**
+ * Check if object is a {@link Multiaddr} instance
+ *
+ * @example
+ *
+ * ```js
+ * import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
+ *
+ * isMultiaddr(5)
+ * // false
+ * isMultiaddr(multiaddr('/ip4/127.0.0.1'))
+ * // true
+ * ```
+ */
+function isMultiaddr(value) {
+    return Boolean(value?.[symbol]);
+}
+/**
+ * A function that takes a {@link MultiaddrInput} and returns a {@link Multiaddr}
+ *
+ * @example
+ * ```js
+ * import { multiaddr } from '@libp2p/multiaddr'
+ *
+ * multiaddr('/ip4/127.0.0.1/tcp/4001')
+ * // Multiaddr(/ip4/127.0.0.1/tcp/4001)
+ * ```
+ *
+ * @param {MultiaddrInput} [addr] - If String or Uint8Array, needs to adhere to the address format of a [multiaddr](https://github.com/multiformats/multiaddr#string-format)
+ */
+function multiaddr(addr) {
+    return new Multiaddr(addr);
+}
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/shogun-ipfs/node_modules/@multiformats/mafmt/dist/src/index.js
+
+/*
+ * Valid combinations
+ */
+const DNS4 = src_base('dns4');
+const DNS6 = src_base('dns6');
+const DNSADDR = src_base('dnsaddr');
+const DNS = src_or(src_base('dns'), DNSADDR, DNS4, DNS6);
+const IP = src_or(src_base('ip4'), src_base('ip6'));
+const TCP = src_or(and(IP, src_base('tcp')), and(DNS, src_base('tcp')));
+const UDP = and(IP, src_base('udp'));
+const UTP = and(UDP, src_base('utp'));
+const QUIC = and(UDP, src_base('quic'));
+const QUICV1 = and(UDP, src_base('quic-v1'));
+const _WebSockets = src_or(and(TCP, src_base('ws')), and(DNS, src_base('ws')));
+const WebSockets = src_or(and(_WebSockets, src_base('p2p')), _WebSockets);
+const _WebSocketsSecure = src_or(and(TCP, src_base('wss')), and(DNS, src_base('wss')), and(TCP, src_base('tls'), src_base('ws')), and(DNS, src_base('tls'), src_base('ws')));
+const WebSocketsSecure = src_or(and(_WebSocketsSecure, src_base('p2p')), _WebSocketsSecure);
+const HTTP = src_or(and(TCP, src_base('http')), and(IP, src_base('http')), and(DNS, src_base('http')));
+const HTTPS = src_or(and(TCP, src_base('https')), and(IP, src_base('https')), and(DNS, src_base('https')));
+const _WebRTCDirect = and(UDP, src_base('webrtc-direct'), src_base('certhash'));
+const WebRTCDirect = src_or(and(_WebRTCDirect, src_base('p2p')), _WebRTCDirect);
+const _WebTransport = and(QUICV1, src_base('webtransport'), src_base('certhash'), src_base('certhash'));
+const WebTransport = src_or(and(_WebTransport, src_base('p2p')), _WebTransport);
+/**
+ * @deprecated
+ */
+const P2PWebRTCStar = src_or(and(WebSockets, src_base('p2p-webrtc-star'), src_base('p2p')), and(WebSocketsSecure, src_base('p2p-webrtc-star'), src_base('p2p')), and(WebSockets, src_base('p2p-webrtc-star')), and(WebSocketsSecure, src_base('p2p-webrtc-star')));
+const WebSocketStar = src_or(and(WebSockets, src_base('p2p-websocket-star'), src_base('p2p')), and(WebSocketsSecure, src_base('p2p-websocket-star'), src_base('p2p')), and(WebSockets, src_base('p2p-websocket-star')), and(WebSocketsSecure, src_base('p2p-websocket-star')));
+/**
+ * @deprecated
+ */
+const P2PWebRTCDirect = src_or(and(HTTP, src_base('p2p-webrtc-direct'), src_base('p2p')), and(HTTPS, src_base('p2p-webrtc-direct'), src_base('p2p')), and(HTTP, src_base('p2p-webrtc-direct')), and(HTTPS, src_base('p2p-webrtc-direct')));
+const Reliable = src_or(_WebSockets, _WebSocketsSecure, HTTP, HTTPS, P2PWebRTCStar, P2PWebRTCDirect, TCP, UTP, QUIC, DNS, WebRTCDirect, WebTransport);
+// Unlike ws-star, stardust can run over any transport thus removing the requirement for websockets (but don't even think about running a stardust server over webrtc-star ;) )
+const Stardust = src_or(and(Reliable, src_base('p2p-stardust'), src_base('p2p')), and(Reliable, src_base('p2p-stardust')));
+const _P2P = src_or(and(Reliable, src_base('p2p')), P2PWebRTCStar, P2PWebRTCDirect, WebRTCDirect, WebTransport, src_base('p2p'));
+const _Circuit = src_or(and(_P2P, src_base('p2p-circuit'), _P2P), and(_P2P, src_base('p2p-circuit')), and(src_base('p2p-circuit'), _P2P), and(Reliable, src_base('p2p-circuit')), and(src_base('p2p-circuit'), Reliable), src_base('p2p-circuit'));
+const CircuitRecursive = () => src_or(and(_Circuit, CircuitRecursive), _Circuit);
+const Circuit = CircuitRecursive();
+const P2P = src_or(and(Circuit, _P2P, Circuit), and(_P2P, Circuit), and(Circuit, _P2P), Circuit, _P2P);
+const IPFS = P2P;
+const WebRTC = src_or(and(Circuit, src_base('webrtc'), src_base('p2p')), and(Circuit, src_base('webrtc')), and(Reliable, src_base('webrtc'), src_base('p2p')), and(Reliable, src_base('webrtc')), src_base('webrtc'));
+/*
+ * Validation funcs
+ */
+function makeMatchesFunction(partialMatch) {
+    function matches(a) {
+        let ma;
+        try {
+            ma = multiaddr(a);
+        }
+        catch (err) { // catch error
+            return false; // also if it's invalid it's probably not matching as well so return false
+        }
+        const out = partialMatch(ma.protoNames());
+        if (out === null) {
+            return false;
+        }
+        if (out === true || out === false) {
+            return out;
+        }
+        return out.length === 0;
+    }
+    return matches;
+}
+function and(...args) {
+    function partialMatch(a) {
+        if (a.length < args.length) {
+            return null;
+        }
+        let out = a;
+        args.some((arg) => {
+            out = typeof arg === 'function'
+                ? arg().partialMatch(a)
+                : arg.partialMatch(a);
+            if (Array.isArray(out)) {
+                a = out;
+            }
+            if (out === null) {
+                return true;
+            }
+            return false;
+        });
+        return out;
+    }
+    return {
+        toString: function () { return '{ ' + args.join(' ') + ' }'; },
+        input: args,
+        matches: makeMatchesFunction(partialMatch),
+        partialMatch
+    };
+}
+function src_or(...args) {
+    function partialMatch(a) {
+        let out = null;
+        args.some((arg) => {
+            const res = typeof arg === 'function'
+                ? arg().partialMatch(a)
+                : arg.partialMatch(a);
+            if (res != null) {
+                out = res;
+                return true;
+            }
+            return false;
+        });
+        return out;
+    }
+    const result = {
+        toString: function () { return '{ ' + args.join(' ') + ' }'; },
+        input: args,
+        matches: makeMatchesFunction(partialMatch),
+        partialMatch
+    };
+    return result;
+}
+function src_base(n) {
+    const name = n;
+    function matches(a) {
+        let ma;
+        try {
+            ma = multiaddr(a);
+        }
+        catch (err) { // catch error
+            return false; // also if it's invalid it's probably not matching as well so return false
+        }
+        const pnames = ma.protoNames();
+        if (pnames.length === 1 && pnames[0] === name) {
+            return true;
+        }
+        return false;
+    }
+    function partialMatch(protos) {
+        if (protos.length === 0) {
+            return null;
+        }
+        if (protos[0] === name) {
+            return protos.slice(1);
+        }
+        return null;
+    }
+    return {
+        toString: function () { return name; },
+        matches,
+        partialMatch
+    };
+}
+//# sourceMappingURL=index.js.map
+// EXTERNAL MODULE: ./node_modules/shogun-ipfs/node_modules/iso-url/index.js
+var iso_url = __webpack_require__("./node_modules/shogun-ipfs/node_modules/iso-url/index.js");
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/bytes.js
+const bytes_empty = new Uint8Array(0);
+function bytes_toHex(d) {
+    return d.reduce((hex, byte) => hex + byte.toString(16).padStart(2, '0'), '');
+}
+function bytes_fromHex(hex) {
+    const hexes = hex.match(/../g);
+    return hexes != null ? new Uint8Array(hexes.map(b => parseInt(b, 16))) : bytes_empty;
+}
+function bytes_equals(aa, bb) {
+    if (aa === bb)
+        return true;
+    if (aa.byteLength !== bb.byteLength) {
+        return false;
+    }
+    for (let ii = 0; ii < aa.byteLength; ii++) {
+        if (aa[ii] !== bb[ii]) {
+            return false;
+        }
+    }
+    return true;
+}
+function bytes_coerce(o) {
+    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
+        return o;
+    if (o instanceof ArrayBuffer)
+        return new Uint8Array(o);
+    if (ArrayBuffer.isView(o)) {
+        return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+    }
+    throw new Error('Unknown type, must be binary type');
+}
+function bytes_isBinary(o) {
+    return o instanceof ArrayBuffer || ArrayBuffer.isView(o);
+}
+function bytes_fromString(str) {
+    return new TextEncoder().encode(str);
+}
+function src_bytes_toString(b) {
+    return new TextDecoder().decode(b);
+}
+//# sourceMappingURL=bytes.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/vendor/base-x.js
+/* eslint-disable */
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+/**
+ * @param {string} ALPHABET
+ * @param {any} name
+ */
+function base_x_base(ALPHABET, name) {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError('Alphabet too long');
+    }
+    var BASE_MAP = new Uint8Array(256);
+    for (var j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (var i = 0; i < ALPHABET.length; i++) {
+        var x = ALPHABET.charAt(i);
+        var xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + ' is ambiguous');
+        }
+        BASE_MAP[xc] = i;
+    }
+    var BASE = ALPHABET.length;
+    var LEADER = ALPHABET.charAt(0);
+    var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    /**
+     * @param {any[] | Iterable<number>} source
+     */
+    function encode(source) {
+        // @ts-ignore
+        if (source instanceof Uint8Array)
+            ;
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+            throw new TypeError('Expected Uint8Array');
+        }
+        if (source.length === 0) {
+            return '';
+        }
+        // Skip & count leading zeroes.
+        var zeroes = 0;
+        var length = 0;
+        var pbegin = 0;
+        var pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        var b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            var carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            var i = 0;
+            for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+                carry += (256 * b58[it1]) >>> 0;
+                b58[it1] = (carry % BASE) >>> 0;
+                carry = (carry / BASE) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            pbegin++;
+        }
+        // Skip leading zeroes in base58 result.
+        var it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
+        // Translate the result into a string.
+        var str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    }
+    /**
+     * @param {string | string[]} source
+     */
+    function decodeUnsafe(source) {
+        if (typeof source !== 'string') {
+            throw new TypeError('Expected String');
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        var psz = 0;
+        // Skip leading spaces.
+        if (source[psz] === ' ') {
+            return;
+        }
+        // Skip and count leading '1's.
+        var zeroes = 0;
+        var length = 0;
+        while (source[psz] === LEADER) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+        var b256 = new Uint8Array(size);
+        // Process the characters.
+        while (source[psz]) {
+            // Decode character
+            var carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255) {
+                return;
+            }
+            var i = 0;
+            for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+                carry += (BASE * b256[it3]) >>> 0;
+                b256[it3] = (carry % 256) >>> 0;
+                carry = (carry / 256) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            psz++;
+        }
+        // Skip trailing spaces.
+        if (source[psz] === ' ') {
+            return;
+        }
+        // Skip leading zeroes in b256.
+        var it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        var vch = new Uint8Array(zeroes + (size - it4));
+        var j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
+    }
+    /**
+     * @param {string | string[]} string
+     */
+    function decode(string) {
+        var buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error(`Non-${name} character`);
+    }
+    return {
+        encode: encode,
+        decodeUnsafe: decodeUnsafe,
+        decode: decode
+    };
+}
+var vendor_base_x_src = base_x_base;
+var base_x_brrp_multiformats_scope_baseX = vendor_base_x_src;
+/* harmony default export */ const vendor_base_x = (base_x_brrp_multiformats_scope_baseX);
+//# sourceMappingURL=base-x.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/bases/base.js
+
+
+/**
+ * Class represents both BaseEncoder and MultibaseEncoder meaning it
+ * can be used to encode to multibase or base encode without multibase
+ * prefix.
+ */
+class base_Encoder {
+    name;
+    prefix;
+    baseEncode;
+    constructor(name, prefix, baseEncode) {
+        this.name = name;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+    }
+    encode(bytes) {
+        if (bytes instanceof Uint8Array) {
+            return `${this.prefix}${this.baseEncode(bytes)}`;
+        }
+        else {
+            throw Error('Unknown type, must be binary type');
+        }
+    }
+}
+/**
+ * Class represents both BaseDecoder and MultibaseDecoder so it could be used
+ * to decode multibases (with matching prefix) or just base decode strings
+ * with corresponding base encoding.
+ */
+class base_Decoder {
+    name;
+    prefix;
+    baseDecode;
+    prefixCodePoint;
+    constructor(name, prefix, baseDecode) {
+        this.name = name;
+        this.prefix = prefix;
+        const prefixCodePoint = prefix.codePointAt(0);
+        /* c8 ignore next 3 */
+        if (prefixCodePoint === undefined) {
+            throw new Error('Invalid prefix character');
+        }
+        this.prefixCodePoint = prefixCodePoint;
+        this.baseDecode = baseDecode;
+    }
+    decode(text) {
+        if (typeof text === 'string') {
+            if (text.codePointAt(0) !== this.prefixCodePoint) {
+                throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+            }
+            return this.baseDecode(text.slice(this.prefix.length));
+        }
+        else {
+            throw Error('Can only multibase decode strings');
+        }
+    }
+    or(decoder) {
+        return base_or(this, decoder);
+    }
+}
+class base_ComposedDecoder {
+    decoders;
+    constructor(decoders) {
+        this.decoders = decoders;
+    }
+    or(decoder) {
+        return base_or(this, decoder);
+    }
+    decode(input) {
+        const prefix = input[0];
+        const decoder = this.decoders[prefix];
+        if (decoder != null) {
+            return decoder.decode(input);
+        }
+        else {
+            throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+        }
+    }
+}
+function base_or(left, right) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return new base_ComposedDecoder({
+        ...(left.decoders ?? { [left.prefix]: left }),
+        ...(right.decoders ?? { [right.prefix]: right })
+    });
+}
+class base_Codec {
+    name;
+    prefix;
+    baseEncode;
+    baseDecode;
+    encoder;
+    decoder;
+    constructor(name, prefix, baseEncode, baseDecode) {
+        this.name = name;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+        this.baseDecode = baseDecode;
+        this.encoder = new base_Encoder(name, prefix, baseEncode);
+        this.decoder = new base_Decoder(name, prefix, baseDecode);
+    }
+    encode(input) {
+        return this.encoder.encode(input);
+    }
+    decode(input) {
+        return this.decoder.decode(input);
+    }
+}
+function base_from({ name, prefix, encode, decode }) {
+    return new base_Codec(name, prefix, encode, decode);
+}
+function base_baseX({ name, prefix, alphabet }) {
+    const { encode, decode } = vendor_base_x(alphabet, name);
+    return base_from({
+        prefix,
+        name,
+        encode,
+        decode: (text) => bytes_coerce(decode(text))
+    });
+}
+function base_decode(string, alphabet, bitsPerChar, name) {
+    // Build the character lookup table:
+    const codes = {};
+    for (let i = 0; i < alphabet.length; ++i) {
+        codes[alphabet[i]] = i;
+    }
+    // Count the padding bytes:
+    let end = string.length;
+    while (string[end - 1] === '=') {
+        --end;
+    }
+    // Allocate the output:
+    const out = new Uint8Array((end * bitsPerChar / 8) | 0);
+    // Parse the data:
+    let bits = 0; // Number of bits currently in the buffer
+    let buffer = 0; // Bits waiting to be written out, MSB first
+    let written = 0; // Next byte to write
+    for (let i = 0; i < end; ++i) {
+        // Read one character from the string:
+        const value = codes[string[i]];
+        if (value === undefined) {
+            throw new SyntaxError(`Non-${name} character`);
+        }
+        // Append the bits to the buffer:
+        buffer = (buffer << bitsPerChar) | value;
+        bits += bitsPerChar;
+        // Write out some bits if the buffer has a byte's worth:
+        if (bits >= 8) {
+            bits -= 8;
+            out[written++] = 0xff & (buffer >> bits);
+        }
+    }
+    // Verify that we have received just enough bits:
+    if (bits >= bitsPerChar || (0xff & (buffer << (8 - bits))) !== 0) {
+        throw new SyntaxError('Unexpected end of data');
+    }
+    return out;
+}
+function base_encode(data, alphabet, bitsPerChar) {
+    const pad = alphabet[alphabet.length - 1] === '=';
+    const mask = (1 << bitsPerChar) - 1;
+    let out = '';
+    let bits = 0; // Number of bits currently in the buffer
+    let buffer = 0; // Bits waiting to be written out, MSB first
+    for (let i = 0; i < data.length; ++i) {
+        // Slurp data into the buffer:
+        buffer = (buffer << 8) | data[i];
+        bits += 8;
+        // Write out as much as we can:
+        while (bits > bitsPerChar) {
+            bits -= bitsPerChar;
+            out += alphabet[mask & (buffer >> bits)];
+        }
+    }
+    // Partial character:
+    if (bits !== 0) {
+        out += alphabet[mask & (buffer << (bitsPerChar - bits))];
+    }
+    // Add padding characters until we hit a byte boundary:
+    if (pad) {
+        while (((out.length * bitsPerChar) & 7) !== 0) {
+            out += '=';
+        }
+    }
+    return out;
+}
+/**
+ * RFC4648 Factory
+ */
+function base_rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+    return base_from({
+        prefix,
+        name,
+        encode(input) {
+            return base_encode(input, alphabet, bitsPerChar);
+        },
+        decode(input) {
+            return base_decode(input, alphabet, bitsPerChar, name);
+        }
+    });
+}
+//# sourceMappingURL=base.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/bases/base32.js
+
+const base32_base32 = base_rfc4648({
+    prefix: 'b',
+    name: 'base32',
+    alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
+    bitsPerChar: 5
+});
+const base32_base32upper = base_rfc4648({
+    prefix: 'B',
+    name: 'base32upper',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+    bitsPerChar: 5
+});
+const base32_base32pad = base_rfc4648({
+    prefix: 'c',
+    name: 'base32pad',
+    alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
+    bitsPerChar: 5
+});
+const base32_base32padupper = base_rfc4648({
+    prefix: 'C',
+    name: 'base32padupper',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
+    bitsPerChar: 5
+});
+const base32_base32hex = base_rfc4648({
+    prefix: 'v',
+    name: 'base32hex',
+    alphabet: '0123456789abcdefghijklmnopqrstuv',
+    bitsPerChar: 5
+});
+const base32_base32hexupper = base_rfc4648({
+    prefix: 'V',
+    name: 'base32hexupper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+    bitsPerChar: 5
+});
+const base32_base32hexpad = base_rfc4648({
+    prefix: 't',
+    name: 'base32hexpad',
+    alphabet: '0123456789abcdefghijklmnopqrstuv=',
+    bitsPerChar: 5
+});
+const base32_base32hexpadupper = base_rfc4648({
+    prefix: 'T',
+    name: 'base32hexpadupper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
+    bitsPerChar: 5
+});
+const base32_base32z = base_rfc4648({
+    prefix: 'h',
+    name: 'base32z',
+    alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+    bitsPerChar: 5
+});
+//# sourceMappingURL=base32.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/bases/base58.js
+
+const base58_base58btc = base_baseX({
+    name: 'base58btc',
+    prefix: 'z',
+    alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+});
+const base58_base58flickr = base_baseX({
+    name: 'base58flickr',
+    prefix: 'Z',
+    alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+});
+//# sourceMappingURL=base58.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/bases/base36.js
+
+const base36_base36 = base_baseX({
+    prefix: 'k',
+    name: 'base36',
+    alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+});
+const base36_base36upper = base_baseX({
+    prefix: 'K',
+    name: 'base36upper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+});
+//# sourceMappingURL=base36.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/vendor/varint.js
+/* eslint-disable */
+var varint_encode_1 = vendor_varint_encode;
+var varint_MSB = 0x80, varint_REST = 0x7F, varint_MSBALL = ~varint_REST, varint_INT = Math.pow(2, 31);
+/**
+ * @param {number} num
+ * @param {number[]} out
+ * @param {number} offset
+ */
+function vendor_varint_encode(num, out, offset) {
+    out = out || [];
+    offset = offset || 0;
+    var oldOffset = offset;
+    while (num >= varint_INT) {
+        out[offset++] = (num & 0xFF) | varint_MSB;
+        num /= 128;
+    }
+    while (num & varint_MSBALL) {
+        out[offset++] = (num & 0xFF) | varint_MSB;
+        num >>>= 7;
+    }
+    out[offset] = num | 0;
+    // @ts-ignore
+    vendor_varint_encode.bytes = offset - oldOffset + 1;
+    return out;
+}
+var vendor_varint_decode = varint_read;
+var varint_MSB$1 = 0x80, varint_REST$1 = 0x7F;
+/**
+ * @param {string | any[]} buf
+ * @param {number} offset
+ */
+function varint_read(buf, offset) {
+    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+    do {
+        if (counter >= l) {
+            // @ts-ignore
+            varint_read.bytes = 0;
+            throw new RangeError('Could not decode varint');
+        }
+        b = buf[counter++];
+        res += shift < 28
+            ? (b & varint_REST$1) << shift
+            : (b & varint_REST$1) * Math.pow(2, shift);
+        shift += 7;
+    } while (b >= varint_MSB$1);
+    // @ts-ignore
+    varint_read.bytes = counter - offset;
+    return res;
+}
+var varint_N1 = Math.pow(2, 7);
+var varint_N2 = Math.pow(2, 14);
+var varint_N3 = Math.pow(2, 21);
+var varint_N4 = Math.pow(2, 28);
+var varint_N5 = Math.pow(2, 35);
+var varint_N6 = Math.pow(2, 42);
+var varint_N7 = Math.pow(2, 49);
+var varint_N8 = Math.pow(2, 56);
+var varint_N9 = Math.pow(2, 63);
+var vendor_varint_length = function (/** @type {number} */ value) {
+    return (value < varint_N1 ? 1
+        : value < varint_N2 ? 2
+            : value < varint_N3 ? 3
+                : value < varint_N4 ? 4
+                    : value < varint_N5 ? 5
+                        : value < varint_N6 ? 6
+                            : value < varint_N7 ? 7
+                                : value < varint_N8 ? 8
+                                    : value < varint_N9 ? 9
+                                        : 10);
+};
+var varint_varint = {
+    encode: varint_encode_1,
+    decode: vendor_varint_decode,
+    encodingLength: vendor_varint_length
+};
+var varint_brrp_varint = varint_varint;
+/* harmony default export */ const src_vendor_varint = (varint_brrp_varint);
+//# sourceMappingURL=varint.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/varint.js
+
+function dist_src_varint_decode(data, offset = 0) {
+    const code = src_vendor_varint.decode(data, offset);
+    return [code, src_vendor_varint.decode.bytes];
+}
+function varint_encodeTo(int, target, offset = 0) {
+    src_vendor_varint.encode(int, target, offset);
+    return target;
+}
+function varint_encodingLength(int) {
+    return src_vendor_varint.encodingLength(int);
+}
+//# sourceMappingURL=varint.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/hashes/digest.js
+
+
+/**
+ * Creates a multihash digest.
+ */
+function digest_create(code, digest) {
+    const size = digest.byteLength;
+    const sizeOffset = varint_encodingLength(code);
+    const digestOffset = sizeOffset + varint_encodingLength(size);
+    const bytes = new Uint8Array(digestOffset + size);
+    varint_encodeTo(code, bytes, 0);
+    varint_encodeTo(size, bytes, sizeOffset);
+    bytes.set(digest, digestOffset);
+    return new digest_Digest(code, size, digest, bytes);
+}
+/**
+ * Turns bytes representation of multihash digest into an instance.
+ */
+function hashes_digest_decode(multihash) {
+    const bytes = bytes_coerce(multihash);
+    const [code, sizeOffset] = dist_src_varint_decode(bytes);
+    const [size, digestOffset] = dist_src_varint_decode(bytes.subarray(sizeOffset));
+    const digest = bytes.subarray(sizeOffset + digestOffset);
+    if (digest.byteLength !== size) {
+        throw new Error('Incorrect length');
+    }
+    return new digest_Digest(code, size, digest, bytes);
+}
+function hashes_digest_equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    else {
+        const data = b;
+        return (a.code === data.code &&
+            a.size === data.size &&
+            data.bytes instanceof Uint8Array &&
+            bytes_equals(a.bytes, data.bytes));
+    }
+}
+/**
+ * Represents a multihash digest which carries information about the
+ * hashing algorithm and an actual hash digest.
+ */
+class digest_Digest {
+    code;
+    size;
+    digest;
+    bytes;
+    /**
+     * Creates a multihash digest.
+     */
+    constructor(code, size, digest, bytes) {
+        this.code = code;
+        this.size = size;
+        this.digest = digest;
+        this.bytes = bytes;
+    }
+}
+/**
+ * Used to check that the passed multihash has the passed code
+ */
+function digest_hasCode(digest, code) {
+    return digest.code === code;
+}
+//# sourceMappingURL=digest.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/link/interface.js
+/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
+/* eslint-disable no-use-before-define */
+
+//# sourceMappingURL=interface.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/node_modules/multiformats/dist/src/cid.js
+
+
+
+
+
+
+// This way TS will also expose all the types from module
+
+function cid_format(link, base) {
+    const { bytes, version } = link;
+    switch (version) {
+        case 0:
+            return cid_toStringV0(bytes, cid_baseCache(link), base ?? base58_base58btc.encoder);
+        default:
+            return cid_toStringV1(bytes, cid_baseCache(link), (base ?? base32_base32.encoder));
+    }
+}
+function cid_toJSON(link) {
+    return {
+        '/': cid_format(link)
+    };
+}
+function cid_fromJSON(json) {
+    return cid_CID.parse(json['/']);
+}
+const cid_cache = new WeakMap();
+function cid_baseCache(cid) {
+    const baseCache = cid_cache.get(cid);
+    if (baseCache == null) {
+        const baseCache = new Map();
+        cid_cache.set(cid, baseCache);
+        return baseCache;
+    }
+    return baseCache;
+}
+class cid_CID {
+    code;
+    version;
+    multihash;
+    bytes;
+    '/';
+    /**
+     * @param version - Version of the CID
+     * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+     * @param multihash - (Multi)hash of the of the content.
+     */
+    constructor(version, code, multihash, bytes) {
+        this.code = code;
+        this.version = version;
+        this.multihash = multihash;
+        this.bytes = bytes;
+        // flag to serializers that this is a CID and
+        // should be treated specially
+        this['/'] = bytes;
+    }
+    /**
+     * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+     * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+     *
+     * @deprecated
+     */
+    get asCID() {
+        return this;
+    }
+    // ArrayBufferView
+    get byteOffset() {
+        return this.bytes.byteOffset;
+    }
+    // ArrayBufferView
+    get byteLength() {
+        return this.bytes.byteLength;
+    }
+    toV0() {
+        switch (this.version) {
+            case 0: {
+                return this;
+            }
+            case 1: {
+                const { code, multihash } = this;
+                if (code !== cid_DAG_PB_CODE) {
+                    throw new Error('Cannot convert a non dag-pb CID to CIDv0');
+                }
+                // sha2-256
+                if (multihash.code !== cid_SHA_256_CODE) {
+                    throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0');
+                }
+                return (cid_CID.createV0(multihash));
+            }
+            default: {
+                throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+            }
+        }
+    }
+    toV1() {
+        switch (this.version) {
+            case 0: {
+                const { code, digest } = this.multihash;
+                const multihash = digest_create(code, digest);
+                return (cid_CID.createV1(this.code, multihash));
+            }
+            case 1: {
+                return this;
+            }
+            default: {
+                throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+            }
+        }
+    }
+    equals(other) {
+        return cid_CID.equals(this, other);
+    }
+    static equals(self, other) {
+        const unknown = other;
+        return (unknown != null &&
+            self.code === unknown.code &&
+            self.version === unknown.version &&
+            hashes_digest_equals(self.multihash, unknown.multihash));
+    }
+    toString(base) {
+        return cid_format(this, base);
+    }
+    toJSON() {
+        return { '/': cid_format(this) };
+    }
+    link() {
+        return this;
+    }
+    [Symbol.toStringTag] = 'CID';
+    // Legacy
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `CID(${this.toString()})`;
+    }
+    /**
+     * Takes any input `value` and returns a `CID` instance if it was
+     * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+     * it will return value back. If `value` is not instance of this CID
+     * class, but is compatible CID it will return new instance of this
+     * `CID` class. Otherwise returns null.
+     *
+     * This allows two different incompatible versions of CID library to
+     * co-exist and interop as long as binary interface is compatible.
+     */
+    static asCID(input) {
+        if (input == null) {
+            return null;
+        }
+        const value = input;
+        if (value instanceof cid_CID) {
+            // If value is instance of CID then we're all set.
+            return value;
+        }
+        else if ((value['/'] != null && value['/'] === value.bytes) || value.asCID === value) {
+            // If value isn't instance of this CID class but `this.asCID === this` or
+            // `value['/'] === value.bytes` is true it is CID instance coming from a
+            // different implementation (diff version or duplicate). In that case we
+            // rebase it to this `CID` implementation so caller is guaranteed to get
+            // instance with expected API.
+            const { version, code, multihash, bytes } = value;
+            return new cid_CID(version, code, multihash, bytes ?? cid_encodeCID(version, code, multihash.bytes));
+        }
+        else if (value[cid_cidSymbol] === true) {
+            // If value is a CID from older implementation that used to be tagged via
+            // symbol we still rebase it to the this `CID` implementation by
+            // delegating that to a constructor.
+            const { version, multihash, code } = value;
+            const digest = hashes_digest_decode(multihash);
+            return cid_CID.create(version, code, digest);
+        }
+        else {
+            // Otherwise value is not a CID (or an incompatible version of it) in
+            // which case we return `null`.
+            return null;
+        }
+    }
+    /**
+     * @param version - Version of the CID
+     * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+     * @param digest - (Multi)hash of the of the content.
+     */
+    static create(version, code, digest) {
+        if (typeof code !== 'number') {
+            throw new Error('String codecs are no longer supported');
+        }
+        if (!(digest.bytes instanceof Uint8Array)) {
+            throw new Error('Invalid digest');
+        }
+        switch (version) {
+            case 0: {
+                if (code !== cid_DAG_PB_CODE) {
+                    throw new Error(`Version 0 CID must use dag-pb (code: ${cid_DAG_PB_CODE}) block encoding`);
+                }
+                else {
+                    return new cid_CID(version, code, digest, digest.bytes);
+                }
+            }
+            case 1: {
+                const bytes = cid_encodeCID(version, code, digest.bytes);
+                return new cid_CID(version, code, digest, bytes);
+            }
+            default: {
+                throw new Error('Invalid version');
+            }
+        }
+    }
+    /**
+     * Simplified version of `create` for CIDv0.
+     */
+    static createV0(digest) {
+        return cid_CID.create(0, cid_DAG_PB_CODE, digest);
+    }
+    /**
+     * Simplified version of `create` for CIDv1.
+     *
+     * @param code - Content encoding format code.
+     * @param digest - Multihash of the content.
+     */
+    static createV1(code, digest) {
+        return cid_CID.create(1, code, digest);
+    }
+    /**
+     * Decoded a CID from its binary representation. The byte array must contain
+     * only the CID with no additional bytes.
+     *
+     * An error will be thrown if the bytes provided do not contain a valid
+     * binary representation of a CID.
+     */
+    static decode(bytes) {
+        const [cid, remainder] = cid_CID.decodeFirst(bytes);
+        if (remainder.length !== 0) {
+            throw new Error('Incorrect length');
+        }
+        return cid;
+    }
+    /**
+     * Decoded a CID from its binary representation at the beginning of a byte
+     * array.
+     *
+     * Returns an array with the first element containing the CID and the second
+     * element containing the remainder of the original byte array. The remainder
+     * will be a zero-length byte array if the provided bytes only contained a
+     * binary CID representation.
+     */
+    static decodeFirst(bytes) {
+        const specs = cid_CID.inspectBytes(bytes);
+        const prefixSize = specs.size - specs.multihashSize;
+        const multihashBytes = bytes_coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+        if (multihashBytes.byteLength !== specs.multihashSize) {
+            throw new Error('Incorrect length');
+        }
+        const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+        const digest = new digest_Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+        const cid = specs.version === 0
+            ? cid_CID.createV0(digest)
+            : cid_CID.createV1(specs.codec, digest);
+        return [cid, bytes.subarray(specs.size)];
+    }
+    /**
+     * Inspect the initial bytes of a CID to determine its properties.
+     *
+     * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+     * bytes but for larger multicodec code values and larger multihash digest
+     * lengths these varints can be quite large. It is recommended that at least
+     * 10 bytes be made available in the `initialBytes` argument for a complete
+     * inspection.
+     */
+    static inspectBytes(initialBytes) {
+        let offset = 0;
+        const next = () => {
+            const [i, length] = dist_src_varint_decode(initialBytes.subarray(offset));
+            offset += length;
+            return i;
+        };
+        let version = next();
+        let codec = cid_DAG_PB_CODE;
+        if (version === 18) {
+            // CIDv0
+            version = 0;
+            offset = 0;
+        }
+        else {
+            codec = next();
+        }
+        if (version !== 0 && version !== 1) {
+            throw new RangeError(`Invalid CID version ${version}`);
+        }
+        const prefixSize = offset;
+        const multihashCode = next(); // multihash code
+        const digestSize = next(); // multihash length
+        const size = offset + digestSize;
+        const multihashSize = size - prefixSize;
+        return { version, codec, multihashCode, digestSize, multihashSize, size };
+    }
+    /**
+     * Takes cid in a string representation and creates an instance. If `base`
+     * decoder is not provided will use a default from the configuration. It will
+     * throw an error if encoding of the CID is not compatible with supplied (or
+     * a default decoder).
+     */
+    static parse(source, base) {
+        const [prefix, bytes] = cid_parseCIDtoBytes(source, base);
+        const cid = cid_CID.decode(bytes);
+        if (cid.version === 0 && source[0] !== 'Q') {
+            throw Error('Version 0 CID string must not include multibase prefix');
+        }
+        // Cache string representation to avoid computing it on `this.toString()`
+        cid_baseCache(cid).set(prefix, source);
+        return cid;
+    }
+}
+function cid_parseCIDtoBytes(source, base) {
+    switch (source[0]) {
+        // CIDv0 is parsed differently
+        case 'Q': {
+            const decoder = base ?? base58_base58btc;
+            return [
+                base58_base58btc.prefix,
+                decoder.decode(`${base58_base58btc.prefix}${source}`)
+            ];
+        }
+        case base58_base58btc.prefix: {
+            const decoder = base ?? base58_base58btc;
+            return [base58_base58btc.prefix, decoder.decode(source)];
+        }
+        case base32_base32.prefix: {
+            const decoder = base ?? base32_base32;
+            return [base32_base32.prefix, decoder.decode(source)];
+        }
+        case base36_base36.prefix: {
+            const decoder = base ?? base36_base36;
+            return [base36_base36.prefix, decoder.decode(source)];
+        }
+        default: {
+            if (base == null) {
+                throw Error('To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided');
+            }
+            return [source[0], base.decode(source)];
+        }
+    }
+}
+function cid_toStringV0(bytes, cache, base) {
+    const { prefix } = base;
+    if (prefix !== base58_base58btc.prefix) {
+        throw Error(`Cannot string encode V0 in ${base.name} encoding`);
+    }
+    const cid = cache.get(prefix);
+    if (cid == null) {
+        const cid = base.encode(bytes).slice(1);
+        cache.set(prefix, cid);
+        return cid;
+    }
+    else {
+        return cid;
+    }
+}
+function cid_toStringV1(bytes, cache, base) {
+    const { prefix } = base;
+    const cid = cache.get(prefix);
+    if (cid == null) {
+        const cid = base.encode(bytes);
+        cache.set(prefix, cid);
+        return cid;
+    }
+    else {
+        return cid;
+    }
+}
+const cid_DAG_PB_CODE = 0x70;
+const cid_SHA_256_CODE = 0x12;
+function cid_encodeCID(version, code, multihash) {
+    const codeOffset = varint_encodingLength(version);
+    const hashOffset = codeOffset + varint_encodingLength(code);
+    const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+    varint_encodeTo(version, bytes, 0);
+    varint_encodeTo(code, bytes, codeOffset);
+    bytes.set(multihash, hashOffset);
+    return bytes;
+}
+const cid_cidSymbol = Symbol.for('@ipld/js-cid/CID');
+//# sourceMappingURL=cid.js.map
+;// ./node_modules/shogun-ipfs/node_modules/is-ipfs/dist/src/index.js
+/**
+ * @packageDocumentation
+ *
+ * A suite of util methods that provides efficient validation.
+ *
+ * Detection of IPFS Paths and identifiers in URLs is a two-stage process:
+ *
+ * 1. `pathPattern`/`pathGatewayPattern`/`subdomainGatewayPattern` regex is applied to quickly identify potential candidates
+ * 2. proper CID validation is applied to remove false-positives
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import * as isIPFS from 'is-ipfs'
+ *
+ * isIPFS.multihash('QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // true
+ * isIPFS.multihash('noop') // false
+ *
+ * isIPFS.cid('QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // true (CIDv0)
+ * isIPFS.cid('bafybeiasb5vpmaounyilfuxbd3lryvosl4yefqrfahsb2esg46q6tu6y5q') // true (CIDv1 in Base32)
+ * isIPFS.cid('zdj7WWeQ43G6JJvLWQWZpyHuAMq6uYWRjkBXFad11vE2LHhQ7') // true (CIDv1 in Base58btc)
+ * isIPFS.cid('noop') // false
+ *
+ * isIPFS.base32cid('bafybeie5gq4jxvzmsym6hjlwxej4rwdoxt7wadqvmmwbqi7r27fclha2va') // true
+ * isIPFS.base32cid('QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // false
+ *
+ * isIPFS.url('https://ipfs.io/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // true
+ * isIPFS.url('https://ipfs.io/ipfs/QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR?filename=guardian.jpg') // true
+ * isIPFS.url('https://ipfs.io/ipns/github.com') // true
+ * isIPFS.url('https://bafybeie5gq4jxvzmsym6hjlwxej4rwdoxt7wadqvmmwbqi7r27fclha2va.ipfs.dweb.link') // true
+ * isIPFS.url('http://en.wikipedia-on-ipfs.org.ipfs.localhost:8080') // true
+ * isIPFS.url('https://github.com/ipfs/js-ipfs/blob/master/README.md') // false
+ * isIPFS.url('https://google.com') // false
+ *
+ * isIPFS.path('/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // true
+ * isIPFS.path('/ipfs/QmbcBPAwCDxRMB1Qe7CRQmxdrTSkxKwM9y6rZw2FjGtbsb/?weird-filename=test.jpg') // true
+ * isIPFS.path('/ipns/github.com') // true
+ * isIPFS.path('/ipfs/js-ipfs/blob/master/README.md') // false
+ *
+ * isIPFS.urlOrPath('https://ipfs.io/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // true
+ * isIPFS.urlOrPath('https://ipfs.io/ipns/github.com') // true
+ * isIPFS.urlOrPath('/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // true
+ * isIPFS.urlOrPath('/ipns/github.com') // true
+ * isIPFS.urlOrPath('https://bafybeie5gq4jxvzmsym6hjlwxej4rwdoxt7wadqvmmwbqi7r27fclha2va.ipfs.dweb.link') // true
+ * isIPFS.urlOrPath('https://google.com') // false
+ *
+ * isIPFS.ipfsUrl('https://ipfs.io/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // true
+ * isIPFS.ipfsUrl('https://ipfs.io/ipfs/invalid-hash') // false
+ *
+ * isIPFS.ipnsUrl('https://ipfs.io/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // false
+ * isIPFS.ipnsUrl('https://ipfs.io/ipns/github.com') // true
+ *
+ * isIPFS.ipfsPath('/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // true
+ * isIPFS.ipfsPath('/ipfs/invalid-hash') // false
+ *
+ * isIPFS.ipnsPath('/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // false
+ * isIPFS.ipnsPath('/ipns/github.com') // true
+ *
+ * isIPFS.cidPath('QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o/path/to/file') // true
+ * isIPFS.cidPath('QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o/') // true
+ * isIPFS.cidPath('QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // false
+ * isIPFS.cidPath('/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o') // false
+ * isIPFS.cidPath('/ipfs/QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o/file') // false
+ *
+ * isIPFS.subdomain('http://bafybeie5gq4jxvzmsym6hjlwxej4rwdoxt7wadqvmmwbqi7r27fclha2va.ipfs.dweb.link') // true
+ * isIPFS.subdomain('http://bafybeiabc2xofh6tdi6vutusorpumwcikw3hf3st4ecjugo6j52f6xwc6q.ipns.dweb.link') // true
+ * isIPFS.subdomain('http://www.bafybeie5gq4jxvzmsym6hjlwxej4rwdoxt7wadqvmmwbqi7r27fclha2va.ipfs.dweb.link') // false
+ * isIPFS.subdomain('http://bafybeie5gq4jxvzmsym6hjlwxej4rwdoxt7wadqvmmwbqi7r27fclha2va.dweb.link') // false
+ *
+ * isIPFS.ipfsSubdomain('http://bafybeie5gq4jxvzmsym6hjlwxej4rwdoxt7wadqvmmwbqi7r27fclha2va.ipfs.dweb.link') // true
+ * isIPFS.ipfsSubdomain('http://bafybeie5gq4jxvzmsym6hjlwxej4rwdoxt7wadqvmmwbqi7r27fclha2va.dweb.link') // false
+ *
+ * isIPFS.ipnsSubdomain('http://bafybeiabc2xofh6tdi6vutusorpumwcikw3hf3st4ecjugo6j52f6xwc6q.ipns.dweb.link') // true
+ * isIPFS.ipnsSubdomain('http://bafybeiabc2xofh6tdi6vutusorpumwcikw3hf3st4ecjugo6j52f6xwc6q.dweb.link') // false
+ * isIPFS.ipnsSubdomain('http://QmcNioXSC1bfJj1dcFErhUfyjFzoX2HodkRccsFFVJJvg8.ipns.dweb.link') // false
+ * isIPFS.ipnsSubdomain('http://en.wikipedia-on-ipfs.org.ipns.localhost:8080') // true (assuming DNSLink)
+ * isIPFS.ipnsSubdomain('http://en-wikipedia--on--ipfs-org.ipns.localhost:8080') // true (assuming inlined DNSLink)
+ * isIPFS.ipnsSubdomain('http://hostname-without-tld-.ipns.dweb.link') // false (not a CID, invalid DNS label)
+ *
+ * isIPFS.multiaddr('/ip4/127.0.0.1/udp/1234') // true
+ * isIPFS.multiaddr('/ip4/127.0.0.1/udp/1234/http') // true
+ * isIPFS.multiaddr('/ip6/::1/udp/1234') // true
+ * isIPFS.multiaddr('ip6/::1/udp/1234') // false
+ * isIPFS.multiaddr('/yoloinvalid/::1/udp/1234') // false
+ *
+ * isIPFS.peerMultiaddr('/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooo4') // true
+ * isIPFS.peerMultiaddr('/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooo4') // true (legacy notation)
+ * isIPFS.peerMultiaddr('/ip4/127.0.0.1/tcp/1234/ws/p2p/QmUjNmr8TgJCn1Ao7DvMy4cjoZU15b9bwSCBLE3vwXiwgj') // true
+ * isIPFS.peerMultiaddr('/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooo4/p2p-circuit/p2p/QmUjNmr8TgJCn1Ao7DvMy4cjoZU15b9bwSCBLE3vwXiwgj') // true
+ * isIPFS.peerMultiaddr('/dnsaddr/bootstrap.libp2p.io') // false (key missing, needs additional DNS lookup to tell if this is valid)
+ * isIPFS.peerMultiaddr('/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN') // true (key present, ip and port can be resolved later)
+ * isIPFS.peerMultiaddr('/ip4/127.0.0.1/udp/1234') // false (key missing)
+ * ```
+ */
+
+
+
+
+
+
+
+
+const pathGatewayPattern = /^https?:\/\/[^/]+\/(ip[fn]s)\/([^/?#]+)/;
+const pathPattern = /^\/(ip[fn]s)\/([^/?#]+)/;
+const defaultProtocolMatch = 1;
+const defaultHashMath = 2;
+// CID, libp2p-key or DNSLink
+const subdomainGatewayPattern = /^https?:\/\/([^/]+)\.(ip[fn]s)\.[^/?]+/;
+const subdomainIdMatch = 1;
+const subdomainProtocolMatch = 2;
+// Fully qualified domain name (FQDN) that has an explicit .tld suffix
+const fqdnWithTld = /^(([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])\.)+([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])$/;
+function isMultihash(hash) {
+    const formatted = src_convertToString(hash);
+    if (formatted === false) {
+        return false;
+    }
+    try {
+        hashes_digest_decode(base58_base58btc.decode(`z${formatted}`));
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+function src_isMultiaddr(input) {
+    try {
+        return Boolean(multiaddr(input));
+    }
+    catch {
+        return false;
+    }
+}
+function isBase32EncodedMultibase(hash) {
+    try {
+        let cid;
+        if (isString(hash)) {
+            cid = cid_CID.parse(hash);
+        }
+        else {
+            cid = cid_CID.asCID(hash);
+        }
+        if (cid == null) {
+            return false;
+        }
+        base32_base32.decode(cid.toString());
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+function isCID(hash) {
+    try {
+        if (isString(hash)) {
+            return Boolean(cid_CID.parse(hash));
+        }
+        if (hash instanceof Uint8Array) {
+            return Boolean(cid_CID.decode(hash));
+        }
+        return Boolean(cid_CID.asCID(hash)); // eslint-disable-line no-new
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * @param {string | Uint8Array | Multiaddr} input
+ */
+function isPeerMultiaddr(input) {
+    return src_isMultiaddr(input) && P2P.matches(input);
+}
+/**
+ * @param {string | Uint8Array} input
+ * @param {RegExp | string} pattern
+ * @param {number} [protocolMatch=1]
+ * @param {number} [hashMatch=2]
+ */
+function isIpfs(input, pattern, protocolMatch = defaultProtocolMatch, hashMatch = defaultHashMath) {
+    const formatted = src_convertToString(input);
+    if (formatted === false) {
+        return false;
+    }
+    const match = formatted.match(pattern);
+    if (match == null) {
+        return false;
+    }
+    if (match[protocolMatch] !== 'ipfs') {
+        return false;
+    }
+    let hash = match[hashMatch];
+    if (hash != null && pattern === subdomainGatewayPattern) {
+        // when doing checks for subdomain context
+        // ensure hash is case-insensitive
+        // (browsers force-lowercase authority component anyway)
+        hash = hash.toLowerCase();
+    }
+    return isCID(hash);
+}
+/**
+ *
+ * @param {string | Uint8Array} input
+ * @param {string | RegExp} pattern
+ * @param {number} [protocolMatch=1]
+ * @param {number} [hashMatch=1]
+ */
+function isIpns(input, pattern, protocolMatch = defaultProtocolMatch, hashMatch = defaultHashMath) {
+    const formatted = src_convertToString(input);
+    if (formatted === false) {
+        return false;
+    }
+    const match = formatted.match(pattern);
+    if (match == null) {
+        return false;
+    }
+    if (match[protocolMatch] !== 'ipns') {
+        return false;
+    }
+    let ipnsId = match[hashMatch];
+    if (ipnsId != null && pattern === subdomainGatewayPattern) {
+        // when doing checks for subdomain context
+        // ensure ipnsId is case-insensitive
+        // (browsers force-lowercase authority compotent anyway)
+        ipnsId = ipnsId.toLowerCase();
+        // Check if it is cidv1
+        if (isCID(ipnsId))
+            return true;
+        // Check if it looks like FQDN
+        try {
+            if (!ipnsId.includes('.') && ipnsId.includes('-')) {
+                // name without tld, assuming its inlined into a single DNS label
+                // (https://github.com/ipfs/in-web-browsers/issues/169)
+                // en-wikipedia--on--ipfs-org → en.wikipedia-on-ipfs.org
+                ipnsId = ipnsId.replace(/--/g, '@').replace(/-/g, '.').replace(/@/g, '-');
+            }
+            // URL implementation in web browsers forces lowercase of the hostname
+            const { hostname } = new iso_url.URL(`http://${ipnsId}`); // eslint-disable-line no-new
+            // Check if potential FQDN has an explicit TLD
+            return fqdnWithTld.test(hostname);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @param {any} input
+ */
+function isString(input) {
+    return typeof input === 'string';
+}
+/**
+ * @param {Uint8Array | string} input
+ */
+function src_convertToString(input) {
+    if (input instanceof Uint8Array) {
+        return (0,to_string.toString)(input, 'base58btc');
+    }
+    if (isString(input)) {
+        return input;
+    }
+    return false;
+}
+/**
+ * Returns `true` if the provided `url` string includes a valid IPFS subdomain
+ * (case-insensitive CIDv1) or `false` otherwise.
+ */
+const ipfsSubdomain = (url) => isIpfs(url, subdomainGatewayPattern, subdomainProtocolMatch, subdomainIdMatch);
+/**
+ * Returns `true` if the provided `url` string looks like a valid IPNS subdomain
+ * (CIDv1 with `libp2p-key` multicodec or something that looks like a FQDN, for
+ * example `en.wikipedia-on-ipfs.org.ipns.localhost:8080`) or `false` otherwise.
+ *
+ * **Note:** `ipnsSubdomain` method works in offline mode: it does not perform
+ * actual IPNS record lookup over DHT or other content routing method. It may
+ * return false-positives:
+ *
+ * - To ensure IPNS record  exists, make a call to `/api/v0/name/resolve?arg=<ipnsid>`
+ * - To ensure DNSLink exists, make a call to `/api/v0/dns?arg=<fqdn>`
+ */
+const ipnsSubdomain = (url) => isIpns(url, subdomainGatewayPattern, subdomainProtocolMatch, subdomainIdMatch);
+/**
+ * Returns `true` if the provided `url` string includes a valid IPFS, looks like
+ * an IPNS/DNSLink subdomain or `false` otherwise.
+ */
+const subdomain = (url) => ipfsSubdomain(url) || ipnsSubdomain(url);
+/**
+ * Returns `true` if the provided string is a valid IPFS url or `false`
+ * otherwise.
+ */
+const ipfsUrl = (url) => isIpfs(url, pathGatewayPattern) || ipfsSubdomain(url);
+/**
+ * Returns `true` if the provided string is a valid IPNS url or `false`
+ * otherwise.
+ */
+const ipnsUrl = (url) => isIpns(url, pathGatewayPattern) || ipnsSubdomain(url);
+/**
+ * Returns `true` if the provided string is a valid IPFS or IPNS url or `false`
+ * otherwise.
+ */
+const url = (url) => ipfsUrl(url) || ipnsUrl(url) || subdomain(url);
+const path = (path) => isIpfs(path, pathPattern) || isIpns(path, pathPattern);
+/**
+ * Returns `true` if the provided string or `Uint8Array`  is a valid `multihash`
+ * or `false` otherwise.
+ */
+
+/**
+ * Returns `true` if the provided `string`, [`Multiaddr`](https://github.com/multiformats/js-multiaddr)
+ * or `Uint8Array` represents a valid multiaddr or `false` otherwise.
+ */
+
+/**
+ * Returns `true` if the provided `string`, [`Multiaddr`](https://github.com/multiformats/js-multiaddr)
+ * or `Uint8Array` represents a valid libp2p peer multiaddr (matching [`P2P`
+ * format from `mafmt`](https://github.com/multiformats/js-mafmt#api)) or
+ * `false` otherwise.
+ */
+
+/**
+ * Returns `true` if the provided string, `Uint8Array` or [`CID`](https://github.com/multiformats/js-multiformats/#readme)
+ * object represents a valid [CID](https://docs.ipfs.io/guides/concepts/cid/) or
+ * `false` otherwise.
+ */
+
+/**
+ * Returns `true` if the provided string is a valid `CID` in Base32 encoding or
+ * `false` otherwise.
+ */
+const base32cid = (cid) => (isCID(cid) && isBase32EncodedMultibase(cid));
+/**
+ * Returns `true` if the provided string is a valid IPFS or IPNS path or `false`
+ * otherwise.
+ */
+const ipfsPath = (path) => isIpfs(path, pathPattern);
+/**
+ * Returns `true` if the provided string is a valid IPNS path or `false`
+ * otherwise.
+ */
+const ipnsPath = (path) => isIpns(path, pathPattern);
+/**
+ * Returns `true` if the provided string is a valid IPFS or IPNS url or path or
+ * `false` otherwise.
+ */
+const urlOrPath = (x) => url(x) || path(x);
+/**
+ * Returns `true` if the provided string is a valid "CID path" (IPFS path
+ * without `/ipfs/` prefix) or `false` otherwise.
+ */
+const cidPath = (path) => isString(path) && !isCID(path) && isIpfs(`/ipfs/${path}`, pathPattern);
+//# sourceMappingURL=index.js.map
+
+/***/ })
+
+}]);
+//# sourceMappingURL=defaultVendors-node_modules_shogun-ipfs_node_modules_is-ipfs_dist_src_index_js.shogun-core.js.map