// Copyright 2015-2019 AJ ONeal. All rights reserved
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
;(function (exports) {

var Enc = exports.Enc = {};

Enc.bufToBin = function (buf) {
  var bin = '';
  // cannot use .map() because Uint8Array would return only 0s
  buf.forEach(function (ch) {
    bin += String.fromCharCode(ch);
  });
  return bin;
};

Enc.bufToHex = function toHex(u8) {
  var hex = [];
  var i, h;
  var len = (u8.byteLength || u8.length);

  for (i = 0; i < len; i += 1) {
    h = u8[i].toString(16);
    if (h.length % 2) { h = '0' + h; }
    hex.push(h);
  }

  return hex.join('').toLowerCase();
};

Enc.urlBase64ToBase64 = function urlsafeBase64ToBase64(str) {
  var r = str % 4;
  if (2 === r) {
    str += '==';
  } else if (3 === r) {
    str += '=';
  }
  return str.replace(/-/g, '+').replace(/_/g, '/');
};

Enc.base64ToBuf = function (b64) {
  return Enc.binToBuf(atob(b64));
};
Enc.binToBuf = function (bin) {
  var arr = bin.split('').map(function (ch) {
    return ch.charCodeAt(0);
  });
  return 'undefined' !== typeof Uint8Array ? new Uint8Array(arr) : arr;
};
Enc.bufToHex = function (u8) {
  var hex = [];
  var i, h;
  var len = (u8.byteLength || u8.length);

  for (i = 0; i < len; i += 1) {
    h = u8[i].toString(16);
    if (h.length % 2) { h = '0' + h; }
    hex.push(h);
  }

  return hex.join('').toLowerCase();
};
Enc.numToHex = function (d) {
  d = d.toString(16);
  if (d.length % 2) {
    return '0' + d;
  }
  return d;
};

Enc.bufToUrlBase64 = function (u8) {
  return Enc.base64ToUrlBase64(Enc.bufToBase64(u8));
};

Enc.base64ToUrlBase64 = function (str) {
  return str.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
};

Enc.bufToBase64 = function (u8) {
  var bin = '';
  u8.forEach(function (i) {
    bin += String.fromCharCode(i);
  });
  return btoa(bin);
};

Enc.hexToBuf = function (hex) {
  var arr = [];
  hex.match(/.{2}/g).forEach(function (h) {
    arr.push(parseInt(h, 16));
  });
  return 'undefined' !== typeof Uint8Array ? new Uint8Array(arr) : arr;
};

Enc.numToHex = function (d) {
  d = d.toString(16);
  if (d.length % 2) {
    return '0' + d;
  }
  return d;
};


//
// JWK to SSH (tested working)
//
Enc.base64ToHex = function (b64) {
  var bin = atob(Enc.urlBase64ToBase64(b64));
  return Enc.binToHex(bin);
};

Enc.binToHex = function (bin) {
  return bin.split('').map(function (ch) {
    var h = ch.charCodeAt(0).toString(16);
    if (h.length % 2) { h = '0' + h; }
    return h;
  }).join('');
};
// TODO are there any nuance differences here?
Enc.utf8ToHex = Enc.binToHex;

Enc.hexToBase64 = function (hex) {
  return btoa(Enc.hexToBin(hex));
};

Enc.hexToBin = function (hex) {
  return hex.match(/.{2}/g).map(function (h) {
    return String.fromCharCode(parseInt(h, 16));
  }).join('');
};

Enc.urlBase64ToBase64 = function urlsafeBase64ToBase64(str) {
  var r = str % 4;
  if (2 === r) {
    str += '==';
  } else if (3 === r) {
    str += '=';
  }
  return str.replace(/-/g, '+').replace(/_/g, '/');
};


}('undefined' !== typeof exports ? module.exports : window ));
;(function (exports) {
'use strict';

if (!exports.ASN1) { exports.ASN1 = {}; }
if (!exports.Enc) { exports.Enc = {}; }
if (!exports.PEM) { exports.PEM = {}; }

var ASN1 = exports.ASN1;
var Enc = exports.Enc;
var PEM = exports.PEM;

//
// Packer
//

// Almost every ASN.1 type that's important for CSR
// can be represented generically with only a few rules.
exports.ASN1 = function ASN1(/*type, hexstrings...*/) {
  var args = Array.prototype.slice.call(arguments);
  var typ = args.shift();
  var str = args.join('').replace(/\s+/g, '').toLowerCase();
  var len = (str.length/2);
  var lenlen = 0;
  var hex = typ;

  // We can't have an odd number of hex chars
  if (len !== Math.round(len)) {
    throw new Error("invalid hex");
  }

  // The first byte of any ASN.1 sequence is the type (Sequence, Integer, etc)
  // The second byte is either the size of the value, or the size of its size

  // 1. If the second byte is < 0x80 (128) it is considered the size
  // 2. If it is > 0x80 then it describes the number of bytes of the size
  //    ex: 0x82 means the next 2 bytes describe the size of the value
  // 3. The special case of exactly 0x80 is "indefinite" length (to end-of-file)

  if (len > 127) {
    lenlen += 1;
    while (len > 255) {
      lenlen += 1;
      len = len >> 8;
    }
  }

  if (lenlen) { hex += Enc.numToHex(0x80 + lenlen); }
  return hex + Enc.numToHex(str.length/2) + str;
};

// The Integer type has some special rules
ASN1.UInt = function UINT() {
  var str = Array.prototype.slice.call(arguments).join('');
  var first = parseInt(str.slice(0, 2), 16);

  // If the first byte is 0x80 or greater, the number is considered negative
  // Therefore we add a '00' prefix if the 0x80 bit is set
  if (0x80 & first) { str = '00' + str; }

  return ASN1('02', str);
};

// The Bit String type also has a special rule
ASN1.BitStr = function BITSTR() {
  var str = Array.prototype.slice.call(arguments).join('');
  // '00' is a mask of how many bits of the next byte to ignore
  return ASN1('03', '00' + str);
};

ASN1.pack = function (arr) {
  var typ = Enc.numToHex(arr[0]);
  var str = '';
  if (Array.isArray(arr[1])) {
    arr[1].forEach(function (a) {
      str += ASN1.pack(a);
    });
  } else if ('string' === typeof arr[1]) {
    str = arr[1];
  } else {
    throw new Error("unexpected array");
  }
  if ('03' === typ) {
    return ASN1.BitStr(str);
  } else if ('02' === typ) {
    return ASN1.UInt(str);
  } else {
    return ASN1(typ, str);
  }
};
Object.keys(ASN1).forEach(function (k) {
  exports.ASN1[k] = ASN1[k];
});
ASN1 = exports.ASN1;

PEM.packBlock = function (opts) {
  // TODO allow for headers?
  return '-----BEGIN ' + opts.type + '-----\n'
    + Enc.bufToBase64(opts.bytes).match(/.{1,64}/g).join('\n') + '\n'
    + '-----END ' + opts.type + '-----'
  ;
};

Enc.bufToBase64 = function (u8) {
  var bin = '';
  u8.forEach(function (i) {
    bin += String.fromCharCode(i);
  });
  return btoa(bin);
};

Enc.hexToBuf = function (hex) {
  var arr = [];
  hex.match(/.{2}/g).forEach(function (h) {
    arr.push(parseInt(h, 16));
  });
  return 'undefined' !== typeof Uint8Array ? new Uint8Array(arr) : arr;
};

Enc.numToHex = function (d) {
  d = d.toString(16);
  if (d.length % 2) {
    return '0' + d;
  }
  return d;
};

}('undefined' !== typeof window ? window : module.exports));
(function (exports) {
  'use strict';

  var x509 = exports.x509 = {};
  var ASN1 = exports.ASN1;
  var Enc = exports.Enc;

  // 1.2.840.10045.3.1.7
  // prime256v1 (ANSI X9.62 named elliptic curve)
  var OBJ_ID_EC = '06 08 2A8648CE3D030107'.replace(/\s+/g, '').toLowerCase();
  // 1.3.132.0.34
  // secp384r1 (SECG (Certicom) named elliptic curve)
  var OBJ_ID_EC_384 = '06 05 2B81040022'.replace(/\s+/g, '').toLowerCase();
  // 1.2.840.10045.2.1
  // ecPublicKey (ANSI X9.62 public key type)
  var OBJ_ID_EC_PUB = '06 07 2A8648CE3D0201'.replace(/\s+/g, '').toLowerCase();

  x509.parseSec1 = function parseEcOnlyPrivkey(u8, jwk) {
    var index = 7;
    var len = 32;
    var olen = OBJ_ID_EC.length / 2;

    if ("P-384" === jwk.crv) {
      olen = OBJ_ID_EC_384.length / 2;
      index = 8;
      len = 48;
    }
    if (len !== u8[index - 1]) {
      throw new Error("Unexpected bitlength " + len);
    }

    // private part is d
    var d = u8.slice(index, index + len);
    // compression bit index
    var ci = index + len + 2 + olen + 2 + 3;
    var c = u8[ci];
    var x, y;

    if (0x04 === c) {
      y = u8.slice(ci + 1 + len, ci + 1 + len + len);
    } else if (0x02 !== c) {
      throw new Error("not a supported EC private key");
    }
    x = u8.slice(ci + 1, ci + 1 + len);

    return {
      kty: jwk.kty
      , crv: jwk.crv
      , d: Enc.bufToUrlBase64(d)
      //, dh: Enc.bufToHex(d)
      , x: Enc.bufToUrlBase64(x)
      //, xh: Enc.bufToHex(x)
      , y: Enc.bufToUrlBase64(y)
      //, yh: Enc.bufToHex(y)
    };
  };

  x509.packPkcs1 = function (jwk) {
    var n = ASN1.UInt(Enc.base64ToHex(jwk.n));
    var e = ASN1.UInt(Enc.base64ToHex(jwk.e));

    if (!jwk.d) {
      return Enc.hexToBuf(ASN1('30', n, e));
    }

    return Enc.hexToBuf(ASN1('30'
    , ASN1.UInt('00')
    , n
    , e
    , ASN1.UInt(Enc.base64ToHex(jwk.d))
    , ASN1.UInt(Enc.base64ToHex(jwk.p))
    , ASN1.UInt(Enc.base64ToHex(jwk.q))
    , ASN1.UInt(Enc.base64ToHex(jwk.dp))
    , ASN1.UInt(Enc.base64ToHex(jwk.dq))
    , ASN1.UInt(Enc.base64ToHex(jwk.qi))
    ));
  };

  x509.parsePkcs8 = function parseEcPkcs8(u8, jwk) {
    var index = 24 + (OBJ_ID_EC.length / 2);
    var len = 32;
    if ("P-384" === jwk.crv) {
      index = 24 + (OBJ_ID_EC_384.length / 2) + 2;
      len = 48;
    }

    //console.log(index, u8.slice(index));
    if (0x04 !== u8[index]) {
      //console.log(jwk);
      throw new Error("privkey not found");
    }
    var d = u8.slice(index + 2, index + 2 + len);
    var ci = index + 2 + len + 5;
    var xi = ci + 1;
    var x = u8.slice(xi, xi + len);
    var yi = xi + len;
    var y;
    if (0x04 === u8[ci]) {
      y = u8.slice(yi, yi + len);
    } else if (0x02 !== u8[ci]) {
      throw new Error("invalid compression bit (expected 0x04 or 0x02)");
    }

    return {
      kty: jwk.kty
      , crv: jwk.crv
      , d: Enc.bufToUrlBase64(d)
      //, dh: Enc.bufToHex(d)
      , x: Enc.bufToUrlBase64(x)
      //, xh: Enc.bufToHex(x)
      , y: Enc.bufToUrlBase64(y)
      //, yh: Enc.bufToHex(y)
    };
  };

  x509.parseSpki = function parsePem(u8, jwk) {
    var ci = 16 + OBJ_ID_EC.length / 2;
    var len = 32;

    if ("P-384" === jwk.crv) {
      ci = 16 + OBJ_ID_EC_384.length / 2;
      len = 48;
    }

    var c = u8[ci];
    var xi = ci + 1;
    var x = u8.slice(xi, xi + len);
    var yi = xi + len;
    var y;
    if (0x04 === c) {
      y = u8.slice(yi, yi + len);
    } else if (0x02 !== c) {
      throw new Error("not a supported EC private key");
    }

    return {
      kty: jwk.kty
      , crv: jwk.crv
      , x: Enc.bufToUrlBase64(x)
      //, xh: Enc.bufToHex(x)
      , y: Enc.bufToUrlBase64(y)
      //, yh: Enc.bufToHex(y)
    };
  };
  x509.parsePkix = x509.parseSpki;

  x509.packSec1 = function (jwk) {
    var d = Enc.base64ToHex(jwk.d);
    var x = Enc.base64ToHex(jwk.x);
    var y = Enc.base64ToHex(jwk.y);
    var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
    return Enc.hexToBuf(
      ASN1('30'
        , ASN1.UInt('01')
        , ASN1('04', d)
        , ASN1('A0', objId)
        , ASN1('A1', ASN1.BitStr('04' + x + y)))
    );
  };
  /**
   * take a private jwk and creates a der from it
   * @param {*} jwk
   */
  x509.packPkcs8 = function (jwk) {
    if ('RSA' === jwk.kty) {
      if (!jwk.d) {
        // Public RSA
        return Enc.hexToBuf(ASN1('30'
          , ASN1('30'
            , ASN1('06', '2a864886f70d010101')
            , ASN1('05')
          )
          , ASN1.BitStr(ASN1('30'
            , ASN1.UInt(Enc.base64ToHex(jwk.n))
            , ASN1.UInt(Enc.base64ToHex(jwk.e))
          ))
        ));
      }

      // Private RSA
      return Enc.hexToBuf(ASN1('30'
        , ASN1.UInt('00')
        , ASN1('30'
          , ASN1('06', '2a864886f70d010101')
          , ASN1('05')
        )
        , ASN1('04'
          , ASN1('30'
            , ASN1.UInt('00')
            , ASN1.UInt(Enc.base64ToHex(jwk.n))
            , ASN1.UInt(Enc.base64ToHex(jwk.e))
            , ASN1.UInt(Enc.base64ToHex(jwk.d))
            , ASN1.UInt(Enc.base64ToHex(jwk.p))
            , ASN1.UInt(Enc.base64ToHex(jwk.q))
            , ASN1.UInt(Enc.base64ToHex(jwk.dp))
            , ASN1.UInt(Enc.base64ToHex(jwk.dq))
            , ASN1.UInt(Enc.base64ToHex(jwk.qi))
          )
        )
      ));
    }

    var d = Enc.base64ToHex(jwk.d);
    var x = Enc.base64ToHex(jwk.x);
    var y = Enc.base64ToHex(jwk.y);
    var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
    return Enc.hexToBuf(
      ASN1('30'
        , ASN1.UInt('00')
        , ASN1('30'
          , OBJ_ID_EC_PUB
          , objId
        )
        , ASN1('04'
          , ASN1('30'
            , ASN1.UInt('01')
            , ASN1('04', d)
            , ASN1('A1', ASN1.BitStr('04' + x + y)))))
    );
  };
  x509.packSpki = function (jwk) {
    if (/EC/i.test(jwk.kty)) {
      return x509.packSpkiEc(jwk);
    }
    return x509.packSpkiRsa(jwk);
  };
  x509.packSpkiRsa = function (jwk) {
  if (!jwk.d) {
    // Public RSA
    return Enc.hexToBuf(ASN1('30'
      , ASN1('30'
        , ASN1('06', '2a864886f70d010101')
        , ASN1('05')
      )
      , ASN1.BitStr(ASN1('30'
        , ASN1.UInt(Enc.base64ToHex(jwk.n))
        , ASN1.UInt(Enc.base64ToHex(jwk.e))
      ))
    ));
  }

  // Private RSA
  return Enc.hexToBuf(ASN1('30'
    , ASN1.UInt('00')
    , ASN1('30'
      , ASN1('06', '2a864886f70d010101')
      , ASN1('05')
    )
    , ASN1('04'
      , ASN1('30'
        , ASN1.UInt('00')
        , ASN1.UInt(Enc.base64ToHex(jwk.n))
        , ASN1.UInt(Enc.base64ToHex(jwk.e))
        , ASN1.UInt(Enc.base64ToHex(jwk.d))
        , ASN1.UInt(Enc.base64ToHex(jwk.p))
        , ASN1.UInt(Enc.base64ToHex(jwk.q))
        , ASN1.UInt(Enc.base64ToHex(jwk.dp))
        , ASN1.UInt(Enc.base64ToHex(jwk.dq))
        , ASN1.UInt(Enc.base64ToHex(jwk.qi))
      )
    )
  ));
};
  x509.packSpkiEc = function (jwk) {
    var x = Enc.base64ToHex(jwk.x);
    var y = Enc.base64ToHex(jwk.y);
    var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
    return Enc.hexToBuf(
      ASN1('30'
        , ASN1('30'
          , OBJ_ID_EC_PUB
          , objId
        )
        , ASN1.BitStr('04' + x + y))
    );
  };
  x509.packPkix = x509.packSpki;

}('undefined' !== typeof module ? module.exports : window));
/*global Promise*/
(function (exports) {
'use strict';

var EC = exports.Eckles = {};
var x509 = exports.x509;
if ('undefined' !== typeof module) { module.exports = EC; }
var PEM = exports.PEM;
var SSH = exports.SSH;
var Enc = {};
var textEncoder = new TextEncoder();

EC._stance = "We take the stance that if you're knowledgeable enough to"
  + " properly and securely use non-standard crypto then you shouldn't need Bluecrypt anyway.";
EC._universal = "Bluecrypt only supports crypto with standard cross-browser and cross-platform support.";
EC.generate = function (opts) {
  var wcOpts = {};
  if (!opts) { opts = {}; }
  if (!opts.kty) { opts.kty = 'EC'; }

  // ECDSA has only the P curves and an associated bitlength
  wcOpts.name = 'ECDSA';
  if (!opts.namedCurve) {
    opts.namedCurve = 'P-256';
  }
  wcOpts.namedCurve = opts.namedCurve; // true for supported curves
  if (/256/.test(wcOpts.namedCurve)) {
    wcOpts.namedCurve = 'P-256';
    wcOpts.hash = { name: "SHA-256" };
  } else if (/384/.test(wcOpts.namedCurve)) {
    wcOpts.namedCurve = 'P-384';
    wcOpts.hash = { name: "SHA-384" };
  } else {
    return Promise.Reject(new Error("'" + wcOpts.namedCurve + "' is not an NIST approved ECDSA namedCurve. "
      + " Please choose either 'P-256' or 'P-384'. "
      + EC._stance));
  }

  var extractable = true;
  return window.crypto.subtle.generateKey(
    wcOpts
  , extractable
  , [ 'sign', 'verify' ]
  ).then(function (result) {
    return window.crypto.subtle.exportKey(
      "jwk"
    , result.privateKey
    ).then(function (privJwk) {
      privJwk.key_ops = undefined;
      privJwk.ext = undefined;
      return {
        private: privJwk
      , public: EC.neuter({ jwk: privJwk })
      };
    });
  });
};

EC.export = function (opts) {
  return Promise.resolve().then(function () {
    if (!opts || !opts.jwk || 'object' !== typeof opts.jwk) {
      throw new Error("must pass { jwk: jwk } as a JSON object");
    }
    var jwk = JSON.parse(JSON.stringify(opts.jwk));
    var format = opts.format;
    if (opts.public || -1 !== [ 'spki', 'pkix', 'ssh', 'rfc4716' ].indexOf(format)) {
      jwk.d = null;
    }
    if ('EC' !== jwk.kty) {
      throw new Error("options.jwk.kty must be 'EC' for EC keys");
    }
    if (!jwk.d) {
      if (!format || -1 !== [ 'spki', 'pkix' ].indexOf(format)) {
        format = 'spki';
      } else if (-1 !== [ 'ssh', 'rfc4716' ].indexOf(format)) {
        format = 'ssh';
      } else {
        throw new Error("options.format must be 'spki' or 'ssh' for public EC keys, not ("
          + typeof format + ") " + format);
      }
    } else {
      if (!format || 'sec1' === format) {
        format = 'sec1';
      } else if ('pkcs8' !== format) {
        throw new Error("options.format must be 'sec1' or 'pkcs8' for private EC keys, not '" + format + "'");
      }
    }
    if (-1 === [ 'P-256', 'P-384' ].indexOf(jwk.crv)) {
      throw new Error("options.jwk.crv must be either P-256 or P-384 for EC keys, not '" + jwk.crv + "'");
    }
    if (!jwk.y) {
      throw new Error("options.jwk.y must be a urlsafe base64-encoded either P-256 or P-384");
    }

    if ('sec1' === format) {
      return PEM.packBlock({ type: "EC PRIVATE KEY", bytes: x509.packSec1(jwk) });
    } else if ('pkcs8' === format) {
      return PEM.packBlock({ type: "PRIVATE KEY", bytes: x509.packPkcs8(jwk) });
    } else if (-1 !== [ 'spki', 'pkix' ].indexOf(format)) {
      return PEM.packBlock({ type: "PUBLIC KEY", bytes: x509.packSpki(jwk) });
    } else if (-1 !== [ 'ssh', 'rfc4716' ].indexOf(format)) {
      return SSH.packSsh(jwk);
    } else {
      throw new Error("Sanity Error: reached unreachable code block with format: " + format);
    }
  });
};
EC.pack = function (opts) {
  return Promise.resolve().then(function () {
    return EC.exportSync(opts);
  });
};

// Chopping off the private parts is now part of the public API.
// I thought it sounded a little too crude at first, but it really is the best name in every possible way.
EC.neuter = function (opts) {
  // trying to find the best balance of an immutable copy with custom attributes
  var jwk = {};
  Object.keys(opts.jwk).forEach(function (k) {
    if ('undefined' === typeof opts.jwk[k]) { return; }
    // ignore EC private parts
    if ('d' === k) { return; }
    jwk[k] = JSON.parse(JSON.stringify(opts.jwk[k]));
  });
  return jwk;
};

// https://stackoverflow.com/questions/42588786/how-to-fingerprint-a-jwk
EC.__thumbprint = function (jwk) {
  // Use the same entropy for SHA as for key
  var alg = 'SHA-256';
  if (/384/.test(jwk.crv)) {
    alg = 'SHA-384';
  }
  return window.crypto.subtle.digest(
    { name: alg }
  , textEncoder.encode('{"crv":"' + jwk.crv + '","kty":"EC","x":"' + jwk.x + '","y":"' + jwk.y + '"}')
  ).then(function (hash) {
    return Enc.bufToUrlBase64(new Uint8Array(hash));
  });
};

EC.thumbprint = function (opts) {
  return Promise.resolve().then(function () {
    var jwk;
    if ('EC' === opts.kty) {
      jwk = opts;
    } else if (opts.jwk) {
      jwk = opts.jwk;
    } else {
      return EC.import(opts).then(function (jwk) {
        return EC.__thumbprint(jwk);
      });
    }
    return EC.__thumbprint(jwk);
  });
};

Enc.bufToUrlBase64 = function (u8) {
  return Enc.bufToBase64(u8)
    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
};

Enc.bufToBase64 = function (u8) {
  var bin = '';
  u8.forEach(function (i) {
    bin += String.fromCharCode(i);
  });
  return btoa(bin);
};

}('undefined' !== typeof module ? module.exports : window));
/*global Promise*/
(function (exports) {
'use strict';

var RSA = exports.Rasha = {};
var x509 = exports.x509;
if ('undefined' !== typeof module) { module.exports = RSA; }
var PEM = exports.PEM;
var SSH = exports.SSH;
var Enc = {};
var textEncoder = new TextEncoder();

RSA._stance = "We take the stance that if you're knowledgeable enough to"
  + " properly and securely use non-standard crypto then you shouldn't need Bluecrypt anyway.";
RSA._universal = "Bluecrypt only supports crypto with standard cross-browser and cross-platform support.";
RSA.generate = function (opts) {
  var wcOpts = {};
  if (!opts) { opts = {}; }
  if (!opts.kty) { opts.kty = 'RSA'; }

  // Support PSS? I don't think it's used for Let's Encrypt
  wcOpts.name = 'RSASSA-PKCS1-v1_5';
  if (!opts.modulusLength) {
    opts.modulusLength = 2048;
  }
  wcOpts.modulusLength = opts.modulusLength;
  if (wcOpts.modulusLength >= 2048 && wcOpts.modulusLength < 3072) {
    // erring on the small side... for no good reason
    wcOpts.hash = { name: "SHA-256" };
  } else if (wcOpts.modulusLength >= 3072 && wcOpts.modulusLength < 4096) {
    wcOpts.hash = { name: "SHA-384" };
  } else if (wcOpts.modulusLength < 4097) {
    wcOpts.hash = { name: "SHA-512" };
  } else {
    // Public key thumbprints should be paired with a hash of similar length,
    // so anything above SHA-512's keyspace would be left under-represented anyway.
    return Promise.Reject(new Error("'" + wcOpts.modulusLength + "' is not within the safe and universally"
      + " acceptable range of 2048-4096. Typically you should pick 2048, 3072, or 4096, though other values"
      + " divisible by 8 are allowed. " + RSA._stance));
  }
  // TODO maybe allow this to be set to any of the standard values?
  wcOpts.publicExponent = new Uint8Array([0x01, 0x00, 0x01]);

  var extractable = true;
  return window.crypto.subtle.generateKey(
    wcOpts
  , extractable
  , [ 'sign', 'verify' ]
  ).then(function (result) {
    return window.crypto.subtle.exportKey(
      "jwk"
    , result.privateKey
    ).then(function (privJwk) {
      return {
        private: privJwk
      , public: RSA.neuter({ jwk: privJwk })
      };
    });
  });
};

// Chopping off the private parts is now part of the public API.
// I thought it sounded a little too crude at first, but it really is the best name in every possible way.
RSA.neuter = function (opts) {
  // trying to find the best balance of an immutable copy with custom attributes
  var jwk = {};
  Object.keys(opts.jwk).forEach(function (k) {
    if ('undefined' === typeof opts.jwk[k]) { return; }
    // ignore RSA private parts
    if (-1 !== ['d', 'p', 'q', 'dp', 'dq', 'qi'].indexOf(k)) { return; }
    jwk[k] = JSON.parse(JSON.stringify(opts.jwk[k]));
  });
  return jwk;
};

// https://stackoverflow.com/questions/42588786/how-to-fingerprint-a-jwk
RSA.__thumbprint = function (jwk) {
  // Use the same entropy for SHA as for key
  var len = Math.floor(jwk.n.length * 0.75);
  var alg = 'SHA-256';
  // TODO this may be a bug
  // need to confirm that the padding is no more or less than 1 byte
  if (len >= 511) {
    alg = 'SHA-512';
  } else if (len >= 383) {
    alg = 'SHA-384';
  }
  return window.crypto.subtle.digest(
    { name: alg }
  , textEncoder.encode('{"e":"' + jwk.e + '","kty":"RSA","n":"' + jwk.n + '"}')
  ).then(function (hash) {
    return Enc.bufToUrlBase64(new Uint8Array(hash));
  });
};

RSA.thumbprint = function (opts) {
  return Promise.resolve().then(function () {
    var jwk;
    if ('EC' === opts.kty) {
      jwk = opts;
    } else if (opts.jwk) {
      jwk = opts.jwk;
    } else {
      return RSA.import(opts).then(function (jwk) {
        return RSA.__thumbprint(jwk);
      });
    }
    return RSA.__thumbprint(jwk);
  });
};

RSA.export = function (opts) {
  return Promise.resolve().then(function () {
    if (!opts || !opts.jwk || 'object' !== typeof opts.jwk) {
      throw new Error("must pass { jwk: jwk }");
    }
    var jwk = JSON.parse(JSON.stringify(opts.jwk));
    var format = opts.format;
    var pub = opts.public;
    if (pub || -1 !== [ 'spki', 'pkix', 'ssh', 'rfc4716' ].indexOf(format)) {
      jwk = RSA.neuter({ jwk: jwk });
    }
    if ('RSA' !== jwk.kty) {
      throw new Error("options.jwk.kty must be 'RSA' for RSA keys");
    }
    if (!jwk.p) {
      // TODO test for n and e
      pub = true;
      if (!format || 'pkcs1' === format) {
        format = 'pkcs1';
      } else if (-1 !== [ 'spki', 'pkix' ].indexOf(format)) {
        format = 'spki';
      } else if (-1 !== [ 'ssh', 'rfc4716' ].indexOf(format)) {
        format = 'ssh';
      } else {
        throw new Error("options.format must be 'spki', 'pkcs1', or 'ssh' for public RSA keys, not ("
          + typeof format + ") " + format);
      }
    } else {
      // TODO test for all necessary keys (d, p, q ...)
      if (!format || 'pkcs1' === format) {
        format = 'pkcs1';
      } else if ('pkcs8' !== format) {
        throw new Error("options.format must be 'pkcs1' or 'pkcs8' for private RSA keys");
      }
    }

    if ('pkcs1' === format) {
      if (jwk.d) {
        return PEM.packBlock({ type: "RSA PRIVATE KEY", bytes: x509.packPkcs1(jwk) });
      } else {
        return PEM.packBlock({ type: "RSA PUBLIC KEY", bytes: x509.packPkcs1(jwk) });
      }
    } else if ('pkcs8' === format) {
      return PEM.packBlock({ type: "PRIVATE KEY", bytes: x509.packPkcs8(jwk) });
    } else if (-1 !== [ 'spki', 'pkix' ].indexOf(format)) {
      return PEM.packBlock({ type: "PUBLIC KEY", bytes: x509.packSpki(jwk) });
    } else if (-1 !== [ 'ssh', 'rfc4716' ].indexOf(format)) {
      return SSH.pack({ jwk: jwk, comment: opts.comment });
    } else {
      throw new Error("Sanity Error: reached unreachable code block with format: " + format);
    }
  });
};
RSA.pack = function (opts) {
  // wrapped in a promise for API compatibility
  // with the forthcoming browser version
  // (and potential future native node capability)
  return Promise.resolve().then(function () {
    return RSA.export(opts);
  });
};

Enc.bufToUrlBase64 = function (u8) {
  return Enc.bufToBase64(u8)
    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
};

Enc.bufToBase64 = function (u8) {
  var bin = '';
  u8.forEach(function (i) {
    bin += String.fromCharCode(i);
  });
  return btoa(bin);
};

}('undefined' !== typeof module ? module.exports : window));
/*global Promise*/
(function (exports) {
'use strict';

var Keypairs = exports.Keypairs = {};
var Rasha = exports.Rasha;
var Eckles = exports.Eckles;
var Enc = exports.Enc || {};

Keypairs._stance = "We take the stance that if you're knowledgeable enough to"
  + " properly and securely use non-standard crypto then you shouldn't need Bluecrypt anyway.";
Keypairs._universal = "Bluecrypt only supports crypto with standard cross-browser and cross-platform support.";
Keypairs.generate = function (opts) {
  opts = opts || {};
  var p;
  if (!opts.kty) { opts.kty = opts.type; }
  if (!opts.kty) { opts.kty = 'EC'; }
  if (/^EC/i.test(opts.kty)) {
    p = Eckles.generate(opts);
  } else if (/^RSA$/i.test(opts.kty)) {
    p = Rasha.generate(opts);
  } else {
    return Promise.Reject(new Error("'" + opts.kty + "' is not a well-supported key type."
      + Keypairs._universal
      + " Please choose 'EC', or 'RSA' if you have good reason to."));
  }
  return p.then(function (pair) {
    return Keypairs.thumbprint({ jwk: pair.public }).then(function (thumb) {
      pair.private.kid = thumb; // maybe not the same id on the private key?
      pair.public.kid = thumb;
      return pair;
    });
  });
};

Keypairs.export = function (opts) {
  return Eckles.export(opts).catch(function (err) {
    return Rasha.export(opts).catch(function () {
      return Promise.reject(err);
    });
  });
};


/**
 * Chopping off the private parts is now part of the public API.
 * I thought it sounded a little too crude at first, but it really is the best name in every possible way.
 */
Keypairs.neuter = function (opts) {
  /** trying to find the best balance of an immutable copy with custom attributes */
  var jwk = {};
  Object.keys(opts.jwk).forEach(function (k) {
    if ('undefined' === typeof opts.jwk[k]) { return; }
    // ignore RSA and EC private parts
    if (-1 !== ['d', 'p', 'q', 'dp', 'dq', 'qi'].indexOf(k)) { return; }
    jwk[k] = JSON.parse(JSON.stringify(opts.jwk[k]));
  });
  return jwk;
};

Keypairs.thumbprint = function (opts) {
  return Promise.resolve().then(function () {
    if (/EC/i.test(opts.jwk.kty)) {
      return Eckles.thumbprint(opts);
    } else {
      return Rasha.thumbprint(opts);
    }
  });
};

Keypairs.publish = function (opts) {
  if ('object' !== typeof opts.jwk || !opts.jwk.kty) { throw new Error("invalid jwk: " + JSON.stringify(opts.jwk)); }

  /** returns a copy */
  var jwk = Keypairs.neuter(opts);

  if (jwk.exp) {
    jwk.exp = setTime(jwk.exp);
  } else {
    if (opts.exp) { jwk.exp = setTime(opts.exp); }
    else if (opts.expiresIn) { jwk.exp = Math.round(Date.now()/1000) + opts.expiresIn; }
    else if (opts.expiresAt) { jwk.exp = opts.expiresAt; }
  }
  if (!jwk.use && false !== jwk.use) { jwk.use = "sig"; }

  if (jwk.kid) { return Promise.resolve(jwk); }
  return Keypairs.thumbprint({ jwk: jwk }).then(function (thumb) { jwk.kid = thumb; return jwk; });
};

// JWT a.k.a. JWS with Claims using Compact Serialization
Keypairs.signJwt = function (opts) {
  return Keypairs.thumbprint({ jwk: opts.jwk }).then(function (thumb) {
    var header = opts.header || {};
    var claims = JSON.parse(JSON.stringify(opts.claims || {}));
    header.typ = 'JWT';

    if (!header.kid) { header.kid = thumb; }
    if (!header.alg && opts.alg) { header.alg = opts.alg; }
    if (!claims.iat && (false === claims.iat || false === opts.iat)) {
      claims.iat = undefined;
    } else if (!claims.iat) {
      claims.iat = Math.round(Date.now()/1000);
    }

    if (opts.exp) {
      claims.exp = setTime(opts.exp);
    } else if (!claims.exp && (false === claims.exp || false === opts.exp)) {
      claims.exp = undefined;
    } else if (!claims.exp) {
      throw new Error("opts.claims.exp should be the expiration date as seconds, human form (i.e. '1h' or '15m') or false");
    }

    if (opts.iss) { claims.iss = opts.iss; }
    if (!claims.iss && (false === claims.iss || false === opts.iss)) {
      claims.iss = undefined;
    } else if (!claims.iss) {
      throw new Error("opts.claims.iss should be in the form of https://example.com/, a secure OIDC base url");
    }

    return Keypairs.signJws({
      jwk: opts.jwk
    , pem: opts.pem
    , protected: header
    , header: undefined
    , payload: claims
    }).then(function (jws) {
      return [ jws.protected, jws.payload, jws.signature ].join('.');
    });
  });
};

Keypairs.signJws = function (opts) {
  return Keypairs.thumbprint(opts).then(function (thumb) {

    function alg() {
      if (!opts.jwk) {
        throw new Error("opts.jwk must exist and must declare 'typ'");
      }
      if (opts.jwk.alg) { return opts.jwk.alg; }
      var typ = ('RSA' === opts.jwk.kty) ? "RS" : "ES";
      return typ + Keypairs._getBits(opts);
    }

    function sign() {
      var protect = opts.protected;
      var payload = opts.payload;

      // Compute JWS signature
      var protectedHeader = "";
      // Because unprotected headers are allowed, regrettably...
      // https://stackoverflow.com/a/46288694
      if (false !== protect) {
        if (!protect) { protect = {}; }
        if (!protect.alg) { protect.alg = alg(); }
        // There's a particular request where ACME / Let's Encrypt explicitly doesn't use a kid
        if (false === protect.kid) { protect.kid = undefined; }
        else if (!protect.kid) { protect.kid = thumb; }
        protectedHeader = JSON.stringify(protect);
      }

      // Not sure how to handle the empty case since ACME POST-as-GET must be empty
      //if (!payload) {
      //  throw new Error("opts.payload should be JSON, string, or ArrayBuffer (it may be empty, but that must be explicit)");
      //}
      // Trying to detect if it's a plain object (not Buffer, ArrayBuffer, Array, Uint8Array, etc)
      if (payload && ('string' !== typeof payload)
        && ('undefined' === typeof payload.byteLength)
        && ('undefined' === typeof payload.buffer)
      ) {
        payload = JSON.stringify(payload);
      }
      // Converting to a buffer, even if it was just converted to a string
      if ('string' === typeof payload) {
        payload = Enc.binToBuf(payload);
      }

      // node specifies RSA-SHAxxx even when it's actually ecdsa (it's all encoded x509 shasums anyway)
      var protected64 = Enc.strToUrlBase64(protectedHeader);
      var payload64 = Enc.bufToUrlBase64(payload);
      var msg = protected64 + '.' + payload64;

      return Keypairs._sign(opts, msg).then(function (buf) {
        var signedMsg = {
          protected: protected64
        , payload: payload64
        , signature: Enc.bufToUrlBase64(buf)
        };

        return signedMsg;
      });
    }

    if (opts.jwk) {
      return sign();
    } else {
      return Keypairs.import({ pem: opts.pem }).then(function (pair) {
        opts.jwk = pair.private;
        return sign();
      });
    }
  });
};

Keypairs._sign = function (opts, payload) {
  return Keypairs._import(opts).then(function (privkey) {
    if ('string' === typeof payload) {
      payload = (new TextEncoder()).encode(payload);
    }
    return window.crypto.subtle.sign(
      { name: Keypairs._getName(opts)
      , hash: { name: 'SHA-' + Keypairs._getBits(opts) }
      }
    , privkey
    , payload
    ).then(function (signature) {
      signature = new Uint8Array(signature); // ArrayBuffer -> u8
      // This will come back into play for CSRs, but not for JOSE
      if ('EC' === opts.jwk.kty && /x509|asn1/i.test(opts.format)) {
        return Keypairs._ecdsaJoseSigToAsn1Sig(signature);
      } else {
        // jose/jws/jwt
        return signature;
      }
    });
  });
};
Keypairs._getBits = function (opts) {
  if (opts.alg) { return opts.alg.replace(/[a-z\-]/ig, ''); }
  // base64 len to byte len
  var len = Math.floor((opts.jwk.n||'').length * 0.75);

  // TODO this may be a bug
  // need to confirm that the padding is no more or less than 1 byte
  if (/521/.test(opts.jwk.crv) || len >= 511) {
    return '512';
  } else if (/384/.test(opts.jwk.crv) || len >= 383) {
    return '384';
  }

  return '256';
};
Keypairs._getName = function (opts) {
  if (/EC/i.test(opts.jwk.kty)) {
    return 'ECDSA';
  } else {
    return 'RSASSA-PKCS1-v1_5';
  }
};
Keypairs._import = function (opts) {
  return Promise.resolve().then(function () {
    var ops;
    // all private keys just happen to have a 'd'
    if (opts.jwk.d) {
      ops = [ 'sign' ];
    } else {
      ops = [ 'verify' ];
    }
    // gotta mark it as extractable, as if it matters
    opts.jwk.ext = true;
    opts.jwk.key_ops = ops;

    return window.crypto.subtle.importKey(
      "jwk"
    , opts.jwk
    , { name: Keypairs._getName(opts)
      , namedCurve: opts.jwk.crv
      , hash: { name: 'SHA-' + Keypairs._getBits(opts) } }
    , true
    , ops
    ).then(function (privkey) {
      delete opts.jwk.ext;
      return privkey;
    });
  });
};
// ECDSA JOSE / JWS / JWT signatures differ from "normal" ASN1/X509 ECDSA signatures
// https://tools.ietf.org/html/rfc7518#section-3.4
Keypairs._ecdsaJoseSigToAsn1Sig = function (bufsig) {
  // it's easier to do the manipulation in the browser with an array
  bufsig = Array.from(bufsig);
  var hlen = bufsig.length / 2; // should be even
  var r = bufsig.slice(0, hlen);
  var s = bufsig.slice(hlen);
  // unpad positive ints less than 32 bytes wide
  while (!r[0]) { r = r.slice(1); }
  while (!s[0]) { s = s.slice(1); }
  // pad (or re-pad) ambiguously non-negative BigInts, up to 33 bytes wide
  if (0x80 & r[0]) { r.unshift(0); }
  if (0x80 & s[0]) { s.unshift(0); }

  var len = 2 + r.length + 2 + s.length;
  var head = [0x30];
  // hard code 0x80 + 1 because it won't be longer than
  // two SHA512 plus two pad bytes (130 bytes <= 256)
  if (len >= 0x80) { head.push(0x81); }
  head.push(len);

  return Uint8Array.from(head.concat([0x02, r.length], r, [0x02, s.length], s));
};

function setTime(time) {
  if ('number' === typeof time) { return time; }

  var t = time.match(/^(\-?\d+)([dhms])$/i);
  if (!t || !t[0]) {
    throw new Error("'" + time + "' should be datetime in seconds or human-readable format (i.e. 3d, 1h, 15m, 30s");
  }

  var now = Math.round(Date.now()/1000);
  var num = parseInt(t[1], 10);
  var unit = t[2];
  var mult = 1;
  switch(unit) {
    // fancy fallthrough, what fun!
    case 'd':
      mult *= 24;
      /*falls through*/
    case 'h':
      mult *= 60;
      /*falls through*/
    case 'm':
      mult *= 60;
      /*falls through*/
    case 's':
      mult *= 1;
  }

  return now + (mult * num);
}

Enc.hexToBuf = function (hex) {
  var arr = [];
  hex.match(/.{2}/g).forEach(function (h) {
    arr.push(parseInt(h, 16));
  });
  return 'undefined' !== typeof Uint8Array ? new Uint8Array(arr) : arr;
};
Enc.strToUrlBase64 = function (str) {
  return Enc.bufToUrlBase64(Enc.binToBuf(str));
};
Enc.binToBuf = function (bin) {
  var arr = bin.split('').map(function (ch) {
    return ch.charCodeAt(0);
  });
  return 'undefined' !== typeof Uint8Array ? new Uint8Array(arr) : arr;
};

}('undefined' !== typeof module ? module.exports : window));
// Copyright 2018 AJ ONeal. All rights reserved
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
;(function (exports) {
'use strict';

if (!exports.ASN1) { exports.ASN1 = {}; }
if (!exports.Enc) { exports.Enc = {}; }
if (!exports.PEM) { exports.PEM = {}; }

var ASN1 = exports.ASN1;
var Enc = exports.Enc;
var PEM = exports.PEM;

//
// Parser
//

// Although I've only seen 9 max in https certificates themselves,
// but each domain list could have up to 100
ASN1.ELOOPN = 102;
ASN1.ELOOP = "uASN1.js Error: iterated over " + ASN1.ELOOPN + "+ elements (probably a malformed file)";
// I've seen https certificates go 29 deep
ASN1.EDEEPN = 60;
ASN1.EDEEP = "uASN1.js Error: element nested " + ASN1.EDEEPN + "+ layers deep (probably a malformed file)";
// Container Types are Sequence 0x30, Container Array? (0xA0, 0xA1)
// Value Types are Boolean 0x01, Integer 0x02, Null 0x05, Object ID 0x06, String 0x0C, 0x16, 0x13, 0x1e Value Array? (0x82)
// Bit String (0x03) and Octet String (0x04) may be values or containers
// Sometimes Bit String is used as a container (RSA Pub Spki)
ASN1.CTYPES = [ 0x30, 0x31, 0xa0, 0xa1 ];
ASN1.VTYPES = [ 0x01, 0x02, 0x05, 0x06, 0x0c, 0x82 ];
ASN1.parse = function parseAsn1Helper(buf) {
  //var ws = '  ';
  function parseAsn1(buf, depth, eager) {
    if (depth.length >= ASN1.EDEEPN) { throw new Error(ASN1.EDEEP); }

    var index = 2; // we know, at minimum, data starts after type (0) and lengthSize (1)
    var asn1 = { type: buf[0], lengthSize: 0, length: buf[1] };
    var child;
    var iters = 0;
    var adjust = 0;
    var adjustedLen;

    // Determine how many bytes the length uses, and what it is
    if (0x80 & asn1.length) {
      asn1.lengthSize = 0x7f & asn1.length;
      // I think that buf->hex->int solves the problem of Endianness... not sure
      asn1.length = parseInt(Enc.bufToHex(buf.slice(index, index + asn1.lengthSize)), 16);
      index += asn1.lengthSize;
    }

    // High-order bit Integers have a leading 0x00 to signify that they are positive.
    // Bit Streams use the first byte to signify padding, which x.509 doesn't use.
    if (0x00 === buf[index] && (0x02 === asn1.type || 0x03 === asn1.type)) {
      // However, 0x00 on its own is a valid number
      if (asn1.length > 1) {
        index += 1;
        adjust = -1;
      }
    }
    adjustedLen = asn1.length + adjust;

    //console.warn(depth.join(ws) + '0x' + Enc.numToHex(asn1.type), index, 'len:', asn1.length, asn1);

    function parseChildren(eager) {
      asn1.children = [];
      //console.warn('1 len:', (2 + asn1.lengthSize + asn1.length), 'idx:', index, 'clen:', 0);
      while (iters < ASN1.ELOOPN && index < (2 + asn1.length + asn1.lengthSize)) {
        iters += 1;
        depth.length += 1;
        child = parseAsn1(buf.slice(index, index + adjustedLen), depth, eager);
        depth.length -= 1;
        // The numbers don't match up exactly and I don't remember why...
        // probably something with adjustedLen or some such, but the tests pass
        index += (2 + child.lengthSize + child.length);
        //console.warn('2 len:', (2 + asn1.lengthSize + asn1.length), 'idx:', index, 'clen:', (2 + child.lengthSize + child.length));
        if (index > (2 + asn1.lengthSize + asn1.length)) {
          if (!eager) { console.error(JSON.stringify(asn1, ASN1._replacer, 2)); }
          throw new Error("Parse error: child value length (" + child.length
            + ") is greater than remaining parent length (" + (asn1.length - index)
            + " = " + asn1.length + " - " + index + ")");
        }
        asn1.children.push(child);
        //console.warn(depth.join(ws) + '0x' + Enc.numToHex(asn1.type), index, 'len:', asn1.length, asn1);
      }
      if (index !== (2 + asn1.lengthSize + asn1.length)) {
        //console.warn('index:', index, 'length:', (2 + asn1.lengthSize + asn1.length));
        throw new Error("premature end-of-file");
      }
      if (iters >= ASN1.ELOOPN) { throw new Error(ASN1.ELOOP); }

      delete asn1.value;
      return asn1;
    }

    // Recurse into types that are _always_ containers
    if (-1 !== ASN1.CTYPES.indexOf(asn1.type)) { return parseChildren(eager); }

    // Return types that are _always_ values
    asn1.value = buf.slice(index, index + adjustedLen);
    if (-1 !== ASN1.VTYPES.indexOf(asn1.type)) { return asn1; }

    // For ambigious / unknown types, recurse and return on failure
    // (and return child array size to zero)
    try { return parseChildren(true); }
    catch(e) { asn1.children.length = 0; return asn1; }
  }

  var asn1 = parseAsn1(buf, []);
  var len = buf.byteLength || buf.length;
  if (len !== 2 + asn1.lengthSize + asn1.length) {
    throw new Error("Length of buffer does not match length of ASN.1 sequence.");
  }
  return asn1;
};
ASN1._replacer = function (k, v) {
  if ('type' === k) { return '0x' + Enc.numToHex(v); }
  if (v && 'value' === k) { return '0x' + Enc.bufToHex(v.data || v); }
  return v;
};

// don't replace the full parseBlock, if it exists
PEM.parseBlock = PEM.parseBlock || function (str) {
  var der = str.split(/\n/).filter(function (line) {
    return !/-----/.test(line);
  }).join('');
  return { bytes: Enc.base64ToBuf(der) };
};

Enc.base64ToBuf = function (b64) {
  return Enc.binToBuf(atob(b64));
};
Enc.binToBuf = function (bin) {
  var arr = bin.split('').map(function (ch) {
    return ch.charCodeAt(0);
  });
  return 'undefined' !== typeof Uint8Array ? new Uint8Array(arr) : arr;
};
Enc.bufToHex = function (u8) {
  var hex = [];
  var i, h;
  var len = (u8.byteLength || u8.length);

  for (i = 0; i < len; i += 1) {
    h = u8[i].toString(16);
    if (h.length % 2) { h = '0' + h; }
    hex.push(h);
  }

  return hex.join('').toLowerCase();
};
Enc.numToHex = function (d) {
  d = d.toString(16);
  if (d.length % 2) {
    return '0' + d;
  }
  return d;
};

}('undefined' !== typeof window ? window : module.exports));
// Copyright 2018-present AJ ONeal. All rights reserved
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
(function (exports) {
'use strict';
/*global Promise*/

var ASN1 = exports.ASN1;
var Enc = exports.Enc;
var PEM = exports.PEM;
var X509 = exports.x509;
var Keypairs = exports.Keypairs;

// TODO find a way that the prior node-ish way of `module.exports = function () {}` isn't broken
var CSR = exports.CSR = function (opts) {
  // We're using a Promise here to be compatible with the browser version
  // which will probably use the webcrypto API for some of the conversions
  return CSR._prepare(opts).then(function (opts) {
    return CSR.create(opts).then(function (bytes) {
      return CSR._encode(opts, bytes);
    });
  });
};

CSR._prepare = function (opts) {
  return Promise.resolve().then(function () {
    var Keypairs;
    opts = JSON.parse(JSON.stringify(opts));

    // We do a bit of extra error checking for user convenience
    if (!opts) { throw new Error("You must pass options with key and domains to rsacsr"); }
    if (!Array.isArray(opts.domains) || 0 === opts.domains.length) {
      new Error("You must pass options.domains as a non-empty array");
    }

    // I need to check that 例.中国 is a valid domain name
    if (!opts.domains.every(function (d) {
      // allow punycode? xn--
      if ('string' === typeof d /*&& /\./.test(d) && !/--/.test(d)*/) {
        return true;
      }
    })) {
      throw new Error("You must pass options.domains as strings");
    }

    if (opts.jwk) { return opts; }
    if (opts.key && opts.key.kty) {
      opts.jwk = opts.key;
      return opts;
    }
    if (!opts.pem && !opts.key) {
      throw new Error("You must pass options.key as a JSON web key");
    }

    Keypairs = exports.Keypairs;
    if (!exports.Keypairs) {
      throw new Error("Keypairs.js is an optional dependency for PEM-to-JWK.\n"
        + "Install it if you'd like to use it:\n"
        + "\tnpm install --save rasha\n"
        + "Otherwise supply a jwk as the private key."
      );
    }

    return Keypairs.import({ pem: opts.pem || opts.key }).then(function (pair) {
      opts.jwk = pair.private;
      return opts;
    });
  });
};

CSR._encode = function (opts, bytes) {
  if ('der' === (opts.encoding||'').toLowerCase()) {
    return bytes;
  }
  return PEM.packBlock({
    type: "CERTIFICATE REQUEST"
  , bytes: bytes /* { jwk: jwk, domains: opts.domains } */
  });
};

CSR.create = function createCsr(opts) {
  var hex = CSR.request(opts.jwk, opts.domains);
  return CSR._sign(opts.jwk, hex).then(function (csr) {
    return Enc.hexToBuf(csr);
  });
};

//
// EC / RSA
//
CSR.request = function createCsrBodyEc(jwk, domains) {
  var asn1pub;
  if (/^EC/i.test(jwk.kty)) {
    asn1pub = X509.packCsrEcPublicKey(jwk);
  } else {
    asn1pub = X509.packCsrRsaPublicKey(jwk);
  }
  return X509.packCsr(asn1pub, domains);
};

CSR._sign = function csrEcSig(jwk, request) {
  // Took some tips from https://gist.github.com/codermapuche/da4f96cdb6d5ff53b7ebc156ec46a10a
  // TODO will have to convert web ECDSA signatures to PEM ECDSA signatures (but RSA should be the same)
  // TODO have a consistent non-private way to sign
  return Keypairs._sign({ jwk: jwk, format: 'x509' }, Enc.hexToBuf(request)).then(function (sig) {
    return CSR._toDer({ request: request, signature: sig, kty: jwk.kty });
  });
};

CSR._toDer = function encode(opts) {
  var sty;
  if (/^EC/i.test(opts.kty)) {
    // 1.2.840.10045.4.3.2 ecdsaWithSHA256 (ANSI X9.62 ECDSA algorithm with SHA256)
    sty = ASN1('30', ASN1('06', '2a8648ce3d040302'));
  } else {
    // 1.2.840.113549.1.1.11 sha256WithRSAEncryption (PKCS #1)
    sty = ASN1('30', ASN1('06', '2a864886f70d01010b'), ASN1('05'));
  }
  return ASN1('30'
    // The Full CSR Request Body
  , opts.request
    // The Signature Type
  , sty
    // The Signature
  , ASN1.BitStr(Enc.bufToHex(opts.signature))
  );
};

X509.packCsr = function (asn1pubkey, domains) {
  return ASN1('30'
    // Version (0)
  , ASN1.UInt('00')

    // 2.5.4.3 commonName (X.520 DN component)
  , ASN1('30', ASN1('31', ASN1('30', ASN1('06', '550403'), ASN1('0c', Enc.utf8ToHex(domains[0])))))

    // Public Key (RSA or EC)
  , asn1pubkey

    // Request Body
  , ASN1('a0'
    , ASN1('30'
        // 1.2.840.113549.1.9.14 extensionRequest (PKCS #9 via CRMF)
      , ASN1('06', '2a864886f70d01090e')
      , ASN1('31'
        , ASN1('30'
          , ASN1('30'
              // 2.5.29.17 subjectAltName (X.509 extension)
            , ASN1('06', '551d11')
            , ASN1('04'
              , ASN1('30', domains.map(function (d) {
                  return ASN1('82', Enc.utf8ToHex(d));
                }).join(''))))))))
  );
};

// TODO finish this later
// we want to parse the domains, the public key, and verify the signature
CSR._info = function (der) {
  // standard base64 PEM
  if ('string' === typeof der && '-' === der[0]) {
    der = PEM.parseBlock(der).bytes;
  }
  // jose urlBase64 not-PEM
  if ('string' === typeof der) {
    der = Enc.base64ToBuf(der);
  }
  // not supporting binary-encoded bas64
  var c = ASN1.parse(der);
  var kty;
  // A cert has 3 parts: cert, signature meta, signature
  if (c.children.length !== 3) {
    throw new Error("doesn't look like a certificate request: expected 3 parts of header");
  }
  var sig = c.children[2];
  if (sig.children.length) {
    // ASN1/X509 EC
    sig = sig.children[0];
    sig = ASN1('30', ASN1.UInt(Enc.bufToHex(sig.children[0].value)), ASN1.UInt(Enc.bufToHex(sig.children[1].value)));
    sig = Enc.hexToBuf(sig);
    kty = 'EC';
  } else {
    // Raw RSA Sig
    sig = sig.value;
    kty = 'RSA';
  }
  //c.children[1]; // signature type
  var req = c.children[0];
  // TODO utf8
  if (4 !== req.children.length) {
    throw new Error("doesn't look like a certificate request: expected 4 parts to request");
  }
  // 0 null
  // 1 commonName / subject
  var sub = Enc.bufToBin(req.children[1].children[0].children[0].children[1].value);
  // 3 public key (type, key)
  //console.log('oid', Enc.bufToHex(req.children[2].children[0].children[0].value));
  var pub;
  // TODO reuse ASN1 parser for these?
  if ('EC' === kty) {
    // throw away compression byte
    pub = req.children[2].children[1].value.slice(1);
    pub = { kty: kty, x: pub.slice(0, 32), y: pub.slice(32) };
    while (0 === pub.x[0]) { pub.x = pub.x.slice(1); }
    while (0 === pub.y[0]) { pub.y = pub.y.slice(1); }
    if ((pub.x.length || pub.x.byteLength) > 48) {
      pub.crv = 'P-521';
    } else if ((pub.x.length || pub.x.byteLength) > 32) {
      pub.crv = 'P-384';
    } else {
      pub.crv = 'P-256';
    }
    pub.x = Enc.bufToUrlBase64(pub.x);
    pub.y = Enc.bufToUrlBase64(pub.y);
  } else {
    pub = req.children[2].children[1].children[0];
    pub = { kty: kty, n: pub.children[0].value, e: pub.children[1].value };
    while (0 === pub.n[0]) { pub.n = pub.n.slice(1); }
    while (0 === pub.e[0]) { pub.e = pub.e.slice(1); }
    pub.n = Enc.bufToUrlBase64(pub.n);
    pub.e = Enc.bufToUrlBase64(pub.e);
  }
  // 4 extensions
  var domains = req.children[3].children.filter(function (seq) {
    //  1.2.840.113549.1.9.14 extensionRequest (PKCS #9 via CRMF)
    if ('2a864886f70d01090e' === Enc.bufToHex(seq.children[0].value)) {
      return true;
    }
  }).map(function (seq) {
    return seq.children[1].children[0].children.filter(function (seq2) {
      // subjectAltName (X.509 extension)
      if ('551d11' === Enc.bufToHex(seq2.children[0].value)) {
        return true;
      }
    }).map(function (seq2) {
      return seq2.children[1].children[0].children.map(function (name) {
        // TODO utf8
        return Enc.bufToBin(name.value);
      });
    })[0];
  })[0];

  return {
    subject: sub
  , altnames: domains
  , jwk: pub
  , signature: sig
  };
};

X509.packCsrRsaPublicKey = function (jwk) {
  // Sequence the key
  var n = ASN1.UInt(Enc.base64ToHex(jwk.n));
  var e = ASN1.UInt(Enc.base64ToHex(jwk.e));
  var asn1pub = ASN1('30', n, e);

  // Add the CSR pub key header
  return ASN1('30', ASN1('30', ASN1('06', '2a864886f70d010101'), ASN1('05')), ASN1.BitStr(asn1pub));
};

X509.packCsrEcPublicKey = function (jwk) {
  var ecOid = X509._oids[jwk.crv];
  if (!ecOid) {
    throw new Error("Unsupported namedCurve '" + jwk.crv + "'. Supported types are " + Object.keys(X509._oids));
  }
  var cmp = '04'; // 04 == x+y, 02 == x-only
  var hxy = '';
  // Placeholder. I'm not even sure if compression should be supported.
  if (!jwk.y) { cmp = '02'; }
  hxy += Enc.base64ToHex(jwk.x);
  if (jwk.y) { hxy += Enc.base64ToHex(jwk.y); }

  // 1.2.840.10045.2.1 ecPublicKey
  return ASN1('30', ASN1('30', ASN1('06', '2a8648ce3d0201'), ASN1('06', ecOid)), ASN1.BitStr(cmp + hxy));
};
X509._oids = {
  // 1.2.840.10045.3.1.7 prime256v1
  // (ANSI X9.62 named elliptic curve) (06 08 - 2A 86 48 CE 3D 03 01 07)
  'P-256': '2a8648ce3d030107'
  // 1.3.132.0.34 P-384 (06 05 - 2B 81 04 00 22)
  // (SEC 2 recommended EC domain secp256r1)
, 'P-384': '2b81040022'
  // requires more logic and isn't a recommended standard
  // 1.3.132.0.35 P-521 (06 05 - 2B 81 04 00 23)
  // (SEC 2 alternate P-521)
//, 'P-521': '2B 81 04 00 23'
};

// don't replace the full parseBlock, if it exists
PEM.parseBlock = PEM.parseBlock || function (str) {
  var der = str.split(/\n/).filter(function (line) {
    return !/-----/.test(line);
  }).join('');
  return { bytes: Enc.base64ToBuf(der) };
};

}('undefined' === typeof window ? module.exports : window));
// Copyright 2018-present AJ ONeal. All rights reserved
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
(function (exports) {
'use strict';
/* globals Promise */

var ACME = exports.ACME = {};
//var Keypairs = exports.Keypairs || {};
//var CSR = exports.CSR;
var Enc = exports.Enc || {};
var Crypto = exports.Crypto || {};

ACME.formatPemChain = function formatPemChain(str) {
  return str.trim().replace(/[\r\n]+/g, '\n').replace(/\-\n\-/g, '-\n\n-') + '\n';
};
ACME.splitPemChain = function splitPemChain(str) {
  return str.trim().split(/[\r\n]{2,}/g).map(function (str) {
    return str + '\n';
  });
};


// http-01: GET https://example.org/.well-known/acme-challenge/{{token}} => {{keyAuth}}
// dns-01: TXT _acme-challenge.example.org. => "{{urlSafeBase64(sha256(keyAuth))}}"
ACME.challengePrefixes = {
  'http-01': '/.well-known/acme-challenge'
, 'dns-01': '_acme-challenge'
};
ACME.challengeTests = {
  'http-01': function (me, auth) {
    return me.http01(auth).then(function (keyAuth) {
      var err;

      // TODO limit the number of bytes that are allowed to be downloaded
      if (auth.keyAuthorization === (keyAuth||'').trim()) {
        return true;
      }

      err = new Error(
        "Error: Failed HTTP-01 Pre-Flight / Dry Run.\n"
      + "curl '" + auth.challengeUrl + "'\n"
      + "Expected: '" + auth.keyAuthorization + "'\n"
      + "Got: '" + keyAuth + "'\n"
      + "See https://git.coolaj86.com/coolaj86/acme-v2.js/issues/4"
      );
      err.code = 'E_FAIL_DRY_CHALLENGE';
      return Promise.reject(err);
    });
  }
, 'dns-01': function (me, auth) {
    // remove leading *. on wildcard domains
    return me.dns01(auth).then(function (ans) {
      var err;

      if (ans.answer.some(function (txt) {
        return auth.dnsAuthorization === txt.data[0];
      })) {
        return true;
      }

      err = new Error(
        "Error: Failed DNS-01 Pre-Flight Dry Run.\n"
      + "dig TXT '" + auth.dnsHost + "' does not return '" + auth.dnsAuthorization + "'\n"
      + "See https://git.coolaj86.com/coolaj86/acme-v2.js/issues/4"
      );
      err.code = 'E_FAIL_DRY_CHALLENGE';
      return Promise.reject(err);
    });
  }
};

ACME._directory = function (me) {
  // GET-as-GET ok
  return me.request({ method: 'GET', url: me.directoryUrl, json: true });
};
ACME._getNonce = function (me) {
  // GET-as-GET, HEAD-as-HEAD ok
  var nonce;
  while (true) {
    nonce = me._nonces.shift();
    if (!nonce) { break; }
    if (Date.now() - nonce.createdAt > (15 * 60 * 1000)) {
      nonce = null;
    } else {
      break;
    }
  }
  if (nonce) { return Promise.resolve(nonce.nonce); }
  return me.request({ method: 'HEAD', url: me._directoryUrls.newNonce }).then(function (resp) {
    return resp.headers['replay-nonce'];
  });
};
ACME._setNonce = function (me, nonce) {
  me._nonces.unshift({ nonce: nonce, createdAt: Date.now() });
};
// ACME RFC Section 7.3 Account Creation
/*
 {
   "protected": base64url({
     "alg": "ES256",
     "jwk": {...},
     "nonce": "6S8IqOGY7eL2lsGoTZYifg",
     "url": "https://example.com/acme/new-account"
   }),
   "payload": base64url({
     "termsOfServiceAgreed": true,
     "onlyReturnExisting": false,
     "contact": [
       "mailto:cert-admin@example.com",
       "mailto:admin@example.com"
     ]
   }),
   "signature": "RZPOnYoPs1PhjszF...-nh6X1qtOFPB519I"
 }
*/
ACME._registerAccount = function (me, options) {
  if (me.debug) { console.debug('[acme-v2] accounts.create'); }

  return new Promise(function (resolve, reject) {

    function agree(tosUrl) {
      var err;
      if (me._tos !== tosUrl) {
        err = new Error("You must agree to the ToS at '" + me._tos + "'");
        err.code = "E_AGREE_TOS";
        reject(err);
        return;
      }

      return ACME._importKeypair(me, options.accountKeypair).then(function (pair) {
        var contact;
        if (options.contact) {
          contact = options.contact.slice(0);
        } else if (options.email) {
          contact = [ 'mailto:' + options.email ];
        }
        var body = {
          termsOfServiceAgreed: tosUrl === me._tos
        , onlyReturnExisting: false
        , contact: contact
        };
        var pExt;
        if (options.externalAccount) {
          pExt = me.Keypairs.signJws({
            // TODO is HMAC the standard, or is this arbitrary?
            secret: options.externalAccount.secret
          , protected: {
              alg: options.externalAccount.alg || "HS256"
            , kid: options.externalAccount.id
            , url: me._directoryUrls.newAccount
            }
          , payload: Enc.binToBuf(JSON.stringify(pair.public))
          }).then(function (jws) {
            body.externalAccountBinding = jws;
            return body;
          });
        } else {
          pExt = Promise.resolve(body);
        }
        return pExt.then(function (body) {
          var payload = JSON.stringify(body);
          return ACME._jwsRequest(me, {
            options: options
          , url: me._directoryUrls.newAccount
          , protected: { kid: false, jwk: pair.public }
          , payload: Enc.binToBuf(payload)
          }).then(function (resp) {
            var account = resp.body;

            if (2 !== Math.floor(resp.statusCode / 100)) {
              throw new Error('account error: ' + JSON.stringify(resp.body));
            }

            var location = resp.headers.location;
            // the account id url
            options._kid = location;
            if (me.debug) { console.debug('[DEBUG] new account location:'); }
            if (me.debug) { console.debug(location); }
            if (me.debug) { console.debug(resp); }

            /*
            {
              contact: ["mailto:jon@example.com"],
              orders: "https://some-url",
              status: 'valid'
            }
            */
            if (!account) { account = { _emptyResponse: true }; }
            // https://git.coolaj86.com/coolaj86/acme-v2.js/issues/8
            if (!account.key) { account.key = {}; }
            account.key.kid = options._kid;
            return account;
          }).then(resolve, reject);
        });
      });
    }

    if (me.debug) { console.debug('[acme-v2] agreeToTerms'); }
    if (1 === options.agreeToTerms.length) {
      // newer promise API
      return Promise.resolve(options.agreeToTerms(me._tos)).then(agree, reject);
    }
    else if (2 === options.agreeToTerms.length) {
      // backwards compat cb API
      return options.agreeToTerms(me._tos, function (err, tosUrl) {
        if (!err) { agree(tosUrl); return; }
        reject(err);
      });
    }
    else {
      reject(new Error('agreeToTerms has incorrect function signature.'
        + ' Should be fn(tos) { return Promise<tos>; }'));
    }
  });
};
/*
 POST /acme/new-order HTTP/1.1
 Host: example.com
 Content-Type: application/jose+json

 {
   "protected": base64url({
     "alg": "ES256",
     "kid": "https://example.com/acme/acct/1",
     "nonce": "5XJ1L3lEkMG7tR6pA00clA",
     "url": "https://example.com/acme/new-order"
   }),
   "payload": base64url({
     "identifiers": [{"type:"dns","value":"example.com"}],
     "notBefore": "2016-01-01T00:00:00Z",
     "notAfter": "2016-01-08T00:00:00Z"
   }),
   "signature": "H6ZXtGjTZyUnPeKn...wEA4TklBdh3e454g"
 }
*/
ACME._getChallenges = function (me, options, authUrl) {
  if (me.debug) { console.debug('\n[DEBUG] getChallenges\n'); }
  // TODO POST-as-GET

  return ACME._jwsRequest(me, {
    options: options
  , protected: { kid: options._kid }
  , payload: ''
  , url: authUrl
  }).then(function (resp) {
    // Pre-emptive rather than lazy for interfaces that need to show the challenges to the user first
    return ACME._challengesToAuth(me, options, resp.body, false).then(function (auths) {
      resp.body._rawChallenges = resp.body.challenges;
      resp.body.challenges = auths;
      return resp.body;
    });
  });
};
ACME._wait = function wait(ms) {
  return new Promise(function (resolve) {
    setTimeout(resolve, (ms || 1100));
  });
};

ACME._testChallengeOptions = function () {
  var chToken = ACME._prnd(16);
  return [
    {
      "type": "http-01",
      "status": "pending",
      "url": "https://acme-staging-v02.example.com/0",
      "token": "test-" + chToken + "-0"
    }
  , {
      "type": "dns-01",
      "status": "pending",
      "url": "https://acme-staging-v02.example.com/1",
      "token": "test-" + chToken + "-1",
      "_wildcard": true
    }
  , {
      "type": "tls-alpn-01",
      "status": "pending",
      "url": "https://acme-staging-v02.example.com/3",
      "token": "test-" + chToken + "-3"
    }
  ];
};
ACME._testChallenges = function (me, options) {
  var CHECK_DELAY = 0;
  return Promise.all(options.domains.map(function (identifierValue) {
    // TODO we really only need one to pass, not all to pass
    var challenges = ACME._testChallengeOptions();
    if (identifierValue.includes("*")) {
      challenges = challenges.filter(function (ch) { return ch._wildcard; });
    }

    // The dry-run comes first in the spirit of "fail fast"
    // (and protecting against challenge failure rate limits)
    var dryrun = true;
    var resp = {
      body: {
        identifier: {
          type: "dns"
        , value: identifierValue.replace(/^\*\./, '')
        }
      , challenges: challenges
      , expires: new Date(Date.now() + (60 * 1000)).toISOString()
      , wildcard: identifierValue.includes('*.') || undefined
      }
    };
    return ACME._challengesToAuth(me, options, resp.body, dryrun).then(function (auths) {
      resp.body._rawChallenges = resp.body.challenges;
      resp.body.challenges = auths;

      var auth = ACME._chooseAuth(options, resp.body.challenges);
      if (!auth) {
        // For example, wildcards require dns-01 and, if we don't have that, we have to bail
        var enabled = Object.keys(options.challenges).join(', ') || 'none';
        var suitable = resp.body.challenges.map(function (r) { return r.type; }).join(', ') || 'none';
        return Promise.reject(new Error(
          "None of the challenge types that you've enabled ( " + enabled + " )"
            + " are suitable for validating the domain you've selected (" + identifierValue + ")."
            + " You must enable one of ( " + suitable + " )."
        ));
      }

      // TODO remove skipChallengeTest
      if (me.skipDryRun || me.skipChallengeTest) {
        return null;
      }

      if ('dns-01' === auth.type) {
        // Give the nameservers a moment to propagate
        CHECK_DELAY = 1.5 * 1000;
      }

      if (!me._canUse[auth.type]) { return; }
      return ACME._setChallenge(me, options, auth).then(function () {
        return auth;
      });
    });
  })).then(function (auths) {
    auths = auths.filter(Boolean);
    if (!auths.length) { /*skip actual test*/ return; }
    return ACME._wait(CHECK_DELAY).then(function () {
      return Promise.all(auths.map(function (auth) {
        return ACME.challengeTests[auth.type](me, auth).then(function (result) {
          // not a blocker
          ACME._removeChallenge(me, options, auth);
          return result;
        });
      }));
    });
  });
};
ACME._chooseAuth = function(options, auths) {
  // For each of the challenge types that we support
  var auth;
  var challengeTypes = Object.keys(options.challenges);
  // ordered from most to least preferred
  challengeTypes = (options.challengePriority||[ 'tls-alpn-01', 'http-01', 'dns-01' ]).filter(function (chType) {
    return challengeTypes.includes(chType);
  });

  challengeTypes.some(function (chType) {
    // And for each of the challenge types that are allowed
    return auths.some(function (ch) {
      // Check to see if there are any matches
      if (ch.type === chType) {
        auth = ch;
        return true;
      }
    });
  });

  return auth;
};
ACME._challengesToAuth = function (me, options, request, dryrun) {
  // we don't poison the dns cache with our dummy request
  var dnsPrefix = ACME.challengePrefixes['dns-01'];
  if (dryrun) {
    dnsPrefix = dnsPrefix.replace('acme-challenge', 'greenlock-dryrun-' + ACME._prnd(4));
  }
  var challengeTypes = Object.keys(options.challenges);

  return ACME._importKeypair(me, options.accountKeypair).then(function (pair) {
    return me.Keypairs.thumbprint({ jwk: pair.public }).then(function (thumb) {
      return Promise.all(request.challenges.map(function (challenge) {
        // Don't do extra work for challenges that we can't satisfy
        if (!challengeTypes.includes(challenge.type)) {
          return null;
        }

        var auth = {};

        // straight copy from the new order response
        // { identifier, status, expires, challenges, wildcard }
        Object.keys(request).forEach(function (key) {
          auth[key] = request[key];
        });

        // copy from the challenge we've chosen
        // { type, status, url, token }
        // (note the duplicate status overwrites the one above, but they should be the same)
        Object.keys(challenge).forEach(function (key) {
          // don't confused devs with the id url
          auth[key] = challenge[key];
        });

        // batteries-included helpers
        auth.hostname = auth.identifier.value;
        // because I'm not 100% clear if the wildcard identifier does or doesn't have the leading *. in all cases
        auth.altname = ACME._untame(auth.identifier.value, auth.wildcard);

        auth.thumbprint = thumb;
        //   keyAuthorization = token || '.' || base64url(JWK_Thumbprint(accountKey))
        auth.keyAuthorization = challenge.token + '.' + auth.thumbprint;

        if ('http-01' === auth.type) {
          // conflicts with ACME challenge id url is already in use, so we call this challengeUrl instead
          // TODO auth.http01Url ?
          auth.challengeUrl = 'http://' + auth.identifier.value + ACME.challengePrefixes['http-01'] + '/' + auth.token;
          return auth;
        }

        if ('dns-01' !== auth.type) {
          return auth;
        }

        return Crypto._sha('sha256', auth.keyAuthorization).then(function (hash) {
          auth.dnsHost = dnsPrefix + '.' + auth.hostname.replace('*.', '');
          auth.dnsAuthorization = hash;
          auth.keyAuthorizationDigest = hash;
          return auth;
        });
      })).then(function (auths) {
        return auths.filter(Boolean);
      });
    });
  });
};

ACME._untame = function (name, wild) {
  if (wild) { name = '*.' + name.replace('*.', ''); }
  return name;
};

// https://tools.ietf.org/html/draft-ietf-acme-acme-10#section-7.5.1
ACME._postChallenge = function (me, options, auth) {
  var RETRY_INTERVAL = me.retryInterval || 1000;
  var DEAUTH_INTERVAL = me.deauthWait || 10 * 1000;
  var MAX_POLL = me.retryPoll || 8;
  var MAX_PEND = me.retryPending || 4;
  var count = 0;

  var altname = ACME._untame(auth.identifier.value, auth.wildcard);

  /*
   POST /acme/authz/1234 HTTP/1.1
   Host: example.com
   Content-Type: application/jose+json

   {
     "protected": base64url({
       "alg": "ES256",
       "kid": "https://example.com/acme/acct/1",
       "nonce": "xWCM9lGbIyCgue8di6ueWQ",
       "url": "https://example.com/acme/authz/1234"
     }),
     "payload": base64url({
       "status": "deactivated"
     }),
     "signature": "srX9Ji7Le9bjszhu...WTFdtujObzMtZcx4"
   }
   */
  function deactivate() {
    if (me.debug) { console.debug('[acme-v2.js] deactivate:'); }
    return ACME._jwsRequest(me, {
      options: options
    , url: auth.url
    , protected: { kid: options._kid }
    , payload: Enc.binToBuf(JSON.stringify({ "status": "deactivated" }))
    }).then(function (resp) {
      if (me.debug) { console.debug('deactivate challenge: resp.body:'); }
      if (me.debug) { console.debug(resp.body); }
      return ACME._wait(DEAUTH_INTERVAL);
    });
  }

  function pollStatus() {
    if (count >= MAX_POLL) {
      return Promise.reject(new Error(
        "[acme-v2] stuck in bad pending/processing state for '" + altname + "'"
      ));
    }

    count += 1;

    if (me.debug) { console.debug('\n[DEBUG] statusChallenge\n'); }
    // TODO POST-as-GET
    return me.request({ method: 'GET', url: auth.url, json: true }).then(function (resp) {
      if ('processing' === resp.body.status) {
        if (me.debug) { console.debug('poll: again'); }
        return ACME._wait(RETRY_INTERVAL).then(pollStatus);
      }

      // This state should never occur
      if ('pending' === resp.body.status) {
        if (count >= MAX_PEND) {
          return ACME._wait(RETRY_INTERVAL).then(deactivate).then(respondToChallenge);
        }
        if (me.debug) { console.debug('poll: again'); }
        return ACME._wait(RETRY_INTERVAL).then(respondToChallenge);
      }

      if ('valid' === resp.body.status) {
        if (me.debug) { console.debug('poll: valid'); }

        try {
          ACME._removeChallenge(me, options, auth);
        } catch(e) {}
        return resp.body;
      }

      var err;
      if (resp.body.error && resp.body.error.detail) {
        err = new Error("[acme-v2] " + auth.altname + " state:" + resp.body.status + " " + resp.body.error.detail);
        err.auth = auth;
        err.altname = auth.altname;
        err.type = auth.type;
        err.urn = resp.body.error.type;
        err.code = ('invalid' === resp.body.status) ? 'E_CHALLENGE_INVALID' : 'E_CHALLENGE_UNKNOWN';
        err.uri = resp.body.url;
      } else {
        err = new Error("[acme-v2] " + auth.altname + " (E_STATE_UKN): " + JSON.stringify(resp.body, null, 2));
        err.code = 'E_CHALLENGE_UNKNOWN';
      }

      return Promise.reject(err);
    });
  }

  function respondToChallenge() {
    if (me.debug) { console.debug('[acme-v2.js] responding to accept challenge:'); }
    return ACME._jwsRequest(me, {
      options: options
    , url: auth.url
    , protected: { kid: options._kid }
    , payload: Enc.binToBuf(JSON.stringify({}))
    }).then(function (resp) {
      if (me.debug) { console.debug('respond to challenge: resp.body:'); }
      if (me.debug) { console.debug(resp.body); }
      return ACME._wait(RETRY_INTERVAL).then(pollStatus);
    });
  }

  return respondToChallenge();
};
ACME._setChallenge = function (me, options, auth) {
  return new Promise(function (resolve, reject) {
    var challengers = options.challenges || {};
    var challenger = (challengers[auth.type] && challengers[auth.type].set) || options.setChallenge;
    try {
      if (1 === challenger.length) {
        challenger(auth).then(resolve).catch(reject);
      } else if (2 === challenger.length) {
        challenger(auth, function (err) {
          if(err) { reject(err); } else { resolve(); }
        });
      } else {
        // TODO remove this old backwards-compat
        var challengeCb = function(err) {
          if(err) { reject(err); } else { resolve(); }
        };
        // for backwards compat adding extra keys without changing params length
        Object.keys(auth).forEach(function (key) {
          challengeCb[key] = auth[key];
        });
        if (!ACME._setChallengeWarn) {
          console.warn("Please update to acme-v2 setChallenge(options) <Promise> or setChallenge(options, cb).");
          console.warn("The API has been changed for compatibility with all ACME / Let's Encrypt challenge types.");
          ACME._setChallengeWarn = true;
        }
        challenger(auth.identifier.value, auth.token, auth.keyAuthorization, challengeCb);
      }
    } catch(e) {
      reject(e);
    }
  }).then(function () {
    // TODO: Do we still need this delay? Or shall we leave it to plugins to account for themselves?
    var DELAY = me.setChallengeWait || 500;
    if (me.debug) { console.debug('\n[DEBUG] waitChallengeDelay %s\n', DELAY); }
    return ACME._wait(DELAY);
  });
};
ACME._setChallengesAll = function (me, options) {
  var order = options.order;
  var setAuths = order.authorizations.slice(0);
  var claims = order.claims.slice(0);
  var validAuths = [];
  var auths = [];

  function setNext() {
    var authUrl = setAuths.shift();
    var claim = claims.shift();
    if (!authUrl) { return Promise.resolve(); }

    // var domain = options.domains[i]; // claim.identifier.value

    // If it's already valid, we're golden it regardless
    if (claim.challenges.some(function (ch) { return 'valid' === ch.status; })) {
      return setNext();
    }

    var auth = ACME._chooseAuth(options, claim.challenges);
    if (!auth) {
      // For example, wildcards require dns-01 and, if we don't have that, we have to bail
      return Promise.reject(new Error(
        "Server didn't offer any challenge we can handle for '" + options.domains.join() + "'."
      ));
    }

    auths.push(auth);
    return ACME._setChallenge(me, options, auth).then(setNext);
  }

  function checkNext() {
    var auth = auths.shift();
    if (!auth) { return; }

    if (!me._canUse[auth.type] || me.skipChallengeTest) {
      // not so much "valid" as "not invalid"
      // but in this case we can't confirm either way
      validAuths.push(auth);
      return Promise.resolve();
    }

    return ACME.challengeTests[auth.type](me, auth).then(function () {
      validAuths.push(auth);
    }).then(checkNext);
  }

  // Actually sets the challenge via ACME
  function challengeNext() {
    var auth = validAuths.shift();
    if (!auth) { return; }
    return ACME._postChallenge(me, options, auth).then(challengeNext);
  }

  // First we set every challenge
  // Then we ask for each challenge to be checked
  // Doing otherwise would potentially cause us to poison our own DNS cache with misses
  return setNext().then(checkNext).then(challengeNext).then(function () {
    if (me.debug) { console.debug("[getCertificate] next.then"); }
    console.log('DEBUG 1 order:');
    console.log(order);
    return order.identifiers.map(function (ident) {
      return ident.value;
    });
  });
};
ACME._finalizeOrder = function (me, options) {
  return ACME._getAccountKid(me, options).then(function () {
    return ACME._setChallengesAll(me, options).then(function () {
      // options._kid added
      if (me.debug) { console.debug('finalizeOrder:'); }
      var order = options.order;
      var validatedDomains = options.order.identifiers.map(function (ident) {
        return ident.value;
      });
      return ACME._getCsrWeb64(me, options, validatedDomains).then(function (csr) {
        var body = { csr: csr };
        var payload = JSON.stringify(body);

        function pollCert() {
          if (me.debug) { console.debug('[acme-v2.js] pollCert:'); }
          return ACME._jwsRequest(me, {
            options: options
          , url: options.order.finalizeUrl
          , protected: { kid: options._kid }
          , payload: Enc.binToBuf(payload)
          }).then(function (resp) {
            if (me.debug) { console.debug('order finalized: resp.body:'); }
            if (me.debug) { console.debug(resp.body); }

            // https://tools.ietf.org/html/draft-ietf-acme-acme-12#section-7.1.3
            // Possible values are: "pending" => ("invalid" || "ready") => "processing" => "valid"
            if ('valid' === resp.body.status) {
              options._expires = resp.body.expires;
              options._certificate = resp.body.certificate;

              return resp.body; // return order
            }

            if ('processing' === resp.body.status) {
              return ACME._wait().then(pollCert);
            }

            if (me.debug) { console.debug("Error: bad status:\n" + JSON.stringify(resp.body, null, 2)); }

            if ('pending' === resp.body.status) {
              return Promise.reject(new Error(
                "Did not finalize order: status 'pending'."
              + " Best guess: You have not accepted at least one challenge for each domain:\n"
              + "Requested: '" + options.domains.join(', ') + "'\n"
              + "Validated: '" + validatedDomains.join(', ') + "'\n"
              + JSON.stringify(resp.body, null, 2)
              ));
            }

            if ('invalid' === resp.body.status) {
              return Promise.reject(new Error(
                "Did not finalize order: status 'invalid'."
              + " Best guess: One or more of the domain challenges could not be verified"
              + " (or the order was canceled).\n"
              + "Requested: '" + options.domains.join(', ') + "'\n"
              + "Validated: '" + validatedDomains.join(', ') + "'\n"
              + JSON.stringify(resp.body, null, 2)
              ));
            }

            if ('ready' === resp.body.status) {
              return Promise.reject(new Error(
                "Did not finalize order: status 'ready'."
              + " Hmmm... this state shouldn't be possible here. That was the last state."
              + " This one should at least be 'processing'.\n"
              + "Requested: '" + options.domains.join(', ') + "'\n"
              + "Validated: '" + validatedDomains.join(', ') + "'\n"
              + JSON.stringify(resp.body, null, 2) + "\n\n"
              + "Please open an issue at https://git.coolaj86.com/coolaj86/acme-v2.js"
              ));
            }

            return Promise.reject(new Error(
              "Didn't finalize order: Unhandled status '" + resp.body.status + "'."
            + " This is not one of the known statuses...\n"
            + "Requested: '" + options.domains.join(', ') + "'\n"
            + "Validated: '" + validatedDomains.join(', ') + "'\n"
            + JSON.stringify(resp.body, null, 2) + "\n\n"
            + "Please open an issue at https://git.coolaj86.com/coolaj86/acme-v2.js"
            ));
          });
        }

        return pollCert();
      }).then(function () {
        if (me.debug) { console.debug('acme-v2: order was finalized'); }
        // TODO POST-as-GET
        return me.request({ method: 'GET', url: options._certificate, json: true }).then(function (resp) {
          if (me.debug) { console.debug('acme-v2: csr submitted and cert received:'); }
          // https://github.com/certbot/certbot/issues/5721
          var certsarr = ACME.splitPemChain(ACME.formatPemChain((resp.body||'')));
          //  cert, chain, fullchain, privkey, /*TODO, subject, altnames, issuedAt, expiresAt */
          var certs = {
            expires: order.expires
          , identifiers: order.identifiers
          //, authorizations: order.authorizations
          , cert: certsarr.shift()
          //, privkey: privkeyPem
          , chain: certsarr.join('\n')
          };
          if (me.debug) { console.debug(certs); }
          return certs;
        });
      });
    });
  });
};
ACME._createOrder = function (me, options) {
  return ACME._getAccountKid(me, options).then(function () {
      // options._kid added
    var body = {
      // raw wildcard syntax MUST be used here
      identifiers: options.domains.sort(function (a, b) {
        // the first in the list will be the subject of the certificate, I believe (and hope)
        if (!options.subject) { return 0; }
        if (options.subject === a) { return -1; }
        if (options.subject === b) { return 1; }
        return 0;
      }).map(function (hostname) {
        return { type: "dns", value: hostname };
      })
      //, "notBefore": "2016-01-01T00:00:00Z"
      //, "notAfter": "2016-01-08T00:00:00Z"
    };

    var payload = JSON.stringify(body);
    if (me.debug) { console.debug('\n[DEBUG] newOrder\n'); }
    return ACME._jwsRequest(me, {
      options: options
    , url: me._directoryUrls.newOrder
    , protected: { kid: options._kid }
    , payload: Enc.binToBuf(payload)
    }).then(function (resp) {
      var order = {
        orderUrl: resp.headers.location
      , finalizeUrl: resp.body.finalize
      , authorizations: resp.body.authorizations
      , identifiers: body.identifiers
      , _response: resp.body
      };
      if (me.debug) { console.debug('[ordered]', location); } // the account id url
      if (me.debug) { console.debug(resp); }

      if (!order.authorizations) {
        return Promise.reject(new Error(
          "[acme-v2.js] authorizations were not fetched for '" + options.domains.join() + "':\n"
          + JSON.stringify(resp.body)
        ));
      }

      return order;
    }).then(function (order) {
      var claims = [];
      if (me.debug) { console.debug("[acme-v2] POST newOrder has authorizations"); }
      var challengeAuths = order.authorizations.slice(0);

      function getNext() {
        var authUrl = challengeAuths.shift();
        if (!authUrl) { return claims; }

        return ACME._getChallenges(me, options, authUrl).then(function (claim) {
          // var domain = options.domains[i]; // claim.identifier.value
          claims.push(claim);
          return getNext();
        });
      }

      return getNext().then(function () {
        order.claims = claims;
        options.order = order;
        return order;
      });
    });
  });
};
ACME._getAccountKid = function (me, options) {
  // It's just fine if there's no account, we'll go get the key id we need via the existing key
  options._kid = options._kid || options.accountKid
    || (options.account && (options.account.kid
      || (options.account.key && options.account.key.kid)));
  if (options._kid) {
    return Promise.resolve(options._kid);
  }

  //return Promise.reject(new Error("must include KeyID"));
  // This is an idempotent request. It'll return the same account for the same public key.
  return ACME._registerAccount(me, options).then(function (account) {
    options._kid = account.key.kid;
    // start back from the top
    return options._kid;
  });
};
// _kid
// registerAccount
// postChallenge
// finalizeOrder
// getCertificate
ACME._getCertificate = function (me, options) {
  if (me.debug) { console.debug('[acme-v2] DEBUG get cert 1'); }

  if (options.csr) {
    // TODO validate csr signature
    options._csr = me.CSR._info(options.csr);
    options.domains = options._csr.altnames;
    if (options._csr.subject !== options.domains[0]) {
      return Promise.reject(new Error("certificate subject (commonName) does not match first altname (SAN)"));
    }
  }
  if (!(options.domains && options.domains.length)) {
    return Promise.reject(new Error("options.domains must be a list of string domain names,"
    + " with the first being the subject of the certificate (or options.subject must specified)."));
  }

  // Do a little dry-run / self-test
  return ACME._testChallenges(me, options).then(function () {
    if (me.debug) { console.debug('[acme-v2] certificates.create'); }
    return ACME._createOrder(me, options).then(function (/*order*/) {
      // options.order = order;
      return ACME._finalizeOrder(me, options);
    });
  });
};
ACME._getCsrWeb64 = function (me, options, validatedDomains) {
  var csr;
  if (options.csr) {
    csr = options.csr;
    // if der, convert to base64
    if ('string' !== typeof csr) { csr = Enc.bufToUrlBase64(csr); }
    // nix PEM headers, if any
    if ('-' === csr[0]) { csr = csr.split(/\n+/).slice(1, -1).join(''); }
    csr = Enc.base64ToUrlBase64(csr.trim().replace(/\s+/g, ''));
    return Promise.resolve(csr);
  }

  return ACME._importKeypair(me, options.serverKeypair || options.domainKeypair).then(function (pair) {
    return me.CSR({ jwk: pair.private, domains: validatedDomains, encoding: 'der' }).then(function (der) {
      return Enc.bufToUrlBase64(der);
    });
  });
};

ACME.create = function create(me) {
  if (!me) { me = {}; }
  // me.debug = true;
  me.challengePrefixes = ACME.challengePrefixes;
  me.Keypairs = me.Keypairs || exports.Keypairs || require('keypairs').Keypairs;
  me.CSR = me.CSR || exports.CSR || require('CSR').CSR;
  me._nonces = [];
  me._canUse = {};
  if (!me._baseUrl) {
    me._baseUrl = "";
  }
  //me.Keypairs = me.Keypairs || require('keypairs');
  //me.request = me.request || require('@root/request');
  if (!me.dns01) {
    me.dns01 = function (auth) {
      return ACME._dns01(me, auth);
    };
  }
  // backwards compat
  if (!me.dig) { me.dig = me.dns01; }
  if (!me.http01) {
    me.http01 = function (auth) {
      return ACME._http01(me, auth);
    };
  }

  if ('function' !== typeof me.request) {
    me.request = ACME._defaultRequest;
  }

  me.init = function (opts) {
    function fin(dir) {
      me._directoryUrls = dir;
      me._tos = dir.meta.termsOfService;
      return dir;
    }
    if (opts && opts.meta && opts.termsOfService) {
      return Promise.resolve(fin(opts));
    }
    if (!me.directoryUrl) { me.directoryUrl = opts; }
    if ('string' !== typeof me.directoryUrl) {
      throw new Error("you must supply either the ACME directory url as a string or an object of the ACME urls");
    }
    var p = Promise.resolve();
    if (!me.skipChallengeTest) {
      p = me.request({ url: me._baseUrl + "/api/_acme_api_/" }).then(function (resp) {
        if (resp.body.success) {
          me._canCheck['http-01'] = true;
          me._canCheck['dns-01'] = true;
        }
      }).catch(function () {
        // ignore
      });
    }
    return p.then(function () {
      return ACME._directory(me).then(function (resp) {
        return fin(resp.body);
      });
    });
  };
  me.accounts = {
    create: function (options) {
      return ACME._registerAccount(me, options);
    }
  };
  me.orders = {
    // create + get challlenges
    request: function (options) {
      return ACME._createOrder(me, options);
    }
    // set challenges, check challenges, finalize order, return order
  , complete: function (options) {
      return ACME._finalizeOrder(me, options);
    }
  };
  me.certificates = {
    create: function (options) {
      return ACME._getCertificate(me, options);
    }
  };
  return me;
};

// Handle nonce, signing, and request altogether
ACME._jwsRequest = function (me, bigopts) {
  return ACME._getNonce(me).then(function (nonce) {
    bigopts.protected.nonce = nonce;
    bigopts.protected.url = bigopts.url;
    // protected.alg: added by Keypairs.signJws
    if (!bigopts.protected.jwk) {
      // protected.kid must be overwritten due to ACME's interpretation of the spec
      if (!bigopts.protected.kid) { bigopts.protected.kid = bigopts.options._kid; }
    }
    return me.Keypairs.signJws(
      { jwk: bigopts.options.accountKeypair.privateKeyJwk
      , protected: bigopts.protected
      , payload: bigopts.payload
      }
    ).then(function (jws) {
      if (me.debug) { console.debug('[acme-v2] ' + bigopts.url + ':'); }
      if (me.debug) { console.debug(jws); }
      return ACME._request(me, { url: bigopts.url, json: jws });
    });
  });
};
// Handle some ACME-specific defaults
ACME._request = function (me, opts) {
  if (!opts.headers) { opts.headers = {}; }
  if (opts.json && true !== opts.json) {
    opts.headers['Content-Type'] = 'application/jose+json';
    opts.body = JSON.stringify(opts.json);
    if (!opts.method) { opts.method = 'POST'; }
  }
  return me.request(opts).then(function (resp) {
    resp = resp.toJSON();
    if (resp.headers['replay-nonce']) {
      ACME._setNonce(me, resp.headers['replay-nonce']);
    }
    return resp;
  });
};
// A very generic, swappable request lib
ACME._defaultRequest = function (opts) {
  // Note: normally we'd have to supply a User-Agent string, but not here in a browser
  if (!opts.headers) { opts.headers = {}; }
  if (opts.json) {
    opts.headers.Accept = 'application/json';
    if (true !== opts.json) { opts.body = JSON.stringify(opts.json); }
  }
  if (!opts.method) {
    opts.method = 'GET';
    if (opts.body) { opts.method = 'POST'; }
  }
  opts.cors = true;
  return window.fetch(opts.url, opts).then(function (resp) {
    var headers = {};
    var result = { statusCode: resp.status, headers: headers, toJSON: function () { return this; } };
    Array.from(resp.headers.entries()).forEach(function (h) { headers[h[0]] = h[1]; });
    if (!headers['content-type']) {
      return result;
    }
    if (/json/.test(headers['content-type'])) {
      return resp.json().then(function (json) {
        result.body = json;
        return result;
      });
    }
    return resp.text().then(function (txt) {
      result.body = txt;
      return result;
    });
  });
};

ACME._importKeypair = function (me, kp) {
  var jwk = kp.privateKeyJwk;
  var p;
  if (jwk) {
    // nix the browser jwk extras
    jwk.key_ops = undefined;
    jwk.ext = undefined;
    p = Promise.resolve({ private: jwk, public: me.Keypairs.neuter({ jwk: jwk }) });
  } else {
    p = me.Keypairs.import({ pem: kp.privateKeyPem });
  }
  return p.then(function (pair) {
    kp.privateKeyJwk = pair.private;
    kp.publicKeyJwk = pair.public;
    if (pair.public.kid) {
      pair = JSON.parse(JSON.stringify(pair));
      delete pair.public.kid;
      delete pair.private.kid;
    }
    return pair;
  });
};

/*
TODO
Per-Order State Params
      _kty
      _alg
      _finalize
      _expires
      _certificate
      _order
      _authorizations
*/

ACME._toWebsafeBase64 = function (b64) {
  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g,"");
};

// In v8 this is crypto random, but we're just using it for pseudorandom
ACME._prnd = function (n) {
  var rnd = '';
  while (rnd.length / 2 < n) {
    var num = Math.random().toString().substr(2);
    if (num.length % 2) {
      num = '0' + num;
    }
    var pairs = num.match(/(..?)/g);
    rnd += pairs.map(ACME._toHex).join('');
  }
  return rnd.substr(0, n*2);
};
ACME._toHex = function (pair) {
  return parseInt(pair, 10).toString(16);
};
ACME._dns01 = function (me, auth) {
  return new me.request({ url: me._baseUrl + "/api/dns/" + auth.dnsHost + "?type=TXT" }).then(function (resp) {
    var err;
    if (!resp.body || !Array.isArray(resp.body.answer)) {
      err = new Error("failed to get DNS response");
      console.error(err);
      throw err;
    }
    if (!resp.body.answer.length) {
      err = new Error("failed to get DNS answer record in response");
      console.error(err);
      throw err;
    }
    return {
      answer: resp.body.answer.map(function (ans) {
        return { data: ans.data, ttl: ans.ttl };
      })
    };
  });
};
ACME._http01 = function (me, auth) {
  var url = encodeURIComponent(auth.challengeUrl);
  return new me.request({ url: me._baseUrl + "/api/http?url=" + url }).then(function (resp) {
    return resp.body;
  });
};
ACME._removeChallenge = function (me, options, auth) {
  var challengers = options.challenges || {};
  var removeChallenge = (challengers[auth.type] && challengers[auth.type].remove) || options.removeChallenge;
  if (1 === removeChallenge.length) {
    removeChallenge(auth).then(function () {}, function () {});
  } else if (2 === removeChallenge.length) {
    removeChallenge(auth, function (err) { return err; });
  } else {
    if (!ACME._removeChallengeWarn) {
      console.warn("Please update to acme-v2 removeChallenge(options) <Promise> or removeChallenge(options, cb).");
      console.warn("The API has been changed for compatibility with all ACME / Let's Encrypt challenge types.");
      ACME._removeChallengeWarn = true;
    }
    removeChallenge(auth.request.identifier, auth.token, function () {});
  }
};

Enc.bufToUrlBase64 = function (u8) {
  return Enc.bufToBase64(u8)
    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
};
Enc.bufToBase64 = function (u8) {
  var bin = '';
  u8.forEach(function (i) {
    bin += String.fromCharCode(i);
  });
  return btoa(bin);
};

Crypto._sha = function (sha, str) {
  var encoder = new TextEncoder();
  var data = encoder.encode(str);
  sha = 'SHA-' + sha.replace(/^sha-?/i, '');
  return window.crypto.subtle.digest(sha, data).then(function (hash) {
    return Enc.bufToUrlBase64(new Uint8Array(hash));
  });
};

}('undefined' === typeof window ? module.exports : window));