forked from RiseUP/riseup-squad18
2266 lines
76 KiB
JavaScript
2266 lines
76 KiB
JavaScript
import {
|
|
__commonJS,
|
|
__require,
|
|
__toESM
|
|
} from "./chunk-7D4SUZUM.js";
|
|
|
|
// browser-external:crypto
|
|
var require_crypto = __commonJS({
|
|
"browser-external:crypto"(exports, module) {
|
|
module.exports = Object.create(new Proxy({}, {
|
|
get(_2, key) {
|
|
if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") {
|
|
console.warn(`Module "crypto" has been externalized for browser compatibility. Cannot access "crypto.${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
});
|
|
|
|
// node_modules/crypto-js/core.js
|
|
var require_core = __commonJS({
|
|
"node_modules/crypto-js/core.js"(exports, module) {
|
|
(function(root, factory) {
|
|
if (typeof exports === "object") {
|
|
module.exports = exports = factory();
|
|
} else if (typeof define === "function" && define.amd) {
|
|
define([], factory);
|
|
} else {
|
|
root.CryptoJS = factory();
|
|
}
|
|
})(exports, function() {
|
|
var CryptoJS = CryptoJS || function(Math2, undefined2) {
|
|
var crypto2;
|
|
if (typeof window !== "undefined" && window.crypto) {
|
|
crypto2 = window.crypto;
|
|
}
|
|
if (typeof self !== "undefined" && self.crypto) {
|
|
crypto2 = self.crypto;
|
|
}
|
|
if (typeof globalThis !== "undefined" && globalThis.crypto) {
|
|
crypto2 = globalThis.crypto;
|
|
}
|
|
if (!crypto2 && typeof window !== "undefined" && window.msCrypto) {
|
|
crypto2 = window.msCrypto;
|
|
}
|
|
if (!crypto2 && typeof global !== "undefined" && global.crypto) {
|
|
crypto2 = global.crypto;
|
|
}
|
|
if (!crypto2 && typeof __require === "function") {
|
|
try {
|
|
crypto2 = require_crypto();
|
|
} catch (err) {
|
|
}
|
|
}
|
|
var cryptoSecureRandomInt = function() {
|
|
if (crypto2) {
|
|
if (typeof crypto2.getRandomValues === "function") {
|
|
try {
|
|
return crypto2.getRandomValues(new Uint32Array(1))[0];
|
|
} catch (err) {
|
|
}
|
|
}
|
|
if (typeof crypto2.randomBytes === "function") {
|
|
try {
|
|
return crypto2.randomBytes(4).readInt32LE();
|
|
} catch (err) {
|
|
}
|
|
}
|
|
}
|
|
throw new Error("Native crypto module could not be used to get secure random number.");
|
|
};
|
|
var create = Object.create || /* @__PURE__ */ function() {
|
|
function F2() {
|
|
}
|
|
return function(obj) {
|
|
var subtype;
|
|
F2.prototype = obj;
|
|
subtype = new F2();
|
|
F2.prototype = null;
|
|
return subtype;
|
|
};
|
|
}();
|
|
var C2 = {};
|
|
var C_lib = C2.lib = {};
|
|
var Base = C_lib.Base = /* @__PURE__ */ function() {
|
|
return {
|
|
/**
|
|
* Creates a new object that inherits from this object.
|
|
*
|
|
* @param {Object} overrides Properties to copy into the new object.
|
|
*
|
|
* @return {Object} The new object.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var MyType = CryptoJS.lib.Base.extend({
|
|
* field: 'value',
|
|
*
|
|
* method: function () {
|
|
* }
|
|
* });
|
|
*/
|
|
extend: function(overrides) {
|
|
var subtype = create(this);
|
|
if (overrides) {
|
|
subtype.mixIn(overrides);
|
|
}
|
|
if (!subtype.hasOwnProperty("init") || this.init === subtype.init) {
|
|
subtype.init = function() {
|
|
subtype.$super.init.apply(this, arguments);
|
|
};
|
|
}
|
|
subtype.init.prototype = subtype;
|
|
subtype.$super = this;
|
|
return subtype;
|
|
},
|
|
/**
|
|
* Extends this object and runs the init method.
|
|
* Arguments to create() will be passed to init().
|
|
*
|
|
* @return {Object} The new object.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var instance = MyType.create();
|
|
*/
|
|
create: function() {
|
|
var instance = this.extend();
|
|
instance.init.apply(instance, arguments);
|
|
return instance;
|
|
},
|
|
/**
|
|
* Initializes a newly created object.
|
|
* Override this method to add some logic when your objects are created.
|
|
*
|
|
* @example
|
|
*
|
|
* var MyType = CryptoJS.lib.Base.extend({
|
|
* init: function () {
|
|
* // ...
|
|
* }
|
|
* });
|
|
*/
|
|
init: function() {
|
|
},
|
|
/**
|
|
* Copies properties into this object.
|
|
*
|
|
* @param {Object} properties The properties to mix in.
|
|
*
|
|
* @example
|
|
*
|
|
* MyType.mixIn({
|
|
* field: 'value'
|
|
* });
|
|
*/
|
|
mixIn: function(properties) {
|
|
for (var propertyName in properties) {
|
|
if (properties.hasOwnProperty(propertyName)) {
|
|
this[propertyName] = properties[propertyName];
|
|
}
|
|
}
|
|
if (properties.hasOwnProperty("toString")) {
|
|
this.toString = properties.toString;
|
|
}
|
|
},
|
|
/**
|
|
* Creates a copy of this object.
|
|
*
|
|
* @return {Object} The clone.
|
|
*
|
|
* @example
|
|
*
|
|
* var clone = instance.clone();
|
|
*/
|
|
clone: function() {
|
|
return this.init.prototype.extend(this);
|
|
}
|
|
};
|
|
}();
|
|
var WordArray = C_lib.WordArray = Base.extend({
|
|
/**
|
|
* Initializes a newly created word array.
|
|
*
|
|
* @param {Array} words (Optional) An array of 32-bit words.
|
|
* @param {number} sigBytes (Optional) The number of significant bytes in the words.
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.lib.WordArray.create();
|
|
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
|
|
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
|
|
*/
|
|
init: function(words, sigBytes) {
|
|
words = this.words = words || [];
|
|
if (sigBytes != undefined2) {
|
|
this.sigBytes = sigBytes;
|
|
} else {
|
|
this.sigBytes = words.length * 4;
|
|
}
|
|
},
|
|
/**
|
|
* Converts this word array to a string.
|
|
*
|
|
* @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
|
|
*
|
|
* @return {string} The stringified word array.
|
|
*
|
|
* @example
|
|
*
|
|
* var string = wordArray + '';
|
|
* var string = wordArray.toString();
|
|
* var string = wordArray.toString(CryptoJS.enc.Utf8);
|
|
*/
|
|
toString: function(encoder) {
|
|
return (encoder || Hex).stringify(this);
|
|
},
|
|
/**
|
|
* Concatenates a word array to this word array.
|
|
*
|
|
* @param {WordArray} wordArray The word array to append.
|
|
*
|
|
* @return {WordArray} This word array.
|
|
*
|
|
* @example
|
|
*
|
|
* wordArray1.concat(wordArray2);
|
|
*/
|
|
concat: function(wordArray) {
|
|
var thisWords = this.words;
|
|
var thatWords = wordArray.words;
|
|
var thisSigBytes = this.sigBytes;
|
|
var thatSigBytes = wordArray.sigBytes;
|
|
this.clamp();
|
|
if (thisSigBytes % 4) {
|
|
for (var i = 0; i < thatSigBytes; i++) {
|
|
var thatByte = thatWords[i >>> 2] >>> 24 - i % 4 * 8 & 255;
|
|
thisWords[thisSigBytes + i >>> 2] |= thatByte << 24 - (thisSigBytes + i) % 4 * 8;
|
|
}
|
|
} else {
|
|
for (var j2 = 0; j2 < thatSigBytes; j2 += 4) {
|
|
thisWords[thisSigBytes + j2 >>> 2] = thatWords[j2 >>> 2];
|
|
}
|
|
}
|
|
this.sigBytes += thatSigBytes;
|
|
return this;
|
|
},
|
|
/**
|
|
* Removes insignificant bits.
|
|
*
|
|
* @example
|
|
*
|
|
* wordArray.clamp();
|
|
*/
|
|
clamp: function() {
|
|
var words = this.words;
|
|
var sigBytes = this.sigBytes;
|
|
words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
|
|
words.length = Math2.ceil(sigBytes / 4);
|
|
},
|
|
/**
|
|
* Creates a copy of this word array.
|
|
*
|
|
* @return {WordArray} The clone.
|
|
*
|
|
* @example
|
|
*
|
|
* var clone = wordArray.clone();
|
|
*/
|
|
clone: function() {
|
|
var clone = Base.clone.call(this);
|
|
clone.words = this.words.slice(0);
|
|
return clone;
|
|
},
|
|
/**
|
|
* Creates a word array filled with random bytes.
|
|
*
|
|
* @param {number} nBytes The number of random bytes to generate.
|
|
*
|
|
* @return {WordArray} The random word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.lib.WordArray.random(16);
|
|
*/
|
|
random: function(nBytes) {
|
|
var words = [];
|
|
for (var i = 0; i < nBytes; i += 4) {
|
|
words.push(cryptoSecureRandomInt());
|
|
}
|
|
return new WordArray.init(words, nBytes);
|
|
}
|
|
});
|
|
var C_enc = C2.enc = {};
|
|
var Hex = C_enc.Hex = {
|
|
/**
|
|
* Converts a word array to a hex string.
|
|
*
|
|
* @param {WordArray} wordArray The word array.
|
|
*
|
|
* @return {string} The hex string.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var hexString = CryptoJS.enc.Hex.stringify(wordArray);
|
|
*/
|
|
stringify: function(wordArray) {
|
|
var words = wordArray.words;
|
|
var sigBytes = wordArray.sigBytes;
|
|
var hexChars = [];
|
|
for (var i = 0; i < sigBytes; i++) {
|
|
var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
|
|
hexChars.push((bite >>> 4).toString(16));
|
|
hexChars.push((bite & 15).toString(16));
|
|
}
|
|
return hexChars.join("");
|
|
},
|
|
/**
|
|
* Converts a hex string to a word array.
|
|
*
|
|
* @param {string} hexStr The hex string.
|
|
*
|
|
* @return {WordArray} The word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.enc.Hex.parse(hexString);
|
|
*/
|
|
parse: function(hexStr) {
|
|
var hexStrLength = hexStr.length;
|
|
var words = [];
|
|
for (var i = 0; i < hexStrLength; i += 2) {
|
|
words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4;
|
|
}
|
|
return new WordArray.init(words, hexStrLength / 2);
|
|
}
|
|
};
|
|
var Latin1 = C_enc.Latin1 = {
|
|
/**
|
|
* Converts a word array to a Latin1 string.
|
|
*
|
|
* @param {WordArray} wordArray The word array.
|
|
*
|
|
* @return {string} The Latin1 string.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
|
|
*/
|
|
stringify: function(wordArray) {
|
|
var words = wordArray.words;
|
|
var sigBytes = wordArray.sigBytes;
|
|
var latin1Chars = [];
|
|
for (var i = 0; i < sigBytes; i++) {
|
|
var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
|
|
latin1Chars.push(String.fromCharCode(bite));
|
|
}
|
|
return latin1Chars.join("");
|
|
},
|
|
/**
|
|
* Converts a Latin1 string to a word array.
|
|
*
|
|
* @param {string} latin1Str The Latin1 string.
|
|
*
|
|
* @return {WordArray} The word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
|
|
*/
|
|
parse: function(latin1Str) {
|
|
var latin1StrLength = latin1Str.length;
|
|
var words = [];
|
|
for (var i = 0; i < latin1StrLength; i++) {
|
|
words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
|
|
}
|
|
return new WordArray.init(words, latin1StrLength);
|
|
}
|
|
};
|
|
var Utf8 = C_enc.Utf8 = {
|
|
/**
|
|
* Converts a word array to a UTF-8 string.
|
|
*
|
|
* @param {WordArray} wordArray The word array.
|
|
*
|
|
* @return {string} The UTF-8 string.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
|
|
*/
|
|
stringify: function(wordArray) {
|
|
try {
|
|
return decodeURIComponent(escape(Latin1.stringify(wordArray)));
|
|
} catch (e) {
|
|
throw new Error("Malformed UTF-8 data");
|
|
}
|
|
},
|
|
/**
|
|
* Converts a UTF-8 string to a word array.
|
|
*
|
|
* @param {string} utf8Str The UTF-8 string.
|
|
*
|
|
* @return {WordArray} The word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
|
|
*/
|
|
parse: function(utf8Str) {
|
|
return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
|
|
}
|
|
};
|
|
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
|
|
/**
|
|
* Resets this block algorithm's data buffer to its initial state.
|
|
*
|
|
* @example
|
|
*
|
|
* bufferedBlockAlgorithm.reset();
|
|
*/
|
|
reset: function() {
|
|
this._data = new WordArray.init();
|
|
this._nDataBytes = 0;
|
|
},
|
|
/**
|
|
* Adds new data to this block algorithm's buffer.
|
|
*
|
|
* @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
|
|
*
|
|
* @example
|
|
*
|
|
* bufferedBlockAlgorithm._append('data');
|
|
* bufferedBlockAlgorithm._append(wordArray);
|
|
*/
|
|
_append: function(data) {
|
|
if (typeof data == "string") {
|
|
data = Utf8.parse(data);
|
|
}
|
|
this._data.concat(data);
|
|
this._nDataBytes += data.sigBytes;
|
|
},
|
|
/**
|
|
* Processes available data blocks.
|
|
*
|
|
* This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
|
|
*
|
|
* @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
|
|
*
|
|
* @return {WordArray} The processed data.
|
|
*
|
|
* @example
|
|
*
|
|
* var processedData = bufferedBlockAlgorithm._process();
|
|
* var processedData = bufferedBlockAlgorithm._process(!!'flush');
|
|
*/
|
|
_process: function(doFlush) {
|
|
var processedWords;
|
|
var data = this._data;
|
|
var dataWords = data.words;
|
|
var dataSigBytes = data.sigBytes;
|
|
var blockSize = this.blockSize;
|
|
var blockSizeBytes = blockSize * 4;
|
|
var nBlocksReady = dataSigBytes / blockSizeBytes;
|
|
if (doFlush) {
|
|
nBlocksReady = Math2.ceil(nBlocksReady);
|
|
} else {
|
|
nBlocksReady = Math2.max((nBlocksReady | 0) - this._minBufferSize, 0);
|
|
}
|
|
var nWordsReady = nBlocksReady * blockSize;
|
|
var nBytesReady = Math2.min(nWordsReady * 4, dataSigBytes);
|
|
if (nWordsReady) {
|
|
for (var offset = 0; offset < nWordsReady; offset += blockSize) {
|
|
this._doProcessBlock(dataWords, offset);
|
|
}
|
|
processedWords = dataWords.splice(0, nWordsReady);
|
|
data.sigBytes -= nBytesReady;
|
|
}
|
|
return new WordArray.init(processedWords, nBytesReady);
|
|
},
|
|
/**
|
|
* Creates a copy of this object.
|
|
*
|
|
* @return {Object} The clone.
|
|
*
|
|
* @example
|
|
*
|
|
* var clone = bufferedBlockAlgorithm.clone();
|
|
*/
|
|
clone: function() {
|
|
var clone = Base.clone.call(this);
|
|
clone._data = this._data.clone();
|
|
return clone;
|
|
},
|
|
_minBufferSize: 0
|
|
});
|
|
var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
|
|
/**
|
|
* Configuration options.
|
|
*/
|
|
cfg: Base.extend(),
|
|
/**
|
|
* Initializes a newly created hasher.
|
|
*
|
|
* @param {Object} cfg (Optional) The configuration options to use for this hash computation.
|
|
*
|
|
* @example
|
|
*
|
|
* var hasher = CryptoJS.algo.SHA256.create();
|
|
*/
|
|
init: function(cfg) {
|
|
this.cfg = this.cfg.extend(cfg);
|
|
this.reset();
|
|
},
|
|
/**
|
|
* Resets this hasher to its initial state.
|
|
*
|
|
* @example
|
|
*
|
|
* hasher.reset();
|
|
*/
|
|
reset: function() {
|
|
BufferedBlockAlgorithm.reset.call(this);
|
|
this._doReset();
|
|
},
|
|
/**
|
|
* Updates this hasher with a message.
|
|
*
|
|
* @param {WordArray|string} messageUpdate The message to append.
|
|
*
|
|
* @return {Hasher} This hasher.
|
|
*
|
|
* @example
|
|
*
|
|
* hasher.update('message');
|
|
* hasher.update(wordArray);
|
|
*/
|
|
update: function(messageUpdate) {
|
|
this._append(messageUpdate);
|
|
this._process();
|
|
return this;
|
|
},
|
|
/**
|
|
* Finalizes the hash computation.
|
|
* Note that the finalize operation is effectively a destructive, read-once operation.
|
|
*
|
|
* @param {WordArray|string} messageUpdate (Optional) A final message update.
|
|
*
|
|
* @return {WordArray} The hash.
|
|
*
|
|
* @example
|
|
*
|
|
* var hash = hasher.finalize();
|
|
* var hash = hasher.finalize('message');
|
|
* var hash = hasher.finalize(wordArray);
|
|
*/
|
|
finalize: function(messageUpdate) {
|
|
if (messageUpdate) {
|
|
this._append(messageUpdate);
|
|
}
|
|
var hash = this._doFinalize();
|
|
return hash;
|
|
},
|
|
blockSize: 512 / 32,
|
|
/**
|
|
* Creates a shortcut function to a hasher's object interface.
|
|
*
|
|
* @param {Hasher} hasher The hasher to create a helper for.
|
|
*
|
|
* @return {Function} The shortcut function.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
|
|
*/
|
|
_createHelper: function(hasher) {
|
|
return function(message, cfg) {
|
|
return new hasher.init(cfg).finalize(message);
|
|
};
|
|
},
|
|
/**
|
|
* Creates a shortcut function to the HMAC's object interface.
|
|
*
|
|
* @param {Hasher} hasher The hasher to use in this HMAC helper.
|
|
*
|
|
* @return {Function} The shortcut function.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
|
|
*/
|
|
_createHmacHelper: function(hasher) {
|
|
return function(message, key) {
|
|
return new C_algo.HMAC.init(hasher, key).finalize(message);
|
|
};
|
|
}
|
|
});
|
|
var C_algo = C2.algo = {};
|
|
return C2;
|
|
}(Math);
|
|
return CryptoJS;
|
|
});
|
|
}
|
|
});
|
|
|
|
// 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 C2 = CryptoJS;
|
|
var C_lib = C2.lib;
|
|
var WordArray = C_lib.WordArray;
|
|
var C_enc = C2.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 j2 = 0; j2 < 4 && i + j2 * 0.75 < sigBytes; j2++) {
|
|
base64Chars.push(map.charAt(triplet >>> 6 * (3 - j2) & 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 j2 = 0; j2 < map.length; j2++) {
|
|
reverseMap[map.charCodeAt(j2)] = j2;
|
|
}
|
|
}
|
|
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;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/crypto-js/enc-hex.js
|
|
var require_enc_hex = __commonJS({
|
|
"node_modules/crypto-js/enc-hex.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) {
|
|
return CryptoJS.enc.Hex;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/crypto-js/sha256.js
|
|
var require_sha256 = __commonJS({
|
|
"node_modules/crypto-js/sha256.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(Math2) {
|
|
var C2 = CryptoJS;
|
|
var C_lib = C2.lib;
|
|
var WordArray = C_lib.WordArray;
|
|
var Hasher = C_lib.Hasher;
|
|
var C_algo = C2.algo;
|
|
var H2 = [];
|
|
var K2 = [];
|
|
(function() {
|
|
function isPrime(n3) {
|
|
var sqrtN = Math2.sqrt(n3);
|
|
for (var factor = 2; factor <= sqrtN; factor++) {
|
|
if (!(n3 % factor)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getFractionalBits(n3) {
|
|
return (n3 - (n3 | 0)) * 4294967296 | 0;
|
|
}
|
|
var n2 = 2;
|
|
var nPrime = 0;
|
|
while (nPrime < 64) {
|
|
if (isPrime(n2)) {
|
|
if (nPrime < 8) {
|
|
H2[nPrime] = getFractionalBits(Math2.pow(n2, 1 / 2));
|
|
}
|
|
K2[nPrime] = getFractionalBits(Math2.pow(n2, 1 / 3));
|
|
nPrime++;
|
|
}
|
|
n2++;
|
|
}
|
|
})();
|
|
var W2 = [];
|
|
var SHA256 = C_algo.SHA256 = Hasher.extend({
|
|
_doReset: function() {
|
|
this._hash = new WordArray.init(H2.slice(0));
|
|
},
|
|
_doProcessBlock: function(M2, offset) {
|
|
var H3 = this._hash.words;
|
|
var a2 = H3[0];
|
|
var b2 = H3[1];
|
|
var c2 = H3[2];
|
|
var d = H3[3];
|
|
var e = H3[4];
|
|
var f2 = H3[5];
|
|
var g2 = H3[6];
|
|
var h = H3[7];
|
|
for (var i = 0; i < 64; i++) {
|
|
if (i < 16) {
|
|
W2[i] = M2[offset + i] | 0;
|
|
} else {
|
|
var gamma0x = W2[i - 15];
|
|
var gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
|
|
var gamma1x = W2[i - 2];
|
|
var gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
|
|
W2[i] = gamma0 + W2[i - 7] + gamma1 + W2[i - 16];
|
|
}
|
|
var ch = e & f2 ^ ~e & g2;
|
|
var maj = a2 & b2 ^ a2 & c2 ^ b2 & c2;
|
|
var sigma0 = (a2 << 30 | a2 >>> 2) ^ (a2 << 19 | a2 >>> 13) ^ (a2 << 10 | a2 >>> 22);
|
|
var sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
|
|
var t1 = h + sigma1 + ch + K2[i] + W2[i];
|
|
var t2 = sigma0 + maj;
|
|
h = g2;
|
|
g2 = f2;
|
|
f2 = e;
|
|
e = d + t1 | 0;
|
|
d = c2;
|
|
c2 = b2;
|
|
b2 = a2;
|
|
a2 = t1 + t2 | 0;
|
|
}
|
|
H3[0] = H3[0] + a2 | 0;
|
|
H3[1] = H3[1] + b2 | 0;
|
|
H3[2] = H3[2] + c2 | 0;
|
|
H3[3] = H3[3] + d | 0;
|
|
H3[4] = H3[4] + e | 0;
|
|
H3[5] = H3[5] + f2 | 0;
|
|
H3[6] = H3[6] + g2 | 0;
|
|
H3[7] = H3[7] + h | 0;
|
|
},
|
|
_doFinalize: function() {
|
|
var data = this._data;
|
|
var dataWords = data.words;
|
|
var nBitsTotal = this._nDataBytes * 8;
|
|
var nBitsLeft = data.sigBytes * 8;
|
|
dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
|
|
dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math2.floor(nBitsTotal / 4294967296);
|
|
dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
|
|
data.sigBytes = dataWords.length * 4;
|
|
this._process();
|
|
return this._hash;
|
|
},
|
|
clone: function() {
|
|
var clone = Hasher.clone.call(this);
|
|
clone._hash = this._hash.clone();
|
|
return clone;
|
|
}
|
|
});
|
|
C2.SHA256 = Hasher._createHelper(SHA256);
|
|
C2.HmacSHA256 = Hasher._createHmacHelper(SHA256);
|
|
})(Math);
|
|
return CryptoJS.SHA256;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/crypto-js/hmac.js
|
|
var require_hmac = __commonJS({
|
|
"node_modules/crypto-js/hmac.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 C2 = CryptoJS;
|
|
var C_lib = C2.lib;
|
|
var Base = C_lib.Base;
|
|
var C_enc = C2.enc;
|
|
var Utf8 = C_enc.Utf8;
|
|
var C_algo = C2.algo;
|
|
var HMAC = C_algo.HMAC = Base.extend({
|
|
/**
|
|
* Initializes a newly created HMAC.
|
|
*
|
|
* @param {Hasher} hasher The hash algorithm to use.
|
|
* @param {WordArray|string} key The secret key.
|
|
*
|
|
* @example
|
|
*
|
|
* var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
|
|
*/
|
|
init: function(hasher, key) {
|
|
hasher = this._hasher = new hasher.init();
|
|
if (typeof key == "string") {
|
|
key = Utf8.parse(key);
|
|
}
|
|
var hasherBlockSize = hasher.blockSize;
|
|
var hasherBlockSizeBytes = hasherBlockSize * 4;
|
|
if (key.sigBytes > hasherBlockSizeBytes) {
|
|
key = hasher.finalize(key);
|
|
}
|
|
key.clamp();
|
|
var oKey = this._oKey = key.clone();
|
|
var iKey = this._iKey = key.clone();
|
|
var oKeyWords = oKey.words;
|
|
var iKeyWords = iKey.words;
|
|
for (var i = 0; i < hasherBlockSize; i++) {
|
|
oKeyWords[i] ^= 1549556828;
|
|
iKeyWords[i] ^= 909522486;
|
|
}
|
|
oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
|
|
this.reset();
|
|
},
|
|
/**
|
|
* Resets this HMAC to its initial state.
|
|
*
|
|
* @example
|
|
*
|
|
* hmacHasher.reset();
|
|
*/
|
|
reset: function() {
|
|
var hasher = this._hasher;
|
|
hasher.reset();
|
|
hasher.update(this._iKey);
|
|
},
|
|
/**
|
|
* Updates this HMAC with a message.
|
|
*
|
|
* @param {WordArray|string} messageUpdate The message to append.
|
|
*
|
|
* @return {HMAC} This HMAC instance.
|
|
*
|
|
* @example
|
|
*
|
|
* hmacHasher.update('message');
|
|
* hmacHasher.update(wordArray);
|
|
*/
|
|
update: function(messageUpdate) {
|
|
this._hasher.update(messageUpdate);
|
|
return this;
|
|
},
|
|
/**
|
|
* Finalizes the HMAC computation.
|
|
* Note that the finalize operation is effectively a destructive, read-once operation.
|
|
*
|
|
* @param {WordArray|string} messageUpdate (Optional) A final message update.
|
|
*
|
|
* @return {WordArray} The HMAC.
|
|
*
|
|
* @example
|
|
*
|
|
* var hmac = hmacHasher.finalize();
|
|
* var hmac = hmacHasher.finalize('message');
|
|
* var hmac = hmacHasher.finalize(wordArray);
|
|
*/
|
|
finalize: function(messageUpdate) {
|
|
var hasher = this._hasher;
|
|
var innerHash = hasher.finalize(messageUpdate);
|
|
hasher.reset();
|
|
var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
|
|
return hmac;
|
|
}
|
|
});
|
|
})();
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/crypto-js/hmac-sha256.js
|
|
var require_hmac_sha256 = __commonJS({
|
|
"node_modules/crypto-js/hmac-sha256.js"(exports, module) {
|
|
(function(root, factory, undef) {
|
|
if (typeof exports === "object") {
|
|
module.exports = exports = factory(require_core(), require_sha256(), require_hmac());
|
|
} else if (typeof define === "function" && define.amd) {
|
|
define(["./core", "./sha256", "./hmac"], factory);
|
|
} else {
|
|
factory(root.CryptoJS);
|
|
}
|
|
})(exports, function(CryptoJS) {
|
|
return CryptoJS.HmacSHA256;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/uuid/dist/esm-browser/regex.js
|
|
var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
|
|
|
|
// node_modules/uuid/dist/esm-browser/validate.js
|
|
function validate(uuid) {
|
|
return typeof uuid === "string" && regex_default.test(uuid);
|
|
}
|
|
var validate_default = validate;
|
|
|
|
// node_modules/uuid/dist/esm-browser/parse.js
|
|
function parse(uuid) {
|
|
if (!validate_default(uuid)) {
|
|
throw TypeError("Invalid UUID");
|
|
}
|
|
let v2;
|
|
return Uint8Array.of((v2 = parseInt(uuid.slice(0, 8), 16)) >>> 24, v2 >>> 16 & 255, v2 >>> 8 & 255, v2 & 255, (v2 = parseInt(uuid.slice(9, 13), 16)) >>> 8, v2 & 255, (v2 = parseInt(uuid.slice(14, 18), 16)) >>> 8, v2 & 255, (v2 = parseInt(uuid.slice(19, 23), 16)) >>> 8, v2 & 255, (v2 = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v2 / 4294967296 & 255, v2 >>> 24 & 255, v2 >>> 16 & 255, v2 >>> 8 & 255, v2 & 255);
|
|
}
|
|
var parse_default = parse;
|
|
|
|
// node_modules/uuid/dist/esm-browser/stringify.js
|
|
var byteToHex = [];
|
|
for (let i = 0; i < 256; ++i) {
|
|
byteToHex.push((i + 256).toString(16).slice(1));
|
|
}
|
|
function unsafeStringify(arr, offset = 0) {
|
|
return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
|
|
}
|
|
|
|
// node_modules/uuid/dist/esm-browser/rng.js
|
|
var getRandomValues;
|
|
var rnds8 = new Uint8Array(16);
|
|
function rng() {
|
|
if (!getRandomValues) {
|
|
if (typeof crypto === "undefined" || !crypto.getRandomValues) {
|
|
throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
|
|
}
|
|
getRandomValues = crypto.getRandomValues.bind(crypto);
|
|
}
|
|
return getRandomValues(rnds8);
|
|
}
|
|
|
|
// node_modules/uuid/dist/esm-browser/md5.js
|
|
function md5(bytes) {
|
|
const words = uint8ToUint32(bytes);
|
|
const md5Bytes = wordsToMd5(words, bytes.length * 8);
|
|
return uint32ToUint8(md5Bytes);
|
|
}
|
|
function uint32ToUint8(input) {
|
|
const bytes = new Uint8Array(input.length * 4);
|
|
for (let i = 0; i < input.length * 4; i++) {
|
|
bytes[i] = input[i >> 2] >>> i % 4 * 8 & 255;
|
|
}
|
|
return bytes;
|
|
}
|
|
function getOutputLength(inputLength8) {
|
|
return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
|
|
}
|
|
function wordsToMd5(x, len) {
|
|
const xpad = new Uint32Array(getOutputLength(len)).fill(0);
|
|
xpad.set(x);
|
|
xpad[len >> 5] |= 128 << len % 32;
|
|
xpad[xpad.length - 1] = len;
|
|
x = xpad;
|
|
let a2 = 1732584193;
|
|
let b2 = -271733879;
|
|
let c2 = -1732584194;
|
|
let d = 271733878;
|
|
for (let i = 0; i < x.length; i += 16) {
|
|
const olda = a2;
|
|
const oldb = b2;
|
|
const oldc = c2;
|
|
const oldd = d;
|
|
a2 = md5ff(a2, b2, c2, d, x[i], 7, -680876936);
|
|
d = md5ff(d, a2, b2, c2, x[i + 1], 12, -389564586);
|
|
c2 = md5ff(c2, d, a2, b2, x[i + 2], 17, 606105819);
|
|
b2 = md5ff(b2, c2, d, a2, x[i + 3], 22, -1044525330);
|
|
a2 = md5ff(a2, b2, c2, d, x[i + 4], 7, -176418897);
|
|
d = md5ff(d, a2, b2, c2, x[i + 5], 12, 1200080426);
|
|
c2 = md5ff(c2, d, a2, b2, x[i + 6], 17, -1473231341);
|
|
b2 = md5ff(b2, c2, d, a2, x[i + 7], 22, -45705983);
|
|
a2 = md5ff(a2, b2, c2, d, x[i + 8], 7, 1770035416);
|
|
d = md5ff(d, a2, b2, c2, x[i + 9], 12, -1958414417);
|
|
c2 = md5ff(c2, d, a2, b2, x[i + 10], 17, -42063);
|
|
b2 = md5ff(b2, c2, d, a2, x[i + 11], 22, -1990404162);
|
|
a2 = md5ff(a2, b2, c2, d, x[i + 12], 7, 1804603682);
|
|
d = md5ff(d, a2, b2, c2, x[i + 13], 12, -40341101);
|
|
c2 = md5ff(c2, d, a2, b2, x[i + 14], 17, -1502002290);
|
|
b2 = md5ff(b2, c2, d, a2, x[i + 15], 22, 1236535329);
|
|
a2 = md5gg(a2, b2, c2, d, x[i + 1], 5, -165796510);
|
|
d = md5gg(d, a2, b2, c2, x[i + 6], 9, -1069501632);
|
|
c2 = md5gg(c2, d, a2, b2, x[i + 11], 14, 643717713);
|
|
b2 = md5gg(b2, c2, d, a2, x[i], 20, -373897302);
|
|
a2 = md5gg(a2, b2, c2, d, x[i + 5], 5, -701558691);
|
|
d = md5gg(d, a2, b2, c2, x[i + 10], 9, 38016083);
|
|
c2 = md5gg(c2, d, a2, b2, x[i + 15], 14, -660478335);
|
|
b2 = md5gg(b2, c2, d, a2, x[i + 4], 20, -405537848);
|
|
a2 = md5gg(a2, b2, c2, d, x[i + 9], 5, 568446438);
|
|
d = md5gg(d, a2, b2, c2, x[i + 14], 9, -1019803690);
|
|
c2 = md5gg(c2, d, a2, b2, x[i + 3], 14, -187363961);
|
|
b2 = md5gg(b2, c2, d, a2, x[i + 8], 20, 1163531501);
|
|
a2 = md5gg(a2, b2, c2, d, x[i + 13], 5, -1444681467);
|
|
d = md5gg(d, a2, b2, c2, x[i + 2], 9, -51403784);
|
|
c2 = md5gg(c2, d, a2, b2, x[i + 7], 14, 1735328473);
|
|
b2 = md5gg(b2, c2, d, a2, x[i + 12], 20, -1926607734);
|
|
a2 = md5hh(a2, b2, c2, d, x[i + 5], 4, -378558);
|
|
d = md5hh(d, a2, b2, c2, x[i + 8], 11, -2022574463);
|
|
c2 = md5hh(c2, d, a2, b2, x[i + 11], 16, 1839030562);
|
|
b2 = md5hh(b2, c2, d, a2, x[i + 14], 23, -35309556);
|
|
a2 = md5hh(a2, b2, c2, d, x[i + 1], 4, -1530992060);
|
|
d = md5hh(d, a2, b2, c2, x[i + 4], 11, 1272893353);
|
|
c2 = md5hh(c2, d, a2, b2, x[i + 7], 16, -155497632);
|
|
b2 = md5hh(b2, c2, d, a2, x[i + 10], 23, -1094730640);
|
|
a2 = md5hh(a2, b2, c2, d, x[i + 13], 4, 681279174);
|
|
d = md5hh(d, a2, b2, c2, x[i], 11, -358537222);
|
|
c2 = md5hh(c2, d, a2, b2, x[i + 3], 16, -722521979);
|
|
b2 = md5hh(b2, c2, d, a2, x[i + 6], 23, 76029189);
|
|
a2 = md5hh(a2, b2, c2, d, x[i + 9], 4, -640364487);
|
|
d = md5hh(d, a2, b2, c2, x[i + 12], 11, -421815835);
|
|
c2 = md5hh(c2, d, a2, b2, x[i + 15], 16, 530742520);
|
|
b2 = md5hh(b2, c2, d, a2, x[i + 2], 23, -995338651);
|
|
a2 = md5ii(a2, b2, c2, d, x[i], 6, -198630844);
|
|
d = md5ii(d, a2, b2, c2, x[i + 7], 10, 1126891415);
|
|
c2 = md5ii(c2, d, a2, b2, x[i + 14], 15, -1416354905);
|
|
b2 = md5ii(b2, c2, d, a2, x[i + 5], 21, -57434055);
|
|
a2 = md5ii(a2, b2, c2, d, x[i + 12], 6, 1700485571);
|
|
d = md5ii(d, a2, b2, c2, x[i + 3], 10, -1894986606);
|
|
c2 = md5ii(c2, d, a2, b2, x[i + 10], 15, -1051523);
|
|
b2 = md5ii(b2, c2, d, a2, x[i + 1], 21, -2054922799);
|
|
a2 = md5ii(a2, b2, c2, d, x[i + 8], 6, 1873313359);
|
|
d = md5ii(d, a2, b2, c2, x[i + 15], 10, -30611744);
|
|
c2 = md5ii(c2, d, a2, b2, x[i + 6], 15, -1560198380);
|
|
b2 = md5ii(b2, c2, d, a2, x[i + 13], 21, 1309151649);
|
|
a2 = md5ii(a2, b2, c2, d, x[i + 4], 6, -145523070);
|
|
d = md5ii(d, a2, b2, c2, x[i + 11], 10, -1120210379);
|
|
c2 = md5ii(c2, d, a2, b2, x[i + 2], 15, 718787259);
|
|
b2 = md5ii(b2, c2, d, a2, x[i + 9], 21, -343485551);
|
|
a2 = safeAdd(a2, olda);
|
|
b2 = safeAdd(b2, oldb);
|
|
c2 = safeAdd(c2, oldc);
|
|
d = safeAdd(d, oldd);
|
|
}
|
|
return Uint32Array.of(a2, b2, c2, d);
|
|
}
|
|
function uint8ToUint32(input) {
|
|
if (input.length === 0) {
|
|
return new Uint32Array();
|
|
}
|
|
const output = new Uint32Array(getOutputLength(input.length * 8)).fill(0);
|
|
for (let i = 0; i < input.length; i++) {
|
|
output[i >> 2] |= (input[i] & 255) << i % 4 * 8;
|
|
}
|
|
return output;
|
|
}
|
|
function safeAdd(x, y2) {
|
|
const lsw = (x & 65535) + (y2 & 65535);
|
|
const msw = (x >> 16) + (y2 >> 16) + (lsw >> 16);
|
|
return msw << 16 | lsw & 65535;
|
|
}
|
|
function bitRotateLeft(num, cnt) {
|
|
return num << cnt | num >>> 32 - cnt;
|
|
}
|
|
function md5cmn(q2, a2, b2, x, s, t) {
|
|
return safeAdd(bitRotateLeft(safeAdd(safeAdd(a2, q2), safeAdd(x, t)), s), b2);
|
|
}
|
|
function md5ff(a2, b2, c2, d, x, s, t) {
|
|
return md5cmn(b2 & c2 | ~b2 & d, a2, b2, x, s, t);
|
|
}
|
|
function md5gg(a2, b2, c2, d, x, s, t) {
|
|
return md5cmn(b2 & d | c2 & ~d, a2, b2, x, s, t);
|
|
}
|
|
function md5hh(a2, b2, c2, d, x, s, t) {
|
|
return md5cmn(b2 ^ c2 ^ d, a2, b2, x, s, t);
|
|
}
|
|
function md5ii(a2, b2, c2, d, x, s, t) {
|
|
return md5cmn(c2 ^ (b2 | ~d), a2, b2, x, s, t);
|
|
}
|
|
var md5_default = md5;
|
|
|
|
// node_modules/uuid/dist/esm-browser/v35.js
|
|
function stringToBytes(str) {
|
|
str = unescape(encodeURIComponent(str));
|
|
const bytes = new Uint8Array(str.length);
|
|
for (let i = 0; i < str.length; ++i) {
|
|
bytes[i] = str.charCodeAt(i);
|
|
}
|
|
return bytes;
|
|
}
|
|
var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
|
|
var URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
|
|
function v35(version, hash, value, namespace, buf, offset) {
|
|
const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
|
|
const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
|
|
if (typeof namespace === "string") {
|
|
namespace = parse_default(namespace);
|
|
}
|
|
if ((namespace == null ? void 0 : namespace.length) !== 16) {
|
|
throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
|
|
}
|
|
let bytes = new Uint8Array(16 + valueBytes.length);
|
|
bytes.set(namespaceBytes);
|
|
bytes.set(valueBytes, namespaceBytes.length);
|
|
bytes = hash(bytes);
|
|
bytes[6] = bytes[6] & 15 | version;
|
|
bytes[8] = bytes[8] & 63 | 128;
|
|
if (buf) {
|
|
offset = offset || 0;
|
|
for (let i = 0; i < 16; ++i) {
|
|
buf[offset + i] = bytes[i];
|
|
}
|
|
return buf;
|
|
}
|
|
return unsafeStringify(bytes);
|
|
}
|
|
|
|
// node_modules/uuid/dist/esm-browser/v3.js
|
|
function v3(value, namespace, buf, offset) {
|
|
return v35(48, md5_default, value, namespace, buf, offset);
|
|
}
|
|
v3.DNS = DNS;
|
|
v3.URL = URL;
|
|
|
|
// node_modules/uuid/dist/esm-browser/native.js
|
|
var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
|
|
var native_default = { randomUUID };
|
|
|
|
// node_modules/uuid/dist/esm-browser/v4.js
|
|
function v4(options, buf, offset) {
|
|
var _a;
|
|
if (native_default.randomUUID && !buf && !options) {
|
|
return native_default.randomUUID();
|
|
}
|
|
options = options || {};
|
|
const rnds = options.random ?? ((_a = options.rng) == null ? void 0 : _a.call(options)) ?? rng();
|
|
if (rnds.length < 16) {
|
|
throw new Error("Random bytes length must be >= 16");
|
|
}
|
|
rnds[6] = rnds[6] & 15 | 64;
|
|
rnds[8] = rnds[8] & 63 | 128;
|
|
if (buf) {
|
|
offset = offset || 0;
|
|
if (offset < 0 || offset + 16 > buf.length) {
|
|
throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
|
|
}
|
|
for (let i = 0; i < 16; ++i) {
|
|
buf[offset + i] = rnds[i];
|
|
}
|
|
return buf;
|
|
}
|
|
return unsafeStringify(rnds);
|
|
}
|
|
var v4_default = v4;
|
|
|
|
// node_modules/uuid/dist/esm-browser/sha1.js
|
|
function f(s, x, y2, z2) {
|
|
switch (s) {
|
|
case 0:
|
|
return x & y2 ^ ~x & z2;
|
|
case 1:
|
|
return x ^ y2 ^ z2;
|
|
case 2:
|
|
return x & y2 ^ x & z2 ^ y2 & z2;
|
|
case 3:
|
|
return x ^ y2 ^ z2;
|
|
}
|
|
}
|
|
function ROTL(x, n2) {
|
|
return x << n2 | x >>> 32 - n2;
|
|
}
|
|
function sha1(bytes) {
|
|
const K2 = [1518500249, 1859775393, 2400959708, 3395469782];
|
|
const H2 = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
|
|
const newBytes = new Uint8Array(bytes.length + 1);
|
|
newBytes.set(bytes);
|
|
newBytes[bytes.length] = 128;
|
|
bytes = newBytes;
|
|
const l = bytes.length / 4 + 2;
|
|
const N2 = Math.ceil(l / 16);
|
|
const M2 = new Array(N2);
|
|
for (let i = 0; i < N2; ++i) {
|
|
const arr = new Uint32Array(16);
|
|
for (let j2 = 0; j2 < 16; ++j2) {
|
|
arr[j2] = bytes[i * 64 + j2 * 4] << 24 | bytes[i * 64 + j2 * 4 + 1] << 16 | bytes[i * 64 + j2 * 4 + 2] << 8 | bytes[i * 64 + j2 * 4 + 3];
|
|
}
|
|
M2[i] = arr;
|
|
}
|
|
M2[N2 - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
|
|
M2[N2 - 1][14] = Math.floor(M2[N2 - 1][14]);
|
|
M2[N2 - 1][15] = (bytes.length - 1) * 8 & 4294967295;
|
|
for (let i = 0; i < N2; ++i) {
|
|
const W2 = new Uint32Array(80);
|
|
for (let t = 0; t < 16; ++t) {
|
|
W2[t] = M2[i][t];
|
|
}
|
|
for (let t = 16; t < 80; ++t) {
|
|
W2[t] = ROTL(W2[t - 3] ^ W2[t - 8] ^ W2[t - 14] ^ W2[t - 16], 1);
|
|
}
|
|
let a2 = H2[0];
|
|
let b2 = H2[1];
|
|
let c2 = H2[2];
|
|
let d = H2[3];
|
|
let e = H2[4];
|
|
for (let t = 0; t < 80; ++t) {
|
|
const s = Math.floor(t / 20);
|
|
const T = ROTL(a2, 5) + f(s, b2, c2, d) + e + K2[s] + W2[t] >>> 0;
|
|
e = d;
|
|
d = c2;
|
|
c2 = ROTL(b2, 30) >>> 0;
|
|
b2 = a2;
|
|
a2 = T;
|
|
}
|
|
H2[0] = H2[0] + a2 >>> 0;
|
|
H2[1] = H2[1] + b2 >>> 0;
|
|
H2[2] = H2[2] + c2 >>> 0;
|
|
H2[3] = H2[3] + d >>> 0;
|
|
H2[4] = H2[4] + e >>> 0;
|
|
}
|
|
return Uint8Array.of(H2[0] >> 24, H2[0] >> 16, H2[0] >> 8, H2[0], H2[1] >> 24, H2[1] >> 16, H2[1] >> 8, H2[1], H2[2] >> 24, H2[2] >> 16, H2[2] >> 8, H2[2], H2[3] >> 24, H2[3] >> 16, H2[3] >> 8, H2[3], H2[4] >> 24, H2[4] >> 16, H2[4] >> 8, H2[4]);
|
|
}
|
|
var sha1_default = sha1;
|
|
|
|
// node_modules/uuid/dist/esm-browser/v5.js
|
|
function v5(value, namespace, buf, offset) {
|
|
return v35(80, sha1_default, value, namespace, buf, offset);
|
|
}
|
|
v5.DNS = DNS;
|
|
v5.URL = URL;
|
|
|
|
// node_modules/@lumi.new/sdk/dist/index.mjs
|
|
var import_enc_base64 = __toESM(require_enc_base64(), 1);
|
|
var import_enc_hex = __toESM(require_enc_hex(), 1);
|
|
var import_hmac_sha256 = __toESM(require_hmac_sha256(), 1);
|
|
var import_sha256 = __toESM(require_sha256(), 1);
|
|
|
|
// node_modules/destr/dist/index.mjs
|
|
var suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
|
|
var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
|
|
var JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
|
|
function jsonParseTransform(key, value) {
|
|
if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
|
|
warnKeyDropped(key);
|
|
return;
|
|
}
|
|
return value;
|
|
}
|
|
function warnKeyDropped(key) {
|
|
console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
|
|
}
|
|
function destr(value, options = {}) {
|
|
if (typeof value !== "string") {
|
|
return value;
|
|
}
|
|
if (value[0] === '"' && value[value.length - 1] === '"' && value.indexOf("\\") === -1) {
|
|
return value.slice(1, -1);
|
|
}
|
|
const _value = value.trim();
|
|
if (_value.length <= 9) {
|
|
switch (_value.toLowerCase()) {
|
|
case "true": {
|
|
return true;
|
|
}
|
|
case "false": {
|
|
return false;
|
|
}
|
|
case "undefined": {
|
|
return void 0;
|
|
}
|
|
case "null": {
|
|
return null;
|
|
}
|
|
case "nan": {
|
|
return Number.NaN;
|
|
}
|
|
case "infinity": {
|
|
return Number.POSITIVE_INFINITY;
|
|
}
|
|
case "-infinity": {
|
|
return Number.NEGATIVE_INFINITY;
|
|
}
|
|
}
|
|
}
|
|
if (!JsonSigRx.test(value)) {
|
|
if (options.strict) {
|
|
throw new SyntaxError("[destr] Invalid JSON");
|
|
}
|
|
return value;
|
|
}
|
|
try {
|
|
if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
|
|
if (options.strict) {
|
|
throw new Error("[destr] Possible prototype pollution");
|
|
}
|
|
return JSON.parse(value, jsonParseTransform);
|
|
}
|
|
return JSON.parse(value);
|
|
} catch (error) {
|
|
if (options.strict) {
|
|
throw error;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
|
|
// node_modules/ufo/dist/index.mjs
|
|
var r = String.fromCharCode;
|
|
var HASH_RE = /#/g;
|
|
var AMPERSAND_RE = /&/g;
|
|
var SLASH_RE = /\//g;
|
|
var EQUAL_RE = /=/g;
|
|
var PLUS_RE = /\+/g;
|
|
var ENC_CARET_RE = /%5e/gi;
|
|
var ENC_BACKTICK_RE = /%60/gi;
|
|
var ENC_PIPE_RE = /%7c/gi;
|
|
var ENC_SPACE_RE = /%20/gi;
|
|
function encode(text) {
|
|
return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
|
|
}
|
|
function encodeQueryValue(input) {
|
|
return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
|
|
}
|
|
function encodeQueryKey(text) {
|
|
return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
|
|
}
|
|
function decode(text = "") {
|
|
try {
|
|
return decodeURIComponent("" + text);
|
|
} catch {
|
|
return "" + text;
|
|
}
|
|
}
|
|
function decodeQueryKey(text) {
|
|
return decode(text.replace(PLUS_RE, " "));
|
|
}
|
|
function decodeQueryValue(text) {
|
|
return decode(text.replace(PLUS_RE, " "));
|
|
}
|
|
function parseQuery(parametersString = "") {
|
|
const object = /* @__PURE__ */ Object.create(null);
|
|
if (parametersString[0] === "?") {
|
|
parametersString = parametersString.slice(1);
|
|
}
|
|
for (const parameter of parametersString.split("&")) {
|
|
const s = parameter.match(/([^=]+)=?(.*)/) || [];
|
|
if (s.length < 2) {
|
|
continue;
|
|
}
|
|
const key = decodeQueryKey(s[1]);
|
|
if (key === "__proto__" || key === "constructor") {
|
|
continue;
|
|
}
|
|
const value = decodeQueryValue(s[2] || "");
|
|
if (object[key] === void 0) {
|
|
object[key] = value;
|
|
} else if (Array.isArray(object[key])) {
|
|
object[key].push(value);
|
|
} else {
|
|
object[key] = [object[key], value];
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
function encodeQueryItem(key, value) {
|
|
if (typeof value === "number" || typeof value === "boolean") {
|
|
value = String(value);
|
|
}
|
|
if (!value) {
|
|
return encodeQueryKey(key);
|
|
}
|
|
if (Array.isArray(value)) {
|
|
return value.map(
|
|
(_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`
|
|
).join("&");
|
|
}
|
|
return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
|
|
}
|
|
function stringifyQuery(query) {
|
|
return Object.keys(query).filter((k2) => query[k2] !== void 0).map((k2) => encodeQueryItem(k2, query[k2])).filter(Boolean).join("&");
|
|
}
|
|
var PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
|
|
var PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
|
|
var PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
|
|
var TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
|
|
var JOIN_LEADING_SLASH_RE = /^\.?\//;
|
|
function hasProtocol(inputString, opts = {}) {
|
|
if (typeof opts === "boolean") {
|
|
opts = { acceptRelative: opts };
|
|
}
|
|
if (opts.strict) {
|
|
return PROTOCOL_STRICT_REGEX.test(inputString);
|
|
}
|
|
return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
|
|
}
|
|
function hasTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return input.endsWith("/");
|
|
}
|
|
return TRAILING_SLASH_RE.test(input);
|
|
}
|
|
function withoutTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
|
|
}
|
|
if (!hasTrailingSlash(input, true)) {
|
|
return input || "/";
|
|
}
|
|
let path = input;
|
|
let fragment = "";
|
|
const fragmentIndex = input.indexOf("#");
|
|
if (fragmentIndex !== -1) {
|
|
path = input.slice(0, fragmentIndex);
|
|
fragment = input.slice(fragmentIndex);
|
|
}
|
|
const [s0, ...s] = path.split("?");
|
|
const cleanPath = s0.endsWith("/") ? s0.slice(0, -1) : s0;
|
|
return (cleanPath || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
|
|
}
|
|
function withTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return input.endsWith("/") ? input : input + "/";
|
|
}
|
|
if (hasTrailingSlash(input, true)) {
|
|
return input || "/";
|
|
}
|
|
let path = input;
|
|
let fragment = "";
|
|
const fragmentIndex = input.indexOf("#");
|
|
if (fragmentIndex !== -1) {
|
|
path = input.slice(0, fragmentIndex);
|
|
fragment = input.slice(fragmentIndex);
|
|
if (!path) {
|
|
return fragment;
|
|
}
|
|
}
|
|
const [s0, ...s] = path.split("?");
|
|
return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
|
|
}
|
|
function withBase(input, base) {
|
|
if (isEmptyURL(base) || hasProtocol(input)) {
|
|
return input;
|
|
}
|
|
const _base = withoutTrailingSlash(base);
|
|
if (input.startsWith(_base)) {
|
|
return input;
|
|
}
|
|
return joinURL(_base, input);
|
|
}
|
|
function withQuery(input, query) {
|
|
const parsed = parseURL(input);
|
|
const mergedQuery = { ...parseQuery(parsed.search), ...query };
|
|
parsed.search = stringifyQuery(mergedQuery);
|
|
return stringifyParsedURL(parsed);
|
|
}
|
|
function isEmptyURL(url) {
|
|
return !url || url === "/";
|
|
}
|
|
function isNonEmptyURL(url) {
|
|
return url && url !== "/";
|
|
}
|
|
function joinURL(base, ...input) {
|
|
let url = base || "";
|
|
for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
|
|
if (url) {
|
|
const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
|
|
url = withTrailingSlash(url) + _segment;
|
|
} else {
|
|
url = segment;
|
|
}
|
|
}
|
|
return url;
|
|
}
|
|
var protocolRelative = Symbol.for("ufo:protocolRelative");
|
|
function parseURL(input = "", defaultProto) {
|
|
const _specialProtoMatch = input.match(
|
|
/^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
|
|
);
|
|
if (_specialProtoMatch) {
|
|
const [, _proto, _pathname = ""] = _specialProtoMatch;
|
|
return {
|
|
protocol: _proto.toLowerCase(),
|
|
pathname: _pathname,
|
|
href: _proto + _pathname,
|
|
auth: "",
|
|
host: "",
|
|
search: "",
|
|
hash: ""
|
|
};
|
|
}
|
|
if (!hasProtocol(input, { acceptRelative: true })) {
|
|
return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
|
|
}
|
|
const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
|
|
let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
|
|
if (protocol === "file:") {
|
|
path = path.replace(/\/(?=[A-Za-z]:)/, "");
|
|
}
|
|
const { pathname, search, hash } = parsePath(path);
|
|
return {
|
|
protocol: protocol.toLowerCase(),
|
|
auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
|
|
host,
|
|
pathname,
|
|
search,
|
|
hash,
|
|
[protocolRelative]: !protocol
|
|
};
|
|
}
|
|
function parsePath(input = "") {
|
|
const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
|
|
return {
|
|
pathname,
|
|
search,
|
|
hash
|
|
};
|
|
}
|
|
function stringifyParsedURL(parsed) {
|
|
const pathname = parsed.pathname || "";
|
|
const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
|
|
const hash = parsed.hash || "";
|
|
const auth = parsed.auth ? parsed.auth + "@" : "";
|
|
const host = parsed.host || "";
|
|
const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
|
|
return proto + auth + host + pathname + search + hash;
|
|
}
|
|
|
|
// node_modules/ofetch/dist/shared/ofetch.03887fc3.mjs
|
|
var FetchError = class extends Error {
|
|
constructor(message, opts) {
|
|
super(message, opts);
|
|
this.name = "FetchError";
|
|
if ((opts == null ? void 0 : opts.cause) && !this.cause) {
|
|
this.cause = opts.cause;
|
|
}
|
|
}
|
|
};
|
|
function createFetchError(ctx) {
|
|
var _a, _b, _c, _d, _e2;
|
|
const errorMessage = ((_a = ctx.error) == null ? void 0 : _a.message) || ((_b = ctx.error) == null ? void 0 : _b.toString()) || "";
|
|
const method = ((_c = ctx.request) == null ? void 0 : _c.method) || ((_d = ctx.options) == null ? void 0 : _d.method) || "GET";
|
|
const url = ((_e2 = ctx.request) == null ? void 0 : _e2.url) || String(ctx.request) || "/";
|
|
const requestStr = `[${method}] ${JSON.stringify(url)}`;
|
|
const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
|
|
const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
|
|
const fetchError = new FetchError(
|
|
message,
|
|
ctx.error ? { cause: ctx.error } : void 0
|
|
);
|
|
for (const key of ["request", "options", "response"]) {
|
|
Object.defineProperty(fetchError, key, {
|
|
get() {
|
|
return ctx[key];
|
|
}
|
|
});
|
|
}
|
|
for (const [key, refKey] of [
|
|
["data", "_data"],
|
|
["status", "status"],
|
|
["statusCode", "status"],
|
|
["statusText", "statusText"],
|
|
["statusMessage", "statusText"]
|
|
]) {
|
|
Object.defineProperty(fetchError, key, {
|
|
get() {
|
|
return ctx.response && ctx.response[refKey];
|
|
}
|
|
});
|
|
}
|
|
return fetchError;
|
|
}
|
|
var payloadMethods = new Set(
|
|
Object.freeze(["PATCH", "POST", "PUT", "DELETE"])
|
|
);
|
|
function isPayloadMethod(method = "GET") {
|
|
return payloadMethods.has(method.toUpperCase());
|
|
}
|
|
function isJSONSerializable(value) {
|
|
if (value === void 0) {
|
|
return false;
|
|
}
|
|
const t = typeof value;
|
|
if (t === "string" || t === "number" || t === "boolean" || t === null) {
|
|
return true;
|
|
}
|
|
if (t !== "object") {
|
|
return false;
|
|
}
|
|
if (Array.isArray(value)) {
|
|
return true;
|
|
}
|
|
if (value.buffer) {
|
|
return false;
|
|
}
|
|
return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
|
|
}
|
|
var textTypes = /* @__PURE__ */ new Set([
|
|
"image/svg",
|
|
"application/xml",
|
|
"application/xhtml",
|
|
"application/html"
|
|
]);
|
|
var JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
|
|
function detectResponseType(_contentType = "") {
|
|
if (!_contentType) {
|
|
return "json";
|
|
}
|
|
const contentType = _contentType.split(";").shift() || "";
|
|
if (JSON_RE.test(contentType)) {
|
|
return "json";
|
|
}
|
|
if (textTypes.has(contentType) || contentType.startsWith("text/")) {
|
|
return "text";
|
|
}
|
|
return "blob";
|
|
}
|
|
function resolveFetchOptions(request, input, defaults, Headers3) {
|
|
const headers = mergeHeaders(
|
|
(input == null ? void 0 : input.headers) ?? (request == null ? void 0 : request.headers),
|
|
defaults == null ? void 0 : defaults.headers,
|
|
Headers3
|
|
);
|
|
let query;
|
|
if ((defaults == null ? void 0 : defaults.query) || (defaults == null ? void 0 : defaults.params) || (input == null ? void 0 : input.params) || (input == null ? void 0 : input.query)) {
|
|
query = {
|
|
...defaults == null ? void 0 : defaults.params,
|
|
...defaults == null ? void 0 : defaults.query,
|
|
...input == null ? void 0 : input.params,
|
|
...input == null ? void 0 : input.query
|
|
};
|
|
}
|
|
return {
|
|
...defaults,
|
|
...input,
|
|
query,
|
|
params: query,
|
|
headers
|
|
};
|
|
}
|
|
function mergeHeaders(input, defaults, Headers3) {
|
|
if (!defaults) {
|
|
return new Headers3(input);
|
|
}
|
|
const headers = new Headers3(defaults);
|
|
if (input) {
|
|
for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers3(input)) {
|
|
headers.set(key, value);
|
|
}
|
|
}
|
|
return headers;
|
|
}
|
|
async function callHooks(context, hooks) {
|
|
if (hooks) {
|
|
if (Array.isArray(hooks)) {
|
|
for (const hook of hooks) {
|
|
await hook(context);
|
|
}
|
|
} else {
|
|
await hooks(context);
|
|
}
|
|
}
|
|
}
|
|
var retryStatusCodes = /* @__PURE__ */ new Set([
|
|
408,
|
|
// Request Timeout
|
|
409,
|
|
// Conflict
|
|
425,
|
|
// Too Early (Experimental)
|
|
429,
|
|
// Too Many Requests
|
|
500,
|
|
// Internal Server Error
|
|
502,
|
|
// Bad Gateway
|
|
503,
|
|
// Service Unavailable
|
|
504
|
|
// Gateway Timeout
|
|
]);
|
|
var nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
|
|
function createFetch(globalOptions = {}) {
|
|
const {
|
|
fetch: fetch2 = globalThis.fetch,
|
|
Headers: Headers3 = globalThis.Headers,
|
|
AbortController: AbortController2 = globalThis.AbortController
|
|
} = globalOptions;
|
|
async function onError(context) {
|
|
const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
|
|
if (context.options.retry !== false && !isAbort) {
|
|
let retries;
|
|
if (typeof context.options.retry === "number") {
|
|
retries = context.options.retry;
|
|
} else {
|
|
retries = isPayloadMethod(context.options.method) ? 0 : 1;
|
|
}
|
|
const responseCode = context.response && context.response.status || 500;
|
|
if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
|
|
const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
|
|
if (retryDelay > 0) {
|
|
await new Promise((resolve) => setTimeout(resolve, retryDelay));
|
|
}
|
|
return $fetchRaw(context.request, {
|
|
...context.options,
|
|
retry: retries - 1
|
|
});
|
|
}
|
|
}
|
|
const error = createFetchError(context);
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(error, $fetchRaw);
|
|
}
|
|
throw error;
|
|
}
|
|
const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
|
|
const context = {
|
|
request: _request,
|
|
options: resolveFetchOptions(
|
|
_request,
|
|
_options,
|
|
globalOptions.defaults,
|
|
Headers3
|
|
),
|
|
response: void 0,
|
|
error: void 0
|
|
};
|
|
if (context.options.method) {
|
|
context.options.method = context.options.method.toUpperCase();
|
|
}
|
|
if (context.options.onRequest) {
|
|
await callHooks(context, context.options.onRequest);
|
|
}
|
|
if (typeof context.request === "string") {
|
|
if (context.options.baseURL) {
|
|
context.request = withBase(context.request, context.options.baseURL);
|
|
}
|
|
if (context.options.query) {
|
|
context.request = withQuery(context.request, context.options.query);
|
|
delete context.options.query;
|
|
}
|
|
if ("query" in context.options) {
|
|
delete context.options.query;
|
|
}
|
|
if ("params" in context.options) {
|
|
delete context.options.params;
|
|
}
|
|
}
|
|
if (context.options.body && isPayloadMethod(context.options.method)) {
|
|
if (isJSONSerializable(context.options.body)) {
|
|
context.options.body = typeof context.options.body === "string" ? context.options.body : JSON.stringify(context.options.body);
|
|
context.options.headers = new Headers3(context.options.headers || {});
|
|
if (!context.options.headers.has("content-type")) {
|
|
context.options.headers.set("content-type", "application/json");
|
|
}
|
|
if (!context.options.headers.has("accept")) {
|
|
context.options.headers.set("accept", "application/json");
|
|
}
|
|
} else if (
|
|
// ReadableStream Body
|
|
"pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || // Node.js Stream Body
|
|
typeof context.options.body.pipe === "function"
|
|
) {
|
|
if (!("duplex" in context.options)) {
|
|
context.options.duplex = "half";
|
|
}
|
|
}
|
|
}
|
|
let abortTimeout;
|
|
if (!context.options.signal && context.options.timeout) {
|
|
const controller = new AbortController2();
|
|
abortTimeout = setTimeout(() => {
|
|
const error = new Error(
|
|
"[TimeoutError]: The operation was aborted due to timeout"
|
|
);
|
|
error.name = "TimeoutError";
|
|
error.code = 23;
|
|
controller.abort(error);
|
|
}, context.options.timeout);
|
|
context.options.signal = controller.signal;
|
|
}
|
|
try {
|
|
context.response = await fetch2(
|
|
context.request,
|
|
context.options
|
|
);
|
|
} catch (error) {
|
|
context.error = error;
|
|
if (context.options.onRequestError) {
|
|
await callHooks(
|
|
context,
|
|
context.options.onRequestError
|
|
);
|
|
}
|
|
return await onError(context);
|
|
} finally {
|
|
if (abortTimeout) {
|
|
clearTimeout(abortTimeout);
|
|
}
|
|
}
|
|
const hasBody = (context.response.body || // https://github.com/unjs/ofetch/issues/324
|
|
// https://github.com/unjs/ofetch/issues/294
|
|
// https://github.com/JakeChampion/fetch/issues/1454
|
|
context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
|
|
if (hasBody) {
|
|
const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
|
|
switch (responseType) {
|
|
case "json": {
|
|
const data = await context.response.text();
|
|
const parseFunction = context.options.parseResponse || destr;
|
|
context.response._data = parseFunction(data);
|
|
break;
|
|
}
|
|
case "stream": {
|
|
context.response._data = context.response.body || context.response._bodyInit;
|
|
break;
|
|
}
|
|
default: {
|
|
context.response._data = await context.response[responseType]();
|
|
}
|
|
}
|
|
}
|
|
if (context.options.onResponse) {
|
|
await callHooks(
|
|
context,
|
|
context.options.onResponse
|
|
);
|
|
}
|
|
if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
|
|
if (context.options.onResponseError) {
|
|
await callHooks(
|
|
context,
|
|
context.options.onResponseError
|
|
);
|
|
}
|
|
return await onError(context);
|
|
}
|
|
return context.response;
|
|
};
|
|
const $fetch = async function $fetch2(request, options) {
|
|
const r2 = await $fetchRaw(request, options);
|
|
return r2._data;
|
|
};
|
|
$fetch.raw = $fetchRaw;
|
|
$fetch.native = (...args) => fetch2(...args);
|
|
$fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
|
|
...globalOptions,
|
|
...customGlobalOptions,
|
|
defaults: {
|
|
...globalOptions.defaults,
|
|
...customGlobalOptions.defaults,
|
|
...defaultOptions
|
|
}
|
|
});
|
|
return $fetch;
|
|
}
|
|
|
|
// node_modules/ofetch/dist/index.mjs
|
|
var _globalThis = function() {
|
|
if (typeof globalThis !== "undefined") {
|
|
return globalThis;
|
|
}
|
|
if (typeof self !== "undefined") {
|
|
return self;
|
|
}
|
|
if (typeof window !== "undefined") {
|
|
return window;
|
|
}
|
|
if (typeof global !== "undefined") {
|
|
return global;
|
|
}
|
|
throw new Error("unable to locate global object");
|
|
}();
|
|
var fetch = _globalThis.fetch ? (...args) => _globalThis.fetch(...args) : () => Promise.reject(new Error("[ofetch] global.fetch is not supported!"));
|
|
var Headers2 = _globalThis.Headers;
|
|
var AbortController = _globalThis.AbortController;
|
|
var ofetch = createFetch({ fetch, Headers: Headers2, AbortController });
|
|
|
|
// node_modules/@lumi.new/sdk/dist/index.mjs
|
|
var V = Object.defineProperty;
|
|
var G = Object.defineProperties;
|
|
var Y = Object.getOwnPropertyDescriptors;
|
|
var q = Object.getOwnPropertySymbols;
|
|
var z = Object.prototype.hasOwnProperty;
|
|
var Z = Object.prototype.propertyIsEnumerable;
|
|
var F = (i) => {
|
|
throw TypeError(i);
|
|
};
|
|
var j = (i, e, t) => e in i ? V(i, e, { enumerable: true, configurable: true, writable: true, value: t }) : i[e] = t;
|
|
var A = (i, e) => {
|
|
for (var t in e || (e = {})) z.call(e, t) && j(i, t, e[t]);
|
|
if (q) for (var t of q(e)) Z.call(e, t) && j(i, t, e[t]);
|
|
return i;
|
|
};
|
|
var H = (i, e) => G(i, Y(e));
|
|
var K = (i, e, t) => e.has(i) || F("Cannot " + t);
|
|
var n = (i, e, t) => (K(i, e, "read from private field"), t ? t.call(i) : e.get(i));
|
|
var u = (i, e, t) => e.has(i) ? F("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(i) : e.set(i, t);
|
|
var g = (i, e, t, r2) => (K(i, e, "write to private field"), r2 ? r2.call(i, t) : e.set(i, t), t);
|
|
var c = (i, e, t) => new Promise((r2, o) => {
|
|
var s = (p) => {
|
|
try {
|
|
h(t.next(p));
|
|
} catch (f2) {
|
|
o(f2);
|
|
}
|
|
}, l = (p) => {
|
|
try {
|
|
h(t.throw(p));
|
|
} catch (f2) {
|
|
o(f2);
|
|
}
|
|
}, h = (p) => p.done ? r2(p.value) : Promise.resolve(p.value).then(s, l);
|
|
h((t = t.apply(i, e)).next());
|
|
});
|
|
var re = "6QrJZ7pFCmBZAeIJF7IArvkCz+EtzA0RVcpHkiQIsQyhs7QtCS9P+CueZdHfB2OtJcgX3BbqY9pfpWeAVTqCwQ==";
|
|
function _(i) {
|
|
return encodeURIComponent(i).replace(/[!'()*]/g, (e) => `%${e.charCodeAt(0).toString(16).toUpperCase()}`);
|
|
}
|
|
function ne(i) {
|
|
return (e) => {
|
|
let { options: t } = e, r2 = Math.floor(Date.now() / 1e3).toString(), o = Math.random().toString(36).substring(2, 15), s = A({}, t.query), l = Object.keys(s).sort().map((w) => `${_(w)}=${_(String(s[w]))}`).join("&"), h = { "x-timestamp": r2, "x-nonce": o }, p = Object.keys(h).sort().map((w) => `${w}:${h[w]}`).join(`
|
|
`), f2 = t.body && !(t.body instanceof FormData) ? JSON.stringify(t.body) : "", x = (0, import_sha256.default)(f2).toString(import_enc_hex.default), S = [l, p, x].join(`
|
|
`);
|
|
console.warn(`Client-side Canonical Request V3:
|
|
`, S);
|
|
let d = import_enc_base64.default.stringify((0, import_hmac_sha256.default)(S, i)), T = new Headers(t.headers);
|
|
Object.entries(h).forEach(([w, Q]) => {
|
|
T.set(w, Q);
|
|
}), T.set("X-Sign", d), t.headers = T;
|
|
};
|
|
}
|
|
function a(i, e, t = {}) {
|
|
return i.auth.accessToken && (t.headers = A({ Authorization: `Bearer ${i.auth.accessToken}` }, t.headers)), ofetch(e, H(A({ baseURL: i.config.apiBaseUrl }, t), { onRequest: ne(re) }));
|
|
}
|
|
function B() {
|
|
var i, e;
|
|
return (e = (i = document.querySelector('link[rel="icon"]')) == null ? void 0 : i.href) != null ? e : null;
|
|
}
|
|
function J() {
|
|
var i;
|
|
return (i = document.title) != null ? i : null;
|
|
}
|
|
function k(i, e, t = localStorage) {
|
|
let r2 = t.getItem(i), o = e ? JSON.stringify(e) : null;
|
|
o ? t.setItem(i, o) : t.removeItem(i), window.dispatchEvent(new StorageEvent("storage", { key: i, oldValue: r2, newValue: o, storageArea: t }));
|
|
}
|
|
function N(i, e = localStorage) {
|
|
let t = e.getItem(i);
|
|
try {
|
|
return t ? JSON.parse(t) : null;
|
|
} catch (r2) {
|
|
return null;
|
|
}
|
|
}
|
|
var y;
|
|
var R;
|
|
var L = class {
|
|
constructor(e) {
|
|
u(this, y);
|
|
u(this, R, `lumi-auth-${v4_default()}`);
|
|
g(this, y, e);
|
|
}
|
|
get accessToken() {
|
|
return N("lumi-access-token");
|
|
}
|
|
set accessToken(e) {
|
|
k("lumi-access-token", e);
|
|
}
|
|
get user() {
|
|
return N("lumi-user");
|
|
}
|
|
set user(e) {
|
|
k("lumi-user", e);
|
|
}
|
|
get isAuthenticated() {
|
|
return !!this.accessToken;
|
|
}
|
|
signIn() {
|
|
let r2 = (window.screen.width - 800) / 2, o = (window.screen.height - 600) / 2, s = window.open(n(this, y).config.authOrigin, n(this, R), `width=800,height=600,left=${r2},top=${o}`), l;
|
|
return new Promise((h, p) => {
|
|
if (!s) return p(new Error("Open auth window failed"));
|
|
let f2 = setInterval(() => {
|
|
s.closed && p(new Error("Auth window closed"));
|
|
}, 1e3), x = (d) => {
|
|
s.closed || (s.focus(), d.stopPropagation(), d.preventDefault());
|
|
}, S = ({ data: d, origin: T, source: w }) => {
|
|
if (!(T !== n(this, y).config.authOrigin || w !== s)) switch (d == null ? void 0 : d.type) {
|
|
case "lumi-ready": {
|
|
s.postMessage({ type: "lumi-init", data: { projectId: n(this, y).config.projectId, icon: B(), title: J() } }, n(this, y).config.authOrigin);
|
|
break;
|
|
}
|
|
case "lumi-sign-in": {
|
|
if (d.data.projectId !== n(this, y).config.projectId) break;
|
|
s.close(), window.focus(), this.accessToken = d.data.accessToken, this.user = d.data.user, h(d.data);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
window.addEventListener("message", S), document.addEventListener("click", x, true), l = () => {
|
|
clearInterval(f2), window.removeEventListener("message", S), document.removeEventListener("click", x, true);
|
|
};
|
|
}).finally(() => l == null ? void 0 : l());
|
|
}
|
|
signOut() {
|
|
this.accessToken = null, this.user = null;
|
|
}
|
|
refreshUser() {
|
|
return c(this, null, function* () {
|
|
let e = yield a(n(this, y), "/lm/user/info", { method: "POST" });
|
|
if (e.code !== 200) throw new Error(e.message);
|
|
return this.user = e.data, e.data;
|
|
});
|
|
}
|
|
onAuthChange(e) {
|
|
let t = (r2) => {
|
|
(r2.key === "lumi-access-token" || r2.key === "lumi-user" || r2.key === null) && e({ isAuthenticated: this.isAuthenticated, user: this.user });
|
|
};
|
|
return window.addEventListener("storage", t), () => {
|
|
window.removeEventListener("storage", t);
|
|
};
|
|
}
|
|
};
|
|
y = /* @__PURE__ */ new WeakMap(), R = /* @__PURE__ */ new WeakMap();
|
|
var m;
|
|
var v = class {
|
|
constructor(e, t) {
|
|
u(this, m);
|
|
g(this, m, e), this.entityName = t;
|
|
}
|
|
list() {
|
|
return c(this, arguments, function* ({ filter: e, sort: t, limit: r2, skip: o } = {}) {
|
|
if (r2) {
|
|
let s = yield a(n(this, m), this.uri("/find"), { method: "POST", body: { filter: e, sort: t, limit: r2, skip: o } });
|
|
if (s.code !== 200) throw new Error(s.message);
|
|
return s.data;
|
|
} else {
|
|
let s = yield a(n(this, m), this.uri("/list"), { method: "POST", body: { filter: e, sort: t } });
|
|
if (s.code !== 200) throw new Error(s.message);
|
|
return { total: s.data.length, list: s.data };
|
|
}
|
|
});
|
|
}
|
|
get(e) {
|
|
return c(this, null, function* () {
|
|
let t = yield a(n(this, m), this.uri(`/${e}`), { method: "GET" });
|
|
if (t.code !== 200) throw new Error(t.message);
|
|
return t.data;
|
|
});
|
|
}
|
|
create(e) {
|
|
return c(this, null, function* () {
|
|
let t = yield a(n(this, m), this.uri(), { method: "POST", body: e });
|
|
if (t.code !== 200) throw new Error(t.message);
|
|
return t.data;
|
|
});
|
|
}
|
|
createMany(e) {
|
|
return c(this, null, function* () {
|
|
let t = yield a(n(this, m), this.uri("/batch"), { method: "POST", body: e });
|
|
if (t.code !== 200) throw new Error(t.message);
|
|
return t.data;
|
|
});
|
|
}
|
|
update(e, t) {
|
|
return c(this, null, function* () {
|
|
let r2 = yield a(n(this, m), this.uri(), { method: "PUT", body: { filter: { _id: e }, update: t } });
|
|
if (r2.code !== 200) throw new Error(r2.message);
|
|
return r2.data;
|
|
});
|
|
}
|
|
delete(e) {
|
|
return c(this, null, function* () {
|
|
let t = yield a(n(this, m), this.uri(`/${e}`), { method: "DELETE" });
|
|
if (t.code !== 200) throw new Error(t.message);
|
|
});
|
|
}
|
|
deleteMany(e) {
|
|
return c(this, null, function* () {
|
|
let t = yield a(n(this, m), this.uri("/batch-by-ids"), { method: "DELETE", params: { ids: e } });
|
|
if (t.code !== 200) throw new Error(t.message);
|
|
});
|
|
}
|
|
uri(e = "") {
|
|
return `/lm/${n(this, m).config.projectId}/${this.entityName}/documents${e}`;
|
|
}
|
|
};
|
|
m = /* @__PURE__ */ new WeakMap();
|
|
var I;
|
|
var P = class {
|
|
constructor(e) {
|
|
u(this, I);
|
|
return g(this, I, e), new Proxy(this, { get(t, r2) {
|
|
return r2 in t || (t[r2] = new v(n(t, I), r2)), t[r2];
|
|
} });
|
|
}
|
|
};
|
|
I = /* @__PURE__ */ new WeakMap();
|
|
var b = class extends Error {
|
|
constructor(t, r2) {
|
|
super(r2);
|
|
this.name = "LumiError";
|
|
this.code = t;
|
|
}
|
|
};
|
|
var C;
|
|
var O = class {
|
|
constructor(e) {
|
|
u(this, C);
|
|
g(this, C, e);
|
|
}
|
|
send(p) {
|
|
return c(this, arguments, function* ({ to: e, subject: t, fromName: r2, html: o, text: s = "", replyTo: l, scheduledAt: h }) {
|
|
if (!e || !t || !o && !s) throw new Error("Failed to send email: Missing required parameters.");
|
|
typeof e == "string" && (e = [e]), typeof l == "string" && (l = [l]);
|
|
let f2 = yield a(n(this, C), `/lm/${n(this, C).config.projectId}/email/send`, { method: "POST", body: { to: e, subject: t, fromName: r2, html: o, text: s, replyTo: l, scheduledAt: h } });
|
|
if (f2.code !== 200) throw new b(f2.code, f2.message);
|
|
});
|
|
}
|
|
};
|
|
C = /* @__PURE__ */ new WeakMap();
|
|
var E;
|
|
var D = class {
|
|
constructor(e) {
|
|
u(this, E);
|
|
g(this, E, e);
|
|
}
|
|
upload(e) {
|
|
return c(this, null, function* () {
|
|
let t = new FormData();
|
|
e.forEach((o) => {
|
|
t.append("files", o);
|
|
});
|
|
let r2 = yield a(n(this, E), `/lm/${n(this, E).config.projectId}/file/batch`, { method: "POST", body: t });
|
|
if (r2.code !== 200) throw new b(r2.code, r2.message);
|
|
return r2.data;
|
|
});
|
|
}
|
|
delete(e) {
|
|
return c(this, null, function* () {
|
|
let t = yield a(n(this, E), `/lm/${n(this, E).config.projectId}/file/batch`, { method: "DELETE", body: { fileUrls: e } });
|
|
if (t.code !== 200) throw new b(t.code, t.message);
|
|
});
|
|
}
|
|
};
|
|
E = /* @__PURE__ */ new WeakMap();
|
|
var U;
|
|
var M = class {
|
|
constructor(e) {
|
|
u(this, U);
|
|
g(this, U, e), this.email = new O(e), this.file = new D(e);
|
|
}
|
|
};
|
|
U = /* @__PURE__ */ new WeakMap();
|
|
var $ = class {
|
|
constructor(e) {
|
|
this.config = e, this.auth = new L(this), this.entities = new P(this), this.tools = new M(this);
|
|
}
|
|
};
|
|
function _e(i) {
|
|
return new $(i);
|
|
}
|
|
export {
|
|
O as EmailTool,
|
|
P as EntitiesClient,
|
|
v as EntityClient,
|
|
D as FileTool,
|
|
L as LumiAuthClient,
|
|
$ as LumiClient,
|
|
M as ToolsClient,
|
|
_e as createClient
|
|
};
|
|
//# sourceMappingURL=@lumi__new_sdk.js.map
|