@rspack/cli 2.0.0-rc.0 → 2.0.0-rc.1

package/dist/json-ext.js

@@ -0,0 +1,772 @@
+import { __webpack_require__ } from "./697.js";
+import "./697.js";
+__webpack_require__.add({
+    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = {
+            version: __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/version.js"),
+            stringifyInfo: __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/stringify-info.js"),
+            stringifyStream: __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/stringify-stream.js"),
+            parseChunked: __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/parse-chunked.js")
+        };
+    },
+    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/parse-chunked.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const { isReadableStream } = __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/utils.js");
+        const TextDecoder = __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/text-decoder.js");
+        const STACK_OBJECT = 1;
+        const STACK_ARRAY = 2;
+        const decoder = new TextDecoder();
+        function isObject(value) {
+            return null !== value && 'object' == typeof value;
+        }
+        function adjustPosition(error, parser) {
+            if ('SyntaxError' === error.name && parser.jsonParseOffset) error.message = error.message.replace(/at position (\d+)/, (_, pos)=>'at position ' + (Number(pos) + parser.jsonParseOffset));
+            return error;
+        }
+        function append(array, elements) {
+            const initialLength = array.length;
+            array.length += elements.length;
+            for(let i = 0; i < elements.length; i++)array[initialLength + i] = elements[i];
+        }
+        module.exports = function(chunkEmitter) {
+            let parser = new ChunkParser();
+            if (isObject(chunkEmitter) && isReadableStream(chunkEmitter)) return new Promise((resolve, reject)=>{
+                chunkEmitter.on('data', (chunk)=>{
+                    try {
+                        parser.push(chunk);
+                    } catch (e) {
+                        reject(adjustPosition(e, parser));
+                        parser = null;
+                    }
+                }).on('error', (e)=>{
+                    parser = null;
+                    reject(e);
+                }).on('end', ()=>{
+                    try {
+                        resolve(parser.finish());
+                    } catch (e) {
+                        reject(adjustPosition(e, parser));
+                    } finally{
+                        parser = null;
+                    }
+                });
+            });
+            if ('function' == typeof chunkEmitter) {
+                const iterator = chunkEmitter();
+                if (isObject(iterator) && (Symbol.iterator in iterator || Symbol.asyncIterator in iterator)) return new Promise(async (resolve, reject)=>{
+                    try {
+                        for await (const chunk of iterator)parser.push(chunk);
+                        resolve(parser.finish());
+                    } catch (e) {
+                        reject(adjustPosition(e, parser));
+                    } finally{
+                        parser = null;
+                    }
+                });
+            }
+            throw new Error("Chunk emitter should be readable stream, generator, async generator or function returning an iterable object");
+        };
+        class ChunkParser {
+            constructor(){
+                this.value = void 0;
+                this.valueStack = null;
+                this.stack = new Array(100);
+                this.lastFlushDepth = 0;
+                this.flushDepth = 0;
+                this.stateString = false;
+                this.stateStringEscape = false;
+                this.pendingByteSeq = null;
+                this.pendingChunk = null;
+                this.chunkOffset = 0;
+                this.jsonParseOffset = 0;
+            }
+            parseAndAppend(fragment, wrap) {
+                if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {
+                    if (wrap) {
+                        this.jsonParseOffset--;
+                        fragment = '{' + fragment + '}';
+                    }
+                    Object.assign(this.valueStack.value, JSON.parse(fragment));
+                } else {
+                    if (wrap) {
+                        this.jsonParseOffset--;
+                        fragment = '[' + fragment + ']';
+                    }
+                    append(this.valueStack.value, JSON.parse(fragment));
+                }
+            }
+            prepareAddition(fragment) {
+                const { value } = this.valueStack;
+                const expectComma = Array.isArray(value) ? 0 !== value.length : 0 !== Object.keys(value).length;
+                if (expectComma) {
+                    if (',' === fragment[0]) {
+                        this.jsonParseOffset++;
+                        return fragment.slice(1);
+                    }
+                    if ('}' !== fragment[0] && ']' !== fragment[0]) {
+                        this.jsonParseOffset -= 3;
+                        return '[[]' + fragment;
+                    }
+                }
+                return fragment;
+            }
+            flush(chunk, start, end) {
+                let fragment = chunk.slice(start, end);
+                this.jsonParseOffset = this.chunkOffset + start;
+                if (null !== this.pendingChunk) {
+                    fragment = this.pendingChunk + fragment;
+                    this.jsonParseOffset -= this.pendingChunk.length;
+                    this.pendingChunk = null;
+                }
+                if (this.flushDepth === this.lastFlushDepth) if (this.flushDepth > 0) this.parseAndAppend(this.prepareAddition(fragment), true);
+                else {
+                    this.value = JSON.parse(fragment);
+                    this.valueStack = {
+                        value: this.value,
+                        prev: null
+                    };
+                }
+                else if (this.flushDepth > this.lastFlushDepth) {
+                    for(let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--)fragment += this.stack[i] === STACK_OBJECT ? '}' : ']';
+                    if (0 === this.lastFlushDepth) {
+                        this.value = JSON.parse(fragment);
+                        this.valueStack = {
+                            value: this.value,
+                            prev: null
+                        };
+                    } else this.parseAndAppend(this.prepareAddition(fragment), true);
+                    for(let i = this.lastFlushDepth || 1; i < this.flushDepth; i++){
+                        let value = this.valueStack.value;
+                        if (this.stack[i - 1] === STACK_OBJECT) {
+                            let key;
+                            for(key in value);
+                            value = value[key];
+                        } else value = value[value.length - 1];
+                        this.valueStack = {
+                            value,
+                            prev: this.valueStack
+                        };
+                    }
+                } else {
+                    fragment = this.prepareAddition(fragment);
+                    for(let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--){
+                        this.jsonParseOffset--;
+                        fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment;
+                    }
+                    this.parseAndAppend(fragment, false);
+                    for(let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--)this.valueStack = this.valueStack.prev;
+                }
+                this.lastFlushDepth = this.flushDepth;
+            }
+            push(chunk) {
+                if ('string' != typeof chunk) {
+                    if (null !== this.pendingByteSeq) {
+                        const origRawChunk = chunk;
+                        chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);
+                        chunk.set(this.pendingByteSeq);
+                        chunk.set(origRawChunk, this.pendingByteSeq.length);
+                        this.pendingByteSeq = null;
+                    }
+                    if (chunk[chunk.length - 1] > 127) for(let seqLength = 0; seqLength < chunk.length; seqLength++){
+                        const byte = chunk[chunk.length - 1 - seqLength];
+                        if (byte >> 6 === 3) {
+                            seqLength++;
+                            if (4 !== seqLength && byte >> 3 === 30 || 3 !== seqLength && byte >> 4 === 14 || 2 !== seqLength && byte >> 5 === 6) {
+                                this.pendingByteSeq = chunk.slice(chunk.length - seqLength);
+                                chunk = chunk.slice(0, -seqLength);
+                            }
+                            break;
+                        }
+                    }
+                    chunk = decoder.decode(chunk);
+                }
+                const chunkLength = chunk.length;
+                let lastFlushPoint = 0;
+                let flushPoint = 0;
+                scan: for(let i = 0; i < chunkLength; i++){
+                    if (this.stateString) {
+                        for(; i < chunkLength; i++)if (this.stateStringEscape) this.stateStringEscape = false;
+                        else switch(chunk.charCodeAt(i)){
+                            case 0x22:
+                                this.stateString = false;
+                                continue scan;
+                            case 0x5C:
+                                this.stateStringEscape = true;
+                        }
+                        break;
+                    }
+                    switch(chunk.charCodeAt(i)){
+                        case 0x22:
+                            this.stateString = true;
+                            this.stateStringEscape = false;
+                            break;
+                        case 0x2C:
+                            flushPoint = i;
+                            break;
+                        case 0x7B:
+                            flushPoint = i + 1;
+                            this.stack[this.flushDepth++] = STACK_OBJECT;
+                            break;
+                        case 0x5B:
+                            flushPoint = i + 1;
+                            this.stack[this.flushDepth++] = STACK_ARRAY;
+                            break;
+                        case 0x5D:
+                        case 0x7D:
+                            flushPoint = i + 1;
+                            this.flushDepth--;
+                            if (this.flushDepth < this.lastFlushDepth) {
+                                this.flush(chunk, lastFlushPoint, flushPoint);
+                                lastFlushPoint = flushPoint;
+                            }
+                            break;
+                        case 0x09:
+                        case 0x0A:
+                        case 0x0D:
+                        case 0x20:
+                            if (lastFlushPoint === i) lastFlushPoint++;
+                            if (flushPoint === i) flushPoint++;
+                            break;
+                    }
+                }
+                if (flushPoint > lastFlushPoint) this.flush(chunk, lastFlushPoint, flushPoint);
+                if (flushPoint < chunkLength) if (null !== this.pendingChunk) this.pendingChunk += chunk;
+                else this.pendingChunk = chunk.slice(flushPoint, chunkLength);
+                this.chunkOffset += chunkLength;
+            }
+            finish() {
+                if (null !== this.pendingChunk) {
+                    this.flush('', 0, 0);
+                    this.pendingChunk = null;
+                }
+                return this.value;
+            }
+        }
+    },
+    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/stringify-info.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const { normalizeReplacer, normalizeSpace, replaceValue, getTypeNative, getTypeAsync, isLeadingSurrogate, isTrailingSurrogate, escapableCharCodeSubstitution, type: { PRIMITIVE, OBJECT, ARRAY, PROMISE, STRING_STREAM, OBJECT_STREAM } } = __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/utils.js");
+        const charLength2048 = Array.from({
+            length: 2048
+        }).map((_, code)=>{
+            if (escapableCharCodeSubstitution.hasOwnProperty(code)) return 2;
+            if (code < 0x20) return 6;
+            return code < 128 ? 1 : 2;
+        });
+        function stringLength(str) {
+            let len = 0;
+            let prevLeadingSurrogate = false;
+            for(let i = 0; i < str.length; i++){
+                const code = str.charCodeAt(i);
+                if (code < 2048) len += charLength2048[code];
+                else if (isLeadingSurrogate(code)) {
+                    len += 6;
+                    prevLeadingSurrogate = true;
+                    continue;
+                } else if (isTrailingSurrogate(code)) len = prevLeadingSurrogate ? len - 2 : len + 6;
+                else len += 3;
+                prevLeadingSurrogate = false;
+            }
+            return len + 2;
+        }
+        function primitiveLength(value) {
+            switch(typeof value){
+                case 'string':
+                    return stringLength(value);
+                case 'number':
+                    return Number.isFinite(value) ? String(value).length : 4;
+                case 'boolean':
+                    return value ? 4 : 5;
+                case 'undefined':
+                case 'object':
+                    return 4;
+                default:
+                    return 0;
+            }
+        }
+        function spaceLength(space) {
+            space = normalizeSpace(space);
+            return 'string' == typeof space ? space.length : 0;
+        }
+        module.exports = function(value, replacer, space, options) {
+            function walk(holder, key, value) {
+                if (stop) return;
+                value = replaceValue(holder, key, value, replacer);
+                let type = getType(value);
+                if (type !== PRIMITIVE && stack.has(value)) {
+                    circular.add(value);
+                    length += 4;
+                    if (!options.continueOnCircular) stop = true;
+                    return;
+                }
+                switch(type){
+                    case PRIMITIVE:
+                        if (void 0 !== value || Array.isArray(holder)) length += primitiveLength(value);
+                        else if (holder === root) length += 9;
+                        break;
+                    case OBJECT:
+                        {
+                            if (visited.has(value)) {
+                                duplicate.add(value);
+                                length += visited.get(value);
+                                break;
+                            }
+                            const valueLength = length;
+                            let entries = 0;
+                            length += 2;
+                            stack.add(value);
+                            for(const key in value)if (hasOwnProperty.call(value, key) && (null === allowlist || allowlist.has(key))) {
+                                const prevLength = length;
+                                walk(value, key, value[key]);
+                                if (prevLength !== length) {
+                                    length += stringLength(key) + 1;
+                                    entries++;
+                                }
+                            }
+                            if (entries > 1) length += entries - 1;
+                            stack.delete(value);
+                            if (space > 0 && entries > 0) {
+                                length += (1 + (stack.size + 1) * space + 1) * entries;
+                                length += 1 + stack.size * space;
+                            }
+                            visited.set(value, length - valueLength);
+                            break;
+                        }
+                    case ARRAY:
+                        {
+                            if (visited.has(value)) {
+                                duplicate.add(value);
+                                length += visited.get(value);
+                                break;
+                            }
+                            const valueLength = length;
+                            length += 2;
+                            stack.add(value);
+                            for(let i = 0; i < value.length; i++)walk(value, i, value[i]);
+                            if (value.length > 1) length += value.length - 1;
+                            stack.delete(value);
+                            if (space > 0 && value.length > 0) {
+                                length += (1 + (stack.size + 1) * space) * value.length;
+                                length += 1 + stack.size * space;
+                            }
+                            visited.set(value, length - valueLength);
+                            break;
+                        }
+                    case PROMISE:
+                    case STRING_STREAM:
+                        async.add(value);
+                        break;
+                    case OBJECT_STREAM:
+                        length += 2;
+                        async.add(value);
+                        break;
+                }
+            }
+            let allowlist = null;
+            replacer = normalizeReplacer(replacer);
+            if (Array.isArray(replacer)) {
+                allowlist = new Set(replacer);
+                replacer = null;
+            }
+            space = spaceLength(space);
+            options = options || {};
+            const visited = new Map();
+            const stack = new Set();
+            const duplicate = new Set();
+            const circular = new Set();
+            const async = new Set();
+            const getType = options.async ? getTypeAsync : getTypeNative;
+            const root = {
+                '': value
+            };
+            let stop = false;
+            let length = 0;
+            walk(root, '', value);
+            return {
+                minLength: isNaN(length) ? 1 / 0 : length,
+                circular: [
+                    ...circular
+                ],
+                duplicate: [
+                    ...duplicate
+                ],
+                async: [
+                    ...async
+                ]
+            };
+        };
+    },
+    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/stringify-stream.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const { Readable } = __webpack_require__("stream");
+        const { normalizeReplacer, normalizeSpace, replaceValue, getTypeAsync, type: { PRIMITIVE, OBJECT, ARRAY, PROMISE, STRING_STREAM, OBJECT_STREAM } } = __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/utils.js");
+        const noop = ()=>{};
+        const hasOwnProperty1 = Object.prototype.hasOwnProperty;
+        const wellformedStringStringify = '"\\ud800"' === JSON.stringify('\ud800') ? JSON.stringify : (s)=>JSON.stringify(s).replace(/\p{Surrogate}/gu, (m)=>`\\u${m.charCodeAt(0).toString(16)}`);
+        function push() {
+            this.push(this._stack.value);
+            this.popStack();
+        }
+        function pushPrimitive(value) {
+            switch(typeof value){
+                case 'string':
+                    this.push(this.encodeString(value));
+                    break;
+                case 'number':
+                    this.push(Number.isFinite(value) ? this.encodeNumber(value) : 'null');
+                    break;
+                case 'boolean':
+                    this.push(value ? 'true' : 'false');
+                    break;
+                case 'undefined':
+                case 'object':
+                    this.push('null');
+                    break;
+                default:
+                    this.destroy(new TypeError(`Do not know how to serialize a ${value.constructor && value.constructor.name || typeof value}`));
+            }
+        }
+        function processObjectEntry(key) {
+            const current = this._stack;
+            if (current.first) this.push(',');
+            else current.first = true;
+            if (this.space) this.push(`\n${this.space.repeat(this._depth)}${this.encodeString(key)}: `);
+            else this.push(this.encodeString(key) + ':');
+        }
+        function processObject() {
+            const current = this._stack;
+            if (current.index === current.keys.length) {
+                if (this.space && current.first) this.push(`\n${this.space.repeat(this._depth - 1)}}`);
+                else this.push('}');
+                this.popStack();
+                return;
+            }
+            const key = current.keys[current.index];
+            this.processValue(current.value, key, current.value[key], processObjectEntry);
+            current.index++;
+        }
+        function processArrayItem(index) {
+            if (0 !== index) this.push(',');
+            if (this.space) this.push(`\n${this.space.repeat(this._depth)}`);
+        }
+        function processArray() {
+            const current = this._stack;
+            if (current.index === current.value.length) {
+                if (this.space && current.index > 0) this.push(`\n${this.space.repeat(this._depth - 1)}]`);
+                else this.push(']');
+                this.popStack();
+                return;
+            }
+            this.processValue(current.value, current.index, current.value[current.index], processArrayItem);
+            current.index++;
+        }
+        function createStreamReader(fn) {
+            return function() {
+                const current = this._stack;
+                const data = current.value.read(this._readSize);
+                if (null !== data) {
+                    current.first = false;
+                    fn.call(this, data, current);
+                } else if (current.first && !current.value._readableState.reading || current.ended) this.popStack();
+                else {
+                    current.first = true;
+                    current.awaiting = true;
+                }
+            };
+        }
+        const processReadableObject = createStreamReader(function(data, current) {
+            this.processValue(current.value, current.index, data, processArrayItem);
+            current.index++;
+        });
+        const processReadableString = createStreamReader(function(data) {
+            this.push(data);
+        });
+        class JsonStringifyStream extends Readable {
+            constructor(value, replacer, space){
+                super({
+                    autoDestroy: true
+                });
+                this.getKeys = Object.keys;
+                this.replacer = normalizeReplacer(replacer);
+                if (Array.isArray(this.replacer)) {
+                    const allowlist = this.replacer;
+                    this.getKeys = (value)=>allowlist.filter((key)=>hasOwnProperty1.call(value, key));
+                    this.replacer = null;
+                }
+                this.space = normalizeSpace(space);
+                this._depth = 0;
+                this.error = null;
+                this._processing = false;
+                this._ended = false;
+                this._readSize = 0;
+                this._buffer = '';
+                this._stack = null;
+                this._visited = new WeakSet();
+                this.pushStack({
+                    handler: ()=>{
+                        this.popStack();
+                        this.processValue({
+                            '': value
+                        }, '', value, noop);
+                    }
+                });
+            }
+            encodeString(value) {
+                if (/[^\x20-\uD799]|[\x22\x5c]/.test(value)) return wellformedStringStringify(value);
+                return '"' + value + '"';
+            }
+            encodeNumber(value) {
+                return value;
+            }
+            processValue(holder, key, value, callback) {
+                value = replaceValue(holder, key, value, this.replacer);
+                let type = getTypeAsync(value);
+                switch(type){
+                    case PRIMITIVE:
+                        if (callback !== processObjectEntry || void 0 !== value) {
+                            callback.call(this, key);
+                            pushPrimitive.call(this, value);
+                        }
+                        break;
+                    case OBJECT:
+                        callback.call(this, key);
+                        if (this._visited.has(value)) return this.destroy(new TypeError('Converting circular structure to JSON'));
+                        this._visited.add(value);
+                        this._depth++;
+                        this.push('{');
+                        this.pushStack({
+                            handler: processObject,
+                            value,
+                            index: 0,
+                            first: false,
+                            keys: this.getKeys(value)
+                        });
+                        break;
+                    case ARRAY:
+                        callback.call(this, key);
+                        if (this._visited.has(value)) return this.destroy(new TypeError('Converting circular structure to JSON'));
+                        this._visited.add(value);
+                        this.push('[');
+                        this.pushStack({
+                            handler: processArray,
+                            value,
+                            index: 0
+                        });
+                        this._depth++;
+                        break;
+                    case PROMISE:
+                        this.pushStack({
+                            handler: noop,
+                            awaiting: true
+                        });
+                        Promise.resolve(value).then((resolved)=>{
+                            this.popStack();
+                            this.processValue(holder, key, resolved, callback);
+                            this.processStack();
+                        }).catch((error)=>{
+                            this.destroy(error);
+                        });
+                        break;
+                    case STRING_STREAM:
+                    case OBJECT_STREAM:
+                        callback.call(this, key);
+                        if (value.readableEnded || value._readableState.endEmitted) return this.destroy(new Error('Readable Stream has ended before it was serialized. All stream data have been lost'));
+                        if (value.readableFlowing) return this.destroy(new Error('Readable Stream is in flowing mode, data may have been lost. Trying to pause stream.'));
+                        if (type === OBJECT_STREAM) {
+                            this.push('[');
+                            this.pushStack({
+                                handler: push,
+                                value: this.space ? '\n' + this.space.repeat(this._depth) + ']' : ']'
+                            });
+                            this._depth++;
+                        }
+                        const self = this.pushStack({
+                            handler: type === OBJECT_STREAM ? processReadableObject : processReadableString,
+                            value,
+                            index: 0,
+                            first: false,
+                            ended: false,
+                            awaiting: !value.readable || 0 === value.readableLength
+                        });
+                        const continueProcessing = ()=>{
+                            if (self.awaiting) {
+                                self.awaiting = false;
+                                this.processStack();
+                            }
+                        };
+                        value.once('error', (error)=>this.destroy(error));
+                        value.once('end', ()=>{
+                            self.ended = true;
+                            continueProcessing();
+                        });
+                        value.on('readable', continueProcessing);
+                        break;
+                }
+            }
+            pushStack(node) {
+                node.prev = this._stack;
+                return this._stack = node;
+            }
+            popStack() {
+                const { handler, value } = this._stack;
+                if (handler === processObject || handler === processArray || handler === processReadableObject) {
+                    this._visited.delete(value);
+                    this._depth--;
+                }
+                this._stack = this._stack.prev;
+            }
+            processStack() {
+                if (this._processing || this._ended) return;
+                try {
+                    this._processing = true;
+                    while(null !== this._stack && !this._stack.awaiting){
+                        this._stack.handler.call(this);
+                        if (!this._processing) return;
+                    }
+                    this._processing = false;
+                } catch (error) {
+                    this.destroy(error);
+                    return;
+                }
+                if (null === this._stack && !this._ended) {
+                    this._finish();
+                    this.push(null);
+                }
+            }
+            push(data) {
+                if (null !== data) {
+                    this._buffer += data;
+                    if (this._buffer.length < this._readSize) return;
+                    data = this._buffer;
+                    this._buffer = '';
+                    this._processing = false;
+                }
+                super.push(data);
+            }
+            _read(size) {
+                this._readSize = size || this.readableHighWaterMark;
+                this.processStack();
+            }
+            _finish() {
+                this._ended = true;
+                this._processing = false;
+                this._stack = null;
+                this._visited = null;
+                if (this._buffer && this._buffer.length) super.push(this._buffer);
+                this._buffer = '';
+            }
+            _destroy(error, cb) {
+                this.error = this.error || error;
+                this._finish();
+                cb(error);
+            }
+        }
+        module.exports = function(value, replacer, space) {
+            return new JsonStringifyStream(value, replacer, space);
+        };
+    },
+    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/text-decoder.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("util").TextDecoder;
+    },
+    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/utils.js" (module) {
+        const PrimitiveType = 1;
+        const ObjectType = 2;
+        const ArrayType = 3;
+        const PromiseType = 4;
+        const ReadableStringType = 5;
+        const ReadableObjectType = 6;
+        const escapableCharCodeSubstitution = {
+            0x08: '\\b',
+            0x09: '\\t',
+            0x0a: '\\n',
+            0x0c: '\\f',
+            0x0d: '\\r',
+            0x22: '\\\"',
+            0x5c: '\\\\'
+        };
+        function isLeadingSurrogate(code) {
+            return code >= 0xD800 && code <= 0xDBFF;
+        }
+        function isTrailingSurrogate(code) {
+            return code >= 0xDC00 && code <= 0xDFFF;
+        }
+        function isReadableStream(value) {
+            return 'function' == typeof value.pipe && 'function' == typeof value._read && 'object' == typeof value._readableState && null !== value._readableState;
+        }
+        function replaceValue(holder, key, value, replacer) {
+            if (value && 'function' == typeof value.toJSON) value = value.toJSON();
+            if (null !== replacer) value = replacer.call(holder, String(key), value);
+            switch(typeof value){
+                case 'function':
+                case 'symbol':
+                    value = void 0;
+                    break;
+                case 'object':
+                    if (null !== value) {
+                        const cls = value.constructor;
+                        if (cls === String || cls === Number || cls === Boolean) value = value.valueOf();
+                    }
+                    break;
+            }
+            return value;
+        }
+        function getTypeNative(value) {
+            if (null === value || 'object' != typeof value) return PrimitiveType;
+            if (Array.isArray(value)) return ArrayType;
+            return ObjectType;
+        }
+        function getTypeAsync(value) {
+            if (null === value || 'object' != typeof value) return PrimitiveType;
+            if ('function' == typeof value.then) return PromiseType;
+            if (isReadableStream(value)) return value._readableState.objectMode ? ReadableObjectType : ReadableStringType;
+            if (Array.isArray(value)) return ArrayType;
+            return ObjectType;
+        }
+        function normalizeReplacer(replacer) {
+            if ('function' == typeof replacer) return replacer;
+            if (Array.isArray(replacer)) {
+                const allowlist = new Set(replacer.map((item)=>{
+                    const cls = item && item.constructor;
+                    return cls === String || cls === Number ? String(item) : null;
+                }).filter((item)=>'string' == typeof item));
+                return [
+                    ...allowlist
+                ];
+            }
+            return null;
+        }
+        function normalizeSpace(space) {
+            if ('number' == typeof space) {
+                if (!Number.isFinite(space) || space < 1) return false;
+                return ' '.repeat(Math.min(space, 10));
+            }
+            if ('string' == typeof space) return space.slice(0, 10) || false;
+            return false;
+        }
+        module.exports = {
+            escapableCharCodeSubstitution,
+            isLeadingSurrogate,
+            isTrailingSurrogate,
+            type: {
+                PRIMITIVE: PrimitiveType,
+                PROMISE: PromiseType,
+                ARRAY: ArrayType,
+                OBJECT: ObjectType,
+                STRING_STREAM: ReadableStringType,
+                OBJECT_STREAM: ReadableObjectType
+            },
+            isReadableStream,
+            replaceValue,
+            getTypeNative,
+            getTypeAsync,
+            normalizeReplacer,
+            normalizeSpace
+        };
+    },
+    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/version.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/package.json").version;
+    },
+    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/package.json" (module) {
+        module.exports = {
+            version: "0.5.7"
+        };
+    }
+});
+__webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/index.js");