ubid-common 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Paradigma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# UbID Common
+
+[![npm version](https://img.shields.io/npm/v/ubid-common.svg)](https://www.npmjs.com/package/ubid-common)
+[![license](https://img.shields.io/npm/l/ubid-common.svg)](LICENSE)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20.19-brightgreen.svg)](https://nodejs.org/)
+
+**UbID Common** is the shared TypeScript library used across the UbID digital identity ecosystem.
+
+It provides reusable components for credential parsing, rendering, verification, public-key resolution, trust evaluation, status validation, X.509 verification, schemas, interfaces, and supporting utilities.
+
+The goal of this package is to provide a single, consistent implementation of common credential and trust functionality across UbID applications, reducing duplication and helping maintain interoperability between issuers, holders, authorization components, and verifiers.
+
+---
+
+## Installation
+
+Install the public npm package:
+
+```bash
+npm install ubid-common

package/dist/ParsingEngine.d.ts

@@ -0,0 +1,3 @@
+import { ParsingEngineI } from "./interfaces";
+export declare function ParsingEngine(): ParsingEngineI;
+//# sourceMappingURL=ParsingEngine.d.ts.map

package/dist/ParsingEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsingEngine.d.ts","sourceRoot":"","sources":["../src/ParsingEngine.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,cAAc,EAAE,MAAM,cAAc,CAAC;AAGhE,wBAAgB,aAAa,IAAI,cAAc,CAuB9C"}

package/dist/ParsingEngine.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsingEngine = ParsingEngine;
+const error_1 = require("./error");
+function ParsingEngine() {
+    const parsers = [];
+    return {
+        register(parser) {
+            parsers.push(parser);
+        },
+        async parse({ rawCredential, credentialIssuer }) {
+            for (const p of parsers) {
+                const result = await p.parse({ rawCredential, credentialIssuer });
+                if (result.success) {
+                    return result;
+                }
+            }
+            return {
+                success: false,
+                error: error_1.CredentialParsingError.CouldNotParse
+            };
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGFyc2luZ0VuZ2luZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9QYXJzaW5nRW5naW5lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBSUEsc0NBdUJDO0FBM0JELG1DQUFpRDtBQUlqRCxTQUFnQixhQUFhO0lBQzVCLE1BQU0sT0FBTyxHQUF1QixFQUFFLENBQUM7SUFFdkMsT0FBTztRQUNOLFFBQVEsQ0FBQyxNQUF3QjtZQUNoQyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3RCLENBQUM7UUFFRCxLQUFLLENBQUMsS0FBSyxDQUFDLEVBQUUsYUFBYSxFQUFDLGdCQUFnQixFQUFFO1lBRTdDLEtBQUssTUFBTSxDQUFDLElBQUksT0FBTyxFQUFFLENBQUM7Z0JBQ3pCLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxDQUFDLEtBQUssQ0FBQyxFQUFFLGFBQWEsRUFBQyxnQkFBZ0IsRUFBRSxDQUFDLENBQUM7Z0JBQ2pFLElBQUksTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDO29CQUNwQixPQUFPLE1BQU0sQ0FBQztnQkFDZixDQUFDO1lBQ0YsQ0FBQztZQUNELE9BQU87Z0JBQ04sT0FBTyxFQUFFLEtBQUs7Z0JBQ2QsS0FBSyxFQUFFLDhCQUFzQixDQUFDLGFBQWE7YUFDM0MsQ0FBQTtRQUVGLENBQUM7S0FDRCxDQUFBO0FBQ0YsQ0FBQyJ9

package/dist/PublicKeyResolverEngine.d.ts

@@ -0,0 +1,3 @@
+import { PublicKeyResolverEngineI } from "./interfaces";
+export declare function PublicKeyResolverEngine(): PublicKeyResolverEngineI;
+//# sourceMappingURL=PublicKeyResolverEngine.d.ts.map

package/dist/PublicKeyResolverEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PublicKeyResolverEngine.d.ts","sourceRoot":"","sources":["../src/PublicKeyResolverEngine.ts"],"names":[],"mappings":"AACA,OAAO,EAAiD,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAEvG,wBAAgB,uBAAuB,IAAI,wBAAwB,CAmBlE"}

package/dist/PublicKeyResolverEngine.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicKeyResolverEngine = PublicKeyResolverEngine;
+const error_1 = require("./error");
+function PublicKeyResolverEngine() {
+    const resolvers = [];
+    return {
+        register(resolver) {
+            resolvers.push(resolver);
+        },
+        async resolve(request) {
+            let lastError = error_1.PublicKeyResolutionError.CannotResolvePublicKey;
+            for (const r of resolvers) {
+                const result = await r.resolve(request);
+                if (result.success) {
+                    return result;
+                }
+                lastError = result.error;
+            }
+            return { success: false, error: lastError };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUHVibGljS2V5UmVzb2x2ZXJFbmdpbmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvUHVibGljS2V5UmVzb2x2ZXJFbmdpbmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSwwREFtQkM7QUF0QkQsbUNBQW1EO0FBR25ELFNBQWdCLHVCQUF1QjtJQUN0QyxNQUFNLFNBQVMsR0FBd0IsRUFBRSxDQUFDO0lBRTFDLE9BQU87UUFDTixRQUFRLENBQUMsUUFBMkI7WUFDbkMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUMxQixDQUFDO1FBQ0QsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFtQztZQUNoRCxJQUFJLFNBQVMsR0FBRyxnQ0FBd0IsQ0FBQyxzQkFBc0IsQ0FBQztZQUNoRSxLQUFLLE1BQU0sQ0FBQyxJQUFJLFNBQVMsRUFBRSxDQUFDO2dCQUMzQixNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7Z0JBQ3hDLElBQUksTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDO29CQUNwQixPQUFPLE1BQU0sQ0FBQztnQkFDZixDQUFDO2dCQUNELFNBQVMsR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDO1lBQzFCLENBQUM7WUFDRCxPQUFPLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsU0FBUyxFQUFFLENBQUM7UUFDN0MsQ0FBQztLQUNELENBQUE7QUFDRixDQUFDIn0=

package/dist/VerifyingEngine.d.ts

@@ -0,0 +1,3 @@
+import { VerifyingEngineI } from "./interfaces";
+export declare function VerifyingEngine(): VerifyingEngineI;
+//# sourceMappingURL=VerifyingEngine.d.ts.map

package/dist/VerifyingEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VerifyingEngine.d.ts","sourceRoot":"","sources":["../src/VerifyingEngine.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKpE,wBAAgB,eAAe,IAAI,gBAAgB,CA8BlD"}

package/dist/VerifyingEngine.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyingEngine = VerifyingEngine;
+const error_1 = require("./error");
+function VerifyingEngine() {
+    const verifiers = [];
+    return {
+        register(credentialVerifier) {
+            verifiers.push(credentialVerifier);
+        },
+        async verify({ rawCredential, opts }) {
+            let lastError = null;
+            for (const v of verifiers) {
+                const result = await v.verify({ rawCredential, opts });
+                if (result.success) {
+                    return result;
+                }
+                lastError = result.error;
+            }
+            return {
+                success: false,
+                error: lastError ? lastError : error_1.CredentialVerificationError.UnknownProblem
+            };
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVmVyaWZ5aW5nRW5naW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL1ZlcmlmeWluZ0VuZ2luZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLDBDQThCQztBQXBDRCxtQ0FBc0Q7QUFNdEQsU0FBZ0IsZUFBZTtJQUM5QixNQUFNLFNBQVMsR0FBeUIsRUFBRSxDQUFDO0lBRTNDLE9BQU87UUFDTixRQUFRLENBQUMsa0JBQXNDO1lBQzlDLFNBQVMsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQztRQUNwQyxDQUFDO1FBRUQsS0FBSyxDQUFDLE1BQU0sQ0FBQyxFQUFFLGFBQWEsRUFBRSxJQUFJLEVBTWpDO1lBQ0EsSUFBSSxTQUFTLEdBQXVDLElBQUksQ0FBQztZQUN6RCxLQUFLLE1BQU0sQ0FBQyxJQUFJLFNBQVMsRUFBRSxDQUFDO2dCQUMzQixNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxhQUFhLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztnQkFDdkQsSUFBSSxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7b0JBQ3BCLE9BQU8sTUFBTSxDQUFDO2dCQUNmLENBQUM7Z0JBQ0QsU0FBUyxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUM7WUFDMUIsQ0FBQztZQUVELE9BQU87Z0JBQ04sT0FBTyxFQUFFLEtBQUs7Z0JBQ2QsS0FBSyxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxtQ0FBMkIsQ0FBQyxjQUFjO2FBQ3pFLENBQUE7UUFDRixDQUFDO0tBQ0QsQ0FBQTtBQUNGLENBQUMifQ==

package/dist/credential-parsers/MsoMdocParser.d.ts

@@ -0,0 +1,6 @@
+import { Context, CredentialParser, HttpClient } from "../interfaces";
+export declare function MsoMdocParser(args: {
+    context: Context;
+    httpClient: HttpClient;
+}): CredentialParser;
+//# sourceMappingURL=MsoMdocParser.d.ts.map

package/dist/credential-parsers/MsoMdocParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MsoMdocParser.d.ts","sourceRoot":"","sources":["../../src/credential-parsers/MsoMdocParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAwB,MAAM,eAAe,CAAC;AAe5F,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,GAAG,gBAAgB,CAmMlG"}

package/dist/credential-parsers/MsoMdocParser.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsoMdocParser = MsoMdocParser;
+const error_1 = require("../error");
+const mdl_1 = require("@auth0/mdl");
+const util_1 = require("../utils/util");
+const types_1 = require("../types");
+const cbor_1 = require("@auth0/mdl/lib/cbor");
+const openID4VCICredentialRendering_1 = require("../functions/openID4VCICredentialRendering");
+const getIssuerMetadata_1 = require("../utils/getIssuerMetadata");
+const convertOpenid4vciToSdjwtvcClaims_1 = require("../functions/convertOpenid4vciToSdjwtvcClaims");
+const matchLocalizedDisplay_1 = require("../utils/matchLocalizedDisplay");
+function MsoMdocParser(args) {
+    function extractValidityInfo(issuerSigned) {
+        return issuerSigned.issuerAuth.decodedPayload.validityInfo;
+    }
+    function collectAllAttrValues(parsedDocument) {
+        return parsedDocument.issuerSignedNameSpaces.reduce((acc, ns) => {
+            acc[ns] = parsedDocument.getIssuerNameSpace(ns);
+            return acc;
+        }, {});
+    }
+    async function fetchIssuerMetadataAndDocs(credentialIssuer) {
+        let issuerMetadata = null;
+        let TypeMetadata = {};
+        try {
+            if (credentialIssuer?.credentialIssuerIdentifier) {
+                const { metadata } = await (0, getIssuerMetadata_1.getIssuerMetadata)(args.httpClient, credentialIssuer.credentialIssuerIdentifier, []);
+                issuerMetadata = metadata ?? null;
+                const issuerClaimsArray = credentialIssuer?.credentialConfigurationId
+                    ? issuerMetadata?.credential_configurations_supported?.[credentialIssuer.credentialConfigurationId]?.claims
+                    : undefined;
+                const convertedClaims = issuerClaimsArray ? (0, convertOpenid4vciToSdjwtvcClaims_1.convertOpenid4vciToSdjwtvcClaims)(issuerClaimsArray) : undefined;
+                if (convertedClaims?.length) {
+                    TypeMetadata = { claims: convertedClaims };
+                }
+            }
+        }
+        catch (e) {
+            console.warn("Issuer metadata unavailable or invalid:", e);
+        }
+        return { issuerMetadata, TypeMetadata };
+    }
+    function makeCredentialFriendlyName(issuerMetadata, credentialIssuer) {
+        return async (preferredLangs = ["en-US"]) => {
+            const issuerDisplayArray = credentialIssuer?.credentialConfigurationId
+                ? issuerMetadata?.credential_configurations_supported?.[credentialIssuer.credentialConfigurationId]?.display
+                : undefined;
+            const issuerDisplayLocalized = (0, matchLocalizedDisplay_1.matchDisplayByLocale)(issuerDisplayArray, preferredLangs);
+            if (issuerDisplayLocalized?.name)
+                return issuerDisplayLocalized.name;
+            return "mdoc Verifiable Credential";
+        };
+    }
+    function makeDataUri(renderer, signedClaims, issuerMetadata, credentialIssuer) {
+        const mdocDisplayConfig = { name: "mdoc Verifiable Credential" };
+        return async (filter, preferredLangs = ["en-US"]) => {
+            try {
+                const issuerDisplayArray = credentialIssuer?.credentialConfigurationId
+                    ? issuerMetadata?.credential_configurations_supported?.[credentialIssuer.credentialConfigurationId]?.display
+                    : undefined;
+                const issuerDisplayLocalized = (0, matchLocalizedDisplay_1.matchDisplayByLocale)(issuerDisplayArray, preferredLangs);
+                return await renderer.renderCustomSvgTemplate({ signedClaims, displayConfig: issuerDisplayLocalized ?? mdocDisplayConfig });
+            }
+            catch (err) {
+                console.error(err);
+                return null;
+            }
+        };
+    }
+    function toParsedCredential(parsedDocument, signedClaims, TypeMetadata, credentialFriendlyName, dataUri) {
+        return {
+            metadata: {
+                credential: {
+                    format: types_1.VerifiableCredentialFormat.MSO_MDOC,
+                    doctype: parsedDocument.docType,
+                    TypeMetadata,
+                    image: { dataUri },
+                    name: credentialFriendlyName
+                },
+                issuer: {
+                    id: parsedDocument.issuerSigned.issuerAuth.certificate.issuer,
+                    name: parsedDocument.issuerSigned.issuerAuth.certificate.issuer
+                }
+            },
+            signedClaims: { ...signedClaims },
+            validityInfo: { ...extractValidityInfo(parsedDocument.issuerSigned) }
+        };
+    }
+    async function deviceResponseParser(rawCredential, credentialIssuer) {
+        try {
+            const decodedCred = (0, util_1.fromBase64Url)(rawCredential);
+            const parsedMDOC = (0, mdl_1.parse)(decodedCred);
+            const [parsedDocument] = parsedMDOC.documents;
+            const signedClaims = collectAllAttrValues(parsedDocument);
+            const renderer = (0, openID4VCICredentialRendering_1.OpenID4VCICredentialRendering)({ httpClient: args.httpClient });
+            const { issuerMetadata, TypeMetadata } = await fetchIssuerMetadataAndDocs(credentialIssuer);
+            const credentialFriendlyName = makeCredentialFriendlyName(issuerMetadata, credentialIssuer);
+            const dataUri = makeDataUri(renderer, {}, issuerMetadata, credentialIssuer);
+            return toParsedCredential(parsedDocument, signedClaims, TypeMetadata, credentialFriendlyName, dataUri);
+        }
+        catch {
+            return null;
+        }
+    }
+    async function issuerSignedParser(rawCredential, credentialIssuer) {
+        try {
+            const credentialBytes = (0, util_1.fromBase64Url)(rawCredential);
+            const issuerSigned = (0, cbor_1.cborDecode)(credentialBytes);
+            const [header, _, payload, sig] = issuerSigned.get('issuerAuth');
+            const decodedIssuerAuthPayload = (0, cbor_1.cborDecode)(payload);
+            const docType = decodedIssuerAuthPayload.data.get('docType');
+            const m = {
+                version: '1.0',
+                documents: [new Map([
+                        ['docType', docType],
+                        ['issuerSigned', issuerSigned]
+                    ])],
+                status: 0
+            };
+            const encoded = (0, cbor_1.cborEncode)(m);
+            const mdoc = (0, mdl_1.parse)(encoded);
+            const [parsedDocument] = mdoc.documents;
+            const signedClaims = collectAllAttrValues(parsedDocument);
+            const renderer = (0, openID4VCICredentialRendering_1.OpenID4VCICredentialRendering)({ httpClient: args.httpClient });
+            const { issuerMetadata, TypeMetadata } = await fetchIssuerMetadataAndDocs(credentialIssuer);
+            const credentialFriendlyName = makeCredentialFriendlyName(issuerMetadata, credentialIssuer);
+            const dataUri = makeDataUri(renderer, {}, issuerMetadata, credentialIssuer);
+            return toParsedCredential(parsedDocument, signedClaims, TypeMetadata, credentialFriendlyName, dataUri);
+        }
+        catch {
+            return null;
+        }
+    }
+    return {
+        async parse({ rawCredential, credentialIssuer }) {
+            if (typeof rawCredential != 'string') {
+                return {
+                    success: false,
+                    error: error_1.CredentialParsingError.InvalidDatatype,
+                };
+            }
+            const deviceResponseParsingResult = await deviceResponseParser(rawCredential, credentialIssuer ?? null);
+            if (deviceResponseParsingResult) {
+                return {
+                    success: true,
+                    value: deviceResponseParsingResult
+                };
+            }
+            const issuerSignedParsingResult = await issuerSignedParser(rawCredential, credentialIssuer ?? null);
+            if (issuerSignedParsingResult) {
+                return {
+                    success: true,
+                    value: issuerSignedParsingResult,
+                };
+            }
+            return {
+                success: false,
+                error: error_1.CredentialParsingError.CouldNotParse,
+            };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/credential-parsers/SDJWTVCParser.d.ts

@@ -0,0 +1,6 @@
+import { Context, CredentialParser, HttpClient } from "../interfaces";
+export declare function SDJWTVCParser(args: {
+    context: Context;
+    httpClient: HttpClient;
+}): CredentialParser;
+//# sourceMappingURL=SDJWTVCParser.d.ts.map

package/dist/credential-parsers/SDJWTVCParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SDJWTVCParser.d.ts","sourceRoot":"","sources":["../../src/credential-parsers/SDJWTVCParser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAYtE,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,GAAG,gBAAgB,CA0OlG"}

package/dist/credential-parsers/SDJWTVCParser.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDJWTVCParser = SDJWTVCParser;
+const core_1 = require("@sd-jwt/core");
+const error_1 = require("../error");
+const types_1 = require("../types");
+const schemas_1 = require("../schemas");
+const rendering_1 = require("../rendering");
+const getSdJwtVcMetadata_1 = require("../utils/getSdJwtVcMetadata");
+const openID4VCICredentialRendering_1 = require("../functions/openID4VCICredentialRendering");
+const zod_1 = require("zod");
+const getIssuerMetadata_1 = require("../utils/getIssuerMetadata");
+const matchLocalizedDisplay_1 = require("../utils/matchLocalizedDisplay");
+const convertOpenid4vciToSdjwtvcClaims_1 = require("../functions/convertOpenid4vciToSdjwtvcClaims");
+function SDJWTVCParser(args) {
+    const encoder = new TextEncoder();
+    function extractValidityInfo(jwtPayload) {
+        let obj = {};
+        if (jwtPayload.exp) {
+            obj = {
+                ...obj,
+                validUntil: new Date(jwtPayload.exp * 1000),
+            };
+        }
+        if (jwtPayload.iat) {
+            obj = {
+                ...obj,
+                signed: new Date(jwtPayload.iat * 1000),
+            };
+        }
+        if (jwtPayload.nbf) {
+            obj = {
+                ...obj,
+                validFrom: new Date(jwtPayload.nbf * 1000),
+            };
+        }
+        return obj;
+    }
+    // Encoding the string into a Uint8Array
+    const hasherAndAlgorithm = {
+        hasher: (data, alg) => {
+            const encoded = typeof data === 'string' ? encoder.encode(data) : new Uint8Array(data);
+            return args.context.subtle.digest(alg, encoded).then((v) => new Uint8Array(v));
+        },
+        alg: 'sha-256',
+    };
+    const cr = (0, rendering_1.CredentialRenderingService)();
+    const renderer = (0, openID4VCICredentialRendering_1.OpenID4VCICredentialRendering)({ httpClient: args.httpClient });
+    return {
+        async parse({ rawCredential, credentialIssuer }) {
+            if (typeof rawCredential !== 'string') {
+                return {
+                    success: false,
+                    error: error_1.CredentialParsingError.InvalidDatatype
+                };
+            }
+            let credentialFriendlyName = async () => null;
+            let dataUri = async () => null;
+            const warnings = [];
+            const { parsedClaims, parsedHeaders, parsedPayload, err } = await (async () => {
+                try {
+                    const parsedSdJwt = await core_1.SDJwt.fromEncode(rawCredential, hasherAndAlgorithm.hasher);
+                    const claims = await parsedSdJwt.getClaims(hasherAndAlgorithm.hasher);
+                    const headers = await parsedSdJwt.jwt?.header;
+                    const payload = await parsedSdJwt.jwt?.payload;
+                    return { parsedClaims: claims, parsedHeaders: headers, parsedPayload: payload, err: null };
+                }
+                catch (err) {
+                    return { parsedClaims: null, parsedHeaders: null, err: err };
+                }
+            })();
+            if (err || !parsedClaims || !parsedHeaders) {
+                return {
+                    success: false,
+                    error: error_1.CredentialParsingError.CouldNotParse,
+                };
+            }
+            const schema = zod_1.z.enum([types_1.VerifiableCredentialFormat.VC_SDJWT, types_1.VerifiableCredentialFormat.DC_SDJWT]);
+            const typParseResult = await schema.safeParseAsync(parsedHeaders.typ);
+            if (typParseResult.error) {
+                return {
+                    success: false,
+                    error: error_1.CredentialParsingError.NotSupportedCredentialType,
+                };
+            }
+            // sd-jwt vc Payload Schema Validation
+            let validatedParsedClaims;
+            try {
+                validatedParsedClaims = schemas_1.SdJwtVcPayloadSchema.parse(parsedClaims);
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: error_1.CredentialParsingError.InvalidSdJwtVcPayload,
+                };
+            }
+            const { metadata: issuerMetadata } = await (0, getIssuerMetadata_1.getIssuerMetadata)(args.httpClient, validatedParsedClaims.iss, warnings);
+            const getSdJwtMetadataResult = await (0, getSdJwtVcMetadata_1.getSdJwtVcMetadata)(args.context, args.httpClient, rawCredential, validatedParsedClaims, warnings);
+            if ('error' in getSdJwtMetadataResult) {
+                return {
+                    success: false,
+                    error: getSdJwtMetadataResult.error,
+                };
+            }
+            let TypeMetadata = {};
+            let credentialMetadata = undefined;
+            const credentialIssuerMetadata = credentialIssuer?.credentialConfigurationId
+                ? issuerMetadata?.credential_configurations_supported?.[credentialIssuer?.credentialConfigurationId]
+                : undefined;
+            if (getSdJwtMetadataResult.credentialMetadata) {
+                credentialMetadata = getSdJwtMetadataResult.credentialMetadata;
+                if (credentialMetadata?.claims) {
+                    TypeMetadata = { claims: credentialMetadata.claims };
+                }
+            }
+            credentialFriendlyName = async (preferredLangs = ['en-US']) => {
+                // 1. Try to match localized credential display
+                const credentialDisplayArray = credentialMetadata?.display;
+                const credentialDisplayLocalized = (0, matchLocalizedDisplay_1.matchDisplayByLocale)(credentialDisplayArray, preferredLangs);
+                if (credentialDisplayLocalized?.name)
+                    return credentialDisplayLocalized.name;
+                // 2. Try to match localized issuer display
+                const issuerDisplayArray = credentialIssuerMetadata?.display;
+                const issuerDisplayLocalized = (0, matchLocalizedDisplay_1.matchDisplayByLocale)(issuerDisplayArray, preferredLangs);
+                if (issuerDisplayLocalized?.name)
+                    return issuerDisplayLocalized.name;
+                return 'SD-JWT Verifiable Credential';
+            };
+            dataUri = async (filter, preferredLangs = ['en-US']) => {
+                // 1. Try to match localized credential display
+                const credentialDisplayArray = credentialMetadata?.display;
+                const credentialDisplayLocalized = (0, matchLocalizedDisplay_1.matchDisplayByLocale)(credentialDisplayArray, preferredLangs);
+                // 2. Try to match localized issuer display
+                const issuerDisplayArray = credentialIssuerMetadata?.display;
+                const issuerDisplayLocalized = (0, matchLocalizedDisplay_1.matchDisplayByLocale)(issuerDisplayArray, preferredLangs);
+                const svgTemplateUri = credentialDisplayLocalized?.rendering?.svg_templates?.[0]?.uri || null;
+                const simpleDisplayConfig = credentialDisplayLocalized?.rendering?.simple || null;
+                // 1. Try SVG template rendering
+                if (svgTemplateUri) {
+                    const svgResponse = await args.httpClient.get(svgTemplateUri, {}, { useCache: true }).catch(() => null);
+                    if (svgResponse && svgResponse.status === 200) {
+                        const svgdata = svgResponse.data;
+                        const rendered = await cr.renderSvgTemplate({
+                            json: validatedParsedClaims,
+                            credentialImageSvgTemplate: svgdata,
+                            sdJwtVcMetadataClaims: credentialMetadata?.claims,
+                            filter,
+                        }).catch(() => null);
+                        if (rendered)
+                            return rendered;
+                    }
+                }
+                // 2. Fallback: simple rendering from credential display
+                if (simpleDisplayConfig && credentialDisplayLocalized) {
+                    const rendered = await renderer.renderCustomSvgTemplate({
+                        signedClaims: validatedParsedClaims,
+                        displayConfig: { ...credentialDisplayLocalized, ...simpleDisplayConfig },
+                    }).catch(() => null);
+                    if (rendered)
+                        return rendered;
+                }
+                // 3. Fallback: rendering from issuer metadata display
+                if (issuerDisplayLocalized) {
+                    const rendered = await renderer.renderCustomSvgTemplate({
+                        signedClaims: validatedParsedClaims,
+                        displayConfig: issuerDisplayLocalized,
+                    }).catch(() => null);
+                    if (rendered)
+                        return rendered;
+                }
+                const rendered = await renderer.renderCustomSvgTemplate({
+                    signedClaims: validatedParsedClaims,
+                    displayConfig: { name: "SD-JWT Verifiable Credential" },
+                }).catch(() => null);
+                if (rendered)
+                    return rendered;
+                // All attempts failed
+                return null;
+            };
+            if (!TypeMetadata?.claims && credentialIssuerMetadata?.claims) {
+                const convertedClaims = (0, convertOpenid4vciToSdjwtvcClaims_1.convertOpenid4vciToSdjwtvcClaims)(credentialIssuerMetadata.claims);
+                if (convertedClaims?.length) {
+                    TypeMetadata = { claims: convertedClaims };
+                }
+            }
+            return {
+                success: true,
+                value: {
+                    signedClaims: validatedParsedClaims,
+                    metadata: {
+                        credential: {
+                            format: typParseResult.data,
+                            vct: validatedParsedClaims?.vct ?? "",
+                            TypeMetadata,
+                            image: {
+                                dataUri: dataUri,
+                            },
+                            name: credentialFriendlyName,
+                        },
+                        issuer: {
+                            id: validatedParsedClaims.iss,
+                            name: validatedParsedClaims.iss,
+                        }
+                    },
+                    validityInfo: {
+                        ...extractValidityInfo(validatedParsedClaims)
+                    },
+                    warnings: getSdJwtMetadataResult.warnings
+                }
+            };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SDJWTVCParser.js","sourceRoot":"","sources":["../../src/credential-parsers/SDJWTVCParser.ts"],"names":[],"mappings":"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"}

package/dist/credential-verifiers/MsoMdocVerifier.d.ts

@@ -0,0 +1,8 @@
+import { Context, CredentialVerifier, PublicKeyResolverEngineI } from "../interfaces";
+import { type X509ChainVerifierI } from "../x509/X509ChainVerifier";
+export declare function MsoMdocVerifier(args: {
+    context: Context;
+    pkResolverEngine: PublicKeyResolverEngineI;
+    x509ChainVerifier?: X509ChainVerifierI;
+}): CredentialVerifier;
+//# sourceMappingURL=MsoMdocVerifier.d.ts.map

package/dist/credential-verifiers/MsoMdocVerifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MsoMdocVerifier.d.ts","sourceRoot":"","sources":["../../src/credential-verifiers/MsoMdocVerifier.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAMtF,OAAO,EAEN,KAAK,kBAAkB,EACvB,MAAM,2BAA2B,CAAC;AAEnC,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,iBAAiB,CAAC,EAAE,kBAAkB,CAAC;CACvC,GAAG,kBAAkB,CA+QrB"}