lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.156.mjs

@@ -1,622 +1,723 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-import t from "fs";
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import { g as e } from "./Package.internal.110.mjs";
 
-import i from "events";
+import { c as t } from "./Package.internal.8.mjs";
 
-import e from "util";
-
-import s from "path";
-
-import { r as n } from "./Package.internal.29.mjs";
-
-import r from "assert";
-
-const h = t;
-
-const f = i;
-
-const o = e.inherits;
-
-const l = s;
+var n = {
+    exports: {}
+};
 
-const u = n();
+var r = {};
 
-const c = r;
+var i = t && t.__classPrivateFieldGet || function(e, t, n, r) {
+    if (n === "a" && !r) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof t === "function" ? e !== t || !r : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return n === "m" ? r : n === "a" ? r.call(e) : r ? r.value : t.get(e);
+};
 
-const d = 100;
+var s, l, a, f, u, o, h, v, p;
 
-const _ = Buffer.allocUnsafe(0);
+Object.defineProperty(r, "__esModule", {
+    value: true
+});
 
-const a = 16 * 1024;
+r.IntervalMatcher = r.GexMatcher = void 0;
 
-const g = "buffer";
+const c = e;
 
-const w = "utf8";
+class GexMatcher {
+    constructor() {}
+    make(e, t) {
+        if ("string" === typeof t && t.match(/[*?]/)) {
+            let e = (0, c.Gex)(t);
+            return {
+                kind: "gex",
+                match: t => null != e.on(t),
+                fix: t,
+                meta: {},
+                same(e) {
+                    return null != e && e.kind === this.kind && e.fix === this.fix;
+                }
+            };
+        } else return undefined;
+    }
+    scan(e, t) {
+        let n = e.filter(e => "*" === e.fix).length > 0;
+        return {
+            complete: n,
+            sound: n,
+            gaps: [],
+            overs: [],
+            why: "no-star"
+        };
+    }
+}
 
-const [m, y] = (process.versions.node || "0.0").split(".").map(Number);
+r.GexMatcher = GexMatcher;
 
-const p = m >= 22 && y >= 7;
+const m = new RegExp([ "^/s*", "(=*[<>/(/[]?=*)?" + "/s*" + "([-+0-9a-fA-FeEoOxX]+(/.([0-9a-fA-FeEoOxX]+))?)" + "([/)/]]?)" + "(" + "/s*(,|&+|/|+|/./.)" + "/s*" + "(=*[<>]?=*)" + "/s*" + "([-+.0-9a-fA-FeEoOxX]+)" + "/s*" + "([/)/]]?)" + ")?" + "/s*$" ].join("").replace(/\//g, "\\"));
 
-function B(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);
+class IntervalMatcher {
+    constructor() {
+        this.kind = "interval";
+        s.set(this, (e, t) => function n(r) {
+            return e(r) && t(r);
+        });
+        l.set(this, (e, t) => function n(r) {
+            return e(r) || t(r);
+        });
+        a.set(this, e => function e(t) {
+            return false;
+        });
+        f.set(this, e => function e(t) {
+            return false;
+        });
+        u.set(this, e => function t(n) {
+            return n > e;
+        });
+        o.set(this, e => function t(n) {
+            return n >= e;
+        });
+        h.set(this, e => function t(n) {
+            return n < e;
+        });
+        v.set(this, e => function t(n) {
+            return n <= e;
+        });
+        p.set(this, e => function t(n) {
+            return n === e;
+        });
+    }
+    make(e, t) {
+        if ("string" === typeof t && t.match(/[=<>.[()\]]/)) {
+            let e = t.match(m);
+            let n = {
+                jo: "and",
+                o0: "err",
+                n0: NaN,
+                o1: "err",
+                n1: NaN
+            };
+            let r = e => false;
+            if (null != e) {
+                let c = IntervalMatcher.normop(e[1]) || IntervalMatcher.normop(e[5]);
+                let m = IntervalMatcher.normop(e[8]) || IntervalMatcher.normop(e[10]);
+                let d = "=" === c ? i(this, p, "f") : "<" === c ? i(this, h, "f") : ")" === c ? i(this, h, "f") : "<=" === c ? i(this, v, "f") : "]" === c ? i(this, v, "f") : ">" === c ? i(this, u, "f") : "(" === c ? i(this, u, "f") : ">=" === c ? i(this, o, "f") : "[" === c ? i(this, o, "f") : i(this, f, "f");
+                let g = Number(e[2]);
+                let k = null == e[9] ? NaN : Number(e[9]);
+                let x = e[7];
+                let N = null == x ? i(this, l, "f") : "&" === x.substring(0, 1) ? i(this, s, "f") : "," === x.substring(0, 1) ? i(this, s, "f") : i(this, l, "f");
+                if (".." === x) {
+                    N = i(this, s, "f");
+                    d = i(this, f, "f") === d ? i(this, o, "f") : d;
+                    m = "" === m ? "<=" : m;
+                }
+                let y = null == m ? i(this, a, "f") : "=" === m ? i(this, p, "f") : "<" === m ? i(this, h, "f") : ")" === m ? i(this, h, "f") : "<=" === m ? i(this, v, "f") : "]" === m ? i(this, v, "f") : ">" === m ? i(this, u, "f") : ">=" === m ? i(this, o, "f") : i(this, f, "f");
+                if (g === k) {
+                    if ("=" === c && null != m) {
+                        k = NaN;
+                        y = i(this, a, "f");
+                        if (m.includes("<")) {
+                            d = i(this, v, "f");
+                        } else if (m.includes(">")) {
+                            d = i(this, o, "f");
+                        } else if (m.includes("=")) {
+                            d = i(this, p, "f");
+                        } else {
+                            d = i(this, f, "f");
+                        }
+                    } else if ("=" === m && null != c) {
+                        k = NaN;
+                        y = i(this, a, "f");
+                        if (c.includes("<")) {
+                            d = i(this, v, "f");
+                        } else if (c.includes(">")) {
+                            d = i(this, o, "f");
+                        } else {
+                            d = i(this, f, "f");
+                        }
                     }
-                });
-            } else {
-                i.emit("error", e);
+                }
+                if (i(this, f, "f") !== d) {
+                    if (i(this, a, "f") === y) {
+                        if (i(this, h, "f") === d || i(this, v, "f") === d) {
+                            y = d;
+                            k = g;
+                            d = i(this, o, "f");
+                            g = Number.NEGATIVE_INFINITY;
+                            N = i(this, s, "f");
+                        } else if (i(this, u, "f") === d || i(this, o, "f") === d) {
+                            y = i(this, v, "f");
+                            k = Number.POSITIVE_INFINITY;
+                            N = i(this, s, "f");
+                        }
+                    }
+                }
+                if (!isNaN(k) && k < g) {
+                    let e = y;
+                    let t = k;
+                    k = g;
+                    g = t;
+                    if (".." !== x) {
+                        y = d;
+                        d = e;
+                    }
+                }
+                let I = d(g);
+                let w = y(k);
+                let M = N(I, w);
+                n = {
+                    jo: M.name,
+                    o0: I.name,
+                    n0: g,
+                    o1: w.name,
+                    n1: k
+                };
+                r = e => {
+                    let t = false;
+                    let n = parseFloat(e);
+                    if (!isNaN(n)) {
+                        t = M(n);
+                    }
+                    return t;
+                };
+                return {
+                    kind: "interval",
+                    fix: t,
+                    meta: n,
+                    match: r,
+                    same(e) {
+                        return null != e && e.kind === this.kind && e.meta.jo === this.meta.jo && e.meta.o0 === this.meta.o0 && e.meta.n0 === this.meta.n0 && e.meta.o1 === this.meta.o1 && e.meta.n1 === this.meta.n1;
+                    }
+                };
             }
-            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"));
-        }
-    }
-    const s = i.append ? "a" : "w";
-    const n = i.mode;
-    if (i.sync) {
-        try {
-            if (i.mkdir) h.mkdirSync(l.dirname(t), {
-                recursive: true
-            });
-            const r = h.openSync(t, s, n);
-            e(null, r);
-        } catch (t) {
-            e(t);
-            throw t;
-        }
-    } else if (i.mkdir) {
-        h.mkdir(l.dirname(t), {
-            recursive: true
-        }, i => {
-            if (i) return e(i);
-            h.open(t, s, n, e);
-        });
-    } else {
-        h.open(t, s, n, e);
     }
-}
-
-function b(t) {
-    if (!(this instanceof b)) {
-        return new b(t);
-    }
-    let {fd: i, dest: e, minLength: s, maxLength: n, maxWrite: r, periodicFlush: f, sync: o, append: l = true, mkdir: c, retryEAGAIN: m, fsync: y, contentMode: p, mode: x} = 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 || a;
-    this._periodicFlush = f || 0;
-    this._periodicFlushTimer = undefined;
-    this.sync = o || false;
-    this.writable = true;
-    this._fsync = y || false;
-    this.append = l || false;
-    this.mode = x;
-    this.retryEAGAIN = m || (() => true);
-    this.mkdir = c || false;
-    let A;
-    let P;
-    if (p === g) {
-        this._writingBuf = _;
-        this.write = W;
-        this.flush = T;
-        this.flushSync = F;
-        this._actualWrite = G;
-        A = () => h.writeSync(this.fd, this._writingBuf);
-        P = () => h.write(this.fd, this._writingBuf, this.release);
-    } else if (p === undefined || p === w) {
-        this._writingBuf = "";
-        this.write = L;
-        this.flush = k;
-        this.flushSync = I;
-        this._actualWrite = N;
-        A = () => h.writeSync(this.fd, this._writingBuf, "utf8");
-        P = () => h.write(this.fd, this._writingBuf, "utf8", this.release);
-    } else {
-        throw new Error(`SonicBoom supports "${w}" and "${g}", but passed ${p}`);
-    }
-    if (typeof i === "number") {
-        this.fd = i;
-        process.nextTick(() => this.emit("ready"));
-    } else if (typeof i === "string") {
-        B(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 {
-                        u(d);
-                        this.release(undefined, 0);
-                    } catch (t) {
-                        this.release(t);
+    scan(e, t) {
+        let n = {
+            complete: false,
+            sound: false,
+            gaps: [],
+            overs: [],
+            lower: null,
+            upper: null
+        };
+        let r = Number.NEGATIVE_INFINITY;
+        let i = Number.POSITIVE_INFINITY;
+        let s = this.half_intervals(e);
+        s.reduce((e, t) => {
+            let n = "eq" === t.o;
+            let i = "lt" === t.o;
+            let s = "lte" === t.o;
+            let l = "gt" === t.o;
+            let a = "gte" === t.o;
+            let f = t.n;
+            if (null == e.lower) {
+                let i = {
+                    n: r,
+                    o: "gte"
+                };
+                e.lower = i;
+                e.upper = t;
+                if (!(r == f && a)) {
+                    if (l || a) {
+                        e.gaps.push([ i, {
+                            n: f,
+                            o: l ? "lte" : "lt",
+                            m: 0
+                        } ]);
+                    } else if (n) {
+                        e.gaps.push([ i, {
+                            n: f,
+                            o: "lte",
+                            m: 1
+                        } ]);
                     }
-                } else {
-                    setTimeout(P, d);
                 }
             } else {
-                this._writing = false;
-                this.emit("error", t);
-            }
-            return;
-        }
-        this.emit("write", i);
-        const e = S(this._writingBuf, this._len, i);
-        this._len = e.len;
-        this._writingBuf = e.writingBuf;
-        if (this._writingBuf.length) {
-            if (!this.sync) {
-                P();
-                return;
-            }
-            try {
-                do {
-                    const t = A();
-                    const i = S(this._writingBuf, this._len, t);
-                    this._len = i.len;
-                    this._writingBuf = i.writingBuf;
-                } while (this._writingBuf.length);
-            } catch (t) {
-                this.release(t);
-                return;
+                let r = "eq" === e.upper.o;
+                let u = "lt" === e.upper.o;
+                let o = "lte" === e.upper.o;
+                "gt" === e.upper.o;
+                "hgte" === e.upper.o;
+                let h = e.upper.n;
+                let v = e.upper;
+                if (f === h) {
+                    if (u && (a || n) || (o || r) && l) ; else if (r || u || o) {
+                        e.gaps.push([ {
+                            n: h,
+                            o: r || o ? "gt" : "gte",
+                            m: 2,
+                            d: {
+                                u: v,
+                                h: t
+                            }
+                        }, {
+                            n: f,
+                            o: n || a ? "lt" : "lte",
+                            m: 3
+                        } ]);
+                    } else ;
+                } else if (h < f) {
+                    if (i || s) ; else if (r || u || o) {
+                        e.gaps.push([ {
+                            n: h,
+                            o: r || o ? "gt" : "gte",
+                            m: 4
+                        }, {
+                            n: f,
+                            o: n || a ? "lt" : "lte",
+                            m: 5
+                        } ]);
+                    }
+                } else {
+                    e.overs.push([ {
+                        n: f,
+                        o: n || a ? "gte" : "gt",
+                        m: 10
+                    }, {
+                        n: h,
+                        o: r || o ? "lte" : "lt",
+                        m: 11
+                    } ]);
+                }
+                e.upper = t;
             }
+            return e;
+        }, n);
+        let l = 0 < s.length && s[s.length - 1];
+        if (l && i !== l.n && l.o !== "gt" && l.o !== "gte") {
+            n.gaps.push([ {
+                n: l.n,
+                o: l.o === "eq" || l.o === "lte" ? "gt" : "gte",
+                m: 6
+            }, {
+                n: i,
+                o: "lte",
+                m: 7
+            } ]);
         }
-        if (this._fsync) {
-            h.fsyncSync(this.fd);
+        n.complete = 0 === n.gaps.length;
+        n.sound = 0 === n.overs.length;
+        return n;
+    }
+    half_intervals(e) {
+        let t = [];
+        for (let n of e) {
+            t.push([ {
+                n: n.meta.n0,
+                o: n.meta.o0
+            }, {
+                n: n.meta.n1,
+                o: n.meta.o1
+            } ]);
         }
-        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();
+        var n = [ "lt", "lte", "eq", "gte", "gt" ];
+        var r = t.map(e => [ isNaN(e[0].n) || null == e[0].n ? null : e[0], isNaN(e[1].n) || null == e[1].n ? null : e[1] ].filter(e => null != e)).sort((e, t) => {
+            if (e[0].n < t[0].n) {
+                return -1;
+            } else if (t[0].n < e[0].n) {
+                return 1;
             } else {
-                this._writing = false;
-                v(this);
-            }
-        } else {
-            this._writing = false;
-            if (this.sync) {
-                if (!this._asyncDrainScheduled) {
-                    this._asyncDrainScheduled = true;
-                    process.nextTick(E, this);
+                var r = n.indexOf(e[0].o);
+                var i = n.indexOf(t[0].o);
+                if (r < i) {
+                    return -1;
+                } else if (i < r) {
+                    return 1;
+                } else {
+                    if (e[1].n < t[1].n) {
+                        return -1;
+                    } else if (t[1].n < e[1].n) {
+                        return 1;
+                    } else {
+                        var s = n.indexOf(e[1].o);
+                        var l = n.indexOf(t[1].o);
+                        return s < l ? -1 : l < s ? 1 : 0;
+                    }
                 }
-            } 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();
+        }).reduce((e, t) => e.concat(...t), []);
+        return r;
     }
 }
 
-function S(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
-    };
-}
+r.IntervalMatcher = IntervalMatcher;
 
-function E(t) {
-    const i = t.listenerCount("drain") > 0;
-    if (!i) return;
-    t._asyncDrainScheduled = false;
-    t.emit("drain");
-}
+s = new WeakMap, l = new WeakMap, a = new WeakMap, f = new WeakMap, u = new WeakMap, 
+o = new WeakMap, h = new WeakMap, v = new WeakMap, p = new WeakMap;
 
-o(b, f);
+IntervalMatcher.normop = e => null == e ? null : ((e.match(/([<>\(\)\[\]])/) || [])[1] || "") + ((e.match(/(=)/) || [])[1] || "");
 
-function x(t, i) {
-    if (t.length === 0) {
-        return _;
-    }
-    if (t.length === 1) {
-        return t[0];
-    }
-    return Buffer.concat(t, i);
-}
-
-function L(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 W(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;
-}
+n.exports;
 
-function A(t) {
-    this._flushPending = true;
-    const i = () => {
-        if (!this._fsync) {
-            try {
-                h.fsync(this.fd, i => {
-                    this._flushPending = false;
-                    t(i);
-                });
-            } catch (i) {
-                t(i);
-            }
-        } else {
-            this._flushPending = false;
-            t();
+(function(t, n) {
+    Object.defineProperty(n, "__esModule", {
+        value: true
+    });
+    n.Gex = void 0;
+    n.Patrun = l;
+    const i = e;
+    Object.defineProperty(n, "Gex", {
+        enumerable: true,
+        get: function() {
+            return i.Gex;
         }
-        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 k(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;
+    });
+    const s = r;
+    function l(e) {
+        e = e || {};
+        var t = {};
+        var n = {};
+        let r = [];
+        if (e.gex) {
+            r.push(new s.GexMatcher);
         }
-        throw i;
-    }
-    if (this.minLength <= 0) {
-        t?.();
-        return;
-    }
-    if (t) {
-        A.call(this, t);
-    }
-    if (this._writing) {
-        return;
-    }
-    if (this._bufs.length === 0) {
-        this._bufs.push("");
-    }
-    this._actualWrite();
-}
-
-function T(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;
+        if (e.interval) {
+            r.push(new s.IntervalMatcher);
         }
-        throw i;
-    }
-    if (this.minLength <= 0) {
-        t?.();
-        return;
-    }
-    if (t) {
-        A.call(this, t);
-    }
-    if (this._writing) {
-        return;
-    }
-    if (this._bufs.length === 0) {
-        this._bufs.push([]);
-        this._lens.push(0);
-    }
-    this._actualWrite();
-}
-
-b.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) {
-            h.close(i, t => {
-                if (t) {
-                    return this.emit("error", t);
-                }
+        t.top = function() {
+            return n;
+        };
+        t.add = function(i, s) {
+            i = {
+                ...i
+            };
+            var l = "function" === typeof e ? e.call(t, i, s) : null;
+            var a = Object.keys(i).filter(e => null != i[e]).sort();
+            a.forEach(function(e) {
+                i[e] = String(i[e]);
             });
-        }
-    });
-    B(this.file, this);
-};
-
-b.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 {
-        v(this);
-    }
-};
-
-function I() {
-    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 = h.writeSync(this.fd, t, "utf8");
-            const e = S(t, this._len, i);
-            t = e.writingBuf;
-            this._len = e.len;
-            if (t.length <= 0) {
-                this._bufs.shift();
+            var f = n;
+            var u;
+            for (var o = 0; o < a.length; o++) {
+                var h = a[o];
+                var v = i[h];
+                let e = r.reduce((e, t) => e || t.make(h, v), undefined);
+                u = f.v;
+                if (u && h == f.k) {
+                    if (e) {
+                        var p = f.g = f.g || {};
+                        var c = p[h] = p[h] || [];
+                        e = c.find(t => t.same(e)) || (c.push(e), e);
+                        f = e.keymap || (e.keymap = {});
+                    } else {
+                        f = u[v] || (u[v] = {});
+                    }
+                } else if (!f.k) {
+                    f.k = h;
+                    f.v = {};
+                    if (e) {
+                        var p = f.g = f.g || {};
+                        var c = p[h] = p[h] || [];
+                        e = c.find(t => t.same(e)) || (c.push(e), e);
+                        f = e.keymap || (e.keymap = {});
+                    } else {
+                        f = f.v[v] = {};
+                    }
+                } else if (h < f.k) {
+                    var m = f.s;
+                    var p = f.g;
+                    f.s = {
+                        k: f.k,
+                        v: f.v
+                    };
+                    if (m) {
+                        f.s.s = m;
+                    }
+                    if (p) {
+                        f.s.g = p;
+                    }
+                    if (f.g) {
+                        f.g = {};
+                    }
+                    f.k = h;
+                    f.v = {};
+                    if (e) {
+                        var p = f.g = f.g || {};
+                        var c = p[h] = p[h] || [];
+                        e = c.find(t => t.same(e)) || (c.push(e), e);
+                        f = e.keymap || (e.keymap = {});
+                    } else {
+                        f = f.v[v] = {};
+                    }
+                } else {
+                    f = f.s || (f.s = {});
+                    o--;
+                }
             }
-        } catch (i) {
-            const e = i.code === "EAGAIN" || i.code === "EBUSY";
-            if (e && !this.retryEAGAIN(i, t.length, this._len - t.length)) {
-                throw i;
+            if (void 0 !== s && f) {
+                f.d = s;
+                if (l) {
+                    f.f = "function" === typeof l ? l : l.find;
+                    f.r = "function" === typeof l.remove ? l.remove : void 0;
+                }
             }
-            u(d);
-        }
-    }
-    try {
-        h.fsyncSync(this.fd);
-    } catch {}
-}
-
-function F() {
-    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.length) {
-        if (t.length <= 0) {
-            t = x(this._bufs[0], this._lens[0]);
-        }
-        try {
-            const i = h.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();
+            return t;
+        };
+        t.findexact = function(e) {
+            return t.find(e, true);
+        };
+        t.find = function(e, r, i) {
+            if (null == e) return null;
+            var s = n;
+            var l = void 0 === n.d ? null : n.d;
+            var a = n.f;
+            var f = null;
+            var u = [];
+            var o = {};
+            var h = Object.keys(e).length;
+            var v = [];
+            if (void 0 !== n.d) {
+                v.push(n.d);
             }
-        } catch (i) {
-            const e = i.code === "EAGAIN" || i.code === "EBUSY";
-            if (e && !this.retryEAGAIN(i, t.length, this._len - t.length)) {
-                throw i;
+            do {
+                f = s.k;
+                if (s.v) {
+                    var p = e[f];
+                    var c = s.v[p];
+                    if (!c && s.g && s.g[f]) {
+                        var m = s.g[f];
+                        for (var d = 0; d < m.length; d++) {
+                            if (m[d].match(p)) {
+                                c = m[d].keymap;
+                                break;
+                            }
+                        }
+                    }
+                    if (c) {
+                        o[f] = true;
+                        if (s.s) {
+                            u.push(s.s);
+                        }
+                        l = void 0 === c.d ? r ? null : l : c.d;
+                        if (i && void 0 !== c.d) {
+                            v.push(c.d);
+                        }
+                        a = c.f;
+                        s = c;
+                    } else {
+                        s = s.s;
+                    }
+                } else {
+                    s = null;
+                }
+                if (null == s && 0 < u.length && (null == l || i && !r)) {
+                    s = u.pop();
+                }
+            } while (s);
+            if (r) {
+                if (Object.keys(o).length !== h) {
+                    l = null;
+                }
+            } else {
+                if (null == l && void 0 !== n.d) {
+                    l = n.d;
+                }
             }
-            u(d);
-        }
-    }
-}
-
-b.prototype.destroy = function() {
-    if (this.destroyed) {
-        return;
-    }
-    v(this);
-};
-
-function N() {
-    const t = this.release;
-    this._writing = true;
-    this._writingBuf = this._writingBuf || this._bufs.shift() || "";
-    if (this.sync) {
-        try {
-            const i = h.writeSync(this.fd, this._writingBuf, "utf8");
-            t(null, i);
-        } catch (i) {
-            t(i);
-        }
-    } else {
-        h.write(this.fd, this._writingBuf, "utf8", t);
-    }
-}
-
-function G() {
-    const t = this.release;
-    this._writing = true;
-    this._writingBuf = this._writingBuf.length ? this._writingBuf : x(this._bufs.shift(), this._lens.shift());
-    if (this.sync) {
-        try {
-            const i = h.writeSync(this.fd, this._writingBuf);
-            t(null, i);
-        } catch (i) {
-            t(i);
-        }
-    } else {
-        if (p) {
-            this._writingBuf = Buffer.from(this._writingBuf);
-        }
-        h.write(this.fd, this._writingBuf, t);
-    }
-}
-
-function v(t) {
-    if (t.fd === -1) {
-        t.once("ready", v.bind(null, t));
-        return;
-    }
-    if (t._periodicFlushTimer !== undefined) {
-        clearInterval(t._periodicFlushTimer);
-    }
-    t.destroyed = true;
-    t._bufs = [];
-    t._lens = [];
-    c(typeof t.fd === "number", `sonic.fd must be a number, got ${typeof t.fd}`);
-    try {
-        h.fsync(t.fd, i);
-    } catch {}
-    function i() {
-        if (t.fd !== 1 && t.fd !== 2) {
-            h.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");
-    }
-}
-
-b.SonicBoom = b;
-
-b.default = b;
-
-var P = b;
-
-export { P as s };
+            if (a) {
+                l = a.call(t, e, l);
+            }
+            return i ? v : l;
+        };
+        t.remove = function(e) {
+            var t = n;
+            var r = null;
+            var i;
+            var s = [];
+            do {
+                i = t.k;
+                if (t.v || t.g) {
+                    if (t.v) {
+                        var l = t.v[e[i]];
+                        if (l) {
+                            s.push({
+                                km: t,
+                                v: e[i]
+                            });
+                        }
+                    }
+                    if (null == l && t.g) {
+                        let n = t.g[i] || [];
+                        for (let r = 0; r < n.length; r++) {
+                            if (n[r].fix === e[i]) {
+                                s.push({
+                                    km: t,
+                                    v: e[i],
+                                    mv: n[r]
+                                });
+                                l = n[r].keymap;
+                                break;
+                            }
+                        }
+                    }
+                    if (l) {
+                        r = l.d;
+                        t = l;
+                    } else {
+                        t = t.s;
+                    }
+                } else {
+                    t = null;
+                }
+            } while (t);
+            if (void 0 !== r) {
+                var a = s[s.length - 1];
+                if (a && a.km && a.km.v) {
+                    var f = a.km.v[a.v] || a.mv && a.mv.keymap;
+                    if (f && (!f.r || f.r(e, f.d))) {
+                        delete f.d;
+                    }
+                }
+            }
+        };
+        t.list = function(e, t) {
+            e = e || {};
+            function r(n, s, l, a) {
+                if (n.v) {
+                    var f = n.k;
+                    var u = (0, i.Gex)(e ? null == e[f] ? t ? null : "*" : e[f] : "*");
+                    var o = {
+                        ...s
+                    };
+                    var h = {
+                        ...l
+                    };
+                    var v;
+                    for (var p in n.v) {
+                        if (p === e[f] || !t && null == e[f] || u.on(p)) {
+                            var c = {
+                                ...o
+                            };
+                            c[f] = p;
+                            var m = {
+                                ...h
+                            };
+                            delete m[f];
+                            v = n.v[p];
+                            if (0 === Object.keys(m).length && v && v.d) {
+                                a.push({
+                                    match: c,
+                                    data: v.d,
+                                    find: v.f
+                                });
+                            }
+                            if (v && null != v.v) {
+                                r(v, {
+                                    ...c
+                                }, {
+                                    ...m
+                                }, a);
+                            }
+                        }
+                    }
+                    v = n.s;
+                    if (v) {
+                        r(v, {
+                            ...o
+                        }, {
+                            ...h
+                        }, a);
+                    }
+                }
+            }
+            var s = [];
+            if (n.d) {
+                s.push({
+                    match: {},
+                    data: n.d,
+                    find: n.f
+                });
+            }
+            r(n, {}, {
+                ...e
+            }, s);
+            return s;
+        };
+        t.toString = function(e, t) {
+            var r = true === e ? true : !!t;
+            var i = "function" === typeof e ? e : function(e) {
+                return "function" === typeof e ? "<" + e.name + ">" : "<" + e + ">";
+            };
+            function s(e, t) {
+                for (var n = 0; n < t; n++) {
+                    e.push(" ");
+                }
+            }
+            var l = [];
+            function a(e, t, n, r) {
+                var f;
+                if (void 0 !== e.d) {
+                    t.push(" " + i(e.d));
+                    l.push(r.join(", ") + " -> " + i(e.d));
+                }
+                if (e.k) {
+                    t.push("\n");
+                    s(t, n);
+                    t.push(e.k + ":");
+                }
+                if (e.v || e.s || e.g) {
+                    n++;
+                }
+                if (e.v) {
+                    var u = Object.keys(e.v).sort();
+                    for (var o = 0; o < u.length; o++) {
+                        var h = u[o];
+                        t.push("\n");
+                        s(t, n);
+                        t.push(h + " ->");
+                        f = r.slice();
+                        f.push(e.k + "=" + h);
+                        a(e.v[h], t, n + 1, f);
+                    }
+                }
+                if (e.g) {
+                    var u = Object.keys(e.g).sort();
+                    for (var o = 0; o < u.length; o++) {
+                        var v = e.g[u[o]];
+                        for (var p = 0; p < v.length; p++) {
+                            var c = v[p];
+                            t.push("\n");
+                            s(t, n);
+                            t.push(c.fix + " ~>");
+                            f = r.slice();
+                            f.push(e.k + "~" + c.fix);
+                            a(c.keymap, t, n + 1, f);
+                        }
+                    }
+                }
+                if (e.s) {
+                    t.push("\n");
+                    s(t, n);
+                    t.push("|");
+                    f = r.slice();
+                    a(e.s, t, n + 1, f);
+                }
+            }
+            var f = [];
+            a(n, f, 0, []);
+            return r ? f.join("") : l.join("\n");
+        };
+        t.inspect = t.toString;
+        t.toJSON = function(e) {
+            return JSON.stringify(n, function(e, t) {
+                if ("function" === typeof t) return "[Function]";
+                return t;
+            }, e);
+        };
+        return t;
+    }
+    function a(e) {
+        return new l(e);
+    }
+    {
+        t.exports = a;
+        t.exports.Patrun = l;
+        t.exports.Gex = i.Gex;
+    }
+    n.default = a;
+})(n, n.exports);
+
+var d = n.exports;
+
+export { d as p };