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

function encrypt (text, originKey) {
    var originKey = originKey.slice(0, 16),
        key = CryptoJS.enc.Utf8.parse(originKey),
        iv = CryptoJS.enc.Utf8.parse(originKey),
        msg = JSON.stringify(text)
    var ciphertext = CryptoJS.AES.encrypt(msg, key, {
        iv: iv,
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
    });
    return ciphertext.toString()
}
// 解密算法

function encrypt(msg, key) {

  // convert to word array so AES treats this as a key and not a passphrase
  var bytesKey = CryptoJS.enc.Hex.parse(key);

  var iv = CryptoJS.lib.WordArray.random(128 / 8);

  // The default output format is CryptoJS.format.OpenSSL,
  // but this only transports the salt.
  var encrypted = CryptoJS.AES.encrypt(msg, bytesKey, {
    iv: iv,
    padding: CryptoJS.pad.Pkcs7,
    mode: CryptoJS.mode.CBC

  });

  // append iv - 32 bytes in hex
  var cipherText = '';

  cipherText += iv.toString() + encrypted.toString();

  return cipherText;
}

export function decrypt(data, pass, iterations = 4500) {
  const keySize = 256;
  const salt = CryptoJS.enc.Hex.parse(data.substr(0, 32));
  const iv = CryptoJS.enc.Hex.parse(data.substr(32, 32));
  const encrypted = data.substring(64);
  const key = CryptoJS.PBKDF2(pass, salt, {
    iterations,
    keySize: keySize / 4
  });
  const decrypted = CryptoJS.AES.decrypt(encrypted, key, {
    iv,
    padding: CryptoJS.pad.Pkcs7,
    mode: CryptoJS.mode.CBC
  });
  return decrypted;
}

function encrypt(msg, pass) {
            var keySize = 256;
            var ivSize = 128;
            var saltSize = 256;
            var iterations = 1000;            
            var salt = CryptoJS.lib.WordArray.random(saltSize / 8);
            var key = CryptoJS.PBKDF2(pass, salt, {
                keySize: keySize / 32,
                iterations: iterations
            });
            var iv = CryptoJS.lib.WordArray.random(ivSize / 8);
            var encrypted = CryptoJS.AES.encrypt(msg, key, {
                iv: iv,
                padding: CryptoJS.pad.Pkcs7,
                mode: CryptoJS.mode.CBC
            });
            var encryptedHex = base64ToHex(encrypted.toString());
            var base64result = hexToBase64(salt + iv + encryptedHex);
            return base64result;
        }

var encryptString = function (stringToEncrypt) {
    var utf8Stringified = CryptoJS.enc.Utf8.parse(stringToEncrypt);
    var encrypted = CryptoJS.AES.encrypt(utf8Stringified.toString(), cryptEncryptionKey,
        {mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7, iv: cryptEncryptionIv});
    return encrypted.ciphertext.toString(CryptoJS.enc.Base64);
};

_aesEncryptedBase64: function _aesEncryptedBase64(payload, key, iv) {
                var encrypted = CryptoJS.AES.encrypt(
                    payload,
                    CryptoJS.enc.Hex.parse(key),
                    {
                        iv: CryptoJS.enc.Hex.parse(iv),
                        mode: CryptoJS.mode.CBC,
                        padding: CryptoJS.pad.ZeroPadding
                    }
                );
                return encrypted.ciphertext.toString(CryptoJS.enc.Base64);
            },

export function aesEncrypt(plaintext, prikey) {
  let srcs = CryptoJS.enc.Utf8.parse(plaintext)
  let key = hmacSHA256(prikey, prikey)

  let iv = CryptoJS.enc.Hex.parse(key.slice(0, 32))
  key = CryptoJS.enc.Hex.parse(key)

  let encrypted = CryptoJS.AES.encrypt(srcs, key, {iv: iv, mode: CryptoJS.mode.CFB, padding: CryptoJS.pad.NoPadding})
  return encrypted.ciphertext.toString()
}

function encrypt(word) {
  let srcs = CryptoJS.enc.Utf8.parse(word);
  let encrypted = CryptoJS.AES.encrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
  return encrypted.ciphertext.toString().toUpperCase();
}

CryptoAdapter.aesEncrypt = function aesEncrypt(plaintext, key_hex, iv_hex) {
        return CryptoJS.AES.encrypt(
            plaintext,
            CryptoJS.enc.Hex.parse(key_hex),
            {
                iv: CryptoJS.enc.Hex.parse(iv_hex),
                mode: CryptoJS.mode.CBC,
                padding: CryptoJS.pad.ZeroPadding
            }
        );
    };

private encrypt(str) {
    var key = CryptoJS.enc.Utf8.parse(this._KEY);
    var iv = CryptoJS.enc.Utf8.parse(this._IV);
    var encrypted = '';
    var srcs = CryptoJS.enc.Utf8.parse(str);
    encrypted = CryptoJS.AES.encrypt(srcs, key, {
      iv: iv,
      mode: CryptoJS.mode.CBC,
      padding: CryptoJS.pad.Pkcs7
    }).ciphertext;

    return encrypted.toString();
  }