@pkcprotocol/pkc-js 0.0.61 → 0.0.63

package/dist/bundled/chunks/src-BOzgM7Fp.js

@@ -0,0 +1,800 @@
+import { n as __exportAll } from "./chunk-2rV9d50f.js";
+import { CID } from "multiformats/cid";
+//#region node_modules/it-first/dist/src/index.js
+/**
+* @packageDocumentation
+*
+* Return the first value in an (async)iterable
+*
+* @example
+*
+* ```javascript
+* import first from 'it-first'
+*
+* // This can also be an iterator, generator, etc
+* const values = [0, 1, 2, 3, 4]
+*
+* const res = first(values)
+*
+* console.info(res) // 0
+* ```
+*
+* Async sources must be awaited:
+*
+* ```javascript
+* import first from 'it-first'
+*
+* const values = async function * () {
+*   yield * [0, 1, 2, 3, 4]
+* }
+*
+* const res = await first(values())
+*
+* console.info(res) // 0
+* ```
+*/
+function isAsyncIterable(thing) {
+	return thing[Symbol.asyncIterator] != null;
+}
+function first(source) {
+	if (isAsyncIterable(source)) return (async () => {
+		for await (const entry of source) return entry;
+	})();
+	for (const entry of source) return entry;
+}
+//#endregion
+//#region node_modules/@ipld/dag-pb/src/pb-decode.js
+const textDecoder = new TextDecoder();
+/**
+* @typedef {import('./interface.js').RawPBLink} RawPBLink
+*/
+/**
+* @typedef {import('./interface.js').RawPBNode} RawPBNode
+*/
+/**
+* @param {Uint8Array} bytes
+* @param {number} offset
+* @returns {[number, number]}
+*/
+function decodeVarint(bytes, offset) {
+	let v = 0;
+	for (let shift = 0;; shift += 7) {
+		/* c8 ignore next 3 */
+		if (shift >= 64) throw new Error("protobuf: varint overflow");
+		/* c8 ignore next 3 */
+		if (offset >= bytes.length) throw new Error("protobuf: unexpected end of data");
+		const b = bytes[offset++];
+		v += shift < 28 ? (b & 127) << shift : (b & 127) * 2 ** shift;
+		if (b < 128) break;
+	}
+	return [v, offset];
+}
+/**
+* @param {Uint8Array} bytes
+* @param {number} offset
+* @returns {[Uint8Array, number]}
+*/
+function decodeBytes(bytes, offset) {
+	let byteLen;
+	[byteLen, offset] = decodeVarint(bytes, offset);
+	const postOffset = offset + byteLen;
+	/* c8 ignore next 3 */
+	if (byteLen < 0 || postOffset < 0) throw new Error("protobuf: invalid length");
+	/* c8 ignore next 3 */
+	if (postOffset > bytes.length) throw new Error("protobuf: unexpected end of data");
+	return [bytes.subarray(offset, postOffset), postOffset];
+}
+/**
+* @param {Uint8Array} bytes
+* @param {number} index
+* @returns {[number, number, number]}
+*/
+function decodeKey(bytes, index) {
+	let wire;
+	[wire, index] = decodeVarint(bytes, index);
+	return [
+		wire & 7,
+		wire >> 3,
+		index
+	];
+}
+/**
+* @param {Uint8Array} bytes
+* @returns {RawPBLink}
+*/
+function decodeLink(bytes) {
+	/** @type {RawPBLink} */
+	const link = {};
+	const l = bytes.length;
+	let index = 0;
+	while (index < l) {
+		let wireType, fieldNum;
+		[wireType, fieldNum, index] = decodeKey(bytes, index);
+		if (fieldNum === 1) {
+			if (link.Hash) throw new Error("protobuf: (PBLink) duplicate Hash section");
+			if (wireType !== 2) throw new Error(`protobuf: (PBLink) wrong wireType (${wireType}) for Hash`);
+			if (link.Name !== void 0) throw new Error("protobuf: (PBLink) invalid order, found Name before Hash");
+			if (link.Tsize !== void 0) throw new Error("protobuf: (PBLink) invalid order, found Tsize before Hash");
+			[link.Hash, index] = decodeBytes(bytes, index);
+		} else if (fieldNum === 2) {
+			if (link.Name !== void 0) throw new Error("protobuf: (PBLink) duplicate Name section");
+			if (wireType !== 2) throw new Error(`protobuf: (PBLink) wrong wireType (${wireType}) for Name`);
+			if (link.Tsize !== void 0) throw new Error("protobuf: (PBLink) invalid order, found Tsize before Name");
+			let byts;
+			[byts, index] = decodeBytes(bytes, index);
+			link.Name = textDecoder.decode(byts);
+		} else if (fieldNum === 3) {
+			if (link.Tsize !== void 0) throw new Error("protobuf: (PBLink) duplicate Tsize section");
+			if (wireType !== 0) throw new Error(`protobuf: (PBLink) wrong wireType (${wireType}) for Tsize`);
+			[link.Tsize, index] = decodeVarint(bytes, index);
+		} else throw new Error(`protobuf: (PBLink) invalid fieldNumber, expected 1, 2 or 3, got ${fieldNum}`);
+	}
+	/* c8 ignore next 3 */
+	if (index > l) throw new Error("protobuf: (PBLink) unexpected end of data");
+	return link;
+}
+/**
+* @param {Uint8Array} bytes
+* @returns {RawPBNode}
+*/
+function decodeNode(bytes) {
+	const l = bytes.length;
+	let index = 0;
+	/** @type {RawPBLink[]|void} */
+	let links = void 0;
+	let linksBeforeData = false;
+	/** @type {Uint8Array|void} */
+	let data = void 0;
+	while (index < l) {
+		let wireType, fieldNum;
+		[wireType, fieldNum, index] = decodeKey(bytes, index);
+		if (wireType !== 2) throw new Error(`protobuf: (PBNode) invalid wireType, expected 2, got ${wireType}`);
+		if (fieldNum === 1) {
+			if (data) throw new Error("protobuf: (PBNode) duplicate Data section");
+			[data, index] = decodeBytes(bytes, index);
+			if (links) linksBeforeData = true;
+		} else if (fieldNum === 2) {
+			if (linksBeforeData) throw new Error("protobuf: (PBNode) duplicate Links section");
+			else if (!links) links = [];
+			let byts;
+			[byts, index] = decodeBytes(bytes, index);
+			links.push(decodeLink(byts));
+		} else throw new Error(`protobuf: (PBNode) invalid fieldNumber, expected 1 or 2, got ${fieldNum}`);
+	}
+	/* c8 ignore next 3 */
+	if (index > l) throw new Error("protobuf: (PBNode) unexpected end of data");
+	/** @type {RawPBNode} */
+	const node = {};
+	if (data) node.Data = data;
+	node.Links = links || [];
+	return node;
+}
+//#endregion
+//#region node_modules/@ipld/dag-pb/src/pb-encode.js
+const textEncoder$1 = new TextEncoder();
+const maxInt32 = 2 ** 32;
+const maxUInt32 = 2 ** 31;
+/**
+* @typedef {import('./interface.js').RawPBLink} RawPBLink
+*/
+/**
+* @typedef {import('./interface.js').RawPBNode} RawPBNode
+*/
+/**
+* encodeLink() is passed a slice of the parent byte array that ends where this
+* link needs to end, so it packs to the right-most part of the passed `bytes`
+*
+* @param {RawPBLink} link
+* @param {Uint8Array} bytes
+* @returns {number}
+*/
+function encodeLink(link, bytes) {
+	let i = bytes.length;
+	if (typeof link.Tsize === "number") {
+		if (link.Tsize < 0) throw new Error("Tsize cannot be negative");
+		if (!Number.isSafeInteger(link.Tsize)) throw new Error("Tsize too large for encoding");
+		i = encodeVarint(bytes, i, link.Tsize) - 1;
+		bytes[i] = 24;
+	}
+	if (typeof link.Name === "string") {
+		const nameBytes = textEncoder$1.encode(link.Name);
+		i -= nameBytes.length;
+		bytes.set(nameBytes, i);
+		i = encodeVarint(bytes, i, nameBytes.length) - 1;
+		bytes[i] = 18;
+	}
+	if (link.Hash) {
+		i -= link.Hash.length;
+		bytes.set(link.Hash, i);
+		i = encodeVarint(bytes, i, link.Hash.length) - 1;
+		bytes[i] = 10;
+	}
+	return bytes.length - i;
+}
+/**
+* Encodes a PBNode into a new byte array of precisely the correct size
+*
+* @param {RawPBNode} node
+* @returns {Uint8Array}
+*/
+function encodeNode(node) {
+	const size = sizeNode(node);
+	const bytes = new Uint8Array(size);
+	let i = size;
+	if (node.Data) {
+		i -= node.Data.length;
+		bytes.set(node.Data, i);
+		i = encodeVarint(bytes, i, node.Data.length) - 1;
+		bytes[i] = 10;
+	}
+	if (node.Links) for (let index = node.Links.length - 1; index >= 0; index--) {
+		const size = encodeLink(node.Links[index], bytes.subarray(0, i));
+		i -= size;
+		i = encodeVarint(bytes, i, size) - 1;
+		bytes[i] = 18;
+	}
+	return bytes;
+}
+/**
+* work out exactly how many bytes this link takes up
+*
+* @param {RawPBLink} link
+* @returns
+*/
+function sizeLink(link) {
+	let n = 0;
+	if (link.Hash) {
+		const l = link.Hash.length;
+		n += 1 + l + sov(l);
+	}
+	if (typeof link.Name === "string") {
+		const l = textEncoder$1.encode(link.Name).length;
+		n += 1 + l + sov(l);
+	}
+	if (typeof link.Tsize === "number") n += 1 + sov(link.Tsize);
+	return n;
+}
+/**
+* Work out exactly how many bytes this node takes up
+*
+* @param {RawPBNode} node
+* @returns {number}
+*/
+function sizeNode(node) {
+	let n = 0;
+	if (node.Data) {
+		const l = node.Data.length;
+		n += 1 + l + sov(l);
+	}
+	if (node.Links) for (const link of node.Links) {
+		const l = sizeLink(link);
+		n += 1 + l + sov(l);
+	}
+	return n;
+}
+/**
+* @param {Uint8Array} bytes
+* @param {number} offset
+* @param {number} v
+* @returns {number}
+*/
+function encodeVarint(bytes, offset, v) {
+	offset -= sov(v);
+	const base = offset;
+	while (v >= maxUInt32) {
+		bytes[offset++] = v & 127 | 128;
+		v /= 128;
+	}
+	while (v >= 128) {
+		bytes[offset++] = v & 127 | 128;
+		v >>>= 7;
+	}
+	bytes[offset] = v;
+	return base;
+}
+/**
+* size of varint
+*
+* @param {number} x
+* @returns {number}
+*/
+function sov(x) {
+	if (x % 2 === 0) x++;
+	return Math.floor((len64(x) + 6) / 7);
+}
+/**
+* golang math/bits, how many bits does it take to represent this integer?
+*
+* @param {number} x
+* @returns {number}
+*/
+function len64(x) {
+	let n = 0;
+	if (x >= maxInt32) {
+		x = Math.floor(x / maxInt32);
+		n = 32;
+	}
+	if (x >= 65536) {
+		x >>>= 16;
+		n += 16;
+	}
+	if (x >= 256) {
+		x >>>= 8;
+		n += 8;
+	}
+	return n + len8tab[x];
+}
+const len8tab = [
+	0,
+	1,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8
+];
+//#endregion
+//#region node_modules/@ipld/dag-pb/src/util.js
+/**
+* @typedef {import('./interface.js').PBLink} PBLink
+* @typedef {import('./interface.js').PBNode} PBNode
+*/
+/**
+* @template T
+* @typedef {import('multiformats/codecs/interface').ByteView<T>} ByteView
+*/
+/**
+* @template T
+* @typedef {import('multiformats/codecs/interface').ArrayBufferView<T>} ArrayBufferView
+*/
+const pbNodeProperties = ["Data", "Links"];
+const pbLinkProperties = [
+	"Hash",
+	"Name",
+	"Tsize"
+];
+const textEncoder = new TextEncoder();
+/**
+* @param {PBLink} a
+* @param {PBLink} b
+* @returns {number}
+*/
+function linkComparator(a, b) {
+	if (a === b) return 0;
+	const abuf = a.Name ? textEncoder.encode(a.Name) : [];
+	const bbuf = b.Name ? textEncoder.encode(b.Name) : [];
+	let x = abuf.length;
+	let y = bbuf.length;
+	for (let i = 0, len = Math.min(x, y); i < len; ++i) if (abuf[i] !== bbuf[i]) {
+		x = abuf[i];
+		y = bbuf[i];
+		break;
+	}
+	return x < y ? -1 : y < x ? 1 : 0;
+}
+/**
+* @param {any} node
+* @param {string[]} properties
+* @returns {boolean}
+*/
+function hasOnlyProperties(node, properties) {
+	return !Object.keys(node).some((p) => !properties.includes(p));
+}
+/**
+* Converts a CID, or a PBLink-like object to a PBLink
+*
+* @param {any} link
+* @returns {PBLink}
+*/
+function asLink(link) {
+	if (typeof link.asCID === "object") {
+		const Hash = CID.asCID(link);
+		if (!Hash) throw new TypeError("Invalid DAG-PB form");
+		return { Hash };
+	}
+	if (typeof link !== "object" || Array.isArray(link)) throw new TypeError("Invalid DAG-PB form");
+	const pbl = {};
+	if (link.Hash) {
+		let cid = CID.asCID(link.Hash);
+		try {
+			if (!cid) {
+				if (typeof link.Hash === "string") cid = CID.parse(link.Hash);
+				else if (link.Hash instanceof Uint8Array) cid = CID.decode(link.Hash);
+			}
+		} catch (e) {
+			throw new TypeError(`Invalid DAG-PB form: ${e.message}`);
+		}
+		if (cid) pbl.Hash = cid;
+	}
+	if (!pbl.Hash) throw new TypeError("Invalid DAG-PB form");
+	if (typeof link.Name === "string") pbl.Name = link.Name;
+	if (typeof link.Tsize === "number") pbl.Tsize = link.Tsize;
+	return pbl;
+}
+/**
+* @param {any} node
+* @returns {PBNode}
+*/
+function prepare(node) {
+	if (node instanceof Uint8Array || typeof node === "string") node = { Data: node };
+	if (typeof node !== "object" || Array.isArray(node)) throw new TypeError("Invalid DAG-PB form");
+	/** @type {PBNode} */
+	const pbn = {};
+	if (node.Data !== void 0) if (typeof node.Data === "string") pbn.Data = textEncoder.encode(node.Data);
+	else if (node.Data instanceof Uint8Array) pbn.Data = node.Data;
+	else throw new TypeError("Invalid DAG-PB form");
+	if (node.Links !== void 0) if (Array.isArray(node.Links)) {
+		pbn.Links = node.Links.map(asLink);
+		pbn.Links.sort(linkComparator);
+	} else throw new TypeError("Invalid DAG-PB form");
+	else pbn.Links = [];
+	return pbn;
+}
+/**
+* @param {PBNode} node
+*/
+function validate(node) {
+	if (!node || typeof node !== "object" || Array.isArray(node) || node instanceof Uint8Array || node["/"] && node["/"] === node.bytes) throw new TypeError("Invalid DAG-PB form");
+	if (!hasOnlyProperties(node, pbNodeProperties)) throw new TypeError("Invalid DAG-PB form (extraneous properties)");
+	if (node.Data !== void 0 && !(node.Data instanceof Uint8Array)) throw new TypeError("Invalid DAG-PB form (Data must be bytes)");
+	if (!Array.isArray(node.Links)) throw new TypeError("Invalid DAG-PB form (Links must be a list)");
+	for (let i = 0; i < node.Links.length; i++) {
+		const link = node.Links[i];
+		if (!link || typeof link !== "object" || Array.isArray(link) || link instanceof Uint8Array || link["/"] && link["/"] === link.bytes) throw new TypeError("Invalid DAG-PB form (bad link)");
+		if (!hasOnlyProperties(link, pbLinkProperties)) throw new TypeError("Invalid DAG-PB form (extraneous properties on link)");
+		if (link.Hash === void 0) throw new TypeError("Invalid DAG-PB form (link must have a Hash)");
+		if (link.Hash == null || !link.Hash["/"] || link.Hash["/"] !== link.Hash.bytes) throw new TypeError("Invalid DAG-PB form (link Hash must be a CID)");
+		if (link.Name !== void 0 && typeof link.Name !== "string") throw new TypeError("Invalid DAG-PB form (link Name must be a string)");
+		if (link.Tsize !== void 0) {
+			if (typeof link.Tsize !== "number" || link.Tsize % 1 !== 0) throw new TypeError("Invalid DAG-PB form (link Tsize must be an integer)");
+			if (link.Tsize < 0) throw new TypeError("Invalid DAG-PB form (link Tsize cannot be negative)");
+		}
+		if (i > 0 && linkComparator(link, node.Links[i - 1]) === -1) throw new TypeError("Invalid DAG-PB form (links must be sorted by Name bytes)");
+	}
+}
+/**
+* @param {Uint8Array} data
+* @param {PBLink[]} [links]
+* @returns {PBNode}
+*/
+function createNode(data, links = []) {
+	return prepare({
+		Data: data,
+		Links: links
+	});
+}
+/**
+* @param {string} name
+* @param {number} size
+* @param {CID} cid
+* @returns {PBLink}
+*/
+function createLink(name, size, cid) {
+	return asLink({
+		Hash: cid,
+		Name: name,
+		Tsize: size
+	});
+}
+/**
+* @template T
+* @param {ByteView<T> | ArrayBufferView<T>} buf
+* @returns {ByteView<T>}
+*/
+function toByteView(buf) {
+	if (buf instanceof ArrayBuffer) return new Uint8Array(buf, 0, buf.byteLength);
+	return buf;
+}
+//#endregion
+//#region node_modules/@ipld/dag-pb/src/index.js
+var src_exports = /* @__PURE__ */ __exportAll({
+	code: () => 112,
+	createLink: () => createLink,
+	createNode: () => createNode,
+	decode: () => decode,
+	encode: () => encode,
+	name: () => name,
+	prepare: () => prepare,
+	validate: () => validate
+});
+/**
+* @template T
+* @typedef {import('multiformats/codecs/interface').ByteView<T>} ByteView
+*/
+/**
+* @template T
+* @typedef {import('multiformats/codecs/interface').ArrayBufferView<T>} ArrayBufferView
+*/
+/**
+* @typedef {import('./interface.js').PBLink} PBLink
+* @typedef {import('./interface.js').PBNode} PBNode
+*/
+const name = "dag-pb";
+/**
+* @param {PBNode} node
+* @returns {ByteView<PBNode>}
+*/
+function encode(node) {
+	validate(node);
+	const pbn = {};
+	if (node.Links) pbn.Links = node.Links.map((l) => {
+		const link = {};
+		if (l.Hash) link.Hash = l.Hash.bytes;
+		if (l.Name !== void 0) link.Name = l.Name;
+		if (l.Tsize !== void 0) link.Tsize = l.Tsize;
+		return link;
+	});
+	if (node.Data) pbn.Data = node.Data;
+	return encodeNode(pbn);
+}
+/**
+* @param {ByteView<PBNode> | ArrayBufferView<PBNode>} bytes
+* @returns {PBNode}
+*/
+function decode(bytes) {
+	const pbn = decodeNode(toByteView(bytes));
+	const node = {};
+	if (pbn.Data) node.Data = pbn.Data;
+	if (pbn.Links) node.Links = pbn.Links.map((l) => {
+		const link = {};
+		try {
+			link.Hash = CID.decode(l.Hash);
+		} catch {}
+		if (!link.Hash) throw new Error("Invalid Hash field found in link, expected CID");
+		if (l.Name !== void 0) link.Name = l.Name;
+		if (l.Tsize !== void 0) link.Tsize = l.Tsize;
+		return link;
+	});
+	return node;
+}
+//#endregion
+export { first as i, src_exports as n, prepare as r, encode as t };