"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getJwkThumbprint = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _jsEncodingUtils = _interopRequireDefault(require("js-encoding-utils"));

var _jsCryptoHash = _interopRequireDefault(require("js-crypto-hash"));

var _buffer = _interopRequireDefault(require("buffer"));

/**
 * thumbprint.js
 */
var Buffer = _buffer.default.Buffer;
/**
 * Compute JWK public key thumbprint specified in RFC7638
 * https://tools.ietf.org/html/rfc7638
 * @param {JsonWebKey} jwkey - A key object in JWK format
 * @param {String} [alg='SHA-256'] - Name of hash algorithm to compute the thumbprint.
 * @param {JwkThumbpirntFormat} [output='binary'] - Output format, 'binary', 'hex' or 'base64'
 * @return {Promise<String|Uint8Array>} - The computed JWK thumbprint.
 */

var getJwkThumbprint =
/*#__PURE__*/
function () {
  var _ref = (0, _asyncToGenerator2.default)(
  /*#__PURE__*/
  _regenerator.default.mark(function _callee(jwkey) {
    var alg,
        output,
        jsonString,
        uint8json,
        thumbPrintBuf,
        _args = arguments;
    return _regenerator.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            alg = _args.length > 1 && _args[1] !== undefined ? _args[1] : 'SHA-256';
            output = _args.length > 2 && _args[2] !== undefined ? _args[2] : 'binary';

            if (!(['hex', 'binary'].indexOf(output) < 0)) {
              _context.next = 4;
              break;
            }

            throw new Error('UnsupportedOutputFormat');

          case 4:
            if (!(jwkey.kty === 'EC')) {
              _context.next = 8;
              break;
            }

            jsonString = JSON.stringify({
              crv: jwkey.crv,
              kty: jwkey.kty,
              x: jwkey.x,
              y: jwkey.y
            });
            _context.next = 13;
            break;

          case 8:
            if (!(jwkey.kty === 'RSA')) {
              _context.next = 12;
              break;
            }

            jsonString = JSON.stringify({
              e: jwkey.e,
              kty: jwkey.kty,
              n: jwkey.n
            });
            _context.next = 13;
            break;

          case 12:
            throw new Error('UnsupportedKeyType');

          case 13:
            uint8json = new Uint8Array(Buffer.from(jsonString, 'utf8'));
            _context.next = 16;
            return _jsCryptoHash.default.compute(uint8json, alg);

          case 16:
            thumbPrintBuf = _context.sent;

            if (!(output === 'hex')) {
              _context.next = 21;
              break;
            }

            return _context.abrupt("return", _jsEncodingUtils.default.encoder.arrayBufferToHexString(thumbPrintBuf));

          case 21:
            if (!(output === 'base64')) {
              _context.next = 25;
              break;
            }

            return _context.abrupt("return", _jsEncodingUtils.default.encoder.encodeBase64(thumbPrintBuf));

          case 25:
            if (!(output === 'binary')) {
              _context.next = 27;
              break;
            }

            return _context.abrupt("return", thumbPrintBuf);

          case 27:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function getJwkThumbprint(_x) {
    return _ref.apply(this, arguments);
  };
}();

exports.getJwkThumbprint = getJwkThumbprint;