microcbor 0.3.0 → 1.0.0

package/lib/encodingLength.js

@@ -1,4 +1,9 @@
-import { getFloat16Precision, getFloat32Precision, Precision } from "fp16";
+import { Precision, getFloat16Precision, getFloat32Precision } from "fp16";
+import { getByteLength } from "./utils.js";
+/**
+ * Calculate the byte length that a value will encode into
+ * without actually allocating anything.
+ */
 export function encodingLength(value) {
     if (value === false) {
         return 1;
@@ -70,9 +75,7 @@ function numberEncodingLength(value) {
     else if (Object.is(value, -0)) {
         return floatEncodingLength(value);
     }
-    else if (Math.floor(value) === value &&
-        Number.MIN_SAFE_INTEGER <= value &&
-        value <= Number.MAX_SAFE_INTEGER) {
+    else if (Math.floor(value) === value && Number.MIN_SAFE_INTEGER <= value && value <= Number.MAX_SAFE_INTEGER) {
         return integerEncodingLength(value);
     }
     else {
@@ -99,71 +102,10 @@ function floatEncodingLength(value) {
     }
 }
 function stringEncodingLength(value) {
-    const length = byteLength(value);
+    const length = getByteLength(value);
     return argumentEncodingLength(length) + length;
 }
 function bytesEncodingLength(value) {
     const length = value.byteLength;
     return argumentEncodingLength(length) + length;
 }
-// https://github.com/feross/buffer/blob/57caad4450d241207066ca3832fb8e9095ad402f/index.js#L434
-function byteLength(string) {
-    let codePoint;
-    const length = string.length;
-    let leadSurrogate = null;
-    let bytes = 0;
-    for (let i = 0; i < length; ++i) {
-        codePoint = string.charCodeAt(i);
-        // is surrogate component
-        if (codePoint > 0xd7ff && codePoint < 0xe000) {
-            // last char was a lead
-            if (!leadSurrogate) {
-                // no lead yet
-                if (codePoint > 0xdbff) {
-                    // unexpected trail
-                    bytes += 3;
-                    continue;
-                }
-                else if (i + 1 === length) {
-                    // unpaired lead
-                    bytes += 3;
-                    continue;
-                }
-                // valid lead
-                leadSurrogate = codePoint;
-                continue;
-            }
-            // 2 leads in a row
-            if (codePoint < 0xdc00) {
-                bytes += 3;
-                leadSurrogate = codePoint;
-                continue;
-            }
-            // valid surrogate pair
-            codePoint =
-                (((leadSurrogate - 0xd800) << 10) | (codePoint - 0xdc00)) + 0x10000;
-        }
-        else if (leadSurrogate) {
-            // valid bmp char, but last char was a lead
-            bytes += 3;
-        }
-        leadSurrogate = null;
-        // encode utf8
-        if (codePoint < 0x80) {
-            bytes += 1;
-        }
-        else if (codePoint < 0x800) {
-            bytes += 2;
-        }
-        else if (codePoint < 0x10000) {
-            bytes += 3;
-        }
-        else if (codePoint < 0x110000) {
-            bytes += 4;
-        }
-        else {
-            throw new Error("Invalid code point");
-        }
-    }
-    return bytes;
-}

package/lib/index.d.ts

@@ -1,7 +1,11 @@
 export type { CBORValue, CBORMap, CBORArray } from "./types.js";
-export { encode, Encoder } from "./encode.js";
-export { decode, Decoder } from "./decode.js";
-export { encodeStream } from "./encodeStream.js";
-export { decodeStream } from "./decodeStream.js";
 export { encodingLength } from "./encodingLength.js";
+export { Encoder, encode } from "./Encoder.js";
+export { Decoder, decode } from "./Decoder.js";
+export { encodeIterable } from "./encodeIterable.js";
+export { decodeIterable } from "./decodeIterable.js";
+export { encodeAsyncIterable } from "./encodeAsyncIterable.js";
+export { decodeAsyncIterable } from "./decodeAsyncIterable.js";
+export { CBORDecoderStream } from "./CBORDecoderStream.js";
+export { CBOREncoderStream } from "./CBOREncoderStream.js";
 export { UnsafeIntegerError } from "./utils.js";

package/lib/index.js

@@ -1,6 +1,10 @@
-export { encode, Encoder } from "./encode.js";
-export { decode, Decoder } from "./decode.js";
-export { encodeStream } from "./encodeStream.js";
-export { decodeStream } from "./decodeStream.js";
 export { encodingLength } from "./encodingLength.js";
+export { Encoder, encode } from "./Encoder.js";
+export { Decoder, decode } from "./Decoder.js";
+export { encodeIterable } from "./encodeIterable.js";
+export { decodeIterable } from "./decodeIterable.js";
+export { encodeAsyncIterable } from "./encodeAsyncIterable.js";
+export { decodeAsyncIterable } from "./decodeAsyncIterable.js";
+export { CBORDecoderStream } from "./CBORDecoderStream.js";
+export { CBOREncoderStream } from "./CBOREncoderStream.js";
 export { UnsafeIntegerError } from "./utils.js";

package/lib/utils.d.ts

@@ -4,3 +4,10 @@ export declare class UnsafeIntegerError extends RangeError {
     readonly value: bigint;
     constructor(message: string, value: bigint);
 }
+export declare class AssertError extends Error {
+    readonly message: string;
+    readonly props?: any | undefined;
+    constructor(message: string, props?: any | undefined);
+}
+export declare function assert(condition: unknown, message?: string, props?: any): asserts condition;
+export declare function getByteLength(string: string): number;

package/lib/utils.js

@@ -6,3 +6,75 @@ export class UnsafeIntegerError extends RangeError {
         this.value = value;
     }
 }
+export class AssertError extends Error {
+    constructor(message, props) {
+        super(message);
+        this.message = message;
+        this.props = props;
+    }
+}
+export function assert(condition, message = "assertion failed", props) {
+    if (!condition) {
+        throw new AssertError(message, props);
+    }
+}
+// https://github.com/feross/buffer/blob/57caad4450d241207066ca3832fb8e9095ad402f/index.js#L434
+export function getByteLength(string) {
+    let codePoint;
+    const length = string.length;
+    let leadSurrogate = null;
+    let bytes = 0;
+    for (let i = 0; i < length; ++i) {
+        codePoint = string.charCodeAt(i);
+        // is surrogate component
+        if (codePoint > 0xd7ff && codePoint < 0xe000) {
+            // last char was a lead
+            if (!leadSurrogate) {
+                // no lead yet
+                if (codePoint > 0xdbff) {
+                    // unexpected trail
+                    bytes += 3;
+                    continue;
+                }
+                else if (i + 1 === length) {
+                    // unpaired lead
+                    bytes += 3;
+                    continue;
+                }
+                // valid lead
+                leadSurrogate = codePoint;
+                continue;
+            }
+            // 2 leads in a row
+            if (codePoint < 0xdc00) {
+                bytes += 3;
+                leadSurrogate = codePoint;
+                continue;
+            }
+            // valid surrogate pair
+            codePoint = (((leadSurrogate - 0xd800) << 10) | (codePoint - 0xdc00)) + 0x10000;
+        }
+        else if (leadSurrogate) {
+            // valid bmp char, but last char was a lead
+            bytes += 3;
+        }
+        leadSurrogate = null;
+        // encode utf8
+        if (codePoint < 0x80) {
+            bytes += 1;
+        }
+        else if (codePoint < 0x800) {
+            bytes += 2;
+        }
+        else if (codePoint < 0x10000) {
+            bytes += 3;
+        }
+        else if (codePoint < 0x110000) {
+            bytes += 4;
+        }
+        else {
+            throw new Error("Invalid code point");
+        }
+    }
+    return bytes;
+}

package/package.json

@@ -1,15 +1,20 @@
 {
 	"name": "microcbor",
-	"version": "0.3.0",
-	"description": "Encode JavaScript values as canonical CBOR",
+	"version": "1.0.0",
 	"type": "module",
-	"main": "lib/index.js",
-	"types": "lib/index.d.ts",
 	"files": [
 		"lib"
 	],
+	"description": "Encode JavaScript values as canonical CBOR",
+	"main": "lib/index.js",
+	"types": "./lib/index.d.ts",
+	"exports": {
+		".": "./lib/index.js"
+	},
 	"scripts": {
-		"build": "tsc",
+		"dev": "tsc --build tsconfig.json test/tsconfig.json --watch",
+		"build": "tsc --build tsconfig.json test/tsconfig.json",
+		"clean": "tsc --build tsconfig.json test/tsconfig.json --clean",
 		"test": "ava"
 	},
 	"repository": {
@@ -27,11 +32,13 @@
 	},
 	"homepage": "https://github.com/joeltg/microcbor#readme",
 	"devDependencies": {
-		"ava": "^5.3.1",
-		"cbor": "^8.1.0",
-		"typescript": "^5.1.6"
+		"@ava/typescript": "^5.0.0",
+		"@types/node": "^22.13.9",
+		"ava": "^6.2.0",
+		"cbor": "^10.0.3",
+		"typescript": "^5.6.0"
 	},
 	"dependencies": {
-		"fp16": "^0.2.0"
+		"fp16": "^1.0.0"
 	}
 }

package/lib/decodeStream.d.ts

@@ -1,2 +0,0 @@
-import type { CBORValue } from "./types.js";
-export declare function decodeStream(source: AsyncIterable<Uint8Array>): AsyncIterable<CBORValue>;

package/lib/encode.d.ts

@@ -1,35 +0,0 @@
-import type { CBORValue } from "./types.js";
-export declare class Encoder {
-    static defaultChunkSize: number;
-    closed: boolean;
-    private buffer;
-    private view;
-    private offset;
-    private readonly encoder;
-    private readonly chunkSize;
-    constructor(options?: {
-        chunkSize?: number;
-        noCopy?: boolean;
-    });
-    private allocate;
-    private float16;
-    private float32;
-    private float64;
-    private uint8;
-    private uint16;
-    private uint32;
-    private uint64;
-    private encodeTypeAndArgument;
-    private encodeNumber;
-    private encodeInteger;
-    private encodeFloat;
-    private encodeString;
-    private encodeBytes;
-    encodeValue(value: CBORValue): Iterable<Uint8Array>;
-    flush(): Iterable<Uint8Array>;
-    private static compareKeys;
-    private static getAdditionalInformation;
-}
-export declare function encode(value: CBORValue, options?: {
-    chunkSize?: number;
-}): Uint8Array;

package/lib/encode.js

@@ -1,228 +0,0 @@
-import { getFloat16Precision, getFloat32Precision, setFloat16, Precision, } from "fp16";
-export class Encoder {
-    constructor(options = {}) {
-        this.encoder = new TextEncoder();
-        this.chunkSize = options.chunkSize || Encoder.defaultChunkSize;
-        this.buffer = new ArrayBuffer(this.chunkSize);
-        this.view = new DataView(this.buffer);
-        this.offset = 0;
-        this.closed = false;
-    }
-    *allocate(size) {
-        if (this.buffer.byteLength < this.offset + size) {
-            yield new Uint8Array(this.buffer, 0, this.offset);
-            const byteLength = Math.max(size, this.chunkSize);
-            this.buffer = new ArrayBuffer(byteLength);
-            this.view = new DataView(this.buffer);
-            this.offset = 0;
-        }
-    }
-    *float16(value) {
-        yield* this.allocate(2);
-        setFloat16(this.view, this.offset, value);
-        this.offset += 2;
-    }
-    *float32(value) {
-        yield* this.allocate(4);
-        this.view.setFloat32(this.offset, value);
-        this.offset += 4;
-    }
-    *float64(value) {
-        yield* this.allocate(8);
-        this.view.setFloat64(this.offset, value);
-        this.offset += 8;
-    }
-    *uint8(value) {
-        yield* this.allocate(1);
-        this.view.setUint8(this.offset, value);
-        this.offset += 1;
-    }
-    *uint16(value) {
-        yield* this.allocate(2);
-        this.view.setUint16(this.offset, value);
-        this.offset += 2;
-    }
-    *uint32(value) {
-        yield* this.allocate(4);
-        this.view.setUint32(this.offset, value);
-        this.offset += 4;
-    }
-    *uint64(value) {
-        yield* this.allocate(8);
-        this.view.setBigUint64(this.offset, BigInt(value));
-        this.offset += 8;
-    }
-    *encodeTypeAndArgument(type, argument) {
-        const additionalInformation = Encoder.getAdditionalInformation(argument);
-        yield* this.uint8((type << 5) | additionalInformation);
-        switch (additionalInformation) {
-            case 24:
-                return yield* this.uint8(argument);
-            case 25:
-                return yield* this.uint16(argument);
-            case 26:
-                return yield* this.uint32(argument);
-            case 27:
-                return yield* this.uint64(argument);
-        }
-    }
-    *encodeNumber(value) {
-        if (Object.is(value, 0)) {
-            yield* this.encodeInteger(value);
-        }
-        else if (Object.is(value, -0)) {
-            yield* this.encodeFloat(value);
-        }
-        else if (Math.floor(value) === value &&
-            Number.MIN_SAFE_INTEGER <= value &&
-            value <= Number.MAX_SAFE_INTEGER) {
-            yield* this.encodeInteger(value);
-        }
-        else {
-            yield* this.encodeFloat(value);
-        }
-    }
-    *encodeInteger(value) {
-        if (value < 0) {
-            yield* this.encodeTypeAndArgument(1, -value - 1);
-        }
-        else {
-            yield* this.encodeTypeAndArgument(0, value);
-        }
-    }
-    *encodeFloat(value) {
-        if (getFloat16Precision(value) === Precision.Exact) {
-            yield* this.uint8(0xe0 | 25);
-            yield* this.float16(value);
-        }
-        else if (getFloat32Precision(value) === Precision.Exact) {
-            yield* this.uint8(0xe0 | 26);
-            yield* this.float32(value);
-        }
-        else {
-            yield* this.uint8(0xe0 | 27);
-            yield* this.float64(value);
-        }
-    }
-    *encodeString(value) {
-        const data = this.encoder.encode(value);
-        yield* this.encodeTypeAndArgument(3, data.byteLength);
-        yield* this.allocate(data.byteLength);
-        new Uint8Array(this.buffer, this.offset).set(data);
-        this.offset += data.byteLength;
-    }
-    *encodeBytes(value) {
-        yield* this.encodeTypeAndArgument(2, value.byteLength);
-        yield* this.allocate(value.byteLength);
-        new Uint8Array(this.buffer, this.offset, value.byteLength).set(value);
-        this.offset += value.byteLength;
-    }
-    *encodeValue(value) {
-        if (this.closed) {
-            return;
-        }
-        if (value === false) {
-            yield* this.uint8(0xf4);
-        }
-        else if (value === true) {
-            yield* this.uint8(0xf5);
-        }
-        else if (value === null) {
-            yield* this.uint8(0xf6);
-        }
-        else if (value === undefined) {
-            yield* this.uint8(0xf7);
-        }
-        else if (typeof value === "number") {
-            yield* this.encodeNumber(value);
-        }
-        else if (typeof value === "string") {
-            yield* this.encodeString(value);
-        }
-        else if (value instanceof Uint8Array) {
-            yield* this.encodeBytes(value);
-        }
-        else if (Array.isArray(value)) {
-            yield* this.encodeTypeAndArgument(4, value.length);
-            for (const element of value) {
-                yield* this.encodeValue(element);
-            }
-        }
-        else {
-            const keys = Object.keys(value).sort(Encoder.compareKeys);
-            yield* this.encodeTypeAndArgument(5, keys.length);
-            for (const key of keys) {
-                yield* this.encodeString(key);
-                yield* this.encodeValue(value[key]);
-            }
-        }
-    }
-    *flush() {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        if (this.offset > 0) {
-            yield new Uint8Array(this.buffer, 0, this.offset);
-        }
-    }
-    // Per the deterministic CBOR spec, we're supposed to sort keys
-    // the byte-wise lexicographic order of the key's CBOR encoding
-    // - ie lower major types come before higher major types!
-    // However, microcbor only supports string keys, which means we
-    // can get away with sorting them without actually encoding them
-    // first. One thing we know for sure about strings is that a
-    // string with a smaller length will sort byte-wise before a string
-    // with a longer length, since strings are encoded with a length
-    // prefix (either in the additionalInformation bits, if < 24, or
-    // in the next serveral bytes, but in all cases the order holds).
-    static compareKeys(a, b) {
-        if (a.length < b.length) {
-            return -1;
-        }
-        else if (b.length < a.length) {
-            return 1;
-        }
-        else {
-            return a < b ? -1 : 1;
-        }
-    }
-    static getAdditionalInformation(argument) {
-        if (argument < 24) {
-            return argument;
-        }
-        else if (argument < 0x100) {
-            return 24;
-        }
-        else if (argument < 0x10000) {
-            return 25;
-        }
-        else if (argument < 0x100000000) {
-            return 26;
-        }
-        else {
-            return 27;
-        }
-    }
-}
-Encoder.defaultChunkSize = 512;
-export function encode(value, options = {}) {
-    const encoder = new Encoder(options);
-    let byteLength = 0;
-    const chunks = [];
-    for (const chunk of encoder.encodeValue(value)) {
-        chunks.push(chunk);
-        byteLength += chunk.byteLength;
-    }
-    for (const chunk of encoder.flush()) {
-        chunks.push(chunk);
-        byteLength += chunk.byteLength;
-    }
-    const data = new Uint8Array(byteLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-        data.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return data;
-}

package/lib/encodeStream.d.ts

@@ -1,4 +0,0 @@
-import type { CBORValue } from "./types.js";
-export declare function encodeStream(source: AsyncIterable<CBORValue>, options?: {
-    chunkSize?: number;
-}): AsyncIterable<Uint8Array>;

package/lib/encodeStream.js

@@ -1,8 +0,0 @@
-import { Encoder } from "./encode.js";
-export async function* encodeStream(source, options = {}) {
-    const encoder = new Encoder(options);
-    for await (const value of source) {
-        yield* encoder.encodeValue(value);
-    }
-    yield* encoder.flush();
-}