@bcts/seedtool-cli 1.0.0-alpha.14

package/dist/index.cjs

@@ -0,0 +1,1370 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let readline = require("readline");
+readline = __toESM(readline);
+let _bcts_components = require("@bcts/components");
+let _bcts_envelope = require("@bcts/envelope");
+let _bcts_known_values = require("@bcts/known-values");
+let _bcts_dcbor = require("@bcts/dcbor");
+let _noble_hashes_sha256 = require("@noble/hashes/sha256");
+let _noble_hashes_hkdf = require("@noble/hashes/hkdf");
+let _scure_bip39 = require("@scure/bip39");
+let _scure_bip39_wordlists_english = require("@scure/bip39/wordlists/english");
+let _bcts_uniform_resources = require("@bcts/uniform-resources");
+let _bcts_tags = require("@bcts/tags");
+
+//#region src/cli.ts
+/**
+* CLI types and interfaces
+* Ported from seedtool-cli-rust/src/cli.rs
+*/
+/**
+* Input format keys.
+* Matches Rust InputFormatKey enum in format.rs
+*/
+let InputFormatKey = /* @__PURE__ */ function(InputFormatKey$1) {
+	InputFormatKey$1["Random"] = "random";
+	InputFormatKey$1["Hex"] = "hex";
+	InputFormatKey$1["Btw"] = "btw";
+	InputFormatKey$1["Btwu"] = "btwu";
+	InputFormatKey$1["Btwm"] = "btwm";
+	InputFormatKey$1["Bits"] = "bits";
+	InputFormatKey$1["Cards"] = "cards";
+	InputFormatKey$1["Dice"] = "dice";
+	InputFormatKey$1["Base6"] = "base6";
+	InputFormatKey$1["Base10"] = "base10";
+	InputFormatKey$1["Ints"] = "ints";
+	InputFormatKey$1["Bip39"] = "bip39";
+	InputFormatKey$1["Sskr"] = "sskr";
+	InputFormatKey$1["Envelope"] = "envelope";
+	InputFormatKey$1["Multipart"] = "multipart";
+	InputFormatKey$1["Seed"] = "seed";
+	return InputFormatKey$1;
+}({});
+/**
+* Output format keys.
+* Matches Rust OutputFormatKey enum in format.rs
+*/
+let OutputFormatKey = /* @__PURE__ */ function(OutputFormatKey$1) {
+	OutputFormatKey$1["Hex"] = "hex";
+	OutputFormatKey$1["Btw"] = "btw";
+	OutputFormatKey$1["Btwu"] = "btwu";
+	OutputFormatKey$1["Btwm"] = "btwm";
+	OutputFormatKey$1["Bits"] = "bits";
+	OutputFormatKey$1["Cards"] = "cards";
+	OutputFormatKey$1["Dice"] = "dice";
+	OutputFormatKey$1["Base6"] = "base6";
+	OutputFormatKey$1["Base10"] = "base10";
+	OutputFormatKey$1["Ints"] = "ints";
+	OutputFormatKey$1["Bip39"] = "bip39";
+	OutputFormatKey$1["Sskr"] = "sskr";
+	OutputFormatKey$1["Envelope"] = "envelope";
+	OutputFormatKey$1["Multipart"] = "multipart";
+	OutputFormatKey$1["Seed"] = "seed";
+	return OutputFormatKey$1;
+}({});
+/**
+* SSKR output format keys.
+* Matches Rust SSKRFormatKey enum in sskr.rs
+*/
+let SSKRFormatKey = /* @__PURE__ */ function(SSKRFormatKey$1) {
+	SSKRFormatKey$1["Envelope"] = "envelope";
+	SSKRFormatKey$1["Btw"] = "btw";
+	SSKRFormatKey$1["Btwm"] = "btwm";
+	SSKRFormatKey$1["Btwu"] = "btwu";
+	SSKRFormatKey$1["Ur"] = "ur";
+	return SSKRFormatKey$1;
+}({});
+/**
+* Parse and validate low int (0-254).
+* Matches Rust parse_low_int function.
+*/
+function parseLowInt(s) {
+	const n = parseInt(s, 10);
+	if (isNaN(n) || n < 0 || n > 254) throw new Error(`Invalid low value: ${s}. Must be 0-254.`);
+	return n;
+}
+/**
+* Parse and validate high int (1-255).
+* Matches Rust parse_high_int function.
+*/
+function parseHighInt(s) {
+	const n = parseInt(s, 10);
+	if (isNaN(n) || n < 1 || n > 255) throw new Error(`Invalid high value: ${s}. Must be 1-255.`);
+	return n;
+}
+/**
+* Parse and validate group threshold (1-16).
+* Matches Rust parse_group_threshold function.
+*/
+function parseGroupThreshold(s) {
+	const n = parseInt(s, 10);
+	if (isNaN(n) || n < 1 || n > 16) throw new Error(`Invalid group threshold: ${s}. Must be 1-16.`);
+	return n;
+}
+/**
+* Parse date string.
+* Accepts "now" or ISO-8601 format.
+* Matches Rust parse_date function.
+*/
+function parseDate(s) {
+	if (s === "now") return /* @__PURE__ */ new Date();
+	const date = new Date(s);
+	if (isNaN(date.getTime())) throw new Error(`Invalid date: ${s}. Use ISO-8601 format or 'now'.`);
+	return date;
+}
+/**
+* Parse SSKR group specification "M-of-N".
+* Returns SSKRGroupSpec instance.
+*/
+function parseGroupSpec(s) {
+	const match = s.match(/^(\d+)-of-(\d+)$/i);
+	if (!match) throw new Error(`Invalid group specification: ${s}. Use format 'M-of-N' (e.g., '2-of-3').`);
+	const threshold = parseInt(match[1], 10);
+	const count = parseInt(match[2], 10);
+	return _bcts_components.SSKRGroupSpec.new(threshold, count);
+}
+/**
+* CLI state and configuration.
+* Matches Rust Cli struct.
+*/
+var Cli = class Cli {
+	/** The input to be transformed. If required and not present, will be read from stdin. */
+	input;
+	/** The number of output units (hex bytes, base-10 digits, etc.) */
+	count = 16;
+	/** The input format. Default: Random */
+	in = InputFormatKey.Random;
+	/** The output format. Default: Hex */
+	out = OutputFormatKey.Hex;
+	/** The lowest int returned (0-254). Default: 0 */
+	low = 0;
+	/** The highest int returned (1-255), low < high. Default: 9 */
+	high = 9;
+	/** The name of the seed. */
+	name;
+	/** The note associated with the seed. */
+	note;
+	/** The seed's creation date, in ISO-8601 format. May also be `now`. */
+	date;
+	/** For `multipart` output, max fragment length. Default: 500 */
+	maxFragmentLen = 500;
+	/** For `multipart` output, additional parts for fountain encoding. Default: 0 */
+	additionalParts = 0;
+	/** Group specifications for SSKR. */
+	groups = [];
+	/** The number of groups that must meet their threshold. Default: 1 */
+	groupThreshold = 1;
+	/** SSKR output format. Default: Envelope */
+	sskrFormat = SSKRFormatKey.Envelope;
+	/** Deterministic RNG seed string. */
+	deterministic;
+	/** The seed being processed (internal state). */
+	seed;
+	/** The RNG source (internal state). */
+	rng;
+	/**
+	* Get input from argument or read from stdin.
+	* Matches Rust expect_input method.
+	*/
+	expectInput() {
+		if (this.input !== void 0) return this.input;
+		throw new Error("Input required but not provided. Use stdin or pass as argument.");
+	}
+	/**
+	* Get input from argument or read from stdin asynchronously.
+	* This is the async version for actual CLI use.
+	*/
+	async expectInputAsync() {
+		if (this.input !== void 0) return this.input;
+		return new Promise((resolve, reject) => {
+			let data = "";
+			const rl = readline.createInterface({
+				input: process.stdin,
+				output: process.stdout,
+				terminal: false
+			});
+			rl.on("line", (line) => {
+				data += line + "\n";
+			});
+			rl.on("close", () => {
+				resolve(data.trim());
+			});
+			rl.on("error", (err) => {
+				reject(err);
+			});
+		});
+	}
+	/**
+	* Get the seed, throwing if not initialized.
+	* Matches Rust expect_seed method.
+	*/
+	expectSeed() {
+		if (this.seed === void 0) throw new Error("Seed not initialized");
+		return this.seed;
+	}
+	/**
+	* Generate random data using the configured RNG.
+	* Matches Rust random_data method.
+	*/
+	randomData(size) {
+		if (this.rng === void 0) throw new Error("RNG not initialized");
+		if (this.rng.type === "secure") return this.rng.rng.randomData(size);
+		else return this.rng.rng.deterministicRandomData(size);
+	}
+	/**
+	* Get the seed with CLI overrides applied (name, note, date).
+	* Matches Rust seed_with_overrides method.
+	*/
+	seedWithOverrides() {
+		const seed = this.expectSeed().clone();
+		if (this.name !== void 0) seed.setName(this.name);
+		if (this.note !== void 0) seed.setNote(this.note);
+		if (this.date !== void 0) seed.setCreationDate(this.date);
+		return seed;
+	}
+	/**
+	* Convert the seed (with overrides) to an Envelope.
+	* Matches Rust to_envelope method.
+	*/
+	toEnvelope() {
+		return this.seedWithOverrides().toEnvelope();
+	}
+	/**
+	* Build SSKR spec from CLI options.
+	* Matches Rust sskr_spec method.
+	*/
+	sskrSpec() {
+		return _bcts_components.SSKRSpec.new(this.groupThreshold, this.groups);
+	}
+	/**
+	* Clone the CLI state.
+	*/
+	clone() {
+		const cli = new Cli();
+		cli.input = this.input;
+		cli.count = this.count;
+		cli.in = this.in;
+		cli.out = this.out;
+		cli.low = this.low;
+		cli.high = this.high;
+		cli.name = this.name;
+		cli.note = this.note;
+		cli.date = this.date;
+		cli.maxFragmentLen = this.maxFragmentLen;
+		cli.additionalParts = this.additionalParts;
+		cli.groups = [...this.groups];
+		cli.groupThreshold = this.groupThreshold;
+		cli.sskrFormat = this.sskrFormat;
+		cli.deterministic = this.deterministic;
+		cli.seed = this.seed?.clone();
+		cli.rng = this.rng;
+		return cli;
+	}
+};
+
+//#endregion
+//#region src/seed.ts
+/**
+* Seed type for seedtool-cli
+* Ported from seedtool-cli-rust/src/seed.rs
+*
+* This is a local Seed type that wraps the seed data with metadata
+* and provides Envelope conversion. It differs from @bcts/components Seed
+* in that it doesn't enforce minimum length (for CLI flexibility) and
+* has direct Envelope conversion methods.
+*/
+/**
+* Seed with optional metadata.
+* Matches Rust Seed struct in seed.rs.
+*/
+var Seed = class Seed {
+	_data;
+	_name;
+	_note;
+	_creationDate;
+	/**
+	* Create a new Seed with the given data.
+	* Matches Rust Seed::new function.
+	*/
+	constructor(data) {
+		this._data = new Uint8Array(data);
+		this._name = "";
+		this._note = "";
+		this._creationDate = void 0;
+	}
+	/**
+	* Create a new Seed with data and optional metadata.
+	* Matches Rust Seed::new_opt function.
+	*/
+	static newOpt(data, name, note, creationDate) {
+		const seed = new Seed(data);
+		seed._name = name;
+		seed._note = note;
+		seed._creationDate = creationDate;
+		return seed;
+	}
+	/**
+	* Create a new Seed from raw data.
+	* Convenience factory method.
+	*/
+	static new(data) {
+		return new Seed(data);
+	}
+	/**
+	* Get the seed data.
+	* Matches Rust seed.data() method.
+	*/
+	data() {
+		return this._data;
+	}
+	/**
+	* Get the seed name.
+	* Matches Rust seed.name() method.
+	* Returns empty string if not set.
+	*/
+	name() {
+		return this._name;
+	}
+	/**
+	* Set the seed name.
+	* Matches Rust seed.set_name() method.
+	*/
+	setName(name) {
+		this._name = name;
+	}
+	/**
+	* Get the seed note.
+	* Matches Rust seed.note() method.
+	* Returns empty string if not set.
+	*/
+	note() {
+		return this._note;
+	}
+	/**
+	* Set the seed note.
+	* Matches Rust seed.set_note() method.
+	*/
+	setNote(note) {
+		this._note = note;
+	}
+	/**
+	* Get the creation date.
+	* Matches Rust seed.creation_date() method.
+	*/
+	creationDate() {
+		return this._creationDate;
+	}
+	/**
+	* Set the creation date.
+	* Matches Rust seed.set_creation_date() method.
+	*/
+	setCreationDate(date) {
+		this._creationDate = date;
+	}
+	/**
+	* Clone the seed.
+	*/
+	clone() {
+		return Seed.newOpt(new Uint8Array(this._data), this._name, this._note, this._creationDate);
+	}
+	/**
+	* Convert to Envelope.
+	* Matches Rust impl From<Seed> for Envelope.
+	*
+	* Creates an envelope with:
+	* - Subject: byte string of seed data
+	* - Type assertion: 'Seed'
+	* - Optional date assertion
+	* - Optional name assertion (if not empty)
+	* - Optional note assertion (if not empty)
+	*/
+	toEnvelope() {
+		let envelope = _bcts_envelope.Envelope.new((0, _bcts_dcbor.toByteString)(this._data));
+		envelope = envelope.addType(_bcts_known_values.SEED_TYPE);
+		if (this._creationDate !== void 0) {
+			const cborDate = _bcts_dcbor.CborDate.fromDatetime(this._creationDate);
+			envelope = envelope.addAssertion(_bcts_known_values.DATE, cborDate);
+		}
+		if (this._name.length > 0) envelope = envelope.addAssertion(_bcts_known_values.NAME, this._name);
+		if (this._note.length > 0) envelope = envelope.addAssertion(_bcts_known_values.NOTE, this._note);
+		return envelope;
+	}
+	/**
+	* Create a Seed from an Envelope.
+	* Matches Rust impl TryFrom<Envelope> for Seed.
+	*/
+	static fromEnvelope(envelope) {
+		envelope.checkTypeValue(_bcts_known_values.SEED_TYPE);
+		const leaf = envelope.subject().asLeaf();
+		if (leaf === void 0) throw new Error("Seed envelope must have a leaf subject");
+		const data = leaf.asByteString();
+		if (data === void 0) throw new Error("Seed envelope subject must be a byte string");
+		let name = "";
+		try {
+			const nameObj = envelope.objectForPredicate(_bcts_known_values.NAME);
+			if (nameObj !== void 0) {
+				const nameStr = nameObj.asText();
+				if (nameStr !== void 0) name = nameStr;
+			}
+		} catch {}
+		let note = "";
+		try {
+			const noteObj = envelope.objectForPredicate(_bcts_known_values.NOTE);
+			if (noteObj !== void 0) {
+				const noteStr = noteObj.asText();
+				if (noteStr !== void 0) note = noteStr;
+			}
+		} catch {}
+		let creationDate;
+		try {
+			const dateObj = envelope.objectForPredicate(_bcts_known_values.DATE);
+			if (dateObj !== void 0) {
+				const leaf$1 = dateObj.asLeaf();
+				if (leaf$1 !== void 0) creationDate = _bcts_dcbor.CborDate.fromTaggedCbor(leaf$1).datetime();
+			}
+		} catch {
+			try {
+				const dateObj = envelope.objectForPredicate(_bcts_known_values.DATE);
+				if (dateObj !== void 0) {
+					const dateStr = dateObj.asText();
+					if (dateStr !== void 0) creationDate = new Date(dateStr);
+				}
+			} catch {}
+		}
+		return Seed.newOpt(data, name, note, creationDate);
+	}
+	/**
+	* Convert to @bcts/components Seed.
+	* Matches Rust impl TryFrom<&Seed> for ComponentsSeed.
+	*/
+	toComponentsSeed() {
+		return _bcts_components.Seed.newOpt(this._data, this._name.length > 0 ? this._name : void 0, this._note.length > 0 ? this._note : void 0, this._creationDate);
+	}
+	/**
+	* Create from @bcts/components Seed.
+	* Matches Rust impl From<ComponentsSeed> for Seed.
+	*/
+	static fromComponentsSeed(seed) {
+		return Seed.newOpt(seed.asBytes(), seed.name(), seed.note(), seed.creationDate());
+	}
+	/**
+	* Get string representation.
+	*/
+	toString() {
+		return `Seed(${Array.from(this._data.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join("")}..., ${this._data.length} bytes)`;
+	}
+	/**
+	* Check equality with another Seed.
+	*/
+	equals(other) {
+		if (this._data.length !== other._data.length) return false;
+		for (let i = 0; i < this._data.length; i++) if (this._data[i] !== other._data[i]) return false;
+		if (this._name !== other._name) return false;
+		if (this._note !== other._note) return false;
+		if (this._creationDate?.getTime() !== other._creationDate?.getTime()) return false;
+		return true;
+	}
+};
+
+//#endregion
+//#region src/random.ts
+/**
+* Random number generation utilities
+* Ported from seedtool-cli-rust/src/random.rs
+*/
+/** SHA256 output size in bytes */
+const SHA256_SIZE = 32;
+/**
+* Deterministic random number generator.
+* Matches Rust DeterministicRandomNumberGenerator struct.
+*
+* Uses HKDF-HMAC-SHA256 to generate deterministic random data
+* from a seed, with an incrementing salt for each call.
+*/
+var DeterministicRandomNumberGenerator = class DeterministicRandomNumberGenerator {
+	seed;
+	salt;
+	/**
+	* Create a new deterministic RNG from a 32-byte seed.
+	*/
+	constructor(seed) {
+		if (seed.length !== SHA256_SIZE) throw new Error(`Seed must be ${SHA256_SIZE} bytes, got ${seed.length}`);
+		this.seed = new Uint8Array(seed);
+		this.salt = 0n;
+	}
+	/**
+	* Create a new deterministic RNG from a seed string.
+	* The string is hashed with SHA256 to produce the seed.
+	* Matches Rust new_with_seed function.
+	*/
+	static newWithSeed(seedString) {
+		return new DeterministicRandomNumberGenerator((0, _noble_hashes_sha256.sha256)(new TextEncoder().encode(seedString)));
+	}
+	/**
+	* Generate deterministic random data.
+	* Matches Rust deterministic_random_data method.
+	*
+	* Each call increments the salt and uses HKDF to derive
+	* the requested number of bytes.
+	*/
+	deterministicRandomData(size) {
+		this.salt += 1n;
+		const saltBytes = new Uint8Array(8);
+		const view = new DataView(saltBytes.buffer);
+		const low = Number(this.salt & 4294967295n);
+		const high = Number(this.salt >> 32n & 4294967295n);
+		view.setUint32(0, low, true);
+		view.setUint32(4, high, true);
+		return hkdfHmacSha256(this.seed, saltBytes, size);
+	}
+	/**
+	* Clone the RNG state.
+	*/
+	clone() {
+		const rng = new DeterministicRandomNumberGenerator(this.seed);
+		rng.salt = this.salt;
+		return rng;
+	}
+};
+/**
+* HKDF-HMAC-SHA256 key derivation.
+* Matches Rust hkdf_hmac_sha256 function from bc-crypto.
+*/
+function hkdfHmacSha256(ikm, salt, length) {
+	return (0, _noble_hashes_hkdf.hkdf)(_noble_hashes_sha256.sha256, ikm, salt, new Uint8Array(0), length);
+}
+/**
+* Generate deterministic random data from entropy using SHA256.
+* If n <= 32, returns the first n bytes of SHA256(entropy).
+* Matches Rust sha256_deterministic_random function.
+*
+* @param entropy - The entropy bytes to hash
+* @param n - Number of bytes to return (must be <= 32)
+* @throws Error if n > 32
+*/
+function sha256DeterministicRandom(entropy, n) {
+	const seed = (0, _noble_hashes_sha256.sha256)(entropy);
+	if (n <= seed.length) return seed.slice(0, n);
+	else throw new Error("Random number generator limits reached.");
+}
+/**
+* Generate deterministic random data from a string using SHA256.
+* Matches Rust sha256_deterministic_random_string function.
+*
+* @param str - The string to hash
+* @param n - Number of bytes to return (must be <= 32)
+* @throws Error if n > 32
+*/
+function sha256DeterministicRandomString(str, n) {
+	return sha256DeterministicRandom(new TextEncoder().encode(str), n);
+}
+/**
+* Generate deterministic random data from entropy using HKDF.
+* This can generate any length output.
+* Matches Rust deterministic_random function.
+*
+* @param entropy - The entropy bytes
+* @param n - Number of bytes to return
+*/
+function deterministicRandom(entropy, n) {
+	return hkdfHmacSha256((0, _noble_hashes_sha256.sha256)(entropy), new Uint8Array(0), n);
+}
+
+//#endregion
+//#region src/util.ts
+/**
+* Utility functions for data conversion
+* Ported from seedtool-cli-rust/src/util.rs
+*/
+/**
+* Convert bytes to hex string.
+* Matches Rust data_to_hex function.
+*/
+function dataToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Convert hex string to bytes.
+* Matches Rust hex_to_data function.
+*/
+function hexToData(hex) {
+	if (hex.length % 2 !== 0) throw new Error("Hex string must have even length");
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) {
+		const byte = parseInt(hex.substring(i, i + 2), 16);
+		if (isNaN(byte)) throw new Error(`Invalid hex character at position ${i}`);
+		bytes[i / 2] = byte;
+	}
+	return bytes;
+}
+/**
+* Convert byte values to a different base range [0, base-1].
+* Each byte (0-255) is scaled proportionally to the target base.
+* Matches Rust data_to_base function.
+*
+* @param buf - Input bytes
+* @param base - Target base (e.g., 6 for base-6)
+* @returns Array of values in range [0, base-1]
+*/
+function dataToBase(buf, base) {
+	const result = new Uint8Array(buf.length);
+	for (let i = 0; i < buf.length; i++) result[i] = Math.round(buf[i] / 255 * (base - 1));
+	return result;
+}
+/**
+* Convert bytes to an alphabet string using a base and alphabet function.
+* Matches Rust data_to_alphabet function.
+*
+* @param buf - Input bytes
+* @param base - Target base
+* @param toAlphabet - Function to convert index to character
+* @returns String of alphabet characters
+*/
+function dataToAlphabet(buf, base, toAlphabet) {
+	const data = dataToBase(buf, base);
+	return Array.from(data).map((b) => toAlphabet(b)).join("");
+}
+/**
+* Parse whitespace-separated integers.
+* Matches Rust parse_ints function.
+*
+* @param input - Space-separated integer string
+* @returns Array of bytes
+* @throws Error if any integer is out of range [0, 255]
+*/
+function parseInts(input) {
+	const parts = input.trim().split(/\s+/);
+	const result = [];
+	for (const s of parts) {
+		if (s === "") continue;
+		const i = parseInt(s, 10);
+		if (isNaN(i)) throw new Error(`Invalid integer: ${s}`);
+		if (i < 0 || i > 255) throw new Error("Integer out of range. Allowed: [0-255]");
+		result.push(i);
+	}
+	return new Uint8Array(result);
+}
+/**
+* Convert bytes to a string of integers in a given range.
+* Matches Rust data_to_ints function.
+*
+* @param buf - Input bytes
+* @param low - Lowest output value (0-254)
+* @param high - Highest output value (1-255), low < high
+* @param separator - String to separate values
+* @returns String of integers
+* @throws Error if range is invalid
+*/
+function dataToInts(buf, low, high, separator) {
+	if (!(low < high && high <= 255)) throw new Error("Int conversion range must be in 0 <= low < high <= 255.");
+	const data = dataToBase(buf, high - low + 1);
+	return Array.from(data).map((b) => (b + low).toString()).join(separator);
+}
+/**
+* Parse a string of digits in a given range to bytes.
+* Matches Rust digits_to_data function.
+*
+* @param inStr - String of digits
+* @param low - Lowest valid digit
+* @param high - Highest valid digit
+* @returns Array of digit values
+* @throws Error if any digit is out of range
+*/
+function digitsToData(inStr, low, high) {
+	const result = [];
+	for (const c of inStr) {
+		const n = c.charCodeAt(0) - "0".charCodeAt(0);
+		if (n < low || n > high) throw new Error(`Invalid digit: ${c}. Expected range [${low}-${high}].`);
+		result.push(n);
+	}
+	return new Uint8Array(result);
+}
+
+//#endregion
+//#region src/formats/hex.ts
+/**
+* Hexadecimal format handler.
+* Round-trippable: hex → seed → hex.
+*/
+var HexFormat = class {
+	name() {
+		return "hex";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		state.seed = Seed.new(hexToData(input));
+		return state;
+	}
+	processOutput(state) {
+		return dataToHex(state.expectSeed().data());
+	}
+};
+
+//#endregion
+//#region src/formats/bip39.ts
+/**
+* BIP39 mnemonic format handler.
+* Round-trippable: mnemonic → seed → mnemonic.
+*/
+var Bip39Format = class {
+	name() {
+		return "bip39";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const normalized = state.expectInput().toLowerCase().trim().replace(/\s+/g, " ");
+		if (!(0, _scure_bip39.validateMnemonic)(normalized, _scure_bip39_wordlists_english.wordlist)) throw new Error("Invalid BIP39 mnemonic");
+		const entropy = (0, _scure_bip39.mnemonicToEntropy)(normalized, _scure_bip39_wordlists_english.wordlist);
+		state.seed = Seed.new(entropy);
+		return state;
+	}
+	processOutput(state) {
+		return (0, _scure_bip39.entropyToMnemonic)(state.expectSeed().data(), _scure_bip39_wordlists_english.wordlist);
+	}
+};
+
+//#endregion
+//#region src/formats/sskr.ts
+/**
+* SSKR format handler.
+* Round-trippable: sskr shares → seed → sskr shares.
+* Supports multiple sub-formats: envelope, btw, btwm, btwu, ur.
+*/
+var SSKRFormat = class {
+	name() {
+		return "sskr";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		state.seed = parseSskrSeed(state.expectInput());
+		return state;
+	}
+	processOutput(state) {
+		const spec = state.sskrSpec();
+		const seed = state.expectSeed();
+		const format = state.sskrFormat;
+		return outputSskrSeed(seed, spec, format);
+	}
+};
+function outputSskrSeed(seed, spec, format) {
+	switch (format) {
+		case "envelope": {
+			const envelope = seed.toEnvelope();
+			const contentKey = _bcts_envelope.SymmetricKey.new();
+			return envelope.wrap().encryptSubject(contentKey).sskrSplitFlattened(spec, contentKey).map((envelope$1) => envelope$1.urString()).join("\n");
+		}
+		case "btw": return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Standard);
+		case "btwm": return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Minimal);
+		case "btwu": return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Uri);
+		case "ur": return makeShares(spec, seed).map((share) => {
+			return _bcts_uniform_resources.UR.fromCbor("sskr", (0, _bcts_dcbor.toByteString)(share.asBytes())).toString();
+		}).join("\n");
+	}
+}
+function makeShares(spec, seed) {
+	const shareGroups = (0, _bcts_components.sskrGenerate)(spec, _bcts_components.SSKRSecret.new(seed.data()));
+	const flatShares = [];
+	for (const group of shareGroups) for (const shareData of group) flatShares.push(_bcts_components.SSKRShare.fromData(shareData));
+	return flatShares;
+}
+function makeBytewordsShares(spec, seed, style) {
+	return makeShares(spec, seed).map((share) => (0, _bcts_dcbor.toTaggedValue)(_bcts_tags.SSKR_SHARE.value, (0, _bcts_dcbor.toByteString)(share.asBytes()))).map((share) => (0, _bcts_uniform_resources.encodeBytewords)(share.toData(), style)).join("\n");
+}
+function parseEnvelopes(input) {
+	try {
+		const shareStrings = input.split(/\s+/).filter((s) => s.length > 0);
+		const shareEnvelopes = [];
+		for (const str of shareStrings) try {
+			const envelope = _bcts_envelope.Envelope.fromURString(str);
+			shareEnvelopes.push(envelope);
+		} catch {}
+		if (shareEnvelopes.length === 0) return null;
+		const recoveredEnvelope = _bcts_envelope.Envelope.sskrJoin(shareEnvelopes).unwrap();
+		return Seed.fromEnvelope(recoveredEnvelope);
+	} catch {
+		return null;
+	}
+}
+function fromUntaggedCborShares(untaggedCborShares) {
+	try {
+		const recoveredSecret = (0, _bcts_components.sskrCombine)(untaggedCborShares);
+		return Seed.new(recoveredSecret.getData());
+	} catch {
+		return null;
+	}
+}
+function fromTaggedCborShares(taggedCborDataShares) {
+	try {
+		const untaggedShares = [];
+		for (const data of taggedCborDataShares) {
+			const cbor = (0, _bcts_dcbor.decodeCbor)(data);
+			const tagged = cbor;
+			if (tagged.tag !== _bcts_tags.SSKR_SHARE.value && tagged.tag !== _bcts_tags.SSKR_SHARE_V1.value) return null;
+			const bytes = (0, _bcts_dcbor.expectBytes)(tagged.value || cbor);
+			untaggedShares.push(bytes);
+		}
+		return fromUntaggedCborShares(untaggedShares);
+	} catch {
+		return null;
+	}
+}
+function parseBytewords(input, style) {
+	try {
+		let shareStrings;
+		if (style === _bcts_uniform_resources.BytewordsStyle.Standard) shareStrings = input.split("\n").filter((s) => s.length > 0);
+		else shareStrings = input.split(/\s+/).filter((s) => s.length > 0);
+		const cborDataShares = [];
+		for (const s of shareStrings) try {
+			const decoded = (0, _bcts_uniform_resources.decodeBytewords)(s, style);
+			cborDataShares.push(decoded);
+		} catch {}
+		if (cborDataShares.length === 0) return null;
+		return fromTaggedCborShares(cborDataShares);
+	} catch {
+		return null;
+	}
+}
+function parseUr(input, expectedTagValue, allowTaggedCbor) {
+	try {
+		const expectedType = expectedTagValue === _bcts_tags.SSKR_SHARE.value ? "sskr" : "crypto-sskr";
+		const shareStrings = input.split(/\s+/).filter((s) => s.length > 0);
+		const urs = [];
+		for (const str of shareStrings) try {
+			const ur = _bcts_uniform_resources.UR.fromURString(str);
+			urs.push(ur);
+		} catch {}
+		if (urs.length === 0) return null;
+		for (const ur of urs) if (ur.type() !== expectedType) return null;
+		const untaggedCborShares = [];
+		for (const ur of urs) {
+			let cbor = ur.cbor();
+			if (allowTaggedCbor) try {
+				const tagged = (0, _bcts_dcbor.decodeCbor)(cbor.toData());
+				if (tagged.tag === _bcts_tags.SSKR_SHARE.value || tagged.tag === _bcts_tags.SSKR_SHARE_V1.value) cbor = tagged.value;
+			} catch {}
+			const bytes = (0, _bcts_dcbor.expectBytes)(cbor);
+			untaggedCborShares.push(bytes);
+		}
+		return fromUntaggedCborShares(untaggedCborShares);
+	} catch {
+		return null;
+	}
+}
+function parseSskrSeed(input) {
+	const envelopeResult = parseEnvelopes(input);
+	if (envelopeResult !== null) return envelopeResult;
+	const btwResult = parseBytewords(input, _bcts_uniform_resources.BytewordsStyle.Standard);
+	if (btwResult !== null) return btwResult;
+	const btwmResult = parseBytewords(input, _bcts_uniform_resources.BytewordsStyle.Minimal);
+	if (btwmResult !== null) return btwmResult;
+	const btwuResult = parseBytewords(input, _bcts_uniform_resources.BytewordsStyle.Uri);
+	if (btwuResult !== null) return btwuResult;
+	const urResult = parseUr(input, _bcts_tags.SSKR_SHARE.value, false);
+	if (urResult !== null) return urResult;
+	const urLegacyResult = parseUr(input, _bcts_tags.SSKR_SHARE_V1.value, true);
+	if (urLegacyResult !== null) return urLegacyResult;
+	throw new Error("Insufficient or invalid SSKR shares.");
+}
+
+//#endregion
+//#region src/formats/envelope.ts
+/**
+* Gordian Envelope format handler.
+* Round-trippable: envelope UR → seed → envelope UR.
+*/
+var EnvelopeFormat = class {
+	name() {
+		return "envelope";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		const envelope = _bcts_envelope.Envelope.fromURString(input);
+		state.seed = Seed.fromEnvelope(envelope);
+		return state;
+	}
+	processOutput(state) {
+		return state.toEnvelope().urString();
+	}
+};
+
+//#endregion
+//#region src/formats/seed-format.ts
+/**
+* Seed UR format handler.
+* Round-trippable: seed UR → seed → seed UR.
+* Uses the ur:seed format from bc-components.
+*/
+var SeedFormat = class {
+	name() {
+		return "seed";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		const componentsSeed = _bcts_components.Seed.fromURString(input);
+		state.seed = Seed.fromComponentsSeed(componentsSeed);
+		return state;
+	}
+	processOutput(state) {
+		return state.seedWithOverrides().toComponentsSeed().urString();
+	}
+};
+
+//#endregion
+//#region src/formats/multipart.ts
+/**
+* Multipart UR format handler.
+* Round-trippable: multipart URs → seed → multipart URs.
+* Uses fountain encoding for reliable transmission.
+*/
+var MultipartFormat = class {
+	name() {
+		return "multipart";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const shares = state.expectInput().split(/\s+/).filter((s) => s.length > 0);
+		const decoder = new _bcts_uniform_resources.MultipartDecoder();
+		for (const share of shares) {
+			decoder.receive(share);
+			if (decoder.isComplete()) break;
+		}
+		if (!decoder.isComplete()) throw new Error("Insufficient multipart shares");
+		const ur = decoder.message();
+		if (ur === void 0) throw new Error("Failed to decode multipart message");
+		const envelope = _bcts_envelope.Envelope.fromUR(ur);
+		state.seed = Seed.fromEnvelope(envelope);
+		return state;
+	}
+	processOutput(state) {
+		const encoder = new _bcts_uniform_resources.MultipartEncoder(state.toEnvelope().ur(), state.maxFragmentLen);
+		const partsCount = encoder.partsCount() + state.additionalParts;
+		const parts = [];
+		for (let i = 0; i < partsCount; i++) parts.push(encoder.nextPart());
+		return parts.join("\n");
+	}
+};
+
+//#endregion
+//#region src/formats/random.ts
+/**
+* Random seed generation format.
+* Input-only: generates a new random seed.
+*/
+var RandomFormat = class {
+	name() {
+		return "random";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const data = state.randomData(state.count);
+		state.seed = Seed.new(data);
+		return state;
+	}
+};
+
+//#endregion
+//#region src/formats/base6.ts
+/**
+* Base-6 format handler.
+* NOT round-trippable: input is entropy source.
+* Digits 0-5 (compatible with https://iancoleman.io/bip39/).
+*/
+var Base6Format = class {
+	name() {
+		return "base6";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		digitsToData(input, 0, 5);
+		const data = sha256DeterministicRandomString(input, state.count);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), 0, 5, "");
+	}
+};
+
+//#endregion
+//#region src/formats/base10.ts
+/**
+* Base-10 format handler.
+* NOT round-trippable: input is entropy source.
+* Digits 0-9 (compatible with https://iancoleman.io/bip39/).
+*/
+var Base10Format = class {
+	name() {
+		return "base10";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		digitsToData(input, 0, 9);
+		const data = sha256DeterministicRandomString(input, state.count);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), 0, 9, "");
+	}
+};
+
+//#endregion
+//#region src/formats/bits.ts
+/**
+* Binary format handler.
+* NOT round-trippable: input is entropy source.
+* Bits 0-1 (compatible with https://iancoleman.io/bip39/).
+*/
+var BitsFormat = class {
+	name() {
+		return "bits";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		digitsToData(input, 0, 1);
+		const data = sha256DeterministicRandomString(input, state.count);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), 0, 1, "");
+	}
+};
+
+//#endregion
+//#region src/formats/dice.ts
+/**
+* Dice roll format handler.
+* NOT round-trippable: input is entropy source.
+* Digits 1-6 (compatible with https://iancoleman.io/bip39/).
+*/
+var DiceFormat = class {
+	name() {
+		return "dice";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		digitsToData(input, 1, 6);
+		const data = sha256DeterministicRandomString(input, state.count);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), 1, 6, "");
+	}
+};
+
+//#endregion
+//#region src/formats/cards.ts
+const CARD_SUITS = "cdhs";
+const CARD_RANKS = "a23456789tjqk";
+/**
+* Parse a card rank character.
+* Returns index 0-12.
+*/
+function parseRank(c) {
+	const lower = c.toLowerCase();
+	const index = CARD_RANKS.indexOf(lower);
+	if (index === -1) throw new Error(`Invalid card rank: ${c}. Allowed: [A,2-9,T,J,Q,K]`);
+	return index;
+}
+/**
+* Parse a card suit character.
+* Returns index 0-3.
+*/
+function parseSuit(c) {
+	const lower = c.toLowerCase();
+	const index = CARD_SUITS.indexOf(lower);
+	if (index === -1) throw new Error(`Invalid card suit: ${c}. Allowed: [C,D,H,S]`);
+	return index;
+}
+/**
+* Convert card string to byte array.
+* Each pair of characters represents one card.
+*/
+function cardsToData(cards) {
+	const len = cards.length;
+	if (len % 2 !== 0) throw new Error("Cards string must have even number of characters.");
+	const count = len / 2;
+	const result = new Uint8Array(count);
+	for (let i = 0; i < count; i++) {
+		const rank = parseRank(cards[i * 2]);
+		result[i] = parseSuit(cards[i * 2 + 1]) * 13 + rank;
+	}
+	return result;
+}
+/**
+* Convert a card index (0-51) to card string.
+*/
+function toCard(n) {
+	if (n > 51) throw new Error(`Card index out of range: ${n}`);
+	const rank = n % 13;
+	const suit = Math.floor(n / 13);
+	return CARD_RANKS[rank] + CARD_SUITS[suit];
+}
+/**
+* Playing cards format handler.
+* NOT round-trippable: input is entropy source.
+* Card notation: rank (A,2-9,T,J,Q,K) + suit (C,D,H,S).
+*/
+var CardsFormat = class {
+	name() {
+		return "cards";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const data = deterministicRandom(cardsToData(state.expectInput()), state.count);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToAlphabet(state.expectSeed().data(), 52, toCard);
+	}
+};
+
+//#endregion
+//#region src/formats/ints.ts
+/**
+* Integer list format handler.
+* NOT round-trippable: input is entropy source.
+* Configurable range via --low and --high CLI options.
+*/
+var IntsFormat = class {
+	name() {
+		return "ints";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const data = deterministicRandom(parseInts(state.expectInput()), state.count);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), state.low, state.high, " ");
+	}
+};
+
+//#endregion
+//#region src/formats/bytewords-standard.ts
+/**
+* Bytewords Standard format handler.
+* Round-trippable: bytewords → seed → bytewords.
+* Uses full words separated by spaces.
+*/
+var BytewordsStandardFormat = class {
+	name() {
+		return "btw";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const data = (0, _bcts_uniform_resources.decodeBytewords)(state.expectInput(), _bcts_uniform_resources.BytewordsStyle.Standard);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return (0, _bcts_uniform_resources.encodeBytewords)(state.expectSeed().data(), _bcts_uniform_resources.BytewordsStyle.Standard);
+	}
+};
+
+//#endregion
+//#region src/formats/bytewords-minimal.ts
+/**
+* Bytewords Minimal format handler.
+* Round-trippable: bytewords → seed → bytewords.
+* Uses 2-letter abbreviations without separators.
+*/
+var BytewordsMinimalFormat = class {
+	name() {
+		return "btwm";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const data = (0, _bcts_uniform_resources.decodeBytewords)(state.expectInput(), _bcts_uniform_resources.BytewordsStyle.Minimal);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return (0, _bcts_uniform_resources.encodeBytewords)(state.expectSeed().data(), _bcts_uniform_resources.BytewordsStyle.Minimal);
+	}
+};
+
+//#endregion
+//#region src/formats/bytewords-uri.ts
+/**
+* Bytewords URI format handler.
+* Round-trippable: bytewords → seed → bytewords.
+* Uses full words separated by hyphens (URI-safe).
+*/
+var BytewordsUriFormat = class {
+	name() {
+		return "btwu";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const data = (0, _bcts_uniform_resources.decodeBytewords)(state.expectInput(), _bcts_uniform_resources.BytewordsStyle.Uri);
+		state.seed = Seed.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return (0, _bcts_uniform_resources.encodeBytewords)(state.expectSeed().data(), _bcts_uniform_resources.BytewordsStyle.Uri);
+	}
+};
+
+//#endregion
+//#region src/formats/format.ts
+/**
+* Select input format by key.
+* Matches Rust select_input_format function.
+*/
+function selectInputFormat(key) {
+	switch (key) {
+		case "random": return new RandomFormat();
+		case "hex": return new HexFormat();
+		case "btw": return new BytewordsStandardFormat();
+		case "btwu": return new BytewordsUriFormat();
+		case "btwm": return new BytewordsMinimalFormat();
+		case "bits": return new BitsFormat();
+		case "cards": return new CardsFormat();
+		case "dice": return new DiceFormat();
+		case "base6": return new Base6Format();
+		case "base10": return new Base10Format();
+		case "ints": return new IntsFormat();
+		case "bip39": return new Bip39Format();
+		case "sskr": return new SSKRFormat();
+		case "envelope": return new EnvelopeFormat();
+		case "multipart": return new MultipartFormat();
+		case "seed": return new SeedFormat();
+		default: throw new Error(`Unknown input format: ${key}`);
+	}
+}
+/**
+* Select output format by key.
+* Matches Rust select_output_format function.
+*/
+function selectOutputFormat(key) {
+	switch (key) {
+		case "hex": return new HexFormat();
+		case "btw": return new BytewordsStandardFormat();
+		case "btwu": return new BytewordsUriFormat();
+		case "btwm": return new BytewordsMinimalFormat();
+		case "bits": return new BitsFormat();
+		case "cards": return new CardsFormat();
+		case "dice": return new DiceFormat();
+		case "base6": return new Base6Format();
+		case "base10": return new Base10Format();
+		case "ints": return new IntsFormat();
+		case "bip39": return new Bip39Format();
+		case "sskr": return new SSKRFormat();
+		case "envelope": return new EnvelopeFormat();
+		case "multipart": return new MultipartFormat();
+		case "seed": return new SeedFormat();
+		default: throw new Error(`Unknown output format: ${key}`);
+	}
+}
+
+//#endregion
+exports.Base10Format = Base10Format;
+exports.Base6Format = Base6Format;
+exports.Bip39Format = Bip39Format;
+exports.BitsFormat = BitsFormat;
+exports.BytewordsMinimalFormat = BytewordsMinimalFormat;
+exports.BytewordsStandardFormat = BytewordsStandardFormat;
+exports.BytewordsUriFormat = BytewordsUriFormat;
+exports.CardsFormat = CardsFormat;
+exports.Cli = Cli;
+exports.DeterministicRandomNumberGenerator = DeterministicRandomNumberGenerator;
+exports.DiceFormat = DiceFormat;
+exports.EnvelopeFormat = EnvelopeFormat;
+exports.HexFormat = HexFormat;
+exports.InputFormatKey = InputFormatKey;
+exports.IntsFormat = IntsFormat;
+exports.MultipartFormat = MultipartFormat;
+exports.OutputFormatKey = OutputFormatKey;
+exports.RandomFormat = RandomFormat;
+exports.SSKRFormat = SSKRFormat;
+exports.SSKRFormatKey = SSKRFormatKey;
+exports.Seed = Seed;
+exports.SeedFormat = SeedFormat;
+exports.dataToAlphabet = dataToAlphabet;
+exports.dataToBase = dataToBase;
+exports.dataToHex = dataToHex;
+exports.dataToInts = dataToInts;
+exports.deterministicRandom = deterministicRandom;
+exports.digitsToData = digitsToData;
+exports.hexToData = hexToData;
+exports.hkdfHmacSha256 = hkdfHmacSha256;
+exports.parseDate = parseDate;
+exports.parseGroupSpec = parseGroupSpec;
+exports.parseGroupThreshold = parseGroupThreshold;
+exports.parseHighInt = parseHighInt;
+exports.parseInts = parseInts;
+exports.parseLowInt = parseLowInt;
+exports.selectInputFormat = selectInputFormat;
+exports.selectOutputFormat = selectOutputFormat;
+exports.sha256DeterministicRandom = sha256DeterministicRandom;
+//# sourceMappingURL=index.cjs.map