@bcts/dcbor 1.0.0-alpha.16 → 1.0.0-alpha.18

package/src/map.ts

@@ -44,14 +44,14 @@ export interface MapEntry {
  * encoded CBOR representation, ensuring deterministic encoding.
  */
 export class CborMap {
-  #dict: SortedMap<MapKey, MapEntry>;
+  private _dict: SortedMap<MapKey, MapEntry>;
 
   /**
    * Creates a new, empty CBOR Map.
    * Optionally initializes from a JavaScript Map.
    */
   constructor(map?: Map<unknown, unknown>) {
-    this.#dict = new SortedMap(null, areBytesEqual, lexicographicallyCompareBytes);
+    this._dict = new SortedMap(null, areBytesEqual, lexicographicallyCompareBytes);
 
     if (map !== undefined) {
       for (const [key, value] of map.entries()) {
@@ -76,7 +76,7 @@ export class CborMap {
     const keyCbor = cbor(key);
     const valueCbor = cbor(value);
     const keyData = cborData(keyCbor);
-    this.#dict.set(keyData, { key: keyCbor, value: valueCbor });
+    this._dict.set(keyData, { key: keyCbor, value: valueCbor });
   }
 
   /**
@@ -86,7 +86,7 @@ export class CborMap {
     this.set(key, value);
   }
 
-  #makeKey<K extends CborInput>(key: K): MapKey {
+  private _makeKey<K extends CborInput>(key: K): MapKey {
     const keyCbor = cbor(key);
     return cborData(keyCbor);
   }
@@ -97,8 +97,8 @@ export class CborMap {
    * Matches Rust's Map::get().
    */
   get<K extends CborInput, V>(key: K): V | undefined {
-    const keyData = this.#makeKey(key);
-    const value = this.#dict.get(keyData);
+    const keyData = this._makeKey(key);
+    const value = this._dict.get(keyData);
     if (value === undefined) {
       return undefined;
     }
@@ -124,24 +124,24 @@ export class CborMap {
    * Matches Rust's Map::contains_key().
    */
   containsKey<K extends CborInput>(key: K): boolean {
-    const keyData = this.#makeKey(key);
-    return this.#dict.has(keyData);
+    const keyData = this._makeKey(key);
+    return this._dict.has(keyData);
   }
 
   delete<K extends CborInput>(key: K): boolean {
-    const keyData = this.#makeKey(key);
-    const existed = this.#dict.has(keyData);
-    this.#dict.delete(keyData);
+    const keyData = this._makeKey(key);
+    const existed = this._dict.has(keyData);
+    this._dict.delete(keyData);
     return existed;
   }
 
   has<K extends CborInput>(key: K): boolean {
-    const keyData = this.#makeKey(key);
-    return this.#dict.has(keyData);
+    const keyData = this._makeKey(key);
+    return this._dict.has(keyData);
   }
 
   clear(): void {
-    this.#dict = new SortedMap(null, areBytesEqual, lexicographicallyCompareBytes);
+    this._dict = new SortedMap(null, areBytesEqual, lexicographicallyCompareBytes);
   }
 
   /**
@@ -149,7 +149,7 @@ export class CborMap {
    * Matches Rust's Map::len().
    */
   get length(): number {
-    return this.#dict.length;
+    return this._dict.length;
   }
 
   /**
@@ -157,7 +157,7 @@ export class CborMap {
    * Also matches Rust's Map::len().
    */
   get size(): number {
-    return this.#dict.length;
+    return this._dict.length;
   }
 
   /**
@@ -165,7 +165,7 @@ export class CborMap {
    * Matches Rust's Map::len().
    */
   len(): number {
-    return this.#dict.length;
+    return this._dict.length;
   }
 
   /**
@@ -173,7 +173,7 @@ export class CborMap {
    * Matches Rust's Map::is_empty().
    */
   isEmpty(): boolean {
-    return this.#dict.length === 0;
+    return this._dict.length === 0;
   }
 
   /**
@@ -181,7 +181,7 @@ export class CborMap {
    * Keys are sorted in lexicographic order of their encoded CBOR bytes.
    */
   get entriesArray(): MapEntry[] {
-    return this.#dict.map((value: MapEntry, _key: MapKey) => ({
+    return this._dict.map((value: MapEntry, _key: MapKey) => ({
       key: value.key,
       value: value.value,
     }));
@@ -213,21 +213,21 @@ export class CborMap {
    * Matches Rust's Map::insert_next().
    */
   setNext<K extends CborInput, V extends CborInput>(key: K, value: V): void {
-    const lastEntry = this.#dict.max();
+    const lastEntry = this._dict.max();
     if (lastEntry === undefined) {
       this.set(key, value);
       return;
     }
     const keyCbor = cbor(key);
     const newKey = cborData(keyCbor);
-    if (this.#dict.has(newKey)) {
+    if (this._dict.has(newKey)) {
       throw new CborError({ type: "DuplicateMapKey" });
     }
-    const lastEntryKey = this.#makeKey(lastEntry.key);
+    const lastEntryKey = this._makeKey(lastEntry.key);
     if (lexicographicallyCompareBytes(newKey, lastEntryKey) <= 0) {
       throw new CborError({ type: "MisorderedMapKey" });
     }
-    this.#dict.set(newKey, { key: keyCbor, value: cbor(value) });
+    this._dict.set(newKey, { key: keyCbor, value: cbor(value) });
   }
 
   get debug(): string {

package/src/prelude.ts

@@ -65,6 +65,9 @@ export type { HexFormatOpts } from "./dump";
 export { EdgeType } from "./walk";
 export type { WalkElement, EdgeTypeVariant, Visitor } from "./walk";
 
+// BigNum support
+export { biguintToCbor, bigintToCbor, cborToBiguint, cborToBigint } from "./bignum";
+
 // Error handling
 export type { Error, Result } from "./error";
 export { Ok, Err, errorMsg, errorToString, CborError } from "./error";

package/src/set.ts

@@ -47,10 +47,10 @@ import { CborError } from "./error";
  * ```
  */
 export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet> {
-  readonly #map: CborMap;
+  private readonly _map: CborMap;
 
   constructor() {
-    this.#map = new CborMap();
+    this._map = new CborMap();
   }
 
   // =========================================================================
@@ -127,7 +127,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
   insert(value: CborInput): void {
     const cborValue = encodeCborValue(value);
     // In a set, key and value are the same
-    this.#map.set(cborValue, cborValue);
+    this._map.set(cborValue, cborValue);
   }
 
   /**
@@ -145,7 +145,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    */
   contains(value: CborInput): boolean {
     const cborValue = encodeCborValue(value);
-    return this.#map.has(cborValue);
+    return this._map.has(cborValue);
   }
 
   /**
@@ -163,14 +163,14 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    */
   delete(value: CborInput): boolean {
     const cborValue = encodeCborValue(value);
-    return this.#map.delete(cborValue);
+    return this._map.delete(cborValue);
   }
 
   /**
    * Remove all elements from the set.
    */
   clear(): void {
-    this.#map.clear();
+    this._map.clear();
   }
 
   /**
@@ -179,7 +179,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    * @returns Number of elements
    */
   get size(): number {
-    return this.#map.size;
+    return this._map.size;
   }
 
   /**
@@ -188,7 +188,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    * @returns true if set has no elements
    */
   isEmpty(): boolean {
-    return this.#map.size === 0;
+    return this._map.size === 0;
   }
 
   // =========================================================================
@@ -313,7 +313,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    * ```
    */
   *[Symbol.iterator](): Iterator<Cbor> {
-    for (const [_, value] of this.#map) {
+    for (const [_, value] of this._map) {
       yield value;
     }
   }

package/src/tags-store.ts

@@ -89,9 +89,9 @@ export interface TagsStoreTrait {
  * Stores tags with their names and optional summarizer functions.
  */
 export class TagsStore implements TagsStoreTrait {
-  readonly #tagsByValue = new Map<string, Tag>();
-  readonly #tagsByName = new Map<string, Tag>();
-  readonly #summarizers = new Map<string, CborSummarizer>();
+  private readonly _tagsByValue = new Map<string, Tag>();
+  private readonly _tagsByName = new Map<string, Tag>();
+  private readonly _summarizers = new Map<string, CborSummarizer>();
 
   constructor() {
     // Start with empty store, matching Rust's Default implementation
@@ -123,8 +123,8 @@ export class TagsStore implements TagsStoreTrait {
       throw new Error(`Tag ${tag.value} must have a non-empty name`);
     }
 
-    const key = this.#valueKey(tag.value);
-    const existing = this.#tagsByValue.get(key);
+    const key = this._valueKey(tag.value);
+    const existing = this._tagsByValue.get(key);
 
     // Rust: if old_name != name { panic!(...) }
     if (existing?.name !== undefined && existing.name !== name) {
@@ -133,8 +133,8 @@ export class TagsStore implements TagsStoreTrait {
       );
     }
 
-    this.#tagsByValue.set(key, tag);
-    this.#tagsByName.set(name, tag);
+    this._tagsByValue.set(key, tag);
+    this._tagsByName.set(name, tag);
   }
 
   /**
@@ -173,13 +173,13 @@ export class TagsStore implements TagsStoreTrait {
    * ```
    */
   setSummarizer(tagValue: CborNumber, summarizer: CborSummarizer): void {
-    const key = this.#valueKey(tagValue);
-    this.#summarizers.set(key, summarizer);
+    const key = this._valueKey(tagValue);
+    this._summarizers.set(key, summarizer);
   }
 
   assignedNameForTag(tag: Tag): string | undefined {
-    const key = this.#valueKey(tag.value);
-    const stored = this.#tagsByValue.get(key);
+    const key = this._valueKey(tag.value);
+    const stored = this._tagsByValue.get(key);
     return stored?.name;
   }
 
@@ -188,12 +188,12 @@ export class TagsStore implements TagsStoreTrait {
   }
 
   tagForValue(value: CborNumber): Tag | undefined {
-    const key = this.#valueKey(value);
-    return this.#tagsByValue.get(key);
+    const key = this._valueKey(value);
+    return this._tagsByValue.get(key);
   }
 
   tagForName(name: string): Tag | undefined {
-    return this.#tagsByName.get(name);
+    return this._tagsByName.get(name);
   }
 
   nameForValue(value: CborNumber): string {
@@ -202,8 +202,8 @@ export class TagsStore implements TagsStoreTrait {
   }
 
   summarizer(tag: CborNumber): CborSummarizer | undefined {
-    const key = this.#valueKey(tag);
-    return this.#summarizers.get(key);
+    const key = this._valueKey(tag);
+    return this._summarizers.get(key);
   }
 
   /**
@@ -212,7 +212,7 @@ export class TagsStore implements TagsStoreTrait {
    *
    * @private
    */
-  #valueKey(value: CborNumber): string {
+  private _valueKey(value: CborNumber): string {
     return value.toString();
   }
 }

package/src/tags.ts

@@ -40,6 +40,18 @@ export const TAG_POSITIVE_BIGNUM = 2;
  */
 export const TAG_NEGATIVE_BIGNUM = 3;
 
+/**
+ * Name for tag 2 (positive bignum).
+ * Matches Rust's `TAG_NAME_POSITIVE_BIGNUM`.
+ */
+export const TAG_NAME_POSITIVE_BIGNUM = "positive-bignum";
+
+/**
+ * Name for tag 3 (negative bignum).
+ * Matches Rust's `TAG_NAME_NEGATIVE_BIGNUM`.
+ */
+export const TAG_NAME_NEGATIVE_BIGNUM = "negative-bignum";
+
 /**
  * Tag 4: Decimal fraction [exponent, mantissa]
  */
@@ -152,6 +164,7 @@ import type { TagsStore, SummarizerResult } from "./tags-store";
 import { getGlobalTagsStore } from "./tags-store";
 import { CborDate } from "./date";
 import type { Cbor } from "./cbor";
+import { biguintFromUntaggedCbor, bigintFromNegativeUntaggedCbor } from "./bignum";
 
 // Tag constants matching Rust
 export const TAG_DATE = 1;
@@ -177,6 +190,39 @@ export const registerTagsIn = (tagsStore: TagsStore): void => {
       return { ok: false, error: { type: "Custom", message } };
     }
   });
+
+  // Register bignum tags (matching Rust's #[cfg(feature = "num-bigint")] block)
+  const biguintTag = createTag(TAG_POSITIVE_BIGNUM, TAG_NAME_POSITIVE_BIGNUM);
+  const bigintTag = createTag(TAG_NEGATIVE_BIGNUM, TAG_NAME_NEGATIVE_BIGNUM);
+  tagsStore.insertAll([biguintTag, bigintTag]);
+
+  // Summarizer for tag 2 (positive bignum)
+  tagsStore.setSummarizer(
+    TAG_POSITIVE_BIGNUM,
+    (untaggedCbor: Cbor, _flat: boolean): SummarizerResult => {
+      try {
+        const value = biguintFromUntaggedCbor(untaggedCbor);
+        return { ok: true, value: `bignum(${value})` };
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { ok: false, error: { type: "Custom", message } };
+      }
+    },
+  );
+
+  // Summarizer for tag 3 (negative bignum)
+  tagsStore.setSummarizer(
+    TAG_NEGATIVE_BIGNUM,
+    (untaggedCbor: Cbor, _flat: boolean): SummarizerResult => {
+      try {
+        const value = bigintFromNegativeUntaggedCbor(untaggedCbor);
+        return { ok: true, value: `bignum(${value})` };
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { ok: false, error: { type: "Custom", message } };
+      }
+    },
+  );
 };
 
 /**