@cbortech/cbor 0.23.0 → 0.24.0

package/README.ja.md

@@ -2,8 +2,8 @@
 
 [CBOR](#準拠している仕様)、[CBOR-EDN](#準拠している仕様)、JavaScript 値を相互変換するための TypeScript ライブラリです。
 
-このパッケージは、現時点では `CBOR` ファサードを中心にした小さな公開 API だけを提供します。
-低レベルのパーサー、エンコーダー、AST クラスは、まだドキュメント上の公開 API には含めていません。
+このパッケージは `CBOR` ファサードに加えて、extension の実装に必要な CBOR AST ノードクラス用の entrypoint を公開します。
+低レベルのパーサー、エンコーダー内部は、ドキュメント上の公開 API には含めていません。
 
 ## インストール
 
@@ -57,7 +57,9 @@ console.log(value);
 ```ts
 import { CBOR } from '@cbortech/cbor';
 
-const text = CBOR.cborToCborEdn(new Uint8Array([0x83, 0x01, 0x02, 0x03]));
+const text = CBOR.fromCBOR(
+  new Uint8Array([0x83, 0x01, 0x02, 0x03])
+).toEDN();
 
 console.log(text);
 // [1,2,3]
@@ -68,7 +70,7 @@ console.log(text);
 ```ts
 import { CBOR } from '@cbortech/cbor';
 
-const bytes = CBOR.cborEdnToCbor('[1, 2, 3]');
+const bytes = CBOR.fromEDN('[1, 2, 3]').toCBOR();
 
 console.log(bytes);
 // Uint8Array([0x83, 0x01, 0x02, 0x03])
@@ -175,12 +177,15 @@ console.log(text);
 ## AST を扱う
 
 `CBOR.fromCBOR()`、`CBOR.fromEDN()`、`CBOR.fromJS()` は CBOR item を返します。
-具体的なノードクラスはまだ公開 API としてドキュメント化していませんが、すべての item は次のメソッドを持ちます。
+`CborTextString`、`CborByteString`、`CborArray`、`CborTag` などの具体的なノードクラスは、
+extension 向けに `@cbortech/cbor/ast` から export されています。すべての item は次のメソッドを持ちます。
 
 ```ts
 import { CBOR } from '@cbortech/cbor';
+import { CborItem } from '@cbortech/cbor/ast';
 
 const item = CBOR.fromEDN('{ "x": 1 }');
+item satisfies CborItem;
 
 const bytes = item.toCBOR();
 const text = item.toEDN();
@@ -321,6 +326,41 @@ console.log(text);
 // DT'2026-05-06T00:00:00Z'
 ```
 
+## オプション extension
+
+追加の application extension は別パッケージとして公開されています。必要なものを
+インストールし、`extensions` オプションに渡して使います。
+
+`hash` は CBOR-EDN の仕様に含まれる application extension ですが、利用には
+外部パッケージが必要です。そのため、このパッケージ本体には含めず、
+`@cbortech/hash-extension` として提供しています。
+
+`uuid` は CBOR-EDN の仕様には定められていない、このライブラリ独自の
+application extension です。仕様上の標準機能と区別するため、
+`@cbortech/uuid-extension` として別パッケージで提供しています。
+
+```bash
+npm install @cbortech/hash-extension @cbortech/uuid-extension
+```
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+import hashExtension from '@cbortech/hash-extension';
+import uuidExtension from '@cbortech/uuid-extension';
+
+const cbor = new CBOR({
+  extensions: [hashExtension, uuidExtension],
+});
+
+const digest = cbor.fromEDN("hash'foo'");
+console.log(digest.toEDN());
+// hash'foo'
+
+const id = cbor.fromEDN("uuid'550e8400-e29b-41d4-a716-446655440000'");
+console.log(id.toEDN());
+// uuid'550e8400-e29b-41d4-a716-446655440000'
+```
+
 ## タグ
 
 JavaScript 上で CBOR のタグ付き値を扱うには `CBOR.Tag` を使います。
@@ -347,6 +387,18 @@ console.log(CBOR.Tag.getValue(value));
 // "hello"
 ```
 
+タグ情報が不要で、中身だけを通常の JavaScript 値として扱いたい場合は
+`stripTags: true` を指定できます。
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+const value = CBOR.parse('42("hello")', { stripTags: true });
+
+console.log(value);
+// "hello"
+```
+
 ## Simple 値
 
 `false`、`true`、`null`、`undefined` 以外の CBOR simple value には `CBOR.Simple` を使います。
@@ -460,7 +512,7 @@ console.log(item.toEDN());
 このライブラリは次の仕様を対象にしています。
 
 - [CBOR, RFC 8949](https://www.rfc-editor.org/rfc/rfc8949)
-- [CBOR Extended Diagnostic Notation (CBOR-EDN), draft-ietf-cbor-edn-literals-23](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-literals/23/)
+- [CBOR Extended Diagnostic Notation (CBOR-EDN), draft-ietf-cbor-edn-literals-24](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-literals/24/)
 
 CBOR-EDN は、CBOR データを人間が読み書きしやすいテキストとして表現するための記法です。
 サンプル、テストベクター、デバッグ、fixture、設定ファイルに近い用途など、CBOR のバイト列をそのまま扱うと読みにくい場面で役立ちます。

package/README.md

@@ -3,9 +3,9 @@
 TypeScript library for converting between [CBOR](#specifications),
 [CBOR-EDN](#specifications), and JavaScript values.
 
-This package currently exposes a small public API centered on the `CBOR` facade.
-Lower-level parser, encoder, and AST classes are intentionally not part of the
-documented public API yet.
+This package exposes the `CBOR` facade plus a separate AST entrypoint for the
+CBOR node classes needed by extensions. Lower-level parser and encoder internals
+are not part of the documented public API.
 
 ## Install
 
@@ -59,7 +59,9 @@ console.log(value);
 ```ts
 import { CBOR } from '@cbortech/cbor';
 
-const text = CBOR.cborToCborEdn(new Uint8Array([0x83, 0x01, 0x02, 0x03]));
+const text = CBOR.fromCBOR(
+  new Uint8Array([0x83, 0x01, 0x02, 0x03])
+).toEDN();
 
 console.log(text);
 // [1,2,3]
@@ -70,7 +72,7 @@ console.log(text);
 ```ts
 import { CBOR } from '@cbortech/cbor';
 
-const bytes = CBOR.cborEdnToCbor('[1, 2, 3]');
+const bytes = CBOR.fromEDN('[1, 2, 3]').toCBOR();
 
 console.log(bytes);
 // Uint8Array([0x83, 0x01, 0x02, 0x03])
@@ -177,13 +179,16 @@ console.log(text);
 ## Working With The AST
 
 `CBOR.fromCBOR()`, `CBOR.fromEDN()`, and `CBOR.fromJS()` return a CBOR item.
-The concrete node classes are not documented as public API yet, but every item
+Concrete node classes such as `CborTextString`, `CborByteString`, `CborArray`,
+and `CborTag` are exported from `@cbortech/cbor/ast` for extensions. Every item
 supports these methods:
 
 ```ts
 import { CBOR } from '@cbortech/cbor';
+import { CborItem } from '@cbortech/cbor/ast';
 
 const item = CBOR.fromEDN('{ "x": 1 }');
+item satisfies CborItem;
 
 const bytes = item.toCBOR();
 const text = item.toEDN();
@@ -325,6 +330,41 @@ console.log(text);
 // DT'2026-05-06T00:00:00Z'
 ```
 
+## Optional Extensions
+
+Additional application extensions are published as separate packages. Install
+the ones you need and pass them through the `extensions` option.
+
+`hash` is an application extension defined by the CBOR-EDN specification, but
+it requires an external package. For that reason, it is not bundled with this
+package and is provided separately as `@cbortech/hash-extension`.
+
+`uuid` is a library-specific application extension that is not defined by the
+CBOR-EDN specification. To keep it distinct from standard CBOR-EDN features, it
+is provided separately as `@cbortech/uuid-extension`.
+
+```bash
+npm install @cbortech/hash-extension @cbortech/uuid-extension
+```
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+import hashExtension from '@cbortech/hash-extension';
+import uuidExtension from '@cbortech/uuid-extension';
+
+const cbor = new CBOR({
+  extensions: [hashExtension, uuidExtension],
+});
+
+const digest = cbor.fromEDN("hash'foo'");
+console.log(digest.toEDN());
+// hash'foo'
+
+const id = cbor.fromEDN("uuid'550e8400-e29b-41d4-a716-446655440000'");
+console.log(id.toEDN());
+// uuid'550e8400-e29b-41d4-a716-446655440000'
+```
+
 ## Tags
 
 Use `CBOR.Tag` for CBOR tagged values in JavaScript.
@@ -351,6 +391,18 @@ console.log(CBOR.Tag.getValue(value));
 // "hello"
 ```
 
+Use `stripTags: true` when you only need the tagged content as a plain
+JavaScript value.
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+const value = CBOR.parse('42("hello")', { stripTags: true });
+
+console.log(value);
+// "hello"
+```
+
 ## Simple Values
 
 Use `CBOR.Simple` for CBOR simple values other than `false`, `true`, `null`, and
@@ -466,7 +518,7 @@ The `CBOR` facade also exposes:
 This library targets:
 
 - [CBOR, RFC 8949](https://www.rfc-editor.org/rfc/rfc8949)
-- [CBOR Extended Diagnostic Notation (CBOR-EDN), draft-ietf-cbor-edn-literals-23](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-literals/23/)
+- [CBOR Extended Diagnostic Notation (CBOR-EDN), draft-ietf-cbor-edn-literals-24](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-literals/24/)
 
 CBOR-EDN is a human-readable text notation for CBOR data. It is useful for
 examples, test vectors, debugging, fixtures, and configuration-like files where

package/dist/ast/CborArray.d.ts

@@ -0,0 +1,17 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem, AnnotatedLine } from './CborItem';
+import { EncodingWidth } from '../cbor/encode';
+/** CBOR Major Type 4 — array (definite- or indefinite-length). */
+export declare class CborArray extends CborItem {
+    readonly items: CborItem[];
+    readonly indefiniteLength: boolean;
+    readonly encodingWidth: EncodingWidth | undefined;
+    constructor(items: CborItem[], options?: {
+        indefiniteLength?: boolean;
+        encodingWidth?: EncodingWidth;
+    });
+    _toCBOR(options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, depth: number): string;
+    _toHexDump(depth: number, options?: ToEDNOptions): AnnotatedLine[];
+    _toJS(options?: ToJSOptions): unknown;
+}

package/dist/ast/CborBignum.d.ts

@@ -0,0 +1,36 @@
+import { ToEDNOptions, ToJSOptions } from '../types';
+import { CborTag } from './CborTag';
+export declare const BIGNUM_UINT_TAG = 2n;
+export declare const BIGNUM_NINT_TAG = 3n;
+/**
+ * Encode a non-negative bigint as a minimal big-endian byte string.
+ * Zero is encoded as the empty byte string per RFC 8949 §3.4.3.
+ */
+export declare function bigintToBytes(n: bigint): Uint8Array;
+/**
+ * Decode a big-endian byte string to a non-negative bigint.
+ * Empty bytes → 0n.
+ */
+export declare function bytesToBigint(bytes: Uint8Array): bigint;
+/**
+ * Unsigned bignum — integers ≥ 2^64.
+ * Wire format: tag(2, big-endian byte string).
+ * toEDN() emits the plain decimal integer.
+ */
+export declare class CborBigUint extends CborTag {
+    readonly bigValue: bigint;
+    constructor(value: bigint);
+    _toEDN(_options: ToEDNOptions | undefined, _depth: number): string;
+    _toJS(_options?: ToJSOptions): bigint;
+}
+/**
+ * Negative bignum — integers ≤ -(2^64 + 1).
+ * Wire format: tag(3, big-endian byte string of (-1 - value)).
+ * toEDN() emits the plain decimal integer.
+ */
+export declare class CborBigNint extends CborTag {
+    readonly bigValue: bigint;
+    constructor(value: bigint);
+    _toEDN(_options: ToEDNOptions | undefined, _depth: number): string;
+    _toJS(_options?: ToJSOptions): bigint;
+}

package/dist/ast/CborByteString.d.ts

@@ -0,0 +1,20 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem } from './CborItem';
+import { EncodingWidth } from '../cbor/encode';
+/** CBOR Major Type 2 — definite-length byte string. */
+export declare class CborByteString extends CborItem {
+    readonly indefiniteLength: false;
+    readonly value: Uint8Array;
+    /** Preferred EDN encoding for this byte string. */
+    readonly ednEncoding: 'hex' | 'base64' | 'base64url' | 'base32' | 'base32hex';
+    readonly encodingWidth: EncodingWidth | undefined;
+    readonly ednSource: string | undefined;
+    constructor(value: Uint8Array, options?: {
+        ednEncoding?: 'hex' | 'base64' | 'base64url' | 'base32' | 'base32hex';
+        encodingWidth?: EncodingWidth;
+        ednSource?: string;
+    });
+    _toCBOR(_options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, _depth: number): string;
+    _toJS(_options?: ToJSOptions): unknown;
+}

package/dist/ast/CborEllipsis.d.ts

@@ -0,0 +1,11 @@
+import { ToEDNOptions } from '../types';
+import { CborTag } from './CborTag';
+import { CborItem } from './CborItem';
+export declare const CPA888_TAG = 888n;
+export declare class CborEllipsis extends CborTag {
+    /** Subtree elision: 888(null) */
+    constructor();
+    /** String/bytes elision: 888([items...]) */
+    constructor(items: CborItem[]);
+    _toEDN(options: ToEDNOptions | undefined, depth: number): string;
+}

package/dist/ast/CborEmbeddedCBOR.d.ts

@@ -0,0 +1,22 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem, AnnotatedLine } from './CborItem';
+/**
+ * CBOR Sequence Literal (§2.5.6) — `<<item, item, ...>>`.
+ *
+ * Encodes as a definite-length byte string whose value is the concatenation
+ * of the CBOR encodings of the contained items.
+ *
+ * @example
+ * // <<1, 2>>  →  h'0102'
+ * new CborEmbeddedCBOR([new CborUint(1n), new CborUint(2n)])
+ */
+export declare class CborEmbeddedCBOR extends CborItem {
+    readonly items: CborItem[];
+    constructor(items: CborItem[]);
+    /** The raw concatenated CBOR bytes of all contained items. */
+    private _content;
+    _toCBOR(options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, depth: number): string;
+    _toHexDump(depth: number, options?: ToEDNOptions): AnnotatedLine[];
+    _toJS(_options?: ToJSOptions): unknown;
+}

package/dist/ast/CborFloat.d.ts

@@ -0,0 +1,27 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem } from './CborItem';
+export type FloatPrecision = 'half' | 'single' | 'double';
+/**
+ * CBOR Major Type 7 — IEEE 754 floating-point number.
+ *
+ * `precision` records the encoding size from the original CBOR stream so
+ * that lossless round-trips are preserved.  When constructing from a JS
+ * `number`, omit `precision` (`undefined`) and the encoder will choose
+ * the smallest encoding that preserves the value exactly.
+ */
+export declare class CborFloat extends CborItem {
+    readonly value: number;
+    /**
+     * Encoding size hint.
+     * - `'half'` / `'single'` / `'double'`: use exactly this size (set by the
+     *   decoder to guarantee lossless round-trips).
+     * - `undefined`: encoder auto-selects the smallest lossless size.
+     */
+    readonly precision: FloatPrecision | undefined;
+    constructor(value: number, options?: {
+        precision?: FloatPrecision;
+    });
+    _toCBOR(_options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, _depth: number): string;
+    _toJS(_options?: ToJSOptions): unknown;
+}

package/dist/ast/CborIndefiniteByteString.d.ts

@@ -0,0 +1,13 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem, AnnotatedLine } from './CborItem';
+import { CborByteString } from './CborByteString';
+/** CBOR Major Type 2 — indefinite-length byte string (chunked). */
+export declare class CborIndefiniteByteString extends CborItem {
+    readonly indefiniteLength: true;
+    readonly chunks: CborByteString[];
+    constructor(chunks: CborByteString[]);
+    _toCBOR(options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, _depth: number): string;
+    _toHexDump(depth: number, options?: ToEDNOptions): AnnotatedLine[];
+    _toJS(_options?: ToJSOptions): unknown;
+}

package/dist/ast/CborIndefiniteTextString.d.ts

@@ -0,0 +1,13 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem, AnnotatedLine } from './CborItem';
+import { CborTextString } from './CborTextString';
+/** CBOR Major Type 3 — indefinite-length UTF-8 text string (chunked). */
+export declare class CborIndefiniteTextString extends CborItem {
+    readonly indefiniteLength: true;
+    readonly chunks: CborTextString[];
+    constructor(chunks: CborTextString[]);
+    _toCBOR(options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, _depth: number): string;
+    _toHexDump(depth: number, options?: ToEDNOptions): AnnotatedLine[];
+    _toJS(_options?: ToJSOptions): unknown;
+}

package/dist/ast/CborItem.d.ts

@@ -0,0 +1,91 @@
+import { CBOROptions, ToEDNOptions, ToJSOptions, ToHexDumpOptions, ToCBOROptions, CborComments } from '../types';
+/** @internal One line of an annotated hex dump. */
+export interface AnnotatedLine {
+    depth: number;
+    hex: string;
+    comment: string;
+}
+/**
+ * Abstract base class for all CBOR AST nodes.
+ *
+ * Every node can serialize itself to CBOR binary, CBOR-EDN text, and a
+ * plain JavaScript value.  Concrete implementations are provided in each
+ * subclass (added in later phases).
+ */
+export declare abstract class CborItem {
+    /**
+     * Character offset of the first character of this item in the parsed source.
+     * Set by parsers; undefined when the node was constructed directly.
+     * For CBOR input this is a byte offset.
+     */
+    start?: number;
+    /**
+     * Character offset just past the last character of this item in the parsed source.
+     * Set by parsers; undefined when the node was constructed directly.
+     * For CBOR input this is a byte offset.
+     */
+    end?: number;
+    /**
+     * Comments captured from CBOR-EDN source when `preserveComments` is enabled.
+     * They do not affect CBOR bytes or JS conversion.
+     */
+    comments?: CborComments;
+    /**
+     * Default options bound by a {@link CBOR} instance factory method.
+     * Per-call options always take precedence.
+     * @internal
+     */
+    _defaults?: CBOROptions;
+    /** Serialize this node to CBOR binary. */
+    toCBOR(options?: ToCBOROptions): Uint8Array;
+    /** Serialize this node to a CBOR-EDN text string. */
+    toEDN(options?: ToEDNOptions): string;
+    /**
+     * Convert this CBOR AST node to a plain JavaScript value.
+     *
+     * If `options.reviver` is supplied it is called with key `''` on the root
+     * result after the full tree has been converted (matching the semantics of
+     * `JSON.parse`).  Container nodes call the reviver on each of their direct
+     * children during conversion, so the walk is bottom-up.
+     */
+    toJS(options?: ToJSOptions): unknown;
+    /**
+     * Generate an RFC 8949 §3 style annotated hex dump of this value.
+     *
+     * @example
+     * const cbor = CBOR.fromEDN('[_ 1, [2, 3]]');
+     * console.log(cbor.toHexDump());
+     * // 9F        -- Start indefinite-length array
+     * //    01     -- 1
+     * //    82     -- Array of length 2
+     * //       02  -- 2
+     * //       03  -- 3
+     * //    FF     -- "break"
+     * // FF        -- "break"
+     */
+    toHexDump(options?: ToHexDumpOptions): string;
+    /** @internal Subclass CBOR encoding implementation. */
+    abstract _toCBOR(options?: ToCBOROptions): Uint8Array;
+    /**
+     * @internal
+     * Depth-aware EDN serialization.
+     * Leaf nodes receive `depth` but may ignore it.
+     * Container nodes use `depth` for indentation and call
+     * `child._toEDN(options, depth + 1)` when recursing.
+     */
+    abstract _toEDN(options: ToEDNOptions | undefined, depth: number): string;
+    /**
+     * @internal
+     * Core conversion logic implemented by each subclass.
+     * Container nodes apply `options.reviver` to their direct children.
+     * Do not call this directly — use `toJS()` instead.
+     */
+    abstract _toJS(options?: ToJSOptions): unknown;
+    /**
+     * @internal
+     * Collect annotated-hex lines for this node.
+     * Leaf nodes emit a single line; container nodes override to emit
+     * open/close lines with recursively collected children.
+     */
+    _toHexDump(depth: number, options?: ToEDNOptions): AnnotatedLine[];
+}

package/dist/ast/CborMap.d.ts

@@ -0,0 +1,17 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem, AnnotatedLine } from './CborItem';
+import { EncodingWidth } from '../cbor/encode';
+/** CBOR Major Type 5 — map (definite- or indefinite-length). */
+export declare class CborMap extends CborItem {
+    readonly entries: [CborItem, CborItem][];
+    readonly indefiniteLength: boolean;
+    readonly encodingWidth: EncodingWidth | undefined;
+    constructor(entries: [CborItem, CborItem][], options?: {
+        indefiniteLength?: boolean;
+        encodingWidth?: EncodingWidth;
+    });
+    _toCBOR(options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, depth: number): string;
+    _toHexDump(depth: number, options?: ToEDNOptions): AnnotatedLine[];
+    _toJS(options?: ToJSOptions): unknown;
+}

package/dist/ast/CborNint.d.ts

@@ -0,0 +1,27 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem } from './CborItem';
+import { EncodingWidth } from '../cbor/encode';
+/**
+ * CBOR Major Type 1 — negative integer (−2^64 … −1).
+ *
+ * The constructor accepts the actual negative value (e.g. `-5n`).
+ * Internally the CBOR "argument" `n` is stored, where the decoded value
+ * equals `−1 − n`.  This matches the wire encoding directly.
+ *
+ * Examples:
+ *   new CborNint(-1n)  → argument = 0n
+ *   new CborNint(-5n)  → argument = 4n
+ */
+export declare class CborNint extends CborItem {
+    /** CBOR raw argument n, where actual value = −1 − n. */
+    readonly argument: bigint;
+    readonly encodingWidth: EncodingWidth | undefined;
+    constructor(value: number | bigint, options?: {
+        encodingWidth?: EncodingWidth;
+    });
+    /** The actual decoded negative value (−1 − argument). */
+    get value(): bigint;
+    _toCBOR(_options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, _depth: number): string;
+    _toJS(options?: ToJSOptions): unknown;
+}

package/dist/ast/CborSimple.d.ts

@@ -0,0 +1,22 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem } from './CborItem';
+/**
+ * CBOR Major Type 7 — simple value (0–255).
+ *
+ * Well-known values:
+ *   20 → false
+ *   21 → true
+ *   22 → null
+ *   23 → undefined
+ */
+export declare class CborSimple extends CborItem {
+    readonly value: number;
+    constructor(value: number);
+    static readonly FALSE: CborSimple;
+    static readonly TRUE: CborSimple;
+    static readonly NULL: CborSimple;
+    static readonly UNDEFINED: CborSimple;
+    _toCBOR(_options?: ToCBOROptions): Uint8Array;
+    _toEDN(_options: ToEDNOptions | undefined, _depth: number): string;
+    _toJS(_options?: ToJSOptions): unknown;
+}

package/dist/ast/CborTag.d.ts

@@ -0,0 +1,16 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem, AnnotatedLine } from './CborItem';
+import { EncodingWidth } from '../cbor/encode';
+/** CBOR Major Type 6 — tagged data item. */
+export declare class CborTag extends CborItem {
+    readonly tag: bigint;
+    readonly content: CborItem;
+    readonly encodingWidth: EncodingWidth | undefined;
+    constructor(tag: number | bigint, content: CborItem, options?: {
+        encodingWidth?: EncodingWidth;
+    });
+    _toCBOR(options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, depth: number): string;
+    _toHexDump(depth: number, options?: ToEDNOptions): AnnotatedLine[];
+    _toJS(options?: ToJSOptions): unknown;
+}

package/dist/ast/CborTextString.d.ts

@@ -0,0 +1,15 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem } from './CborItem';
+import { EncodingWidth } from '../cbor/encode';
+/** CBOR Major Type 3 — definite-length UTF-8 text string. */
+export declare class CborTextString extends CborItem {
+    readonly indefiniteLength: false;
+    readonly value: string;
+    readonly encodingWidth: EncodingWidth | undefined;
+    constructor(value: string, options?: {
+        encodingWidth?: EncodingWidth;
+    });
+    _toCBOR(_options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, depth: number): string;
+    _toJS(_options?: ToJSOptions): unknown;
+}

package/dist/ast/CborUint.d.ts

@@ -0,0 +1,14 @@
+import { ToEDNOptions, ToJSOptions, ToCBOROptions } from '../types';
+import { CborItem } from './CborItem';
+import { EncodingWidth } from '../cbor/encode';
+/** CBOR Major Type 0 — unsigned integer (0 … 2^64−1). */
+export declare class CborUint extends CborItem {
+    readonly value: bigint;
+    readonly encodingWidth: EncodingWidth | undefined;
+    constructor(value: number | bigint, options?: {
+        encodingWidth?: EncodingWidth;
+    });
+    _toCBOR(_options?: ToCBOROptions): Uint8Array;
+    _toEDN(options: ToEDNOptions | undefined, _depth: number): string;
+    _toJS(options?: ToJSOptions): unknown;
+}

package/dist/ast/CborUnresolvedAppExt.d.ts

@@ -0,0 +1,16 @@
+import { ToEDNOptions } from '../types';
+import { CborTag } from './CborTag';
+import { CborItem } from './CborItem';
+/** Provisional tag number for the Unresolved Application-Extension stand-in. */
+export declare const CPA999_TAG = 999n;
+/**
+ * Stand-in for an unrecognised EDN application-extension literal.
+ *
+ * Structure:
+ *   App-string:  CPA999([prefix, text])
+ *   App-sequence: CPA999([prefix, [items...]])
+ */
+export declare class CborUnresolvedAppExt extends CborTag {
+    constructor(prefix: string, items: CborItem[]);
+    _toEDN(options: ToEDNOptions | undefined, depth: number): string;
+}

package/dist/ast/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../mapEntries-bihZ3yks.cjs`);exports.CborArray=e.p,exports.CborBigNint=e.c,exports.CborBigUint=e.l,exports.CborByteString=e.g,exports.CborEmbeddedCBOR=e.u,exports.CborFloat=e.v,exports.CborIndefiniteByteString=e.h,exports.CborIndefiniteTextString=e.m,exports.CborItem=e.x,exports.CborMap=e.f,exports.CborNint=e.y,exports.CborSimple=e.d,exports.CborTag=e._,exports.CborTextString=e.o,exports.CborUint=e.b;

package/dist/ast/index.d.ts

@@ -0,0 +1,15 @@
+export { CborItem } from './CborItem';
+export { CborUint } from './CborUint';
+export { CborBigUint, CborBigNint } from './CborBignum';
+export { CborNint } from './CborNint';
+export { CborByteString } from './CborByteString';
+export { CborIndefiniteByteString } from './CborIndefiniteByteString';
+export { CborTextString } from './CborTextString';
+export { CborIndefiniteTextString } from './CborIndefiniteTextString';
+export { CborArray } from './CborArray';
+export { CborEmbeddedCBOR } from './CborEmbeddedCBOR';
+export { CborMap } from './CborMap';
+export { CborTag } from './CborTag';
+export { CborFloat } from './CborFloat';
+export type { FloatPrecision } from './CborFloat';
+export { CborSimple } from './CborSimple';

package/dist/ast/index.js

@@ -0,0 +1,2 @@
+import { _ as e, b as t, c as n, d as r, f as i, g as a, h as o, l as s, m as c, o as l, p as u, u as d, v as f, x as p, y as m } from "../mapEntries-D5MWtXqq.js";
+export { u as CborArray, n as CborBigNint, s as CborBigUint, a as CborByteString, d as CborEmbeddedCBOR, f as CborFloat, o as CborIndefiniteByteString, c as CborIndefiniteTextString, p as CborItem, i as CborMap, m as CborNint, r as CborSimple, e as CborTag, l as CborTextString, t as CborUint };