@rspack-debug/browser 2.0.3 → 2.0.5

package/dist/index.js

@@ -125,7 +125,7 @@ __webpack_require__.add({
     "../../node_modules/.pnpm/asn1.js@4.10.1/node_modules/asn1.js/lib/asn1/base/buffer.js" (__unused_rspack_module, exports, __webpack_require__) {
         var inherits = __webpack_require__("../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js");
         var Reporter = __webpack_require__("../../node_modules/.pnpm/asn1.js@4.10.1/node_modules/asn1.js/lib/asn1/base/index.js").Reporter;
-        var Buffer = __webpack_require__("./src/browser/buffer.ts").Buffer;
+        var Buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").Buffer;
         function DecoderBuffer(base, options) {
             Reporter.call(this, options);
             if (!Buffer.isBuffer(base)) return void this.error('Input not Buffer');
@@ -1013,7 +1013,7 @@ __webpack_require__.add({
     },
     "../../node_modules/.pnpm/asn1.js@4.10.1/node_modules/asn1.js/lib/asn1/decoders/pem.js" (module, __unused_rspack_exports, __webpack_require__) {
         var inherits = __webpack_require__("../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js");
-        var Buffer = __webpack_require__("./src/browser/buffer.ts").Buffer;
+        var Buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").Buffer;
         var DERDecoder = __webpack_require__("../../node_modules/.pnpm/asn1.js@4.10.1/node_modules/asn1.js/lib/asn1/decoders/der.js");
         function PEMDecoder(entity) {
             DERDecoder.call(this, entity);
@@ -1049,7 +1049,7 @@ __webpack_require__.add({
     },
     "../../node_modules/.pnpm/asn1.js@4.10.1/node_modules/asn1.js/lib/asn1/encoders/der.js" (module, __unused_rspack_exports, __webpack_require__) {
         var inherits = __webpack_require__("../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js");
-        var Buffer = __webpack_require__("./src/browser/buffer.ts").Buffer;
+        var Buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").Buffer;
         var asn1 = __webpack_require__("../../node_modules/.pnpm/asn1.js@4.10.1/node_modules/asn1.js/lib/asn1.js");
         var base = asn1.base;
         var der = asn1.constants.der;
@@ -2761,6 +2761,95 @@ __webpack_require__.add({
             isDeepStrictEqual: isDeepStrictEqual
         };
     },
+    "../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js" (__unused_rspack_module, exports) {
+        exports.byteLength = byteLength;
+        exports.toByteArray = toByteArray;
+        exports.fromByteArray = fromByteArray;
+        var lookup = [];
+        var revLookup = [];
+        var Arr = "u" > typeof Uint8Array ? Uint8Array : Array;
+        var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+        for(var i = 0, len = code.length; i < len; ++i){
+            lookup[i] = code[i];
+            revLookup[code.charCodeAt(i)] = i;
+        }
+        revLookup['-'.charCodeAt(0)] = 62;
+        revLookup['_'.charCodeAt(0)] = 63;
+        function getLens(b64) {
+            var len = b64.length;
+            if (len % 4 > 0) throw new Error('Invalid string. Length must be a multiple of 4');
+            var validLen = b64.indexOf('=');
+            if (-1 === validLen) validLen = len;
+            var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+            return [
+                validLen,
+                placeHoldersLen
+            ];
+        }
+        function byteLength(b64) {
+            var lens = getLens(b64);
+            var validLen = lens[0];
+            var placeHoldersLen = lens[1];
+            return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+        }
+        function _byteLength(b64, validLen, placeHoldersLen) {
+            return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+        }
+        function toByteArray(b64) {
+            var tmp;
+            var lens = getLens(b64);
+            var validLen = lens[0];
+            var placeHoldersLen = lens[1];
+            var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+            var curByte = 0;
+            var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+            var i;
+            for(i = 0; i < len; i += 4){
+                tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+                arr[curByte++] = tmp >> 16 & 0xFF;
+                arr[curByte++] = tmp >> 8 & 0xFF;
+                arr[curByte++] = 0xFF & tmp;
+            }
+            if (2 === placeHoldersLen) {
+                tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+                arr[curByte++] = 0xFF & tmp;
+            }
+            if (1 === placeHoldersLen) {
+                tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+                arr[curByte++] = tmp >> 8 & 0xFF;
+                arr[curByte++] = 0xFF & tmp;
+            }
+            return arr;
+        }
+        function tripletToBase64(num) {
+            return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[0x3F & num];
+        }
+        function encodeChunk(uint8, start, end) {
+            var tmp;
+            var output = [];
+            for(var i = start; i < end; i += 3){
+                tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (0xFF & uint8[i + 2]);
+                output.push(tripletToBase64(tmp));
+            }
+            return output.join('');
+        }
+        function fromByteArray(uint8) {
+            var tmp;
+            var len = uint8.length;
+            var extraBytes = len % 3;
+            var parts = [];
+            var maxChunkLength = 16383;
+            for(var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength)parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+            if (1 === extraBytes) {
+                tmp = uint8[len - 1];
+                parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '==');
+            } else if (2 === extraBytes) {
+                tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+                parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + '=');
+            }
+            return parts.join('');
+        }
+    },
     "../../node_modules/.pnpm/bn.js@4.12.3/node_modules/bn.js/lib/bn.js" (module, __unused_rspack_exports, __webpack_require__) {
         module = __webpack_require__.nmd(module);
         (function(module, exports) {
@@ -8600,7 +8689,7 @@ __webpack_require__.add({
         module.exports = modes;
     },
     "../../node_modules/.pnpm/browserify-aes@1.2.0/node_modules/browserify-aes/modes/ofb.js" (__unused_rspack_module, exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         var xor = __webpack_require__("../../node_modules/.pnpm/buffer-xor@1.0.3/node_modules/buffer-xor/index.js");
         function getBlock(self1) {
             self1._prev = self1._cipher.encryptBlock(self1._prev);
@@ -9117,7 +9206,7 @@ __webpack_require__.add({
         module.exports = verify;
     },
     "../../node_modules/.pnpm/browserify-zlib@0.2.0/node_modules/browserify-zlib/lib/binding.js" (__unused_rspack_module, exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
         var assert = __webpack_require__("../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/assert.js");
         var Zstream = __webpack_require__("../../node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/zstream.js");
@@ -9378,12 +9467,12 @@ __webpack_require__.add({
     },
     "../../node_modules/.pnpm/browserify-zlib@0.2.0/node_modules/browserify-zlib/lib/index.js" (__unused_rspack_module, exports, __webpack_require__) {
         var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
-        var Buffer = __webpack_require__("./src/browser/buffer.ts").Buffer;
+        var Buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").Buffer;
         var Transform = __webpack_require__("../../node_modules/.pnpm/stream-browserify@3.0.0/node_modules/stream-browserify/index.js").Transform;
         var binding = __webpack_require__("../../node_modules/.pnpm/browserify-zlib@0.2.0/node_modules/browserify-zlib/lib/binding.js");
         var util = __webpack_require__("../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js");
         var assert = __webpack_require__("../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/assert.js").ok;
-        var kMaxLength = __webpack_require__("./src/browser/buffer.ts").kMaxLength;
+        var kMaxLength = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").kMaxLength;
         var kRangeErrorMessage = "Cannot create final Buffer. It would be larger than 0x" + kMaxLength.toString(16) + ' bytes';
         binding.Z_MIN_WINDOWBITS = 8;
         binding.Z_MAX_WINDOWBITS = 15;
@@ -9485,320 +9574,1402 @@ __webpack_require__.add({
         exports.deflateRawSync = function(buffer, opts) {
             return zlibBufferSync(new DeflateRaw(opts), buffer);
         };
-        exports.unzip = function(buffer, opts, callback) {
-            if ('function' == typeof opts) {
-                callback = opts;
-                opts = {};
-            }
-            return zlibBuffer(new Unzip(opts), buffer, callback);
+        exports.unzip = function(buffer, opts, callback) {
+            if ('function' == typeof opts) {
+                callback = opts;
+                opts = {};
+            }
+            return zlibBuffer(new Unzip(opts), buffer, callback);
+        };
+        exports.unzipSync = function(buffer, opts) {
+            return zlibBufferSync(new Unzip(opts), buffer);
+        };
+        exports.inflate = function(buffer, opts, callback) {
+            if ('function' == typeof opts) {
+                callback = opts;
+                opts = {};
+            }
+            return zlibBuffer(new Inflate(opts), buffer, callback);
+        };
+        exports.inflateSync = function(buffer, opts) {
+            return zlibBufferSync(new Inflate(opts), buffer);
+        };
+        exports.gunzip = function(buffer, opts, callback) {
+            if ('function' == typeof opts) {
+                callback = opts;
+                opts = {};
+            }
+            return zlibBuffer(new Gunzip(opts), buffer, callback);
+        };
+        exports.gunzipSync = function(buffer, opts) {
+            return zlibBufferSync(new Gunzip(opts), buffer);
+        };
+        exports.inflateRaw = function(buffer, opts, callback) {
+            if ('function' == typeof opts) {
+                callback = opts;
+                opts = {};
+            }
+            return zlibBuffer(new InflateRaw(opts), buffer, callback);
+        };
+        exports.inflateRawSync = function(buffer, opts) {
+            return zlibBufferSync(new InflateRaw(opts), buffer);
+        };
+        function zlibBuffer(engine, buffer, callback) {
+            var buffers = [];
+            var nread = 0;
+            engine.on('error', onError);
+            engine.on('end', onEnd);
+            engine.end(buffer);
+            flow();
+            function flow() {
+                var chunk;
+                while(null !== (chunk = engine.read())){
+                    buffers.push(chunk);
+                    nread += chunk.length;
+                }
+                engine.once('readable', flow);
+            }
+            function onError(err) {
+                engine.removeListener('end', onEnd);
+                engine.removeListener('readable', flow);
+                callback(err);
+            }
+            function onEnd() {
+                var buf;
+                var err = null;
+                if (nread >= kMaxLength) err = new RangeError(kRangeErrorMessage);
+                else buf = Buffer.concat(buffers, nread);
+                buffers = [];
+                engine.close();
+                callback(err, buf);
+            }
+        }
+        function zlibBufferSync(engine, buffer) {
+            if ('string' == typeof buffer) buffer = Buffer.from(buffer);
+            if (!Buffer.isBuffer(buffer)) throw new TypeError('Not a string or buffer');
+            var flushFlag = engine._finishFlushFlag;
+            return engine._processChunk(buffer, flushFlag);
+        }
+        function Deflate(opts) {
+            if (!(this instanceof Deflate)) return new Deflate(opts);
+            Zlib.call(this, opts, binding.DEFLATE);
+        }
+        function Inflate(opts) {
+            if (!(this instanceof Inflate)) return new Inflate(opts);
+            Zlib.call(this, opts, binding.INFLATE);
+        }
+        function Gzip(opts) {
+            if (!(this instanceof Gzip)) return new Gzip(opts);
+            Zlib.call(this, opts, binding.GZIP);
+        }
+        function Gunzip(opts) {
+            if (!(this instanceof Gunzip)) return new Gunzip(opts);
+            Zlib.call(this, opts, binding.GUNZIP);
+        }
+        function DeflateRaw(opts) {
+            if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts);
+            Zlib.call(this, opts, binding.DEFLATERAW);
+        }
+        function InflateRaw(opts) {
+            if (!(this instanceof InflateRaw)) return new InflateRaw(opts);
+            Zlib.call(this, opts, binding.INFLATERAW);
+        }
+        function Unzip(opts) {
+            if (!(this instanceof Unzip)) return new Unzip(opts);
+            Zlib.call(this, opts, binding.UNZIP);
+        }
+        function isValidFlushFlag(flag) {
+            return flag === binding.Z_NO_FLUSH || flag === binding.Z_PARTIAL_FLUSH || flag === binding.Z_SYNC_FLUSH || flag === binding.Z_FULL_FLUSH || flag === binding.Z_FINISH || flag === binding.Z_BLOCK;
+        }
+        function Zlib(opts, mode) {
+            var _this = this;
+            this._opts = opts = opts || {};
+            this._chunkSize = opts.chunkSize || exports.Z_DEFAULT_CHUNK;
+            Transform.call(this, opts);
+            if (opts.flush && !isValidFlushFlag(opts.flush)) throw new Error('Invalid flush flag: ' + opts.flush);
+            if (opts.finishFlush && !isValidFlushFlag(opts.finishFlush)) throw new Error('Invalid flush flag: ' + opts.finishFlush);
+            this._flushFlag = opts.flush || binding.Z_NO_FLUSH;
+            this._finishFlushFlag = void 0 !== opts.finishFlush ? opts.finishFlush : binding.Z_FINISH;
+            if (opts.chunkSize) {
+                if (opts.chunkSize < exports.Z_MIN_CHUNK || opts.chunkSize > exports.Z_MAX_CHUNK) throw new Error('Invalid chunk size: ' + opts.chunkSize);
+            }
+            if (opts.windowBits) {
+                if (opts.windowBits < exports.Z_MIN_WINDOWBITS || opts.windowBits > exports.Z_MAX_WINDOWBITS) throw new Error('Invalid windowBits: ' + opts.windowBits);
+            }
+            if (opts.level) {
+                if (opts.level < exports.Z_MIN_LEVEL || opts.level > exports.Z_MAX_LEVEL) throw new Error('Invalid compression level: ' + opts.level);
+            }
+            if (opts.memLevel) {
+                if (opts.memLevel < exports.Z_MIN_MEMLEVEL || opts.memLevel > exports.Z_MAX_MEMLEVEL) throw new Error('Invalid memLevel: ' + opts.memLevel);
+            }
+            if (opts.strategy) {
+                if (opts.strategy != exports.Z_FILTERED && opts.strategy != exports.Z_HUFFMAN_ONLY && opts.strategy != exports.Z_RLE && opts.strategy != exports.Z_FIXED && opts.strategy != exports.Z_DEFAULT_STRATEGY) throw new Error('Invalid strategy: ' + opts.strategy);
+            }
+            if (opts.dictionary) {
+                if (!Buffer.isBuffer(opts.dictionary)) throw new Error('Invalid dictionary: it should be a Buffer instance');
+            }
+            this._handle = new binding.Zlib(mode);
+            var self1 = this;
+            this._hadError = false;
+            this._handle.onerror = function(message, errno) {
+                _close(self1);
+                self1._hadError = true;
+                var error = new Error(message);
+                error.errno = errno;
+                error.code = exports.codes[errno];
+                self1.emit('error', error);
+            };
+            var level = exports.Z_DEFAULT_COMPRESSION;
+            if ('number' == typeof opts.level) level = opts.level;
+            var strategy = exports.Z_DEFAULT_STRATEGY;
+            if ('number' == typeof opts.strategy) strategy = opts.strategy;
+            this._handle.init(opts.windowBits || exports.Z_DEFAULT_WINDOWBITS, level, opts.memLevel || exports.Z_DEFAULT_MEMLEVEL, strategy, opts.dictionary);
+            this._buffer = Buffer.allocUnsafe(this._chunkSize);
+            this._offset = 0;
+            this._level = level;
+            this._strategy = strategy;
+            this.once('end', this.close);
+            Object.defineProperty(this, '_closed', {
+                get: function() {
+                    return !_this._handle;
+                },
+                configurable: true,
+                enumerable: true
+            });
+        }
+        util.inherits(Zlib, Transform);
+        Zlib.prototype.params = function(level, strategy, callback) {
+            if (level < exports.Z_MIN_LEVEL || level > exports.Z_MAX_LEVEL) throw new RangeError('Invalid compression level: ' + level);
+            if (strategy != exports.Z_FILTERED && strategy != exports.Z_HUFFMAN_ONLY && strategy != exports.Z_RLE && strategy != exports.Z_FIXED && strategy != exports.Z_DEFAULT_STRATEGY) throw new TypeError('Invalid strategy: ' + strategy);
+            if (this._level !== level || this._strategy !== strategy) {
+                var self1 = this;
+                this.flush(binding.Z_SYNC_FLUSH, function() {
+                    assert(self1._handle, 'zlib binding closed');
+                    self1._handle.params(level, strategy);
+                    if (!self1._hadError) {
+                        self1._level = level;
+                        self1._strategy = strategy;
+                        if (callback) callback();
+                    }
+                });
+            } else process.nextTick(callback);
+        };
+        Zlib.prototype.reset = function() {
+            assert(this._handle, 'zlib binding closed');
+            return this._handle.reset();
+        };
+        Zlib.prototype._flush = function(callback) {
+            this._transform(Buffer.alloc(0), '', callback);
+        };
+        Zlib.prototype.flush = function(kind, callback) {
+            var _this2 = this;
+            var ws = this._writableState;
+            if ('function' == typeof kind || void 0 === kind && !callback) {
+                callback = kind;
+                kind = binding.Z_FULL_FLUSH;
+            }
+            if (ws.ended) {
+                if (callback) process.nextTick(callback);
+            } else if (ws.ending) {
+                if (callback) this.once('end', callback);
+            } else if (ws.needDrain) {
+                if (callback) this.once('drain', function() {
+                    return _this2.flush(kind, callback);
+                });
+            } else {
+                this._flushFlag = kind;
+                this.write(Buffer.alloc(0), '', callback);
+            }
+        };
+        Zlib.prototype.close = function(callback) {
+            _close(this, callback);
+            process.nextTick(emitCloseNT, this);
+        };
+        function _close(engine, callback) {
+            if (callback) process.nextTick(callback);
+            if (!engine._handle) return;
+            engine._handle.close();
+            engine._handle = null;
+        }
+        function emitCloseNT(self1) {
+            self1.emit('close');
+        }
+        Zlib.prototype._transform = function(chunk, encoding, cb) {
+            var flushFlag;
+            var ws = this._writableState;
+            var ending = ws.ending || ws.ended;
+            var last = ending && (!chunk || ws.length === chunk.length);
+            if (null !== chunk && !Buffer.isBuffer(chunk)) return cb(new Error('invalid input'));
+            if (!this._handle) return cb(new Error('zlib binding closed'));
+            if (last) flushFlag = this._finishFlushFlag;
+            else {
+                flushFlag = this._flushFlag;
+                if (chunk.length >= ws.length) this._flushFlag = this._opts.flush || binding.Z_NO_FLUSH;
+            }
+            this._processChunk(chunk, flushFlag, cb);
+        };
+        Zlib.prototype._processChunk = function(chunk, flushFlag, cb) {
+            var availInBefore = chunk && chunk.length;
+            var availOutBefore = this._chunkSize - this._offset;
+            var inOff = 0;
+            var self1 = this;
+            var async = 'function' == typeof cb;
+            if (!async) {
+                var buffers = [];
+                var nread = 0;
+                var error;
+                this.on('error', function(er) {
+                    error = er;
+                });
+                assert(this._handle, 'zlib binding closed');
+                do var res = this._handle.writeSync(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, availOutBefore);
+                while (!this._hadError && callback(res[0], res[1]))
+                if (this._hadError) throw error;
+                if (nread >= kMaxLength) {
+                    _close(this);
+                    throw new RangeError(kRangeErrorMessage);
+                }
+                var buf = Buffer.concat(buffers, nread);
+                _close(this);
+                return buf;
+            }
+            assert(this._handle, 'zlib binding closed');
+            var req = this._handle.write(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, availOutBefore);
+            req.buffer = chunk;
+            req.callback = callback;
+            function callback(availInAfter, availOutAfter) {
+                if (this) {
+                    this.buffer = null;
+                    this.callback = null;
+                }
+                if (self1._hadError) return;
+                var have = availOutBefore - availOutAfter;
+                assert(have >= 0, 'have should not go down');
+                if (have > 0) {
+                    var out = self1._buffer.slice(self1._offset, self1._offset + have);
+                    self1._offset += have;
+                    if (async) self1.push(out);
+                    else {
+                        buffers.push(out);
+                        nread += out.length;
+                    }
+                }
+                if (0 === availOutAfter || self1._offset >= self1._chunkSize) {
+                    availOutBefore = self1._chunkSize;
+                    self1._offset = 0;
+                    self1._buffer = Buffer.allocUnsafe(self1._chunkSize);
+                }
+                if (0 === availOutAfter) {
+                    inOff += availInBefore - availInAfter;
+                    availInBefore = availInAfter;
+                    if (!async) return true;
+                    var newReq = self1._handle.write(flushFlag, chunk, inOff, availInBefore, self1._buffer, self1._offset, self1._chunkSize);
+                    newReq.callback = callback;
+                    newReq.buffer = chunk;
+                    return;
+                }
+                if (!async) return false;
+                cb();
+            }
+        };
+        util.inherits(Deflate, Zlib);
+        util.inherits(Inflate, Zlib);
+        util.inherits(Gzip, Zlib);
+        util.inherits(Gunzip, Zlib);
+        util.inherits(DeflateRaw, Zlib);
+        util.inherits(InflateRaw, Zlib);
+        util.inherits(Unzip, Zlib);
+    },
+    "../../node_modules/.pnpm/buffer-xor@1.0.3/node_modules/buffer-xor/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
+        module.exports = function(a, b) {
+            var length = Math.min(a.length, b.length);
+            var buffer = new Buffer(length);
+            for(var i = 0; i < length; ++i)buffer[i] = a[i] ^ b[i];
+            return buffer;
+        };
+    },
+    "../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        /*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */ var base64 = __webpack_require__("../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js");
+        var ieee754 = __webpack_require__("../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js");
+        var customInspectSymbol = 'function' == typeof Symbol && 'function' == typeof Symbol['for'] ? Symbol['for']('nodejs.util.inspect.custom') : null;
+        exports.Buffer = Buffer;
+        exports.SlowBuffer = SlowBuffer;
+        exports.INSPECT_MAX_BYTES = 50;
+        var K_MAX_LENGTH = 0x7fffffff;
+        exports.kMaxLength = K_MAX_LENGTH;
+        Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
+        if (!Buffer.TYPED_ARRAY_SUPPORT && "u" > typeof console && 'function' == typeof console.error) console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
+        function typedArraySupport() {
+            try {
+                var arr = new Uint8Array(1);
+                var proto = {
+                    foo: function() {
+                        return 42;
+                    }
+                };
+                Object.setPrototypeOf(proto, Uint8Array.prototype);
+                Object.setPrototypeOf(arr, proto);
+                return 42 === arr.foo();
+            } catch (e) {
+                return false;
+            }
+        }
+        Object.defineProperty(Buffer.prototype, 'parent', {
+            enumerable: true,
+            get: function() {
+                if (!Buffer.isBuffer(this)) return;
+                return this.buffer;
+            }
+        });
+        Object.defineProperty(Buffer.prototype, 'offset', {
+            enumerable: true,
+            get: function() {
+                if (!Buffer.isBuffer(this)) return;
+                return this.byteOffset;
+            }
+        });
+        function createBuffer(length) {
+            if (length > K_MAX_LENGTH) throw new RangeError('The value "' + length + '" is invalid for option "size"');
+            var buf = new Uint8Array(length);
+            Object.setPrototypeOf(buf, Buffer.prototype);
+            return buf;
+        }
+        function Buffer(arg, encodingOrOffset, length) {
+            if ('number' == typeof arg) {
+                if ('string' == typeof encodingOrOffset) throw new TypeError('The "string" argument must be of type string. Received type number');
+                return allocUnsafe(arg);
+            }
+            return from(arg, encodingOrOffset, length);
+        }
+        Buffer.poolSize = 8192;
+        function from(value, encodingOrOffset, length) {
+            if ('string' == typeof value) return fromString(value, encodingOrOffset);
+            if (ArrayBuffer.isView(value)) return fromArrayView(value);
+            if (null == value) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+            if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) return fromArrayBuffer(value, encodingOrOffset, length);
+            if ("u" > typeof SharedArrayBuffer && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) return fromArrayBuffer(value, encodingOrOffset, length);
+            if ('number' == typeof value) throw new TypeError('The "value" argument must not be of type number. Received type number');
+            var valueOf = value.valueOf && value.valueOf();
+            if (null != valueOf && valueOf !== value) return Buffer.from(valueOf, encodingOrOffset, length);
+            var b = fromObject(value);
+            if (b) return b;
+            if ("u" > typeof Symbol && null != Symbol.toPrimitive && 'function' == typeof value[Symbol.toPrimitive]) return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length);
+            throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+        }
+        Buffer.from = function(value, encodingOrOffset, length) {
+            return from(value, encodingOrOffset, length);
+        };
+        Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
+        Object.setPrototypeOf(Buffer, Uint8Array);
+        function assertSize(size) {
+            if ('number' != typeof size) throw new TypeError('"size" argument must be of type number');
+            if (size < 0) throw new RangeError('The value "' + size + '" is invalid for option "size"');
+        }
+        function alloc(size, fill, encoding) {
+            assertSize(size);
+            if (size <= 0) return createBuffer(size);
+            if (void 0 !== fill) return 'string' == typeof encoding ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+            return createBuffer(size);
+        }
+        Buffer.alloc = function(size, fill, encoding) {
+            return alloc(size, fill, encoding);
+        };
+        function allocUnsafe(size) {
+            assertSize(size);
+            return createBuffer(size < 0 ? 0 : 0 | checked(size));
+        }
+        Buffer.allocUnsafe = function(size) {
+            return allocUnsafe(size);
+        };
+        Buffer.allocUnsafeSlow = function(size) {
+            return allocUnsafe(size);
+        };
+        function fromString(string, encoding) {
+            if ('string' != typeof encoding || '' === encoding) encoding = 'utf8';
+            if (!Buffer.isEncoding(encoding)) throw new TypeError('Unknown encoding: ' + encoding);
+            var length = 0 | byteLength(string, encoding);
+            var buf = createBuffer(length);
+            var actual = buf.write(string, encoding);
+            if (actual !== length) buf = buf.slice(0, actual);
+            return buf;
+        }
+        function fromArrayLike(array) {
+            var length = array.length < 0 ? 0 : 0 | checked(array.length);
+            var buf = createBuffer(length);
+            for(var i = 0; i < length; i += 1)buf[i] = 255 & array[i];
+            return buf;
+        }
+        function fromArrayView(arrayView) {
+            if (isInstance(arrayView, Uint8Array)) {
+                var copy = new Uint8Array(arrayView);
+                return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+            }
+            return fromArrayLike(arrayView);
+        }
+        function fromArrayBuffer(array, byteOffset, length) {
+            if (byteOffset < 0 || array.byteLength < byteOffset) throw new RangeError('"offset" is outside of buffer bounds');
+            if (array.byteLength < byteOffset + (length || 0)) throw new RangeError('"length" is outside of buffer bounds');
+            var buf;
+            buf = void 0 === byteOffset && void 0 === length ? new Uint8Array(array) : void 0 === length ? new Uint8Array(array, byteOffset) : new Uint8Array(array, byteOffset, length);
+            Object.setPrototypeOf(buf, Buffer.prototype);
+            return buf;
+        }
+        function fromObject(obj) {
+            if (Buffer.isBuffer(obj)) {
+                var len = 0 | checked(obj.length);
+                var buf = createBuffer(len);
+                if (0 === buf.length) return buf;
+                obj.copy(buf, 0, 0, len);
+                return buf;
+            }
+            if (void 0 !== obj.length) {
+                if ('number' != typeof obj.length || numberIsNaN(obj.length)) return createBuffer(0);
+                return fromArrayLike(obj);
+            }
+            if ('Buffer' === obj.type && Array.isArray(obj.data)) return fromArrayLike(obj.data);
+        }
+        function checked(length) {
+            if (length >= K_MAX_LENGTH) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + ' bytes');
+            return 0 | length;
+        }
+        function SlowBuffer(length) {
+            if (+length != length) length = 0;
+            return Buffer.alloc(+length);
+        }
+        Buffer.isBuffer = function(b) {
+            return null != b && true === b._isBuffer && b !== Buffer.prototype;
+        };
+        Buffer.compare = function(a, b) {
+            if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
+            if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
+            if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+            if (a === b) return 0;
+            var x = a.length;
+            var y = b.length;
+            for(var i = 0, len = Math.min(x, y); i < len; ++i)if (a[i] !== b[i]) {
+                x = a[i];
+                y = b[i];
+                break;
+            }
+            if (x < y) return -1;
+            if (y < x) return 1;
+            return 0;
+        };
+        Buffer.isEncoding = function(encoding) {
+            switch(String(encoding).toLowerCase()){
+                case 'hex':
+                case 'utf8':
+                case 'utf-8':
+                case 'ascii':
+                case 'latin1':
+                case 'binary':
+                case 'base64':
+                case 'ucs2':
+                case 'ucs-2':
+                case 'utf16le':
+                case 'utf-16le':
+                    return true;
+                default:
+                    return false;
+            }
+        };
+        Buffer.concat = function(list, length) {
+            if (!Array.isArray(list)) throw new TypeError('"list" argument must be an Array of Buffers');
+            if (0 === list.length) return Buffer.alloc(0);
+            var i;
+            if (void 0 === length) {
+                length = 0;
+                for(i = 0; i < list.length; ++i)length += list[i].length;
+            }
+            var buffer = Buffer.allocUnsafe(length);
+            var pos = 0;
+            for(i = 0; i < list.length; ++i){
+                var buf = list[i];
+                if (isInstance(buf, Uint8Array)) if (pos + buf.length > buffer.length) Buffer.from(buf).copy(buffer, pos);
+                else Uint8Array.prototype.set.call(buffer, buf, pos);
+                else if (Buffer.isBuffer(buf)) buf.copy(buffer, pos);
+                else throw new TypeError('"list" argument must be an Array of Buffers');
+                pos += buf.length;
+            }
+            return buffer;
+        };
+        function byteLength(string, encoding) {
+            if (Buffer.isBuffer(string)) return string.length;
+            if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) return string.byteLength;
+            if ('string' != typeof string) throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
+            var len = string.length;
+            var mustMatch = arguments.length > 2 && true === arguments[2];
+            if (!mustMatch && 0 === len) return 0;
+            var loweredCase = false;
+            for(;;)switch(encoding){
+                case 'ascii':
+                case 'latin1':
+                case 'binary':
+                    return len;
+                case 'utf8':
+                case 'utf-8':
+                    return utf8ToBytes(string).length;
+                case 'ucs2':
+                case 'ucs-2':
+                case 'utf16le':
+                case 'utf-16le':
+                    return 2 * len;
+                case 'hex':
+                    return len >>> 1;
+                case 'base64':
+                    return base64ToBytes(string).length;
+                default:
+                    if (loweredCase) return mustMatch ? -1 : utf8ToBytes(string).length;
+                    encoding = ('' + encoding).toLowerCase();
+                    loweredCase = true;
+            }
+        }
+        Buffer.byteLength = byteLength;
+        function slowToString(encoding, start, end) {
+            var loweredCase = false;
+            if (void 0 === start || start < 0) start = 0;
+            if (start > this.length) return '';
+            if (void 0 === end || end > this.length) end = this.length;
+            if (end <= 0) return '';
+            end >>>= 0;
+            start >>>= 0;
+            if (end <= start) return '';
+            if (!encoding) encoding = 'utf8';
+            while(true)switch(encoding){
+                case 'hex':
+                    return hexSlice(this, start, end);
+                case 'utf8':
+                case 'utf-8':
+                    return utf8Slice(this, start, end);
+                case 'ascii':
+                    return asciiSlice(this, start, end);
+                case 'latin1':
+                case 'binary':
+                    return latin1Slice(this, start, end);
+                case 'base64':
+                    return base64Slice(this, start, end);
+                case 'ucs2':
+                case 'ucs-2':
+                case 'utf16le':
+                case 'utf-16le':
+                    return utf16leSlice(this, start, end);
+                default:
+                    if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);
+                    encoding = (encoding + '').toLowerCase();
+                    loweredCase = true;
+            }
+        }
+        Buffer.prototype._isBuffer = true;
+        function swap(b, n, m) {
+            var i = b[n];
+            b[n] = b[m];
+            b[m] = i;
+        }
+        Buffer.prototype.swap16 = function() {
+            var len = this.length;
+            if (len % 2 !== 0) throw new RangeError('Buffer size must be a multiple of 16-bits');
+            for(var i = 0; i < len; i += 2)swap(this, i, i + 1);
+            return this;
+        };
+        Buffer.prototype.swap32 = function() {
+            var len = this.length;
+            if (len % 4 !== 0) throw new RangeError('Buffer size must be a multiple of 32-bits');
+            for(var i = 0; i < len; i += 4){
+                swap(this, i, i + 3);
+                swap(this, i + 1, i + 2);
+            }
+            return this;
+        };
+        Buffer.prototype.swap64 = function() {
+            var len = this.length;
+            if (len % 8 !== 0) throw new RangeError('Buffer size must be a multiple of 64-bits');
+            for(var i = 0; i < len; i += 8){
+                swap(this, i, i + 7);
+                swap(this, i + 1, i + 6);
+                swap(this, i + 2, i + 5);
+                swap(this, i + 3, i + 4);
+            }
+            return this;
+        };
+        Buffer.prototype.toString = function() {
+            var length = this.length;
+            if (0 === length) return '';
+            if (0 === arguments.length) return utf8Slice(this, 0, length);
+            return slowToString.apply(this, arguments);
+        };
+        Buffer.prototype.toLocaleString = Buffer.prototype.toString;
+        Buffer.prototype.equals = function(b) {
+            if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');
+            if (this === b) return true;
+            return 0 === Buffer.compare(this, b);
+        };
+        Buffer.prototype.inspect = function() {
+            var str = '';
+            var max = exports.INSPECT_MAX_BYTES;
+            str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim();
+            if (this.length > max) str += ' ... ';
+            return '<Buffer ' + str + '>';
+        };
+        if (customInspectSymbol) Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
+        Buffer.prototype.compare = function(target, start, end, thisStart, thisEnd) {
+            if (isInstance(target, Uint8Array)) target = Buffer.from(target, target.offset, target.byteLength);
+            if (!Buffer.isBuffer(target)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
+            if (void 0 === start) start = 0;
+            if (void 0 === end) end = target ? target.length : 0;
+            if (void 0 === thisStart) thisStart = 0;
+            if (void 0 === thisEnd) thisEnd = this.length;
+            if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) throw new RangeError('out of range index');
+            if (thisStart >= thisEnd && start >= end) return 0;
+            if (thisStart >= thisEnd) return -1;
+            if (start >= end) return 1;
+            start >>>= 0;
+            end >>>= 0;
+            thisStart >>>= 0;
+            thisEnd >>>= 0;
+            if (this === target) return 0;
+            var x = thisEnd - thisStart;
+            var y = end - start;
+            var len = Math.min(x, y);
+            var thisCopy = this.slice(thisStart, thisEnd);
+            var targetCopy = target.slice(start, end);
+            for(var i = 0; i < len; ++i)if (thisCopy[i] !== targetCopy[i]) {
+                x = thisCopy[i];
+                y = targetCopy[i];
+                break;
+            }
+            if (x < y) return -1;
+            if (y < x) return 1;
+            return 0;
+        };
+        function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+            if (0 === buffer.length) return -1;
+            if ('string' == typeof byteOffset) {
+                encoding = byteOffset;
+                byteOffset = 0;
+            } else if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff;
+            else if (byteOffset < -2147483648) byteOffset = -2147483648;
+            byteOffset *= 1;
+            if (numberIsNaN(byteOffset)) byteOffset = dir ? 0 : buffer.length - 1;
+            if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+            if (byteOffset >= buffer.length) if (dir) return -1;
+            else byteOffset = buffer.length - 1;
+            else if (byteOffset < 0) if (!dir) return -1;
+            else byteOffset = 0;
+            if ('string' == typeof val) val = Buffer.from(val, encoding);
+            if (Buffer.isBuffer(val)) {
+                if (0 === val.length) return -1;
+                return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+            }
+            if ('number' == typeof val) {
+                val &= 0xFF;
+                if ('function' == typeof Uint8Array.prototype.indexOf) if (dir) return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+                else return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+                return arrayIndexOf(buffer, [
+                    val
+                ], byteOffset, encoding, dir);
+            }
+            throw new TypeError('val must be string, number or Buffer');
+        }
+        function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+            var indexSize = 1;
+            var arrLength = arr.length;
+            var valLength = val.length;
+            if (void 0 !== encoding) {
+                encoding = String(encoding).toLowerCase();
+                if ('ucs2' === encoding || 'ucs-2' === encoding || 'utf16le' === encoding || 'utf-16le' === encoding) {
+                    if (arr.length < 2 || val.length < 2) return -1;
+                    indexSize = 2;
+                    arrLength /= 2;
+                    valLength /= 2;
+                    byteOffset /= 2;
+                }
+            }
+            function read(buf, i) {
+                if (1 === indexSize) return buf[i];
+                return buf.readUInt16BE(i * indexSize);
+            }
+            var i;
+            if (dir) {
+                var foundIndex = -1;
+                for(i = byteOffset; i < arrLength; i++)if (read(arr, i) === read(val, -1 === foundIndex ? 0 : i - foundIndex)) {
+                    if (-1 === foundIndex) foundIndex = i;
+                    if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+                } else {
+                    if (-1 !== foundIndex) i -= i - foundIndex;
+                    foundIndex = -1;
+                }
+            } else {
+                if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+                for(i = byteOffset; i >= 0; i--){
+                    var found = true;
+                    for(var j = 0; j < valLength; j++)if (read(arr, i + j) !== read(val, j)) {
+                        found = false;
+                        break;
+                    }
+                    if (found) return i;
+                }
+            }
+            return -1;
+        }
+        Buffer.prototype.includes = function(val, byteOffset, encoding) {
+            return -1 !== this.indexOf(val, byteOffset, encoding);
+        };
+        Buffer.prototype.indexOf = function(val, byteOffset, encoding) {
+            return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+        };
+        Buffer.prototype.lastIndexOf = function(val, byteOffset, encoding) {
+            return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+        };
+        function hexWrite(buf, string, offset, length) {
+            offset = Number(offset) || 0;
+            var remaining = buf.length - offset;
+            if (length) {
+                length = Number(length);
+                if (length > remaining) length = remaining;
+            } else length = remaining;
+            var strLen = string.length;
+            if (length > strLen / 2) length = strLen / 2;
+            for(var i = 0; i < length; ++i){
+                var parsed = parseInt(string.substr(2 * i, 2), 16);
+                if (numberIsNaN(parsed)) break;
+                buf[offset + i] = parsed;
+            }
+            return i;
+        }
+        function utf8Write(buf, string, offset, length) {
+            return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+        }
+        function asciiWrite(buf, string, offset, length) {
+            return blitBuffer(asciiToBytes(string), buf, offset, length);
+        }
+        function base64Write(buf, string, offset, length) {
+            return blitBuffer(base64ToBytes(string), buf, offset, length);
+        }
+        function ucs2Write(buf, string, offset, length) {
+            return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+        }
+        Buffer.prototype.write = function(string, offset, length, encoding) {
+            if (void 0 === offset) {
+                encoding = 'utf8';
+                length = this.length;
+                offset = 0;
+            } else if (void 0 === length && 'string' == typeof offset) {
+                encoding = offset;
+                length = this.length;
+                offset = 0;
+            } else if (isFinite(offset)) {
+                offset >>>= 0;
+                if (isFinite(length)) {
+                    length >>>= 0;
+                    if (void 0 === encoding) encoding = 'utf8';
+                } else {
+                    encoding = length;
+                    length = void 0;
+                }
+            } else throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');
+            var remaining = this.length - offset;
+            if (void 0 === length || length > remaining) length = remaining;
+            if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) throw new RangeError('Attempt to write outside buffer bounds');
+            if (!encoding) encoding = 'utf8';
+            var loweredCase = false;
+            for(;;)switch(encoding){
+                case 'hex':
+                    return hexWrite(this, string, offset, length);
+                case 'utf8':
+                case 'utf-8':
+                    return utf8Write(this, string, offset, length);
+                case 'ascii':
+                case 'latin1':
+                case 'binary':
+                    return asciiWrite(this, string, offset, length);
+                case 'base64':
+                    return base64Write(this, string, offset, length);
+                case 'ucs2':
+                case 'ucs-2':
+                case 'utf16le':
+                case 'utf-16le':
+                    return ucs2Write(this, string, offset, length);
+                default:
+                    if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);
+                    encoding = ('' + encoding).toLowerCase();
+                    loweredCase = true;
+            }
+        };
+        Buffer.prototype.toJSON = function() {
+            return {
+                type: 'Buffer',
+                data: Array.prototype.slice.call(this._arr || this, 0)
+            };
+        };
+        function base64Slice(buf, start, end) {
+            if (0 === start && end === buf.length) return base64.fromByteArray(buf);
+            return base64.fromByteArray(buf.slice(start, end));
+        }
+        function utf8Slice(buf, start, end) {
+            end = Math.min(buf.length, end);
+            var res = [];
+            var i = start;
+            while(i < end){
+                var firstByte = buf[i];
+                var codePoint = null;
+                var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;
+                if (i + bytesPerSequence <= end) {
+                    var secondByte, thirdByte, fourthByte, tempCodePoint;
+                    switch(bytesPerSequence){
+                        case 1:
+                            if (firstByte < 0x80) codePoint = firstByte;
+                            break;
+                        case 2:
+                            secondByte = buf[i + 1];
+                            if ((0xC0 & secondByte) === 0x80) {
+                                tempCodePoint = (0x1F & firstByte) << 0x6 | 0x3F & secondByte;
+                                if (tempCodePoint > 0x7F) codePoint = tempCodePoint;
+                            }
+                            break;
+                        case 3:
+                            secondByte = buf[i + 1];
+                            thirdByte = buf[i + 2];
+                            if ((0xC0 & secondByte) === 0x80 && (0xC0 & thirdByte) === 0x80) {
+                                tempCodePoint = (0xF & firstByte) << 0xC | (0x3F & secondByte) << 0x6 | 0x3F & thirdByte;
+                                if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) codePoint = tempCodePoint;
+                            }
+                            break;
+                        case 4:
+                            secondByte = buf[i + 1];
+                            thirdByte = buf[i + 2];
+                            fourthByte = buf[i + 3];
+                            if ((0xC0 & secondByte) === 0x80 && (0xC0 & thirdByte) === 0x80 && (0xC0 & fourthByte) === 0x80) {
+                                tempCodePoint = (0xF & firstByte) << 0x12 | (0x3F & secondByte) << 0xC | (0x3F & thirdByte) << 0x6 | 0x3F & fourthByte;
+                                if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) codePoint = tempCodePoint;
+                            }
+                    }
+                }
+                if (null === codePoint) {
+                    codePoint = 0xFFFD;
+                    bytesPerSequence = 1;
+                } else if (codePoint > 0xFFFF) {
+                    codePoint -= 0x10000;
+                    res.push(codePoint >>> 10 & 0x3FF | 0xD800);
+                    codePoint = 0xDC00 | 0x3FF & codePoint;
+                }
+                res.push(codePoint);
+                i += bytesPerSequence;
+            }
+            return decodeCodePointsArray(res);
+        }
+        var MAX_ARGUMENTS_LENGTH = 0x1000;
+        function decodeCodePointsArray(codePoints) {
+            var len = codePoints.length;
+            if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
+            var res = '';
+            var i = 0;
+            while(i < len)res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
+            return res;
+        }
+        function asciiSlice(buf, start, end) {
+            var ret = '';
+            end = Math.min(buf.length, end);
+            for(var i = start; i < end; ++i)ret += String.fromCharCode(0x7F & buf[i]);
+            return ret;
+        }
+        function latin1Slice(buf, start, end) {
+            var ret = '';
+            end = Math.min(buf.length, end);
+            for(var i = start; i < end; ++i)ret += String.fromCharCode(buf[i]);
+            return ret;
+        }
+        function hexSlice(buf, start, end) {
+            var len = buf.length;
+            if (!start || start < 0) start = 0;
+            if (!end || end < 0 || end > len) end = len;
+            var out = '';
+            for(var i = start; i < end; ++i)out += hexSliceLookupTable[buf[i]];
+            return out;
+        }
+        function utf16leSlice(buf, start, end) {
+            var bytes = buf.slice(start, end);
+            var res = '';
+            for(var i = 0; i < bytes.length - 1; i += 2)res += String.fromCharCode(bytes[i] + 256 * bytes[i + 1]);
+            return res;
+        }
+        Buffer.prototype.slice = function(start, end) {
+            var len = this.length;
+            start = ~~start;
+            end = void 0 === end ? len : ~~end;
+            if (start < 0) {
+                start += len;
+                if (start < 0) start = 0;
+            } else if (start > len) start = len;
+            if (end < 0) {
+                end += len;
+                if (end < 0) end = 0;
+            } else if (end > len) end = len;
+            if (end < start) end = start;
+            var newBuf = this.subarray(start, end);
+            Object.setPrototypeOf(newBuf, Buffer.prototype);
+            return newBuf;
+        };
+        function checkOffset(offset, ext, length) {
+            if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');
+            if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');
+        }
+        Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function(offset, byteLength, noAssert) {
+            offset >>>= 0;
+            byteLength >>>= 0;
+            if (!noAssert) checkOffset(offset, byteLength, this.length);
+            var val = this[offset];
+            var mul = 1;
+            var i = 0;
+            while(++i < byteLength && (mul *= 0x100))val += this[offset + i] * mul;
+            return val;
+        };
+        Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function(offset, byteLength, noAssert) {
+            offset >>>= 0;
+            byteLength >>>= 0;
+            if (!noAssert) checkOffset(offset, byteLength, this.length);
+            var val = this[offset + --byteLength];
+            var mul = 1;
+            while(byteLength > 0 && (mul *= 0x100))val += this[offset + --byteLength] * mul;
+            return val;
+        };
+        Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 1, this.length);
+            return this[offset];
+        };
+        Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 2, this.length);
+            return this[offset] | this[offset + 1] << 8;
+        };
+        Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 2, this.length);
+            return this[offset] << 8 | this[offset + 1];
+        };
+        Buffer.prototype.readUint32LE = Buffer.prototype.readUInt32LE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + 0x1000000 * this[offset + 3];
+        };
+        Buffer.prototype.readUint32BE = Buffer.prototype.readUInt32BE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return 0x1000000 * this[offset] + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+        };
+        Buffer.prototype.readIntLE = function(offset, byteLength, noAssert) {
+            offset >>>= 0;
+            byteLength >>>= 0;
+            if (!noAssert) checkOffset(offset, byteLength, this.length);
+            var val = this[offset];
+            var mul = 1;
+            var i = 0;
+            while(++i < byteLength && (mul *= 0x100))val += this[offset + i] * mul;
+            mul *= 0x80;
+            if (val >= mul) val -= Math.pow(2, 8 * byteLength);
+            return val;
+        };
+        Buffer.prototype.readIntBE = function(offset, byteLength, noAssert) {
+            offset >>>= 0;
+            byteLength >>>= 0;
+            if (!noAssert) checkOffset(offset, byteLength, this.length);
+            var i = byteLength;
+            var mul = 1;
+            var val = this[offset + --i];
+            while(i > 0 && (mul *= 0x100))val += this[offset + --i] * mul;
+            mul *= 0x80;
+            if (val >= mul) val -= Math.pow(2, 8 * byteLength);
+            return val;
+        };
+        Buffer.prototype.readInt8 = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 1, this.length);
+            if (!(0x80 & this[offset])) return this[offset];
+            return (0xff - this[offset] + 1) * -1;
+        };
+        Buffer.prototype.readInt16LE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 2, this.length);
+            var val = this[offset] | this[offset + 1] << 8;
+            return 0x8000 & val ? 0xFFFF0000 | val : val;
+        };
+        Buffer.prototype.readInt16BE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 2, this.length);
+            var val = this[offset + 1] | this[offset] << 8;
+            return 0x8000 & val ? 0xFFFF0000 | val : val;
+        };
+        Buffer.prototype.readInt32LE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+        };
+        Buffer.prototype.readInt32BE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+        };
+        Buffer.prototype.readFloatLE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return ieee754.read(this, offset, true, 23, 4);
+        };
+        Buffer.prototype.readFloatBE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return ieee754.read(this, offset, false, 23, 4);
+        };
+        Buffer.prototype.readDoubleLE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 8, this.length);
+            return ieee754.read(this, offset, true, 52, 8);
+        };
+        Buffer.prototype.readDoubleBE = function(offset, noAssert) {
+            offset >>>= 0;
+            if (!noAssert) checkOffset(offset, 8, this.length);
+            return ieee754.read(this, offset, false, 52, 8);
+        };
+        function checkInt(buf, value, offset, ext, max, min) {
+            if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
+            if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
+            if (offset + ext > buf.length) throw new RangeError('Index out of range');
+        }
+        Buffer.prototype.writeUintLE = Buffer.prototype.writeUIntLE = function(value, offset, byteLength, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            byteLength >>>= 0;
+            if (!noAssert) {
+                var maxBytes = Math.pow(2, 8 * byteLength) - 1;
+                checkInt(this, value, offset, byteLength, maxBytes, 0);
+            }
+            var mul = 1;
+            var i = 0;
+            this[offset] = 0xFF & value;
+            while(++i < byteLength && (mul *= 0x100))this[offset + i] = value / mul & 0xFF;
+            return offset + byteLength;
+        };
+        Buffer.prototype.writeUintBE = Buffer.prototype.writeUIntBE = function(value, offset, byteLength, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            byteLength >>>= 0;
+            if (!noAssert) {
+                var maxBytes = Math.pow(2, 8 * byteLength) - 1;
+                checkInt(this, value, offset, byteLength, maxBytes, 0);
+            }
+            var i = byteLength - 1;
+            var mul = 1;
+            this[offset + i] = 0xFF & value;
+            while(--i >= 0 && (mul *= 0x100))this[offset + i] = value / mul & 0xFF;
+            return offset + byteLength;
+        };
+        Buffer.prototype.writeUint8 = Buffer.prototype.writeUInt8 = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
+            this[offset] = 0xff & value;
+            return offset + 1;
+        };
+        Buffer.prototype.writeUint16LE = Buffer.prototype.writeUInt16LE = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
+            this[offset] = 0xff & value;
+            this[offset + 1] = value >>> 8;
+            return offset + 2;
+        };
+        Buffer.prototype.writeUint16BE = Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
+            this[offset] = value >>> 8;
+            this[offset + 1] = 0xff & value;
+            return offset + 2;
+        };
+        Buffer.prototype.writeUint32LE = Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
+            this[offset + 3] = value >>> 24;
+            this[offset + 2] = value >>> 16;
+            this[offset + 1] = value >>> 8;
+            this[offset] = 0xff & value;
+            return offset + 4;
+        };
+        Buffer.prototype.writeUint32BE = Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
+            this[offset] = value >>> 24;
+            this[offset + 1] = value >>> 16;
+            this[offset + 2] = value >>> 8;
+            this[offset + 3] = 0xff & value;
+            return offset + 4;
+        };
+        Buffer.prototype.writeIntLE = function(value, offset, byteLength, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) {
+                var limit = Math.pow(2, 8 * byteLength - 1);
+                checkInt(this, value, offset, byteLength, limit - 1, -limit);
+            }
+            var i = 0;
+            var mul = 1;
+            var sub = 0;
+            this[offset] = 0xFF & value;
+            while(++i < byteLength && (mul *= 0x100)){
+                if (value < 0 && 0 === sub && 0 !== this[offset + i - 1]) sub = 1;
+                this[offset + i] = (value / mul | 0) - sub & 0xFF;
+            }
+            return offset + byteLength;
+        };
+        Buffer.prototype.writeIntBE = function(value, offset, byteLength, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) {
+                var limit = Math.pow(2, 8 * byteLength - 1);
+                checkInt(this, value, offset, byteLength, limit - 1, -limit);
+            }
+            var i = byteLength - 1;
+            var mul = 1;
+            var sub = 0;
+            this[offset + i] = 0xFF & value;
+            while(--i >= 0 && (mul *= 0x100)){
+                if (value < 0 && 0 === sub && 0 !== this[offset + i + 1]) sub = 1;
+                this[offset + i] = (value / mul | 0) - sub & 0xFF;
+            }
+            return offset + byteLength;
+        };
+        Buffer.prototype.writeInt8 = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -128);
+            if (value < 0) value = 0xff + value + 1;
+            this[offset] = 0xff & value;
+            return offset + 1;
+        };
+        Buffer.prototype.writeInt16LE = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -32768);
+            this[offset] = 0xff & value;
+            this[offset + 1] = value >>> 8;
+            return offset + 2;
+        };
+        Buffer.prototype.writeInt16BE = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -32768);
+            this[offset] = value >>> 8;
+            this[offset + 1] = 0xff & value;
+            return offset + 2;
+        };
+        Buffer.prototype.writeInt32LE = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -2147483648);
+            this[offset] = 0xff & value;
+            this[offset + 1] = value >>> 8;
+            this[offset + 2] = value >>> 16;
+            this[offset + 3] = value >>> 24;
+            return offset + 4;
+        };
+        Buffer.prototype.writeInt32BE = function(value, offset, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -2147483648);
+            if (value < 0) value = 0xffffffff + value + 1;
+            this[offset] = value >>> 24;
+            this[offset + 1] = value >>> 16;
+            this[offset + 2] = value >>> 8;
+            this[offset + 3] = 0xff & value;
+            return offset + 4;
         };
-        exports.unzipSync = function(buffer, opts) {
-            return zlibBufferSync(new Unzip(opts), buffer);
+        function checkIEEE754(buf, value, offset, ext, max, min) {
+            if (offset + ext > buf.length) throw new RangeError('Index out of range');
+            if (offset < 0) throw new RangeError('Index out of range');
+        }
+        function writeFloat(buf, value, offset, littleEndian, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);
+            ieee754.write(buf, value, offset, littleEndian, 23, 4);
+            return offset + 4;
+        }
+        Buffer.prototype.writeFloatLE = function(value, offset, noAssert) {
+            return writeFloat(this, value, offset, true, noAssert);
         };
-        exports.inflate = function(buffer, opts, callback) {
-            if ('function' == typeof opts) {
-                callback = opts;
-                opts = {};
-            }
-            return zlibBuffer(new Inflate(opts), buffer, callback);
+        Buffer.prototype.writeFloatBE = function(value, offset, noAssert) {
+            return writeFloat(this, value, offset, false, noAssert);
         };
-        exports.inflateSync = function(buffer, opts) {
-            return zlibBufferSync(new Inflate(opts), buffer);
+        function writeDouble(buf, value, offset, littleEndian, noAssert) {
+            value *= 1;
+            offset >>>= 0;
+            if (!noAssert) checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157e+308);
+            ieee754.write(buf, value, offset, littleEndian, 52, 8);
+            return offset + 8;
+        }
+        Buffer.prototype.writeDoubleLE = function(value, offset, noAssert) {
+            return writeDouble(this, value, offset, true, noAssert);
         };
-        exports.gunzip = function(buffer, opts, callback) {
-            if ('function' == typeof opts) {
-                callback = opts;
-                opts = {};
-            }
-            return zlibBuffer(new Gunzip(opts), buffer, callback);
+        Buffer.prototype.writeDoubleBE = function(value, offset, noAssert) {
+            return writeDouble(this, value, offset, false, noAssert);
         };
-        exports.gunzipSync = function(buffer, opts) {
-            return zlibBufferSync(new Gunzip(opts), buffer);
+        Buffer.prototype.copy = function(target, targetStart, start, end) {
+            if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer');
+            if (!start) start = 0;
+            if (!end && 0 !== end) end = this.length;
+            if (targetStart >= target.length) targetStart = target.length;
+            if (!targetStart) targetStart = 0;
+            if (end > 0 && end < start) end = start;
+            if (end === start) return 0;
+            if (0 === target.length || 0 === this.length) return 0;
+            if (targetStart < 0) throw new RangeError('targetStart out of bounds');
+            if (start < 0 || start >= this.length) throw new RangeError('Index out of range');
+            if (end < 0) throw new RangeError('sourceEnd out of bounds');
+            if (end > this.length) end = this.length;
+            if (target.length - targetStart < end - start) end = target.length - targetStart + start;
+            var len = end - start;
+            if (this === target && 'function' == typeof Uint8Array.prototype.copyWithin) this.copyWithin(targetStart, start, end);
+            else Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
+            return len;
         };
-        exports.inflateRaw = function(buffer, opts, callback) {
-            if ('function' == typeof opts) {
-                callback = opts;
-                opts = {};
+        Buffer.prototype.fill = function(val, start, end, encoding) {
+            if ('string' == typeof val) {
+                if ('string' == typeof start) {
+                    encoding = start;
+                    start = 0;
+                    end = this.length;
+                } else if ('string' == typeof end) {
+                    encoding = end;
+                    end = this.length;
+                }
+                if (void 0 !== encoding && 'string' != typeof encoding) throw new TypeError('encoding must be a string');
+                if ('string' == typeof encoding && !Buffer.isEncoding(encoding)) throw new TypeError('Unknown encoding: ' + encoding);
+                if (1 === val.length) {
+                    var code = val.charCodeAt(0);
+                    if ('utf8' === encoding && code < 128 || 'latin1' === encoding) val = code;
+                }
+            } else if ('number' == typeof val) val &= 255;
+            else if ('boolean' == typeof val) val = Number(val);
+            if (start < 0 || this.length < start || this.length < end) throw new RangeError('Out of range index');
+            if (end <= start) return this;
+            start >>>= 0;
+            end = void 0 === end ? this.length : end >>> 0;
+            if (!val) val = 0;
+            var i;
+            if ('number' == typeof val) for(i = start; i < end; ++i)this[i] = val;
+            else {
+                var bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding);
+                var len = bytes.length;
+                if (0 === len) throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+                for(i = 0; i < end - start; ++i)this[i + start] = bytes[i % len];
             }
-            return zlibBuffer(new InflateRaw(opts), buffer, callback);
-        };
-        exports.inflateRawSync = function(buffer, opts) {
-            return zlibBufferSync(new InflateRaw(opts), buffer);
+            return this;
         };
-        function zlibBuffer(engine, buffer, callback) {
-            var buffers = [];
-            var nread = 0;
-            engine.on('error', onError);
-            engine.on('end', onEnd);
-            engine.end(buffer);
-            flow();
-            function flow() {
-                var chunk;
-                while(null !== (chunk = engine.read())){
-                    buffers.push(chunk);
-                    nread += chunk.length;
+        var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+        function base64clean(str) {
+            str = str.split('=')[0];
+            str = str.trim().replace(INVALID_BASE64_RE, '');
+            if (str.length < 2) return '';
+            while(str.length % 4 !== 0)str += '=';
+            return str;
+        }
+        function utf8ToBytes(string, units) {
+            units = units || 1 / 0;
+            var codePoint;
+            var length = string.length;
+            var leadSurrogate = null;
+            var bytes = [];
+            for(var i = 0; i < length; ++i){
+                codePoint = string.charCodeAt(i);
+                if (codePoint > 0xD7FF && codePoint < 0xE000) {
+                    if (!leadSurrogate) {
+                        if (codePoint > 0xDBFF) {
+                            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
+                            continue;
+                        }
+                        if (i + 1 === length) {
+                            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
+                            continue;
+                        }
+                        leadSurrogate = codePoint;
+                        continue;
+                    }
+                    if (codePoint < 0xDC00) {
+                        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
+                        leadSurrogate = codePoint;
+                        continue;
+                    }
+                    codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
+                } else if (leadSurrogate) {
+                    if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
                 }
-                engine.once('readable', flow);
-            }
-            function onError(err) {
-                engine.removeListener('end', onEnd);
-                engine.removeListener('readable', flow);
-                callback(err);
-            }
-            function onEnd() {
-                var buf;
-                var err = null;
-                if (nread >= kMaxLength) err = new RangeError(kRangeErrorMessage);
-                else buf = Buffer.concat(buffers, nread);
-                buffers = [];
-                engine.close();
-                callback(err, buf);
+                leadSurrogate = null;
+                if (codePoint < 0x80) {
+                    if ((units -= 1) < 0) break;
+                    bytes.push(codePoint);
+                } else if (codePoint < 0x800) {
+                    if ((units -= 2) < 0) break;
+                    bytes.push(codePoint >> 0x6 | 0xC0, 0x3F & codePoint | 0x80);
+                } else if (codePoint < 0x10000) {
+                    if ((units -= 3) < 0) break;
+                    bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, 0x3F & codePoint | 0x80);
+                } else if (codePoint < 0x110000) {
+                    if ((units -= 4) < 0) break;
+                    bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, 0x3F & codePoint | 0x80);
+                } else throw new Error('Invalid code point');
             }
+            return bytes;
         }
-        function zlibBufferSync(engine, buffer) {
-            if ('string' == typeof buffer) buffer = Buffer.from(buffer);
-            if (!Buffer.isBuffer(buffer)) throw new TypeError('Not a string or buffer');
-            var flushFlag = engine._finishFlushFlag;
-            return engine._processChunk(buffer, flushFlag);
-        }
-        function Deflate(opts) {
-            if (!(this instanceof Deflate)) return new Deflate(opts);
-            Zlib.call(this, opts, binding.DEFLATE);
-        }
-        function Inflate(opts) {
-            if (!(this instanceof Inflate)) return new Inflate(opts);
-            Zlib.call(this, opts, binding.INFLATE);
-        }
-        function Gzip(opts) {
-            if (!(this instanceof Gzip)) return new Gzip(opts);
-            Zlib.call(this, opts, binding.GZIP);
-        }
-        function Gunzip(opts) {
-            if (!(this instanceof Gunzip)) return new Gunzip(opts);
-            Zlib.call(this, opts, binding.GUNZIP);
-        }
-        function DeflateRaw(opts) {
-            if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts);
-            Zlib.call(this, opts, binding.DEFLATERAW);
-        }
-        function InflateRaw(opts) {
-            if (!(this instanceof InflateRaw)) return new InflateRaw(opts);
-            Zlib.call(this, opts, binding.INFLATERAW);
+        function asciiToBytes(str) {
+            var byteArray = [];
+            for(var i = 0; i < str.length; ++i)byteArray.push(0xFF & str.charCodeAt(i));
+            return byteArray;
         }
-        function Unzip(opts) {
-            if (!(this instanceof Unzip)) return new Unzip(opts);
-            Zlib.call(this, opts, binding.UNZIP);
+        function utf16leToBytes(str, units) {
+            var c, hi, lo;
+            var byteArray = [];
+            for(var i = 0; i < str.length; ++i){
+                if ((units -= 2) < 0) break;
+                c = str.charCodeAt(i);
+                hi = c >> 8;
+                lo = c % 256;
+                byteArray.push(lo);
+                byteArray.push(hi);
+            }
+            return byteArray;
         }
-        function isValidFlushFlag(flag) {
-            return flag === binding.Z_NO_FLUSH || flag === binding.Z_PARTIAL_FLUSH || flag === binding.Z_SYNC_FLUSH || flag === binding.Z_FULL_FLUSH || flag === binding.Z_FINISH || flag === binding.Z_BLOCK;
+        function base64ToBytes(str) {
+            return base64.toByteArray(base64clean(str));
         }
-        function Zlib(opts, mode) {
-            var _this = this;
-            this._opts = opts = opts || {};
-            this._chunkSize = opts.chunkSize || exports.Z_DEFAULT_CHUNK;
-            Transform.call(this, opts);
-            if (opts.flush && !isValidFlushFlag(opts.flush)) throw new Error('Invalid flush flag: ' + opts.flush);
-            if (opts.finishFlush && !isValidFlushFlag(opts.finishFlush)) throw new Error('Invalid flush flag: ' + opts.finishFlush);
-            this._flushFlag = opts.flush || binding.Z_NO_FLUSH;
-            this._finishFlushFlag = void 0 !== opts.finishFlush ? opts.finishFlush : binding.Z_FINISH;
-            if (opts.chunkSize) {
-                if (opts.chunkSize < exports.Z_MIN_CHUNK || opts.chunkSize > exports.Z_MAX_CHUNK) throw new Error('Invalid chunk size: ' + opts.chunkSize);
-            }
-            if (opts.windowBits) {
-                if (opts.windowBits < exports.Z_MIN_WINDOWBITS || opts.windowBits > exports.Z_MAX_WINDOWBITS) throw new Error('Invalid windowBits: ' + opts.windowBits);
-            }
-            if (opts.level) {
-                if (opts.level < exports.Z_MIN_LEVEL || opts.level > exports.Z_MAX_LEVEL) throw new Error('Invalid compression level: ' + opts.level);
-            }
-            if (opts.memLevel) {
-                if (opts.memLevel < exports.Z_MIN_MEMLEVEL || opts.memLevel > exports.Z_MAX_MEMLEVEL) throw new Error('Invalid memLevel: ' + opts.memLevel);
-            }
-            if (opts.strategy) {
-                if (opts.strategy != exports.Z_FILTERED && opts.strategy != exports.Z_HUFFMAN_ONLY && opts.strategy != exports.Z_RLE && opts.strategy != exports.Z_FIXED && opts.strategy != exports.Z_DEFAULT_STRATEGY) throw new Error('Invalid strategy: ' + opts.strategy);
-            }
-            if (opts.dictionary) {
-                if (!Buffer.isBuffer(opts.dictionary)) throw new Error('Invalid dictionary: it should be a Buffer instance');
+        function blitBuffer(src, dst, offset, length) {
+            for(var i = 0; i < length; ++i){
+                if (i + offset >= dst.length || i >= src.length) break;
+                dst[i + offset] = src[i];
             }
-            this._handle = new binding.Zlib(mode);
-            var self1 = this;
-            this._hadError = false;
-            this._handle.onerror = function(message, errno) {
-                _close(self1);
-                self1._hadError = true;
-                var error = new Error(message);
-                error.errno = errno;
-                error.code = exports.codes[errno];
-                self1.emit('error', error);
-            };
-            var level = exports.Z_DEFAULT_COMPRESSION;
-            if ('number' == typeof opts.level) level = opts.level;
-            var strategy = exports.Z_DEFAULT_STRATEGY;
-            if ('number' == typeof opts.strategy) strategy = opts.strategy;
-            this._handle.init(opts.windowBits || exports.Z_DEFAULT_WINDOWBITS, level, opts.memLevel || exports.Z_DEFAULT_MEMLEVEL, strategy, opts.dictionary);
-            this._buffer = Buffer.allocUnsafe(this._chunkSize);
-            this._offset = 0;
-            this._level = level;
-            this._strategy = strategy;
-            this.once('end', this.close);
-            Object.defineProperty(this, '_closed', {
-                get: function() {
-                    return !_this._handle;
-                },
-                configurable: true,
-                enumerable: true
-            });
+            return i;
         }
-        util.inherits(Zlib, Transform);
-        Zlib.prototype.params = function(level, strategy, callback) {
-            if (level < exports.Z_MIN_LEVEL || level > exports.Z_MAX_LEVEL) throw new RangeError('Invalid compression level: ' + level);
-            if (strategy != exports.Z_FILTERED && strategy != exports.Z_HUFFMAN_ONLY && strategy != exports.Z_RLE && strategy != exports.Z_FIXED && strategy != exports.Z_DEFAULT_STRATEGY) throw new TypeError('Invalid strategy: ' + strategy);
-            if (this._level !== level || this._strategy !== strategy) {
-                var self1 = this;
-                this.flush(binding.Z_SYNC_FLUSH, function() {
-                    assert(self1._handle, 'zlib binding closed');
-                    self1._handle.params(level, strategy);
-                    if (!self1._hadError) {
-                        self1._level = level;
-                        self1._strategy = strategy;
-                        if (callback) callback();
-                    }
-                });
-            } else process.nextTick(callback);
-        };
-        Zlib.prototype.reset = function() {
-            assert(this._handle, 'zlib binding closed');
-            return this._handle.reset();
-        };
-        Zlib.prototype._flush = function(callback) {
-            this._transform(Buffer.alloc(0), '', callback);
-        };
-        Zlib.prototype.flush = function(kind, callback) {
-            var _this2 = this;
-            var ws = this._writableState;
-            if ('function' == typeof kind || void 0 === kind && !callback) {
-                callback = kind;
-                kind = binding.Z_FULL_FLUSH;
-            }
-            if (ws.ended) {
-                if (callback) process.nextTick(callback);
-            } else if (ws.ending) {
-                if (callback) this.once('end', callback);
-            } else if (ws.needDrain) {
-                if (callback) this.once('drain', function() {
-                    return _this2.flush(kind, callback);
-                });
-            } else {
-                this._flushFlag = kind;
-                this.write(Buffer.alloc(0), '', callback);
-            }
-        };
-        Zlib.prototype.close = function(callback) {
-            _close(this, callback);
-            process.nextTick(emitCloseNT, this);
-        };
-        function _close(engine, callback) {
-            if (callback) process.nextTick(callback);
-            if (!engine._handle) return;
-            engine._handle.close();
-            engine._handle = null;
+        function isInstance(obj, type) {
+            return obj instanceof type || null != obj && null != obj.constructor && null != obj.constructor.name && obj.constructor.name === type.name;
         }
-        function emitCloseNT(self1) {
-            self1.emit('close');
+        function numberIsNaN(obj) {
+            return obj !== obj;
         }
-        Zlib.prototype._transform = function(chunk, encoding, cb) {
-            var flushFlag;
-            var ws = this._writableState;
-            var ending = ws.ending || ws.ended;
-            var last = ending && (!chunk || ws.length === chunk.length);
-            if (null !== chunk && !Buffer.isBuffer(chunk)) return cb(new Error('invalid input'));
-            if (!this._handle) return cb(new Error('zlib binding closed'));
-            if (last) flushFlag = this._finishFlushFlag;
-            else {
-                flushFlag = this._flushFlag;
-                if (chunk.length >= ws.length) this._flushFlag = this._opts.flush || binding.Z_NO_FLUSH;
-            }
-            this._processChunk(chunk, flushFlag, cb);
-        };
-        Zlib.prototype._processChunk = function(chunk, flushFlag, cb) {
-            var availInBefore = chunk && chunk.length;
-            var availOutBefore = this._chunkSize - this._offset;
-            var inOff = 0;
-            var self1 = this;
-            var async = 'function' == typeof cb;
-            if (!async) {
-                var buffers = [];
-                var nread = 0;
-                var error;
-                this.on('error', function(er) {
-                    error = er;
-                });
-                assert(this._handle, 'zlib binding closed');
-                do var res = this._handle.writeSync(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, availOutBefore);
-                while (!this._hadError && callback(res[0], res[1]))
-                if (this._hadError) throw error;
-                if (nread >= kMaxLength) {
-                    _close(this);
-                    throw new RangeError(kRangeErrorMessage);
-                }
-                var buf = Buffer.concat(buffers, nread);
-                _close(this);
-                return buf;
-            }
-            assert(this._handle, 'zlib binding closed');
-            var req = this._handle.write(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, availOutBefore);
-            req.buffer = chunk;
-            req.callback = callback;
-            function callback(availInAfter, availOutAfter) {
-                if (this) {
-                    this.buffer = null;
-                    this.callback = null;
-                }
-                if (self1._hadError) return;
-                var have = availOutBefore - availOutAfter;
-                assert(have >= 0, 'have should not go down');
-                if (have > 0) {
-                    var out = self1._buffer.slice(self1._offset, self1._offset + have);
-                    self1._offset += have;
-                    if (async) self1.push(out);
-                    else {
-                        buffers.push(out);
-                        nread += out.length;
-                    }
-                }
-                if (0 === availOutAfter || self1._offset >= self1._chunkSize) {
-                    availOutBefore = self1._chunkSize;
-                    self1._offset = 0;
-                    self1._buffer = Buffer.allocUnsafe(self1._chunkSize);
-                }
-                if (0 === availOutAfter) {
-                    inOff += availInBefore - availInAfter;
-                    availInBefore = availInAfter;
-                    if (!async) return true;
-                    var newReq = self1._handle.write(flushFlag, chunk, inOff, availInBefore, self1._buffer, self1._offset, self1._chunkSize);
-                    newReq.callback = callback;
-                    newReq.buffer = chunk;
-                    return;
-                }
-                if (!async) return false;
-                cb();
+        var hexSliceLookupTable = function() {
+            var alphabet = '0123456789abcdef';
+            var table = new Array(256);
+            for(var i = 0; i < 16; ++i){
+                var i16 = 16 * i;
+                for(var j = 0; j < 16; ++j)table[i16 + j] = alphabet[i] + alphabet[j];
             }
-        };
-        util.inherits(Deflate, Zlib);
-        util.inherits(Inflate, Zlib);
-        util.inherits(Gzip, Zlib);
-        util.inherits(Gunzip, Zlib);
-        util.inherits(DeflateRaw, Zlib);
-        util.inherits(InflateRaw, Zlib);
-        util.inherits(Unzip, Zlib);
-    },
-    "../../node_modules/.pnpm/buffer-xor@1.0.3/node_modules/buffer-xor/index.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
-        module.exports = function(a, b) {
-            var length = Math.min(a.length, b.length);
-            var buffer = new Buffer(length);
-            for(var i = 0; i < length; ++i)buffer[i] = a[i] ^ b[i];
-            return buffer;
-        };
+            return table;
+        }();
     },
     "../../node_modules/.pnpm/builtin-status-codes@3.0.0/node_modules/builtin-status-codes/browser.js" (module) {
         module.exports = {
@@ -10070,13 +11241,13 @@ __webpack_require__.add({
             return null === arg || 'boolean' == typeof arg || 'number' == typeof arg || 'string' == typeof arg || 'symbol' == typeof arg || void 0 === arg;
         }
         exports.isPrimitive = isPrimitive;
-        exports.isBuffer = __webpack_require__("./src/browser/buffer.ts").Buffer.isBuffer;
+        exports.isBuffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").Buffer.isBuffer;
         function objectToString(o) {
             return Object.prototype.toString.call(o);
         }
     },
     "../../node_modules/.pnpm/create-ecdh@4.0.4/node_modules/create-ecdh/browser.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         var elliptic = __webpack_require__("../../node_modules/.pnpm/elliptic@6.6.1/node_modules/elliptic/lib/elliptic.js");
         var BN = __webpack_require__("../../node_modules/.pnpm/bn.js@4.12.3/node_modules/bn.js/lib/bn.js");
         module.exports = function(curve) {
@@ -11461,7 +12632,7 @@ __webpack_require__.add({
         };
     },
     "../../node_modules/.pnpm/diffie-hellman@5.0.3/node_modules/diffie-hellman/browser.js" (__unused_rspack_module, exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         var generatePrime = __webpack_require__("../../node_modules/.pnpm/diffie-hellman@5.0.3/node_modules/diffie-hellman/lib/generatePrime.js");
         var primes = __webpack_require__("../../node_modules/.pnpm/diffie-hellman@5.0.3/node_modules/diffie-hellman/lib/primes.json");
         var DH = __webpack_require__("../../node_modules/.pnpm/diffie-hellman@5.0.3/node_modules/diffie-hellman/lib/dh.js");
@@ -11491,7 +12662,7 @@ __webpack_require__.add({
         exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman;
     },
     "../../node_modules/.pnpm/diffie-hellman@5.0.3/node_modules/diffie-hellman/lib/dh.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         var BN = __webpack_require__("../../node_modules/.pnpm/bn.js@4.12.3/node_modules/bn.js/lib/bn.js");
         var MillerRabin = __webpack_require__("../../node_modules/.pnpm/miller-rabin@4.0.1/node_modules/miller-rabin/lib/mr.js");
         var millerRabin = new MillerRabin();
@@ -14616,9 +15787,9 @@ __webpack_require__.add({
         }
         utils.intFromLE = intFromLE;
     },
-    "../../node_modules/.pnpm/enhanced-resolve@5.21.2/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
-        const { nextTick } = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.21.2/node_modules/enhanced-resolve/lib/util/process-browser.js");
+    "../../node_modules/.pnpm/enhanced-resolve@5.21.3/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
+        const { nextTick } = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.21.3/node_modules/enhanced-resolve/lib/util/process-browser.js");
         const dirname = (path)=>{
             let idx = path.length - 1;
             while(idx >= 0){
@@ -14913,7 +16084,7 @@ __webpack_require__.add({
             }
         };
     },
-    "../../node_modules/.pnpm/enhanced-resolve@5.21.2/node_modules/enhanced-resolve/lib/util/process-browser.js" (module) {
+    "../../node_modules/.pnpm/enhanced-resolve@5.21.3/node_modules/enhanced-resolve/lib/util/process-browser.js" (module) {
         module.exports = {
             versions: {},
             nextTick (fn) {
@@ -15756,7 +16927,7 @@ __webpack_require__.add({
             ]
         };
         var bind = __webpack_require__("../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js");
-        var hasOwn = __webpack_require__("../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js");
+        var hasOwn = __webpack_require__("../../node_modules/.pnpm/hasown@2.0.3/node_modules/hasown/index.js");
         var $concat = bind.call($call, Array.prototype.concat);
         var $spliceApply = bind.call($apply, Array.prototype.splice);
         var $replace = bind.call($call, String.prototype.replace);
@@ -18248,7 +19419,7 @@ __webpack_require__.add({
         }
         exports.shr64_lo = shr64_lo;
     },
-    "../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/hasown@2.0.3/node_modules/hasown/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         var call = Function.prototype.call;
         var $hasOwn = Object.prototype.hasOwnProperty;
         var bind = __webpack_require__("../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js");
@@ -18357,6 +19528,76 @@ __webpack_require__.add({
             return params;
         }
     },
+    "../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js" (__unused_rspack_module, exports) {
+        /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */ exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+            var e, m;
+            var eLen = 8 * nBytes - mLen - 1;
+            var eMax = (1 << eLen) - 1;
+            var eBias = eMax >> 1;
+            var nBits = -7;
+            var i = isLE ? nBytes - 1 : 0;
+            var d = isLE ? -1 : 1;
+            var s = buffer[offset + i];
+            i += d;
+            e = s & (1 << -nBits) - 1;
+            s >>= -nBits;
+            nBits += eLen;
+            for(; nBits > 0; e = 256 * e + buffer[offset + i], i += d, nBits -= 8);
+            m = e & (1 << -nBits) - 1;
+            e >>= -nBits;
+            nBits += mLen;
+            for(; nBits > 0; m = 256 * m + buffer[offset + i], i += d, nBits -= 8);
+            if (0 === e) e = 1 - eBias;
+            else {
+                if (e === eMax) return m ? NaN : 1 / 0 * (s ? -1 : 1);
+                m += Math.pow(2, mLen);
+                e -= eBias;
+            }
+            return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+        };
+        exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+            var e, m, c;
+            var eLen = 8 * nBytes - mLen - 1;
+            var eMax = (1 << eLen) - 1;
+            var eBias = eMax >> 1;
+            var rt = 23 === mLen ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+            var i = isLE ? 0 : nBytes - 1;
+            var d = isLE ? 1 : -1;
+            var s = value < 0 || 0 === value && 1 / value < 0 ? 1 : 0;
+            value = Math.abs(value);
+            if (isNaN(value) || value === 1 / 0) {
+                m = isNaN(value) ? 1 : 0;
+                e = eMax;
+            } else {
+                e = Math.floor(Math.log(value) / Math.LN2);
+                if (value * (c = Math.pow(2, -e)) < 1) {
+                    e--;
+                    c *= 2;
+                }
+                if (e + eBias >= 1) value += rt / c;
+                else value += rt * Math.pow(2, 1 - eBias);
+                if (value * c >= 2) {
+                    e++;
+                    c /= 2;
+                }
+                if (e + eBias >= eMax) {
+                    m = 0;
+                    e = eMax;
+                } else if (e + eBias >= 1) {
+                    m = (value * c - 1) * Math.pow(2, mLen);
+                    e += eBias;
+                } else {
+                    m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+                    e = 0;
+                }
+            }
+            for(; mLen >= 8; buffer[offset + i] = 0xff & m, i += d, m /= 256, mLen -= 8);
+            e = e << mLen | m;
+            eLen += mLen;
+            for(; eLen > 0; buffer[offset + i] = 0xff & e, i += d, e /= 256, eLen -= 8);
+            buffer[offset + i - d] |= 128 * s;
+        };
+    },
     "../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js" (module) {
         if ('function' == typeof Object.create) module.exports = function(ctor, superCtor) {
             if (superCtor) {
@@ -18546,7 +19787,7 @@ __webpack_require__.add({
     "../../node_modules/.pnpm/is-regex@1.2.1/node_modules/is-regex/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         var callBound = __webpack_require__("../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js");
         var hasToStringTag = __webpack_require__("../../node_modules/.pnpm/has-tostringtag@1.0.2/node_modules/has-tostringtag/shams.js")();
-        var hasOwn = __webpack_require__("../../node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js");
+        var hasOwn = __webpack_require__("../../node_modules/.pnpm/hasown@2.0.3/node_modules/hasown/index.js");
         var gOPD = __webpack_require__("../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js");
         var fn;
         if (hasToStringTag) {
@@ -26340,7 +27581,7 @@ __webpack_require__.add({
             return emitter.listeners(type).length;
         };
         var Stream = __webpack_require__("../../node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/stream-browser.js");
-        var Buffer = __webpack_require__("./src/browser/buffer.ts").Buffer;
+        var Buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").Buffer;
         var OurUint8Array = (void 0 !== __webpack_require__.g ? __webpack_require__.g : "u" > typeof window ? window : "u" > typeof self ? self : {}).Uint8Array || function() {};
         function _uint8ArrayToBuffer(chunk) {
             return Buffer.from(chunk);
@@ -27089,7 +28330,7 @@ __webpack_require__.add({
             deprecate: __webpack_require__("../../node_modules/.pnpm/util-deprecate@1.0.2/node_modules/util-deprecate/browser.js")
         };
         var Stream = __webpack_require__("../../node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/stream-browser.js");
-        var Buffer = __webpack_require__("./src/browser/buffer.ts").Buffer;
+        var Buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").Buffer;
         var OurUint8Array = (void 0 !== __webpack_require__.g ? __webpack_require__.g : "u" > typeof window ? window : "u" > typeof self ? self : {}).Uint8Array || function() {};
         function _uint8ArrayToBuffer(chunk) {
             return Buffer.from(chunk);
@@ -27724,7 +28965,7 @@ __webpack_require__.add({
             }
             return ("string" === hint ? String : Number)(input);
         }
-        var _require = __webpack_require__("./src/browser/buffer.ts"), Buffer = _require.Buffer;
+        var _require = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js"), Buffer = _require.Buffer;
         var _require2 = __webpack_require__("?c028"), inspect = _require2.inspect;
         var custom = inspect && inspect.custom || 'inspect';
         function copyBuffer(src, target, offset) {
@@ -28164,7 +29405,7 @@ __webpack_require__.add({
         exports.pipeline = __webpack_require__("../../node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/pipeline.js");
     },
     "../../node_modules/.pnpm/ripemd160@2.0.3/node_modules/ripemd160/index.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts").Buffer;
+        var Buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js").Buffer;
         var inherits = __webpack_require__("../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js");
         var HashBase = __webpack_require__("../../node_modules/.pnpm/hash-base@3.1.2/node_modules/hash-base/index.js");
         var ARRAY16 = new Array(16);
@@ -28610,7 +29851,7 @@ __webpack_require__.add({
         module.exports = RIPEMD160;
     },
     "../../node_modules/.pnpm/safe-buffer@5.1.2/node_modules/safe-buffer/index.js" (module, exports, __webpack_require__) {
-        var buffer = __webpack_require__("./src/browser/buffer.ts");
+        var buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js");
         var Buffer = buffer.Buffer;
         function copyProps(src, dst) {
             for(var key in src)dst[key] = src[key];
@@ -28646,7 +29887,7 @@ __webpack_require__.add({
         };
     },
     "../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js" (module, exports, __webpack_require__) {
-        /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */ var buffer = __webpack_require__("./src/browser/buffer.ts");
+        /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */ var buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js");
         var Buffer = buffer.Buffer;
         function copyProps(src, dst) {
             for(var key in src)dst[key] = src[key];
@@ -29850,7 +31091,7 @@ __webpack_require__.add({
         xhr = null;
     },
     "../../node_modules/.pnpm/stream-http@3.2.0/node_modules/stream-http/lib/request.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
         var capability = __webpack_require__("../../node_modules/.pnpm/stream-http@3.2.0/node_modules/stream-http/lib/capability.js");
         var inherits = __webpack_require__("../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js");
@@ -30102,7 +31343,7 @@ __webpack_require__.add({
     },
     "../../node_modules/.pnpm/stream-http@3.2.0/node_modules/stream-http/lib/response.js" (__unused_rspack_module, exports, __webpack_require__) {
         var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         var capability = __webpack_require__("../../node_modules/.pnpm/stream-http@3.2.0/node_modules/stream-http/lib/capability.js");
         var inherits = __webpack_require__("../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js");
         var stream = __webpack_require__("../../node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/readable-browser.js");
@@ -33242,7 +34483,7 @@ __webpack_require__.add({
         };
     },
     "../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/CachedSource.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         const Source = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/Source.js");
         const streamAndGetSourceAndMap = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/streamAndGetSourceAndMap.js");
         const streamChunksOfRawSource = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/streamChunksOfRawSource.js");
@@ -33467,7 +34708,7 @@ __webpack_require__.add({
         module.exports = CompatSource;
     },
     "../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/ConcatSource.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         const RawSource = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/RawSource.js");
         const Source = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/Source.js");
         const { getMap, getSourceAndMap } = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/getFromStreamChunks.js");
@@ -33643,7 +34884,7 @@ __webpack_require__.add({
         module.exports = ConcatSource;
     },
     "../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/OriginalSource.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         const Source = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/Source.js");
         const { getMap, getSourceAndMap } = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/getFromStreamChunks.js");
         const getGeneratedSourceInfo = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/getGeneratedSourceInfo.js");
@@ -33744,7 +34985,7 @@ __webpack_require__.add({
         module.exports = OriginalSource;
     },
     "../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/PrefixSource.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         const RawSource = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/RawSource.js");
         const Source = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/Source.js");
         const { getMap, getSourceAndMap } = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/getFromStreamChunks.js");
@@ -33803,7 +35044,7 @@ __webpack_require__.add({
         module.exports = PrefixSource;
     },
     "../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/RawSource.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         const Source = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/Source.js");
         const streamChunksOfRawSource = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/streamChunksOfRawSource.js");
         const { internString, isDualStringBufferCachingEnabled } = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/stringBufferUtils.js");
@@ -34161,7 +35402,7 @@ __webpack_require__.add({
         module.exports = SizeOnlySource;
     },
     "../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/Source.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         class Source {
             source() {
                 throw new Error("Abstract");
@@ -34190,7 +35431,7 @@ __webpack_require__.add({
         module.exports = Source;
     },
     "../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/SourceMapSource.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+        var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
         const Source = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/Source.js");
         const { getMap, getSourceAndMap } = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/getFromStreamChunks.js");
         const streamChunksOfCombinedSourceMap = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/helpers/streamChunksOfCombinedSourceMap.js");
@@ -35318,9 +36559,8 @@ __webpack_require__.add({
         }
     },
     "./src/browser/buffer.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.r(__webpack_exports__);
         __webpack_require__.d(__webpack_exports__, {
-            Buffer: ()=>_napi_rs_wasm_runtime_fs__rspack_import_0.hp
+            h: ()=>_napi_rs_wasm_runtime_fs__rspack_import_0.hp
         });
         var _napi_rs_wasm_runtime_fs__rspack_import_0 = __webpack_require__("../../node_modules/.pnpm/@napi-rs+wasm-runtime@1.1.4_@emnapi+core@1.10.0_@emnapi+runtime@1.10.0/node_modules/@napi-rs/wasm-runtime/dist/fs.js");
     },
@@ -35339,14 +36579,14 @@ __webpack_require__.add({
             watch: ()=>watch
         });
         var _napi_rs_wasm_runtime_fs__rspack_import_0 = __webpack_require__("../../node_modules/.pnpm/@napi-rs+wasm-runtime@1.1.4_@emnapi+core@1.10.0_@emnapi+runtime@1.10.0/node_modules/@napi-rs/wasm-runtime/dist/fs.js");
-        var _rspack_binding__rspack_import_1 = __webpack_require__("@rspack/binding?5821");
+        var _rspack_binding__rspack_import_1 = __webpack_require__("@rspack/binding?d2c4");
         const fs = _rspack_binding__rspack_import_1.__fs;
         const volume = _rspack_binding__rspack_import_1.__volume;
         const memfs = _napi_rs_wasm_runtime_fs__rspack_import_0.tO;
         const { readFileSync, readdirSync, lstat, existsSync, readdir, watch } = fs;
         const __rspack_default_export = fs;
     },
-    "@rspack/binding?5821" (module) {
+    "@rspack/binding?d2c4" (module) {
         module.exports = __rspack_external__rspack_wasi_browser_js_bd433424;
     },
     "?7763" () {},
@@ -55106,7 +56346,7 @@ function createFakeCompilationDependencies(getDeps, addDeps) {
     };
 }
 const webpack_sources_lib = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/index.js");
-var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 class SourceAdapter {
     static fromBinding(source) {
         if (!source.map) return new webpack_sources_lib.RawSource(source.source);
@@ -56186,6 +57426,12 @@ const BundlerInfoRspackPlugin = base_create(external_rspack_wasi_browser_js_Buil
     }));
 const CaseSensitivePlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.CaseSensitivePlugin, ()=>{}, 'compilation');
 const ChunkPrefetchPreloadPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.ChunkPrefetchPreloadPlugin, ()=>{});
+class CircularModulesInfoPlugin extends RspackBuiltinPlugin {
+    name = external_rspack_wasi_browser_js_BuiltinPluginName.CircularModulesInfoPlugin;
+    raw(_compiler) {
+        return createBuiltinPlugin(this.name, void 0);
+    }
+}
 class CircularDependencyRspackPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.CircularDependencyRspackPlugin;
     _options;
@@ -56281,6 +57527,7 @@ const CssChunkingPlugin = base_create(rspack_wasi_browser.BuiltinPluginName.CssC
     }
     return options;
 });
+const CssHttpExternalsRspackPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.CssHttpExternalsRspackPlugin, ()=>void 0);
 const CssModulesPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.CssModulesPlugin, ()=>{}, 'compilation');
 const path_browserify = __webpack_require__("../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js");
 var path_browserify_default = /*#__PURE__*/ __webpack_require__.n(path_browserify);
@@ -56657,7 +57904,7 @@ function applyLimits(options) {
 base_create(external_rspack_wasi_browser_js_BuiltinPluginName.EsmNodeTargetPlugin, ()=>void 0);
 const EvalDevToolModulePlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.EvalDevToolModulePlugin, (options)=>options, 'compilation');
 const EvalSourceMapDevToolPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.EvalSourceMapDevToolPlugin, (options)=>options, 'compilation');
-var util_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var util_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 function isNil(value) {
     return null == value;
 }
@@ -57355,7 +58602,7 @@ class Hash {
         throw new AbstractMethodError();
     }
 }
-var wasm_hash_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var wasm_hash_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 const MAX_SHORT_STRING = -4 & Math.floor(16368);
 class WasmHash {
     exports;
@@ -57474,7 +58721,7 @@ const wasm_hash_create = (wasmModule, instancesPool, chunkSize, digestSize)=>{
     return new WasmHash(new WebAssembly.Instance(wasmModule), instancesPool, chunkSize, digestSize);
 };
 const wasm_hash = wasm_hash_create;
-var md4_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var md4_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 let createMd4;
 const hash_md4 = ()=>{
     if (!createMd4) {
@@ -57483,7 +58730,7 @@ const hash_md4 = ()=>{
     }
     return createMd4();
 };
-var xxhash64_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var xxhash64_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 let createXxhash64;
 const hash_xxhash64 = ()=>{
     if (!createXxhash64) {
@@ -57492,7 +58739,7 @@ const hash_xxhash64 = ()=>{
     }
     return createXxhash64();
 };
-var createHash_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var createHash_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 const BULK_SIZE = 2000;
 const digestCaches = {};
 class BulkUpdateDecorator extends Hash {
@@ -57663,7 +58910,7 @@ function handleResult(loader, module, callback) {
     if ('function' != typeof loader.normal && 'function' != typeof loader.pitch) return callback(new LoaderLoadingError(`Module '${loader.path}' is not a loader (must have normal or pitch function)`));
     callback();
 }
-var utils_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var utils_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 const decoder = new TextDecoder();
 function utf8BufferToString(buf) {
     const isShared = buf.buffer instanceof SharedArrayBuffer || buf.buffer.constructor?.name === 'SharedArrayBuffer';
@@ -58564,6 +59811,7 @@ function getRawOutput(output) {
 function getRawOutputEnvironment(environment = {}) {
     return {
         const: Boolean(environment.const),
+        computedProperty: Boolean(environment.computedProperty),
         methodShorthand: Boolean(environment.methodShorthand),
         arrowFunction: Boolean(environment.arrowFunction),
         nodePrefixForCoreModules: Boolean(environment.nodePrefixForCoreModules),
@@ -58798,12 +60046,16 @@ function getRawParserOptions(parser, type) {
     };
     if ('css' === type) return {
         type: 'css',
-        css: getRawCssParserOptions(parser)
+        css: getRawCssParserOptionsForCss(parser)
     };
     if ('css/auto' === type) return {
         type: 'css/auto',
         cssAuto: getRawCssParserOptions(parser)
     };
+    if ('css/global' === type) return {
+        type: 'css/global',
+        cssGlobal: getRawCssParserOptions(parser)
+    };
     if ('css/module' === type) return {
         type: 'css/module',
         cssModule: getRawCssParserOptions(parser)
@@ -58866,7 +60118,22 @@ function getRawCssParserOptions(parser) {
     return {
         namedExports: parser.namedExports,
         url: parser.url,
-        resolveImport: parser.resolveImport
+        import: parser.import,
+        resolveImport: parser.resolveImport,
+        animation: parser.animation,
+        customIdents: parser.customIdents,
+        dashedIdents: parser.dashedIdents
+    };
+}
+function getRawCssParserOptionsForCss(parser) {
+    return {
+        namedExports: parser.namedExports,
+        url: parser.url,
+        import: parser.import,
+        resolveImport: parser.resolveImport,
+        animation: parser.animation,
+        customIdents: parser.customIdents,
+        dashedIdents: parser.dashedIdents
     };
 }
 function getRawJsonParserOptions(parser) {
@@ -58896,6 +60163,10 @@ function getRawGeneratorOptions(generator, type) {
         type: 'css/auto',
         cssAuto: getRawCssAutoOrModuleGeneratorOptions(generator)
     };
+    if ('css/global' === type) return {
+        type: 'css/global',
+        cssGlobal: getRawCssAutoOrModuleGeneratorOptions(generator)
+    };
     if ('css/module' === type) return {
         type: 'css/module',
         cssModule: getRawCssAutoOrModuleGeneratorOptions(generator)
@@ -58956,6 +60227,10 @@ function getRawCssGeneratorOptions(options) {
 function getRawCssAutoOrModuleGeneratorOptions(options) {
     return {
         localIdentName: options.localIdentName,
+        localIdentHashDigest: options.localIdentHashDigest,
+        localIdentHashDigestLength: options.localIdentHashDigestLength,
+        localIdentHashFunction: options.localIdentHashFunction,
+        localIdentHashSalt: options.localIdentHashSalt,
         exportsConvention: options.exportsConvention,
         exportsOnly: options.exportsOnly,
         esModule: options.esModule
@@ -58986,16 +60261,18 @@ class ExternalsPlugin extends RspackBuiltinPlugin {
     type;
     externals;
     placeInInitial;
+    fallbackType;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.ExternalsPlugin;
     #resolveRequestCache = new Map();
-    constructor(type, externals, placeInInitial){
-        super(), this.type = type, this.externals = externals, this.placeInInitial = placeInInitial;
+    constructor(type, externals, placeInInitial, fallbackType){
+        super(), this.type = type, this.externals = externals, this.placeInInitial = placeInInitial, this.fallbackType = fallbackType;
     }
     raw() {
         const type = this.type;
         const externals = this.externals;
         const raw = {
             type,
+            fallbackType: this.fallbackType,
             externals: (Array.isArray(externals) ? externals : [
                 externals
             ]).filter(Boolean).map((item)=>this.#getRawExternalItem(item)),
@@ -59111,11 +60388,10 @@ class HotModuleReplacementPlugin extends RspackBuiltinPlugin {
         return createBuiltinPlugin(this.name, void 0);
     }
 }
-const HttpExternalsRspackPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.HttpExternalsRspackPlugin, (css, webAsync)=>({
-        css,
+const HttpExternalsRspackPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.HttpExternalsRspackPlugin, (webAsync)=>({
         webAsync
     }));
-var HttpUriPlugin_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var HttpUriPlugin_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 memoize(()=>__webpack_require__("../../node_modules/.pnpm/stream-http@3.2.0/node_modules/stream-http/index.js"));
 memoize(()=>__webpack_require__("../../node_modules/.pnpm/https-browserify@1.0.0/node_modules/https-browserify/index.js"));
 const defaultHttpClientForBrowser = async (url, headers)=>{
@@ -59772,7 +61048,7 @@ const SizeLimitsPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPlug
     };
 });
 const SourceMapDevToolPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.SourceMapDevToolPlugin, (options)=>options, 'compilation');
-var SubresourceIntegrityPlugin_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var SubresourceIntegrityPlugin_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 const SubresourceIntegrityPlugin_PLUGIN_NAME = 'SubresourceIntegrityPlugin';
 const NATIVE_HTML_PLUGIN = 'HtmlRspackPlugin';
 const HTTP_PROTOCOL_REGEX = /^https?:/;
@@ -60728,6 +62004,35 @@ const browserslistTargetHandler_resolve = (browsers)=>{
                 9
             ]
         }),
+        computedProperty: rawChecker({
+            chrome: 47,
+            and_chr: 47,
+            edge: 12,
+            firefox: 34,
+            and_ff: 34,
+            opera: 34,
+            op_mob: 34,
+            safari: 8,
+            ios_saf: 8,
+            samsung: 5,
+            android: 47,
+            and_qq: [
+                14,
+                9
+            ],
+            and_uc: [
+                15,
+                5
+            ],
+            kaios: [
+                2,
+                5
+            ],
+            node: [
+                4,
+                0
+            ]
+        }),
         arrowFunction: rawChecker({
             chrome: 45,
             and_chr: 45,
@@ -61147,6 +62452,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 importScriptsInWorker: false,
                 globalThis: v(12),
                 const: v(6),
+                computedProperty: v(4),
                 templateLiteral: v(4),
                 optionalChaining: v(14),
                 methodShorthand: v(4),
@@ -61192,6 +62498,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 importScriptsInWorker: true,
                 globalThis: v(5),
                 const: v(1, 1),
+                computedProperty: v(1, 1),
                 templateLiteral: v(1, 1),
                 optionalChaining: v(8),
                 methodShorthand: v(1, 1),
@@ -61232,6 +62539,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 require: false,
                 globalThis: v(0, 43),
                 const: v(0, 15),
+                computedProperty: v(0, 15),
                 templateLiteral: v(0, 13),
                 optionalChaining: v(0, 44),
                 methodShorthand: v(0, 15),
@@ -61256,6 +62564,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             return {
                 esVersion: v > 2022 ? 2022 : v,
                 const: v >= 2015,
+                computedProperty: v >= 2015,
                 templateLiteral: v >= 2015,
                 optionalChaining: v >= 2020,
                 methodShorthand: v >= 2015,
@@ -61353,19 +62662,21 @@ const applyRspackOptionsDefaults = (options)=>{
     applySnapshotDefaults(options.snapshot, {
         production
     });
+    applyOutputDefaults(options, {
+        context: options.context,
+        targetProperties,
+        isAffectedByBrowserslist: void 0 === target || 'string' == typeof target && target.startsWith('browserslist') || Array.isArray(target) && target.some((target)=>target.startsWith('browserslist')),
+        entry: options.entry
+    });
     applyModuleDefaults(options.module, {
         asyncWebAssembly: options.experiments.asyncWebAssembly,
         targetProperties,
         mode: options.mode,
         uniqueName: options.output.uniqueName,
         deferImport: options.experiments.deferImport,
-        outputModule: options.output.module
-    });
-    applyOutputDefaults(options, {
-        context: options.context,
-        targetProperties,
-        isAffectedByBrowserslist: void 0 === target || 'string' == typeof target && target.startsWith('browserslist') || Array.isArray(target) && target.some((target)=>target.startsWith('browserslist')),
-        entry: options.entry
+        outputModule: options.output.module,
+        hashFunction: options.output.hashFunction,
+        hashSalt: options.output.hashSalt
     });
     applyExternalsPresetsDefaults(options.externalsPresets, {
         targetProperties,
@@ -61480,10 +62791,25 @@ const applyCssGeneratorOptionsDefaults = (generatorOptions, { targetProperties }
     D(generatorOptions, 'exportsOnly', !targetProperties || false === targetProperties.document);
     D(generatorOptions, 'esModule', true);
 };
+const applyCssModuleGeneratorOptionsDefaults = (generatorOptions, { hashFunction, hashSalt, localIdentName, targetProperties })=>{
+    D(generatorOptions, 'exportsOnly', !targetProperties || false === targetProperties.document);
+    D(generatorOptions, 'esModule', true);
+    D(generatorOptions, 'exportsConvention', 'as-is');
+    D(generatorOptions, 'localIdentName', localIdentName);
+    D(generatorOptions, 'localIdentHashSalt', hashSalt);
+    D(generatorOptions, 'localIdentHashFunction', hashFunction);
+    D(generatorOptions, 'localIdentHashDigest', 'base64url');
+    D(generatorOptions, 'localIdentHashDigestLength', 6);
+};
+const applyCssModuleParserOptionsDefaults = (parserOptions)=>{
+    D(parserOptions, 'namedExports', true);
+    D(parserOptions, 'url', true);
+    D(parserOptions, 'import', true);
+};
 const applyJsonGeneratorOptionsDefaults = (generatorOptions)=>{
     D(generatorOptions, 'JSONParse', true);
 };
-const applyModuleDefaults = (module, { asyncWebAssembly, targetProperties, mode, uniqueName, deferImport, outputModule })=>{
+const applyModuleDefaults = (module, { asyncWebAssembly, targetProperties, mode, uniqueName, deferImport, outputModule, hashFunction, hashSalt })=>{
     assertNotNill(module.parser);
     assertNotNill(module.generator);
     F(module.parser, "asset", ()=>({}));
@@ -61506,14 +62832,17 @@ const applyModuleDefaults = (module, { asyncWebAssembly, targetProperties, mode,
     assertNotNill(module.parser.css);
     D(module.parser.css, 'namedExports', true);
     D(module.parser.css, 'url', true);
+    D(module.parser.css, 'import', true);
+    D(module.parser.css, 'animation', true);
     F(module.parser, 'css/auto', ()=>({}));
     assertNotNill(module.parser['css/auto']);
-    D(module.parser['css/auto'], 'namedExports', true);
-    D(module.parser['css/auto'], 'url', true);
+    applyCssModuleParserOptionsDefaults(module.parser['css/auto']);
+    F(module.parser, 'css/global', ()=>({}));
+    assertNotNill(module.parser['css/global']);
+    applyCssModuleParserOptionsDefaults(module.parser['css/global']);
     F(module.parser, 'css/module', ()=>({}));
     assertNotNill(module.parser['css/module']);
-    D(module.parser['css/module'], 'namedExports', true);
-    D(module.parser['css/module'], 'url', true);
+    applyCssModuleParserOptionsDefaults(module.parser['css/module']);
     F(module.generator, 'css', ()=>({}));
     assertNotNill(module.generator.css);
     applyCssGeneratorOptionsDefaults(module.generator.css, {
@@ -61521,19 +62850,29 @@ const applyModuleDefaults = (module, { asyncWebAssembly, targetProperties, mode,
     });
     F(module.generator, 'css/auto', ()=>({}));
     assertNotNill(module.generator['css/auto']);
-    applyCssGeneratorOptionsDefaults(module.generator['css/auto'], {
+    const localIdentName = 'development' === mode ? uniqueName && uniqueName.length > 0 ? '[uniqueName]-[id]-[local]' : '[id]-[local]' : '[fullhash]';
+    applyCssModuleGeneratorOptionsDefaults(module.generator['css/auto'], {
+        hashFunction,
+        hashSalt,
+        localIdentName,
         targetProperties
     });
-    D(module.generator['css/auto'], 'exportsConvention', 'as-is');
-    const localIdentName = 'development' === mode ? uniqueName && uniqueName.length > 0 ? '[uniqueName]-[id]-[local]' : '[id]-[local]' : '[fullhash]';
-    D(module.generator['css/auto'], 'localIdentName', localIdentName);
     F(module.generator, 'css/module', ()=>({}));
     assertNotNill(module.generator['css/module']);
-    applyCssGeneratorOptionsDefaults(module.generator['css/module'], {
+    applyCssModuleGeneratorOptionsDefaults(module.generator['css/module'], {
+        hashFunction,
+        hashSalt,
+        localIdentName,
+        targetProperties
+    });
+    F(module.generator, 'css/global', ()=>({}));
+    assertNotNill(module.generator['css/global']);
+    applyCssModuleGeneratorOptionsDefaults(module.generator['css/global'], {
+        hashFunction,
+        hashSalt,
+        localIdentName,
         targetProperties
     });
-    D(module.generator['css/module'], 'exportsConvention', 'as-is');
-    D(module.generator['css/module'], 'localIdentName', localIdentName);
     A(module, 'defaultRules', ()=>{
         const esm = {
             type: "javascript/esm",
@@ -61699,6 +63038,7 @@ const applyOutputDefaults = (options, { context, targetProperties: tp, isAffecte
     F(environment, 'globalThis', ()=>tp && tp.globalThis);
     F(environment, 'bigIntLiteral', ()=>tp && optimistic(tp.bigIntLiteral));
     F(environment, 'const', ()=>tp && optimistic(tp.const));
+    F(environment, 'computedProperty', ()=>tp && optimistic(tp.computedProperty));
     F(environment, 'methodShorthand', ()=>tp && optimistic(tp.methodShorthand));
     F(environment, 'arrowFunction', ()=>tp && optimistic(tp.arrowFunction));
     F(environment, 'asyncFunction', ()=>tp && optimistic(tp.asyncFunction));
@@ -61858,7 +63198,7 @@ const applyOutputDefaults = (options, { context, targetProperties: tp, isAffecte
     });
     D(output, 'bundlerInfo', {});
     if ('object' == typeof output.bundlerInfo) {
-        D(output.bundlerInfo, 'version', "2.0.3");
+        D(output.bundlerInfo, 'version', "2.0.5");
         D(output.bundlerInfo, 'bundler', 'rspack');
         D(output.bundlerInfo, 'force', false);
     }
@@ -62829,7 +64169,7 @@ const mkdirp = (fs, p, callback)=>{
         callback();
     });
 };
-var FileSystem_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var FileSystem_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 const BUFFER_SIZE = 1000;
 const ASYNC_NOOP = async ()=>{};
 const NOOP_FILESYSTEM = {
@@ -63516,7 +64856,7 @@ class MultiStats {
             return obj;
         });
         if (childOptions.version) {
-            obj.rspackVersion = "2.0.3";
+            obj.rspackVersion = "2.0.5";
             obj.version = "5.75.0";
         }
         if (childOptions.hash) obj.hash = obj.children.map((j)=>j.hash).join('');
@@ -64393,7 +65733,7 @@ function nodeConsole({ colors, appendOnly, stream }) {
         }
     };
 }
-const CachedInputFileSystem = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.21.2/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js");
+const CachedInputFileSystem = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.21.3/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js");
 var CachedInputFileSystem_default = /*#__PURE__*/ __webpack_require__.n(CachedInputFileSystem);
 class NodeEnvironmentPlugin {
     options;
@@ -65222,7 +66562,7 @@ const SIMPLE_EXTRACTORS = {
         },
         version: (object)=>{
             object.version = "5.75.0";
-            object.rspackVersion = "2.0.3";
+            object.rspackVersion = "2.0.5";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -66726,15 +68066,18 @@ class RspackOptionsApply {
         compiler.outputFileSystem = fs_0["default"];
         if (options.externals) {
             if (!options.externalsType) throw new Error('options.externalsType should have a value after `applyRspackOptionsDefaults`');
-            new ExternalsPlugin(options.externalsType, options.externals, false).apply(compiler);
+            new ExternalsPlugin(options.externalsType, options.externals, false, getModernModuleCjsExternalType(options)).apply(compiler);
+        }
+        if (options.externalsPresets.node) {
+            new NodeTargetPlugin().apply(compiler);
+            new CssHttpExternalsRspackPlugin().apply(compiler);
         }
-        if (options.externalsPresets.node) new NodeTargetPlugin().apply(compiler);
         if (options.externalsPresets.electronMain) new ElectronTargetPlugin('main').apply(compiler);
         if (options.externalsPresets.electronPreload) new ElectronTargetPlugin('preload').apply(compiler);
         if (options.externalsPresets.electronRenderer) new ElectronTargetPlugin('renderer').apply(compiler);
         if (options.externalsPresets.electron && !options.externalsPresets.electronMain && !options.externalsPresets.electronPreload && !options.externalsPresets.electronRenderer) new ElectronTargetPlugin().apply(compiler);
         if (options.externalsPresets.nwjs) new ExternalsPlugin('node-commonjs', 'nw.gui', false).apply(compiler);
-        if (options.externalsPresets.web || options.externalsPresets.webAsync || options.externalsPresets.node) new HttpExternalsRspackPlugin(true, !!options.externalsPresets.webAsync).apply(compiler);
+        if (options.externalsPresets.web || options.externalsPresets.webAsync) new HttpExternalsRspackPlugin(!!options.externalsPresets.webAsync).apply(compiler);
         new ChunkPrefetchPreloadPlugin().apply(compiler);
         if (options.output.pathinfo) new ModuleInfoHeaderPlugin('verbose' === options.output.pathinfo).apply(compiler);
         if ('string' == typeof options.output.chunkFormat) switch(options.output.chunkFormat){
@@ -66801,6 +68144,7 @@ class RspackOptionsApply {
         if (options.optimization.mergeDuplicateChunks) new MergeDuplicateChunksPlugin().apply(compiler);
         if (options.optimization.sideEffects) new SideEffectsFlagPlugin(options.experiments.pureFunctions).apply(compiler);
         if (options.optimization.providedExports) new FlagDependencyExportsPlugin().apply(compiler);
+        if ('production' === options.mode) new CircularModulesInfoPlugin().apply(compiler);
         if (options.optimization.usedExports) new FlagDependencyUsagePlugin('global' === options.optimization.usedExports).apply(compiler);
         if (options.optimization.concatenateModules) new ModuleConcatenationPlugin().apply(compiler);
         if (options.optimization.inlineExports) new InlineExportsPlugin().apply(compiler);
@@ -66886,6 +68230,10 @@ class RspackOptionsApply {
         compiler.hooks.afterResolvers.call(compiler);
     }
 }
+function getModernModuleCjsExternalType(options) {
+    const presets = options.externalsPresets;
+    return presets.node || presets.electron || presets.electronMain || presets.electronPreload || presets.electronRenderer || presets.nwjs ? 'node-commonjs' : 'commonjs';
+}
 const validateConfig_ERROR_PREFIX = 'Invalid Rspack configuration:';
 const validateContext = ({ context })=>{
     if (context && !(0, path_browserify.isAbsolute)(context)) throw new Error(`${validateConfig_ERROR_PREFIX} "context" must be an absolute path, get "${context}".`);
@@ -67108,7 +68456,7 @@ const createHtmlPluginHooksRegisters = (getCompiler, createTap)=>{
         })
     };
 };
-var compilation_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var compilation_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 class CodeGenerationResult {
     #inner;
     constructor(result){
@@ -67576,7 +68924,7 @@ const createContextModuleFactoryHooksRegisters = (getCompiler, createTap)=>({
             };
         })
     });
-var javascriptModules_Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
+var javascriptModules_Buffer = __webpack_require__("./src/browser/buffer.ts")["h"];
 const createJavaScriptModulesHooksRegisters = (getCompiler, createTap)=>({
         registerJavascriptModulesChunkHashTaps: createTap(rspack_wasi_browser.RegisterJsTapKind.JavascriptModulesChunkHash, function() {
             return JavascriptModulesPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).chunkHash;
@@ -68461,7 +69809,7 @@ class Compiler {
         const rawOptions = getRawOptions(options, this);
         rawOptions.__references = Object.fromEntries(this.#ruleSet.builtinReferences.entries());
         rawOptions.__virtual_files = VirtualModulesPlugin.__internal__take_virtual_files(this);
-        const instanceBinding = __webpack_require__("@rspack/binding?5821");
+        const instanceBinding = __webpack_require__("@rspack/binding?d2c4");
         this.#registers = this.#createHooksRegisters();
         const inputFileSystem = this.inputFileSystem && ThreadsafeInputNodeFS.needsBinding(options.experiments.useInputFileSystem) ? ThreadsafeInputNodeFS.__to_binding(this.inputFileSystem) : void 0;
         try {
@@ -70051,7 +71399,7 @@ function transformSync(source, options) {
     const _options = JSON.stringify(options || {});
     return rspack_wasi_browser.transformSync(source, _options);
 }
-const exports_rspackVersion = "2.0.3";
+const exports_rspackVersion = "2.0.5";
 const exports_version = "5.75.0";
 const exports_WebpackError = Error;
 const exports_config = {