@socketsecurity/cli-with-sentry 1.1.14 → 1.1.17

package/external/@socketsecurity/registry/external/make-fetch-happen.js

@@ -1794,13 +1794,13 @@ function requireCommonjs$4() {
   return commonjs$5
 }
 
-let minipass$2
-let hasRequiredMinipass$2
-function requireMinipass$2() {
-  if (hasRequiredMinipass$2) {
-    return minipass$2
+let minipass
+let hasRequiredMinipass
+function requireMinipass() {
+  if (hasRequiredMinipass) {
+    return minipass
   }
-  hasRequiredMinipass$2 = 1
+  hasRequiredMinipass = 1
   const proc =
     typeof process === 'object' && process
       ? process
@@ -1885,7 +1885,7 @@ function requireMinipass$2() {
       src.on('error', this.proxyErrors)
     }
   }
-  minipass$2 = class Minipass extends Stream {
+  minipass = class Minipass extends Stream {
     constructor(options) {
       super()
       this[FLOWING] = false
@@ -2489,7 +2489,7 @@ function requireMinipass$2() {
       )
     }
   }
-  return minipass$2
+  return minipass
 }
 
 let minipassSized
@@ -2499,7 +2499,7 @@ function requireMinipassSized() {
     return minipassSized
   }
   hasRequiredMinipassSized = 1
-  const Minipass = requireMinipass$2()
+  const Minipass = requireMinipass()
   class SizeError extends Error {
     constructor(found, expect) {
       super(`Bad data size: expected ${expect} bytes, but got ${found}`)
@@ -15695,1673 +15695,277 @@ function requirePolicy() {
       }
     }
 
-    // static method to quickly determine if a request alone is storable
-    static storable(request, options) {
-      // no cachePath means no caching
-      if (!options.cachePath) {
-        return false
-      }
-
-      // user explicitly asked not to cache
-      if (options.cache === 'no-store') {
-        return false
-      }
-
-      // we only cache GET and HEAD requests
-      if (!['GET', 'HEAD'].includes(request.method)) {
-        return false
-      }
-
-      // otherwise, let http-cache-semantics make the decision
-      // based on the request's headers
-      const policy = new CacheSemantics(
-        requestObject(request),
-        emptyResponse,
-        policyOptions
-      )
-      return policy.storable()
-    }
-
-    // returns true if the policy satisfies the request
-    satisfies(request) {
-      const _req = requestObject(request)
-      if (this.request.headers.host !== _req.headers.host) {
-        return false
-      }
-      if (this.request.compress !== _req.compress) {
-        return false
-      }
-      const negotiatorA = new Negotiator(this.request)
-      const negotiatorB = new Negotiator(_req)
-      if (
-        JSON.stringify(negotiatorA.mediaTypes()) !==
-        JSON.stringify(negotiatorB.mediaTypes())
-      ) {
-        return false
-      }
-      if (
-        JSON.stringify(negotiatorA.languages()) !==
-        JSON.stringify(negotiatorB.languages())
-      ) {
-        return false
-      }
-      if (
-        JSON.stringify(negotiatorA.encodings()) !==
-        JSON.stringify(negotiatorB.encodings())
-      ) {
-        return false
-      }
-      if (this.options.integrity) {
-        return ssri.parse(this.options.integrity).match(this.entry.integrity)
-      }
-      return true
-    }
-
-    // returns true if the request and response allow caching
-    storable() {
-      return this.policy.storable()
-    }
-
-    // NOTE: this is a hack to avoid parsing the cache-control
-    // header ourselves, it returns true if the response's
-    // cache-control contains must-revalidate
-    get mustRevalidate() {
-      return !!this.policy._rescc['must-revalidate']
-    }
-
-    // returns true if the cached response requires revalidation
-    // for the given request
-    needsRevalidation(request) {
-      const _req = requestObject(request)
-      // force method to GET because we only cache GETs
-      // but can serve a HEAD from a cached GET
-      _req.method = 'GET'
-      return !this.policy.satisfiesWithoutRevalidation(_req)
-    }
-    responseHeaders() {
-      return this.policy.responseHeaders()
-    }
-
-    // returns a new object containing the appropriate headers
-    // to send a revalidation request
-    revalidationHeaders(request) {
-      const _req = requestObject(request)
-      return this.policy.revalidationHeaders(_req)
-    }
-
-    // returns true if the request/response was revalidated
-    // successfully. returns false if a new response was received
-    revalidated(request, response) {
-      const _req = requestObject(request)
-      const _res = responseObject(response)
-      const policy = this.policy.revalidatedPolicy(_req, _res)
-      return !policy.modified
-    }
-  }
-  policy = CachePolicy
-  return policy
-}
-
-let errors$2
-let hasRequiredErrors$2
-function requireErrors$2() {
-  if (hasRequiredErrors$2) {
-    return errors$2
-  }
-  hasRequiredErrors$2 = 1
-  class NotCachedError extends Error {
-    constructor(url) {
-      /* eslint-disable-next-line max-len */
-      super(
-        `request to ${url} failed: cache mode is 'only-if-cached' but no cached response is available.`
-      )
-      this.code = 'ENOTCACHED'
-    }
-  }
-  errors$2 = {
-    NotCachedError
-  }
-  return errors$2
-}
-
-let minipass$1
-let hasRequiredMinipass$1
-function requireMinipass$1() {
-  if (hasRequiredMinipass$1) {
-    return minipass$1
-  }
-  hasRequiredMinipass$1 = 1
-  const proc =
-    typeof process === 'object' && process
-      ? process
-      : {
-          stdout: null,
-          stderr: null
-        }
-  const EE = require$$0$5
-  const Stream = require$$1$2
-  const SD = require$$2$2.StringDecoder
-  const EOF = Symbol('EOF')
-  const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
-  const EMITTED_END = Symbol('emittedEnd')
-  const EMITTING_END = Symbol('emittingEnd')
-  const EMITTED_ERROR = Symbol('emittedError')
-  const CLOSED = Symbol('closed')
-  const READ = Symbol('read')
-  const FLUSH = Symbol('flush')
-  const FLUSHCHUNK = Symbol('flushChunk')
-  const ENCODING = Symbol('encoding')
-  const DECODER = Symbol('decoder')
-  const FLOWING = Symbol('flowing')
-  const PAUSED = Symbol('paused')
-  const RESUME = Symbol('resume')
-  const BUFFERLENGTH = Symbol('bufferLength')
-  const BUFFERPUSH = Symbol('bufferPush')
-  const BUFFERSHIFT = Symbol('bufferShift')
-  const OBJECTMODE = Symbol('objectMode')
-  const DESTROYED = Symbol('destroyed')
-  const EMITDATA = Symbol('emitData')
-  const EMITEND = Symbol('emitEnd')
-  const EMITEND2 = Symbol('emitEnd2')
-  const ASYNC = Symbol('async')
-  const defer = fn => Promise.resolve().then(fn)
-
-  // TODO remove when Node v8 support drops
-  const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
-  const ASYNCITERATOR =
-    (doIter && Symbol.asyncIterator) || Symbol('asyncIterator not implemented')
-  const ITERATOR =
-    (doIter && Symbol.iterator) || Symbol('iterator not implemented')
-
-  // events that mean 'the stream is over'
-  // these are treated specially, and re-emitted
-  // if they are listened for after emitting.
-  const isEndish = ev => ev === 'end' || ev === 'finish' || ev === 'prefinish'
-  const isArrayBuffer = b =>
-    b instanceof ArrayBuffer ||
-    (typeof b === 'object' &&
-      b.constructor &&
-      b.constructor.name === 'ArrayBuffer' &&
-      b.byteLength >= 0)
-  const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
-  class Pipe {
-    constructor(src, dest, opts) {
-      this.src = src
-      this.dest = dest
-      this.opts = opts
-      this.ondrain = () => src[RESUME]()
-      dest.on('drain', this.ondrain)
-    }
-    unpipe() {
-      this.dest.removeListener('drain', this.ondrain)
-    }
-    // istanbul ignore next - only here for the prototype
-    proxyErrors() {}
-    end() {
-      this.unpipe()
-      if (this.opts.end) {
-        this.dest.end()
-      }
-    }
-  }
-  class PipeProxyErrors extends Pipe {
-    unpipe() {
-      this.src.removeListener('error', this.proxyErrors)
-      super.unpipe()
-    }
-    constructor(src, dest, opts) {
-      super(src, dest, opts)
-      this.proxyErrors = er => dest.emit('error', er)
-      src.on('error', this.proxyErrors)
-    }
-  }
-  minipass$1 = class Minipass extends Stream {
-    constructor(options) {
-      super()
-      this[FLOWING] = false
-      // whether we're explicitly paused
-      this[PAUSED] = false
-      this.pipes = []
-      this.buffer = []
-      this[OBJECTMODE] = (options && options.objectMode) || false
-      if (this[OBJECTMODE]) {
-        this[ENCODING] = null
-      } else {
-        this[ENCODING] = (options && options.encoding) || null
-      }
-      if (this[ENCODING] === 'buffer') {
-        this[ENCODING] = null
-      }
-      this[ASYNC] = (options && !!options.async) || false
-      this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
-      this[EOF] = false
-      this[EMITTED_END] = false
-      this[EMITTING_END] = false
-      this[CLOSED] = false
-      this[EMITTED_ERROR] = null
-      this.writable = true
-      this.readable = true
-      this[BUFFERLENGTH] = 0
-      this[DESTROYED] = false
-    }
-    get bufferLength() {
-      return this[BUFFERLENGTH]
-    }
-    get encoding() {
-      return this[ENCODING]
-    }
-    set encoding(enc) {
-      if (this[OBJECTMODE]) {
-        throw new Error('cannot set encoding in objectMode')
-      }
-      if (
-        this[ENCODING] &&
-        enc !== this[ENCODING] &&
-        ((this[DECODER] && this[DECODER].lastNeed) || this[BUFFERLENGTH])
-      ) {
-        throw new Error('cannot change encoding')
-      }
-      if (this[ENCODING] !== enc) {
-        this[DECODER] = enc ? new SD(enc) : null
-        if (this.buffer.length) {
-          this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
-        }
-      }
-      this[ENCODING] = enc
-    }
-    setEncoding(enc) {
-      this.encoding = enc
-    }
-    get objectMode() {
-      return this[OBJECTMODE]
-    }
-    set objectMode(om) {
-      this[OBJECTMODE] = this[OBJECTMODE] || !!om
-    }
-    get ['async']() {
-      return this[ASYNC]
-    }
-    set ['async'](a) {
-      this[ASYNC] = this[ASYNC] || !!a
-    }
-    write(chunk, encoding, cb) {
-      if (this[EOF]) {
-        throw new Error('write after end')
-      }
-      if (this[DESTROYED]) {
-        this.emit(
-          'error',
-          Object.assign(
-            new Error('Cannot call write after a stream was destroyed'),
-            {
-              code: 'ERR_STREAM_DESTROYED'
-            }
-          )
-        )
-        return true
-      }
-      if (typeof encoding === 'function') {
-        ;(cb = encoding), (encoding = 'utf8')
-      }
-      if (!encoding) {
-        encoding = 'utf8'
-      }
-      const fn = this[ASYNC] ? defer : f => f()
-
-      // convert array buffers and typed array views into buffers
-      // at some point in the future, we may want to do the opposite!
-      // leave strings and buffers as-is
-      // anything else switches us into object mode
-      if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
-        if (isArrayBufferView(chunk)) {
-          chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
-        } else if (isArrayBuffer(chunk)) {
-          chunk = Buffer.from(chunk)
-        } else if (typeof chunk !== 'string') {
-          // use the setter so we throw if we have encoding set
-          this.objectMode = true
-        }
-      }
-
-      // handle object mode up front, since it's simpler
-      // this yields better performance, fewer checks later.
-      if (this[OBJECTMODE]) {
-        /* istanbul ignore if - maybe impossible? */
-        if (this.flowing && this[BUFFERLENGTH] !== 0) {
-          this[FLUSH](true)
-        }
-        if (this.flowing) {
-          this.emit('data', chunk)
-        } else {
-          this[BUFFERPUSH](chunk)
-        }
-        if (this[BUFFERLENGTH] !== 0) {
-          this.emit('readable')
-        }
-        if (cb) {
-          fn(cb)
-        }
-        return this.flowing
-      }
-
-      // at this point the chunk is a buffer or string
-      // don't buffer it up or send it to the decoder
-      if (!chunk.length) {
-        if (this[BUFFERLENGTH] !== 0) {
-          this.emit('readable')
-        }
-        if (cb) {
-          fn(cb)
-        }
-        return this.flowing
-      }
-
-      // fast-path writing strings of same encoding to a stream with
-      // an empty buffer, skipping the buffer/decoder dance
-      if (
-        typeof chunk === 'string' &&
-        // unless it is a string already ready for us to use
-        !(encoding === this[ENCODING] && !this[DECODER].lastNeed)
-      ) {
-        chunk = Buffer.from(chunk, encoding)
-      }
-      if (Buffer.isBuffer(chunk) && this[ENCODING]) {
-        chunk = this[DECODER].write(chunk)
-      }
-
-      // Note: flushing CAN potentially switch us into not-flowing mode
-      if (this.flowing && this[BUFFERLENGTH] !== 0) {
-        this[FLUSH](true)
-      }
-      if (this.flowing) {
-        this.emit('data', chunk)
-      } else {
-        this[BUFFERPUSH](chunk)
-      }
-      if (this[BUFFERLENGTH] !== 0) {
-        this.emit('readable')
-      }
-      if (cb) {
-        fn(cb)
-      }
-      return this.flowing
-    }
-    read(n) {
-      if (this[DESTROYED]) {
-        return null
-      }
-      if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
-        this[MAYBE_EMIT_END]()
-        return null
-      }
-      if (this[OBJECTMODE]) {
-        n = null
-      }
-      if (this.buffer.length > 1 && !this[OBJECTMODE]) {
-        if (this.encoding) {
-          this.buffer = [this.buffer.join('')]
-        } else {
-          this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
-        }
-      }
-      const ret = this[READ](n || null, this.buffer[0])
-      this[MAYBE_EMIT_END]()
-      return ret
-    }
-    [READ](n, chunk) {
-      if (n === chunk.length || n === null) {
-        this[BUFFERSHIFT]()
-      } else {
-        this.buffer[0] = chunk.slice(n)
-        chunk = chunk.slice(0, n)
-        this[BUFFERLENGTH] -= n
-      }
-      this.emit('data', chunk)
-      if (!this.buffer.length && !this[EOF]) {
-        this.emit('drain')
-      }
-      return chunk
-    }
-    end(chunk, encoding, cb) {
-      if (typeof chunk === 'function') {
-        ;(cb = chunk), (chunk = null)
-      }
-      if (typeof encoding === 'function') {
-        ;(cb = encoding), (encoding = 'utf8')
-      }
-      if (chunk) {
-        this.write(chunk, encoding)
-      }
-      if (cb) {
-        this.once('end', cb)
-      }
-      this[EOF] = true
-      this.writable = false
-
-      // if we haven't written anything, then go ahead and emit,
-      // even if we're not reading.
-      // we'll re-emit if a new 'end' listener is added anyway.
-      // This makes MP more suitable to write-only use cases.
-      if (this.flowing || !this[PAUSED]) {
-        this[MAYBE_EMIT_END]()
-      }
-      return this
-    }
-
-    // don't let the internal resume be overwritten
-    [RESUME]() {
-      if (this[DESTROYED]) {
-        return
-      }
-      this[PAUSED] = false
-      this[FLOWING] = true
-      this.emit('resume')
-      if (this.buffer.length) {
-        this[FLUSH]()
-      } else if (this[EOF]) {
-        this[MAYBE_EMIT_END]()
-      } else {
-        this.emit('drain')
-      }
-    }
-    resume() {
-      return this[RESUME]()
-    }
-    pause() {
-      this[FLOWING] = false
-      this[PAUSED] = true
-    }
-    get destroyed() {
-      return this[DESTROYED]
-    }
-    get flowing() {
-      return this[FLOWING]
-    }
-    get paused() {
-      return this[PAUSED]
-    }
-    [BUFFERPUSH](chunk) {
-      if (this[OBJECTMODE]) {
-        this[BUFFERLENGTH] += 1
-      } else {
-        this[BUFFERLENGTH] += chunk.length
-      }
-      this.buffer.push(chunk)
-    }
-    [BUFFERSHIFT]() {
-      if (this.buffer.length) {
-        if (this[OBJECTMODE]) {
-          this[BUFFERLENGTH] -= 1
-        } else {
-          this[BUFFERLENGTH] -= this.buffer[0].length
-        }
-      }
-      return this.buffer.shift()
-    }
-    [FLUSH](noDrain) {
-      do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
-      if (!noDrain && !this.buffer.length && !this[EOF]) {
-        this.emit('drain')
-      }
-    }
-    [FLUSHCHUNK](chunk) {
-      return chunk ? (this.emit('data', chunk), this.flowing) : false
-    }
-    pipe(dest, opts) {
-      if (this[DESTROYED]) {
-        return
-      }
-      const ended = this[EMITTED_END]
-      opts = opts || {}
-      if (dest === proc.stdout || dest === proc.stderr) {
-        opts.end = false
-      } else {
-        opts.end = opts.end !== false
-      }
-      opts.proxyErrors = !!opts.proxyErrors
-
-      // piping an ended stream ends immediately
-      if (ended) {
-        if (opts.end) {
-          dest.end()
-        }
-      } else {
-        this.pipes.push(
-          !opts.proxyErrors
-            ? new Pipe(this, dest, opts)
-            : new PipeProxyErrors(this, dest, opts)
-        )
-        if (this[ASYNC]) {
-          defer(() => this[RESUME]())
-        } else {
-          this[RESUME]()
-        }
-      }
-      return dest
-    }
-    unpipe(dest) {
-      const p = this.pipes.find(p => p.dest === dest)
-      if (p) {
-        this.pipes.splice(this.pipes.indexOf(p), 1)
-        p.unpipe()
-      }
-    }
-    addListener(ev, fn) {
-      return this.on(ev, fn)
-    }
-    on(ev, fn) {
-      const ret = super.on(ev, fn)
-      if (ev === 'data' && !this.pipes.length && !this.flowing) {
-        this[RESUME]()
-      } else if (ev === 'readable' && this[BUFFERLENGTH] !== 0) {
-        super.emit('readable')
-      } else if (isEndish(ev) && this[EMITTED_END]) {
-        super.emit(ev)
-        this.removeAllListeners(ev)
-      } else if (ev === 'error' && this[EMITTED_ERROR]) {
-        if (this[ASYNC]) {
-          defer(() => fn.call(this, this[EMITTED_ERROR]))
-        } else {
-          fn.call(this, this[EMITTED_ERROR])
-        }
-      }
-      return ret
-    }
-    get emittedEnd() {
-      return this[EMITTED_END]
-    }
-    [MAYBE_EMIT_END]() {
-      if (
-        !this[EMITTING_END] &&
-        !this[EMITTED_END] &&
-        !this[DESTROYED] &&
-        this.buffer.length === 0 &&
-        this[EOF]
-      ) {
-        this[EMITTING_END] = true
-        this.emit('end')
-        this.emit('prefinish')
-        this.emit('finish')
-        if (this[CLOSED]) {
-          this.emit('close')
-        }
-        this[EMITTING_END] = false
-      }
-    }
-    emit(ev, data, ...extra) {
-      // error and close are only events allowed after calling destroy()
-      if (
-        ev !== 'error' &&
-        ev !== 'close' &&
-        ev !== DESTROYED &&
-        this[DESTROYED]
-      ) {
-        return
-      } else if (ev === 'data') {
-        return !data
-          ? false
-          : this[ASYNC]
-            ? defer(() => this[EMITDATA](data))
-            : this[EMITDATA](data)
-      } else if (ev === 'end') {
-        return this[EMITEND]()
-      } else if (ev === 'close') {
-        this[CLOSED] = true
-        // don't emit close before 'end' and 'finish'
-        if (!this[EMITTED_END] && !this[DESTROYED]) {
-          return
-        }
-        const ret = super.emit('close')
-        this.removeAllListeners('close')
-        return ret
-      } else if (ev === 'error') {
-        this[EMITTED_ERROR] = data
-        const ret = super.emit('error', data)
-        this[MAYBE_EMIT_END]()
-        return ret
-      } else if (ev === 'resume') {
-        const ret = super.emit('resume')
-        this[MAYBE_EMIT_END]()
-        return ret
-      } else if (ev === 'finish' || ev === 'prefinish') {
-        const ret = super.emit(ev)
-        this.removeAllListeners(ev)
-        return ret
-      }
-
-      // Some other unknown event
-      const ret = super.emit(ev, data, ...extra)
-      this[MAYBE_EMIT_END]()
-      return ret
-    }
-    [EMITDATA](data) {
-      for (const p of this.pipes) {
-        if (p.dest.write(data) === false) {
-          this.pause()
-        }
-      }
-      const ret = super.emit('data', data)
-      this[MAYBE_EMIT_END]()
-      return ret
-    }
-    [EMITEND]() {
-      if (this[EMITTED_END]) {
-        return
-      }
-      this[EMITTED_END] = true
-      this.readable = false
-      if (this[ASYNC]) {
-        defer(() => this[EMITEND2]())
-      } else {
-        this[EMITEND2]()
-      }
-    }
-    [EMITEND2]() {
-      if (this[DECODER]) {
-        const data = this[DECODER].end()
-        if (data) {
-          for (const p of this.pipes) {
-            p.dest.write(data)
-          }
-          super.emit('data', data)
-        }
-      }
-      for (const p of this.pipes) {
-        p.end()
-      }
-      const ret = super.emit('end')
-      this.removeAllListeners('end')
-      return ret
-    }
-
-    // const all = await stream.collect()
-    collect() {
-      const buf = []
-      if (!this[OBJECTMODE]) {
-        buf.dataLength = 0
-      }
-      // set the promise first, in case an error is raised
-      // by triggering the flow here.
-      const p = this.promise()
-      this.on('data', c => {
-        buf.push(c)
-        if (!this[OBJECTMODE]) {
-          buf.dataLength += c.length
-        }
-      })
-      return p.then(() => buf)
-    }
-
-    // const data = await stream.concat()
-    concat() {
-      return this[OBJECTMODE]
-        ? Promise.reject(new Error('cannot concat in objectMode'))
-        : this.collect().then(buf =>
-            this[OBJECTMODE]
-              ? Promise.reject(new Error('cannot concat in objectMode'))
-              : this[ENCODING]
-                ? buf.join('')
-                : Buffer.concat(buf, buf.dataLength)
-          )
-    }
-
-    // stream.promise().then(() => done, er => emitted error)
-    promise() {
-      return new Promise((resolve, reject) => {
-        this.on(DESTROYED, () => reject(new Error('stream destroyed')))
-        this.on('error', er => reject(er))
-        this.on('end', () => resolve())
-      })
-    }
-
-    // for await (let chunk of stream)
-    [ASYNCITERATOR]() {
-      const next = () => {
-        const res = this.read()
-        if (res !== null) {
-          return Promise.resolve({
-            done: false,
-            value: res
-          })
-        }
-        if (this[EOF]) {
-          return Promise.resolve({
-            done: true
-          })
-        }
-        let resolve = null
-        let reject = null
-        const onerr = er => {
-          this.removeListener('data', ondata)
-          this.removeListener('end', onend)
-          reject(er)
-        }
-        const ondata = value => {
-          this.removeListener('error', onerr)
-          this.removeListener('end', onend)
-          this.pause()
-          resolve({
-            value: value,
-            done: !!this[EOF]
-          })
-        }
-        const onend = () => {
-          this.removeListener('error', onerr)
-          this.removeListener('data', ondata)
-          resolve({
-            done: true
-          })
-        }
-        const ondestroy = () => onerr(new Error('stream destroyed'))
-        return new Promise((res, rej) => {
-          reject = rej
-          resolve = res
-          this.once(DESTROYED, ondestroy)
-          this.once('error', onerr)
-          this.once('end', onend)
-          this.once('data', ondata)
-        })
-      }
-      return {
-        next
-      }
-    }
-
-    // for (let chunk of stream)
-    [ITERATOR]() {
-      const next = () => {
-        const value = this.read()
-        const done = value === null
-        return {
-          value,
-          done
-        }
-      }
-      return {
-        next
-      }
-    }
-    destroy(er) {
-      if (this[DESTROYED]) {
-        if (er) {
-          this.emit('error', er)
-        } else {
-          this.emit(DESTROYED)
-        }
-        return this
-      }
-      this[DESTROYED] = true
-
-      // throw away all buffered data, it's never coming out
-      this.buffer.length = 0
-      this[BUFFERLENGTH] = 0
-      if (typeof this.close === 'function' && !this[CLOSED]) {
-        this.close()
-      }
-      if (er) {
-        this.emit('error', er)
-      }
-      // if no error to emit, still reject pending promises
-      else {
-        this.emit(DESTROYED)
-      }
-      return this
-    }
-    static isStream(s) {
-      return (
-        !!s &&
-        (s instanceof Minipass ||
-          s instanceof Stream ||
-          (s instanceof EE &&
-            (typeof s.pipe === 'function' ||
-              // readable
-              (typeof s.write === 'function' && typeof s.end === 'function')))) // writable
-      )
-    }
-  }
-  return minipass$1
-}
-
-let minipassFlush
-let hasRequiredMinipassFlush
-function requireMinipassFlush() {
-  if (hasRequiredMinipassFlush) {
-    return minipassFlush
-  }
-  hasRequiredMinipassFlush = 1
-  const Minipass = requireMinipass$1()
-  const _flush = Symbol('_flush')
-  const _flushed = Symbol('_flushed')
-  const _flushing = Symbol('_flushing')
-  class Flush extends Minipass {
-    constructor(opt = {}) {
-      if (typeof opt === 'function') {
-        opt = {
-          flush: opt
-        }
-      }
-      super(opt)
-
-      // or extend this class and provide a 'flush' method in your subclass
-      if (typeof opt.flush !== 'function' && typeof this.flush !== 'function') {
-        throw new TypeError('must provide flush function in options')
-      }
-      this[_flush] = opt.flush || this.flush
-    }
-    emit(ev, ...data) {
-      if ((ev !== 'end' && ev !== 'finish') || this[_flushed]) {
-        return super.emit(ev, ...data)
-      }
-      if (this[_flushing]) {
-        return
-      }
-      this[_flushing] = true
-      const afterFlush = er => {
-        this[_flushed] = true
-        er ? super.emit('error', er) : super.emit('end')
-      }
-      const ret = this[_flush](afterFlush)
-      if (ret && ret.then) {
-        ret.then(
-          () => afterFlush(),
-          er => afterFlush(er)
-        )
-      }
-    }
-  }
-  minipassFlush = Flush
-  return minipassFlush
-}
-
-const lib$6 = { exports: {} }
-
-const get = { exports: {} }
-
-const minipassCollect = { exports: {} }
-
-let hasRequiredMinipassCollect
-function requireMinipassCollect() {
-  if (hasRequiredMinipassCollect) {
-    return minipassCollect.exports
-  }
-  hasRequiredMinipassCollect = 1
-  const { Minipass } = requireCommonjs$5()
-  const _data = Symbol('_data')
-  const _length = Symbol('_length')
-  class Collect extends Minipass {
-    constructor(options) {
-      super(options)
-      this[_data] = []
-      this[_length] = 0
-    }
-    write(chunk, encoding, cb) {
-      if (typeof encoding === 'function') {
-        ;(cb = encoding), (encoding = 'utf8')
-      }
-      if (!encoding) {
-        encoding = 'utf8'
-      }
-      const c = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding)
-      this[_data].push(c)
-      this[_length] += c.length
-      if (cb) {
-        cb()
-      }
-      return true
-    }
-    end(chunk, encoding, cb) {
-      if (typeof chunk === 'function') {
-        ;(cb = chunk), (chunk = null)
-      }
-      if (typeof encoding === 'function') {
-        ;(cb = encoding), (encoding = 'utf8')
-      }
-      if (chunk) {
-        this.write(chunk, encoding)
-      }
-      const result = Buffer.concat(this[_data], this[_length])
-      super.write(result)
-      return super.end(cb)
-    }
-  }
-  minipassCollect.exports = Collect
-
-  // it would be possible to DRY this a bit by doing something like
-  // this.collector = new Collect() and listening on its data event,
-  // but it's not much code, and we may as well save the extra obj
-  class CollectPassThrough extends Minipass {
-    constructor(options) {
-      super(options)
-      this[_data] = []
-      this[_length] = 0
-    }
-    write(chunk, encoding, cb) {
-      if (typeof encoding === 'function') {
-        ;(cb = encoding), (encoding = 'utf8')
-      }
-      if (!encoding) {
-        encoding = 'utf8'
-      }
-      const c = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding)
-      this[_data].push(c)
-      this[_length] += c.length
-      return super.write(chunk, encoding, cb)
-    }
-    end(chunk, encoding, cb) {
-      if (typeof chunk === 'function') {
-        ;(cb = chunk), (chunk = null)
-      }
-      if (typeof encoding === 'function') {
-        ;(cb = encoding), (encoding = 'utf8')
-      }
-      if (chunk) {
-        this.write(chunk, encoding)
-      }
-      const result = Buffer.concat(this[_data], this[_length])
-      this.emit('collect', result)
-      return super.end(cb)
-    }
-  }
-  minipassCollect.exports.PassThrough = CollectPassThrough
-  return minipassCollect.exports
-}
-
-let minipass
-let hasRequiredMinipass
-function requireMinipass() {
-  if (hasRequiredMinipass) {
-    return minipass
-  }
-  hasRequiredMinipass = 1
-  const proc =
-    typeof process === 'object' && process
-      ? process
-      : {
-          stdout: null,
-          stderr: null
-        }
-  const EE = require$$0$5
-  const Stream = require$$1$2
-  const SD = require$$2$2.StringDecoder
-  const EOF = Symbol('EOF')
-  const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
-  const EMITTED_END = Symbol('emittedEnd')
-  const EMITTING_END = Symbol('emittingEnd')
-  const EMITTED_ERROR = Symbol('emittedError')
-  const CLOSED = Symbol('closed')
-  const READ = Symbol('read')
-  const FLUSH = Symbol('flush')
-  const FLUSHCHUNK = Symbol('flushChunk')
-  const ENCODING = Symbol('encoding')
-  const DECODER = Symbol('decoder')
-  const FLOWING = Symbol('flowing')
-  const PAUSED = Symbol('paused')
-  const RESUME = Symbol('resume')
-  const BUFFERLENGTH = Symbol('bufferLength')
-  const BUFFERPUSH = Symbol('bufferPush')
-  const BUFFERSHIFT = Symbol('bufferShift')
-  const OBJECTMODE = Symbol('objectMode')
-  const DESTROYED = Symbol('destroyed')
-  const EMITDATA = Symbol('emitData')
-  const EMITEND = Symbol('emitEnd')
-  const EMITEND2 = Symbol('emitEnd2')
-  const ASYNC = Symbol('async')
-  const defer = fn => Promise.resolve().then(fn)
-
-  // TODO remove when Node v8 support drops
-  const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
-  const ASYNCITERATOR =
-    (doIter && Symbol.asyncIterator) || Symbol('asyncIterator not implemented')
-  const ITERATOR =
-    (doIter && Symbol.iterator) || Symbol('iterator not implemented')
-
-  // events that mean 'the stream is over'
-  // these are treated specially, and re-emitted
-  // if they are listened for after emitting.
-  const isEndish = ev => ev === 'end' || ev === 'finish' || ev === 'prefinish'
-  const isArrayBuffer = b =>
-    b instanceof ArrayBuffer ||
-    (typeof b === 'object' &&
-      b.constructor &&
-      b.constructor.name === 'ArrayBuffer' &&
-      b.byteLength >= 0)
-  const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
-  class Pipe {
-    constructor(src, dest, opts) {
-      this.src = src
-      this.dest = dest
-      this.opts = opts
-      this.ondrain = () => src[RESUME]()
-      dest.on('drain', this.ondrain)
-    }
-    unpipe() {
-      this.dest.removeListener('drain', this.ondrain)
-    }
-    // istanbul ignore next - only here for the prototype
-    proxyErrors() {}
-    end() {
-      this.unpipe()
-      if (this.opts.end) {
-        this.dest.end()
-      }
-    }
-  }
-  class PipeProxyErrors extends Pipe {
-    unpipe() {
-      this.src.removeListener('error', this.proxyErrors)
-      super.unpipe()
-    }
-    constructor(src, dest, opts) {
-      super(src, dest, opts)
-      this.proxyErrors = er => dest.emit('error', er)
-      src.on('error', this.proxyErrors)
-    }
-  }
-  minipass = class Minipass extends Stream {
-    constructor(options) {
-      super()
-      this[FLOWING] = false
-      // whether we're explicitly paused
-      this[PAUSED] = false
-      this.pipes = []
-      this.buffer = []
-      this[OBJECTMODE] = (options && options.objectMode) || false
-      if (this[OBJECTMODE]) {
-        this[ENCODING] = null
-      } else {
-        this[ENCODING] = (options && options.encoding) || null
-      }
-      if (this[ENCODING] === 'buffer') {
-        this[ENCODING] = null
-      }
-      this[ASYNC] = (options && !!options.async) || false
-      this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
-      this[EOF] = false
-      this[EMITTED_END] = false
-      this[EMITTING_END] = false
-      this[CLOSED] = false
-      this[EMITTED_ERROR] = null
-      this.writable = true
-      this.readable = true
-      this[BUFFERLENGTH] = 0
-      this[DESTROYED] = false
-    }
-    get bufferLength() {
-      return this[BUFFERLENGTH]
-    }
-    get encoding() {
-      return this[ENCODING]
-    }
-    set encoding(enc) {
-      if (this[OBJECTMODE]) {
-        throw new Error('cannot set encoding in objectMode')
-      }
-      if (
-        this[ENCODING] &&
-        enc !== this[ENCODING] &&
-        ((this[DECODER] && this[DECODER].lastNeed) || this[BUFFERLENGTH])
-      ) {
-        throw new Error('cannot change encoding')
-      }
-      if (this[ENCODING] !== enc) {
-        this[DECODER] = enc ? new SD(enc) : null
-        if (this.buffer.length) {
-          this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
-        }
-      }
-      this[ENCODING] = enc
-    }
-    setEncoding(enc) {
-      this.encoding = enc
-    }
-    get objectMode() {
-      return this[OBJECTMODE]
-    }
-    set objectMode(om) {
-      this[OBJECTMODE] = this[OBJECTMODE] || !!om
-    }
-    get ['async']() {
-      return this[ASYNC]
-    }
-    set ['async'](a) {
-      this[ASYNC] = this[ASYNC] || !!a
-    }
-    write(chunk, encoding, cb) {
-      if (this[EOF]) {
-        throw new Error('write after end')
-      }
-      if (this[DESTROYED]) {
-        this.emit(
-          'error',
-          Object.assign(
-            new Error('Cannot call write after a stream was destroyed'),
-            {
-              code: 'ERR_STREAM_DESTROYED'
-            }
-          )
-        )
-        return true
-      }
-      if (typeof encoding === 'function') {
-        ;(cb = encoding), (encoding = 'utf8')
-      }
-      if (!encoding) {
-        encoding = 'utf8'
-      }
-      const fn = this[ASYNC] ? defer : f => f()
-
-      // convert array buffers and typed array views into buffers
-      // at some point in the future, we may want to do the opposite!
-      // leave strings and buffers as-is
-      // anything else switches us into object mode
-      if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
-        if (isArrayBufferView(chunk)) {
-          chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
-        } else if (isArrayBuffer(chunk)) {
-          chunk = Buffer.from(chunk)
-        } else if (typeof chunk !== 'string') {
-          // use the setter so we throw if we have encoding set
-          this.objectMode = true
-        }
-      }
-
-      // handle object mode up front, since it's simpler
-      // this yields better performance, fewer checks later.
-      if (this[OBJECTMODE]) {
-        /* istanbul ignore if - maybe impossible? */
-        if (this.flowing && this[BUFFERLENGTH] !== 0) {
-          this[FLUSH](true)
-        }
-        if (this.flowing) {
-          this.emit('data', chunk)
-        } else {
-          this[BUFFERPUSH](chunk)
-        }
-        if (this[BUFFERLENGTH] !== 0) {
-          this.emit('readable')
-        }
-        if (cb) {
-          fn(cb)
-        }
-        return this.flowing
-      }
-
-      // at this point the chunk is a buffer or string
-      // don't buffer it up or send it to the decoder
-      if (!chunk.length) {
-        if (this[BUFFERLENGTH] !== 0) {
-          this.emit('readable')
-        }
-        if (cb) {
-          fn(cb)
-        }
-        return this.flowing
-      }
-
-      // fast-path writing strings of same encoding to a stream with
-      // an empty buffer, skipping the buffer/decoder dance
-      if (
-        typeof chunk === 'string' &&
-        // unless it is a string already ready for us to use
-        !(encoding === this[ENCODING] && !this[DECODER].lastNeed)
-      ) {
-        chunk = Buffer.from(chunk, encoding)
-      }
-      if (Buffer.isBuffer(chunk) && this[ENCODING]) {
-        chunk = this[DECODER].write(chunk)
-      }
-
-      // Note: flushing CAN potentially switch us into not-flowing mode
-      if (this.flowing && this[BUFFERLENGTH] !== 0) {
-        this[FLUSH](true)
-      }
-      if (this.flowing) {
-        this.emit('data', chunk)
-      } else {
-        this[BUFFERPUSH](chunk)
-      }
-      if (this[BUFFERLENGTH] !== 0) {
-        this.emit('readable')
-      }
-      if (cb) {
-        fn(cb)
-      }
-      return this.flowing
-    }
-    read(n) {
-      if (this[DESTROYED]) {
-        return null
-      }
-      if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
-        this[MAYBE_EMIT_END]()
-        return null
-      }
-      if (this[OBJECTMODE]) {
-        n = null
-      }
-      if (this.buffer.length > 1 && !this[OBJECTMODE]) {
-        if (this.encoding) {
-          this.buffer = [this.buffer.join('')]
-        } else {
-          this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
-        }
-      }
-      const ret = this[READ](n || null, this.buffer[0])
-      this[MAYBE_EMIT_END]()
-      return ret
-    }
-    [READ](n, chunk) {
-      if (n === chunk.length || n === null) {
-        this[BUFFERSHIFT]()
-      } else {
-        this.buffer[0] = chunk.slice(n)
-        chunk = chunk.slice(0, n)
-        this[BUFFERLENGTH] -= n
-      }
-      this.emit('data', chunk)
-      if (!this.buffer.length && !this[EOF]) {
-        this.emit('drain')
-      }
-      return chunk
-    }
-    end(chunk, encoding, cb) {
-      if (typeof chunk === 'function') {
-        ;(cb = chunk), (chunk = null)
-      }
-      if (typeof encoding === 'function') {
-        ;(cb = encoding), (encoding = 'utf8')
-      }
-      if (chunk) {
-        this.write(chunk, encoding)
-      }
-      if (cb) {
-        this.once('end', cb)
-      }
-      this[EOF] = true
-      this.writable = false
-
-      // if we haven't written anything, then go ahead and emit,
-      // even if we're not reading.
-      // we'll re-emit if a new 'end' listener is added anyway.
-      // This makes MP more suitable to write-only use cases.
-      if (this.flowing || !this[PAUSED]) {
-        this[MAYBE_EMIT_END]()
-      }
-      return this
-    }
-
-    // don't let the internal resume be overwritten
-    [RESUME]() {
-      if (this[DESTROYED]) {
-        return
-      }
-      this[PAUSED] = false
-      this[FLOWING] = true
-      this.emit('resume')
-      if (this.buffer.length) {
-        this[FLUSH]()
-      } else if (this[EOF]) {
-        this[MAYBE_EMIT_END]()
-      } else {
-        this.emit('drain')
-      }
-    }
-    resume() {
-      return this[RESUME]()
-    }
-    pause() {
-      this[FLOWING] = false
-      this[PAUSED] = true
-    }
-    get destroyed() {
-      return this[DESTROYED]
-    }
-    get flowing() {
-      return this[FLOWING]
-    }
-    get paused() {
-      return this[PAUSED]
-    }
-    [BUFFERPUSH](chunk) {
-      if (this[OBJECTMODE]) {
-        this[BUFFERLENGTH] += 1
-      } else {
-        this[BUFFERLENGTH] += chunk.length
-      }
-      this.buffer.push(chunk)
-    }
-    [BUFFERSHIFT]() {
-      if (this.buffer.length) {
-        if (this[OBJECTMODE]) {
-          this[BUFFERLENGTH] -= 1
-        } else {
-          this[BUFFERLENGTH] -= this.buffer[0].length
-        }
-      }
-      return this.buffer.shift()
-    }
-    [FLUSH](noDrain) {
-      do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
-      if (!noDrain && !this.buffer.length && !this[EOF]) {
-        this.emit('drain')
-      }
-    }
-    [FLUSHCHUNK](chunk) {
-      return chunk ? (this.emit('data', chunk), this.flowing) : false
-    }
-    pipe(dest, opts) {
-      if (this[DESTROYED]) {
-        return
+    // static method to quickly determine if a request alone is storable
+    static storable(request, options) {
+      // no cachePath means no caching
+      if (!options.cachePath) {
+        return false
       }
-      const ended = this[EMITTED_END]
-      opts = opts || {}
-      if (dest === proc.stdout || dest === proc.stderr) {
-        opts.end = false
-      } else {
-        opts.end = opts.end !== false
+
+      // user explicitly asked not to cache
+      if (options.cache === 'no-store') {
+        return false
       }
-      opts.proxyErrors = !!opts.proxyErrors
 
-      // piping an ended stream ends immediately
-      if (ended) {
-        if (opts.end) {
-          dest.end()
-        }
-      } else {
-        this.pipes.push(
-          !opts.proxyErrors
-            ? new Pipe(this, dest, opts)
-            : new PipeProxyErrors(this, dest, opts)
-        )
-        if (this[ASYNC]) {
-          defer(() => this[RESUME]())
-        } else {
-          this[RESUME]()
-        }
+      // we only cache GET and HEAD requests
+      if (!['GET', 'HEAD'].includes(request.method)) {
+        return false
       }
-      return dest
+
+      // otherwise, let http-cache-semantics make the decision
+      // based on the request's headers
+      const policy = new CacheSemantics(
+        requestObject(request),
+        emptyResponse,
+        policyOptions
+      )
+      return policy.storable()
     }
-    unpipe(dest) {
-      const p = this.pipes.find(p => p.dest === dest)
-      if (p) {
-        this.pipes.splice(this.pipes.indexOf(p), 1)
-        p.unpipe()
+
+    // returns true if the policy satisfies the request
+    satisfies(request) {
+      const _req = requestObject(request)
+      if (this.request.headers.host !== _req.headers.host) {
+        return false
       }
-    }
-    addListener(ev, fn) {
-      return this.on(ev, fn)
-    }
-    on(ev, fn) {
-      const ret = super.on(ev, fn)
-      if (ev === 'data' && !this.pipes.length && !this.flowing) {
-        this[RESUME]()
-      } else if (ev === 'readable' && this[BUFFERLENGTH] !== 0) {
-        super.emit('readable')
-      } else if (isEndish(ev) && this[EMITTED_END]) {
-        super.emit(ev)
-        this.removeAllListeners(ev)
-      } else if (ev === 'error' && this[EMITTED_ERROR]) {
-        if (this[ASYNC]) {
-          defer(() => fn.call(this, this[EMITTED_ERROR]))
-        } else {
-          fn.call(this, this[EMITTED_ERROR])
-        }
+      if (this.request.compress !== _req.compress) {
+        return false
       }
-      return ret
-    }
-    get emittedEnd() {
-      return this[EMITTED_END]
-    }
-    [MAYBE_EMIT_END]() {
+      const negotiatorA = new Negotiator(this.request)
+      const negotiatorB = new Negotiator(_req)
       if (
-        !this[EMITTING_END] &&
-        !this[EMITTED_END] &&
-        !this[DESTROYED] &&
-        this.buffer.length === 0 &&
-        this[EOF]
+        JSON.stringify(negotiatorA.mediaTypes()) !==
+        JSON.stringify(negotiatorB.mediaTypes())
       ) {
-        this[EMITTING_END] = true
-        this.emit('end')
-        this.emit('prefinish')
-        this.emit('finish')
-        if (this[CLOSED]) {
-          this.emit('close')
-        }
-        this[EMITTING_END] = false
+        return false
       }
-    }
-    emit(ev, data, ...extra) {
-      // error and close are only events allowed after calling destroy()
       if (
-        ev !== 'error' &&
-        ev !== 'close' &&
-        ev !== DESTROYED &&
-        this[DESTROYED]
+        JSON.stringify(negotiatorA.languages()) !==
+        JSON.stringify(negotiatorB.languages())
       ) {
-        return
-      } else if (ev === 'data') {
-        return !data
-          ? false
-          : this[ASYNC]
-            ? defer(() => this[EMITDATA](data))
-            : this[EMITDATA](data)
-      } else if (ev === 'end') {
-        return this[EMITEND]()
-      } else if (ev === 'close') {
-        this[CLOSED] = true
-        // don't emit close before 'end' and 'finish'
-        if (!this[EMITTED_END] && !this[DESTROYED]) {
-          return
-        }
-        const ret = super.emit('close')
-        this.removeAllListeners('close')
-        return ret
-      } else if (ev === 'error') {
-        this[EMITTED_ERROR] = data
-        const ret = super.emit('error', data)
-        this[MAYBE_EMIT_END]()
-        return ret
-      } else if (ev === 'resume') {
-        const ret = super.emit('resume')
-        this[MAYBE_EMIT_END]()
-        return ret
-      } else if (ev === 'finish' || ev === 'prefinish') {
-        const ret = super.emit(ev)
-        this.removeAllListeners(ev)
-        return ret
+        return false
+      }
+      if (
+        JSON.stringify(negotiatorA.encodings()) !==
+        JSON.stringify(negotiatorB.encodings())
+      ) {
+        return false
       }
+      if (this.options.integrity) {
+        return ssri.parse(this.options.integrity).match(this.entry.integrity)
+      }
+      return true
+    }
 
-      // Some other unknown event
-      const ret = super.emit(ev, data, ...extra)
-      this[MAYBE_EMIT_END]()
-      return ret
+    // returns true if the request and response allow caching
+    storable() {
+      return this.policy.storable()
     }
-    [EMITDATA](data) {
-      for (const p of this.pipes) {
-        if (p.dest.write(data) === false) {
-          this.pause()
-        }
-      }
-      const ret = super.emit('data', data)
-      this[MAYBE_EMIT_END]()
-      return ret
+
+    // NOTE: this is a hack to avoid parsing the cache-control
+    // header ourselves, it returns true if the response's
+    // cache-control contains must-revalidate
+    get mustRevalidate() {
+      return !!this.policy._rescc['must-revalidate']
     }
-    [EMITEND]() {
-      if (this[EMITTED_END]) {
-        return
-      }
-      this[EMITTED_END] = true
-      this.readable = false
-      if (this[ASYNC]) {
-        defer(() => this[EMITEND2]())
-      } else {
-        this[EMITEND2]()
-      }
+
+    // returns true if the cached response requires revalidation
+    // for the given request
+    needsRevalidation(request) {
+      const _req = requestObject(request)
+      // force method to GET because we only cache GETs
+      // but can serve a HEAD from a cached GET
+      _req.method = 'GET'
+      return !this.policy.satisfiesWithoutRevalidation(_req)
     }
-    [EMITEND2]() {
-      if (this[DECODER]) {
-        const data = this[DECODER].end()
-        if (data) {
-          for (const p of this.pipes) {
-            p.dest.write(data)
-          }
-          super.emit('data', data)
-        }
-      }
-      for (const p of this.pipes) {
-        p.end()
-      }
-      const ret = super.emit('end')
-      this.removeAllListeners('end')
-      return ret
+    responseHeaders() {
+      return this.policy.responseHeaders()
     }
 
-    // const all = await stream.collect()
-    collect() {
-      const buf = []
-      if (!this[OBJECTMODE]) {
-        buf.dataLength = 0
-      }
-      // set the promise first, in case an error is raised
-      // by triggering the flow here.
-      const p = this.promise()
-      this.on('data', c => {
-        buf.push(c)
-        if (!this[OBJECTMODE]) {
-          buf.dataLength += c.length
-        }
-      })
-      return p.then(() => buf)
+    // returns a new object containing the appropriate headers
+    // to send a revalidation request
+    revalidationHeaders(request) {
+      const _req = requestObject(request)
+      return this.policy.revalidationHeaders(_req)
     }
 
-    // const data = await stream.concat()
-    concat() {
-      return this[OBJECTMODE]
-        ? Promise.reject(new Error('cannot concat in objectMode'))
-        : this.collect().then(buf =>
-            this[OBJECTMODE]
-              ? Promise.reject(new Error('cannot concat in objectMode'))
-              : this[ENCODING]
-                ? buf.join('')
-                : Buffer.concat(buf, buf.dataLength)
-          )
+    // returns true if the request/response was revalidated
+    // successfully. returns false if a new response was received
+    revalidated(request, response) {
+      const _req = requestObject(request)
+      const _res = responseObject(response)
+      const policy = this.policy.revalidatedPolicy(_req, _res)
+      return !policy.modified
     }
+  }
+  policy = CachePolicy
+  return policy
+}
 
-    // stream.promise().then(() => done, er => emitted error)
-    promise() {
-      return new Promise((resolve, reject) => {
-        this.on(DESTROYED, () => reject(new Error('stream destroyed')))
-        this.on('error', er => reject(er))
-        this.on('end', () => resolve())
-      })
+let errors$2
+let hasRequiredErrors$2
+function requireErrors$2() {
+  if (hasRequiredErrors$2) {
+    return errors$2
+  }
+  hasRequiredErrors$2 = 1
+  class NotCachedError extends Error {
+    constructor(url) {
+      /* eslint-disable-next-line max-len */
+      super(
+        `request to ${url} failed: cache mode is 'only-if-cached' but no cached response is available.`
+      )
+      this.code = 'ENOTCACHED'
     }
+  }
+  errors$2 = {
+    NotCachedError
+  }
+  return errors$2
+}
 
-    // for await (let chunk of stream)
-    [ASYNCITERATOR]() {
-      const next = () => {
-        const res = this.read()
-        if (res !== null) {
-          return Promise.resolve({
-            done: false,
-            value: res
-          })
-        }
-        if (this[EOF]) {
-          return Promise.resolve({
-            done: true
-          })
-        }
-        let resolve = null
-        let reject = null
-        const onerr = er => {
-          this.removeListener('data', ondata)
-          this.removeListener('end', onend)
-          reject(er)
-        }
-        const ondata = value => {
-          this.removeListener('error', onerr)
-          this.removeListener('end', onend)
-          this.pause()
-          resolve({
-            value: value,
-            done: !!this[EOF]
-          })
-        }
-        const onend = () => {
-          this.removeListener('error', onerr)
-          this.removeListener('data', ondata)
-          resolve({
-            done: true
-          })
+let minipassFlush
+let hasRequiredMinipassFlush
+function requireMinipassFlush() {
+  if (hasRequiredMinipassFlush) {
+    return minipassFlush
+  }
+  hasRequiredMinipassFlush = 1
+  const Minipass = requireMinipass()
+  const _flush = Symbol('_flush')
+  const _flushed = Symbol('_flushed')
+  const _flushing = Symbol('_flushing')
+  class Flush extends Minipass {
+    constructor(opt = {}) {
+      if (typeof opt === 'function') {
+        opt = {
+          flush: opt
         }
-        const ondestroy = () => onerr(new Error('stream destroyed'))
-        return new Promise((res, rej) => {
-          reject = rej
-          resolve = res
-          this.once(DESTROYED, ondestroy)
-          this.once('error', onerr)
-          this.once('end', onend)
-          this.once('data', ondata)
-        })
       }
-      return {
-        next
+      super(opt)
+
+      // or extend this class and provide a 'flush' method in your subclass
+      if (typeof opt.flush !== 'function' && typeof this.flush !== 'function') {
+        throw new TypeError('must provide flush function in options')
+      }
+      this[_flush] = opt.flush || this.flush
+    }
+    emit(ev, ...data) {
+      if ((ev !== 'end' && ev !== 'finish') || this[_flushed]) {
+        return super.emit(ev, ...data)
+      }
+      if (this[_flushing]) {
+        return
+      }
+      this[_flushing] = true
+      const afterFlush = er => {
+        this[_flushed] = true
+        er ? super.emit('error', er) : super.emit('end')
+      }
+      const ret = this[_flush](afterFlush)
+      if (ret && ret.then) {
+        ret.then(
+          () => afterFlush(),
+          er => afterFlush(er)
+        )
       }
     }
+  }
+  minipassFlush = Flush
+  return minipassFlush
+}
 
-    // for (let chunk of stream)
-    [ITERATOR]() {
-      const next = () => {
-        const value = this.read()
-        const done = value === null
-        return {
-          value,
-          done
-        }
+const lib$6 = { exports: {} }
+
+const get = { exports: {} }
+
+const minipassCollect = { exports: {} }
+
+let hasRequiredMinipassCollect
+function requireMinipassCollect() {
+  if (hasRequiredMinipassCollect) {
+    return minipassCollect.exports
+  }
+  hasRequiredMinipassCollect = 1
+  const { Minipass } = requireCommonjs$5()
+  const _data = Symbol('_data')
+  const _length = Symbol('_length')
+  class Collect extends Minipass {
+    constructor(options) {
+      super(options)
+      this[_data] = []
+      this[_length] = 0
+    }
+    write(chunk, encoding, cb) {
+      if (typeof encoding === 'function') {
+        ;(cb = encoding), (encoding = 'utf8')
       }
-      return {
-        next
+      if (!encoding) {
+        encoding = 'utf8'
+      }
+      const c = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding)
+      this[_data].push(c)
+      this[_length] += c.length
+      if (cb) {
+        cb()
       }
+      return true
     }
-    destroy(er) {
-      if (this[DESTROYED]) {
-        if (er) {
-          this.emit('error', er)
-        } else {
-          this.emit(DESTROYED)
-        }
-        return this
+    end(chunk, encoding, cb) {
+      if (typeof chunk === 'function') {
+        ;(cb = chunk), (chunk = null)
       }
-      this[DESTROYED] = true
-
-      // throw away all buffered data, it's never coming out
-      this.buffer.length = 0
-      this[BUFFERLENGTH] = 0
-      if (typeof this.close === 'function' && !this[CLOSED]) {
-        this.close()
+      if (typeof encoding === 'function') {
+        ;(cb = encoding), (encoding = 'utf8')
       }
-      if (er) {
-        this.emit('error', er)
+      if (chunk) {
+        this.write(chunk, encoding)
       }
-      // if no error to emit, still reject pending promises
-      else {
-        this.emit(DESTROYED)
+      const result = Buffer.concat(this[_data], this[_length])
+      super.write(result)
+      return super.end(cb)
+    }
+  }
+  minipassCollect.exports = Collect
+
+  // it would be possible to DRY this a bit by doing something like
+  // this.collector = new Collect() and listening on its data event,
+  // but it's not much code, and we may as well save the extra obj
+  class CollectPassThrough extends Minipass {
+    constructor(options) {
+      super(options)
+      this[_data] = []
+      this[_length] = 0
+    }
+    write(chunk, encoding, cb) {
+      if (typeof encoding === 'function') {
+        ;(cb = encoding), (encoding = 'utf8')
       }
-      return this
+      if (!encoding) {
+        encoding = 'utf8'
+      }
+      const c = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding)
+      this[_data].push(c)
+      this[_length] += c.length
+      return super.write(chunk, encoding, cb)
     }
-    static isStream(s) {
-      return (
-        !!s &&
-        (s instanceof Minipass ||
-          s instanceof Stream ||
-          (s instanceof EE &&
-            (typeof s.pipe === 'function' ||
-              // readable
-              (typeof s.write === 'function' && typeof s.end === 'function')))) // writable
-      )
+    end(chunk, encoding, cb) {
+      if (typeof chunk === 'function') {
+        ;(cb = chunk), (chunk = null)
+      }
+      if (typeof encoding === 'function') {
+        ;(cb = encoding), (encoding = 'utf8')
+      }
+      if (chunk) {
+        this.write(chunk, encoding)
+      }
+      const result = Buffer.concat(this[_data], this[_length])
+      this.emit('collect', result)
+      return super.end(cb)
     }
   }
-  return minipass
+  minipassCollect.exports.PassThrough = CollectPassThrough
+  return minipassCollect.exports
 }
 
 let minipassPipeline
@@ -35368,7 +33972,11 @@ function requireCommon() {
   Object.defineProperty(common, '__esModule', {
     value: true
   })
-  common.isCorrect = common.isInSubnet = void 0
+  common.isInSubnet = isInSubnet
+  common.isCorrect = isCorrect
+  common.numberToPaddedHex = numberToPaddedHex
+  common.stringToPaddedHex = stringToPaddedHex
+  common.testBit = testBit
   function isInSubnet(address) {
     if (this.subnetMask < address.subnetMask) {
       return false
@@ -35378,7 +33986,6 @@ function requireCommon() {
     }
     return false
   }
-  common.isInSubnet = isInSubnet
   function isCorrect(defaultBits) {
     return function () {
       if (this.addressMinusSuffix !== this.correctForm()) {
@@ -35390,7 +33997,24 @@ function requireCommon() {
       return this.parsedSubnet === String(this.subnetMask)
     }
   }
-  common.isCorrect = isCorrect
+  function numberToPaddedHex(number) {
+    return number.toString(16).padStart(2, '0')
+  }
+  function stringToPaddedHex(numberString) {
+    return numberToPaddedHex(parseInt(numberString, 10))
+  }
+  /**
+   * @param binaryValue Binary representation of a value (e.g. `10`)
+   * @param position Byte position, where 0 is the least significant bit
+   */
+  function testBit(binaryValue, position) {
+    const { length } = binaryValue
+    if (position > length) {
+      return false
+    }
+    const positionInString = length - position
+    return binaryValue.substring(positionInString, positionInString + 1) === '1'
+  }
   return common
 }
 
@@ -35434,2213 +34058,13 @@ function requireAddressError() {
     constructor(message, parseMessage) {
       super(message)
       this.name = 'AddressError'
-      if (parseMessage !== null) {
-        this.parseMessage = parseMessage
-      }
+      this.parseMessage = parseMessage
     }
   }
   addressError.AddressError = AddressError
   return addressError
 }
 
-const jsbn = { exports: {} }
-
-let hasRequiredJsbn
-function requireJsbn() {
-  if (hasRequiredJsbn) {
-    return jsbn.exports
-  }
-  hasRequiredJsbn = 1
-  ;(function (module, exports) {
-    ;(function () {
-      // Copyright (c) 2005  Tom Wu
-      // All Rights Reserved.
-      // See "LICENSE" for details.
-
-      // Basic JavaScript BN library - subset useful for RSA encryption.
-
-      // Bits per digit
-      let dbits
-
-      // JavaScript engine analysis
-      const canary = 0xdeadbeefcafe
-      const j_lm = (canary & 0xffffff) == 0xefcafe
-
-      // (public) Constructor
-      function BigInteger(a, b, c) {
-        if (a != null) {
-          if ('number' == typeof a) this.fromNumber(a, b, c)
-          else if (b == null && 'string' != typeof a) this.fromString(a, 256)
-          else this.fromString(a, b)
-        }
-      }
-
-      // return new, unset BigInteger
-      function nbi() {
-        return new BigInteger(null)
-      }
-
-      // am: Compute w_j += (x*this_i), propagate carries,
-      // c is initial carry, returns final carry.
-      // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
-      // We need to select the fastest one that works in this environment.
-
-      // am1: use a single mult and divide to get the high bits,
-      // max digit bits should be 26 because
-      // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
-      function am1(i, x, w, j, c, n) {
-        while (--n >= 0) {
-          const v = x * this[i++] + w[j] + c
-          c = Math.floor(v / 0x4000000)
-          w[j++] = v & 0x3ffffff
-        }
-        return c
-      }
-      // am2 avoids a big mult-and-extract completely.
-      // Max digit bits should be <= 30 because we do bitwise ops
-      // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
-      function am2(i, x, w, j, c, n) {
-        const xl = x & 0x7fff,
-          xh = x >> 15
-        while (--n >= 0) {
-          let l = this[i] & 0x7fff
-          const h = this[i++] >> 15
-          const m = xh * l + h * xl
-          l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff)
-          c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30)
-          w[j++] = l & 0x3fffffff
-        }
-        return c
-      }
-      // Alternately, set max digit bits to 28 since some
-      // browsers slow down when dealing with 32-bit numbers.
-      function am3(i, x, w, j, c, n) {
-        const xl = x & 0x3fff,
-          xh = x >> 14
-        while (--n >= 0) {
-          let l = this[i] & 0x3fff
-          const h = this[i++] >> 14
-          const m = xh * l + h * xl
-          l = xl * l + ((m & 0x3fff) << 14) + w[j] + c
-          c = (l >> 28) + (m >> 14) + xh * h
-          w[j++] = l & 0xfffffff
-        }
-        return c
-      }
-      const inBrowser = typeof navigator !== 'undefined'
-      if (
-        inBrowser &&
-        j_lm &&
-        navigator.appName == 'Microsoft Internet Explorer'
-      ) {
-        BigInteger.prototype.am = am2
-        dbits = 30
-      } else if (inBrowser && j_lm && navigator.appName != 'Netscape') {
-        BigInteger.prototype.am = am1
-        dbits = 26
-      } else {
-        // Mozilla/Netscape seems to prefer am3
-        BigInteger.prototype.am = am3
-        dbits = 28
-      }
-      BigInteger.prototype.DB = dbits
-      BigInteger.prototype.DM = (1 << dbits) - 1
-      BigInteger.prototype.DV = 1 << dbits
-      const BI_FP = 52
-      BigInteger.prototype.FV = Math.pow(2, BI_FP)
-      BigInteger.prototype.F1 = BI_FP - dbits
-      BigInteger.prototype.F2 = 2 * dbits - BI_FP
-
-      // Digit conversions
-      const BI_RM = '0123456789abcdefghijklmnopqrstuvwxyz'
-      const BI_RC = new Array()
-      let rr, vv
-      rr = '0'.charCodeAt(0)
-      for (vv = 0; vv <= 9; ++vv) {
-        BI_RC[rr++] = vv
-      }
-      rr = 'a'.charCodeAt(0)
-      for (vv = 10; vv < 36; ++vv) {
-        BI_RC[rr++] = vv
-      }
-      rr = 'A'.charCodeAt(0)
-      for (vv = 10; vv < 36; ++vv) {
-        BI_RC[rr++] = vv
-      }
-      function int2char(n) {
-        return BI_RM.charAt(n)
-      }
-      function intAt(s, i) {
-        const c = BI_RC[s.charCodeAt(i)]
-        return c == null ? -1 : c
-      }
-
-      // (protected) copy this to r
-      function bnpCopyTo(r) {
-        for (let i = this.t - 1; i >= 0; --i) {
-          r[i] = this[i]
-        }
-        r.t = this.t
-        r.s = this.s
-      }
-
-      // (protected) set from integer value x, -DV <= x < DV
-      function bnpFromInt(x) {
-        this.t = 1
-        this.s = x < 0 ? -1 : 0
-        if (x > 0) {
-          this[0] = x
-        } else if (x < -1) {
-          this[0] = x + this.DV
-        } else {
-          this.t = 0
-        }
-      }
-
-      // return bigint initialized to value
-      function nbv(i) {
-        const r = nbi()
-        r.fromInt(i)
-        return r
-      }
-
-      // (protected) set from string and radix
-      function bnpFromString(s, b) {
-        let k
-        if (b == 16) {
-          k = 4
-        } else if (b == 8) {
-          k = 3
-        } else if (b == 256) {
-          k = 8
-        } // byte array
-        else if (b == 2) {
-          k = 1
-        } else if (b == 32) {
-          k = 5
-        } else if (b == 4) {
-          k = 2
-        } else {
-          this.fromRadix(s, b)
-          return
-        }
-        this.t = 0
-        this.s = 0
-        let i = s.length,
-          mi = false,
-          sh = 0
-        while (--i >= 0) {
-          const x = k == 8 ? s[i] & 0xff : intAt(s, i)
-          if (x < 0) {
-            if (s.charAt(i) == '-') {
-              mi = true
-            }
-            continue
-          }
-          mi = false
-          if (sh == 0) {
-            this[this.t++] = x
-          } else if (sh + k > this.DB) {
-            this[this.t - 1] |= (x & ((1 << (this.DB - sh)) - 1)) << sh
-            this[this.t++] = x >> (this.DB - sh)
-          } else {
-            this[this.t - 1] |= x << sh
-          }
-          sh += k
-          if (sh >= this.DB) {
-            sh -= this.DB
-          }
-        }
-        if (k == 8 && (s[0] & 0x80) != 0) {
-          this.s = -1
-          if (sh > 0) {
-            this[this.t - 1] |= ((1 << (this.DB - sh)) - 1) << sh
-          }
-        }
-        this.clamp()
-        if (mi) {
-          BigInteger.ZERO.subTo(this, this)
-        }
-      }
-
-      // (protected) clamp off excess high words
-      function bnpClamp() {
-        const c = this.s & this.DM
-        while (this.t > 0 && this[this.t - 1] == c) {
-          --this.t
-        }
-      }
-
-      // (public) return string representation in given radix
-      function bnToString(b) {
-        if (this.s < 0) {
-          return '-' + this.negate().toString(b)
-        }
-        let k
-        if (b == 16) {
-          k = 4
-        } else if (b == 8) {
-          k = 3
-        } else if (b == 2) {
-          k = 1
-        } else if (b == 32) {
-          k = 5
-        } else if (b == 4) {
-          k = 2
-        } else {
-          return this.toRadix(b)
-        }
-        let km = (1 << k) - 1,
-          d,
-          m = false,
-          r = '',
-          i = this.t
-        let p = this.DB - ((i * this.DB) % k)
-        if (i-- > 0) {
-          if (p < this.DB && (d = this[i] >> p) > 0) {
-            m = true
-            r = int2char(d)
-          }
-          while (i >= 0) {
-            if (p < k) {
-              d = (this[i] & ((1 << p) - 1)) << (k - p)
-              d |= this[--i] >> (p += this.DB - k)
-            } else {
-              d = (this[i] >> (p -= k)) & km
-              if (p <= 0) {
-                p += this.DB
-                --i
-              }
-            }
-            if (d > 0) {
-              m = true
-            }
-            if (m) {
-              r += int2char(d)
-            }
-          }
-        }
-        return m ? r : '0'
-      }
-
-      // (public) -this
-      function bnNegate() {
-        const r = nbi()
-        BigInteger.ZERO.subTo(this, r)
-        return r
-      }
-
-      // (public) |this|
-      function bnAbs() {
-        return this.s < 0 ? this.negate() : this
-      }
-
-      // (public) return + if this > a, - if this < a, 0 if equal
-      function bnCompareTo(a) {
-        let r = this.s - a.s
-        if (r != 0) {
-          return r
-        }
-        let i = this.t
-        r = i - a.t
-        if (r != 0) {
-          return this.s < 0 ? -r : r
-        }
-        while (--i >= 0) {
-          if ((r = this[i] - a[i]) != 0) return r
-        }
-        return 0
-      }
-
-      // returns bit length of the integer x
-      function nbits(x) {
-        let r = 1,
-          t
-        if ((t = x >>> 16) != 0) {
-          x = t
-          r += 16
-        }
-        if ((t = x >> 8) != 0) {
-          x = t
-          r += 8
-        }
-        if ((t = x >> 4) != 0) {
-          x = t
-          r += 4
-        }
-        if ((t = x >> 2) != 0) {
-          x = t
-          r += 2
-        }
-        if ((t = x >> 1) != 0) {
-          x = t
-          r += 1
-        }
-        return r
-      }
-
-      // (public) return the number of bits in "this"
-      function bnBitLength() {
-        if (this.t <= 0) {
-          return 0
-        }
-        return (
-          this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM))
-        )
-      }
-
-      // (protected) r = this << n*DB
-      function bnpDLShiftTo(n, r) {
-        let i
-        for (i = this.t - 1; i >= 0; --i) {
-          r[i + n] = this[i]
-        }
-        for (i = n - 1; i >= 0; --i) {
-          r[i] = 0
-        }
-        r.t = this.t + n
-        r.s = this.s
-      }
-
-      // (protected) r = this >> n*DB
-      function bnpDRShiftTo(n, r) {
-        for (let i = n; i < this.t; ++i) {
-          r[i - n] = this[i]
-        }
-        r.t = Math.max(this.t - n, 0)
-        r.s = this.s
-      }
-
-      // (protected) r = this << n
-      function bnpLShiftTo(n, r) {
-        const bs = n % this.DB
-        const cbs = this.DB - bs
-        const bm = (1 << cbs) - 1
-        let ds = Math.floor(n / this.DB),
-          c = (this.s << bs) & this.DM,
-          i
-        for (i = this.t - 1; i >= 0; --i) {
-          r[i + ds + 1] = (this[i] >> cbs) | c
-          c = (this[i] & bm) << bs
-        }
-        for (i = ds - 1; i >= 0; --i) {
-          r[i] = 0
-        }
-        r[ds] = c
-        r.t = this.t + ds + 1
-        r.s = this.s
-        r.clamp()
-      }
-
-      // (protected) r = this >> n
-      function bnpRShiftTo(n, r) {
-        r.s = this.s
-        const ds = Math.floor(n / this.DB)
-        if (ds >= this.t) {
-          r.t = 0
-          return
-        }
-        const bs = n % this.DB
-        const cbs = this.DB - bs
-        const bm = (1 << bs) - 1
-        r[0] = this[ds] >> bs
-        for (let i = ds + 1; i < this.t; ++i) {
-          r[i - ds - 1] |= (this[i] & bm) << cbs
-          r[i - ds] = this[i] >> bs
-        }
-        if (bs > 0) {
-          r[this.t - ds - 1] |= (this.s & bm) << cbs
-        }
-        r.t = this.t - ds
-        r.clamp()
-      }
-
-      // (protected) r = this - a
-      function bnpSubTo(a, r) {
-        let i = 0,
-          c = 0,
-          m = Math.min(a.t, this.t)
-        while (i < m) {
-          c += this[i] - a[i]
-          r[i++] = c & this.DM
-          c >>= this.DB
-        }
-        if (a.t < this.t) {
-          c -= a.s
-          while (i < this.t) {
-            c += this[i]
-            r[i++] = c & this.DM
-            c >>= this.DB
-          }
-          c += this.s
-        } else {
-          c += this.s
-          while (i < a.t) {
-            c -= a[i]
-            r[i++] = c & this.DM
-            c >>= this.DB
-          }
-          c -= a.s
-        }
-        r.s = c < 0 ? -1 : 0
-        if (c < -1) {
-          r[i++] = this.DV + c
-        } else if (c > 0) {
-          r[i++] = c
-        }
-        r.t = i
-        r.clamp()
-      }
-
-      // (protected) r = this * a, r != this,a (HAC 14.12)
-      // "this" should be the larger one if appropriate.
-      function bnpMultiplyTo(a, r) {
-        const x = this.abs(),
-          y = a.abs()
-        let i = x.t
-        r.t = i + y.t
-        while (--i >= 0) {
-          r[i] = 0
-        }
-        for (i = 0; i < y.t; ++i) {
-          r[i + x.t] = x.am(0, y[i], r, i, 0, x.t)
-        }
-        r.s = 0
-        r.clamp()
-        if (this.s != a.s) {
-          BigInteger.ZERO.subTo(r, r)
-        }
-      }
-
-      // (protected) r = this^2, r != this (HAC 14.16)
-      function bnpSquareTo(r) {
-        const x = this.abs()
-        let i = (r.t = 2 * x.t)
-        while (--i >= 0) {
-          r[i] = 0
-        }
-        for (i = 0; i < x.t - 1; ++i) {
-          const c = x.am(i, x[i], r, 2 * i, 0, 1)
-          if (
-            (r[i + x.t] += x.am(
-              i + 1,
-              2 * x[i],
-              r,
-              2 * i + 1,
-              c,
-              x.t - i - 1
-            )) >= x.DV
-          ) {
-            r[i + x.t] -= x.DV
-            r[i + x.t + 1] = 1
-          }
-        }
-        if (r.t > 0) {
-          r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1)
-        }
-        r.s = 0
-        r.clamp()
-      }
-
-      // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
-      // r != q, this != m.  q or r may be null.
-      function bnpDivRemTo(m, q, r) {
-        const pm = m.abs()
-        if (pm.t <= 0) {
-          return
-        }
-        const pt = this.abs()
-        if (pt.t < pm.t) {
-          if (q != null) {
-            q.fromInt(0)
-          }
-          if (r != null) {
-            this.copyTo(r)
-          }
-          return
-        }
-        if (r == null) {
-          r = nbi()
-        }
-        const y = nbi(),
-          ts = this.s,
-          ms = m.s
-        const nsh = this.DB - nbits(pm[pm.t - 1]) // normalize modulus
-        if (nsh > 0) {
-          pm.lShiftTo(nsh, y)
-          pt.lShiftTo(nsh, r)
-        } else {
-          pm.copyTo(y)
-          pt.copyTo(r)
-        }
-        const ys = y.t
-        const y0 = y[ys - 1]
-        if (y0 == 0) {
-          return
-        }
-        const yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0)
-        const d1 = this.FV / yt,
-          d2 = (1 << this.F1) / yt,
-          e = 1 << this.F2
-        let i = r.t,
-          j = i - ys,
-          t = q == null ? nbi() : q
-        y.dlShiftTo(j, t)
-        if (r.compareTo(t) >= 0) {
-          r[r.t++] = 1
-          r.subTo(t, r)
-        }
-        BigInteger.ONE.dlShiftTo(ys, t)
-        t.subTo(y, y) // "negative" y so we can replace sub with am later
-        while (y.t < ys) {
-          y[y.t++] = 0
-        }
-        while (--j >= 0) {
-          // Estimate quotient digit
-          let qd =
-            r[--i] == y0 ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2)
-          if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) {
-            // Try it out
-            y.dlShiftTo(j, t)
-            r.subTo(t, r)
-            while (r[i] < --qd) {
-              r.subTo(t, r)
-            }
-          }
-        }
-        if (q != null) {
-          r.drShiftTo(ys, q)
-          if (ts != ms) {
-            BigInteger.ZERO.subTo(q, q)
-          }
-        }
-        r.t = ys
-        r.clamp()
-        if (nsh > 0) {
-          r.rShiftTo(nsh, r)
-        } // Denormalize remainder
-        if (ts < 0) {
-          BigInteger.ZERO.subTo(r, r)
-        }
-      }
-
-      // (public) this mod a
-      function bnMod(a) {
-        const r = nbi()
-        this.abs().divRemTo(a, null, r)
-        if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) {
-          a.subTo(r, r)
-        }
-        return r
-      }
-
-      // Modular reduction using "classic" algorithm
-      function Classic(m) {
-        this.m = m
-      }
-      function cConvert(x) {
-        if (x.s < 0 || x.compareTo(this.m) >= 0) {
-          return x.mod(this.m)
-        } else {
-          return x
-        }
-      }
-      function cRevert(x) {
-        return x
-      }
-      function cReduce(x) {
-        x.divRemTo(this.m, null, x)
-      }
-      function cMulTo(x, y, r) {
-        x.multiplyTo(y, r)
-        this.reduce(r)
-      }
-      function cSqrTo(x, r) {
-        x.squareTo(r)
-        this.reduce(r)
-      }
-      Classic.prototype.convert = cConvert
-      Classic.prototype.revert = cRevert
-      Classic.prototype.reduce = cReduce
-      Classic.prototype.mulTo = cMulTo
-      Classic.prototype.sqrTo = cSqrTo
-
-      // (protected) return "-1/this % 2^DB"; useful for Mont. reduction
-      // justification:
-      //         xy == 1 (mod m)
-      //         xy =  1+km
-      //   xy(2-xy) = (1+km)(1-km)
-      // x[y(2-xy)] = 1-k^2m^2
-      // x[y(2-xy)] == 1 (mod m^2)
-      // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
-      // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
-      // JS multiply "overflows" differently from C/C++, so care is needed here.
-      function bnpInvDigit() {
-        if (this.t < 1) {
-          return 0
-        }
-        const x = this[0]
-        if ((x & 1) == 0) {
-          return 0
-        }
-        let y = x & 3 // y == 1/x mod 2^2
-        y = (y * (2 - (x & 0xf) * y)) & 0xf // y == 1/x mod 2^4
-        y = (y * (2 - (x & 0xff) * y)) & 0xff // y == 1/x mod 2^8
-        y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff // y == 1/x mod 2^16
-        // last step - calculate inverse mod DV directly;
-        // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
-        y = (y * (2 - ((x * y) % this.DV))) % this.DV // y == 1/x mod 2^dbits
-        // we really want the negative inverse, and -DV < y < DV
-        return y > 0 ? this.DV - y : -y
-      }
-
-      // Montgomery reduction
-      function Montgomery(m) {
-        this.m = m
-        this.mp = m.invDigit()
-        this.mpl = this.mp & 0x7fff
-        this.mph = this.mp >> 15
-        this.um = (1 << (m.DB - 15)) - 1
-        this.mt2 = 2 * m.t
-      }
-
-      // xR mod m
-      function montConvert(x) {
-        const r = nbi()
-        x.abs().dlShiftTo(this.m.t, r)
-        r.divRemTo(this.m, null, r)
-        if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) {
-          this.m.subTo(r, r)
-        }
-        return r
-      }
-
-      // x/R mod m
-      function montRevert(x) {
-        const r = nbi()
-        x.copyTo(r)
-        this.reduce(r)
-        return r
-      }
-
-      // x = x/R mod m (HAC 14.32)
-      function montReduce(x) {
-        while (x.t <= this.mt2) {
-          // pad x so am has enough room later
-          x[x.t++] = 0
-        }
-        for (let i = 0; i < this.m.t; ++i) {
-          // faster way of calculating u0 = x[i]*mp mod DV
-          let j = x[i] & 0x7fff
-          const u0 =
-            (j * this.mpl +
-              (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) &
-            x.DM
-          // use am to combine the multiply-shift-add into one call
-          j = i + this.m.t
-          x[j] += this.m.am(0, u0, x, i, 0, this.m.t)
-          // propagate carry
-          while (x[j] >= x.DV) {
-            x[j] -= x.DV
-            x[++j]++
-          }
-        }
-        x.clamp()
-        x.drShiftTo(this.m.t, x)
-        if (x.compareTo(this.m) >= 0) {
-          x.subTo(this.m, x)
-        }
-      }
-
-      // r = "x^2/R mod m"; x != r
-      function montSqrTo(x, r) {
-        x.squareTo(r)
-        this.reduce(r)
-      }
-
-      // r = "xy/R mod m"; x,y != r
-      function montMulTo(x, y, r) {
-        x.multiplyTo(y, r)
-        this.reduce(r)
-      }
-      Montgomery.prototype.convert = montConvert
-      Montgomery.prototype.revert = montRevert
-      Montgomery.prototype.reduce = montReduce
-      Montgomery.prototype.mulTo = montMulTo
-      Montgomery.prototype.sqrTo = montSqrTo
-
-      // (protected) true iff this is even
-      function bnpIsEven() {
-        return (this.t > 0 ? this[0] & 1 : this.s) == 0
-      }
-
-      // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
-      function bnpExp(e, z) {
-        if (e > 0xffffffff || e < 1) {
-          return BigInteger.ONE
-        }
-        let r = nbi(),
-          r2 = nbi(),
-          g = z.convert(this),
-          i = nbits(e) - 1
-        g.copyTo(r)
-        while (--i >= 0) {
-          z.sqrTo(r, r2)
-          if ((e & (1 << i)) > 0) {
-            z.mulTo(r2, g, r)
-          } else {
-            const t = r
-            r = r2
-            r2 = t
-          }
-        }
-        return z.revert(r)
-      }
-
-      // (public) this^e % m, 0 <= e < 2^32
-      function bnModPowInt(e, m) {
-        let z
-        if (e < 256 || m.isEven()) {
-          z = new Classic(m)
-        } else {
-          z = new Montgomery(m)
-        }
-        return this.exp(e, z)
-      }
-
-      // protected
-      BigInteger.prototype.copyTo = bnpCopyTo
-      BigInteger.prototype.fromInt = bnpFromInt
-      BigInteger.prototype.fromString = bnpFromString
-      BigInteger.prototype.clamp = bnpClamp
-      BigInteger.prototype.dlShiftTo = bnpDLShiftTo
-      BigInteger.prototype.drShiftTo = bnpDRShiftTo
-      BigInteger.prototype.lShiftTo = bnpLShiftTo
-      BigInteger.prototype.rShiftTo = bnpRShiftTo
-      BigInteger.prototype.subTo = bnpSubTo
-      BigInteger.prototype.multiplyTo = bnpMultiplyTo
-      BigInteger.prototype.squareTo = bnpSquareTo
-      BigInteger.prototype.divRemTo = bnpDivRemTo
-      BigInteger.prototype.invDigit = bnpInvDigit
-      BigInteger.prototype.isEven = bnpIsEven
-      BigInteger.prototype.exp = bnpExp
-
-      // public
-      BigInteger.prototype.toString = bnToString
-      BigInteger.prototype.negate = bnNegate
-      BigInteger.prototype.abs = bnAbs
-      BigInteger.prototype.compareTo = bnCompareTo
-      BigInteger.prototype.bitLength = bnBitLength
-      BigInteger.prototype.mod = bnMod
-      BigInteger.prototype.modPowInt = bnModPowInt
-
-      // "constants"
-      BigInteger.ZERO = nbv(0)
-      BigInteger.ONE = nbv(1)
-
-      // Copyright (c) 2005-2009  Tom Wu
-      // All Rights Reserved.
-      // See "LICENSE" for details.
-
-      // Extended JavaScript BN functions, required for RSA private ops.
-
-      // Version 1.1: new BigInteger("0", 10) returns "proper" zero
-      // Version 1.2: square() API, isProbablePrime fix
-
-      // (public)
-      function bnClone() {
-        const r = nbi()
-        this.copyTo(r)
-        return r
-      }
-
-      // (public) return value as integer
-      function bnIntValue() {
-        if (this.s < 0) {
-          if (this.t == 1) {
-            return this[0] - this.DV
-          } else if (this.t == 0) {
-            return -1
-          }
-        } else if (this.t == 1) {
-          return this[0]
-        } else if (this.t == 0) {
-          return 0
-        }
-        // assumes 16 < DB < 32
-        return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0]
-      }
-
-      // (public) return value as byte
-      function bnByteValue() {
-        return this.t == 0 ? this.s : (this[0] << 24) >> 24
-      }
-
-      // (public) return value as short (assumes DB>=16)
-      function bnShortValue() {
-        return this.t == 0 ? this.s : (this[0] << 16) >> 16
-      }
-
-      // (protected) return x s.t. r^x < DV
-      function bnpChunkSize(r) {
-        return Math.floor((Math.LN2 * this.DB) / Math.log(r))
-      }
-
-      // (public) 0 if this == 0, 1 if this > 0
-      function bnSigNum() {
-        if (this.s < 0) {
-          return -1
-        } else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) {
-          return 0
-        } else {
-          return 1
-        }
-      }
-
-      // (protected) convert to radix string
-      function bnpToRadix(b) {
-        if (b == null) {
-          b = 10
-        }
-        if (this.signum() == 0 || b < 2 || b > 36) {
-          return '0'
-        }
-        const cs = this.chunkSize(b)
-        const a = Math.pow(b, cs)
-        let d = nbv(a),
-          y = nbi(),
-          z = nbi(),
-          r = ''
-        this.divRemTo(d, y, z)
-        while (y.signum() > 0) {
-          r = (a + z.intValue()).toString(b).substr(1) + r
-          y.divRemTo(d, y, z)
-        }
-        return z.intValue().toString(b) + r
-      }
-
-      // (protected) convert from radix string
-      function bnpFromRadix(s, b) {
-        this.fromInt(0)
-        if (b == null) {
-          b = 10
-        }
-        const cs = this.chunkSize(b)
-        let d = Math.pow(b, cs),
-          mi = false,
-          j = 0,
-          w = 0
-        for (let i = 0; i < s.length; ++i) {
-          const x = intAt(s, i)
-          if (x < 0) {
-            if (s.charAt(i) == '-' && this.signum() == 0) {
-              mi = true
-            }
-            continue
-          }
-          w = b * w + x
-          if (++j >= cs) {
-            this.dMultiply(d)
-            this.dAddOffset(w, 0)
-            j = 0
-            w = 0
-          }
-        }
-        if (j > 0) {
-          this.dMultiply(Math.pow(b, j))
-          this.dAddOffset(w, 0)
-        }
-        if (mi) {
-          BigInteger.ZERO.subTo(this, this)
-        }
-      }
-
-      // (protected) alternate constructor
-      function bnpFromNumber(a, b, c) {
-        if ('number' == typeof b) {
-          // new BigInteger(int,int,RNG)
-          if (a < 2) {
-            this.fromInt(1)
-          } else {
-            this.fromNumber(a, c)
-            if (!this.testBit(a - 1)) {
-              // force MSB set
-              this.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, this)
-            }
-            if (this.isEven()) {
-              this.dAddOffset(1, 0)
-            } // force odd
-            while (!this.isProbablePrime(b)) {
-              this.dAddOffset(2, 0)
-              if (this.bitLength() > a) {
-                this.subTo(BigInteger.ONE.shiftLeft(a - 1), this)
-              }
-            }
-          }
-        } else {
-          // new BigInteger(int,RNG)
-          const x = new Array(),
-            t = a & 7
-          x.length = (a >> 3) + 1
-          b.nextBytes(x)
-          if (t > 0) {
-            x[0] &= (1 << t) - 1
-          } else {
-            x[0] = 0
-          }
-          this.fromString(x, 256)
-        }
-      }
-
-      // (public) convert to bigendian byte array
-      function bnToByteArray() {
-        let i = this.t,
-          r = new Array()
-        r[0] = this.s
-        let p = this.DB - ((i * this.DB) % 8),
-          d,
-          k = 0
-        if (i-- > 0) {
-          if (p < this.DB && (d = this[i] >> p) != (this.s & this.DM) >> p) {
-            r[k++] = d | (this.s << (this.DB - p))
-          }
-          while (i >= 0) {
-            if (p < 8) {
-              d = (this[i] & ((1 << p) - 1)) << (8 - p)
-              d |= this[--i] >> (p += this.DB - 8)
-            } else {
-              d = (this[i] >> (p -= 8)) & 0xff
-              if (p <= 0) {
-                p += this.DB
-                --i
-              }
-            }
-            if ((d & 0x80) != 0) {
-              d |= -256
-            }
-            if (k == 0 && (this.s & 0x80) != (d & 0x80)) {
-              ++k
-            }
-            if (k > 0 || d != this.s) {
-              r[k++] = d
-            }
-          }
-        }
-        return r
-      }
-      function bnEquals(a) {
-        return this.compareTo(a) == 0
-      }
-      function bnMin(a) {
-        return this.compareTo(a) < 0 ? this : a
-      }
-      function bnMax(a) {
-        return this.compareTo(a) > 0 ? this : a
-      }
-
-      // (protected) r = this op a (bitwise)
-      function bnpBitwiseTo(a, op, r) {
-        let i,
-          f,
-          m = Math.min(a.t, this.t)
-        for (i = 0; i < m; ++i) {
-          r[i] = op(this[i], a[i])
-        }
-        if (a.t < this.t) {
-          f = a.s & this.DM
-          for (i = m; i < this.t; ++i) {
-            r[i] = op(this[i], f)
-          }
-          r.t = this.t
-        } else {
-          f = this.s & this.DM
-          for (i = m; i < a.t; ++i) {
-            r[i] = op(f, a[i])
-          }
-          r.t = a.t
-        }
-        r.s = op(this.s, a.s)
-        r.clamp()
-      }
-
-      // (public) this & a
-      function op_and(x, y) {
-        return x & y
-      }
-      function bnAnd(a) {
-        const r = nbi()
-        this.bitwiseTo(a, op_and, r)
-        return r
-      }
-
-      // (public) this | a
-      function op_or(x, y) {
-        return x | y
-      }
-      function bnOr(a) {
-        const r = nbi()
-        this.bitwiseTo(a, op_or, r)
-        return r
-      }
-
-      // (public) this ^ a
-      function op_xor(x, y) {
-        return x ^ y
-      }
-      function bnXor(a) {
-        const r = nbi()
-        this.bitwiseTo(a, op_xor, r)
-        return r
-      }
-
-      // (public) this & ~a
-      function op_andnot(x, y) {
-        return x & ~y
-      }
-      function bnAndNot(a) {
-        const r = nbi()
-        this.bitwiseTo(a, op_andnot, r)
-        return r
-      }
-
-      // (public) ~this
-      function bnNot() {
-        const r = nbi()
-        for (let i = 0; i < this.t; ++i) {
-          r[i] = this.DM & ~this[i]
-        }
-        r.t = this.t
-        r.s = ~this.s
-        return r
-      }
-
-      // (public) this << n
-      function bnShiftLeft(n) {
-        const r = nbi()
-        if (n < 0) {
-          this.rShiftTo(-n, r)
-        } else {
-          this.lShiftTo(n, r)
-        }
-        return r
-      }
-
-      // (public) this >> n
-      function bnShiftRight(n) {
-        const r = nbi()
-        if (n < 0) {
-          this.lShiftTo(-n, r)
-        } else {
-          this.rShiftTo(n, r)
-        }
-        return r
-      }
-
-      // return index of lowest 1-bit in x, x < 2^31
-      function lbit(x) {
-        if (x == 0) {
-          return -1
-        }
-        let r = 0
-        if ((x & 0xffff) == 0) {
-          x >>= 16
-          r += 16
-        }
-        if ((x & 0xff) == 0) {
-          x >>= 8
-          r += 8
-        }
-        if ((x & 0xf) == 0) {
-          x >>= 4
-          r += 4
-        }
-        if ((x & 3) == 0) {
-          x >>= 2
-          r += 2
-        }
-        if ((x & 1) == 0) {
-          ++r
-        }
-        return r
-      }
-
-      // (public) returns index of lowest 1-bit (or -1 if none)
-      function bnGetLowestSetBit() {
-        for (let i = 0; i < this.t; ++i) {
-          if (this[i] != 0) return i * this.DB + lbit(this[i])
-        }
-        if (this.s < 0) {
-          return this.t * this.DB
-        }
-        return -1
-      }
-
-      // return number of 1 bits in x
-      function cbit(x) {
-        let r = 0
-        while (x != 0) {
-          x &= x - 1
-          ++r
-        }
-        return r
-      }
-
-      // (public) return number of set bits
-      function bnBitCount() {
-        let r = 0,
-          x = this.s & this.DM
-        for (let i = 0; i < this.t; ++i) {
-          r += cbit(this[i] ^ x)
-        }
-        return r
-      }
-
-      // (public) true iff nth bit is set
-      function bnTestBit(n) {
-        const j = Math.floor(n / this.DB)
-        if (j >= this.t) {
-          return this.s != 0
-        }
-        return (this[j] & (1 << (n % this.DB))) != 0
-      }
-
-      // (protected) this op (1<<n)
-      function bnpChangeBit(n, op) {
-        const r = BigInteger.ONE.shiftLeft(n)
-        this.bitwiseTo(r, op, r)
-        return r
-      }
-
-      // (public) this | (1<<n)
-      function bnSetBit(n) {
-        return this.changeBit(n, op_or)
-      }
-
-      // (public) this & ~(1<<n)
-      function bnClearBit(n) {
-        return this.changeBit(n, op_andnot)
-      }
-
-      // (public) this ^ (1<<n)
-      function bnFlipBit(n) {
-        return this.changeBit(n, op_xor)
-      }
-
-      // (protected) r = this + a
-      function bnpAddTo(a, r) {
-        let i = 0,
-          c = 0,
-          m = Math.min(a.t, this.t)
-        while (i < m) {
-          c += this[i] + a[i]
-          r[i++] = c & this.DM
-          c >>= this.DB
-        }
-        if (a.t < this.t) {
-          c += a.s
-          while (i < this.t) {
-            c += this[i]
-            r[i++] = c & this.DM
-            c >>= this.DB
-          }
-          c += this.s
-        } else {
-          c += this.s
-          while (i < a.t) {
-            c += a[i]
-            r[i++] = c & this.DM
-            c >>= this.DB
-          }
-          c += a.s
-        }
-        r.s = c < 0 ? -1 : 0
-        if (c > 0) {
-          r[i++] = c
-        } else if (c < -1) {
-          r[i++] = this.DV + c
-        }
-        r.t = i
-        r.clamp()
-      }
-
-      // (public) this + a
-      function bnAdd(a) {
-        const r = nbi()
-        this.addTo(a, r)
-        return r
-      }
-
-      // (public) this - a
-      function bnSubtract(a) {
-        const r = nbi()
-        this.subTo(a, r)
-        return r
-      }
-
-      // (public) this * a
-      function bnMultiply(a) {
-        const r = nbi()
-        this.multiplyTo(a, r)
-        return r
-      }
-
-      // (public) this^2
-      function bnSquare() {
-        const r = nbi()
-        this.squareTo(r)
-        return r
-      }
-
-      // (public) this / a
-      function bnDivide(a) {
-        const r = nbi()
-        this.divRemTo(a, r, null)
-        return r
-      }
-
-      // (public) this % a
-      function bnRemainder(a) {
-        const r = nbi()
-        this.divRemTo(a, null, r)
-        return r
-      }
-
-      // (public) [this/a,this%a]
-      function bnDivideAndRemainder(a) {
-        const q = nbi(),
-          r = nbi()
-        this.divRemTo(a, q, r)
-        return new Array(q, r)
-      }
-
-      // (protected) this *= n, this >= 0, 1 < n < DV
-      function bnpDMultiply(n) {
-        this[this.t] = this.am(0, n - 1, this, 0, 0, this.t)
-        ++this.t
-        this.clamp()
-      }
-
-      // (protected) this += n << w words, this >= 0
-      function bnpDAddOffset(n, w) {
-        if (n == 0) {
-          return
-        }
-        while (this.t <= w) {
-          this[this.t++] = 0
-        }
-        this[w] += n
-        while (this[w] >= this.DV) {
-          this[w] -= this.DV
-          if (++w >= this.t) {
-            this[this.t++] = 0
-          }
-          ++this[w]
-        }
-      }
-
-      // A "null" reducer
-      function NullExp() {}
-      function nNop(x) {
-        return x
-      }
-      function nMulTo(x, y, r) {
-        x.multiplyTo(y, r)
-      }
-      function nSqrTo(x, r) {
-        x.squareTo(r)
-      }
-      NullExp.prototype.convert = nNop
-      NullExp.prototype.revert = nNop
-      NullExp.prototype.mulTo = nMulTo
-      NullExp.prototype.sqrTo = nSqrTo
-
-      // (public) this^e
-      function bnPow(e) {
-        return this.exp(e, new NullExp())
-      }
-
-      // (protected) r = lower n words of "this * a", a.t <= n
-      // "this" should be the larger one if appropriate.
-      function bnpMultiplyLowerTo(a, n, r) {
-        let i = Math.min(this.t + a.t, n)
-        r.s = 0 // assumes a,this >= 0
-        r.t = i
-        while (i > 0) {
-          r[--i] = 0
-        }
-        let j
-        for (j = r.t - this.t; i < j; ++i) {
-          r[i + this.t] = this.am(0, a[i], r, i, 0, this.t)
-        }
-        for (j = Math.min(a.t, n); i < j; ++i) {
-          this.am(0, a[i], r, i, 0, n - i)
-        }
-        r.clamp()
-      }
-
-      // (protected) r = "this * a" without lower n words, n > 0
-      // "this" should be the larger one if appropriate.
-      function bnpMultiplyUpperTo(a, n, r) {
-        --n
-        let i = (r.t = this.t + a.t - n)
-        r.s = 0 // assumes a,this >= 0
-        while (--i >= 0) {
-          r[i] = 0
-        }
-        for (i = Math.max(n - this.t, 0); i < a.t; ++i) {
-          r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n)
-        }
-        r.clamp()
-        r.drShiftTo(1, r)
-      }
-
-      // Barrett modular reduction
-      function Barrett(m) {
-        // setup Barrett
-        this.r2 = nbi()
-        this.q3 = nbi()
-        BigInteger.ONE.dlShiftTo(2 * m.t, this.r2)
-        this.mu = this.r2.divide(m)
-        this.m = m
-      }
-      function barrettConvert(x) {
-        if (x.s < 0 || x.t > 2 * this.m.t) {
-          return x.mod(this.m)
-        } else if (x.compareTo(this.m) < 0) {
-          return x
-        } else {
-          const r = nbi()
-          x.copyTo(r)
-          this.reduce(r)
-          return r
-        }
-      }
-      function barrettRevert(x) {
-        return x
-      }
-
-      // x = x mod m (HAC 14.42)
-      function barrettReduce(x) {
-        x.drShiftTo(this.m.t - 1, this.r2)
-        if (x.t > this.m.t + 1) {
-          x.t = this.m.t + 1
-          x.clamp()
-        }
-        this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3)
-        this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2)
-        while (x.compareTo(this.r2) < 0) {
-          x.dAddOffset(1, this.m.t + 1)
-        }
-        x.subTo(this.r2, x)
-        while (x.compareTo(this.m) >= 0) {
-          x.subTo(this.m, x)
-        }
-      }
-
-      // r = x^2 mod m; x != r
-      function barrettSqrTo(x, r) {
-        x.squareTo(r)
-        this.reduce(r)
-      }
-
-      // r = x*y mod m; x,y != r
-      function barrettMulTo(x, y, r) {
-        x.multiplyTo(y, r)
-        this.reduce(r)
-      }
-      Barrett.prototype.convert = barrettConvert
-      Barrett.prototype.revert = barrettRevert
-      Barrett.prototype.reduce = barrettReduce
-      Barrett.prototype.mulTo = barrettMulTo
-      Barrett.prototype.sqrTo = barrettSqrTo
-
-      // (public) this^e % m (HAC 14.85)
-      function bnModPow(e, m) {
-        let i = e.bitLength(),
-          k,
-          r = nbv(1),
-          z
-        if (i <= 0) {
-          return r
-        } else if (i < 18) {
-          k = 1
-        } else if (i < 48) {
-          k = 3
-        } else if (i < 144) {
-          k = 4
-        } else if (i < 768) {
-          k = 5
-        } else {
-          k = 6
-        }
-        if (i < 8) {
-          z = new Classic(m)
-        } else if (m.isEven()) {
-          z = new Barrett(m)
-        } else {
-          z = new Montgomery(m)
-        }
-
-        // precomputation
-        let g = new Array(),
-          n = 3,
-          k1 = k - 1,
-          km = (1 << k) - 1
-        g[1] = z.convert(this)
-        if (k > 1) {
-          const g2 = nbi()
-          z.sqrTo(g[1], g2)
-          while (n <= km) {
-            g[n] = nbi()
-            z.mulTo(g2, g[n - 2], g[n])
-            n += 2
-          }
-        }
-        let j = e.t - 1,
-          w,
-          is1 = true,
-          r2 = nbi(),
-          t
-        i = nbits(e[j]) - 1
-        while (j >= 0) {
-          if (i >= k1) {
-            w = (e[j] >> (i - k1)) & km
-          } else {
-            w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i)
-            if (j > 0) {
-              w |= e[j - 1] >> (this.DB + i - k1)
-            }
-          }
-          n = k
-          while ((w & 1) == 0) {
-            w >>= 1
-            --n
-          }
-          if ((i -= n) < 0) {
-            i += this.DB
-            --j
-          }
-          if (is1) {
-            // ret == 1, don't bother squaring or multiplying it
-            g[w].copyTo(r)
-            is1 = false
-          } else {
-            while (n > 1) {
-              z.sqrTo(r, r2)
-              z.sqrTo(r2, r)
-              n -= 2
-            }
-            if (n > 0) {
-              z.sqrTo(r, r2)
-            } else {
-              t = r
-              r = r2
-              r2 = t
-            }
-            z.mulTo(r2, g[w], r)
-          }
-          while (j >= 0 && (e[j] & (1 << i)) == 0) {
-            z.sqrTo(r, r2)
-            t = r
-            r = r2
-            r2 = t
-            if (--i < 0) {
-              i = this.DB - 1
-              --j
-            }
-          }
-        }
-        return z.revert(r)
-      }
-
-      // (public) gcd(this,a) (HAC 14.54)
-      function bnGCD(a) {
-        let x = this.s < 0 ? this.negate() : this.clone()
-        let y = a.s < 0 ? a.negate() : a.clone()
-        if (x.compareTo(y) < 0) {
-          const t = x
-          x = y
-          y = t
-        }
-        let i = x.getLowestSetBit(),
-          g = y.getLowestSetBit()
-        if (g < 0) {
-          return x
-        }
-        if (i < g) {
-          g = i
-        }
-        if (g > 0) {
-          x.rShiftTo(g, x)
-          y.rShiftTo(g, y)
-        }
-        while (x.signum() > 0) {
-          if ((i = x.getLowestSetBit()) > 0) {
-            x.rShiftTo(i, x)
-          }
-          if ((i = y.getLowestSetBit()) > 0) {
-            y.rShiftTo(i, y)
-          }
-          if (x.compareTo(y) >= 0) {
-            x.subTo(y, x)
-            x.rShiftTo(1, x)
-          } else {
-            y.subTo(x, y)
-            y.rShiftTo(1, y)
-          }
-        }
-        if (g > 0) {
-          y.lShiftTo(g, y)
-        }
-        return y
-      }
-
-      // (protected) this % n, n < 2^26
-      function bnpModInt(n) {
-        if (n <= 0) {
-          return 0
-        }
-        let d = this.DV % n,
-          r = this.s < 0 ? n - 1 : 0
-        if (this.t > 0) {
-          if (d == 0) r = this[0] % n
-          else for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n
-        }
-        return r
-      }
-
-      // (public) 1/this % m (HAC 14.61)
-      function bnModInverse(m) {
-        const ac = m.isEven()
-        if ((this.isEven() && ac) || m.signum() == 0) {
-          return BigInteger.ZERO
-        }
-        const u = m.clone(),
-          v = this.clone()
-        const a = nbv(1),
-          b = nbv(0),
-          c = nbv(0),
-          d = nbv(1)
-        while (u.signum() != 0) {
-          while (u.isEven()) {
-            u.rShiftTo(1, u)
-            if (ac) {
-              if (!a.isEven() || !b.isEven()) {
-                a.addTo(this, a)
-                b.subTo(m, b)
-              }
-              a.rShiftTo(1, a)
-            } else if (!b.isEven()) {
-              b.subTo(m, b)
-            }
-            b.rShiftTo(1, b)
-          }
-          while (v.isEven()) {
-            v.rShiftTo(1, v)
-            if (ac) {
-              if (!c.isEven() || !d.isEven()) {
-                c.addTo(this, c)
-                d.subTo(m, d)
-              }
-              c.rShiftTo(1, c)
-            } else if (!d.isEven()) {
-              d.subTo(m, d)
-            }
-            d.rShiftTo(1, d)
-          }
-          if (u.compareTo(v) >= 0) {
-            u.subTo(v, u)
-            if (ac) {
-              a.subTo(c, a)
-            }
-            b.subTo(d, b)
-          } else {
-            v.subTo(u, v)
-            if (ac) {
-              c.subTo(a, c)
-            }
-            d.subTo(b, d)
-          }
-        }
-        if (v.compareTo(BigInteger.ONE) != 0) {
-          return BigInteger.ZERO
-        }
-        if (d.compareTo(m) >= 0) {
-          return d.subtract(m)
-        }
-        if (d.signum() < 0) {
-          d.addTo(m, d)
-        } else {
-          return d
-        }
-        if (d.signum() < 0) {
-          return d.add(m)
-        } else {
-          return d
-        }
-      }
-      const lowprimes = [
-        2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
-        71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139,
-        149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
-        227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
-        307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383,
-        389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
-        467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569,
-        571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647,
-        653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743,
-        751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839,
-        853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
-        947, 953, 967, 971, 977, 983, 991, 997
-      ]
-      const lplim = (1 << 26) / lowprimes[lowprimes.length - 1]
-
-      // (public) test primality with certainty >= 1-.5^t
-      function bnIsProbablePrime(t) {
-        let i,
-          x = this.abs()
-        if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {
-          for (i = 0; i < lowprimes.length; ++i) {
-            if (x[0] == lowprimes[i]) return true
-          }
-          return false
-        }
-        if (x.isEven()) {
-          return false
-        }
-        i = 1
-        while (i < lowprimes.length) {
-          let m = lowprimes[i],
-            j = i + 1
-          while (j < lowprimes.length && m < lplim) {
-            m *= lowprimes[j++]
-          }
-          m = x.modInt(m)
-          while (i < j) {
-            if (m % lowprimes[i++] == 0) return false
-          }
-        }
-        return x.millerRabin(t)
-      }
-
-      // (protected) true if probably prime (HAC 4.24, Miller-Rabin)
-      function bnpMillerRabin(t) {
-        const n1 = this.subtract(BigInteger.ONE)
-        const k = n1.getLowestSetBit()
-        if (k <= 0) {
-          return false
-        }
-        const r = n1.shiftRight(k)
-        t = (t + 1) >> 1
-        if (t > lowprimes.length) {
-          t = lowprimes.length
-        }
-        const a = nbi()
-        for (let i = 0; i < t; ++i) {
-          //Pick bases at random, instead of starting at 2
-          a.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)])
-          let y = a.modPow(r, this)
-          if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
-            let j = 1
-            while (j++ < k && y.compareTo(n1) != 0) {
-              y = y.modPowInt(2, this)
-              if (y.compareTo(BigInteger.ONE) == 0) {
-                return false
-              }
-            }
-            if (y.compareTo(n1) != 0) {
-              return false
-            }
-          }
-        }
-        return true
-      }
-
-      // protected
-      BigInteger.prototype.chunkSize = bnpChunkSize
-      BigInteger.prototype.toRadix = bnpToRadix
-      BigInteger.prototype.fromRadix = bnpFromRadix
-      BigInteger.prototype.fromNumber = bnpFromNumber
-      BigInteger.prototype.bitwiseTo = bnpBitwiseTo
-      BigInteger.prototype.changeBit = bnpChangeBit
-      BigInteger.prototype.addTo = bnpAddTo
-      BigInteger.prototype.dMultiply = bnpDMultiply
-      BigInteger.prototype.dAddOffset = bnpDAddOffset
-      BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo
-      BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo
-      BigInteger.prototype.modInt = bnpModInt
-      BigInteger.prototype.millerRabin = bnpMillerRabin
-
-      // public
-      BigInteger.prototype.clone = bnClone
-      BigInteger.prototype.intValue = bnIntValue
-      BigInteger.prototype.byteValue = bnByteValue
-      BigInteger.prototype.shortValue = bnShortValue
-      BigInteger.prototype.signum = bnSigNum
-      BigInteger.prototype.toByteArray = bnToByteArray
-      BigInteger.prototype.equals = bnEquals
-      BigInteger.prototype.min = bnMin
-      BigInteger.prototype.max = bnMax
-      BigInteger.prototype.and = bnAnd
-      BigInteger.prototype.or = bnOr
-      BigInteger.prototype.xor = bnXor
-      BigInteger.prototype.andNot = bnAndNot
-      BigInteger.prototype.not = bnNot
-      BigInteger.prototype.shiftLeft = bnShiftLeft
-      BigInteger.prototype.shiftRight = bnShiftRight
-      BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit
-      BigInteger.prototype.bitCount = bnBitCount
-      BigInteger.prototype.testBit = bnTestBit
-      BigInteger.prototype.setBit = bnSetBit
-      BigInteger.prototype.clearBit = bnClearBit
-      BigInteger.prototype.flipBit = bnFlipBit
-      BigInteger.prototype.add = bnAdd
-      BigInteger.prototype.subtract = bnSubtract
-      BigInteger.prototype.multiply = bnMultiply
-      BigInteger.prototype.divide = bnDivide
-      BigInteger.prototype.remainder = bnRemainder
-      BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder
-      BigInteger.prototype.modPow = bnModPow
-      BigInteger.prototype.modInverse = bnModInverse
-      BigInteger.prototype.pow = bnPow
-      BigInteger.prototype.gcd = bnGCD
-      BigInteger.prototype.isProbablePrime = bnIsProbablePrime
-
-      // JSBN-specific extension
-      BigInteger.prototype.square = bnSquare
-
-      // Expose the Barrett function
-      BigInteger.prototype.Barrett = Barrett
-
-      // BigInteger interfaces not implemented in jsbn:
-
-      // BigInteger(int signum, byte[] magnitude)
-      // double doubleValue()
-      // float floatValue()
-      // int hashCode()
-      // long longValue()
-      // static BigInteger valueOf(long val)
-
-      // Random number generator - requires a PRNG backend, e.g. prng4.js
-
-      // For best results, put code like
-      // <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>
-      // in your main HTML document.
-
-      let rng_state
-      let rng_pool
-      let rng_pptr
-      // Pool size must be a multiple of 4 and greater than 32.
-      // An array of bytes the size of the pool will be passed to init()
-      const rng_psize = 256
-
-      // Mix in a 32-bit integer into the pool
-      function rng_seed_int(x) {
-        rng_pool[rng_pptr++] ^= x & 255
-        rng_pool[rng_pptr++] ^= (x >> 8) & 255
-        rng_pool[rng_pptr++] ^= (x >> 16) & 255
-        rng_pool[rng_pptr++] ^= (x >> 24) & 255
-        if (rng_pptr >= rng_psize) {
-          rng_pptr -= rng_psize
-        }
-      }
-
-      // Mix in the current time (w/milliseconds) into the pool
-      function rng_seed_time() {
-        rng_seed_int(new Date().getTime())
-      }
-
-      // Initialize the pool with junk if needed.
-      if (rng_pool == null) {
-        rng_pool = new Array()
-        rng_pptr = 0
-        let t
-        if (typeof window !== 'undefined' && window.crypto) {
-          if (window.crypto.getRandomValues) {
-            // Use webcrypto if available
-            const ua = new Uint8Array(32)
-            window.crypto.getRandomValues(ua)
-            for (t = 0; t < 32; ++t) {
-              rng_pool[rng_pptr++] = ua[t]
-            }
-          } else if (
-            navigator.appName == 'Netscape' &&
-            navigator.appVersion < '5'
-          ) {
-            // Extract entropy (256 bits) from NS4 RNG if available
-            const z = window.crypto.random(32)
-            for (t = 0; t < z.length; ++t) {
-              rng_pool[rng_pptr++] = z.charCodeAt(t) & 255
-            }
-          }
-        }
-        while (rng_pptr < rng_psize) {
-          // extract some randomness from Math.random()
-          t = Math.floor(65536 * Math.random())
-          rng_pool[rng_pptr++] = t >>> 8
-          rng_pool[rng_pptr++] = t & 255
-        }
-        rng_pptr = 0
-        rng_seed_time()
-        //rng_seed_int(window.screenX);
-        //rng_seed_int(window.screenY);
-      }
-      function rng_get_byte() {
-        if (rng_state == null) {
-          rng_seed_time()
-          rng_state = prng_newstate()
-          rng_state.init(rng_pool)
-          for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) {
-            rng_pool[rng_pptr] = 0
-          }
-          rng_pptr = 0
-          //rng_pool = null;
-        }
-        // TODO: allow reseeding after first request
-        return rng_state.next()
-      }
-      function rng_get_bytes(ba) {
-        let i
-        for (i = 0; i < ba.length; ++i) {
-          ba[i] = rng_get_byte()
-        }
-      }
-      function SecureRandom() {}
-      SecureRandom.prototype.nextBytes = rng_get_bytes
-
-      // prng4.js - uses Arcfour as a PRNG
-
-      function Arcfour() {
-        this.i = 0
-        this.j = 0
-        this.S = new Array()
-      }
-
-      // Initialize arcfour context from key, an array of ints, each from [0..255]
-      function ARC4init(key) {
-        let i, j, t
-        for (i = 0; i < 256; ++i) {
-          this.S[i] = i
-        }
-        j = 0
-        for (i = 0; i < 256; ++i) {
-          j = (j + this.S[i] + key[i % key.length]) & 255
-          t = this.S[i]
-          this.S[i] = this.S[j]
-          this.S[j] = t
-        }
-        this.i = 0
-        this.j = 0
-      }
-      function ARC4next() {
-        let t
-        this.i = (this.i + 1) & 255
-        this.j = (this.j + this.S[this.i]) & 255
-        t = this.S[this.i]
-        this.S[this.i] = this.S[this.j]
-        this.S[this.j] = t
-        return this.S[(t + this.S[this.i]) & 255]
-      }
-      Arcfour.prototype.init = ARC4init
-      Arcfour.prototype.next = ARC4next
-
-      // Plug in your RNG constructor here
-      function prng_newstate() {
-        return new Arcfour()
-      }
-      {
-        module.exports = {
-          default: BigInteger,
-          BigInteger: BigInteger,
-          SecureRandom: SecureRandom
-        }
-      }
-    }).call(this)
-  })(jsbn)
-  return jsbn.exports
-}
-
-const sprintf = {}
-
-/* global window, exports, define */
-let hasRequiredSprintf
-function requireSprintf() {
-  if (hasRequiredSprintf) {
-    return sprintf
-  }
-  hasRequiredSprintf = 1
-  ;(function (exports) {
-    !(function () {
-      const re = {
-        not_type: /[^T]/,
-        not_primitive: /[^v]/,
-        number: /[diefg]/,
-        numeric_arg: /[bcdiefguxX]/,
-        json: /[j]/,
-        text: /^[^\x25]+/,
-        modulo: /^\x25{2}/,
-        placeholder:
-          /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
-        key: /^([a-z_][a-z_\d]*)/i,
-        key_access: /^\.([a-z_][a-z_\d]*)/i,
-        index_access: /^\[(\d+)\]/,
-        sign: /^[+-]/
-      }
-      function sprintf(key) {
-        // `arguments` is not an array, but should be fine for this call
-        return sprintf_format(sprintf_parse(key), arguments)
-      }
-      function vsprintf(fmt, argv) {
-        return sprintf.apply(null, [fmt].concat(argv || []))
-      }
-      function sprintf_format(parse_tree, argv) {
-        let cursor = 1,
-          tree_length = parse_tree.length,
-          arg,
-          output = '',
-          i,
-          k,
-          ph,
-          pad,
-          pad_character,
-          pad_length,
-          is_positive,
-          sign
-        for (i = 0; i < tree_length; i++) {
-          if (typeof parse_tree[i] === 'string') {
-            output += parse_tree[i]
-          } else if (typeof parse_tree[i] === 'object') {
-            ph = parse_tree[i] // convenience purposes only
-            if (ph.keys) {
-              // keyword argument
-              arg = argv[cursor]
-              for (k = 0; k < ph.keys.length; k++) {
-                if (arg == undefined) {
-                  throw new Error(
-                    sprintf(
-                      '[sprintf] Cannot access property "%s" of undefined value "%s"',
-                      ph.keys[k],
-                      ph.keys[k - 1]
-                    )
-                  )
-                }
-                arg = arg[ph.keys[k]]
-              }
-            } else if (ph.param_no) {
-              // positional argument (explicit)
-              arg = argv[ph.param_no]
-            } else {
-              // positional argument (implicit)
-              arg = argv[cursor++]
-            }
-            if (
-              re.not_type.test(ph.type) &&
-              re.not_primitive.test(ph.type) &&
-              arg instanceof Function
-            ) {
-              arg = arg()
-            }
-            if (
-              re.numeric_arg.test(ph.type) &&
-              typeof arg !== 'number' &&
-              isNaN(arg)
-            ) {
-              throw new TypeError(
-                sprintf('[sprintf] expecting number but found %T', arg)
-              )
-            }
-            if (re.number.test(ph.type)) {
-              is_positive = arg >= 0
-            }
-            switch (ph.type) {
-              case 'b':
-                arg = parseInt(arg, 10).toString(2)
-                break
-              case 'c':
-                arg = String.fromCharCode(parseInt(arg, 10))
-                break
-              case 'd':
-              case 'i':
-                arg = parseInt(arg, 10)
-                break
-              case 'j':
-                arg = JSON.stringify(
-                  arg,
-                  null,
-                  ph.width ? parseInt(ph.width) : 0
-                )
-                break
-              case 'e':
-                arg = ph.precision
-                  ? parseFloat(arg).toExponential(ph.precision)
-                  : parseFloat(arg).toExponential()
-                break
-              case 'f':
-                arg = ph.precision
-                  ? parseFloat(arg).toFixed(ph.precision)
-                  : parseFloat(arg)
-                break
-              case 'g':
-                arg = ph.precision
-                  ? String(Number(arg.toPrecision(ph.precision)))
-                  : parseFloat(arg)
-                break
-              case 'o':
-                arg = (parseInt(arg, 10) >>> 0).toString(8)
-                break
-              case 's':
-                arg = String(arg)
-                arg = ph.precision ? arg.substring(0, ph.precision) : arg
-                break
-              case 't':
-                arg = String(!!arg)
-                arg = ph.precision ? arg.substring(0, ph.precision) : arg
-                break
-              case 'T':
-                arg = Object.prototype.toString
-                  .call(arg)
-                  .slice(8, -1)
-                  .toLowerCase()
-                arg = ph.precision ? arg.substring(0, ph.precision) : arg
-                break
-              case 'u':
-                arg = parseInt(arg, 10) >>> 0
-                break
-              case 'v':
-                arg = arg.valueOf()
-                arg = ph.precision ? arg.substring(0, ph.precision) : arg
-                break
-              case 'x':
-                arg = (parseInt(arg, 10) >>> 0).toString(16)
-                break
-              case 'X':
-                arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()
-                break
-            }
-            if (re.json.test(ph.type)) {
-              output += arg
-            } else {
-              if (re.number.test(ph.type) && (!is_positive || ph.sign)) {
-                sign = is_positive ? '+' : '-'
-                arg = arg.toString().replace(re.sign, '')
-              } else {
-                sign = ''
-              }
-              pad_character = ph.pad_char
-                ? ph.pad_char === '0'
-                  ? '0'
-                  : ph.pad_char.charAt(1)
-                : ' '
-              pad_length = ph.width - (sign + arg).length
-              pad = ph.width
-                ? pad_length > 0
-                  ? pad_character.repeat(pad_length)
-                  : ''
-                : ''
-              output += ph.align
-                ? sign + arg + pad
-                : pad_character === '0'
-                  ? sign + pad + arg
-                  : pad + sign + arg
-            }
-          }
-        }
-        return output
-      }
-      const sprintf_cache = Object.create(null)
-      function sprintf_parse(fmt) {
-        if (sprintf_cache[fmt]) {
-          return sprintf_cache[fmt]
-        }
-        let _fmt = fmt,
-          match,
-          parse_tree = [],
-          arg_names = 0
-        while (_fmt) {
-          if ((match = re.text.exec(_fmt)) !== null) {
-            parse_tree.push(match[0])
-          } else if ((match = re.modulo.exec(_fmt)) !== null) {
-            parse_tree.push('%')
-          } else if ((match = re.placeholder.exec(_fmt)) !== null) {
-            if (match[2]) {
-              arg_names |= 1
-              let field_list = [],
-                replacement_field = match[2],
-                field_match = []
-              if ((field_match = re.key.exec(replacement_field)) !== null) {
-                field_list.push(field_match[1])
-                while (
-                  (replacement_field = replacement_field.substring(
-                    field_match[0].length
-                  )) !== ''
-                ) {
-                  if (
-                    (field_match = re.key_access.exec(replacement_field)) !==
-                    null
-                  ) {
-                    field_list.push(field_match[1])
-                  } else if (
-                    (field_match = re.index_access.exec(replacement_field)) !==
-                    null
-                  ) {
-                    field_list.push(field_match[1])
-                  } else {
-                    throw new SyntaxError(
-                      '[sprintf] failed to parse named argument key'
-                    )
-                  }
-                }
-              } else {
-                throw new SyntaxError(
-                  '[sprintf] failed to parse named argument key'
-                )
-              }
-              match[2] = field_list
-            } else {
-              arg_names |= 2
-            }
-            if (arg_names === 3) {
-              throw new Error(
-                '[sprintf] mixing positional and named placeholders is not (yet) supported'
-              )
-            }
-            parse_tree.push({
-              placeholder: match[0],
-              param_no: match[1],
-              keys: match[2],
-              sign: match[3],
-              pad_char: match[4],
-              align: match[5],
-              width: match[6],
-              precision: match[7],
-              type: match[8]
-            })
-          } else {
-            throw new SyntaxError('[sprintf] unexpected placeholder')
-          }
-          _fmt = _fmt.substring(match[0].length)
-        }
-        return (sprintf_cache[fmt] = parse_tree)
-      }
-
-      /**
-       * export to either browser or node.js
-       */
-      /* eslint-disable quote-props */
-      {
-        exports['sprintf'] = sprintf
-        exports['vsprintf'] = vsprintf
-      }
-      if (typeof window !== 'undefined') {
-        window['sprintf'] = sprintf
-        window['vsprintf'] = vsprintf
-      }
-      /* eslint-enable quote-props */
-    })() // eslint-disable-line
-  })(sprintf)
-  return sprintf
-}
-
 let hasRequiredIpv4
 function requireIpv4() {
   if (hasRequiredIpv4) {
@@ -37709,8 +34133,6 @@ function requireIpv4() {
   const common = __importStar(requireCommon())
   const constants = __importStar(requireConstants$1())
   const address_error_1 = requireAddressError()
-  const jsbn_1 = requireJsbn()
-  const sprintf_js_1 = requireSprintf()
   /**
    * Represents an IPv4 address
    * @class Address4
@@ -37831,7 +34253,7 @@ function requireIpv4() {
      */
     toHex() {
       return this.parsedAddress
-        .map(part => (0, sprintf_js_1.sprintf)('%02x', parseInt(part, 10)))
+        .map(part => common.stringToPaddedHex(part))
         .join(':')
     }
     /**
@@ -37853,39 +34275,32 @@ function requireIpv4() {
       const output = []
       let i
       for (i = 0; i < constants.GROUPS; i += 2) {
-        const hex = (0, sprintf_js_1.sprintf)(
-          '%02x%02x',
-          parseInt(this.parsedAddress[i], 10),
-          parseInt(this.parsedAddress[i + 1], 10)
+        output.push(
+          `${common.stringToPaddedHex(this.parsedAddress[i])}${common.stringToPaddedHex(this.parsedAddress[i + 1])}`
         )
-        output.push((0, sprintf_js_1.sprintf)('%x', parseInt(hex, 16)))
       }
       return output.join(':')
     }
     /**
-     * Returns the address as a BigInteger
+     * Returns the address as a `bigint`
      * @memberof Address4
      * @instance
-     * @returns {BigInteger}
+     * @returns {bigint}
      */
-    bigInteger() {
-      return new jsbn_1.BigInteger(
-        this.parsedAddress
-          .map(n => (0, sprintf_js_1.sprintf)('%02x', parseInt(n, 10)))
-          .join(''),
-        16
+    bigInt() {
+      return BigInt(
+        `0x${this.parsedAddress.map(n => common.stringToPaddedHex(n)).join('')}`
       )
     }
     /**
      * Helper function getting start address.
      * @memberof Address4
      * @instance
-     * @returns {BigInteger}
+     * @returns {bigint}
      */
     _startAddress() {
-      return new jsbn_1.BigInteger(
-        this.mask() + '0'.repeat(constants.BITS - this.subnetMask),
-        2
+      return BigInt(
+        `0b${this.mask() + '0'.repeat(constants.BITS - this.subnetMask)}`
       )
     }
     /**
@@ -37896,7 +34311,7 @@ function requireIpv4() {
      * @returns {Address4}
      */
     startAddress() {
-      return Address4.fromBigInteger(this._startAddress())
+      return Address4.fromBigInt(this._startAddress())
     }
     /**
      * The first host address in the range given by this address's subnet ie
@@ -37906,19 +34321,18 @@ function requireIpv4() {
      * @returns {Address4}
      */
     startAddressExclusive() {
-      const adjust = new jsbn_1.BigInteger('1')
-      return Address4.fromBigInteger(this._startAddress().add(adjust))
+      const adjust = BigInt('1')
+      return Address4.fromBigInt(this._startAddress() + adjust)
     }
     /**
      * Helper function getting end address.
      * @memberof Address4
      * @instance
-     * @returns {BigInteger}
+     * @returns {bigint}
      */
     _endAddress() {
-      return new jsbn_1.BigInteger(
-        this.mask() + '1'.repeat(constants.BITS - this.subnetMask),
-        2
+      return BigInt(
+        `0b${this.mask() + '1'.repeat(constants.BITS - this.subnetMask)}`
       )
     }
     /**
@@ -37929,7 +34343,7 @@ function requireIpv4() {
      * @returns {Address4}
      */
     endAddress() {
-      return Address4.fromBigInteger(this._endAddress())
+      return Address4.fromBigInt(this._endAddress())
     }
     /**
      * The last host address in the range given by this address's subnet ie
@@ -37939,18 +34353,18 @@ function requireIpv4() {
      * @returns {Address4}
      */
     endAddressExclusive() {
-      const adjust = new jsbn_1.BigInteger('1')
-      return Address4.fromBigInteger(this._endAddress().subtract(adjust))
+      const adjust = BigInt('1')
+      return Address4.fromBigInt(this._endAddress() - adjust)
     }
     /**
-     * Converts a BigInteger to a v4 address object
+     * Converts a BigInt to a v4 address object
      * @memberof Address4
      * @static
-     * @param {BigInteger} bigInteger - a BigInteger to convert
+     * @param {bigint} bigInt - a BigInt to convert
      * @returns {Address4}
      */
-    static fromBigInteger(bigInteger) {
-      return Address4.fromInteger(parseInt(bigInteger.toString(), 10))
+    static fromBigInt(bigInt) {
+      return Address4.fromHex(bigInt.toString(16))
     }
     /**
      * Returns the first n bits of the address, defaulting to the
@@ -37990,7 +34404,7 @@ function requireIpv4() {
       if (options.omitSuffix) {
         return reversed
       }
-      return (0, sprintf_js_1.sprintf)('%s.in-addr.arpa.', reversed)
+      return `${reversed}.in-addr.arpa.`
     }
     /**
      * Returns true if the given address is a multicast address
@@ -38008,7 +34422,7 @@ function requireIpv4() {
      * @returns {string}
      */
     binaryZeroPad() {
-      return this.bigInteger().toString(2).padStart(constants.BITS, '0')
+      return this.bigInt().toString(2).padStart(constants.BITS, '0')
     }
     /**
      * Groups an IPv4 address for inclusion at the end of an IPv6 address
@@ -38018,11 +34432,7 @@ function requireIpv4() {
       const segments = this.parsedAddress
       return this.address.replace(
         constants.RE_ADDRESS,
-        (0, sprintf_js_1.sprintf)(
-          '<span class="hover-group group-v4 group-6">%s</span>.<span class="hover-group group-v4 group-7">%s</span>',
-          segments.slice(0, 2).join('.'),
-          segments.slice(2, 4).join('.')
-        )
+        `<span class="hover-group group-v4 group-6">${segments.slice(0, 2).join('.')}</span>.<span class="hover-group group-v4 group-7">${segments.slice(2, 4).join('.')}</span>`
       )
     }
   }
@@ -38126,8 +34536,8 @@ function requireConstants() {
    * @static
    */
   constants.RE_ZONE_STRING = /%.*$/
-  constants.RE_URL = new RegExp(/^\[{0,1}([0-9a-f:]+)\]{0,1}/)
-  constants.RE_URL_WITH_PORT = new RegExp(/\[([0-9a-f:]+)\]:([0-9]{1,5})/)
+  constants.RE_URL = /^\[{0,1}([0-9a-f:]+)\]{0,1}/
+  constants.RE_URL_WITH_PORT = /\[([0-9a-f:]+)\]:([0-9]{1,5})/
   return constants
 }
 
@@ -38142,19 +34552,16 @@ function requireHelpers$1() {
   Object.defineProperty(helpers, '__esModule', {
     value: true
   })
-  helpers.simpleGroup =
-    helpers.spanLeadingZeroes =
-    helpers.spanAll =
-    helpers.spanAllZeroes =
-      void 0
-  const sprintf_js_1 = requireSprintf()
+  helpers.spanAllZeroes = spanAllZeroes
+  helpers.spanAll = spanAll
+  helpers.spanLeadingZeroes = spanLeadingZeroes
+  helpers.simpleGroup = simpleGroup
   /**
    * @returns {String} the string with all zeroes contained in a <span>
    */
   function spanAllZeroes(s) {
     return s.replace(/(0+)/g, '<span class="zero">$1</span>')
   }
-  helpers.spanAllZeroes = spanAllZeroes
   /**
    * @returns {String} the string with each character contained in a <span>
    */
@@ -38163,16 +34570,10 @@ function requireHelpers$1() {
     return letters
       .map(
         (n, i) =>
-          (0, sprintf_js_1.sprintf)(
-            '<span class="digit value-%s position-%d">%s</span>',
-            n,
-            i + offset,
-            spanAllZeroes(n)
-          ) // XXX Use #base-2 .value-0 instead?
+          `<span class="digit value-${n} position-${i + offset}">${spanAllZeroes(n)}</span>`
       )
       .join('')
   }
-  helpers.spanAll = spanAll
   function spanLeadingZeroesSimple(group) {
     return group.replace(/^(0+)/, '<span class="zero">$1</span>')
   }
@@ -38183,7 +34584,6 @@ function requireHelpers$1() {
     const groups = address.split(':')
     return groups.map(g => spanLeadingZeroesSimple(g)).join(':')
   }
-  helpers.spanLeadingZeroes = spanLeadingZeroes
   /**
    * Groups an address
    * @returns {String} a grouped address
@@ -38194,14 +34594,9 @@ function requireHelpers$1() {
       if (/group-v4/.test(g)) {
         return g
       }
-      return (0, sprintf_js_1.sprintf)(
-        '<span class="hover-group group-%d">%s</span>',
-        i + offset,
-        spanLeadingZeroesSimple(g)
-      )
+      return `<span class="hover-group group-${i + offset}">${spanLeadingZeroesSimple(g)}</span>`
     })
   }
-  helpers.simpleGroup = simpleGroup
   return helpers
 }
 
@@ -38270,25 +34665,21 @@ function requireRegularExpressions() {
   Object.defineProperty(regularExpressions, '__esModule', {
     value: true
   })
-  regularExpressions.possibleElisions =
-    regularExpressions.simpleRegularExpression =
-    regularExpressions.ADDRESS_BOUNDARY =
-    regularExpressions.padGroup =
-    regularExpressions.groupPossibilities =
-      void 0
+  regularExpressions.ADDRESS_BOUNDARY = void 0
+  regularExpressions.groupPossibilities = groupPossibilities
+  regularExpressions.padGroup = padGroup
+  regularExpressions.simpleRegularExpression = simpleRegularExpression
+  regularExpressions.possibleElisions = possibleElisions
   const v6 = __importStar(requireConstants())
-  const sprintf_js_1 = requireSprintf()
   function groupPossibilities(possibilities) {
-    return (0, sprintf_js_1.sprintf)('(%s)', possibilities.join('|'))
+    return `(${possibilities.join('|')})`
   }
-  regularExpressions.groupPossibilities = groupPossibilities
   function padGroup(group) {
     if (group.length < 4) {
-      return (0, sprintf_js_1.sprintf)('0{0,%d}%s', 4 - group.length, group)
+      return `0{0,${4 - group.length}}${group}`
     }
     return group
   }
-  regularExpressions.padGroup = padGroup
   regularExpressions.ADDRESS_BOUNDARY = '[^A-Fa-f0-9:]'
   function simpleRegularExpression(groups) {
     const zeroIndexes = []
@@ -38315,7 +34706,6 @@ function requireRegularExpressions() {
     possibilities.push(groups.map(padGroup).join(':'))
     return groupPossibilities(possibilities)
   }
-  regularExpressions.simpleRegularExpression = simpleRegularExpression
   function possibleElisions(elidedGroups, moreLeft, moreRight) {
     const left = moreLeft ? '' : ':'
     const right = moreRight ? '' : ':'
@@ -38333,32 +34723,21 @@ function requireRegularExpressions() {
       possibilities.push(':')
     }
     // 4. elision from the left side
-    possibilities.push(
-      (0, sprintf_js_1.sprintf)('%s(:0{1,4}){1,%d}', left, elidedGroups - 1)
-    )
+    possibilities.push(`${left}(:0{1,4}){1,${elidedGroups - 1}}`)
     // 5. elision from the right side
-    possibilities.push(
-      (0, sprintf_js_1.sprintf)('(0{1,4}:){1,%d}%s', elidedGroups - 1, right)
-    )
+    possibilities.push(`(0{1,4}:){1,${elidedGroups - 1}}${right}`)
     // 6. no elision
-    possibilities.push(
-      (0, sprintf_js_1.sprintf)('(0{1,4}:){%d}0{1,4}', elidedGroups - 1)
-    )
+    possibilities.push(`(0{1,4}:){${elidedGroups - 1}}0{1,4}`)
     // 7. elision (including sloppy elision) from the middle
     for (let groups = 1; groups < elidedGroups - 1; groups++) {
       for (let position = 1; position < elidedGroups - groups; position++) {
         possibilities.push(
-          (0, sprintf_js_1.sprintf)(
-            '(0{1,4}:){%d}:(0{1,4}:){%d}0{1,4}',
-            position,
-            elidedGroups - position - groups - 1
-          )
+          `(0{1,4}:){${position}}:(0{1,4}:){${elidedGroups - position - groups - 1}}0{1,4}`
         )
       }
     }
     return groupPossibilities(possibilities)
   }
-  regularExpressions.possibleElisions = possibleElisions
   return regularExpressions
 }
 
@@ -38435,8 +34814,7 @@ function requireIpv6() {
   const ipv4_1 = requireIpv4()
   const regular_expressions_1 = requireRegularExpressions()
   const address_error_1 = requireAddressError()
-  const jsbn_1 = requireJsbn()
-  const sprintf_js_1 = requireSprintf()
+  const common_1 = requireCommon()
   function assert(condition) {
     if (!condition) {
       throw new Error('Assertion failed.')
@@ -38471,7 +34849,7 @@ function requireIpv6() {
     return s1.concat(['compact']).concat(s2)
   }
   function paddedHex(octet) {
-    return (0, sprintf_js_1.sprintf)('%04x', parseInt(octet, 16))
+    return parseInt(octet, 16).toString(16).padStart(4, '0')
   }
   function unsignByte(b) {
     // eslint-disable-next-line no-bitwise
@@ -38548,18 +34926,18 @@ function requireIpv6() {
       }
     }
     /**
-     * Convert a BigInteger to a v6 address object
+     * Convert a BigInt to a v6 address object
      * @memberof Address6
      * @static
-     * @param {BigInteger} bigInteger - a BigInteger to convert
+     * @param {bigint} bigInt - a BigInt to convert
      * @returns {Address6}
      * @example
-     * var bigInteger = new BigInteger('1000000000000');
-     * var address = Address6.fromBigInteger(bigInteger);
+     * var bigInt = BigInt('1000000000000');
+     * var address = Address6.fromBigInt(bigInt);
      * address.correctForm(); // '::e8:d4a5:1000'
      */
-    static fromBigInteger(bigInteger) {
-      const hex = bigInteger.toString(16).padStart(32, '0')
+    static fromBigInt(bigInt) {
+      const hex = bigInt.toString(16).padStart(32, '0')
       const groups = []
       let i
       for (i = 0; i < constants6.GROUPS; i++) {
@@ -38676,10 +35054,7 @@ function requireIpv6() {
      * @returns {String} the Microsoft UNC transcription of the address
      */
     microsoftTranscription() {
-      return (0, sprintf_js_1.sprintf)(
-        '%s.ipv6-literal.net',
-        this.correctForm().replace(/:/g, '-')
-      )
+      return `${this.correctForm().replace(/:/g, '-')}.ipv6-literal.net`
     }
     /**
      * Return the first n bits of the address, defaulting to the subnet mask
@@ -38695,7 +35070,7 @@ function requireIpv6() {
      * Return the number of possible subnets of a given size in the address
      * @memberof Address6
      * @instance
-     * @param {number} [size=128] - the subnet size
+     * @param {number} [subnetSize=128] - the subnet size
      * @returns {String}
      */
     // TODO: probably useful to have a numeric version of this too
@@ -38706,20 +35081,17 @@ function requireIpv6() {
       if (subnetPowers < 0) {
         return '0'
       }
-      return addCommas(
-        new jsbn_1.BigInteger('2', 10).pow(subnetPowers).toString(10)
-      )
+      return addCommas((BigInt('2') ** BigInt(subnetPowers)).toString(10))
     }
     /**
      * Helper function getting start address.
      * @memberof Address6
      * @instance
-     * @returns {BigInteger}
+     * @returns {bigint}
      */
     _startAddress() {
-      return new jsbn_1.BigInteger(
-        this.mask() + '0'.repeat(constants6.BITS - this.subnetMask),
-        2
+      return BigInt(
+        `0b${this.mask() + '0'.repeat(constants6.BITS - this.subnetMask)}`
       )
     }
     /**
@@ -38730,7 +35102,7 @@ function requireIpv6() {
      * @returns {Address6}
      */
     startAddress() {
-      return Address6.fromBigInteger(this._startAddress())
+      return Address6.fromBigInt(this._startAddress())
     }
     /**
      * The first host address in the range given by this address's subnet ie
@@ -38740,19 +35112,18 @@ function requireIpv6() {
      * @returns {Address6}
      */
     startAddressExclusive() {
-      const adjust = new jsbn_1.BigInteger('1')
-      return Address6.fromBigInteger(this._startAddress().add(adjust))
+      const adjust = BigInt('1')
+      return Address6.fromBigInt(this._startAddress() + adjust)
     }
     /**
      * Helper function getting end address.
      * @memberof Address6
      * @instance
-     * @returns {BigInteger}
+     * @returns {bigint}
      */
     _endAddress() {
-      return new jsbn_1.BigInteger(
-        this.mask() + '1'.repeat(constants6.BITS - this.subnetMask),
-        2
+      return BigInt(
+        `0b${this.mask() + '1'.repeat(constants6.BITS - this.subnetMask)}`
       )
     }
     /**
@@ -38763,7 +35134,7 @@ function requireIpv6() {
      * @returns {Address6}
      */
     endAddress() {
-      return Address6.fromBigInteger(this._endAddress())
+      return Address6.fromBigInt(this._endAddress())
     }
     /**
      * The last host address in the range given by this address's subnet ie
@@ -38773,8 +35144,8 @@ function requireIpv6() {
      * @returns {Address6}
      */
     endAddressExclusive() {
-      const adjust = new jsbn_1.BigInteger('1')
-      return Address6.fromBigInteger(this._endAddress().subtract(adjust))
+      const adjust = BigInt('1')
+      return Address6.fromBigInt(this._endAddress() - adjust)
     }
     /**
      * Return the scope of the address
@@ -38783,7 +35154,8 @@ function requireIpv6() {
      * @returns {String}
      */
     getScope() {
-      let scope = constants6.SCOPES[this.getBits(12, 16).intValue()]
+      let scope =
+        constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)]
       if (this.getType() === 'Global unicast' && scope !== 'Link local') {
         scope = 'Global'
       }
@@ -38804,13 +35176,13 @@ function requireIpv6() {
       return 'Global unicast'
     }
     /**
-     * Return the bits in the given range as a BigInteger
+     * Return the bits in the given range as a BigInt
      * @memberof Address6
      * @instance
-     * @returns {BigInteger}
+     * @returns {bigint}
      */
     getBits(start, end) {
-      return new jsbn_1.BigInteger(this.getBitsBase2(start, end), 2)
+      return BigInt(`0b${this.getBitsBase2(start, end)}`)
     }
     /**
      * Return the bits in the given range as a base-2 string
@@ -38868,7 +35240,7 @@ function requireIpv6() {
         if (options.omitSuffix) {
           return reversed
         }
-        return (0, sprintf_js_1.sprintf)('%s.ip6.arpa.', reversed)
+        return `${reversed}.ip6.arpa.`
       }
       if (options.omitSuffix) {
         return ''
@@ -38919,7 +35291,7 @@ function requireIpv6() {
       }
       let correct = groups.join(':')
       correct = correct.replace(/^compact$/, '::')
-      correct = correct.replace(/^compact|compact$/, ':')
+      correct = correct.replace(/(^compact)|(compact$)/, ':')
       correct = correct.replace(/compact/, '')
       return correct
     }
@@ -38935,7 +35307,7 @@ function requireIpv6() {
      * //  0000000000000000000000000000000000000000000000000001000000010001'
      */
     binaryZeroPad() {
-      return this.bigInteger().toString(2).padStart(constants6.BITS, '0')
+      return this.bigInt().toString(2).padStart(constants6.BITS, '0')
     }
     // TODO: Improve the semantics of this helper function
     parse4in6(address) {
@@ -38968,11 +35340,7 @@ function requireIpv6() {
       const badCharacters = address.match(constants6.RE_BAD_CHARACTERS)
       if (badCharacters) {
         throw new address_error_1.AddressError(
-          (0, sprintf_js_1.sprintf)(
-            'Bad character%s detected in address: %s',
-            badCharacters.length > 1 ? 's' : '',
-            badCharacters.join('')
-          ),
+          `Bad character${badCharacters.length > 1 ? 's' : ''} detected in address: ${badCharacters.join('')}`,
           address.replace(
             constants6.RE_BAD_CHARACTERS,
             '<span class="parse-error">$1</span>'
@@ -38982,10 +35350,7 @@ function requireIpv6() {
       const badAddress = address.match(constants6.RE_BAD_ADDRESS)
       if (badAddress) {
         throw new address_error_1.AddressError(
-          (0, sprintf_js_1.sprintf)(
-            'Address failed regex: %s',
-            badAddress.join('')
-          ),
+          `Address failed regex: ${badAddress.join('')}`,
           address.replace(
             constants6.RE_BAD_ADDRESS,
             '<span class="parse-error">$1</span>'
@@ -39021,9 +35386,7 @@ function requireIpv6() {
       } else {
         throw new address_error_1.AddressError('Too many :: groups found')
       }
-      groups = groups.map(group =>
-        (0, sprintf_js_1.sprintf)('%x', parseInt(group, 16))
-      )
+      groups = groups.map(group => parseInt(group, 16).toString(16))
       if (groups.length !== this.groups) {
         throw new address_error_1.AddressError(
           'Incorrect number of groups found'
@@ -39048,20 +35411,17 @@ function requireIpv6() {
      */
     decimal() {
       return this.parsedAddress
-        .map(n => (0, sprintf_js_1.sprintf)('%05d', parseInt(n, 16)))
+        .map(n => parseInt(n, 16).toString(10).padStart(5, '0'))
         .join(':')
     }
     /**
-     * Return the address as a BigInteger
+     * Return the address as a BigInt
      * @memberof Address6
      * @instance
-     * @returns {BigInteger}
+     * @returns {bigint}
      */
-    bigInteger() {
-      return new jsbn_1.BigInteger(
-        this.parsedAddress.map(paddedHex).join(''),
-        16
-      )
+    bigInt() {
+      return BigInt(`0x${this.parsedAddress.map(paddedHex).join('')}`)
     }
     /**
      * Return the last two groups of this address as an IPv4 address string
@@ -39075,7 +35435,7 @@ function requireIpv6() {
     to4() {
       const binary = this.binaryZeroPad().split('')
       return ipv4_1.Address4.fromHex(
-        new jsbn_1.BigInteger(binary.slice(96, 128).join(''), 2).toString(16)
+        BigInt(`0b${binary.slice(96, 128).join('')}`).toString(16)
       )
     }
     /**
@@ -39123,31 +35483,25 @@ function requireIpv6() {
         public IPv4 address of the NAT with all bits inverted.
       */
       const prefix = this.getBitsBase16(0, 32)
-      const udpPort = this.getBits(80, 96)
-        .xor(new jsbn_1.BigInteger('ffff', 16))
-        .toString()
+      const bitsForUdpPort = this.getBits(80, 96)
+      // eslint-disable-next-line no-bitwise
+      const udpPort = (bitsForUdpPort ^ BigInt('0xffff')).toString()
       const server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64))
+      const bitsForClient4 = this.getBits(96, 128)
+      // eslint-disable-next-line no-bitwise
       const client4 = ipv4_1.Address4.fromHex(
-        this.getBits(96, 128)
-          .xor(new jsbn_1.BigInteger('ffffffff', 16))
-          .toString(16)
+        (bitsForClient4 ^ BigInt('0xffffffff')).toString(16)
       )
-      const flags = this.getBits(64, 80)
       const flagsBase2 = this.getBitsBase2(64, 80)
-      const coneNat = flags.testBit(15)
-      const reserved = flags.testBit(14)
-      const groupIndividual = flags.testBit(8)
-      const universalLocal = flags.testBit(9)
-      const nonce = new jsbn_1.BigInteger(
-        flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16),
-        2
+      const coneNat = (0, common_1.testBit)(flagsBase2, 15)
+      const reserved = (0, common_1.testBit)(flagsBase2, 14)
+      const groupIndividual = (0, common_1.testBit)(flagsBase2, 8)
+      const universalLocal = (0, common_1.testBit)(flagsBase2, 9)
+      const nonce = BigInt(
+        `0b${flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16)}`
       ).toString(10)
       return {
-        prefix: (0, sprintf_js_1.sprintf)(
-          '%s:%s',
-          prefix.slice(0, 4),
-          prefix.slice(4, 8)
-        ),
+        prefix: `${prefix.slice(0, 4)}:${prefix.slice(4, 8)}`,
         server4: server4.address,
         client4: client4.address,
         flags: flagsBase2,
@@ -39175,7 +35529,7 @@ function requireIpv6() {
       const prefix = this.getBitsBase16(0, 16)
       const gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48))
       return {
-        prefix: (0, sprintf_js_1.sprintf)('%s', prefix.slice(0, 4)),
+        prefix: prefix.slice(0, 4),
         gateway: gateway.address
       }
     }
@@ -39205,12 +35559,14 @@ function requireIpv6() {
      * @returns {Array}
      */
     toByteArray() {
-      const byteArray = this.bigInteger().toByteArray()
-      // work around issue where `toByteArray` returns a leading 0 element
-      if (byteArray.length === 17 && byteArray[0] === 0) {
-        return byteArray.slice(1)
+      const valueWithoutPadding = this.bigInt().toString(16)
+      const leadingPad = '0'.repeat(valueWithoutPadding.length % 2)
+      const value = `${leadingPad}${valueWithoutPadding}`
+      const bytes = []
+      for (let i = 0, length = value.length; i < length; i += 2) {
+        bytes.push(parseInt(value.substring(i, i + 2), 16))
       }
-      return byteArray
+      return bytes
     }
     /**
      * Return an unsigned byte array
@@ -39237,16 +35593,14 @@ function requireIpv6() {
      * @returns {Address6}
      */
     static fromUnsignedByteArray(bytes) {
-      const BYTE_MAX = new jsbn_1.BigInteger('256', 10)
-      let result = new jsbn_1.BigInteger('0', 10)
-      let multiplier = new jsbn_1.BigInteger('1', 10)
+      const BYTE_MAX = BigInt('256')
+      let result = BigInt('0')
+      let multiplier = BigInt('1')
       for (let i = bytes.length - 1; i >= 0; i--) {
-        result = result.add(
-          multiplier.multiply(new jsbn_1.BigInteger(bytes[i].toString(10), 10))
-        )
-        multiplier = multiplier.multiply(BYTE_MAX)
+        result += multiplier * BigInt(bytes[i].toString(10))
+        multiplier *= BYTE_MAX
       }
-      return Address6.fromBigInteger(result)
+      return Address6.fromBigInt(result)
     }
     /**
      * Returns true if the address is in the canonical form, false otherwise
@@ -39327,13 +35681,9 @@ function requireIpv6() {
       if (optionalPort === undefined) {
         optionalPort = ''
       } else {
-        optionalPort = (0, sprintf_js_1.sprintf)(':%s', optionalPort)
+        optionalPort = `:${optionalPort}`
       }
-      return (0, sprintf_js_1.sprintf)(
-        'http://[%s]%s/',
-        this.correctForm(),
-        optionalPort
-      )
+      return `http://[${this.correctForm()}]${optionalPort}/`
     }
     /**
      * @returns {String} a link suitable for conveying the address via a URL hash
@@ -39355,19 +35705,11 @@ function requireIpv6() {
       if (options.v4) {
         formFunction = this.to4in6
       }
+      const form = formFunction.call(this)
       if (options.className) {
-        return (0, sprintf_js_1.sprintf)(
-          '<a href="%1$s%2$s" class="%3$s">%2$s</a>',
-          options.prefix,
-          formFunction.call(this),
-          options.className
-        )
+        return `<a href="${options.prefix}${form}" class="${options.className}">${form}</a>`
       }
-      return (0, sprintf_js_1.sprintf)(
-        '<a href="%1$s%2$s">%2$s</a>',
-        options.prefix,
-        formFunction.call(this)
-      )
+      return `<a href="${options.prefix}${form}">${form}</a>`
     }
     /**
      * Groups an address
@@ -39394,11 +35736,9 @@ function requireIpv6() {
         i < this.elisionBegin + this.elidedGroups;
         i++
       ) {
-        classes.push((0, sprintf_js_1.sprintf)('group-%d', i))
+        classes.push(`group-${i}`)
       }
-      output.push(
-        (0, sprintf_js_1.sprintf)('<span class="%s"></span>', classes.join(' '))
-      )
+      output.push(`<span class="${classes.join(' ')}"></span>`)
       if (right.length) {
         output.push(...helpers.simpleGroup(right, this.elisionEnd))
       } else {