@bcts/uniform-resources 1.0.0-alpha.12 → 1.0.0-alpha.14

package/dist/index.cjs

@@ -1,3 +1,4 @@
+let _bcts_crypto = require("@bcts/crypto");
 
 //#region ../dcbor/dist/index.mjs
 var __create = Object.create;
@@ -4898,7 +4899,13 @@ var TagsStore = class {
 	/**
 	* Insert a tag into the registry.
 	*
-	* @param tag - The tag to register
+	* Matches Rust's TagsStore::insert() behavior:
+	* - Throws if the tag name is undefined or empty
+	* - Throws if a tag with the same value exists with a different name
+	* - Allows re-registering the same tag value with the same name
+	*
+	* @param tag - The tag to register (must have a non-empty name)
+	* @throws Error if tag has no name, empty name, or conflicts with existing registration
 	*
 	* @example
 	* ```typescript
@@ -4907,9 +4914,13 @@ var TagsStore = class {
 	* ```
 	*/
 	insert(tag) {
+		const name = tag.name;
+		if (name === void 0 || name === "") throw new Error(`Tag ${tag.value} must have a non-empty name`);
 		const key = this.#valueKey(tag.value);
+		const existing = this.#tagsByValue.get(key);
+		if (existing?.name !== void 0 && existing.name !== name) throw new Error(`Attempt to register tag: ${tag.value} '${existing.name}' with different name: '${name}'`);
 		this.#tagsByValue.set(key, tag);
-		if (tag.name !== void 0) this.#tagsByName.set(tag.name, tag);
+		this.#tagsByName.set(name, tag);
 	}
 	/**
 	* Insert multiple tags into the registry.
@@ -4947,21 +4958,6 @@ var TagsStore = class {
 		const key = this.#valueKey(tagValue$1);
 		this.#summarizers.set(key, summarizer);
 	}
-	/**
-	* Remove a tag from the registry.
-	*
-	* @param tagValue - The numeric tag value to remove
-	* @returns true if a tag was removed, false otherwise
-	*/
-	remove(tagValue$1) {
-		const key = this.#valueKey(tagValue$1);
-		const tag = this.#tagsByValue.get(key);
-		if (tag === void 0) return false;
-		this.#tagsByValue.delete(key);
-		if (tag.name !== void 0) this.#tagsByName.delete(tag.name);
-		this.#summarizers.delete(key);
-		return true;
-	}
 	assignedNameForTag(tag) {
 		const key = this.#valueKey(tag.value);
 		return this.#tagsByValue.get(key)?.name;
@@ -4985,30 +4981,6 @@ var TagsStore = class {
 		return this.#summarizers.get(key);
 	}
 	/**
-	* Get all registered tags.
-	*
-	* @returns Array of all registered tags
-	*/
-	getAllTags() {
-		return Array.from(this.#tagsByValue.values());
-	}
-	/**
-	* Clear all registered tags and summarizers.
-	*/
-	clear() {
-		this.#tagsByValue.clear();
-		this.#tagsByName.clear();
-		this.#summarizers.clear();
-	}
-	/**
-	* Get the number of registered tags.
-	*
-	* @returns Number of tags in the registry
-	*/
-	get size() {
-		return this.#tagsByValue.size;
-	}
-	/**
 	* Create a string key for a numeric tag value.
 	* Handles both number and bigint types.
 	*
@@ -5371,11 +5343,17 @@ function formatMap(map, opts) {
 }
 /**
 * Format tagged value.
+*
+* Matches Rust's diag_item() for Tagged case.
 */
 function formatTagged(tag, content, opts) {
 	if (opts.summarize === true) {
 		const summarizer = resolveTagsStore(opts.tags)?.summarizer(tag);
-		if (summarizer !== void 0) return summarizer(content, opts.flat ?? false);
+		if (summarizer !== void 0) {
+			const result$1 = summarizer(content, opts.flat ?? false);
+			if (result$1.ok) return result$1.value;
+			else return `<error: ${result$1.error.type === "Custom" ? result$1.error.message : result$1.error.type === "WrongTag" ? `expected CBOR tag ${result$1.error.expected.value}, but got ${result$1.error.actual.value}` : result$1.error.type}>`;
+		}
 	}
 	let comment;
 	if (opts.annotate === true) {
@@ -6006,21 +5984,20 @@ let EdgeType = /* @__PURE__ */ function(EdgeType$1) {
 * @param cbor - The CBOR value to traverse
 * @param initialState - Initial state value
 * @param visitor - Function to call for each element
-* @returns Final state after traversal
 *
 * @example
 * ```typescript
-* // Count all text strings in a structure
-* interface CountState { count: number }
+* // Count all text strings in a structure using RefCell-like pattern
+* const count = { value: 0 };
 *
 * const structure = cbor({ name: 'Alice', tags: ['urgent', 'draft'] });
-* const result = walk(structure, { count: 0 }, (element, level, edge, state) => {
+* walk(structure, null, (element, level, edge, state) => {
 *   if (element.type === 'single' && element.cbor.type === MajorType.Text) {
-*     return [{ count: state.count + 1 }, false];
+*     count.value++;
 *   }
 *   return [state, false];
 * });
-* console.log(result.count); // 3 (name, urgent, draft)
+* console.log(count.value); // 3 (name, urgent, draft)
 * ```
 *
 * @example
@@ -6029,7 +6006,7 @@ let EdgeType = /* @__PURE__ */ function(EdgeType$1) {
 * const structure = cbor([1, 2, 3, 'found', 5, 6]);
 * let found = false;
 *
-* walk(structure, null, (element, level, edge) => {
+* walk(structure, null, (element, level, edge, state) => {
 *   if (element.type === 'single' &&
 *       element.cbor.type === MajorType.Text &&
 *       element.cbor.value === 'found') {
@@ -6041,7 +6018,7 @@ let EdgeType = /* @__PURE__ */ function(EdgeType$1) {
 * ```
 */
 const walk = (cbor$1, initialState, visitor) => {
-	return walkInternal(cbor$1, 0, { type: EdgeType.None }, initialState, visitor);
+	walkInternal(cbor$1, 0, { type: EdgeType.None }, initialState, visitor);
 };
 /**
 * Internal recursive walk implementation.
@@ -6525,7 +6502,7 @@ const attachMethods = (obj) => {
 			return this.value;
 		},
 		walk(initialState, visitor) {
-			return walk(this, initialState, visitor);
+			walk(this, initialState, visitor);
 		},
 		validateTag(expectedTags) {
 			if (this.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
@@ -6661,6 +6638,16 @@ var CBORError = class extends URError {
 	}
 };
 /**
+* Error type for UR decoder errors.
+* Matches Rust's Error::UR(String) variant.
+*/
+var URDecodeError = class extends URError {
+	constructor(message) {
+		super(`UR decoder error (${message})`);
+		this.name = "URDecodeError";
+	}
+};
+/**
 * Helper function to check if a result is an error.
 */
 function isError(result) {
@@ -6689,13 +6676,6 @@ function isValidURType(urType) {
 	return Array.from(urType).every((char) => isURTypeChar(char));
 }
 /**
-* Validates and returns a UR type, or throws an error if invalid.
-*/
-function validateURType(urType) {
-	if (!isValidURType(urType)) throw new InvalidTypeError();
-	return urType;
-}
-/**
 * Bytewords for encoding/decoding bytes as words.
 * See: https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-004-bytewords.md
 */
@@ -7266,7 +7246,7 @@ function encodeBytemojisIdentifier(data) {
 let BytewordsStyle = /* @__PURE__ */ function(BytewordsStyle$1) {
 	/** Full 4-letter words separated by spaces */
 	BytewordsStyle$1["Standard"] = "standard";
-	/** Full 4-letter words without separators */
+	/** Full 4-letter words separated by hyphens (URI-safe) */
 	BytewordsStyle$1["Uri"] = "uri";
 	/** First and last character only (minimal) - used by UR encoding */
 	BytewordsStyle$1["Minimal"] = "minimal";
@@ -7342,7 +7322,7 @@ function encodeBytewords(data, style = BytewordsStyle.Minimal) {
 	}
 	switch (style) {
 		case BytewordsStyle.Standard: return words.join(" ");
-		case BytewordsStyle.Uri:
+		case BytewordsStyle.Uri: return words.join("-");
 		case BytewordsStyle.Minimal: return words.join("");
 	}
 }
@@ -7362,14 +7342,11 @@ function decodeBytewords(encoded, style = BytewordsStyle.Minimal) {
 			});
 			break;
 		case BytewordsStyle.Uri:
-			if (lowercased.length % 4 !== 0) throw new Error("Invalid URI bytewords length");
-			bytes = [];
-			for (let i = 0; i < lowercased.length; i += 4) {
-				const word = lowercased.slice(i, i + 4);
+			bytes = lowercased.split("-").map((word) => {
 				const index = BYTEWORDS_MAP.get(word);
 				if (index === void 0) throw new Error(`Invalid byteword: ${word}`);
-				bytes.push(index);
-			}
+				return index;
+			});
 			break;
 		case BytewordsStyle.Minimal:
 			if (lowercased.length % 2 !== 0) throw new Error("Invalid minimal bytewords length");
@@ -7674,6 +7651,7 @@ function isURCodable(obj) {
 * for deterministic fragment selection in fountain codes.
 *
 * Reference: https://prng.di.unimi.it/
+* BC-UR Reference: https://github.com/nicklockwood/fountain-codes
 */
 const MAX_UINT64 = BigInt("0xffffffffffffffff");
 /**
@@ -7693,21 +7671,28 @@ function rotl(x, k) {
 var Xoshiro256 = class Xoshiro256 {
 	s;
 	/**
-	* Creates a new Xoshiro256** instance from a seed.
+	* Creates a new Xoshiro256** instance from a 32-byte seed.
 	*
-	* The seed is hashed using SHA-256 to initialize the state.
-	* For consistent results across encoder/decoder, use the same seed.
+	* The seed must be exactly 32 bytes (256 bits). The bytes are interpreted
+	* using the BC-UR reference algorithm: each 8-byte chunk is read as
+	* big-endian then stored as little-endian for the state.
 	*
-	* @param seed - The seed bytes (any length)
+	* @param seed - The seed bytes (must be exactly 32 bytes)
 	*/
 	constructor(seed) {
-		const hash = this.hashSeed(seed);
-		this.s = [
-			this.bytesToBigInt(hash.slice(0, 8)),
-			this.bytesToBigInt(hash.slice(8, 16)),
-			this.bytesToBigInt(hash.slice(16, 24)),
-			this.bytesToBigInt(hash.slice(24, 32))
+		if (seed.length !== 32) throw new Error(`Seed must be 32 bytes, got ${seed.length}`);
+		const s = [
+			0n,
+			0n,
+			0n,
+			0n
 		];
+		for (let i = 0; i < 4; i++) {
+			let v = 0n;
+			for (let n = 0; n < 8; n++) v = v << 8n | BigInt(seed[8 * i + n] ?? 0);
+			s[i] = v;
+		}
+		this.s = s;
 	}
 	/**
 	* Creates a Xoshiro256** instance from raw state values.
@@ -7724,33 +7709,6 @@ var Xoshiro256 = class Xoshiro256 {
 		return instance;
 	}
 	/**
-	* Simple hash function for seeding.
-	* This is a basic implementation - in production use SHA-256.
-	*/
-	hashSeed(seed) {
-		const result = new Uint8Array(32);
-		if (seed.length === 0) return result;
-		for (let i = 0; i < 32; i++) {
-			let hash = 0;
-			for (const byte of seed) hash = hash * 31 + byte + i >>> 0;
-			hash ^= hash >>> 16;
-			hash = hash * 2246822507 >>> 0;
-			hash ^= hash >>> 13;
-			hash = hash * 3266489909 >>> 0;
-			hash ^= hash >>> 16;
-			result[i] = hash & 255;
-		}
-		return result;
-	}
-	/**
-	* Converts 8 bytes to a 64-bit BigInt (little-endian).
-	*/
-	bytesToBigInt(bytes) {
-		let result = 0n;
-		for (let i = 7; i >= 0; i--) result = result << 8n | BigInt(bytes[i] ?? 0);
-		return result;
-	}
-	/**
 	* Generates the next 64-bit random value.
 	*/
 	next() {
@@ -7766,17 +7724,19 @@ var Xoshiro256 = class Xoshiro256 {
 	}
 	/**
 	* Generates a random double in [0, 1).
+	* Matches BC-UR reference: self.next() as f64 / (u64::MAX as f64 + 1.0)
 	*/
 	nextDouble() {
 		const value = this.next();
-		return Number(value >> 11n) / Number(1n << 53n);
+		return Number(value) / 0x10000000000000000;
 	}
 	/**
-	* Generates a random integer in [low, high).
+	* Generates a random integer in [low, high] (inclusive).
+	* Matches BC-UR reference: (self.next_double() * ((high - low + 1) as f64)) as u64 + low
 	*/
 	nextInt(low, high) {
-		const range$1 = high - low;
-		return low + Math.floor(this.nextDouble() * range$1);
+		const range$1 = high - low + 1;
+		return Math.floor(this.nextDouble() * range$1) + low;
 	}
 	/**
 	* Generates a random byte [0, 255].
@@ -7792,24 +7752,102 @@ var Xoshiro256 = class Xoshiro256 {
 		for (let i = 0; i < count; i++) result[i] = this.nextByte();
 		return result;
 	}
+	/**
+	* Shuffles items by repeatedly picking random indices.
+	* Matches BC-UR reference implementation.
+	*/
+	shuffled(items) {
+		const source = [...items];
+		const shuffled = [];
+		while (source.length > 0) {
+			const index = this.nextInt(0, source.length - 1);
+			const item = source.splice(index, 1)[0];
+			if (item !== void 0) shuffled.push(item);
+		}
+		return shuffled;
+	}
+	/**
+	* Chooses the degree (number of fragments to mix) using a weighted sampler.
+	* Uses the robust soliton distribution with weights [1/1, 1/2, 1/3, ..., 1/n].
+	* Matches BC-UR reference implementation.
+	*/
+	chooseDegree(seqLen) {
+		const weights = [];
+		for (let i = 1; i <= seqLen; i++) weights.push(1 / i);
+		return new WeightedSampler(weights).next(this) + 1;
+	}
+};
+/**
+* Weighted sampler using Vose's alias method.
+* Allows O(1) sampling from a discrete probability distribution.
+*/
+var WeightedSampler = class {
+	aliases;
+	probs;
+	constructor(weights) {
+		const n = weights.length;
+		if (n === 0) throw new Error("Weights array cannot be empty");
+		const sum = weights.reduce((a, b) => a + b, 0);
+		if (sum <= 0) throw new Error("Weights must sum to a positive value");
+		const normalized = weights.map((w) => w * n / sum);
+		this.aliases = Array.from({ length: n }).fill(0);
+		this.probs = Array.from({ length: n }).fill(0);
+		const small = [];
+		const large = [];
+		for (let i = n - 1; i >= 0; i--) if (normalized[i] < 1) small.push(i);
+		else large.push(i);
+		while (small.length > 0 && large.length > 0) {
+			const a = small.pop();
+			const g = large.pop();
+			if (a === void 0 || g === void 0) break;
+			this.probs[a] = normalized[a] ?? 0;
+			this.aliases[a] = g;
+			normalized[g] = (normalized[g] ?? 0) + (normalized[a] ?? 0) - 1;
+			if (normalized[g] !== void 0 && normalized[g] < 1) small.push(g);
+			else large.push(g);
+		}
+		while (large.length > 0) {
+			const g = large.pop();
+			if (g === void 0) break;
+			this.probs[g] = 1;
+		}
+		while (small.length > 0) {
+			const a = small.pop();
+			if (a === void 0) break;
+			this.probs[a] = 1;
+		}
+	}
+	/**
+	* Sample from the distribution.
+	*/
+	next(rng) {
+		const r1 = rng.nextDouble();
+		const r2 = rng.nextDouble();
+		const n = this.probs.length;
+		const i = Math.floor(n * r1);
+		if (r2 < this.probs[i]) return i;
+		else return this.aliases[i];
+	}
 };
 /**
-* Creates a seed for the Xoshiro PRNG from message checksum and sequence number.
+* Creates a Xoshiro256 PRNG instance from message checksum and sequence number.
+*
+* This creates an 8-byte seed by concatenating seqNum and checksum (both in
+* big-endian), then hashes it with SHA-256 to get the 32-byte seed for Xoshiro.
 *
-* This ensures that both encoder and decoder produce the same random sequence
-* for a given message and part number.
+* This matches the BC-UR reference implementation.
 */
 function createSeed(checksum, seqNum) {
-	const seed = new Uint8Array(8);
-	seed[0] = checksum >>> 24 & 255;
-	seed[1] = checksum >>> 16 & 255;
-	seed[2] = checksum >>> 8 & 255;
-	seed[3] = checksum & 255;
-	seed[4] = seqNum >>> 24 & 255;
-	seed[5] = seqNum >>> 16 & 255;
-	seed[6] = seqNum >>> 8 & 255;
-	seed[7] = seqNum & 255;
-	return seed;
+	const seed8 = new Uint8Array(8);
+	seed8[0] = seqNum >>> 24 & 255;
+	seed8[1] = seqNum >>> 16 & 255;
+	seed8[2] = seqNum >>> 8 & 255;
+	seed8[3] = seqNum & 255;
+	seed8[4] = checksum >>> 24 & 255;
+	seed8[5] = checksum >>> 16 & 255;
+	seed8[6] = checksum >>> 8 & 255;
+	seed8[7] = checksum & 255;
+	return (0, _bcts_crypto.sha256)(seed8);
 }
 
 //#endregion
@@ -7856,6 +7894,11 @@ function xorBytes(a, b) {
 * This uses a seeded Xoshiro256** PRNG to deterministically select fragments,
 * ensuring encoder and decoder agree without explicit coordination.
 *
+* The algorithm matches the BC-UR reference implementation:
+* 1. For pure parts (seqNum <= seqLen), return single fragment index
+* 2. For mixed parts, use weighted sampling to choose degree
+* 3. Shuffle all indices and take the first 'degree' indices
+*
 * @param seqNum - The sequence number (1-based)
 * @param seqLen - Total number of pure fragments
 * @param checksum - CRC32 checksum of the message
@@ -7864,26 +7907,10 @@ function xorBytes(a, b) {
 function chooseFragments(seqNum, seqLen, checksum) {
 	if (seqNum <= seqLen) return [seqNum - 1];
 	const rng = new Xoshiro256(createSeed(checksum, seqNum));
-	const degree = chooseDegree(rng, seqLen);
-	const indices = /* @__PURE__ */ new Set();
-	while (indices.size < degree) {
-		const index = rng.nextInt(0, seqLen);
-		indices.add(index);
-	}
-	return Array.from(indices).sort((a, b) => a - b);
-}
-/**
-* Chooses the degree (number of fragments to mix) using a simplified
-* robust soliton distribution.
-*
-* This ensures good coverage of fragments for efficient decoding.
-*/
-function chooseDegree(rng, seqLen) {
-	const r = rng.nextDouble();
-	if (r < .5) return 1;
-	else if (r < .75) return 2;
-	else if (r < .9) return Math.min(3, seqLen);
-	else return Math.min(rng.nextInt(4, seqLen + 1), seqLen);
+	const degree = rng.chooseDegree(seqLen);
+	const allIndices = [];
+	for (let i = 0; i < seqLen; i++) allIndices.push(i);
+	return rng.shuffled(allIndices).slice(0, degree);
 }
 /**
 * Mixes the selected fragments using XOR.
@@ -8123,14 +8150,6 @@ var MultipartEncoder = class {
 		this._fountainEncoder = new FountainEncoder(ur.cbor().toData(), maxFragmentLen);
 	}
 	/**
-	* Returns whether the message fits in a single part.
-	*
-	* For single-part messages, consider using UR.string() directly.
-	*/
-	isSinglePart() {
-		return this._fountainEncoder.isSinglePart();
-	}
-	/**
 	* Gets the next part of the encoding.
 	*
 	* Parts 1 through seqLen are "pure" fragments containing one piece each.
@@ -8158,20 +8177,17 @@ var MultipartEncoder = class {
 		return `ur:${this._ur.urTypeStr()}/${part.seqNum}-${part.seqLen}/${encoded}`;
 	}
 	/**
-	* Encodes part metadata and data into bytes for bytewords encoding.
+	* Encodes part metadata and data as CBOR for bytewords encoding.
+	* Format: CBOR array [seqNum, seqLen, messageLen, checksum, data]
 	*/
 	_encodePartData(part) {
-		const result = new Uint8Array(8 + part.data.length);
-		result[0] = part.messageLen >>> 24 & 255;
-		result[1] = part.messageLen >>> 16 & 255;
-		result[2] = part.messageLen >>> 8 & 255;
-		result[3] = part.messageLen & 255;
-		result[4] = part.checksum >>> 24 & 255;
-		result[5] = part.checksum >>> 16 & 255;
-		result[6] = part.checksum >>> 8 & 255;
-		result[7] = part.checksum & 255;
-		result.set(part.data, 8);
-		return result;
+		return cbor([
+			part.seqNum,
+			part.seqLen,
+			part.messageLen,
+			part.checksum,
+			part.data
+		]).toData();
 	}
 	/**
 	* Gets the current part index.
@@ -8188,22 +8204,6 @@ var MultipartEncoder = class {
 	partsCount() {
 		return this._fountainEncoder.seqLen;
 	}
-	/**
-	* Checks if all pure parts have been emitted.
-	*
-	* Even after this returns true, you can continue calling nextPart()
-	* to generate additional rateless parts for redundancy.
-	*/
-	isComplete() {
-		return this._fountainEncoder.isComplete();
-	}
-	/**
-	* Resets the encoder to start from the beginning.
-	*/
-	reset() {
-		this._currentIndex = 0;
-		this._fountainEncoder.reset();
-	}
 };
 
 //#endregion
@@ -8285,16 +8285,23 @@ var MultipartDecoder = class {
 	}
 	/**
 	* Decodes a multipart UR's fountain part data.
+	*
+	* The multipart body is a CBOR array: [seqNum, seqLen, messageLen, checksum, data]
 	*/
 	_decodeFountainPart(partInfo) {
-		const rawData = decodeBytewords(partInfo.encodedData, BytewordsStyle.Minimal);
-		if (rawData.length < 8) throw new URError("Invalid multipart data: too short");
-		const messageLen = (rawData[0] << 24 | rawData[1] << 16 | rawData[2] << 8 | rawData[3]) >>> 0;
-		const checksum = (rawData[4] << 24 | rawData[5] << 16 | rawData[6] << 8 | rawData[7]) >>> 0;
-		const data = rawData.slice(8);
+		const decoded = decodeCbor(decodeBytewords(partInfo.encodedData, BytewordsStyle.Minimal));
+		if (decoded.type !== MajorType.Array) throw new URError("Invalid multipart data: expected CBOR array");
+		const items = decoded.value;
+		if (items.length !== 5) throw new URError(`Invalid multipart data: expected 5 elements, got ${items.length}`);
+		const seqNum = Number(items[0].value);
+		const seqLen = Number(items[1].value);
+		const messageLen = Number(items[2].value);
+		const checksum = Number(items[3].value);
+		const data = items[4].value;
+		if (seqNum !== partInfo.seqNum || seqLen !== partInfo.seqLen) throw new URError(`Multipart metadata mismatch: URL says ${partInfo.seqNum}-${partInfo.seqLen}, CBOR says ${seqNum}-${seqLen}`);
 		return {
-			seqNum: partInfo.seqNum,
-			seqLen: partInfo.seqLen,
+			seqNum,
+			seqLen,
 			messageLen,
 			checksum,
 			data
@@ -8314,48 +8321,25 @@ var MultipartDecoder = class {
 	message() {
 		return this._decodedMessage;
 	}
-	/**
-	* Returns the decoding progress as a fraction (0 to 1).
-	*/
-	progress() {
-		if (this._decodedMessage !== null) return 1;
-		if (this._fountainDecoder === null) return 0;
-		return this._fountainDecoder.progress();
-	}
-	/**
-	* Resets the decoder to receive a new message.
-	*/
-	reset() {
-		this._urType = null;
-		this._fountainDecoder = null;
-		this._decodedMessage = null;
-	}
 };
 
 //#endregion
 exports.BYTEMOJIS = BYTEMOJIS;
 exports.BYTEWORDS = BYTEWORDS;
-exports.BYTEWORDS_MAP = BYTEWORDS_MAP;
 exports.BytewordsError = BytewordsError;
 exports.BytewordsStyle = BytewordsStyle;
 exports.CBORError = CBORError;
-exports.FountainDecoder = FountainDecoder;
-exports.FountainEncoder = FountainEncoder;
 exports.InvalidSchemeError = InvalidSchemeError;
 exports.InvalidTypeError = InvalidTypeError;
-exports.MINIMAL_BYTEWORDS_MAP = MINIMAL_BYTEWORDS_MAP;
 exports.MultipartDecoder = MultipartDecoder;
 exports.MultipartEncoder = MultipartEncoder;
 exports.NotSinglePartError = NotSinglePartError;
 exports.TypeUnspecifiedError = TypeUnspecifiedError;
 exports.UR = UR;
+exports.URDecodeError = URDecodeError;
 exports.URError = URError;
 exports.URType = URType;
 exports.UnexpectedTypeError = UnexpectedTypeError;
-exports.Xoshiro256 = Xoshiro256;
-exports.chooseFragments = chooseFragments;
-exports.crc32 = crc32;
-exports.createSeed = createSeed;
 exports.decodeBytewords = decodeBytewords;
 exports.encodeBytemojisIdentifier = encodeBytemojisIdentifier;
 exports.encodeBytewords = encodeBytewords;
@@ -8364,10 +8348,4 @@ exports.isError = isError;
 exports.isURCodable = isURCodable;
 exports.isURDecodable = isURDecodable;
 exports.isUREncodable = isUREncodable;
-exports.isURTypeChar = isURTypeChar;
-exports.isValidURType = isValidURType;
-exports.mixFragments = mixFragments;
-exports.splitMessage = splitMessage;
-exports.validateURType = validateURType;
-exports.xorBytes = xorBytes;
 //# sourceMappingURL=index.cjs.map