@rspack/cli 2.0.1 → 2.0.2

package/dist/json-ext.js

@@ -1,776 +1,210 @@
-import { __webpack_require__ } from "./162.js";
-import "./162.js";
-import * as __rspack_external_util from "util";
-__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: '\\\\'
+Symbol('empty');
+new TextDecoder();
+function utils_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 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;
+}
+function utils_normalizeStringifyOptions(optionsOrReplacer, space) {
+    if (null === optionsOrReplacer || Array.isArray(optionsOrReplacer) || 'object' != typeof optionsOrReplacer) optionsOrReplacer = {
+        replacer: optionsOrReplacer,
+        space
+    };
+    let replacer = normalizeReplacer(optionsOrReplacer.replacer);
+    let getKeys = Object.keys;
+    if (Array.isArray(replacer)) {
+        const allowlist = replacer;
+        getKeys = ()=>allowlist;
+        replacer = null;
+    }
+    return {
+        ...optionsOrReplacer,
+        replacer,
+        getKeys,
+        space: normalizeSpace(optionsOrReplacer.space)
+    };
+}
+function utils_resolveStringifyMode(mode = 'json') {
+    if ('json' === mode || 'jsonl' === mode) return mode;
+    throw new TypeError('Invalid options: `mode` should be "json" or "jsonl"');
+}
+function encodeString(value) {
+    if (/[^\x20\x21\x23-\x5B\x5D-\uD799]/.test(value)) return JSON.stringify(value);
+    return '"' + value + '"';
+}
+function* stringify_chunked_stringifyChunked(value, ...args) {
+    const { replacer, getKeys, space, ...options } = utils_normalizeStringifyOptions(...args);
+    const highWaterMark = Number(options.highWaterMark) || 0x4000;
+    const roots = 'jsonl' === utils_resolveStringifyMode(options.mode) && Array.isArray(value) ? value : [
+        value
+    ];
+    const rootCount = roots.length;
+    const keyStrings = new Map();
+    const stack = [];
+    let rootValue = null;
+    let prevState = null;
+    let state = null;
+    let stateValue = null;
+    let stateEmpty = true;
+    let stateKeys = [];
+    let stateIndex = 0;
+    let buffer = '';
+    for(let i = 0; i < rootCount; i++){
+        if (null !== rootValue) buffer += '\n';
+        rootValue = {
+            '': roots[i]
         };
-        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;
+        prevState = null;
+        state = ()=>printEntry('', roots[i]);
+        stateValue = rootValue;
+        stateEmpty = true;
+        stateKeys = [
+            ''
+        ];
+        stateIndex = 0;
+        do {
+            state();
+            if (buffer.length >= highWaterMark || null === prevState && i === rootCount - 1) {
+                yield buffer;
+                buffer = '';
+            }
+        }while (null !== prevState);
+    }
+    function printObject() {
+        if (0 === stateIndex) {
+            stateKeys = getKeys(stateValue);
+            buffer += '{';
+        }
+        if (stateIndex === stateKeys.length) {
+            buffer += space && !stateEmpty ? `\n${space.repeat(stack.length - 1)}}` : '}';
+            popState();
+            return;
+        }
+        const key = stateKeys[stateIndex++];
+        printEntry(key, stateValue[key]);
+    }
+    function printArray() {
+        if (0 === stateIndex) buffer += '[';
+        if (stateIndex === stateValue.length) {
+            buffer += space && !stateEmpty ? `\n${space.repeat(stack.length - 1)}]` : ']';
+            popState();
+            return;
+        }
+        printEntry(stateIndex, stateValue[stateIndex++]);
+    }
+    function printEntryPrelude(key) {
+        if (stateEmpty) stateEmpty = false;
+        else buffer += ',';
+        if (space && null !== prevState) buffer += `\n${space.repeat(stack.length)}`;
+        if (state === printObject) {
+            let keyString = keyStrings.get(key);
+            if (void 0 === keyString) keyStrings.set(key, keyString = encodeString(key) + (space ? ': ' : ':'));
+            buffer += keyString;
         }
-        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 printEntry(key, value) {
+        value = utils_replaceValue(stateValue, key, value, replacer);
+        if (null === value || 'object' != typeof value) {
+            if (state !== printObject || void 0 !== value) {
+                printEntryPrelude(key);
+                pushPrimitive(value);
+            }
+        } else {
+            if (stack.includes(value)) throw new TypeError('Converting circular structure to JSON');
+            printEntryPrelude(key);
+            stack.push(value);
+            pushState();
+            state = Array.isArray(value) ? printArray : printObject;
+            stateValue = value;
+            stateEmpty = true;
+            stateIndex = 0;
         }
-        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;
+    }
+    function pushPrimitive(value) {
+        switch(typeof value){
+            case 'string':
+                buffer += encodeString(value);
+                break;
+            case 'number':
+                buffer += Number.isFinite(value) ? String(value) : 'null';
+                break;
+            case 'boolean':
+                buffer += value ? 'true' : 'false';
+                break;
+            case 'undefined':
+            case 'object':
+                buffer += 'null';
+                break;
+            default:
+                throw new TypeError(`Do not know how to serialize a ${value.constructor?.name || typeof value}`);
         }
-        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;
-    },
-    util (module) {
-        module.exports = __rspack_external_util;
-    },
-    "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/package.json" (module) {
-        module.exports = {
-            version: "0.5.7"
+    }
+    function pushState() {
+        prevState = {
+            keys: stateKeys,
+            index: stateIndex,
+            prev: prevState
         };
     }
+    function popState() {
+        stack.pop();
+        const value = stack.length > 0 ? stack[stack.length - 1] : rootValue;
+        state = Array.isArray(value) ? printArray : printObject;
+        stateValue = value;
+        stateEmpty = false;
+        stateKeys = prevState.keys;
+        stateIndex = prevState.index;
+        prevState = prevState.prev;
+    }
+}
+const hasOwn = 'function' == typeof Object.hasOwn ? Object.hasOwn : (object, key)=>Object.hasOwnProperty.call(object, key);
+const escapableCharCodeSubstitution = {
+    0x08: '\\b',
+    0x09: '\\t',
+    0x0a: '\\n',
+    0x0c: '\\f',
+    0x0d: '\\r',
+    0x22: '\\\"',
+    0x5c: '\\\\'
+};
+Uint8Array.from({
+    length: 2048
+}, (_, code)=>{
+    if (hasOwn(escapableCharCodeSubstitution, code)) return 2;
+    if (code < 0x20) return 6;
+    return code < 128 ? 1 : 2;
 });
-__webpack_require__("../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/index.js");
+export { stringify_chunked_stringifyChunked as stringifyChunked };