@rspack-debug/browser 2.0.4 → 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;
@@ -9792,7 +9881,7 @@ __webpack_require__.add({
         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"];
+        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);
@@ -9800,6 +9889,1088 @@ __webpack_require__.add({
             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;
+        };
+        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);
+        };
+        Buffer.prototype.writeFloatBE = function(value, offset, noAssert) {
+            return writeFloat(this, value, offset, false, noAssert);
+        };
+        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);
+        };
+        Buffer.prototype.writeDoubleBE = function(value, offset, noAssert) {
+            return writeDouble(this, value, offset, false, noAssert);
+        };
+        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;
+        };
+        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 this;
+        };
+        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);
+                }
+                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 asciiToBytes(str) {
+            var byteArray = [];
+            for(var i = 0; i < str.length; ++i)byteArray.push(0xFF & str.charCodeAt(i));
+            return byteArray;
+        }
+        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 base64ToBytes(str) {
+            return base64.toByteArray(base64clean(str));
+        }
+        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];
+            }
+            return i;
+        }
+        function isInstance(obj, type) {
+            return obj instanceof type || null != obj && null != obj.constructor && null != obj.constructor.name && obj.constructor.name === type.name;
+        }
+        function numberIsNaN(obj) {
+            return obj !== obj;
+        }
+        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];
+            }
+            return table;
+        }();
+    },
     "../../node_modules/.pnpm/builtin-status-codes@3.0.0/node_modules/builtin-status-codes/browser.js" (module) {
         module.exports = {
             100: "Continue",
@@ -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();
@@ -14617,7 +15788,7 @@ __webpack_require__.add({
         utils.intFromLE = intFromLE;
     },
     "../../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")["Buffer"];
+        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;
@@ -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) {
@@ -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?c724");
+        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?c724" (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);
@@ -56121,7 +57361,7 @@ function canInherentFromParent(affectedHooks) {
     if (void 0 === affectedHooks) return false;
     return !HOOKS_CAN_NOT_INHERENT_FROM_PARENT.includes(affectedHooks);
 }
-class base_RspackBuiltinPlugin {
+class RspackBuiltinPlugin {
     affectedHooks;
     apply(compiler) {
         const raw = this.raw(compiler);
@@ -56131,14 +57371,14 @@ class base_RspackBuiltinPlugin {
         }
     }
 }
-function base_createBuiltinPlugin(name, options) {
+function createBuiltinPlugin(name, options) {
     return {
         name: name,
         options: options ?? false
     };
 }
 function base_create(name, resolve, affectedHooks) {
-    class Plugin extends base_RspackBuiltinPlugin {
+    class Plugin extends RspackBuiltinPlugin {
         name = name;
         _args;
         affectedHooks = affectedHooks;
@@ -56147,7 +57387,7 @@ function base_create(name, resolve, affectedHooks) {
             this._args = args;
         }
         raw(compiler) {
-            return base_createBuiltinPlugin(name, resolve.apply(compiler, this._args));
+            return createBuiltinPlugin(name, resolve.apply(compiler, this._args));
         }
     }
     Object.defineProperty(Plugin, 'name', {
@@ -56186,13 +57426,13 @@ 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 null {
-    name = BuiltinPluginName.CircularModulesInfoPlugin;
+class CircularModulesInfoPlugin extends RspackBuiltinPlugin {
+    name = external_rspack_wasi_browser_js_BuiltinPluginName.CircularModulesInfoPlugin;
     raw(_compiler) {
         return createBuiltinPlugin(this.name, void 0);
     }
 }
-class CircularDependencyRspackPlugin extends base_RspackBuiltinPlugin {
+class CircularDependencyRspackPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.CircularDependencyRspackPlugin;
     _options;
     constructor(options){
@@ -56222,7 +57462,7 @@ class CircularDependencyRspackPlugin extends base_RspackBuiltinPlugin {
                 this._options.onEnd(compilation);
             } : void 0
         };
-        return base_createBuiltinPlugin(this.name, rawOptions);
+        return createBuiltinPlugin(this.name, rawOptions);
     }
 }
 const CommonJsChunkFormatPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.CommonJsChunkFormatPlugin, ()=>{});
@@ -56373,18 +57613,18 @@ const normalizeValue = (define1, supportsBigIntLiteral)=>{
     };
     return normalizeObject(define1);
 };
-class DeterministicChunkIdsPlugin extends base_RspackBuiltinPlugin {
+class DeterministicChunkIdsPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.DeterministicChunkIdsPlugin;
     affectedHooks = 'compilation';
     raw() {
-        return base_createBuiltinPlugin(this.name, void 0);
+        return createBuiltinPlugin(this.name, void 0);
     }
 }
-class DeterministicModuleIdsPlugin extends base_RspackBuiltinPlugin {
+class DeterministicModuleIdsPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.DeterministicModuleIdsPlugin;
     affectedHooks = 'compilation';
     raw() {
-        return base_createBuiltinPlugin(this.name, void 0);
+        return createBuiltinPlugin(this.name, void 0);
     }
 }
 const DllEntryPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.DllEntryPlugin, (context, entries, options)=>({
@@ -56453,7 +57693,7 @@ function getRawEntryOptions(entry) {
         dependOn: entry.dependOn
     };
 }
-class DynamicEntryPlugin extends base_RspackBuiltinPlugin {
+class DynamicEntryPlugin extends RspackBuiltinPlugin {
     context;
     entry;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.DynamicEntryPlugin;
@@ -56475,7 +57715,7 @@ class DynamicEntryPlugin extends base_RspackBuiltinPlugin {
                 });
             }
         };
-        return base_createBuiltinPlugin(this.name, raw);
+        return createBuiltinPlugin(this.name, raw);
     }
 }
 const ElectronTargetPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.ElectronTargetPlugin, (context)=>context ?? 'none');
@@ -56532,7 +57772,7 @@ class JsSplitChunkSizes {
         return sizes;
     }
 }
-class SplitChunksPlugin extends base_RspackBuiltinPlugin {
+class SplitChunksPlugin extends RspackBuiltinPlugin {
     options;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.SplitChunksPlugin;
     affectedHooks = 'thisCompilation';
@@ -56542,7 +57782,7 @@ class SplitChunksPlugin extends base_RspackBuiltinPlugin {
     raw(compiler) {
         const rawOptions = SplitChunksPlugin_toRawSplitChunksOptions(this.options, compiler);
         if (void 0 === rawOptions) throw new Error('rawOptions should not be undefined');
-        return base_createBuiltinPlugin(this.name, rawOptions);
+        return createBuiltinPlugin(this.name, rawOptions);
     }
 }
 function SplitChunksPlugin_toRawSplitChunksOptions(sc, compiler) {
@@ -56615,7 +57855,7 @@ const EnableLibraryPlugin_getEnabledTypes = (compiler)=>{
     }
     return set;
 };
-class EnableLibraryPlugin extends base_RspackBuiltinPlugin {
+class EnableLibraryPlugin extends RspackBuiltinPlugin {
     type;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.EnableLibraryPlugin;
     constructor(type){
@@ -56632,7 +57872,7 @@ class EnableLibraryPlugin extends base_RspackBuiltinPlugin {
         const enabled = EnableLibraryPlugin_getEnabledTypes(compiler);
         if (enabled.has(type)) return;
         enabled.add(type);
-        return base_createBuiltinPlugin(this.name, {
+        return createBuiltinPlugin(this.name, {
             libraryType: type,
             preserveModules: compiler.options.output.library?.preserveModules,
             splitChunks: SplitChunksPlugin_toRawSplitChunksOptions(compiler.options.optimization.splitChunks ?? false, compiler)
@@ -56664,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;
 }
@@ -57362,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;
@@ -57481,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) {
@@ -57490,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) {
@@ -57499,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 {
@@ -57670,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';
@@ -58571,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),
@@ -58805,7 +60046,7 @@ function getRawParserOptions(parser, type) {
     };
     if ('css' === type) return {
         type: 'css',
-        css: getRawCssParserOptions(parser)
+        css: getRawCssParserOptionsForCss(parser)
     };
     if ('css/auto' === type) return {
         type: 'css/auto',
@@ -58877,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) {
@@ -59001,26 +60257,28 @@ function getRawStats(stats) {
         colors
     };
 }
-class ExternalsPlugin extends base_RspackBuiltinPlugin {
+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)),
             placeInInitial: this.placeInInitial ?? false
         };
-        return base_createBuiltinPlugin(this.name, raw);
+        return createBuiltinPlugin(this.name, raw);
     }
     #processResolveResult = (text)=>{
         if (!text) return;
@@ -59109,7 +60367,7 @@ function getRawExternalItemValue(value) {
 const FetchCompileAsyncWasmPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.FetchCompileAsyncWasmPlugin, ()=>{}, 'thisCompilation');
 const FileUriPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.FileUriPlugin, ()=>{}, 'compilation');
 const FlagDependencyExportsPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.FlagDependencyExportsPlugin, ()=>{}, 'compilation');
-class FlagDependencyUsagePlugin extends base_RspackBuiltinPlugin {
+class FlagDependencyUsagePlugin extends RspackBuiltinPlugin {
     global;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.FlagDependencyUsagePlugin;
     affectedHooks = 'compilation';
@@ -59117,23 +60375,23 @@ class FlagDependencyUsagePlugin extends base_RspackBuiltinPlugin {
         super(), this.global = global;
     }
     raw() {
-        return base_createBuiltinPlugin(this.name, this.global);
+        return createBuiltinPlugin(this.name, this.global);
     }
 }
 const HashedModuleIdsPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.HashedModuleIdsPlugin, (options)=>({
         ...options
     }), 'compilation');
-class HotModuleReplacementPlugin extends base_RspackBuiltinPlugin {
+class HotModuleReplacementPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.HotModuleReplacementPlugin;
     raw(compiler) {
         if (void 0 === compiler.options.output.strictModuleErrorHandling) compiler.options.output.strictModuleErrorHandling = true;
-        return base_createBuiltinPlugin(this.name, void 0);
+        return createBuiltinPlugin(this.name, void 0);
     }
 }
 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)=>{
@@ -59149,7 +60407,7 @@ const defaultHttpClientForBrowser = async (url, headers)=>{
         body: HttpUriPlugin_Buffer.from(await res.arrayBuffer())
     };
 };
-class HttpUriPlugin extends base_RspackBuiltinPlugin {
+class HttpUriPlugin extends RspackBuiltinPlugin {
     options;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.HttpUriPlugin;
     affectedHooks = 'compilation';
@@ -59168,7 +60426,7 @@ class HttpUriPlugin extends base_RspackBuiltinPlugin {
             upgrade: options.upgrade ?? false,
             httpClient: options.httpClient ?? defaultHttpClient
         };
-        return base_createBuiltinPlugin(this.name, raw);
+        return createBuiltinPlugin(this.name, raw);
     }
 }
 const compilationOptionsMap = new WeakMap();
@@ -59384,11 +60642,11 @@ const IgnorePlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginNa
 const InferAsyncModulesPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.InferAsyncModulesPlugin, ()=>{}, 'compilation');
 const InlineExportsPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.InlineExportsPlugin, ()=>{}, 'compilation');
 const JavascriptModulesPlugin_compilationHooksMap = new WeakMap();
-class JavascriptModulesPlugin extends base_RspackBuiltinPlugin {
+class JavascriptModulesPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.JavascriptModulesPlugin;
     affectedHooks = 'compilation';
     raw() {
-        return base_createBuiltinPlugin(this.name, void 0);
+        return createBuiltinPlugin(this.name, void 0);
     }
     static getCompilationHooks(compilation) {
         checkCompilation(compilation);
@@ -59455,7 +60713,7 @@ const LimitChunkCountPlugin = base_create(external_rspack_wasi_browser_js_Builti
 const lazyCompilationMiddleware = ()=>{
     throw new Error('lazy compilation middleware is not supported in browser');
 };
-class MangleExportsPlugin extends base_RspackBuiltinPlugin {
+class MangleExportsPlugin extends RspackBuiltinPlugin {
     deterministic;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.MangleExportsPlugin;
     affectedHooks = 'compilation';
@@ -59463,33 +60721,33 @@ class MangleExportsPlugin extends base_RspackBuiltinPlugin {
         super(), this.deterministic = deterministic;
     }
     raw() {
-        return base_createBuiltinPlugin(this.name, this.deterministic);
+        return createBuiltinPlugin(this.name, this.deterministic);
     }
 }
 const MergeDuplicateChunksPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.MergeDuplicateChunksPlugin, ()=>{});
 const ModuleChunkFormatPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.ModuleChunkFormatPlugin, ()=>{});
-class ModuleConcatenationPlugin extends base_RspackBuiltinPlugin {
+class ModuleConcatenationPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.ModuleConcatenationPlugin;
     affectedHooks = 'compilation';
     raw() {
-        return base_createBuiltinPlugin(this.name, void 0);
+        return createBuiltinPlugin(this.name, void 0);
     }
 }
 const ModuleInfoHeaderPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.ModuleInfoHeaderPlugin, (verbose)=>verbose, 'compilation');
 const NamedChunkIdsPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.NamedChunkIdsPlugin, ()=>{}, 'compilation');
 const NamedModuleIdsPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.NamedModuleIdsPlugin, ()=>{}, 'compilation');
-class NaturalChunkIdsPlugin extends base_RspackBuiltinPlugin {
+class NaturalChunkIdsPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.NaturalChunkIdsPlugin;
     affectedHooks = 'compilation';
     raw() {
-        return base_createBuiltinPlugin(this.name, void 0);
+        return createBuiltinPlugin(this.name, void 0);
     }
 }
-class NaturalModuleIdsPlugin extends base_RspackBuiltinPlugin {
+class NaturalModuleIdsPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.NaturalModuleIdsPlugin;
     affectedHooks = 'compilation';
     raw() {
-        return base_createBuiltinPlugin(this.name, void 0);
+        return createBuiltinPlugin(this.name, void 0);
     }
 }
 const NodeTargetPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.NodeTargetPlugin, ()=>void 0);
@@ -59711,7 +60969,7 @@ class Coordinator {
         });
     }
 }
-class RscClientPlugin extends base_RspackBuiltinPlugin {
+class RscClientPlugin extends RspackBuiltinPlugin {
     name = 'RscClientPlugin';
     #options;
     constructor(options){
@@ -59720,12 +60978,12 @@ class RscClientPlugin extends base_RspackBuiltinPlugin {
     }
     raw(compiler) {
         this.#options.coordinator.applyClientCompiler(compiler);
-        return base_createBuiltinPlugin(this.name, {
+        return createBuiltinPlugin(this.name, {
             coordinator: this.#options.coordinator[GET_OR_INIT_BINDING]()
         });
     }
 }
-class RscServerPlugin extends base_RspackBuiltinPlugin {
+class RscServerPlugin extends RspackBuiltinPlugin {
     name = 'RscServerPlugin';
     #options;
     constructor(options){
@@ -59737,7 +60995,7 @@ class RscServerPlugin extends base_RspackBuiltinPlugin {
         const { coordinator, onServerComponentChanges } = this.#options;
         let onManifest;
         if (this.#options.onManifest) onManifest = (json)=>Promise.resolve(this.#options.onManifest(JSON.parse(json)));
-        return base_createBuiltinPlugin(this.name, {
+        return createBuiltinPlugin(this.name, {
             coordinator: coordinator[GET_OR_INIT_BINDING](),
             cssLink: this.#options.cssLink,
             onServerComponentChanges,
@@ -59771,7 +61029,7 @@ const rsc = {
         ssr: 'server-side-rendering'
     }
 };
-class SideEffectsFlagPlugin extends base_RspackBuiltinPlugin {
+class SideEffectsFlagPlugin extends RspackBuiltinPlugin {
     analyzeSideEffectsFree;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.SideEffectsFlagPlugin;
     affectedHooks = 'compilation';
@@ -59779,7 +61037,7 @@ class SideEffectsFlagPlugin extends base_RspackBuiltinPlugin {
         super(), this.analyzeSideEffectsFree = analyzeSideEffectsFree;
     }
     raw() {
-        return base_createBuiltinPlugin(this.name, this.analyzeSideEffectsFree);
+        return createBuiltinPlugin(this.name, this.analyzeSideEffectsFree);
     }
 }
 const SizeLimitsPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.SizeLimitsPlugin, (options)=>{
@@ -59790,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?:/;
@@ -60021,7 +61279,7 @@ const SwcJsMinimizerRspackPlugin = base_create(external_rspack_wasi_browser_js_B
     };
 }, 'compilation');
 const URLPlugin = base_create(external_rspack_wasi_browser_js_BuiltinPluginName.URLPlugin, ()=>{}, 'compilation');
-class WorkerPlugin extends base_RspackBuiltinPlugin {
+class WorkerPlugin extends RspackBuiltinPlugin {
     chunkLoading;
     wasmLoading;
     module;
@@ -60034,7 +61292,7 @@ class WorkerPlugin extends base_RspackBuiltinPlugin {
     raw(compiler) {
         if (this.chunkLoading) new EnableChunkLoadingPlugin(this.chunkLoading).apply(compiler);
         if (this.wasmLoading) new EnableWasmLoadingPlugin(this.wasmLoading).apply(compiler);
-        return base_createBuiltinPlugin(this.name, void 0);
+        return createBuiltinPlugin(this.name, void 0);
     }
 }
 class ContextModuleFactory {
@@ -60746,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,
@@ -61165,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),
@@ -61210,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),
@@ -61250,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),
@@ -61274,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,
@@ -61510,6 +62801,11 @@ const applyCssModuleGeneratorOptionsDefaults = (generatorOptions, { 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);
 };
@@ -61536,18 +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']);
-    D(module.parser['css/global'], 'namedExports', true);
-    D(module.parser['css/global'], 'url', true);
+    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, {
@@ -61743,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));
@@ -61902,7 +63198,7 @@ const applyOutputDefaults = (options, { context, targetProperties: tp, isAffecte
     });
     D(output, 'bundlerInfo', {});
     if ('object' == typeof output.bundlerInfo) {
-        D(output.bundlerInfo, 'version', "2.0.4");
+        D(output.bundlerInfo, 'version', "2.0.5");
         D(output.bundlerInfo, 'bundler', 'rspack');
         D(output.bundlerInfo, 'force', false);
     }
@@ -62873,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 = {
@@ -63560,7 +64856,7 @@ class MultiStats {
             return obj;
         });
         if (childOptions.version) {
-            obj.rspackVersion = "2.0.4";
+            obj.rspackVersion = "2.0.5";
             obj.version = "5.75.0";
         }
         if (childOptions.hash) obj.hash = obj.children.map((j)=>j.hash).join('');
@@ -65266,7 +66562,7 @@ const SIMPLE_EXTRACTORS = {
         },
         version: (object)=>{
             object.version = "5.75.0";
-            object.rspackVersion = "2.0.4";
+            object.rspackVersion = "2.0.5";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -66770,7 +68066,7 @@ 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);
@@ -66848,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);
@@ -66933,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}".`);
@@ -67155,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){
@@ -67623,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;
@@ -68508,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?c724");
+        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 {
@@ -68951,7 +70252,7 @@ function isSingleton(compiler) {
 function setSingleton(compiler) {
     compilerSet.add(compiler);
 }
-class ShareRuntimePlugin extends base_RspackBuiltinPlugin {
+class ShareRuntimePlugin extends RspackBuiltinPlugin {
     enhanced;
     name = external_rspack_wasi_browser_js_BuiltinPluginName.ShareRuntimePlugin;
     constructor(enhanced = false){
@@ -68960,7 +70261,7 @@ class ShareRuntimePlugin extends base_RspackBuiltinPlugin {
     raw(compiler) {
         if (isSingleton(compiler)) return;
         setSingleton(compiler);
-        return base_createBuiltinPlugin(this.name, this.enhanced);
+        return createBuiltinPlugin(this.name, this.enhanced);
     }
 }
 const VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
@@ -69008,7 +70309,7 @@ function normalizeConsumeShareOptions(consumes, shareScope) {
             treeShakingMode: item.treeShakingMode
         }));
 }
-class ConsumeSharedPlugin extends base_RspackBuiltinPlugin {
+class ConsumeSharedPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.ConsumeSharedPlugin;
     _options;
     constructor(options){
@@ -69027,7 +70328,7 @@ class ConsumeSharedPlugin extends base_RspackBuiltinPlugin {
                 })),
             enhanced: this._options.enhanced
         };
-        return base_createBuiltinPlugin(this.name, rawOptions);
+        return createBuiltinPlugin(this.name, rawOptions);
     }
 }
 function normalizeProvideShareOptions(options, shareScope, enhanced) {
@@ -69059,7 +70360,7 @@ function normalizeProvideShareOptions(options, shareScope, enhanced) {
         return raw;
     });
 }
-class ProvideSharedPlugin extends base_RspackBuiltinPlugin {
+class ProvideSharedPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.ProvideSharedPlugin;
     _provides;
     _enhanced;
@@ -69074,7 +70375,7 @@ class ProvideSharedPlugin extends base_RspackBuiltinPlugin {
                 key,
                 ...v
             }));
-        return base_createBuiltinPlugin(this.name, rawOptions);
+        return createBuiltinPlugin(this.name, rawOptions);
     }
 }
 function validateShareScope(shareScope, enhanced, pluginName) {
@@ -69299,7 +70600,7 @@ function normalizeManifestOptions(mfConfig) {
         name: containerName
     };
 }
-class ModuleFederationManifestPlugin extends base_RspackBuiltinPlugin {
+class ModuleFederationManifestPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.ModuleFederationManifestPlugin;
     rawOpts;
     constructor(opts){
@@ -69323,11 +70624,11 @@ class ModuleFederationManifestPlugin extends base_RspackBuiltinPlugin {
             shared,
             buildInfo: getBuildInfo('development' === compiler.options.mode, compiler, this.rawOpts)
         };
-        return base_createBuiltinPlugin(this.name, rawOptions);
+        return createBuiltinPlugin(this.name, rawOptions);
     }
 }
 const SHARE_ENTRY_ASSET = 'collect-shared-entries.json';
-class CollectSharedEntryPlugin extends base_RspackBuiltinPlugin {
+class CollectSharedEntryPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.CollectSharedEntryPlugin;
     sharedOptions;
     _collectedEntries;
@@ -69367,14 +70668,14 @@ class CollectSharedEntryPlugin extends base_RspackBuiltinPlugin {
                 })),
             filename: this.getFilename()
         };
-        return base_createBuiltinPlugin(this.name, rawOptions);
+        return createBuiltinPlugin(this.name, rawOptions);
     }
 }
 function assert(condition, msg) {
     if (!condition) throw new Error(msg);
 }
 const HOT_UPDATE_SUFFIX = '.hot-update';
-class SharedContainerPlugin extends base_RspackBuiltinPlugin {
+class SharedContainerPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.SharedContainerPlugin;
     filename = '';
     _options;
@@ -69411,7 +70712,7 @@ class SharedContainerPlugin extends base_RspackBuiltinPlugin {
     raw(compiler) {
         const { library } = this._options;
         if (!compiler.options.output.enabledLibraryTypes.includes(library.type)) compiler.options.output.enabledLibraryTypes.push(library.type);
-        return base_createBuiltinPlugin(this.name, this._options);
+        return createBuiltinPlugin(this.name, this._options);
     }
     apply(compiler) {
         super.apply(compiler);
@@ -69432,7 +70733,7 @@ class SharedContainerPlugin extends base_RspackBuiltinPlugin {
         });
     }
 }
-class SharedUsedExportsOptimizerPlugin extends base_RspackBuiltinPlugin {
+class SharedUsedExportsOptimizerPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.SharedUsedExportsOptimizerPlugin;
     sharedOptions;
     injectTreeShakingUsedExports;
@@ -69459,7 +70760,7 @@ class SharedUsedExportsOptimizerPlugin extends base_RspackBuiltinPlugin {
     }
     raw() {
         if (!this.sharedOptions.length) return;
-        return base_createBuiltinPlugin(this.name, this.buildOptions());
+        return createBuiltinPlugin(this.name, this.buildOptions());
     }
 }
 const VIRTUAL_ENTRY = './virtual-entry.js';
@@ -69940,7 +71241,7 @@ function getDefaultEntryRuntime(paths, options, compiler, treeShakingShareFallba
     ].join(';');
     return `@module-federation/runtime/rspack.js!=!data:text/javascript,${encodeURIComponent(content)}`;
 }
-class ContainerPlugin extends base_RspackBuiltinPlugin {
+class ContainerPlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.ContainerPlugin;
     _options;
     constructor(options){
@@ -69987,10 +71288,10 @@ class ContainerPlugin extends base_RspackBuiltinPlugin {
                 })),
             enhanced
         };
-        return base_createBuiltinPlugin(this.name, rawOptions);
+        return createBuiltinPlugin(this.name, rawOptions);
     }
 }
-class ContainerReferencePlugin extends base_RspackBuiltinPlugin {
+class ContainerReferencePlugin extends RspackBuiltinPlugin {
     name = external_rspack_wasi_browser_js_BuiltinPluginName.ContainerReferencePlugin;
     _options;
     constructor(options){
@@ -70040,7 +71341,7 @@ class ContainerReferencePlugin extends base_RspackBuiltinPlugin {
                 })),
             enhanced: this._options.enhanced
         };
-        return base_createBuiltinPlugin(this.name, rawOptions);
+        return createBuiltinPlugin(this.name, rawOptions);
     }
 }
 class ModuleFederationPluginV1 {
@@ -70098,7 +71399,7 @@ function transformSync(source, options) {
     const _options = JSON.stringify(options || {});
     return rspack_wasi_browser.transformSync(source, _options);
 }
-const exports_rspackVersion = "2.0.4";
+const exports_rspackVersion = "2.0.5";
 const exports_version = "5.75.0";
 const exports_WebpackError = Error;
 const exports_config = {