{"version":3,"file":"index.cjs","names":["KNOWN_VALUE","Digest","MajorType","bcRegistry","communityRegistry","rdfRegistry","rdfsRegistry","owl2Registry","dceRegistry","dctRegistry","foafRegistry","skosRegistry","solidRegistry","vcRegistry","gs1Registry","schemaRegistry","communityExtRegistry"],"sources":["../src/known-value.ts","../src/known-values-store.ts","../data/0_blockchain_commons_registry.json","../data/1000_community_registry.json","../data/2000_rdf_registry.json","../data/2050_rdfs_registry.json","../data/2100_owl2_registry.json","../data/2200_dce_registry.json","../data/2300_dct_registry.json","../data/2500_foaf_registry.json","../data/2700_skos_registry.json","../data/2800_solid_registry.json","../data/2900_vc_registry.json","../data/3000_gs1_registry.json","../data/10000_schema_registry.json","../data/100000_community_registry.json","../src/bundled-registries.ts","../src/known-values-registry.ts"],"sourcesContent":["/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n *\n * A value in a namespace of unsigned integers that represents a stand-alone\n * ontological concept.\n *\n * Known Values provide a compact, deterministic way to represent commonly used\n * ontological concepts such as relationships between entities, classes of\n * entities, properties, or enumerated values. They are particularly useful as\n * predicates in Gordian Envelope assertions, offering a more compact and\n * deterministic alternative to URIs. However, known values are not exclusive\n * to Gordian Envelopes and can be used in any context where a compact, unique\n * identifier for a concept is needed.\n *\n * A Known Value is represented as a 64-bit unsigned integer with an optional\n * human-readable name. This approach ensures:\n *\n * - **Compact binary representation** - Each Known Value requires only 1-9\n *   bytes depending on value range\n * - **Deterministic encoding** - Every concept has exactly one valid binary\n *   representation\n * - **Enhanced security** - Eliminates URI manipulation vulnerabilities\n * - **Standardized semantics** - Values are registered in a central registry\n *\n * While Known Values are most commonly used as predicates in assertions, they\n * can appear in any position in an Envelope (subject, predicate, or object).\n *\n * @example\n * ```typescript\n * import { KnownValue } from '@bcts/known-values';\n *\n * // Create a Known Value with a numeric value\n * const knownValue = new KnownValue(42);\n * console.log(knownValue.value()); // 42\n *\n * // Create a Known Value with a name\n * const namedValue = new KnownValue(1, 'isA');\n * console.log(namedValue.value()); // 1\n * console.log(namedValue.name()); // \"isA\"\n *\n * // CBOR encoding\n * const cbor = namedValue.taggedCbor();\n * const bytes = namedValue.toCborData();\n *\n * // CBOR decoding\n * const decoded = KnownValue.fromTaggedCbor(cbor);\n * const decodedFromBytes = KnownValue.fromCborData(bytes);\n *\n * // Use a pre-defined Known Value from the registry\n * import { IS_A } from '@bcts/known-values';\n * console.log(IS_A.value()); // 1\n * console.log(IS_A.name()); // \"isA\"\n * ```\n *\n * @specification\n *\n * Known Values are defined in\n * [BCR-2023-002](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-002-known-value.md)\n * and implemented as an Envelope extension in\n * [BCR-2023-003](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-003-envelope-known-value.md).\n */\n\nimport {\n  type Cbor,\n  type Tag,\n  type CborTaggedEncodable,\n  type CborTaggedDecodable,\n  cbor,\n  cborData,\n  decodeCbor,\n  MajorType,\n} from \"@bcts/dcbor\";\nimport { KNOWN_VALUE, Digest, type DigestProvider } from \"@bcts/components\";\n\n/**\n * The numeric value for the CBOR tag used for Known Values.\n * This is Tag 40000 as defined in the Blockchain Commons registry.\n */\nexport const TAG_KNOWN_VALUE = KNOWN_VALUE.value;\n\n/**\n * The CBOR tag used for Known Values.\n * This is Tag 40000 as defined in the Blockchain Commons registry.\n */\nexport const KNOWN_VALUE_TAG: Tag = KNOWN_VALUE;\n\n/**\n * Type for values that can be used to create a KnownValue.\n * Supports both number (for values up to 2^53-1) and bigint (for full 64-bit range).\n */\nexport type KnownValueInput = number | bigint;\n\nexport class KnownValue\n  implements CborTaggedEncodable, CborTaggedDecodable<KnownValue>, DigestProvider\n{\n  private readonly _value: bigint;\n  private readonly _assignedName: string | undefined;\n\n  /**\n   * Creates a new KnownValue with the given numeric value and optional name.\n   *\n   * @param value - The numeric value (number or bigint). Numbers are converted to bigint internally.\n   * @param assignedName - Optional human-readable name for the value\n   *\n   * @example\n   * ```typescript\n   * const knownValue = new KnownValue(42);\n   * console.log(knownValue.value()); // 42\n   *\n   * const namedValue = new KnownValue(1, 'isA');\n   * console.log(namedValue.name()); // \"isA\"\n   *\n   * // Using bigint for large values\n   * const largeValue = new KnownValue(9007199254740993n);\n   * ```\n   */\n  constructor(value: KnownValueInput, assignedName?: string) {\n    this._value = typeof value === \"bigint\" ? value : BigInt(value);\n    this._assignedName = assignedName;\n  }\n\n  // ===========================================================================\n  // Value Accessors (backward compatible API)\n  // ===========================================================================\n\n  /**\n   * Returns the numeric value of the KnownValue.\n   *\n   * This is the raw unsigned integer that identifies the concept.\n   * Returns a number for backward compatibility. For values > MAX_SAFE_INTEGER,\n   * use `valueBigInt()`.\n   *\n   * @example\n   * ```typescript\n   * import { IS_A, NOTE } from '@bcts/known-values';\n   * console.log(IS_A.value()); // 1\n   * console.log(NOTE.value()); // 4\n   * ```\n   */\n  value(): number {\n    if (this._value > BigInt(Number.MAX_SAFE_INTEGER)) {\n      throw new RangeError(\n        `KnownValue ${this._value} exceeds MAX_SAFE_INTEGER. Use valueBigInt() instead.`,\n      );\n    }\n    return Number(this._value);\n  }\n\n  /**\n   * Returns the numeric value of the KnownValue as a bigint.\n   *\n   * Use this for values that may exceed Number.MAX_SAFE_INTEGER (2^53-1).\n   *\n   * @example\n   * ```typescript\n   * const largeValue = new KnownValue(9007199254740993n);\n   * console.log(largeValue.valueBigInt()); // 9007199254740993n\n   * ```\n   */\n  valueBigInt(): bigint {\n    return this._value;\n  }\n\n  /**\n   * Returns the assigned name of the KnownValue, if one exists.\n   *\n   * @example\n   * ```typescript\n   * const namedValue = new KnownValue(1, 'isA');\n   * console.log(namedValue.assignedName()); // \"isA\"\n   *\n   * const unnamedValue = new KnownValue(42);\n   * console.log(unnamedValue.assignedName()); // undefined\n   * ```\n   */\n  assignedName(): string | undefined {\n    return this._assignedName;\n  }\n\n  /**\n   * Returns a human-readable name for the KnownValue.\n   *\n   * If the KnownValue has an assigned name, that name is returned.\n   * Otherwise, the string representation of the numeric value is returned.\n   *\n   * @example\n   * ```typescript\n   * const namedValue = new KnownValue(1, 'isA');\n   * console.log(namedValue.name()); // \"isA\"\n   *\n   * const unnamedValue = new KnownValue(42);\n   * console.log(unnamedValue.name()); // \"42\"\n   * ```\n   */\n  name(): string {\n    return this._assignedName ?? this._value.toString();\n  }\n\n  // ===========================================================================\n  // Equality and Hashing\n  // ===========================================================================\n\n  /**\n   * Compares this KnownValue with another for equality.\n   * Equality is based solely on the numeric value, ignoring the name.\n   *\n   * @param other - The KnownValue to compare with\n   * @returns true if the values are equal\n   *\n   * @example\n   * ```typescript\n   * const kv1 = new KnownValue(1, 'isA');\n   * const kv2 = new KnownValue(1, 'different');\n   * console.log(kv1.equals(kv2)); // true (same value, different name)\n   * ```\n   */\n  equals(other: KnownValue): boolean {\n    return this._value === other._value;\n  }\n\n  /**\n   * Hash code based on the numeric value.\n   * Useful for using KnownValue in hash-based collections.\n   */\n  hashCode(): number {\n    // Convert bigint to a 32-bit hash\n    return Number(this._value & BigInt(0xffffffff));\n  }\n\n  // ===========================================================================\n  // DigestProvider Implementation\n  // ===========================================================================\n\n  /**\n   * Returns the cryptographic digest of this KnownValue.\n   *\n   * The digest is computed from the tagged CBOR encoding of the value,\n   * providing a unique content-addressable identifier.\n   *\n   * This is used for Envelope integration where KnownValues are hashed\n   * for tree construction.\n   *\n   * @returns A Digest of the tagged CBOR encoding\n   *\n   * @example\n   * ```typescript\n   * const kv = new KnownValue(1, \"isA\");\n   * const digest = kv.digest();\n   * console.log(digest.hex()); // SHA-256 hash of the CBOR encoding\n   * ```\n   */\n  digest(): Digest {\n    return Digest.fromImage(this.toCborData());\n  }\n\n  /**\n   * String representation of the KnownValue.\n   *\n   * If a name is assigned, the name is displayed. Otherwise, the numeric value\n   * is displayed.\n   */\n  toString(): string {\n    return this.name();\n  }\n\n  // ===========================================================================\n  // CBOR Encoding (CborTaggedEncodable interface)\n  // ===========================================================================\n\n  /**\n   * Returns the CBOR tags associated with KnownValue.\n   *\n   * The primary tag is TAG_KNOWN_VALUE (201).\n   *\n   * @returns Array containing the KnownValue tag\n   */\n  cborTags(): Tag[] {\n    return [KNOWN_VALUE_TAG];\n  }\n\n  /**\n   * Returns the untagged CBOR encoding of this KnownValue.\n   *\n   * The untagged representation is simply the unsigned integer value.\n   *\n   * @returns CBOR representation of the value (unsigned integer)\n   */\n  untaggedCbor(): Cbor {\n    return cbor(this._value);\n  }\n\n  /**\n   * Returns the tagged CBOR encoding of this KnownValue.\n   *\n   * This wraps the unsigned integer value with tag 201.\n   *\n   * @returns Tagged CBOR representation\n   *\n   * @example\n   * ```typescript\n   * const kv = new KnownValue(1, 'isA');\n   * const tagged = kv.taggedCbor();\n   * console.log(tagged.toHex()); // \"d8c901\" (tag 201, value 1)\n   * ```\n   */\n  taggedCbor(): Cbor {\n    return cbor({\n      tag: TAG_KNOWN_VALUE,\n      value: this._value,\n    });\n  }\n\n  /**\n   * Returns the tagged CBOR encoding as binary data.\n   *\n   * @returns Binary CBOR representation\n   *\n   * @example\n   * ```typescript\n   * const kv = new KnownValue(1, 'isA');\n   * const bytes = kv.toCborData();\n   * // bytes is Uint8Array containing the CBOR encoding\n   * ```\n   */\n  toCborData(): Uint8Array {\n    return cborData(this.taggedCbor());\n  }\n\n  /**\n   * Alias for `toCborData()` to match the dcbor interface.\n   */\n  taggedCborData(): Uint8Array {\n    return this.toCborData();\n  }\n\n  // ===========================================================================\n  // CBOR Decoding (CborTaggedDecodable interface)\n  // ===========================================================================\n\n  /**\n   * Creates a KnownValue from untagged CBOR (an unsigned integer).\n   * Instance method for interface compliance.\n   *\n   * @param cborValue - The CBOR value (must be an unsigned integer)\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR is not an unsigned integer\n   */\n  fromUntaggedCbor(cborValue: Cbor): KnownValue {\n    return KnownValue.fromUntaggedCbor(cborValue);\n  }\n\n  /**\n   * Creates a KnownValue from tagged CBOR (tag 201).\n   * Instance method for interface compliance.\n   *\n   * @param cborValue - The tagged CBOR value\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR is not properly tagged or contains invalid data\n   */\n  fromTaggedCbor(cborValue: Cbor): KnownValue {\n    return KnownValue.fromTaggedCbor(cborValue);\n  }\n\n  // ===========================================================================\n  // Static Factory Methods\n  // ===========================================================================\n\n  /**\n   * Creates a KnownValue from untagged CBOR (an unsigned integer).\n   *\n   * @param cborValue - The CBOR value (must be an unsigned integer)\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR is not an unsigned integer\n   *\n   * @example\n   * ```typescript\n   * const cborValue = cbor(42);\n   * const kv = KnownValue.fromUntaggedCbor(cborValue);\n   * console.log(kv.value()); // 42\n   * ```\n   */\n  static fromUntaggedCbor(cborValue: Cbor): KnownValue {\n    if (cborValue.type !== MajorType.Unsigned) {\n      throw new Error(`Expected unsigned integer for KnownValue, got major type ${cborValue.type}`);\n    }\n    const numValue = cborValue.value;\n    return new KnownValue(typeof numValue === \"bigint\" ? numValue : BigInt(numValue));\n  }\n\n  /**\n   * Creates a KnownValue from tagged CBOR (tag 201).\n   *\n   * @param cborValue - The tagged CBOR value\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR is not properly tagged or contains invalid data\n   *\n   * @example\n   * ```typescript\n   * const kv = KnownValue.fromTaggedCbor(taggedCborValue);\n   * ```\n   */\n  static fromTaggedCbor(cborValue: Cbor): KnownValue {\n    if (cborValue.type !== MajorType.Tagged) {\n      throw new Error(`Expected tagged CBOR for KnownValue, got major type ${cborValue.type}`);\n    }\n\n    const tag = cborValue.tag;\n    if (tag !== BigInt(TAG_KNOWN_VALUE) && tag !== TAG_KNOWN_VALUE) {\n      throw new Error(`Expected tag ${TAG_KNOWN_VALUE} for KnownValue, got ${tag}`);\n    }\n\n    return KnownValue.fromUntaggedCbor(cborValue.value);\n  }\n\n  /**\n   * Creates a KnownValue from binary CBOR data.\n   *\n   * @param data - Binary CBOR data (must be a tagged KnownValue)\n   * @returns A new KnownValue\n   * @throws {Error} If the data cannot be decoded or is not a valid KnownValue\n   *\n   * @example\n   * ```typescript\n   * const bytes = new Uint8Array([0xd8, 0xc9, 0x01]); // tag 201, value 1\n   * const kv = KnownValue.fromCborData(bytes);\n   * console.log(kv.value()); // 1\n   * ```\n   */\n  static fromCborData(data: Uint8Array): KnownValue {\n    const cborValue = decodeCbor(data);\n    return KnownValue.fromTaggedCbor(cborValue);\n  }\n\n  /**\n   * Creates a KnownValue from a CBOR value, automatically detecting\n   * whether it's tagged or untagged.\n   *\n   * @param cborValue - The CBOR value (tagged or untagged)\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR cannot be converted to a KnownValue\n   *\n   * @example\n   * ```typescript\n   * // Works with both tagged and untagged\n   * const kv1 = KnownValue.fromCbor(cbor(42));\n   * const kv2 = KnownValue.fromCbor(taggedCborValue);\n   * ```\n   */\n  static fromCbor(cborValue: Cbor): KnownValue {\n    if (cborValue.type === MajorType.Tagged) {\n      return KnownValue.fromTaggedCbor(cborValue);\n    }\n    return KnownValue.fromUntaggedCbor(cborValue);\n  }\n}\n","/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n */\n\nimport { KnownValue, type KnownValueInput } from \"./known-value\";\n\n/**\n * A store that maps between Known Values and their assigned names.\n *\n * The `KnownValuesStore` provides a bidirectional mapping between:\n * - Numeric values (bigint) and their corresponding KnownValue instances\n * - String names and their corresponding KnownValue instances\n *\n * This enables efficient lookup in both directions, making it possible to:\n * - Find the name for a given numeric value\n * - Find the numeric value for a given name\n * - Retrieve complete KnownValue instances by either name or value\n *\n * The store is typically populated with predefined Known Values from the\n * registry, but can also be extended with custom values.\n *\n * @example\n * ```typescript\n * import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';\n *\n * // Create a store with predefined Known Values\n * const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);\n *\n * // Look up a Known Value by name\n * const isA = store.knownValueNamed('isA');\n * console.log(isA?.value()); // 1\n *\n * // Look up a name for a raw value\n * const name = store.name(new KnownValue(3));\n * console.log(name); // \"signed\"\n *\n * // Insert a custom Known Value\n * const customStore = store.clone();\n * customStore.insert(new KnownValue(100, 'customValue'));\n * console.log(customStore.knownValueNamed('customValue')?.value()); // 100\n * ```\n */\nexport class KnownValuesStore {\n  // Use bigint for map keys to support full 64-bit range\n  private knownValuesByRawValue: Map<bigint, KnownValue>;\n  private knownValuesByAssignedName: Map<string, KnownValue>;\n\n  /**\n   * Creates a new KnownValuesStore with the provided Known Values.\n   *\n   * This constructor takes an iterable of KnownValue instances and\n   * populates the store with them, creating mappings from both raw\n   * values and names to the corresponding KnownValue instances.\n   *\n   * @param knownValues - Iterable of KnownValue instances to populate the store\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';\n   *\n   * // Create a store with predefined Known Values\n   * const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);\n   *\n   * // Look up Known Values\n   * console.log(store.knownValueNamed('isA')?.value()); // 1\n   * console.log(store.knownValueNamed('note')?.value()); // 4\n   * ```\n   */\n  constructor(knownValues: Iterable<KnownValue> = []) {\n    this.knownValuesByRawValue = new Map();\n    this.knownValuesByAssignedName = new Map();\n\n    for (const knownValue of knownValues) {\n      this._insert(knownValue);\n    }\n  }\n\n  /**\n   * Inserts a KnownValue into the store.\n   *\n   * If the KnownValue has an assigned name, it will be indexed by both its\n   * raw value and its name. If a KnownValue with the same raw value or name\n   * already exists in the store, it will be replaced.\n   *\n   * @param knownValue - The KnownValue to insert\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, KnownValue } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore();\n   * store.insert(new KnownValue(100, 'customValue'));\n   * console.log(store.knownValueNamed('customValue')?.value()); // 100\n   * ```\n   */\n  insert(knownValue: KnownValue): void {\n    this._insert(knownValue);\n  }\n\n  /**\n   * Returns the assigned name for a KnownValue, if present in the store.\n   *\n   * @param knownValue - The KnownValue to look up\n   * @returns The assigned name, or undefined if not found\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   * console.log(store.assignedName(IS_A)); // \"isA\"\n   * console.log(store.assignedName(new KnownValue(999))); // undefined\n   * ```\n   */\n  assignedName(knownValue: KnownValue): string | undefined {\n    return this.knownValuesByRawValue.get(knownValue.valueBigInt())?.assignedName();\n  }\n\n  /**\n   * Returns a human-readable name for a KnownValue.\n   *\n   * If the KnownValue has an assigned name in the store, that name is\n   * returned. Otherwise, the KnownValue's default name (which may be its\n   * numeric value as a string) is returned.\n   *\n   * @param knownValue - The KnownValue to get the name for\n   * @returns The name (assigned or numeric)\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   * console.log(store.name(IS_A)); // \"isA\"\n   * console.log(store.name(new KnownValue(999))); // \"999\"\n   * ```\n   */\n  name(knownValue: KnownValue): string {\n    const assignedName = this.assignedName(knownValue);\n    return assignedName ?? knownValue.name();\n  }\n\n  /**\n   * Looks up a KnownValue by its assigned name.\n   *\n   * Returns the KnownValue if found, or undefined if no KnownValue\n   * with the given name exists in the store.\n   *\n   * @param assignedName - The name to look up\n   * @returns The KnownValue, or undefined if not found\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   *\n   * const isA = store.knownValueNamed('isA');\n   * console.log(isA?.value()); // 1\n   *\n   * console.log(store.knownValueNamed('nonexistent')); // undefined\n   * ```\n   */\n  knownValueNamed(assignedName: string): KnownValue | undefined {\n    return this.knownValuesByAssignedName.get(assignedName);\n  }\n\n  /**\n   * Looks up a KnownValue by its raw numeric value.\n   *\n   * @param rawValue - The numeric value to look up (number or bigint)\n   * @returns The KnownValue, or undefined if not found\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   * const isA = store.knownValueForValue(1);\n   * console.log(isA?.name()); // \"isA\"\n   * ```\n   */\n  knownValueForValue(rawValue: KnownValueInput): KnownValue | undefined {\n    const key = typeof rawValue === \"bigint\" ? rawValue : BigInt(rawValue);\n    return this.knownValuesByRawValue.get(key);\n  }\n\n  /**\n   * Retrieves a KnownValue for a raw value, using a store if provided.\n   *\n   * This static method allows looking up a KnownValue by its raw numeric\n   * value:\n   * - If a store is provided and contains a mapping for the raw value, that\n   *   KnownValue is returned\n   * - Otherwise, a new KnownValue with no assigned name is created and\n   *   returned\n   *\n   * @param rawValue - The numeric value to look up (number or bigint)\n   * @param knownValues - Optional store to search in\n   * @returns The KnownValue from the store or a new unnamed KnownValue\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   *\n   * // Known value from store\n   * const isA = KnownValuesStore.knownValueForRawValue(1, store);\n   * console.log(isA.name()); // \"isA\"\n   *\n   * // Unknown value creates a new KnownValue\n   * const unknown = KnownValuesStore.knownValueForRawValue(999, store);\n   * console.log(unknown.name()); // \"999\"\n   *\n   * // No store provided also creates a new KnownValue\n   * const unknown2 = KnownValuesStore.knownValueForRawValue(1, undefined);\n   * console.log(unknown2.name()); // \"1\"\n   * ```\n   */\n  static knownValueForRawValue(\n    rawValue: KnownValueInput,\n    knownValues?: KnownValuesStore,\n  ): KnownValue {\n    if (knownValues !== undefined) {\n      const value = knownValues.knownValueForValue(rawValue);\n      if (value !== undefined) {\n        return value;\n      }\n    }\n    return new KnownValue(rawValue);\n  }\n\n  /**\n   * Attempts to find a KnownValue by its name, using a store if provided.\n   *\n   * This static method allows looking up a KnownValue by its name:\n   * - If a store is provided and contains a mapping for the name, that\n   *   KnownValue is returned\n   * - Otherwise, undefined is returned\n   *\n   * @param name - The name to look up\n   * @param knownValues - Optional store to search in\n   * @returns The KnownValue if found, or undefined\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   *\n   * // Known value from store\n   * const isA = KnownValuesStore.knownValueForName('isA', store);\n   * console.log(isA?.value()); // 1\n   *\n   * // Unknown name returns undefined\n   * console.log(KnownValuesStore.knownValueForName('unknown', store)); // undefined\n   *\n   * // No store provided also returns undefined\n   * console.log(KnownValuesStore.knownValueForName('isA', undefined)); // undefined\n   * ```\n   */\n  static knownValueForName(name: string, knownValues?: KnownValuesStore): KnownValue | undefined {\n    return knownValues?.knownValueNamed(name);\n  }\n\n  /**\n   * Returns a human-readable name for a KnownValue, using a store if provided.\n   *\n   * This static method allows getting a name for a KnownValue:\n   * - If a store is provided and contains a mapping for the KnownValue, its\n   *   assigned name is returned\n   * - Otherwise, the KnownValue's default name (which may be its numeric\n   *   value as a string) is returned\n   *\n   * @param knownValue - The KnownValue to get the name for\n   * @param knownValues - Optional store to use for lookup\n   * @returns The name (assigned or numeric)\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   *\n   * // Known value from store\n   * let name = KnownValuesStore.nameForKnownValue(IS_A, store);\n   * console.log(name); // \"isA\"\n   *\n   * // Unknown value in store uses KnownValue's name method\n   * name = KnownValuesStore.nameForKnownValue(new KnownValue(999), store);\n   * console.log(name); // \"999\"\n   *\n   * // No store provided also uses KnownValue's name method\n   * name = KnownValuesStore.nameForKnownValue(IS_A, undefined);\n   * console.log(name); // \"isA\"\n   * ```\n   */\n  static nameForKnownValue(knownValue: KnownValue, knownValues?: KnownValuesStore): string {\n    if (knownValues !== undefined) {\n      const assignedName = knownValues.assignedName(knownValue);\n      if (assignedName !== undefined && assignedName !== \"\") {\n        return assignedName;\n      }\n    }\n    return knownValue.name();\n  }\n\n  /**\n   * Creates a shallow clone of this store.\n   *\n   * @returns A new KnownValuesStore with the same entries\n   */\n  clone(): KnownValuesStore {\n    const cloned = new KnownValuesStore();\n    cloned.knownValuesByRawValue = new Map(this.knownValuesByRawValue);\n    cloned.knownValuesByAssignedName = new Map(this.knownValuesByAssignedName);\n    return cloned;\n  }\n\n  /**\n   * Internal helper method to insert a KnownValue into the store's maps.\n   */\n  private _insert(knownValue: KnownValue): void {\n    // If there's an existing value with the same codepoint, remove its name\n    // from the name index to avoid stale entries\n    const existing = this.knownValuesByRawValue.get(knownValue.valueBigInt());\n    if (existing !== undefined) {\n      const oldName = existing.assignedName();\n      if (oldName !== undefined && oldName !== \"\") {\n        this.knownValuesByAssignedName.delete(oldName);\n      }\n    }\n\n    this.knownValuesByRawValue.set(knownValue.valueBigInt(), knownValue);\n    const assignedName = knownValue.assignedName();\n    if (assignedName !== undefined && assignedName !== \"\") {\n      this.knownValuesByAssignedName.set(assignedName, knownValue);\n    }\n  }\n}\n","","","","","","","","","","","","","","","/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n *\n * Bundled registry data loaded at build time.\n *\n * This module imports all JSON registry files from the `data/` directory\n * so they are embedded in the bundle and available in all environments\n * (Node.js, browser, etc.) without filesystem access.\n */\n\nimport { KnownValue } from \"./known-value\";\n\n/**\n * A single entry in a known values JSON registry file.\n */\nexport interface RegistryEntry {\n  /** The unique numeric identifier for this known value. */\n  codepoint: number;\n  /** The canonical string name for this known value. */\n  name: string;\n  /** The type of entry (e.g., \"property\", \"class\", \"value\"). */\n  type?: string;\n  /** An optional URI reference for this known value. */\n  uri?: string;\n  /** An optional human-readable description. */\n  description?: string;\n}\n\n/**\n * Root structure of a known values JSON registry file.\n */\nexport interface RegistryFile {\n  /** Metadata about this registry. */\n  ontology?: {\n    name?: string;\n    source_url?: string;\n    start_code_point?: number;\n    processing_strategy?: string;\n  };\n  /** Information about how this file was generated. */\n  generated?: { tool?: string; version?: string };\n  /** The known value entries in this registry. */\n  entries: RegistryEntry[];\n  /** Statistics about this registry (ignored during parsing). */\n  statistics?: unknown;\n}\n\n// Import all bundled registry JSON files\nimport bcRegistry from \"../data/0_blockchain_commons_registry.json\";\nimport communityRegistry from \"../data/1000_community_registry.json\";\nimport rdfRegistry from \"../data/2000_rdf_registry.json\";\nimport rdfsRegistry from \"../data/2050_rdfs_registry.json\";\nimport owl2Registry from \"../data/2100_owl2_registry.json\";\nimport dceRegistry from \"../data/2200_dce_registry.json\";\nimport dctRegistry from \"../data/2300_dct_registry.json\";\nimport foafRegistry from \"../data/2500_foaf_registry.json\";\nimport skosRegistry from \"../data/2700_skos_registry.json\";\nimport solidRegistry from \"../data/2800_solid_registry.json\";\nimport vcRegistry from \"../data/2900_vc_registry.json\";\nimport gs1Registry from \"../data/3000_gs1_registry.json\";\nimport schemaRegistry from \"../data/10000_schema_registry.json\";\nimport communityExtRegistry from \"../data/100000_community_registry.json\";\n\n/**\n * All bundled registries in load order.\n * Later entries override earlier entries when codepoints collide.\n */\nconst ALL_REGISTRIES: RegistryFile[] = [\n  bcRegistry,\n  communityRegistry,\n  rdfRegistry,\n  rdfsRegistry,\n  owl2Registry,\n  dceRegistry,\n  dctRegistry,\n  foafRegistry,\n  skosRegistry,\n  solidRegistry,\n  vcRegistry,\n  gs1Registry,\n  schemaRegistry,\n  communityExtRegistry,\n];\n\n/**\n * Loads all known values from the bundled JSON registry files.\n *\n * Returns a flat array of KnownValue instances parsed from all\n * bundled registry files. The caller is responsible for inserting\n * them into a KnownValuesStore (later entries override earlier ones\n * when codepoints match).\n */\nexport function loadBundledRegistries(): KnownValue[] {\n  const values: KnownValue[] = [];\n  for (const registry of ALL_REGISTRIES) {\n    for (const entry of registry.entries) {\n      values.push(new KnownValue(entry.codepoint, entry.name));\n    }\n  }\n  return values;\n}\n","/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n */\n\nimport { KnownValue } from \"./known-value\";\nimport { loadBundledRegistries } from \"./bundled-registries\";\nimport { KnownValuesStore } from \"./known-values-store\";\n\n// For definitions see: https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-002-known-value.md#appendix-a-registry\n\n// =============================================================================\n// Raw Value Constants (_RAW)\n// =============================================================================\n// These constants provide direct access to the raw numeric values for pattern\n// matching scenarios. They mirror the Rust implementation which creates both\n// XXX_RAW and XXX constants for each known value.\n\n// General\nexport const UNIT_RAW = 0n;\nexport const IS_A_RAW = 1n;\nexport const ID_RAW = 2n;\nexport const SIGNED_RAW = 3n;\nexport const NOTE_RAW = 4n;\nexport const HAS_RECIPIENT_RAW = 5n;\nexport const SSKR_SHARE_RAW = 6n;\nexport const CONTROLLER_RAW = 7n;\nexport const KEY_RAW = 8n;\nexport const DEREFERENCE_VIA_RAW = 9n;\nexport const ENTITY_RAW = 10n;\nexport const NAME_RAW = 11n;\nexport const LANGUAGE_RAW = 12n;\nexport const ISSUER_RAW = 13n;\nexport const HOLDER_RAW = 14n;\nexport const SALT_RAW = 15n;\nexport const DATE_RAW = 16n;\nexport const UNKNOWN_VALUE_RAW = 17n;\nexport const VERSION_VALUE_RAW = 18n;\nexport const HAS_SECRET_RAW = 19n;\nexport const DIFF_EDITS_RAW = 20n;\nexport const VALID_FROM_RAW = 21n;\nexport const VALID_UNTIL_RAW = 22n;\nexport const POSITION_RAW = 23n;\nexport const NICKNAME_RAW = 24n;\nexport const VALUE_RAW = 25n;\nexport const ATTESTATION_RAW = 26n;\nexport const VERIFIABLE_AT_RAW = 27n;\n\n// Attachments\nexport const ATTACHMENT_RAW = 50n;\nexport const VENDOR_RAW = 51n;\nexport const CONFORMS_TO_RAW = 52n;\n\n// XID Documents\nexport const ALLOW_RAW = 60n;\nexport const DENY_RAW = 61n;\nexport const ENDPOINT_RAW = 62n;\nexport const DELEGATE_RAW = 63n;\nexport const PROVENANCE_RAW = 64n;\nexport const PRIVATE_KEY_RAW = 65n;\nexport const SERVICE_RAW = 66n;\nexport const CAPABILITY_RAW = 67n;\nexport const PROVENANCE_GENERATOR_RAW = 68n;\n\n// XID Privileges\nexport const PRIVILEGE_ALL_RAW = 70n;\nexport const PRIVILEGE_AUTH_RAW = 71n;\nexport const PRIVILEGE_SIGN_RAW = 72n;\nexport const PRIVILEGE_ENCRYPT_RAW = 73n;\nexport const PRIVILEGE_ELIDE_RAW = 74n;\nexport const PRIVILEGE_ISSUE_RAW = 75n;\nexport const PRIVILEGE_ACCESS_RAW = 76n;\nexport const PRIVILEGE_DELEGATE_RAW = 80n;\nexport const PRIVILEGE_VERIFY_RAW = 81n;\nexport const PRIVILEGE_UPDATE_RAW = 82n;\nexport const PRIVILEGE_TRANSFER_RAW = 83n;\nexport const PRIVILEGE_ELECT_RAW = 84n;\nexport const PRIVILEGE_BURN_RAW = 85n;\nexport const PRIVILEGE_REVOKE_RAW = 86n;\n\n// Expression and Function Calls\nexport const BODY_RAW = 100n;\nexport const RESULT_RAW = 101n;\nexport const ERROR_RAW = 102n;\nexport const OK_VALUE_RAW = 103n;\nexport const PROCESSING_VALUE_RAW = 104n;\nexport const SENDER_RAW = 105n;\nexport const SENDER_CONTINUATION_RAW = 106n;\nexport const RECIPIENT_CONTINUATION_RAW = 107n;\nexport const CONTENT_RAW = 108n;\n\n// Cryptography\nexport const SEED_TYPE_RAW = 200n;\nexport const PRIVATE_KEY_TYPE_RAW = 201n;\nexport const PUBLIC_KEY_TYPE_RAW = 202n;\nexport const MASTER_KEY_TYPE_RAW = 203n;\n\n// Cryptocurrency Assets\nexport const ASSET_RAW = 300n;\nexport const BITCOIN_VALUE_RAW = 301n;\nexport const ETHEREUM_VALUE_RAW = 302n;\nexport const TEZOS_VALUE_RAW = 303n;\n\n// Cryptocurrency Networks\nexport const NETWORK_RAW = 400n;\nexport const MAIN_NET_VALUE_RAW = 401n;\nexport const TEST_NET_VALUE_RAW = 402n;\n\n// Bitcoin\nexport const BIP32_KEY_TYPE_RAW = 500n;\nexport const CHAIN_CODE_RAW = 501n;\nexport const DERIVATION_PATH_TYPE_RAW = 502n;\nexport const PARENT_PATH_RAW = 503n;\nexport const CHILDREN_PATH_RAW = 504n;\nexport const PARENT_FINGERPRINT_RAW = 505n;\nexport const PSBT_TYPE_RAW = 506n;\nexport const OUTPUT_DESCRIPTOR_TYPE_RAW = 507n;\nexport const OUTPUT_DESCRIPTOR_RAW = 508n;\n\n// Graphs\nexport const GRAPH_RAW = 600n;\nexport const SOURCE_TARGET_GRAPH_RAW = 601n;\nexport const PARENT_CHILD_GRAPH_RAW = 602n;\nexport const DIGRAPH_RAW = 603n;\nexport const ACYCLIC_GRAPH_RAW = 604n;\nexport const MULTIGRAPH_RAW = 605n;\nexport const PSEUDOGRAPH_RAW = 606n;\nexport const GRAPH_FRAGMENT_RAW = 607n;\nexport const DAG_RAW = 608n;\nexport const TREE_RAW = 609n;\nexport const FOREST_RAW = 610n;\nexport const COMPOUND_GRAPH_RAW = 611n;\nexport const HYPERGRAPH_RAW = 612n;\nexport const DIHYPERGRAPH_RAW = 613n;\nexport const NODE_RAW = 700n;\nexport const EDGE_RAW = 701n;\nexport const SOURCE_RAW = 702n;\nexport const TARGET_RAW = 703n;\nexport const PARENT_RAW = 704n;\nexport const CHILD_RAW = 705n;\n\n// =============================================================================\n// KnownValue Constants\n// =============================================================================\n\n//\n// General\n//\n\nexport const UNIT = new KnownValue(0, \"\");\nexport const IS_A = new KnownValue(1, \"isA\");\nexport const ID = new KnownValue(2, \"id\");\nexport const SIGNED = new KnownValue(3, \"signed\");\nexport const NOTE = new KnownValue(4, \"note\");\nexport const HAS_RECIPIENT = new KnownValue(5, \"hasRecipient\");\nexport const SSKR_SHARE = new KnownValue(6, \"sskrShare\");\nexport const CONTROLLER = new KnownValue(7, \"controller\");\nexport const KEY = new KnownValue(8, \"key\");\nexport const DEREFERENCE_VIA = new KnownValue(9, \"dereferenceVia\");\nexport const ENTITY = new KnownValue(10, \"entity\");\nexport const NAME = new KnownValue(11, \"name\");\nexport const LANGUAGE = new KnownValue(12, \"language\");\nexport const ISSUER = new KnownValue(13, \"issuer\");\nexport const HOLDER = new KnownValue(14, \"holder\");\nexport const SALT = new KnownValue(15, \"salt\");\nexport const DATE = new KnownValue(16, \"date\");\nexport const UNKNOWN_VALUE = new KnownValue(17, \"Unknown\");\nexport const VERSION_VALUE = new KnownValue(18, \"version\");\nexport const HAS_SECRET = new KnownValue(19, \"hasSecret\");\nexport const DIFF_EDITS = new KnownValue(20, \"edits\");\nexport const VALID_FROM = new KnownValue(21, \"validFrom\");\nexport const VALID_UNTIL = new KnownValue(22, \"validUntil\");\nexport const POSITION = new KnownValue(23, \"position\");\nexport const NICKNAME = new KnownValue(24, \"nickname\");\nexport const VALUE = new KnownValue(25, \"value\");\nexport const ATTESTATION = new KnownValue(26, \"attestation\");\nexport const VERIFIABLE_AT = new KnownValue(27, \"verifiableAt\");\n// 28-49 *unassigned*\n\n//\n// Attachments\n//\n\nexport const ATTACHMENT = new KnownValue(50, \"attachment\");\nexport const VENDOR = new KnownValue(51, \"vendor\");\nexport const CONFORMS_TO = new KnownValue(52, \"conformsTo\");\n// 53-59 *unassigned*\n\n//\n// XID Documents\n//\n\nexport const ALLOW = new KnownValue(60, \"allow\");\nexport const DENY = new KnownValue(61, \"deny\");\nexport const ENDPOINT = new KnownValue(62, \"endpoint\");\nexport const DELEGATE = new KnownValue(63, \"delegate\");\nexport const PROVENANCE = new KnownValue(64, \"provenance\");\nexport const PRIVATE_KEY = new KnownValue(65, \"privateKey\");\nexport const SERVICE = new KnownValue(66, \"service\");\nexport const CAPABILITY = new KnownValue(67, \"capability\");\nexport const PROVENANCE_GENERATOR = new KnownValue(68, \"provenanceGenerator\");\n// 68-69 *unassigned*\n\n//\n// XID Privileges\n//\n\nexport const PRIVILEGE_ALL = new KnownValue(70, \"All\");\nexport const PRIVILEGE_AUTH = new KnownValue(71, \"Authorize\");\nexport const PRIVILEGE_SIGN = new KnownValue(72, \"Sign\");\nexport const PRIVILEGE_ENCRYPT = new KnownValue(73, \"Encrypt\");\nexport const PRIVILEGE_ELIDE = new KnownValue(74, \"Elide\");\nexport const PRIVILEGE_ISSUE = new KnownValue(75, \"Issue\");\nexport const PRIVILEGE_ACCESS = new KnownValue(76, \"Access\");\n// 77-79 *unassigned*\nexport const PRIVILEGE_DELEGATE = new KnownValue(80, \"Delegate\");\nexport const PRIVILEGE_VERIFY = new KnownValue(81, \"Verify\");\nexport const PRIVILEGE_UPDATE = new KnownValue(82, \"Update\");\nexport const PRIVILEGE_TRANSFER = new KnownValue(83, \"Transfer\");\nexport const PRIVILEGE_ELECT = new KnownValue(84, \"Elect\");\nexport const PRIVILEGE_BURN = new KnownValue(85, \"Burn\");\nexport const PRIVILEGE_REVOKE = new KnownValue(86, \"Revoke\");\n// 87-99 *unassigned*\n\n//\n// Expression and Function Calls\n//\n\nexport const BODY = new KnownValue(100, \"body\");\nexport const RESULT = new KnownValue(101, \"result\");\nexport const ERROR = new KnownValue(102, \"error\");\nexport const OK_VALUE = new KnownValue(103, \"OK\");\nexport const PROCESSING_VALUE = new KnownValue(104, \"Processing\");\nexport const SENDER = new KnownValue(105, \"sender\");\nexport const SENDER_CONTINUATION = new KnownValue(106, \"senderContinuation\");\nexport const RECIPIENT_CONTINUATION = new KnownValue(107, \"recipientContinuation\");\nexport const CONTENT = new KnownValue(108, \"content\");\n// 109-199 *unassigned*\n\n//\n// Cryptography\n//\n\nexport const SEED_TYPE = new KnownValue(200, \"Seed\");\nexport const PRIVATE_KEY_TYPE = new KnownValue(201, \"PrivateKey\");\nexport const PUBLIC_KEY_TYPE = new KnownValue(202, \"PublicKey\");\nexport const MASTER_KEY_TYPE = new KnownValue(203, \"MasterKey\");\n// 204-299 *unassigned*\n\n//\n// Cryptocurrency Assets\n//\n\nexport const ASSET = new KnownValue(300, \"asset\");\nexport const BITCOIN_VALUE = new KnownValue(301, \"Bitcoin\");\nexport const ETHEREUM_VALUE = new KnownValue(302, \"Ethereum\");\nexport const TEZOS_VALUE = new KnownValue(303, \"Tezos\");\n// 304-399 *unassigned*\n\n//\n// Cryptocurrency Networks\n//\n\nexport const NETWORK = new KnownValue(400, \"network\");\nexport const MAIN_NET_VALUE = new KnownValue(401, \"MainNet\");\nexport const TEST_NET_VALUE = new KnownValue(402, \"TestNet\");\n// 403-499 *unassigned*\n\n//\n// Bitcoin\n//\n\nexport const BIP32_KEY_TYPE = new KnownValue(500, \"BIP32Key\");\nexport const CHAIN_CODE = new KnownValue(501, \"chainCode\");\nexport const DERIVATION_PATH_TYPE = new KnownValue(502, \"DerivationPath\");\nexport const PARENT_PATH = new KnownValue(503, \"parentPath\");\nexport const CHILDREN_PATH = new KnownValue(504, \"childrenPath\");\nexport const PARENT_FINGERPRINT = new KnownValue(505, \"parentFingerprint\");\nexport const PSBT_TYPE = new KnownValue(506, \"PSBT\");\nexport const OUTPUT_DESCRIPTOR_TYPE = new KnownValue(507, \"OutputDescriptor\");\nexport const OUTPUT_DESCRIPTOR = new KnownValue(508, \"outputDescriptor\");\n// 509-599 *unassigned*\n\n//\n// Graphs\n//\n\nexport const GRAPH = new KnownValue(600, \"Graph\");\nexport const SOURCE_TARGET_GRAPH = new KnownValue(601, \"SourceTargetGraph\");\nexport const PARENT_CHILD_GRAPH = new KnownValue(602, \"ParentChildGraph\");\nexport const DIGRAPH = new KnownValue(603, \"Digraph\");\nexport const ACYCLIC_GRAPH = new KnownValue(604, \"AcyclicGraph\");\nexport const MULTIGRAPH = new KnownValue(605, \"Multigraph\");\nexport const PSEUDOGRAPH = new KnownValue(606, \"Pseudograph\");\nexport const GRAPH_FRAGMENT = new KnownValue(607, \"GraphFragment\");\nexport const DAG = new KnownValue(608, \"DAG\");\nexport const TREE = new KnownValue(609, \"Tree\");\nexport const FOREST = new KnownValue(610, \"Forest\");\nexport const COMPOUND_GRAPH = new KnownValue(611, \"CompoundGraph\");\nexport const HYPERGRAPH = new KnownValue(612, \"Hypergraph\");\nexport const DIHYPERGRAPH = new KnownValue(613, \"Dihypergraph\");\n// 614-699 *unassigned*\nexport const NODE = new KnownValue(700, \"node\");\nexport const EDGE = new KnownValue(701, \"edge\");\nexport const SOURCE = new KnownValue(702, \"source\");\nexport const TARGET = new KnownValue(703, \"target\");\nexport const PARENT = new KnownValue(704, \"parent\");\nexport const CHILD = new KnownValue(705, \"child\");\nexport const SELF_RAW = 706n;\nexport const SELF = new KnownValue(706, \"Self\");\n// 707-... *unassigned*\n\n/**\n * A lazily initialized singleton that holds the global registry of known\n * values.\n *\n * This class provides thread-safe, lazy initialization of the global\n * KnownValuesStore that contains all the predefined Known Values in the\n * registry. The store is created only when first accessed, and subsequent\n * accesses reuse the same instance.\n *\n * This is used internally by the crate and should not typically be needed by\n * users of the API, who should access Known Values through the constants\n * exposed in the `known_values` module.\n */\nexport class LazyKnownValues {\n  private _data: KnownValuesStore | undefined;\n\n  /**\n   * Gets the global KnownValuesStore, initializing it if necessary.\n   *\n   * This method guarantees that initialization occurs exactly once.\n   */\n  get(): KnownValuesStore {\n    if (this._data === undefined) {\n      const store = new KnownValuesStore([\n        UNIT,\n        IS_A,\n        ID,\n        SIGNED,\n        NOTE,\n        HAS_RECIPIENT,\n        SSKR_SHARE,\n        CONTROLLER,\n        KEY,\n        DEREFERENCE_VIA,\n        ENTITY,\n        NAME,\n        LANGUAGE,\n        ISSUER,\n        HOLDER,\n        SALT,\n        DATE,\n        UNKNOWN_VALUE,\n        VERSION_VALUE,\n        HAS_SECRET,\n        DIFF_EDITS,\n        VALID_FROM,\n        VALID_UNTIL,\n        POSITION,\n        NICKNAME,\n        VALUE,\n        ATTESTATION,\n        VERIFIABLE_AT,\n        ATTACHMENT,\n        VENDOR,\n        CONFORMS_TO,\n        ALLOW,\n        DENY,\n        ENDPOINT,\n        DELEGATE,\n        PROVENANCE,\n        PRIVATE_KEY,\n        SERVICE,\n        CAPABILITY,\n        PROVENANCE_GENERATOR,\n        PRIVILEGE_ALL,\n        PRIVILEGE_AUTH,\n        PRIVILEGE_SIGN,\n        PRIVILEGE_ENCRYPT,\n        PRIVILEGE_ELIDE,\n        PRIVILEGE_ISSUE,\n        PRIVILEGE_ACCESS,\n        PRIVILEGE_DELEGATE,\n        PRIVILEGE_VERIFY,\n        PRIVILEGE_UPDATE,\n        PRIVILEGE_TRANSFER,\n        PRIVILEGE_ELECT,\n        PRIVILEGE_BURN,\n        PRIVILEGE_REVOKE,\n        BODY,\n        RESULT,\n        ERROR,\n        OK_VALUE,\n        PROCESSING_VALUE,\n        SENDER,\n        SENDER_CONTINUATION,\n        RECIPIENT_CONTINUATION,\n        CONTENT,\n        SEED_TYPE,\n        PRIVATE_KEY_TYPE,\n        PUBLIC_KEY_TYPE,\n        MASTER_KEY_TYPE,\n        ASSET,\n        BITCOIN_VALUE,\n        ETHEREUM_VALUE,\n        TEZOS_VALUE,\n        NETWORK,\n        MAIN_NET_VALUE,\n        TEST_NET_VALUE,\n        BIP32_KEY_TYPE,\n        CHAIN_CODE,\n        DERIVATION_PATH_TYPE,\n        PARENT_PATH,\n        CHILDREN_PATH,\n        PARENT_FINGERPRINT,\n        PSBT_TYPE,\n        OUTPUT_DESCRIPTOR_TYPE,\n        OUTPUT_DESCRIPTOR,\n        GRAPH,\n        SOURCE_TARGET_GRAPH,\n        PARENT_CHILD_GRAPH,\n        DIGRAPH,\n        ACYCLIC_GRAPH,\n        MULTIGRAPH,\n        PSEUDOGRAPH,\n        GRAPH_FRAGMENT,\n        DAG,\n        TREE,\n        FOREST,\n        COMPOUND_GRAPH,\n        HYPERGRAPH,\n        DIHYPERGRAPH,\n        NODE,\n        EDGE,\n        SOURCE,\n        TARGET,\n        PARENT,\n        CHILD,\n      ]);\n\n      // Load bundled registry values from JSON data files.\n      // These are embedded at build time and available in all environments.\n      // Matching Rust behavior: later inserts overwrite earlier ones.\n      for (const value of loadBundledRegistries()) {\n        store.insert(value);\n      }\n\n      this._data = store;\n    }\n    return this._data;\n  }\n}\n\n/**\n * The global registry of Known Values.\n *\n * This static instance provides access to all standard Known Values defined in\n * the registry specification. It is lazily initialized on first access.\n *\n * Most users should not need to interact with this directly, as the predefined\n * Known Values are exposed as constants in the `known_values` module.\n *\n * @example\n * ```typescript\n * import { KNOWN_VALUES } from '@bcts/known-values';\n *\n * // Access the global store\n * const knownValues = KNOWN_VALUES.get();\n *\n * // Look up a Known Value by name\n * const isA = knownValues.knownValueNamed('isA');\n * console.log(isA?.value()); // 1\n * ```\n */\nexport const KNOWN_VALUES = new LazyKnownValues();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,MAAa,kBAAkBA,iBAAAA,YAAY;;;;;AAM3C,MAAa,kBAAuBA,iBAAAA;AAQpC,IAAa,aAAb,MAAa,WAEb;CACE;CACA;;;;;;;;;;;;;;;;;;;CAoBA,YAAY,OAAwB,cAAuB;EACzD,KAAK,SAAS,OAAO,UAAU,WAAW,QAAQ,OAAO,KAAK;EAC9D,KAAK,gBAAgB;CACvB;;;;;;;;;;;;;;;CAoBA,QAAgB;EACd,IAAI,KAAK,SAAS,OAAO,OAAO,gBAAgB,GAC9C,MAAM,IAAI,WACR,cAAc,KAAK,OAAO,sDAC5B;EAEF,OAAO,OAAO,KAAK,MAAM;CAC3B;;;;;;;;;;;;CAaA,cAAsB;EACpB,OAAO,KAAK;CACd;;;;;;;;;;;;;CAcA,eAAmC;EACjC,OAAO,KAAK;CACd;;;;;;;;;;;;;;;;CAiBA,OAAe;EACb,OAAO,KAAK,iBAAiB,KAAK,OAAO,SAAS;CACpD;;;;;;;;;;;;;;;CAoBA,OAAO,OAA4B;EACjC,OAAO,KAAK,WAAW,MAAM;CAC/B;;;;;CAMA,WAAmB;EAEjB,OAAO,OAAO,KAAK,SAAS,OAAO,UAAU,CAAC;CAChD;;;;;;;;;;;;;;;;;;;CAwBA,SAAiB;EACf,OAAOC,iBAAAA,OAAO,UAAU,KAAK,WAAW,CAAC;CAC3C;;;;;;;CAQA,WAAmB;EACjB,OAAO,KAAK,KAAK;CACnB;;;;;;;;CAaA,WAAkB;EAChB,OAAO,CAAC,eAAe;CACzB;;;;;;;;CASA,eAAqB;EACnB,QAAA,GAAA,YAAA,KAAA,CAAY,KAAK,MAAM;CACzB;;;;;;;;;;;;;;;CAgBA,aAAmB;EACjB,QAAA,GAAA,YAAA,KAAA,CAAY;GACV,KAAK;GACL,OAAO,KAAK;EACd,CAAC;CACH;;;;;;;;;;;;;CAcA,aAAyB;EACvB,QAAA,GAAA,YAAA,SAAA,CAAgB,KAAK,WAAW,CAAC;CACnC;;;;CAKA,iBAA6B;EAC3B,OAAO,KAAK,WAAW;CACzB;;;;;;;;;CAcA,iBAAiB,WAA6B;EAC5C,OAAO,WAAW,iBAAiB,SAAS;CAC9C;;;;;;;;;CAUA,eAAe,WAA6B;EAC1C,OAAO,WAAW,eAAe,SAAS;CAC5C;;;;;;;;;;;;;;;CAoBA,OAAO,iBAAiB,WAA6B;EACnD,IAAI,UAAU,SAASC,YAAAA,UAAU,UAC/B,MAAM,IAAI,MAAM,4DAA4D,UAAU,MAAM;EAE9F,MAAM,WAAW,UAAU;EAC3B,OAAO,IAAI,WAAW,OAAO,aAAa,WAAW,WAAW,OAAO,QAAQ,CAAC;CAClF;;;;;;;;;;;;;CAcA,OAAO,eAAe,WAA6B;EACjD,IAAI,UAAU,SAASA,YAAAA,UAAU,QAC/B,MAAM,IAAI,MAAM,uDAAuD,UAAU,MAAM;EAGzF,MAAM,MAAM,UAAU;EACtB,IAAI,QAAQ,OAAO,eAAe,KAAK,QAAQ,iBAC7C,MAAM,IAAI,MAAM,gBAAgB,gBAAgB,uBAAuB,KAAK;EAG9E,OAAO,WAAW,iBAAiB,UAAU,KAAK;CACpD;;;;;;;;;;;;;;;CAgBA,OAAO,aAAa,MAA8B;EAChD,MAAM,aAAA,GAAA,YAAA,WAAA,CAAuB,IAAI;EACjC,OAAO,WAAW,eAAe,SAAS;CAC5C;;;;;;;;;;;;;;;;CAiBA,OAAO,SAAS,WAA6B;EAC3C,IAAI,UAAU,SAASA,YAAAA,UAAU,QAC/B,OAAO,WAAW,eAAe,SAAS;EAE5C,OAAO,WAAW,iBAAiB,SAAS;CAC9C;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5ZA,IAAa,mBAAb,MAAa,iBAAiB;CAE5B;CACA;;;;;;;;;;;;;;;;;;;;;;CAuBA,YAAY,cAAoC,CAAC,GAAG;EAClD,KAAK,wCAAwB,IAAI,IAAI;EACrC,KAAK,4CAA4B,IAAI,IAAI;EAEzC,KAAK,MAAM,cAAc,aACvB,KAAK,QAAQ,UAAU;CAE3B;;;;;;;;;;;;;;;;;;;CAoBA,OAAO,YAA8B;EACnC,KAAK,QAAQ,UAAU;CACzB;;;;;;;;;;;;;;;;CAiBA,aAAa,YAA4C;EACvD,OAAO,KAAK,sBAAsB,IAAI,WAAW,YAAY,CAAC,CAAC,EAAE,aAAa;CAChF;;;;;;;;;;;;;;;;;;;;CAqBA,KAAK,YAAgC;EAEnC,OADqB,KAAK,aAAa,UACrB,KAAK,WAAW,KAAK;CACzC;;;;;;;;;;;;;;;;;;;;;;CAuBA,gBAAgB,cAA8C;EAC5D,OAAO,KAAK,0BAA0B,IAAI,YAAY;CACxD;;;;;;;;;;;;;;;;CAiBA,mBAAmB,UAAmD;EACpE,MAAM,MAAM,OAAO,aAAa,WAAW,WAAW,OAAO,QAAQ;EACrE,OAAO,KAAK,sBAAsB,IAAI,GAAG;CAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCA,OAAO,sBACL,UACA,aACY;EACZ,IAAI,gBAAgB,KAAA,GAAW;GAC7B,MAAM,QAAQ,YAAY,mBAAmB,QAAQ;GACrD,IAAI,UAAU,KAAA,GACZ,OAAO;EAEX;EACA,OAAO,IAAI,WAAW,QAAQ;CAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BA,OAAO,kBAAkB,MAAc,aAAwD;EAC7F,OAAO,aAAa,gBAAgB,IAAI;CAC1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCA,OAAO,kBAAkB,YAAwB,aAAwC;EACvF,IAAI,gBAAgB,KAAA,GAAW;GAC7B,MAAM,eAAe,YAAY,aAAa,UAAU;GACxD,IAAI,iBAAiB,KAAA,KAAa,iBAAiB,IACjD,OAAO;EAEX;EACA,OAAO,WAAW,KAAK;CACzB;;;;;;CAOA,QAA0B;EACxB,MAAM,SAAS,IAAI,iBAAiB;EACpC,OAAO,wBAAwB,IAAI,IAAI,KAAK,qBAAqB;EACjE,OAAO,4BAA4B,IAAI,IAAI,KAAK,yBAAyB;EACzE,OAAO;CACT;;;;CAKA,QAAgB,YAA8B;EAG5C,MAAM,WAAW,KAAK,sBAAsB,IAAI,WAAW,YAAY,CAAC;EACxE,IAAI,aAAa,KAAA,GAAW;GAC1B,MAAM,UAAU,SAAS,aAAa;GACtC,IAAI,YAAY,KAAA,KAAa,YAAY,IACvC,KAAK,0BAA0B,OAAO,OAAO;EAEjD;EAEA,KAAK,sBAAsB,IAAI,WAAW,YAAY,GAAG,UAAU;EACnE,MAAM,eAAe,WAAW,aAAa;EAC7C,IAAI,iBAAiB,KAAA,KAAa,iBAAiB,IACjD,KAAK,0BAA0B,IAAI,cAAc,UAAU;CAE/D;AACF;;;;;;;;;;;;;;;;;;AejRA,MAAM,iBAAiC;CACrCC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAAA;CACAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;GACF,CAAC;GAKD,KAAK,MAAM,SAAS,sBAAsB,GACxC,MAAM,OAAO,KAAK;GAGpB,KAAK,QAAQ;EACf;EACA,OAAO,KAAK;CACd;AACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,eAAe,IAAI,gBAAgB"}