@owf/x509 0.0.0-stage → 0.0.0

package/dist/index.cjs

@@ -0,0 +1,1169 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _peculiar_asn1_schema = require("@peculiar/asn1-schema");
+let _peculiar_asn1_x509 = require("@peculiar/asn1-x509");
+let _peculiar_asn1_x509_qualified = require("@peculiar/asn1-x509-qualified");
+let _peculiar_asn1_x509_qualified_etsi = require("@peculiar/asn1-x509-qualified-etsi");
+let _owf_identity_common = require("@owf/identity-common");
+let asn1js = require("asn1js");
+asn1js = __toESM(asn1js);
+//#region src/constants.ts
+/** X.520 attribute types and PKCS#9 emailAddress, as used in distinguished names */
+const ATTRIBUTE_TYPES = {
+	commonName: "2.5.4.3",
+	surname: "2.5.4.4",
+	serialNumber: "2.5.4.5",
+	countryName: "2.5.4.6",
+	localityName: "2.5.4.7",
+	stateOrProvinceName: "2.5.4.8",
+	streetAddress: "2.5.4.9",
+	organizationName: "2.5.4.10",
+	organizationalUnitName: "2.5.4.11",
+	title: "2.5.4.12",
+	postalCode: "2.5.4.17",
+	telephoneNumber: "2.5.4.20",
+	givenName: "2.5.4.42",
+	initials: "2.5.4.43",
+	generationQualifier: "2.5.4.44",
+	pseudonym: "2.5.4.65",
+	organizationIdentifier: "2.5.4.97",
+	emailAddress: "1.2.840.113549.1.9.1"
+};
+/** Policy qualifier identifiers (RFC 5280 clause 4.2.1.4) */
+const POLICY_QUALIFIERS = {
+	cps: "1.3.6.1.5.5.7.2.1",
+	unotice: "1.3.6.1.5.5.7.2.2"
+};
+/** Access methods for the Authority Information Access extension (RFC 5280 clause 4.2.2.1) */
+const ACCESS_METHODS = {
+	ocsp: "1.3.6.1.5.5.7.48.1",
+	caIssuers: "1.3.6.1.5.5.7.48.2"
+};
+/** QCStatements extension (RFC 3739) and statements from ETSI EN 319 412-5 */
+const QC_STATEMENTS = {
+	extension: _peculiar_asn1_x509_qualified.id_pe_qcStatements,
+	qcCompliance: _peculiar_asn1_x509_qualified_etsi.id_etsi_qcs_qcCompliance,
+	qcSSCD: _peculiar_asn1_x509_qualified_etsi.id_etsi_qcs_qcSSCD,
+	qcPDS: _peculiar_asn1_x509_qualified_etsi.id_etsi_qcs_qcPDS,
+	qcType: _peculiar_asn1_x509_qualified_etsi.id_etsi_qcs_qcType,
+	qcCClegislation: _peculiar_asn1_x509_qualified_etsi.id_etsi_qcs_qcCClegislation
+};
+/** QcType values (ETSI EN 319 412-5 clause 4.2.3) */
+const QC_TYPES = {
+	esign: _peculiar_asn1_x509_qualified_etsi.id_etsi_qct_esign,
+	eseal: _peculiar_asn1_x509_qualified_etsi.id_etsi_qct_eseal,
+	web: _peculiar_asn1_x509_qualified_etsi.id_etsi_qct_web
+};
+/** Signature algorithms supported for creating and describing certificates and CRLs */
+const SIGNATURE_ALGORITHMS = {
+	ES256: {
+		oid: "1.2.840.10045.4.3.2",
+		hash: "SHA-256",
+		family: "ecdsa"
+	},
+	ES384: {
+		oid: "1.2.840.10045.4.3.3",
+		hash: "SHA-384",
+		family: "ecdsa"
+	},
+	ES512: {
+		oid: "1.2.840.10045.4.3.4",
+		hash: "SHA-512",
+		family: "ecdsa"
+	},
+	RS256: {
+		oid: "1.2.840.113549.1.1.11",
+		hash: "SHA-256",
+		family: "rsa"
+	},
+	RS384: {
+		oid: "1.2.840.113549.1.1.12",
+		hash: "SHA-384",
+		family: "rsa"
+	},
+	RS512: {
+		oid: "1.2.840.113549.1.1.13",
+		hash: "SHA-512",
+		family: "rsa"
+	}
+};
+/** Public key algorithm and curve identifiers */
+const KEY_ALGORITHMS = {
+	ecPublicKey: "1.2.840.10045.2.1",
+	rsaEncryption: "1.2.840.113549.1.1.1",
+	"P-256": "1.2.840.10045.3.1.7",
+	"P-384": "1.3.132.0.34",
+	"P-521": "1.3.132.0.35"
+};
+/** CRL entry revocation reasons (RFC 5280 clause 5.3.1) */
+const CRL_REASONS = {
+	unspecified: 0,
+	keyCompromise: 1,
+	cACompromise: 2,
+	affiliationChanged: 3,
+	superseded: 4,
+	cessationOfOperation: 5,
+	certificateHold: 6,
+	removeFromCRL: 8,
+	privilegeWithdrawn: 9,
+	aACompromise: 10
+};
+//#endregion
+//#region src/x509-exception.ts
+/**
+* X509Exception is thrown when a certificate or CRL cannot be parsed or created.
+*/
+var X509Exception = class X509Exception extends _owf_identity_common.IdentityException {
+	constructor(message, details) {
+		super(message, details);
+		Object.setPrototypeOf(this, X509Exception.prototype);
+		this.name = "X509Exception";
+	}
+};
+//#endregion
+//#region src/encoding.ts
+const PEM_LABELS = {
+	certificate: "CERTIFICATE",
+	crl: "X509 CRL"
+};
+/**
+* Normalize a {@link DerInput} to DER bytes. PEM strings must use the given label; the
+* first matching block is used.
+*/
+function toDer(input, label = PEM_LABELS.certificate) {
+	if (input instanceof Uint8Array) return input;
+	if (input instanceof ArrayBuffer) return new Uint8Array(input);
+	if (typeof input !== "string") throw new X509Exception("Input must be DER bytes, a base64 DER string, or PEM");
+	let body = input;
+	if (input.includes("-----BEGIN")) {
+		const pem = input.match(new RegExp(`-----BEGIN ${label}-----([\\s\\S]*?)-----END ${label}-----`));
+		if (!pem) throw new X509Exception(`No PEM block with label "${label}" found`);
+		body = pem[1];
+	}
+	body = body.replace(/\s/g, "");
+	if (!/^[A-Za-z0-9+/]+={0,2}$/.test(body)) throw new X509Exception("Input is neither PEM nor base64 encoded DER");
+	return _owf_identity_common.base64.decode(body);
+}
+/** Encode DER bytes as PEM. */
+function toPem(der, label = PEM_LABELS.certificate) {
+	return `-----BEGIN ${label}-----\n${(_owf_identity_common.base64.encode(der).match(/.{1,64}/g) ?? []).join("\n")}\n-----END ${label}-----\n`;
+}
+/** Copy bytes into a standalone ArrayBuffer (asn1-schema works on ArrayBuffers). */
+function toArrayBuffer(bytes) {
+	return bytes.slice().buffer;
+}
+//#endregion
+//#region src/der.ts
+const CURVES = {
+	"P-256": {
+		oid: KEY_ALGORITHMS["P-256"],
+		size: 32
+	},
+	"P-384": {
+		oid: KEY_ALGORITHMS["P-384"],
+		size: 48
+	},
+	"P-521": {
+		oid: KEY_ALGORITHMS["P-521"],
+		size: 66
+	}
+};
+/** Byte length of a coordinate (and of r and s in an ECDSA signature) for a named curve OID */
+function curveCoordinateLength(namedCurve) {
+	return Object.values(CURVES).find((c) => c.oid === namedCurve)?.size;
+}
+/** Parse a single DER value, rejecting trailing or malformed data. */
+function parseDer(bytes) {
+	const buffer = bytes instanceof Uint8Array ? toArrayBuffer(bytes) : bytes;
+	const result = asn1js.fromBER(buffer);
+	if (result.offset === -1 || result.offset !== buffer.byteLength) throw new X509Exception("Invalid DER encoding");
+	return result.result;
+}
+/** Decode an ASN.1 string type (or unwrap an explicit tag around one) to a JS string. */
+function asn1ToString(node) {
+	if (node instanceof asn1js.BaseStringBlock) return node.getValue();
+	if (node instanceof asn1js.Constructed && node.valueBlock.value.length === 1) return asn1ToString(node.valueBlock.value[0]);
+}
+/** Strip leading zeros from an unsigned big endian integer. */
+function stripLeadingZeros(bytes) {
+	let i = 0;
+	while (i < bytes.length - 1 && bytes[i] === 0) i++;
+	return bytes.subarray(i);
+}
+/**
+* Encode unsigned big endian bytes as the content of a DER INTEGER, adding a leading
+* zero when the high bit is set so the value stays positive.
+*/
+function toPositiveIntegerBytes(bytes) {
+	const stripped = stripLeadingZeros(bytes);
+	return stripped[0] & 128 ? (0, _owf_identity_common.concatBytes)(new Uint8Array([0]), stripped) : stripped;
+}
+function integer(bytes) {
+	return new asn1js.Integer({ valueHex: toArrayBuffer(toPositiveIntegerBytes(bytes)) });
+}
+function leftPad(bytes, length) {
+	const stripped = stripLeadingZeros(bytes);
+	if (stripped.length > length) throw new X509Exception("Integer does not fit the expected length");
+	const out = new Uint8Array(length);
+	out.set(stripped, length - stripped.length);
+	return out;
+}
+/** Convert an IEEE P1363 (r || s) ECDSA signature to DER. */
+function ecdsaP1363ToDer(signature, coordinateLength) {
+	if (signature.length !== coordinateLength * 2) throw new X509Exception(`Expected a ${coordinateLength * 2} byte IEEE P1363 ECDSA signature, got ${signature.length} bytes`);
+	const seq = new asn1js.Sequence({ value: [integer(signature.subarray(0, coordinateLength)), integer(signature.subarray(coordinateLength))] });
+	return new Uint8Array(seq.toBER());
+}
+/** Convert a DER ECDSA signature to IEEE P1363 (r || s). */
+function ecdsaDerToP1363(signature, coordinateLength) {
+	const seq = parseDer(signature);
+	if (!(seq instanceof asn1js.Sequence) || seq.valueBlock.value.length !== 2) throw new X509Exception("Invalid DER ECDSA signature");
+	const [r, s] = seq.valueBlock.value;
+	if (!(r instanceof asn1js.Integer) || !(s instanceof asn1js.Integer)) throw new X509Exception("Invalid DER ECDSA signature");
+	return (0, _owf_identity_common.concatBytes)(leftPad(new Uint8Array(r.valueBlock.valueHexView), coordinateLength), leftPad(new Uint8Array(s.valueBlock.valueHexView), coordinateLength));
+}
+/**
+* Convert a public JWK to a DER SubjectPublicKeyInfo. Refuses private keys: only the
+* public part of the wallet-relying party key is needed to issue its certificate.
+*/
+function publicJwkToSpki(jwk) {
+	if (jwk.d !== void 0 || jwk.p !== void 0 || jwk.q !== void 0) throw new X509Exception("The subject public key must not contain private key material");
+	if (jwk.kty === "EC") {
+		const curve = CURVES[jwk.crv];
+		if (!curve || !jwk.x || !jwk.y) throw new X509Exception(`Unsupported EC public key (crv: ${jwk.crv})`);
+		const point = (0, _owf_identity_common.concatBytes)(new Uint8Array([4]), leftPad(_owf_identity_common.base64url.decode(jwk.x), curve.size), leftPad(_owf_identity_common.base64url.decode(jwk.y), curve.size));
+		const spki = new _peculiar_asn1_x509.SubjectPublicKeyInfo({
+			algorithm: new _peculiar_asn1_x509.AlgorithmIdentifier({
+				algorithm: KEY_ALGORITHMS.ecPublicKey,
+				parameters: new asn1js.ObjectIdentifier({ value: curve.oid }).toBER()
+			}),
+			subjectPublicKey: toArrayBuffer(point)
+		});
+		return new Uint8Array(_peculiar_asn1_schema.AsnConvert.serialize(spki));
+	}
+	if (jwk.kty === "RSA") {
+		if (!jwk.n || !jwk.e) throw new X509Exception("RSA public key requires n and e");
+		const rsaPublicKey = new asn1js.Sequence({ value: [integer(_owf_identity_common.base64url.decode(jwk.n)), integer(_owf_identity_common.base64url.decode(jwk.e))] });
+		const spki = new _peculiar_asn1_x509.SubjectPublicKeyInfo({
+			algorithm: new _peculiar_asn1_x509.AlgorithmIdentifier({
+				algorithm: KEY_ALGORITHMS.rsaEncryption,
+				parameters: null
+			}),
+			subjectPublicKey: rsaPublicKey.toBER()
+		});
+		return new Uint8Array(_peculiar_asn1_schema.AsnConvert.serialize(spki));
+	}
+	throw new X509Exception(`Unsupported key type: ${jwk.kty}`);
+}
+/** Describe a SubjectPublicKeyInfo, including a JWK for EC and RSA keys. */
+function describePublicKey(spki) {
+	const der = new Uint8Array(_peculiar_asn1_schema.AsnConvert.serialize(spki));
+	const algorithm = spki.algorithm.algorithm;
+	const key = new Uint8Array(spki.subjectPublicKey);
+	if (algorithm === KEY_ALGORITHMS.ecPublicKey && spki.algorithm.parameters) {
+		const namedCurveNode = parseDer(spki.algorithm.parameters);
+		const namedCurve = namedCurveNode instanceof asn1js.ObjectIdentifier ? namedCurveNode.valueBlock.toString() : void 0;
+		const entry = Object.entries(CURVES).find(([, c]) => c.oid === namedCurve);
+		let jwk;
+		if (entry && key[0] === 4 && key.length === 1 + entry[1].size * 2) {
+			const size = entry[1].size;
+			jwk = {
+				kty: "EC",
+				crv: entry[0],
+				x: _owf_identity_common.base64url.encode(key.subarray(1, 1 + size)),
+				y: _owf_identity_common.base64url.encode(key.subarray(1 + size))
+			};
+		}
+		return {
+			algorithm,
+			namedCurve,
+			spki: der,
+			jwk
+		};
+	}
+	if (algorithm === KEY_ALGORITHMS.rsaEncryption) {
+		let jwk;
+		try {
+			const seq = parseDer(key);
+			if (seq instanceof asn1js.Sequence) {
+				const [n, e] = seq.valueBlock.value;
+				if (n instanceof asn1js.Integer && e instanceof asn1js.Integer) jwk = {
+					kty: "RSA",
+					n: _owf_identity_common.base64url.encode(stripLeadingZeros(new Uint8Array(n.valueBlock.valueHexView))),
+					e: _owf_identity_common.base64url.encode(stripLeadingZeros(new Uint8Array(e.valueBlock.valueHexView)))
+				};
+			}
+		} catch {}
+		return {
+			algorithm,
+			spki: der,
+			jwk
+		};
+	}
+	return {
+		algorithm,
+		spki: der
+	};
+}
+function toHex(bytes) {
+	return (0, _owf_identity_common.hexEncode)(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes));
+}
+function derLength(length) {
+	if (length < 128) return new Uint8Array([length]);
+	const bytes = [];
+	for (let l = length; l > 0; l >>= 8) bytes.unshift(l & 255);
+	return new Uint8Array([128 | bytes.length, ...bytes]);
+}
+/** Encode a single DER TLV. */
+function derTlv(tag, content) {
+	return (0, _owf_identity_common.concatBytes)(new Uint8Array([tag]), derLength(content.length), content);
+}
+/** Interpret big endian two's complement INTEGER content as a bigint (non-negative values only). */
+function integerBytesToBigInt(bytes) {
+	return bytes.length === 0 ? BigInt(0) : BigInt(`0x${(0, _owf_identity_common.hexEncode)(bytes)}`);
+}
+//#endregion
+//#region src/name.ts
+const NAME_BY_OID = new Map(Object.entries(ATTRIBUTE_TYPES).map(([name, oid]) => [oid, name]));
+/** Short names for the RFC 4514 representation (RFC 4514 clause 3 plus common extensions) */
+const RFC4514_SHORT_NAMES = {
+	commonName: "CN",
+	surname: "SN",
+	serialNumber: "SERIALNUMBER",
+	countryName: "C",
+	localityName: "L",
+	stateOrProvinceName: "ST",
+	streetAddress: "STREET",
+	organizationName: "O",
+	organizationalUnitName: "OU",
+	title: "T",
+	givenName: "GN",
+	organizationIdentifier: "organizationIdentifier",
+	emailAddress: "E"
+};
+function attributeValueToString(value) {
+	if (value.anyValue) return `#${toHex(value.anyValue)}`;
+	return value.toString();
+}
+function escapeRfc4514(value) {
+	return value.replace(/[\\"+,;<>=]/g, (c) => `\\${c}`).replace(/^[ #]/, (c) => `\\${c}`).replace(/ $/, "\\ ");
+}
+/** Convert an ASN.1 Name into a {@link DistinguishedName}. */
+function parseName(name) {
+	const attributes = [];
+	const rdnStrings = [];
+	for (const rdn of name) {
+		const parts = [];
+		for (const atv of rdn) {
+			const attrName = NAME_BY_OID.get(atv.type);
+			const value = attributeValueToString(atv.value);
+			attributes.push({
+				type: atv.type,
+				name: attrName,
+				value
+			});
+			const key = (attrName && RFC4514_SHORT_NAMES[attrName]) ?? atv.type;
+			parts.push(`${key}=${atv.value.anyValue ? value : escapeRfc4514(value)}`);
+		}
+		rdnStrings.push(parts.join("+"));
+	}
+	const first = (n) => attributes.find((a) => a.name === n)?.value;
+	return {
+		attributes,
+		rfc4514: rdnStrings.reverse().join(","),
+		commonName: first("commonName"),
+		organizationName: first("organizationName"),
+		organizationIdentifier: first("organizationIdentifier"),
+		organizationalUnitNames: attributes.filter((a) => a.name === "organizationalUnitName").map((a) => a.value),
+		countryName: first("countryName"),
+		localityName: first("localityName"),
+		stateOrProvinceName: first("stateOrProvinceName"),
+		serialNumber: first("serialNumber"),
+		givenName: first("givenName"),
+		surname: first("surname"),
+		pseudonym: first("pseudonym")
+	};
+}
+/** Attributes that X.520 restricts to PrintableString */
+const PRINTABLE_ATTRIBUTES = /* @__PURE__ */ new Set(["countryName", "serialNumber"]);
+/**
+* Build an ASN.1 Name from attributes in encoding order (most general first), one attribute
+* per RDN. Empty values are skipped. `countryName` and `serialNumber` are encoded as
+* PrintableString, `emailAddress` as IA5String and everything else as UTF8String.
+*/
+function buildName(attributes) {
+	const rdns = [];
+	for (const [nameOrOid, value] of attributes) {
+		if (value === void 0 || value === "") continue;
+		const name = nameOrOid in ATTRIBUTE_TYPES ? nameOrOid : NAME_BY_OID.get(nameOrOid);
+		if (!name && !/^\d+(\.\d+)+$/.test(nameOrOid)) throw new X509Exception(`Unknown name attribute: ${nameOrOid}`);
+		const type = name ? ATTRIBUTE_TYPES[name] : nameOrOid;
+		const attributeValue = name && PRINTABLE_ATTRIBUTES.has(name) ? new _peculiar_asn1_x509.AttributeValue({ printableString: value }) : name === "emailAddress" ? new _peculiar_asn1_x509.AttributeValue({ ia5String: value }) : new _peculiar_asn1_x509.AttributeValue({ utf8String: value });
+		rdns.push(new _peculiar_asn1_x509.RelativeDistinguishedName([new _peculiar_asn1_x509.AttributeTypeAndValue({
+			type,
+			value: attributeValue
+		})]));
+	}
+	return new _peculiar_asn1_x509.Name(rdns);
+}
+function normalize(value) {
+	return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+/**
+* Compare two distinguished names attribute by attribute, ignoring case and insignificant
+* whitespace in the values (a simplification of the RFC 5280 clause 7.1 matching rules).
+*/
+function namesEqual(a, b) {
+	return a.attributes.length === b.attributes.length && a.attributes.every((attr, i) => attr.type === b.attributes[i].type && normalize(attr.value) === normalize(b.attributes[i].value));
+}
+//#endregion
+//#region src/extensions.ts
+/** Convert ASN.1 extensions, rejecting duplicates (RFC 5280 clause 4.2). */
+function toExtensions(extensions) {
+	const result = (extensions ?? []).map((e) => ({
+		oid: e.extnID,
+		critical: e.critical,
+		value: new Uint8Array(e.extnValue.buffer)
+	}));
+	const seen = /* @__PURE__ */ new Set();
+	for (const { oid } of result) {
+		if (seen.has(oid)) throw new X509Exception(`Duplicate extension ${oid}`);
+		seen.add(oid);
+	}
+	return result;
+}
+/** Decode an extension value with an asn1-schema type, if the extension is present. */
+function decodeExtension(extensions, oid, type, name) {
+	const extension = extensions.find((e) => e.oid === oid);
+	if (!extension) return void 0;
+	try {
+		return _peculiar_asn1_schema.AsnConvert.parse(toArrayBuffer(extension.value), type);
+	} catch (error) {
+		throw new X509Exception(`Invalid ${name} extension`, error);
+	}
+}
+function uriOf(name) {
+	return name?.uniformResourceIdentifier;
+}
+function urisOf(names) {
+	return (names ?? []).map(uriOf).filter((u) => u !== void 0);
+}
+function emptySubjectAlternativeNames() {
+	return {
+		dnsNames: [],
+		uris: [],
+		emails: [],
+		ipAddresses: [],
+		directoryNames: [],
+		otherNames: []
+	};
+}
+function toSubjectAlternativeNames(names) {
+	const result = emptySubjectAlternativeNames();
+	for (const name of names) if (name.uniformResourceIdentifier !== void 0) result.uris.push(name.uniformResourceIdentifier);
+	else if (name.rfc822Name !== void 0) result.emails.push(name.rfc822Name);
+	else if (name.dNSName !== void 0) result.dnsNames.push(name.dNSName);
+	else if (name.iPAddress !== void 0) result.ipAddresses.push(name.iPAddress);
+	else if (name.directoryName) result.directoryNames.push(parseName(name.directoryName));
+	else if (name.otherName) {
+		const value = new Uint8Array(name.otherName.value);
+		let text;
+		try {
+			text = asn1ToString(parseDer(value));
+		} catch {}
+		result.otherNames.push({
+			typeId: name.otherName.typeId,
+			value,
+			text
+		});
+	}
+	return result;
+}
+/** Telephone numbers from otherName entries with type-id id-at-telephoneNumber */
+function telephoneNumbers(names) {
+	return names.otherNames.filter((o) => o.typeId === ATTRIBUTE_TYPES.telephoneNumber && o.text !== void 0).map((o) => o.text);
+}
+//#endregion
+//#region src/qc-statements.ts
+const QC_TYPE_BY_OID = new Map(Object.entries(QC_TYPES).map(([name, oid]) => [oid, name]));
+/** Decode the statementInfo of a statement with its ETSI EN 319 412-5 schema. */
+function statementInfo(statement, type) {
+	if (!statement.statementInfo) throw new X509Exception(`QCStatement ${statement.statementId} is missing its statementInfo`);
+	try {
+		return _peculiar_asn1_schema.AsnConvert.parse(statement.statementInfo, type);
+	} catch (error) {
+		throw new X509Exception(`Invalid statementInfo for QCStatement ${statement.statementId}`, error);
+	}
+}
+/** Convert a decoded QCStatements extension (RFC 3739, ETSI EN 319 412-5). */
+function parseQcStatements(statements) {
+	const result = {
+		statementIds: [],
+		qcCompliance: false,
+		qcSSCD: false,
+		qcTypes: [],
+		pds: [],
+		legislationCountries: []
+	};
+	for (const statement of statements) {
+		result.statementIds.push(statement.statementId);
+		switch (statement.statementId) {
+			case QC_STATEMENTS.qcCompliance:
+				result.qcCompliance = true;
+				break;
+			case QC_STATEMENTS.qcSSCD:
+				result.qcSSCD = true;
+				break;
+			case QC_STATEMENTS.qcType:
+				for (const oid of statementInfo(statement, _peculiar_asn1_x509_qualified_etsi.QcType)) result.qcTypes.push(QC_TYPE_BY_OID.get(oid) ?? oid);
+				break;
+			case QC_STATEMENTS.qcPDS:
+				for (const { url, language } of statementInfo(statement, _peculiar_asn1_x509_qualified_etsi.QcEuPDS)) result.pds.push({
+					url,
+					language
+				});
+				break;
+			case QC_STATEMENTS.qcCClegislation: result.legislationCountries.push(...statementInfo(statement, _peculiar_asn1_x509_qualified_etsi.QcCClegislation));
+		}
+	}
+	return result;
+}
+function statement(statementId, info) {
+	return Object.assign(new _peculiar_asn1_x509_qualified.QCStatement(), {
+		statementId,
+		statementInfo: info === void 0 ? void 0 : _peculiar_asn1_schema.AsnConvert.serialize(info)
+	});
+}
+/** Build a QCStatements extension value with QcCompliance and the given statements. */
+function toQcStatements(input) {
+	const statements = new _peculiar_asn1_x509_qualified.QCStatements([statement(QC_STATEMENTS.qcCompliance)]);
+	if (input.qcSSCD) statements.push(statement(QC_STATEMENTS.qcSSCD));
+	if (input.qcTypes.length > 0) statements.push(statement(QC_STATEMENTS.qcType, new _peculiar_asn1_x509_qualified_etsi.QcType(input.qcTypes.map((t) => QC_TYPES[t]))));
+	if (input.pds?.length) statements.push(statement(QC_STATEMENTS.qcPDS, new _peculiar_asn1_x509_qualified_etsi.QcEuPDS(input.pds.map((p) => new _peculiar_asn1_x509_qualified_etsi.PdsLocation(p)))));
+	if (input.legislationCountries?.length) statements.push(statement(QC_STATEMENTS.qcCClegislation, new _peculiar_asn1_x509_qualified_etsi.QcCClegislation(input.legislationCountries)));
+	return statements;
+}
+//#endregion
+//#region src/certificate.ts
+const SIGNATURE_ALGORITHM_BY_OID = new Map(Object.entries(SIGNATURE_ALGORITHMS).map(([name, { oid }]) => [oid, name]));
+function signatureAlgorithmName(oid) {
+	return SIGNATURE_ALGORITHM_BY_OID.get(oid);
+}
+function toPolicies(policies) {
+	return (policies ?? []).map((policy) => {
+		const cpsUris = [];
+		const userNotices = [];
+		for (const qualifier of policy.policyQualifiers ?? []) if (qualifier.policyQualifierId === POLICY_QUALIFIERS.cps) {
+			const uri = asn1ToString(parseDer(qualifier.qualifier));
+			if (uri) cpsUris.push(uri);
+		} else if (qualifier.policyQualifierId === POLICY_QUALIFIERS.unotice) {
+			const notice = _peculiar_asn1_schema.AsnConvert.parse(qualifier.qualifier, _peculiar_asn1_x509.UserNotice);
+			if (notice.explicitText) userNotices.push(notice.explicitText.toString());
+		}
+		return {
+			oid: policy.policyIdentifier,
+			cpsUris,
+			userNotices
+		};
+	});
+}
+/**
+* Parse an X.509 certificate.
+*
+* Decodes the standard extensions of RFC 5280 plus QCStatements. Parsing does not verify the
+* signature; use {@link verifyCertificateSignature} for that.
+*
+* @param input DER bytes, base64 encoded DER, or PEM
+* @param options Resource limits forwarded to asn1js (`berOptions`)
+* @throws X509Exception when the input is not a well-formed X.509 certificate
+*/
+function parseCertificate(input, options) {
+	const der = toDer(input, PEM_LABELS.certificate);
+	let certificate;
+	try {
+		certificate = _peculiar_asn1_schema.AsnConvert.parse(toArrayBuffer(der), _peculiar_asn1_x509.Certificate, options);
+	} catch (error) {
+		throw new X509Exception("Invalid X.509 certificate", error);
+	}
+	if (!certificate.tbsCertificateRaw) throw new X509Exception("Unable to extract the TBSCertificate");
+	const tbs = certificate.tbsCertificate;
+	const extensions = toExtensions(tbs.extensions);
+	const decode = (oid, type, name) => decodeExtension(extensions, oid, type, name);
+	const san = decode(_peculiar_asn1_x509.id_ce_subjectAltName, _peculiar_asn1_x509.SubjectAlternativeName, "subjectAltName");
+	const keyUsage = decode(_peculiar_asn1_x509.id_ce_keyUsage, _peculiar_asn1_x509.KeyUsage, "keyUsage");
+	const eku = decode(_peculiar_asn1_x509.id_ce_extKeyUsage, _peculiar_asn1_x509.ExtendedKeyUsage, "extKeyUsage");
+	const basicConstraints = decode(_peculiar_asn1_x509.id_ce_basicConstraints, _peculiar_asn1_x509.BasicConstraints, "basicConstraints");
+	const ski = decode(_peculiar_asn1_x509.id_ce_subjectKeyIdentifier, _peculiar_asn1_x509.SubjectKeyIdentifier, "subjectKeyIdentifier");
+	const aki = decode(_peculiar_asn1_x509.id_ce_authorityKeyIdentifier, _peculiar_asn1_x509.AuthorityKeyIdentifier, "authorityKeyIdentifier");
+	const crlDps = decode(_peculiar_asn1_x509.id_ce_cRLDistributionPoints, _peculiar_asn1_x509.CRLDistributionPoints, "cRLDistributionPoints");
+	const aia = decode(_peculiar_asn1_x509.id_pe_authorityInfoAccess, _peculiar_asn1_x509.AuthorityInfoAccessSyntax, "authorityInfoAccess") ?? [];
+	const qcStatements = decode(QC_STATEMENTS.extension, _peculiar_asn1_x509_qualified.QCStatements, "qcStatements");
+	const accessUrls = (method) => aia.filter((a) => a.accessMethod === method).map((a) => uriOf(a.accessLocation)).filter((u) => u !== void 0);
+	return {
+		der,
+		pem: toPem(der, PEM_LABELS.certificate),
+		version: tbs.version + 1,
+		serialNumber: toHex(tbs.serialNumber),
+		issuer: parseName(tbs.issuer),
+		subject: parseName(tbs.subject),
+		notBefore: tbs.validity.notBefore.getTime(),
+		notAfter: tbs.validity.notAfter.getTime(),
+		publicKey: describePublicKey(tbs.subjectPublicKeyInfo),
+		signatureAlgorithm: certificate.signatureAlgorithm.algorithm,
+		signatureAlgorithmName: signatureAlgorithmName(certificate.signatureAlgorithm.algorithm),
+		tbsCertificate: new Uint8Array(certificate.tbsCertificateRaw),
+		signature: new Uint8Array(certificate.signatureValue),
+		policies: toPolicies(decode(_peculiar_asn1_x509.id_ce_certificatePolicies, _peculiar_asn1_x509.CertificatePolicies, "certificatePolicies")),
+		subjectAlternativeNames: san ? toSubjectAlternativeNames(san) : emptySubjectAlternativeNames(),
+		keyUsage: keyUsage?.toJSON(),
+		extendedKeyUsage: eku ? [...eku] : void 0,
+		basicConstraints: basicConstraints ? {
+			cA: basicConstraints.cA,
+			pathLenConstraint: basicConstraints.pathLenConstraint
+		} : void 0,
+		subjectKeyIdentifier: ski ? toHex(ski.buffer) : void 0,
+		authorityKeyIdentifier: aki?.keyIdentifier ? toHex(aki.keyIdentifier.buffer) : void 0,
+		crlDistributionPoints: (crlDps ?? []).flatMap((dp) => urisOf(dp.distributionPoint?.fullName)),
+		ocspUrls: accessUrls(ACCESS_METHODS.ocsp),
+		caIssuersUrls: accessUrls(ACCESS_METHODS.caIssuers),
+		qcStatements: qcStatements ? parseQcStatements(qcStatements) : void 0,
+		extensions
+	};
+}
+//#endregion
+//#region src/signature.ts
+/** AlgorithmIdentifier for a supported signature algorithm (RFC 3279, RFC 5758). */
+function signatureAlgorithmIdentifier(name) {
+	const algorithm = SIGNATURE_ALGORITHMS[name];
+	if (!algorithm) throw new X509Exception(`Unsupported signature algorithm: ${name}`);
+	return new _peculiar_asn1_x509.AlgorithmIdentifier({
+		algorithm: algorithm.oid,
+		parameters: algorithm.family === "rsa" ? new asn1js.Null().toBER() : void 0
+	});
+}
+/** Normalize a serial number to positive DER INTEGER content (RFC 5280 clause 4.1.2.2). */
+function toSerialNumber(serialNumber) {
+	const positive = toPositiveIntegerBytes(typeof serialNumber === "string" ? (0, _owf_identity_common.hexDecode)(serialNumber.replace(/^0x/i, "")) : serialNumber);
+	if (positive.length === 0 || positive.every((b) => b === 0)) throw new X509Exception("Serial number must be a positive integer");
+	if (positive.length > 20) throw new X509Exception("Serial number must not be longer than 20 octets (RFC 5280 clause 4.1.2.2)");
+	return toArrayBuffer(positive);
+}
+/**
+* Combine prepared to-be-signed bytes with their signature into the DER encoding of the
+* signed structure: `SEQUENCE { tbs, signatureAlgorithm, BIT STRING signature }`.
+*/
+function assembleSignedStructure(prepared, signature, signatureEncoding = "ieee-p1363") {
+	const algorithm = SIGNATURE_ALGORITHMS[prepared.signatureAlgorithm];
+	let signatureDer = signature;
+	if (algorithm.family === "ecdsa" && signatureEncoding === "ieee-p1363") {
+		const coordinateLength = curveCoordinateLength(prepared.signerPublicKey.namedCurve);
+		if (!coordinateLength) throw new X509Exception("Unable to determine the curve of the signer key for ECDSA encoding");
+		signatureDer = ecdsaP1363ToDer(signature, coordinateLength);
+	}
+	const algorithmIdentifier = new Uint8Array(_peculiar_asn1_schema.AsnConvert.serialize(signatureAlgorithmIdentifier(prepared.signatureAlgorithm)));
+	return derTlv(48, (0, _owf_identity_common.concatBytes)(prepared.tbs, algorithmIdentifier, derTlv(3, (0, _owf_identity_common.concatBytes)(new Uint8Array([0]), signatureDer))));
+}
+async function verifySignature(signed, data, publicKey, verifier) {
+	let signatureP1363 = signed.signature;
+	if (signed.signatureAlgorithmName && SIGNATURE_ALGORITHMS[signed.signatureAlgorithmName].family === "ecdsa") {
+		const coordinateLength = curveCoordinateLength(publicKey.namedCurve);
+		if (!coordinateLength) return false;
+		try {
+			signatureP1363 = ecdsaDerToP1363(signed.signature, coordinateLength);
+		} catch {
+			return false;
+		}
+	}
+	return verifier({
+		data,
+		signature: signed.signature,
+		signatureP1363,
+		signatureAlgorithm: signed.signatureAlgorithm,
+		signatureAlgorithmName: signed.signatureAlgorithmName,
+		publicKey
+	});
+}
+function toCertificate(input) {
+	return typeof input === "object" && "tbsCertificate" in input ? input : parseCertificate(input);
+}
+/**
+* Verify that `certificate` was signed by the key of `issuerCertificate`.
+*
+* The issuer name and, when both are present, the authority / subject key identifiers must
+* match. The cryptographic check is delegated to `verifier`, so no global crypto is needed:
+* with WebCrypto, import `publicKey.jwk` and verify `signatureP1363` over `data`.
+*
+* This checks a single link, not a path to a trust anchor.
+*/
+async function verifyCertificateSignature(certificate, issuerCertificate, verifier) {
+	const cert = toCertificate(certificate);
+	const issuer = toCertificate(issuerCertificate);
+	if (!namesEqual(cert.issuer, issuer.subject)) return false;
+	if (cert.authorityKeyIdentifier && issuer.subjectKeyIdentifier && cert.authorityKeyIdentifier !== issuer.subjectKeyIdentifier) return false;
+	return verifySignature(cert, cert.tbsCertificate, issuer.publicKey, verifier);
+}
+/**
+* Verify that `crl` was signed by `issuerCertificate`.
+*
+* The CRL issuer name and, when both are present, the key identifiers must match, and the
+* issuer key usage (if present) must allow cRLSign (RFC 5280 clause 6.3.3).
+*/
+async function verifyCrlSignature(crl, issuerCertificate, verifier) {
+	const issuer = toCertificate(issuerCertificate);
+	if (!namesEqual(crl.issuer, issuer.subject)) return false;
+	if (crl.authorityKeyIdentifier && issuer.subjectKeyIdentifier && crl.authorityKeyIdentifier !== issuer.subjectKeyIdentifier) return false;
+	if (issuer.keyUsage && !issuer.keyUsage.includes("crlSign")) return false;
+	return verifySignature(crl, crl.tbsCertList, issuer.publicKey, verifier);
+}
+//#endregion
+//#region src/create.ts
+function extension(extnID, value, critical = false) {
+	return new _peculiar_asn1_x509.Extension({
+		extnID,
+		critical,
+		extnValue: new _peculiar_asn1_schema.OctetString(_peculiar_asn1_schema.AsnConvert.serialize(value))
+	});
+}
+function keyUsageFlags(usages) {
+	return usages.reduce((flags, usage) => flags | _peculiar_asn1_x509.KeyUsageFlags[usage === "crlSign" ? "cRLSign" : usage], 0);
+}
+/** Parse an issuer certificate into its ASN.1 form. */
+function parseIssuerCertificate(input) {
+	try {
+		return _peculiar_asn1_schema.AsnConvert.parse(toArrayBuffer(toDer(input, PEM_LABELS.certificate)), _peculiar_asn1_x509.Certificate);
+	} catch (error) {
+		throw new X509Exception("Invalid issuer certificate", error);
+	}
+}
+/** The subject key identifier of an ASN.1 certificate, if present. */
+function subjectKeyIdentifierOf(certificate) {
+	const ski = certificate.tbsCertificate.extensions?.find((e) => e.extnID === _peculiar_asn1_x509.id_ce_subjectKeyIdentifier);
+	return ski ? _peculiar_asn1_schema.AsnConvert.parse(ski.extnValue.buffer, _peculiar_asn1_x509.SubjectKeyIdentifier).buffer : void 0;
+}
+/**
+* Encode an otherName whose value is a PrintableString (or UTF8String for non-printable
+* values), e.g. an `id-at-telephoneNumber` subject alternative name.
+*/
+function stringOtherName(typeId, value) {
+	const encoded = /^[A-Za-z0-9 '()+,\-./:=?]*$/.test(value) ? new asn1js.PrintableString({ value }) : new asn1js.Utf8String({ value });
+	return {
+		typeId,
+		value: new Uint8Array(encoded.toBER())
+	};
+}
+/**
+* Build the TBSCertificate for a certificate template.
+*
+* Sign the returned `tbs` bytes with the issuer key wherever that key lives and pass the
+* signature to {@link assembleCertificate}. {@link createCertificate} wraps both steps
+* around a signer callback.
+*/
+async function prepareCertificate(template) {
+	if (!(template.notAfter > template.notBefore)) throw new X509Exception("notAfter must be later than notBefore");
+	const spkiDer = template.subjectPublicKey instanceof Uint8Array ? template.subjectPublicKey : publicJwkToSpki(template.subjectPublicKey);
+	let subjectPublicKeyInfo;
+	try {
+		subjectPublicKeyInfo = _peculiar_asn1_schema.AsnConvert.parse(toArrayBuffer(spkiDer), _peculiar_asn1_x509.SubjectPublicKeyInfo);
+	} catch (error) {
+		throw new X509Exception("Invalid subject public key", error);
+	}
+	const issuer = template.issuerCertificate ? parseIssuerCertificate(template.issuerCertificate) : void 0;
+	const subject = buildName(template.subject);
+	if (subject.length === 0) throw new X509Exception("The subject must not be empty");
+	const extensions = [];
+	const basicConstraints = template.basicConstraints ?? { cA: false };
+	extensions.push(extension(_peculiar_asn1_x509.id_ce_basicConstraints, new _peculiar_asn1_x509.BasicConstraints(basicConstraints), true));
+	const keyUsage = template.keyUsage ?? (basicConstraints.cA ? ["keyCertSign", "crlSign"] : ["digitalSignature"]);
+	if (keyUsage.length > 0) extensions.push(extension(_peculiar_asn1_x509.id_ce_keyUsage, new _peculiar_asn1_x509.KeyUsage(keyUsageFlags(keyUsage)), true));
+	if (template.extendedKeyUsage?.length) extensions.push(extension(_peculiar_asn1_x509.id_ce_extKeyUsage, new _peculiar_asn1_x509.ExtendedKeyUsage(template.extendedKeyUsage)));
+	if (template.certificatePolicies?.length) extensions.push(extension(_peculiar_asn1_x509.id_ce_certificatePolicies, new _peculiar_asn1_x509.CertificatePolicies(template.certificatePolicies.map((policy) => new _peculiar_asn1_x509.PolicyInformation({
+		policyIdentifier: policy.oid,
+		policyQualifiers: policy.cpsUris?.length ? policy.cpsUris.map((uri) => new _peculiar_asn1_x509.PolicyQualifierInfo({
+			policyQualifierId: POLICY_QUALIFIERS.cps,
+			qualifier: new asn1js.IA5String({ value: uri }).toBER()
+		})) : void 0
+	})))));
+	const san = template.subjectAlternativeNames;
+	const generalNames = [
+		...(san?.dnsNames ?? []).map((dNSName) => new _peculiar_asn1_x509.GeneralName({ dNSName })),
+		...(san?.uris ?? []).map((uniformResourceIdentifier) => new _peculiar_asn1_x509.GeneralName({ uniformResourceIdentifier })),
+		...(san?.emails ?? []).map((rfc822Name) => new _peculiar_asn1_x509.GeneralName({ rfc822Name })),
+		...(san?.otherNames ?? []).map((o) => new _peculiar_asn1_x509.GeneralName({ otherName: new _peculiar_asn1_x509.OtherName({
+			typeId: o.typeId,
+			value: toArrayBuffer(o.value)
+		}) }))
+	];
+	if (generalNames.length > 0) extensions.push(extension(_peculiar_asn1_x509.id_ce_subjectAltName, new _peculiar_asn1_x509.SubjectAlternativeName(generalNames)));
+	let subjectKeyIdentifier;
+	if (template.hasher) {
+		subjectKeyIdentifier = toArrayBuffer((await template.hasher(subjectPublicKeyInfo.subjectPublicKey, "sha-256")).slice(0, 20));
+		extensions.push(extension(_peculiar_asn1_x509.id_ce_subjectKeyIdentifier, new _peculiar_asn1_x509.SubjectKeyIdentifier(subjectKeyIdentifier)));
+	}
+	const authorityKeyIdentifier = issuer ? subjectKeyIdentifierOf(issuer) : subjectKeyIdentifier;
+	if (authorityKeyIdentifier) extensions.push(extension(_peculiar_asn1_x509.id_ce_authorityKeyIdentifier, new _peculiar_asn1_x509.AuthorityKeyIdentifier({ keyIdentifier: new _peculiar_asn1_x509.KeyIdentifier(authorityKeyIdentifier) })));
+	if (template.crlDistributionPoints?.length) extensions.push(extension(_peculiar_asn1_x509.id_ce_cRLDistributionPoints, new _peculiar_asn1_x509.CRLDistributionPoints(template.crlDistributionPoints.map((uri) => new _peculiar_asn1_x509.DistributionPoint({ distributionPoint: new _peculiar_asn1_x509.DistributionPointName({ fullName: [new _peculiar_asn1_x509.GeneralName({ uniformResourceIdentifier: uri })] }) })))));
+	const accessDescriptions = [...(template.ocspUrls ?? []).map((uri) => [ACCESS_METHODS.ocsp, uri]), ...(template.caIssuersUrls ?? []).map((uri) => [ACCESS_METHODS.caIssuers, uri])].map(([accessMethod, uri]) => new _peculiar_asn1_x509.AccessDescription({
+		accessMethod,
+		accessLocation: new _peculiar_asn1_x509.GeneralName({ uniformResourceIdentifier: uri })
+	}));
+	if (accessDescriptions.length > 0) extensions.push(extension(_peculiar_asn1_x509.id_pe_authorityInfoAccess, new _peculiar_asn1_x509.AuthorityInfoAccessSyntax(accessDescriptions)));
+	if (template.qcStatements) {
+		const qcStatements = toQcStatements({
+			...template.qcStatements,
+			qcTypes: template.qcStatements.qcTypes ?? []
+		});
+		extensions.push(extension(QC_STATEMENTS.extension, qcStatements));
+	}
+	for (const custom of template.extensions ?? []) extensions.push(toAsnExtension(custom));
+	const seen = /* @__PURE__ */ new Set();
+	for (const { extnID } of extensions) {
+		if (seen.has(extnID)) throw new X509Exception(`Duplicate extension ${extnID}`);
+		seen.add(extnID);
+	}
+	const tbs = new _peculiar_asn1_x509.TBSCertificate({
+		version: _peculiar_asn1_x509.Version.v3,
+		serialNumber: toSerialNumber(template.serialNumber),
+		signature: signatureAlgorithmIdentifier(template.signatureAlgorithm),
+		issuer: issuer ? issuer.tbsCertificate.subject : subject,
+		validity: new _peculiar_asn1_x509.Validity({
+			notBefore: template.notBefore,
+			notAfter: template.notAfter
+		}),
+		subject,
+		subjectPublicKeyInfo,
+		extensions: new _peculiar_asn1_x509.Extensions(extensions)
+	});
+	return {
+		tbs: new Uint8Array(_peculiar_asn1_schema.AsnConvert.serialize(tbs)),
+		signatureAlgorithm: template.signatureAlgorithm,
+		signerPublicKey: describePublicKey(issuer ? issuer.tbsCertificate.subjectPublicKeyInfo : subjectPublicKeyInfo)
+	};
+}
+function toAsnExtension(extension) {
+	return new _peculiar_asn1_x509.Extension({
+		extnID: extension.oid,
+		critical: extension.critical,
+		extnValue: new _peculiar_asn1_schema.OctetString(toArrayBuffer(extension.value))
+	});
+}
+/**
+* Combine a prepared TBSCertificate with the issuer signature.
+*
+* @param signatureEncoding Encoding of ECDSA signatures; WebCrypto produces `ieee-p1363` (default)
+*/
+function assembleCertificate(prepared, signature, signatureEncoding) {
+	return parseCertificate(assembleSignedStructure(prepared, signature, signatureEncoding));
+}
+/**
+* Create an X.509 v3 certificate.
+*
+* The issuer key is never passed in: the `signer` callback receives the DER encoded
+* TBSCertificate and returns the signature, so the key can stay in WebCrypto, a KMS or an
+* HSM. Only the public key of the subject is needed; a JWK with private key material is
+* rejected.
+*/
+async function createCertificate(template) {
+	const prepared = await prepareCertificate(template);
+	return assembleCertificate(prepared, await template.signer(prepared.tbs), template.signatureEncoding);
+}
+//#endregion
+//#region src/crl.ts
+const REASON_BY_CODE = new Map(Object.entries(CRL_REASONS).map(([name, code]) => [code, name]));
+/** CRL extensions understood by {@link getRevocationStatus} */
+const KNOWN_CRL_EXTENSIONS = /* @__PURE__ */ new Set([
+	_peculiar_asn1_x509.id_ce_authorityKeyIdentifier,
+	_peculiar_asn1_x509.id_ce_issuerAltName,
+	_peculiar_asn1_x509.id_ce_cRLNumber,
+	_peculiar_asn1_x509.id_ce_deltaCRLIndicator,
+	_peculiar_asn1_x509.id_ce_issuingDistributionPoint,
+	_peculiar_asn1_x509.id_ce_freshestCRL,
+	_peculiar_asn1_x509.id_pe_authorityInfoAccess
+]);
+/** CRL entry extensions understood by {@link getRevocationStatus} */
+const KNOWN_ENTRY_EXTENSIONS = /* @__PURE__ */ new Set([
+	_peculiar_asn1_x509.id_ce_cRLReasons,
+	_peculiar_asn1_x509.id_ce_invalidityDate,
+	_peculiar_asn1_x509.id_ce_certificateIssuer,
+	"2.5.29.23"
+]);
+function decodeInteger(extensions, oid, name) {
+	const extension = extensions.find((e) => e.oid === oid);
+	if (!extension) return void 0;
+	const node = parseDer(extension.value);
+	const bytes = node instanceof asn1js.Integer ? new Uint8Array(node.valueBlock.valueHexView) : void 0;
+	if (!bytes || bytes.length === 0 || bytes[0] & 128) throw new X509Exception(`Invalid ${name} extension`);
+	return integerBytesToBigInt(bytes);
+}
+function directoryNameOf(names) {
+	const name = names.find((n) => n.directoryName)?.directoryName;
+	return name ? parseName(name) : void 0;
+}
+function toRevokedCertificates(entries) {
+	let certificateIssuer;
+	return (entries ?? []).map((entry) => {
+		const extensions = toExtensions(entry.crlEntryExtensions);
+		const decode = (oid, type, name) => decodeExtension(extensions, oid, type, name);
+		const reason = decode(_peculiar_asn1_x509.id_ce_cRLReasons, _peculiar_asn1_x509.CRLReason, "reasonCode");
+		const invalidity = decode(_peculiar_asn1_x509.id_ce_invalidityDate, _peculiar_asn1_x509.InvalidityDate, "invalidityDate");
+		const issuer = decode(_peculiar_asn1_x509.id_ce_certificateIssuer, _peculiar_asn1_x509.CertificateIssuer, "certificateIssuer");
+		if (issuer) certificateIssuer = directoryNameOf(issuer);
+		return {
+			serialNumber: toHex(entry.userCertificate),
+			revocationDate: entry.revocationDate.getTime(),
+			reason: reason ? REASON_BY_CODE.get(reason.reason) : void 0,
+			invalidityDate: invalidity?.value,
+			certificateIssuer,
+			extensions
+		};
+	});
+}
+/** ASN.1 nodes per CRL entry: SEQUENCE, INTEGER, Time and up to three extensions of four nodes */
+const NODES_PER_ENTRY = 16;
+/**
+* Parse an X.509 certificate revocation list (RFC 5280 clause 5).
+*
+* Parsing does not verify the signature; use {@link verifyCrlSignature} or {@link checkRevocation}.
+*
+* @param input DER bytes, base64 encoded DER, or PEM (`X509 CRL`)
+* @throws X509Exception when the input is not a well-formed CRL or exceeds the size limits
+*/
+function parseCrl(input, options = {}) {
+	const der = toDer(input, PEM_LABELS.crl);
+	const { maxEntries = 1e5, berOptions } = options;
+	let crl;
+	try {
+		crl = _peculiar_asn1_schema.AsnConvert.parse(toArrayBuffer(der), _peculiar_asn1_x509.CertificateList, { berOptions: {
+			maxNodes: 1e3 + maxEntries * NODES_PER_ENTRY,
+			...berOptions
+		} });
+	} catch (error) {
+		throw new X509Exception("Invalid CRL", error);
+	}
+	if (!crl.tbsCertListRaw) throw new X509Exception("Unable to extract the TBSCertList");
+	const tbs = crl.tbsCertList;
+	const extensions = toExtensions(tbs.crlExtensions);
+	const decode = (oid, type, name) => decodeExtension(extensions, oid, type, name);
+	const aki = decode(_peculiar_asn1_x509.id_ce_authorityKeyIdentifier, _peculiar_asn1_x509.AuthorityKeyIdentifier, "authorityKeyIdentifier");
+	const idp = decode(_peculiar_asn1_x509.id_ce_issuingDistributionPoint, _peculiar_asn1_x509.IssuingDistributionPoint, "issuingDistributionPoint");
+	const freshest = decode(_peculiar_asn1_x509.id_ce_freshestCRL, _peculiar_asn1_x509.FreshestCRL, "freshestCRL");
+	return {
+		der,
+		pem: toPem(der, PEM_LABELS.crl),
+		version: tbs.version === void 0 ? 1 : tbs.version + 1,
+		issuer: parseName(tbs.issuer),
+		thisUpdate: tbs.thisUpdate.getTime(),
+		nextUpdate: tbs.nextUpdate?.getTime(),
+		signatureAlgorithm: crl.signatureAlgorithm.algorithm,
+		signatureAlgorithmName: signatureAlgorithmName(crl.signatureAlgorithm.algorithm),
+		signature: new Uint8Array(crl.signature),
+		tbsCertList: new Uint8Array(crl.tbsCertListRaw),
+		crlNumber: decodeInteger(extensions, _peculiar_asn1_x509.id_ce_cRLNumber, "cRLNumber"),
+		deltaCrlIndicator: decodeInteger(extensions, _peculiar_asn1_x509.id_ce_deltaCRLIndicator, "deltaCRLIndicator"),
+		authorityKeyIdentifier: aki?.keyIdentifier ? toHex(aki.keyIdentifier.buffer) : void 0,
+		issuingDistributionPoint: idp ? {
+			distributionPointUris: urisOf(idp.distributionPoint?.fullName),
+			onlyContainsUserCerts: idp.onlyContainsUserCerts,
+			onlyContainsCACerts: idp.onlyContainsCACerts,
+			onlyContainsAttributeCerts: idp.onlyContainsAttributeCerts,
+			indirectCRL: idp.indirectCRL,
+			onlySomeReasons: idp.onlySomeReasons?.toJSON()
+		} : void 0,
+		freshestCrl: (freshest ?? []).flatMap((dp) => urisOf(dp.distributionPoint?.fullName)),
+		revokedCertificates: toRevokedCertificates(tbs.revokedCertificates),
+		extensions
+	};
+}
+function normalizeSerial(hex) {
+	return hex.toLowerCase().replace(/^(00)+(?=..)/, "");
+}
+function unknown(reason, message) {
+	return {
+		status: "unknown",
+		reason,
+		message
+	};
+}
+/**
+* Look up the revocation status of `certificate` in `crl`.
+*
+* This does **not** verify the CRL signature; use {@link checkRevocation} unless the CRL
+* has already been verified. The CRL must be issued by the certificate issuer (or be an
+* indirect CRL naming it), must be current, and must cover the certificate. Otherwise the
+* status is `unknown` with the reason, and the caller should find a suitable CRL or fall
+* back to OCSP.
+*/
+function getRevocationStatus(certificate, crl, options = {}) {
+	if (crl.deltaCrlIndicator !== void 0) return unknown("delta_crl", "Delta CRLs can only be used together with their base CRL");
+	const unsupported = crl.extensions.find((e) => e.critical && !KNOWN_CRL_EXTENSIONS.has(e.oid));
+	if (unsupported) return unknown("unsupported_critical_extension", `Unsupported critical CRL extension ${unsupported.oid}`);
+	const idp = crl.issuingDistributionPoint;
+	const indirect = idp?.indirectCRL ?? false;
+	if (!indirect) {
+		if (!namesEqual(crl.issuer, certificate.issuer)) return unknown("issuer_mismatch", "The CRL is not issued by the certificate issuer");
+		if (crl.authorityKeyIdentifier && certificate.authorityKeyIdentifier && crl.authorityKeyIdentifier !== certificate.authorityKeyIdentifier) return unknown("issuer_mismatch", "The CRL is signed with a different key than the certificate");
+	}
+	if (options.now !== false) {
+		const now = options.now ?? /* @__PURE__ */ new Date();
+		if (now < crl.thisUpdate) return unknown("crl_not_yet_valid", `The CRL is not valid before ${crl.thisUpdate.toISOString()}`);
+		if (crl.nextUpdate && now > crl.nextUpdate) return unknown("crl_expired", `The CRL expired at ${crl.nextUpdate.toISOString()}`);
+	}
+	if (idp) {
+		const isCA = certificate.basicConstraints?.cA === true;
+		if (idp.onlyContainsAttributeCerts) return unknown("out_of_scope", "The CRL only covers attribute certificates");
+		if (idp.onlyContainsCACerts && !isCA) return unknown("out_of_scope", "The CRL only covers CA certificates");
+		if (idp.onlyContainsUserCerts && isCA) return unknown("out_of_scope", "The CRL only covers end-entity certificates");
+		if (idp.distributionPointUris.length > 0 && !idp.distributionPointUris.some((uri) => certificate.crlDistributionPoints.includes(uri))) return unknown("out_of_scope", "The CRL distribution point does not match the certificate");
+	}
+	const serial = normalizeSerial(certificate.serialNumber);
+	const entry = crl.revokedCertificates.find((e) => normalizeSerial(e.serialNumber) === serial && (!indirect || namesEqual(e.certificateIssuer ?? crl.issuer, certificate.issuer)));
+	if (entry) {
+		const unsupportedEntry = entry.extensions.find((e) => e.critical && !KNOWN_ENTRY_EXTENSIONS.has(e.oid));
+		if (unsupportedEntry) return unknown("unsupported_critical_extension", `Unsupported critical CRL entry extension ${unsupportedEntry.oid}`);
+		if (entry.reason === "removeFromCRL") return { status: "good" };
+		return {
+			status: "revoked",
+			revocationDate: entry.revocationDate,
+			reason: entry.reason,
+			invalidityDate: entry.invalidityDate
+		};
+	}
+	if (idp?.onlySomeReasons) return unknown("out_of_scope", `The CRL only covers the reasons ${idp.onlySomeReasons.join(", ")}`);
+	return { status: "good" };
+}
+/**
+* Verify the CRL signature against `crlIssuerCertificate`, then look up the revocation
+* status of `certificate` (see {@link getRevocationStatus}).
+*
+* The signature check is delegated to `verifier`; an invalid signature yields `unknown`
+* with reason `invalid_signature`. Fetching the CRL (see `crlDistributionPoints` on the
+* certificate) is up to the caller.
+*/
+async function checkRevocation(options) {
+	if (!await verifyCrlSignature(options.crl, options.crlIssuerCertificate, options.verifier)) return unknown("invalid_signature", "The CRL signature is invalid or not issued by the given certificate");
+	return getRevocationStatus(options.certificate, options.crl, { now: options.now });
+}
+function bigintToIntegerBytes(value) {
+	const n = BigInt(value);
+	if (n < BigInt(0)) throw new X509Exception("CRL numbers must not be negative");
+	const hex = n.toString(16);
+	const bytes = toPositiveIntegerBytes((0, _owf_identity_common.hexDecode)(hex.length % 2 ? `0${hex}` : hex));
+	if (bytes.length > 20) throw new X509Exception("CRL numbers must not be longer than 20 octets");
+	return bytes;
+}
+function derExtension(oid, value, critical = false) {
+	return new _peculiar_asn1_x509.Extension({
+		extnID: oid,
+		critical,
+		extnValue: new _peculiar_asn1_schema.OctetString(value instanceof Uint8Array ? toArrayBuffer(value) : value)
+	});
+}
+/**
+* Build the TBSCertList of a v2 CRL. Sign the returned `tbs` bytes with the CRL issuer key
+* and pass the signature to {@link assembleCrl}, or use {@link createCrl} with a signer.
+*/
+function prepareCrl(template) {
+	if (!(template.nextUpdate > template.thisUpdate)) throw new X509Exception("nextUpdate must be later than thisUpdate");
+	const issuer = parseIssuerCertificate(template.issuerCertificate);
+	const extensions = [];
+	const ski = subjectKeyIdentifierOf(issuer);
+	if (ski) extensions.push(derExtension(_peculiar_asn1_x509.id_ce_authorityKeyIdentifier, _peculiar_asn1_schema.AsnConvert.serialize(new _peculiar_asn1_x509.AuthorityKeyIdentifier({ keyIdentifier: new _peculiar_asn1_x509.KeyIdentifier(ski) }))));
+	extensions.push(derExtension(_peculiar_asn1_x509.id_ce_cRLNumber, new asn1js.Integer({ valueHex: toArrayBuffer(bigintToIntegerBytes(template.crlNumber)) }).toBER()));
+	const idp = template.issuingDistributionPoint;
+	if (idp) extensions.push(derExtension(_peculiar_asn1_x509.id_ce_issuingDistributionPoint, _peculiar_asn1_schema.AsnConvert.serialize(new _peculiar_asn1_x509.IssuingDistributionPoint({
+		distributionPoint: idp.distributionPointUris?.length ? new _peculiar_asn1_x509.DistributionPointName({ fullName: idp.distributionPointUris.map((uri) => new _peculiar_asn1_x509.GeneralName({ uniformResourceIdentifier: uri })) }) : void 0,
+		onlyContainsUserCerts: idp.onlyContainsUserCerts ?? false,
+		onlyContainsCACerts: idp.onlyContainsCACerts ?? false
+	})), true));
+	for (const custom of template.extensions ?? []) extensions.push(toAsnExtension(custom));
+	const revoked = (template.revokedCertificates ?? []).map((entry) => {
+		const entryExtensions = [];
+		if (entry.reason && entry.reason !== "unspecified") entryExtensions.push(derExtension(_peculiar_asn1_x509.id_ce_cRLReasons, new asn1js.Enumerated({ value: CRL_REASONS[entry.reason] }).toBER()));
+		if (entry.invalidityDate) entryExtensions.push(derExtension(_peculiar_asn1_x509.id_ce_invalidityDate, _peculiar_asn1_schema.AsnConvert.serialize(new _peculiar_asn1_x509.InvalidityDate(entry.invalidityDate))));
+		return new _peculiar_asn1_x509.RevokedCertificate({
+			userCertificate: toSerialNumber(entry.serialNumber),
+			revocationDate: new _peculiar_asn1_x509.Time(entry.revocationDate),
+			crlEntryExtensions: entryExtensions.length > 0 ? entryExtensions : void 0
+		});
+	});
+	const tbs = new _peculiar_asn1_x509.TBSCertList({
+		version: _peculiar_asn1_x509.Version.v2,
+		signature: signatureAlgorithmIdentifier(template.signatureAlgorithm),
+		issuer: issuer.tbsCertificate.subject,
+		thisUpdate: new _peculiar_asn1_x509.Time(template.thisUpdate),
+		nextUpdate: new _peculiar_asn1_x509.Time(template.nextUpdate),
+		revokedCertificates: revoked.length > 0 ? revoked : void 0,
+		crlExtensions: extensions
+	});
+	return {
+		tbs: new Uint8Array(_peculiar_asn1_schema.AsnConvert.serialize(tbs)),
+		signatureAlgorithm: template.signatureAlgorithm,
+		signerPublicKey: describePublicKey(issuer.tbsCertificate.subjectPublicKeyInfo)
+	};
+}
+/** Combine a prepared TBSCertList with the issuer signature. */
+function assembleCrl(prepared, signature, signatureEncoding) {
+	return parseCrl(assembleSignedStructure(prepared, signature, signatureEncoding));
+}
+/**
+* Create a v2 CRL. The CRL issuer key is never passed in: the `signer` callback receives the
+* DER encoded TBSCertList and returns the signature.
+*/
+async function createCrl(template) {
+	const prepared = prepareCrl(template);
+	return assembleCrl(prepared, await template.signer(prepared.tbs), template.signatureEncoding);
+}
+//#endregion
+exports.ACCESS_METHODS = ACCESS_METHODS;
+exports.ATTRIBUTE_TYPES = ATTRIBUTE_TYPES;
+exports.CRL_REASONS = CRL_REASONS;
+exports.KEY_ALGORITHMS = KEY_ALGORITHMS;
+exports.PEM_LABELS = PEM_LABELS;
+exports.POLICY_QUALIFIERS = POLICY_QUALIFIERS;
+exports.QC_STATEMENTS = QC_STATEMENTS;
+exports.QC_TYPES = QC_TYPES;
+exports.SIGNATURE_ALGORITHMS = SIGNATURE_ALGORITHMS;
+exports.X509Exception = X509Exception;
+exports.assembleCertificate = assembleCertificate;
+exports.assembleCrl = assembleCrl;
+exports.assembleSignedStructure = assembleSignedStructure;
+exports.checkRevocation = checkRevocation;
+exports.createCertificate = createCertificate;
+exports.createCrl = createCrl;
+exports.ecdsaDerToP1363 = ecdsaDerToP1363;
+exports.ecdsaP1363ToDer = ecdsaP1363ToDer;
+exports.getRevocationStatus = getRevocationStatus;
+exports.namesEqual = namesEqual;
+exports.parseCertificate = parseCertificate;
+exports.parseCrl = parseCrl;
+exports.prepareCertificate = prepareCertificate;
+exports.prepareCrl = prepareCrl;
+exports.publicJwkToSpki = publicJwkToSpki;
+exports.stringOtherName = stringOtherName;
+exports.telephoneNumbers = telephoneNumbers;
+exports.toDer = toDer;
+exports.toPem = toPem;
+exports.verifyCertificateSignature = verifyCertificateSignature;
+exports.verifyCrlSignature = verifyCrlSignature;
+
+//# sourceMappingURL=index.cjs.map