lakutata/src/lib/ioc/ListModules.mjs

An IoC-based universal application framework.

import { g as t, c as e } from "../../../vendor/Package.5.mjs";

import "../../../vendor/Package.8.mjs";

import r from "os";

import * as n from "path";

import s from "path";

import { i } from "../../../vendor/Package.9.mjs";

import "../../../vendor/Package.10.mjs";

import o from "util";

import a from "stream";

import u from "fs";

import c from "events";

import { flatten as l } from "./Utils.mjs";

import "./FunctionTokenizer.mjs";

import "../../../vendor/Package.2.mjs";

import "../../../vendor/Package.1.mjs";

import "../base/internal/DataValidator.mjs";

import "../../../vendor/Package.4.mjs";

import "node:util/types";

import "../validation/VLD.mjs";

import "../../../vendor/Package.11.mjs";

import "url";

import "../../exceptions/dto/InvalidValueException.mjs";

import "../base/abstracts/Exception.mjs";

import "../base/internal/BasicInfo.mjs";

import "../helpers/As.mjs";

import "../../../vendor/Package.6.mjs";

import "../../../vendor/Package.7.mjs";

import "../base/internal/ThrowWarning.mjs";

import "../helpers/Templating.mjs";

import "../base/internal/CamelCase.mjs";

import "../helpers/NoCase.mjs";

import "../helpers/IsHtml.mjs";

import "../helpers/IsXML.mjs";

import "../../constants/DTOMetadataKey.mjs";

import "../helpers/ObjectConstructor.mjs";

import "../helpers/ObjectParentConstructors.mjs";

import "../helpers/ObjectParentConstructor.mjs";

import "../helpers/ObjectPrototype.mjs";

var f = {};

var p = {};

var h = {};

"use strict";

Object.defineProperty(h, "__esModule", {
    value: true
});

var d = h.splitWhen = g = h.flatten = void 0;

function _(t) {
    return t.reduce(((t, e) => [].concat(t, e)), []);
}

var g = h.flatten = _;

function y(t, e) {
    const r = [ [] ];
    let n = 0;
    for (const s of t) {
        if (e(s)) {
            n++;
            r[n] = [];
        } else {
            r[n].push(s);
        }
    }
    return r;
}

d = h.splitWhen = y;

var v = {};

"use strict";

Object.defineProperty(v, "__esModule", {
    value: true
});

var m = v.isEnoentCodeError = void 0;

function S(t) {
    return t.code === "ENOENT";
}

m = v.isEnoentCodeError = S;

var A = {};

"use strict";

Object.defineProperty(A, "__esModule", {
    value: true
});

var E = A.createDirentFromStats = void 0;

let b = class DirentFromStats {
    constructor(t, e) {
        this.name = t;
        this.isBlockDevice = e.isBlockDevice.bind(e);
        this.isCharacterDevice = e.isCharacterDevice.bind(e);
        this.isDirectory = e.isDirectory.bind(e);
        this.isFIFO = e.isFIFO.bind(e);
        this.isFile = e.isFile.bind(e);
        this.isSocket = e.isSocket.bind(e);
        this.isSymbolicLink = e.isSymbolicLink.bind(e);
    }
};

function R(t, e) {
    return new b(t, e);
}

E = A.createDirentFromStats = R;

var P = {};

"use strict";

Object.defineProperty(P, "__esModule", {
    value: true
});

var x = P.convertPosixPathToPattern = q = P.convertWindowsPathToPattern = V = P.convertPathToPattern = K = P.escapePosixPath = U = P.escapeWindowsPath = B = P.escape = j = P.removeLeadingDotSegment = I = P.makeAbsolute = D = P.unixify = void 0;

const C = r;

const w = s;

const T = C.platform() === "win32";

const k = 2;

const O = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;

const L = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;

const H = /^\\\\([.?])/;

const $ = /\\(?![!()+@[\]{}])/g;

function M(t) {
    return t.replace(/\\/g, "/");
}

var D = P.unixify = M;

function F(t, e) {
    return w.resolve(t, e);
}

var I = P.makeAbsolute = F;

function N(t) {
    if (t.charAt(0) === ".") {
        const e = t.charAt(1);
        if (e === "/" || e === "\\") {
            return t.slice(k);
        }
    }
    return t;
}

var j = P.removeLeadingDotSegment = N;

var B = P.escape = T ? G : W;

function G(t) {
    return t.replace(L, "\\$2");
}

var U = P.escapeWindowsPath = G;

function W(t) {
    return t.replace(O, "\\$2");
}

var K = P.escapePosixPath = W;

var V = P.convertPathToPattern = T ? Q : X;

function Q(t) {
    return G(t).replace(H, "//$1").replace($, "/");
}

var q = P.convertWindowsPathToPattern = Q;

function X(t) {
    return W(t);
}

x = P.convertPosixPathToPattern = X;

var Y = {};

"use strict";

var Z = i;

var z = s.posix.dirname;

var J = r.platform() === "win32";

var tt = "/";

var et = /\\/g;

var rt = /[\{\[].*[\}\]]$/;

var nt = /(^|[^\\])([\{\[]|\([^\)]+$)/;

var st = /\\([\!\*\?\|\[\]\(\)\{\}])/g;

var it = function t(e, r) {
    var n = Object.assign({
        flipBackslashes: true
    }, r);
    if (n.flipBackslashes && J && e.indexOf(tt) < 0) {
        e = e.replace(et, tt);
    }
    if (rt.test(e)) {
        e += tt;
    }
    e += "a";
    do {
        e = z(e);
    } while (Z(e) || nt.test(e));
    return e.replace(st, "$1");
};

const ot = t(it);

var at = {};

(function(t) {
    "use strict";
    t.isInteger = t => {
        if (typeof t === "number") {
            return Number.isInteger(t);
        }
        if (typeof t === "string" && t.trim() !== "") {
            return Number.isInteger(Number(t));
        }
        return false;
    };
    t.find = (t, e) => t.nodes.find((t => t.type === e));
    t.exceedsLimit = (e, r, n = 1, s) => {
        if (s === false) return false;
        if (!t.isInteger(e) || !t.isInteger(r)) return false;
        return (Number(r) - Number(e)) / Number(n) >= s;
    };
    t.escapeNode = (t, e = 0, r) => {
        const n = t.nodes[e];
        if (!n) return;
        if (r && n.type === r || n.type === "open" || n.type === "close") {
            if (n.escaped !== true) {
                n.value = "\\" + n.value;
                n.escaped = true;
            }
        }
    };
    t.encloseBrace = t => {
        if (t.type !== "brace") return false;
        if (t.commas >> 0 + t.ranges >> 0 === 0) {
            t.invalid = true;
            return true;
        }
        return false;
    };
    t.isInvalidBrace = t => {
        if (t.type !== "brace") return false;
        if (t.invalid === true || t.dollar) return true;
        if (t.commas >> 0 + t.ranges >> 0 === 0) {
            t.invalid = true;
            return true;
        }
        if (t.open !== true || t.close !== true) {
            t.invalid = true;
            return true;
        }
        return false;
    };
    t.isOpenOrClose = t => {
        if (t.type === "open" || t.type === "close") {
            return true;
        }
        return t.open === true || t.close === true;
    };
    t.reduce = t => t.reduce(((t, e) => {
        if (e.type === "text") t.push(e.value);
        if (e.type === "range") e.type = "text";
        return t;
    }), []);
    t.flatten = (...t) => {
        const e = [];
        const r = t => {
            for (let n = 0; n < t.length; n++) {
                const s = t[n];
                if (Array.isArray(s)) {
                    r(s);
                    continue;
                }
                if (s !== undefined) {
                    e.push(s);
                }
            }
            return e;
        };
        r(t);
        return e;
    };
})(at);

const ut = t(at);

"use strict";

const ct = at;

var lt = (t, e = {}) => {
    const r = (t, n = {}) => {
        const s = e.escapeInvalid && ct.isInvalidBrace(n);
        const i = t.invalid === true && e.escapeInvalid === true;
        let o = "";
        if (t.value) {
            if ((s || i) && ct.isOpenOrClose(t)) {
                return "\\" + t.value;
            }
            return t.value;
        }
        if (t.value) {
            return t.value;
        }
        if (t.nodes) {
            for (const e of t.nodes) {
                o += r(e);
            }
        }
        return o;
    };
    return r(t);
};

const ft = t(lt);

"use strict";

var pt = function(t) {
    if (typeof t === "number") {
        return t - t === 0;
    }
    if (typeof t === "string" && t.trim() !== "") {
        return Number.isFinite ? Number.isFinite(+t) : isFinite(+t);
    }
    return false;
};

const ht = t(pt);

"use strict";

const dt = pt;

const _t = (t, e, r) => {
    if (dt(t) === false) {
        throw new TypeError("toRegexRange: expected the first argument to be a number");
    }
    if (e === void 0 || t === e) {
        return String(t);
    }
    if (dt(e) === false) {
        throw new TypeError("toRegexRange: expected the second argument to be a number.");
    }
    let n = {
        relaxZeros: true,
        ...r
    };
    if (typeof n.strictZeros === "boolean") {
        n.relaxZeros = n.strictZeros === false;
    }
    let s = String(n.relaxZeros);
    let i = String(n.shorthand);
    let o = String(n.capture);
    let a = String(n.wrap);
    let u = t + ":" + e + "=" + s + i + o + a;
    if (_t.cache.hasOwnProperty(u)) {
        return _t.cache[u].result;
    }
    let c = Math.min(t, e);
    let l = Math.max(t, e);
    if (Math.abs(c - l) === 1) {
        let r = t + "|" + e;
        if (n.capture) {
            return `(${r})`;
        }
        if (n.wrap === false) {
            return r;
        }
        return `(?:${r})`;
    }
    let f = wt(t) || wt(e);
    let p = {
        min: t,
        max: e,
        a: c,
        b: l
    };
    let h = [];
    let d = [];
    if (f) {
        p.isPadded = f;
        p.maxLen = String(p.max).length;
    }
    if (c < 0) {
        let t = l < 0 ? Math.abs(l) : 1;
        d = mt(t, Math.abs(c), p, n);
        c = p.a = 0;
    }
    if (l >= 0) {
        h = mt(c, l, p, n);
    }
    p.negatives = d;
    p.positives = h;
    p.result = gt(d, h, n);
    if (n.capture === true) {
        p.result = `(${p.result})`;
    } else if (n.wrap !== false && h.length + d.length > 1) {
        p.result = `(?:${p.result})`;
    }
    _t.cache[u] = p;
    return p.result;
};

function gt(t, e, r) {
    let n = St(t, e, "-", false, r) || [];
    let s = St(e, t, "", false, r) || [];
    let i = St(t, e, "-?", true, r) || [];
    let o = n.concat(i).concat(s);
    return o.join("|");
}

function yt(t, e) {
    let r = 1;
    let n = 1;
    let s = Rt(t, r);
    let i = new Set([ e ]);
    while (t <= s && s <= e) {
        i.add(s);
        r += 1;
        s = Rt(t, r);
    }
    s = Pt(e + 1, n) - 1;
    while (t < s && s <= e) {
        i.add(s);
        n += 1;
        s = Pt(e + 1, n) - 1;
    }
    i = [ ...i ];
    i.sort(Et);
    return i;
}

function vt(t, e, r) {
    if (t === e) {
        return {
            pattern: t,
            count: [],
            digits: 0
        };
    }
    let n = At(t, e);
    let s = n.length;
    let i = "";
    let o = 0;
    for (let t = 0; t < s; t++) {
        let [e, s] = n[t];
        if (e === s) {
            i += e;
        } else if (e !== "0" || s !== "9") {
            i += Ct(e, s, r);
        } else {
            o++;
        }
    }
    if (o) {
        i += r.shorthand === true ? "\\d" : "[0-9]";
    }
    return {
        pattern: i,
        count: [ o ],
        digits: s
    };
}

function mt(t, e, r, n) {
    let s = yt(t, e);
    let i = [];
    let o = t;
    let a;
    for (let t = 0; t < s.length; t++) {
        let e = s[t];
        let u = vt(String(o), String(e), n);
        let c = "";
        if (!r.isPadded && a && a.pattern === u.pattern) {
            if (a.count.length > 1) {
                a.count.pop();
            }
            a.count.push(u.count[0]);
            a.string = a.pattern + xt(a.count);
            o = e + 1;
            continue;
        }
        if (r.isPadded) {
            c = Tt(e, r, n);
        }
        u.string = c + u.pattern + xt(u.count);
        i.push(u);
        o = e + 1;
        a = u;
    }
    return i;
}

function St(t, e, r, n, s) {
    let i = [];
    for (let s of t) {
        let {string: t} = s;
        if (!n && !bt(e, "string", t)) {
            i.push(r + t);
        }
        if (n && bt(e, "string", t)) {
            i.push(r + t);
        }
    }
    return i;
}

function At(t, e) {
    let r = [];
    for (let n = 0; n < t.length; n++) r.push([ t[n], e[n] ]);
    return r;
}

function Et(t, e) {
    return t > e ? 1 : e > t ? -1 : 0;
}

function bt(t, e, r) {
    return t.some((t => t[e] === r));
}

function Rt(t, e) {
    return Number(String(t).slice(0, -e) + "9".repeat(e));
}

function Pt(t, e) {
    return t - t % Math.pow(10, e);
}

function xt(t) {
    let [e = 0, r = ""] = t;
    if (r || e > 1) {
        return `{${e + (r ? "," + r : "")}}`;
    }
    return "";
}

function Ct(t, e, r) {
    return `[${t}${e - t === 1 ? "" : "-"}${e}]`;
}

function wt(t) {
    return /^-?(0+)\d/.test(t);
}

function Tt(t, e, r) {
    if (!e.isPadded) {
        return t;
    }
    let n = Math.abs(e.maxLen - String(t).length);
    let s = r.relaxZeros !== false;
    switch (n) {
      case 0:
        return "";

      case 1:
        return s ? "0?" : "0";

      case 2:
        return s ? "0{0,2}" : "00";

      default:
        {
            return s ? `0{0,${n}}` : `0{${n}}`;
        }
    }
}

_t.cache = {};

_t.clearCache = () => _t.cache = {};

var kt = _t;

const Ot = t(kt);

"use strict";

const Lt = o;

const Ht = kt;

const $t = t => t !== null && typeof t === "object" && !Array.isArray(t);

const Mt = t => e => t === true ? Number(e) : String(e);

const Dt = t => typeof t === "number" || typeof t === "string" && t !== "";

const Ft = t => Number.isInteger(+t);

const It = t => {
    let e = `${t}`;
    let r = -1;
    if (e[0] === "-") e = e.slice(1);
    if (e === "0") return false;
    while (e[++r] === "0") ;
    return r > 0;
};

const Nt = (t, e, r) => {
    if (typeof t === "string" || typeof e === "string") {
        return true;
    }
    return r.stringify === true;
};

const jt = (t, e, r) => {
    if (e > 0) {
        let r = t[0] === "-" ? "-" : "";
        if (r) t = t.slice(1);
        t = r + t.padStart(r ? e - 1 : e, "0");
    }
    if (r === false) {
        return String(t);
    }
    return t;
};

const Bt = (t, e) => {
    let r = t[0] === "-" ? "-" : "";
    if (r) {
        t = t.slice(1);
        e--;
    }
    while (t.length < e) t = "0" + t;
    return r ? "-" + t : t;
};

const Gt = (t, e, r) => {
    t.negatives.sort(((t, e) => t < e ? -1 : t > e ? 1 : 0));
    t.positives.sort(((t, e) => t < e ? -1 : t > e ? 1 : 0));
    let n = e.capture ? "" : "?:";
    let s = "";
    let i = "";
    let o;
    if (t.positives.length) {
        s = t.positives.map((t => Bt(String(t), r))).join("|");
    }
    if (t.negatives.length) {
        i = `-(${n}${t.negatives.map((t => Bt(String(t), r))).join("|")})`;
    }
    if (s && i) {
        o = `${s}|${i}`;
    } else {
        o = s || i;
    }
    if (e.wrap) {
        return `(${n}${o})`;
    }
    return o;
};

const Ut = (t, e, r, n) => {
    if (r) {
        return Ht(t, e, {
            wrap: false,
            ...n
        });
    }
    let s = String.fromCharCode(t);
    if (t === e) return s;
    let i = String.fromCharCode(e);
    return `[${s}-${i}]`;
};

const Wt = (t, e, r) => {
    if (Array.isArray(t)) {
        let e = r.wrap === true;
        let n = r.capture ? "" : "?:";
        return e ? `(${n}${t.join("|")})` : t.join("|");
    }
    return Ht(t, e, r);
};

const Kt = (...t) => new RangeError("Invalid range arguments: " + Lt.inspect(...t));

const Vt = (t, e, r) => {
    if (r.strictRanges === true) throw Kt([ t, e ]);
    return [];
};

const Qt = (t, e) => {
    if (e.strictRanges === true) {
        throw new TypeError(`Expected step "${t}" to be a number`);
    }
    return [];
};

const qt = (t, e, r = 1, n = {}) => {
    let s = Number(t);
    let i = Number(e);
    if (!Number.isInteger(s) || !Number.isInteger(i)) {
        if (n.strictRanges === true) throw Kt([ t, e ]);
        return [];
    }
    if (s === 0) s = 0;
    if (i === 0) i = 0;
    let o = s > i;
    let a = String(t);
    let u = String(e);
    let c = String(r);
    r = Math.max(Math.abs(r), 1);
    let l = It(a) || It(u) || It(c);
    let f = l ? Math.max(a.length, u.length, c.length) : 0;
    let p = l === false && Nt(t, e, n) === false;
    let h = n.transform || Mt(p);
    if (n.toRegex && r === 1) {
        return Ut(Bt(t, f), Bt(e, f), true, n);
    }
    let d = {
        negatives: [],
        positives: []
    };
    let _ = t => d[t < 0 ? "negatives" : "positives"].push(Math.abs(t));
    let g = [];
    let y = 0;
    while (o ? s >= i : s <= i) {
        if (n.toRegex === true && r > 1) {
            _(s);
        } else {
            g.push(jt(h(s, y), f, p));
        }
        s = o ? s - r : s + r;
        y++;
    }
    if (n.toRegex === true) {
        return r > 1 ? Gt(d, n, f) : Wt(g, null, {
            wrap: false,
            ...n
        });
    }
    return g;
};

const Xt = (t, e, r = 1, n = {}) => {
    if (!Ft(t) && t.length > 1 || !Ft(e) && e.length > 1) {
        return Vt(t, e, n);
    }
    let s = n.transform || (t => String.fromCharCode(t));
    let i = `${t}`.charCodeAt(0);
    let o = `${e}`.charCodeAt(0);
    let a = i > o;
    let u = Math.min(i, o);
    let c = Math.max(i, o);
    if (n.toRegex && r === 1) {
        return Ut(u, c, false, n);
    }
    let l = [];
    let f = 0;
    while (a ? i >= o : i <= o) {
        l.push(s(i, f));
        i = a ? i - r : i + r;
        f++;
    }
    if (n.toRegex === true) {
        return Wt(l, null, {
            wrap: false,
            options: n
        });
    }
    return l;
};

const Yt = (t, e, r, n = {}) => {
    if (e == null && Dt(t)) {
        return [ t ];
    }
    if (!Dt(t) || !Dt(e)) {
        return Vt(t, e, n);
    }
    if (typeof r === "function") {
        return Yt(t, e, 1, {
            transform: r
        });
    }
    if ($t(r)) {
        return Yt(t, e, 0, r);
    }
    let s = {
        ...n
    };
    if (s.capture === true) s.wrap = true;
    r = r || s.step || 1;
    if (!Ft(r)) {
        if (r != null && !$t(r)) return Qt(r, s);
        return Yt(t, e, 1, r);
    }
    if (Ft(t) && Ft(e)) {
        return qt(t, e, r, s);
    }
    return Xt(t, e, Math.max(Math.abs(r), 1), s);
};

var Zt = Yt;

const zt = t(Zt);

"use strict";

const Jt = Zt;

const te = at;

const ee = (t, e = {}) => {
    const r = (t, n = {}) => {
        const s = te.isInvalidBrace(n);
        const i = t.invalid === true && e.escapeInvalid === true;
        const o = s === true || i === true;
        const a = e.escapeInvalid === true ? "\\" : "";
        let u = "";
        if (t.isOpen === true) {
            return a + t.value;
        }
        if (t.isClose === true) {
            console.log("node.isClose", a, t.value);
            return a + t.value;
        }
        if (t.type === "open") {
            return o ? a + t.value : "(";
        }
        if (t.type === "close") {
            return o ? a + t.value : ")";
        }
        if (t.type === "comma") {
            return t.prev.type === "comma" ? "" : o ? t.value : "|";
        }
        if (t.value) {
            return t.value;
        }
        if (t.nodes && t.ranges > 0) {
            const r = te.reduce(t.nodes);
            const n = Jt(...r, {
                ...e,
                wrap: false,
                toRegex: true,
                strictZeros: true
            });
            if (n.length !== 0) {
                return r.length > 1 && n.length > 1 ? `(${n})` : n;
            }
        }
        if (t.nodes) {
            for (const e of t.nodes) {
                u += r(e, t);
            }
        }
        return u;
    };
    return r(t);
};

var re = ee;

const ne = t(re);

"use strict";

const se = Zt;

const ie = lt;

const oe = at;

const ae = (t = "", e = "", r = false) => {
    const n = [];
    t = [].concat(t);
    e = [].concat(e);
    if (!e.length) return t;
    if (!t.length) {
        return r ? oe.flatten(e).map((t => `{${t}}`)) : e;
    }
    for (const s of t) {
        if (Array.isArray(s)) {
            for (const t of s) {
                n.push(ae(t, e, r));
            }
        } else {
            for (let t of e) {
                if (r === true && typeof t === "string") t = `{${t}}`;
                n.push(Array.isArray(t) ? ae(s, t, r) : s + t);
            }
        }
    }
    return oe.flatten(n);
};

const ue = (t, e = {}) => {
    const r = e.rangeLimit === undefined ? 1e3 : e.rangeLimit;
    const n = (t, s = {}) => {
        t.queue = [];
        let i = s;
        let o = s.queue;
        while (i.type !== "brace" && i.type !== "root" && i.parent) {
            i = i.parent;
            o = i.queue;
        }
        if (t.invalid || t.dollar) {
            o.push(ae(o.pop(), ie(t, e)));
            return;
        }
        if (t.type === "brace" && t.invalid !== true && t.nodes.length === 2) {
            o.push(ae(o.pop(), [ "{}" ]));
            return;
        }
        if (t.nodes && t.ranges > 0) {
            const n = oe.reduce(t.nodes);
            if (oe.exceedsLimit(...n, e.step, r)) {
                throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
            }
            let s = se(...n, e);
            if (s.length === 0) {
                s = ie(t, e);
            }
            o.push(ae(o.pop(), s));
            t.nodes = [];
            return;
        }
        const a = oe.encloseBrace(t);
        let u = t.queue;
        let c = t;
        while (c.type !== "brace" && c.type !== "root" && c.parent) {
            c = c.parent;
            u = c.queue;
        }
        for (let e = 0; e < t.nodes.length; e++) {
            const r = t.nodes[e];
            if (r.type === "comma" && t.type === "brace") {
                if (e === 1) u.push("");
                u.push("");
                continue;
            }
            if (r.type === "close") {
                o.push(ae(o.pop(), u, a));
                continue;
            }
            if (r.value && r.type !== "open") {
                u.push(ae(u.pop(), r.value));
                continue;
            }
            if (r.nodes) {
                n(r, t);
            }
        }
        return u;
    };
    return oe.flatten(n(t));
};

var ce = ue;

const le = t(ce);

"use strict";

var fe = {
    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 pe = t(fe);

"use strict";

const he = lt;

const {MAX_LENGTH: de, CHAR_BACKSLASH: _e, CHAR_BACKTICK: ge, CHAR_COMMA: ye, CHAR_DOT: ve, CHAR_LEFT_PARENTHESES: me, CHAR_RIGHT_PARENTHESES: Se, CHAR_LEFT_CURLY_BRACE: Ae, CHAR_RIGHT_CURLY_BRACE: Ee, CHAR_LEFT_SQUARE_BRACKET: be, CHAR_RIGHT_SQUARE_BRACKET: Re, CHAR_DOUBLE_QUOTE: Pe, CHAR_SINGLE_QUOTE: xe, CHAR_NO_BREAK_SPACE: Ce, CHAR_ZERO_WIDTH_NOBREAK_SPACE: we} = fe;

const Te = (t, e = {}) => {
    if (typeof t !== "string") {
        throw new TypeError("Expected a string");
    }
    const r = e || {};
    const n = typeof r.maxLength === "number" ? Math.min(de, r.maxLength) : de;
    if (t.length > n) {
        throw new SyntaxError(`Input length (${t.length}), exceeds max characters (${n})`);
    }
    const s = {
        type: "root",
        input: t,
        nodes: []
    };
    const i = [ s ];
    let o = s;
    let a = s;
    let u = 0;
    const c = t.length;
    let l = 0;
    let f = 0;
    let p;
    const h = () => t[l++];
    const d = t => {
        if (t.type === "text" && a.type === "dot") {
            a.type = "text";
        }
        if (a && a.type === "text" && t.type === "text") {
            a.value += t.value;
            return;
        }
        o.nodes.push(t);
        t.parent = o;
        t.prev = a;
        a = t;
        return t;
    };
    d({
        type: "bos"
    });
    while (l < c) {
        o = i[i.length - 1];
        p = h();
        if (p === we || p === Ce) {
            continue;
        }
        if (p === _e) {
            d({
                type: "text",
                value: (e.keepEscaping ? p : "") + h()
            });
            continue;
        }
        if (p === Re) {
            d({
                type: "text",
                value: "\\" + p
            });
            continue;
        }
        if (p === be) {
            u++;
            let t;
            while (l < c && (t = h())) {
                p += t;
                if (t === be) {
                    u++;
                    continue;
                }
                if (t === _e) {
                    p += h();
                    continue;
                }
                if (t === Re) {
                    u--;
                    if (u === 0) {
                        break;
                    }
                }
            }
            d({
                type: "text",
                value: p
            });
            continue;
        }
        if (p === me) {
            o = d({
                type: "paren",
                nodes: []
            });
            i.push(o);
            d({
                type: "text",
                value: p
            });
            continue;
        }
        if (p === Se) {
            if (o.type !== "paren") {
                d({
                    type: "text",
                    value: p
                });
                continue;
            }
            o = i.pop();
            d({
                type: "text",
                value: p
            });
            o = i[i.length - 1];
            continue;
        }
        if (p === Pe || p === xe || p === ge) {
            const t = p;
            let r;
            if (e.keepQuotes !== true) {
                p = "";
            }
            while (l < c && (r = h())) {
                if (r === _e) {
                    p += r + h();
                    continue;
                }
                if (r === t) {
                    if (e.keepQuotes === true) p += r;
                    break;
                }
                p += r;
            }
            d({
                type: "text",
                value: p
            });
            continue;
        }
        if (p === Ae) {
            f++;
            const t = a.value && a.value.slice(-1) === "$" || o.dollar === true;
            const e = {
                type: "brace",
                open: true,
                close: false,
                dollar: t,
                depth: f,
                commas: 0,
                ranges: 0,
                nodes: []
            };
            o = d(e);
            i.push(o);
            d({
                type: "open",
                value: p
            });
            continue;
        }
        if (p === Ee) {
            if (o.type !== "brace") {
                d({
                    type: "text",
                    value: p
                });
                continue;
            }
            const t = "close";
            o = i.pop();
            o.close = true;
            d({
                type: t,
                value: p
            });
            f--;
            o = i[i.length - 1];
            continue;
        }
        if (p === ye && f > 0) {
            if (o.ranges > 0) {
                o.ranges = 0;
                const t = o.nodes.shift();
                o.nodes = [ t, {
                    type: "text",
                    value: he(o)
                } ];
            }
            d({
                type: "comma",
                value: p
            });
            o.commas++;
            continue;
        }
        if (p === ve && f > 0 && o.commas === 0) {
            const t = o.nodes;
            if (f === 0 || t.length === 0) {
                d({
                    type: "text",
                    value: p
                });
                continue;
            }
            if (a.type === "dot") {
                o.range = [];
                a.value += p;
                a.type = "range";
                if (o.nodes.length !== 3 && o.nodes.length !== 5) {
                    o.invalid = true;
                    o.ranges = 0;
                    a.type = "text";
                    continue;
                }
                o.ranges++;
                o.args = [];
                continue;
            }
            if (a.type === "range") {
                t.pop();
                const e = t[t.length - 1];
                e.value += a.value + p;
                a = e;
                o.ranges--;
                continue;
            }
            d({
                type: "dot",
                value: p
            });
            continue;
        }
        d({
            type: "text",
            value: p
        });
    }
    do {
        o = i.pop();
        if (o.type !== "root") {
            o.nodes.forEach((t => {
                if (!t.nodes) {
                    if (t.type === "open") t.isOpen = true;
                    if (t.type === "close") t.isClose = true;
                    if (!t.nodes) t.type = "text";
                    t.invalid = true;
                }
            }));
            const t = i[i.length - 1];
            const e = t.nodes.indexOf(o);
            t.nodes.splice(e, 1, ...o.nodes);
        }
    } while (i.length > 0);
    d({
        type: "eos"
    });
    return s;
};

var ke = Te;

const Oe = t(ke);

"use strict";

const Le = lt;

const He = re;

const $e = ce;

const Me = ke;

const De = (t, e = {}) => {
    let r = [];
    if (Array.isArray(t)) {
        for (const n of t) {
            const t = De.create(n, e);
            if (Array.isArray(t)) {
                r.push(...t);
            } else {
                r.push(t);
            }
        }
    } else {
        r = [].concat(De.create(t, e));
    }
    if (e && e.expand === true && e.nodupes === true) {
        r = [ ...new Set(r) ];
    }
    return r;
};

De.parse = (t, e = {}) => Me(t, e);

De.stringify = (t, e = {}) => {
    if (typeof t === "string") {
        return Le(De.parse(t, e), e);
    }
    return Le(t, e);
};

De.compile = (t, e = {}) => {
    if (typeof t === "string") {
        t = De.parse(t, e);
    }
    return He(t, e);
};

De.expand = (t, e = {}) => {
    if (typeof t === "string") {
        t = De.parse(t, e);
    }
    let r = $e(t, e);
    if (e.noempty === true) {
        r = r.filter(Boolean);
    }
    if (e.nodupes === true) {
        r = [ ...new Set(r) ];
    }
    return r;
};

De.create = (t, e = {}) => {
    if (t === "" || t.length < 3) {
        return [ t ];
    }
    return e.expand !== true ? De.compile(t, e) : De.expand(t, e);
};

var Fe = De;

const Ie = t(Fe);

var Ne = {};

"use strict";

const je = s;

const Be = "\\\\/";

const Ge = `[^${Be}]`;

const Ue = "\\.";

const We = "\\+";

const Ke = "\\?";

const Ve = "\\/";

const Qe = "(?=.)";

const qe = "[^/]";

const Xe = `(?:${Ve}|$)`;

const Ye = `(?:^|${Ve})`;

const Ze = `${Ue}{1,2}${Xe}`;

const ze = `(?!${Ue})`;

const Je = `(?!${Ye}${Ze})`;

const tr = `(?!${Ue}{0,1}${Xe})`;

const er = `(?!${Ze})`;

const rr = `[^.${Ve}]`;

const nr = `${qe}*?`;

const sr = {
    DOT_LITERAL: Ue,
    PLUS_LITERAL: We,
    QMARK_LITERAL: Ke,
    SLASH_LITERAL: Ve,
    ONE_CHAR: Qe,
    QMARK: qe,
    END_ANCHOR: Xe,
    DOTS_SLASH: Ze,
    NO_DOT: ze,
    NO_DOTS: Je,
    NO_DOT_SLASH: tr,
    NO_DOTS_SLASH: er,
    QMARK_NO_DOT: rr,
    STAR: nr,
    START_ANCHOR: Ye
};

const ir = {
    ...sr,
    SLASH_LITERAL: `[${Be}]`,
    QMARK: Ge,
    STAR: `${Ge}*?`,
    DOTS_SLASH: `${Ue}{1,2}(?:[${Be}]|$)`,
    NO_DOT: `(?!${Ue})`,
    NO_DOTS: `(?!(?:^|[${Be}])${Ue}{1,2}(?:[${Be}]|$))`,
    NO_DOT_SLASH: `(?!${Ue}{0,1}(?:[${Be}]|$))`,
    NO_DOTS_SLASH: `(?!${Ue}{1,2}(?:[${Be}]|$))`,
    QMARK_NO_DOT: `[^.${Be}]`,
    START_ANCHOR: `(?:^|[${Be}])`,
    END_ANCHOR: `(?:[${Be}]|$)`
};

const or = {
    alnum: "a-zA-Z0-9",
    alpha: "a-zA-Z",
    ascii: "\\x00-\\x7F",
    blank: " \\t",
    cntrl: "\\x00-\\x1F\\x7F",
    digit: "0-9",
    graph: "\\x21-\\x7E",
    lower: "a-z",
    print: "\\x20-\\x7E ",
    punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
    space: " \\t\\r\\n\\v\\f",
    upper: "A-Z",
    word: "A-Za-z0-9_",
    xdigit: "A-Fa-f0-9"
};

var ar = {
    MAX_LENGTH: 1024 * 64,
    POSIX_REGEX_SOURCE: or,
    REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
    REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
    REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
    REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
    REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
    REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
    REPLACEMENTS: {
        "***": "*",
        "**/**": "**",
        "**/**/**": "**"
    },
    CHAR_0: 48,
    CHAR_9: 57,
    CHAR_UPPERCASE_A: 65,
    CHAR_LOWERCASE_A: 97,
    CHAR_UPPERCASE_Z: 90,
    CHAR_LOWERCASE_Z: 122,
    CHAR_LEFT_PARENTHESES: 40,
    CHAR_RIGHT_PARENTHESES: 41,
    CHAR_ASTERISK: 42,
    CHAR_AMPERSAND: 38,
    CHAR_AT: 64,
    CHAR_BACKWARD_SLASH: 92,
    CHAR_CARRIAGE_RETURN: 13,
    CHAR_CIRCUMFLEX_ACCENT: 94,
    CHAR_COLON: 58,
    CHAR_COMMA: 44,
    CHAR_DOT: 46,
    CHAR_DOUBLE_QUOTE: 34,
    CHAR_EQUAL: 61,
    CHAR_EXCLAMATION_MARK: 33,
    CHAR_FORM_FEED: 12,
    CHAR_FORWARD_SLASH: 47,
    CHAR_GRAVE_ACCENT: 96,
    CHAR_HASH: 35,
    CHAR_HYPHEN_MINUS: 45,
    CHAR_LEFT_ANGLE_BRACKET: 60,
    CHAR_LEFT_CURLY_BRACE: 123,
    CHAR_LEFT_SQUARE_BRACKET: 91,
    CHAR_LINE_FEED: 10,
    CHAR_NO_BREAK_SPACE: 160,
    CHAR_PERCENT: 37,
    CHAR_PLUS: 43,
    CHAR_QUESTION_MARK: 63,
    CHAR_RIGHT_ANGLE_BRACKET: 62,
    CHAR_RIGHT_CURLY_BRACE: 125,
    CHAR_RIGHT_SQUARE_BRACKET: 93,
    CHAR_SEMICOLON: 59,
    CHAR_SINGLE_QUOTE: 39,
    CHAR_SPACE: 32,
    CHAR_TAB: 9,
    CHAR_UNDERSCORE: 95,
    CHAR_VERTICAL_LINE: 124,
    CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
    SEP: je.sep,
    extglobChars(t) {
        return {
            "!": {
                type: "negate",
                open: "(?:(?!(?:",
                close: `))${t.STAR})`
            },
            "?": {
                type: "qmark",
                open: "(?:",
                close: ")?"
            },
            "+": {
                type: "plus",
                open: "(?:",
                close: ")+"
            },
            "*": {
                type: "star",
                open: "(?:",
                close: ")*"
            },
            "@": {
                type: "at",
                open: "(?:",
                close: ")"
            }
        };
    },
    globChars(t) {
        return t === true ? ir : sr;
    }
};

const ur = t(ar);

(function(t) {
    "use strict";
    const e = s;
    const r = process.platform === "win32";
    const {REGEX_BACKSLASH: n, REGEX_REMOVE_BACKSLASH: i, REGEX_SPECIAL_CHARS: o, REGEX_SPECIAL_CHARS_GLOBAL: a} = ar;
    t.isObject = t => t !== null && typeof t === "object" && !Array.isArray(t);
    t.hasRegexChars = t => o.test(t);
    t.isRegexChar = e => e.length === 1 && t.hasRegexChars(e);
    t.escapeRegex = t => t.replace(a, "\\$1");
    t.toPosixSlashes = t => t.replace(n, "/");
    t.removeBackslashes = t => t.replace(i, (t => t === "\\" ? "" : t));
    t.supportsLookbehinds = () => {
        const t = process.version.slice(1).split(".").map(Number);
        if (t.length === 3 && t[0] >= 9 || t[0] === 8 && t[1] >= 10) {
            return true;
        }
        return false;
    };
    t.isWindows = t => {
        if (t && typeof t.windows === "boolean") {
            return t.windows;
        }
        return r === true || e.sep === "\\";
    };
    t.escapeLast = (e, r, n) => {
        const s = e.lastIndexOf(r, n);
        if (s === -1) return e;
        if (e[s - 1] === "\\") return t.escapeLast(e, r, s - 1);
        return `${e.slice(0, s)}\\${e.slice(s)}`;
    };
    t.removePrefix = (t, e = {}) => {
        let r = t;
        if (r.startsWith("./")) {
            r = r.slice(2);
            e.prefix = "./";
        }
        return r;
    };
    t.wrapOutput = (t, e = {}, r = {}) => {
        const n = r.contains ? "" : "^";
        const s = r.contains ? "" : "$";
        let i = `${n}(?:${t})${s}`;
        if (e.negated === true) {
            i = `(?:^(?!${i}).*$)`;
        }
        return i;
    };
})(Ne);

const cr = t(Ne);

"use strict";

const lr = Ne;

const {CHAR_ASTERISK: fr, CHAR_AT: pr, CHAR_BACKWARD_SLASH: hr, CHAR_COMMA: dr, CHAR_DOT: _r, CHAR_EXCLAMATION_MARK: gr, CHAR_FORWARD_SLASH: yr, CHAR_LEFT_CURLY_BRACE: vr, CHAR_LEFT_PARENTHESES: mr, CHAR_LEFT_SQUARE_BRACKET: Sr, CHAR_PLUS: Ar, CHAR_QUESTION_MARK: Er, CHAR_RIGHT_CURLY_BRACE: br, CHAR_RIGHT_PARENTHESES: Rr, CHAR_RIGHT_SQUARE_BRACKET: Pr} = ar;

const xr = t => t === yr || t === hr;

const Cr = t => {
    if (t.isPrefix !== true) {
        t.depth = t.isGlobstar ? Infinity : 1;
    }
};

const wr = (t, e) => {
    const r = e || {};
    const n = t.length - 1;
    const s = r.parts === true || r.scanToEnd === true;
    const i = [];
    const o = [];
    const a = [];
    let u = t;
    let c = -1;
    let l = 0;
    let f = 0;
    let p = false;
    let h = false;
    let d = false;
    let _ = false;
    let g = false;
    let y = false;
    let v = false;
    let m = false;
    let S = false;
    let A = false;
    let E = 0;
    let b;
    let R;
    let P = {
        value: "",
        depth: 0,
        isGlob: false
    };
    const x = () => c >= n;
    const C = () => u.charCodeAt(c + 1);
    const w = () => {
        b = R;
        return u.charCodeAt(++c);
    };
    while (c < n) {
        R = w();
        let t;
        if (R === hr) {
            v = P.backslashes = true;
            R = w();
            if (R === vr) {
                y = true;
            }
            continue;
        }
        if (y === true || R === vr) {
            E++;
            while (x() !== true && (R = w())) {
                if (R === hr) {
                    v = P.backslashes = true;
                    w();
                    continue;
                }
                if (R === vr) {
                    E++;
                    continue;
                }
                if (y !== true && R === _r && (R = w()) === _r) {
                    p = P.isBrace = true;
                    d = P.isGlob = true;
                    A = true;
                    if (s === true) {
                        continue;
                    }
                    break;
                }
                if (y !== true && R === dr) {
                    p = P.isBrace = true;
                    d = P.isGlob = true;
                    A = true;
                    if (s === true) {
                        continue;
                    }
                    break;
                }
                if (R === br) {
                    E--;
                    if (E === 0) {
                        y = false;
                        p = P.isBrace = true;
                        A = true;
                        break;
                    }
                }
            }
            if (s === true) {
                continue;
            }
            break;
        }
        if (R === yr) {
            i.push(c);
            o.push(P);
            P = {
                value: "",
                depth: 0,
                isGlob: false
            };
            if (A === true) continue;
            if (b === _r && c === l + 1) {
                l += 2;
                continue;
            }
            f = c + 1;
            continue;
        }
        if (r.noext !== true) {
            const t = R === Ar || R === pr || R === fr || R === Er || R === gr;
            if (t === true && C() === mr) {
                d = P.isGlob = true;
                _ = P.isExtglob = true;
                A = true;
                if (R === gr && c === l) {
                    S = true;
                }
                if (s === true) {
                    while (x() !== true && (R = w())) {
                        if (R === hr) {
                            v = P.backslashes = true;
                            R = w();
                            continue;
                        }
                        if (R === Rr) {
                            d = P.isGlob = true;
                            A = true;
                            break;
                        }
                    }
                    continue;
                }
                break;
            }
        }
        if (R === fr) {
            if (b === fr) g = P.isGlobstar = true;
            d = P.isGlob = true;
            A = true;
            if (s === true) {
                continue;
            }
            break;
        }
        if (R === Er) {
            d = P.isGlob = true;
            A = true;
            if (s === true) {
                continue;
            }
            break;
        }
        if (R === Sr) {
            while (x() !== true && (t = w())) {
                if (t === hr) {
                    v = P.backslashes = true;
                    w();
                    continue;
                }
                if (t === Pr) {
                    h = P.isBracket = true;
                    d = P.isGlob = true;
                    A = true;
                    break;
                }
            }
            if (s === true) {
                continue;
            }
            break;
        }
        if (r.nonegate !== true && R === gr && c === l) {
            m = P.negated = true;
            l++;
            continue;
        }
        if (r.noparen !== true && R === mr) {
            d = P.isGlob = true;
            if (s === true) {
                while (x() !== true && (R = w())) {
                    if (R === mr) {
                        v = P.backslashes = true;
                        R = w();
                        continue;
                    }
                    if (R === Rr) {
                        A = true;
                        break;
                    }
                }
                continue;
            }
            break;
        }
        if (d === true) {
            A = true;
            if (s === true) {
                continue;
            }
            break;
        }
    }
    if (r.noext === true) {
        _ = false;
        d = false;
    }
    let T = u;
    let k = "";
    let O = "";
    if (l > 0) {
        k = u.slice(0, l);
        u = u.slice(l);
        f -= l;
    }
    if (T && d === true && f > 0) {
        T = u.slice(0, f);
        O = u.slice(f);
    } else if (d === true) {
        T = "";
        O = u;
    } else {
        T = u;
    }
    if (T && T !== "" && T !== "/" && T !== u) {
        if (xr(T.charCodeAt(T.length - 1))) {
            T = T.slice(0, -1);
        }
    }
    if (r.unescape === true) {
        if (O) O = lr.removeBackslashes(O);
        if (T && v === true) {
            T = lr.removeBackslashes(T);
        }
    }
    const L = {
        prefix: k,
        input: t,
        start: l,
        base: T,
        glob: O,
        isBrace: p,
        isBracket: h,
        isGlob: d,
        isExtglob: _,
        isGlobstar: g,
        negated: m,
        negatedExtglob: S
    };
    if (r.tokens === true) {
        L.maxDepth = 0;
        if (!xr(R)) {
            o.push(P);
        }
        L.tokens = o;
    }
    if (r.parts === true || r.tokens === true) {
        let e;
        for (let n = 0; n < i.length; n++) {
            const s = e ? e + 1 : l;
            const u = i[n];
            const c = t.slice(s, u);
            if (r.tokens) {
                if (n === 0 && l !== 0) {
                    o[n].isPrefix = true;
                    o[n].value = k;
                } else {
                    o[n].value = c;
                }
                Cr(o[n]);
                L.maxDepth += o[n].depth;
            }
            if (n !== 0 || c !== "") {
                a.push(c);
            }
            e = u;
        }
        if (e && e + 1 < t.length) {
            const n = t.slice(e + 1);
            a.push(n);
            if (r.tokens) {
                o[o.length - 1].value = n;
                Cr(o[o.length - 1]);
                L.maxDepth += o[o.length - 1].depth;
            }
        }
        L.slashes = i;
        L.parts = a;
    }
    return L;
};

var Tr = wr;

const kr = t(Tr);

"use strict";

const Or = ar;

const Lr = Ne;

const {MAX_LENGTH: Hr, POSIX_REGEX_SOURCE: $r, REGEX_NON_SPECIAL_CHARS: Mr, REGEX_SPECIAL_CHARS_BACKREF: Dr, REPLACEMENTS: Fr} = Or;

const Ir = (t, e) => {
    if (typeof e.expandRange === "function") {
        return e.expandRange(...t, e);
    }
    t.sort();
    const r = `[${t.join("-")}]`;
    try {
        new RegExp(r);
    } catch (e) {
        return t.map((t => Lr.escapeRegex(t))).join("..");
    }
    return r;
};

const Nr = (t, e) => `Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`;

const jr = (t, e) => {
    if (typeof t !== "string") {
        throw new TypeError("Expected a string");
    }
    t = Fr[t] || t;
    const r = {
        ...e
    };
    const n = typeof r.maxLength === "number" ? Math.min(Hr, r.maxLength) : Hr;
    let s = t.length;
    if (s > n) {
        throw new SyntaxError(`Input length: ${s}, exceeds maximum allowed length: ${n}`);
    }
    const i = {
        type: "bos",
        value: "",
        output: r.prepend || ""
    };
    const o = [ i ];
    const a = r.capture ? "" : "?:";
    const u = Lr.isWindows(e);
    const c = Or.globChars(u);
    const l = Or.extglobChars(c);
    const {DOT_LITERAL: f, PLUS_LITERAL: p, SLASH_LITERAL: h, ONE_CHAR: d, DOTS_SLASH: _, NO_DOT: g, NO_DOT_SLASH: y, NO_DOTS_SLASH: v, QMARK: m, QMARK_NO_DOT: S, STAR: A, START_ANCHOR: E} = c;
    const b = t => `(${a}(?:(?!${E}${t.dot ? _ : f}).)*?)`;
    const R = r.dot ? "" : g;
    const P = r.dot ? m : S;
    let x = r.bash === true ? b(r) : A;
    if (r.capture) {
        x = `(${x})`;
    }
    if (typeof r.noext === "boolean") {
        r.noextglob = r.noext;
    }
    const C = {
        input: t,
        index: -1,
        start: 0,
        dot: r.dot === true,
        consumed: "",
        output: "",
        prefix: "",
        backtrack: false,
        negated: false,
        brackets: 0,
        braces: 0,
        parens: 0,
        quotes: 0,
        globstar: false,
        tokens: o
    };
    t = Lr.removePrefix(t, C);
    s = t.length;
    const w = [];
    const T = [];
    const k = [];
    let O = i;
    let L;
    const H = () => C.index === s - 1;
    const $ = C.peek = (e = 1) => t[C.index + e];
    const M = C.advance = () => t[++C.index] || "";
    const D = () => t.slice(C.index + 1);
    const F = (t = "", e = 0) => {
        C.consumed += t;
        C.index += e;
    };
    const I = t => {
        C.output += t.output != null ? t.output : t.value;
        F(t.value);
    };
    const N = () => {
        let t = 1;
        while ($() === "!" && ($(2) !== "(" || $(3) === "?")) {
            M();
            C.start++;
            t++;
        }
        if (t % 2 === 0) {
            return false;
        }
        C.negated = true;
        C.start++;
        return true;
    };
    const j = t => {
        C[t]++;
        k.push(t);
    };
    const B = t => {
        C[t]--;
        k.pop();
    };
    const G = t => {
        if (O.type === "globstar") {
            const e = C.braces > 0 && (t.type === "comma" || t.type === "brace");
            const r = t.extglob === true || w.length && (t.type === "pipe" || t.type === "paren");
            if (t.type !== "slash" && t.type !== "paren" && !e && !r) {
                C.output = C.output.slice(0, -O.output.length);
                O.type = "star";
                O.value = "*";
                O.output = x;
                C.output += O.output;
            }
        }
        if (w.length && t.type !== "paren") {
            w[w.length - 1].inner += t.value;
        }
        if (t.value || t.output) I(t);
        if (O && O.type === "text" && t.type === "text") {
            O.value += t.value;
            O.output = (O.output || "") + t.value;
            return;
        }
        t.prev = O;
        o.push(t);
        O = t;
    };
    const U = (t, e) => {
        const n = {
            ...l[e],
            conditions: 1,
            inner: ""
        };
        n.prev = O;
        n.parens = C.parens;
        n.output = C.output;
        const s = (r.capture ? "(" : "") + n.open;
        j("parens");
        G({
            type: t,
            value: e,
            output: C.output ? "" : d
        });
        G({
            type: "paren",
            extglob: true,
            value: M(),
            output: s
        });
        w.push(n);
    };
    const W = t => {
        let n = t.close + (r.capture ? ")" : "");
        let s;
        if (t.type === "negate") {
            let i = x;
            if (t.inner && t.inner.length > 1 && t.inner.includes("/")) {
                i = b(r);
            }
            if (i !== x || H() || /^\)+$/.test(D())) {
                n