lakutata/src/lib/ioc/ListModules.cjs

An IoC-based universal application framework.

"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

const t = require("../../../vendor/Package.5.cjs");

require("../../../vendor/Package.8.cjs");

const e = require("os");

const r = require("path");

const n = require("../../../vendor/Package.9.cjs");

require("../../../vendor/Package.10.cjs");

const s = require("util");

const i = require("stream");

const o = require("fs");

const a = require("events");

const u = require("./Utils.cjs");

require("./FunctionTokenizer.cjs");

require("../../../vendor/Package.2.cjs");

require("../../../vendor/Package.1.cjs");

require("../base/internal/DataValidator.cjs");

require("../../../vendor/Package.4.cjs");

require("node:util/types");

require("../validation/VLD.cjs");

require("../../../vendor/Package.11.cjs");

require("url");

require("../../exceptions/dto/InvalidValueException.cjs");

require("../base/abstracts/Exception.cjs");

require("../base/internal/BasicInfo.cjs");

require("../helpers/As.cjs");

require("../../../vendor/Package.6.cjs");

require("../../../vendor/Package.7.cjs");

require("../base/internal/ThrowWarning.cjs");

require("../helpers/Templating.cjs");

require("../base/internal/CamelCase.cjs");

require("../helpers/NoCase.cjs");

require("../helpers/IsHtml.cjs");

require("../helpers/IsXML.cjs");

require("../../constants/DTOMetadataKey.cjs");

require("../helpers/ObjectConstructor.cjs");

require("../helpers/ObjectParentConstructors.cjs");

require("../helpers/ObjectParentConstructor.cjs");

require("../helpers/ObjectPrototype.cjs");

const c = t => t && t.__esModule ? t : {
    default: t
};

function l(t) {
    if (t && t.__esModule) return t;
    const e = Object.create(null, {
        [Symbol.toStringTag]: {
            value: "Module"
        }
    });
    if (t) {
        for (const r in t) {
            if (r !== "default") {
                const n = Object.getOwnPropertyDescriptor(t, r);
                Object.defineProperty(e, r, n.get ? n : {
                    enumerable: true,
                    get: () => t[r]
                });
            }
        }
    }
    e.default = t;
    return Object.freeze(e);
}

const f = c(e);

const p = l(r);

const h = c(s);

const d = c(i);

const _ = c(o);

const g = c(a);

var y = {};

var v = {};

var m = {};

"use strict";

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

var S = m.splitWhen = A = m.flatten = void 0;

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

var A = m.flatten = E;

function b(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;
}

S = m.splitWhen = b;

var R = {};

"use strict";

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

var P = R.isEnoentCodeError = void 0;

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

P = R.isEnoentCodeError = x;

var C = {};

"use strict";

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

var w = C.createDirentFromStats = void 0;

let T = 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 O(t, e) {
    return new T(t, e);
}

w = C.createDirentFromStats = O;

var k = {};

"use strict";

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

var L = k.convertPosixPathToPattern = tt = k.convertWindowsPathToPattern = z = k.convertPathToPattern = Z = k.escapePosixPath = X = k.escapeWindowsPath = V = k.escape = K = k.removeLeadingDotSegment = U = k.makeAbsolute = q = k.unixify = void 0;

const H = f.default;

const D = p.default;

const F = H.platform() === "win32";

const M = 2;

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

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

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

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

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

var q = k.unixify = B;

function G(t, e) {
    return D.resolve(t, e);
}

var U = k.makeAbsolute = G;

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

var K = k.removeLeadingDotSegment = W;

var V = k.escape = F ? Q : Y;

function Q(t) {
    return t.replace(j, "\\$2");
}

var X = k.escapeWindowsPath = Q;

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

var Z = k.escapePosixPath = Y;

var z = k.convertPathToPattern = F ? J : et;

function J(t) {
    return Q(t).replace(I, "//$1").replace(N, "/");
}

var tt = k.convertWindowsPathToPattern = J;

function et(t) {
    return Y(t);
}

L = k.convertPosixPathToPattern = et;

var rt = {};

"use strict";

var nt = n.isGlob;

var st = p.default.posix.dirname;

var it = f.default.platform() === "win32";

var ot = "/";

var at = /\\/g;

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

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

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

var ft = function t(e, r) {
    var n = Object.assign({
        flipBackslashes: true
    }, r);
    if (n.flipBackslashes && it && e.indexOf(ot) < 0) {
        e = e.replace(at, ot);
    }
    if (ut.test(e)) {
        e += ot;
    }
    e += "a";
    do {
        e = st(e);
    } while (nt(e) || ct.test(e));
    return e.replace(lt, "$1");
};

const pt = t.getDefaultExportFromCjs(ft);

var ht = {};

(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;
    };
})(ht);

const dt = t.getDefaultExportFromCjs(ht);

"use strict";

const _t = ht;

var gt = (t, e = {}) => {
    const r = (t, n = {}) => {
        const s = e.escapeInvalid && _t.isInvalidBrace(n);
        const i = t.invalid === true && e.escapeInvalid === true;
        let o = "";
        if (t.value) {
            if ((s || i) && _t.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 yt = t.getDefaultExportFromCjs(gt);

"use strict";

var vt = 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 mt = t.getDefaultExportFromCjs(vt);

"use strict";

const St = vt;

const Et = (t, e, r) => {
    if (St(t) === false) {
        throw new TypeError("toRegexRange: expected the first argument to be a number");
    }
    if (e === void 0 || t === e) {
        return String(t);
    }
    if (St(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 (Et.cache.hasOwnProperty(u)) {
        return Et.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 = Dt(t) || Dt(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 = Pt(t, Math.abs(c), p, n);
        c = p.a = 0;
    }
    if (l >= 0) {
        h = Pt(c, l, p, n);
    }
    p.negatives = d;
    p.positives = h;
    p.result = At(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})`;
    }
    Et.cache[u] = p;
    return p.result;
};

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

function bt(t, e) {
    let r = 1;
    let n = 1;
    let s = Ot(t, r);
    let i = new Set([ e ]);
    while (t <= s && s <= e) {
        i.add(s);
        r += 1;
        s = Ot(t, r);
    }
    s = kt(e + 1, n) - 1;
    while (t < s && s <= e) {
        i.add(s);
        n += 1;
        s = kt(e + 1, n) - 1;
    }
    i = [ ...i ];
    i.sort(wt);
    return i;
}

function Rt(t, e, r) {
    if (t === e) {
        return {
            pattern: t,
            count: [],
            digits: 0
        };
    }
    let n = Ct(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 += Ht(e, s, r);
        } else {
            o++;
        }
    }
    if (o) {
        i += r.shorthand === true ? "\\d" : "[0-9]";
    }
    return {
        pattern: i,
        count: [ o ],
        digits: s
    };
}

function Pt(t, e, r, n) {
    let s = bt(t, e);
    let i = [];
    let o = t;
    let a;
    for (let t = 0; t < s.length; t++) {
        let e = s[t];
        let u = Rt(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 + Lt(a.count);
            o = e + 1;
            continue;
        }
        if (r.isPadded) {
            c = Ft(e, r, n);
        }
        u.string = c + u.pattern + Lt(u.count);
        i.push(u);
        o = e + 1;
        a = u;
    }
    return i;
}

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

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

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

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

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

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

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

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

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

function Ft(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}}`;
        }
    }
}

Et.cache = {};

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

var Mt = Et;

const $t = t.getDefaultExportFromCjs(Mt);

"use strict";

const jt = h.default;

const It = Mt;

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

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

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

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

const Ut = 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 Wt = (t, e, r) => {
    if (typeof t === "string" || typeof e === "string") {
        return true;
    }
    return r.stringify === true;
};

const Kt = (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 Vt = (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 Qt = (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 => Vt(String(t), r))).join("|");
    }
    if (t.negatives.length) {
        i = `-(${n}${t.negatives.map((t => Vt(String(t), r))).join("|")})`;
    }
    if (s && i) {
        o = `${s}|${i}`;
    } else {
        o = s || i;
    }
    if (e.wrap) {
        return `(${n}${o})`;
    }
    return o;
};

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

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

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

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

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

const te = (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 Zt([ 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 = Ut(a) || Ut(u) || Ut(c);
    let f = l ? Math.max(a.length, u.length, c.length) : 0;
    let p = l === false && Wt(t, e, n) === false;
    let h = n.transform || Bt(p);
    if (n.toRegex && r === 1) {
        return Xt(Vt(t, f), Vt(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(Kt(h(s, y), f, p));
        }
        s = o ? s - r : s + r;
        y++;
    }
    if (n.toRegex === true) {
        return r > 1 ? Qt(d, n, f) : Yt(g, null, {
            wrap: false,
            ...n
        });
    }
    return g;
};

const ee = (t, e, r = 1, n = {}) => {
    if (!Gt(t) && t.length > 1 || !Gt(e) && e.length > 1) {
        return zt(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 Xt(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 Yt(l, null, {
            wrap: false,
            options: n
        });
    }
    return l;
};

const re = (t, e, r, n = {}) => {
    if (e == null && qt(t)) {
        return [ t ];
    }
    if (!qt(t) || !qt(e)) {
        return zt(t, e, n);
    }
    if (typeof r === "function") {
        return re(t, e, 1, {
            transform: r
        });
    }
    if (Nt(r)) {
        return re(t, e, 0, r);
    }
    let s = {
        ...n
    };
    if (s.capture === true) s.wrap = true;
    r = r || s.step || 1;
    if (!Gt(r)) {
        if (r != null && !Nt(r)) return Jt(r, s);
        return re(t, e, 1, r);
    }
    if (Gt(t) && Gt(e)) {
        return te(t, e, r, s);
    }
    return ee(t, e, Math.max(Math.abs(r), 1), s);
};

var ne = re;

const se = t.getDefaultExportFromCjs(ne);

"use strict";

const ie = ne;

const oe = ht;

const ae = (t, e = {}) => {
    const r = (t, n = {}) => {
        const s = oe.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 = oe.reduce(t.nodes);
            const n = ie(...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 ue = ae;

const ce = t.getDefaultExportFromCjs(ue);

"use strict";

const le = ne;

const fe = gt;

const pe = ht;

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

const de = (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(he(o.pop(), fe(t, e)));
            return;
        }
        if (t.type === "brace" && t.invalid !== true && t.nodes.length === 2) {
            o.push(he(o.pop(), [ "{}" ]));
            return;
        }
        if (t.nodes && t.ranges > 0) {
            const n = pe.reduce(t.nodes);
            if (pe.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 = le(...n, e);
            if (s.length === 0) {
                s = fe(t, e);
            }
            o.push(he(o.pop(), s));
            t.nodes = [];
            return;
        }
        const a = pe.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(he(o.pop(), u, a));
                continue;
            }
            if (r.value && r.type !== "open") {
                u.push(he(u.pop(), r.value));
                continue;
            }
            if (r.nodes) {
                n(r, t);
            }
        }
        return u;
    };
    return pe.flatten(n(t));
};

var _e = de;

const ge = t.getDefaultExportFromCjs(_e);

"use strict";

var ye = {
    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 ve = t.getDefaultExportFromCjs(ye);

"use strict";

const me = gt;

const {MAX_LENGTH: Se, CHAR_BACKSLASH: Ee, CHAR_BACKTICK: Ae, CHAR_COMMA: be, CHAR_DOT: Re, CHAR_LEFT_PARENTHESES: Pe, CHAR_RIGHT_PARENTHESES: xe, CHAR_LEFT_CURLY_BRACE: Ce, CHAR_RIGHT_CURLY_BRACE: we, CHAR_LEFT_SQUARE_BRACKET: Te, CHAR_RIGHT_SQUARE_BRACKET: Oe, CHAR_DOUBLE_QUOTE: ke, CHAR_SINGLE_QUOTE: Le, CHAR_NO_BREAK_SPACE: He, CHAR_ZERO_WIDTH_NOBREAK_SPACE: De} = ye;

const Fe = (t, e = {}) => {
    if (typeof t !== "string") {
        throw new TypeError("Expected a string");
    }
    const r = e || {};
    const n = typeof r.maxLength === "number" ? Math.min(Se, r.maxLength) : Se;
    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 === De || p === He) {
            continue;
        }
        if (p === Ee) {
            d({
                type: "text",
                value: (e.keepEscaping ? p : "") + h()
            });
            continue;
        }
        if (p === Oe) {
            d({
                type: "text",
                value: "\\" + p
            });
            continue;
        }
        if (p === Te) {
            u++;
            let t;
            while (l < c && (t = h())) {
                p += t;
                if (t === Te) {
                    u++;
                    continue;
                }
                if (t === Ee) {
                    p += h();
                    continue;
                }
                if (t === Oe) {
                    u--;
                    if (u === 0) {
                        break;
                    }
                }
            }
            d({
                type: "text",
                value: p
            });
            continue;
        }
        if (p === Pe) {
            o = d({
                type: "paren",
                nodes: []
            });
            i.push(o);
            d({
                type: "text",
                value: p
            });
            continue;
        }
        if (p === xe) {
            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 === ke || p === Le || p === Ae) {
            const t = p;
            let r;
            if (e.keepQuotes !== true) {
                p = "";
            }
            while (l < c && (r = h())) {
                if (r === Ee) {
                    p += r + h();
                    continue;
                }
                if (r === t) {
                    if (e.keepQuotes === true) p += r;
                    break;
                }
                p += r;
            }
            d({
                type: "text",
                value: p
            });
            continue;
        }
        if (p === Ce) {
            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 === we) {
            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 === be && f > 0) {
            if (o.ranges > 0) {
                o.ranges = 0;
                const t = o.nodes.shift();
                o.nodes = [ t, {
                    type: "text",
                    value: me(o)
                } ];
            }
            d({
                type: "comma",
                value: p
            });
            o.commas++;
            continue;
        }
        if (p === Re && 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 Me = Fe;

const $e = t.getDefaultExportFromCjs(Me);

"use strict";

const je = gt;

const Ie = ue;

const Ne = _e;

const Be = Me;

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

qe.parse = (t, e = {}) => Be(t, e);

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

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

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

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

var Ge = qe;

const Ue = t.getDefaultExportFromCjs(Ge);

var We = {};

"use strict";

const Ke = p.default;

const Ve = "\\\\/";

const Qe = `[^${Ve}]`;

const Xe = "\\.";

const Ye = "\\+";

const Ze = "\\?";

const ze = "\\/";

const Je = "(?=.)";

const tr = "[^/]";

const er = `(?:${ze}|$)`;

const rr = `(?:^|${ze})`;

const nr = `${Xe}{1,2}${er}`;

const sr = `(?!${Xe})`;

const ir = `(?!${rr}${nr})`;

const or = `(?!${Xe}{0,1}${er})`;

const ar = `(?!${nr})`;

const ur = `[^.${ze}]`;

const cr = `${tr}*?`;

const lr = {
    DOT_LITERAL: Xe,
    PLUS_LITERAL: Ye,
    QMARK_LITERAL: Ze,
    SLASH_LITERAL: ze,
    ONE_CHAR: Je,
    QMARK: tr,
    END_ANCHOR: er,
    DOTS_SLASH: nr,
    NO_DOT: sr,
    NO_DOTS: ir,
    NO_DOT_SLASH: or,
    NO_DOTS_SLASH: ar,
    QMARK_NO_DOT: ur,
    STAR: cr,
    START_ANCHOR: rr
};

const fr = {
    ...lr,
    SLASH_LITERAL: `[${Ve}]`,
    QMARK: Qe,
    STAR: `${Qe}*?`,
    DOTS_SLASH: `${Xe}{1,2}(?:[${Ve}]|$)`,
    NO_DOT: `(?!${Xe})`,
    NO_DOTS: `(?!(?:^|[${Ve}])${Xe}{1,2}(?:[${Ve}]|$))`,
    NO_DOT_SLASH: `(?!${Xe}{0,1}(?:[${Ve}]|$))`,
    NO_DOTS_SLASH: `(?!${Xe}{1,2}(?:[${Ve}]|$))`,
    QMARK_NO_DOT: `[^.${Ve}]`,
    START_ANCHOR: `(?:^|[${Ve}])`,
    END_ANCHOR: `(?:[${Ve}]|$)`
};

const pr = {
    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 hr = {
    MAX_LENGTH: 1024 * 64,
    POSIX_REGEX_SOURCE: pr,
    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: Ke.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 ? fr : lr;
    }
};

const dr = t.getDefaultExportFromCjs(hr);

(function(t) {
    "use strict";
    const e = p.default;
    const r = process.platform === "win32";
    const {REGEX_BACKSLASH: n, REGEX_REMOVE_BACKSLASH: s, REGEX_SPECIAL_CHARS: i, REGEX_SPECIAL_CHARS_GLOBAL: o} = hr;
    t.isObject = t => t !== null && typeof t === "object" && !Array.isArray(t);
    t.hasRegexChars = t => i.test(t);
    t.isRegexChar = e => e.length === 1 && t.hasRegexChars(e);
    t.escapeRegex = t => t.replace(o, "\\$1");
    t.toPosixSlashes = t => t.replace(n, "/");
    t.removeBackslashes = t => t.replace(s, (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;
    };
})(We);

const _r = t.getDefaultExportFromCjs(We);

"use strict";

const gr = We;

const {CHAR_ASTERISK: yr, CHAR_AT: vr, CHAR_BACKWARD_SLASH: mr, CHAR_COMMA: Sr, CHAR_DOT: Er, CHAR_EXCLAMATION_MARK: Ar, CHAR_FORWARD_SLASH: br, CHAR_LEFT_CURLY_BRACE: Rr, CHAR_LEFT_PARENTHESES: Pr, CHAR_LEFT_SQUARE_BRACKET: xr, CHAR_PLUS: Cr, CHAR_QUESTION_MARK: wr, CHAR_RIGHT_CURLY_BRACE: Tr, CHAR_RIGHT_PARENTHESES: Or, CHAR_RIGHT_SQUARE_BRACKET: kr} = hr;

const Lr = t => t === br || t === mr;

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

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

var Fr = Dr;

const Mr = t.getDefaultExportFromCjs(Fr);

"use strict";

const $r = hr;

const jr = We;

const {MAX_LENGTH: Ir, POSIX_REGEX_SOURCE: Nr, REGEX_NON_SPECIAL_CHARS: Br, REGEX_SPECIAL_CHARS_BACKREF: qr, REPLACEMENTS: Gr} = $r;

const Ur = (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 => jr.escapeRegex(t))).join("..");
    }
    return r;
};

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

const Kr = (t, e) => {
    if (typeof t !== "string") {
        throw new TypeError("Expected a string");
    }
    t = Gr[t] || t;
    const r = {
        ...e
    };
    const n = typeof r.maxLength === "number" ? Math.min(Ir, r.maxLength) : Ir;
    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 = jr.isWindows(e);
    const c = $r.globChars(u);
    const l = $r.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: E, START_ANCHOR: A} = c;
    const b = t => `(${a}(?:(?!${A}${t.dot ? _ : f}).)*?)`;
    const R = r.dot ? "" : g;
    const P = r.dot ? m : S;
    let x = r.bash === true ? b(r) : E;
    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 = jr.removePrefix(t, C);
    s = t.length;
    const w = [];
    const T = [];
    const O = [];
    let k = i;
    let L;
    const H = () => C.index === s - 1;
    const D = C.peek = (e = 1) => t[C.index + e];
    const F = C.advance = () => t[++C.index] || "";
    const M = () => t.slice(C.index + 1);
    const $ = (t = "", e = 0) => {
        C.consumed += t;
        C.index += e;
    };
    const j = t => {
        C.output += t.output != null ? t.output : t.value;
        $(t.value);
    };
    const I = () => {
        let t = 1;
        while (D() === "!" && (D(2) !== "(" || D(3) === "?")) {
            F();
            C.start++;
            t++;
        }
        if (t % 2 === 0) {
            return false;
        }
        C.negated = true;
        C.start++;
        return true;
    };
    const N = t => {
        C[t]++;
        O.push(t);
    };
    const B = t => {
        C[t]--;
        O.pop();
    };
    const q = t => {
        if (k.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, -k.output.length);
                k.type = "star";
                k.value = "*";
                k.output = x;
                C.output += k.output;
            }