@owf/eudi-jades 0.1.0

package/dist/index.mjs

@@ -0,0 +1,924 @@
+import { base64urlDecode, base64urlEncode } from "@owf/identity-common";
+import { z } from "zod";
+import { parseCertificateChain } from "@owf/crypto";
+//#region src/constants.ts
+/**
+* JAdES Constants
+*
+* Algorithm definitions and OIDs as per ETSI TS 119 182-1.
+*/
+/**
+* Supported signature algorithms with their hash algorithms.
+*/
+const ALGORITHMS = {
+	RS256: {
+		hash: "SHA-256",
+		family: "RSA"
+	},
+	RS384: {
+		hash: "SHA-384",
+		family: "RSA"
+	},
+	RS512: {
+		hash: "SHA-512",
+		family: "RSA"
+	},
+	PS256: {
+		hash: "SHA-256",
+		family: "RSA-PSS"
+	},
+	PS384: {
+		hash: "SHA-384",
+		family: "RSA-PSS"
+	},
+	PS512: {
+		hash: "SHA-512",
+		family: "RSA-PSS"
+	},
+	ES256: {
+		hash: "SHA-256",
+		family: "ECDSA",
+		namedCurve: "P-256"
+	},
+	ES384: {
+		hash: "SHA-384",
+		family: "ECDSA",
+		namedCurve: "P-384"
+	},
+	ES512: {
+		hash: "SHA-512",
+		family: "ECDSA",
+		namedCurve: "P-521"
+	}
+};
+/**
+* Commitment type OIDs as per RFC 5035.
+*/
+let CommitmentOIDs = /* @__PURE__ */ function(CommitmentOIDs) {
+	/** Proof of origin */
+	CommitmentOIDs["proofOfOrigin"] = "1.2.840.113549.1.9.16.6.1";
+	/** Proof of receipt */
+	CommitmentOIDs["proofOfReceipt"] = "1.2.840.113549.1.9.16.6.2";
+	/** Proof of delivery */
+	CommitmentOIDs["proofOfDelivery"] = "1.2.840.113549.1.9.16.6.3";
+	/** Proof of sender */
+	CommitmentOIDs["proofOfSender"] = "1.2.840.113549.1.9.16.6.4";
+	/** Proof of approval */
+	CommitmentOIDs["proofOfApproval"] = "1.2.840.113549.1.9.16.6.5";
+	/** Proof of creation */
+	CommitmentOIDs["proofOfCreation"] = "1.2.840.113549.1.9.16.6.6";
+	return CommitmentOIDs;
+}({});
+/**
+* JAdES baseline profiles as per ETSI TS 119 182-1.
+*/
+let JAdESProfile = /* @__PURE__ */ function(JAdESProfile) {
+	/** Basic - Baseline: basic signature format */
+	JAdESProfile["B_B"] = "B-B";
+	/** Basic with Time: signatures with timestamp */
+	JAdESProfile["B_T"] = "B-T";
+	/** Basic Long-Term: signatures with validation data for long-term preservation */
+	JAdESProfile["B_LT"] = "B-LT";
+	/** Basic Long-Term with Archive timestamps */
+	JAdESProfile["B_LTA"] = "B-LTA";
+	return JAdESProfile;
+}({});
+/**
+* Detached signature mechanism identifiers as per ETSI TS 119 182-1 Section 5.2.8.
+*/
+const DETACHED_MECHANISM_IDS = {
+	httpHeaders: "http://uri.etsi.org/19182/HttpHeaders",
+	objectDigest: "http://uri.etsi.org/19182/ObjectIdByURIHash"
+};
+/**
+* Critical header parameters that must be understood.
+* ETSI TS 119 182-1 specifies these parameters as critical.
+*/
+const CRITICAL_PARAMETERS = [
+	"x5t#o",
+	"sigX5ts",
+	"sigT",
+	"sigD",
+	"sigPl",
+	"sigPId",
+	"srCms",
+	"srAts",
+	"adoTst",
+	"b64"
+];
+//#endregion
+//#region src/jades-exception.ts
+/**
+* JAdES Exception
+*
+* Custom exception for JAdES-related errors.
+*/
+var JAdESException = class JAdESException extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "JAdESException";
+		Object.setPrototypeOf(this, JAdESException.prototype);
+	}
+};
+//#endregion
+//#region src/schemas.ts
+/**
+* JAdES Zod Schemas
+*
+* Zod schemas for JAdES (JSON Advanced Electronic Signatures) as per ETSI TS 119 182-1.
+* Types are derived from these schemas via z.infer<>.
+*
+* @see https://www.etsi.org/deliver/etsi_ts/119100_119199/11918201/01.02.01_60/ts_11918201v010201p.pdf
+*/
+/**
+* Supported signature algorithms.
+*/
+const SignAlgSchema = z.enum([
+	"ES256",
+	"ES384",
+	"ES512",
+	"RS256",
+	"RS384",
+	"RS512",
+	"PS256",
+	"PS384",
+	"PS512"
+]);
+/**
+* X.509 Certificate Thumbprint with algorithm specification.
+* ETSI TS 119 182-1 Section 5.2.2.2
+*/
+const X5tOSchema = z.object({
+	digAlg: z.string().min(1),
+	digVal: z.string().min(1)
+});
+/**
+* Commitment reference as per ETSI TS 119 182-1 Section 5.2.5.
+*/
+const CommitmentReferenceSchema = z.object({
+	commId: z.string().min(1),
+	commQuals: z.array(z.object({}).passthrough()).optional()
+});
+/**
+* Signature policy hash.
+*/
+const SignaturePolicyHashSchema = z.object({
+	hashAlgo: z.string().min(1),
+	hashVal: z.string().min(1)
+});
+/**
+* Signature policy descriptor.
+* ETSI TS 119 182-1 Section 5.2.4
+*/
+const SignaturePolicySchema = z.object({
+	sigPolicyId: z.string().optional(),
+	sigPolicyHash: SignaturePolicyHashSchema.optional(),
+	sigPolicyQualifiers: z.array(z.object({}).passthrough()).optional()
+});
+/**
+* Issuer and serial number for signer identification.
+*/
+const IssuerSerialSchema = z.object({
+	issuer: z.string().min(1),
+	serialNumber: z.string().min(1)
+});
+/**
+* Signer identifier.
+* ETSI TS 119 182-1 Section 5.2.3
+*/
+const SignerIdentifierSchema = z.object({
+	issuerSerial: IssuerSerialSchema.optional(),
+	subjectKeyIdentifier: z.string().optional()
+});
+/**
+* Detached signature descriptor.
+* ETSI TS 119 182-1 Section 5.2.8
+*/
+const SigDSchema = z.object({
+	mId: z.string().min(1),
+	pars: z.tuple([z.string(), z.string()]),
+	hashM: z.string().optional(),
+	ctM: z.string().optional()
+});
+/**
+* Timestamp token value.
+*/
+const TstTokenValueSchema = z.object({ val: z.string().min(1) });
+/**
+* Timestamp tokens container.
+*/
+const TstTokensSchema = z.object({ tstTokens: z.array(TstTokenValueSchema).min(1) });
+/**
+* Signature timestamp container (for B-T profile).
+*/
+const SigTstSchema = z.object({ sigTst: TstTokensSchema });
+/**
+* X.509 certificate values (for B-LT profile).
+*/
+const XValsSchema = z.object({ xVals: z.array(z.object({ x509Cert: z.string().min(1) })) });
+/**
+* Revocation values (for B-LT profile).
+*/
+const RValsSchema = z.object({ rVals: z.object({
+	crlVals: z.array(z.string()),
+	ocspVals: z.array(z.string())
+}) });
+/**
+* Archive timestamp (for B-LTA profile).
+*/
+const ArcTstSchema = z.object({ arcTst: TstTokensSchema.extend({ canonAlg: z.string().optional() }) });
+/**
+* ETSI Unsigned properties for different JAdES profiles.
+*/
+const EtsiUSchema = z.union([
+	z.array(SigTstSchema),
+	z.tuple([
+		SigTstSchema,
+		XValsSchema,
+		RValsSchema
+	]),
+	z.tuple([
+		SigTstSchema,
+		XValsSchema,
+		RValsSchema,
+		ArcTstSchema
+	])
+]);
+/**
+* JAdES Protected Header parameters as per ETSI TS 119 182-1.
+*/
+const ProtectedHeaderSchema = z.object({
+	alg: SignAlgSchema.optional(),
+	cty: z.string().optional(),
+	kid: z.string().optional(),
+	x5u: z.string().url().optional(),
+	x5c: z.array(z.string().min(1)).min(1).optional(),
+	"x5t#S256": z.string().min(1).optional(),
+	"x5t#o": X5tOSchema.optional(),
+	sigX5ts: z.array(X5tOSchema).min(2).optional(),
+	srCms: z.array(CommitmentReferenceSchema).optional(),
+	srAts: z.array(z.object({}).passthrough()).optional(),
+	sigPl: SignaturePolicySchema.optional(),
+	sigPId: SignerIdentifierSchema.optional(),
+	sigT: z.string().optional(),
+	sigD: SigDSchema.optional(),
+	b64: z.literal(false).optional(),
+	crit: z.array(z.string()).optional(),
+	iat: z.number().int().positive().optional(),
+	signedAt: z.number().int().positive().optional(),
+	jti: z.string().optional(),
+	typ: z.string().optional(),
+	adoTst: z.array(z.object({}).passthrough()).optional()
+}).passthrough();
+/**
+* Protected header schema for signing (alg required).
+*/
+const ProtectedHeaderForSigningSchema = ProtectedHeaderSchema.extend({ alg: SignAlgSchema }).refine((header) => {
+	return !!(header["x5t#S256"] || header.x5c || header["x5t#o"] || header.sigX5ts);
+}, { message: "JAdES signature requires at least one certificate header: x5t#S256, x5c, x5t#o, or sigX5ts" });
+/**
+* JAdES Unprotected Header parameters.
+*/
+const UnprotectedHeaderSchema = z.object({
+	etsiU: EtsiUSchema.optional(),
+	disclosures: z.array(z.string()).optional(),
+	kid: z.string().optional(),
+	kb_jwt: z.string().optional()
+}).passthrough();
+/**
+* Signature entry in General JWS.
+*/
+const JWSSignatureSchema = z.object({
+	protected: z.string().min(1),
+	signature: z.string().min(1),
+	header: UnprotectedHeaderSchema.optional()
+});
+/**
+* General JWS structure with multiple signatures.
+*/
+const GeneralJWSSchema = z.object({
+	payload: z.string(),
+	signatures: z.array(JWSSignatureSchema).min(1)
+});
+/**
+* Flattened JWS structure (single signature).
+*/
+const FlattenedJWSSchema = z.object({
+	protected: z.string().min(1),
+	payload: z.string(),
+	signature: z.string().min(1),
+	header: UnprotectedHeaderSchema.optional()
+});
+/**
+* Compact JWS representation.
+*/
+const CompactJWSSchema = z.object({
+	protected: z.string().min(1),
+	payload: z.string(),
+	signature: z.string().min(1)
+});
+/**
+* Sign options for JAdES signing.
+*/
+const SignOptionsSchema = z.object({
+	alg: SignAlgSchema,
+	kid: z.string().optional(),
+	certificates: z.array(z.string()).optional()
+});
+z.object({ skipSignatureValidation: z.boolean().optional() });
+//#endregion
+//#region src/utils.ts
+/**
+* JAdES Utility Functions
+*
+* Helper functions for certificate handling and header generation.
+*/
+/**
+* Parse PEM-encoded certificate chain and return base64 DER strings.
+*
+* @param pem - One or more PEM-encoded certificates
+* @returns Array of base64-encoded DER certificate strings
+*/
+function parseCerts(pem) {
+	return parseCertificateChain(pem);
+}
+/**
+* Generate x5c header value from PEM certificates.
+* The certificates are converted to base64-encoded DER format.
+*
+* ETSI TS 119 182-1 Section 5.1.8
+*
+* @param certs - PEM-encoded certificate(s) or array of base64 DER certs
+* @returns Array of base64-encoded DER certificate strings
+*/
+function generateX5c(certs) {
+	if (typeof certs === "string") return parseCertificateChain(certs);
+	return certs;
+}
+/**
+* Generate x5t#S256 header value (SHA-256 thumbprint of certificate).
+*
+* ETSI TS 119 182-1 Section 5.1.7
+*
+* @param certDer - Base64-encoded DER certificate
+* @returns Base64url-encoded SHA-256 thumbprint
+*/
+async function generateX5tS256(certDer) {
+	const certBytes = base64ToUint8Array(certDer);
+	const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", certBytes);
+	return uint8ArrayToBase64Url(new Uint8Array(hashBuffer));
+}
+/**
+* Generate x5t#o header value (certificate thumbprint with specified algorithm).
+*
+* ETSI TS 119 182-1 Section 5.2.2.2
+*
+* @param certDer - Base64-encoded DER certificate
+* @param algorithm - Hash algorithm ('SHA-384' or 'SHA-512')
+* @returns X5tO object with algorithm identifier and digest value
+*/
+async function generateX5tO(certDer, algorithm = "SHA-512") {
+	const algMap = {
+		"SHA-384": "S384",
+		"SHA-512": "S512"
+	};
+	const certBytes = base64ToUint8Array(certDer);
+	const hashBuffer = await globalThis.crypto.subtle.digest(algorithm, certBytes);
+	return {
+		digAlg: algMap[algorithm],
+		digVal: uint8ArrayToBase64Url(new Uint8Array(hashBuffer))
+	};
+}
+/**
+* Generate sigX5ts header value (certificate chain thumbprints).
+*
+* ETSI TS 119 182-1 Section 5.2.2.3
+*
+* @param certsDer - Array of base64-encoded DER certificates
+* @param algorithm - Hash algorithm ('SHA-384' or 'SHA-512')
+* @returns Array of X5tO objects
+*/
+async function generateSigX5ts(certsDer, algorithm = "SHA-512") {
+	if (certsDer.length < 2) throw new JAdESException("sigX5ts requires at least 2 certificates");
+	return Promise.all(certsDer.map((cert) => generateX5tO(cert, algorithm)));
+}
+/**
+* Generate a JAdES-compliant kid from X.509 certificate.
+*
+* According to ETSI TS 119 182-1 Section 5.1.4, the kid should be
+* the base64 encoding of DER-encoded IssuerSerial sequence.
+*
+* This implementation generates a SHA-256 thumbprint of the certificate
+* as a simpler approach that uniquely identifies the certificate.
+*
+* @param certDer - Base64-encoded DER certificate
+* @returns Base64url-encoded key identifier
+*/
+async function generateKid(certDer) {
+	return generateX5tS256(certDer);
+}
+/**
+* Encode an object as a base64url JSON string.
+*
+* @param obj - Object to encode
+* @returns Base64url-encoded JSON string
+*/
+function encodeJSON(obj) {
+	return base64urlEncode(JSON.stringify(obj));
+}
+/**
+* Decode a base64url JSON string to an object.
+*
+* @param encoded - Base64url-encoded JSON string
+* @returns Decoded object
+*/
+function decodeJSON(encoded) {
+	return JSON.parse(base64urlDecode(encoded));
+}
+/**
+* Get current ISO 8601 timestamp for sigT header.
+*
+* @returns ISO 8601 timestamp string
+*/
+function getSigningTime() {
+	return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+/**
+* Validate that the protected header has at least one certificate header.
+* As per ETSI TS 119 182-1 Section 5.1.7, a JAdES signature shall have
+* at least one of: x5t#S256, x5c, x5t#o, sigX5ts.
+*
+* @param header - Protected header object
+* @returns true if valid
+* @throws JAdESException if no certificate header is present
+*/
+function validateCertificateHeaders(header) {
+	if (!!!(header["x5t#S256"] || header.x5c || header["x5t#o"] || header.sigX5ts)) throw new JAdESException("JAdES signature requires at least one certificate header: x5t#S256, x5c, x5t#o, or sigX5ts");
+	return true;
+}
+function base64ToUint8Array(base64) {
+	const normalized = base64.replace(/-/g, "+").replace(/_/g, "/");
+	const padded = normalized.padEnd(normalized.length + (4 - normalized.length % 4) % 4, "=");
+	const binaryString = atob(padded);
+	const bytes = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+	return bytes;
+}
+function uint8ArrayToBase64Url(bytes) {
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+//#endregion
+//#region src/token.ts
+/**
+* JAdES Token
+*
+* Main class for creating JAdES-compliant signatures.
+* Implements ETSI TS 119 182-1 standard for JSON Advanced Electronic Signatures.
+*
+* @example
+* ```typescript
+* import { Token, parseCerts, generateX5c } from '@owf/eudi-jades'
+* import { ES256 } from '@owf/crypto'
+*
+* const payload = { hello: 'world' }
+* const token = new Token(payload)
+*
+* const certs = parseCerts(pemCertificate)
+* token.setProtectedHeader({
+*   alg: 'ES256',
+*   x5c: generateX5c(certs),
+* })
+*
+* const signer = await ES256.getSigner(privateKey)
+* await token.sign(signer)
+*
+* const compactJws = token.toString()
+* const generalJws = token.toJSON()
+* ```
+*/
+/**
+* JAdES Token class for creating conformant JAdES signatures.
+*/
+var Token = class {
+	/**
+	* Create a new JAdES Token.
+	*
+	* @param payload - The payload to sign. If undefined, creates a detached signature.
+	*/
+	constructor(payload) {
+		this.protectedHeader = {};
+		this.unprotectedHeader = {};
+		this.payload = payload;
+		this.encodedPayload = payload === void 0 ? "" : base64urlEncode(JSON.stringify(payload));
+	}
+	/**
+	* Set the protected header parameters.
+	*
+	* @param header - Protected header parameters
+	* @returns this for method chaining
+	*/
+	setProtectedHeader(header) {
+		if (header.alg) {
+			if (!SignAlgSchema.safeParse(header.alg).success) throw new JAdESException(`Invalid algorithm: ${header.alg}`);
+		}
+		const result = ProtectedHeaderSchema.safeParse(header);
+		if (!result.success) throw new JAdESException(`Invalid protected header: ${result.error.issues.map((e) => e.message).join(", ")}`);
+		this.protectedHeader = {
+			...this.protectedHeader,
+			...header
+		};
+		return this;
+	}
+	/**
+	* Set the unprotected header parameters.
+	*
+	* @param header - Unprotected header parameters
+	* @returns this for method chaining
+	*/
+	setUnprotectedHeader(header) {
+		this.unprotectedHeader = {
+			...this.unprotectedHeader,
+			...header
+		};
+		return this;
+	}
+	/**
+	* Set X.509 certificate chain (x5c header).
+	*
+	* ETSI TS 119 182-1 Section 5.1.8
+	*
+	* @param certs - Array of base64-encoded DER certificates
+	* @returns this for method chaining
+	*/
+	setX5c(certs) {
+		this.protectedHeader.x5c = certs;
+		return this;
+	}
+	/**
+	* Set X.509 certificate URL (x5u header).
+	*
+	* ETSI TS 119 182-1 Section 5.1.5
+	*
+	* @param uri - URI to certificate resource
+	* @returns this for method chaining
+	*/
+	setX5u(uri) {
+		this.protectedHeader.x5u = uri;
+		return this;
+	}
+	/**
+	* Set X.509 certificate SHA-256 thumbprint (x5t#S256 header).
+	*
+	* ETSI TS 119 182-1 Section 5.1.7
+	*
+	* @param thumbprint - Base64url-encoded SHA-256 thumbprint
+	* @returns this for method chaining
+	*/
+	setX5tS256(thumbprint) {
+		this.protectedHeader["x5t#S256"] = thumbprint;
+		return this;
+	}
+	/**
+	* Set X.509 certificate thumbprint with other algorithm (x5t#o header).
+	*
+	* ETSI TS 119 182-1 Section 5.2.2.2
+	*
+	* @param x5tO - X5tO object with algorithm and digest value
+	* @returns this for method chaining
+	*/
+	setX5tO(x5tO) {
+		this.protectedHeader["x5t#o"] = x5tO;
+		return this;
+	}
+	/**
+	* Set signing time (sigT header).
+	*
+	* ETSI TS 119 182-1 Section 5.2.1
+	*
+	* @param time - ISO 8601 timestamp (defaults to current time)
+	* @returns this for method chaining
+	*/
+	setSigningTime(time) {
+		this.protectedHeader.sigT = time ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+		return this;
+	}
+	/**
+	* Set signedAt timestamp in protected header.
+	*
+	* @param sec - Unix timestamp in seconds (defaults to current time)
+	* @returns this for method chaining
+	*/
+	setSignedAt(sec) {
+		this.protectedHeader.signedAt = sec ?? Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	/**
+	* Set issued at timestamp (iat) in protected header.
+	*
+	* @param sec - Unix timestamp in seconds (defaults to current time)
+	* @returns this for method chaining
+	*/
+	setIssuedAt(sec) {
+		this.protectedHeader.iat = sec ?? Math.floor(Date.now() / 1e3);
+		return this;
+	}
+	/**
+	* Set key ID (kid header).
+	*
+	* @param kid - Key identifier
+	* @returns this for method chaining
+	*/
+	setKid(kid) {
+		this.protectedHeader.kid = kid;
+		return this;
+	}
+	/**
+	* Set content type (cty header).
+	*
+	* @param cty - Content type
+	* @returns this for method chaining
+	*/
+	setContentType(cty) {
+		this.protectedHeader.cty = cty;
+		return this;
+	}
+	/**
+	* Set token type (typ header).
+	*
+	* @param typ - Token type
+	* @returns this for method chaining
+	*/
+	setType(typ) {
+		this.protectedHeader.typ = typ;
+		return this;
+	}
+	/**
+	* Set b64 header parameter.
+	*
+	* ETSI TS 119 182-1 Section 5.1.10
+	* RFC 7797 Section 3
+	*
+	* @param b64 - If true (default), payload is base64url encoded. If false, payload is unencoded.
+	* @returns this for method chaining
+	*/
+	setB64(b64) {
+		if (b64) delete this.protectedHeader.b64;
+		else this.protectedHeader.b64 = false;
+		return this;
+	}
+	/**
+	* Configure detached signature mode.
+	*
+	* ETSI TS 119 182-1 Section 5.2.8
+	*
+	* @param sigD - Detached signature descriptor
+	* @returns this for method chaining
+	*/
+	setDetached(sigD) {
+		this.protectedHeader.sigD = sigD;
+		this.encodedPayload = "";
+		if (sigD.mId === DETACHED_MECHANISM_IDS.httpHeaders) this.setB64(false);
+		return this;
+	}
+	/**
+	* Get the signing input (data to be signed).
+	*
+	* @returns The signing input string (header.payload)
+	*/
+	getSigningInput() {
+		return `${this.getEncodedProtectedHeader()}.${this.encodedPayload}`;
+	}
+	/**
+	* Get the hash of the signing input for external signing.
+	*
+	* @param algorithm - Hash algorithm (defaults to algorithm from header)
+	* @returns Promise resolving to hash bytes
+	*/
+	async getHash(algorithm) {
+		const alg = algorithm ?? this.getHashAlgorithm();
+		const signingInput = this.getSigningInput();
+		const encoder = new TextEncoder();
+		const hashBuffer = await globalThis.crypto.subtle.digest(alg, encoder.encode(signingInput));
+		return new Uint8Array(hashBuffer);
+	}
+	/**
+	* Set the signature (for external signing).
+	*
+	* @param signature - Base64url-encoded signature
+	* @returns this for method chaining
+	*/
+	setSignature(signature) {
+		this.signature = signature;
+		return this;
+	}
+	/**
+	* Sign the token using the provided signer function.
+	*
+	* @param signer - Async function that signs data and returns base64url signature
+	* @returns Promise resolving to this for method chaining
+	*/
+	async sign(signer) {
+		this.validateBeforeSign();
+		this.signature = await signer(this.getSigningInput());
+		return this;
+	}
+	/**
+	* Export to compact JWS serialization.
+	*
+	* @returns Compact JWS string (header.payload.signature)
+	*/
+	toString() {
+		if (!this.signature) throw new JAdESException("Token not signed yet");
+		return `${this.getEncodedProtectedHeader()}.${this.encodedPayload}.${this.signature}`;
+	}
+	/**
+	* Export to General JWS JSON serialization.
+	*
+	* @returns GeneralJWS object
+	*/
+	toJSON() {
+		if (!this.signature) throw new JAdESException("Token not signed yet");
+		const result = {
+			payload: this.encodedPayload,
+			signatures: [{
+				protected: this.getEncodedProtectedHeader(),
+				signature: this.signature
+			}]
+		};
+		if (Object.keys(this.unprotectedHeader).length > 0) result.signatures[0].header = this.unprotectedHeader;
+		return result;
+	}
+	/**
+	* Export to flattened JWS JSON serialization.
+	*
+	* @returns Flattened JWS object
+	*/
+	toFlattenedJSON() {
+		if (!this.signature) throw new JAdESException("Token not signed yet");
+		const result = {
+			protected: this.getEncodedProtectedHeader(),
+			payload: this.encodedPayload,
+			signature: this.signature
+		};
+		if (Object.keys(this.unprotectedHeader).length > 0) result.header = this.unprotectedHeader;
+		return result;
+	}
+	/**
+	* Get the protected header object.
+	*/
+	getProtectedHeader() {
+		return { ...this.protectedHeader };
+	}
+	/**
+	* Get the unprotected header object.
+	*/
+	getUnprotectedHeader() {
+		return { ...this.unprotectedHeader };
+	}
+	/**
+	* Get the payload.
+	*/
+	getPayload() {
+		return this.payload;
+	}
+	getEncodedProtectedHeader() {
+		return encodeJSON(this.buildFinalHeader());
+	}
+	buildFinalHeader() {
+		const header = { ...this.protectedHeader };
+		const critParams = CRITICAL_PARAMETERS.filter((param) => param in header);
+		if (critParams.length > 0) header.crit = critParams;
+		return header;
+	}
+	validateBeforeSign() {
+		const result = ProtectedHeaderForSigningSchema.safeParse(this.protectedHeader);
+		if (!result.success) throw new JAdESException(`Invalid protected header for signing: ${result.error.issues.map((e) => e.message).join(", ")}`);
+	}
+	getHashAlgorithm() {
+		const algMap = {
+			RS256: "SHA-256",
+			RS384: "SHA-384",
+			RS512: "SHA-512",
+			PS256: "SHA-256",
+			PS384: "SHA-384",
+			PS512: "SHA-512",
+			ES256: "SHA-256",
+			ES384: "SHA-384",
+			ES512: "SHA-512"
+		};
+		const alg = this.protectedHeader.alg;
+		if (!alg || !algMap[alg]) throw new JAdESException(`Unsupported algorithm: ${alg}`);
+		return algMap[alg];
+	}
+};
+//#endregion
+//#region src/verifier.ts
+/**
+* JAdES Verifier
+*
+* Functions for verifying JAdES signatures.
+*/
+/**
+* Verify a JAdES signature in compact serialization.
+*
+* @param jws - Compact JWS string
+* @param verifier - Async function that verifies signature
+* @returns Promise resolving to verification result
+*/
+async function verifyCompact(jws, verifier) {
+	const parts = jws.split(".");
+	if (parts.length !== 3) throw new JAdESException("Invalid JWS format: expected 3 parts");
+	const [encodedHeader, encodedPayload, signature] = parts;
+	const valid = await verifier(`${encodedHeader}.${encodedPayload}`, signature);
+	if (!valid) throw new JAdESException("Invalid signature");
+	const rawHeader = JSON.parse(base64urlDecode(encodedHeader));
+	const headerResult = ProtectedHeaderSchema.safeParse(rawHeader);
+	if (!headerResult.success) throw new JAdESException(`Invalid protected header: ${headerResult.error.issues.map((e) => e.message).join(", ")}`);
+	return {
+		header: headerResult.data,
+		payload: encodedPayload ? JSON.parse(base64urlDecode(encodedPayload)) : {},
+		valid
+	};
+}
+/**
+* Verify a JAdES signature in General JWS JSON serialization.
+*
+* @param generalJws - General JWS object
+* @param verifier - Async function that verifies signature
+* @param signatureIndex - Index of signature to verify (default: 0)
+* @returns Promise resolving to verification result
+*/
+async function verifyGeneral(generalJws, verifier, signatureIndex = 0) {
+	const jwsResult = GeneralJWSSchema.safeParse(generalJws);
+	if (!jwsResult.success) throw new JAdESException(`Invalid General JWS structure: ${jwsResult.error.issues.map((e) => e.message).join(", ")}`);
+	const sig = generalJws.signatures[signatureIndex];
+	if (!sig) throw new JAdESException(`Signature at index ${signatureIndex} not found`);
+	const valid = await verifier(`${sig.protected}.${generalJws.payload}`, sig.signature);
+	if (!valid) throw new JAdESException("Invalid signature");
+	const rawHeader = JSON.parse(base64urlDecode(sig.protected));
+	const headerResult = ProtectedHeaderSchema.safeParse(rawHeader);
+	if (!headerResult.success) throw new JAdESException(`Invalid protected header: ${headerResult.error.issues.map((e) => e.message).join(", ")}`);
+	return {
+		header: headerResult.data,
+		payload: generalJws.payload ? JSON.parse(base64urlDecode(generalJws.payload)) : {},
+		unprotectedHeader: sig.header,
+		valid
+	};
+}
+/**
+* Verify a JAdES signature (auto-detects format).
+*
+* @param jws - JWS string or GeneralJWS object
+* @param verifier - Async function that verifies signature
+* @returns Promise resolving to verification result
+*/
+async function verify(jws, verifier) {
+	if (typeof jws === "string") {
+		try {
+			const parsed = JSON.parse(jws);
+			if (parsed.signatures && Array.isArray(parsed.signatures)) return verifyGeneral(parsed, verifier);
+		} catch {}
+		return verifyCompact(jws, verifier);
+	}
+	return verifyGeneral(jws, verifier);
+}
+/**
+* Decode a JWS without verifying the signature.
+* Use this only for inspection - always verify before trusting the content.
+*
+* @param jws - JWS string or GeneralJWS object
+* @returns Decoded header and payload
+*/
+function decode(jws) {
+	if (typeof jws === "string") {
+		try {
+			const parsed = JSON.parse(jws);
+			if (parsed.signatures && Array.isArray(parsed.signatures)) {
+				const sig = parsed.signatures[0];
+				return {
+					header: JSON.parse(base64urlDecode(sig.protected)),
+					payload: parsed.payload ? JSON.parse(base64urlDecode(parsed.payload)) : {},
+					unprotectedHeader: sig.header
+				};
+			}
+		} catch {}
+		const parts = jws.split(".");
+		if (parts.length !== 3) throw new JAdESException("Invalid JWS format");
+		return {
+			header: JSON.parse(base64urlDecode(parts[0])),
+			payload: parts[1] ? JSON.parse(base64urlDecode(parts[1])) : {}
+		};
+	}
+	const sig = jws.signatures[0];
+	return {
+		header: JSON.parse(base64urlDecode(sig.protected)),
+		payload: jws.payload ? JSON.parse(base64urlDecode(jws.payload)) : {},
+		unprotectedHeader: sig.header
+	};
+}
+//#endregion
+export { ALGORITHMS, ArcTstSchema, CRITICAL_PARAMETERS, CommitmentOIDs, CompactJWSSchema, DETACHED_MECHANISM_IDS, EtsiUSchema, FlattenedJWSSchema, GeneralJWSSchema, JAdESException, JAdESProfile, ProtectedHeaderForSigningSchema, ProtectedHeaderSchema, RValsSchema, SigDSchema, SigTstSchema, SignAlgSchema, SignOptionsSchema, SignaturePolicySchema, SignerIdentifierSchema, Token, TstTokensSchema, UnprotectedHeaderSchema, X5tOSchema, XValsSchema, decode, decodeJSON, encodeJSON, generateKid, generateSigX5ts, generateX5c, generateX5tO, generateX5tS256, getSigningTime, parseCerts, validateCertificateHeaders, verify, verifyCompact, verifyGeneral };
+
+//# sourceMappingURL=index.mjs.map