@ivujs/i-utils 1.1.1

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

@@ -0,0 +1,427 @@
+/*
+ * [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.mjs

@@ -0,0 +1,57 @@
+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 };