lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.41.mjs

@@ -1,639 +1,415 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-import "util";
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import { r as t } from "./Package.internal.42.mjs";
 
-import "./Package.internal.42.mjs";
+import { r as e } from "./Package.internal.43.mjs";
 
-import { f as e } from "./Package.internal.43.mjs";
+import n from "buffer";
 
-var t = {};
-
-(function(e) {
-    e.isInteger = e => {
-        if (typeof e === "number") {
-            return Number.isInteger(e);
-        }
-        if (typeof e === "string" && e.trim() !== "") {
-            return Number.isInteger(Number(e));
-        }
-        return false;
-    };
-    e.find = (e, t) => e.nodes.find(e => e.type === t);
-    e.exceedsLimit = (t, n, r = 1, o) => {
-        if (o === false) return false;
-        if (!e.isInteger(t) || !e.isInteger(n)) return false;
-        return (Number(n) - Number(t)) / Number(r) >= o;
-    };
-    e.escapeNode = (e, t = 0, n) => {
-        const r = e.nodes[t];
-        if (!r) return;
-        if (n && r.type === n || r.type === "open" || r.type === "close") {
-            if (r.escaped !== true) {
-                r.value = "\\" + r.value;
-                r.escaped = true;
-            }
-        }
-    };
-    e.encloseBrace = e => {
-        if (e.type !== "brace") return false;
-        if (e.commas >> 0 + e.ranges >> 0 === 0) {
-            e.invalid = true;
-            return true;
-        }
-        return false;
-    };
-    e.isInvalidBrace = e => {
-        if (e.type !== "brace") return false;
-        if (e.invalid === true || e.dollar) return true;
-        if (e.commas >> 0 + e.ranges >> 0 === 0) {
-            e.invalid = true;
-            return true;
-        }
-        if (e.open !== true || e.close !== true) {
-            e.invalid = true;
-            return true;
-        }
-        return false;
-    };
-    e.isOpenOrClose = e => {
-        if (e.type === "open" || e.type === "close") {
-            return true;
-        }
-        return e.open === true || e.close === true;
-    };
-    e.reduce = e => e.reduce((e, t) => {
-        if (t.type === "text") e.push(t.value);
-        if (t.type === "range") t.type = "text";
-        return e;
-    }, []);
-    e.flatten = (...e) => {
-        const t = [];
-        const n = e => {
-            for (let r = 0; r < e.length; r++) {
-                const o = e[r];
-                if (Array.isArray(o)) {
-                    n(o);
-                    continue;
-                }
-                if (o !== undefined) {
-                    t.push(o);
-                }
-            }
-            return t;
-        };
-        n(e);
-        return t;
-    };
-})(t);
-
-const n = t;
-
-var r = (e, t = {}) => {
-    const r = (e, o = {}) => {
-        const s = t.escapeInvalid && n.isInvalidBrace(o);
-        const i = e.invalid === true && t.escapeInvalid === true;
-        let u = "";
-        if (e.value) {
-            if ((s || i) && n.isOpenOrClose(e)) {
-                return "\\" + e.value;
-            }
-            return e.value;
-        }
-        if (e.value) {
-            return e.value;
-        }
-        if (e.nodes) {
-            for (const t of e.nodes) {
-                u += r(t);
-            }
-        }
-        return u;
-    };
-    return r(e);
+var i = {
+    exports: {}
 };
 
-const o = e;
-
-const s = t;
+const {Buffer: s} = n;
 
-const i = (e, t = {}) => {
-    const n = (e, r = {}) => {
-        const i = s.isInvalidBrace(r);
-        const u = e.invalid === true && t.escapeInvalid === true;
-        const a = i === true || u === true;
-        const l = t.escapeInvalid === true ? "\\" : "";
-        let p = "";
-        if (e.isOpen === true) {
-            return l + e.value;
-        }
-        if (e.isClose === true) {
-            console.log("node.isClose", l, e.value);
-            return l + e.value;
-        }
-        if (e.type === "open") {
-            return a ? l + e.value : "(";
-        }
-        if (e.type === "close") {
-            return a ? l + e.value : ")";
-        }
-        if (e.type === "comma") {
-            return e.prev.type === "comma" ? "" : a ? e.value : "|";
-        }
-        if (e.value) {
-            return e.value;
-        }
-        if (e.nodes && e.ranges > 0) {
-            const n = s.reduce(e.nodes);
-            const r = o(...n, {
-                ...t,
-                wrap: false,
-                toRegex: true,
-                strictZeros: true
-            });
-            if (r.length !== 0) {
-                return n.length > 1 && r.length > 1 ? `(${r})` : r;
-            }
-        }
-        if (e.nodes) {
-            for (const t of e.nodes) {
-                p += n(t, e);
-            }
-        }
-        return p;
-    };
-    return n(e);
-};
+const f = Symbol.for("BufferList");
 
-var u = i;
-
-const a = e;
+function r(t) {
+    if (!(this instanceof r)) {
+        return new r(t);
+    }
+    r._init.call(this, t);
+}
 
-const l = r;
+r._init = function t(e) {
+    Object.defineProperty(this, f, {
+        value: true
+    });
+    this._bufs = [];
+    this.length = 0;
+    if (e) {
+        this.append(e);
+    }
+};
 
-const p = t;
+r.prototype._new = function t(e) {
+    return new r(e);
+};
 
-const c = (e = "", t = "", n = false) => {
-    const r = [];
-    e = [].concat(e);
-    t = [].concat(t);
-    if (!t.length) return e;
-    if (!e.length) {
-        return n ? p.flatten(t).map(e => `{${e}}`) : t;
+r.prototype._offset = function t(e) {
+    if (e === 0) {
+        return [ 0, 0 ];
     }
-    for (const o of e) {
-        if (Array.isArray(o)) {
-            for (const e of o) {
-                r.push(c(e, t, n));
-            }
-        } else {
-            for (let e of t) {
-                if (n === true && typeof e === "string") e = `{${e}}`;
-                r.push(Array.isArray(e) ? c(o, e, n) : o + e);
-            }
+    let n = 0;
+    for (let t = 0; t < this._bufs.length; t++) {
+        const i = n + this._bufs[t].length;
+        if (e < i || t === this._bufs.length - 1) {
+            return [ t, e - n ];
         }
+        n = i;
     }
-    return p.flatten(r);
 };
 
-const f = (e, t = {}) => {
-    const n = t.rangeLimit === undefined ? 1e3 : t.rangeLimit;
-    const r = (e, o = {}) => {
-        e.queue = [];
-        let s = o;
-        let i = o.queue;
-        while (s.type !== "brace" && s.type !== "root" && s.parent) {
-            s = s.parent;
-            i = s.queue;
-        }
-        if (e.invalid || e.dollar) {
-            i.push(c(i.pop(), l(e, t)));
-            return;
-        }
-        if (e.type === "brace" && e.invalid !== true && e.nodes.length === 2) {
-            i.push(c(i.pop(), [ "{}" ]));
-            return;
-        }
-        if (e.nodes && e.ranges > 0) {
-            const r = p.reduce(e.nodes);
-            if (p.exceedsLimit(...r, t.step, n)) {
-                throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
-            }
-            let o = a(...r, t);
-            if (o.length === 0) {
-                o = l(e, t);
-            }
-            i.push(c(i.pop(), o));
-            e.nodes = [];
-            return;
-        }
-        const u = p.encloseBrace(e);
-        let f = e.queue;
-        let A = e;
-        while (A.type !== "brace" && A.type !== "root" && A.parent) {
-            A = A.parent;
-            f = A.queue;
-        }
-        for (let t = 0; t < e.nodes.length; t++) {
-            const n = e.nodes[t];
-            if (n.type === "comma" && e.type === "brace") {
-                if (t === 1) f.push("");
-                f.push("");
-                continue;
-            }
-            if (n.type === "close") {
-                i.push(c(i.pop(), f, u));
-                continue;
-            }
-            if (n.value && n.type !== "open") {
-                f.push(c(f.pop(), n.value));
-                continue;
-            }
-            if (n.nodes) {
-                r(n, e);
-            }
-        }
-        return f;
-    };
-    return p.flatten(r(e));
+r.prototype._reverseOffset = function(t) {
+    const e = t[0];
+    let n = t[1];
+    for (let t = 0; t < e; t++) {
+        n += this._bufs[t].length;
+    }
+    return n;
 };
 
-var A = f;
-
-var R = {
-    MAX_LENGTH: 1e4,
-    CHAR_0: "0",
-    CHAR_9: "9",
-    CHAR_UPPERCASE_A: "A",
-    CHAR_LOWERCASE_A: "a",
-    CHAR_UPPERCASE_Z: "Z",
-    CHAR_LOWERCASE_Z: "z",
-    CHAR_LEFT_PARENTHESES: "(",
-    CHAR_RIGHT_PARENTHESES: ")",
-    CHAR_ASTERISK: "*",
-    CHAR_AMPERSAND: "&",
-    CHAR_AT: "@",
-    CHAR_BACKSLASH: "\\",
-    CHAR_BACKTICK: "`",
-    CHAR_CARRIAGE_RETURN: "\r",
-    CHAR_CIRCUMFLEX_ACCENT: "^",
-    CHAR_COLON: ":",
-    CHAR_COMMA: ",",
-    CHAR_DOLLAR: "$",
-    CHAR_DOT: ".",
-    CHAR_DOUBLE_QUOTE: '"',
-    CHAR_EQUAL: "=",
-    CHAR_EXCLAMATION_MARK: "!",
-    CHAR_FORM_FEED: "\f",
-    CHAR_FORWARD_SLASH: "/",
-    CHAR_HASH: "#",
-    CHAR_HYPHEN_MINUS: "-",
-    CHAR_LEFT_ANGLE_BRACKET: "<",
-    CHAR_LEFT_CURLY_BRACE: "{",
-    CHAR_LEFT_SQUARE_BRACKET: "[",
-    CHAR_LINE_FEED: "\n",
-    CHAR_NO_BREAK_SPACE: " ",
-    CHAR_PERCENT: "%",
-    CHAR_PLUS: "+",
-    CHAR_QUESTION_MARK: "?",
-    CHAR_RIGHT_ANGLE_BRACKET: ">",
-    CHAR_RIGHT_CURLY_BRACE: "}",
-    CHAR_RIGHT_SQUARE_BRACKET: "]",
-    CHAR_SEMICOLON: ";",
-    CHAR_SINGLE_QUOTE: "'",
-    CHAR_SPACE: " ",
-    CHAR_TAB: "\t",
-    CHAR_UNDERSCORE: "_",
-    CHAR_VERTICAL_LINE: "|",
-    CHAR_ZERO_WIDTH_NOBREAK_SPACE: "\ufeff"
+r.prototype.get = function t(e) {
+    if (e > this.length || e < 0) {
+        return undefined;
+    }
+    const n = this._offset(e);
+    return this._bufs[n[0]][n[1]];
 };
 
-const _ = r;
-
-const {MAX_LENGTH: C, CHAR_BACKSLASH: E, CHAR_BACKTICK: d, CHAR_COMMA: y, CHAR_DOT: H, CHAR_LEFT_PARENTHESES: v, CHAR_RIGHT_PARENTHESES: g, CHAR_LEFT_CURLY_BRACE: h, CHAR_RIGHT_CURLY_BRACE: m, CHAR_LEFT_SQUARE_BRACKET: T, CHAR_RIGHT_SQUARE_BRACKET: L, CHAR_DOUBLE_QUOTE: S, CHAR_SINGLE_QUOTE: x, CHAR_NO_BREAK_SPACE: I, CHAR_ZERO_WIDTH_NOBREAK_SPACE: O} = R;
+r.prototype.slice = function t(e, n) {
+    if (typeof e === "number" && e < 0) {
+        e += this.length;
+    }
+    if (typeof n === "number" && n < 0) {
+        n += this.length;
+    }
+    return this.copy(null, 0, e, n);
+};
 
-const N = (e, t = {}) => {
-    if (typeof e !== "string") {
-        throw new TypeError("Expected a string");
+r.prototype.copy = function t(e, n, i, f) {
+    if (typeof i !== "number" || i < 0) {
+        i = 0;
     }
-    const n = t || {};
-    const r = typeof n.maxLength === "number" ? Math.min(C, n.maxLength) : C;
-    if (e.length > r) {
-        throw new SyntaxError(`Input length (${e.length}), exceeds max characters (${r})`);
+    if (typeof f !== "number" || f > this.length) {
+        f = this.length;
     }
-    const o = {
-        type: "root",
-        input: e,
-        nodes: []
-    };
-    const s = [ o ];
-    let i = o;
+    if (i >= this.length) {
+        return e || s.alloc(0);
+    }
+    if (f <= 0) {
+        return e || s.alloc(0);
+    }
+    const t = !!e;
+    const r = this._offset(i);
+    const o = f - i;
     let u = o;
-    let a = 0;
-    const l = e.length;
-    let p = 0;
-    let c = 0;
-    let f;
-    const A = () => e[p++];
-    const R = e => {
-        if (e.type === "text" && u.type === "dot") {
-            u.type = "text";
+    let h = t && n || 0;
+    let l = r[1];
+    if (i === 0 && f === this.length) {
+        if (!t) {
+            return this._bufs.length === 1 ? this._bufs[0] : s.concat(this._bufs, this.length);
         }
-        if (u && u.type === "text" && e.type === "text") {
-            u.value += e.value;
-            return;
+        for (let t = 0; t < this._bufs.length; t++) {
+            this._bufs[t].copy(e, h);
+            h += this._bufs[t].length;
         }
-        i.nodes.push(e);
-        e.parent = i;
-        e.prev = u;
-        u = e;
         return e;
-    };
-    R({
-        type: "bos"
-    });
-    while (p < l) {
-        i = s[s.length - 1];
-        f = A();
-        if (f === O || f === I) {
-            continue;
+    }
+    if (u <= this._bufs[r[0]].length - l) {
+        return t ? this._bufs[r[0]].copy(e, n, l, l + u) : this._bufs[r[0]].slice(l, l + u);
+    }
+    if (!t) {
+        e = s.allocUnsafe(o);
+    }
+    for (let t = r[0]; t < this._bufs.length; t++) {
+        const n = this._bufs[t].length - l;
+        if (u > n) {
+            this._bufs[t].copy(e, h, l);
+            h += n;
+        } else {
+            this._bufs[t].copy(e, h, l, l + u);
+            h += n;
+            break;
         }
-        if (f === E) {
-            R({
-                type: "text",
-                value: (t.keepEscaping ? f : "") + A()
-            });
-            continue;
+        u -= n;
+        if (l) {
+            l = 0;
         }
-        if (f === L) {
-            R({
-                type: "text",
-                value: "\\" + f
-            });
-            continue;
+    }
+    if (e.length > h) return e.slice(0, h);
+    return e;
+};
+
+r.prototype.shallowSlice = function t(e, n) {
+    e = e || 0;
+    n = typeof n !== "number" ? this.length : n;
+    if (e < 0) {
+        e += this.length;
+    }
+    if (n < 0) {
+        n += this.length;
+    }
+    if (e === n) {
+        return this._new();
+    }
+    const i = this._offset(e);
+    const s = this._offset(n);
+    const f = this._bufs.slice(i[0], s[0] + 1);
+    if (s[1] === 0) {
+        f.pop();
+    } else {
+        f[f.length - 1] = f[f.length - 1].slice(0, s[1]);
+    }
+    if (i[1] !== 0) {
+        f[0] = f[0].slice(i[1]);
+    }
+    return this._new(f);
+};
+
+r.prototype.toString = function t(e, n, i) {
+    return this.slice(n, i).toString(e);
+};
+
+r.prototype.consume = function t(e) {
+    e = Math.trunc(e);
+    if (Number.isNaN(e) || e <= 0) return this;
+    while (this._bufs.length) {
+        if (e >= this._bufs[0].length) {
+            e -= this._bufs[0].length;
+            this.length -= this._bufs[0].length;
+            this._bufs.shift();
+        } else {
+            this._bufs[0] = this._bufs[0].slice(e);
+            this.length -= e;
+            break;
         }
-        if (f === T) {
-            a++;
-            let e;
-            while (p < l && (e = A())) {
-                f += e;
-                if (e === T) {
-                    a++;
-                    continue;
-                }
-                if (e === E) {
-                    f += A();
-                    continue;
-                }
-                if (e === L) {
-                    a--;
-                    if (a === 0) {
-                        break;
-                    }
-                }
-            }
-            R({
-                type: "text",
-                value: f
-            });
-            continue;
+    }
+    return this;
+};
+
+r.prototype.duplicate = function t() {
+    const e = this._new();
+    for (let t = 0; t < this._bufs.length; t++) {
+        e.append(this._bufs[t]);
+    }
+    return e;
+};
+
+r.prototype.append = function t(e) {
+    if (e == null) {
+        return this;
+    }
+    if (e.buffer) {
+        this._appendBuffer(s.from(e.buffer, e.byteOffset, e.byteLength));
+    } else if (Array.isArray(e)) {
+        for (let t = 0; t < e.length; t++) {
+            this.append(e[t]);
         }
-        if (f === v) {
-            i = R({
-                type: "paren",
-                nodes: []
-            });
-            s.push(i);
-            R({
-                type: "text",
-                value: f
-            });
-            continue;
+    } else if (this._isBufferList(e)) {
+        for (let t = 0; t < e._bufs.length; t++) {
+            this.append(e._bufs[t]);
         }
-        if (f === g) {
-            if (i.type !== "paren") {
-                R({
-                    type: "text",
-                    value: f
-                });
-                continue;
-            }
-            i = s.pop();
-            R({
-                type: "text",
-                value: f
-            });
-            i = s[s.length - 1];
-            continue;
+    } else {
+        if (typeof e === "number") {
+            e = e.toString();
         }
-        if (f === S || f === x || f === d) {
-            const e = f;
-            let n;
-            if (t.keepQuotes !== true) {
-                f = "";
-            }
-            while (p < l && (n = A())) {
-                if (n === E) {
-                    f += n + A();
-                    continue;
+        this._appendBuffer(s.from(e));
+    }
+    return this;
+};
+
+r.prototype._appendBuffer = function t(e) {
+    this._bufs.push(e);
+    this.length += e.length;
+};
+
+r.prototype.indexOf = function(t, e, n) {
+    if (n === undefined && typeof e === "string") {
+        n = e;
+        e = undefined;
+    }
+    if (typeof t === "function" || Array.isArray(t)) {
+        throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.');
+    } else if (typeof t === "number") {
+        t = s.from([ t ]);
+    } else if (typeof t === "string") {
+        t = s.from(t, n);
+    } else if (this._isBufferList(t)) {
+        t = t.slice();
+    } else if (Array.isArray(t.buffer)) {
+        t = s.from(t.buffer, t.byteOffset, t.byteLength);
+    } else if (!s.isBuffer(t)) {
+        t = s.from(t);
+    }
+    e = Number(e || 0);
+    if (isNaN(e)) {
+        e = 0;
+    }
+    if (e < 0) {
+        e = this.length + e;
+    }
+    if (e < 0) {
+        e = 0;
+    }
+    if (t.length === 0) {
+        return e > this.length ? this.length : e;
+    }
+    const i = this._offset(e);
+    let f = i[0];
+    let r = i[1];
+    for (;f < this._bufs.length; f++) {
+        const e = this._bufs[f];
+        while (r < e.length) {
+            const n = e.length - r;
+            if (n >= t.length) {
+                const n = e.indexOf(t, r);
+                if (n !== -1) {
+                    return this._reverseOffset([ f, n ]);
                 }
-                if (n === e) {
-                    if (t.keepQuotes === true) f += n;
-                    break;
+                r = e.length - t.length + 1;
+            } else {
+                const e = this._reverseOffset([ f, r ]);
+                if (this._match(e, t)) {
+                    return e;
                 }
-                f += n;
+                r++;
             }
-            R({
-                type: "text",
-                value: f
-            });
-            continue;
         }
-        if (f === h) {
-            c++;
-            const e = u.value && u.value.slice(-1) === "$" || i.dollar === true;
-            const t = {
-                type: "brace",
-                open: true,
-                close: false,
-                dollar: e,
-                depth: c,
-                commas: 0,
-                ranges: 0,
-                nodes: []
-            };
-            i = R(t);
-            s.push(i);
-            R({
-                type: "open",
-                value: f
-            });
-            continue;
-        }
-        if (f === m) {
-            if (i.type !== "brace") {
-                R({
-                    type: "text",
-                    value: f
-                });
-                continue;
-            }
-            const e = "close";
-            i = s.pop();
-            i.close = true;
-            R({
-                type: e,
-                value: f
-            });
-            c--;
-            i = s[s.length - 1];
-            continue;
-        }
-        if (f === y && c > 0) {
-            if (i.ranges > 0) {
-                i.ranges = 0;
-                const e = i.nodes.shift();
-                i.nodes = [ e, {
-                    type: "text",
-                    value: _(i)
-                } ];
-            }
-            R({
-                type: "comma",
-                value: f
-            });
-            i.commas++;
-            continue;
+        r = 0;
+    }
+    return -1;
+};
+
+r.prototype._match = function(t, e) {
+    if (this.length - t < e.length) {
+        return false;
+    }
+    for (let n = 0; n < e.length; n++) {
+        if (this.get(t + n) !== e[n]) {
+            return false;
         }
-        if (f === H && c > 0 && i.commas === 0) {
-            const e = i.nodes;
-            if (c === 0 || e.length === 0) {
-                R({
-                    type: "text",
-                    value: f
-                });
-                continue;
-            }
-            if (u.type === "dot") {
-                i.range = [];
-                u.value += f;
-                u.type = "range";
-                if (i.nodes.length !== 3 && i.nodes.length !== 5) {
-                    i.invalid = true;
-                    i.ranges = 0;
-                    u.type = "text";
-                    continue;
-                }
-                i.ranges++;
-                i.args = [];
-                continue;
-            }
-            if (u.type === "range") {
-                e.pop();
-                const t = e[e.length - 1];
-                t.value += u.value + f;
-                u = t;
-                i.ranges--;
-                continue;
+    }
+    return true;
+};
+
+(function() {
+    const t = {
+        readDoubleBE: 8,
+        readDoubleLE: 8,
+        readFloatBE: 4,
+        readFloatLE: 4,
+        readInt32BE: 4,
+        readInt32LE: 4,
+        readUInt32BE: 4,
+        readUInt32LE: 4,
+        readInt16BE: 2,
+        readInt16LE: 2,
+        readUInt16BE: 2,
+        readUInt16LE: 2,
+        readInt8: 1,
+        readUInt8: 1,
+        readIntBE: null,
+        readIntLE: null,
+        readUIntBE: null,
+        readUIntLE: null
+    };
+    for (const e in t) {
+        (function(e) {
+            if (t[e] === null) {
+                r.prototype[e] = function(t, n) {
+                    return this.slice(t, t + n)[e](0, n);
+                };
+            } else {
+                r.prototype[e] = function(n = 0) {
+                    return this.slice(n, n + t[e])[e](0);
+                };
             }
-            R({
-                type: "dot",
-                value: f
-            });
-            continue;
-        }
-        R({
-            type: "text",
-            value: f
-        });
+        })(e);
     }
-    do {
-        i = s.pop();
-        if (i.type !== "root") {
-            i.nodes.forEach(e => {
-                if (!e.nodes) {
-                    if (e.type === "open") e.isOpen = true;
-                    if (e.type === "close") e.isClose = true;
-                    if (!e.nodes) e.type = "text";
-                    e.invalid = true;
-                }
-            });
-            const e = s[s.length - 1];
-            const t = e.nodes.indexOf(i);
-            e.nodes.splice(t, 1, ...i.nodes);
-        }
-    } while (s.length > 0);
-    R({
-        type: "eos"
-    });
-    return o;
+})();
+
+r.prototype._isBufferList = function t(e) {
+    return e instanceof r || r.isBufferList(e);
 };
 
-var B = N;
+r.isBufferList = function t(e) {
+    return e != null && e[f];
+};
 
-const U = r;
+var o = r;
 
-const b = u;
+i.exports;
 
-const K = A;
+const u = t.Duplex;
 
-const P = B;
+const h = e();
 
-const w = (e, t = {}) => {
-    let n = [];
-    if (Array.isArray(e)) {
-        for (const r of e) {
-            const e = w.create(r, t);
-            if (Array.isArray(e)) {
-                n.push(...e);
-            } else {
-                n.push(e);
-            }
-        }
-    } else {
-        n = [].concat(w.create(e, t));
+const l = o;
+
+function c(t) {
+    if (!(this instanceof c)) {
+        return new c(t);
     }
-    if (t && t.expand === true && t.nodupes === true) {
-        n = [ ...new Set(n) ];
+    if (typeof t === "function") {
+        this._callback = t;
+        const e = function t(e) {
+            if (this._callback) {
+                this._callback(e);
+                this._callback = null;
+            }
+        }.bind(this);
+        this.on("pipe", function t(n) {
+            n.on("error", e);
+        });
+        this.on("unpipe", function t(n) {
+            n.removeListener("error", e);
+        });
+        t = null;
     }
-    return n;
-};
+    l._init.call(this, t);
+    u.call(this);
+}
 
-w.parse = (e, t = {}) => P(e, t);
+h(c, u);
 
-w.stringify = (e, t = {}) => {
-    if (typeof e === "string") {
-        return U(w.parse(e, t), t);
-    }
-    return U(e, t);
+Object.assign(c.prototype, l.prototype);
+
+c.prototype._new = function t(e) {
+    return new c(e);
 };
 
-w.compile = (e, t = {}) => {
-    if (typeof e === "string") {
-        e = w.parse(e, t);
+c.prototype._write = function t(e, n, i) {
+    this._appendBuffer(e);
+    if (typeof i === "function") {
+        i();
     }
-    return b(e, t);
 };
 
-w.expand = (e, t = {}) => {
-    if (typeof e === "string") {
-        e = w.parse(e, t);
-    }
-    let n = K(e, t);
-    if (t.noempty === true) {
-        n = n.filter(Boolean);
+c.prototype._read = function t(e) {
+    if (!this.length) {
+        return this.push(null);
     }
-    if (t.nodupes === true) {
-        n = [ ...new Set(n) ];
-    }
-    return n;
+    e = Math.min(e, this.length);
+    this.push(this.slice(0, e));
+    this.consume(e);
 };
 
-w.create = (e, t = {}) => {
-    if (e === "" || e.length < 3) {
-        return [ e ];
+c.prototype.end = function t(e) {
+    u.prototype.end.call(this, e);
+    if (this._callback) {
+        this._callback(null, this.slice());
+        this._callback = null;
     }
-    return t.expand !== true ? w.compile(e, t) : w.expand(e, t);
 };
 
-var M = w;
+c.prototype._destroy = function t(e, n) {
+    this._bufs.length = 0;
+    this.length = 0;
+    n(e);
+};
+
+c.prototype._isBufferList = function t(e) {
+    return e instanceof c || e instanceof l || c.isBufferList(e);
+};
+
+c.isBufferList = l.isBufferList;
+
+i.exports = c;
+
+i.exports.BufferListStream = c;
+
+i.exports.BufferList = l;
+
+var p = i.exports;
 
-export { M as b };
+export { p as b };