nid-webauthn-emulator 0.2.11 → 0.2.13

package/dist/spec/libs/cbor.spec.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const encode_utils_1 = __importDefault(require("../../src/libs/encode-utils"));
+(0, globals_1.describe)("CBOR encode/decode edge cases", () => {
+    (0, globals_1.test)("round-trips primitive values and large integer encodings", () => {
+        const encoded = encode_utils_1.default.encodeCbor({
+            1: "one",
+            nil: null,
+            values: [false, true, undefined, -2, 24, 0x100, 0x1_0000, 0x1_0000_0000],
+        });
+        const decoded = encode_utils_1.default.decodeCbor(encoded);
+        (0, globals_1.expect)(decoded[1]).toBe("one");
+        (0, globals_1.expect)(decoded.nil).toBeNull();
+        (0, globals_1.expect)(decoded.values).toEqual([false, true, undefined, -2, 24, 0x100, 0x1_0000, 0x1_0000_0000]);
+    });
+    (0, globals_1.test)("handles ArrayBuffer values within objects and arrays", () => {
+        const ab = new Uint8Array([1, 2, 3]).buffer; // ArrayBuffer branch
+        const ua = new Uint8Array([4, 5]);
+        const obj = {
+            v1: ab,
+            v2: ua,
+            arr: [ab, ua],
+        };
+        const encoded = encode_utils_1.default.encodeCbor(obj);
+        const decoded = encode_utils_1.default.decodeCbor(encoded);
+        // ArrayBuffer is decoded back to Uint8Array
+        (0, globals_1.expect)(decoded.v1).toBeInstanceOf(Uint8Array);
+        (0, globals_1.expect)(Array.from(decoded.v1)).toEqual([1, 2, 3]);
+        // Existing Uint8Array round-trips
+        (0, globals_1.expect)(Array.from(decoded.v2)).toEqual([4, 5]);
+        // Mixed array elements preserved as Uint8Array
+        (0, globals_1.expect)(Array.isArray(decoded.arr)).toBe(true);
+        const [a0, a1] = decoded.arr;
+        (0, globals_1.expect)(Array.from(a0)).toEqual([1, 2, 3]);
+        (0, globals_1.expect)(Array.from(a1)).toEqual([4, 5]);
+    });
+    (0, globals_1.test)("handles Buffer values without conversion in encoder and to Uint8Array on decode", () => {
+        const buf = Buffer.from([9, 8]);
+        const obj = { b: buf };
+        const encoded = encode_utils_1.default.encodeCbor(obj);
+        const decoded = encode_utils_1.default.decodeCbor(encoded);
+        (0, globals_1.expect)(decoded.b).toBeInstanceOf(Uint8Array);
+        (0, globals_1.expect)(Array.from(decoded.b)).toEqual([9, 8]);
+    });
+    (0, globals_1.test)("keeps non-exact integer object keys as text string map keys", () => {
+        const decoded = encode_utils_1.default.decodeCbor(encode_utils_1.default.encodeCbor({
+            "1": false,
+            "01": true,
+            "1abc": true,
+        }));
+        (0, globals_1.expect)(decoded[1]).toBe(false);
+        (0, globals_1.expect)(decoded["01"]).toBe(true);
+        (0, globals_1.expect)(decoded["1abc"]).toBe(true);
+    });
+    (0, globals_1.test)("decodes explicit integer widths", () => {
+        (0, globals_1.expect)(encode_utils_1.default.decodeCbor(new Uint8Array([0x1a, 0x00, 0x01, 0x00, 0x00]))).toBe(0x1_0000);
+        (0, globals_1.expect)(encode_utils_1.default.decodeCbor(new Uint8Array([0x1b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00]))).toBe(0x1_0000_0000);
+        (0, globals_1.expect)(encode_utils_1.default.decodeCbor(new Uint8Array([0xf6]))).toBeNull();
+    });
+    (0, globals_1.test)("rejects unsupported values and malformed input", () => {
+        (0, globals_1.expect)(() => encode_utils_1.default.encodeCbor(Symbol("unsupported"))).toThrow("Unsupported CBOR value type: symbol");
+        (0, globals_1.expect)(() => encode_utils_1.default.encodeCbor({ value: Number.NaN })).toThrow("CBOR only supports safe integers");
+        (0, globals_1.expect)(() => encode_utils_1.default.decodeCbor(new Uint8Array())).toThrow("Insufficient data");
+        (0, globals_1.expect)(() => encode_utils_1.default.decodeCbor(new Uint8Array([0x42, 0x01]))).toThrow("Insufficient data");
+        (0, globals_1.expect)(() => encode_utils_1.default.decodeCbor(new Uint8Array([0x5f]))).toThrow("Unsupported indefinite-length CBOR data");
+        (0, globals_1.expect)(() => encode_utils_1.default.decodeCbor(new Uint8Array([0x01, 0x02]))).toThrow("Unexpected trailing CBOR data");
+        (0, globals_1.expect)(() => encode_utils_1.default.decodeCbor(new Uint8Array([0xc1, 0x01]))).toThrow("Unsupported CBOR tagged value");
+        (0, globals_1.expect)(() => encode_utils_1.default.decodeCbor(new Uint8Array([0xf8]))).toThrow("Unsupported CBOR simple value: 24");
+        (0, globals_1.expect)(() => encode_utils_1.default.decodeCbor(new Uint8Array([0xa1, 0x41, 0x01, 0x01]))).toThrow("Unsupported CBOR map key type");
+        (0, globals_1.expect)(() => encode_utils_1.default.decodeCbor(new Uint8Array([0x1b, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))).toThrow("CBOR integer exceeds JavaScript safe integer range");
+    });
+});

package/dist/src/libs/cbor.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeCbor(data: object): Uint8Array<ArrayBuffer>;
+export declare function decodeCbor<T>(data: Uint8Array<ArrayBuffer>): T;

package/dist/src/libs/cbor.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeCbor = encodeCbor;
+exports.decodeCbor = decodeCbor;
+function appendCborTypeAndLength(out, majorType, value) {
+    const prefix = majorType << 5;
+    if (value < 24) {
+        out.push(prefix | value);
+        return;
+    }
+    if (value <= 0xff) {
+        out.push(prefix | 24, value);
+        return;
+    }
+    if (value <= 0xffff) {
+        out.push(prefix | 25, value >> 8, value & 0xff);
+        return;
+    }
+    if (value <= 0xffffffff) {
+        out.push(prefix | 26, (value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff);
+        return;
+    }
+    const bigValue = BigInt(value);
+    out.push(prefix | 27);
+    for (let shift = 56n; shift >= 0n; shift -= 8n) {
+        out.push(Number((bigValue >> shift) & 0xffn));
+    }
+}
+function appendCborByteString(out, data) {
+    appendCborTypeAndLength(out, 2, data.byteLength);
+    out.push(...data);
+}
+function objectKeyToCborMapKey(key) {
+    const numberKey = Number(key);
+    return Number.isSafeInteger(numberKey) && String(numberKey) === key ? numberKey : key;
+}
+function appendCborValue(out, value) {
+    if (value instanceof Uint8Array) {
+        appendCborByteString(out, value);
+        return;
+    }
+    if (value instanceof ArrayBuffer) {
+        appendCborByteString(out, new Uint8Array(value));
+        return;
+    }
+    if (Array.isArray(value)) {
+        appendCborTypeAndLength(out, 4, value.length);
+        for (const item of value)
+            appendCborValue(out, item);
+        return;
+    }
+    switch (typeof value) {
+        case "number":
+            if (!Number.isSafeInteger(value))
+                throw new Error("CBOR only supports safe integers");
+            if (value >= 0) {
+                appendCborTypeAndLength(out, 0, value);
+            }
+            else {
+                appendCborTypeAndLength(out, 1, -1 - value);
+            }
+            return;
+        case "string": {
+            const encoded = new TextEncoder().encode(value);
+            appendCborTypeAndLength(out, 3, encoded.byteLength);
+            out.push(...encoded);
+            return;
+        }
+        case "boolean":
+            out.push(value ? 0xf5 : 0xf4);
+            return;
+        case "undefined":
+            out.push(0xf7);
+            return;
+        case "object":
+            if (value === null) {
+                out.push(0xf6);
+                return;
+            }
+            break;
+        default:
+            throw new Error(`Unsupported CBOR value type: ${typeof value}`);
+    }
+    const entries = Object.entries(value);
+    appendCborTypeAndLength(out, 5, entries.length);
+    for (const [k, v] of entries) {
+        appendCborValue(out, objectKeyToCborMapKey(k));
+        appendCborValue(out, v);
+    }
+}
+function encodeCbor(data) {
+    const out = [];
+    appendCborValue(out, data);
+    return new Uint8Array(out);
+}
+class CborReader {
+    data;
+    offset = 0;
+    textDecoder = new TextDecoder("utf-8", { fatal: true });
+    constructor(data) {
+        this.data = data;
+    }
+    read() {
+        const value = this.readValue();
+        if (this.offset !== this.data.byteLength) {
+            throw new Error("Unexpected trailing CBOR data");
+        }
+        return value;
+    }
+    readValue() {
+        const initialByte = this.readByte();
+        const majorType = initialByte >> 5;
+        const additionalInfo = initialByte & 0x1f;
+        switch (majorType) {
+            case 0:
+                return this.readLength(additionalInfo);
+            case 1:
+                return -1 - this.readLength(additionalInfo);
+            case 2:
+                return this.readByteString(this.readLength(additionalInfo));
+            case 3:
+                return this.readTextString(this.readLength(additionalInfo));
+            case 4:
+                return this.readArray(this.readLength(additionalInfo));
+            case 5:
+                return this.readMap(this.readLength(additionalInfo));
+            case 6:
+                throw new Error("Unsupported CBOR tagged value");
+            case 7:
+                return this.readSimpleValue(additionalInfo);
+        }
+    }
+    readByte() {
+        if (this.offset >= this.data.byteLength) {
+            throw new Error("Insufficient data");
+        }
+        return this.data[this.offset++];
+    }
+    readBytes(length) {
+        if (this.offset + length > this.data.byteLength) {
+            throw new Error("Insufficient data");
+        }
+        const bytes = this.data.slice(this.offset, this.offset + length);
+        this.offset += length;
+        return bytes;
+    }
+    readLength(additionalInfo) {
+        if (additionalInfo < 24)
+            return additionalInfo;
+        if (additionalInfo === 24)
+            return this.readByte();
+        if (additionalInfo === 25)
+            return (this.readByte() << 8) | this.readByte();
+        if (additionalInfo === 26) {
+            return this.readByte() * 0x1000000 + ((this.readByte() << 16) | (this.readByte() << 8) | this.readByte());
+        }
+        if (additionalInfo === 27) {
+            let value = 0n;
+            for (let i = 0; i < 8; i++) {
+                value = (value << 8n) | BigInt(this.readByte());
+            }
+            if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw new Error("CBOR integer exceeds JavaScript safe integer range");
+            }
+            return Number(value);
+        }
+        throw new Error("Unsupported indefinite-length CBOR data");
+    }
+    readByteString(length) {
+        return this.readBytes(length);
+    }
+    readTextString(length) {
+        return this.textDecoder.decode(this.readBytes(length));
+    }
+    readArray(length) {
+        const values = [];
+        for (let i = 0; i < length; i++) {
+            values.push(this.readValue());
+        }
+        return values;
+    }
+    readMap(length) {
+        const value = {};
+        for (let i = 0; i < length; i++) {
+            const key = this.readValue();
+            if (typeof key !== "string" && typeof key !== "number") {
+                throw new Error("Unsupported CBOR map key type");
+            }
+            value[key] = this.readValue();
+        }
+        return value;
+    }
+    readSimpleValue(additionalInfo) {
+        switch (additionalInfo) {
+            case 20:
+                return false;
+            case 21:
+                return true;
+            case 22:
+                return null;
+            case 23:
+                return undefined;
+            default:
+                throw new Error(`Unsupported CBOR simple value: ${additionalInfo}`);
+        }
+    }
+}
+function decodeCbor(data) {
+    return new CborReader(data).read();
+}

package/dist/src/libs/encode-utils.d.ts

@@ -1,9 +1,8 @@
+import { decodeCbor, encodeCbor } from "./cbor";
 declare function encodeBase64Url(data: BufferSource): string;
 declare function decodeBase64Url(base64Url: string): Uint8Array<ArrayBuffer>;
 declare function bufferSourceToUint8Array(data: BufferSource): Uint8Array<ArrayBuffer>;
 declare function strToUint8Array(data: string): Uint8Array<ArrayBuffer>;
-declare function encodeCbor(data: object): Uint8Array<ArrayBuffer>;
-declare function decodeCbor<T>(data: Uint8Array<ArrayBuffer>): T;
 declare const EncodeUtils: {
     strToUint8Array: typeof strToUint8Array;
     bufferSourceToUint8Array: typeof bufferSourceToUint8Array;

package/dist/src/libs/encode-utils.js

@@ -1,9 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const cbor_1 = __importDefault(require("cbor"));
+const cbor_1 = require("./cbor");
 function encodeBase64Url(data) {
     const buffer = bufferSourceToUint8Array(data);
     let binaryString = "";
@@ -29,70 +26,12 @@ function bufferSourceToUint8Array(data) {
 function strToUint8Array(data) {
     return new Uint8Array(data.split("").map((c) => c.charCodeAt(0)));
 }
-function encodeCbor(data) {
-    function encoder(value) {
-        if (value instanceof Buffer) {
-            return value;
-        }
-        if (value instanceof Uint8Array) {
-            return Buffer.from(value);
-        }
-        if (value instanceof ArrayBuffer) {
-            return Buffer.from(value);
-        }
-        if (Array.isArray(value)) {
-            return value.map((v) => encoder(v));
-        }
-        if (typeof value === "object" && value !== null) {
-            const encodedData = new Map();
-            for (const [k, v] of Object.entries(value)) {
-                const ki = Number.parseInt(k, 10);
-                if (Number.isNaN(ki)) {
-                    encodedData.set(k, encoder(v));
-                }
-                else {
-                    encodedData.set(ki, encoder(v));
-                }
-            }
-            return encodedData;
-        }
-        return value;
-    }
-    return new Uint8Array(cbor_1.default.encode(encoder(data)));
-}
-function decodeCbor(data) {
-    const canonicalData = cbor_1.default.decode(data);
-    function decoder(value) {
-        if (value instanceof Buffer) {
-            return new Uint8Array(value);
-        }
-        if (Array.isArray(value)) {
-            return value.map((v) => decoder(v));
-        }
-        if (value instanceof Map) {
-            const decodedData = {};
-            for (const [k, v] of value) {
-                Object.assign(decodedData, { [k]: decoder(v) });
-            }
-            return decodedData;
-        }
-        if (typeof value === "object" && value !== null) {
-            const decodedData = {};
-            for (const [k, v] of Object.entries(value)) {
-                Object.assign(decodedData, { [k]: decoder(v) });
-            }
-            return decodedData;
-        }
-        return value;
-    }
-    return decoder(canonicalData);
-}
 const EncodeUtils = {
     strToUint8Array,
     bufferSourceToUint8Array,
     encodeBase64Url,
     decodeBase64Url,
-    encodeCbor,
-    decodeCbor,
+    encodeCbor: cbor_1.encodeCbor,
+    decodeCbor: cbor_1.decodeCbor,
 };
 exports.default = EncodeUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nid-webauthn-emulator",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "keywords": [
     "test",
     "e2e",
@@ -18,19 +18,18 @@
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "devDependencies": {
-    "@biomejs/biome": "^2.4.9",
-    "@jest/globals": "^30.3.0",
-    "@simplewebauthn/server": "^13.3.0",
-    "@tsconfig/recommended": "^1.0.13",
-    "@types/node": "^25.5.0",
-    "jest": "^30.3.0",
-    "ts-jest": "^29.4.6",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
+    "@biomejs/biome": "2.4.15",
+    "@jest/globals": "30.4.1",
+    "@simplewebauthn/server": "13.3.0",
+    "@tsconfig/recommended": "1.0.13",
+    "@types/node": "25.9.1",
+    "jest": "30.4.2",
+    "ts-jest": "29.4.11",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3"
   },
   "dependencies": {
-    "cbor": "^10.0.12",
-    "tldts": "^7.0.27"
+    "tldts": "7.1.2"
   },
   "scripts": {
     "check": "biome check .",

package/dist/spec/libs/encode-utils.spec.js

@@ -1,38 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const globals_1 = require("@jest/globals");
-const encode_utils_1 = __importDefault(require("../../src/libs/encode-utils"));
-(0, globals_1.describe)("EncodeUtils encodeCbor/decodeCbor edge cases", () => {
-    (0, globals_1.test)("handles ArrayBuffer values within objects and arrays", () => {
-        const ab = new Uint8Array([1, 2, 3]).buffer; // ArrayBuffer branch
-        const ua = new Uint8Array([4, 5]);
-        const obj = {
-            v1: ab,
-            v2: ua,
-            arr: [ab, ua],
-        };
-        const encoded = encode_utils_1.default.encodeCbor(obj);
-        const decoded = encode_utils_1.default.decodeCbor(encoded);
-        // ArrayBuffer is decoded back to Uint8Array
-        (0, globals_1.expect)(decoded.v1).toBeInstanceOf(Uint8Array);
-        (0, globals_1.expect)(Array.from(decoded.v1)).toEqual([1, 2, 3]);
-        // Existing Uint8Array round-trips
-        (0, globals_1.expect)(Array.from(decoded.v2)).toEqual([4, 5]);
-        // Mixed array elements preserved as Uint8Array
-        (0, globals_1.expect)(Array.isArray(decoded.arr)).toBe(true);
-        const [a0, a1] = decoded.arr;
-        (0, globals_1.expect)(Array.from(a0)).toEqual([1, 2, 3]);
-        (0, globals_1.expect)(Array.from(a1)).toEqual([4, 5]);
-    });
-    (0, globals_1.test)("handles Buffer values without conversion in encoder and to Uint8Array on decode", () => {
-        const buf = Buffer.from([9, 8]);
-        const obj = { b: buf };
-        const encoded = encode_utils_1.default.encodeCbor(obj);
-        const decoded = encode_utils_1.default.decodeCbor(encoded);
-        (0, globals_1.expect)(decoded.b).toBeInstanceOf(Uint8Array);
-        (0, globals_1.expect)(Array.from(decoded.b)).toEqual([9, 8]);
-    });
-});