@recoillink/cli 0.0.0-stage → 45.0.1

package/bundle/841.index.js

@@ -0,0 +1,2093 @@
+export const id = 841;
+export const ids = [841];
+export const modules = {
+
+/***/ 48841:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  AsnParser: () => (/* reexport */ parser_AsnParser),
+  AsnProp: () => (/* reexport */ AsnProp),
+  AsnPropTypes: () => (/* reexport */ enums_AsnPropTypes),
+  AsnType: () => (/* reexport */ AsnType),
+  AsnTypeTypes: () => (/* reexport */ enums_AsnTypeTypes)
+});
+
+// UNUSED EXPORTS: AsnAnyConverter, AsnArray, AsnBitStringConverter, AsnBmpStringConverter, AsnBooleanConverter, AsnCharacterStringConverter, AsnChoiceType, AsnConstructedOctetStringConverter, AsnConvert, AsnEnumeratedConverter, AsnGeneralStringConverter, AsnGeneralizedTimeConverter, AsnGraphicStringConverter, AsnIA5StringConverter, AsnIntegerArrayBufferConverter, AsnIntegerBigIntConverter, AsnIntegerConverter, AsnNullConverter, AsnNumericStringConverter, AsnObjectIdentifierConverter, AsnOctetStringConverter, AsnPrintableStringConverter, AsnRelativeObjectIdentifierConverter, AsnSchemaValidationError, AsnSequenceType, AsnSerializer, AsnSetType, AsnTeletexStringConverter, AsnUTCTimeConverter, AsnUniversalStringConverter, AsnUtf8StringConverter, AsnVideotexStringConverter, AsnVisibleStringConverter, BitString, OctetString, defaultConverter
+
+// EXTERNAL MODULE: ../../node_modules/.pnpm/asn1js@3.0.10/node_modules/asn1js/build/index.js
+var build = __webpack_require__(92452);
+var build_namespaceObject = /*#__PURE__*/__webpack_require__.t(build, 2);
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/bytes/buffer-source.js
+const ARRAY_BUFFER_TAG = "[object ArrayBuffer]";
+const SHARED_ARRAY_BUFFER_TAG = "[object SharedArrayBuffer]";
+function tagOf(value) {
+    return Object.prototype.toString.call(value);
+}
+function isDataViewConstructor(type) {
+    return type === DataView || type.prototype instanceof DataView;
+}
+function bytesPerElement(type) {
+    if (isDataViewConstructor(type)) {
+        return 1;
+    }
+    const value = type.BYTES_PER_ELEMENT;
+    return value ?? 1;
+}
+function isArrayBufferViewLike(value) {
+    if (ArrayBuffer.isView(value)) {
+        return true;
+    }
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const view = value;
+    return typeof view.byteOffset === "number"
+        && typeof view.byteLength === "number"
+        && isArrayBufferLike(view.buffer);
+}
+function copyBytes(data) {
+    const view = toUint8Array(data);
+    const copy = new Uint8Array(view.byteLength);
+    copy.set(view);
+    return copy;
+}
+function isArrayBuffer(value) {
+    return tagOf(value) === ARRAY_BUFFER_TAG;
+}
+function isSharedArrayBuffer(value) {
+    return typeof SharedArrayBuffer !== "undefined" && tagOf(value) === SHARED_ARRAY_BUFFER_TAG;
+}
+function isArrayBufferLike(value) {
+    return isArrayBuffer(value) || isSharedArrayBuffer(value);
+}
+function isArrayBufferView(value) {
+    return isArrayBufferViewLike(value);
+}
+function buffer_source_isBufferSource(value) {
+    return isArrayBufferLike(value) || isArrayBufferView(value);
+}
+function assertBufferSource(value) {
+    if (!buffer_source_isBufferSource(value)) {
+        throw new TypeError("Expected ArrayBuffer, SharedArrayBuffer, or ArrayBufferView");
+    }
+}
+function toUint8Array(data) {
+    assertBufferSource(data);
+    if (isArrayBufferLike(data)) {
+        return new Uint8Array(data);
+    }
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+function toUint8ArrayCopy(data) {
+    return copyBytes(data);
+}
+function buffer_source_toArrayBuffer(data) {
+    assertBufferSource(data);
+    if (isArrayBuffer(data)) {
+        return data;
+    }
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(toUint8Array(data));
+    return buffer;
+}
+function toArrayBufferLike(data) {
+    assertBufferSource(data);
+    if (isArrayBufferLike(data)) {
+        return data;
+    }
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
+    }
+    return copyBytes(data).buffer;
+}
+function toView(data, type) {
+    assertBufferSource(data);
+    if (ArrayBuffer.isView(data) && data.constructor === type) {
+        return data;
+    }
+    const view = toUint8Array(data);
+    const elementSize = bytesPerElement(type);
+    if (view.byteOffset % elementSize !== 0 || view.byteLength % elementSize !== 0) {
+        throw new RangeError(`Cannot create ${type.name} over unaligned byte range`);
+    }
+    if (isDataViewConstructor(type)) {
+        return new type(view.buffer, view.byteOffset, view.byteLength);
+    }
+    return new type(view.buffer, view.byteOffset, view.byteLength / elementSize);
+}
+function toViewCopy(data, type) {
+    const copy = toUint8ArrayCopy(data);
+    return toView(copy, type);
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/bytes/index.js
+
+
+
+
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/encoding/binary.js
+
+function encode(data) {
+    const bytes = toUint8Array(data);
+    let result = "";
+    for (const byte of bytes) {
+        result += String.fromCharCode(byte);
+    }
+    return result;
+}
+function decode(text) {
+    const result = new Uint8Array(text.length);
+    for (let i = 0; i < text.length; i++) {
+        result[i] = text.charCodeAt(i) & 0xff;
+    }
+    return result;
+}
+function is(text) {
+    return typeof text === "string";
+}
+const binary = { encode, decode, is };
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/encoding/hex.js
+
+const HEX_CHARACTER_REGEX = /^[0-9a-f]$/i;
+const COMMON_SEPARATORS = [" ", "\t", "\n", "\r", ":", "-", "."];
+function resolveSeparators(options) {
+    if (options.separators === "none") {
+        return [];
+    }
+    if (!options.separators || options.separators === "common") {
+        return COMMON_SEPARATORS;
+    }
+    return options.separators;
+}
+function validateSeparator(separator) {
+    if (!separator) {
+        throw new TypeError("Hex separators must be non-empty strings");
+    }
+}
+function matchSeparator(text, index, separators) {
+    for (const separator of separators) {
+        if (text.startsWith(separator, index)) {
+            return separator;
+        }
+    }
+    return undefined;
+}
+function detectCase(text) {
+    const hasUpper = /[A-F]/.test(text);
+    const hasLower = /[a-f]/.test(text);
+    return hasUpper && !hasLower ? "upper" : "lower";
+}
+function detectLineSeparator(text) {
+    const match = /\r\n|\n/.exec(text);
+    if (!match) {
+        return undefined;
+    }
+    return match[0] === "\r\n" ? "\r\n" : "\n";
+}
+function compactForDetection(text) {
+    return text.replace(/[^0-9a-f]/gi, "");
+}
+function detectGroup(text) {
+    const segments = text.match(/[0-9A-Fa-f]+|[^0-9A-Fa-f]+/g) ?? [];
+    if (segments.length < 3) {
+        return undefined;
+    }
+    const hexSegments = segments.filter((_, index) => index % 2 === 0);
+    const separators = segments.filter((_, index) => index % 2 === 1);
+    const separator = separators[0];
+    if (!separator || separators.some((item) => item !== separator)) {
+        return undefined;
+    }
+    if (hexSegments.some((segment) => segment.length === 0 || segment.length % 2 !== 0)) {
+        return undefined;
+    }
+    const firstLength = hexSegments[0]?.length ?? 0;
+    if (!firstLength) {
+        return undefined;
+    }
+    if (hexSegments.slice(0, -1).some((segment) => segment.length !== firstLength)) {
+        return undefined;
+    }
+    if ((hexSegments[hexSegments.length - 1]?.length ?? 0) > firstLength) {
+        return undefined;
+    }
+    return {
+        size: firstLength / 2,
+        separator,
+    };
+}
+function detectFormat(text) {
+    const trimmed = text.trim();
+    const prefix = /^0x/i.test(trimmed) ? "0x" : "";
+    const body = prefix ? trimmed.slice(2) : trimmed;
+    const lineSeparator = detectLineSeparator(body);
+    const lines = body.split(/\r\n|\n/).filter((line) => line.length > 0);
+    const sampleLine = lines[0]?.trim() ?? "";
+    const group = detectGroup(sampleLine);
+    const format = {
+        case: detectCase(trimmed),
+        prefix,
+    };
+    if (group) {
+        format.group = group;
+    }
+    if (lineSeparator && lines.length > 1) {
+        const firstLineBytes = compactForDetection(lines[0] ?? "").length / 2;
+        if (firstLineBytes > 0 && lines.slice(0, -1).every((line) => compactForDetection(line).length / 2 === firstLineBytes)) {
+            format.line = {
+                bytesPerLine: firstLineBytes,
+                separator: lineSeparator,
+            };
+        }
+    }
+    return format;
+}
+function normalizeText(text, options) {
+    const allowPrefix = options.allowPrefix ?? true;
+    const separators = [...resolveSeparators(options)].sort((left, right) => right.length - left.length);
+    for (const separator of separators) {
+        validateSeparator(separator);
+    }
+    let working = text.trim();
+    if (/^0x/i.test(working)) {
+        if (!allowPrefix) {
+            throw new TypeError("Hexadecimal text must not include a 0x prefix");
+        }
+        working = working.slice(2);
+    }
+    let normalized = "";
+    let lastTokenWasSeparator = false;
+    for (let index = 0; index < working.length;) {
+        const character = working[index] ?? "";
+        if (HEX_CHARACTER_REGEX.test(character)) {
+            normalized += character;
+            lastTokenWasSeparator = false;
+            index += 1;
+            continue;
+        }
+        const separator = matchSeparator(working, index, separators);
+        if (!separator) {
+            throw new TypeError("Input is not valid hexadecimal text");
+        }
+        if (options.strict && (lastTokenWasSeparator || normalized.length === 0)) {
+            throw new TypeError("Hexadecimal text contains misplaced separators");
+        }
+        lastTokenWasSeparator = true;
+        index += separator.length;
+    }
+    if (options.strict && lastTokenWasSeparator && normalized.length > 0) {
+        throw new TypeError("Hexadecimal text must not end with a separator");
+    }
+    if (normalized.length % 2 !== 0) {
+        if (!options.allowOddLength) {
+            throw new TypeError("Hexadecimal text must contain an even number of characters");
+        }
+        normalized = `0${normalized}`;
+    }
+    return normalized.toLowerCase();
+}
+function groupPairs(pairs, group) {
+    if (!group) {
+        return pairs.join("");
+    }
+    if (!Number.isInteger(group.size) || group.size < 1) {
+        throw new RangeError("Hex group size must be a positive integer");
+    }
+    const chunks = [];
+    for (let index = 0; index < pairs.length; index += group.size) {
+        chunks.push(pairs.slice(index, index + group.size).join(""));
+    }
+    return chunks.join(group.separator);
+}
+function normalize(text, options = {}) {
+    return normalizeText(text, options);
+}
+function hex_is(text, options = {}) {
+    if (typeof text !== "string") {
+        return false;
+    }
+    try {
+        normalize(text, options);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hex_encode(data, options = {}) {
+    const bytes = toUint8Array(data);
+    const casing = options.case ?? "lower";
+    const pairs = Array.from(bytes, (byte) => {
+        const text = byte.toString(16).padStart(2, "0");
+        return casing === "upper" ? text.toUpperCase() : text;
+    });
+    let body = "";
+    if (options.line) {
+        const bytesPerLine = options.line.bytesPerLine;
+        if (!Number.isInteger(bytesPerLine) || bytesPerLine < 1) {
+            throw new RangeError("Hex bytesPerLine must be a positive integer");
+        }
+        const separator = options.line.separator ?? "\n";
+        const lines = [];
+        for (let index = 0; index < pairs.length; index += bytesPerLine) {
+            lines.push(groupPairs(pairs.slice(index, index + bytesPerLine), options.group));
+        }
+        body = lines.join(separator);
+    }
+    else {
+        body = groupPairs(pairs, options.group);
+    }
+    return `${options.prefix ?? ""}${body}`;
+}
+function hex_decode(text, options = {}) {
+    const normalized = normalize(text, options);
+    const result = new Uint8Array(normalized.length / 2);
+    for (let i = 0; i < normalized.length; i += 2) {
+        result[i / 2] = Number.parseInt(normalized.slice(i, i + 2), 16);
+    }
+    return result;
+}
+function parse(text, options = {}) {
+    const normalized = normalize(text, options);
+    return {
+        bytes: hex_decode(normalized),
+        format: detectFormat(text),
+        normalized,
+    };
+}
+function format(data, value) {
+    return hex_encode(data, value);
+}
+const formats = {
+    compact: Object.freeze({}),
+    upper: Object.freeze({ case: "upper" }),
+    colon: Object.freeze({ group: { size: 1, separator: ":" } }),
+    colonUpper: Object.freeze({ case: "upper", group: { size: 1, separator: ":" } }),
+    groupsOf4: Object.freeze({ group: { size: 4, separator: " " } }),
+    prefixed: Object.freeze({ prefix: "0x" }),
+};
+const hex = { encode: hex_encode, decode: hex_decode, format, formats, is: hex_is, normalize, parse };
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/encoding/utf8.js
+
+function utf8_encode(text) {
+    return new TextEncoder().encode(text);
+}
+function utf8_decode(data) {
+    return new TextDecoder("utf-8", { fatal: false }).decode(toUint8Array(data));
+}
+const utf8 = { encode: utf8_encode, decode: utf8_decode };
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/encoding/utf16.js
+
+function utf16_encode(text, options = {}) {
+    const result = new ArrayBuffer(text.length * 2);
+    const view = new DataView(result);
+    for (let i = 0; i < text.length; i++) {
+        view.setUint16(i * 2, text.charCodeAt(i), options.littleEndian ?? false);
+    }
+    return new Uint8Array(result);
+}
+function utf16_decode(data, options = {}) {
+    const buffer = buffer_source_toArrayBuffer(data);
+    const view = new DataView(buffer);
+    let result = "";
+    for (let i = 0; i < buffer.byteLength; i += 2) {
+        result += String.fromCharCode(view.getUint16(i, options.littleEndian ?? false));
+    }
+    return result;
+}
+const utf16 = { encode: utf16_encode, decode: utf16_decode };
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/encoding/base64.js
+
+
+const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+function nodeBuffer() {
+    return globalThis.Buffer;
+}
+function base64_normalize(text) {
+    return text.replace(/[\n\r\t ]/g, "");
+}
+function pad(text) {
+    const remainder = text.length % 4;
+    return remainder ? text + "=".repeat(4 - remainder) : text;
+}
+function base64_is(text) {
+    if (typeof text !== "string") {
+        return false;
+    }
+    const normalized = base64_normalize(text);
+    return normalized === "" || BASE64_REGEX.test(normalized);
+}
+function base64_encode(data, _options) {
+    const bytes = toUint8Array(data);
+    const buffer = nodeBuffer();
+    if (buffer) {
+        return buffer.from(bytes).toString("base64");
+    }
+    return btoa(encode(bytes));
+}
+function base64_decode(text, _options) {
+    const normalized = base64_normalize(text);
+    if (!base64_is(normalized)) {
+        throw new TypeError("Input is not valid Base64 text");
+    }
+    const buffer = nodeBuffer();
+    if (buffer) {
+        return new Uint8Array(buffer.from(normalized, "base64"));
+    }
+    return decode(atob(normalized));
+}
+const base64 = { encode: base64_encode, decode: base64_decode, is: base64_is, normalize: base64_normalize, pad };
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/encoding/base64url.js
+
+const BASE64URL_REGEX = /^[A-Za-z0-9_-]*$/;
+function base64url_normalize(text) {
+    return text.replace(/[\n\r\t ]/g, "");
+}
+function base64url_is(text) {
+    return typeof text === "string" && BASE64URL_REGEX.test(base64url_normalize(text));
+}
+function base64url_encode(data, _options) {
+    return base64.encode(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64url_decode(text, _options) {
+    const normalized = base64url_normalize(text);
+    if (!base64url_is(normalized)) {
+        throw new TypeError("Input is not valid Base64Url text");
+    }
+    return base64.decode(base64.pad(normalized.replace(/-/g, "+").replace(/_/g, "/")));
+}
+const base64url = { encode: base64url_encode, decode: base64url_decode, is: base64url_is, normalize: base64url_normalize };
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/encoding/index.js
+
+
+
+
+
+
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/pem/pem.js
+
+const LABEL_REGEX = /^[A-Z0-9][A-Z0-9 ._-]*[A-Z0-9]$/i;
+const PEM_BLOCK_REGEX = /-----BEGIN ([^-]+)-----([\s\S]*?)-----END \1-----/g;
+function assertLabel(label) {
+    if (!LABEL_REGEX.test(label)) {
+        throw new TypeError(`Invalid PEM label '${label}'`);
+    }
+}
+function wrap(text, lineLength) {
+    const result = [];
+    for (let i = 0; i < text.length; i += lineLength) {
+        result.push(text.slice(i, i + lineLength));
+    }
+    return result;
+}
+function parseBody(body) {
+    const normalized = body.trim().replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n").map((line) => line.trim()).filter(Boolean);
+    const headers = {};
+    let index = 0;
+    for (; index < lines.length; index++) {
+        const line = lines[index];
+        const separator = line.indexOf(":");
+        if (separator <= 0) {
+            break;
+        }
+        headers[line.slice(0, separator).trim()] = line.slice(separator + 1).trim();
+    }
+    return {
+        headers: Object.keys(headers).length ? headers : undefined,
+        base64Lines: lines.slice(index),
+        base64Text: lines.slice(index).join(""),
+    };
+}
+function detectNewline(text) {
+    return /\r\n/.test(text) ? "\r\n" : "\n";
+}
+function collectBlocks(text, options = {}) {
+    const blocks = [];
+    const requestedLabel = options.label;
+    let match;
+    PEM_BLOCK_REGEX.lastIndex = 0;
+    while ((match = PEM_BLOCK_REGEX.exec(text))) {
+        const label = match[1].trim();
+        if (requestedLabel && label !== requestedLabel) {
+            continue;
+        }
+        assertLabel(label);
+        const parsed = parseBody(match[2]);
+        blocks.push({
+            label,
+            data: base64.decode(parsed.base64Text),
+            headers: parsed.headers,
+            lineLength: parsed.base64Lines[0]?.length ?? 64,
+            newline: detectNewline(match[0]),
+        });
+    }
+    if (options.strict && blocks.length === 0) {
+        throw new TypeError(requestedLabel
+            ? `No PEM block with label '${requestedLabel}' was found`
+            : "No PEM blocks were found");
+    }
+    return blocks;
+}
+function pem_encode(label, data, options = {}) {
+    assertLabel(label);
+    const lineLength = options.lineLength ?? 64;
+    if (!Number.isInteger(lineLength) || lineLength < 1) {
+        throw new RangeError("PEM lineLength must be a positive integer");
+    }
+    const newline = options.newline ?? "\n";
+    const lines = [`-----BEGIN ${label}-----`];
+    if (options.headers) {
+        for (const [name, value] of Object.entries(options.headers)) {
+            lines.push(`${name}: ${value}`);
+        }
+        lines.push("");
+    }
+    lines.push(...wrap(base64.encode(data), lineLength));
+    lines.push(`-----END ${label}-----`);
+    return `${lines.join(newline)}${newline}`;
+}
+function encodeMany(blocks, options = {}) {
+    return blocks.map((block) => pem_encode(block.label, block.data, { ...options, headers: block.headers ?? options.headers })).join("");
+}
+function pem_decode(text, options = {}) {
+    return collectBlocks(text, options).map(({ lineLength: _lineLength, newline: _newline, ...block }) => block);
+}
+function find(text, label) {
+    return pem_decode(text, { label })[0];
+}
+function findAll(text, label) {
+    return pem_decode(text, { label });
+}
+function decodeFirst(text, label) {
+    const [block] = pem_decode(text, { label, strict: true });
+    return block.data;
+}
+function pem_parse(text, options = {}) {
+    const [block] = collectBlocks(text, { ...options, strict: true });
+    const format = {
+        label: block.label,
+        headers: block.headers,
+        lineLength: block.lineLength,
+        newline: block.newline,
+    };
+    return {
+        bytes: block.data,
+        format,
+        normalized: pem_encode(block.label, block.data, format),
+    };
+}
+function pem_format(data, value) {
+    return pem_encode(value.label, data, value);
+}
+const pem = { decode: pem_decode, decodeFirst, encode: pem_encode, encodeMany, find, findAll, format: pem_format, parse: pem_parse };
+const pemConverter = {
+    name: "pem",
+    encode: (data, options) => {
+        if (!options?.label) {
+            throw new TypeError("PEM label is required");
+        }
+        return pem_encode(options.label, data, options);
+    },
+    decode: (text, options) => decodeFirst(text, options?.label),
+    format: pem_format,
+    is: (text) => typeof text === "string" && /-----BEGIN [^-]+-----/.test(text),
+    parse: pem_parse,
+};
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/pem/index.js
+
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/converters/registry.js
+function keyOf(name) {
+    return name.trim().toLowerCase();
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function removeConverter(converters, primaryNames, converter) {
+    for (const alias of [converter.name, ...(converter.aliases ?? [])]) {
+        converters.delete(keyOf(alias));
+    }
+    primaryNames.delete(keyOf(converter.name));
+}
+function requireCapability(converter, name, capability) {
+    const method = converter[capability];
+    if (typeof method !== "function") {
+        throw new Error(`Converter '${name}' does not support ${capability}()`);
+    }
+    return method;
+}
+function detectConfidence(name, text, converter) {
+    const normalizedName = keyOf(converter.name || name);
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return 0;
+    }
+    let accepted = false;
+    if (converter.is) {
+        accepted = converter.is(text);
+    }
+    let decodable = false;
+    try {
+        converter.decode(text);
+        decodable = true;
+    }
+    catch {
+        decodable = false;
+    }
+    if (!accepted && !decodable) {
+        return 0;
+    }
+    switch (normalizedName) {
+        case "pem":
+            return /-----BEGIN [^-]+-----/.test(text) ? 1 : 0;
+        case "hex": {
+            const compact = trimmed.replace(/^0x/i, "").replace(/[\s:.-]/g, "");
+            if (!compact || /[^0-9a-f]/i.test(compact) || compact.length % 2 !== 0) {
+                return 0;
+            }
+            if (/^0x/i.test(trimmed) || /[:\s.-]/.test(trimmed)) {
+                return 0.95;
+            }
+            if (/[a-f]/.test(trimmed) || /[A-F]/.test(trimmed)) {
+                return 0.8;
+            }
+            return 0.45;
+        }
+        case "base64url":
+            if (/[-_]/.test(trimmed)) {
+                return 0.95;
+            }
+            if (/=/.test(trimmed)) {
+                return 0.1;
+            }
+            return 0.6;
+        case "base64":
+            if (/[+/=]/.test(trimmed)) {
+                return 0.9;
+            }
+            return 0.55;
+        case "binary":
+        case "utf8":
+        case "utf16be":
+        case "utf16le":
+            return 0;
+        default:
+            return accepted && decodable ? 0.75 : 0.5;
+    }
+}
+function createConverterRegistry(initialConverters = []) {
+    const converters = new Map();
+    const primaryNames = new Set();
+    const api = {
+        register(converter, options = {}) {
+            if (!converter.name || !keyOf(converter.name)) {
+                throw new TypeError("Converter name is required");
+            }
+            const names = [...new Set([converter.name, ...(converter.aliases ?? [])].map(keyOf))];
+            const conflicts = new Set();
+            for (const name of names) {
+                const existing = converters.get(name);
+                if (!existing) {
+                    continue;
+                }
+                if (!options.override) {
+                    throw new Error(`Converter '${name}' is already registered`);
+                }
+                conflicts.add(existing);
+            }
+            for (const conflicting of conflicts) {
+                removeConverter(converters, primaryNames, conflicting);
+            }
+            for (const name of names) {
+                converters.set(name, converter);
+            }
+            primaryNames.add(keyOf(converter.name));
+            return this;
+        },
+        unregister(name) {
+            const converter = converters.get(keyOf(name));
+            if (!converter) {
+                return false;
+            }
+            removeConverter(converters, primaryNames, converter);
+            return true;
+        },
+        has(name) {
+            return converters.has(keyOf(name));
+        },
+        get(name) {
+            const converter = converters.get(keyOf(name));
+            if (!converter) {
+                throw new Error(`Converter '${name}' is not registered`);
+            }
+            return converter;
+        },
+        list() {
+            return [...primaryNames].map((name) => this.get(name));
+        },
+        encode(name, data, options) {
+            return this.get(name).encode(data, options);
+        },
+        decode(name, text, options) {
+            return this.get(name).decode(text, options);
+        },
+        tryDecode(name, text, options) {
+            try {
+                return { ok: true, bytes: this.decode(name, text, options) };
+            }
+            catch (error) {
+                return { ok: false, error: toError(error) };
+            }
+        },
+        normalize(name, text, options) {
+            const converter = this.get(name);
+            return requireCapability(converter, name, "normalize").call(converter, text, options);
+        },
+        parse(name, text, options) {
+            const converter = this.get(name);
+            return requireCapability(converter, name, "parse").call(converter, text, options);
+        },
+        format(name, data, format) {
+            const converter = this.get(name);
+            return requireCapability(converter, name, "format").call(converter, data, format);
+        },
+        transcode(text, options) {
+            const bytes = this.decode(options.from, text, options.fromOptions);
+            return this.encode(options.to, bytes, options.toOptions);
+        },
+        detect(text, options = {}) {
+            const formatNames = options.formats?.length
+                ? options.formats.map((name) => String(name))
+                : this.list()
+                    .map((converter) => converter.name)
+                    .filter((name) => !["binary", "utf8", "utf16be", "utf16le"].includes(keyOf(name)));
+            const detections = new Map();
+            for (const requestedName of formatNames) {
+                const converter = this.get(requestedName);
+                const confidence = detectConfidence(requestedName, text, converter);
+                if (confidence <= 0) {
+                    continue;
+                }
+                const format = converter.name;
+                const current = detections.get(format);
+                if (!current || confidence > current.confidence) {
+                    detections.set(format, { format, confidence });
+                }
+            }
+            return [...detections.values()].sort((left, right) => right.confidence - left.confidence);
+        },
+    };
+    for (const converter of initialConverters) {
+        api.register(converter);
+    }
+    return api;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/converters/defaults.js
+
+
+
+
+const binaryConverter = {
+    name: "binary",
+    aliases: ["latin1"],
+    encode: encode,
+    decode: decode,
+    is: is,
+};
+const hexConverter = {
+    name: "hex",
+    encode: hex_encode,
+    decode: hex_decode,
+    format: format,
+    is: hex_is,
+    normalize: normalize,
+    parse: parse,
+};
+const base64Converter = {
+    name: "base64",
+    aliases: ["b64"],
+    encode: base64_encode,
+    decode: base64_decode,
+    is: base64_is,
+    normalize: base64_normalize,
+};
+const base64urlConverter = {
+    name: "base64url",
+    aliases: ["base64-url", "b64url"],
+    encode: base64url_encode,
+    decode: base64url_decode,
+    is: base64url_is,
+    normalize: base64url_normalize,
+};
+const utf8Converter = {
+    name: "utf8",
+    aliases: ["utf-8"],
+    encode: (data) => utf8_decode(data),
+    decode: (text) => utf8_encode(text),
+    is: (text) => typeof text === "string",
+};
+const utf16beConverter = {
+    name: "utf16be",
+    aliases: ["utf16", "utf-16", "utf-16be"],
+    encode: (data) => utf16_decode(data),
+    decode: (text) => utf16_encode(text),
+    is: (text) => typeof text === "string",
+};
+const utf16leConverter = {
+    name: "utf16le",
+    aliases: ["utf-16le", "ucs2", "usc2"],
+    encode: (data) => utf16_decode(data, { littleEndian: true }),
+    decode: (text) => utf16_encode(text, { littleEndian: true }),
+    is: (text) => typeof text === "string",
+};
+const defaultConverters = [
+    binaryConverter,
+    hexConverter,
+    base64Converter,
+    base64urlConverter,
+    utf8Converter,
+    utf16beConverter,
+    utf16leConverter,
+    pemConverter,
+];
+const defaultConverterRegistry = createConverterRegistry(defaultConverters);
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/converters/convert.js
+
+
+
+function convert_encode(name, data, ...args) {
+    return defaultConverterRegistry.encode(name, data, ...args);
+}
+function convert_decode(name, text, ...args) {
+    return defaultConverterRegistry.decode(name, text, ...args);
+}
+function tryDecode(name, text, ...args) {
+    return defaultConverterRegistry.tryDecode(name, text, ...args);
+}
+function convert_normalize(name, text, ...args) {
+    return defaultConverterRegistry.normalize(name, text, ...args);
+}
+function convert_parse(name, text, ...args) {
+    return defaultConverterRegistry.parse(name, text, ...args);
+}
+function convert_format(name, data, value) {
+    return defaultConverterRegistry.format(name, data, value);
+}
+function transcode(text, options) {
+    return defaultConverterRegistry.transcode(text, options);
+}
+function detect(text, options) {
+    return defaultConverterRegistry.detect(text, options);
+}
+function normalizeEncodingName(encoding) {
+    return encoding.toLowerCase();
+}
+const convert_convert = {
+    encode: convert_encode,
+    decode: convert_decode,
+    tryDecode,
+    normalize: convert_normalize,
+    parse: convert_parse,
+    format: convert_format,
+    transcode,
+    detect,
+    to(format, data, ...args) {
+        return convert_encode(format, data, ...args);
+    },
+    from(format, text, ...args) {
+        return convert_decode(format, text, ...args);
+    },
+    toString(data, encoding = "utf8") {
+        return convert_encode(encoding, data);
+    },
+    fromString(text, encoding = "utf8") {
+        if (normalizeEncodingName(encoding) === "hex") {
+            return buffer_source_toArrayBuffer(hex_decode(text, { allowOddLength: true }));
+        }
+        return buffer_source_toArrayBuffer(convert_decode(encoding, text));
+    },
+    toBase64: base64_encode,
+    fromBase64: (text) => buffer_source_toArrayBuffer(base64_decode(text)),
+    toBase64Url: base64url_encode,
+    fromBase64Url: (text) => buffer_source_toArrayBuffer(base64url_decode(text)),
+    toHex: hex_encode,
+    fromHex: (text) => buffer_source_toArrayBuffer(hex_decode(text, { allowOddLength: true })),
+    toBinary: encode,
+    fromBinary: (text) => buffer_source_toArrayBuffer(decode(text)),
+    toUtf8String: utf8_decode,
+    fromUtf8String: (text) => buffer_source_toArrayBuffer(utf8_encode(text)),
+    toUtf16String: (data, littleEndian = false) => utf16_decode(data, { littleEndian }),
+    fromUtf16String: (text, littleEndian = false) => buffer_source_toArrayBuffer(utf16_encode(text, { littleEndian })),
+    isHex: hex_is,
+    isBase64: base64_is,
+    isBase64Url: base64url_is,
+    formatString: base64_normalize,
+};
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/converters/index.js
+
+
+
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/legacy/convert.js
+
+function normalizeTextEncoding(encoding) {
+    return encoding === "ascii" ? "binary" : encoding;
+}
+class Convert {
+    static DEFAULT_UTF8_ENCODING = (/* unused pure expression or super */ null && ("utf8"));
+    static isHex(data) {
+        return convert.isHex(data);
+    }
+    static isBase64(data) {
+        return convert.isBase64(data);
+    }
+    static isBase64Url(data) {
+        return convert.isBase64Url(data);
+    }
+    static ToString(buffer, enc = "utf8") {
+        return convert.toString(buffer, enc);
+    }
+    static FromString(str, enc = "utf8") {
+        if (!str) {
+            return new ArrayBuffer(0);
+        }
+        return convert.fromString(str, enc);
+    }
+    static ToBase64(buffer) {
+        return convert.toBase64(buffer);
+    }
+    static FromBase64(base64) {
+        return convert.fromBase64(base64);
+    }
+    static FromBase64Url(base64url) {
+        return convert.fromBase64Url(base64url);
+    }
+    static ToBase64Url(data) {
+        return convert.toBase64Url(data);
+    }
+    static FromUtf8String(text, encoding = Convert.DEFAULT_UTF8_ENCODING) {
+        return convert.fromString(text, normalizeTextEncoding(encoding));
+    }
+    static ToUtf8String(buffer, encoding = Convert.DEFAULT_UTF8_ENCODING) {
+        return convert.toString(buffer, normalizeTextEncoding(encoding));
+    }
+    static FromBinary(text) {
+        return convert.fromBinary(text);
+    }
+    static ToBinary(buffer) {
+        return convert.toBinary(buffer);
+    }
+    static ToHex(buffer) {
+        return convert.toHex(buffer);
+    }
+    static FromHex(hexString) {
+        return convert.fromHex(hexString);
+    }
+    static ToUtf16String(buffer, littleEndian = false) {
+        return convert.toUtf16String(buffer, littleEndian);
+    }
+    static FromUtf16String(text, littleEndian = false) {
+        return convert.fromUtf16String(text, littleEndian);
+    }
+    static Base64Padding(base64) {
+        const padCount = 4 - (base64.length % 4);
+        return padCount < 4 ? base64 + "=".repeat(padCount) : base64;
+    }
+    static formatString(data) {
+        return convert.formatString(data);
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/legacy/index.js
+
+
+
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+utils@2.0.3/node_modules/@peculiar/utils/build/esm/index.js
+
+
+
+
+
+
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/enums.js
+var enums_AsnTypeTypes;
+(function (AsnTypeTypes) {
+    AsnTypeTypes[AsnTypeTypes["Sequence"] = 0] = "Sequence";
+    AsnTypeTypes[AsnTypeTypes["Set"] = 1] = "Set";
+    AsnTypeTypes[AsnTypeTypes["Choice"] = 2] = "Choice";
+})(enums_AsnTypeTypes || (enums_AsnTypeTypes = {}));
+var enums_AsnPropTypes;
+(function (AsnPropTypes) {
+    AsnPropTypes[AsnPropTypes["Any"] = 1] = "Any";
+    AsnPropTypes[AsnPropTypes["Boolean"] = 2] = "Boolean";
+    AsnPropTypes[AsnPropTypes["OctetString"] = 3] = "OctetString";
+    AsnPropTypes[AsnPropTypes["BitString"] = 4] = "BitString";
+    AsnPropTypes[AsnPropTypes["Integer"] = 5] = "Integer";
+    AsnPropTypes[AsnPropTypes["Enumerated"] = 6] = "Enumerated";
+    AsnPropTypes[AsnPropTypes["ObjectIdentifier"] = 7] = "ObjectIdentifier";
+    AsnPropTypes[AsnPropTypes["Utf8String"] = 8] = "Utf8String";
+    AsnPropTypes[AsnPropTypes["BmpString"] = 9] = "BmpString";
+    AsnPropTypes[AsnPropTypes["UniversalString"] = 10] = "UniversalString";
+    AsnPropTypes[AsnPropTypes["NumericString"] = 11] = "NumericString";
+    AsnPropTypes[AsnPropTypes["PrintableString"] = 12] = "PrintableString";
+    AsnPropTypes[AsnPropTypes["TeletexString"] = 13] = "TeletexString";
+    AsnPropTypes[AsnPropTypes["VideotexString"] = 14] = "VideotexString";
+    AsnPropTypes[AsnPropTypes["IA5String"] = 15] = "IA5String";
+    AsnPropTypes[AsnPropTypes["GraphicString"] = 16] = "GraphicString";
+    AsnPropTypes[AsnPropTypes["VisibleString"] = 17] = "VisibleString";
+    AsnPropTypes[AsnPropTypes["GeneralString"] = 18] = "GeneralString";
+    AsnPropTypes[AsnPropTypes["CharacterString"] = 19] = "CharacterString";
+    AsnPropTypes[AsnPropTypes["UTCTime"] = 20] = "UTCTime";
+    AsnPropTypes[AsnPropTypes["GeneralizedTime"] = 21] = "GeneralizedTime";
+    AsnPropTypes[AsnPropTypes["DATE"] = 22] = "DATE";
+    AsnPropTypes[AsnPropTypes["TimeOfDay"] = 23] = "TimeOfDay";
+    AsnPropTypes[AsnPropTypes["DateTime"] = 24] = "DateTime";
+    AsnPropTypes[AsnPropTypes["Duration"] = 25] = "Duration";
+    AsnPropTypes[AsnPropTypes["TIME"] = 26] = "TIME";
+    AsnPropTypes[AsnPropTypes["Null"] = 27] = "Null";
+    AsnPropTypes[AsnPropTypes["RelativeObjectIdentifier"] = 28] = "RelativeObjectIdentifier";
+})(enums_AsnPropTypes || (enums_AsnPropTypes = {}));
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/types/bit_string.js
+
+
+class BitString {
+    unusedBits = 0;
+    value = new ArrayBuffer(0);
+    constructor(params, unusedBits = 0) {
+        if (params) {
+            if (typeof params === "number") {
+                this.fromNumber(params);
+            }
+            else if (isBufferSource(params)) {
+                this.unusedBits = unusedBits;
+                this.value = toArrayBuffer(params);
+            }
+            else {
+                throw TypeError("Unsupported type of 'params' argument for BitString");
+            }
+        }
+    }
+    fromASN(asn) {
+        if (!(asn instanceof asn1js.BitString)) {
+            throw new TypeError("Argument 'asn' is not instance of ASN.1 BitString");
+        }
+        this.unusedBits = asn.valueBlock.unusedBits;
+        this.value = toArrayBuffer(asn.valueBlock.valueHex);
+        return this;
+    }
+    toASN() {
+        return new asn1js.BitString({
+            unusedBits: this.unusedBits,
+            valueHex: this.value,
+        });
+    }
+    toSchema(name) {
+        return new asn1js.BitString({ name });
+    }
+    toNumber() {
+        let res = "";
+        const uintArray = new Uint8Array(this.value);
+        for (const octet of uintArray) {
+            res += octet.toString(2).padStart(8, "0");
+        }
+        res = res.split("").reverse().join("");
+        if (this.unusedBits) {
+            res = res.slice(this.unusedBits).padStart(this.unusedBits, "0");
+        }
+        return parseInt(res, 2);
+    }
+    fromNumber(value) {
+        let bits = value.toString(2);
+        const octetSize = (bits.length + 7) >> 3;
+        this.unusedBits = (octetSize << 3) - bits.length;
+        const octets = new Uint8Array(octetSize);
+        bits = bits
+            .padStart(octetSize << 3, "0")
+            .split("")
+            .reverse()
+            .join("");
+        let index = 0;
+        while (index < octetSize) {
+            octets[index] = parseInt(bits.slice(index << 3, (index << 3) + 8), 2);
+            index++;
+        }
+        this.value = octets.buffer;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/types/octet_string.js
+
+
+class OctetString {
+    buffer;
+    get byteLength() {
+        return this.buffer.byteLength;
+    }
+    get byteOffset() {
+        return 0;
+    }
+    constructor(param) {
+        if (typeof param === "number") {
+            this.buffer = new ArrayBuffer(param);
+        }
+        else {
+            if (buffer_source_isBufferSource(param)) {
+                this.buffer = buffer_source_toArrayBuffer(param);
+            }
+            else if (Array.isArray(param)) {
+                this.buffer = new Uint8Array(param).buffer;
+            }
+            else {
+                this.buffer = new ArrayBuffer(0);
+            }
+        }
+    }
+    fromASN(asn) {
+        if (!(asn instanceof build.OctetString)) {
+            throw new TypeError("Argument 'asn' is not instance of ASN.1 OctetString");
+        }
+        this.buffer = buffer_source_toArrayBuffer(asn.valueBlock.valueHex);
+        return this;
+    }
+    toASN() {
+        return new build.OctetString({ valueHex: this.buffer });
+    }
+    toSchema(name) {
+        return new build.OctetString({ name });
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/types/index.js
+
+
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/converters.js
+
+
+
+
+const AsnAnyConverter = {
+    fromASN: (value) => (value instanceof build.Null ? null : buffer_source_toArrayBuffer(value.valueBeforeDecodeView)),
+    toASN: (value) => {
+        if (value === null) {
+            return new build.Null();
+        }
+        const schema = build.fromBER(value);
+        if (schema.result.error) {
+            throw new Error(schema.result.error);
+        }
+        return schema.result;
+    },
+};
+const AsnIntegerConverter = {
+    fromASN: (value) => value.valueBlock.valueHexView.byteLength >= 4
+        ? value.valueBlock.toString()
+        : value.valueBlock.valueDec,
+    toASN: (value) => new build.Integer({ value: +value }),
+};
+const AsnEnumeratedConverter = {
+    fromASN: (value) => value.valueBlock.valueDec,
+    toASN: (value) => new build.Enumerated({ value }),
+};
+const AsnIntegerArrayBufferConverter = {
+    fromASN: (value) => buffer_source_toArrayBuffer(value.valueBlock.valueHexView),
+    toASN: (value) => new build.Integer({ valueHex: value }),
+};
+const AsnIntegerBigIntConverter = {
+    fromASN: (value) => value.toBigInt(),
+    toASN: (value) => build.Integer.fromBigInt(value),
+};
+const AsnBitStringConverter = {
+    fromASN: (value) => buffer_source_toArrayBuffer(value.valueBlock.valueHexView),
+    toASN: (value) => new build.BitString({ valueHex: value }),
+};
+const AsnObjectIdentifierConverter = {
+    fromASN: (value) => value.valueBlock.toString(),
+    toASN: (value) => new build.ObjectIdentifier({ value }),
+};
+const AsnRelativeObjectIdentifierConverter = {
+    fromASN: (value) => value.valueBlock.toString(),
+    toASN: (value) => new build.RelativeObjectIdentifier({ value }),
+};
+const AsnBooleanConverter = {
+    fromASN: (value) => value.valueBlock.value,
+    toASN: (value) => new build.Boolean({ value }),
+};
+const AsnOctetStringConverter = {
+    fromASN: (value) => buffer_source_toArrayBuffer(value.valueBlock.valueHexView),
+    toASN: (value) => new build.OctetString({ valueHex: value }),
+};
+const AsnConstructedOctetStringConverter = {
+    fromASN: (value) => new OctetString(value.getValue()),
+    toASN: (value) => value.toASN(),
+};
+function createStringConverter(Asn1Type) {
+    return {
+        fromASN: (value) => value.valueBlock.value,
+        toASN: (value) => new Asn1Type({ value }),
+    };
+}
+const AsnUtf8StringConverter = createStringConverter(build.Utf8String);
+const AsnBmpStringConverter = createStringConverter(build.BmpString);
+const AsnUniversalStringConverter = createStringConverter(build.UniversalString);
+const AsnNumericStringConverter = createStringConverter(build.NumericString);
+const AsnPrintableStringConverter = createStringConverter(build.PrintableString);
+const AsnTeletexStringConverter = createStringConverter(build.TeletexString);
+const AsnVideotexStringConverter = createStringConverter(build.VideotexString);
+const AsnIA5StringConverter = createStringConverter(build.IA5String);
+const AsnGraphicStringConverter = createStringConverter(build.GraphicString);
+const AsnVisibleStringConverter = createStringConverter(build.VisibleString);
+const AsnGeneralStringConverter = createStringConverter(build.GeneralString);
+const AsnCharacterStringConverter = createStringConverter(build.CharacterString);
+const AsnUTCTimeConverter = {
+    fromASN: (value) => value.toDate(),
+    toASN: (value) => new build.UTCTime({ valueDate: value }),
+};
+const AsnGeneralizedTimeConverter = {
+    fromASN: (value) => value.toDate(),
+    toASN: (value) => new build.GeneralizedTime({ valueDate: value }),
+};
+const AsnNullConverter = {
+    fromASN: () => null,
+    toASN: () => {
+        return new build.Null();
+    },
+};
+function converters_defaultConverter(type) {
+    switch (type) {
+        case enums_AsnPropTypes.Any:
+            return AsnAnyConverter;
+        case enums_AsnPropTypes.BitString:
+            return AsnBitStringConverter;
+        case enums_AsnPropTypes.BmpString:
+            return AsnBmpStringConverter;
+        case enums_AsnPropTypes.Boolean:
+            return AsnBooleanConverter;
+        case enums_AsnPropTypes.CharacterString:
+            return AsnCharacterStringConverter;
+        case enums_AsnPropTypes.Enumerated:
+            return AsnEnumeratedConverter;
+        case enums_AsnPropTypes.GeneralString:
+            return AsnGeneralStringConverter;
+        case enums_AsnPropTypes.GeneralizedTime:
+            return AsnGeneralizedTimeConverter;
+        case enums_AsnPropTypes.GraphicString:
+            return AsnGraphicStringConverter;
+        case enums_AsnPropTypes.IA5String:
+            return AsnIA5StringConverter;
+        case enums_AsnPropTypes.Integer:
+            return AsnIntegerConverter;
+        case enums_AsnPropTypes.Null:
+            return AsnNullConverter;
+        case enums_AsnPropTypes.NumericString:
+            return AsnNumericStringConverter;
+        case enums_AsnPropTypes.ObjectIdentifier:
+            return AsnObjectIdentifierConverter;
+        case enums_AsnPropTypes.RelativeObjectIdentifier:
+            return AsnRelativeObjectIdentifierConverter;
+        case enums_AsnPropTypes.OctetString:
+            return AsnOctetStringConverter;
+        case enums_AsnPropTypes.PrintableString:
+            return AsnPrintableStringConverter;
+        case enums_AsnPropTypes.TeletexString:
+            return AsnTeletexStringConverter;
+        case enums_AsnPropTypes.UTCTime:
+            return AsnUTCTimeConverter;
+        case enums_AsnPropTypes.UniversalString:
+            return AsnUniversalStringConverter;
+        case enums_AsnPropTypes.Utf8String:
+            return AsnUtf8StringConverter;
+        case enums_AsnPropTypes.VideotexString:
+            return AsnVideotexStringConverter;
+        case enums_AsnPropTypes.VisibleString:
+            return AsnVisibleStringConverter;
+        default:
+            return null;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/helper.js
+function helper_isConvertible(target) {
+    if (typeof target === "function" && target.prototype) {
+        if (target.prototype.toASN && target.prototype.fromASN) {
+            return true;
+        }
+        else {
+            return helper_isConvertible(target.prototype);
+        }
+    }
+    else {
+        return !!(target && typeof target === "object" && "toASN" in target && "fromASN" in target);
+    }
+}
+function isTypeOfArray(target) {
+    if (target) {
+        const proto = Object.getPrototypeOf(target);
+        if (proto?.prototype?.constructor === Array) {
+            return true;
+        }
+        return isTypeOfArray(proto);
+    }
+    return false;
+}
+function helper_isArrayEqual(bytes1, bytes2) {
+    if (!(bytes1 && bytes2)) {
+        return false;
+    }
+    if (bytes1.byteLength !== bytes2.byteLength) {
+        return false;
+    }
+    const b1 = new Uint8Array(bytes1);
+    const b2 = new Uint8Array(bytes2);
+    for (let i = 0; i < bytes1.byteLength; i++) {
+        if (b1[i] !== b2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/schema.js
+
+
+
+class AsnSchemaStorage {
+    items = new WeakMap();
+    has(target) {
+        return this.items.has(target);
+    }
+    get(target, checkSchema = false) {
+        const schema = this.items.get(target);
+        if (!schema) {
+            throw new Error(`Cannot get schema for '${target.prototype.constructor.name}' target`);
+        }
+        if (checkSchema && !schema.schema) {
+            throw new Error(`Schema '${target.prototype.constructor.name}' doesn't contain ASN.1 schema. Call 'AsnSchemaStorage.cache'.`);
+        }
+        return schema;
+    }
+    cache(target) {
+        const schema = this.get(target);
+        if (!schema.schema) {
+            schema.schema = this.create(target, true);
+        }
+    }
+    createDefault(target) {
+        const schema = {
+            type: enums_AsnTypeTypes.Sequence,
+            items: {},
+        };
+        const parentSchema = this.findParentSchema(target);
+        if (parentSchema) {
+            Object.assign(schema, parentSchema);
+            schema.items = Object.assign({}, schema.items, parentSchema.items);
+        }
+        return schema;
+    }
+    create(target, useNames) {
+        const schema = this.items.get(target) || this.createDefault(target);
+        const asn1Value = [];
+        for (const key in schema.items) {
+            const item = schema.items[key];
+            const name = useNames ? key : "";
+            let asn1Item;
+            if (typeof item.type === "number") {
+                const Asn1TypeName = enums_AsnPropTypes[item.type];
+                const Asn1Type = build_namespaceObject[Asn1TypeName];
+                if (!Asn1Type) {
+                    throw new Error(`Cannot get ASN1 class by name '${Asn1TypeName}'`);
+                }
+                asn1Item = new Asn1Type({ name });
+            }
+            else if (helper_isConvertible(item.type)) {
+                const instance = new item.type();
+                asn1Item = instance.toSchema(name);
+            }
+            else if (item.optional) {
+                const itemSchema = this.get(item.type);
+                if (itemSchema.type === enums_AsnTypeTypes.Choice) {
+                    asn1Item = new build.Any({ name });
+                }
+                else {
+                    asn1Item = this.create(item.type, false);
+                    asn1Item.name = name;
+                }
+            }
+            else {
+                asn1Item = new build.Any({ name });
+            }
+            const optional = !!item.optional || item.defaultValue !== undefined;
+            if (item.repeated) {
+                asn1Item.name = "";
+                const Container = item.repeated === "set" ? build.Set : build.Sequence;
+                asn1Item = new Container({
+                    name: "",
+                    value: [
+                        new build.Repeated({
+                            name,
+                            value: asn1Item,
+                        }),
+                    ],
+                });
+            }
+            if (item.context !== null && item.context !== undefined) {
+                if (item.implicit) {
+                    if (typeof item.type === "number" || helper_isConvertible(item.type)) {
+                        const Container = item.repeated ? build.Constructed : build.Primitive;
+                        asn1Value.push(new Container({
+                            name,
+                            optional,
+                            idBlock: {
+                                tagClass: 3,
+                                tagNumber: item.context,
+                            },
+                        }));
+                    }
+                    else {
+                        this.cache(item.type);
+                        const isRepeated = !!item.repeated;
+                        let value = !isRepeated ? this.get(item.type, true).schema : asn1Item;
+                        value = "valueBlock" in value ? value.valueBlock.value : value.value;
+                        asn1Value.push(new build.Constructed({
+                            name: !isRepeated ? name : "",
+                            optional,
+                            idBlock: {
+                                tagClass: 3,
+                                tagNumber: item.context,
+                            },
+                            value: value,
+                        }));
+                    }
+                }
+                else {
+                    asn1Value.push(new build.Constructed({
+                        optional,
+                        idBlock: {
+                            tagClass: 3,
+                            tagNumber: item.context,
+                        },
+                        value: [asn1Item],
+                    }));
+                }
+            }
+            else {
+                asn1Item.optional = optional;
+                asn1Value.push(asn1Item);
+            }
+        }
+        switch (schema.type) {
+            case enums_AsnTypeTypes.Sequence:
+                return new build.Sequence({
+                    value: asn1Value,
+                    name: "",
+                });
+            case enums_AsnTypeTypes.Set:
+                return new build.Set({
+                    value: asn1Value,
+                    name: "",
+                });
+            case enums_AsnTypeTypes.Choice:
+                return new build.Choice({
+                    value: asn1Value,
+                    name: "",
+                });
+            default:
+                throw new Error("Unsupported ASN1 type in use");
+        }
+    }
+    set(target, schema) {
+        this.items.set(target, schema);
+        return this;
+    }
+    findParentSchema(target) {
+        const parent = Object.getPrototypeOf(target);
+        if (parent) {
+            const schema = this.items.get(parent);
+            return schema || this.findParentSchema(parent);
+        }
+        return null;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/storage.js
+
+const storage_schemaStorage = new AsnSchemaStorage();
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/decorators.js
+
+
+
+const AsnType = (options) => (target) => {
+    let schema;
+    if (!storage_schemaStorage.has(target)) {
+        schema = storage_schemaStorage.createDefault(target);
+        storage_schemaStorage.set(target, schema);
+    }
+    else {
+        schema = storage_schemaStorage.get(target);
+    }
+    Object.assign(schema, options);
+};
+const AsnChoiceType = () => AsnType({ type: AsnTypeTypes.Choice });
+const AsnSetType = (options) => AsnType({
+    type: AsnTypeTypes.Set,
+    ...options,
+});
+const AsnSequenceType = (options) => AsnType({
+    type: AsnTypeTypes.Sequence,
+    ...options,
+});
+const AsnProp = (options) => (target, propertyKey) => {
+    let schema;
+    if (!storage_schemaStorage.has(target.constructor)) {
+        schema = storage_schemaStorage.createDefault(target.constructor);
+        storage_schemaStorage.set(target.constructor, schema);
+    }
+    else {
+        schema = storage_schemaStorage.get(target.constructor);
+    }
+    const copyOptions = Object.assign({}, options);
+    if (typeof copyOptions.type === "number" && !copyOptions.converter) {
+        const defaultConverter = converters_defaultConverter(options.type);
+        if (!defaultConverter) {
+            throw new Error(`Cannot get default converter for property '${propertyKey}' of ${target.constructor.name}`);
+        }
+        copyOptions.converter = defaultConverter;
+    }
+    copyOptions.raw = options.raw;
+    schema.items[propertyKey] = copyOptions;
+};
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/errors/schema_validation.js
+class AsnSchemaValidationError extends Error {
+    schemas = [];
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/parser.js
+
+
+
+
+
+
+
+class parser_AsnParser {
+    static parse(data, target, options) {
+        const asn1Parsed = build.fromBER(buffer_source_toArrayBuffer(data), options?.berOptions);
+        if (asn1Parsed.result.error) {
+            throw new Error(asn1Parsed.result.error);
+        }
+        const res = this.fromASN(asn1Parsed.result, target, options);
+        return res;
+    }
+    static fromASN(asn1Schema, target, options) {
+        try {
+            if (helper_isConvertible(target)) {
+                const value = new target();
+                return value.fromASN(asn1Schema);
+            }
+            const schema = storage_schemaStorage.get(target);
+            storage_schemaStorage.cache(target);
+            let targetSchema = schema.schema;
+            const choiceResult = this.handleChoiceTypes(asn1Schema, schema, target, targetSchema, options);
+            if (choiceResult?.result) {
+                return choiceResult.result;
+            }
+            if (choiceResult?.targetSchema) {
+                targetSchema = choiceResult.targetSchema;
+            }
+            const sequenceResult = this.handleSequenceTypes(asn1Schema, schema, target, targetSchema);
+            const res = new target();
+            if (isTypeOfArray(target)) {
+                return this.handleArrayTypes(asn1Schema, schema, target, options);
+            }
+            this.processSchemaItems(schema, sequenceResult, res, options);
+            return res;
+        }
+        catch (error) {
+            if (error instanceof AsnSchemaValidationError) {
+                error.schemas.push(target.name);
+            }
+            throw error;
+        }
+    }
+    static handleChoiceTypes(asn1Schema, schema, target, targetSchema, options) {
+        if (asn1Schema.constructor === build.Constructed && schema.type === enums_AsnTypeTypes.Choice && asn1Schema.idBlock.tagClass === 3) {
+            for (const key in schema.items) {
+                const schemaItem = schema.items[key];
+                if (schemaItem.context === asn1Schema.idBlock.tagNumber && schemaItem.implicit) {
+                    if (typeof schemaItem.type === "function" && storage_schemaStorage.has(schemaItem.type)) {
+                        const fieldSchema = storage_schemaStorage.get(schemaItem.type);
+                        if (fieldSchema && fieldSchema.type === enums_AsnTypeTypes.Sequence) {
+                            const newSeq = new build.Sequence();
+                            if ("value" in asn1Schema.valueBlock && Array.isArray(asn1Schema.valueBlock.value) && "value" in newSeq.valueBlock) {
+                                newSeq.valueBlock.value = asn1Schema.valueBlock.value;
+                                const fieldValue = this.fromASN(newSeq, schemaItem.type, options);
+                                const res = new target();
+                                res[key] = fieldValue;
+                                return { result: res };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else if (asn1Schema.constructor === build.Constructed && schema.type !== enums_AsnTypeTypes.Choice) {
+            const newTargetSchema = new build.Constructed({
+                idBlock: {
+                    tagClass: 3,
+                    tagNumber: asn1Schema.idBlock.tagNumber,
+                },
+                value: schema.schema.valueBlock.value,
+            });
+            for (const key in schema.items) {
+                delete asn1Schema[key];
+            }
+            return { targetSchema: newTargetSchema };
+        }
+        return null;
+    }
+    static handleSequenceTypes(asn1Schema, schema, target, targetSchema) {
+        if (schema.type === enums_AsnTypeTypes.Sequence) {
+            const asn1ComparedSchema = build.compareSchema({}, asn1Schema, targetSchema);
+            if (!asn1ComparedSchema.verified) {
+                throw new AsnSchemaValidationError(`Data does not match to ${target.name} ASN1 schema.${asn1ComparedSchema.result.error ? ` ${asn1ComparedSchema.result.error}` : ""}`);
+            }
+            return asn1ComparedSchema;
+        }
+        else {
+            const asn1ComparedSchema = build.compareSchema({}, asn1Schema, targetSchema);
+            if (!asn1ComparedSchema.verified) {
+                throw new AsnSchemaValidationError(`Data does not match to ${target.name} ASN1 schema.${asn1ComparedSchema.result.error ? ` ${asn1ComparedSchema.result.error}` : ""}`);
+            }
+            return asn1ComparedSchema;
+        }
+    }
+    static processRepeatedField(asn1Elements, asn1Index, schemaItem) {
+        let elementsToProcess = asn1Elements.slice(asn1Index);
+        if (elementsToProcess.length === 1 && elementsToProcess[0].constructor.name === "Sequence") {
+            const seq = elementsToProcess[0];
+            if (seq.valueBlock && seq.valueBlock.value && Array.isArray(seq.valueBlock.value)) {
+                elementsToProcess = seq.valueBlock.value;
+            }
+        }
+        if (typeof schemaItem.type === "number") {
+            const converter = converters_defaultConverter(schemaItem.type);
+            if (!converter)
+                throw new Error(`No converter for ASN.1 type ${schemaItem.type}`);
+            return elementsToProcess
+                .filter((el) => el && el.valueBlock)
+                .map((el) => {
+                try {
+                    return converter.fromASN(el);
+                }
+                catch {
+                    return undefined;
+                }
+            })
+                .filter((v) => v !== undefined);
+        }
+        else {
+            return elementsToProcess
+                .filter((el) => el && el.valueBlock)
+                .map((el) => {
+                try {
+                    return this.fromASN(el, schemaItem.type);
+                }
+                catch {
+                    return undefined;
+                }
+            })
+                .filter((v) => v !== undefined);
+        }
+    }
+    static processPrimitiveField(asn1Element, schemaItem) {
+        const converter = converters_defaultConverter(schemaItem.type);
+        if (!converter)
+            throw new Error(`No converter for ASN.1 type ${schemaItem.type}`);
+        return converter.fromASN(asn1Element);
+    }
+    static isOptionalChoiceField(schemaItem) {
+        return (schemaItem.optional &&
+            typeof schemaItem.type === "function" &&
+            storage_schemaStorage.has(schemaItem.type) &&
+            storage_schemaStorage.get(schemaItem.type).type === enums_AsnTypeTypes.Choice);
+    }
+    static processOptionalChoiceField(asn1Element, schemaItem) {
+        try {
+            const value = this.fromASN(asn1Element, schemaItem.type);
+            return {
+                processed: true,
+                value,
+            };
+        }
+        catch (err) {
+            if (err instanceof AsnSchemaValidationError && /Wrong values for Choice type/.test(err.message)) {
+                return { processed: false };
+            }
+            throw err;
+        }
+    }
+    static handleArrayTypes(asn1Schema, schema, target, options) {
+        if (!("value" in asn1Schema.valueBlock && Array.isArray(asn1Schema.valueBlock.value))) {
+            throw new Error("Cannot get items from the ASN.1 parsed value. ASN.1 object is not constructed.");
+        }
+        const itemType = schema.itemType;
+        if (typeof itemType === "number") {
+            const converter = converters_defaultConverter(itemType);
+            if (!converter) {
+                throw new Error(`Cannot get default converter for array item of ${target.name} ASN1 schema`);
+            }
+            return target.from(asn1Schema.valueBlock.value, (element) => converter.fromASN(element));
+        }
+        else {
+            return target.from(asn1Schema.valueBlock.value, (element) => this.fromASN(element, itemType, options));
+        }
+    }
+    static processSchemaItems(schema, asn1ComparedSchema, res, options) {
+        for (const key in schema.items) {
+            const asn1SchemaValue = asn1ComparedSchema.result[key];
+            if (!asn1SchemaValue) {
+                continue;
+            }
+            const schemaItem = schema.items[key];
+            const schemaItemType = schemaItem.type;
+            let parsedValue;
+            if (typeof schemaItemType === "number" || helper_isConvertible(schemaItemType)) {
+                parsedValue = this.processPrimitiveSchemaItem(asn1SchemaValue, schemaItem, schemaItemType, options);
+            }
+            else {
+                parsedValue = this.processComplexSchemaItem(asn1SchemaValue, schemaItem, schemaItemType, options);
+            }
+            if (parsedValue && typeof parsedValue === "object" && "value" in parsedValue && "raw" in parsedValue) {
+                res[key] = parsedValue.value;
+                res[`${key}Raw`] = parsedValue.raw;
+            }
+            else {
+                res[key] = parsedValue;
+            }
+        }
+    }
+    static processPrimitiveSchemaItem(asn1SchemaValue, schemaItem, schemaItemType, options) {
+        const converter = schemaItem.converter ?? (helper_isConvertible(schemaItemType) ? new schemaItemType() : null);
+        if (!converter) {
+            throw new Error("Converter is empty");
+        }
+        if (schemaItem.repeated) {
+            return this.processRepeatedPrimitiveItem(asn1SchemaValue, schemaItem, converter, options);
+        }
+        else {
+            return this.processSinglePrimitiveItem(asn1SchemaValue, schemaItem, schemaItemType, converter, options);
+        }
+    }
+    static processRepeatedPrimitiveItem(asn1SchemaValue, schemaItem, converter, options) {
+        if (schemaItem.implicit) {
+            const Container = schemaItem.repeated === "sequence" ? build.Sequence : build.Set;
+            const newItem = new Container();
+            newItem.valueBlock = asn1SchemaValue.valueBlock;
+            const newItemAsn = build.fromBER(newItem.toBER(false), options?.berOptions);
+            if (newItemAsn.offset === -1) {
+                throw new Error(`Cannot parse the child item. ${newItemAsn.result.error}`);
+            }
+            if (!("value" in newItemAsn.result.valueBlock && Array.isArray(newItemAsn.result.valueBlock.value))) {
+                throw new Error("Cannot get items from the ASN.1 parsed value. ASN.1 object is not constructed.");
+            }
+            const value = newItemAsn.result.valueBlock.value;
+            return Array.from(value, (element) => converter.fromASN(element));
+        }
+        else {
+            return Array.from(asn1SchemaValue, (element) => converter.fromASN(element));
+        }
+    }
+    static processSinglePrimitiveItem(asn1SchemaValue, schemaItem, schemaItemType, converter, options) {
+        let value = asn1SchemaValue;
+        if (schemaItem.implicit) {
+            let newItem;
+            if (helper_isConvertible(schemaItemType)) {
+                newItem = new schemaItemType().toSchema("");
+            }
+            else {
+                const Asn1TypeName = enums_AsnPropTypes[schemaItemType];
+                const Asn1Type = build_namespaceObject[Asn1TypeName];
+                if (!Asn1Type) {
+                    throw new Error(`Cannot get '${Asn1TypeName}' class from asn1js module`);
+                }
+                newItem = new Asn1Type();
+            }
+            newItem.valueBlock = value.valueBlock;
+            value = build.fromBER(newItem.toBER(false), options?.berOptions).result;
+        }
+        return converter.fromASN(value);
+    }
+    static processComplexSchemaItem(asn1SchemaValue, schemaItem, schemaItemType, options) {
+        if (schemaItem.repeated) {
+            if (!Array.isArray(asn1SchemaValue)) {
+                throw new Error("Cannot get list of items from the ASN.1 parsed value. ASN.1 value should be iterable.");
+            }
+            return Array.from(asn1SchemaValue, (element) => this.fromASN(element, schemaItemType, options));
+        }
+        else {
+            const valueToProcess = this.handleImplicitTagging(asn1SchemaValue, schemaItem, schemaItemType);
+            if (this.isOptionalChoiceField(schemaItem)) {
+                try {
+                    return this.fromASN(valueToProcess, schemaItemType, options);
+                }
+                catch (err) {
+                    if (err instanceof AsnSchemaValidationError && /Wrong values for Choice type/.test(err.message)) {
+                        return undefined;
+                    }
+                    throw err;
+                }
+            }
+            else {
+                const parsedValue = this.fromASN(valueToProcess, schemaItemType, options);
+                if (schemaItem.raw) {
+                    return {
+                        value: parsedValue,
+                        raw: asn1SchemaValue.valueBeforeDecodeView,
+                    };
+                }
+                return parsedValue;
+            }
+        }
+    }
+    static handleImplicitTagging(asn1SchemaValue, schemaItem, schemaItemType) {
+        if (schemaItem.implicit && typeof schemaItem.context === "number") {
+            const schema = storage_schemaStorage.get(schemaItemType);
+            if (schema.type === enums_AsnTypeTypes.Sequence) {
+                const newSeq = new build.Sequence();
+                if ("value" in asn1SchemaValue.valueBlock && Array.isArray(asn1SchemaValue.valueBlock.value) && "value" in newSeq.valueBlock) {
+                    newSeq.valueBlock.value = asn1SchemaValue.valueBlock.value;
+                    return newSeq;
+                }
+            }
+            else if (schema.type === enums_AsnTypeTypes.Set) {
+                const newSet = new build.Set();
+                if ("value" in asn1SchemaValue.valueBlock && Array.isArray(asn1SchemaValue.valueBlock.value) && "value" in newSet.valueBlock) {
+                    newSet.valueBlock.value = asn1SchemaValue.valueBlock.value;
+                    return newSet;
+                }
+            }
+        }
+        return asn1SchemaValue;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/serializer.js
+
+
+
+
+
+
+class serializer_AsnSerializer {
+    static serialize(obj) {
+        if (obj instanceof asn1js.BaseBlock) {
+            return obj.toBER(false);
+        }
+        return this.toASN(obj).toBER(false);
+    }
+    static toASN(obj) {
+        if (obj && typeof obj === "object" && isConvertible(obj)) {
+            return obj.toASN();
+        }
+        if (!(obj && typeof obj === "object")) {
+            throw new TypeError("Parameter 1 should be type of Object.");
+        }
+        const target = obj.constructor;
+        const schema = schemaStorage.get(target);
+        schemaStorage.cache(target);
+        let asn1Value = [];
+        if (schema.itemType) {
+            if (!Array.isArray(obj)) {
+                throw new TypeError("Parameter 1 should be type of Array.");
+            }
+            if (typeof schema.itemType === "number") {
+                const converter = converters.defaultConverter(schema.itemType);
+                if (!converter) {
+                    throw new Error(`Cannot get default converter for array item of ${target.name} ASN1 schema`);
+                }
+                asn1Value = obj.map((o) => converter.toASN(o));
+            }
+            else {
+                asn1Value = obj.map((o) => this.toAsnItem({ type: schema.itemType }, "[]", target, o));
+            }
+        }
+        else {
+            for (const key in schema.items) {
+                const schemaItem = schema.items[key];
+                const objProp = obj[key];
+                if (objProp === undefined ||
+                    schemaItem.defaultValue === objProp ||
+                    (typeof schemaItem.defaultValue === "object" && typeof objProp === "object" && isArrayEqual(this.serialize(schemaItem.defaultValue), this.serialize(objProp)))) {
+                    continue;
+                }
+                const asn1Item = serializer_AsnSerializer.toAsnItem(schemaItem, key, target, objProp);
+                if (typeof schemaItem.context === "number") {
+                    if (schemaItem.implicit) {
+                        if (!schemaItem.repeated && (typeof schemaItem.type === "number" || isConvertible(schemaItem.type))) {
+                            const value = {};
+                            value.valueHex = asn1Item instanceof asn1js.Null ? toArrayBuffer(asn1Item.valueBeforeDecodeView) : asn1Item.valueBlock.toBER();
+                            asn1Value.push(new asn1js.Primitive({
+                                optional: schemaItem.optional,
+                                idBlock: {
+                                    tagClass: 3,
+                                    tagNumber: schemaItem.context,
+                                },
+                                ...value,
+                            }));
+                        }
+                        else {
+                            asn1Value.push(new asn1js.Constructed({
+                                optional: schemaItem.optional,
+                                idBlock: {
+                                    tagClass: 3,
+                                    tagNumber: schemaItem.context,
+                                },
+                                value: asn1Item.valueBlock.value,
+                            }));
+                        }
+                    }
+                    else {
+                        asn1Value.push(new asn1js.Constructed({
+                            optional: schemaItem.optional,
+                            idBlock: {
+                                tagClass: 3,
+                                tagNumber: schemaItem.context,
+                            },
+                            value: [asn1Item],
+                        }));
+                    }
+                }
+                else if (schemaItem.repeated) {
+                    asn1Value = asn1Value.concat(asn1Item);
+                }
+                else {
+                    asn1Value.push(asn1Item);
+                }
+            }
+        }
+        let asnSchema;
+        switch (schema.type) {
+            case AsnTypeTypes.Sequence:
+                asnSchema = new asn1js.Sequence({ value: asn1Value });
+                break;
+            case AsnTypeTypes.Set:
+                asnSchema = new asn1js.Set({ value: asn1Value });
+                break;
+            case AsnTypeTypes.Choice:
+                if (!asn1Value[0]) {
+                    throw new Error(`Schema '${target.name}' has wrong data. Choice cannot be empty.`);
+                }
+                asnSchema = asn1Value[0];
+                break;
+        }
+        return asnSchema;
+    }
+    static toAsnItem(schemaItem, key, target, objProp) {
+        let asn1Item;
+        if (typeof schemaItem.type === "number") {
+            const converter = schemaItem.converter;
+            if (!converter) {
+                throw new Error(`Property '${key}' doesn't have converter for type ${AsnPropTypes[schemaItem.type]} in schema '${target.name}'`);
+            }
+            if (schemaItem.repeated) {
+                if (!Array.isArray(objProp)) {
+                    throw new TypeError("Parameter 'objProp' should be type of Array.");
+                }
+                const items = Array.from(objProp, (element) => converter.toASN(element));
+                const Container = schemaItem.repeated === "sequence" ? asn1js.Sequence : asn1js.Set;
+                asn1Item = new Container({ value: items });
+            }
+            else {
+                asn1Item = converter.toASN(objProp);
+            }
+        }
+        else {
+            if (schemaItem.repeated) {
+                if (!Array.isArray(objProp)) {
+                    throw new TypeError("Parameter 'objProp' should be type of Array.");
+                }
+                const items = Array.from(objProp, (element) => this.toASN(element));
+                const Container = schemaItem.repeated === "sequence" ? asn1js.Sequence : asn1js.Set;
+                asn1Item = new Container({ value: items });
+            }
+            else {
+                asn1Item = this.toASN(objProp);
+            }
+        }
+        return asn1Item;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/objects.js
+class AsnArray extends Array {
+    constructor(items = []) {
+        if (typeof items === "number") {
+            super(items);
+        }
+        else {
+            super();
+            for (const item of items) {
+                this.push(item);
+            }
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/convert.js
+
+
+
+
+class AsnConvert {
+    static serialize(obj) {
+        return AsnSerializer.serialize(obj);
+    }
+    static parse(data, target, options) {
+        return AsnParser.parse(data, target, options);
+    }
+    static toString(data, options) {
+        const buf = isBufferSource(data) ? toArrayBuffer(data) : AsnConvert.serialize(data);
+        const asn = asn1js.fromBER(buf, options?.berOptions);
+        if (asn.offset === -1) {
+            throw new Error(`Cannot decode ASN.1 data. ${asn.result.error}`);
+        }
+        return asn.result.toString();
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@peculiar+asn1-schema@2.9.4/node_modules/@peculiar/asn1-schema/build/es2015/index.js
+
+
+
+
+
+
+
+
+
+
+
+/***/ })
+
+};