@ivujs/i-utils 1.1.14 → 1.1.16

package/dist/cjs/crypto/base64/base64.cjs

@@ -0,0 +1,348 @@
+'use strict';
+
+/*
+ * [hi-base64]{@link https://github.com/emn178/hi-base64}
+ *
+ * @version 0.3.1
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2014-2023
+ * @license MIT
+ */
+/* jslint bitwise: true */
+var ENCODING_ERROR = "not a UTF-8 string";
+var WINDOW = typeof window === "object";
+var root = WINDOW ? window : {};
+if (root.HI_BASE64_NO_WINDOW) {
+    WINDOW = false;
+}
+var WEB_WORKER = !WINDOW && typeof self === "object";
+var NODE_JS = !root.HI_BASE64_NO_NODE_JS && typeof process === "object" && process.versions && process.versions.node;
+if (NODE_JS) {
+    root = global;
+}
+else if (WEB_WORKER) {
+    root = self;
+}
+var BASE64_ENCODE_CHAR = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+var BASE64_DECODE_CHAR = {};
+for (var i = 0; i < 64; ++i) {
+    BASE64_DECODE_CHAR[BASE64_ENCODE_CHAR[i]] = i;
+}
+BASE64_DECODE_CHAR["-"] = 62;
+BASE64_DECODE_CHAR["_"] = 63;
+var cleanBase64Str = function (base64Str) {
+    return base64Str.split("=")[0].replace(/[\r\n]/g, "");
+};
+var utf8ToBytes = function (str) {
+    var bytes = [];
+    for (var i = 0; i < str.length; i++) {
+        var c = str.charCodeAt(i);
+        if (c < 0x80) {
+            bytes[bytes.length] = c;
+        }
+        else if (c < 0x800) {
+            bytes[bytes.length] = 0xc0 | (c >> 6);
+            bytes[bytes.length] = 0x80 | (c & 0x3f);
+        }
+        else if (c < 0xd800 || c >= 0xe000) {
+            bytes[bytes.length] = 0xe0 | (c >> 12);
+            bytes[bytes.length] = 0x80 | ((c >> 6) & 0x3f);
+            bytes[bytes.length] = 0x80 | (c & 0x3f);
+        }
+        else {
+            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(++i) & 0x3ff));
+            bytes[bytes.length] = 0xf0 | (c >> 18);
+            bytes[bytes.length] = 0x80 | ((c >> 12) & 0x3f);
+            bytes[bytes.length] = 0x80 | ((c >> 6) & 0x3f);
+            bytes[bytes.length] = 0x80 | (c & 0x3f);
+        }
+    }
+    return bytes;
+};
+var decodeAsBytes = function (base64Str) {
+    base64Str = cleanBase64Str(base64Str);
+    var v1, v2, v3, v4, bytes = [], index = 0, length = base64Str.length;
+    // 4 char to 3 bytes
+    for (var i = 0, count = (length >> 2) << 2; i < count;) {
+        v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        v4 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        bytes[index++] = ((v1 << 2) | (v2 >>> 4)) & 255;
+        bytes[index++] = ((v2 << 4) | (v3 >>> 2)) & 255;
+        bytes[index++] = ((v3 << 6) | v4) & 255;
+    }
+    // remain bytes
+    var remain = length - count;
+    if (remain === 2) {
+        v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        bytes[index++] = ((v1 << 2) | (v2 >>> 4)) & 255;
+    }
+    else if (remain === 3) {
+        v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+        bytes[index++] = ((v1 << 2) | (v2 >>> 4)) & 255;
+        bytes[index++] = ((v2 << 4) | (v3 >>> 2)) & 255;
+    }
+    return bytes;
+};
+var encodeFromBytes = function (bytes) {
+    var v1, v2, v3, base64Str = [], length = bytes.length;
+    for (var i = 0, count = parseInt(length / 3) * 3; i < count;) {
+        v1 = bytes[i++];
+        v2 = bytes[i++];
+        v3 = bytes[i++];
+        base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[((v1 << 4) | (v2 >>> 4)) & 63], BASE64_ENCODE_CHAR[((v2 << 2) | (v3 >>> 6)) & 63], BASE64_ENCODE_CHAR[v3 & 63]);
+    }
+    // remain char
+    var remain = length - count;
+    if (remain === 1) {
+        v1 = bytes[i];
+        base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[(v1 << 4) & 63], "==");
+    }
+    else if (remain === 2) {
+        v1 = bytes[i++];
+        v2 = bytes[i];
+        base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[((v1 << 4) | (v2 >>> 4)) & 63], BASE64_ENCODE_CHAR[(v2 << 2) & 63], "=");
+    }
+    return base64Str.join("");
+};
+var btoa = root.btoa, atob = root.atob, utf8Base64Encode, utf8Base64Decode;
+if (NODE_JS) {
+    var Buffer = require("buffer").Buffer;
+    btoa = function (str) {
+        return Buffer.from(str, "ascii").toString("base64");
+    };
+    utf8Base64Encode = function (str) {
+        return Buffer.from(str).toString("base64");
+    };
+    encodeFromBytes = utf8Base64Encode;
+    atob = function (base64Str) {
+        return Buffer.from(base64Str, "base64").toString("ascii");
+    };
+    utf8Base64Decode = function (base64Str) {
+        return Buffer.from(base64Str, "base64").toString();
+    };
+}
+else if (!btoa) {
+    btoa = function (str) {
+        var v1, v2, v3, base64Str = [], length = str.length;
+        for (var i = 0, count = parseInt(length / 3) * 3; i < count;) {
+            v1 = str.charCodeAt(i++);
+            v2 = str.charCodeAt(i++);
+            v3 = str.charCodeAt(i++);
+            base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[((v1 << 4) | (v2 >>> 4)) & 63], BASE64_ENCODE_CHAR[((v2 << 2) | (v3 >>> 6)) & 63], BASE64_ENCODE_CHAR[v3 & 63]);
+        }
+        // remain char
+        var remain = length - count;
+        if (remain === 1) {
+            v1 = str.charCodeAt(i);
+            base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[(v1 << 4) & 63], "==");
+        }
+        else if (remain === 2) {
+            v1 = str.charCodeAt(i++);
+            v2 = str.charCodeAt(i);
+            base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[((v1 << 4) | (v2 >>> 4)) & 63], BASE64_ENCODE_CHAR[(v2 << 2) & 63], "=");
+        }
+        return base64Str.join("");
+    };
+    utf8Base64Encode = function (str) {
+        var v1, v2, v3, base64Str = [], bytes = utf8ToBytes(str), length = bytes.length;
+        for (var i = 0, count = parseInt(length / 3) * 3; i < count;) {
+            v1 = bytes[i++];
+            v2 = bytes[i++];
+            v3 = bytes[i++];
+            base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[((v1 << 4) | (v2 >>> 4)) & 63], BASE64_ENCODE_CHAR[((v2 << 2) | (v3 >>> 6)) & 63], BASE64_ENCODE_CHAR[v3 & 63]);
+        }
+        // remain char
+        var remain = length - count;
+        if (remain === 1) {
+            v1 = bytes[i];
+            base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[(v1 << 4) & 63], "==");
+        }
+        else if (remain === 2) {
+            v1 = bytes[i++];
+            v2 = bytes[i];
+            base64Str.push(BASE64_ENCODE_CHAR[v1 >>> 2], BASE64_ENCODE_CHAR[((v1 << 4) | (v2 >>> 4)) & 63], BASE64_ENCODE_CHAR[(v2 << 2) & 63], "=");
+        }
+        return base64Str.join("");
+    };
+    atob = function (base64Str) {
+        var v1, v2, v3, v4, str = [], length = base64Str.length;
+        // 4 char to 3 bytes
+        for (var i = 0, count = (length >> 2) << 2; i < count;) {
+            v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            v4 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            str.push(String.fromCharCode(((v1 << 2) | (v2 >>> 4)) & 255), String.fromCharCode(((v2 << 4) | (v3 >>> 2)) & 255), String.fromCharCode(((v3 << 6) | v4) & 255));
+        }
+        // remain bytes
+        var remain = length - count;
+        if (remain === 2) {
+            v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            str.push(String.fromCharCode(((v1 << 2) | (v2 >>> 4)) & 255));
+        }
+        else if (remain === 3) {
+            v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
+            str.push(String.fromCharCode(((v1 << 2) | (v2 >>> 4)) & 255), String.fromCharCode(((v2 << 4) | (v3 >>> 2)) & 255));
+        }
+        return str.join("");
+    };
+    utf8Base64Decode = function (base64Str) {
+        var str = [], bytes = decodeAsBytes(base64Str), length = bytes.length;
+        var i = 0, followingChars = 0, b, c;
+        while (i < length) {
+            b = bytes[i++];
+            if (b <= 0x7f) {
+                str.push(String.fromCharCode(b));
+                continue;
+            }
+            else if (b > 0xbf && b <= 0xdf) {
+                c = b & 0x1f;
+                followingChars = 1;
+            }
+            else if (b <= 0xef) {
+                c = b & 0x0f;
+                followingChars = 2;
+            }
+            else if (b <= 0xf7) {
+                c = b & 0x07;
+                followingChars = 3;
+            }
+            else {
+                throw new Error(ENCODING_ERROR);
+            }
+            for (var j = 0; j < followingChars; ++j) {
+                b = bytes[i++];
+                if (b < 0x80 || b > 0xbf) {
+                    throw new Error(ENCODING_ERROR);
+                }
+                c <<= 6;
+                c += b & 0x3f;
+            }
+            if (c >= 0xd800 && c <= 0xdfff) {
+                throw new Error(ENCODING_ERROR);
+            }
+            if (c > 0x10ffff) {
+                throw new Error(ENCODING_ERROR);
+            }
+            if (c <= 0xffff) {
+                str.push(String.fromCharCode(c));
+            }
+            else {
+                c -= 0x10000;
+                str.push(String.fromCharCode((c >> 10) + 0xd800), String.fromCharCode((c & 0x3ff) + 0xdc00));
+            }
+        }
+        return str.join("");
+    };
+}
+else {
+    utf8Base64Encode = function (str) {
+        var result = [];
+        for (var i = 0; i < str.length; i++) {
+            var charcode = str.charCodeAt(i);
+            if (charcode < 0x80) {
+                result.push(String.fromCharCode(charcode));
+            }
+            else if (charcode < 0x800) {
+                result.push(String.fromCharCode(0xc0 | (charcode >> 6)), String.fromCharCode(0x80 | (charcode & 0x3f)));
+            }
+            else if (charcode < 0xd800 || charcode >= 0xe000) {
+                result.push(String.fromCharCode(0xe0 | (charcode >> 12)), String.fromCharCode(0x80 | ((charcode >> 6) & 0x3f)), String.fromCharCode(0x80 | (charcode & 0x3f)));
+            }
+            else {
+                charcode = 0x10000 + (((charcode & 0x3ff) << 10) | (str.charCodeAt(++i) & 0x3ff));
+                result.push(String.fromCharCode(0xf0 | (charcode >> 18)), String.fromCharCode(0x80 | ((charcode >> 12) & 0x3f)), String.fromCharCode(0x80 | ((charcode >> 6) & 0x3f)), String.fromCharCode(0x80 | (charcode & 0x3f)));
+            }
+        }
+        return btoa(result.join(""));
+    };
+    utf8Base64Decode = function (base64Str) {
+        var tmpStr = atob(base64Str.replace(/-/g, "+").replace(/_/g, "/"));
+        if (!/[^\x00-\x7F]/.test(tmpStr)) {
+            return tmpStr;
+        }
+        var str = [], i = 0, length = tmpStr.length, followingChars = 0, b, c;
+        while (i < length) {
+            b = tmpStr.charCodeAt(i++);
+            if (b <= 0x7f) {
+                str.push(String.fromCharCode(b));
+                continue;
+            }
+            else if (b > 0xbf && b <= 0xdf) {
+                c = b & 0x1f;
+                followingChars = 1;
+            }
+            else if (b <= 0xef) {
+                c = b & 0x0f;
+                followingChars = 2;
+            }
+            else if (b <= 0xf7) {
+                c = b & 0x07;
+                followingChars = 3;
+            }
+            else {
+                throw new Error(ENCODING_ERROR);
+            }
+            for (var j = 0; j < followingChars; ++j) {
+                b = tmpStr.charCodeAt(i++);
+                if (b < 0x80 || b > 0xbf) {
+                    throw new Error(ENCODING_ERROR);
+                }
+                c <<= 6;
+                c += b & 0x3f;
+            }
+            if (c >= 0xd800 && c <= 0xdfff) {
+                throw new Error(ENCODING_ERROR);
+            }
+            if (c > 0x10ffff) {
+                throw new Error(ENCODING_ERROR);
+            }
+            if (c <= 0xffff) {
+                str.push(String.fromCharCode(c));
+            }
+            else {
+                c -= 0x10000;
+                str.push(String.fromCharCode((c >> 10) + 0xd800), String.fromCharCode((c & 0x3ff) + 0xdc00));
+            }
+        }
+        return str.join("");
+    };
+}
+var encode = function (str, asciiOnly) {
+    var notString = typeof str != "string";
+    if (notString && str.constructor === root.ArrayBuffer) {
+        str = new Uint8Array(str);
+    }
+    if (notString) {
+        return encodeFromBytes(str);
+    }
+    else {
+        if (/[^\x00-\x7F]/.test(str)) {
+            return utf8Base64Encode(str);
+        }
+        else {
+            return btoa(str);
+        }
+    }
+};
+var decode = function (base64Str, asciiOnly) {
+    base64Str = cleanBase64Str(base64Str);
+    return asciiOnly ? atob(base64Str) : utf8Base64Decode(base64Str);
+};
+/* 以下是内部实现需要的es模块化导出方法 */
+const utf8Encode = utf8Base64Encode;
+const utf8Decode = utf8Base64Decode;
+
+exports.decode = decode;
+exports.decodeAsBytes = decodeAsBytes;
+exports.encode = encode;
+exports.utf8Decode = utf8Decode;
+exports.utf8Encode = utf8Encode;

package/dist/cjs/crypto/base64/index.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var base64 = require('./base64.cjs');
+
+/**
+ * base64 加密
+ * @param {String} str 字符串
+ * @returns {String} 返回加密后的字符串
+ */
+function encode(str) {
+    return base64.encode(str);
+}
+/**
+ * base64 解密
+ * @param {String} str 字符串
+ * @returns {String} 返回解密后的字符串
+ */
+function decode(str) {
+    return base64.decode(str);
+}
+/**
+ * base64 utf8加密
+ * @param {String} str 字符串
+ * @returns {String} 返回加密后的字符串
+ */
+function utf8Encode(str) {
+    return base64.utf8Encode(str);
+}
+/**
+ * base64 utf8解密
+ * @param {String} str 字符串
+ * @returns {String} 返回解密后的字符串
+ */
+function utf8Decode(str) {
+    return base64.utf8Decode(str);
+}
+/**
+ * base64 加密字节数组
+ * @param {Array} array 数组
+ * @returns {String} 返回加密后的字符串
+ */
+function encodeAsBytes(array) {
+    return base64.encode(array);
+}
+/**
+ * base64 解密字节数组
+ * @param {String} str 字符串
+ * @returns {Array} 返回解密后的字节数组
+ */
+function decodeAsBytes(str) {
+    return base64.decodeAsBytes(str);
+}
+
+exports.decode = decode;
+exports.decodeAsBytes = decodeAsBytes;
+exports.encode = encode;
+exports.encodeAsBytes = encodeAsBytes;
+exports.utf8Decode = utf8Decode;
+exports.utf8Encode = utf8Encode;

package/dist/cjs/crypto/des/des.cjs

@@ -0,0 +1,257 @@
+'use strict';
+
+var index = require('../base64/index.cjs');
+
+const { encode, decode } = index;
+/**
+ * 使用方法
+ * 实例化对象 new Des()
+ * 加密方法 encrypt(key,plaintext)
+ * 解密方法 decrypt(key,ciphertext)
+ * 示例---------------------------------------------------
+ * var Des = new Des();
+ * var key = 'custom key';
+ * var value = '需要加密的内容'
+ * var ciphertext = encrypt(key,value);//加密
+ * var plaintext = encrypt(key,ciphertext);//解密
+ */
+function Des(key, value) {
+    this.key = key;
+    this.value = value;
+}
+/**
+ * @param {String} key 密钥
+ * @param {String} value 内容
+ * @param {String} type 类型 ->encrypt加密|decrypt解密
+ */
+Des.prototype._DesCreate = function (key, value, type) {
+    var message = value;
+    if (type === "decrypt") {
+        var requestValue = "";
+        for (var i = value.substr(0, 2) == "0x" ? 2 : 0; i < value.length; i += 2) {
+            requestValue += String.fromCharCode(parseInt(value.substr(i, 2), 16));
+        }
+        message = requestValue;
+    }
+    var spfunction1 = new Array(0x1010400, 0, 0x10000, 0x1010404, 0x1010004, 0x10404, 0x4, 0x10000, 0x400, 0x1010400, 0x1010404, 0x400, 0x1000404, 0x1010004, 0x1000000, 0x4, 0x404, 0x1000400, 0x1000400, 0x10400, 0x10400, 0x1010000, 0x1010000, 0x1000404, 0x10004, 0x1000004, 0x1000004, 0x10004, 0, 0x404, 0x10404, 0x1000000, 0x10000, 0x1010404, 0x4, 0x1010000, 0x1010400, 0x1000000, 0x1000000, 0x400, 0x1010004, 0x10000, 0x10400, 0x1000004, 0x400, 0x4, 0x1000404, 0x10404, 0x1010404, 0x10004, 0x1010000, 0x1000404, 0x1000004, 0x404, 0x10404, 0x1010400, 0x404, 0x1000400, 0x1000400, 0, 0x10004, 0x10400, 0, 0x1010004);
+    var spfunction2 = new Array(-2146402272, -2147450880, 0x8000, 0x108020, 0x100000, 0x20, -2146435040, -2147450848, -2147483616, -2146402272, -2146402304, -2147483648, -2147450880, 0x100000, 0x20, -2146435040, 0x108000, 0x100020, -2147450848, 0, -2147483648, 0x8000, 0x108020, -2146435072, 0x100020, -2147483616, 0, 0x108000, 0x8020, -2146402304, -2146435072, 0x8020, 0, 0x108020, -2146435040, 0x100000, -2147450848, -2146435072, -2146402304, 0x8000, -2146435072, -2147450880, 0x20, -2146402272, 0x108020, 0x20, 0x8000, -2147483648, 0x8020, -2146402304, 0x100000, -2147483616, 0x100020, -2147450848, -2147483616, 0x100020, 0x108000, 0, -2147450880, 0x8020, -2147483648, -2146435040, -2146402272, 0x108000);
+    var spfunction3 = new Array(0x208, 0x8020200, 0, 0x8020008, 0x8000200, 0, 0x20208, 0x8000200, 0x20008, 0x8000008, 0x8000008, 0x20000, 0x8020208, 0x20008, 0x8020000, 0x208, 0x8000000, 0x8, 0x8020200, 0x200, 0x20200, 0x8020000, 0x8020008, 0x20208, 0x8000208, 0x20200, 0x20000, 0x8000208, 0x8, 0x8020208, 0x200, 0x8000000, 0x8020200, 0x8000000, 0x20008, 0x208, 0x20000, 0x8020200, 0x8000200, 0, 0x200, 0x20008, 0x8020208, 0x8000200, 0x8000008, 0x200, 0, 0x8020008, 0x8000208, 0x20000, 0x8000000, 0x8020208, 0x8, 0x20208, 0x20200, 0x8000008, 0x8020000, 0x8000208, 0x208, 0x8020000, 0x20208, 0x8, 0x8020008, 0x20200);
+    var spfunction4 = new Array(0x802001, 0x2081, 0x2081, 0x80, 0x802080, 0x800081, 0x800001, 0x2001, 0, 0x802000, 0x802000, 0x802081, 0x81, 0, 0x800080, 0x800001, 0x1, 0x2000, 0x800000, 0x802001, 0x80, 0x800000, 0x2001, 0x2080, 0x800081, 0x1, 0x2080, 0x800080, 0x2000, 0x802080, 0x802081, 0x81, 0x800080, 0x800001, 0x802000, 0x802081, 0x81, 0, 0, 0x802000, 0x2080, 0x800080, 0x800081, 0x1, 0x802001, 0x2081, 0x2081, 0x80, 0x802081, 0x81, 0x1, 0x2000, 0x800001, 0x2001, 0x802080, 0x800081, 0x2001, 0x2080, 0x800000, 0x802001, 0x80, 0x800000, 0x2000, 0x802080);
+    var spfunction5 = new Array(0x100, 0x2080100, 0x2080000, 0x42000100, 0x80000, 0x100, 0x40000000, 0x2080000, 0x40080100, 0x80000, 0x2000100, 0x40080100, 0x42000100, 0x42080000, 0x80100, 0x40000000, 0x2000000, 0x40080000, 0x40080000, 0, 0x40000100, 0x42080100, 0x42080100, 0x2000100, 0x42080000, 0x40000100, 0, 0x42000000, 0x2080100, 0x2000000, 0x42000000, 0x80100, 0x80000, 0x42000100, 0x100, 0x2000000, 0x40000000, 0x2080000, 0x42000100, 0x40080100, 0x2000100, 0x40000000, 0x42080000, 0x2080100, 0x40080100, 0x100, 0x2000000, 0x42080000, 0x42080100, 0x80100, 0x42000000, 0x42080100, 0x2080000, 0, 0x40080000, 0x42000000, 0x80100, 0x2000100, 0x40000100, 0x80000, 0, 0x40080000, 0x2080100, 0x40000100);
+    var spfunction6 = new Array(0x20000010, 0x20400000, 0x4000, 0x20404010, 0x20400000, 0x10, 0x20404010, 0x400000, 0x20004000, 0x404010, 0x400000, 0x20000010, 0x400010, 0x20004000, 0x20000000, 0x4010, 0, 0x400010, 0x20004010, 0x4000, 0x404000, 0x20004010, 0x10, 0x20400010, 0x20400010, 0, 0x404010, 0x20404000, 0x4010, 0x404000, 0x20404000, 0x20000000, 0x20004000, 0x10, 0x20400010, 0x404000, 0x20404010, 0x400000, 0x4010, 0x20000010, 0x400000, 0x20004000, 0x20000000, 0x4010, 0x20000010, 0x20404010, 0x404000, 0x20400000, 0x404010, 0x20404000, 0, 0x20400010, 0x10, 0x4000, 0x20400000, 0x404010, 0x4000, 0x400010, 0x20004010, 0, 0x20404000, 0x20000000, 0x400010, 0x20004010);
+    var spfunction7 = new Array(0x200000, 0x4200002, 0x4000802, 0, 0x800, 0x4000802, 0x200802, 0x4200800, 0x4200802, 0x200000, 0, 0x4000002, 0x2, 0x4000000, 0x4200002, 0x802, 0x4000800, 0x200802, 0x200002, 0x4000800, 0x4000002, 0x4200000, 0x4200800, 0x200002, 0x4200000, 0x800, 0x802, 0x4200802, 0x200800, 0x2, 0x4000000, 0x200800, 0x4000000, 0x200800, 0x200000, 0x4000802, 0x4000802, 0x4200002, 0x4200002, 0x2, 0x200002, 0x4000000, 0x4000800, 0x200000, 0x4200800, 0x802, 0x200802, 0x4200800, 0x802, 0x4000002, 0x4200802, 0x4200000, 0x200800, 0, 0x2, 0x4200802, 0, 0x200802, 0x4200000, 0x800, 0x4000002, 0x4000800, 0x800, 0x200002);
+    var spfunction8 = new Array(0x10001040, 0x1000, 0x40000, 0x10041040, 0x10000000, 0x10001040, 0x40, 0x10000000, 0x40040, 0x10040000, 0x10041040, 0x41000, 0x10041000, 0x41040, 0x1000, 0x40, 0x10040000, 0x10000040, 0x10001000, 0x1040, 0x41000, 0x40040, 0x10040040, 0x10041000, 0x1040, 0, 0, 0x10040040, 0x10000040, 0x10001000, 0x41040, 0x40000, 0x41040, 0x40000, 0x10041000, 0x1000, 0x40, 0x10040040, 0x1000, 0x41040, 0x10001000, 0x40, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x40000, 0x10001040, 0, 0x10041040, 0x40040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0, 0x10041040, 0x41000, 0x41000, 0x1040, 0x1040, 0x40040, 0x10000000, 0x10041000);
+    var keys = this._DesCreateKeys(key);
+    var m = 0, i, j, temp, right1, right2, left, right, looping;
+    var endloop, loopinc;
+    var len = message.length;
+    var chunk = 0;
+    var iterations = keys.length == 32 ? 3 : 9;
+    if (iterations == 3) {
+        looping = type === "encrypt" ? new Array(0, 32, 2) : new Array(30, -2, -2);
+    }
+    else {
+        looping =
+            type === "encrypt" ? new Array(0, 32, 2, 62, 30, -2, 64, 96, 2) : new Array(94, 62, -2, 32, 64, 2, 30, -2, -2);
+    }
+    var result = "";
+    var tempresult = "";
+    while (m < len) {
+        left =
+            (message.charCodeAt(m++) << 24) |
+                (message.charCodeAt(m++) << 16) |
+                (message.charCodeAt(m++) << 8) |
+                message.charCodeAt(m++);
+        right =
+            (message.charCodeAt(m++) << 24) |
+                (message.charCodeAt(m++) << 16) |
+                (message.charCodeAt(m++) << 8) |
+                message.charCodeAt(m++);
+        temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+        right ^= temp;
+        left ^= temp << 4;
+        temp = ((left >>> 16) ^ right) & 0x0000ffff;
+        right ^= temp;
+        left ^= temp << 16;
+        temp = ((right >>> 2) ^ left) & 0x33333333;
+        left ^= temp;
+        right ^= temp << 2;
+        temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+        left ^= temp;
+        right ^= temp << 8;
+        temp = ((left >>> 1) ^ right) & 0x55555555;
+        right ^= temp;
+        left ^= temp << 1;
+        left = (left << 1) | (left >>> 31);
+        right = (right << 1) | (right >>> 31);
+        for (j = 0; j < iterations; j += 3) {
+            endloop = looping[j + 1];
+            loopinc = looping[j + 2];
+            for (i = looping[j]; i != endloop; i += loopinc) {
+                right1 = right ^ keys[i];
+                right2 = ((right >>> 4) | (right << 28)) ^ keys[i + 1];
+                temp = left;
+                left = right;
+                right =
+                    temp ^
+                        (spfunction2[(right1 >>> 24) & 0x3f] |
+                            spfunction4[(right1 >>> 16) & 0x3f] |
+                            spfunction6[(right1 >>> 8) & 0x3f] |
+                            spfunction8[right1 & 0x3f] |
+                            spfunction1[(right2 >>> 24) & 0x3f] |
+                            spfunction3[(right2 >>> 16) & 0x3f] |
+                            spfunction5[(right2 >>> 8) & 0x3f] |
+                            spfunction7[right2 & 0x3f]);
+            }
+            temp = left;
+            left = right;
+            right = temp;
+        }
+        left = (left >>> 1) | (left << 31);
+        right = (right >>> 1) | (right << 31);
+        temp = ((left >>> 1) ^ right) & 0x55555555;
+        right ^= temp;
+        left ^= temp << 1;
+        temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+        left ^= temp;
+        right ^= temp << 8;
+        temp = ((right >>> 2) ^ left) & 0x33333333;
+        left ^= temp;
+        right ^= temp << 2;
+        temp = ((left >>> 16) ^ right) & 0x0000ffff;
+        right ^= temp;
+        left ^= temp << 16;
+        temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+        right ^= temp;
+        left ^= temp << 4;
+        tempresult += String.fromCharCode(left >>> 24, (left >>> 16) & 0xff, (left >>> 8) & 0xff, left & 0xff, right >>> 24, (right >>> 16) & 0xff, (right >>> 8) & 0xff, right & 0xff);
+        chunk += 8;
+        if (chunk == 512) {
+            result += tempresult;
+            tempresult = "";
+            chunk = 0;
+        }
+    }
+    var resultTempresult = result + tempresult;
+    if (type === "encrypt") {
+        var resultCiphertext = "";
+        var hexes = new Array("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f");
+        for (var i = 0; i < resultTempresult.length; i++) {
+            resultCiphertext += hexes[resultTempresult.charCodeAt(i) >> 4] + hexes[resultTempresult.charCodeAt(i) & 0xf];
+        }
+        return resultCiphertext;
+    }
+    return result + tempresult;
+};
+Des.prototype._DesCreateKeys = function (key) {
+    var pc2bytes0 = new Array(0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000, 0x20010004, 0x200, 0x204, 0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200, 0x20010204);
+    var pc2bytes1 = new Array(0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000, 0x4100001, 0x100, 0x101, 0x100100, 0x100101, 0x4000100, 0x4000101, 0x4100100, 0x4100101);
+    var pc2bytes2 = new Array(0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808, 0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808);
+    var pc2bytes3 = new Array(0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000, 0x8202000, 0x20000, 0x220000, 0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000, 0x8222000);
+    var pc2bytes4 = new Array(0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000, 0x41000, 0x1010, 0x41010, 0x1000, 0x41000, 0x1010, 0x41010);
+    var pc2bytes5 = new Array(0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400, 0x2000020, 0x2000420, 0x2000000, 0x2000400, 0x2000020, 0x2000420);
+    var pc2bytes6 = new Array(0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002, 0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002);
+    var pc2bytes7 = new Array(0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800, 0x20010800, 0x20000, 0x30000, 0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800, 0x20030800);
+    var pc2bytes8 = new Array(0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000, 0x2040000, 0x2000000, 0x2040000, 0x2000002, 0x2040002, 0x2000002, 0x2040002);
+    var pc2bytes9 = new Array(0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008, 0x400, 0x10000400, 0x408, 0x10000408, 0x400, 0x10000400, 0x408, 0x10000408);
+    var pc2bytes10 = new Array(0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000, 0x2020, 0x2000, 0x2020, 0x102000, 0x102020, 0x102000, 0x102020);
+    var pc2bytes11 = new Array(0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200, 0x1200200, 0x4000000, 0x5000000, 0x4000200, 0x5000200, 0x4200000, 0x5200000, 0x4200200, 0x5200200);
+    var pc2bytes12 = new Array(0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000, 0x8081000, 0x10, 0x1010, 0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010);
+    var pc2bytes13 = new Array(0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101, 0x105, 0x1, 0x5, 0x101, 0x105);
+    var iterations = key.length > 8 ? 3 : 1;
+    var keys = new Array(32 * iterations);
+    var shifts = new Array(0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
+    var lefttemp, righttemp, m = 0, n = 0, temp;
+    for (var j = 0; j < iterations; j++) {
+        var left = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
+        var right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
+        temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+        right ^= temp;
+        left ^= temp << 4;
+        temp = ((right >>> -16) ^ left) & 0x0000ffff;
+        left ^= temp;
+        right ^= temp << -16;
+        temp = ((left >>> 2) ^ right) & 0x33333333;
+        right ^= temp;
+        left ^= temp << 2;
+        temp = ((right >>> -16) ^ left) & 0x0000ffff;
+        left ^= temp;
+        right ^= temp << -16;
+        temp = ((left >>> 1) ^ right) & 0x55555555;
+        right ^= temp;
+        left ^= temp << 1;
+        temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+        left ^= temp;
+        right ^= temp << 8;
+        temp = ((left >>> 1) ^ right) & 0x55555555;
+        right ^= temp;
+        left ^= temp << 1;
+        temp = (left << 8) | ((right >>> 20) & 0x000000f0);
+        left = (right << 24) | ((right << 8) & 0xff0000) | ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);
+        right = temp;
+        for (var i = 0; i < shifts.length; i++) {
+            if (shifts[i]) {
+                left = (left << 2) | (left >>> 26);
+                right = (right << 2) | (right >>> 26);
+            }
+            else {
+                left = (left << 1) | (left >>> 27);
+                right = (right << 1) | (right >>> 27);
+            }
+            left &= -15;
+            right &= -15;
+            lefttemp =
+                pc2bytes0[left >>> 28] |
+                    pc2bytes1[(left >>> 24) & 0xf] |
+                    pc2bytes2[(left >>> 20) & 0xf] |
+                    pc2bytes3[(left >>> 16) & 0xf] |
+                    pc2bytes4[(left >>> 12) & 0xf] |
+                    pc2bytes5[(left >>> 8) & 0xf] |
+                    pc2bytes6[(left >>> 4) & 0xf];
+            righttemp =
+                pc2bytes7[right >>> 28] |
+                    pc2bytes8[(right >>> 24) & 0xf] |
+                    pc2bytes9[(right >>> 20) & 0xf] |
+                    pc2bytes10[(right >>> 16) & 0xf] |
+                    pc2bytes11[(right >>> 12) & 0xf] |
+                    pc2bytes12[(right >>> 8) & 0xf] |
+                    pc2bytes13[(right >>> 4) & 0xf];
+            temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;
+            keys[n++] = lefttemp ^ temp;
+            keys[n++] = righttemp ^ (temp << 16);
+        }
+    }
+    return keys;
+};
+/*
+------------------------------------------------------------------------------------
+以上方法对象的私有方法
+为了解决中文乱码
+使用base64先加密，再用des加密
+同理，解密时先用deds解密，再使用base64解密
+------------------------------------------------------------------------------------
+*/
+/**
+ * 加密
+ * @param {String} key 密钥
+ * @param {String} plaintext 明文
+ * @return {String} ciphertext 密文
+ */
+Des.prototype.encrypt = function (key, plaintext) {
+    var encodedString = encode(plaintext);
+    var ciphertext = this._DesCreate(key, encodedString, "encrypt");
+    return ciphertext;
+};
+/**
+ * 解密
+ * @param {String} key 密钥
+ * @param {String} ciphertext 密文
+ * @return {String} plaintext 明文
+ */
+Des.prototype.decrypt = function (key, ciphertext) {
+    var decryptText = this._DesCreate(key, ciphertext, "decrypt"); // Des解密
+    var plaintext = decode(decryptText); // base64解密
+    return plaintext;
+};
+
+module.exports = Des;