@cbortech/cbor 0.23.0 → 0.23.1

package/README.ja.md

@@ -2,8 +2,8 @@
 
 [CBOR](#準拠している仕様)、[CBOR-EDN](#準拠している仕様)、JavaScript 値を相互変換するための TypeScript ライブラリです。
 
-このパッケージは、現時点では `CBOR` ファサードを中心にした小さな公開 API だけを提供します。
-低レベルのパーサー、エンコーダー、AST クラスは、まだドキュメント上の公開 API には含めていません。
+このパッケージは `CBOR` ファサードに加えて、extension の実装に必要な CBOR AST ノードクラス用の entrypoint を公開します。
+低レベルのパーサー、エンコーダー内部は、ドキュメント上の公開 API には含めていません。
 
 ## インストール
 
@@ -175,12 +175,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();

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
 
@@ -177,13 +177,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();

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-C73nWM8o.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-CSjvgq1X.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 };

package/dist/cbor/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const MT_UINT = 0;
+export declare const MT_NINT = 1;
+export declare const MT_BYTES = 2;
+export declare const MT_TEXT = 3;
+export declare const MT_ARRAY = 4;
+export declare const MT_MAP = 5;
+export declare const MT_TAG = 6;
+export declare const MT_SIMPLE = 7;
+export declare const AI_1BYTE = 24;
+export declare const AI_2BYTE = 25;
+export declare const AI_4BYTE = 26;
+export declare const AI_8BYTE = 27;
+export declare const AI_INDEFINITE = 31;
+export declare const BREAK_CODE = 255;

package/dist/cbor/decoder.d.ts

@@ -0,0 +1,11 @@
+import { FromCBOROptions } from '../types';
+import { CborItem } from '../ast/CborItem';
+/**
+ * Decode a CBOR-encoded byte array into a CborItem AST node.
+ *
+ * Accepts any `ArrayBufferView` (e.g. `Uint8Array`, `DataView`) or
+ * `ArrayBufferLike` (e.g. `ArrayBuffer`, `SharedArrayBuffer`).
+ *
+ * Throws if the input is not well-formed CBOR or contains trailing bytes.
+ */
+export declare function decodeCBOR(input: ArrayBufferView | ArrayBufferLike, options?: FromCBOROptions): CborItem;

package/dist/cbor/encode.d.ts

@@ -0,0 +1,35 @@
+import { FloatPrecision } from '../ast/CborFloat';
+/**
+ * EDN encoding indicator, mapping to a specific CBOR AI encoding:
+ *   'i' → ai 0–23  (argument in initial byte, value must be 0–23)
+ *   0   → AI 24    (1-byte argument, value must be 0–0xFF)
+ *   1   → AI 25    (2-byte argument, value must be 0–0xFFFF)
+ *   2   → AI 26    (4-byte argument, value must be 0–0xFFFFFFFF)
+ *   3   → AI 27    (8-byte argument, value must be 0–0xFFFFFFFFFFFFFFFF)
+ */
+export type EncodingWidth = 'i' | 0 | 1 | 2 | 3;
+/**
+ * Encode a CBOR initial byte + argument into a Uint8Array.
+ *
+ * When `encodingWidth` is provided the argument is always written using that
+ * many additional bytes (AI = 24 + encodingWidth), even if the value would fit
+ * in fewer bytes.  Without it the smallest valid encoding is chosen.
+ */
+export declare function writeHead(mt: number, value: bigint, encodingWidth?: EncodingWidth): Uint8Array;
+/** Concatenate multiple Uint8Arrays into one. */
+export declare function concat(parts: Uint8Array[]): Uint8Array;
+/**
+ * Returns true if `value` can be exactly represented as a float16 without
+ * precision loss (including -0, Infinity, -Infinity, NaN identity).
+ */
+export declare function canEncodeAsFloat16(value: number): boolean;
+/**
+ * Returns true if `value` can be exactly represented as a float32 without
+ * precision loss.
+ */
+export declare function canEncodeAsFloat32(value: number): boolean;
+/**
+ * Choose the smallest float precision that represents `value` exactly.
+ * Used by CborFloat.toCBOR() when `precision` is undefined.
+ */
+export declare function autoSelectFloatPrecision(value: number): FloatPrecision;

package/dist/cbor/encoder.d.ts

@@ -0,0 +1,7 @@
+import { CborItem } from '../ast/CborItem';
+import { ToCBOROptions } from '../types';
+/**
+ * Encode a CborItem AST node to CBOR binary.
+ * Equivalent to calling value.toCBOR() directly.
+ */
+export declare function encodeCBOR(value: CborItem, options?: ToCBOROptions): Uint8Array;