120 lines
4.0 KiB
JavaScript
120 lines
4.0 KiB
JavaScript
import {
|
|
require_core
|
|
} from "./chunk-CV3XWTUU.js";
|
|
import {
|
|
__commonJS
|
|
} from "./chunk-GFT2G5UO.js";
|
|
|
|
// node_modules/crypto-js/enc-base64.js
|
|
var require_enc_base64 = __commonJS({
|
|
"node_modules/crypto-js/enc-base64.js"(exports, module) {
|
|
(function(root, factory) {
|
|
if (typeof exports === "object") {
|
|
module.exports = exports = factory(require_core());
|
|
} else if (typeof define === "function" && define.amd) {
|
|
define(["./core"], factory);
|
|
} else {
|
|
factory(root.CryptoJS);
|
|
}
|
|
})(exports, function(CryptoJS) {
|
|
(function() {
|
|
var C = CryptoJS;
|
|
var C_lib = C.lib;
|
|
var WordArray = C_lib.WordArray;
|
|
var C_enc = C.enc;
|
|
var Base64 = C_enc.Base64 = {
|
|
/**
|
|
* Converts a word array to a Base64 string.
|
|
*
|
|
* @param {WordArray} wordArray The word array.
|
|
*
|
|
* @return {string} The Base64 string.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var base64String = CryptoJS.enc.Base64.stringify(wordArray);
|
|
*/
|
|
stringify: function(wordArray) {
|
|
var words = wordArray.words;
|
|
var sigBytes = wordArray.sigBytes;
|
|
var map = this._map;
|
|
wordArray.clamp();
|
|
var base64Chars = [];
|
|
for (var i = 0; i < sigBytes; i += 3) {
|
|
var byte1 = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
|
|
var byte2 = words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
|
|
var byte3 = words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
|
|
var triplet = byte1 << 16 | byte2 << 8 | byte3;
|
|
for (var j = 0; j < 4 && i + j * 0.75 < sigBytes; j++) {
|
|
base64Chars.push(map.charAt(triplet >>> 6 * (3 - j) & 63));
|
|
}
|
|
}
|
|
var paddingChar = map.charAt(64);
|
|
if (paddingChar) {
|
|
while (base64Chars.length % 4) {
|
|
base64Chars.push(paddingChar);
|
|
}
|
|
}
|
|
return base64Chars.join("");
|
|
},
|
|
/**
|
|
* Converts a Base64 string to a word array.
|
|
*
|
|
* @param {string} base64Str The Base64 string.
|
|
*
|
|
* @return {WordArray} The word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.enc.Base64.parse(base64String);
|
|
*/
|
|
parse: function(base64Str) {
|
|
var base64StrLength = base64Str.length;
|
|
var map = this._map;
|
|
var reverseMap = this._reverseMap;
|
|
if (!reverseMap) {
|
|
reverseMap = this._reverseMap = [];
|
|
for (var j = 0; j < map.length; j++) {
|
|
reverseMap[map.charCodeAt(j)] = j;
|
|
}
|
|
}
|
|
var paddingChar = map.charAt(64);
|
|
if (paddingChar) {
|
|
var paddingIndex = base64Str.indexOf(paddingChar);
|
|
if (paddingIndex !== -1) {
|
|
base64StrLength = paddingIndex;
|
|
}
|
|
}
|
|
return parseLoop(base64Str, base64StrLength, reverseMap);
|
|
},
|
|
_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
|
|
};
|
|
function parseLoop(base64Str, base64StrLength, reverseMap) {
|
|
var words = [];
|
|
var nBytes = 0;
|
|
for (var i = 0; i < base64StrLength; i++) {
|
|
if (i % 4) {
|
|
var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2;
|
|
var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
|
|
var bitsCombined = bits1 | bits2;
|
|
words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
|
|
nBytes++;
|
|
}
|
|
}
|
|
return WordArray.create(words, nBytes);
|
|
}
|
|
})();
|
|
return CryptoJS.enc.Base64;
|
|
});
|
|
}
|
|
});
|
|
|
|
export {
|
|
require_enc_base64
|
|
};
|
|
//# sourceMappingURL=chunk-LEGLQYRL.js.map
|