lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.45.cjs

@@ -1,365 +1,639 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const e = require("events");
+require("util");
 
-const t = require("./Package.internal.2.cjs");
+require("./Package.internal.46.cjs");
 
-const r = require("./Package.internal.13.cjs");
+const e = require("./Package.internal.47.cjs");
 
-const a = e => e && e.__esModule ? e : {
-    default: e
-};
+var t = {};
 
-const s = a(e);
-
-var c = e => e === 0 ? "primary" : `secondary:${e - 1}`;
-
-exports.createCache = e => {
-    const a = new s.default;
-    const n = new r.Keyv;
-    n.serialize = void 0;
-    n.deserialize = void 0;
-    const i = e?.stores?.length ? e.stores : [ n ];
-    const o = e?.nonBlocking ?? false;
-    const l = e?.cacheId ?? Math.random().toString(36).slice(2);
-    const m = async e => {
-        let t;
-        if (o) {
-            try {
-                t = await Promise.race(i.map(async t => t.get(e)));
-                if (t === void 0) {
-                    return void 0;
-                }
-            } catch (t) {
-                a.emit("get", {
-                    key: e,
-                    error: 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 < i.length; r++) {
-                const s = i[r];
-                try {
-                    const n = await s.get(e);
-                    if (n !== void 0) {
-                        t = n;
-                        a.emit("get", {
-                            key: e,
-                            value: t,
-                            store: c(r)
-                        });
-                        break;
-                    }
-                } catch (t) {
-                    a.emit("get", {
-                        key: e,
-                        error: t,
-                        store: c(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 y = async e => {
-        let t = e.map(() => void 0);
-        if (o) {
-            try {
-                t = await Promise.race(i.map(async t => t.getMany(e)));
-            } catch (t) {
-                a.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 i) {
-                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 c = await r.getMany(s);
-                    for (const [e, r] of c.entries()) {
-                        if (r === void 0) {
-                            continue;
-                        }
-                        const {originalIndex: s} = a[e];
-                        t[s] = r;
-                    }
-                } catch (t) {
-                    a.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);
             }
         }
-        a.emit("mget", {
-            keys: e,
-            values: t
-        });
-        return t;
+        return u;
     };
-    const u = async e => {
-        let t;
-        if (o) {
-            try {
-                t = await Promise.race(i.map(async t => t.get(e, {
-                    raw: true
-                })));
-                if (t === void 0) {
-                    return void 0;
-                }
-            } catch (t) {
-                a.emit("ttl", {
-                    key: e,
-                    error: t
-                });
+    return r(e);
+};
+
+const o = e.fillRange;
+
+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 c = "";
+        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) {
+                c += n(t, e);
+            }
+        }
+        return c;
+    };
+    return n(e);
+};
+
+var u = i;
+
+const a = e.fillRange;
+
+const l = r;
+
+const c = t;
+
+const p = (e = "", t = "", n = false) => {
+    const r = [];
+    e = [].concat(e);
+    t = [].concat(t);
+    if (!t.length) return e;
+    if (!e.length) {
+        return n ? c.flatten(t).map(e => `{${e}}`) : t;
+    }
+    for (const o of e) {
+        if (Array.isArray(o)) {
+            for (const e of o) {
+                r.push(p(e, t, n));
             }
         } else {
-            for (const r of i) {
-                try {
-                    const s = await r.get(e, {
-                        raw: true
-                    });
-                    if (s !== void 0) {
-                        t = s;
-                        a.emit("ttl", {
-                            key: e,
-                            value: t
-                        });
-                        break;
-                    }
-                } catch (t) {
-                    a.emit("ttl", {
-                        key: e,
-                        error: t
-                    });
-                }
+            for (let e of t) {
+                if (n === true && typeof e === "string") e = `{${e}}`;
+                r.push(Array.isArray(e) ? p(o, e, n) : o + e);
+            }
+        }
+    }
+    return c.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(p(i.pop(), l(e, t)));
+            return;
+        }
+        if (e.type === "brace" && e.invalid !== true && e.nodes.length === 2) {
+            i.push(p(i.pop(), [ "{}" ]));
+            return;
+        }
+        if (e.nodes && e.ranges > 0) {
+            const r = c.reduce(e.nodes);
+            if (c.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(p(i.pop(), o));
+            e.nodes = [];
+            return;
+        }
+        const u = c.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(p(i.pop(), f, u));
+                continue;
+            }
+            if (n.value && n.type !== "open") {
+                f.push(p(f.pop(), n.value));
+                continue;
+            }
+            if (n.nodes) {
+                r(n, e);
             }
         }
-        if (t?.expires) {
-            return t.expires;
+        return f;
+    };
+    return c.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: g, CHAR_RIGHT_PARENTHESES: v, CHAR_LEFT_CURLY_BRACE: h, CHAR_RIGHT_CURLY_BRACE: T, CHAR_LEFT_SQUARE_BRACKET: m, 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 c = 0;
+    let p = 0;
+    let f;
+    const A = () => e[c++];
+    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;
         }
-        return void 0;
+        i.nodes.push(e);
+        e.parent = i;
+        e.prev = u;
+        u = e;
+        return e;
     };
-    const f = async (t, r, s, n) => {
-        try {
-            const i = t.map(async (t, i) => {
-                await t.set(r, s, n ?? e?.ttl);
-                a.emit("set", {
-                    key: r,
-                    value: s,
-                    store: c(i)
-                });
+    R({
+        type: "bos"
+    });
+    while (c < 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 (o) {
-                Promise.all(i);
-                a.emit("set", {
-                    key: r,
-                    value: s
-                });
-                return s;
+            continue;
+        }
+        if (f === L) {
+            R({
+                type: "text",
+                value: "\\" + f
+            });
+            continue;
+        }
+        if (f === m) {
+            a++;
+            let e;
+            while (c < l && (e = A())) {
+                f += e;
+                if (e === m) {
+                    a++;
+                    continue;
+                }
+                if (e === E) {
+                    f += A();
+                    continue;
+                }
+                if (e === L) {
+                    a--;
+                    if (a === 0) {
+                        break;
+                    }
+                }
             }
-            await Promise.all(i);
-            a.emit("set", {
-                key: r,
-                value: s
+            R({
+                type: "text",
+                value: f
+            });
+            continue;
+        }
+        if (f === g) {
+            i = R({
+                type: "paren",
+                nodes: []
             });
-            return s;
-        } catch (e) {
-            a.emit("set", {
-                key: r,
-                value: s,
-                error: e
+            s.push(i);
+            R({
+                type: "text",
+                value: f
             });
-            return Promise.reject(e);
+            continue;
         }
-    };
-    const d = async (t, r) => {
-        const s = r.map(({key: t, value: r, ttl: a}) => ({
-            key: t,
-            value: r,
-            ttl: a ?? e?.ttl
-        }));
-        try {
-            const e = t.map(async e => e.setMany(s));
-            if (o) {
-                Promise.all(e);
-                a.emit("mset", {
-                    list: s
+        if (f === v) {
+            if (i.type !== "paren") {
+                R({
+                    type: "text",
+                    value: f
                 });
-                return s;
+                continue;
             }
-            await Promise.all(e);
-            a.emit("mset", {
-                list: s
-            });
-            return s;
-        } catch (e) {
-            a.emit("mset", {
-                list: s,
-                error: e
+            i = s.pop();
+            R({
+                type: "text",
+                value: f
             });
-            return Promise.reject(e);
+            i = s[s.length - 1];
+            continue;
         }
-    };
-    const h = async e => {
-        try {
-            if (o) {
-                Promise.all(i.map(async t => t.delete(e)));
-                a.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(i.map(async t => t.delete(e)));
-            a.emit("del", {
-                key: e
+            while (c < 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) {
-            a.emit("del", {
-                key: e,
-                error: t
+            continue;
+        }
+        if (f === h) {
+            p++;
+            const e = u.value && u.value.slice(-1) === "$" || i.dollar === true;
+            const t = {
+                type: "brace",
+                open: true,
+                close: false,
+                dollar: e,
+                depth: p,
+                commas: 0,
+                ranges: 0,
+                nodes: []
+            };
+            i = R(t);
+            s.push(i);
+            R({
+                type: "open",
+                value: f
             });
-            return Promise.reject(t);
+            continue;
         }
-    };
-    const v = async e => {
-        try {
-            const t = [];
-            for (const r of e) {
-                t.push(...i.map(async e => e.delete(r)));
-            }
-            if (o) {
-                Promise.all(t);
-                a.emit("mdel", {
-                    keys: e
+        if (f === T) {
+            if (i.type !== "brace") {
+                R({
+                    type: "text",
+                    value: f
                 });
-                return true;
+                continue;
             }
-            await Promise.all(t);
-            a.emit("mdel", {
-                keys: e
-            });
-            return true;
-        } catch (t) {
-            a.emit("mdel", {
-                keys: e,
-                error: t
+            const e = "close";
+            i = s.pop();
+            i.close = true;
+            R({
+                type: e,
+                value: f
             });
-            return Promise.reject(t);
+            p--;
+            i = s[s.length - 1];
+            continue;
         }
-    };
-    const k = async () => {
-        try {
-            if (o) {
-                Promise.all(i.map(async e => e.clear()));
-                a.emit("clear");
-                return true;
+        if (f === y && p > 0) {
+            if (i.ranges > 0) {
+                i.ranges = 0;
+                const e = i.nodes.shift();
+                i.nodes = [ e, {
+                    type: "text",
+                    value: _(i)
+                } ];
             }
-            await Promise.all(i.map(async e => e.clear()));
-            a.emit("clear");
-            return true;
-        } catch (e) {
-            a.emit("clear", e);
-            return Promise.reject(e);
+            R({
+                type: "comma",
+                value: f
+            });
+            i.commas++;
+            continue;
         }
-    };
-    const w = async (r, s, c, n) => t.coalesceAsync(`${l}::${r}`, async () => {
-        let o;
-        let m;
-        let y = 0;
-        let u;
-        const {ttl: d, refreshThreshold: h, raw: v} = t.isObject(c) ? c : {
-            ttl: c,
-            refreshThreshold: n
-        };
-        const k = r => t.runIfFn(d, r) ?? e?.ttl;
-        for (;y < i.length; y++) {
-            try {
-                const e = await i[y].get(r, {
-                    raw: true
+        if (f === H && p > 0 && i.commas === 0) {
+            const e = i.nodes;
+            if (p === 0 || e.length === 0) {
+                R({
+                    type: "text",
+                    value: f
                 });
-                if (e !== void 0) {
-                    o = e.value;
-                    m = e;
-                    if (typeof e.expires === "number") {
-                        u = Math.max(0, e.expires - Date.now());
-                    }
-                    break;
-                }
-            } catch {}
-        }
-        if (o === void 0) {
-            const e = await s();
-            const t = k(e);
-            await f(i, r, e, t);
-            return v ? {
-                value: e,
-                expires: Date.now() + t
-            } : e;
-        }
-        const w = t.lessThan(u, t.runIfFn(h, o) ?? e?.refreshThreshold);
-        if (w) {
-            t.coalesceAsync(`+++${l}__${r}`, s).then(async t => {
-                try {
-                    await f(e?.refreshAllStores ? i : i.slice(0, y + 1), r, t, k(t));
-                    a.emit("refresh", {
-                        key: r,
-                        value: t
-                    });
-                } catch (e) {
-                    a.emit("refresh", {
-                        key: r,
-                        value: o,
-                        error: e
-                    });
+                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(e => {
-                a.emit("refresh", {
-                    key: r,
-                    value: o,
-                    error: e
-                });
+                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 (!w && y > 0) {
-            await f(i.slice(0, y), r, o, k(o));
+        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 v ? m : o;
+    } while (s.length > 0);
+    R({
+        type: "eos"
     });
-    const g = (e, t) => a.addListener(e, t);
-    const p = (e, t) => a.removeListener(e, t);
-    const P = async () => {
-        try {
-            await Promise.all(i.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 j = () => l;
-    return {
-        get: m,
-        mget: y,
-        ttl: u,
-        set: async (e, t, r) => f(i, e, t, r),
-        mset: async e => d(i, e),
-        del: h,
-        mdel: v,
-        clear: k,
-        wrap: w,
-        on: g,
-        off: p,
-        disconnect: P,
-        cacheId: j,
-        stores: i
-    };
+    } else {
+        n = [].concat(w.create(e, t));
+    }
+    if (t && t.expand === true && t.nodupes === true) {
+        n = [ ...new Set(n) ];
+    }
+    return n;
 };
+
+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);
+};
+
+exports.braces_1 = w;