agentplugged 1.0.4 → 1.2.0

package/dist/helpers.js

@@ -2113,7 +2113,7 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.utilToBase = utilToBase;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/asn1js@3.0.10/node_modules/asn1js/build/index.js
+//#region ../../node_modules/.pnpm/asn1js@3.1.0/node_modules/asn1js/build/index.js
 /*!
 * Copyright (c) 2014, GMO GlobalSign
 * Copyright (c) 2015-2022, Peculiar Ventures
@@ -2181,7 +2181,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		const retView = new Uint8Array(outputLength);
 		for (let i = 0; i < buffers.length; i++) {
 			const buffer = buffers[i];
-			retView.set(new Uint8Array(buffer), prevLength);
+			retView.set(buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer), prevLength);
 			prevLength += buffer.byteLength;
 		}
 		return retView.buffer;
@@ -2214,14 +2214,14 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 			this.items = [];
 		}
 		write(buf) {
-			this.items.push(buf);
+			this.items.push(buf instanceof ArrayBuffer ? buf : concat([buf]));
 		}
 		final() {
 			return concat(this.items);
 		}
 	};
-	const powers2 = [new Uint8Array([1])];
-	const digitsString = "0123456789";
+	const ORIGINAL_VIEW_WRITER_WRITE = ViewWriter.prototype.write;
+	const ORIGINAL_VIEW_WRITER_FINAL = ViewWriter.prototype.final;
 	const NAME = "name";
 	const VALUE_HEX_VIEW = "valueHexView";
 	const IS_HEX_ONLY = "isHexOnly";
@@ -2271,7 +2271,8 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 					return EMPTY_BUFFER;
 				}
 				if (sizeOnly) return new ArrayBuffer(this.valueHexView.byteLength);
-				return this.valueHexView.byteLength === this.valueHexView.buffer.byteLength ? this.valueHexView.buffer : this.valueHexView.slice().buffer;
+				if (this.valueHexView.buffer instanceof ArrayBuffer && this.valueHexView.byteLength === this.valueHexView.buffer.byteLength) return this.valueHexView.buffer;
+				return pvtsutils__namespace.BufferSourceConverter.toArrayBuffer(this.valueHexView);
 			}
 			toJSON() {
 				return {
@@ -2389,12 +2390,15 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		fromBER(inputBuffer, inputOffset, inputLength) {
 			const inputView = pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer);
 			if (!checkBufferParams(this, inputView, inputOffset, inputLength)) return -1;
-			const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
-			if (intBuffer.length === 0) {
+			const fastArgs = Number.isInteger(inputOffset) && Number.isInteger(inputLength);
+			const intBuffer = fastArgs ? inputView : inputView.subarray(inputOffset, inputOffset + inputLength);
+			const baseIndex = fastArgs ? inputOffset : 0;
+			const bufferLength = fastArgs ? inputLength : intBuffer.length;
+			if (bufferLength === 0) {
 				this.error = "Zero buffer length";
 				return -1;
 			}
-			switch (intBuffer[0] & 192) {
+			switch (intBuffer[baseIndex] & 192) {
 				case 0:
 					this.tagClass = 1;
 					break;
@@ -2411,9 +2415,9 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 					this.error = "Unknown tag class";
 					return -1;
 			}
-			this.isConstructed = (intBuffer[0] & 32) === 32;
+			this.isConstructed = (intBuffer[baseIndex] & 32) === 32;
 			this.isHexOnly = false;
-			const tagNumberMask = intBuffer[0] & 31;
+			const tagNumberMask = intBuffer[baseIndex] & 31;
 			if (tagNumberMask !== 31) {
 				this.tagNumber = tagNumberMask;
 				this.blockLength = 1;
@@ -2421,16 +2425,16 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 				let count = 0;
 				while (true) {
 					const tagByteIndex = count + 1;
-					if (tagByteIndex >= intBuffer.length) {
+					if (tagByteIndex >= bufferLength) {
 						this.error = "End of input reached before message was fully decoded";
 						return -1;
 					}
 					count++;
-					if ((intBuffer[tagByteIndex] & 128) === 0) break;
+					if ((intBuffer[baseIndex + tagByteIndex] & 128) === 0) break;
 				}
 				this.blockLength = count + 1;
 				const intTagNumberBuffer = this.valueHexView = new Uint8Array(count);
-				for (let i = 0; i < count; i++) intTagNumberBuffer[i] = intBuffer[i + 1] & 127;
+				for (let i = 0; i < count; i++) intTagNumberBuffer[i] = intBuffer[baseIndex + i + 1] & 127;
 				if (this.blockLength <= 9) this.tagNumber = pvutils__namespace.utilFromBase(intTagNumberBuffer, 7);
 				else {
 					this.isHexOnly = true;
@@ -2466,6 +2470,8 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	LocalIdentificationBlock.NAME = "identificationBlock";
+	const ORIGINAL_LOCAL_IDENTIFICATION_TO_BER = LocalIdentificationBlock.prototype.toBER;
+	const ORIGINAL_LOCAL_IDENTIFICATION_FROM_BER = LocalIdentificationBlock.prototype.fromBER;
 	var LocalLengthBlock = class extends LocalBaseBlock {
 		constructor({ lenBlock = {} } = {}) {
 			var _a, _b, _c;
@@ -2477,32 +2483,35 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		fromBER(inputBuffer, inputOffset, inputLength) {
 			const view = pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer);
 			if (!checkBufferParams(this, view, inputOffset, inputLength)) return -1;
-			const intBuffer = view.subarray(inputOffset, inputOffset + inputLength);
-			if (intBuffer.length === 0) {
+			const fastArgs = Number.isInteger(inputOffset) && Number.isInteger(inputLength);
+			const intBuffer = fastArgs ? view : view.subarray(inputOffset, inputOffset + inputLength);
+			const baseIndex = fastArgs ? inputOffset : 0;
+			const bufferLength = fastArgs ? inputLength : intBuffer.length;
+			if (bufferLength === 0) {
 				this.error = "Zero buffer length";
 				return -1;
 			}
-			if (intBuffer[0] === 255) {
+			if (intBuffer[baseIndex] === 255) {
 				this.error = "Length block 0xFF is reserved by standard";
 				return -1;
 			}
-			this.isIndefiniteForm = intBuffer[0] === 128;
+			this.isIndefiniteForm = intBuffer[baseIndex] === 128;
 			if (this.isIndefiniteForm) {
 				this.blockLength = 1;
 				return inputOffset + this.blockLength;
 			}
-			this.longFormUsed = !!(intBuffer[0] & 128);
+			this.longFormUsed = !!(intBuffer[baseIndex] & 128);
 			if (this.longFormUsed === false) {
-				this.length = intBuffer[0];
+				this.length = intBuffer[baseIndex];
 				this.blockLength = 1;
 				return inputOffset + this.blockLength;
 			}
-			const count = intBuffer[0] & 127;
+			const count = intBuffer[baseIndex] & 127;
 			if (count > 8) {
 				this.error = "Too big integer";
 				return -1;
 			}
-			if (count + 1 > intBuffer.length) {
+			if (count + 1 > bufferLength) {
 				this.error = "End of input reached before message was fully decoded";
 				return -1;
 			}
@@ -2557,7 +2566,328 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	LocalLengthBlock.NAME = "lengthBlock";
+	const ORIGINAL_LOCAL_LENGTH_TO_BER = LocalLengthBlock.prototype.toBER;
+	const ORIGINAL_LOCAL_LENGTH_FROM_BER = LocalLengthBlock.prototype.fromBER;
 	const typeStore = {};
+	var _a$y;
+	var _b;
+	var _c;
+	const originalUint8ArraySliceInfo = findMethod(Uint8Array.prototype, "slice");
+	const originalUint8ArrayConstructor = (_a$y = Object.getOwnPropertyDescriptor(Uint8Array.prototype, "constructor")) === null || _a$y === void 0 ? void 0 : _a$y.value;
+	const originalArrayIterator = (_b = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator)) === null || _b === void 0 ? void 0 : _b.value;
+	const intrinsicTypedArrayByteLength = (_c = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "byteLength")) === null || _c === void 0 ? void 0 : _c.get;
+	const BUILTIN_DISPATCH_PAYLOAD_THRESHOLD = 16384;
+	const BUILTIN_DISPATCH_MAX_DEPTH = 64;
+	let builtinRegistry;
+	function registerBuiltinEncoder(builtinConstructors, internals) {
+		const nextInternals = internals || builtinRegistry;
+		if (!nextInternals) {
+			builtinRegistry = void 0;
+			return;
+		}
+		builtinRegistry = {
+			...nextInternals,
+			...builtinConstructors
+		};
+	}
+	function dataProperty(object, name) {
+		const descriptor = Object.getOwnPropertyDescriptor(object, name);
+		if (!descriptor || !("value" in descriptor)) return void 0;
+		return descriptor.value;
+	}
+	function intrinsicPayloadByteLength(value) {
+		if (!intrinsicTypedArrayByteLength || !value || typeof value !== "object") return void 0;
+		try {
+			const byteLength = intrinsicTypedArrayByteLength.call(value);
+			return typeof byteLength === "number" ? byteLength : void 0;
+		} catch {
+			return;
+		}
+	}
+	function largePayloadOrChain(block, depth) {
+		if (depth > BUILTIN_DISPATCH_MAX_DEPTH || !block || typeof block !== "object") return false;
+		const valueBlockDescriptor = Object.getOwnPropertyDescriptor(block, "valueBlock");
+		if (!valueBlockDescriptor || !("value" in valueBlockDescriptor)) return false;
+		const valueBlock = valueBlockDescriptor.value;
+		if (!valueBlock || typeof valueBlock !== "object") return false;
+		const payloadDescriptor = Object.getOwnPropertyDescriptor(valueBlock, "valueHexView");
+		if (payloadDescriptor) {
+			if (!("value" in payloadDescriptor)) return false;
+			const byteLength = intrinsicPayloadByteLength(payloadDescriptor.value);
+			return byteLength !== void 0 && byteLength >= BUILTIN_DISPATCH_PAYLOAD_THRESHOLD;
+		}
+		const valuesDescriptor = Object.getOwnPropertyDescriptor(valueBlock, "value");
+		if (!valuesDescriptor || !("value" in valuesDescriptor) || !Array.isArray(valuesDescriptor.value)) return false;
+		const values = valuesDescriptor.value;
+		const lengthDescriptor = Object.getOwnPropertyDescriptor(values, "length");
+		if (!lengthDescriptor || !("value" in lengthDescriptor) || lengthDescriptor.value !== 1) return false;
+		const indexDescriptor = Object.getOwnPropertyDescriptor(values, "0");
+		if (!indexDescriptor || !("value" in indexDescriptor)) return false;
+		return largePayloadOrChain(indexDescriptor.value, depth + 1);
+	}
+	function shouldUseBuiltinEncoder(block) {
+		try {
+			return largePayloadOrChain(block, 0);
+		} catch {
+			return false;
+		}
+	}
+	function sameDataMethod(current, original) {
+		return !!current && "value" in current && current.value === original && current.writable === true && current.enumerable === false && current.configurable === true;
+	}
+	function writerMethodsStable(registry) {
+		return sameDataMethod(Object.getOwnPropertyDescriptor(registry.ViewWriter.prototype, "write"), registry.originalWriterWrite) && sameDataMethod(Object.getOwnPropertyDescriptor(registry.ViewWriter.prototype, "final"), registry.originalWriterFinal);
+	}
+	function findMethod(prototype, name) {
+		let current = prototype;
+		while (current) {
+			const descriptor = Object.getOwnPropertyDescriptor(current, name);
+			if (descriptor) {
+				if ("value" in descriptor && typeof descriptor.value === "function") return {
+					declaringPrototype: current,
+					method: descriptor.value
+				};
+				return;
+			}
+			current = Object.getPrototypeOf(current);
+		}
+	}
+	function stableInheritedMethod(prototype, name, original) {
+		if (!original) return false;
+		let current = prototype;
+		while (current) {
+			const descriptor = Object.getOwnPropertyDescriptor(current, name);
+			if (current === original.declaringPrototype) return !!descriptor && "value" in descriptor && descriptor.value === original.method;
+			if (descriptor) return false;
+			current = Object.getPrototypeOf(current);
+		}
+		return false;
+	}
+	function prototypeMethod(object, prototype, name, expected) {
+		if (Object.prototype.hasOwnProperty.call(object, name)) return false;
+		if (Object.getPrototypeOf(object) !== prototype) return false;
+		const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+		return !!descriptor && "value" in descriptor && descriptor.value === expected;
+	}
+	function inheritedMethod(object, name, expected, primitiveConstructor) {
+		if (Object.prototype.hasOwnProperty.call(object, name)) return false;
+		const prototype = Object.getPrototypeOf(object);
+		const originalPrimitiveValuePrototype = Object.getPrototypeOf(primitiveConstructor.prototype);
+		if (prototype !== primitiveConstructor.prototype || Object.getPrototypeOf(prototype) !== originalPrimitiveValuePrototype) return false;
+		if (prototype && Object.getOwnPropertyDescriptor(prototype, name)) return false;
+		const parentDescriptor = Object.getOwnPropertyDescriptor(originalPrimitiveValuePrototype, name);
+		return !!parentDescriptor && "value" in parentDescriptor && parentDescriptor.value === expected;
+	}
+	function plainPayload(value, allowEmpty = false) {
+		if (!(value instanceof Uint8Array) || Object.getPrototypeOf(value) !== Uint8Array.prototype) return void 0;
+		for (const name of [
+			"buffer",
+			"byteOffset",
+			"byteLength",
+			"length",
+			"slice",
+			"constructor"
+		]) if (Object.prototype.hasOwnProperty.call(value, name)) return void 0;
+		const constructorDescriptor = Object.getOwnPropertyDescriptor(Uint8Array.prototype, "constructor");
+		if (!constructorDescriptor || !("value" in constructorDescriptor) || constructorDescriptor.value !== originalUint8ArrayConstructor) return void 0;
+		if (!stableInheritedMethod(Uint8Array.prototype, "slice", originalUint8ArraySliceInfo)) return void 0;
+		try {
+			const buffer = value.buffer;
+			if (!(buffer instanceof ArrayBuffer) || Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype) return void 0;
+			if (Object.prototype.hasOwnProperty.call(buffer, "byteLength")) return void 0;
+			if (value.byteLength !== value.length || !allowEmpty && value.byteLength === 0) return void 0;
+			if (value.byteOffset < 0 || value.byteOffset + value.byteLength > buffer.byteLength) return void 0;
+		} catch {
+			return;
+		}
+		return value;
+	}
+	function validIdBlock(block, constructed, registry) {
+		if (Object.getPrototypeOf(block) !== registry.LocalIdentificationBlock.prototype) return false;
+		if (!prototypeMethod(block, registry.LocalIdentificationBlock.prototype, "toBER", registry.originalIdentificationToBER)) return false;
+		const tagClass = dataProperty(block, "tagClass");
+		const tagNumber = dataProperty(block, "tagNumber");
+		const isConstructed = dataProperty(block, "isConstructed");
+		const isHexOnly = dataProperty(block, "isHexOnly");
+		const valueHexView = dataProperty(block, "valueHexView");
+		if (typeof tagClass !== "number" || !Number.isInteger(tagClass) || tagClass < 1 || tagClass > 4) return false;
+		if (typeof tagNumber !== "number" || !Number.isInteger(tagNumber) || tagNumber < 0) return false;
+		if (isConstructed !== constructed || typeof isHexOnly !== "boolean") return false;
+		if (isHexOnly) return !!plainPayload(valueHexView);
+		return Number.isSafeInteger(tagNumber);
+	}
+	function validLengthBlock(block, allowIndefinite, registry) {
+		if (Object.getPrototypeOf(block) !== registry.LocalLengthBlock.prototype) return false;
+		if (!prototypeMethod(block, registry.LocalLengthBlock.prototype, "toBER", registry.originalLengthToBER)) return false;
+		const indefinite = dataProperty(block, "isIndefiniteForm");
+		const longForm = dataProperty(block, "longFormUsed");
+		const lengthDescriptor = Object.getOwnPropertyDescriptor(block, "length");
+		const length = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : void 0;
+		const longFormDescriptor = Object.getOwnPropertyDescriptor(block, "longFormUsed");
+		return typeof indefinite === "boolean" && (indefinite === false || allowIndefinite) && typeof longForm === "boolean" && !!longFormDescriptor && "value" in longFormDescriptor && longFormDescriptor.writable === true && !!lengthDescriptor && "value" in lengthDescriptor && lengthDescriptor.writable === true && typeof length === "number" && Number.isSafeInteger(length) && length >= 0;
+	}
+	function validBaseBlock(block, isConstructed, registry) {
+		const idBlock = dataProperty(block, "idBlock");
+		const lenBlock = dataProperty(block, "lenBlock");
+		return !!idBlock && !!lenBlock && validIdBlock(idBlock, isConstructed, registry) && validLengthBlock(lenBlock, isConstructed, registry);
+	}
+	function constructedChild(block, registry) {
+		const valueBlock = dataProperty(block, "valueBlock");
+		if (!valueBlock || Object.getPrototypeOf(valueBlock) !== registry.LocalConstructedValueBlock.prototype) return void 0;
+		if (!prototypeMethod(valueBlock, registry.LocalConstructedValueBlock.prototype, "toBER", registry.originalConstructedToBER)) return void 0;
+		const values = dataProperty(valueBlock, "value");
+		if (!Array.isArray(values) || Object.getPrototypeOf(values) !== Array.prototype) return void 0;
+		const lengthDescriptor = Object.getOwnPropertyDescriptor(values, "length");
+		if (!lengthDescriptor || !("value" in lengthDescriptor) || lengthDescriptor.value !== 1) return void 0;
+		if (Object.prototype.hasOwnProperty.call(values, Symbol.iterator)) return void 0;
+		const iteratorDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+		if (!iteratorDescriptor || !("value" in iteratorDescriptor) || iteratorDescriptor.value !== originalArrayIterator) return void 0;
+		const indexDescriptor = Object.getOwnPropertyDescriptor(values, "0");
+		if (!indexDescriptor || !("value" in indexDescriptor)) return void 0;
+		if (Object.getOwnPropertyNames(values).length !== 2) return void 0;
+		return indexDescriptor.value;
+	}
+	function bitPayload(block, registry) {
+		const valueBlock = dataProperty(block, "valueBlock");
+		if (!valueBlock || Object.getPrototypeOf(valueBlock) !== registry.LocalBitStringValueBlock.prototype) return void 0;
+		if (!prototypeMethod(valueBlock, registry.LocalBitStringValueBlock.prototype, "toBER", registry.originalBitStringToBER)) return void 0;
+		if (dataProperty(valueBlock, "isConstructed") !== false) return void 0;
+		const unusedBits = dataProperty(valueBlock, "unusedBits");
+		if (typeof unusedBits !== "number" || !Number.isInteger(unusedBits) || unusedBits < 0 || unusedBits > 7) return void 0;
+		const payload = plainPayload(dataProperty(valueBlock, "valueHexView"), true);
+		if (!payload) return void 0;
+		return {
+			payload,
+			prefix: Uint8Array.of(payload.byteLength ? unusedBits : 0)
+		};
+	}
+	function primitivePayload(block, kind, registry) {
+		const valueBlock = dataProperty(block, "valueBlock");
+		if (!valueBlock) return void 0;
+		if (kind === "integer") {
+			if (Object.getPrototypeOf(valueBlock) !== registry.LocalIntegerValueBlock.prototype) return void 0;
+			if (!prototypeMethod(valueBlock, registry.LocalIntegerValueBlock.prototype, "toBER", registry.originalIntegerToBER)) return void 0;
+		} else if (kind === "octet") {
+			if (Object.getPrototypeOf(valueBlock) !== registry.LocalOctetStringValueBlock.prototype) return void 0;
+			if (!prototypeMethod(valueBlock, registry.LocalOctetStringValueBlock.prototype, "toBER", registry.originalOctetStringToBER)) return void 0;
+			if (dataProperty(valueBlock, "isConstructed") !== false) return void 0;
+		} else {
+			if (Object.getPrototypeOf(valueBlock) !== registry.LocalPrimitiveValueBlock.prototype) return void 0;
+			if (!inheritedMethod(valueBlock, "toBER", registry.originalPrimitiveToBER, registry.LocalPrimitiveValueBlock)) return void 0;
+		}
+		if (kind === "primitive" && dataProperty(valueBlock, "isHexOnly") !== true) return void 0;
+		if (typeof dataProperty(valueBlock, "isHexOnly") !== "boolean") return void 0;
+		return plainPayload(dataProperty(valueBlock, "valueHexView"));
+	}
+	function validOuterMethod(block, registry) {
+		if (Object.prototype.hasOwnProperty.call(block, "toBER")) return false;
+		let prototype = block;
+		while (prototype) {
+			const descriptor = Object.getOwnPropertyDescriptor(prototype, "toBER");
+			if (descriptor) return "value" in descriptor && descriptor.value === registry.originalBaseBlockToBER;
+			prototype = Object.getPrototypeOf(prototype);
+		}
+		return false;
+	}
+	function isPrimitive(block, type, registry) {
+		const constructor = registry[type];
+		return !!constructor && Object.getPrototypeOf(block) === constructor.prototype;
+	}
+	function isConstructed(block, registry) {
+		return Object.getPrototypeOf(block) === registry.Sequence.prototype || Object.getPrototypeOf(block) === registry.Set.prototype || Object.getPrototypeOf(block) === registry.Constructed.prototype;
+	}
+	function inspectNode(block, depth, registry) {
+		if (depth > BUILTIN_DISPATCH_MAX_DEPTH || !block || typeof block !== "object") return void 0;
+		try {
+			if (!validOuterMethod(block, registry)) return void 0;
+			const primitiveKind = isPrimitive(block, "BitString", registry) ? "bit" : isPrimitive(block, "Integer", registry) ? "integer" : isPrimitive(block, "OctetString", registry) ? "octet" : isPrimitive(block, "Primitive", registry) ? "primitive" : void 0;
+			const constructed = primitiveKind === void 0 && isConstructed(block, registry);
+			if (!primitiveKind && !constructed) return void 0;
+			if (!validBaseBlock(block, constructed, registry)) return void 0;
+			const idBlock = dataProperty(block, "idBlock");
+			const lenBlock = dataProperty(block, "lenBlock");
+			if (!idBlock || !lenBlock) return void 0;
+			if (primitiveKind) {
+				const bit = primitiveKind === "bit" ? bitPayload(block, registry) : void 0;
+				const payload = primitiveKind === "bit" ? bit === null || bit === void 0 ? void 0 : bit.payload : primitivePayload(block, primitiveKind, registry);
+				return payload ? {
+					block,
+					kind: primitiveKind,
+					idBlock,
+					lenBlock,
+					indefinite: false,
+					payload,
+					prefix: bit === null || bit === void 0 ? void 0 : bit.prefix
+				} : void 0;
+			}
+			const child = constructedChild(block, registry);
+			const validatedChild = child && inspectNode(child, depth + 1, registry);
+			const indefinite = dataProperty(lenBlock, "isIndefiniteForm");
+			return validatedChild ? {
+				block,
+				kind: "constructed",
+				idBlock,
+				lenBlock,
+				indefinite: indefinite === true,
+				child: validatedChild
+			} : void 0;
+		} catch {
+			return;
+		}
+	}
+	function buildNode(node, sizeOnly, registry) {
+		var _a, _b;
+		const id = Reflect.apply(registry.originalIdentificationToBER, node.idBlock, [sizeOnly]);
+		if (!(id instanceof ArrayBuffer) || id.byteLength === 0) throw TypeError("Built-in identifier encoding failed");
+		let payload;
+		if (node.kind === "constructed") payload = buildNode(node.child, sizeOnly, registry);
+		else payload = node.payload;
+		const length = (payload instanceof Uint8Array ? payload.byteLength : payload.total) + ((_b = (_a = node.prefix) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0);
+		let len;
+		if (node.indefinite) len = Uint8Array.of(128).buffer;
+		else {
+			node.lenBlock.length = length;
+			len = Reflect.apply(registry.originalLengthToBER, node.lenBlock, [sizeOnly]);
+			if (!(len instanceof ArrayBuffer) || len.byteLength === 0) throw TypeError("Built-in length encoding failed");
+		}
+		const total = id.byteLength + len.byteLength + length + (node.indefinite ? 2 : 0);
+		if (!Number.isSafeInteger(total)) throw RangeError("Built-in encoding is too large");
+		return {
+			id,
+			len,
+			payload,
+			length,
+			total,
+			indefinite: node.indefinite,
+			prefix: node.prefix
+		};
+	}
+	function flatten(node, output, offset, sizeOnly) {
+		output.set(new Uint8Array(node.id), offset);
+		offset += node.id.byteLength;
+		output.set(new Uint8Array(node.len), offset);
+		offset += node.len.byteLength;
+		if (node.prefix) {
+			if (!sizeOnly) output.set(node.prefix, offset);
+			offset += node.prefix.byteLength;
+		}
+		if (node.payload instanceof Uint8Array) {
+			if (!sizeOnly) output.set(node.payload, offset);
+			offset += node.payload.byteLength;
+		} else offset = flatten(node.payload, output, offset, sizeOnly);
+		if (node.indefinite) offset += 2;
+		return offset;
+	}
+	function tryEncodeBuiltin(block, sizeOnly = false) {
+		const registry = builtinRegistry;
+		if (!registry || !writerMethodsStable(registry)) return void 0;
+		const validated = inspectNode(block, 0, registry);
+		if (!validated) return void 0;
+		const node = buildNode(validated, sizeOnly, registry);
+		const output = new Uint8Array(node.total);
+		flatten(node, output, 0, sizeOnly);
+		return output.buffer;
+	}
 	var BaseBlock = class extends LocalBaseBlock {
 		constructor({ name = EMPTY_STRING, optional = false, primitiveSchema, ...parameters } = {}, valueBlockType) {
 			super(parameters);
@@ -2581,7 +2911,15 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 		toBER(sizeOnly, writer) {
 			const _writer = writer || new ViewWriter();
-			if (!writer) prepareIndefiniteForm(this);
+			if (!writer) {
+				prepareIndefiniteForm(this);
+				if (sizeOnly === true || sizeOnly === false || sizeOnly === void 0) {
+					if (shouldUseBuiltinEncoder(this)) {
+						const encoded = tryEncodeBuiltin(this, sizeOnly === true);
+						if (encoded) return encoded;
+					}
+				}
+			}
 			const idBlockBuf = this.idBlock.toBER(sizeOnly);
 			_writer.write(idBlockBuf);
 			if (this.lenBlock.isIndefiniteForm) {
@@ -2626,6 +2964,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	BaseBlock.NAME = "BaseBlock";
+	const ORIGINAL_BASE_BLOCK_TO_BER = BaseBlock.prototype.toBER;
 	function prepareIndefiniteForm(baseBlock) {
 		var _a;
 		if (baseBlock instanceof typeStore.Constructed) {
@@ -2661,6 +3000,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	BaseStringBlock.NAME = "BaseStringBlock";
+	var _a$x;
 	var LocalPrimitiveValueBlock = class extends HexBlock(ValueBlock) {
 		constructor({ isHexOnly = true, ...parameters } = {}) {
 			super(parameters);
@@ -2668,6 +3008,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	LocalPrimitiveValueBlock.NAME = "PrimitiveValueBlock";
+	const ORIGINAL_LOCAL_PRIMITIVE_TO_BER = (_a$x = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(LocalPrimitiveValueBlock.prototype), "toBER")) === null || _a$x === void 0 ? void 0 : _a$x.value;
 	var _a$w;
 	var Primitive = class extends BaseBlock {
 		constructor(parameters = {}) {
@@ -2680,6 +3021,70 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		typeStore.Primitive = _a$w;
 	})();
 	Primitive.NAME = "PRIMITIVE";
+	let fastParserRegistry;
+	function registerFastParser(constructors) {
+		fastParserRegistry = {
+			Integer: constructors.Integer,
+			Null: constructors.Null,
+			Sequence: constructors.Sequence
+		};
+	}
+	function fastParserContext(context) {
+		const nodes = Object.getOwnPropertyDescriptor(context, "nodesCount");
+		const maxNodes = Object.getOwnPropertyDescriptor(context, "maxNodes");
+		const maxContentLength = Object.getOwnPropertyDescriptor(context, "maxContentLength");
+		if (!nodes || !("value" in nodes) || nodes.writable !== true) return false;
+		if (!maxNodes || !("value" in maxNodes) || !maxContentLength || !("value" in maxContentLength)) return false;
+		return typeof nodes.value === "number" && Number.isSafeInteger(nodes.value) && nodes.value >= 0 && typeof maxNodes.value === "number" && Number.isSafeInteger(maxNodes.value) && maxNodes.value >= 0 && typeof maxContentLength.value === "number" && Number.isSafeInteger(maxContentLength.value) && maxContentLength.value >= 0 && nodes.value < maxNodes.value;
+	}
+	function fastParserType(store, name, value) {
+		const descriptor = Object.getOwnPropertyDescriptor(store, name);
+		return !!descriptor && "value" in descriptor && descriptor.value === value;
+	}
+	function tryFastFromBER(inputBuffer, inputOffset, inputLength, context) {
+		const registry = fastParserRegistry;
+		if (!registry) return void 0;
+		let Constructor;
+		let length = 0;
+		try {
+			if (Object.getPrototypeOf(inputBuffer) !== Uint8Array.prototype) return void 0;
+			if (!Number.isSafeInteger(inputOffset) || inputOffset < 0 || !Number.isSafeInteger(inputLength) || inputLength < 2) return;
+			if (inputOffset > inputBuffer.byteLength || inputLength > inputBuffer.byteLength - inputOffset) return void 0;
+			const tag = inputBuffer[inputOffset];
+			if (tag !== 2 && tag !== 5 && tag !== 48) return void 0;
+			length = inputBuffer[inputOffset + 1];
+			if (length >= 128 || length > inputLength - 2) return void 0;
+			if (tag === 5 && length !== 0) return void 0;
+			if (!fastParserContext(context)) return void 0;
+			if (length > Object.getOwnPropertyDescriptor(context, "maxContentLength").value) return;
+			const constructorName = tag === 2 ? "Integer" : tag === 5 ? "Null" : "Sequence";
+			Constructor = registry[constructorName];
+			if (!fastParserType(typeStore, constructorName, Constructor)) return void 0;
+			const identificationFromBER = Object.getOwnPropertyDescriptor(LocalIdentificationBlock.prototype, "fromBER");
+			const lengthFromBER = Object.getOwnPropertyDescriptor(LocalLengthBlock.prototype, "fromBER");
+			if (!identificationFromBER || !("value" in identificationFromBER) || identificationFromBER.value !== ORIGINAL_LOCAL_IDENTIFICATION_FROM_BER || !lengthFromBER || !("value" in lengthFromBER) || lengthFromBER.value !== ORIGINAL_LOCAL_LENGTH_FROM_BER) return void 0;
+		} catch {
+			return;
+		}
+		if (!Constructor) return void 0;
+		const result = new Constructor();
+		result.idBlock.tagClass = 1;
+		result.idBlock.tagNumber = inputBuffer[inputOffset] & 31;
+		result.idBlock.isConstructed = inputBuffer[inputOffset] === 48;
+		result.idBlock.isHexOnly = false;
+		result.idBlock.blockLength = 1;
+		result.lenBlock.isIndefiniteForm = false;
+		result.lenBlock.longFormUsed = false;
+		result.lenBlock.length = length;
+		result.lenBlock.blockLength = 1;
+		context.nodesCount += 1;
+		const resultOffset = result.fromBER(inputBuffer, inputOffset + 2, length, context);
+		result.valueBeforeDecodeView = inputBuffer.subarray(inputOffset, inputOffset + result.blockLength);
+		return {
+			offset: resultOffset,
+			result
+		};
+	}
 	const DEFAULT_MAX_DEPTH = 100;
 	const DEFAULT_MAX_NODES = 1e4;
 	const DEFAULT_MAX_CONTENT_LENGTH = 16777216;
@@ -2687,13 +3092,14 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const MAX_NODES_EXCEEDED_ERROR = "Maximum ASN.1 node count exceeded";
 	const MAX_CONTENT_LENGTH_EXCEEDED_ERROR = "Maximum ASN.1 content length exceeded";
 	function createFromBerContext(options = {}) {
-		var _a, _b, _c;
+		var _a, _b, _c, _d;
 		return {
 			depth: 0,
 			maxDepth: (_a = options.maxDepth) !== null && _a !== void 0 ? _a : DEFAULT_MAX_DEPTH,
 			nodesCount: 0,
 			maxNodes: (_b = options.maxNodes) !== null && _b !== void 0 ? _b : DEFAULT_MAX_NODES,
-			maxContentLength: (_c = options.maxContentLength) !== null && _c !== void 0 ? _c : DEFAULT_MAX_CONTENT_LENGTH
+			maxContentLength: (_c = options.maxContentLength) !== null && _c !== void 0 ? _c : DEFAULT_MAX_CONTENT_LENGTH,
+			parseEmbedded: (_d = options.parseEmbedded) !== null && _d !== void 0 ? _d : true
 		};
 	}
 	function createErrorResult(error) {
@@ -2731,17 +3137,15 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		return newObject;
 	}
 	function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.length, context = createFromBerContext()) {
+		const fastResult = tryFastFromBER(inputBuffer, inputOffset, inputLength, context);
+		if (fastResult) return fastResult;
 		const incomingOffset = inputOffset;
 		let returnObject = new BaseBlock({}, ValueBlock);
-		const baseBlock = new LocalBaseBlock();
-		if (!checkBufferParams(baseBlock, inputBuffer, inputOffset, inputLength)) {
-			returnObject.error = baseBlock.error;
-			return {
-				offset: -1,
-				result: returnObject
-			};
-		}
-		if (!inputBuffer.subarray(inputOffset, inputOffset + inputLength).length) {
+		if (!checkBufferParams(returnObject, inputBuffer, inputOffset, inputLength)) return {
+			offset: -1,
+			result: returnObject
+		};
+		if (Number.isInteger(inputOffset) && Number.isInteger(inputLength) ? inputLength === 0 : inputBuffer.subarray(inputOffset, inputOffset + inputLength).length === 0) {
 			returnObject.error = "Zero buffer length";
 			return {
 				offset: -1,
@@ -2936,7 +3340,8 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 				result
 			};
 		}
-		return localFromBER(pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength, createFromBerContext(options));
+		const inputView = pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer);
+		return localFromBER(options.copyInput === false ? inputView : inputView.slice(), 0, inputBuffer.byteLength, createFromBerContext(options));
 	}
 	function checkLen(indefiniteLength, length) {
 		if (indefiniteLength) return 1;
@@ -2994,6 +3399,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	LocalConstructedValueBlock.NAME = "ConstructedValueBlock";
+	const ORIGINAL_LOCAL_CONSTRUCTED_TO_BER = LocalConstructedValueBlock.prototype.toBER;
 	var _a$v;
 	var Constructed = class extends BaseBlock {
 		constructor(parameters = {}) {
@@ -3108,7 +3514,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 			return inputOffset + inputLength;
 		}
 		toBER() {
-			return this.valueHexView.slice();
+			return this.valueHexView.slice().buffer;
 		}
 		toJSON() {
 			return {
@@ -3184,6 +3590,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	LocalOctetStringValueBlock.NAME = "OctetStringValueBlock";
+	const ORIGINAL_LOCAL_OCTET_STRING_TO_BER = LocalOctetStringValueBlock.prototype.toBER;
 	var _a$r;
 	var OctetString = class extends BaseBlock {
 		constructor({ idBlock = {}, lenBlock = {}, ...parameters } = {}) {
@@ -3211,7 +3618,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 				if (this.lenBlock.error.length === 0) this.blockLength += this.lenBlock.blockLength;
 				return inputOffset;
 			}
-			if (!this.valueBlock.isConstructed) {
+			if (!this.valueBlock.isConstructed && (context === null || context === void 0 ? void 0 : context.parseEmbedded) !== false) {
 				const buf = (inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer).subarray(inputOffset, inputOffset + inputLength);
 				try {
 					if (buf.byteLength) {
@@ -3282,7 +3689,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 				this.error = "Unused bits for BitString must be in range 0-7";
 				return -1;
 			}
-			if (!this.unusedBits) {
+			if (!this.unusedBits && (context === null || context === void 0 ? void 0 : context.parseEmbedded) !== false) {
 				const buf = intBuffer.subarray(1);
 				try {
 					if (buf.byteLength) {
@@ -3318,6 +3725,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	LocalBitStringValueBlock.NAME = "BitStringValueBlock";
+	const ORIGINAL_LOCAL_BIT_STRING_TO_BER = LocalBitStringValueBlock.prototype.toBER;
 	var _a$q;
 	var BitString = class extends BaseBlock {
 		constructor({ idBlock = {}, lenBlock = {}, ...parameters } = {}) {
@@ -3358,85 +3766,45 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		typeStore.BitString = _a$q;
 	})();
 	BitString.NAME = BIT_STRING_NAME;
-	var _a$p;
-	function viewAdd(first, second) {
-		const c = new Uint8Array([0]);
-		const firstView = new Uint8Array(first);
-		const secondView = new Uint8Array(second);
-		let firstViewCopy = firstView.slice(0);
-		const firstViewCopyLength = firstViewCopy.length - 1;
-		const secondViewCopy = secondView.slice(0);
-		const secondViewCopyLength = secondViewCopy.length - 1;
-		let value = 0;
-		const max = secondViewCopyLength < firstViewCopyLength ? firstViewCopyLength : secondViewCopyLength;
-		let counter = 0;
-		for (let i = max; i >= 0; i--, counter++) {
-			switch (true) {
-				case counter < secondViewCopy.length:
-					value = firstViewCopy[firstViewCopyLength - counter] + secondViewCopy[secondViewCopyLength - counter] + c[0];
-					break;
-				default: value = firstViewCopy[firstViewCopyLength - counter] + c[0];
-			}
-			c[0] = value / 10;
-			switch (true) {
-				case counter >= firstViewCopy.length:
-					firstViewCopy = pvutils__namespace.utilConcatView(new Uint8Array([value % 10]), firstViewCopy);
-					break;
-				default: firstViewCopy[firstViewCopyLength - counter] = value % 10;
-			}
-		}
-		if (c[0] > 0) firstViewCopy = pvutils__namespace.utilConcatView(c, firstViewCopy);
-		return firstViewCopy;
-	}
-	function power2(n) {
-		if (n >= powers2.length) for (let p = powers2.length; p <= n; p++) {
-			const c = new Uint8Array([0]);
-			let digits = powers2[p - 1].slice(0);
-			for (let i = digits.length - 1; i >= 0; i--) {
-				const newValue = new Uint8Array([(digits[i] << 1) + c[0]]);
-				c[0] = newValue[0] / 10;
-				digits[i] = newValue[0] % 10;
-			}
-			if (c[0] > 0) digits = pvutils__namespace.utilConcatView(c, digits);
-			powers2.push(digits);
-		}
-		return powers2[n];
-	}
-	function viewSub(first, second) {
-		let b = 0;
-		const firstView = new Uint8Array(first);
-		const secondView = new Uint8Array(second);
-		const firstViewCopy = firstView.slice(0);
-		const firstViewCopyLength = firstViewCopy.length - 1;
-		const secondViewCopy = secondView.slice(0);
-		const secondViewCopyLength = secondViewCopy.length - 1;
-		let value;
-		let counter = 0;
-		for (let i = secondViewCopyLength; i >= 0; i--, counter++) {
-			value = firstViewCopy[firstViewCopyLength - counter] - secondViewCopy[secondViewCopyLength - counter] - b;
-			switch (true) {
-				case value < 0:
-					b = 1;
-					firstViewCopy[firstViewCopyLength - counter] = value + 10;
-					break;
-				default:
-					b = 0;
-					firstViewCopy[firstViewCopyLength - counter] = value;
-			}
-		}
-		if (b > 0) for (let i = firstViewCopyLength - secondViewCopyLength + 1; i >= 0; i--, counter++) {
-			value = firstViewCopy[firstViewCopyLength - counter] - b;
-			if (value < 0) {
-				b = 1;
-				firstViewCopy[firstViewCopyLength - counter] = value + 10;
-			} else {
-				b = 0;
-				firstViewCopy[firstViewCopyLength - counter] = value;
-				break;
-			}
-		}
-		return firstViewCopy.slice();
+	function bytesToSignedBigInt(view) {
+		if (!view.byteLength) return BigInt(0);
+		const value = BigInt(`0x${pvtsutils__namespace.Convert.ToHex(view)}`);
+		if (view[0] & 128) return value - (BigInt(1) << BigInt(view.byteLength * 8));
+		return value;
+	}
+	function bytesToSignedDecimal(view) {
+		if (typeof BigInt !== "undefined") return bytesToSignedBigInt(view).toString(10);
+		const BASE = 1e7;
+		const DECIMAL_DIGITS = 7;
+		if (!view.byteLength) return "0";
+		const negative = !!(view[0] & 128);
+		let magnitude = view;
+		if (negative) {
+			magnitude = new Uint8Array(view.length);
+			let carry = 1;
+			for (let i = view.length - 1; i >= 0; i--) {
+				const value = (view[i] ^ 255) + carry;
+				magnitude[i] = value & 255;
+				carry = value >> 8;
+			}
+		}
+		const limbs = [0];
+		for (let index = 0; index < magnitude.length; index++) {
+			let carry = magnitude[index];
+			for (let i = 0; i < limbs.length; i++) {
+				const value = limbs[i] * 256 + carry;
+				limbs[i] = value % BASE;
+				carry = Math.floor(value / BASE);
+			}
+			if (carry) limbs.push(carry);
+		}
+		let top = limbs.length - 1;
+		while (top > 0 && limbs[top] === 0) top--;
+		let result = String(limbs[top]);
+		for (let i = top - 1; i >= 0; i--) result += String(limbs[i]).padStart(DECIMAL_DIGITS, "0");
+		return negative && result !== "0" ? `-${result}` : result;
 	}
+	var _a$p;
 	var LocalIntegerValueBlock = class extends HexBlock(ValueBlock) {
 		setValueHex() {
 			if (this.valueHexView.length >= 4) {
@@ -3506,33 +3874,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 			};
 		}
 		toString() {
-			const firstBit = this.valueHexView.length * 8 - 1;
-			let digits = new Uint8Array(this.valueHexView.length * 8 / 3);
-			let bitNumber = 0;
-			let currentByte;
-			const asn1View = this.valueHexView;
-			let result = "";
-			let flag = false;
-			for (let byteNumber = asn1View.byteLength - 1; byteNumber >= 0; byteNumber--) {
-				currentByte = asn1View[byteNumber];
-				for (let i = 0; i < 8; i++) {
-					if ((currentByte & 1) === 1) switch (bitNumber) {
-						case firstBit:
-							digits = viewSub(power2(bitNumber), digits);
-							result = "-";
-							break;
-						default: digits = viewAdd(digits, power2(bitNumber));
-					}
-					bitNumber++;
-					currentByte >>= 1;
-				}
-			}
-			for (let i = 0; i < digits.length; i++) {
-				if (digits[i]) flag = true;
-				if (flag) result += digitsString.charAt(digits[i]);
-			}
-			if (flag === false) result += digitsString.charAt(0);
-			return result;
+			return bytesToSignedDecimal(this.valueHexView);
 		}
 	};
 	_a$p = LocalIntegerValueBlock;
@@ -3548,6 +3890,8 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 			}
 		});
 	})();
+	const ORIGINAL_LOCAL_INTEGER_TO_BER = LocalIntegerValueBlock.prototype.toBER;
+	const ORIGINAL_LOCAL_INTEGER_TO_STRING = LocalIntegerValueBlock.prototype.toString;
 	var _a$o;
 	var Integer = class extends BaseBlock {
 		constructor(parameters = {}) {
@@ -3557,7 +3901,10 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 		toBigInt() {
 			assertBigInt();
-			return BigInt(this.valueBlock.toString());
+			const valueBlock = this.valueBlock;
+			const toString = valueBlock.toString;
+			if (toString === ORIGINAL_LOCAL_INTEGER_TO_STRING) return bytesToSignedBigInt(valueBlock.valueHexView);
+			return BigInt(Reflect.apply(toString, valueBlock, []));
 		}
 		static fromBigInt(value) {
 			assertBigInt();
@@ -3619,15 +3966,27 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 			const inputView = pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer);
 			if (!checkBufferParams(this, inputView, inputOffset, inputLength)) return -1;
 			const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
-			this.valueHexView = new Uint8Array(inputLength);
-			for (let i = 0; i < inputLength; i++) {
-				this.valueHexView[i] = intBuffer[i] & 127;
-				this.blockLength++;
-				if ((intBuffer[i] & 128) === 0) break;
-			}
-			const tempView = new Uint8Array(this.blockLength);
-			for (let i = 0; i < this.blockLength; i++) tempView[i] = this.valueHexView[i];
-			this.valueHexView = tempView;
+			if (this.blockLength === 0 && Number.isInteger(inputOffset) && Number.isInteger(inputLength)) {
+				let sidLength = 0;
+				while (sidLength < inputLength) {
+					const octet = intBuffer[sidLength];
+					sidLength++;
+					if ((octet & 128) === 0) break;
+				}
+				this.blockLength = sidLength;
+				this.valueHexView = new Uint8Array(sidLength);
+				for (let i = 0; i < sidLength; i++) this.valueHexView[i] = intBuffer[i] & 127;
+			} else {
+				this.valueHexView = new Uint8Array(inputLength);
+				for (let i = 0; i < inputLength; i++) {
+					this.valueHexView[i] = intBuffer[i] & 127;
+					this.blockLength++;
+					if ((intBuffer[i] & 128) === 0) break;
+				}
+				const tempView = new Uint8Array(this.blockLength);
+				for (let i = 0; i < this.blockLength; i++) tempView[i] = this.valueHexView[i];
+				this.valueHexView = tempView;
+			}
 			if ((intBuffer[this.blockLength - 1] & 128) !== 0) {
 				this.error = "End of input reached before message was fully decoded";
 				return -1;
@@ -3655,7 +4014,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 				const retView = new Uint8Array(this.blockLength);
 				for (let i = 0; i < this.blockLength - 1; i++) retView[i] = curView[i] | 128;
 				retView[this.blockLength - 1] = curView[this.blockLength - 1];
-				return retView.buffer;
+				return pvtsutils__namespace.BufferSourceConverter.toArrayBuffer(retView);
 			}
 			const encodedBuf = pvutils__namespace.utilToBase(this.valueDec, 7);
 			if (encodedBuf.byteLength === 0) {
@@ -3669,7 +4028,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 				for (let i = 0; i < len; i++) retView[i] = encodedView[i] | 128;
 				retView[len] = encodedView[len];
 			}
-			return retView;
+			return pvtsutils__namespace.BufferSourceConverter.toArrayBuffer(retView);
 		}
 		toString() {
 			let result = "";
@@ -3843,15 +4202,27 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 			const inputView = pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer);
 			if (!checkBufferParams(this, inputView, inputOffset, inputLength)) return -1;
 			const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
-			this.valueHexView = new Uint8Array(inputLength);
-			for (let i = 0; i < inputLength; i++) {
-				this.valueHexView[i] = intBuffer[i] & 127;
-				this.blockLength++;
-				if ((intBuffer[i] & 128) === 0) break;
-			}
-			const tempView = new Uint8Array(this.blockLength);
-			for (let i = 0; i < this.blockLength; i++) tempView[i] = this.valueHexView[i];
-			this.valueHexView = tempView;
+			if (this.blockLength === 0 && Number.isInteger(inputOffset) && Number.isInteger(inputLength)) {
+				let sidLength = 0;
+				while (sidLength < inputLength) {
+					const octet = intBuffer[sidLength];
+					sidLength++;
+					if ((octet & 128) === 0) break;
+				}
+				this.blockLength = sidLength;
+				this.valueHexView = new Uint8Array(sidLength);
+				for (let i = 0; i < sidLength; i++) this.valueHexView[i] = intBuffer[i] & 127;
+			} else {
+				this.valueHexView = new Uint8Array(inputLength);
+				for (let i = 0; i < inputLength; i++) {
+					this.valueHexView[i] = intBuffer[i] & 127;
+					this.blockLength++;
+					if ((intBuffer[i] & 128) === 0) break;
+				}
+				const tempView = new Uint8Array(this.blockLength);
+				for (let i = 0; i < this.blockLength; i++) tempView[i] = this.valueHexView[i];
+				this.valueHexView = tempView;
+			}
 			if ((intBuffer[this.blockLength - 1] & 128) !== 0) {
 				this.error = "End of input reached before message was fully decoded";
 				return -1;
@@ -4331,7 +4702,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 		toString(encoding = "iso") {
 			if (encoding === "iso") {
-				const outputArray = new Array(7);
+				const outputArray = Array.from({ length: 7 });
 				outputArray[0] = pvutils__namespace.padNumber(this.year < 2e3 ? this.year - 1900 : this.year - 2e3, 2);
 				outputArray[1] = pvutils__namespace.padNumber(this.month, 2);
 				outputArray[2] = pvutils__namespace.padNumber(this.day, 2);
@@ -4508,7 +4879,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 				outputArray.push(pvutils__namespace.padNumber(this.second, 2));
 				if (this.millisecond !== 0) {
 					outputArray.push(".");
-					outputArray.push(pvutils__namespace.padNumber(this.millisecond, 3));
+					outputArray.push(pvutils__namespace.padNumber(this.millisecond, 3).replace(/0+$/, ""));
 				}
 				outputArray.push("Z");
 				return outputArray.join("");
@@ -4870,6 +5241,40 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 		};
 		return compareSchema(asn1.result, asn1.result, inputSchema);
 	}
+	registerBuiltinEncoder({
+		BitString,
+		Integer,
+		OctetString,
+		Primitive,
+		Constructed,
+		Sequence,
+		Set
+	}, {
+		BaseBlock,
+		ViewWriter,
+		LocalIdentificationBlock,
+		LocalLengthBlock,
+		LocalIntegerValueBlock,
+		LocalOctetStringValueBlock,
+		LocalConstructedValueBlock,
+		LocalBitStringValueBlock,
+		LocalPrimitiveValueBlock,
+		originalBaseBlockToBER: ORIGINAL_BASE_BLOCK_TO_BER,
+		originalWriterWrite: ORIGINAL_VIEW_WRITER_WRITE,
+		originalWriterFinal: ORIGINAL_VIEW_WRITER_FINAL,
+		originalIdentificationToBER: ORIGINAL_LOCAL_IDENTIFICATION_TO_BER,
+		originalLengthToBER: ORIGINAL_LOCAL_LENGTH_TO_BER,
+		originalIntegerToBER: ORIGINAL_LOCAL_INTEGER_TO_BER,
+		originalOctetStringToBER: ORIGINAL_LOCAL_OCTET_STRING_TO_BER,
+		originalBitStringToBER: ORIGINAL_LOCAL_BIT_STRING_TO_BER,
+		originalConstructedToBER: ORIGINAL_LOCAL_CONSTRUCTED_TO_BER,
+		originalPrimitiveToBER: ORIGINAL_LOCAL_PRIMITIVE_TO_BER
+	});
+	registerFastParser({
+		Integer,
+		Null,
+		Sequence
+	});
 	exports.Any = Any;
 	exports.BaseBlock = BaseBlock;
 	exports.BaseStringBlock = BaseStringBlock;
@@ -14751,7 +15156,7 @@ var require_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 	tslib_1.__exportStar(require_certification_request_info(), exports);
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/@peculiar+x509@2.1.0/node_modules/@peculiar/x509/build/x509.cjs.js
+//#region ../../node_modules/.pnpm/@peculiar+x509@2.2.0/node_modules/@peculiar/x509/build/x509.cjs.js
 /*!
 * MIT License
 * 
@@ -15219,36 +15624,6 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 	};
 	_AsnData_rawData = /* @__PURE__ */ new WeakMap(), _AsnData_options = /* @__PURE__ */ new WeakMap();
 	AsnData.NAME = "ASN";
-	var Extension = class Extension extends AsnData {
-		constructor(...args) {
-			let raw;
-			let options;
-			if (pvtsutils.BufferSourceConverter.isBufferSource(args[0])) {
-				raw = pvtsutils.BufferSourceConverter.toArrayBuffer(args[0]);
-				options = args[1];
-			} else raw = asn1Schema.AsnConvert.serialize(new asn1X509.Extension({
-				extnID: args[0],
-				critical: args[1],
-				extnValue: new asn1Schema.OctetString(pvtsutils.BufferSourceConverter.toArrayBuffer(args[2]))
-			}));
-			super(raw, asn1X509.Extension, options);
-		}
-		onInit(asn) {
-			this.type = asn.extnID;
-			this.critical = asn.critical;
-			this.value = asn.extnValue.buffer;
-		}
-		toTextObject() {
-			const obj = this.toTextObjectWithoutValue();
-			obj[""] = this.value;
-			return obj;
-		}
-		toTextObjectWithoutValue() {
-			const obj = this.toTextObjectEmpty(this.critical ? "critical" : void 0);
-			if (obj[TextObject.NAME] === Extension.NAME) obj[TextObject.NAME] = OidSerializer.toString(this.type);
-			return obj;
-		}
-	};
 	var _a;
 	var CryptoProvider = class CryptoProvider {
 		static isCryptoKeyPair(data) {
@@ -15306,6 +15681,69 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 	_a = Symbol.toStringTag;
 	CryptoProvider.DEFAULT = "default";
 	const cryptoProvider = new CryptoProvider();
+	const selfProducedParseOptions = { berOptions: {
+		maxDepth: Infinity,
+		maxNodes: Infinity,
+		maxContentLength: Infinity
+	} };
+	function toPositiveIntegerOctets(input) {
+		let firstNonZero = 0;
+		while (firstNonZero < input.length - 1 && input[firstNonZero] === 0) firstNonZero++;
+		let serialNumber = input.slice(firstNonZero);
+		if (!serialNumber.length) serialNumber = new Uint8Array([0]);
+		if (serialNumber[0] > 127) {
+			const newSerialNumber = new Uint8Array(serialNumber.length + 1);
+			newSerialNumber[0] = 0;
+			newSerialNumber.set(serialNumber, 1);
+			serialNumber = newSerialNumber;
+		}
+		return serialNumber.buffer;
+	}
+	function normalizeCertificateSerialNumber(input) {
+		return toPositiveIntegerOctets(pvtsutils.BufferSourceConverter.toUint8Array(pvtsutils.Convert.FromHex(input || "")));
+	}
+	function generateCertificateSerialNumber(input, crypto = cryptoProvider.get()) {
+		const inputView = pvtsutils.BufferSourceConverter.toUint8Array(pvtsutils.Convert.FromHex(input || ""));
+		return toPositiveIntegerOctets(inputView.length && inputView.some((o) => o > 0) ? inputView : crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)));
+	}
+	function getCertificateSerialNumber(raw) {
+		let serialNumber = pvtsutils.BufferSourceConverter.toUint8Array(raw);
+		if (serialNumber.length > 1 && serialNumber[0] === 0 && serialNumber[1] > 127) serialNumber = serialNumber.slice(1);
+		return pvtsutils.Convert.ToHex(serialNumber);
+	}
+	var Extension = class Extension extends AsnData {
+		constructor(...args) {
+			let raw;
+			let options;
+			if (pvtsutils.BufferSourceConverter.isBufferSource(args[0])) {
+				raw = pvtsutils.BufferSourceConverter.toArrayBuffer(args[0]);
+				options = args[1];
+			} else {
+				raw = asn1Schema.AsnConvert.serialize(new asn1X509.Extension({
+					extnID: args[0],
+					critical: args[1],
+					extnValue: new asn1Schema.OctetString(pvtsutils.BufferSourceConverter.toArrayBuffer(args[2]))
+				}));
+				options = selfProducedParseOptions;
+			}
+			super(raw, asn1X509.Extension, options);
+		}
+		onInit(asn) {
+			this.type = asn.extnID;
+			this.critical = asn.critical;
+			this.value = asn.extnValue.buffer;
+		}
+		toTextObject() {
+			const obj = this.toTextObjectWithoutValue();
+			obj[""] = this.value;
+			return obj;
+		}
+		toTextObjectWithoutValue() {
+			const obj = this.toTextObjectEmpty(this.critical ? "critical" : void 0);
+			if (obj[TextObject.NAME] === Extension.NAME) obj[TextObject.NAME] = OidSerializer.toString(this.type);
+			return obj;
+		}
+	};
 	const OID_REGEX = /^[0-2](?:\.[1-9][0-9]*)+$/;
 	function isOID(id) {
 		return new RegExp(OID_REGEX).test(id);
@@ -15500,53 +15938,62 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const REGISTERED_ID = "id";
 	var GeneralName = class extends AsnData {
 		constructor(...args) {
+			var _a;
 			let name;
-			if (args.length === 2) switch (args[0]) {
-				case DN: {
-					const derName = new Name(args[1]).toArrayBuffer();
-					const asnName = asn1Schema.AsnConvert.parse(derName, asn1X509__namespace.Name);
-					name = new asn1X509__namespace.GeneralName({ directoryName: asnName });
-					break;
-				}
-				case DNS:
-					name = new asn1X509__namespace.GeneralName({ dNSName: args[1] });
-					break;
-				case EMAIL:
-					name = new asn1X509__namespace.GeneralName({ rfc822Name: args[1] });
-					break;
-				case GUID: {
-					const matches = new RegExp(GUID_REGEX, "i").exec(args[1]);
-					if (!matches) throw new Error("Cannot parse GUID value. Value doesn't match to regular expression");
-					const hex = matches.slice(1).map((o, i) => {
-						if (i < 3) return pvtsutils.Convert.ToHex(new Uint8Array(pvtsutils.Convert.FromHex(o)).reverse());
-						return o;
-					}).join("");
-					name = new asn1X509__namespace.GeneralName({ otherName: new asn1X509__namespace.OtherName({
-						typeId: id_GUID,
-						value: asn1Schema.AsnConvert.serialize(new asn1Schema.OctetString(pvtsutils.Convert.FromHex(hex)))
-					}) });
-					break;
+			let options;
+			if (pvtsutils.BufferSourceConverter.isBufferSource(args[0])) {
+				options = args[1];
+				name = asn1Schema.AsnConvert.parse(args[0], asn1X509__namespace.GeneralName, options);
+			} else if (typeof args[0] === "string") {
+				options = selfProducedParseOptions;
+				switch (args[0]) {
+					case DN: {
+						const derName = new Name(args[1]).toArrayBuffer();
+						const asnName = asn1Schema.AsnConvert.parse(derName, asn1X509__namespace.Name, selfProducedParseOptions);
+						name = new asn1X509__namespace.GeneralName({ directoryName: asnName });
+						break;
+					}
+					case DNS:
+						name = new asn1X509__namespace.GeneralName({ dNSName: args[1] });
+						break;
+					case EMAIL:
+						name = new asn1X509__namespace.GeneralName({ rfc822Name: args[1] });
+						break;
+					case GUID: {
+						const matches = new RegExp(GUID_REGEX, "i").exec(args[1]);
+						if (!matches) throw new Error("Cannot parse GUID value. Value doesn't match to regular expression");
+						const hex = matches.slice(1).map((o, i) => {
+							if (i < 3) return pvtsutils.Convert.ToHex(new Uint8Array(pvtsutils.Convert.FromHex(o)).reverse());
+							return o;
+						}).join("");
+						name = new asn1X509__namespace.GeneralName({ otherName: new asn1X509__namespace.OtherName({
+							typeId: id_GUID,
+							value: asn1Schema.AsnConvert.serialize(new asn1Schema.OctetString(pvtsutils.Convert.FromHex(hex)))
+						}) });
+						break;
+					}
+					case IP:
+						name = new asn1X509__namespace.GeneralName({ iPAddress: args[1] });
+						break;
+					case REGISTERED_ID:
+						name = new asn1X509__namespace.GeneralName({ registeredID: args[1] });
+						break;
+					case UPN:
+						name = new asn1X509__namespace.GeneralName({ otherName: new asn1X509__namespace.OtherName({
+							typeId: id_UPN,
+							value: asn1Schema.AsnConvert.serialize(asn1Schema.AsnUtf8StringConverter.toASN(args[1]))
+						}) });
+						break;
+					case URL:
+						name = new asn1X509__namespace.GeneralName({ uniformResourceIdentifier: args[1] });
+						break;
+					default: throw new Error("Cannot create GeneralName. Unsupported type of the name");
 				}
-				case IP:
-					name = new asn1X509__namespace.GeneralName({ iPAddress: args[1] });
-					break;
-				case REGISTERED_ID:
-					name = new asn1X509__namespace.GeneralName({ registeredID: args[1] });
-					break;
-				case UPN:
-					name = new asn1X509__namespace.GeneralName({ otherName: new asn1X509__namespace.OtherName({
-						typeId: id_UPN,
-						value: asn1Schema.AsnConvert.serialize(asn1Schema.AsnUtf8StringConverter.toASN(args[1]))
-					}) });
-					break;
-				case URL:
-					name = new asn1X509__namespace.GeneralName({ uniformResourceIdentifier: args[1] });
-					break;
-				default: throw new Error("Cannot create GeneralName. Unsupported type of the name");
+			} else {
+				name = args[0];
+				options = (_a = args[1]) !== null && _a !== void 0 ? _a : selfProducedParseOptions;
 			}
-			else if (pvtsutils.BufferSourceConverter.isBufferSource(args[0])) name = asn1Schema.AsnConvert.parse(args[0], asn1X509__namespace.GeneralName);
-			else name = args[0];
-			super(name);
+			super(name, options);
 		}
 		onInit(asn) {
 			if (asn.dNSName != void 0) {
@@ -15570,7 +16017,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 			} else if (asn.otherName != void 0) {
 				if (asn.otherName.typeId === id_GUID) {
 					this.type = GUID;
-					const guid = asn1Schema.AsnConvert.parse(asn.otherName.value, asn1Schema.OctetString);
+					const guid = asn1Schema.AsnConvert.parse(asn.otherName.value, asn1Schema.OctetString, this.parseOptions);
 					const matches = new RegExp(GUID_REGEX, "i").exec(pvtsutils.Convert.ToHex(guid));
 					if (!matches) throw new Error(ERR_GUID);
 					this.value = matches.slice(1).map((o, i) => {
@@ -15579,7 +16026,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 					}).join("-");
 				} else if (asn.otherName.typeId === id_UPN) {
 					this.type = UPN;
-					this.value = asn1Schema.AsnConvert.parse(asn.otherName.value, asn1X509__namespace.DirectoryString).toString();
+					this.value = asn1Schema.AsnConvert.parse(asn.otherName.value, asn1X509__namespace.DirectoryString, this.parseOptions).toString();
 				} else throw new Error(ERR_GN_STRING_FORMAT);
 			} else throw new Error(ERR_GN_STRING_FORMAT);
 		}
@@ -15612,27 +16059,30 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 	};
 	var GeneralNames = class extends AsnData {
-		constructor(params) {
+		constructor(params, options) {
 			let names;
+			let stored = selfProducedParseOptions;
 			if (params instanceof asn1X509__namespace.GeneralNames) names = params;
 			else if (Array.isArray(params)) {
 				const items = [];
 				for (const name of params) if (name instanceof asn1X509__namespace.GeneralName) items.push(name);
 				else {
-					const asnName = asn1Schema.AsnConvert.parse(new GeneralName(name.type, name.value).rawData, asn1X509__namespace.GeneralName);
+					const asnName = asn1Schema.AsnConvert.parse(new GeneralName(name.type, name.value).rawData, asn1X509__namespace.GeneralName, selfProducedParseOptions);
 					items.push(asnName);
 				}
 				names = new asn1X509__namespace.GeneralNames(items);
-			} else if (pvtsutils.BufferSourceConverter.isBufferSource(params)) names = asn1Schema.AsnConvert.parse(params, asn1X509__namespace.GeneralNames);
-			else throw new Error("Cannot initialize GeneralNames. Incorrect incoming arguments");
-			super(names);
+			} else if (pvtsutils.BufferSourceConverter.isBufferSource(params)) {
+				names = asn1Schema.AsnConvert.parse(params, asn1X509__namespace.GeneralNames, options);
+				stored = options !== null && options !== void 0 ? options : {};
+			} else throw new Error("Cannot initialize GeneralNames. Incorrect incoming arguments");
+			super(names, stored);
 		}
 		onInit(asn) {
 			const items = [];
 			for (const asnName of asn) {
 				let name = null;
 				try {
-					name = new GeneralName(asnName);
+					name = new GeneralName(asnName, this.parseOptions);
 				} catch {
 					continue;
 				}
@@ -15897,7 +16347,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 				super(asn1X509__namespace.id_ce_authorityKeyIdentifier, args[1], asn1Schema.AsnConvert.serialize(value));
 			} else {
 				const certId = args[0];
-				const certIdName = certId.name instanceof GeneralNames ? asn1Schema.AsnConvert.parse(certId.name.rawData, asn1X509__namespace.GeneralNames) : certId.name;
+				const certIdName = certId.name instanceof GeneralNames ? asn1Schema.AsnConvert.parse(certId.name.rawData, asn1X509__namespace.GeneralNames, selfProducedParseOptions) : certId.name;
 				const value = new asn1X509__namespace.AuthorityKeyIdentifier({
 					authorityCertIssuer: certIdName,
 					authorityCertSerialNumber: pvtsutils.Convert.FromHex(certId.serialNumber)
@@ -16195,7 +16645,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 			if (typeof url === "string") url = new GeneralName("url", url);
 			value.push(new asn1X509__namespace.AccessDescription({
 				accessMethod: method,
-				accessLocation: asn1Schema.AsnConvert.parse(url.rawData, asn1X509__namespace.GeneralName)
+				accessLocation: asn1Schema.AsnConvert.parse(url.rawData, asn1X509__namespace.GeneralName, selfProducedParseOptions)
 			}));
 		});
 	}
@@ -16231,6 +16681,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 					type,
 					values
 				}));
+				options = selfProducedParseOptions;
 			}
 			super(raw, asn1X509.Attribute, options);
 		}
@@ -16281,7 +16732,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 			else {
 				const extensions = args[0];
 				const value = new asn1X509__namespace.Extensions();
-				for (const extension of extensions) value.push(asn1Schema.AsnConvert.parse(extension.rawData, asn1X509__namespace.Extension));
+				for (const extension of extensions) value.push(asn1Schema.AsnConvert.parse(extension.rawData, asn1X509__namespace.Extension, selfProducedParseOptions));
 				super(asnPkcs9__namespace.id_pkcs9_at_extensionRequest, [asn1Schema.AsnConvert.serialize(value)]);
 			}
 			(_a = this.items) !== null && _a !== void 0 || (this.items = []);
@@ -16755,16 +17206,16 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 			if (!params.keys.privateKey) throw new Error("Bad field 'keys' in 'params' argument. 'privateKey' is empty");
 			if (!params.keys.publicKey) throw new Error("Bad field 'keys' in 'params' argument. 'publicKey' is empty");
 			const spki = await crypto.subtle.exportKey("spki", params.keys.publicKey);
-			const asnReq = new asn1Csr.CertificationRequest({ certificationRequestInfo: new asn1Csr.CertificationRequestInfo({ subjectPKInfo: asn1Schema.AsnConvert.parse(spki, asn1X509.SubjectPublicKeyInfo) }) });
+			const asnReq = new asn1Csr.CertificationRequest({ certificationRequestInfo: new asn1Csr.CertificationRequestInfo({ subjectPKInfo: asn1Schema.AsnConvert.parse(spki, asn1X509.SubjectPublicKeyInfo, selfProducedParseOptions) }) });
 			if (params.name) {
 				const name = params.name instanceof Name ? params.name : new Name(params.name);
-				asnReq.certificationRequestInfo.subject = asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509.Name);
+				asnReq.certificationRequestInfo.subject = asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509.Name, selfProducedParseOptions);
 			}
-			if (params.attributes) for (const o of params.attributes) asnReq.certificationRequestInfo.attributes.push(asn1Schema.AsnConvert.parse(o.rawData, asn1X509.Attribute));
+			if (params.attributes) for (const o of params.attributes) asnReq.certificationRequestInfo.attributes.push(asn1Schema.AsnConvert.parse(o.rawData, asn1X509.Attribute, selfProducedParseOptions));
 			if (params.extensions && params.extensions.length) {
 				const attr = new asn1X509.Attribute({ type: asnPkcs9.id_pkcs9_at_extensionRequest });
 				const extensions = new asn1X509.Extensions();
-				for (const o of params.extensions) extensions.push(asn1Schema.AsnConvert.parse(o.rawData, asn1X509.Extension));
+				for (const o of params.extensions) extensions.push(asn1Schema.AsnConvert.parse(o.rawData, asn1X509.Extension, selfProducedParseOptions));
 				attr.values.push(asn1Schema.AsnConvert.serialize(extensions));
 				asnReq.certificationRequestInfo.attributes.push(attr);
 			}
@@ -16783,34 +17234,9 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 			}
 			if (!asnSignature) throw Error("Cannot convert WebCrypto signature value to ASN.1 format");
 			asnReq.signature = asnSignature;
-			return new Pkcs10CertificateRequest(asn1Schema.AsnConvert.serialize(asnReq));
+			return new Pkcs10CertificateRequest(asn1Schema.AsnConvert.serialize(asnReq), selfProducedParseOptions);
 		}
 	};
-	function toPositiveIntegerOctets(input) {
-		let firstNonZero = 0;
-		while (firstNonZero < input.length - 1 && input[firstNonZero] === 0) firstNonZero++;
-		let serialNumber = input.slice(firstNonZero);
-		if (!serialNumber.length) serialNumber = new Uint8Array([0]);
-		if (serialNumber[0] > 127) {
-			const newSerialNumber = new Uint8Array(serialNumber.length + 1);
-			newSerialNumber[0] = 0;
-			newSerialNumber.set(serialNumber, 1);
-			serialNumber = newSerialNumber;
-		}
-		return serialNumber.buffer;
-	}
-	function normalizeCertificateSerialNumber(input) {
-		return toPositiveIntegerOctets(pvtsutils.BufferSourceConverter.toUint8Array(pvtsutils.Convert.FromHex(input || "")));
-	}
-	function generateCertificateSerialNumber(input, crypto = cryptoProvider.get()) {
-		const inputView = pvtsutils.BufferSourceConverter.toUint8Array(pvtsutils.Convert.FromHex(input || ""));
-		return toPositiveIntegerOctets(inputView.length && inputView.some((o) => o > 0) ? inputView : crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)));
-	}
-	function getCertificateSerialNumber(raw) {
-		let serialNumber = pvtsutils.BufferSourceConverter.toUint8Array(raw);
-		if (serialNumber.length > 1 && serialNumber[0] === 0 && serialNumber[1] > 127) serialNumber = serialNumber.slice(1);
-		return pvtsutils.Convert.ToHex(serialNumber);
-	}
 	var _X509Certificate_tbs;
 	var _X509Certificate_serialNumber;
 	var _X509Certificate_subjectName;
@@ -17159,10 +17585,13 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 		static async create(params, crypto = cryptoProvider.get()) {
 			var _a;
 			let spki;
+			let spkiOptions = selfProducedParseOptions;
 			if (params.publicKey instanceof PublicKey) spki = params.publicKey.rawData;
 			else if ("publicKey" in params.publicKey) spki = params.publicKey.publicKey.rawData;
-			else if (pvtsutils.BufferSourceConverter.isBufferSource(params.publicKey)) spki = params.publicKey;
-			else spki = await crypto.subtle.exportKey("spki", params.publicKey);
+			else if (pvtsutils.BufferSourceConverter.isBufferSource(params.publicKey)) {
+				spki = params.publicKey;
+				spkiOptions = void 0;
+			} else spki = await crypto.subtle.exportKey("spki", params.publicKey);
 			const serialNumber = generateCertificateSerialNumber(params.serialNumber, crypto);
 			const notBefore = params.notBefore || /* @__PURE__ */ new Date();
 			const notAfter = params.notAfter || new Date(notBefore.getTime() + 31536e6);
@@ -17173,16 +17602,16 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 					notBefore,
 					notAfter
 				}),
-				extensions: new asn1X509__namespace.Extensions(((_a = params.extensions) === null || _a === void 0 ? void 0 : _a.map((o) => asn1Schema.AsnConvert.parse(o.rawData, asn1X509__namespace.Extension))) || []),
-				subjectPublicKeyInfo: asn1Schema.AsnConvert.parse(spki, asn1X509__namespace.SubjectPublicKeyInfo)
+				extensions: new asn1X509__namespace.Extensions(((_a = params.extensions) === null || _a === void 0 ? void 0 : _a.map((o) => asn1Schema.AsnConvert.parse(o.rawData, asn1X509__namespace.Extension, selfProducedParseOptions))) || []),
+				subjectPublicKeyInfo: asn1Schema.AsnConvert.parse(spki, asn1X509__namespace.SubjectPublicKeyInfo, spkiOptions)
 			}) });
 			if (params.subject) {
 				const name = params.subject instanceof Name ? params.subject : new Name(params.subject);
-				asnX509.tbsCertificate.subject = asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509__namespace.Name);
+				asnX509.tbsCertificate.subject = asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509__namespace.Name, selfProducedParseOptions);
 			}
 			if (params.issuer) {
 				const name = params.issuer instanceof Name ? params.issuer : new Name(params.issuer);
-				asnX509.tbsCertificate.issuer = asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509__namespace.Name);
+				asnX509.tbsCertificate.issuer = asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509__namespace.Name, selfProducedParseOptions);
 			}
 			const defaultSigningAlgorithm = { hash: "SHA-256" };
 			const signatureAlgorithm = "signingKey" in params ? {
@@ -17205,7 +17634,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 			}
 			if (!asnSignature) throw Error("Cannot convert ASN.1 signature value to WebCrypto format");
 			asnX509.signatureValue = asnSignature;
-			return new X509Certificate(asn1Schema.AsnConvert.serialize(asnX509));
+			return new X509Certificate(asn1Schema.AsnConvert.serialize(asnX509), selfProducedParseOptions);
 		}
 	};
 	var _X509CrlEntry_serialNumber;
@@ -17445,11 +17874,11 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 			const name = params.issuer instanceof Name ? params.issuer : new Name(params.issuer);
 			const asnX509Crl = new asn1X509__namespace.CertificateList({ tbsCertList: new asn1X509__namespace.TBSCertList({
 				version: asn1X509__namespace.Version.v2,
-				issuer: asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509__namespace.Name),
+				issuer: asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509__namespace.Name, selfProducedParseOptions),
 				thisUpdate: new asn1X509.Time(params.thisUpdate || /* @__PURE__ */ new Date())
 			}) });
 			if (params.nextUpdate) asnX509Crl.tbsCertList.nextUpdate = new asn1X509.Time(params.nextUpdate);
-			if (params.extensions && params.extensions.length) asnX509Crl.tbsCertList.crlExtensions = new asn1X509__namespace.Extensions(params.extensions.map((o) => asn1Schema.AsnConvert.parse(o.rawData, asn1X509__namespace.Extension)) || []);
+			if (params.extensions && params.extensions.length) asnX509Crl.tbsCertList.crlExtensions = new asn1X509__namespace.Extensions(params.extensions.map((o) => asn1Schema.AsnConvert.parse(o.rawData, asn1X509__namespace.Extension, selfProducedParseOptions)) || []);
 			if (params.entries && params.entries.length) {
 				asnX509Crl.tbsCertList.revokedCertificates = [];
 				for (const entry of params.entries) {
@@ -17459,7 +17888,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 						userCertificate,
 						revocationDate: new asn1X509.Time(entry.revocationDate || /* @__PURE__ */ new Date())
 					});
-					if ("extensions" in entry && ((_a = entry.extensions) === null || _a === void 0 ? void 0 : _a.length)) revokedCert.crlEntryExtensions = entry.extensions.map((o) => asn1Schema.AsnConvert.parse(o.rawData, asn1X509__namespace.Extension));
+					if ("extensions" in entry && ((_a = entry.extensions) === null || _a === void 0 ? void 0 : _a.length)) revokedCert.crlEntryExtensions = entry.extensions.map((o) => asn1Schema.AsnConvert.parse(o.rawData, asn1X509__namespace.Extension, selfProducedParseOptions));
 					else revokedCert.crlEntryExtensions = [];
 					if (!(entry instanceof X509CrlEntry)) {
 						if (entry.reason) revokedCert.crlEntryExtensions.push(new asn1X509__namespace.Extension({
@@ -17477,7 +17906,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 							revokedCert.crlEntryExtensions.push(new asn1X509__namespace.Extension({
 								extnID: asn1X509__namespace.id_ce_certificateIssuer,
 								critical: false,
-								extnValue: new asn1Schema.OctetString(asn1Schema.AsnConvert.serialize(asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509__namespace.Name)))
+								extnValue: new asn1Schema.OctetString(asn1Schema.AsnConvert.serialize(asn1Schema.AsnConvert.parse(name.toArrayBuffer(), asn1X509__namespace.Name, selfProducedParseOptions)))
 							}));
 						}
 					}
@@ -17500,7 +17929,7 @@ var require_x509_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
 			}
 			if (!asnSignature) throw Error("Cannot convert ASN.1 signature value to WebCrypto format");
 			asnX509Crl.signature = asnSignature;
-			return new X509Crl(asn1Schema.AsnConvert.serialize(asnX509Crl));
+			return new X509Crl(asn1Schema.AsnConvert.serialize(asnX509Crl), selfProducedParseOptions);
 		}
 	};
 	ExtensionFactory.register(asn1X509__namespace.id_ce_basicConstraints, BasicConstraintsExtension);