lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.160.cjs

@@ -1,119 +1,636 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const t = require("stream");
+const t = require("fs");
 
-const e = require("string_decoder");
+const i = require("events");
 
-const s = t => t && t.__esModule ? t : {
+const e = require("util");
+
+const s = require("path");
+
+const n = require("./Package.internal.33.cjs");
+
+const r = require("assert");
+
+const h = t => t && t.__esModule ? t : {
     default: t
 };
 
-const r = s(t);
+const f = h(t);
 
-const i = s(e);
+const o = h(i);
 
-const {Transform: n} = r.default;
+const l = h(e);
 
-const {StringDecoder: o} = i.default;
+const u = h(s);
 
-const f = Symbol("last");
+const c = h(r);
 
-const h = Symbol("decoder");
+const d = f.default;
 
-function c(t, e, s) {
-    let r;
-    if (this.overflow) {
-        const e = this[h].write(t);
-        r = e.split(this.matcher);
-        if (r.length === 1) return s();
-        r.shift();
-        this.overflow = false;
-    } else {
-        this[f] += this[h].write(t);
-        r = this[f].split(this.matcher);
+const _ = o.default;
+
+const a = l.default.inherits;
+
+const g = u.default;
+
+const w = n.requireAtomicSleep();
+
+const y = c.default;
+
+const m = 100;
+
+const p = Buffer.allocUnsafe(0);
+
+const B = 16 * 1024;
+
+const b = "buffer";
+
+const S = "utf8";
+
+const [E, x] = (process.versions.node || "0.0").split(".").map(Number);
+
+const L = E >= 22 && x >= 7;
+
+function A(t, i) {
+    i._opening = true;
+    i._writing = true;
+    i._asyncDrainScheduled = false;
+    function e(e, s) {
+        if (e) {
+            i._reopening = false;
+            i._writing = false;
+            i._opening = false;
+            if (i.sync) {
+                process.nextTick(() => {
+                    if (i.listenerCount("error") > 0) {
+                        i.emit("error", e);
+                    }
+                });
+            } else {
+                i.emit("error", e);
+            }
+            return;
+        }
+        const n = i._reopening;
+        i.fd = s;
+        i.file = t;
+        i._reopening = false;
+        i._opening = false;
+        i._writing = false;
+        if (i.sync) {
+            process.nextTick(() => i.emit("ready"));
+        } else {
+            i.emit("ready");
+        }
+        if (i.destroyed) {
+            return;
+        }
+        if (!i._writing && i._len > i.minLength || i._flushPending) {
+            i._actualWrite();
+        } else if (n) {
+            process.nextTick(() => i.emit("drain"));
+        }
     }
-    this[f] = r.pop();
-    for (let t = 0; t < r.length; t++) {
+    const s = i.append ? "a" : "w";
+    const n = i.mode;
+    if (i.sync) {
         try {
-            a(this, this.mapper(r[t]));
+            if (i.mkdir) d.mkdirSync(g.dirname(t), {
+                recursive: true
+            });
+            const r = d.openSync(t, s, n);
+            e(null, r);
         } catch (t) {
-            return s(t);
+            e(t);
+            throw t;
+        }
+    } else if (i.mkdir) {
+        d.mkdir(g.dirname(t), {
+            recursive: true
+        }, i => {
+            if (i) return e(i);
+            d.open(t, s, n, e);
+        });
+    } else {
+        d.open(t, s, n, e);
+    }
+}
+
+function W(t) {
+    if (!(this instanceof W)) {
+        return new W(t);
+    }
+    let {fd: i, dest: e, minLength: s, maxLength: n, maxWrite: r, periodicFlush: h, sync: f, append: o = true, mkdir: l, retryEAGAIN: u, fsync: c, contentMode: _, mode: a} = t || {};
+    i = i || e;
+    this._len = 0;
+    this.fd = -1;
+    this._bufs = [];
+    this._lens = [];
+    this._writing = false;
+    this._ending = false;
+    this._reopening = false;
+    this._asyncDrainScheduled = false;
+    this._flushPending = false;
+    this._hwm = Math.max(s || 0, 16387);
+    this.file = null;
+    this.destroyed = false;
+    this.minLength = s || 0;
+    this.maxLength = n || 0;
+    this.maxWrite = r || B;
+    this._periodicFlush = h || 0;
+    this._periodicFlushTimer = undefined;
+    this.sync = f || false;
+    this.writable = true;
+    this._fsync = c || false;
+    this.append = o || false;
+    this.mode = a;
+    this.retryEAGAIN = u || (() => true);
+    this.mkdir = l || false;
+    let g;
+    let y;
+    if (_ === b) {
+        this._writingBuf = p;
+        this.write = N;
+        this.flush = P;
+        this.flushSync = D;
+        this._actualWrite = U;
+        g = () => d.writeSync(this.fd, this._writingBuf);
+        y = () => d.write(this.fd, this._writingBuf, this.release);
+    } else if (_ === undefined || _ === S) {
+        this._writingBuf = "";
+        this.write = F;
+        this.flush = q;
+        this.flushSync = v;
+        this._actualWrite = M;
+        g = () => d.writeSync(this.fd, this._writingBuf, "utf8");
+        y = () => d.write(this.fd, this._writingBuf, "utf8", this.release);
+    } else {
+        throw new Error(`SonicBoom supports "${S}" and "${b}", but passed ${_}`);
+    }
+    if (typeof i === "number") {
+        this.fd = i;
+        process.nextTick(() => this.emit("ready"));
+    } else if (typeof i === "string") {
+        A(i, this);
+    } else {
+        throw new Error("SonicBoom supports only file descriptors and files");
+    }
+    if (this.minLength >= this.maxWrite) {
+        throw new Error(`minLength should be smaller than maxWrite (${this.maxWrite})`);
+    }
+    this.release = (t, i) => {
+        if (t) {
+            if ((t.code === "EAGAIN" || t.code === "EBUSY") && this.retryEAGAIN(t, this._writingBuf.length, this._len - this._writingBuf.length)) {
+                if (this.sync) {
+                    try {
+                        w(m);
+                        this.release(undefined, 0);
+                    } catch (t) {
+                        this.release(t);
+                    }
+                } else {
+                    setTimeout(y, m);
+                }
+            } else {
+                this._writing = false;
+                this.emit("error", t);
+            }
+            return;
+        }
+        this.emit("write", i);
+        const e = k(this._writingBuf, this._len, i);
+        this._len = e.len;
+        this._writingBuf = e.writingBuf;
+        if (this._writingBuf.length) {
+            if (!this.sync) {
+                y();
+                return;
+            }
+            try {
+                do {
+                    const t = g();
+                    const i = k(this._writingBuf, this._len, t);
+                    this._len = i.len;
+                    this._writingBuf = i.writingBuf;
+                } while (this._writingBuf.length);
+            } catch (t) {
+                this.release(t);
+                return;
+            }
+        }
+        if (this._fsync) {
+            d.fsyncSync(this.fd);
+        }
+        const s = this._len;
+        if (this._reopening) {
+            this._writing = false;
+            this._reopening = false;
+            this.reopen();
+        } else if (s > this.minLength) {
+            this._actualWrite();
+        } else if (this._ending) {
+            if (s > 0) {
+                this._actualWrite();
+            } else {
+                this._writing = false;
+                $(this);
+            }
+        } else {
+            this._writing = false;
+            if (this.sync) {
+                if (!this._asyncDrainScheduled) {
+                    this._asyncDrainScheduled = true;
+                    process.nextTick(T, this);
+                }
+            } else {
+                this.emit("drain");
+            }
+        }
+    };
+    this.on("newListener", function(t) {
+        if (t === "drain") {
+            this._asyncDrainScheduled = false;
+        }
+    });
+    if (this._periodicFlush !== 0) {
+        this._periodicFlushTimer = setInterval(() => this.flush(null), this._periodicFlush);
+        this._periodicFlushTimer.unref();
+    }
+}
+
+function k(t, i, e) {
+    if (typeof t === "string" && Buffer.byteLength(t) !== e) {
+        e = Buffer.from(t).subarray(0, e).toString().length;
+    }
+    i = Math.max(i - e, 0);
+    t = t.slice(e);
+    return {
+        writingBuf: t,
+        len: i
+    };
+}
+
+function T(t) {
+    const i = t.listenerCount("drain") > 0;
+    if (!i) return;
+    t._asyncDrainScheduled = false;
+    t.emit("drain");
+}
+
+a(W, _);
+
+function I(t, i) {
+    if (t.length === 0) {
+        return p;
+    }
+    if (t.length === 1) {
+        return t[0];
+    }
+    return Buffer.concat(t, i);
+}
+
+function F(t) {
+    if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+    }
+    const i = this._len + t.length;
+    const e = this._bufs;
+    if (this.maxLength && i > this.maxLength) {
+        this.emit("drop", t);
+        return this._len < this._hwm;
+    }
+    if (e.length === 0 || e[e.length - 1].length + t.length > this.maxWrite) {
+        e.push("" + t);
+    } else {
+        e[e.length - 1] += t;
+    }
+    this._len = i;
+    if (!this._writing && this._len >= this.minLength) {
+        this._actualWrite();
+    }
+    return this._len < this._hwm;
+}
+
+function N(t) {
+    if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+    }
+    const i = this._len + t.length;
+    const e = this._bufs;
+    const s = this._lens;
+    if (this.maxLength && i > this.maxLength) {
+        this.emit("drop", t);
+        return this._len < this._hwm;
+    }
+    if (e.length === 0 || s[s.length - 1] + t.length > this.maxWrite) {
+        e.push([ t ]);
+        s.push(t.length);
+    } else {
+        e[e.length - 1].push(t);
+        s[s.length - 1] += t.length;
+    }
+    this._len = i;
+    if (!this._writing && this._len >= this.minLength) {
+        this._actualWrite();
+    }
+    return this._len < this._hwm;
+}
+
+function G(t) {
+    this._flushPending = true;
+    const i = () => {
+        if (!this._fsync) {
+            try {
+                d.fsync(this.fd, i => {
+                    this._flushPending = false;
+                    t(i);
+                });
+            } catch (i) {
+                t(i);
+            }
+        } else {
+            this._flushPending = false;
+            t();
+        }
+        this.off("error", e);
+    };
+    const e = e => {
+        this._flushPending = false;
+        t(e);
+        this.off("drain", i);
+    };
+    this.once("drain", i);
+    this.once("error", e);
+}
+
+function q(t) {
+    if (t != null && typeof t !== "function") {
+        throw new Error("flush cb must be a function");
+    }
+    if (this.destroyed) {
+        const i = new Error("SonicBoom destroyed");
+        if (t) {
+            t(i);
+            return;
+        }
+        throw i;
+    }
+    if (this.minLength <= 0) {
+        t?.();
+        return;
+    }
+    if (t) {
+        G.call(this, t);
+    }
+    if (this._writing) {
+        return;
+    }
+    if (this._bufs.length === 0) {
+        this._bufs.push("");
+    }
+    this._actualWrite();
+}
+
+function P(t) {
+    if (t != null && typeof t !== "function") {
+        throw new Error("flush cb must be a function");
+    }
+    if (this.destroyed) {
+        const i = new Error("SonicBoom destroyed");
+        if (t) {
+            t(i);
+            return;
         }
+        throw i;
     }
-    this.overflow = this[f].length > this.maxLength;
-    if (this.overflow && !this.skipOverflow) {
-        s(new Error("maximum buffer reached"));
+    if (this.minLength <= 0) {
+        t?.();
         return;
     }
-    s();
+    if (t) {
+        G.call(this, t);
+    }
+    if (this._writing) {
+        return;
+    }
+    if (this._bufs.length === 0) {
+        this._bufs.push([]);
+        this._lens.push(0);
+    }
+    this._actualWrite();
 }
 
-function l(t) {
-    this[f] += this[h].end();
-    if (this[f]) {
+W.prototype.reopen = function(t) {
+    if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+    }
+    if (this._opening) {
+        this.once("ready", () => {
+            this.reopen(t);
+        });
+        return;
+    }
+    if (this._ending) {
+        return;
+    }
+    if (!this.file) {
+        throw new Error("Unable to reopen a file descriptor, you must pass a file to SonicBoom");
+    }
+    if (t) {
+        this.file = t;
+    }
+    this._reopening = true;
+    if (this._writing) {
+        return;
+    }
+    const i = this.fd;
+    this.once("ready", () => {
+        if (i !== this.fd) {
+            d.close(i, t => {
+                if (t) {
+                    return this.emit("error", t);
+                }
+            });
+        }
+    });
+    A(this.file, this);
+};
+
+W.prototype.end = function() {
+    if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+    }
+    if (this._opening) {
+        this.once("ready", () => {
+            this.end();
+        });
+        return;
+    }
+    if (this._ending) {
+        return;
+    }
+    this._ending = true;
+    if (this._writing) {
+        return;
+    }
+    if (this._len > 0 && this.fd >= 0) {
+        this._actualWrite();
+    } else {
+        $(this);
+    }
+};
+
+function v() {
+    if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+    }
+    if (this.fd < 0) {
+        throw new Error("sonic boom is not ready yet");
+    }
+    if (!this._writing && this._writingBuf.length > 0) {
+        this._bufs.unshift(this._writingBuf);
+        this._writingBuf = "";
+    }
+    let t = "";
+    while (this._bufs.length || t) {
+        if (t.length <= 0) {
+            t = this._bufs[0];
+        }
+        try {
+            const i = d.writeSync(this.fd, t, "utf8");
+            const e = k(t, this._len, i);
+            t = e.writingBuf;
+            this._len = e.len;
+            if (t.length <= 0) {
+                this._bufs.shift();
+            }
+        } catch (i) {
+            const e = i.code === "EAGAIN" || i.code === "EBUSY";
+            if (e && !this.retryEAGAIN(i, t.length, this._len - t.length)) {
+                throw i;
+            }
+            w(m);
+        }
+    }
+    try {
+        d.fsyncSync(this.fd);
+    } catch {}
+}
+
+function D() {
+    if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+    }
+    if (this.fd < 0) {
+        throw new Error("sonic boom is not ready yet");
+    }
+    if (!this._writing && this._writingBuf.length > 0) {
+        this._bufs.unshift([ this._writingBuf ]);
+        this._writingBuf = p;
+    }
+    let t = p;
+    while (this._bufs.length || t.length) {
+        if (t.length <= 0) {
+            t = I(this._bufs[0], this._lens[0]);
+        }
         try {
-            a(this, this.mapper(this[f]));
-        } catch (e) {
-            return t(e);
+            const i = d.writeSync(this.fd, t);
+            t = t.subarray(i);
+            this._len = Math.max(this._len - i, 0);
+            if (t.length <= 0) {
+                this._bufs.shift();
+                this._lens.shift();
+            }
+        } catch (i) {
+            const e = i.code === "EAGAIN" || i.code === "EBUSY";
+            if (e && !this.retryEAGAIN(i, t.length, this._len - t.length)) {
+                throw i;
+            }
+            w(m);
         }
     }
-    t();
 }
 
-function a(t, e) {
-    if (e !== undefined) {
-        t.push(e);
+W.prototype.destroy = function() {
+    if (this.destroyed) {
+        return;
+    }
+    $(this);
+};
+
+function M() {
+    const t = this.release;
+    this._writing = true;
+    this._writingBuf = this._writingBuf || this._bufs.shift() || "";
+    if (this.sync) {
+        try {
+            const i = d.writeSync(this.fd, this._writingBuf, "utf8");
+            t(null, i);
+        } catch (i) {
+            t(i);
+        }
+    } else {
+        d.write(this.fd, this._writingBuf, "utf8", t);
     }
 }
 
-function u(t) {
-    return t;
+function U() {
+    const t = this.release;
+    this._writing = true;
+    this._writingBuf = this._writingBuf.length ? this._writingBuf : I(this._bufs.shift(), this._lens.shift());
+    if (this.sync) {
+        try {
+            const i = d.writeSync(this.fd, this._writingBuf);
+            t(null, i);
+        } catch (i) {
+            t(i);
+        }
+    } else {
+        if (L) {
+            this._writingBuf = Buffer.from(this._writingBuf);
+        }
+        d.write(this.fd, this._writingBuf, t);
+    }
 }
 
-function p(t, e, s) {
-    t = t || /\r?\n/;
-    e = e || u;
-    s = s || {};
-    switch (arguments.length) {
-      case 1:
-        if (typeof t === "function") {
-            e = t;
-            t = /\r?\n/;
-        } else if (typeof t === "object" && !(t instanceof RegExp) && !t[Symbol.split]) {
-            s = t;
-            t = /\r?\n/;
-        }
-        break;
-
-      case 2:
-        if (typeof t === "function") {
-            s = e;
-            e = t;
-            t = /\r?\n/;
-        } else if (typeof e === "object") {
-            s = e;
-            e = u;
-        }
-    }
-    s = Object.assign({}, s);
-    s.autoDestroy = true;
-    s.transform = c;
-    s.flush = l;
-    s.readableObjectMode = true;
-    const r = new n(s);
-    r[f] = "";
-    r[h] = new o("utf8");
-    r.matcher = t;
-    r.mapper = e;
-    r.maxLength = s.maxLength;
-    r.skipOverflow = s.skipOverflow || false;
-    r.overflow = false;
-    r._destroy = function(t, e) {
-        this._writableState.errorEmitted = false;
-        e(t);
-    };
-    return r;
+function $(t) {
+    if (t.fd === -1) {
+        t.once("ready", $.bind(null, t));
+        return;
+    }
+    if (t._periodicFlushTimer !== undefined) {
+        clearInterval(t._periodicFlushTimer);
+    }
+    t.destroyed = true;
+    t._bufs = [];
+    t._lens = [];
+    y(typeof t.fd === "number", `sonic.fd must be a number, got ${typeof t.fd}`);
+    try {
+        d.fsync(t.fd, i);
+    } catch {}
+    function i() {
+        if (t.fd !== 1 && t.fd !== 2) {
+            d.close(t.fd, e);
+        } else {
+            e();
+        }
+    }
+    function e(i) {
+        if (i) {
+            t.emit("error", i);
+            return;
+        }
+        if (t._ending && !t._writing) {
+            t.emit("finish");
+        }
+        t.emit("close");
+    }
 }
 
-exports.split2 = p;
+W.SonicBoom = W;
+
+W.default = W;
+
+exports.sonicBoom = W;