How to use the crypto-js.enc function in crypto-js

bip39.mnemonicToEntropy(backupData.encryptedRecoverySecretMnemonic), 'hex', 'base64');
            }

            // decrypt encryption secret
            if (usePassword) {
                secret = CryptoJS.AES.decrypt(backupData.passwordEncryptedSecretMnemonic, backupData.password).toString(CryptoJS.enc.Utf8);
            } else {
                secret = CryptoJS.AES.decrypt(backupData.encryptedRecoverySecretMnemonic, backupData.recoverySecretDecryptionKey).toString(CryptoJS.enc.Utf8);
            }

            if (!secret) {
                throw new Error("Could not decrypt secret with " + (usePassword ? "password" : "decryption key"));
            }

            // now finally decrypt the primary seed and convert to buffer (along with backup seed)
            primarySeed = new Buffer(CryptoJS.AES.decrypt(backupData.encryptedPrimaryMnemonic, secret).toString(CryptoJS.enc.Utf8), 'base64');

            if (backupData.backupMnemonic) {
                backupSeed = new Buffer(bip39.mnemonicToEntropy(backupData.backupMnemonic), 'hex');
            }

        break;

        case 3:
            // convert mnemonics to hex (bip39) and then base64 for decryption
            backupData.encryptedPrimaryMnemonic = EncryptionMnemonic.decode(backupData.encryptedPrimaryMnemonic);
            if (usePassword) {
                backupData.passwordEncryptedSecretMnemonic = EncryptionMnemonic.decode(backupData.passwordEncryptedSecretMnemonic);
            } else {
                backupData.encryptedRecoverySecretMnemonic = EncryptionMnemonic.decode(backupData.encryptedRecoverySecretMnemonic);
            }

module.exports.decryptPrivateKey = function(encryptedKey, password) {

  // Decrypt private key and convert it to hex string
  return CryptoJS.AES.decrypt(encryptedKey, password).toString(CryptoJS.enc.Utf8)

}

co(function*() {

        if (ConfigStorage.exists(__dirname + "/" + configFile)) {
            console.log("Loading configuration from", configFile);

            const data = JSON.parse(ConfigStorage.load(__dirname + "/" + configFile));
            var password = yield prompt.password('password: ');
            var bytes = CryptoJS.AES.decrypt(data.encryptedAccountKey, password);
            var privateKey = bytes.toString(CryptoJS.enc.Utf8);
            privateKeyHex = privateKey;
            ConfigStorage.save(__dirname+'/.currentAccount', JSON.stringify({
                privateKey: privateKeyHex

            }));

        }
        process.exit();

    });
};

this.encodeToken=function (token) {
        let wordArray = crypto.enc.Utf8.parse(token);
        let str = crypto.enc.Base64.stringify(wordArray);
        str+=Math.floor(Math.random() * (99 - 10 + 1) + 10);
        str=str.split("").reverse().join("");
        return str;
    }
}

truncated.push(0)
                        poses.push(encode_Uint8("Unspecified"))
                    });
                    if(tags.length){
                        builder.setIntegers('image/height', [tags[0].h]);
                        builder.setIntegers('image/width', [tags[0].w]);
                    } else {
                        builder.setIntegers('image/height', [self.frameHeight]);
                        builder.setIntegers('image/width', [self.frameWidth]);
                    }
                    

                    builder.setBinaries('image/filename', [encode_Uint8(frameName)]);
                    builder.setBinaries('image/source_id', [encode_Uint8(frameName)]);

                    builder.setBinaries('image/key/sha256', [encode_Uint8(CryptoJS.SHA256(b64).toString(CryptoJS.enc.Base64))]);

                    builder.setBinaries('image/encoded', [b64]);

                    if (videotagging.currTFRecord) {
                        builder.setBytes('image/format', [encode_Uint8(videotagging.getCurrentFrameId().split(".").slice(-2)[0])]);
                    } else if(videotagging.imagelist){
                        builder.setBinaries('image/format', [encode_Uint8(videotagging.getCurrentFrameId().split(".").slice(-1)[0])]);
                    } else {
                        builder.setBinaries('image/format', [encode_Uint8('mp4')]);
                    }

                    
                    builder.setFloats('image/object/bbox/xmin', xmin);
                    builder.setFloats('image/object/bbox/ymin', ymin);
                    builder.setFloats('image/object/bbox/xmax', xmax);
                    builder.setFloats('image/object/bbox/ymax', ymax);

public login(username, password) {
        let data = JSON.stringify({
            requestType: 'LOGIN'
        });

        let byteArr = CryptoJS.enc.Utf8.parse(username + ':' + password);
        let encoded = CryptoJS.enc.Base64.stringify(byteArr);
        let authValue = 'Basic ' + encoded;

        return this.documentService.postWithHeader(Links.BASIC_AUTH, data,{ 'Authorization' : authValue });
    }

_encrypt_word_array(plaintext) {
        //https://code.google.com/p/crypto-js/issues/detail?id=85
        var cipher = CryptoJS.AES.encrypt(plaintext, this.key, {iv: this.iv});
        return CryptoJS.enc.Base64.parse(cipher.toString());
    }

export function loadUserdata() {
  let loginReducer = {
    loggedInUser: false,
    userdata: {},
  };

  let localUserdata = JSON.parse(localStorage.getItem('localUser'));

  if (localStorage.getItem('user')) {
    let phrase = 'tc-core';
    let decrypted = CryptoJS.AES.decrypt(localStorage.getItem('user'), phrase);
    let userdata = JSON.parse(decrypted.toString(CryptoJS.enc.Utf8));
    loginReducer.userdata = userdata;
    loginReducer.loggedInUser = true;
  } else if (localUserdata) {
    loginReducer.userdata = localUserdata;
    loginReducer.loggedInUser = true;
  }

  return loginReducer;
}
/**

proto.base64 = function() {
  this.finalize();
  if (this._hash) {
    return this._hash.toString(CryptoJS.enc.Base64);
  }
  return null;
};