authing_ruby 1.1.0 → 1.1.5

data/lib/authing_ruby/test/js_sdk_test/node_modules/jsencrypt/lib/JSEncryptRSAKey.js

@@ -1,315 +0,0 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { hex2b64 } from "./lib/jsbn/base64";
-import { Hex } from "./lib/asn1js/hex";
-import { Base64 } from "./lib/asn1js/base64";
-import { ASN1 } from "./lib/asn1js/asn1";
-import { RSAKey } from "./lib/jsbn/rsa";
-import { parseBigInt } from "./lib/jsbn/jsbn";
-import { KJUR } from "./lib/jsrsasign/asn1-1.0";
-/**
- * Create a new JSEncryptRSAKey that extends Tom Wu's RSA key object.
- * This object is just a decorator for parsing the key parameter
- * @param {string|Object} key - The key in string format, or an object containing
- * the parameters needed to build a RSAKey object.
- * @constructor
- */
-var JSEncryptRSAKey = /** @class */ (function (_super) {
-    __extends(JSEncryptRSAKey, _super);
-    function JSEncryptRSAKey(key) {
-        var _this = _super.call(this) || this;
-        // Call the super constructor.
-        //  RSAKey.call(this);
-        // If a key key was provided.
-        if (key) {
-            // If this is a string...
-            if (typeof key === "string") {
-                _this.parseKey(key);
-            }
-            else if (JSEncryptRSAKey.hasPrivateKeyProperty(key) ||
-                JSEncryptRSAKey.hasPublicKeyProperty(key)) {
-                // Set the values for the key.
-                _this.parsePropertiesFrom(key);
-            }
-        }
-        return _this;
-    }
-    /**
-     * Method to parse a pem encoded string containing both a public or private key.
-     * The method will translate the pem encoded string in a der encoded string and
-     * will parse private key and public key parameters. This method accepts public key
-     * in the rsaencryption pkcs #1 format (oid: 1.2.840.113549.1.1.1).
-     *
-     * @todo Check how many rsa formats use the same format of pkcs #1.
-     *
-     * The format is defined as:
-     * PublicKeyInfo ::= SEQUENCE {
-     *   algorithm       AlgorithmIdentifier,
-     *   PublicKey       BIT STRING
-     * }
-     * Where AlgorithmIdentifier is:
-     * AlgorithmIdentifier ::= SEQUENCE {
-     *   algorithm       OBJECT IDENTIFIER,     the OID of the enc algorithm
-     *   parameters      ANY DEFINED BY algorithm OPTIONAL (NULL for PKCS #1)
-     * }
-     * and PublicKey is a SEQUENCE encapsulated in a BIT STRING
-     * RSAPublicKey ::= SEQUENCE {
-     *   modulus           INTEGER,  -- n
-     *   publicExponent    INTEGER   -- e
-     * }
-     * it's possible to examine the structure of the keys obtained from openssl using
-     * an asn.1 dumper as the one used here to parse the components: http://lapo.it/asn1js/
-     * @argument {string} pem the pem encoded string, can include the BEGIN/END header/footer
-     * @private
-     */
-    JSEncryptRSAKey.prototype.parseKey = function (pem) {
-        try {
-            var modulus = 0;
-            var public_exponent = 0;
-            var reHex = /^\s*(?:[0-9A-Fa-f][0-9A-Fa-f]\s*)+$/;
-            var der = reHex.test(pem) ? Hex.decode(pem) : Base64.unarmor(pem);
-            var asn1 = ASN1.decode(der);
-            // Fixes a bug with OpenSSL 1.0+ private keys
-            if (asn1.sub.length === 3) {
-                asn1 = asn1.sub[2].sub[0];
-            }
-            if (asn1.sub.length === 9) {
-                // Parse the private key.
-                modulus = asn1.sub[1].getHexStringValue(); // bigint
-                this.n = parseBigInt(modulus, 16);
-                public_exponent = asn1.sub[2].getHexStringValue(); // int
-                this.e = parseInt(public_exponent, 16);
-                var private_exponent = asn1.sub[3].getHexStringValue(); // bigint
-                this.d = parseBigInt(private_exponent, 16);
-                var prime1 = asn1.sub[4].getHexStringValue(); // bigint
-                this.p = parseBigInt(prime1, 16);
-                var prime2 = asn1.sub[5].getHexStringValue(); // bigint
-                this.q = parseBigInt(prime2, 16);
-                var exponent1 = asn1.sub[6].getHexStringValue(); // bigint
-                this.dmp1 = parseBigInt(exponent1, 16);
-                var exponent2 = asn1.sub[7].getHexStringValue(); // bigint
-                this.dmq1 = parseBigInt(exponent2, 16);
-                var coefficient = asn1.sub[8].getHexStringValue(); // bigint
-                this.coeff = parseBigInt(coefficient, 16);
-            }
-            else if (asn1.sub.length === 2) {
-                // Parse the public key.
-                var bit_string = asn1.sub[1];
-                var sequence = bit_string.sub[0];
-                modulus = sequence.sub[0].getHexStringValue();
-                this.n = parseBigInt(modulus, 16);
-                public_exponent = sequence.sub[1].getHexStringValue();
-                this.e = parseInt(public_exponent, 16);
-            }
-            else {
-                return false;
-            }
-            return true;
-        }
-        catch (ex) {
-            return false;
-        }
-    };
-    /**
-     * Translate rsa parameters in a hex encoded string representing the rsa key.
-     *
-     * The translation follow the ASN.1 notation :
-     * RSAPrivateKey ::= SEQUENCE {
-     *   version           Version,
-     *   modulus           INTEGER,  -- n
-     *   publicExponent    INTEGER,  -- e
-     *   privateExponent   INTEGER,  -- d
-     *   prime1            INTEGER,  -- p
-     *   prime2            INTEGER,  -- q
-     *   exponent1         INTEGER,  -- d mod (p1)
-     *   exponent2         INTEGER,  -- d mod (q-1)
-     *   coefficient       INTEGER,  -- (inverse of q) mod p
-     * }
-     * @returns {string}  DER Encoded String representing the rsa private key
-     * @private
-     */
-    JSEncryptRSAKey.prototype.getPrivateBaseKey = function () {
-        var options = {
-            array: [
-                new KJUR.asn1.DERInteger({ int: 0 }),
-                new KJUR.asn1.DERInteger({ bigint: this.n }),
-                new KJUR.asn1.DERInteger({ int: this.e }),
-                new KJUR.asn1.DERInteger({ bigint: this.d }),
-                new KJUR.asn1.DERInteger({ bigint: this.p }),
-                new KJUR.asn1.DERInteger({ bigint: this.q }),
-                new KJUR.asn1.DERInteger({ bigint: this.dmp1 }),
-                new KJUR.asn1.DERInteger({ bigint: this.dmq1 }),
-                new KJUR.asn1.DERInteger({ bigint: this.coeff })
-            ]
-        };
-        var seq = new KJUR.asn1.DERSequence(options);
-        return seq.getEncodedHex();
-    };
-    /**
-     * base64 (pem) encoded version of the DER encoded representation
-     * @returns {string} pem encoded representation without header and footer
-     * @public
-     */
-    JSEncryptRSAKey.prototype.getPrivateBaseKeyB64 = function () {
-        return hex2b64(this.getPrivateBaseKey());
-    };
-    /**
-     * Translate rsa parameters in a hex encoded string representing the rsa public key.
-     * The representation follow the ASN.1 notation :
-     * PublicKeyInfo ::= SEQUENCE {
-     *   algorithm       AlgorithmIdentifier,
-     *   PublicKey       BIT STRING
-     * }
-     * Where AlgorithmIdentifier is:
-     * AlgorithmIdentifier ::= SEQUENCE {
-     *   algorithm       OBJECT IDENTIFIER,     the OID of the enc algorithm
-     *   parameters      ANY DEFINED BY algorithm OPTIONAL (NULL for PKCS #1)
-     * }
-     * and PublicKey is a SEQUENCE encapsulated in a BIT STRING
-     * RSAPublicKey ::= SEQUENCE {
-     *   modulus           INTEGER,  -- n
-     *   publicExponent    INTEGER   -- e
-     * }
-     * @returns {string} DER Encoded String representing the rsa public key
-     * @private
-     */
-    JSEncryptRSAKey.prototype.getPublicBaseKey = function () {
-        var first_sequence = new KJUR.asn1.DERSequence({
-            array: [
-                new KJUR.asn1.DERObjectIdentifier({ oid: "1.2.840.113549.1.1.1" }),
-                new KJUR.asn1.DERNull()
-            ]
-        });
-        var second_sequence = new KJUR.asn1.DERSequence({
-            array: [
-                new KJUR.asn1.DERInteger({ bigint: this.n }),
-                new KJUR.asn1.DERInteger({ int: this.e })
-            ]
-        });
-        var bit_string = new KJUR.asn1.DERBitString({
-            hex: "00" + second_sequence.getEncodedHex()
-        });
-        var seq = new KJUR.asn1.DERSequence({
-            array: [
-                first_sequence,
-                bit_string
-            ]
-        });
-        return seq.getEncodedHex();
-    };
-    /**
-     * base64 (pem) encoded version of the DER encoded representation
-     * @returns {string} pem encoded representation without header and footer
-     * @public
-     */
-    JSEncryptRSAKey.prototype.getPublicBaseKeyB64 = function () {
-        return hex2b64(this.getPublicBaseKey());
-    };
-    /**
-     * wrap the string in block of width chars. The default value for rsa keys is 64
-     * characters.
-     * @param {string} str the pem encoded string without header and footer
-     * @param {Number} [width=64] - the length the string has to be wrapped at
-     * @returns {string}
-     * @private
-     */
-    JSEncryptRSAKey.wordwrap = function (str, width) {
-        width = width || 64;
-        if (!str) {
-            return str;
-        }
-        var regex = "(.{1," + width + "})( +|$\n?)|(.{1," + width + "})";
-        return str.match(RegExp(regex, "g")).join("\n");
-    };
-    /**
-     * Retrieve the pem encoded private key
-     * @returns {string} the pem encoded private key with header/footer
-     * @public
-     */
-    JSEncryptRSAKey.prototype.getPrivateKey = function () {
-        var key = "-----BEGIN RSA PRIVATE KEY-----\n";
-        key += JSEncryptRSAKey.wordwrap(this.getPrivateBaseKeyB64()) + "\n";
-        key += "-----END RSA PRIVATE KEY-----";
-        return key;
-    };
-    /**
-     * Retrieve the pem encoded public key
-     * @returns {string} the pem encoded public key with header/footer
-     * @public
-     */
-    JSEncryptRSAKey.prototype.getPublicKey = function () {
-        var key = "-----BEGIN PUBLIC KEY-----\n";
-        key += JSEncryptRSAKey.wordwrap(this.getPublicBaseKeyB64()) + "\n";
-        key += "-----END PUBLIC KEY-----";
-        return key;
-    };
-    /**
-     * Check if the object contains the necessary parameters to populate the rsa modulus
-     * and public exponent parameters.
-     * @param {Object} [obj={}] - An object that may contain the two public key
-     * parameters
-     * @returns {boolean} true if the object contains both the modulus and the public exponent
-     * properties (n and e)
-     * @todo check for types of n and e. N should be a parseable bigInt object, E should
-     * be a parseable integer number
-     * @private
-     */
-    JSEncryptRSAKey.hasPublicKeyProperty = function (obj) {
-        obj = obj || {};
-        return (obj.hasOwnProperty("n") &&
-            obj.hasOwnProperty("e"));
-    };
-    /**
-     * Check if the object contains ALL the parameters of an RSA key.
-     * @param {Object} [obj={}] - An object that may contain nine rsa key
-     * parameters
-     * @returns {boolean} true if the object contains all the parameters needed
-     * @todo check for types of the parameters all the parameters but the public exponent
-     * should be parseable bigint objects, the public exponent should be a parseable integer number
-     * @private
-     */
-    JSEncryptRSAKey.hasPrivateKeyProperty = function (obj) {
-        obj = obj || {};
-        return (obj.hasOwnProperty("n") &&
-            obj.hasOwnProperty("e") &&
-            obj.hasOwnProperty("d") &&
-            obj.hasOwnProperty("p") &&
-            obj.hasOwnProperty("q") &&
-            obj.hasOwnProperty("dmp1") &&
-            obj.hasOwnProperty("dmq1") &&
-            obj.hasOwnProperty("coeff"));
-    };
-    /**
-     * Parse the properties of obj in the current rsa object. Obj should AT LEAST
-     * include the modulus and public exponent (n, e) parameters.
-     * @param {Object} obj - the object containing rsa parameters
-     * @private
-     */
-    JSEncryptRSAKey.prototype.parsePropertiesFrom = function (obj) {
-        this.n = obj.n;
-        this.e = obj.e;
-        if (obj.hasOwnProperty("d")) {
-            this.d = obj.d;
-            this.p = obj.p;
-            this.q = obj.q;
-            this.dmp1 = obj.dmp1;
-            this.dmq1 = obj.dmq1;
-            this.coeff = obj.coeff;
-        }
-    };
-    return JSEncryptRSAKey;
-}(RSAKey));
-export { JSEncryptRSAKey };

data/lib/authing_ruby/test/js_sdk_test/node_modules/jsencrypt/lib/index.d.ts

@@ -1,3 +0,0 @@
-import { JSEncrypt } from './JSEncrypt';
-export { JSEncrypt };
-export default JSEncrypt;

data/lib/authing_ruby/test/js_sdk_test/node_modules/jsencrypt/lib/index.js

@@ -1,3 +0,0 @@
-import { JSEncrypt } from './JSEncrypt';
-export { JSEncrypt };
-export default JSEncrypt;

data/lib/authing_ruby/test/js_sdk_test/node_modules/jsencrypt/lib/lib/asn1js/asn1.d.ts

@@ -1,51 +0,0 @@
-import { Int10 } from "./int10";
-export declare class Stream {
-    constructor(enc: Stream | number[], pos?: number);
-    private enc;
-    pos: number;
-    get(pos?: number): number;
-    hexDigits: string;
-    hexByte(b: number): string;
-    hexDump(start: number, end: number, raw: boolean): string;
-    isASCII(start: number, end: number): boolean;
-    parseStringISO(start: number, end: number): string;
-    parseStringUTF(start: number, end: number): string;
-    parseStringBMP(start: number, end: number): string;
-    parseTime(start: number, end: number, shortYear: boolean): string;
-    parseInteger(start: number, end: number): string | 0 | -1;
-    parseBitString(start: number, end: number, maxLength: number): string;
-    parseOctetString(start: number, end: number, maxLength: number): string;
-    parseOID(start: number, end: number, maxLength: number): string;
-}
-export declare class ASN1 {
-    constructor(stream: Stream, header: number, length: number, tag: ASN1Tag, sub: ASN1[]);
-    private stream;
-    private header;
-    private length;
-    private tag;
-    sub: ASN1[];
-    typeName(): string;
-    content(maxLength: number): string | 0 | -1;
-    toString(): string;
-    toPrettyString(indent: string): string;
-    posStart(): number;
-    posContent(): number;
-    posEnd(): number;
-    toHexString(): string;
-    static decodeLength(stream: Stream): number;
-    /**
-     * Retrieve the hexadecimal value (as a string) of the current ASN.1 element
-     * @returns {string}
-     * @public
-     */
-    getHexStringValue(): string;
-    static decode(str: Stream | number[]): ASN1;
-}
-export declare class ASN1Tag {
-    constructor(stream: Stream);
-    tagClass: number;
-    tagConstructed: boolean;
-    tagNumber: number | Int10;
-    isUniversal(): boolean;
-    isEOC(): boolean;
-}

data/lib/authing_ruby/test/js_sdk_test/node_modules/jsencrypt/lib/lib/asn1js/asn1.js

@@ -1,565 +0,0 @@
-// ASN.1 JavaScript decoder
-// Copyright (c) 2008-2014 Lapo Luchini <lapo@lapo.it>
-// Permission to use, copy, modify, and/or distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-/*jshint browser: true, strict: true, immed: true, latedef: true, undef: true, regexdash: false */
-/*global oids */
-import { Int10 } from "./int10";
-var ellipsis = "\u2026";
-var 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,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;
-var 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,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;
-function stringCut(str, len) {
-    if (str.length > len) {
-        str = str.substring(0, len) + ellipsis;
-    }
-    return str;
-}
-var Stream = /** @class */ (function () {
-    function Stream(enc, pos) {
-        this.hexDigits = "0123456789ABCDEF";
-        if (enc instanceof Stream) {
-            this.enc = enc.enc;
-            this.pos = enc.pos;
-        }
-        else {
-            // enc should be an array or a binary string
-            this.enc = enc;
-            this.pos = pos;
-        }
-    }
-    Stream.prototype.get = function (pos) {
-        if (pos === undefined) {
-            pos = this.pos++;
-        }
-        if (pos >= this.enc.length) {
-            throw new Error("Requesting byte offset " + pos + " on a stream of length " + this.enc.length);
-        }
-        return ("string" === typeof this.enc) ? this.enc.charCodeAt(pos) : this.enc[pos];
-    };
-    Stream.prototype.hexByte = function (b) {
-        return this.hexDigits.charAt((b >> 4) & 0xF) + this.hexDigits.charAt(b & 0xF);
-    };
-    Stream.prototype.hexDump = function (start, end, raw) {
-        var s = "";
-        for (var i = start; i < end; ++i) {
-            s += this.hexByte(this.get(i));
-            if (raw !== true) {
-                switch (i & 0xF) {
-                    case 0x7:
-                        s += "  ";
-                        break;
-                    case 0xF:
-                        s += "\n";
-                        break;
-                    default:
-                        s += " ";
-                }
-            }
-        }
-        return s;
-    };
-    Stream.prototype.isASCII = function (start, end) {
-        for (var i = start; i < end; ++i) {
-            var c = this.get(i);
-            if (c < 32 || c > 176) {
-                return false;
-            }
-        }
-        return true;
-    };
-    Stream.prototype.parseStringISO = function (start, end) {
-        var s = "";
-        for (var i = start; i < end; ++i) {
-            s += String.fromCharCode(this.get(i));
-        }
-        return s;
-    };
-    Stream.prototype.parseStringUTF = function (start, end) {
-        var s = "";
-        for (var i = start; i < end;) {
-            var c = this.get(i++);
-            if (c < 128) {
-                s += String.fromCharCode(c);
-            }
-            else if ((c > 191) && (c < 224)) {
-                s += String.fromCharCode(((c & 0x1F) << 6) | (this.get(i++) & 0x3F));
-            }
-            else {
-                s += String.fromCharCode(((c & 0x0F) << 12) | ((this.get(i++) & 0x3F) << 6) | (this.get(i++) & 0x3F));
-            }
-        }
-        return s;
-    };
-    Stream.prototype.parseStringBMP = function (start, end) {
-        var str = "";
-        var hi;
-        var lo;
-        for (var i = start; i < end;) {
-            hi = this.get(i++);
-            lo = this.get(i++);
-            str += String.fromCharCode((hi << 8) | lo);
-        }
-        return str;
-    };
-    Stream.prototype.parseTime = function (start, end, shortYear) {
-        var s = this.parseStringISO(start, end);
-        var m = (shortYear ? reTimeS : reTimeL).exec(s);
-        if (!m) {
-            return "Unrecognized time: " + s;
-        }
-        if (shortYear) {
-            // to avoid querying the timer, use the fixed range [1970, 2069]
-            // it will conform with ITU X.400 [-10, +40] sliding window until 2030
-            m[1] = +m[1];
-            m[1] += (+m[1] < 70) ? 2000 : 1900;
-        }
-        s = m[1] + "-" + m[2] + "-" + m[3] + " " + m[4];
-        if (m[5]) {
-            s += ":" + m[5];
-            if (m[6]) {
-                s += ":" + m[6];
-                if (m[7]) {
-                    s += "." + m[7];
-                }
-            }
-        }
-        if (m[8]) {
-            s += " UTC";
-            if (m[8] != "Z") {
-                s += m[8];
-                if (m[9]) {
-                    s += ":" + m[9];
-                }
-            }
-        }
-        return s;
-    };
-    Stream.prototype.parseInteger = function (start, end) {
-        var v = this.get(start);
-        var neg = (v > 127);
-        var pad = neg ? 255 : 0;
-        var len;
-        var s = "";
-        // skip unuseful bits (not allowed in DER)
-        while (v == pad && ++start < end) {
-            v = this.get(start);
-        }
-        len = end - start;
-        if (len === 0) {
-            return neg ? -1 : 0;
-        }
-        // show bit length of huge integers
-        if (len > 4) {
-            s = v;
-            len <<= 3;
-            while (((+s ^ pad) & 0x80) == 0) {
-                s = +s << 1;
-                --len;
-            }
-            s = "(" + len + " bit)\n";
-        }
-        // decode the integer
-        if (neg) {
-            v = v - 256;
-        }
-        var n = new Int10(v);
-        for (var i = start + 1; i < end; ++i) {
-            n.mulAdd(256, this.get(i));
-        }
-        return s + n.toString();
-    };
-    Stream.prototype.parseBitString = function (start, end, maxLength) {
-        var unusedBit = this.get(start);
-        var lenBit = ((end - start - 1) << 3) - unusedBit;
-        var intro = "(" + lenBit + " bit)\n";
-        var s = "";
-        for (var i = start + 1; i < end; ++i) {
-            var b = this.get(i);
-            var skip = (i == end - 1) ? unusedBit : 0;
-            for (var j = 7; j >= skip; --j) {
-                s += (b >> j) & 1 ? "1" : "0";
-            }
-            if (s.length > maxLength) {
-                return intro + stringCut(s, maxLength);
-            }
-        }
-        return intro + s;
-    };
-    Stream.prototype.parseOctetString = function (start, end, maxLength) {
-        if (this.isASCII(start, end)) {
-            return stringCut(this.parseStringISO(start, end), maxLength);
-        }
-        var len = end - start;
-        var s = "(" + len + " byte)\n";
-        maxLength /= 2; // we work in bytes
-        if (len > maxLength) {
-            end = start + maxLength;
-        }
-        for (var i = start; i < end; ++i) {
-            s += this.hexByte(this.get(i));
-        }
-        if (len > maxLength) {
-            s += ellipsis;
-        }
-        return s;
-    };
-    Stream.prototype.parseOID = function (start, end, maxLength) {
-        var s = "";
-        var n = new Int10();
-        var bits = 0;
-        for (var i = start; i < end; ++i) {
-            var v = this.get(i);
-            n.mulAdd(128, v & 0x7F);
-            bits += 7;
-            if (!(v & 0x80)) { // finished
-                if (s === "") {
-                    n = n.simplify();
-                    if (n instanceof Int10) {
-                        n.sub(80);
-                        s = "2." + n.toString();
-                    }
-                    else {
-                        var m = n < 80 ? n < 40 ? 0 : 1 : 2;
-                        s = m + "." + (n - m * 40);
-                    }
-                }
-                else {
-                    s += "." + n.toString();
-                }
-                if (s.length > maxLength) {
-                    return stringCut(s, maxLength);
-                }
-                n = new Int10();
-                bits = 0;
-            }
-        }
-        if (bits > 0) {
-            s += ".incomplete";
-        }
-        return s;
-    };
-    return Stream;
-}());
-export { Stream };
-var ASN1 = /** @class */ (function () {
-    function ASN1(stream, header, length, tag, sub) {
-        if (!(tag instanceof ASN1Tag)) {
-            throw new Error("Invalid tag value.");
-        }
-        this.stream = stream;
-        this.header = header;
-        this.length = length;
-        this.tag = tag;
-        this.sub = sub;
-    }
-    ASN1.prototype.typeName = function () {
-        switch (this.tag.tagClass) {
-            case 0: // universal
-                switch (this.tag.tagNumber) {
-                    case 0x00:
-                        return "EOC";
-                    case 0x01:
-                        return "BOOLEAN";
-                    case 0x02:
-                        return "INTEGER";
-                    case 0x03:
-                        return "BIT_STRING";
-                    case 0x04:
-                        return "OCTET_STRING";
-                    case 0x05:
-                        return "NULL";
-                    case 0x06:
-                        return "OBJECT_IDENTIFIER";
-                    case 0x07:
-                        return "ObjectDescriptor";
-                    case 0x08:
-                        return "EXTERNAL";
-                    case 0x09:
-                        return "REAL";
-                    case 0x0A:
-                        return "ENUMERATED";
-                    case 0x0B:
-                        return "EMBEDDED_PDV";
-                    case 0x0C:
-                        return "UTF8String";
-                    case 0x10:
-                        return "SEQUENCE";
-                    case 0x11:
-                        return "SET";
-                    case 0x12:
-                        return "NumericString";
-                    case 0x13:
-                        return "PrintableString"; // ASCII subset
-                    case 0x14:
-                        return "TeletexString"; // aka T61String
-                    case 0x15:
-                        return "VideotexString";
-                    case 0x16:
-                        return "IA5String"; // ASCII
-                    case 0x17:
-                        return "UTCTime";
-                    case 0x18:
-                        return "GeneralizedTime";
-                    case 0x19:
-                        return "GraphicString";
-                    case 0x1A:
-                        return "VisibleString"; // ASCII subset
-                    case 0x1B:
-                        return "GeneralString";
-                    case 0x1C:
-                        return "UniversalString";
-                    case 0x1E:
-                        return "BMPString";
-                }
-                return "Universal_" + this.tag.tagNumber.toString();
-            case 1:
-                return "Application_" + this.tag.tagNumber.toString();
-            case 2:
-                return "[" + this.tag.tagNumber.toString() + "]"; // Context
-            case 3:
-                return "Private_" + this.tag.tagNumber.toString();
-        }
-    };
-    ASN1.prototype.content = function (maxLength) {
-        if (this.tag === undefined) {
-            return null;
-        }
-        if (maxLength === undefined) {
-            maxLength = Infinity;
-        }
-        var content = this.posContent();
-        var len = Math.abs(this.length);
-        if (!this.tag.isUniversal()) {
-            if (this.sub !== null) {
-                return "(" + this.sub.length + " elem)";
-            }
-            return this.stream.parseOctetString(content, content + len, maxLength);
-        }
-        switch (this.tag.tagNumber) {
-            case 0x01: // BOOLEAN
-                return (this.stream.get(content) === 0) ? "false" : "true";
-            case 0x02: // INTEGER
-                return this.stream.parseInteger(content, content + len);
-            case 0x03: // BIT_STRING
-                return this.sub ? "(" + this.sub.length + " elem)" :
-                    this.stream.parseBitString(content, content + len, maxLength);
-            case 0x04: // OCTET_STRING
-                return this.sub ? "(" + this.sub.length + " elem)" :
-                    this.stream.parseOctetString(content, content + len, maxLength);
-            // case 0x05: // NULL
-            case 0x06: // OBJECT_IDENTIFIER
-                return this.stream.parseOID(content, content + len, maxLength);
-            // case 0x07: // ObjectDescriptor
-            // case 0x08: // EXTERNAL
-            // case 0x09: // REAL
-            // case 0x0A: // ENUMERATED
-            // case 0x0B: // EMBEDDED_PDV
-            case 0x10: // SEQUENCE
-            case 0x11: // SET
-                if (this.sub !== null) {
-                    return "(" + this.sub.length + " elem)";
-                }
-                else {
-                    return "(no elem)";
-                }
-            case 0x0C: // UTF8String
-                return stringCut(this.stream.parseStringUTF(content, content + len), maxLength);
-            case 0x12: // NumericString
-            case 0x13: // PrintableString
-            case 0x14: // TeletexString
-            case 0x15: // VideotexString
-            case 0x16: // IA5String
-            // case 0x19: // GraphicString
-            case 0x1A: // VisibleString
-                // case 0x1B: // GeneralString
-                // case 0x1C: // UniversalString
-                return stringCut(this.stream.parseStringISO(content, content + len), maxLength);
-            case 0x1E: // BMPString
-                return stringCut(this.stream.parseStringBMP(content, content + len), maxLength);
-            case 0x17: // UTCTime
-            case 0x18: // GeneralizedTime
-                return this.stream.parseTime(content, content + len, (this.tag.tagNumber == 0x17));
-        }
-        return null;
-    };
-    ASN1.prototype.toString = function () {
-        return this.typeName() + "@" + this.stream.pos + "[header:" + this.header + ",length:" + this.length + ",sub:" + ((this.sub === null) ? "null" : this.sub.length) + "]";
-    };
-    ASN1.prototype.toPrettyString = function (indent) {
-        if (indent === undefined) {
-            indent = "";
-        }
-        var s = indent + this.typeName() + " @" + this.stream.pos;
-        if (this.length >= 0) {
-            s += "+";
-        }
-        s += this.length;
-        if (this.tag.tagConstructed) {
-            s += " (constructed)";
-        }
-        else if ((this.tag.isUniversal() && ((this.tag.tagNumber == 0x03) || (this.tag.tagNumber == 0x04))) && (this.sub !== null)) {
-            s += " (encapsulates)";
-        }
-        s += "\n";
-        if (this.sub !== null) {
-            indent += "  ";
-            for (var i = 0, max = this.sub.length; i < max; ++i) {
-                s += this.sub[i].toPrettyString(indent);
-            }
-        }
-        return s;
-    };
-    ASN1.prototype.posStart = function () {
-        return this.stream.pos;
-    };
-    ASN1.prototype.posContent = function () {
-        return this.stream.pos + this.header;
-    };
-    ASN1.prototype.posEnd = function () {
-        return this.stream.pos + this.header + Math.abs(this.length);
-    };
-    ASN1.prototype.toHexString = function () {
-        return this.stream.hexDump(this.posStart(), this.posEnd(), true);
-    };
-    ASN1.decodeLength = function (stream) {
-        var buf = stream.get();
-        var len = buf & 0x7F;
-        if (len == buf) {
-            return len;
-        }
-        // no reason to use Int10, as it would be a huge buffer anyways
-        if (len > 6) {
-            throw new Error("Length over 48 bits not supported at position " + (stream.pos - 1));
-        }
-        if (len === 0) {
-            return null;
-        } // undefined
-        buf = 0;
-        for (var i = 0; i < len; ++i) {
-            buf = (buf * 256) + stream.get();
-        }
-        return buf;
-    };
-    /**
-     * Retrieve the hexadecimal value (as a string) of the current ASN.1 element
-     * @returns {string}
-     * @public
-     */
-    ASN1.prototype.getHexStringValue = function () {
-        var hexString = this.toHexString();
-        var offset = this.header * 2;
-        var length = this.length * 2;
-        return hexString.substr(offset, length);
-    };
-    ASN1.decode = function (str) {
-        var stream;
-        if (!(str instanceof Stream)) {
-            stream = new Stream(str, 0);
-        }
-        else {
-            stream = str;
-        }
-        var streamStart = new Stream(stream);
-        var tag = new ASN1Tag(stream);
-        var len = ASN1.decodeLength(stream);
-        var start = stream.pos;
-        var header = start - streamStart.pos;
-        var sub = null;
-        var getSub = function () {
-            var ret = [];
-            if (len !== null) {
-                // definite length
-                var end = start + len;
-                while (stream.pos < end) {
-                    ret[ret.length] = ASN1.decode(stream);
-                }
-                if (stream.pos != end) {
-                    throw new Error("Content size is not correct for container starting at offset " + start);
-                }
-            }
-            else {
-                // undefined length
-                try {
-                    for (;;) {
-                        var s = ASN1.decode(stream);
-                        if (s.tag.isEOC()) {
-                            break;
-                        }
-                        ret[ret.length] = s;
-                    }
-                    len = start - stream.pos; // undefined lengths are represented as negative values
-                }
-                catch (e) {
-                    throw new Error("Exception while decoding undefined length content: " + e);
-                }
-            }
-            return ret;
-        };
-        if (tag.tagConstructed) {
-            // must have valid content
-            sub = getSub();
-        }
-        else if (tag.isUniversal() && ((tag.tagNumber == 0x03) || (tag.tagNumber == 0x04))) {
-            // sometimes BitString and OctetString are used to encapsulate ASN.1
-            try {
-                if (tag.tagNumber == 0x03) {
-                    if (stream.get() != 0) {
-                        throw new Error("BIT STRINGs with unused bits cannot encapsulate.");
-                    }
-                }
-                sub = getSub();
-                for (var i = 0; i < sub.length; ++i) {
-                    if (sub[i].tag.isEOC()) {
-                        throw new Error("EOC is not supposed to be actual content.");
-                    }
-                }
-            }
-            catch (e) {
-                // but silently ignore when they don't
-                sub = null;
-            }
-        }
-        if (sub === null) {
-            if (len === null) {
-                throw new Error("We can't skip over an invalid tag with undefined length at offset " + start);
-            }
-            stream.pos = start + Math.abs(len);
-        }
-        return new ASN1(streamStart, header, len, tag, sub);
-    };
-    return ASN1;
-}());
-export { ASN1 };
-var ASN1Tag = /** @class */ (function () {
-    function ASN1Tag(stream) {
-        var buf = stream.get();
-        this.tagClass = buf >> 6;
-        this.tagConstructed = ((buf & 0x20) !== 0);
-        this.tagNumber = buf & 0x1F;
-        if (this.tagNumber == 0x1F) { // long tag
-            var n = new Int10();
-            do {
-                buf = stream.get();
-                n.mulAdd(128, buf & 0x7F);
-            } while (buf & 0x80);
-            this.tagNumber = n.simplify();
-        }
-    }
-    ASN1Tag.prototype.isUniversal = function () {
-        return this.tagClass === 0x00;
-    };
-    ASN1Tag.prototype.isEOC = function () {
-        return this.tagClass === 0x00 && this.tagNumber === 0x00;
-    };
-    return ASN1Tag;
-}());
-export { ASN1Tag };