@bcts/known-values 1.0.0-alpha.10

package/dist/index.iife.js

@@ -0,0 +1,1019 @@
+var bctsKnownValues = (function(exports, _bcts_dcbor, _bcts_components) {
+
+
+//#region src/known-value.ts
+/**
+	* A value in a namespace of unsigned integers that represents a stand-alone
+	* ontological concept.
+	*
+	* Known Values provide a compact, deterministic way to represent commonly used
+	* ontological concepts such as relationships between entities, classes of
+	* entities, properties, or enumerated values. They are particularly useful as
+	* predicates in Gordian Envelope assertions, offering a more compact and
+	* deterministic alternative to URIs. However, known values are not exclusive
+	* to Gordian Envelopes and can be used in any context where a compact, unique
+	* identifier for a concept is needed.
+	*
+	* A Known Value is represented as a 64-bit unsigned integer with an optional
+	* human-readable name. This approach ensures:
+	*
+	* - **Compact binary representation** - Each Known Value requires only 1-9
+	*   bytes depending on value range
+	* - **Deterministic encoding** - Every concept has exactly one valid binary
+	*   representation
+	* - **Enhanced security** - Eliminates URI manipulation vulnerabilities
+	* - **Standardized semantics** - Values are registered in a central registry
+	*
+	* While Known Values are most commonly used as predicates in assertions, they
+	* can appear in any position in an Envelope (subject, predicate, or object).
+	*
+	* @example
+	* ```typescript
+	* import { KnownValue } from '@bcts/known-values';
+	*
+	* // Create a Known Value with a numeric value
+	* const knownValue = new KnownValue(42);
+	* console.log(knownValue.value()); // 42
+	*
+	* // Create a Known Value with a name
+	* const namedValue = new KnownValue(1, 'isA');
+	* console.log(namedValue.value()); // 1
+	* console.log(namedValue.name()); // "isA"
+	*
+	* // CBOR encoding
+	* const cbor = namedValue.taggedCbor();
+	* const bytes = namedValue.toCborData();
+	*
+	* // CBOR decoding
+	* const decoded = KnownValue.fromTaggedCbor(cbor);
+	* const decodedFromBytes = KnownValue.fromCborData(bytes);
+	*
+	* // Use a pre-defined Known Value from the registry
+	* import { IS_A } from '@bcts/known-values';
+	* console.log(IS_A.value()); // 1
+	* console.log(IS_A.name()); // "isA"
+	* ```
+	*
+	* @specification
+	*
+	* Known Values are defined in
+	* [BCR-2023-002](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-002-known-value.md)
+	* and implemented as an Envelope extension in
+	* [BCR-2023-003](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-003-envelope-known-value.md).
+	*/
+	/**
+	* The numeric value for the CBOR tag used for Known Values.
+	* This is Tag 40000 as defined in the Blockchain Commons registry.
+	*/
+	const TAG_KNOWN_VALUE = _bcts_components.KNOWN_VALUE.value;
+	/**
+	* The CBOR tag used for Known Values.
+	* This is Tag 40000 as defined in the Blockchain Commons registry.
+	*/
+	const KNOWN_VALUE_TAG = _bcts_components.KNOWN_VALUE;
+	var KnownValue = class KnownValue {
+		_value;
+		_assignedName;
+		/**
+		* Creates a new KnownValue with the given numeric value and optional name.
+		*
+		* @param value - The numeric value (number or bigint). Numbers are converted to bigint internally.
+		* @param assignedName - Optional human-readable name for the value
+		*
+		* @example
+		* ```typescript
+		* const knownValue = new KnownValue(42);
+		* console.log(knownValue.value()); // 42
+		*
+		* const namedValue = new KnownValue(1, 'isA');
+		* console.log(namedValue.name()); // "isA"
+		*
+		* // Using bigint for large values
+		* const largeValue = new KnownValue(9007199254740993n);
+		* ```
+		*/
+		constructor(value, assignedName) {
+			this._value = typeof value === "bigint" ? value : BigInt(value);
+			this._assignedName = assignedName;
+		}
+		/**
+		* Returns the numeric value of the KnownValue.
+		*
+		* This is the raw unsigned integer that identifies the concept.
+		* Returns a number for backward compatibility. For values > MAX_SAFE_INTEGER,
+		* use `valueBigInt()`.
+		*
+		* @example
+		* ```typescript
+		* import { IS_A, NOTE } from '@bcts/known-values';
+		* console.log(IS_A.value()); // 1
+		* console.log(NOTE.value()); // 4
+		* ```
+		*/
+		value() {
+			if (this._value > BigInt(Number.MAX_SAFE_INTEGER)) throw new RangeError(`KnownValue ${this._value} exceeds MAX_SAFE_INTEGER. Use valueBigInt() instead.`);
+			return Number(this._value);
+		}
+		/**
+		* Returns the numeric value of the KnownValue as a bigint.
+		*
+		* Use this for values that may exceed Number.MAX_SAFE_INTEGER (2^53-1).
+		*
+		* @example
+		* ```typescript
+		* const largeValue = new KnownValue(9007199254740993n);
+		* console.log(largeValue.valueBigInt()); // 9007199254740993n
+		* ```
+		*/
+		valueBigInt() {
+			return this._value;
+		}
+		/**
+		* Returns the assigned name of the KnownValue, if one exists.
+		*
+		* @example
+		* ```typescript
+		* const namedValue = new KnownValue(1, 'isA');
+		* console.log(namedValue.assignedName()); // "isA"
+		*
+		* const unnamedValue = new KnownValue(42);
+		* console.log(unnamedValue.assignedName()); // undefined
+		* ```
+		*/
+		assignedName() {
+			return this._assignedName;
+		}
+		/**
+		* Returns a human-readable name for the KnownValue.
+		*
+		* If the KnownValue has an assigned name, that name is returned.
+		* Otherwise, the string representation of the numeric value is returned.
+		*
+		* @example
+		* ```typescript
+		* const namedValue = new KnownValue(1, 'isA');
+		* console.log(namedValue.name()); // "isA"
+		*
+		* const unnamedValue = new KnownValue(42);
+		* console.log(unnamedValue.name()); // "42"
+		* ```
+		*/
+		name() {
+			return this._assignedName ?? this._value.toString();
+		}
+		/**
+		* Compares this KnownValue with another for equality.
+		* Equality is based solely on the numeric value, ignoring the name.
+		*
+		* @param other - The KnownValue to compare with
+		* @returns true if the values are equal
+		*
+		* @example
+		* ```typescript
+		* const kv1 = new KnownValue(1, 'isA');
+		* const kv2 = new KnownValue(1, 'different');
+		* console.log(kv1.equals(kv2)); // true (same value, different name)
+		* ```
+		*/
+		equals(other) {
+			return this._value === other._value;
+		}
+		/**
+		* Hash code based on the numeric value.
+		* Useful for using KnownValue in hash-based collections.
+		*/
+		hashCode() {
+			return Number(this._value & BigInt(4294967295));
+		}
+		/**
+		* String representation of the KnownValue.
+		*
+		* If a name is assigned, the name is displayed. Otherwise, the numeric value
+		* is displayed.
+		*/
+		toString() {
+			return this.name();
+		}
+		/**
+		* Returns the CBOR tags associated with KnownValue.
+		*
+		* The primary tag is TAG_KNOWN_VALUE (201).
+		*
+		* @returns Array containing the KnownValue tag
+		*/
+		cborTags() {
+			return [KNOWN_VALUE_TAG];
+		}
+		/**
+		* Returns the untagged CBOR encoding of this KnownValue.
+		*
+		* The untagged representation is simply the unsigned integer value.
+		*
+		* @returns CBOR representation of the value (unsigned integer)
+		*/
+		untaggedCbor() {
+			return (0, _bcts_dcbor.cbor)(this._value);
+		}
+		/**
+		* Returns the tagged CBOR encoding of this KnownValue.
+		*
+		* This wraps the unsigned integer value with tag 201.
+		*
+		* @returns Tagged CBOR representation
+		*
+		* @example
+		* ```typescript
+		* const kv = new KnownValue(1, 'isA');
+		* const tagged = kv.taggedCbor();
+		* console.log(tagged.toHex()); // "d8c901" (tag 201, value 1)
+		* ```
+		*/
+		taggedCbor() {
+			return (0, _bcts_dcbor.cbor)({
+				tag: TAG_KNOWN_VALUE,
+				value: this._value
+			});
+		}
+		/**
+		* Returns the tagged CBOR encoding as binary data.
+		*
+		* @returns Binary CBOR representation
+		*
+		* @example
+		* ```typescript
+		* const kv = new KnownValue(1, 'isA');
+		* const bytes = kv.toCborData();
+		* // bytes is Uint8Array containing the CBOR encoding
+		* ```
+		*/
+		toCborData() {
+			return (0, _bcts_dcbor.cborData)(this.taggedCbor());
+		}
+		/**
+		* Alias for `toCborData()` to match the dcbor interface.
+		*/
+		taggedCborData() {
+			return this.toCborData();
+		}
+		/**
+		* Creates a KnownValue from untagged CBOR (an unsigned integer).
+		* Instance method for interface compliance.
+		*
+		* @param cborValue - The CBOR value (must be an unsigned integer)
+		* @returns A new KnownValue
+		* @throws {Error} If the CBOR is not an unsigned integer
+		*/
+		fromUntaggedCbor(cborValue) {
+			return KnownValue.fromUntaggedCbor(cborValue);
+		}
+		/**
+		* Creates a KnownValue from tagged CBOR (tag 201).
+		* Instance method for interface compliance.
+		*
+		* @param cborValue - The tagged CBOR value
+		* @returns A new KnownValue
+		* @throws {Error} If the CBOR is not properly tagged or contains invalid data
+		*/
+		fromTaggedCbor(cborValue) {
+			return KnownValue.fromTaggedCbor(cborValue);
+		}
+		/**
+		* Creates a KnownValue from untagged CBOR (an unsigned integer).
+		*
+		* @param cborValue - The CBOR value (must be an unsigned integer)
+		* @returns A new KnownValue
+		* @throws {Error} If the CBOR is not an unsigned integer
+		*
+		* @example
+		* ```typescript
+		* const cborValue = cbor(42);
+		* const kv = KnownValue.fromUntaggedCbor(cborValue);
+		* console.log(kv.value()); // 42
+		* ```
+		*/
+		static fromUntaggedCbor(cborValue) {
+			if (cborValue.type !== _bcts_dcbor.MajorType.Unsigned) throw new Error(`Expected unsigned integer for KnownValue, got major type ${cborValue.type}`);
+			const numValue = cborValue.value;
+			return new KnownValue(typeof numValue === "bigint" ? numValue : BigInt(numValue));
+		}
+		/**
+		* Creates a KnownValue from tagged CBOR (tag 201).
+		*
+		* @param cborValue - The tagged CBOR value
+		* @returns A new KnownValue
+		* @throws {Error} If the CBOR is not properly tagged or contains invalid data
+		*
+		* @example
+		* ```typescript
+		* const kv = KnownValue.fromTaggedCbor(taggedCborValue);
+		* ```
+		*/
+		static fromTaggedCbor(cborValue) {
+			if (cborValue.type !== _bcts_dcbor.MajorType.Tagged) throw new Error(`Expected tagged CBOR for KnownValue, got major type ${cborValue.type}`);
+			const tag = cborValue.tag;
+			if (tag !== BigInt(TAG_KNOWN_VALUE) && tag !== TAG_KNOWN_VALUE) throw new Error(`Expected tag ${TAG_KNOWN_VALUE} for KnownValue, got ${tag}`);
+			return KnownValue.fromUntaggedCbor(cborValue.value);
+		}
+		/**
+		* Creates a KnownValue from binary CBOR data.
+		*
+		* @param data - Binary CBOR data (must be a tagged KnownValue)
+		* @returns A new KnownValue
+		* @throws {Error} If the data cannot be decoded or is not a valid KnownValue
+		*
+		* @example
+		* ```typescript
+		* const bytes = new Uint8Array([0xd8, 0xc9, 0x01]); // tag 201, value 1
+		* const kv = KnownValue.fromCborData(bytes);
+		* console.log(kv.value()); // 1
+		* ```
+		*/
+		static fromCborData(data) {
+			const cborValue = (0, _bcts_dcbor.decodeCbor)(data);
+			return KnownValue.fromTaggedCbor(cborValue);
+		}
+		/**
+		* Creates a KnownValue from a CBOR value, automatically detecting
+		* whether it's tagged or untagged.
+		*
+		* @param cborValue - The CBOR value (tagged or untagged)
+		* @returns A new KnownValue
+		* @throws {Error} If the CBOR cannot be converted to a KnownValue
+		*
+		* @example
+		* ```typescript
+		* // Works with both tagged and untagged
+		* const kv1 = KnownValue.fromCbor(cbor(42));
+		* const kv2 = KnownValue.fromCbor(taggedCborValue);
+		* ```
+		*/
+		static fromCbor(cborValue) {
+			if (cborValue.type === _bcts_dcbor.MajorType.Tagged) return KnownValue.fromTaggedCbor(cborValue);
+			return KnownValue.fromUntaggedCbor(cborValue);
+		}
+	};
+
+//#endregion
+//#region src/known-values-store.ts
+/**
+	* A store that maps between Known Values and their assigned names.
+	*
+	* The `KnownValuesStore` provides a bidirectional mapping between:
+	* - Numeric values (bigint) and their corresponding KnownValue instances
+	* - String names and their corresponding KnownValue instances
+	*
+	* This enables efficient lookup in both directions, making it possible to:
+	* - Find the name for a given numeric value
+	* - Find the numeric value for a given name
+	* - Retrieve complete KnownValue instances by either name or value
+	*
+	* The store is typically populated with predefined Known Values from the
+	* registry, but can also be extended with custom values.
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';
+	*
+	* // Create a store with predefined Known Values
+	* const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);
+	*
+	* // Look up a Known Value by name
+	* const isA = store.knownValueNamed('isA');
+	* console.log(isA?.value()); // 1
+	*
+	* // Look up a name for a raw value
+	* const name = store.name(new KnownValue(3));
+	* console.log(name); // "signed"
+	*
+	* // Insert a custom Known Value
+	* const customStore = store.clone();
+	* customStore.insert(new KnownValue(100, 'customValue'));
+	* console.log(customStore.knownValueNamed('customValue')?.value()); // 100
+	* ```
+	*/
+	var KnownValuesStore = class KnownValuesStore {
+		knownValuesByRawValue;
+		knownValuesByAssignedName;
+		/**
+		* Creates a new KnownValuesStore with the provided Known Values.
+		*
+		* This constructor takes an iterable of KnownValue instances and
+		* populates the store with them, creating mappings from both raw
+		* values and names to the corresponding KnownValue instances.
+		*
+		* @param knownValues - Iterable of KnownValue instances to populate the store
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';
+		*
+		* // Create a store with predefined Known Values
+		* const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);
+		*
+		* // Look up Known Values
+		* console.log(store.knownValueNamed('isA')?.value()); // 1
+		* console.log(store.knownValueNamed('note')?.value()); // 4
+		* ```
+		*/
+		constructor(knownValues = []) {
+			this.knownValuesByRawValue = /* @__PURE__ */ new Map();
+			this.knownValuesByAssignedName = /* @__PURE__ */ new Map();
+			for (const knownValue of knownValues) this._insert(knownValue);
+		}
+		/**
+		* Inserts a KnownValue into the store.
+		*
+		* If the KnownValue has an assigned name, it will be indexed by both its
+		* raw value and its name. If a KnownValue with the same raw value or name
+		* already exists in the store, it will be replaced.
+		*
+		* @param knownValue - The KnownValue to insert
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, KnownValue } from '@bcts/known-values';
+		*
+		* const store = new KnownValuesStore();
+		* store.insert(new KnownValue(100, 'customValue'));
+		* console.log(store.knownValueNamed('customValue')?.value()); // 100
+		* ```
+		*/
+		insert(knownValue) {
+			this._insert(knownValue);
+		}
+		/**
+		* Returns the assigned name for a KnownValue, if present in the store.
+		*
+		* @param knownValue - The KnownValue to look up
+		* @returns The assigned name, or undefined if not found
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+		*
+		* const store = new KnownValuesStore([IS_A]);
+		* console.log(store.assignedName(IS_A)); // "isA"
+		* console.log(store.assignedName(new KnownValue(999))); // undefined
+		* ```
+		*/
+		assignedName(knownValue) {
+			return this.knownValuesByRawValue.get(knownValue.valueBigInt())?.assignedName();
+		}
+		/**
+		* Returns a human-readable name for a KnownValue.
+		*
+		* If the KnownValue has an assigned name in the store, that name is
+		* returned. Otherwise, the KnownValue's default name (which may be its
+		* numeric value as a string) is returned.
+		*
+		* @param knownValue - The KnownValue to get the name for
+		* @returns The name (assigned or numeric)
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+		*
+		* const store = new KnownValuesStore([IS_A]);
+		* console.log(store.name(IS_A)); // "isA"
+		* console.log(store.name(new KnownValue(999))); // "999"
+		* ```
+		*/
+		name(knownValue) {
+			return this.assignedName(knownValue) ?? knownValue.name();
+		}
+		/**
+		* Looks up a KnownValue by its assigned name.
+		*
+		* Returns the KnownValue if found, or undefined if no KnownValue
+		* with the given name exists in the store.
+		*
+		* @param assignedName - The name to look up
+		* @returns The KnownValue, or undefined if not found
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+		*
+		* const store = new KnownValuesStore([IS_A]);
+		*
+		* const isA = store.knownValueNamed('isA');
+		* console.log(isA?.value()); // 1
+		*
+		* console.log(store.knownValueNamed('nonexistent')); // undefined
+		* ```
+		*/
+		knownValueNamed(assignedName) {
+			return this.knownValuesByAssignedName.get(assignedName);
+		}
+		/**
+		* Looks up a KnownValue by its raw numeric value.
+		*
+		* @param rawValue - The numeric value to look up (number or bigint)
+		* @returns The KnownValue, or undefined if not found
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+		*
+		* const store = new KnownValuesStore([IS_A]);
+		* const isA = store.knownValueForValue(1);
+		* console.log(isA?.name()); // "isA"
+		* ```
+		*/
+		knownValueForValue(rawValue) {
+			const key = typeof rawValue === "bigint" ? rawValue : BigInt(rawValue);
+			return this.knownValuesByRawValue.get(key);
+		}
+		/**
+		* Retrieves a KnownValue for a raw value, using a store if provided.
+		*
+		* This static method allows looking up a KnownValue by its raw numeric
+		* value:
+		* - If a store is provided and contains a mapping for the raw value, that
+		*   KnownValue is returned
+		* - Otherwise, a new KnownValue with no assigned name is created and
+		*   returned
+		*
+		* @param rawValue - The numeric value to look up (number or bigint)
+		* @param knownValues - Optional store to search in
+		* @returns The KnownValue from the store or a new unnamed KnownValue
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+		*
+		* const store = new KnownValuesStore([IS_A]);
+		*
+		* // Known value from store
+		* const isA = KnownValuesStore.knownValueForRawValue(1, store);
+		* console.log(isA.name()); // "isA"
+		*
+		* // Unknown value creates a new KnownValue
+		* const unknown = KnownValuesStore.knownValueForRawValue(999, store);
+		* console.log(unknown.name()); // "999"
+		*
+		* // No store provided also creates a new KnownValue
+		* const unknown2 = KnownValuesStore.knownValueForRawValue(1, undefined);
+		* console.log(unknown2.name()); // "1"
+		* ```
+		*/
+		static knownValueForRawValue(rawValue, knownValues) {
+			if (knownValues !== void 0) {
+				const value = knownValues.knownValueForValue(rawValue);
+				if (value !== void 0) return value;
+			}
+			return new KnownValue(rawValue);
+		}
+		/**
+		* Attempts to find a KnownValue by its name, using a store if provided.
+		*
+		* This static method allows looking up a KnownValue by its name:
+		* - If a store is provided and contains a mapping for the name, that
+		*   KnownValue is returned
+		* - Otherwise, undefined is returned
+		*
+		* @param name - The name to look up
+		* @param knownValues - Optional store to search in
+		* @returns The KnownValue if found, or undefined
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+		*
+		* const store = new KnownValuesStore([IS_A]);
+		*
+		* // Known value from store
+		* const isA = KnownValuesStore.knownValueForName('isA', store);
+		* console.log(isA?.value()); // 1
+		*
+		* // Unknown name returns undefined
+		* console.log(KnownValuesStore.knownValueForName('unknown', store)); // undefined
+		*
+		* // No store provided also returns undefined
+		* console.log(KnownValuesStore.knownValueForName('isA', undefined)); // undefined
+		* ```
+		*/
+		static knownValueForName(name, knownValues) {
+			return knownValues?.knownValueNamed(name);
+		}
+		/**
+		* Returns a human-readable name for a KnownValue, using a store if provided.
+		*
+		* This static method allows getting a name for a KnownValue:
+		* - If a store is provided and contains a mapping for the KnownValue, its
+		*   assigned name is returned
+		* - Otherwise, the KnownValue's default name (which may be its numeric
+		*   value as a string) is returned
+		*
+		* @param knownValue - The KnownValue to get the name for
+		* @param knownValues - Optional store to use for lookup
+		* @returns The name (assigned or numeric)
+		*
+		* @example
+		* ```typescript
+		* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+		*
+		* const store = new KnownValuesStore([IS_A]);
+		*
+		* // Known value from store
+		* let name = KnownValuesStore.nameForKnownValue(IS_A, store);
+		* console.log(name); // "isA"
+		*
+		* // Unknown value in store uses KnownValue's name method
+		* name = KnownValuesStore.nameForKnownValue(new KnownValue(999), store);
+		* console.log(name); // "999"
+		*
+		* // No store provided also uses KnownValue's name method
+		* name = KnownValuesStore.nameForKnownValue(IS_A, undefined);
+		* console.log(name); // "isA"
+		* ```
+		*/
+		static nameForKnownValue(knownValue, knownValues) {
+			if (knownValues !== void 0) {
+				const assignedName = knownValues.assignedName(knownValue);
+				if (assignedName !== void 0 && assignedName !== "") return assignedName;
+			}
+			return knownValue.name();
+		}
+		/**
+		* Creates a shallow clone of this store.
+		*
+		* @returns A new KnownValuesStore with the same entries
+		*/
+		clone() {
+			const cloned = new KnownValuesStore();
+			cloned.knownValuesByRawValue = new Map(this.knownValuesByRawValue);
+			cloned.knownValuesByAssignedName = new Map(this.knownValuesByAssignedName);
+			return cloned;
+		}
+		/**
+		* Internal helper method to insert a KnownValue into the store's maps.
+		*/
+		_insert(knownValue) {
+			this.knownValuesByRawValue.set(knownValue.valueBigInt(), knownValue);
+			const assignedName = knownValue.assignedName();
+			if (assignedName !== void 0 && assignedName !== "") this.knownValuesByAssignedName.set(assignedName, knownValue);
+		}
+	};
+
+//#endregion
+//#region src/known-values-registry.ts
+	const UNIT = new KnownValue(0, "");
+	const IS_A = new KnownValue(1, "isA");
+	const ID = new KnownValue(2, "id");
+	const SIGNED = new KnownValue(3, "signed");
+	const NOTE = new KnownValue(4, "note");
+	const HAS_RECIPIENT = new KnownValue(5, "hasRecipient");
+	const SSKR_SHARE = new KnownValue(6, "sskrShare");
+	const CONTROLLER = new KnownValue(7, "controller");
+	const KEY = new KnownValue(8, "key");
+	const DEREFERENCE_VIA = new KnownValue(9, "dereferenceVia");
+	const ENTITY = new KnownValue(10, "entity");
+	const NAME = new KnownValue(11, "name");
+	const LANGUAGE = new KnownValue(12, "language");
+	const ISSUER = new KnownValue(13, "issuer");
+	const HOLDER = new KnownValue(14, "holder");
+	const SALT = new KnownValue(15, "salt");
+	const DATE = new KnownValue(16, "date");
+	const UNKNOWN_VALUE = new KnownValue(17, "Unknown");
+	const VERSION_VALUE = new KnownValue(18, "version");
+	const HAS_SECRET = new KnownValue(19, "hasSecret");
+	const DIFF_EDITS = new KnownValue(20, "edits");
+	const VALID_FROM = new KnownValue(21, "validFrom");
+	const VALID_UNTIL = new KnownValue(22, "validUntil");
+	const POSITION = new KnownValue(23, "position");
+	const NICKNAME = new KnownValue(24, "nickname");
+	const ATTACHMENT = new KnownValue(50, "attachment");
+	const VENDOR = new KnownValue(51, "vendor");
+	const CONFORMS_TO = new KnownValue(52, "conformsTo");
+	const ALLOW = new KnownValue(60, "allow");
+	const DENY = new KnownValue(61, "deny");
+	const ENDPOINT = new KnownValue(62, "endpoint");
+	const DELEGATE = new KnownValue(63, "delegate");
+	const PROVENANCE = new KnownValue(64, "provenance");
+	const PRIVATE_KEY = new KnownValue(65, "privateKey");
+	const SERVICE = new KnownValue(66, "service");
+	const CAPABILITY = new KnownValue(67, "capability");
+	const PROVENANCE_GENERATOR = new KnownValue(68, "provenanceGenerator");
+	const PRIVILEGE_ALL = new KnownValue(70, "All");
+	const PRIVILEGE_AUTH = new KnownValue(71, "Auth");
+	const PRIVILEGE_SIGN = new KnownValue(72, "Sign");
+	const PRIVILEGE_ENCRYPT = new KnownValue(73, "Encrypt");
+	const PRIVILEGE_ELIDE = new KnownValue(74, "Elide");
+	const PRIVILEGE_ISSUE = new KnownValue(75, "Issue");
+	const PRIVILEGE_ACCESS = new KnownValue(76, "Access");
+	const PRIVILEGE_DELEGATE = new KnownValue(80, "Delegate");
+	const PRIVILEGE_VERIFY = new KnownValue(81, "Verify");
+	const PRIVILEGE_UPDATE = new KnownValue(82, "Update");
+	const PRIVILEGE_TRANSFER = new KnownValue(83, "Transfer");
+	const PRIVILEGE_ELECT = new KnownValue(84, "Elect");
+	const PRIVILEGE_BURN = new KnownValue(85, "Burn");
+	const PRIVILEGE_REVOKE = new KnownValue(86, "Revoke");
+	const BODY = new KnownValue(100, "body");
+	const RESULT = new KnownValue(101, "result");
+	const ERROR = new KnownValue(102, "error");
+	const OK_VALUE = new KnownValue(103, "OK");
+	const PROCESSING_VALUE = new KnownValue(104, "Processing");
+	const SENDER = new KnownValue(105, "sender");
+	const SENDER_CONTINUATION = new KnownValue(106, "senderContinuation");
+	const RECIPIENT_CONTINUATION = new KnownValue(107, "recipientContinuation");
+	const CONTENT = new KnownValue(108, "content");
+	const SEED_TYPE = new KnownValue(200, "Seed");
+	const PRIVATE_KEY_TYPE = new KnownValue(201, "PrivateKey");
+	const PUBLIC_KEY_TYPE = new KnownValue(202, "PublicKey");
+	const MASTER_KEY_TYPE = new KnownValue(203, "MasterKey");
+	const ASSET = new KnownValue(300, "asset");
+	const BITCOIN_VALUE = new KnownValue(301, "BTC");
+	const ETHEREUM_VALUE = new KnownValue(302, "ETH");
+	const TEZOS_VALUE = new KnownValue(303, "XTZ");
+	const NETWORK = new KnownValue(400, "network");
+	const MAIN_NET_VALUE = new KnownValue(401, "MainNet");
+	const TEST_NET_VALUE = new KnownValue(402, "TestNet");
+	const BIP32_KEY_TYPE = new KnownValue(500, "BIP32Key");
+	const CHAIN_CODE = new KnownValue(501, "chainCode");
+	const DERIVATION_PATH_TYPE = new KnownValue(502, "DerivationPath");
+	const PARENT_PATH = new KnownValue(503, "parent");
+	const CHILDREN_PATH = new KnownValue(504, "children");
+	const PARENT_FINGERPRINT = new KnownValue(505, "parentFingerprint");
+	const PSBT_TYPE = new KnownValue(506, "PSBT");
+	const OUTPUT_DESCRIPTOR_TYPE = new KnownValue(507, "OutputDescriptor");
+	const OUTPUT_DESCRIPTOR = new KnownValue(508, "outputDescriptor");
+	const GRAPH = new KnownValue(600, "graph");
+	const SOURCE_TARGET_GRAPH = new KnownValue(601, "SourceTargetGraph");
+	const PARENT_CHILD_GRAPH = new KnownValue(602, "ParentChildGraph");
+	const DIGRAPH = new KnownValue(603, "Digraph");
+	const ACYCLIC_GRAPH = new KnownValue(604, "AcyclicGraph");
+	const MULTIGRAPH = new KnownValue(605, "Multigraph");
+	const PSEUDOGRAPH = new KnownValue(606, "Pseudograph");
+	const GRAPH_FRAGMENT = new KnownValue(607, "GraphFragment");
+	const DAG = new KnownValue(608, "DAG");
+	const TREE = new KnownValue(609, "Tree");
+	const FOREST = new KnownValue(610, "Forest");
+	const COMPOUND_GRAPH = new KnownValue(611, "CompoundGraph");
+	const HYPERGRAPH = new KnownValue(612, "Hypergraph");
+	const DIHYPERGRAPH = new KnownValue(613, "Dihypergraph");
+	const NODE = new KnownValue(700, "node");
+	const EDGE = new KnownValue(701, "edge");
+	const SOURCE = new KnownValue(702, "source");
+	const TARGET = new KnownValue(703, "target");
+	const PARENT = new KnownValue(704, "parent");
+	const CHILD = new KnownValue(705, "child");
+	/**
+	* A lazily initialized singleton that holds the global registry of known
+	* values.
+	*
+	* This class provides thread-safe, lazy initialization of the global
+	* KnownValuesStore that contains all the predefined Known Values in the
+	* registry. The store is created only when first accessed, and subsequent
+	* accesses reuse the same instance.
+	*
+	* This is used internally by the crate and should not typically be needed by
+	* users of the API, who should access Known Values through the constants
+	* exposed in the `known_values` module.
+	*/
+	var LazyKnownValues = class {
+		_data;
+		/**
+		* Gets the global KnownValuesStore, initializing it if necessary.
+		*
+		* This method guarantees that initialization occurs exactly once.
+		*/
+		get() {
+			this._data ??= new KnownValuesStore([
+				UNIT,
+				IS_A,
+				ID,
+				SIGNED,
+				NOTE,
+				HAS_RECIPIENT,
+				SSKR_SHARE,
+				CONTROLLER,
+				KEY,
+				DEREFERENCE_VIA,
+				ENTITY,
+				NAME,
+				LANGUAGE,
+				ISSUER,
+				HOLDER,
+				SALT,
+				DATE,
+				UNKNOWN_VALUE,
+				VERSION_VALUE,
+				HAS_SECRET,
+				DIFF_EDITS,
+				VALID_FROM,
+				VALID_UNTIL,
+				POSITION,
+				NICKNAME,
+				ATTACHMENT,
+				VENDOR,
+				CONFORMS_TO,
+				ALLOW,
+				DENY,
+				ENDPOINT,
+				DELEGATE,
+				PROVENANCE,
+				PRIVATE_KEY,
+				SERVICE,
+				CAPABILITY,
+				PROVENANCE_GENERATOR,
+				PRIVILEGE_ALL,
+				PRIVILEGE_AUTH,
+				PRIVILEGE_SIGN,
+				PRIVILEGE_ENCRYPT,
+				PRIVILEGE_ELIDE,
+				PRIVILEGE_ISSUE,
+				PRIVILEGE_ACCESS,
+				PRIVILEGE_DELEGATE,
+				PRIVILEGE_VERIFY,
+				PRIVILEGE_UPDATE,
+				PRIVILEGE_TRANSFER,
+				PRIVILEGE_ELECT,
+				PRIVILEGE_BURN,
+				PRIVILEGE_REVOKE,
+				BODY,
+				RESULT,
+				ERROR,
+				OK_VALUE,
+				PROCESSING_VALUE,
+				SENDER,
+				SENDER_CONTINUATION,
+				RECIPIENT_CONTINUATION,
+				CONTENT,
+				SEED_TYPE,
+				PRIVATE_KEY_TYPE,
+				PUBLIC_KEY_TYPE,
+				MASTER_KEY_TYPE,
+				ASSET,
+				BITCOIN_VALUE,
+				ETHEREUM_VALUE,
+				TEZOS_VALUE,
+				NETWORK,
+				MAIN_NET_VALUE,
+				TEST_NET_VALUE,
+				BIP32_KEY_TYPE,
+				CHAIN_CODE,
+				DERIVATION_PATH_TYPE,
+				PARENT_PATH,
+				CHILDREN_PATH,
+				PARENT_FINGERPRINT,
+				PSBT_TYPE,
+				OUTPUT_DESCRIPTOR_TYPE,
+				OUTPUT_DESCRIPTOR,
+				GRAPH,
+				SOURCE_TARGET_GRAPH,
+				PARENT_CHILD_GRAPH,
+				DIGRAPH,
+				ACYCLIC_GRAPH,
+				MULTIGRAPH,
+				PSEUDOGRAPH,
+				GRAPH_FRAGMENT,
+				DAG,
+				TREE,
+				FOREST,
+				COMPOUND_GRAPH,
+				HYPERGRAPH,
+				DIHYPERGRAPH,
+				NODE,
+				EDGE,
+				SOURCE,
+				TARGET,
+				PARENT,
+				CHILD
+			]);
+			return this._data;
+		}
+	};
+	/**
+	* The global registry of Known Values.
+	*
+	* This static instance provides access to all standard Known Values defined in
+	* the registry specification. It is lazily initialized on first access.
+	*
+	* Most users should not need to interact with this directly, as the predefined
+	* Known Values are exposed as constants in the `known_values` module.
+	*
+	* @example
+	* ```typescript
+	* import { KNOWN_VALUES } from '@bcts/known-values';
+	*
+	* // Access the global store
+	* const knownValues = KNOWN_VALUES.get();
+	*
+	* // Look up a Known Value by name
+	* const isA = knownValues.knownValueNamed('isA');
+	* console.log(isA?.value()); // 1
+	* ```
+	*/
+	const KNOWN_VALUES = new LazyKnownValues();
+
+//#endregion
+exports.ACYCLIC_GRAPH = ACYCLIC_GRAPH;
+exports.ALLOW = ALLOW;
+exports.ASSET = ASSET;
+exports.ATTACHMENT = ATTACHMENT;
+exports.BIP32_KEY_TYPE = BIP32_KEY_TYPE;
+exports.BITCOIN_VALUE = BITCOIN_VALUE;
+exports.BODY = BODY;
+exports.CAPABILITY = CAPABILITY;
+exports.CHAIN_CODE = CHAIN_CODE;
+exports.CHILD = CHILD;
+exports.CHILDREN_PATH = CHILDREN_PATH;
+exports.COMPOUND_GRAPH = COMPOUND_GRAPH;
+exports.CONFORMS_TO = CONFORMS_TO;
+exports.CONTENT = CONTENT;
+exports.CONTROLLER = CONTROLLER;
+exports.DAG = DAG;
+exports.DATE = DATE;
+exports.DELEGATE = DELEGATE;
+exports.DENY = DENY;
+exports.DEREFERENCE_VIA = DEREFERENCE_VIA;
+exports.DERIVATION_PATH_TYPE = DERIVATION_PATH_TYPE;
+exports.DIFF_EDITS = DIFF_EDITS;
+exports.DIGRAPH = DIGRAPH;
+exports.DIHYPERGRAPH = DIHYPERGRAPH;
+exports.EDGE = EDGE;
+exports.ENDPOINT = ENDPOINT;
+exports.ENTITY = ENTITY;
+exports.ERROR = ERROR;
+exports.ETHEREUM_VALUE = ETHEREUM_VALUE;
+exports.FOREST = FOREST;
+exports.GRAPH = GRAPH;
+exports.GRAPH_FRAGMENT = GRAPH_FRAGMENT;
+exports.HAS_RECIPIENT = HAS_RECIPIENT;
+exports.HAS_SECRET = HAS_SECRET;
+exports.HOLDER = HOLDER;
+exports.HYPERGRAPH = HYPERGRAPH;
+exports.ID = ID;
+exports.ISSUER = ISSUER;
+exports.IS_A = IS_A;
+exports.KEY = KEY;
+exports.KNOWN_VALUES = KNOWN_VALUES;
+exports.KNOWN_VALUE_TAG = KNOWN_VALUE_TAG;
+exports.KnownValue = KnownValue;
+exports.KnownValuesStore = KnownValuesStore;
+exports.LANGUAGE = LANGUAGE;
+exports.LazyKnownValues = LazyKnownValues;
+exports.MAIN_NET_VALUE = MAIN_NET_VALUE;
+exports.MASTER_KEY_TYPE = MASTER_KEY_TYPE;
+exports.MULTIGRAPH = MULTIGRAPH;
+exports.NAME = NAME;
+exports.NETWORK = NETWORK;
+exports.NICKNAME = NICKNAME;
+exports.NODE = NODE;
+exports.NOTE = NOTE;
+exports.OK_VALUE = OK_VALUE;
+exports.OUTPUT_DESCRIPTOR = OUTPUT_DESCRIPTOR;
+exports.OUTPUT_DESCRIPTOR_TYPE = OUTPUT_DESCRIPTOR_TYPE;
+exports.PARENT = PARENT;
+exports.PARENT_CHILD_GRAPH = PARENT_CHILD_GRAPH;
+exports.PARENT_FINGERPRINT = PARENT_FINGERPRINT;
+exports.PARENT_PATH = PARENT_PATH;
+exports.POSITION = POSITION;
+exports.PRIVATE_KEY = PRIVATE_KEY;
+exports.PRIVATE_KEY_TYPE = PRIVATE_KEY_TYPE;
+exports.PRIVILEGE_ACCESS = PRIVILEGE_ACCESS;
+exports.PRIVILEGE_ALL = PRIVILEGE_ALL;
+exports.PRIVILEGE_AUTH = PRIVILEGE_AUTH;
+exports.PRIVILEGE_BURN = PRIVILEGE_BURN;
+exports.PRIVILEGE_DELEGATE = PRIVILEGE_DELEGATE;
+exports.PRIVILEGE_ELECT = PRIVILEGE_ELECT;
+exports.PRIVILEGE_ELIDE = PRIVILEGE_ELIDE;
+exports.PRIVILEGE_ENCRYPT = PRIVILEGE_ENCRYPT;
+exports.PRIVILEGE_ISSUE = PRIVILEGE_ISSUE;
+exports.PRIVILEGE_REVOKE = PRIVILEGE_REVOKE;
+exports.PRIVILEGE_SIGN = PRIVILEGE_SIGN;
+exports.PRIVILEGE_TRANSFER = PRIVILEGE_TRANSFER;
+exports.PRIVILEGE_UPDATE = PRIVILEGE_UPDATE;
+exports.PRIVILEGE_VERIFY = PRIVILEGE_VERIFY;
+exports.PROCESSING_VALUE = PROCESSING_VALUE;
+exports.PROVENANCE = PROVENANCE;
+exports.PROVENANCE_GENERATOR = PROVENANCE_GENERATOR;
+exports.PSBT_TYPE = PSBT_TYPE;
+exports.PSEUDOGRAPH = PSEUDOGRAPH;
+exports.PUBLIC_KEY_TYPE = PUBLIC_KEY_TYPE;
+exports.RECIPIENT_CONTINUATION = RECIPIENT_CONTINUATION;
+exports.RESULT = RESULT;
+exports.SALT = SALT;
+exports.SEED_TYPE = SEED_TYPE;
+exports.SENDER = SENDER;
+exports.SENDER_CONTINUATION = SENDER_CONTINUATION;
+exports.SERVICE = SERVICE;
+exports.SIGNED = SIGNED;
+exports.SOURCE = SOURCE;
+exports.SOURCE_TARGET_GRAPH = SOURCE_TARGET_GRAPH;
+exports.SSKR_SHARE = SSKR_SHARE;
+exports.TAG_KNOWN_VALUE = TAG_KNOWN_VALUE;
+exports.TARGET = TARGET;
+exports.TEST_NET_VALUE = TEST_NET_VALUE;
+exports.TEZOS_VALUE = TEZOS_VALUE;
+exports.TREE = TREE;
+exports.UNIT = UNIT;
+exports.UNKNOWN_VALUE = UNKNOWN_VALUE;
+exports.VALID_FROM = VALID_FROM;
+exports.VALID_UNTIL = VALID_UNTIL;
+exports.VENDOR = VENDOR;
+exports.VERSION_VALUE = VERSION_VALUE;
+return exports;
+})({}, bctsDcbor, bctsComponents);
+//# sourceMappingURL=index.iife.js.map