@cbortech/cbor 0.24.0 → 0.25.1

package/dist/simple.d.ts

@@ -6,12 +6,12 @@
  * Also serves as a namespace for simple-value utilities.
  *
  * @example
- * const v = CBOR.fromEDN('simple(19)').toJS();
+ * const v = CBOR.fromCDN('simple(19)').toJS();
  * Simple.is(v);    // true
  * Simple.get(v);   // 19
  *
  * const node = CBOR.fromJS(new Simple(19));
- * node.toEDN();    // "simple(19)"
+ * node.toCDN();    // "simple(19)"
  */
 export declare class Simple {
     readonly value: number;

package/dist/tag.d.ts

@@ -19,7 +19,7 @@ export declare function getCborTaggedValue(value: unknown): unknown;
  * Namespace for CBOR tag annotation utilities.
  *
  * @example
- * const v = CBOR.fromEDN('42("hello")').toJS();
+ * const v = CBOR.fromCDN('42("hello")').toJS();
  * Tag.get(v);        // 42n
  * Tag.getValue(v);   // "hello"
  *

package/dist/types.d.ts

@@ -40,7 +40,7 @@ export interface ToJSOptions {
      * - `'object'`: always `Record<string, unknown>` — non-string keys are
      *   converted via `String()`. Duplicate keys are overwritten (last wins).
      * - `'entries'`: always `MapEntries` (a typed `Array` subclass) — preserves all
-     *   entries including duplicate keys (§2.6.2 of draft-ietf-cbor-edn-literals-20).
+     *   entries including duplicate keys (§2.6.3 of draft-ietf-cbor-edn-literals-25).
      *   `fromJS()` recognises `MapEntries` instances and converts them back to `CborMap`.
      * @default 'auto'
      */
@@ -80,6 +80,28 @@ export interface ToJSOptions {
 }
 export interface ToCBOROptions {
 }
+/**
+ * A CBOR validity violation detected during decoding.
+ */
+export interface DecodeWarning {
+    /** Human-readable description of the violation. */
+    message: string;
+    /** Byte offset within the decoded input where the violation was detected. */
+    offset: number;
+}
+/**
+ * A CDN/EDN validity violation detected during parsing.
+ */
+export interface ParseWarning {
+    /** Human-readable description of the violation. */
+    message: string;
+    /** Character offset within the input text where the violation was detected. */
+    offset?: number;
+    /** Line number (1-based) where the violation was detected. */
+    line?: number;
+    /** Column number (1-based) where the violation was detected. */
+    column?: number;
+}
 export interface FromCBOROptions {
     /**
      * Byte offset within the supplied input at which CBOR decoding starts.
@@ -110,6 +132,39 @@ export interface FromCBOROptions {
      * `CborTag` node.
      */
     extensions?: CborExtension[];
+    /**
+     * Controls how CBOR validity violations are handled.
+     *
+     * - `true` (default): violations call `onWarning` and then throw, stopping
+     *   decoding immediately.
+     * - `false`: recoverable violations call `onWarning` and decoding continues
+     *   with a best-effort interpretation of the data.
+     *
+     * Truly malformed data (e.g. truncated input, reserved AI values) always
+     * throws regardless of this setting.
+     *
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * Callback invoked when a CBOR validity violation is detected.
+     *
+     * In strict mode (the default), this is called before the error is thrown.
+     * In non-strict mode (`strict: false`), this is called and decoding
+     * continues.
+     *
+     * If not supplied and `silent` is not `true`, violations are reported via
+     * `console.warn`.
+     */
+    onWarning?: (warning: DecodeWarning) => void;
+    /**
+     * When `true`, suppresses the default `console.warn` output for validity
+     * violations.  An explicit `onWarning` callback is still invoked even when
+     * `silent` is `true`.
+     *
+     * @default false
+     */
+    silent?: boolean;
 }
 /**
  * Options for parsing an annotated hex dump.
@@ -122,9 +177,9 @@ export interface FromHexDumpOptions {
      */
     extensions?: CborExtension[];
 }
-export interface FromEDNOptions {
+export interface FromCDNOptions {
     /**
-     * Character offset within the supplied text at which CBOR-EDN parsing starts.
+     * Character offset within the supplied text at which CDN parsing starts.
      * Leading whitespace/comments at or after this offset are skipped as usual.
      *
      * @default 0
@@ -135,22 +190,22 @@ export interface FromEDNOptions {
      *
      * When `false`, parsing still requires the item to consume the remaining
      * input, preserving the historical single-item behaviour. Set this to `true`
-     * when using `CborItem.end` to continue parsing a CBOR-EDN sequence.
-     * Top-level comma separators are not skipped by `fromEDN()` itself; handle
+     * when using `CborItem.end` to continue parsing a CDN sequence.
+     * Top-level comma separators are not skipped by `fromCDN()` itself; handle
      * them in sequence-level code before passing the next `offset`. For example,
      * after parsing `1, 2`, the first item's `end` points just before the comma;
      * advance past that comma before parsing the next item.
      *
      * @example
      * // Read two whitespace-separated items, validating that the second is last.
-     * const first = CBOR.fromEDN(text, { allowTrailing: true });
-     * const second = CBOR.fromEDN(text, { offset: first.end });
+     * const first = CBOR.fromCDN(text, { allowTrailing: true });
+     * const second = CBOR.fromCDN(text, { offset: first.end });
      *
      * @default false
      */
     allowTrailing?: boolean;
     /**
-     * Extension plugins for EDN parsing.
+     * Extension plugins for CDN parsing.
      * Each extension declares which app-string prefixes (and, in future, tag
      * numbers) it handles via `appStringPrefixes` / `tagNumbers`, and provides
      * callback methods that return `CborItem`-subclassed objects controlling
@@ -162,11 +217,11 @@ export interface FromEDNOptions {
     extensions?: CborExtension[];
     /**
      * How to handle unrecognised application-extension identifiers
-     * (§4.1 draft-ietf-cbor-edn-literals-20).
+     * (§4.1 of draft-ietf-cbor-edn-literals-25).
      *
      * - `'cpa999'`: wrap the literal in a `CPA999` tag
      *   (`CborUnresolvedAppExt`) instead of failing. The resulting node
-     *   round-trips through `toEDN()` back to the original notation.
+     *   round-trips through `toCDN()` back to the original notation.
      * - `'error'`: throw `SyntaxError` for unknown prefixes.
      * @default 'cpa999'
      */
@@ -184,16 +239,56 @@ export interface FromEDNOptions {
      */
     allowInvalidUtf8?: boolean;
     /**
-     * Preserve comments found between CBOR-EDN values and attach them to the AST.
+     * Preserve comments found between CDN values and attach them to the AST.
      *
      * Comments are metadata only: they are ignored by CBOR binary encoding and
-     * JavaScript conversion. Use together with `ToEDNOptions.preserveComments`
-     * to include them when formatting back to EDN.
+     * JavaScript conversion. Use together with `ToCDNOptions.preserveComments`
+     * to include them when formatting back to CDN.
+     *
+     * The string values `'c-style'` and `'cdn-style'` are treated as `true`
+     * for parsing purposes; they become meaningful when passed to `toCDN()`.
      *
      * @default false
      */
-    preserveComments?: boolean;
+    preserveComments?: boolean | 'c-style' | 'cdn-style';
+    /**
+     * Controls how CDN/EDN validity violations are handled.
+     *
+     * - `true` (default): recoverable violations call `onWarning` and then throw.
+     * - `false`: recoverable violations call `onWarning` and parsing continues
+     *   with a best-effort interpretation of the input.
+     *
+     * Hard syntax errors (e.g. unterminated strings, unexpected tokens) always
+     * throw regardless of this setting.
+     *
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * Callback invoked when a CDN/EDN validity violation is detected.
+     *
+     * In strict mode (the default), this is called before the error is thrown.
+     * In non-strict mode (`strict: false`), this is called and parsing continues.
+     *
+     * If not supplied and `silent` is not `true`, violations are reported via
+     * `console.warn`.
+     */
+    onWarning?: (warning: ParseWarning) => void;
+    /**
+     * When `true`, suppresses the default `console.warn` output for validity
+     * violations.  An explicit `onWarning` callback is still invoked even when
+     * `silent` is `true`.
+     *
+     * @default false
+     */
+    silent?: boolean;
 }
+/**
+ * Options for parsing Concise Diagnostic Notation (CDN).
+ *
+ * @deprecated Use `FromCDNOptions` instead.
+ */
+export type FromEDNOptions = FromCDNOptions;
 export interface FromJSOptions {
     /**
      * Extension plugins applied during `fromJS()`.
@@ -238,7 +333,7 @@ export interface FromJSOptions {
      */
     undefinedOmits?: boolean;
 }
-export interface ToEDNOptions {
+export interface ToCDNOptions {
     /**
      * Indentation for pretty-printing.
      * - `number`: number of spaces
@@ -247,16 +342,25 @@ export interface ToEDNOptions {
      */
     indent?: number | string;
     /**
-     * Emit comments previously captured by `FromEDNOptions.preserveComments`.
+     * Emit comments previously captured by `FromCDNOptions.preserveComments`.
+     *
+     * - `true`: emit comments with their original markers.
+     * - `'c-style'`: emit comments, normalising line comments to `//` and block
+     *   comments to `/* … *\/`.
+     * - `'cdn-style'`: emit comments, normalising line comments to `#` and block
+     *   comments to `/ … /`. When a `/* … *\/` comment's content contains `/`
+     *   (which cannot be represented inside `/ … /`), the `/* … *\/` form is
+     *   kept as-is.
+     * - `false` / omitted: strip all comments from the output.
      *
      * When enabled for containers, comment-bearing arrays/maps are emitted in
      * multi-line form even if `indent` is omitted.
      *
      * @default false
      */
-    preserveComments?: boolean;
+    preserveComments?: boolean | 'c-style' | 'cdn-style';
     /**
-     * Re-emit byte string literals parsed from EDN using their original source
+     * Re-emit byte string literals parsed from CDN using their original source
      * text when available.
      *
      * This preserves the spelling and interior layout of non-concatenated
@@ -278,17 +382,14 @@ export interface ToEDNOptions {
      * @default 'comma'
      */
     commas?: 'comma' | 'none' | 'trailing';
-    /**
     /**
      * Fallback binary encoding for byte string literals when sqstr is not applicable.
      * - `'hex'`: `h'...'`
      * - `'base64'`: `b64'...'`
      * - `'base64url'`: `b64'...'` (base64url alphabet)
-     * - `'base32'`: `b32'...'`
-     * - `'base32hex'`: `h32'...'`
      * @default 'hex'
      */
-    bstrEncoding?: 'hex' | 'base64' | 'base64url' | 'base32' | 'base32hex';
+    bstrEncoding?: 'hex' | 'base64' | 'base64url';
     /**
      * Whether to prefer single-quoted string form (`sqstr`) for byte strings.
      * - `'printable-string'`: emit `'...'` when the bytes are valid UTF-8 and
@@ -308,7 +409,7 @@ export interface ToEDNOptions {
      */
     appStrings?: boolean;
     /**
-     * Numeric format for integer values in EDN output.
+     * Numeric format for integer values in CDN output.
      * - `'decimal'`: standard decimal notation (e.g. `42`, `-14159024`)
      * - `'hex'`: hexadecimal notation (e.g. `0x2a`, `-0xd83130`)
      * - `'octal'`: octal notation (e.g. `0o52`, `-0o67061560`)
@@ -317,25 +418,35 @@ export interface ToEDNOptions {
      */
     intFormat?: 'decimal' | 'hex' | 'octal' | 'binary';
     /**
-     * Numeric format for floating-point values in EDN output.
+     * Numeric format for floating-point values in CDN output.
      * - `'decimal'`: standard decimal notation (e.g. `1.5`, `145544.0_3`)
      * - `'hex'`: C99-style hex float notation (e.g. `0x1.8p+0`, `0x1.1c54p+17_3`)
      * @default 'decimal'
      */
     floatFormat?: 'decimal' | 'hex';
     /**
-     * Split long text strings using EDN string concatenation syntax (`"a" + "b"`).
+     * Split long text strings using CDN string concatenation syntax (`"a" + "b"`).
      * Only effective when `indent` is specified.
      *
      * - `'newline'`: split at newline characters
-     * - `'cboredn'`: split according to CBOR-EDN structure when the string content
-     *                is parseable as CBOR-EDN (JSON superset)
+     * - `'cdn'`: split according to CDN structure when the string content
+     *                is parseable as CDN (JSON superset)
+     * - `'cboredn'`: deprecated alias for `'cdn'`
      *
-     * When both are specified, CBOR-EDN structure split points are combined with
+     * When both are specified, CDN structure split points are combined with
      * newline split points.
      */
-    textStringFormat?: ('newline' | 'cboredn')[];
+    textStringFormat?: TextStringFormat[];
 }
+export type TextStringFormat = 'newline' | 'cdn' | DeprecatedTextStringFormat;
+/** @deprecated Use `'cdn'` instead. */
+export type DeprecatedTextStringFormat = 'cboredn';
+/**
+ * Options for serializing Concise Diagnostic Notation (CDN).
+ *
+ * @deprecated Use `ToCDNOptions` instead.
+ */
+export type ToEDNOptions = ToCDNOptions;
 export interface CborComment {
     kind: 'line' | 'block';
     marker: '#' | '//' | '/*' | '/';
@@ -359,4 +470,4 @@ export interface CborComments {
  * Note: `encodeIntegerAs` (from {@link FromJSOptions}) and `integerAs` (from
  * {@link ToJSOptions}) are distinct fields and do not conflict.
  */
-export type CBOROptions = FromEDNOptions & FromJSOptions & ToCBOROptions & ToEDNOptions & ToJSOptions & ToHexDumpOptions;
+export type CBOROptions = FromCDNOptions & FromJSOptions & ToCBOROptions & ToCDNOptions & ToJSOptions & ToHexDumpOptions;

package/dist/utils/hexfloat.d.ts

@@ -4,7 +4,7 @@
  * Hex float format:
  *   [-] 0x [hex digits] [. [hex digits]] p [+-] [decimal exponent]
  *
- * This notation appears in CBOR-EDN (draft-ietf-cbor-edn-literals) as an
+ * This notation appears in CDN (draft-ietf-cbor-edn-literals-25) as an
  * alternative representation for floating-point values (major type 7).
  */
 /**
@@ -17,7 +17,7 @@
 export declare function parseHexFloat(s: string): number;
 /**
  * Convert a JS number to a normalized hex float string compatible with
- * CBOR-EDN diagnostic notation.
+ * CDN diagnostic notation.
  *
  * - Normal values: `0x1.[hex fraction]p[+-][exp]`  (e.g. `0x1.8p+0` for 1.5)
  * - Subnormal values: `0x0.[hex fraction]p-1022`

package/dist/utils/strip-comments.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Strip whitespace and EDN §2.2 comments from app-string content.
+ *
+ * Used by extensions whose content allows the same comment syntax as byte
+ * string literals (b32, h32, float, …):
+ *   SP / LF / CR       — whitespace, skipped
+ *   # … LF             — line comment
+ *   // … LF            — line comment
+ *   /* … *\/           — block comment (unterminated → SyntaxError)
+ *   / … /              — block comment (unterminated → SyntaxError)
+ */
+export declare function stripComments(str: string): string;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@cbortech/cbor",
-  "version": "0.24.0",
-  "description": "Convert between CBOR, CBOR-EDN, and JavaScript values",
+  "version": "0.25.1",
+  "description": "Convert between CBOR, CDN, and JavaScript values",
   "keywords": [
     "cbor",
+    "cdn",
     "cbor-edn",
-    "edn",
     "diagnostic-notation",
     "json",
     "jsonc",
@@ -67,9 +67,11 @@
     "start": "node dist/index.js",
     "dev": "npm run build && npm start",
     "clean": "node -e \"['dist','coverage'].forEach(d=>require('fs').rmSync(d,{recursive:true,force:true}))\"",
-    "test": "vitest run",
+    "test": "vitest run --exclude src/cdn/edn-test-vectors.test.ts --exclude src/cdn/edn-abnf-vectors.test.ts",
     "test:exports": "npm run build && node scripts/check-package-exports.mjs",
-    "test:node": "vitest run",
+    "test:node": "vitest run --exclude src/cdn/edn-test-vectors.test.ts --exclude src/cdn/edn-abnf-vectors.test.ts",
+    "test:edn-vectors": "vitest run src/cdn/edn-test-vectors.test.ts",
+    "test:edn-abnf": "vitest run src/cdn/edn-abnf-vectors.test.ts",
     "test:chromium": "cross-env BROWSER=chromium vitest run --config vitest.browser.config.ts",
     "test:firefox": "cross-env BROWSER=firefox vitest run --config vitest.browser.config.ts",
     "test:webkit": "cross-env BROWSER=webkit vitest run --config vitest.browser.config.ts",
@@ -82,16 +84,16 @@
   },
   "devDependencies": {
     "@types/node": "^24.12.4",
-    "@vitest/browser": "^4.1.6",
-    "@vitest/browser-playwright": "^4.1.6",
-    "@vitest/coverage-v8": "^4.1.6",
-    "@vitest/ui": "^4.1.6",
+    "@vitest/browser": "^4.1.8",
+    "@vitest/browser-playwright": "^4.1.8",
+    "@vitest/coverage-v8": "^4.1.8",
+    "@vitest/ui": "^4.1.8",
     "cross-env": "^10.1.0",
     "playwright": "^1.60.0",
     "prettier": "^3.8.3",
     "typescript": "^5.9.3",
-    "vite": "^8.0.12",
+    "vite": "^8.0.16",
     "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.1.6"
+    "vitest": "^4.1.8"
   }
 }

package/dist/edn/parser.d.ts

@@ -1,7 +0,0 @@
-import { CborItem } from '../ast/CborItem';
-import { FromEDNOptions } from '../types';
-/**
- * Parse a CBOR-EDN diagnostic notation string into a CborItem AST node.
- * Throws SyntaxError on invalid input.
- */
-export declare function parseEDN(text: string, options?: FromEDNOptions): CborItem;

package/dist/edn/serializer.d.ts

@@ -1,7 +0,0 @@
-import { CborItem } from '../ast/CborItem';
-import { ToEDNOptions } from '../types';
-/**
- * Serialize a CborItem AST node to CBOR-EDN diagnostic notation.
- * Equivalent to calling value.toEDN(options) directly.
- */
-export declare function toEDN(value: CborItem, options?: ToEDNOptions): string;