lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.45.mjs

@@ -1,359 +1,639 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
-import e from "events";
-
-import { c as t, i as r, r as a, l as s } from "./Package.internal.2.mjs";
-
-import { K as i } from "./Package.internal.13.mjs";
-
-var o = e => e === 0 ? "primary" : `secondary:${e - 1}`;
-
-var c = c => {
-    const n = new e;
-    const l = new i;
-    l.serialize = void 0;
-    l.deserialize = void 0;
-    const m = c?.stores?.length ? c.stores : [ l ];
-    const y = c?.nonBlocking ?? false;
-    const u = c?.cacheId ?? Math.random().toString(36).slice(2);
-    const f = async e => {
-        let t;
-        if (y) {
-            try {
-                t = await Promise.race(m.map(async t => t.get(e)));
-                if (t === void 0) {
-                    return void 0;
-                }
-            } catch (t) {
-                n.emit("get", {
-                    key: e,
-                    error: t
-                });
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import "util";
+
+import "./Package.internal.46.mjs";
+
+import { f as e } from "./Package.internal.47.mjs";
+
+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;
             }
-        } else {
-            for (let r = 0; r < m.length; r++) {
-                const a = m[r];
-                try {
-                    const s = await a.get(e);
-                    if (s !== void 0) {
-                        t = s;
-                        n.emit("get", {
-                            key: e,
-                            value: t,
-                            store: o(r)
-                        });
-                        break;
-                    }
-                } catch (t) {
-                    n.emit("get", {
-                        key: e,
-                        error: t,
-                        store: o(r)
-                    });
+        }
+    };
+    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;
     };
-    const d = async e => {
-        let t = e.map(() => void 0);
-        if (y) {
-            try {
-                t = await Promise.race(m.map(async t => t.getMany(e)));
-            } catch (t) {
-                n.emit("mget", {
-                    keys: e,
-                    error: 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;
             }
-        } else {
-            for (const r of m) {
-                try {
-                    const a = t.map((t, r) => t === void 0 ? {
-                        originalIndex: r,
-                        key: e[r]
-                    } : void 0).filter(e => e !== void 0);
-                    if (a.length === 0) {
-                        break;
-                    }
-                    const s = a.map(e => e.key);
-                    const i = await r.getMany(s);
-                    for (const [e, r] of i.entries()) {
-                        if (r === void 0) {
-                            continue;
-                        }
-                        const {originalIndex: s} = a[e];
-                        t[s] = r;
-                    }
-                } catch (t) {
-                    n.emit("mget", {
-                        keys: e,
-                        error: t
-                    });
-                }
+            return e.value;
+        }
+        if (e.value) {
+            return e.value;
+        }
+        if (e.nodes) {
+            for (const t of e.nodes) {
+                u += r(t);
             }
         }
-        n.emit("mget", {
-            keys: e,
-            values: t
-        });
-        return t;
+        return u;
     };
-    const h = async e => {
-        let t;
-        if (y) {
-            try {
-                t = await Promise.race(m.map(async t => t.get(e, {
-                    raw: true
-                })));
-                if (t === void 0) {
-                    return void 0;
-                }
-            } catch (t) {
-                n.emit("ttl", {
-                    key: e,
-                    error: t
-                });
+    return r(e);
+};
+
+const o = e;
+
+const s = t;
+
+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);
+};
+
+var u = i;
+
+const a = e;
+
+const l = r;
+
+const p = t;
+
+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;
+    }
+    for (const o of e) {
+        if (Array.isArray(o)) {
+            for (const e of o) {
+                r.push(c(e, t, n));
             }
         } else {
-            for (const r of m) {
-                try {
-                    const a = await r.get(e, {
-                        raw: true
-                    });
-                    if (a !== void 0) {
-                        t = a;
-                        n.emit("ttl", {
-                            key: e,
-                            value: t
-                        });
-                        break;
-                    }
-                } catch (t) {
-                    n.emit("ttl", {
-                        key: e,
-                        error: t
-                    });
-                }
+            for (let e of t) {
+                if (n === true && typeof e === "string") e = `{${e}}`;
+                r.push(Array.isArray(e) ? c(o, e, n) : o + e);
             }
         }
-        if (t?.expires) {
-            return t.expires;
+    }
+    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;
         }
-        return void 0;
+        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;
     };
-    const v = async (e, t, r, a) => {
-        try {
-            const s = e.map(async (e, s) => {
-                await e.set(t, r, a ?? c?.ttl);
-                n.emit("set", {
-                    key: t,
-                    value: r,
-                    store: o(s)
-                });
+    return p.flatten(r(e));
+};
+
+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"
+};
+
+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;
+
+const N = (e, t = {}) => {
+    if (typeof e !== "string") {
+        throw new TypeError("Expected a string");
+    }
+    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})`);
+    }
+    const o = {
+        type: "root",
+        input: e,
+        nodes: []
+    };
+    const s = [ o ];
+    let i = o;
+    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";
+        }
+        if (u && u.type === "text" && e.type === "text") {
+            u.value += e.value;
+            return;
+        }
+        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 (f === E) {
+            R({
+                type: "text",
+                value: (t.keepEscaping ? f : "") + A()
             });
-            if (y) {
-                Promise.all(s);
-                n.emit("set", {
-                    key: t,
-                    value: r
-                });
-                return r;
+            continue;
+        }
+        if (f === L) {
+            R({
+                type: "text",
+                value: "\\" + f
+            });
+            continue;
+        }
+        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;
+                    }
+                }
             }
-            await Promise.all(s);
-            n.emit("set", {
-                key: t,
-                value: r
+            R({
+                type: "text",
+                value: f
+            });
+            continue;
+        }
+        if (f === v) {
+            i = R({
+                type: "paren",
+                nodes: []
             });
-            return r;
-        } catch (e) {
-            n.emit("set", {
-                key: t,
-                value: r,
-                error: e
+            s.push(i);
+            R({
+                type: "text",
+                value: f
             });
-            return Promise.reject(e);
+            continue;
         }
-    };
-    const k = async (e, t) => {
-        const r = t.map(({key: e, value: t, ttl: r}) => ({
-            key: e,
-            value: t,
-            ttl: r ?? c?.ttl
-        }));
-        try {
-            const t = e.map(async e => e.setMany(r));
-            if (y) {
-                Promise.all(t);
-                n.emit("mset", {
-                    list: r
+        if (f === g) {
+            if (i.type !== "paren") {
+                R({
+                    type: "text",
+                    value: f
                 });
-                return r;
+                continue;
             }
-            await Promise.all(t);
-            n.emit("mset", {
-                list: r
-            });
-            return r;
-        } catch (e) {
-            n.emit("mset", {
-                list: r,
-                error: e
+            i = s.pop();
+            R({
+                type: "text",
+                value: f
             });
-            return Promise.reject(e);
+            i = s[s.length - 1];
+            continue;
         }
-    };
-    const p = async e => {
-        try {
-            if (y) {
-                Promise.all(m.map(async t => t.delete(e)));
-                n.emit("del", {
-                    key: e
-                });
-                return true;
+        if (f === S || f === x || f === d) {
+            const e = f;
+            let n;
+            if (t.keepQuotes !== true) {
+                f = "";
             }
-            await Promise.all(m.map(async t => t.delete(e)));
-            n.emit("del", {
-                key: e
+            while (p < l && (n = A())) {
+                if (n === E) {
+                    f += n + A();
+                    continue;
+                }
+                if (n === e) {
+                    if (t.keepQuotes === true) f += n;
+                    break;
+                }
+                f += n;
+            }
+            R({
+                type: "text",
+                value: f
             });
-            return true;
-        } catch (t) {
-            n.emit("del", {
-                key: e,
-                error: t
+            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
             });
-            return Promise.reject(t);
+            continue;
         }
-    };
-    const w = async e => {
-        try {
-            const t = [];
-            for (const r of e) {
-                t.push(...m.map(async e => e.delete(r)));
-            }
-            if (y) {
-                Promise.all(t);
-                n.emit("mdel", {
-                    keys: e
+        if (f === m) {
+            if (i.type !== "brace") {
+                R({
+                    type: "text",
+                    value: f
                 });
-                return true;
+                continue;
             }
-            await Promise.all(t);
-            n.emit("mdel", {
-                keys: e
-            });
-            return true;
-        } catch (t) {
-            n.emit("mdel", {
-                keys: e,
-                error: t
+            const e = "close";
+            i = s.pop();
+            i.close = true;
+            R({
+                type: e,
+                value: f
             });
-            return Promise.reject(t);
+            c--;
+            i = s[s.length - 1];
+            continue;
         }
-    };
-    const g = async () => {
-        try {
-            if (y) {
-                Promise.all(m.map(async e => e.clear()));
-                n.emit("clear");
-                return true;
+        if (f === y && c > 0) {
+            if (i.ranges > 0) {
+                i.ranges = 0;
+                const e = i.nodes.shift();
+                i.nodes = [ e, {
+                    type: "text",
+                    value: _(i)
+                } ];
             }
-            await Promise.all(m.map(async e => e.clear()));
-            n.emit("clear");
-            return true;
-        } catch (e) {
-            n.emit("clear", e);
-            return Promise.reject(e);
+            R({
+                type: "comma",
+                value: f
+            });
+            i.commas++;
+            continue;
         }
-    };
-    const P = async (e, i, o, l) => t(`${u}::${e}`, async () => {
-        let y;
-        let f;
-        let d = 0;
-        let h;
-        const {ttl: k, refreshThreshold: p, raw: w} = r(o) ? o : {
-            ttl: o,
-            refreshThreshold: l
-        };
-        const g = e => a(k, e) ?? c?.ttl;
-        for (;d < m.length; d++) {
-            try {
-                const t = await m[d].get(e, {
-                    raw: true
+        if (f === H && c > 0 && i.commas === 0) {
+            const e = i.nodes;
+            if (c === 0 || e.length === 0) {
+                R({
+                    type: "text",
+                    value: f
                 });
-                if (t !== void 0) {
-                    y = t.value;
-                    f = t;
-                    if (typeof t.expires === "number") {
-                        h = Math.max(0, t.expires - Date.now());
-                    }
-                    break;
-                }
-            } catch {}
-        }
-        if (y === void 0) {
-            const t = await i();
-            const r = g(t);
-            await v(m, e, t, r);
-            return w ? {
-                value: t,
-                expires: Date.now() + r
-            } : t;
-        }
-        const P = s(h, a(p, y) ?? c?.refreshThreshold);
-        if (P) {
-            t(`+++${u}__${e}`, i).then(async t => {
-                try {
-                    await v(c?.refreshAllStores ? m : m.slice(0, d + 1), e, t, g(t));
-                    n.emit("refresh", {
-                        key: e,
-                        value: t
-                    });
-                } catch (t) {
-                    n.emit("refresh", {
-                        key: e,
-                        value: y,
-                        error: t
-                    });
+                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;
                 }
-            }).catch(t => {
-                n.emit("refresh", {
-                    key: e,
-                    value: y,
-                    error: t
-                });
+                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;
+            }
+            R({
+                type: "dot",
+                value: f
             });
+            continue;
         }
-        if (!P && d > 0) {
-            await v(m.slice(0, d), e, y, g(y));
+        R({
+            type: "text",
+            value: f
+        });
+    }
+    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);
         }
-        return w ? f : y;
+    } while (s.length > 0);
+    R({
+        type: "eos"
     });
-    const x = (e, t) => n.addListener(e, t);
-    const j = (e, t) => n.removeListener(e, t);
-    const b = async () => {
-        try {
-            await Promise.all(m.map(async e => e.disconnect()));
-        } catch (e) {
-            return Promise.reject(e);
+    return o;
+};
+
+var B = N;
+
+const U = r;
+
+const b = u;
+
+const K = A;
+
+const P = B;
+
+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);
+            }
         }
-    };
-    const M = () => u;
-    return {
-        get: f,
-        mget: d,
-        ttl: h,
-        set: async (e, t, r) => v(m, e, t, r),
-        mset: async e => k(m, e),
-        del: p,
-        mdel: w,
-        clear: g,
-        wrap: P,
-        on: x,
-        off: j,
-        disconnect: b,
-        cacheId: M,
-        stores: m
-    };
+    } else {
+        n = [].concat(w.create(e, t));
+    }
+    if (t && t.expand === true && t.nodupes === true) {
+        n = [ ...new Set(n) ];
+    }
+    return n;
 };
 
-export { c };
+w.parse = (e, t = {}) => P(e, t);
+
+w.stringify = (e, t = {}) => {
+    if (typeof e === "string") {
+        return U(w.parse(e, t), t);
+    }
+    return U(e, t);
+};
+
+w.compile = (e, t = {}) => {
+    if (typeof e === "string") {
+        e = w.parse(e, t);
+    }
+    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);
+    }
+    if (t.nodupes === true) {
+        n = [ ...new Set(n) ];
+    }
+    return n;
+};
+
+w.create = (e, t = {}) => {
+    if (e === "" || e.length < 3) {
+        return [ e ];
+    }
+    return t.expand !== true ? w.compile(e, t) : w.expand(e, t);
+};
+
+var M = w;
+
+export { M as b };