{"version":3,"sources":["jsdelivr-header.js","/npm/@lapo/asn1js@2.1.3/asn1.js"],"names":[],"mappings":"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","file":"/npm/@lapo/asn1js@2.1.3/asn1.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@lapo/asn1js@2.1.3/asn1.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","// ASN.1 JavaScript decoder\n// Copyright (c) 2008 Lapo Luchini <lapo@lapo.it>\n\n// Permission to use, copy, modify, and/or distribute this software for any\n// purpose with or without fee is hereby granted, provided that the above\n// copyright notice and this permission notice appear in all copies.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\nimport { oids } from './oids.js';\n\nconst\n    ellipsis = '\\u2026',\n    reTimeS =     /^(\\d\\d)(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])([01]\\d|2[0-3])(?:([0-5]\\d)(?:([0-5]\\d)(?:[.,](\\d{1,}))?)?)?(Z|(-(?:0\\d|1[0-2])|[+](?:0\\d|1[0-4]))([0-5]\\d)?)?$/,\n    reTimeL = /^(\\d\\d\\d\\d)(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])([01]\\d|2[0-3])(?:([0-5]\\d)(?:([0-5]\\d)(?:[.,](\\d{1,}))?)?)?(Z|(-(?:0\\d|1[0-2])|[+](?:0\\d|1[0-4]))([0-5]\\d)?)?$/,\n    hexDigits = '0123456789ABCDEF',\n    b64Std = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',\n    b64URL = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',\n    tableT61 = [\n        ['', ''],\n        ['AEIOUaeiou', 'ÀÈÌÒÙàèìòù'], // Grave\n        ['ACEILNORSUYZacegilnorsuyz', 'ÁĆÉÍĹŃÓŔŚÚÝŹáćéģíĺńóŕśúýź'], // Acute\n        ['ACEGHIJOSUWYaceghijosuwy', 'ÂĈÊĜĤÎĴÔŜÛŴŶâĉêĝĥîĵôŝûŵŷ'], // Circumflex\n        ['AINOUainou', 'ÃĨÑÕŨãĩñõũ'], // Tilde\n        ['AEIOUaeiou', 'ĀĒĪŌŪāēīōū'], // Macron\n        ['AGUagu', 'ĂĞŬăğŭ'], // Breve\n        ['CEGIZcegz', 'ĊĖĠİŻċėġż'], // Dot\n        ['AEIOUYaeiouy', 'ÄËÏÖÜŸäëïöüÿ'], // Umlaut or diæresis\n        ['', ''],\n        ['AUau', 'ÅŮåů'], // Ring\n        ['CGKLNRSTcklnrst', 'ÇĢĶĻŅŖŞŢçķļņŗşţ'], // Cedilla\n        ['', ''],\n        ['OUou', 'ŐŰőű'], // Double Acute\n        ['AEIUaeiu', 'ĄĘĮŲąęįų'], // Ogonek\n        ['CDELNRSTZcdelnrstz', 'ČĎĚĽŇŘŠŤŽčďěľňřšťž'], // Caron\n    ];\n\n/**\n * Truncates a string to a specified length and adds an ellipsis if needed.\n * @param {string} str - The input string to truncate\n * @param {number} len - The maximum length of the string\n * @returns {string} The truncated string\n */\nfunction stringCut(str, len) {\n    if (str.length > len)\n        str = str.substring(0, len) + ellipsis;\n    return str;\n}\n\n/**\n * Checks if a string contains only printable characters (ASCII 32-126, plus tab, newline, carriage return)\n * @param {string} s - The string to check\n * @throws {Error} If an unprintable character is found\n */\nfunction checkPrintable(s) {\n    let i, v;\n    for (i = 0; i < s.length; ++i) {\n        v = s.charCodeAt(i);\n        if (v < 32 && v != 9 && v != 10 && v != 13) // [\\t\\r\\n] are (kinda) printable\n            throw new Error('Unprintable character at index ' + i + ' (code ' + s.str.charCodeAt(i) + ')');\n    }\n}\n\n/**\n * Class to manage a stream of bytes, with a zero-copy approach.\n * It uses an existing array or binary string and advances a position index.\n */\nexport class Stream {\n\n    /**\n     * Creates a new Stream object.\n     * @param {Stream|array|string} enc data (will not be copied)\n     * @param {?number} pos starting position (mandatory when `enc` is not a Stream)\n     */\n    constructor(enc, pos) {\n        if (enc instanceof Stream) {\n            this.enc = enc.enc;\n            this.pos = enc.pos;\n        } else {\n            this.enc = enc;\n            this.pos = pos;\n        }\n        if (typeof this.pos != 'number')\n            throw new Error('\"pos\" must be a numeric value');\n        // Set up the raw byte access function based on the type of data\n        if (typeof this.enc == 'string')\n            this.getRaw = pos => this.enc.charCodeAt(pos);\n        else if (typeof this.enc[0] == 'number')\n            this.getRaw = pos => this.enc[pos];\n        else\n            throw new Error('\"enc\" must be a numeric array or a string');\n    }\n\n    /**\n     * Get the byte at current position (and increment it) or at a specified position (and avoid moving current position).\n     * @param {?number} pos read position if specified, else current position (and increment it)\n     * @returns {number} The byte value at the specified position\n     */\n    get(pos) {\n        if (pos === undefined)\n            pos = this.pos++;\n        if (pos >= this.enc.length)\n            throw new Error('Requesting byte offset ' + pos + ' on a stream of length ' + this.enc.length);\n        return this.getRaw(pos);\n    }\n\n    /**\n     * Convert a single byte to a hexadecimal string (of length 2).\n     * @param {number} b - The byte to convert\n     * @returns {string} Hexadecimal representation of the byte\n     */\n    static hexByte(b) {\n        return hexDigits.charAt((b >> 4) & 0xF) + hexDigits.charAt(b & 0xF);\n    }\n\n    /**\n     * Hexadecimal dump of a specified region of the stream.\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {string} type - 'raw', 'byte' or 'dump' (default)\n     * @returns {string} Hexadecimal representation of the data\n     */\n    hexDump(start, end, type = 'dump') {\n        let s = '';\n        for (let i = start; i < end; ++i) {\n            if (type == 'byte' && i > start)\n                s += ' ';\n            s += Stream.hexByte(this.get(i));\n            if (type == 'dump')\n                switch (i & 0xF) {\n                case 0x7: s += '  '; break;\n                case 0xF: s += '\\n'; break;\n                default:  s += ' ';\n                }\n        }\n        return s;\n    }\n\n    /**\n     * Base64url dump of a specified region of the stream (according to RFC 4648 section 5).\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {string} type - 'url' (default, section 5 without padding) or 'std' (section 4 with padding)\n     * @returns {string} Base64 encoded representation of the data\n     */\n    b64Dump(start, end, type = 'url') {\n        const b64 = type === 'url' ? b64URL : b64Std,\n            extra = (end - start) % 3;\n        let s = '',\n            i, c;\n        for (i = start; i + 2 < end; i += 3) {\n            c = this.get(i) << 16 | this.get(i + 1) << 8 | this.get(i + 2);\n            s += b64.charAt(c >> 18 & 0x3F);\n            s += b64.charAt(c >> 12 & 0x3F);\n            s += b64.charAt(c >>  6 & 0x3F);\n            s += b64.charAt(c       & 0x3F);\n        }\n        if (extra > 0) {\n            c = this.get(i) << 16;\n            if (extra > 1) c |= this.get(i + 1) << 8;\n            s += b64.charAt(c >> 18 & 0x3F);\n            s += b64.charAt(c >> 12 & 0x3F);\n            if (extra == 2) s += b64.charAt(c >> 6 & 0x3F);\n            if (b64 === b64Std) s += '==='.slice(0, 3 - extra);\n        }\n        return s;\n    }\n\n    /**\n     * Check if a region of the stream contains only ASCII characters (32-176)\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @returns {boolean} True if all characters are ASCII, false otherwise\n     */\n    isASCII(start, end) {\n        for (let i = start; i < end; ++i) {\n            let c = this.get(i);\n            if (c < 32 || c > 176)\n                return false;\n        }\n        return true;\n    }\n\n    /**\n     * Parse a region of the stream as an ISO string\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {number} maxLength - maximum length of the output string\n     * @returns {Object} Object with size and str properties\n     */\n    parseStringISO(start, end, maxLength) {\n        let s = '';\n        for (let i = start; i < end; ++i)\n            s += String.fromCharCode(this.get(i));\n        return { size: s.length, str: stringCut(s, maxLength) };\n    }\n\n    /**\n     * Parse a region of the stream as a T.61 string\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {number} maxLength - maximum length of the output string\n     * @returns {Object} Object with size and str properties\n     */\n    parseStringT61(start, end, maxLength) {\n        // warning: this code is not very well tested so far\n        function merge(c, d) {\n            const t = tableT61[c - 0xC0];\n            const i = t[0].indexOf(String.fromCharCode(d));\n            return (i < 0) ? '\\0' : t[1].charAt(i);\n        }\n        let s = '', c;\n        for (let i = start; i < end; ++i) {\n            c = this.get(i);\n            if (c >= 0xA4 && c <= 0xBF)\n                s += '$¥#§¤\\0\\0«\\0\\0\\0\\0°±²³×µ¶·÷\\0\\0»¼½¾¿'.charAt(c - 0xA4);\n            else if (c >= 0xE0 && c <= 0xFF)\n                s += 'ΩÆЪĦ\\0IJĿŁØŒºÞŦŊʼnĸæđðħıijŀłøœßþŧŋ\\0'.charAt(c - 0xE0);\n            else if (c >= 0xC0 && c <= 0xCF)\n                s += merge(c, this.get(++i));\n            else // using ISO 8859-1 for characters undefined (or equal) in T.61\n                s += String.fromCharCode(c);\n        }\n        return { size: s.length, str: stringCut(s, maxLength) };\n    }\n\n    /**\n     * Parse a region of the stream as a UTF-8 string\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {number} maxLength - maximum length of the output string\n     * @returns {Object} Object with size and str properties\n     */\n    parseStringUTF(start, end, maxLength) {\n        /**\n         * Helper function to process UTF-8 continuation bytes\n         * @param {number} c - The continuation byte\n         * @returns {number} The extracted data bits\n         */\n        function ex(c) { // must be 10xxxxxx\n            if ((c < 0x80) || (c >= 0xC0))\n                throw new Error('Invalid UTF-8 continuation byte: ' + c);\n            return (c & 0x3F);\n        }\n        /**\n         * Helper function to convert a code point to a surrogate pair\n         * @param {number} cp - The code point to convert\n         * @returns {string} The surrogate pair as a string\n         */\n        function surrogate(cp) {\n            if (cp < 0x10000)\n                throw new Error('UTF-8 overlong encoding, codepoint encoded in 4 bytes: ' + cp);\n            // we could use String.fromCodePoint(cp) but let's be nice to older browsers and use surrogate pairs\n            cp -= 0x10000;\n            return String.fromCharCode((cp >> 10) + 0xD800, (cp & 0x3FF) + 0xDC00);\n        }\n        let s = '';\n        for (let i = start; i < end; ) {\n            const c = this.get(i++);\n            if (c < 0x80) // 0xxxxxxx (7 bit)\n                s += String.fromCharCode(c);\n            else if (c < 0xC0)\n                throw new Error('Invalid UTF-8 starting byte: ' + c);\n            else if (c < 0xE0) // 110xxxxx 10xxxxxx (11 bit)\n                s += String.fromCharCode(((c & 0x1F) << 6) | ex(this.get(i++)));\n            else if (c < 0xF0) // 1110xxxx 10xxxxxx 10xxxxxx (16 bit)\n                s += String.fromCharCode(((c & 0x0F) << 12) | (ex(this.get(i++)) << 6) | ex(this.get(i++)));\n            else if (c < 0xF8) // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx (21 bit)\n                s += surrogate(((c & 0x07) << 18) | (ex(this.get(i++)) << 12) | (ex(this.get(i++)) << 6) | ex(this.get(i++)));\n            else\n                throw new Error('Invalid UTF-8 starting byte (since 2003 it is restricted to 4 bytes): ' + c);\n        }\n        return { size: s.length, str: stringCut(s, maxLength) };\n    }\n\n    /**\n     * Parse a region of the stream as a BMP (Basic Multilingual Plane) string\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {number} maxLength - maximum length of the output string\n     * @returns {Object} Object with size and str properties\n     */\n    parseStringBMP(start, end, maxLength) {\n        let s = '', hi, lo;\n        for (let i = start; i < end; ) {\n            hi = this.get(i++);\n            lo = this.get(i++);\n            s += String.fromCharCode((hi << 8) | lo);\n        }\n        return { size: s.length, str: stringCut(s, maxLength) };\n    }\n\n    /**\n     * Parse a region of the stream as a time string\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {boolean} shortYear - Whether to parse as short year (2-digit)\n     * @returns {string} Formatted time string\n     */\n    parseTime(start, end, shortYear) {\n        let s = this.parseStringISO(start, end).str,\n            m = (shortYear ? reTimeS : reTimeL).exec(s);\n        if (!m)\n            throw new Error('Unrecognized time: ' + s);\n        if (shortYear) {\n            // to avoid querying the timer, use the fixed range [1970, 2069]\n            // it will conform with ITU X.400 [-10, +40] sliding window until 2030\n            m[1] = +m[1];\n            m[1] += (m[1] < 70) ? 2000 : 1900;\n        }\n        s = m[1] + '-' + m[2] + '-' + m[3] + ' ' + m[4];\n        if (m[5]) {\n            s += ':' + m[5];\n            if (m[6]) {\n                s += ':' + m[6];\n                if (m[7])\n                    s += '.' + m[7];\n            }\n        }\n        if (m[8]) {\n            s += ' UTC';\n            if (m[9])\n                s += m[9] + ':' + (m[10] || '00');\n        }\n        return s;\n    }\n\n    /**\n     * Parse a region of the stream as an integer\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @returns {string} Formatted integer string\n     */\n    parseInteger(start, end) {\n        let v = this.get(start),\n            s = '';\n        const neg = (v > 127),\n            pad = neg ? 255 : 0;\n        // skip unuseful bits (not allowed in DER)\n        while (v == pad && ++start < end)\n            v = this.get(start);\n        const len = end - start;\n        if (len === 0)\n            return neg ? '-1' : '0';\n        // show bit length of huge integers\n        if (len > 4) {\n            let v2 = v,\n                lenBit = len << 3;\n            while (((v2 ^ pad) & 0x80) == 0) {\n                v2 <<= 1;\n                --lenBit;\n            }\n            s = '(' + lenBit + ' bit)\\n';\n        }\n        // decode the integer\n        if (neg) v = v - 256;\n        let n = BigInt(v);\n        for (let i = start + 1; i < end; ++i)\n            n = (n << 8n) | BigInt(this.get(i));\n        return s + n;\n    }\n\n    /**\n     * Parse a region of the stream as a bit string.\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {number} maxLength - maximum length of the output string\n     * @returns {Object} Object with size and str properties\n     */\n    parseBitString(start, end, maxLength) {\n        const unusedBits = this.get(start);\n        if (unusedBits > 7)\n            throw new Error('Invalid BitString with unusedBits=' + unusedBits);\n        const lenBit = ((end - start - 1) << 3) - unusedBits;\n        let s = '';\n        for (let i = start + 1; i < end; ++i) {\n            let b = this.get(i),\n                skip = (i == end - 1) ? unusedBits : 0;\n            for (let j = 7; j >= skip; --j)\n                s += (b >> j) & 1 ? '1' : '0';\n            if (s.length > maxLength)\n                s = stringCut(s, maxLength);\n        }\n        return { size: lenBit, str: s };\n    }\n\n    /**\n     * Parse a region of the stream as an octet string.\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {number} maxLength - maximum length of the output string\n     * @returns {Object} Object with size and str properties\n     */\n    parseOctetString(start, end, maxLength) {\n        try {\n            let s = this.parseStringUTF(start, end, maxLength);\n            checkPrintable(s.str);\n            return { size: end - start, str: s.str };\n        } catch (ignore) {\n            // If UTF-8 parsing fails, fall back to hexadecimal dump\n        }\n        const len = end - start;\n        maxLength /= 2; // we work in bytes\n        if (len > maxLength)\n            end = start + maxLength;\n        let s = '';\n        for (let i = start; i < end; ++i)\n            s += Stream.hexByte(this.get(i));\n        if (len > maxLength)\n            s += ellipsis;\n        return { size: len, str: s };\n    }\n\n    /**\n     * Parse a region of the stream as an OID (Object Identifier).\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {number} maxLength - maximum length of the output string\n     * @param {boolean} isRelative - Whether the OID is relative\n     * @returns {string} Formatted OID string\n     */\n    parseOID(start, end, maxLength, isRelative) {\n        let s = '',\n            n = 0n,\n            bits = 0;\n        for (let i = start; i < end; ++i) {\n            let v = this.get(i);\n            // Shift bits and add the lower 7 bits of the byte\n            n = (n << 7n) | BigInt(v & 0x7F);\n            bits += 7;\n            // If the most significant bit is 0, this is the last byte of the OID component\n            if (!(v & 0x80)) { // finished\n                // If this is the first component, handle it specially\n                if (s === '') {\n                    if (isRelative) {\n                        s = n.toString();\n                    } else {\n                        let m = n < 80 ? n < 40 ? 0n : 1n : 2n;\n                        s = m + '.' + (n - m * 40n);\n                    }\n                } else\n                    s += '.' + n;\n                if (s.length > maxLength)\n                    return stringCut(s, maxLength);\n                n = 0n;\n                bits = 0;\n            }\n        }\n        if (bits > 0)\n            s += '.incomplete';\n        // If OIDs mapping is available and the OID is absolute, try to resolve it\n        if (typeof oids === 'object' && !isRelative) {\n            let oid = oids[s];\n            if (oid) {\n                if (oid.d) s += '\\n' + oid.d;\n                if (oid.c) s += '\\n' + oid.c;\n                if (oid.w) s += '\\n(warning!)';\n            }\n        }\n        return s;\n    }\n\n    /**\n     * Parse a region of the stream as a relative OID (Object Identifier).\n     * @param {number} start - starting position (included)\n     * @param {number} end - ending position (excluded)\n     * @param {number} maxLength - maximum length of the output string\n     * @returns {string} Formatted relative OID string\n     */\n    parseRelativeOID(start, end, maxLength) {\n        return this.parseOID(start, end, maxLength, true);\n    }\n}\n\nfunction recurse(el, parser, maxLength) {\n    let avoidRecurse = true;\n    if (el.tag.tagConstructed && el.sub) {\n        avoidRecurse = false;\n        el.sub.forEach(function (e1) {\n            if (e1.tag.tagClass != el.tag.tagClass || e1.tag.tagNumber != el.tag.tagNumber)\n                avoidRecurse = true;\n        });\n    }\n    if (avoidRecurse)\n        return el.stream[parser](el.posContent(), el.posContent() + Math.abs(el.length), maxLength);\n    let d = { size: 0, str: '' };\n    el.sub.forEach(function (el) {\n        let d1 = recurse(el, parser, maxLength - d.str.length);\n        d.size += d1.size;\n        d.str += d1.str;\n    });\n    return d;\n}\n\nclass ASN1Tag {\n    constructor(stream) {\n        let buf = stream.get();\n        this.tagClass = buf >> 6;\n        this.tagConstructed = ((buf & 0x20) !== 0);\n        this.tagNumber = buf & 0x1F;\n        if (this.tagNumber == 0x1F) { // long tag\n            let n = 0n;\n            do {\n                buf = stream.get();\n                n = (n << 7n) | BigInt(buf & 0x7F);\n            } while (buf & 0x80);\n            this.tagNumber = n <= Number.MAX_SAFE_INTEGER ? Number(n) : n;\n        }\n    }\n    isUniversal() {\n        return this.tagClass === 0x00;\n    }\n    isEOC() {\n        return this.tagClass === 0x00 && this.tagNumber === 0x00;\n    }\n}\n\n/**\n * ASN1 class for parsing ASN.1 encoded data.\n * Instances of this class represent an ASN.1 element and provides methods to parse and display its content.\n */\nexport class ASN1 {\n    /**\n     * Creates an ASN1 parser object.\n     * @param {Stream} stream - The stream containing the ASN.1 data.\n     * @param {number} header - The header length.\n     * @param {number} length - The length of the data.\n     * @param {ASN1Tag} tag - The ASN.1 tag.\n     * @param {number} tagLen - The length of the tag.\n     * @param {Array} sub - The sub-elements.\n     */\n    constructor(stream, header, length, tag, tagLen, sub) {\n        if (!(tag instanceof ASN1Tag)) throw new Error('Invalid tag value.');\n        this.stream = stream;\n        this.header = header;\n        this.length = length;\n        this.tag = tag;\n        this.tagLen = tagLen;\n        this.sub = sub;\n    }\n\n    /**\n     * Get the type name of the ASN.1 element.\n     * @returns {string} The type name.\n     */\n    typeName() {\n        switch (this.tag.tagClass) {\n        case 0: // universal\n            switch (this.tag.tagNumber) {\n            case 0x00: return 'EOC';\n            case 0x01: return 'BOOLEAN';\n            case 0x02: return 'INTEGER';\n            case 0x03: return 'BIT_STRING';\n            case 0x04: return 'OCTET_STRING';\n            case 0x05: return 'NULL';\n            case 0x06: return 'OBJECT_IDENTIFIER';\n            case 0x07: return 'ObjectDescriptor';\n            case 0x08: return 'EXTERNAL';\n            case 0x09: return 'REAL';\n            case 0x0A: return 'ENUMERATED';\n            case 0x0B: return 'EMBEDDED_PDV';\n            case 0x0C: return 'UTF8String';\n            case 0x0D: return 'RELATIVE_OID';\n            case 0x10: return 'SEQUENCE';\n            case 0x11: return 'SET';\n            case 0x12: return 'NumericString';\n            case 0x13: return 'PrintableString'; // ASCII subset\n            case 0x14: return 'TeletexString'; // aka T61String\n            case 0x15: return 'VideotexString';\n            case 0x16: return 'IA5String'; // ASCII\n            case 0x17: return 'UTCTime';\n            case 0x18: return 'GeneralizedTime';\n            case 0x19: return 'GraphicString';\n            case 0x1A: return 'VisibleString'; // ASCII subset\n            case 0x1B: return 'GeneralString';\n            case 0x1C: return 'UniversalString';\n            case 0x1E: return 'BMPString';\n            }\n            return 'Universal_' + this.tag.tagNumber.toString();\n        case 1: return 'Application_' + this.tag.tagNumber.toString();\n        case 2: return '[' + this.tag.tagNumber.toString() + ']'; // Context\n        case 3: return 'Private_' + this.tag.tagNumber.toString();\n        }\n    }\n\n    /**\n     * Get a string preview of the content (intended for humans).\n     * @param {number} maxLength - The maximum length of the content.\n     * @returns {string|null} The content preview or null if not supported.\n     */\n    content(maxLength) {\n        if (this.tag === undefined)\n            return null;\n        if (maxLength === undefined)\n            maxLength = Infinity;\n        const content = this.posContent(),\n            len = Math.abs(this.length);\n        if (!this.tag.isUniversal()) {\n            if (this.sub !== null)\n                return '(' + this.sub.length + ' elem)';\n            let d1 = this.stream.parseOctetString(content, content + len, maxLength);\n            return '(' + d1.size + ' byte)\\n' + d1.str;\n        }\n        switch (this.tag.tagNumber) {\n        case 0x01: // BOOLEAN\n            if (len != 1) return 'invalid length ' + len;\n            return (this.stream.get(content) === 0) ? 'false' : 'true';\n        case 0x02: // INTEGER\n            if (len < 1) return 'invalid length ' + len;\n            return this.stream.parseInteger(content, content + len);\n        case 0x03: { // BIT_STRING\n            let d = recurse(this, 'parseBitString', maxLength);\n            return '(' + d.size + ' bit)\\n' + d.str;\n        }\n        case 0x04: { // OCTET_STRING\n            let d = recurse(this, 'parseOctetString', maxLength);\n            return '(' + d.size + ' byte)\\n' + d.str;\n        }\n        //case 0x05: // NULL\n        case 0x06: // OBJECT_IDENTIFIER\n            if (len < 1) return 'invalid length ' + len; // pgut001's dumpasn1.c enforces a minimum lenght of 3\n            return this.stream.parseOID(content, content + len, maxLength);\n        //case 0x07: // ObjectDescriptor\n        //case 0x08: // EXTERNAL\n        //case 0x09: // REAL\n        case 0x0A: // ENUMERATED\n            return this.stream.parseInteger(content, content + len);\n        //case 0x0B: // EMBEDDED_PDV\n        case 0x0D: // RELATIVE-OID\n            return this.stream.parseRelativeOID(content, content + len, maxLength);\n        case 0x10: // SEQUENCE\n        case 0x11: // SET\n            if (this.sub !== null)\n                return '(' + this.sub.length + ' elem)';\n            else\n                return '(no elem)';\n        case 0x0C: // UTF8String\n            return recurse(this, 'parseStringUTF', maxLength).str;\n        case 0x14: // TeletexString\n            return recurse(this, 'parseStringT61', maxLength).str;\n        case 0x12: // NumericString\n        case 0x13: // PrintableString\n        case 0x15: // VideotexString\n        case 0x16: // IA5String\n        case 0x1A: // VisibleString\n        case 0x1B: // GeneralString\n        //case 0x19: // GraphicString\n        //case 0x1C: // UniversalString\n            return recurse(this, 'parseStringISO', maxLength).str;\n        case 0x1E: // BMPString\n            return recurse(this, 'parseStringBMP', maxLength).str;\n        case 0x17: // UTCTime\n        case 0x18: // GeneralizedTime\n            return this.stream.parseTime(content, content + len, (this.tag.tagNumber == 0x17));\n        }\n        return null;\n    }\n\n    /**\n     * Get a string representation of the ASN.1 element.\n     * @returns {string} The string representation.\n     */\n    toString() {\n        return this.typeName() + '@' + this.stream.pos + '[header:' + this.header + ',length:' + this.length + ',sub:' + ((this.sub === null) ? 'null' : this.sub.length) + ']';\n    }\n\n    /**\n     * Get a pretty string representation of the ASN.1 element.\n     * @param {string} indent - The indentation string.\n     * @returns {string} The pretty string representation.\n     */\n    toPrettyString(indent) {\n        if (indent === undefined) indent = '';\n        let s = indent;\n        if (this.def) {\n            if (this.def.id)\n                s += this.def.id + ' ';\n            if (this.def.name && this.def.name != this.typeName().replace(/_/g, ' '))\n                s+= this.def.name + ' ';\n            if (this.def.mismatch)\n                s += '[?] ';\n        }\n        s += this.typeName() + ' @' + this.stream.pos;\n        if (this.length >= 0)\n            s += '+';\n        s += this.length;\n        if (this.tag.tagConstructed)\n            s += ' (constructed)';\n        else if ((this.tag.isUniversal() && ((this.tag.tagNumber == 0x03) || (this.tag.tagNumber == 0x04))) && (this.sub !== null))\n            s += ' (encapsulates)';\n        let content = this.content();\n        if (content)\n            s += ': ' + content.replace(/\\n/g, '|');\n        s += '\\n';\n        if (this.sub !== null) {\n            indent += '  ';\n            for (let i = 0, max = this.sub.length; i < max; ++i)\n                s += this.sub[i].toPrettyString(indent);\n        }\n        return s;\n    }\n\n    /**\n     * Get the starting position of the element in the stream.\n     * @returns {number} The starting position.\n     */\n    posStart() {\n        return this.stream.pos;\n    }\n\n    /**\n     * Get the position of the content in the stream.\n     * @returns {number} The content position.\n     */\n    posContent() {\n        return this.stream.pos + this.header;\n    }\n\n    /**\n     * Get the ending position of the element in the stream.\n     * @returns {number} The ending position.\n     */\n    posEnd() {\n        return this.stream.pos + this.header + Math.abs(this.length);\n    }\n\n    /**\n     * Get the position of the length in the stream.\n     * @returns {number} The length position.\n     */\n    posLen() {\n        return this.stream.pos + this.tagLen;\n    }\n\n    /**\n     * Get a hexadecimal dump of the node.\n     * @param {string} [type='raw'] - The dump type: 'raw', 'byte', or 'dump'.\n     * @returns {string} The hexadecimal dump.\n     */\n    toHexString(type = 'raw') {\n        return this.stream.hexDump(this.posStart(), this.posEnd(), type);\n    }\n\n    /**\n     * Get a base64url dump of the node (according to RFC 4648 section 5).\n     * @param {string} [type='url'] - The dump type: 'url' (section 5 without padding) or 'std' (section 4 with padding).\n     * @returns {string} The base64 encoded representation.\n     */\n    toB64String(type = 'url') {\n        return this.stream.b64Dump(this.posStart(), this.posEnd(), type);\n    }\n\n    /**\n     * Decode the length field of an ASN.1 element.\n     * @param {Stream} stream - The stream to read from.\n     * @returns {number|null} The decoded length, or null for indefinite length.\n     * @throws {Error} If the length is invalid or exceeds 48 bits.\n     */\n    static decodeLength(stream) {\n        const buf = stream.get(),\n            len = buf & 0x7F;\n        if (len == buf) // first bit was 0, short form\n            return len;\n        if (len === 0) // long form with length 0 is a special case\n            return null; // undefined length\n        if (len > 6) // no reason to use BigInt, as it would be a huge buffer anyways\n            throw new Error('Length over 48 bits not supported at position ' + (stream.pos - 1));\n        let value = 0;\n        for (let i = 0; i < len; ++i)\n            value = (value * 256) + stream.get();\n        return value;\n    }\n\n    /**\n     * Decode an ASN.1 element from a stream.\n     * @param {Stream|array|string} stream - The input data.\n     * @param {number} [offset=0] - The offset to start decoding from.\n     * @param {Function} [type=ASN1] - The class to instantiate.\n     * @returns {ASN1} The decoded ASN.1 element.\n     * @throws {Error} If the decoding fails.\n     */\n    static decode(stream, offset, type = ASN1) {\n        if (!(type == ASN1 || type.prototype instanceof ASN1))\n            throw new Error('Must pass a class that extends ASN1');\n        if (!(stream instanceof Stream))\n            stream = new Stream(stream, offset || 0);\n        let streamStart = new Stream(stream),\n            tag = new ASN1Tag(stream),\n            tagLen = stream.pos - streamStart.pos,\n            len = ASN1.decodeLength(stream),\n            start = stream.pos,\n            end = (len !== null) ? (start + len) : null,\n            header = start - streamStart.pos,\n            sub = null,\n            getSub = function () {\n                sub = [];\n                if (len !== null) {\n                    // definite length\n                    while (stream.pos < end)\n                        sub[sub.length] = type.decode(stream);\n                    if (stream.pos != end)\n                        throw new Error('Content size is not correct for container at offset ' + start);\n                } else {\n                    // undefined length\n                    try {\n                        for (;;) {\n                            let s = type.decode(stream);\n                            if (s.tag.isEOC())\n                                break;\n                            sub[sub.length] = s;\n                        }\n                        len = start - stream.pos; // undefined lengths are represented as negative values\n                    } catch (e) {\n                        throw new Error('Exception while decoding undefined length content at offset ' + start + ': ' + e);\n                    }\n                }\n            };\n        if (end !== null && end > stream.enc.length)\n            throw new Error('Element at offset ' + start +  ' has a length of ' + len + ', which is past the end of the stream');\n        if (tag.tagConstructed) {\n            // must have valid content\n            getSub();\n        } else if (tag.isUniversal() && ((tag.tagNumber == 0x03) || (tag.tagNumber == 0x04))) {\n            // sometimes BitString and OctetString are used to encapsulate ASN.1\n            try {\n                if (tag.tagNumber == 0x03)\n                    if (stream.get() != 0)\n                        throw new Error('BIT STRINGs with unused bits cannot encapsulate.');\n                getSub();\n                for (let s of sub) {\n                    if (s.tag.isEOC())\n                        throw new Error('EOC is not supposed to be actual content.');\n                    try {\n                        s.content();\n                    } catch (e) {\n                        throw new Error('Unable to parse content: ' + e);\n                    }\n                }\n            } catch (ignore) {\n                // but silently ignore when they don't\n                sub = null;\n                //DEBUG console.log('Could not decode structure at ' + start + ':', e);\n            }\n        }\n        if (sub === null) {\n            if (len === null)\n                throw new Error(\"We can't skip over an invalid tag with undefined length at offset \" + start);\n            stream.pos = start + Math.abs(len);\n        }\n        return new type(streamStart, header, len, tag, tagLen, sub);\n    }\n\n}\n"]}