@ivujs/i-utils 1.1.16 → 1.1.17

package/dist/es/crypto/base64/base64.mjs

@@ -1,342 +0,0 @@
-/*
- * [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;
-
-export { decode, decodeAsBytes, encode, utf8Decode, utf8Encode };

package/dist/es/crypto/base64/index.d.ts

@@ -1,36 +0,0 @@
-/**
- * base64 加密
- * @param {String} str 字符串
- * @returns {String} 返回加密后的字符串
- */
-export function encode(str: string): string;
-/**
- * base64 解密
- * @param {String} str 字符串
- * @returns {String} 返回解密后的字符串
- */
-export function decode(str: string): string;
-/**
- * base64 utf8加密
- * @param {String} str 字符串
- * @returns {String} 返回加密后的字符串
- */
-export function utf8Encode(str: string): string;
-/**
- * base64 utf8解密
- * @param {String} str 字符串
- * @returns {String} 返回解密后的字符串
- */
-export function utf8Decode(str: string): string;
-/**
- * base64 加密字节数组
- * @param {Array} array 数组
- * @returns {String} 返回加密后的字符串
- */
-export function encodeAsBytes(array: any[]): string;
-/**
- * base64 解密字节数组
- * @param {String} str 字符串
- * @returns {Array} 返回解密后的字节数组
- */
-export function decodeAsBytes(str: string): any[];

package/dist/es/crypto/base64/index.mjs

@@ -1,52 +0,0 @@
-import { encode as encode$1, decode as decode$1, utf8Encode as utf8Encode$1, utf8Decode as utf8Decode$1, decodeAsBytes as decodeAsBytes$1 } from './base64.mjs';
-
-/**
- * base64 加密
- * @param {String} str 字符串
- * @returns {String} 返回加密后的字符串
- */
-function encode(str) {
-    return encode$1(str);
-}
-/**
- * base64 解密
- * @param {String} str 字符串
- * @returns {String} 返回解密后的字符串
- */
-function decode(str) {
-    return decode$1(str);
-}
-/**
- * base64 utf8加密
- * @param {String} str 字符串
- * @returns {String} 返回加密后的字符串
- */
-function utf8Encode(str) {
-    return utf8Encode$1(str);
-}
-/**
- * base64 utf8解密
- * @param {String} str 字符串
- * @returns {String} 返回解密后的字符串
- */
-function utf8Decode(str) {
-    return utf8Decode$1(str);
-}
-/**
- * base64 加密字节数组
- * @param {Array} array 数组
- * @returns {String} 返回加密后的字符串
- */
-function encodeAsBytes(array) {
-    return encode$1(array);
-}
-/**
- * base64 解密字节数组
- * @param {String} str 字符串
- * @returns {Array} 返回解密后的字节数组
- */
-function decodeAsBytes(str) {
-    return decodeAsBytes$1(str);
-}
-
-export { decode, decodeAsBytes, encode, encodeAsBytes, utf8Decode, utf8Encode };

package/dist/es/crypto/des/des.d.ts

@@ -1,52 +0,0 @@
-export default Des;
-/**
- * 使用方法
- * 实例化对象 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);//解密
- */
-declare function Des(key: any, value: any): void;
-declare class Des {
-    /**
-     * 使用方法
-     * 实例化对象 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);//解密
-     */
-    constructor(key: any, value: any);
-    key: any;
-    value: any;
-    /**
-     * @param {String} key 密钥
-     * @param {String} value 内容
-     * @param {String} type 类型 ->encrypt加密|decrypt解密
-     */
-    _DesCreate(key: string, value: string, type: string): string;
-    _DesCreateKeys(key: any): any[];
-    /**
-     * 加密
-     * @param {String} key 密钥
-     * @param {String} plaintext 明文
-     * @return {String} ciphertext 密文
-     */
-    encrypt(key: string, plaintext: string): string;
-    /**
-     * 解密
-     * @param {String} key 密钥
-     * @param {String} ciphertext 密文
-     * @return {String} plaintext 明文
-     */
-    decrypt(key: string, ciphertext: string): string;
-}