How to use the pouchdb-binary-utils.atob function in pouchdb-binary-utils

for (var i = 0; i < attachments.length; i++) {
        var key = attachments[i];
        var att = docInfo.data._attachments[key];

        if (att.stub) {
          // still need to update the refs mapping
          var id = docInfo.data._id;
          var rev = docInfo.data._rev;
          saveAttachmentRefs(id, rev, att.digest, attachmentSaved);
          continue;
        }
        var data;
        if (typeof att.data === 'string') {
          // input is assumed to be a base64 string
          try {
            data = atob(att.data);
          } catch (e) {
            callback(createError(BAD_ARG,
                     'Attachment is not a valid base64 string'));
            return;
          }
          doMD5(docInfo, key, attachmentSaved)(data);
        } else {
          prepareAttachmentForStorage(att.data,
            doMD5(docInfo, key, attachmentSaved));
        }
      }

      function finish() {
        var seq = docInfo.metadata.rev_map[docInfo.metadata.rev];
        /* istanbul ignore if */
        if (seq) {

for (var i = 0; i < attachments.length; i++) {
        var key = attachments[i];
        var att = docInfo.data._attachments[key];

        if (att.stub) {
          // still need to update the refs mapping
          var id = docInfo.data._id;
          var rev = docInfo.data._rev;
          saveAttachmentRefs(id, rev, att.digest, attachmentSaved);
          continue;
        }
        var data;
        if (typeof att.data === 'string') {
          // input is assumed to be a base64 string
          try {
            data = pouchdbBinaryUtils.atob(att.data);
          } catch (e) {
            callback(pouchdbErrors.createError(pouchdbErrors.BAD_ARG,
                     'Attachment is not a valid base64 string'));
            return;
          }
          doMD5(docInfo, key, attachmentSaved)(data);
        } else {
          prepareAttachmentForStorage(att.data,
            doMD5(docInfo, key, attachmentSaved));
        }
      }

      function finish() {
        var seq = docInfo.metadata.rev_map[docInfo.metadata.rev];
        /* istanbul ignore if */
        if (seq) {

callback = type;
      type = blob;
      blob = rev;
      rev = null;
    }
    var id = encodeDocId(docId) + '/' + encodeAttachmentId(attachmentId);
    var url = genDBUrl(host, id);
    if (rev) {
      url += '?rev=' + rev;
    }

    if (typeof blob === 'string') {
      // input is assumed to be a base64 string
      var binary;
      try {
        binary = atob(blob);
      } catch (err) {
        return callback(createError(BAD_ARG,
                        'Attachment is not a valid base64 string'));
      }
      blob = binary ? binStringToBluffer(binary, type) : '';
    }

    // Add the attachment
    fetchJSON(url, {
      headers: new Headers({'Content-Type': type}),
      method: 'PUT',
      body: blob
    }, callback).catch(callback);
  });

for (var i = 0; i < attachments.length; i++) {
        var key = attachments[i];
        var att = docInfo.data._attachments[key];

        if (att.stub) {
          // still need to update the refs mapping
          var id = docInfo.data._id;
          var rev = docInfo.data._rev;
          saveAttachmentRefs(id, rev, att.digest, attachmentSaved);
          continue;
        }
        var data;
        if (typeof att.data === 'string') {
          // input is assumed to be a base64 string
          try {
            data = pouchdbBinaryUtils.atob(att.data);
          } catch (e) {
            callback(pouchdbErrors.createError(pouchdbErrors.BAD_ARG,
                     'Attachment is not a valid base64 string'));
            return;
          }
          doMD5(docInfo, key, attachmentSaved)(data);
        } else {
          prepareAttachmentForStorage(att.data,
            doMD5(docInfo, key, attachmentSaved));
        }
      }

      function finish() {
        var seq = docInfo.metadata.rev_map[docInfo.metadata.rev];
        /* istanbul ignore if */
        if (seq) {

for (var i = 0; i < attachments.length; i++) {
        var key = attachments[i]
        var att = docInfo.data._attachments[key]

        if (att.stub) {
          // still need to update the refs mapping
          var id = docInfo.data._id
          var rev = docInfo.data._rev
          saveAttachmentRefs(id, rev, att.digest, attachmentSaved)
          continue
        }
        var data
        if (typeof att.data === 'string') {
          // input is assumed to be a base64 string
          try {
            data = atob(att.data)
          } catch (e) {
            callback(createError(BAD_ARG,
                     'Attachment is not a valid base64 string'))
            return
          }
          doMD5(docInfo, key, attachmentSaved)(data)
        } else {
          prepareAttachmentForStorage(att.data,
            doMD5(docInfo, key, attachmentSaved))
        }
      }

      function finish () {
        var seq = docInfo.metadata.rev_map[docInfo.metadata.rev]
        /* istanbul ignore if */
        if (seq) {

if (!data)
              return reject(
                createError(MISSING_STUB, 'can not find attachment')
              )
            return resolve({
              attachment,
              dbAttachment: [attachmentKey, data]
            })
          })
        })
      }

      let resolveB64Data
      if (typeof attachment.data === 'string') {
        try {
          ensureB64String(attachment.data)
        } catch (error) {
          return Promise.reject(
            createError(BAD_ARG, 'Attachment is not a valid base64 string')
          )
        }
        resolveB64Data = Promise.resolve(attachment.data)
      } else {
        resolveB64Data = new Promise((resolve, reject) => {
          blobOrBufferToBase64(attachment.data, b64 => resolve(b64))
        }).catch(() =>
          Promise.reject(
            createError(BAD_ARG, 'Attachment is not a valid buffer/blob')
          )
        )
      }

function parseBase64(data) {
  try {
    return atob(data);
  } catch (e) {
    var err = createError(BAD_ARG,
      'Attachment is not a valid base64 string');
    return {error: err};
  }
}