@kevisual/api 0.0.42 → 0.0.44

package/dist/query-resources.js

@@ -0,0 +1,1734 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/core.js
+var require_core = __commonJS((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 crypto;
+      if (typeof window !== "undefined" && window.crypto) {
+        crypto = window.crypto;
+      }
+      if (typeof self !== "undefined" && self.crypto) {
+        crypto = self.crypto;
+      }
+      if (typeof globalThis !== "undefined" && globalThis.crypto) {
+        crypto = globalThis.crypto;
+      }
+      if (!crypto && typeof window !== "undefined" && window.msCrypto) {
+        crypto = window.msCrypto;
+      }
+      if (!crypto && typeof global !== "undefined" && global.crypto) {
+        crypto = global.crypto;
+      }
+      if (!crypto && true) {
+        try {
+          crypto = __require("crypto");
+        } catch (err) {}
+      }
+      var cryptoSecureRandomInt = function() {
+        if (crypto) {
+          if (typeof crypto.getRandomValues === "function") {
+            try {
+              return crypto.getRandomValues(new Uint32Array(1))[0];
+            } catch (err) {}
+          }
+          if (typeof crypto.randomBytes === "function") {
+            try {
+              return crypto.randomBytes(4).readInt32LE();
+            } catch (err) {}
+          }
+        }
+        throw new Error("Native crypto module could not be used to get secure random number.");
+      };
+      var create = Object.create || function() {
+        function F() {}
+        return function(obj) {
+          var subtype;
+          F.prototype = obj;
+          subtype = new F;
+          F.prototype = null;
+          return subtype;
+        };
+      }();
+      var C = {};
+      var C_lib = C.lib = {};
+      var Base = C_lib.Base = function() {
+        return {
+          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;
+          },
+          create: function() {
+            var instance = this.extend();
+            instance.init.apply(instance, arguments);
+            return instance;
+          },
+          init: function() {},
+          mixIn: function(properties) {
+            for (var propertyName in properties) {
+              if (properties.hasOwnProperty(propertyName)) {
+                this[propertyName] = properties[propertyName];
+              }
+            }
+            if (properties.hasOwnProperty("toString")) {
+              this.toString = properties.toString;
+            }
+          },
+          clone: function() {
+            return this.init.prototype.extend(this);
+          }
+        };
+      }();
+      var WordArray = C_lib.WordArray = Base.extend({
+        init: function(words, sigBytes) {
+          words = this.words = words || [];
+          if (sigBytes != undefined2) {
+            this.sigBytes = sigBytes;
+          } else {
+            this.sigBytes = words.length * 4;
+          }
+        },
+        toString: function(encoder) {
+          return (encoder || Hex).stringify(this);
+        },
+        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 j = 0;j < thatSigBytes; j += 4) {
+              thisWords[thisSigBytes + j >>> 2] = thatWords[j >>> 2];
+            }
+          }
+          this.sigBytes += thatSigBytes;
+          return this;
+        },
+        clamp: function() {
+          var words = this.words;
+          var sigBytes = this.sigBytes;
+          words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
+          words.length = Math2.ceil(sigBytes / 4);
+        },
+        clone: function() {
+          var clone = Base.clone.call(this);
+          clone.words = this.words.slice(0);
+          return clone;
+        },
+        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 = C.enc = {};
+      var Hex = C_enc.Hex = {
+        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("");
+        },
+        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 = {
+        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("");
+        },
+        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 = {
+        stringify: function(wordArray) {
+          try {
+            return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+          } catch (e) {
+            throw new Error("Malformed UTF-8 data");
+          }
+        },
+        parse: function(utf8Str) {
+          return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+        }
+      };
+      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+        reset: function() {
+          this._data = new WordArray.init;
+          this._nDataBytes = 0;
+        },
+        _append: function(data) {
+          if (typeof data == "string") {
+            data = Utf8.parse(data);
+          }
+          this._data.concat(data);
+          this._nDataBytes += data.sigBytes;
+        },
+        _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);
+        },
+        clone: function() {
+          var clone = Base.clone.call(this);
+          clone._data = this._data.clone();
+          return clone;
+        },
+        _minBufferSize: 0
+      });
+      var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+        cfg: Base.extend(),
+        init: function(cfg) {
+          this.cfg = this.cfg.extend(cfg);
+          this.reset();
+        },
+        reset: function() {
+          BufferedBlockAlgorithm.reset.call(this);
+          this._doReset();
+        },
+        update: function(messageUpdate) {
+          this._append(messageUpdate);
+          this._process();
+          return this;
+        },
+        finalize: function(messageUpdate) {
+          if (messageUpdate) {
+            this._append(messageUpdate);
+          }
+          var hash = this._doFinalize();
+          return hash;
+        },
+        blockSize: 512 / 32,
+        _createHelper: function(hasher) {
+          return function(message, cfg) {
+            return new hasher.init(cfg).finalize(message);
+          };
+        },
+        _createHmacHelper: function(hasher) {
+          return function(message, key) {
+            return new C_algo.HMAC.init(hasher, key).finalize(message);
+          };
+        }
+      });
+      var C_algo = C.algo = {};
+      return C;
+    }(Math);
+    return CryptoJS;
+  });
+});
+
+// node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/md5.js
+var require_md5 = __commonJS((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 C = CryptoJS;
+      var C_lib = C.lib;
+      var WordArray = C_lib.WordArray;
+      var Hasher = C_lib.Hasher;
+      var C_algo = C.algo;
+      var T = [];
+      (function() {
+        for (var i = 0;i < 64; i++) {
+          T[i] = Math2.abs(Math2.sin(i + 1)) * 4294967296 | 0;
+        }
+      })();
+      var MD5 = C_algo.MD5 = Hasher.extend({
+        _doReset: function() {
+          this._hash = new WordArray.init([
+            1732584193,
+            4023233417,
+            2562383102,
+            271733878
+          ]);
+        },
+        _doProcessBlock: function(M, offset) {
+          for (var i = 0;i < 16; i++) {
+            var offset_i = offset + i;
+            var M_offset_i = M[offset_i];
+            M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
+          }
+          var H = this._hash.words;
+          var M_offset_0 = M[offset + 0];
+          var M_offset_1 = M[offset + 1];
+          var M_offset_2 = M[offset + 2];
+          var M_offset_3 = M[offset + 3];
+          var M_offset_4 = M[offset + 4];
+          var M_offset_5 = M[offset + 5];
+          var M_offset_6 = M[offset + 6];
+          var M_offset_7 = M[offset + 7];
+          var M_offset_8 = M[offset + 8];
+          var M_offset_9 = M[offset + 9];
+          var M_offset_10 = M[offset + 10];
+          var M_offset_11 = M[offset + 11];
+          var M_offset_12 = M[offset + 12];
+          var M_offset_13 = M[offset + 13];
+          var M_offset_14 = M[offset + 14];
+          var M_offset_15 = M[offset + 15];
+          var a = H[0];
+          var b = H[1];
+          var c = H[2];
+          var d = H[3];
+          a = FF(a, b, c, d, M_offset_0, 7, T[0]);
+          d = FF(d, a, b, c, M_offset_1, 12, T[1]);
+          c = FF(c, d, a, b, M_offset_2, 17, T[2]);
+          b = FF(b, c, d, a, M_offset_3, 22, T[3]);
+          a = FF(a, b, c, d, M_offset_4, 7, T[4]);
+          d = FF(d, a, b, c, M_offset_5, 12, T[5]);
+          c = FF(c, d, a, b, M_offset_6, 17, T[6]);
+          b = FF(b, c, d, a, M_offset_7, 22, T[7]);
+          a = FF(a, b, c, d, M_offset_8, 7, T[8]);
+          d = FF(d, a, b, c, M_offset_9, 12, T[9]);
+          c = FF(c, d, a, b, M_offset_10, 17, T[10]);
+          b = FF(b, c, d, a, M_offset_11, 22, T[11]);
+          a = FF(a, b, c, d, M_offset_12, 7, T[12]);
+          d = FF(d, a, b, c, M_offset_13, 12, T[13]);
+          c = FF(c, d, a, b, M_offset_14, 17, T[14]);
+          b = FF(b, c, d, a, M_offset_15, 22, T[15]);
+          a = GG(a, b, c, d, M_offset_1, 5, T[16]);
+          d = GG(d, a, b, c, M_offset_6, 9, T[17]);
+          c = GG(c, d, a, b, M_offset_11, 14, T[18]);
+          b = GG(b, c, d, a, M_offset_0, 20, T[19]);
+          a = GG(a, b, c, d, M_offset_5, 5, T[20]);
+          d = GG(d, a, b, c, M_offset_10, 9, T[21]);
+          c = GG(c, d, a, b, M_offset_15, 14, T[22]);
+          b = GG(b, c, d, a, M_offset_4, 20, T[23]);
+          a = GG(a, b, c, d, M_offset_9, 5, T[24]);
+          d = GG(d, a, b, c, M_offset_14, 9, T[25]);
+          c = GG(c, d, a, b, M_offset_3, 14, T[26]);
+          b = GG(b, c, d, a, M_offset_8, 20, T[27]);
+          a = GG(a, b, c, d, M_offset_13, 5, T[28]);
+          d = GG(d, a, b, c, M_offset_2, 9, T[29]);
+          c = GG(c, d, a, b, M_offset_7, 14, T[30]);
+          b = GG(b, c, d, a, M_offset_12, 20, T[31]);
+          a = HH(a, b, c, d, M_offset_5, 4, T[32]);
+          d = HH(d, a, b, c, M_offset_8, 11, T[33]);
+          c = HH(c, d, a, b, M_offset_11, 16, T[34]);
+          b = HH(b, c, d, a, M_offset_14, 23, T[35]);
+          a = HH(a, b, c, d, M_offset_1, 4, T[36]);
+          d = HH(d, a, b, c, M_offset_4, 11, T[37]);
+          c = HH(c, d, a, b, M_offset_7, 16, T[38]);
+          b = HH(b, c, d, a, M_offset_10, 23, T[39]);
+          a = HH(a, b, c, d, M_offset_13, 4, T[40]);
+          d = HH(d, a, b, c, M_offset_0, 11, T[41]);
+          c = HH(c, d, a, b, M_offset_3, 16, T[42]);
+          b = HH(b, c, d, a, M_offset_6, 23, T[43]);
+          a = HH(a, b, c, d, M_offset_9, 4, T[44]);
+          d = HH(d, a, b, c, M_offset_12, 11, T[45]);
+          c = HH(c, d, a, b, M_offset_15, 16, T[46]);
+          b = HH(b, c, d, a, M_offset_2, 23, T[47]);
+          a = II(a, b, c, d, M_offset_0, 6, T[48]);
+          d = II(d, a, b, c, M_offset_7, 10, T[49]);
+          c = II(c, d, a, b, M_offset_14, 15, T[50]);
+          b = II(b, c, d, a, M_offset_5, 21, T[51]);
+          a = II(a, b, c, d, M_offset_12, 6, T[52]);
+          d = II(d, a, b, c, M_offset_3, 10, T[53]);
+          c = II(c, d, a, b, M_offset_10, 15, T[54]);
+          b = II(b, c, d, a, M_offset_1, 21, T[55]);
+          a = II(a, b, c, d, M_offset_8, 6, T[56]);
+          d = II(d, a, b, c, M_offset_15, 10, T[57]);
+          c = II(c, d, a, b, M_offset_6, 15, T[58]);
+          b = II(b, c, d, a, M_offset_13, 21, T[59]);
+          a = II(a, b, c, d, M_offset_4, 6, T[60]);
+          d = II(d, a, b, c, M_offset_11, 10, T[61]);
+          c = II(c, d, a, b, M_offset_2, 15, T[62]);
+          b = II(b, c, d, a, M_offset_9, 21, T[63]);
+          H[0] = H[0] + a | 0;
+          H[1] = H[1] + b | 0;
+          H[2] = H[2] + c | 0;
+          H[3] = H[3] + d | 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;
+          var nBitsTotalH = Math2.floor(nBitsTotal / 4294967296);
+          var nBitsTotalL = nBitsTotal;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
+          data.sigBytes = (dataWords.length + 1) * 4;
+          this._process();
+          var hash = this._hash;
+          var H = hash.words;
+          for (var i = 0;i < 4; i++) {
+            var H_i = H[i];
+            H[i] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
+          }
+          return hash;
+        },
+        clone: function() {
+          var clone = Hasher.clone.call(this);
+          clone._hash = this._hash.clone();
+          return clone;
+        }
+      });
+      function FF(a, b, c, d, x, s, t) {
+        var n = a + (b & c | ~b & d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function GG(a, b, c, d, x, s, t) {
+        var n = a + (b & d | c & ~d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function HH(a, b, c, d, x, s, t) {
+        var n = a + (b ^ c ^ d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function II(a, b, c, d, x, s, t) {
+        var n = a + (c ^ (b | ~d)) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      C.MD5 = Hasher._createHelper(MD5);
+      C.HmacMD5 = Hasher._createHmacHelper(MD5);
+    })(Math);
+    return CryptoJS.MD5;
+  });
+});
+
+// node_modules/.pnpm/spark-md5@3.0.2/node_modules/spark-md5/spark-md5.js
+var require_spark_md5 = __commonJS((exports, module) => {
+  (function(factory) {
+    if (typeof exports === "object") {
+      module.exports = factory();
+    } else if (typeof define === "function" && define.amd) {
+      define(factory);
+    } else {
+      var glob;
+      try {
+        glob = window;
+      } catch (e) {
+        glob = self;
+      }
+      glob.SparkMD5 = factory();
+    }
+  })(function(undefined2) {
+    var add32 = function(a, b) {
+      return a + b & 4294967295;
+    }, hex_chr = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+    function cmn(q, a, b, x, s, t) {
+      a = add32(add32(a, q), add32(x, t));
+      return add32(a << s | a >>> 32 - s, b);
+    }
+    function md5cycle(x, k) {
+      var a = x[0], b = x[1], c = x[2], d = x[3];
+      a += (b & c | ~b & d) + k[0] - 680876936 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[1] - 389564586 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[2] + 606105819 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[4] - 176418897 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[7] - 45705983 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[10] - 42063 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
+      a = (a << 7 | a >>> 25) + b | 0;
+      d += (a & b | ~a & c) + k[13] - 40341101 | 0;
+      d = (d << 12 | d >>> 20) + a | 0;
+      c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
+      c = (c << 17 | c >>> 15) + d | 0;
+      b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
+      b = (b << 22 | b >>> 10) + c | 0;
+      a += (b & d | c & ~d) + k[1] - 165796510 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[11] + 643717713 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[0] - 373897302 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[5] - 701558691 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[10] + 38016083 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[15] - 660478335 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[4] - 405537848 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[9] + 568446438 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[3] - 187363961 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
+      a = (a << 5 | a >>> 27) + b | 0;
+      d += (a & c | b & ~c) + k[2] - 51403784 | 0;
+      d = (d << 9 | d >>> 23) + a | 0;
+      c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
+      c = (c << 14 | c >>> 18) + d | 0;
+      b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
+      b = (b << 20 | b >>> 12) + c | 0;
+      a += (b ^ c ^ d) + k[5] - 378558 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[14] - 35309556 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[7] - 155497632 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[13] + 681279174 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[0] - 358537222 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[3] - 722521979 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[6] + 76029189 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (b ^ c ^ d) + k[9] - 640364487 | 0;
+      a = (a << 4 | a >>> 28) + b | 0;
+      d += (a ^ b ^ c) + k[12] - 421815835 | 0;
+      d = (d << 11 | d >>> 21) + a | 0;
+      c += (d ^ a ^ b) + k[15] + 530742520 | 0;
+      c = (c << 16 | c >>> 16) + d | 0;
+      b += (c ^ d ^ a) + k[2] - 995338651 | 0;
+      b = (b << 23 | b >>> 9) + c | 0;
+      a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
+      a = (a << 6 | a >>> 26) + b | 0;
+      d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
+      d = (d << 10 | d >>> 22) + a | 0;
+      c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
+      c = (c << 15 | c >>> 17) + d | 0;
+      b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
+      b = (b << 21 | b >>> 11) + c | 0;
+      x[0] = a + x[0] | 0;
+      x[1] = b + x[1] | 0;
+      x[2] = c + x[2] | 0;
+      x[3] = d + x[3] | 0;
+    }
+    function md5blk(s) {
+      var md5blks = [], i;
+      for (i = 0;i < 64; i += 4) {
+        md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+      }
+      return md5blks;
+    }
+    function md5blk_array(a) {
+      var md5blks = [], i;
+      for (i = 0;i < 64; i += 4) {
+        md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+      }
+      return md5blks;
+    }
+    function md51(s) {
+      var n = s.length, state = [1732584193, -271733879, -1732584194, 271733878], i, length, tail, tmp, lo, hi;
+      for (i = 64;i <= n; i += 64) {
+        md5cycle(state, md5blk(s.substring(i - 64, i)));
+      }
+      s = s.substring(i - 64);
+      length = s.length;
+      tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      for (i = 0;i < length; i += 1) {
+        tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+      }
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(state, tail);
+        for (i = 0;i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = n * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(state, tail);
+      return state;
+    }
+    function md51_array(a) {
+      var n = a.length, state = [1732584193, -271733879, -1732584194, 271733878], i, length, tail, tmp, lo, hi;
+      for (i = 64;i <= n; i += 64) {
+        md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+      }
+      a = i - 64 < n ? a.subarray(i - 64) : new Uint8Array(0);
+      length = a.length;
+      tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      for (i = 0;i < length; i += 1) {
+        tail[i >> 2] |= a[i] << (i % 4 << 3);
+      }
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(state, tail);
+        for (i = 0;i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = n * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(state, tail);
+      return state;
+    }
+    function rhex(n) {
+      var s = "", j;
+      for (j = 0;j < 4; j += 1) {
+        s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15];
+      }
+      return s;
+    }
+    function hex(x) {
+      var i;
+      for (i = 0;i < x.length; i += 1) {
+        x[i] = rhex(x[i]);
+      }
+      return x.join("");
+    }
+    if (hex(md51("hello")) !== "5d41402abc4b2a76b9719d911017c592") {
+      add32 = function(x, y) {
+        var lsw = (x & 65535) + (y & 65535), msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+        return msw << 16 | lsw & 65535;
+      };
+    }
+    if (typeof ArrayBuffer !== "undefined" && !ArrayBuffer.prototype.slice) {
+      (function() {
+        function clamp(val, length) {
+          val = val | 0 || 0;
+          if (val < 0) {
+            return Math.max(val + length, 0);
+          }
+          return Math.min(val, length);
+        }
+        ArrayBuffer.prototype.slice = function(from, to) {
+          var length = this.byteLength, begin = clamp(from, length), end = length, num, target, targetArray, sourceArray;
+          if (to !== undefined2) {
+            end = clamp(to, length);
+          }
+          if (begin > end) {
+            return new ArrayBuffer(0);
+          }
+          num = end - begin;
+          target = new ArrayBuffer(num);
+          targetArray = new Uint8Array(target);
+          sourceArray = new Uint8Array(this, begin, num);
+          targetArray.set(sourceArray);
+          return target;
+        };
+      })();
+    }
+    function toUtf8(str) {
+      if (/[\u0080-\uFFFF]/.test(str)) {
+        str = unescape(encodeURIComponent(str));
+      }
+      return str;
+    }
+    function utf8Str2ArrayBuffer(str, returnUInt8Array) {
+      var length = str.length, buff = new ArrayBuffer(length), arr = new Uint8Array(buff), i;
+      for (i = 0;i < length; i += 1) {
+        arr[i] = str.charCodeAt(i);
+      }
+      return returnUInt8Array ? arr : buff;
+    }
+    function arrayBuffer2Utf8Str(buff) {
+      return String.fromCharCode.apply(null, new Uint8Array(buff));
+    }
+    function concatenateArrayBuffers(first, second, returnUInt8Array) {
+      var result = new Uint8Array(first.byteLength + second.byteLength);
+      result.set(new Uint8Array(first));
+      result.set(new Uint8Array(second), first.byteLength);
+      return returnUInt8Array ? result : result.buffer;
+    }
+    function hexToBinaryString(hex2) {
+      var bytes = [], length = hex2.length, x;
+      for (x = 0;x < length - 1; x += 2) {
+        bytes.push(parseInt(hex2.substr(x, 2), 16));
+      }
+      return String.fromCharCode.apply(String, bytes);
+    }
+    function SparkMD5() {
+      this.reset();
+    }
+    SparkMD5.prototype.append = function(str) {
+      this.appendBinary(toUtf8(str));
+      return this;
+    };
+    SparkMD5.prototype.appendBinary = function(contents) {
+      this._buff += contents;
+      this._length += contents.length;
+      var length = this._buff.length, i;
+      for (i = 64;i <= length; i += 64) {
+        md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
+      }
+      this._buff = this._buff.substring(i - 64);
+      return this;
+    };
+    SparkMD5.prototype.end = function(raw) {
+      var buff = this._buff, length = buff.length, i, tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ret;
+      for (i = 0;i < length; i += 1) {
+        tail[i >> 2] |= buff.charCodeAt(i) << (i % 4 << 3);
+      }
+      this._finish(tail, length);
+      ret = hex(this._hash);
+      if (raw) {
+        ret = hexToBinaryString(ret);
+      }
+      this.reset();
+      return ret;
+    };
+    SparkMD5.prototype.reset = function() {
+      this._buff = "";
+      this._length = 0;
+      this._hash = [1732584193, -271733879, -1732584194, 271733878];
+      return this;
+    };
+    SparkMD5.prototype.getState = function() {
+      return {
+        buff: this._buff,
+        length: this._length,
+        hash: this._hash.slice()
+      };
+    };
+    SparkMD5.prototype.setState = function(state) {
+      this._buff = state.buff;
+      this._length = state.length;
+      this._hash = state.hash;
+      return this;
+    };
+    SparkMD5.prototype.destroy = function() {
+      delete this._hash;
+      delete this._buff;
+      delete this._length;
+    };
+    SparkMD5.prototype._finish = function(tail, length) {
+      var i = length, tmp, lo, hi;
+      tail[i >> 2] |= 128 << (i % 4 << 3);
+      if (i > 55) {
+        md5cycle(this._hash, tail);
+        for (i = 0;i < 16; i += 1) {
+          tail[i] = 0;
+        }
+      }
+      tmp = this._length * 8;
+      tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+      lo = parseInt(tmp[2], 16);
+      hi = parseInt(tmp[1], 16) || 0;
+      tail[14] = lo;
+      tail[15] = hi;
+      md5cycle(this._hash, tail);
+    };
+    SparkMD5.hash = function(str, raw) {
+      return SparkMD5.hashBinary(toUtf8(str), raw);
+    };
+    SparkMD5.hashBinary = function(content, raw) {
+      var hash = md51(content), ret = hex(hash);
+      return raw ? hexToBinaryString(ret) : ret;
+    };
+    SparkMD5.ArrayBuffer = function() {
+      this.reset();
+    };
+    SparkMD5.ArrayBuffer.prototype.append = function(arr) {
+      var buff = concatenateArrayBuffers(this._buff.buffer, arr, true), length = buff.length, i;
+      this._length += arr.byteLength;
+      for (i = 64;i <= length; i += 64) {
+        md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
+      }
+      this._buff = i - 64 < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);
+      return this;
+    };
+    SparkMD5.ArrayBuffer.prototype.end = function(raw) {
+      var buff = this._buff, length = buff.length, tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], i, ret;
+      for (i = 0;i < length; i += 1) {
+        tail[i >> 2] |= buff[i] << (i % 4 << 3);
+      }
+      this._finish(tail, length);
+      ret = hex(this._hash);
+      if (raw) {
+        ret = hexToBinaryString(ret);
+      }
+      this.reset();
+      return ret;
+    };
+    SparkMD5.ArrayBuffer.prototype.reset = function() {
+      this._buff = new Uint8Array(0);
+      this._length = 0;
+      this._hash = [1732584193, -271733879, -1732584194, 271733878];
+      return this;
+    };
+    SparkMD5.ArrayBuffer.prototype.getState = function() {
+      var state = SparkMD5.prototype.getState.call(this);
+      state.buff = arrayBuffer2Utf8Str(state.buff);
+      return state;
+    };
+    SparkMD5.ArrayBuffer.prototype.setState = function(state) {
+      state.buff = utf8Str2ArrayBuffer(state.buff, true);
+      return SparkMD5.prototype.setState.call(this, state);
+    };
+    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+    SparkMD5.ArrayBuffer.hash = function(arr, raw) {
+      var hash = md51_array(new Uint8Array(arr)), ret = hex(hash);
+      return raw ? hexToBinaryString(ret) : ret;
+    };
+    return SparkMD5;
+  });
+});
+
+// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query-browser.js
+var isTextForContentType = (contentType) => {
+  if (!contentType)
+    return false;
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  return textTypes.some((type) => contentType.includes(type));
+};
+var adapter = async (opts = {}, overloadOpts) => {
+  const controller = new AbortController;
+  const signal = controller.signal;
+  const isPostFile = opts.isPostFile || false;
+  let responseType = opts.responseType || "json";
+  if (opts.isBlob) {
+    responseType = "blob";
+  } else if (opts.isText) {
+    responseType = "text";
+  }
+  const timeout = opts.timeout || 60000 * 3;
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  let method = overloadOpts?.method || opts?.method || "POST";
+  let headers = { ...opts?.headers, ...overloadOpts?.headers };
+  let origin = "";
+  let url;
+  if (opts?.url?.startsWith("http")) {
+    url = new URL(opts.url);
+  } else {
+    origin = window?.location?.origin || "http://localhost:51515";
+    url = new URL(opts.url, origin);
+  }
+  const isGet = method === "GET";
+  const oldSearchParams = url.searchParams;
+  if (isGet) {
+    let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts.body });
+    url.search = searchParams.toString();
+  } else {
+    const params = {
+      ...Object.fromEntries(oldSearchParams),
+      ...opts.params
+    };
+    const searchParams = new URLSearchParams(params);
+    if (typeof opts.body === "object" && opts.body !== null) {
+      let body2 = opts.body || {};
+      if (!params.path && body2?.path) {
+        searchParams.set("path", body2.path);
+        if (body2?.key) {
+          searchParams.set("key", body2.key);
+        }
+      }
+    }
+    url.search = searchParams.toString();
+  }
+  let body = undefined;
+  if (isGet) {
+    body = undefined;
+  } else if (isPostFile) {
+    body = opts.body;
+  } else {
+    headers = {
+      "Content-Type": "application/json",
+      ...headers
+    };
+    body = JSON.stringify(opts.body);
+  }
+  return fetch(url, {
+    method: method.toUpperCase(),
+    signal,
+    body,
+    ...overloadOpts,
+    headers
+  }).then(async (response) => {
+    const contentType = response.headers.get("Content-Type");
+    if (responseType === "blob") {
+      return await response.blob();
+    }
+    const isText = responseType === "text";
+    const isJson = contentType && contentType.includes("application/json");
+    if (isJson && !isText) {
+      return await response.json();
+    } else if (isTextForContentType(contentType)) {
+      return {
+        code: response.status,
+        status: response.status,
+        data: await response.text()
+      };
+    } else {
+      return response;
+    }
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+};
+
+// node_modules/.pnpm/path-browserify-esm@1.0.6/node_modules/path-browserify-esm/index.esm.js
+function assertPath(path) {
+  if (typeof path !== "string") {
+    throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+  }
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "";
+  var lastSegmentLength = 0;
+  var lastSlash = -1;
+  var dots = 0;
+  var code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = "";
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === 46 && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root;
+  var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) {
+    return base;
+  }
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+  return dir + sep + base;
+}
+var posix = {
+  process_cwd: "",
+  setCWD: function setCWD(_cwd) {
+    posix.process_cwd = _cwd;
+  },
+  resolve: function resolve() {
+    var resolvedPath = "";
+    var resolvedAbsolute = false;
+    var cwd;
+    for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+      var path;
+      if (i >= 0)
+        path = arguments[i];
+      else {
+        if (cwd === undefined)
+          cwd = posix.process_cwd;
+        path = cwd;
+      }
+      assertPath(path);
+      if (path.length === 0) {
+        continue;
+      }
+      if (path + "/" === resolvedPath) {
+        continue;
+      }
+      resolvedPath = path + "/" + resolvedPath;
+      resolvedAbsolute = path.charCodeAt(0) === 47;
+    }
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+      if (resolvedPath.length > 0)
+        return "/" + resolvedPath;
+      else
+        return "/";
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    } else {
+      return ".";
+    }
+  },
+  normalize: function normalize(path) {
+    assertPath(path);
+    if (path.length === 0)
+      return ".";
+    var isAbsolute2 = path.charCodeAt(0) === 47;
+    var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+    path = normalizeStringPosix(path, !isAbsolute2);
+    if (path.length === 0 && !isAbsolute2)
+      path = ".";
+    if (path.length > 0 && trailingSeparator)
+      path += "/";
+    if (isAbsolute2)
+      return "/" + path;
+    return path;
+  },
+  isAbsolute: function isAbsolute(path) {
+    assertPath(path);
+    return path.length > 0 && path.charCodeAt(0) === 47;
+  },
+  join: function join() {
+    if (arguments.length === 0)
+      return ".";
+    var joined;
+    for (var i = 0;i < arguments.length; ++i) {
+      var arg = arguments[i];
+      assertPath(arg);
+      if (arg.length > 0) {
+        if (joined === undefined)
+          joined = arg;
+        else
+          joined += "/" + arg;
+      }
+    }
+    if (joined === undefined)
+      return ".";
+    return posix.normalize(joined);
+  },
+  relative: function relative(from, to) {
+    assertPath(from);
+    assertPath(to);
+    if (from === to)
+      return "";
+    const from2 = from.replaceAll("\\", "/");
+    const to2 = to.replaceAll("\\", "/");
+    if (from2 != from && to2 != to) {
+      return posix.relative(from2, to2).replaceAll("/", "\\");
+    } else if (from2 != from) {
+      return posix.relative(from2, to).replaceAll("/", "\\");
+    } else if (to2 != to) {
+      return posix.relative(from, to2);
+    }
+    from = posix.resolve(from);
+    to = posix.resolve(to);
+    if (from === to)
+      return "";
+    var fromStart = 1;
+    for (;fromStart < from.length; ++fromStart) {
+      if (from.charCodeAt(fromStart) !== 47)
+        break;
+    }
+    var fromEnd = from.length;
+    var fromLen = fromEnd - fromStart;
+    var toStart = 1;
+    for (;toStart < to.length; ++toStart) {
+      if (to.charCodeAt(toStart) !== 47)
+        break;
+    }
+    var toEnd = to.length;
+    var toLen = toEnd - toStart;
+    var length = fromLen < toLen ? fromLen : toLen;
+    var lastCommonSep = -1;
+    var i = 0;
+    for (;i <= length; ++i) {
+      if (i === length) {
+        if (toLen > length) {
+          if (to.charCodeAt(toStart + i) === 47) {
+            return to.slice(toStart + i + 1);
+          } else if (i === 0) {
+            return to.slice(toStart + i);
+          }
+        } else if (fromLen > length) {
+          if (from.charCodeAt(fromStart + i) === 47) {
+            lastCommonSep = i;
+          } else if (i === 0) {
+            lastCommonSep = 0;
+          }
+        }
+        break;
+      }
+      var fromCode = from.charCodeAt(fromStart + i);
+      var toCode = to.charCodeAt(toStart + i);
+      if (fromCode !== toCode)
+        break;
+      else if (fromCode === 47)
+        lastCommonSep = i;
+    }
+    var out = "";
+    for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i) {
+      if (i === fromEnd || from.charCodeAt(i) === 47) {
+        if (out.length === 0)
+          out += "..";
+        else
+          out += "/..";
+      }
+    }
+    if (out.length > 0)
+      return out + to.slice(toStart + lastCommonSep);
+    else {
+      toStart += lastCommonSep;
+      if (to.charCodeAt(toStart) === 47)
+        ++toStart;
+      return to.slice(toStart);
+    }
+  },
+  _makeLong: function _makeLong(path) {
+    return path;
+  },
+  dirname: function dirname(path) {
+    assertPath(path);
+    if (path.length === 0)
+      return ".";
+    var code = path.charCodeAt(0);
+    var hasRoot = code === 47;
+    var end = -1;
+    var matchedSlash = true;
+    for (var i = path.length - 1;i >= 1; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          end = i;
+          break;
+        }
+      } else {
+        matchedSlash = false;
+      }
+    }
+    if (end === -1)
+      return hasRoot ? "/" : ".";
+    if (hasRoot && end === 1)
+      return "//";
+    return path.slice(0, end);
+  },
+  basename: function basename(path, ext) {
+    if (ext !== undefined && typeof ext !== "string")
+      throw new TypeError('"ext" argument must be a string');
+    assertPath(path);
+    var start = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i;
+    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+      if (ext.length === path.length && ext === path)
+        return "";
+      var extIdx = ext.length - 1;
+      var firstNonSlashEnd = -1;
+      for (i = path.length - 1;i >= 0; --i) {
+        var code = path.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else {
+          if (firstNonSlashEnd === -1) {
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            if (code === ext.charCodeAt(extIdx)) {
+              if (--extIdx === -1) {
+                end = i;
+              }
+            } else {
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+      if (start === end)
+        end = firstNonSlashEnd;
+      else if (end === -1)
+        end = path.length;
+      return path.slice(start, end);
+    } else {
+      for (i = path.length - 1;i >= 0; --i) {
+        if (path.charCodeAt(i) === 47) {
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else if (end === -1) {
+          matchedSlash = false;
+          end = i + 1;
+        }
+      }
+      if (end === -1)
+        return "";
+      return path.slice(start, end);
+    }
+  },
+  extname: function extname(path) {
+    assertPath(path);
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var preDotState = 0;
+    for (var i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46) {
+        if (startDot === -1)
+          startDot = i;
+        else if (preDotState !== 1)
+          preDotState = 1;
+      } else if (startDot !== -1) {
+        preDotState = -1;
+      }
+    }
+    if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      return "";
+    }
+    return path.slice(startDot, end);
+  },
+  format: function format(pathObject) {
+    if (pathObject === null || typeof pathObject !== "object") {
+      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+    }
+    return _format("/", pathObject);
+  },
+  parse: function parse(path) {
+    assertPath(path);
+    var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+    if (path.length === 0)
+      return ret;
+    var code = path.charCodeAt(0);
+    var isAbsolute2 = code === 47;
+    var start;
+    if (isAbsolute2) {
+      ret.root = "/";
+      start = 1;
+    } else {
+      start = 0;
+    }
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i = path.length - 1;
+    var preDotState = 0;
+    for (;i >= start; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46) {
+        if (startDot === -1)
+          startDot = i;
+        else if (preDotState !== 1)
+          preDotState = 1;
+      } else if (startDot !== -1) {
+        preDotState = -1;
+      }
+    }
+    if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      if (end !== -1) {
+        if (startPart === 0 && isAbsolute2)
+          ret.base = ret.name = path.slice(1, end);
+        else
+          ret.base = ret.name = path.slice(startPart, end);
+      }
+    } else {
+      if (startPart === 0 && isAbsolute2) {
+        ret.name = path.slice(1, startDot);
+        ret.base = path.slice(1, end);
+      } else {
+        ret.name = path.slice(startPart, startDot);
+        ret.base = path.slice(startPart, end);
+      }
+      ret.ext = path.slice(startDot, end);
+    }
+    if (startPart > 0)
+      ret.dir = path.slice(0, startPart - 1);
+    else if (isAbsolute2)
+      ret.dir = "/";
+    return ret;
+  },
+  sep: "/",
+  delimiter: ":",
+  win32: null,
+  posix: null
+};
+posix.posix = posix;
+
+// query/query-resources/utils.ts
+var import_md5 = __toESM(require_md5(), 1);
+var import_spark_md5 = __toESM(require_spark_md5(), 1);
+var hashContent = (str) => {
+  if (typeof str === "string") {
+    return import_md5.default(str).toString();
+  } else if (str instanceof Blob) {
+    return hashBlob(str);
+  } else if (Buffer.isBuffer(str)) {
+    return import_md5.default(str.toString()).toString();
+  }
+  console.error("hashContent error: input must be a string, Blob, or Buffer");
+  return "";
+};
+var hashBlob = (blob) => {
+  return new Promise(async (resolve2, reject) => {
+    try {
+      const spark = new import_spark_md5.default.ArrayBuffer;
+      spark.append(await blob.arrayBuffer());
+      resolve2(spark.end());
+    } catch (error) {
+      console.error("hashBlob error", error);
+      reject(error);
+    }
+  });
+};
+
+// query/query-resources/index.ts
+class QueryResources {
+  prefix;
+  storage;
+  onProcess;
+  constructor(opts) {
+    if (opts.username) {
+      this.prefix = `/${opts.username}/resources/`;
+    } else {
+      this.prefix = opts.prefix || "";
+    }
+    this.storage = opts.storage || localStorage;
+    this.onProcess = opts.onProcess || (() => {});
+  }
+  setUsername(username) {
+    this.prefix = `/${username}/resources/`;
+  }
+  setPrefix(prefix) {
+    this.prefix = prefix;
+  }
+  header(headers, json = true) {
+    const token = this.storage.getItem("token");
+    const _headers = {
+      "Content-Type": "application/json",
+      ...headers
+    };
+    if (!json) {
+      delete _headers["Content-Type"];
+    }
+    if (!token) {
+      return _headers;
+    }
+    return {
+      ..._headers,
+      Authorization: `Bearer ${token}`
+    };
+  }
+  async get(data, opts) {
+    return adapter({
+      url: opts.url,
+      method: "GET",
+      body: data,
+      ...opts,
+      headers: this.header(opts?.headers)
+    });
+  }
+  async getList(prefix, data, opts) {
+    return this.get(data, {
+      url: `${this.prefix}${prefix}`,
+      body: data,
+      ...opts
+    });
+  }
+  async fetchFile(filepath, opts) {
+    const url = `${this.prefix}${filepath}`;
+    return this.get({}, { url, method: "GET", ...opts, headers: this.header(opts?.headers, false), isText: true });
+  }
+  async uploadFile(filepath, content, opts) {
+    const pathname = `${this.prefix}${filepath}`;
+    const filename = posix.basename(pathname);
+    const type = getContentType(filename);
+    const url = new URL(pathname, window.location.origin);
+    const hashResult = hashContent(content);
+    const hash = hashResult instanceof Promise ? await hashResult : hashResult;
+    url.searchParams.set("hash", hash);
+    const { chunkSize, maxSize, ...restOpts } = opts || {};
+    const isBlob = content instanceof Blob;
+    const fileSize = isBlob ? content.size : new Blob([content]).size;
+    const CHUNK_THRESHOLD = maxSize ?? 20 * 1024 * 1024;
+    if (fileSize > CHUNK_THRESHOLD && isBlob) {
+      return this.uploadChunkedFile(filepath, content, hash, { chunkSize, ...restOpts });
+    }
+    this.onProcess?.({ type: "uploadBegin", filename, size: fileSize, process: 0 });
+    const formData = new FormData;
+    if (isBlob) {
+      formData.append("file", content);
+    } else {
+      formData.append("file", new Blob([content], { type }));
+    }
+    const res = await adapter({
+      url: url.toString(),
+      isPostFile: true,
+      method: "POST",
+      body: formData,
+      timeout: 5 * 60 * 1000,
+      ...restOpts,
+      headers: { ...restOpts?.headers, ...this.header(restOpts?.headers, false) },
+      params: {
+        hash,
+        ...restOpts?.params
+      }
+    });
+    this.onProcess?.({ type: "uploadFinish", filename, size: fileSize, process: 100 });
+    return res;
+  }
+  async uploadChunkedFile(filepath, file, hash, opts) {
+    const pathname = `${this.prefix}${filepath}`;
+    const filename = posix.basename(pathname);
+    const url = new URL(pathname, window.location.origin);
+    url.searchParams.set("hash", hash);
+    url.searchParams.set("chunk", "1");
+    console.log(`url,`, url, hash);
+    const { chunkSize: _chunkSize, ...restOpts } = opts || {};
+    const chunkSize = _chunkSize ?? 5 * 1024 * 1024;
+    const totalChunks = Math.ceil(file.size / chunkSize);
+    this.onProcess?.({ type: "uploadBegin", filename, size: file.size, process: 0 });
+    for (let currentChunk = 0;currentChunk < totalChunks; currentChunk++) {
+      this.onProcess?.({ type: "uploadChunkedFile", filename, size: file.size, process: 0, totalChunks, currentChunk: currentChunk + 1 });
+      const start = currentChunk * chunkSize;
+      const end = Math.min(start + chunkSize, file.size);
+      const chunkBlob = file.slice(start, end);
+      const chunkFile = new File([chunkBlob], filename, { type: file.type || "application/octet-stream" });
+      const formData = new FormData;
+      formData.append("file", chunkFile, filename);
+      formData.append("chunkIndex", currentChunk.toString());
+      formData.append("totalChunks", totalChunks.toString());
+      console.log(`Uploading chunk ${currentChunk + 1}/${totalChunks}`, url.toString());
+      try {
+        const res = await adapter({
+          url: url.toString(),
+          isPostFile: true,
+          method: "POST",
+          body: formData,
+          timeout: 5 * 60 * 1000,
+          ...restOpts,
+          headers: { ...restOpts?.headers, ...this.header(restOpts?.headers, false) },
+          params: {
+            hash,
+            chunk: "1",
+            chunkIndex: currentChunk,
+            totalChunks,
+            ...restOpts?.params
+          }
+        });
+        if (res.code !== 200) {
+          throw new Error(`Chunk 上传失败 code ${res.code}, 错误信息是: ${res.message}`);
+        }
+        console.log(`Chunk ${currentChunk + 1}/${totalChunks} uploaded`, res);
+        this.onProcess?.({ type: "uploadChunkedFile", filename, size: file.size, process: Math.round((currentChunk + 1) / totalChunks * 100), totalChunks, currentChunk: currentChunk + 1 });
+      } catch (error) {
+        console.error(`Error uploading chunk ${currentChunk + 1}/${totalChunks}`, error);
+        return { code: 500, message: `分块上传失败: ${error.message}` };
+      }
+    }
+    this.onProcess?.({ type: "uploadFinish", filename, size: file.size, process: 100 });
+    return { code: 200, message: "上传成功" };
+  }
+  async getStat(filepath, opts) {
+    const url = `${this.prefix}${filepath}`;
+    return adapter({
+      url,
+      params: {
+        stat: "1"
+      },
+      method: "GET",
+      headers: this.header(opts?.headers)
+    });
+  }
+  async getState(filepath, opts) {
+    return this.getStat(filepath, opts);
+  }
+  async createFolder(folderpath, opts) {
+    const filepath = folderpath.endsWith("/") ? `${folderpath}keep.txt` : `${folderpath}/keep.txt`;
+    return this.uploadFile(filepath, "文件夹占位，其他文件不存在，文件夹不存在，如果有其他文件夹，删除当前文件夹占位文件即可", opts);
+  }
+  async rename(oldpath, newpath, opts) {
+    const pathname = `${this.prefix}${oldpath}`;
+    const newName = `${this.prefix}${newpath}`;
+    const params = {
+      newName
+    };
+    const url = pathname;
+    return adapter({
+      url,
+      method: "PUT",
+      headers: this.header(opts?.headers),
+      params
+    });
+  }
+  async deleteFile(filepath, opts) {
+    const url = `${this.prefix}${filepath}`;
+    return adapter({
+      url,
+      method: "DELETE",
+      headers: this.header(opts?.headers)
+    });
+  }
+}
+var getContentType = (filename) => {
+  const ext = posix.extname(filename);
+  let type = "text/plain";
+  switch (ext) {
+    case "":
+      type = "application/octet-stream";
+      break;
+    case ".json":
+      type = "application/json";
+      break;
+    case ".txt":
+      type = "text/plain";
+      break;
+    case ".csv":
+      type = "text/csv";
+      break;
+    case ".md":
+      type = "text/markdown";
+      break;
+    case ".html":
+    case ".htm":
+      type = "text/html";
+      break;
+    case ".xml":
+      type = "application/xml";
+      break;
+    case ".js":
+      type = "application/javascript";
+      break;
+    case ".css":
+      type = "text/css";
+      break;
+    case ".ts":
+      type = "application/typescript";
+      break;
+    case ".pdf":
+      type = "application/pdf";
+      break;
+    case ".zip":
+      type = "application/zip";
+      break;
+    case ".docx":
+      type = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+      break;
+    case ".xlsx":
+      type = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+      break;
+    case ".mp3":
+      type = "audio/mpeg";
+      break;
+    case ".mp4":
+      type = "video/mp4";
+      break;
+    case ".png":
+    case ".jpg":
+    case ".jpeg":
+    case ".gif":
+    case ".webp":
+      type = `image/${ext.slice(1)}`;
+      break;
+    case ".svg":
+      type = "image/svg+xml";
+      break;
+  }
+  return type;
+};
+export {
+  getContentType,
+  QueryResources
+};