@rife/logger 0.0.6-beta.15 → 0.0.6-beta.17

package/dist/worker/pino-file.cjs

@@ -946,19 +946,32 @@ var __webpack_modules__ = {
             return stringify;
         }
     },
-    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/index.js" (module1, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/index.js" (module1, __unused_rspack_exports, __webpack_require__) {
         "use strict";
-        const { version } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/package.json");
+        const { version } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/package.json");
         const { EventEmitter } = __webpack_require__("events");
         const { Worker } = __webpack_require__("worker_threads");
         const { join } = __webpack_require__("path");
         const { pathToFileURL } = __webpack_require__("url");
-        const { wait } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/wait.js");
-        const { WRITE_INDEX, READ_INDEX } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/indexes.js");
+        const { wait } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/wait.js");
+        const { WRITE_INDEX, READ_INDEX, SEQ_INDEX } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/indexes.js");
         const buffer = __webpack_require__("buffer");
         const assert = __webpack_require__("assert");
         const kImpl = Symbol('kImpl');
         const MAX_STRING = buffer.constants.MAX_STRING_LENGTH;
+        function noop() {}
+        function updateState(stream, fn) {
+            Atomics.add(stream[kImpl].state, SEQ_INDEX, 1);
+            fn();
+            Atomics.add(stream[kImpl].state, SEQ_INDEX, 1);
+            Atomics.notify(stream[kImpl].state, SEQ_INDEX);
+        }
+        function resetIndexes(stream) {
+            updateState(stream, ()=>{
+                Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+            });
+        }
         class FakeWeakRef {
             constructor(value){
                 this._value = value;
@@ -983,6 +996,7 @@ var __webpack_modules__ = {
             const toExecute = bundlerOverrides['thread-stream-worker'] || join(__dirname, 'lib', 'worker.js');
             const worker = new Worker(toExecute, {
                 ...opts.workerOpts,
+                name: opts.workerOpts?.name || 'thread-stream',
                 trackUnmanagedFds: false,
                 workerData: {
                     filename: 0 === filename.indexOf('file://') ? filename : pathToFileURL(filename).href,
@@ -1010,42 +1024,31 @@ var __webpack_modules__ = {
             }
         }
         function nextFlush(stream) {
-            const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-            let leftover = stream[kImpl].data.length - writeIndex;
-            if (leftover > 0) {
-                if (0 === stream[kImpl].buf.length) {
-                    stream[kImpl].flushing = false;
-                    if (stream[kImpl].ending) end(stream);
-                    else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
+            while(true){
+                const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+                const leftover = stream[kImpl].data.length - writeIndex;
+                if (leftover > 0) {
+                    if (0 === stream[kImpl].bufLen) {
+                        stream[kImpl].flushing = false;
+                        if (stream[kImpl].ending) end(stream);
+                        else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
+                        return;
+                    }
+                    write(stream, leftover, noop);
+                    continue;
+                }
+                if (0 === leftover) {
+                    if (0 === writeIndex && 0 === stream[kImpl].bufLen) return;
+                    waitForRead(stream, ()=>{
+                        if (stream.destroyed) return;
+                        resetIndexes(stream);
+                        nextFlush(stream);
+                    });
                     return;
                 }
-                let toWrite = stream[kImpl].buf.slice(0, leftover);
-                let toWriteBytes = Buffer.byteLength(toWrite);
-                if (toWriteBytes <= leftover) {
-                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-                    write(stream, toWrite, nextFlush.bind(null, stream));
-                } else stream.flush(()=>{
-                    if (stream.destroyed) return;
-                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-                    Atomics.notify(stream[kImpl].state, READ_INDEX);
-                    while(toWriteBytes > stream[kImpl].data.length){
-                        leftover /= 2;
-                        toWrite = stream[kImpl].buf.slice(0, leftover);
-                        toWriteBytes = Buffer.byteLength(toWrite);
-                    }
-                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-                    write(stream, toWrite, nextFlush.bind(null, stream));
-                });
-            } else if (0 === leftover) {
-                if (0 === writeIndex && 0 === stream[kImpl].buf.length) return;
-                stream.flush(()=>{
-                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-                    Atomics.notify(stream[kImpl].state, READ_INDEX);
-                    nextFlush(stream);
-                });
-            } else destroy(stream, new Error('overwritten'));
+                destroy(stream, new Error('overwritten'));
+                return;
+            }
         }
         function onWorkerMessage(msg) {
             const stream = this.stream.deref();
@@ -1054,10 +1057,11 @@ var __webpack_modules__ = {
                 this.terminate();
                 return;
             }
+            if (msg?.code == null) return;
             switch(msg.code){
                 case 'READY':
                     this.stream = new WeakRef1(stream);
-                    stream.flush(()=>{
+                    waitForRead(stream, ()=>{
                         stream[kImpl].ready = true;
                         stream.emit('ready');
                     });
@@ -1069,6 +1073,19 @@ var __webpack_modules__ = {
                     if (Array.isArray(msg.args)) stream.emit(msg.name, ...msg.args);
                     else stream.emit(msg.name, msg.args);
                     break;
+                case 'FLUSHED':
+                    {
+                        if ('thread-stream' !== msg.context) {
+                            destroy(stream, new Error('this should not happen: ' + msg.code));
+                            break;
+                        }
+                        const cb = stream[kImpl].flushCallbacks.get(msg.id);
+                        if (cb) {
+                            stream[kImpl].flushCallbacks.delete(msg.id);
+                            process.nextTick(cb);
+                        }
+                        break;
+                    }
                 case 'WARNING':
                     process.emitWarning(msg.err);
                     break;
@@ -1103,13 +1120,18 @@ var __webpack_modules__ = {
                 this[kImpl].finished = false;
                 this[kImpl].errored = null;
                 this[kImpl].closed = false;
-                this[kImpl].buf = '';
+                this[kImpl].buf = [];
+                this[kImpl].bufHead = 0;
+                this[kImpl].bufLen = 0;
+                this[kImpl].flushCallbacks = new Map();
+                this[kImpl].nextFlushId = 0;
                 this.worker = createWorker(this, opts);
                 this.on('message', (message, transferList)=>{
                     this.worker.postMessage(message, transferList);
                 });
             }
             write(data) {
+                const dataBuf = Buffer.isBuffer(data) ? data : Buffer.from(data);
                 if (this[kImpl].destroyed) {
                     error(this, new Error('the worker has exited'));
                     return false;
@@ -1118,14 +1140,15 @@ var __webpack_modules__ = {
                     error(this, new Error('the worker is ending'));
                     return false;
                 }
-                if (this[kImpl].flushing && this[kImpl].buf.length + data.length >= MAX_STRING) try {
+                if (this[kImpl].flushing && this[kImpl].bufLen + dataBuf.length >= MAX_STRING) try {
                     writeSync(this);
                     this[kImpl].flushing = true;
                 } catch (err) {
                     destroy(this, err);
                     return false;
                 }
-                this[kImpl].buf += data;
+                this[kImpl].buf.push(dataBuf);
+                this[kImpl].bufLen += dataBuf.length;
                 if (this[kImpl].sync) try {
                     writeSync(this);
                     return true;
@@ -1137,7 +1160,7 @@ var __webpack_modules__ = {
                     this[kImpl].flushing = true;
                     setImmediate(nextFlush, this);
                 }
-                this[kImpl].needDrain = this[kImpl].data.length - this[kImpl].buf.length - Atomics.load(this[kImpl].state, WRITE_INDEX) <= 0;
+                this[kImpl].needDrain = this[kImpl].data.length - this[kImpl].bufLen - Atomics.load(this[kImpl].state, WRITE_INDEX) <= 0;
                 return !this[kImpl].needDrain;
             }
             end() {
@@ -1146,19 +1169,10 @@ var __webpack_modules__ = {
                 end(this);
             }
             flush(cb) {
-                if (this[kImpl].destroyed) {
-                    if ('function' == typeof cb) process.nextTick(cb, new Error('the worker has exited'));
-                    return;
-                }
-                const writeIndex = Atomics.load(this[kImpl].state, WRITE_INDEX);
-                wait(this[kImpl].state, READ_INDEX, writeIndex, 1 / 0, (err, res)=>{
-                    if (err) {
-                        destroy(this, err);
-                        process.nextTick(cb, err);
-                        return;
-                    }
-                    if ('not-equal' === res) return void this.flush(cb);
-                    process.nextTick(cb);
+                cb = 'function' == typeof cb ? cb : noop;
+                flushBuffer(this, (err)=>{
+                    if (err) return void process.nextTick(cb, err);
+                    requestWorkerFlush(this, cb);
                 });
             }
             flushSync() {
@@ -1200,6 +1214,63 @@ var __webpack_modules__ = {
                 return this[kImpl].errored;
             }
         }
+        function flushBuffer(stream, cb) {
+            if (stream[kImpl].destroyed) return void process.nextTick(cb, new Error('the worker has exited'));
+            if (!stream[kImpl].sync && (stream[kImpl].flushing || stream[kImpl].bufLen > 0)) return void setImmediate(flushBuffer, stream, cb);
+            waitForRead(stream, cb);
+        }
+        function waitForRead(stream, cb) {
+            const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+            wait(stream[kImpl].state, READ_INDEX, writeIndex, 1 / 0, (err, res)=>{
+                if (err) {
+                    destroy(stream, err);
+                    cb(err);
+                    return;
+                }
+                if ('ok' !== res) return void waitForRead(stream, cb);
+                cb();
+            });
+        }
+        function requestWorkerFlush(stream, cb) {
+            if (stream[kImpl].destroyed) return void process.nextTick(cb, new Error('the worker has exited'));
+            if (!stream[kImpl].ready) {
+                const onReady = ()=>{
+                    cleanup();
+                    requestWorkerFlush(stream, cb);
+                };
+                const onClose = ()=>{
+                    cleanup();
+                    process.nextTick(cb, new Error('the worker has exited'));
+                };
+                const cleanup = ()=>{
+                    stream.off('ready', onReady);
+                    stream.off('close', onClose);
+                };
+                stream.once('ready', onReady);
+                stream.once('close', onClose);
+                return;
+            }
+            const id = ++stream[kImpl].nextFlushId;
+            stream[kImpl].flushCallbacks.set(id, cb);
+            try {
+                stream.worker.postMessage({
+                    code: 'FLUSH',
+                    context: 'thread-stream',
+                    id
+                });
+            } catch (err) {
+                stream[kImpl].flushCallbacks.delete(id);
+                destroy(stream, err);
+                process.nextTick(cb, err);
+            }
+        }
+        function failPendingFlushCallbacks(stream, err) {
+            const callbacks = stream[kImpl].flushCallbacks;
+            if (0 === callbacks.size) return;
+            const flushErr = err || new Error('the worker has exited');
+            for (const cb of callbacks.values())process.nextTick(cb, flushErr);
+            callbacks.clear();
+        }
         function error(stream, err) {
             setImmediate(()=>{
                 stream.emit('error', err);
@@ -1208,6 +1279,7 @@ var __webpack_modules__ = {
         function destroy(stream, err) {
             if (stream[kImpl].destroyed) return;
             stream[kImpl].destroyed = true;
+            failPendingFlushCallbacks(stream, err);
             if (err) {
                 stream[kImpl].errored = err;
                 error(stream, err);
@@ -1221,12 +1293,37 @@ var __webpack_modules__ = {
                 stream.emit('close');
             });
         }
-        function write(stream, data, cb) {
+        function write(stream, maxBytes, cb) {
             const current = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-            const length = Buffer.byteLength(data);
-            stream[kImpl].data.write(data, current);
-            Atomics.store(stream[kImpl].state, WRITE_INDEX, current + length);
-            Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+            let offset = current;
+            let remaining = maxBytes;
+            while(remaining > 0 && 0 !== stream[kImpl].bufLen){
+                const head = stream[kImpl].bufHead;
+                const buf = stream[kImpl].buf[head];
+                if (buf.length <= remaining) {
+                    buf.copy(stream[kImpl].data, offset);
+                    offset += buf.length;
+                    remaining -= buf.length;
+                    stream[kImpl].bufLen -= buf.length;
+                    stream[kImpl].bufHead = head + 1;
+                    if (stream[kImpl].bufHead === stream[kImpl].buf.length) {
+                        stream[kImpl].buf.length = 0;
+                        stream[kImpl].bufHead = 0;
+                    } else if (stream[kImpl].bufHead >= 1024 && 2 * stream[kImpl].bufHead >= stream[kImpl].buf.length) {
+                        stream[kImpl].buf.splice(0, stream[kImpl].bufHead);
+                        stream[kImpl].bufHead = 0;
+                    }
+                    continue;
+                }
+                buf.copy(stream[kImpl].data, offset, 0, remaining);
+                stream[kImpl].buf[head] = buf.subarray(remaining);
+                stream[kImpl].bufLen -= remaining;
+                offset += remaining;
+                remaining = 0;
+            }
+            updateState(stream, ()=>{
+                Atomics.store(stream[kImpl].state, WRITE_INDEX, offset);
+            });
             cb();
             return true;
         }
@@ -1236,8 +1333,9 @@ var __webpack_modules__ = {
             try {
                 stream.flushSync();
                 let readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
-                Atomics.store(stream[kImpl].state, WRITE_INDEX, -1);
-                Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+                updateState(stream, ()=>{
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, -1);
+                });
                 let spins = 0;
                 while(-1 !== readIndex){
                     Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1000);
@@ -1259,35 +1357,16 @@ var __webpack_modules__ = {
                 else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
             };
             stream[kImpl].flushing = false;
-            while(0 !== stream[kImpl].buf.length){
+            while(0 !== stream[kImpl].bufLen){
                 const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-                let leftover = stream[kImpl].data.length - writeIndex;
+                const leftover = stream[kImpl].data.length - writeIndex;
                 if (0 === leftover) {
                     flushSync(stream);
-                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-                    Atomics.notify(stream[kImpl].state, READ_INDEX);
+                    resetIndexes(stream);
                     continue;
                 }
                 if (leftover < 0) throw new Error('overwritten');
-                let toWrite = stream[kImpl].buf.slice(0, leftover);
-                let toWriteBytes = Buffer.byteLength(toWrite);
-                if (toWriteBytes <= leftover) {
-                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-                    write(stream, toWrite, cb);
-                } else {
-                    flushSync(stream);
-                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-                    Atomics.notify(stream[kImpl].state, READ_INDEX);
-                    while(toWriteBytes > stream[kImpl].buf.length){
-                        leftover /= 2;
-                        toWrite = stream[kImpl].buf.slice(0, leftover);
-                        toWriteBytes = Buffer.byteLength(toWrite);
-                    }
-                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-                    write(stream, toWrite, cb);
-                }
+                write(stream, leftover, cb);
             }
         }
         function flushSync(stream) {
@@ -1304,16 +1383,18 @@ var __webpack_modules__ = {
         }
         module1.exports = ThreadStream;
     },
-    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/indexes.js" (module1) {
+    "../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/indexes.js" (module1) {
         "use strict";
+        const SEQ_INDEX = 2;
         const WRITE_INDEX = 4;
         const READ_INDEX = 8;
         module1.exports = {
             WRITE_INDEX,
-            READ_INDEX
+            READ_INDEX,
+            SEQ_INDEX
         };
     },
-    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/wait.js" (module1) {
+    "../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/wait.js" (module1) {
         "use strict";
         const WAIT_MS = 10000;
         function wait(state, index, expected, timeout, done) {
@@ -1337,7 +1418,10 @@ var __webpack_modules__ = {
                 if (max !== 1 / 0 && Date.now() > max) return void done(null, 'timed-out');
                 const remaining = max === 1 / 0 ? WAIT_MS : Math.min(WAIT_MS, Math.max(1, max - Date.now()));
                 const result = Atomics.waitAsync(state, index, expected, remaining);
-                if (result.async) result.value.then(check);
+                if (result.async) result.value.then((res)=>{
+                    if ('ok' === res) return void done(null, 'ok');
+                    check();
+                });
                 else setImmediate(check);
             };
             check();
@@ -2392,7 +2476,7 @@ var __webpack_modules__ = {
         const diagChan = __webpack_require__("node:diagnostics_channel");
         const format = __webpack_require__("../../node_modules/.pnpm/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js");
         const { mapHttpRequest, mapHttpResponse } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/index.js");
-        const SonicBoom = __webpack_require__("../../node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js");
+        const SonicBoom = __webpack_require__("../../node_modules/.pnpm/sonic-boom@4.2.1/node_modules/sonic-boom/index.js");
         const onExit = __webpack_require__("../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js");
         const { lsCacheSym, chindingsSym, writeSym, serializersSym, formatOptsSym, endSym, stringifiersSym, stringifySym, stringifySafeSym, wildcardFirstSym, nestedKeySym, formattersSym, messageKeySym, errorKeySym, nestedKeyStrSym, msgPrefixSym } = __webpack_require__("../../node_modules/.pnpm/pino@10.3.1/node_modules/pino/lib/symbols.js");
         const { isMainThread } = __webpack_require__("worker_threads");
@@ -2668,7 +2752,7 @@ var __webpack_modules__ = {
         const { fileURLToPath } = __webpack_require__("node:url");
         const sleep = __webpack_require__("../../node_modules/.pnpm/atomic-sleep@1.0.0/node_modules/atomic-sleep/index.js");
         const onExit = __webpack_require__("../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js");
-        const ThreadStream = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/index.js");
+        const ThreadStream = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/index.js");
         function setupOnExit(stream) {
             onExit.register(stream, autoEnd);
             onExit.registerBeforeExit(stream, flush);
@@ -2999,7 +3083,7 @@ var __webpack_modules__ = {
         module1.exports["default"] = pino;
         module1.exports.pino = pino;
     },
-    "../../node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js" (module1, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/sonic-boom@4.2.1/node_modules/sonic-boom/index.js" (module1, __unused_rspack_exports, __webpack_require__) {
         "use strict";
         const fs = __webpack_require__("fs");
         const EventEmitter = __webpack_require__("events");
@@ -3105,8 +3189,14 @@ var __webpack_modules__ = {
                 this.flush = flush;
                 this.flushSync = flushSync;
                 this._actualWrite = actualWrite;
-                fsWriteSync = ()=>fs.writeSync(this.fd, this._writingBuf, 'utf8');
-                fsWrite = ()=>fs.write(this.fd, this._writingBuf, 'utf8', this.release);
+                fsWriteSync = ()=>{
+                    if (Buffer.isBuffer(this._writingBuf)) return fs.writeSync(this.fd, this._writingBuf);
+                    return fs.writeSync(this.fd, this._writingBuf, 'utf8');
+                };
+                fsWrite = ()=>{
+                    if (Buffer.isBuffer(this._writingBuf)) return fs.write(this.fd, this._writingBuf, this.release);
+                    return fs.write(this.fd, this._writingBuf, 'utf8', this.release);
+                };
             } else throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
             if ('number' == typeof fd) {
                 this.fd = fd;
@@ -3178,9 +3268,9 @@ var __webpack_modules__ = {
             }
         }
         function releaseWritingBuf(writingBuf, len, n1) {
-            if ('string' == typeof writingBuf && Buffer.byteLength(writingBuf) !== n1) n1 = Buffer.from(writingBuf).subarray(0, n1).toString().length;
+            if ('string' == typeof writingBuf) writingBuf = Buffer.from(writingBuf);
             len = Math.max(len - n1, 0);
-            writingBuf = writingBuf.slice(n1);
+            writingBuf = writingBuf.subarray(n1);
             return {
                 writingBuf,
                 len
@@ -3200,13 +3290,15 @@ var __webpack_modules__ = {
         }
         function write(data) {
             if (this.destroyed) throw new Error('SonicBoom destroyed');
-            const len = this._len + data.length;
+            data = '' + data;
+            const dataLen = Buffer.byteLength(data);
+            const len = this._len + dataLen;
             const bufs = this._bufs;
             if (this.maxLength && len > this.maxLength) {
                 this.emit('drop', data);
                 return this._len < this._hwm;
             }
-            if (0 === bufs.length || bufs[bufs.length - 1].length + data.length > this.maxWrite) bufs.push('' + data);
+            if (0 === bufs.length || Buffer.byteLength(bufs[bufs.length - 1]) + dataLen > this.maxWrite) bufs.push(data);
             else bufs[bufs.length - 1] += data;
             this._len = len;
             if (!this._writing && this._len >= this.minLength) this._actualWrite();
@@ -3324,10 +3416,10 @@ var __webpack_modules__ = {
                 this._writingBuf = '';
             }
             let buf = '';
-            while(this._bufs.length || buf){
+            while(this._bufs.length || buf.length){
                 if (buf.length <= 0) buf = this._bufs[0];
                 try {
-                    const n1 = fs.writeSync(this.fd, buf, 'utf8');
+                    const n1 = Buffer.isBuffer(buf) ? fs.writeSync(this.fd, buf) : fs.writeSync(this.fd, buf, 'utf8');
                     const releasedBufObj = releaseWritingBuf(buf, this._len, n1);
                     buf = releasedBufObj.writingBuf;
                     this._len = releasedBufObj.len;
@@ -3376,14 +3468,14 @@ var __webpack_modules__ = {
         function actualWrite() {
             const release = this.release;
             this._writing = true;
-            this._writingBuf = this._writingBuf || this._bufs.shift() || '';
+            this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || '';
             if (this.sync) try {
-                const written = fs.writeSync(this.fd, this._writingBuf, 'utf8');
+                const written = Buffer.isBuffer(this._writingBuf) ? fs.writeSync(this.fd, this._writingBuf) : fs.writeSync(this.fd, this._writingBuf, 'utf8');
                 release(null, written);
             } catch (err) {
                 release(err);
             }
-            else fs.write(this.fd, this._writingBuf, 'utf8', release);
+            else fs.write(this.fd, this._writingBuf, release);
         }
         function actualWriteBuffer() {
             const release = this.release;
@@ -3424,10 +3516,10 @@ var __webpack_modules__ = {
         SonicBoom.default = SonicBoom;
         module1.exports = SonicBoom;
     },
-    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/package.json" (module1) {
+    "../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/package.json" (module1) {
         "use strict";
         module1.exports = {
-            version: "4.0.0"
+            version: "4.2.0"
         };
     }
 };