@moq-web/cat 0.1.0

package/dist/cbor.js

@@ -0,0 +1,379 @@
+// SPDX-FileCopyrightText: Copyright (c) 2025 Cisco Systems
+// SPDX-License-Identifier: BSD-2-Clause
+// ============================================================================
+// Constants
+// ============================================================================
+const MAX_SAFE_DECODE_DEPTH = 32;
+const MAX_ENCODE_DEPTH = 32;
+const MAX_DECODE_LENGTH = 1_048_576; // 1 MiB
+// ============================================================================
+// Encoder
+// ============================================================================
+/**
+ * Encode a CBOR value to bytes.
+ */
+export function cborEncode(value) {
+    const parts = [];
+    encodeValue(parts, value, 0);
+    return concatenate(parts);
+}
+/**
+ * Encode a CBOR tagged value.
+ */
+export function cborEncodeTagged(tag, value) {
+    const parts = [];
+    parts.push(encodeHead(6, tag));
+    encodeValue(parts, value, 0);
+    return concatenate(parts);
+}
+function encodeValue(parts, value, depth) {
+    if (depth > MAX_ENCODE_DEPTH) {
+        throw new CborError('CBOR encoding depth exceeded');
+    }
+    if (value === null) {
+        parts.push(new Uint8Array([0xf6])); // simple(22)
+        return;
+    }
+    if (value === true) {
+        parts.push(new Uint8Array([0xf5])); // simple(21)
+        return;
+    }
+    if (value === false) {
+        parts.push(new Uint8Array([0xf4])); // simple(20)
+        return;
+    }
+    if (typeof value === 'number') {
+        // L3: Reject numbers that exceed safe integer range for encoding
+        if (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER) {
+            throw new CborError('Number exceeds safe integer range; use bigint for values > 2^53');
+        }
+        if (value >= 0) {
+            parts.push(encodeHead(0, value));
+        }
+        else {
+            parts.push(encodeHead(1, -1 - value));
+        }
+        return;
+    }
+    if (typeof value === 'bigint') {
+        if (value >= 0n) {
+            parts.push(encodeHeadBigInt(0, value));
+        }
+        else {
+            parts.push(encodeHeadBigInt(1, -1n - value));
+        }
+        return;
+    }
+    if (typeof value === 'string') {
+        const encoded = new TextEncoder().encode(value);
+        parts.push(encodeHead(3, encoded.length));
+        parts.push(encoded);
+        return;
+    }
+    if (value instanceof Uint8Array) {
+        parts.push(encodeHead(2, value.length));
+        parts.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        parts.push(encodeHead(4, value.length));
+        for (const item of value) {
+            encodeValue(parts, item, depth + 1);
+        }
+        return;
+    }
+    if (value instanceof Map) {
+        // Deterministic encoding: sort by encoded key bytes (CBOR canonical)
+        const entries = Array.from(value.entries());
+        const encodedEntries = [];
+        for (const [key, val] of entries) {
+            const keyParts = [];
+            encodeValue(keyParts, key, depth + 1);
+            encodedEntries.push({ keyBytes: concatenate(keyParts), key, val });
+        }
+        // Sort by encoded key bytes (length first, then lexicographic)
+        encodedEntries.sort((a, b) => {
+            if (a.keyBytes.length !== b.keyBytes.length)
+                return a.keyBytes.length - b.keyBytes.length;
+            for (let i = 0; i < a.keyBytes.length; i++) {
+                if (a.keyBytes[i] !== b.keyBytes[i])
+                    return a.keyBytes[i] - b.keyBytes[i];
+            }
+            return 0;
+        });
+        parts.push(encodeHead(5, encodedEntries.length));
+        for (const entry of encodedEntries) {
+            parts.push(entry.keyBytes);
+            encodeValue(parts, entry.val, depth + 1);
+        }
+        return;
+    }
+    throw new CborError(`Unsupported CBOR value type: ${typeof value}`);
+}
+/**
+ * Encode CBOR major type + argument header.
+ */
+function encodeHead(majorType, value) {
+    const mt = majorType << 5;
+    if (value < 24) {
+        return new Uint8Array([mt | value]);
+    }
+    if (value < 0x100) {
+        return new Uint8Array([mt | 24, value]);
+    }
+    if (value < 0x10000) {
+        return new Uint8Array([mt | 25, (value >> 8) & 0xff, value & 0xff]);
+    }
+    if (value < 0x100000000) {
+        return new Uint8Array([
+            mt | 26,
+            (value >> 24) & 0xff,
+            (value >> 16) & 0xff,
+            (value >> 8) & 0xff,
+            value & 0xff,
+        ]);
+    }
+    // 8-byte encoding — use BigInt path for precision safety
+    return encodeHeadBigInt(majorType, BigInt(value));
+}
+/**
+ * Encode CBOR major type + argument header for bigint values.
+ */
+function encodeHeadBigInt(majorType, value) {
+    if (value < 24n) {
+        return new Uint8Array([(majorType << 5) | Number(value)]);
+    }
+    if (value < 0x100n) {
+        return new Uint8Array([(majorType << 5) | 24, Number(value)]);
+    }
+    if (value < 0x10000n) {
+        const n = Number(value);
+        return new Uint8Array([(majorType << 5) | 25, (n >> 8) & 0xff, n & 0xff]);
+    }
+    if (value < 0x100000000n) {
+        const n = Number(value);
+        return new Uint8Array([
+            (majorType << 5) | 26,
+            (n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff,
+        ]);
+    }
+    const buf = new Uint8Array(9);
+    buf[0] = (majorType << 5) | 27;
+    const view = new DataView(buf.buffer);
+    view.setBigUint64(1, value, false);
+    return buf;
+}
+// ============================================================================
+// Decoder
+// ============================================================================
+/**
+ * Decode a CBOR value from bytes.
+ *
+ * @param data - The CBOR bytes
+ * @param offset - Starting offset (default 0)
+ * @returns Decoded value and number of bytes consumed
+ */
+export function cborDecode(data, offset = 0) {
+    if (data.length === 0 || offset >= data.length) {
+        throw new CborError('Empty CBOR input');
+    }
+    const result = decodeValue(data, offset, 0);
+    return { value: result.value, bytesRead: result.offset - offset };
+}
+/**
+ * Decode a CBOR tagged value. If the data starts with a tag, returns the tag
+ * and inner value. Otherwise returns tag=-1 and the decoded value.
+ */
+export function cborDecodeTagged(data, offset = 0) {
+    if (offset >= data.length) {
+        throw new CborError('Empty CBOR input');
+    }
+    const initial = data[offset];
+    const majorType = initial >> 5;
+    if (majorType === 6) {
+        // Tag
+        const { value: tag, newOffset } = readArgument(data, offset);
+        const inner = decodeValue(data, newOffset, 0);
+        return { tag: Number(tag), value: inner.value, bytesRead: inner.offset - offset };
+    }
+    const result = decodeValue(data, offset, 0);
+    return { tag: -1, value: result.value, bytesRead: result.offset - offset };
+}
+function decodeValue(data, offset, depth) {
+    if (depth > MAX_SAFE_DECODE_DEPTH) {
+        throw new CborError('CBOR nesting depth exceeded');
+    }
+    if (offset >= data.length) {
+        throw new CborError('Unexpected end of CBOR data');
+    }
+    const initial = data[offset];
+    const majorType = initial >> 5;
+    switch (majorType) {
+        case 0: { // unsigned integer
+            const { value, newOffset } = readArgument(data, offset);
+            return { value: value <= Number.MAX_SAFE_INTEGER ? Number(value) : value, offset: newOffset };
+        }
+        case 1: { // negative integer
+            const { value, newOffset } = readArgument(data, offset);
+            if (value <= Number.MAX_SAFE_INTEGER) {
+                return { value: -1 - Number(value), offset: newOffset };
+            }
+            return { value: -1n - value, offset: newOffset };
+        }
+        case 2: { // byte string
+            const { value: len, newOffset } = readArgument(data, offset);
+            const length = Number(len);
+            validateLength(length, data.length - newOffset);
+            const bytes = data.slice(newOffset, newOffset + length);
+            return { value: bytes, offset: newOffset + length };
+        }
+        case 3: { // text string
+            const { value: len, newOffset } = readArgument(data, offset);
+            const length = Number(len);
+            validateLength(length, data.length - newOffset);
+            const bytes = data.slice(newOffset, newOffset + length);
+            return { value: new TextDecoder().decode(bytes), offset: newOffset + length };
+        }
+        case 4: { // array
+            const { value: len, newOffset } = readArgument(data, offset);
+            const length = Number(len);
+            if (length > MAX_DECODE_LENGTH) {
+                throw new CborError(`Array too large: ${length}`);
+            }
+            const arr = [];
+            let pos = newOffset;
+            for (let i = 0; i < length; i++) {
+                const item = decodeValue(data, pos, depth + 1);
+                arr.push(item.value);
+                pos = item.offset;
+            }
+            return { value: arr, offset: pos };
+        }
+        case 5: { // map
+            const { value: len, newOffset } = readArgument(data, offset);
+            const length = Number(len);
+            if (length > MAX_DECODE_LENGTH) {
+                throw new CborError(`Map too large: ${length}`);
+            }
+            const map = new Map();
+            let pos = newOffset;
+            for (let i = 0; i < length; i++) {
+                const keyResult = decodeValue(data, pos, depth + 1);
+                const key = keyResult.value;
+                pos = keyResult.offset;
+                const valResult = decodeValue(data, pos, depth + 1);
+                pos = valResult.offset;
+                let mapKey;
+                if (typeof key === 'number' || typeof key === 'string') {
+                    mapKey = key;
+                }
+                else if (typeof key === 'bigint') {
+                    mapKey = Number(key);
+                }
+                else {
+                    throw new CborError(`Unsupported map key type: ${typeof key}`);
+                }
+                // Reject duplicate map keys (RFC 8949 Section 5.6)
+                if (map.has(mapKey)) {
+                    throw new CborError(`Duplicate CBOR map key: ${mapKey}`);
+                }
+                map.set(mapKey, valResult.value);
+            }
+            return { value: map, offset: pos };
+        }
+        case 6: { // tag — reject unknown tags in security context
+            const { value: tagNum, newOffset } = readArgument(data, offset);
+            const tag = Number(tagNum);
+            // Only allow COSE_Sign1 tag (18) — reject all others
+            if (tag !== 18) {
+                throw new CborError(`Unsupported CBOR tag: ${tag}`);
+            }
+            const inner = decodeValue(data, newOffset, depth + 1);
+            return { value: inner.value, offset: inner.offset };
+        }
+        case 7: { // simple values
+            const additionalInfo = initial & 0x1f;
+            if (additionalInfo === 20)
+                return { value: false, offset: offset + 1 };
+            if (additionalInfo === 21)
+                return { value: true, offset: offset + 1 };
+            if (additionalInfo === 22)
+                return { value: null, offset: offset + 1 };
+            // Float16/32/64 not supported
+            if (additionalInfo >= 25 && additionalInfo <= 27) {
+                throw new CborError('Float CBOR values not supported');
+            }
+            return { value: additionalInfo, offset: offset + 1 };
+        }
+        default:
+            throw new CborError(`Unknown CBOR major type: ${majorType}`);
+    }
+}
+/**
+ * Read CBOR argument (additional info + extended value).
+ */
+function readArgument(data, offset) {
+    const initial = data[offset];
+    const additionalInfo = initial & 0x1f;
+    offset++;
+    if (additionalInfo < 24) {
+        return { value: BigInt(additionalInfo), newOffset: offset };
+    }
+    if (additionalInfo === 24) {
+        if (offset >= data.length)
+            throw new CborError('Unexpected end of CBOR data');
+        return { value: BigInt(data[offset]), newOffset: offset + 1 };
+    }
+    if (additionalInfo === 25) {
+        if (offset + 2 > data.length)
+            throw new CborError('Unexpected end of CBOR data');
+        const value = (data[offset] << 8) | data[offset + 1];
+        return { value: BigInt(value), newOffset: offset + 2 };
+    }
+    if (additionalInfo === 26) {
+        if (offset + 4 > data.length)
+            throw new CborError('Unexpected end of CBOR data');
+        const value = ((data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]) >>> 0;
+        return { value: BigInt(value), newOffset: offset + 4 };
+    }
+    if (additionalInfo === 27) {
+        if (offset + 8 > data.length)
+            throw new CborError('Unexpected end of CBOR data');
+        const view = new DataView(data.buffer, data.byteOffset + offset, 8);
+        const value = view.getBigUint64(0, false);
+        return { value, newOffset: offset + 8 };
+    }
+    throw new CborError(`Invalid CBOR additional info: ${additionalInfo}`);
+}
+function validateLength(length, available) {
+    if (length > MAX_DECODE_LENGTH) {
+        throw new CborError(`Data too large: ${length}`);
+    }
+    if (length > available) {
+        throw new CborError(`Insufficient data: need ${length}, have ${available}`);
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function concatenate(parts) {
+    let totalLength = 0;
+    for (const p of parts)
+        totalLength += p.length;
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const p of parts) {
+        result.set(p, offset);
+        offset += p.length;
+    }
+    return result;
+}
+/**
+ * CBOR encoding/decoding error.
+ */
+export class CborError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CborError';
+    }
+}

package/dist/cose.d.ts

@@ -0,0 +1,67 @@
+import { CoseAlgorithm, type CoseSign1, type CborValue } from './types.js';
+/**
+ * Encode a COSE_Sign1 structure to CBOR bytes.
+ * Produces a bare 4-element array (no CBOR Tag 18) for relay compatibility.
+ */
+export declare function coseSign1Encode(sign1: CoseSign1): Uint8Array;
+/**
+ * Decode a COSE_Sign1 structure from CBOR bytes.
+ * Handles both CBOR Tag 18 and bare 4-element array.
+ *
+ * @throws {CoseError} If the data is not a valid COSE_Sign1 structure
+ */
+export declare function coseSign1Decode(data: Uint8Array): CoseSign1;
+/**
+ * Construct the Sig_structure for COSE_Sign1 signing/verification.
+ *
+ * Sig_structure = [
+ *   context : "Signature1",
+ *   body_protected : bstr,
+ *   external_aad : bstr,
+ *   payload : bstr
+ * ]
+ */
+export declare function coseSign1SigStructure(protectedHeader: Uint8Array, payload: Uint8Array, externalAAD?: Uint8Array): Uint8Array;
+/**
+ * Construct the MAC_structure for COSE_Mac0 (RFC 9052 Section 6.3).
+ *
+ * MAC_structure = [
+ *   context : "MAC0",
+ *   body_protected : bstr,
+ *   external_aad : bstr,
+ *   payload : bstr
+ * ]
+ */
+export declare function coseMac0MacStructure(protectedHeader: Uint8Array, payload: Uint8Array, externalAAD?: Uint8Array): Uint8Array;
+/**
+ * Create and sign a COSE_Sign1 or COSE_Mac0 structure.
+ * Automatically selects Sig_structure vs MAC_structure based on algorithm.
+ */
+export declare function coseSign1Sign(algorithm: CoseAlgorithm, protectedHeaders: Map<number, CborValue>, payload: Uint8Array, privateKey: CryptoKey, unprotectedHeaders?: Map<number, CborValue>): Promise<CoseSign1>;
+/**
+ * Verify the signature of a COSE_Sign1 structure.
+ *
+ * Accepts an optional `requiredAlgorithm` to prevent algorithm confusion.
+ * When provided, the token's algorithm must match exactly.
+ *
+ * Only catches DOMException from WebCrypto. Other errors propagate.
+ */
+export declare function coseSign1Verify(sign1: CoseSign1, publicKey: CryptoKey, requiredAlgorithm?: CoseAlgorithm): Promise<boolean>;
+/**
+ * Extract the algorithm from a COSE_Sign1 protected header.
+ *
+ * @throws {CoseError} If the algorithm is missing or unsupported
+ */
+export declare function coseSign1GetAlgorithm(sign1: CoseSign1): CoseAlgorithm;
+/**
+ * Decode the protected header of a COSE_Sign1 as a map.
+ *
+ * Rejects truly empty headers (0 bytes). Accepts empty CBOR map (0xa0).
+ */
+export declare function coseSign1DecodeProtectedHeader(protectedHeader: Uint8Array): Map<number, CborValue>;
+/**
+ * COSE encoding/decoding error.
+ */
+export declare class CoseError extends Error {
+    constructor(message: string);
+}

package/dist/cose.js

@@ -0,0 +1,253 @@
+// SPDX-FileCopyrightText: Copyright (c) 2025 Cisco Systems
+// SPDX-License-Identifier: BSD-2-Clause
+/**
+ * @fileoverview COSE_Sign1 Implementation (RFC 9052)
+ *
+ * Implements COSE_Sign1 structure for creating and verifying
+ * signed tokens using ECDSA (ES256/ES384/ES512) via WebCrypto.
+ */
+import { cborEncode, cborDecode, cborDecodeTagged } from './cbor.js';
+import { CoseHeaderParam, COSE_ALG_PARAMS, } from './types.js';
+/** COSE_Sign1 CBOR tag number */
+const COSE_SIGN1_TAG = 18;
+/**
+ * Convert Uint8Array to ArrayBuffer for WebCrypto API compatibility.
+ */
+function toArrayBuffer(arr) {
+    return arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
+}
+// ============================================================================
+// Encoding / Decoding
+// ============================================================================
+/**
+ * Encode a COSE_Sign1 structure to CBOR bytes.
+ * Produces a bare 4-element array (no CBOR Tag 18) for relay compatibility.
+ */
+export function coseSign1Encode(sign1) {
+    const array = [
+        sign1.protectedHeader,
+        sign1.unprotectedHeader,
+        sign1.payload,
+        sign1.signature,
+    ];
+    return cborEncode(array);
+}
+/**
+ * Decode a COSE_Sign1 structure from CBOR bytes.
+ * Handles both CBOR Tag 18 and bare 4-element array.
+ *
+ * @throws {CoseError} If the data is not a valid COSE_Sign1 structure
+ */
+export function coseSign1Decode(data) {
+    const { tag, value } = cborDecodeTagged(data);
+    // Accept both tagged (18) and bare array
+    if (tag !== -1 && tag !== COSE_SIGN1_TAG) {
+        throw new CoseError(`Unexpected CBOR tag: ${tag}, expected ${COSE_SIGN1_TAG}`);
+    }
+    if (!Array.isArray(value) || value.length !== 4) {
+        throw new CoseError(`COSE_Sign1 must be a 4-element array, got ${Array.isArray(value) ? value.length : typeof value}`);
+    }
+    const [protectedHeader, unprotectedHeader, payload, signature] = value;
+    if (!(protectedHeader instanceof Uint8Array)) {
+        throw new CoseError('COSE_Sign1 protected header must be a bstr');
+    }
+    if (!(payload instanceof Uint8Array)) {
+        throw new CoseError('COSE_Sign1 payload must be a bstr');
+    }
+    if (!(signature instanceof Uint8Array)) {
+        throw new CoseError('COSE_Sign1 signature must be a bstr');
+    }
+    // Decode unprotected header map
+    let unprotectedMap;
+    if (unprotectedHeader instanceof Map) {
+        unprotectedMap = unprotectedHeader;
+    }
+    else {
+        unprotectedMap = new Map();
+    }
+    return {
+        protectedHeader,
+        unprotectedHeader: unprotectedMap,
+        payload,
+        signature,
+    };
+}
+// ============================================================================
+// Sig_structure (RFC 9052 Section 4.4)
+// ============================================================================
+/**
+ * Construct the Sig_structure for COSE_Sign1 signing/verification.
+ *
+ * Sig_structure = [
+ *   context : "Signature1",
+ *   body_protected : bstr,
+ *   external_aad : bstr,
+ *   payload : bstr
+ * ]
+ */
+export function coseSign1SigStructure(protectedHeader, payload, externalAAD = new Uint8Array(0)) {
+    const structure = [
+        'Signature1',
+        protectedHeader,
+        externalAAD,
+        payload,
+    ];
+    return cborEncode(structure);
+}
+/**
+ * Construct the MAC_structure for COSE_Mac0 (RFC 9052 Section 6.3).
+ *
+ * MAC_structure = [
+ *   context : "MAC0",
+ *   body_protected : bstr,
+ *   external_aad : bstr,
+ *   payload : bstr
+ * ]
+ */
+export function coseMac0MacStructure(protectedHeader, payload, externalAAD = new Uint8Array(0)) {
+    const structure = [
+        'MAC0',
+        protectedHeader,
+        externalAAD,
+        payload,
+    ];
+    return cborEncode(structure);
+}
+// ============================================================================
+// Sign / Verify
+// ============================================================================
+/**
+ * Create and sign a COSE_Sign1 or COSE_Mac0 structure.
+ * Automatically selects Sig_structure vs MAC_structure based on algorithm.
+ */
+export async function coseSign1Sign(algorithm, protectedHeaders, payload, privateKey, unprotectedHeaders) {
+    const algParams = COSE_ALG_PARAMS[algorithm];
+    if (!algParams) {
+        throw new CoseError(`Unsupported COSE algorithm: ${algorithm}`);
+    }
+    // Build protected header map with algorithm
+    const headerMap = new Map(protectedHeaders);
+    headerMap.set(CoseHeaderParam.ALG, algorithm);
+    // Encode protected header to CBOR
+    const protectedHeader = cborEncode(headerMap);
+    // Construct signing/MAC input based on algorithm type
+    const toBeSigned = algParams.isMac
+        ? coseMac0MacStructure(protectedHeader, payload)
+        : coseSign1SigStructure(protectedHeader, payload);
+    // Sign or MAC with WebCrypto
+    let signatureBuffer;
+    if (algParams.isMac) {
+        signatureBuffer = await crypto.subtle.sign(algParams.name, privateKey, toArrayBuffer(toBeSigned));
+    }
+    else {
+        signatureBuffer = await crypto.subtle.sign({ name: algParams.name, hash: algParams.hash }, privateKey, toArrayBuffer(toBeSigned));
+    }
+    const signature = new Uint8Array(signatureBuffer);
+    // Validate signature/tag length
+    if (signature.length !== algParams.sigLength) {
+        throw new CoseError(`Unexpected signature length: ${signature.length}, expected ${algParams.sigLength}`);
+    }
+    return {
+        protectedHeader,
+        unprotectedHeader: unprotectedHeaders ?? new Map(),
+        payload,
+        signature,
+    };
+}
+/**
+ * Verify the signature of a COSE_Sign1 structure.
+ *
+ * Accepts an optional `requiredAlgorithm` to prevent algorithm confusion.
+ * When provided, the token's algorithm must match exactly.
+ *
+ * Only catches DOMException from WebCrypto. Other errors propagate.
+ */
+export async function coseSign1Verify(sign1, publicKey, requiredAlgorithm) {
+    // Extract algorithm from protected header
+    const algorithm = coseSign1GetAlgorithm(sign1);
+    const algParams = COSE_ALG_PARAMS[algorithm];
+    if (!algParams) {
+        return false;
+    }
+    // Enforce required algorithm if specified
+    if (requiredAlgorithm !== undefined && algorithm !== requiredAlgorithm) {
+        return false;
+    }
+    // For ECDSA: verify algorithm matches the public key's curve
+    if (!algParams.isMac) {
+        const keyAlg = publicKey.algorithm;
+        if (keyAlg.namedCurve && keyAlg.namedCurve !== algParams.namedCurve) {
+            return false;
+        }
+    }
+    // Validate signature/tag length
+    if (sign1.signature.length !== algParams.sigLength) {
+        return false;
+    }
+    // Construct signing/MAC input based on algorithm type
+    const toBeVerified = algParams.isMac
+        ? coseMac0MacStructure(sign1.protectedHeader, sign1.payload)
+        : coseSign1SigStructure(sign1.protectedHeader, sign1.payload);
+    // Only catch DOMException from WebCrypto, let other errors propagate
+    try {
+        if (algParams.isMac) {
+            return await crypto.subtle.verify(algParams.name, publicKey, // for HMAC, this is the shared secret key
+            toArrayBuffer(sign1.signature), toArrayBuffer(toBeVerified));
+        }
+        return await crypto.subtle.verify({ name: algParams.name, hash: algParams.hash }, publicKey, toArrayBuffer(sign1.signature), toArrayBuffer(toBeVerified));
+    }
+    catch (e) {
+        if (e instanceof DOMException) {
+            return false;
+        }
+        throw e;
+    }
+}
+/**
+ * Extract the algorithm from a COSE_Sign1 protected header.
+ *
+ * @throws {CoseError} If the algorithm is missing or unsupported
+ */
+export function coseSign1GetAlgorithm(sign1) {
+    // Empty protected header (zero bytes) is invalid — must contain at least an empty map
+    if (sign1.protectedHeader.length === 0) {
+        throw new CoseError('Empty protected header');
+    }
+    const decoded = cborDecode(sign1.protectedHeader);
+    if (!(decoded.value instanceof Map)) {
+        throw new CoseError('Protected header must be a CBOR map');
+    }
+    const alg = decoded.value.get(CoseHeaderParam.ALG);
+    if (alg === undefined) {
+        throw new CoseError('Algorithm (alg) not found in protected header');
+    }
+    const algValue = typeof alg === 'number' ? alg : Number(alg);
+    if (!(algValue in COSE_ALG_PARAMS)) {
+        throw new CoseError(`Unsupported algorithm: ${algValue}`);
+    }
+    return algValue;
+}
+/**
+ * Decode the protected header of a COSE_Sign1 as a map.
+ *
+ * Rejects truly empty headers (0 bytes). Accepts empty CBOR map (0xa0).
+ */
+export function coseSign1DecodeProtectedHeader(protectedHeader) {
+    if (protectedHeader.length === 0) {
+        throw new CoseError('Protected header must not be empty');
+    }
+    const decoded = cborDecode(protectedHeader);
+    if (!(decoded.value instanceof Map)) {
+        throw new CoseError('Protected header must be a CBOR map');
+    }
+    return decoded.value;
+}
+/**
+ * COSE encoding/decoding error.
+ */
+export class CoseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CoseError';
+    }
+}