microcbor 0.1.0 → 0.2.1

package/lib/encodingLength.js

@@ -0,0 +1,169 @@
+import { getFloat16Precision, getFloat32Precision, Precision } from "fp16";
+export function encodingLength(value) {
+    if (value === false) {
+        return 1;
+    }
+    else if (value === true) {
+        return 1;
+    }
+    else if (value === null) {
+        return 1;
+    }
+    else if (value === undefined) {
+        return 1;
+    }
+    else if (typeof value === "number") {
+        return numberEncodingLength(value);
+    }
+    else if (typeof value === "string") {
+        return stringEncodingLength(value);
+    }
+    else if (value instanceof Uint8Array) {
+        return bytesEncodingLength(value);
+    }
+    else if (Array.isArray(value)) {
+        let length = argumentEncodingLength(value.length);
+        for (const element of value) {
+            length += encodingLength(element);
+        }
+        return length;
+    }
+    else if (typeof value === "object") {
+        const keys = Object.keys(value);
+        let length = argumentEncodingLength(keys.length);
+        for (const key of keys) {
+            if (typeof key === "string") {
+                length += stringEncodingLength(key);
+                length += encodingLength(value[key]);
+            }
+            else {
+                throw new Error("object keys must be strings");
+            }
+        }
+        return length;
+    }
+    else {
+        throw new Error("invalid value");
+    }
+}
+function argumentEncodingLength(argument) {
+    if (argument < 24) {
+        return 1;
+    }
+    else if (argument < 0x100) {
+        return 1 + 1;
+    }
+    else if (argument < 0x10000) {
+        return 1 + 2;
+    }
+    else if (argument < 0x100000000) {
+        return 1 + 4;
+    }
+    else {
+        return 1 + 8;
+    }
+}
+function numberEncodingLength(value) {
+    if (Object.is(value, 0)) {
+        return integerEncodingLength(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) {
+        return integerEncodingLength(value);
+    }
+    else {
+        return floatEncodingLength(value);
+    }
+}
+function integerEncodingLength(value) {
+    if (value < 0) {
+        return argumentEncodingLength(-value - 1);
+    }
+    else {
+        return argumentEncodingLength(value);
+    }
+}
+function floatEncodingLength(value) {
+    if (getFloat16Precision(value) === Precision.Exact) {
+        return 1 + 2;
+    }
+    else if (getFloat32Precision(value) === Precision.Exact) {
+        return 1 + 4;
+    }
+    else {
+        return 1 + 8;
+    }
+}
+function stringEncodingLength(value) {
+    const length = byteLength(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,2 +1,7 @@
-export * from "./encode.js";
-export * from "./decode.js";
+export type { CBORValue, CBORMap, CBORArray } from "./types.js";
+export { encode, Encoder } from "./encode.js";
+export { decode } from "./decode.js";
+export { encodeStream } from "./encodeStream.js";
+export { decodeStream } from "./decodeStream.js";
+export { encodingLength } from "./encodingLength.js";
+export { UnsafeIntegerError } from "./utils.js";

package/lib/index.js

@@ -1,2 +1,6 @@
-export * from "./encode.js";
-export * from "./decode.js";
+export { encode, Encoder } from "./encode.js";
+export { decode } from "./decode.js";
+export { encodeStream } from "./encodeStream.js";
+export { decodeStream } from "./decodeStream.js";
+export { encodingLength } from "./encodingLength.js";
+export { UnsafeIntegerError } from "./utils.js";

package/lib/types.d.ts

@@ -0,0 +1,6 @@
+export declare type CBORValue = undefined | null | boolean | number | string | Uint8Array | CBORArray | CBORMap;
+export interface CBORArray extends Array<CBORValue> {
+}
+export interface CBORMap {
+    [key: string]: CBORValue;
+}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/lib/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const maxSafeInteger: bigint;
+export declare const minSafeInteger: bigint;
+export declare class UnsafeIntegerError extends RangeError {
+    readonly value: bigint;
+    constructor(message: string, value: bigint);
+}

package/lib/utils.js

@@ -0,0 +1,8 @@
+export const maxSafeInteger = BigInt(Number.MAX_SAFE_INTEGER);
+export const minSafeInteger = BigInt(Number.MIN_SAFE_INTEGER);
+export class UnsafeIntegerError extends RangeError {
+    constructor(message, value) {
+        super(message);
+        this.value = value;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "microcbor",
-	"version": "0.1.0",
-	"description": "Encode JSON values as canonical CBOR",
+	"version": "0.2.1",
+	"description": "Encode JavaScript values as canonical CBOR",
 	"type": "module",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
@@ -27,11 +27,11 @@
 	},
 	"homepage": "https://github.com/joeltg/microcbor#readme",
 	"devDependencies": {
-		"ava": "^4.0.0-alpha.2",
-		"cbor": "^8.0.0",
-		"typescript": "^4.4.2"
+		"ava": "^4.3.1",
+		"cbor": "^8.0.2",
+		"typescript": "^4.8.2"
 	},
 	"dependencies": {
-		"fp16": "^0.1.2"
+		"fp16": "^0.2.0"
 	}
 }