rsbuild-plugin-arethetypeswrong 0.1.1 → 0.3.0

package/dist/@arethetypeswrong/core.js

@@ -0,0 +1,3412 @@
+/*! LICENSE: core.js.LICENSE.txt */
+import typescript from "typescript";
+import { createRequire } from "module";
+import { __webpack_require__ } from "../453.js";
+import { getResolutionOption, getResolutionKinds, visitResolutions, allBuildTools, resolvedThroughFallback } from "../utils.js";
+__webpack_require__.add({
+    "./node_modules/.pnpm/@andrewbranch+untar.js@1.0.3/node_modules/@andrewbranch/untar.js/lib/bytestream.js" (module) {
+        const ByteStream = function(ab, opt_offset, opt_length) {
+            var offset = opt_offset || 0;
+            var length = opt_length || ab.byteLength;
+            this.bytes = new Uint8Array(ab, offset, length);
+            this.ptr = 0;
+        };
+        ByteStream.prototype.peekNumber = function(n) {
+            if (n <= 0 || "number" != typeof n) return -1;
+            var result = 0;
+            var curByte = this.ptr + n - 1;
+            while(curByte >= this.ptr){
+                result <<= 8;
+                result |= this.bytes[curByte];
+                --curByte;
+            }
+            return result;
+        };
+        ByteStream.prototype.readNumber = function(n) {
+            var num = this.peekNumber(n);
+            this.ptr += n;
+            return num;
+        };
+        ByteStream.prototype.peekSignedNumber = function(n) {
+            var num = this.peekNumber(n);
+            var HALF = Math.pow(2, 8 * n - 1);
+            var FULL = 2 * HALF;
+            if (num >= HALF) num -= FULL;
+            return num;
+        };
+        ByteStream.prototype.readSignedNumber = function(n) {
+            var num = this.peekSignedNumber(n);
+            this.ptr += n;
+            return num;
+        };
+        ByteStream.prototype.peekBytes = function(n, movePointers) {
+            if (n <= 0 || "number" != typeof n) return null;
+            var result = this.bytes.subarray(this.ptr, this.ptr + n);
+            if (movePointers) this.ptr += n;
+            return result;
+        };
+        ByteStream.prototype.readBytes = function(n) {
+            return this.peekBytes(n, true);
+        };
+        ByteStream.prototype.peekString = function(n) {
+            if (n <= 0 || "number" != typeof n) return "";
+            var result = "";
+            for(var p = this.ptr, end = this.ptr + n; p < end; ++p)result += String.fromCharCode(this.bytes[p]);
+            return result;
+        };
+        ByteStream.prototype.readString = function(n) {
+            var strToReturn = this.peekString(n);
+            this.ptr += n;
+            return strToReturn;
+        };
+        module.exports = ByteStream;
+    },
+    "./node_modules/.pnpm/@andrewbranch+untar.js@1.0.3/node_modules/@andrewbranch/untar.js/lib/untar.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const ByteStream = __webpack_require__("./node_modules/.pnpm/@andrewbranch+untar.js@1.0.3/node_modules/@andrewbranch/untar.js/lib/bytestream.js");
+        const readCleanString = function(bstr, numBytes) {
+            const str = bstr.readString(numBytes);
+            const zIndex = str.indexOf(String.fromCharCode(0));
+            return -1 != zIndex ? str.substring(0, zIndex) : str;
+        };
+        function TarLocalFile(bstream) {
+            this.isValid = false;
+            this.name = readCleanString(bstream, 100);
+            this.mode = readCleanString(bstream, 8);
+            this.uid = readCleanString(bstream, 8);
+            this.gid = readCleanString(bstream, 8);
+            this.size = parseInt(readCleanString(bstream, 12), 8);
+            this.mtime = readCleanString(bstream, 12);
+            this.chksum = readCleanString(bstream, 8);
+            this.typeflag = readCleanString(bstream, 1);
+            this.linkname = readCleanString(bstream, 100);
+            this.maybeMagic = readCleanString(bstream, 6);
+            if ("ustar" == this.maybeMagic) {
+                this.version = readCleanString(bstream, 2);
+                this.uname = readCleanString(bstream, 32);
+                this.gname = readCleanString(bstream, 32);
+                this.devmajor = readCleanString(bstream, 8);
+                this.devminor = readCleanString(bstream, 8);
+                this.prefix = readCleanString(bstream, 155);
+                if (this.prefix.length) this.name = this.prefix + "/" + this.name;
+                bstream.readBytes(12);
+            } else bstream.readBytes(249);
+            this.filename = this.name;
+            this.fileData = null;
+            if (0 === +this.typeflag) {
+                this.fileData = new Uint8Array(bstream.bytes.buffer, bstream.ptr, this.size);
+                if (this.name.length > 0 && this.fileData && this.fileData.buffer) this.isValid = true;
+            }
+            bstream.ptr += this.size;
+            const remaining = 512 - bstream.ptr % 512;
+            if (remaining > 0 && remaining < 512) bstream.readBytes(remaining);
+        }
+        module.exports.P = function(arrayBuffer) {
+            const bstream = new ByteStream(arrayBuffer);
+            const localFiles = [];
+            while(0 != bstream.peekNumber(4)){
+                const oneLocalFile = new TarLocalFile(bstream);
+                if (oneLocalFile && oneLocalFile.isValid) localFiles.push(oneLocalFile);
+            }
+            return localFiles;
+        };
+    }
+});
+let lexer_A;
+const lexer_Q = 1 === new Uint8Array(new Uint16Array([
+    1
+]).buffer)[0];
+function parse(g, I = "@") {
+    if (!lexer_A) throw new Error("Not initialized");
+    const D = g.length + 1, N = (lexer_A.__heap_base.value || lexer_A.__heap_base) + 4 * D - lexer_A.memory.buffer.byteLength;
+    N > 0 && lexer_A.memory.grow(Math.ceil(N / 65536));
+    const k = lexer_A.sa(D);
+    (lexer_Q ? C : lexer_E)(g, new Uint16Array(lexer_A.memory.buffer, k, D));
+    const w = lexer_A.parseCJS(k, g.length, 0, 0, 0);
+    if (w) {
+        const Q = new Error(`Parse error ${I}${lexer_A.e()}:${g.slice(0, lexer_A.e()).split("\n").length}:${lexer_A.e() - g.lastIndexOf("\n", lexer_A.e() - 1)}`);
+        throw Object.assign(Q, {
+            idx: lexer_A.e()
+        }), 5 !== w && 6 !== w && 7 !== w || Object.assign(Q, {
+            code: "ERR_LEXER_ESM_SYNTAX"
+        }), Q;
+    }
+    let H = new Set, J = new Set, o = new Set;
+    for(; lexer_A.rre();){
+        const Q = lexer_B(g.slice(lexer_A.res(), lexer_A.ree()));
+        Q && J.add(Q);
+    }
+    for(; lexer_A.ru();)o.add(lexer_B(g.slice(lexer_A.us(), lexer_A.ue())));
+    for(; lexer_A.re();){
+        let Q = lexer_B(g.slice(lexer_A.es(), lexer_A.ee()));
+        void 0 === Q || o.has(Q) || H.add(Q);
+    }
+    return {
+        exports: [
+            ...H
+        ],
+        reexports: [
+            ...J
+        ]
+    };
+}
+function lexer_B(A) {
+    if ('"' !== A[0] && "'" !== A[0]) return A;
+    try {
+        const Q = (0, eval)(A);
+        for(let A = 0; A < Q.length; A++){
+            const B = 64512 & Q.charCodeAt(A);
+            if (!(B < 55296)) {
+                if (55296 !== B) return;
+                if (56320 != (64512 & Q.charCodeAt(++A))) return;
+            }
+        }
+        return Q;
+    } catch  {}
+}
+function lexer_E(A, Q) {
+    const B = A.length;
+    let E = 0;
+    for(; E < B;){
+        const B = A.charCodeAt(E);
+        Q[E++] = (255 & B) << 8 | B >>> 8;
+    }
+}
+function C(A, Q) {
+    const B = A.length;
+    let E = 0;
+    for(; E < B;)Q[E] = A.charCodeAt(E++);
+}
+function lexer_g() {
+    const A = "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";
+    return "u" > typeof Buffer ? Buffer.from(A, "base64") : Uint8Array.from(atob(A), (A)=>A.charCodeAt(0));
+}
+let lexer_I;
+function lexer_init() {
+    return lexer_I || (lexer_I = (async ()=>{
+        const Q = await WebAssembly.compile(lexer_g()), { exports: B } = await WebAssembly.instantiate(Q);
+        lexer_A = B;
+    })());
+}
+function defineCheck(options) {
+    return options;
+}
+const cjsOnlyExportsDefault = defineCheck({
+    name: "CJSOnlyExportsDefault",
+    dependencies: ({ entrypoints, subpath, resolutionKind })=>{
+        var _a;
+        const entrypoint = entrypoints[subpath].resolutions[resolutionKind];
+        const implementationFileName = null == (_a = entrypoint.implementationResolution) ? void 0 : _a.fileName;
+        return [
+            implementationFileName,
+            resolutionKind
+        ];
+    },
+    execute: ([implementationFileName, resolutionKind], context)=>{
+        var _a, _b, _c;
+        if (!implementationFileName) return;
+        if ("node10" === resolutionKind || "node16-cjs" === resolutionKind) return;
+        const host = null != (_a = context.hosts.findHostForFiles([
+            implementationFileName
+        ])) ? _a : context.hosts.bundler;
+        const sourceFile = host.getSourceFile(implementationFileName);
+        if (!sourceFile.externalModuleIndicator && sourceFile.commonJsModuleIndicator && (null == (_c = null == (_b = sourceFile.symbol) ? void 0 : _b.exports) ? void 0 : _c.has(typescript.InternalSymbolName.Default)) && sourceFile.symbol.exports.has(typescript.escapeLeadingUnderscores("__esModule")) && !sourceFile.symbol.exports.has(typescript.InternalSymbolName.ExportEquals)) {
+            const decl = sourceFile.symbol.exports.get(typescript.InternalSymbolName.Default).declarations[0];
+            return {
+                kind: "CJSOnlyExportsDefault",
+                fileName: implementationFileName,
+                pos: decl.getStart(sourceFile),
+                end: decl.end
+            };
+        }
+    }
+});
+var esm_require = createRequire('/');
+try {
+    esm_require('worker_threads').Worker;
+} catch (e) {}
+var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+var fleb = new u8([
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    2,
+    2,
+    3,
+    3,
+    3,
+    3,
+    4,
+    4,
+    4,
+    4,
+    5,
+    5,
+    5,
+    5,
+    0,
+    0,
+    0,
+    0
+]);
+var fdeb = new u8([
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    2,
+    2,
+    3,
+    3,
+    4,
+    4,
+    5,
+    5,
+    6,
+    6,
+    7,
+    7,
+    8,
+    8,
+    9,
+    9,
+    10,
+    10,
+    11,
+    11,
+    12,
+    12,
+    13,
+    13,
+    0,
+    0
+]);
+var clim = new u8([
+    16,
+    17,
+    18,
+    0,
+    8,
+    7,
+    9,
+    6,
+    10,
+    5,
+    11,
+    4,
+    12,
+    3,
+    13,
+    2,
+    14,
+    1,
+    15
+]);
+var freb = function(eb, start) {
+    var b = new u16(31);
+    for(var i = 0; i < 31; ++i)b[i] = start += 1 << eb[i - 1];
+    var r = new i32(b[30]);
+    for(var i = 1; i < 30; ++i)for(var j = b[i]; j < b[i + 1]; ++j)r[j] = j - b[i] << 5 | i;
+    return {
+        b: b,
+        r: r
+    };
+};
+var esm_a = freb(fleb, 2), esm_fl = esm_a.b, revfl = esm_a.r;
+esm_fl[28] = 258, revfl[258] = 28;
+var esm_b = freb(fdeb, 0), fd = esm_b.b;
+esm_b.r;
+var rev = new u16(32768);
+for(var esm_i = 0; esm_i < 32768; ++esm_i){
+    var x = (0xAAAA & esm_i) >> 1 | (0x5555 & esm_i) << 1;
+    x = (0xCCCC & x) >> 2 | (0x3333 & x) << 2;
+    x = (0xF0F0 & x) >> 4 | (0x0F0F & x) << 4;
+    rev[esm_i] = ((0xFF00 & x) >> 8 | (0x00FF & x) << 8) >> 1;
+}
+var hMap = function(cd, mb, r) {
+    var s = cd.length;
+    var i = 0;
+    var l = new u16(mb);
+    for(; i < s; ++i)if (cd[i]) ++l[cd[i] - 1];
+    var le = new u16(mb);
+    for(i = 1; i < mb; ++i)le[i] = le[i - 1] + l[i - 1] << 1;
+    var co;
+    if (r) {
+        co = new u16(1 << mb);
+        var rvb = 15 - mb;
+        for(i = 0; i < s; ++i)if (cd[i]) {
+            var sv = i << 4 | cd[i];
+            var r_1 = mb - cd[i];
+            var v = le[cd[i] - 1]++ << r_1;
+            for(var m = v | (1 << r_1) - 1; v <= m; ++v)co[rev[v] >> rvb] = sv;
+        }
+    } else {
+        co = new u16(s);
+        for(i = 0; i < s; ++i)if (cd[i]) co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+    }
+    return co;
+};
+var flt = new u8(288);
+for(var esm_i = 0; esm_i < 144; ++esm_i)flt[esm_i] = 8;
+for(var esm_i = 144; esm_i < 256; ++esm_i)flt[esm_i] = 9;
+for(var esm_i = 256; esm_i < 280; ++esm_i)flt[esm_i] = 7;
+for(var esm_i = 280; esm_i < 288; ++esm_i)flt[esm_i] = 8;
+var fdt = new u8(32);
+for(var esm_i = 0; esm_i < 32; ++esm_i)fdt[esm_i] = 5;
+var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+var esm_max = function(a) {
+    var m = a[0];
+    for(var i = 1; i < a.length; ++i)if (a[i] > m) m = a[i];
+    return m;
+};
+var bits = function(d, p, m) {
+    var o = p / 8 | 0;
+    return (d[o] | d[o + 1] << 8) >> (7 & p) & m;
+};
+var bits16 = function(d, p) {
+    var o = p / 8 | 0;
+    return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (7 & p);
+};
+var shft = function(p) {
+    return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+    if (null == s || s < 0) s = 0;
+    if (null == e || e > v.length) e = v.length;
+    return new u8(v.subarray(s, e));
+};
+var ec = [
+    'unexpected EOF',
+    'invalid block type',
+    'invalid length/literal',
+    'invalid distance',
+    'stream finished',
+    'no stream handler',
+    ,
+    'no callback',
+    'invalid UTF-8 data',
+    'extra field too long',
+    'date not in range 1980-2099',
+    'filename too long',
+    'stream finishing',
+    'invalid zip data'
+];
+var esm_err = function(ind, msg, nt) {
+    var e = new Error(msg || ec[ind]);
+    e.code = ind;
+    if (Error.captureStackTrace) Error.captureStackTrace(e, esm_err);
+    if (!nt) throw e;
+    return e;
+};
+var inflt = function(dat, st, buf, dict) {
+    var sl = dat.length, dl = dict ? dict.length : 0;
+    if (!sl || st.f && !st.l) return buf || new u8(0);
+    var noBuf = !buf;
+    var resize = noBuf || 2 != st.i;
+    var noSt = st.i;
+    if (noBuf) buf = new u8(3 * sl);
+    var cbuf = function(l) {
+        var bl = buf.length;
+        if (l > bl) {
+            var nbuf = new u8(Math.max(2 * bl, l));
+            nbuf.set(buf);
+            buf = nbuf;
+        }
+    };
+    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+    var tbts = 8 * sl;
+    do {
+        if (!lm) {
+            final = bits(dat, pos, 1);
+            var type = bits(dat, pos + 1, 3);
+            pos += 3;
+            if (type) if (1 == type) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+            else if (2 == type) {
+                var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                var tl = hLit + bits(dat, pos + 5, 31) + 1;
+                pos += 14;
+                var ldt = new u8(tl);
+                var clt = new u8(19);
+                for(var i = 0; i < hcLen; ++i)clt[clim[i]] = bits(dat, pos + 3 * i, 7);
+                pos += 3 * hcLen;
+                var clb = esm_max(clt), clbmsk = (1 << clb) - 1;
+                var clm = hMap(clt, clb, 1);
+                for(var i = 0; i < tl;){
+                    var r = clm[bits(dat, pos, clbmsk)];
+                    pos += 15 & r;
+                    var s = r >> 4;
+                    if (s < 16) ldt[i++] = s;
+                    else {
+                        var c = 0, n = 0;
+                        if (16 == s) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                        else if (17 == s) n = 3 + bits(dat, pos, 7), pos += 3;
+                        else if (18 == s) n = 11 + bits(dat, pos, 127), pos += 7;
+                        while(n--)ldt[i++] = c;
+                    }
+                }
+                var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                lbt = esm_max(lt);
+                dbt = esm_max(dt);
+                lm = hMap(lt, lbt, 1);
+                dm = hMap(dt, dbt, 1);
+            } else esm_err(1);
+            else {
+                var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+                if (t > sl) {
+                    if (noSt) esm_err(0);
+                    break;
+                }
+                if (resize) cbuf(bt + l);
+                buf.set(dat.subarray(s, t), bt);
+                st.b = bt += l, st.p = pos = 8 * t, st.f = final;
+                continue;
+            }
+            if (pos > tbts) {
+                if (noSt) esm_err(0);
+                break;
+            }
+        }
+        if (resize) cbuf(bt + 131072);
+        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        var lpos = pos;
+        for(;; lpos = pos){
+            var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+            pos += 15 & c;
+            if (pos > tbts) {
+                if (noSt) esm_err(0);
+                break;
+            }
+            if (!c) esm_err(2);
+            if (sym < 256) buf[bt++] = sym;
+            else if (256 == sym) {
+                lpos = pos, lm = null;
+                break;
+            } else {
+                var add = sym - 254;
+                if (sym > 264) {
+                    var i = sym - 257, b = fleb[i];
+                    add = bits(dat, pos, (1 << b) - 1) + esm_fl[i];
+                    pos += b;
+                }
+                var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+                if (!d) esm_err(3);
+                pos += 15 & d;
+                var dt = fd[dsym];
+                if (dsym > 3) {
+                    var b = fdeb[dsym];
+                    dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+                }
+                if (pos > tbts) {
+                    if (noSt) esm_err(0);
+                    break;
+                }
+                if (resize) cbuf(bt + 131072);
+                var end = bt + add;
+                if (bt < dt) {
+                    var shift = dl - dt, dend = Math.min(dt, end);
+                    if (shift + bt < 0) esm_err(3);
+                    for(; bt < dend; ++bt)buf[bt] = dict[shift + bt];
+                }
+                for(; bt < end; ++bt)buf[bt] = buf[bt - dt];
+            }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+    }while (!final);
+    return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /*#__PURE__*/ new u8(0);
+var gzs = function(d) {
+    if (31 != d[0] || 139 != d[1] || 8 != d[2]) esm_err(6, 'invalid gzip data');
+    var flg = d[3];
+    var st = 10;
+    if (4 & flg) st += (d[10] | d[11] << 8) + 2;
+    for(var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]);
+    return st + (2 & flg);
+};
+var esm_Inflate = /*#__PURE__*/ function() {
+    function Inflate(opts, cb) {
+        if ('function' == typeof opts) cb = opts, opts = {};
+        this.ondata = cb;
+        var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+        this.s = {
+            i: 0,
+            b: dict ? dict.length : 0
+        };
+        this.o = new u8(32768);
+        this.p = new u8(0);
+        if (dict) this.o.set(dict);
+    }
+    Inflate.prototype.e = function(c) {
+        if (!this.ondata) esm_err(5);
+        if (this.d) esm_err(4);
+        if (this.p.length) {
+            if (c.length) {
+                var n = new u8(this.p.length + c.length);
+                n.set(this.p), n.set(c, this.p.length), this.p = n;
+            }
+        } else this.p = c;
+    };
+    Inflate.prototype.c = function(final) {
+        this.s.i = +(this.d = final || false);
+        var bts = this.s.b;
+        var dt = inflt(this.p, this.s, this.o);
+        this.ondata(slc(dt, bts, this.s.b), this.d);
+        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+        this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+    };
+    Inflate.prototype.push = function(chunk, final) {
+        this.e(chunk), this.c(final);
+    };
+    return Inflate;
+}();
+var esm_Gunzip = /*#__PURE__*/ function() {
+    function Gunzip(opts, cb) {
+        this.v = 1;
+        this.r = 0;
+        esm_Inflate.call(this, opts, cb);
+    }
+    Gunzip.prototype.push = function(chunk, final) {
+        esm_Inflate.prototype.e.call(this, chunk);
+        this.r += chunk.length;
+        if (this.v) {
+            var p = this.p.subarray(this.v - 1);
+            var s = p.length > 3 ? gzs(p) : 4;
+            if (s > p.length) {
+                if (!final) return;
+            } else if (this.v > 1 && this.onmember) this.onmember(this.r - p.length);
+            this.p = p.subarray(s), this.v = 0;
+        }
+        esm_Inflate.prototype.c.call(this, final);
+        if (this.s.f && !this.s.l && !final) {
+            this.v = shft(this.s.p) + 9;
+            this.s = {
+                i: 0
+            };
+            this.o = new u8(0);
+            this.push(new u8(0), final);
+        }
+    };
+    return Gunzip;
+}();
+var esm_td = "u" > typeof TextDecoder && /*#__PURE__*/ new TextDecoder();
+try {
+    esm_td.decode(et, {
+        stream: true
+    });
+} catch (e) {}
+'function' == typeof queueMicrotask ? queueMicrotask : 'function' == typeof setTimeout && setTimeout;
+__webpack_require__("./node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js");
+const untar = __webpack_require__("./node_modules/.pnpm/@andrewbranch+untar.js@1.0.3/node_modules/@andrewbranch/untar.js/lib/untar.js");
+var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+    if ("m" === kind) throw new TypeError("Private method is not writable");
+    if ("a" === kind && !f) throw new TypeError("Private accessor was defined without a setter");
+    if ("function" == typeof state ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return "a" === kind ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+    if ("a" === kind && !f) throw new TypeError("Private accessor was defined without a getter");
+    if ("function" == typeof state ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return "m" === kind ? f : "a" === kind ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Package_files;
+class Package {
+    constructor(files, packageName, packageVersion, resolvedUrl, typesPackage){
+        _Package_files.set(this, {});
+        __classPrivateFieldSet(this, _Package_files, files, "f");
+        this.packageName = packageName;
+        this.packageVersion = packageVersion;
+        this.resolvedUrl = resolvedUrl;
+        this.typesPackage = typesPackage;
+    }
+    tryReadFile(path) {
+        const file = __classPrivateFieldGet(this, _Package_files, "f")[path];
+        if (void 0 === file) return;
+        if ("string" == typeof file) return file;
+        const content = new TextDecoder().decode(file);
+        __classPrivateFieldGet(this, _Package_files, "f")[path] = content;
+        return content;
+    }
+    readFile(path) {
+        const content = this.tryReadFile(path);
+        if (void 0 === content) throw new Error(`File not found: ${path}`);
+        return content;
+    }
+    fileExists(path) {
+        return path in __classPrivateFieldGet(this, _Package_files, "f");
+    }
+    directoryExists(path) {
+        path = typescript.ensureTrailingDirectorySeparator(path);
+        for(const file in __classPrivateFieldGet(this, _Package_files, "f"))if (file.startsWith(path)) return true;
+        return false;
+    }
+    containsTypes(directory = "/") {
+        return this.listFiles(directory).some(typescript.hasTSFileExtension);
+    }
+    listFiles(directory = "/") {
+        directory = typescript.ensureTrailingDirectorySeparator(directory);
+        return "/" === directory ? Object.keys(__classPrivateFieldGet(this, _Package_files, "f")) : Object.keys(__classPrivateFieldGet(this, _Package_files, "f")).filter((f)=>f.startsWith(directory));
+    }
+    mergedWithTypes(typesPackage) {
+        const files = {
+            ...__classPrivateFieldGet(this, _Package_files, "f"),
+            ...__classPrivateFieldGet(typesPackage, _Package_files, "f")
+        };
+        return new Package(files, this.packageName, this.packageVersion, this.resolvedUrl, {
+            packageName: typesPackage.packageName,
+            packageVersion: typesPackage.packageVersion,
+            resolvedUrl: typesPackage.resolvedUrl
+        });
+    }
+}
+_Package_files = new WeakMap();
+function createPackageFromTarballData(tarball) {
+    const { files, packageName, packageVersion } = extractTarball(tarball);
+    return new Package(files, packageName, packageVersion);
+}
+function extractTarball(tarball) {
+    var _a;
+    let unzipped;
+    new esm_Gunzip((chunk)=>unzipped = chunk).push(tarball, true);
+    const data = (0, untar.P)(unzipped);
+    const prefix = data[0].filename.substring(0, data[0].filename.indexOf("/") + 1);
+    const packageJsonText = null == (_a = data.find((f)=>f.filename === `${prefix}package.json`)) ? void 0 : _a.fileData;
+    const packageJson = JSON.parse(new TextDecoder().decode(packageJsonText));
+    const packageName = packageJson.name;
+    const packageVersion = packageJson.version;
+    const files = data.reduce((acc, file)=>{
+        acc[typescript.combinePaths("/node_modules/" + packageName, file.filename.substring(prefix.length))] = file.fileData;
+        return acc;
+    }, {});
+    return {
+        files,
+        packageName,
+        packageVersion
+    };
+}
+function* extractDestructedNames(node) {
+    switch(node.kind){
+        case typescript.SyntaxKind.ArrayBindingPattern:
+            for (const element of node.elements)if (element.kind === typescript.SyntaxKind.BindingElement) yield* extractDestructedNames(element.name);
+            break;
+        case typescript.SyntaxKind.Identifier:
+            yield node.text;
+            break;
+        case typescript.SyntaxKind.ObjectBindingPattern:
+            for (const element of node.elements)yield* extractDestructedNames(element.name);
+            break;
+        default:
+    }
+}
+function getEsmModuleBindings(sourceText) {
+    const options = {
+        languageVersion: typescript.ScriptTarget.ESNext,
+        impliedNodeFormat: typescript.ModuleKind.ESNext
+    };
+    const sourceFile = typescript.createSourceFile("module.cjs", sourceText, options, false, typescript.ScriptKind.JS);
+    const exports = [];
+    const reexports = [];
+    for (const statement of sourceFile.statements)switch(statement.kind){
+        case typescript.SyntaxKind.ExportDeclaration:
+            {
+                const declaration = statement;
+                const { exportClause } = declaration;
+                if (!declaration.isTypeOnly) {
+                    if (exportClause) if (exportClause.kind === typescript.SyntaxKind.NamedExports) {
+                        for (const element of exportClause.elements)if (!element.isTypeOnly) exports.push(element.name.text);
+                    } else exports.push(exportClause.name.text);
+                    else if (declaration.moduleSpecifier && typescript.isStringLiteral(declaration.moduleSpecifier)) reexports.push(declaration.moduleSpecifier.text);
+                }
+                break;
+            }
+        case typescript.SyntaxKind.ExportAssignment:
+            {
+                const assignment = statement;
+                if (!assignment.isExportEquals) exports.push("default");
+                break;
+            }
+        case typescript.SyntaxKind.ClassDeclaration:
+        case typescript.SyntaxKind.FunctionDeclaration:
+            {
+                const declaration = statement;
+                if (typescript.hasSyntacticModifier(declaration, typescript.ModifierFlags.Export)) {
+                    if (typescript.hasSyntacticModifier(declaration, typescript.ModifierFlags.Default)) exports.push("default");
+                    else if (declaration.name) exports.push(declaration.name.text);
+                }
+                break;
+            }
+        case typescript.SyntaxKind.VariableStatement:
+            {
+                const declaration = statement;
+                if (typescript.hasSyntacticModifier(declaration, typescript.ModifierFlags.Export)) for (const declarator of declaration.declarationList.declarations)exports.push(...extractDestructedNames(declarator.name));
+                break;
+            }
+    }
+    return {
+        exports,
+        reexports
+    };
+}
+function getCjsModuleBindings(sourceText) {
+    return parse(sourceText);
+}
+const Pull = Symbol.for("Task.Pull");
+function acquire(value) {
+    let initial = value;
+    return ()=>{
+        if (initial === Never) throw new Error("Value was acquired more than once");
+        const result = initial;
+        initial = Never;
+        return result;
+    };
+}
+const Never = Symbol("Never");
+function pull(pullable, signal, channel) {
+    if (signal.aborted) return void channel.halt(signal.reason);
+    if (null !== pullable && "object" == typeof pullable) {
+        if (Pull in pullable) return void pullable[Pull](signal, channel);
+        else if ("function" == typeof pullable.then) {
+            const forwardAbort = ()=>{
+                send = ()=>{};
+                channel.halt(signal.reason);
+            };
+            signal.addEventListener("abort", forwardAbort);
+            let send = (receive)=>{
+                signal.removeEventListener("abort", forwardAbort);
+                receive(channel);
+            };
+            pullable.then((value)=>send((channel)=>channel.resolve(value)), (error)=>send((channel)=>channel.reject(error)));
+            return;
+        }
+    } else if (void 0 === pullable) return void channel.resolve(void 0);
+    channel.reject(new Error("Yielded value is not pullable"));
+}
+class HaltHolder {
+    reason;
+    constructor(reason){
+        this.reason = reason;
+    }
+}
+function resolveMaybeHalt(channel, value) {
+    if (value instanceof HaltHolder) channel.halt(value.reason);
+    else channel.resolve(value);
+}
+function driver(signal, channel, task) {
+    if (signal.aborted) {
+        try {
+            if (!task.next().done) task.return(void 0);
+            channel.halt(signal.reason);
+        } catch (error) {
+            channel.reject(error);
+        }
+        return;
+    }
+    const abortController = new AbortController();
+    const forwardAbort = ()=>{
+        abortController.abort(signal.reason);
+    };
+    signal.addEventListener("abort", forwardAbort);
+    const cleanup = ()=>{
+        signal.removeEventListener("abort", forwardAbort);
+        abortController.abort("Terminated");
+    };
+    const resumeDriver = (operation)=>{
+        try {
+            let next = operation;
+            let step = (operation)=>{
+                next = operation;
+            };
+            const stepChannel = {
+                resolve: (value)=>step(()=>task.next(value)),
+                reject: (reason)=>step(()=>task.throw(reason)),
+                halt: (reason)=>step(()=>task.return(new HaltHolder(reason)))
+            };
+            do {
+                const result = next();
+                next = null;
+                if (result.done) {
+                    cleanup();
+                    resolveMaybeHalt(channel, result.value);
+                    return;
+                }
+                pull(result.value, abortController.signal, stepChannel);
+            }while (next);
+            step = resumeDriver;
+        } catch (error) {
+            cleanup();
+            channel.reject(error);
+        }
+    };
+    resumeDriver(()=>task.next());
+}
+class Future {
+    replay = null;
+    pending = [];
+    constructor(executor){
+        const settle = (replay)=>{
+            this.replay = replay;
+            for (const channel of this.pending.splice(0))replay(channel);
+        };
+        executor((value)=>settle((channel)=>channel.resolve(value)), (error)=>settle((channel)=>channel.reject(error)), (reason)=>settle((channel)=>channel.halt(reason)));
+    }
+    static resolve(value) {
+        return new Future((resolve)=>resolve(value));
+    }
+    static reject(reason) {
+        return new Future((resolve, reject)=>reject(reason));
+    }
+    static halt(reason) {
+        return new Future((resolve, reject, halt)=>halt(reason));
+    }
+    [Pull](signal, channel) {
+        if (null === this.replay) this.pending.push(channel);
+        else this.replay(channel);
+    }
+    continue(halted) {
+        return new Promise((resolve, reject)=>{
+            this[Pull](null, {
+                resolve,
+                reject,
+                halt (reason) {
+                    try {
+                        resolve(halted?.(reason));
+                    } catch (error) {
+                        reject(error);
+                    }
+                }
+            });
+        });
+    }
+    then(resolved, rejected) {
+        const promise = new Promise((resolve, reject)=>{
+            this[Pull](null, {
+                resolve,
+                reject,
+                halt (reason) {
+                    reject(new Error(`Future was halted with reason: ${reason}`));
+                }
+            });
+        });
+        return promise.then(resolved, rejected);
+    }
+}
+function begin(task, { signal } = {}) {
+    return pullAsFuture(task, signal);
+}
+function task_task(body, { signal } = {}) {
+    let future;
+    const holder = acquire(body());
+    const pullable = {
+        [Pull] (pullSignal, channel) {
+            const combinedSignal = function() {
+                if (!signal) return pullSignal;
+                if (signal.aborted) return signal;
+                {
+                    const controller = new AbortController();
+                    const cleanup = ()=>{
+                        signal.removeEventListener("abort", handleSignal);
+                        pullSignal.removeEventListener("abort", handlePullSignal);
+                    };
+                    const handleSignal = ()=>{
+                        cleanup();
+                        controller.abort(signal.reason);
+                    };
+                    const handlePullSignal = ()=>{
+                        cleanup();
+                        controller.abort(pullSignal.reason);
+                    };
+                    signal.addEventListener("abort", handleSignal);
+                    pullSignal.addEventListener("abort", handlePullSignal);
+                    return controller.signal;
+                }
+            }();
+            driver(combinedSignal, channel, holder());
+        },
+        then (resolve, reject) {
+            future ??= pullAsFuture(pullable, signal);
+            return future.then(resolve, reject);
+        }
+    };
+    return pullable;
+}
+function pullAsFuture(pullable, signal) {
+    return new Future((resolve, reject, abort)=>pullable[Pull](signal ?? new AbortController().signal, {
+            resolve,
+            reject,
+            halt: abort
+        }));
+}
+function expect(pullable) {
+    const controller = new AbortController();
+    let send = ()=>{
+        const error = new Error("Expected value was not resolved");
+        controller.abort(error);
+        throw error;
+    };
+    pullable[Pull](controller.signal, {
+        resolve (value) {
+            send = ()=>value;
+        },
+        reject (error) {
+            controller.abort(error);
+            send = ()=>{
+                throw error;
+            };
+        },
+        halt (reason) {
+            send = ()=>{
+                throw new Error(`Expected value was halted with reason: ${reason}`);
+            };
+        }
+    });
+    return send();
+}
+function makeFileSystemSyncAdapter(fs) {
+    return {
+        *directoryExists (path) {
+            return fs.directoryExists(path);
+        },
+        *fileExists (path) {
+            return fs.fileExists(path);
+        },
+        *readFileJSON (path) {
+            return fs.readFileJSON(path);
+        },
+        *readLink (path) {
+            return fs.readLink(path);
+        }
+    };
+}
+const nodeCoreModules = [
+    "assert",
+    "assert/strict",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "dns",
+    "dns/promises",
+    "domain",
+    "events",
+    "fs",
+    "fs/promises",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "inspector/promises",
+    "module",
+    "net",
+    "os",
+    "path",
+    "path/posix",
+    "path/win32",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "readline/promises",
+    "repl",
+    "stream",
+    "stream/consumers",
+    "stream/promises",
+    "stream/web",
+    "string_decoder",
+    "sys",
+    "test",
+    "test/reporters",
+    "timers",
+    "timers/promises",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "util/types",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib"
+];
+function resolveSync(fs, specifier, parentURL) {
+    return expect(begin(task_task(()=>resolver(makeFileSystemSyncAdapter(fs), specifier, parentURL))));
+}
+const defaultConditions = [
+    "node",
+    "import"
+];
+function* resolver(fs, specifier, parentURL) {
+    const url = yield* function*() {
+        if (URL.canParse(specifier)) return new URL(specifier);
+        if (/^(\/|\.\.?\/)/.test(specifier)) return yield* resolveFileLinks(fs, new URL(specifier, parentURL));
+        if (specifier.startsWith("#")) {
+            const resolved = yield* packageImportsResolve(fs, specifier, parentURL, defaultConditions);
+            return yield* resolveFileLinks(fs, resolved);
+        }
+        const resolved = yield* packageResolve(fs, specifier, parentURL);
+        if ("node:" === resolved.protocol) return resolved;
+        return yield* resolveFileLinks(fs, resolved);
+    }();
+    const format = yield* function*() {
+        if ("file:" === url.protocol) {
+            if (/%2f|%5c/i.test(url.href)) throw new Error("Invalid Module Specifier");
+            if (yield* fs.directoryExists(url)) throw new Error("Unsupported Directory Import");
+            if (!(yield* fs.fileExists(url))) throw new Error("Module Not Found");
+            return yield* esmFileFormat(fs, url);
+        }
+        if ("node:" === url.protocol) return "builtin";
+    }();
+    return {
+        format,
+        url
+    };
+}
+function* packageResolve(fs, packageSpecifier, parentURL) {
+    if (nodeCoreModules.includes(packageSpecifier)) return new URL(`node:${packageSpecifier}`);
+    const packageName = function() {
+        if ("" === packageSpecifier) throw new Error("Invalid Module Specifier");
+        if (packageSpecifier.startsWith("@")) {
+            let slash = packageSpecifier.indexOf("/");
+            if (-1 === slash) throw new Error("Invalid Module Specifier");
+            slash = packageSpecifier.indexOf("/", slash + 1);
+            return -1 === slash ? packageSpecifier : packageSpecifier.slice(0, slash);
+        }
+        {
+            const slash = packageSpecifier.indexOf("/");
+            return -1 === slash ? packageSpecifier : packageSpecifier.slice(0, slash);
+        }
+    }();
+    if (packageName.startsWith(".") || packageName.includes("\\") || packageName.includes("%")) throw new Error("Invalid Module Specifier");
+    const packageSubpath = `.${packageSpecifier.substring(packageName.length)}`;
+    const selfUrl = yield* packageSelfResolve(fs, packageName, packageSubpath, parentURL);
+    if (void 0 !== selfUrl) return selfUrl;
+    const sentinel = new URL(`/node_modules/${packageName}/`, parentURL);
+    let packageURL;
+    do {
+        packageURL = new URL(`node_modules/${packageName}/`, parentURL);
+        parentURL = new URL("..", parentURL);
+        if (!(yield* fs.directoryExists(packageURL))) continue;
+        const pjson = yield* readPackageJson(fs, packageURL);
+        packageURL = yield* resolveDirectoryLinks(fs, packageURL);
+        if (pjson?.exports != null) return yield* packageExportsResolve(fs, packageURL, packageSubpath, pjson.exports, defaultConditions);
+        if ("." === packageSubpath) {
+            packageURL = yield* resolveDirectoryLinks(fs, packageURL);
+            if ("string" == typeof pjson?.main) {
+                if ("module" !== pjson.type) {
+                    const directoryFragment = pjson.main.endsWith("/") ? pjson.main : `${pjson.main}/`;
+                    if (yield* fs.directoryExists(new URL(directoryFragment, packageURL))) {
+                        const legacyResolution = yield* loadAsDirectory(fs, new URL(directoryFragment, packageURL), defaultExtensions);
+                        if (legacyResolution) return legacyResolution.url;
+                    } else {
+                        const legacyResolution = yield* loadAsFile(fs, pjson.main, packageURL, defaultExtensions);
+                        if (legacyResolution) return legacyResolution.url;
+                    }
+                }
+                return new URL(pjson.main, packageURL);
+            }
+            if (pjson?.type !== "module") {
+                const legacyResolution = yield* loadIndex(fs, ".", packageURL, defaultExtensions);
+                if (legacyResolution) return legacyResolution.url;
+            }
+            return new URL(packageSubpath, packageURL);
+        }
+        if (pjson?.type !== "module") {
+            const legacyResolution = yield* loadAsFile(fs, packageSubpath, packageURL, defaultExtensions);
+            if (legacyResolution) return legacyResolution.url;
+        }
+    }while (packageURL.href !== sentinel.href);
+    throw new Error("Module Not Found");
+}
+function* packageSelfResolve(fs, packageName, packageSubpath, parentURL) {
+    const packageURL = yield* lookupPackageScope(fs, parentURL);
+    if (null === packageURL) return;
+    const pjson = yield* readPackageJson(fs, packageURL);
+    if (pjson?.exports == null) return;
+    if (pjson.name === packageName) return yield* packageExportsResolve(fs, packageURL, packageSubpath, pjson.exports, defaultConditions);
+}
+function* packageExportsResolve(fs, packageURL, subpath, exports, conditions) {
+    const exportsIsObject = "object" == typeof exports && null !== exports;
+    const exportsKeys = exportsIsObject ? Object.keys(exports) : void 0;
+    const hasDotKeys = exportsKeys?.some((key)=>key.startsWith("."));
+    const hasNonDotKeys = exportsKeys?.some((key)=>!key.startsWith("."));
+    if (hasDotKeys && hasNonDotKeys) throw new Error("Invalid Package Configuration");
+    if ("." === subpath) {
+        const mainExport = function() {
+            if ("string" == typeof exports || Array.isArray(exports) || !hasDotKeys) return exports;
+            if (exportsIsObject && "." in exports) return exports["."];
+        }();
+        if (void 0 !== mainExport) {
+            const resolved = yield* packageTargetResolve(fs, packageURL, mainExport, null, false, conditions);
+            if (null != resolved) return resolved;
+        }
+    }
+    if (exportsIsObject && hasDotKeys && !hasNonDotKeys) {
+        const exportRecord = exports;
+        const resolved = yield* packageImportsExportsResolve(fs, subpath, exportRecord, packageURL, false, conditions);
+        if (null != resolved) return resolved;
+    }
+    throw new Error("Package Path Not Exported");
+}
+function* packageImportsResolve(fs, specifier, parentURL, conditions) {
+    if ("#" === specifier || specifier.startsWith("#/")) throw new Error("Invalid Module Specifier");
+    const packageURL = yield* lookupPackageScope(fs, parentURL);
+    if (null !== packageURL) {
+        const pjson = yield* readPackageJson(fs, packageURL);
+        if ("object" == typeof pjson?.imports && null !== pjson.imports) {
+            const imports = pjson.imports;
+            const resolved = yield* packageImportsExportsResolve(fs, specifier, imports, packageURL, true, conditions);
+            if (null != resolved) return resolved;
+        }
+    }
+    throw new Error("Package Import Not Defined");
+}
+function* packageImportsExportsResolve(fs, matchKey, matchObj, packageURL, isImports, conditions) {
+    if (matchKey.endsWith("/")) throw new Error("Invalid Module Specifier");
+    if (matchKey in matchObj && !matchKey.includes("*")) {
+        const target = matchObj[matchKey];
+        return yield* packageTargetResolve(fs, packageURL, target, null, isImports, conditions);
+    }
+    const expansionKeys = Object.keys(matchObj).filter((key)=>{
+        const ii = key.indexOf("*");
+        return -1 !== ii && ii === key.lastIndexOf("*");
+    }).sort(patternKeyCompare);
+    for (const key of expansionKeys){
+        const patternBase = key.substring(0, key.indexOf("*"));
+        if (matchKey.startsWith(patternBase) && matchKey !== patternBase) {
+            const patternTrailer = key.substring(key.indexOf("*") + 1);
+            if (0 === patternTrailer.length || matchKey.endsWith(patternTrailer) && matchKey.length >= key.length) {
+                const target = matchObj[key];
+                const patternMatch = matchKey.substring(patternBase.length, matchKey.length - patternTrailer.length);
+                return yield* packageTargetResolve(fs, packageURL, target, patternMatch, isImports, conditions);
+            }
+        }
+    }
+    return null;
+}
+function patternKeyCompare(keyA, keyB) {
+    const indexOfStarA = keyA.indexOf("*");
+    const baseLengthA = -1 === indexOfStarA ? keyA.length : indexOfStarA + 1;
+    const indexOfStarB = keyB.indexOf("*");
+    const baseLengthB = -1 === indexOfStarB ? keyB.length : indexOfStarB + 1;
+    const baseDifference = baseLengthB - baseLengthA;
+    if (0 !== baseDifference) return baseDifference;
+    if (-1 === indexOfStarA) return 1;
+    if (-1 === baseLengthB) return -1;
+    const difference = keyB.length - keyA.length;
+    if (0 !== difference) return difference;
+    return 0;
+}
+function* packageTargetResolve(fs, packageURL, target, patternMatch, isImports, conditions) {
+    if ("string" == typeof target) {
+        if (!target.startsWith("./")) {
+            if (!isImports || target.startsWith("../") || target.startsWith("/") || URL.canParse(target)) throw new Error("Invalid Package Target");
+            if (null === patternMatch) return yield* packageResolve(fs, target, new URL(`${packageURL.href}/`));
+            return yield* packageResolve(fs, target.replaceAll("*", patternMatch), new URL(`${packageURL.href}/`));
+        }
+        if (target.slice(2).split(/\/|\\/).some((segment)=>"" === segment || "." === segment || ".." === segment || "node_modules" === segment)) throw new Error("Invalid Package Target");
+        const resolvedTarget = new URL(target, packageURL);
+        if (null === patternMatch) return resolvedTarget;
+        if (patternMatch.split(/\/|\\/).some((segment)=>"" === segment || "." === segment || ".." === segment || "node_modules" === segment)) throw new Error("Invalid Module Specifier");
+        return new URL(resolvedTarget.href.replaceAll("*", patternMatch));
+    }
+    if ("object" == typeof target && null !== target) {
+        if (Object.keys(target).some((key)=>/^[0-9]+$/.test(key))) throw new Error("Invalid Package Configuration");
+        for (const [property, targetValue] of Object.entries(target))if ("default" === property || conditions.includes(property)) {
+            const resolved = yield* packageTargetResolve(fs, packageURL, targetValue, patternMatch, isImports, conditions);
+            if (void 0 === resolved) continue;
+            return resolved;
+        }
+        return;
+    }
+    if (Array.isArray(target)) {
+        if (0 === target.length) return null;
+        for (const targetValue of target){
+            const resolved = yield* packageTargetResolve(fs, packageURL, targetValue, patternMatch, isImports, conditions);
+            if (void 0 !== resolved) return resolved;
+        }
+        return null;
+    }
+    if (null === target) return null;
+    throw new Error("Invalid Package Target");
+}
+function* esmFileFormat(fs, url) {
+    if (url.pathname.endsWith(".mjs")) return "module";
+    if (url.pathname.endsWith(".cjs")) return "commonjs";
+    if (url.pathname.endsWith(".json")) return "json";
+    if (url.pathname.endsWith(".wasm")) return "wasm";
+    if (url.pathname.endsWith(".node")) return "addon";
+    const packageURL = yield* lookupPackageScope(fs, url);
+    if (null === packageURL) throw new Error("Invalid Module Specifier");
+    const pjson = yield* readPackageJson(fs, packageURL);
+    const packageType = pjson?.type === "module" || pjson?.type === "commonjs" ? pjson.type : null;
+    if (url.pathname.endsWith(".js")) {
+        if (null !== packageType) {
+            if ("string" != typeof packageType) throw new Error("Invalid Package Configuration");
+            return packageType;
+        }
+        return "commonjs";
+    }
+    const segments = url.pathname.split("/");
+    if (!segments[segments.length - 1].includes(".")) {
+        if (null !== packageType) return packageType;
+        return "commonjs";
+    }
+}
+function* lookupPackageScope(fs, url) {
+    let scopeURL = url;
+    const sentinel = new URL("/package.json", url);
+    while(true){
+        const pjsonURL = new URL("package.json", scopeURL);
+        if (yield* fs.fileExists(pjsonURL)) return new URL(".", scopeURL);
+        if (scopeURL.href === sentinel.href) break;
+        scopeURL = new URL("../package.json", scopeURL);
+        if (scopeURL.pathname.endsWith("/node_modules/package.json")) break;
+    }
+    return null;
+}
+function* readPackageJson(fs, packageURL) {
+    const pjsonURL = new URL("package.json", packageURL);
+    if (!(yield* fs.fileExists(pjsonURL))) return null;
+    const jsonPayload = yield* fs.readFileJSON(pjsonURL);
+    if ("object" == typeof jsonPayload && null !== jsonPayload) return jsonPayload;
+    throw new Error("Invalid Package Configuration");
+}
+function makeDetectCycle() {
+    const seen = new Set();
+    return (url)=>{
+        const { href } = url;
+        if (seen.has(href)) throw new Error("Circular Link");
+        seen.add(href);
+    };
+}
+function* resolveFileLinks(fs, path) {
+    const detectCycle = makeDetectCycle();
+    const read = function*(url) {
+        detectCycle(url);
+        const link = yield* fs.readLink(url);
+        if (void 0 === link) return url;
+        return yield* read(new URL(link, url));
+    };
+    return yield* read(path);
+}
+function* resolveDirectoryLinks(fs, path) {
+    const detectCycle = makeDetectCycle();
+    const read = function*(url) {
+        detectCycle(url);
+        const link = yield* fs.readLink(new URL(url.pathname.slice(0, -1), url));
+        if (void 0 === link) return url;
+        if ("/" === link) return new URL("/", url);
+        if (link.startsWith("/")) return yield* read(new URL(`${link}/`, url));
+        if (link.endsWith("..")) return yield* read(new URL(`../${link}`, url));
+        return yield* read(new URL(`../${link}/`, url));
+    };
+    return yield* read(path);
+}
+const cjs_defaultConditions = [
+    "node",
+    "require"
+];
+const defaultExtensions = [
+    ".js",
+    ".json",
+    ".node"
+];
+function cjs_resolveSync(fs, specifier, parentURL, context) {
+    return expect(begin(task_task(()=>cjs_resolver(makeFileSystemSyncAdapter(fs), specifier, parentURL, context))));
+}
+function* cjs_resolver(fs, fragment, parentURL, context) {
+    const extensions = context?.extensions ?? defaultExtensions;
+    if (fragment.startsWith("node:")) return {
+        format: "builtin",
+        url: new URL(encodeFragment(fragment))
+    };
+    if (nodeCoreModules.includes(fragment)) return {
+        format: "builtin",
+        url: new URL(`node:${encodeFragment(fragment)}`)
+    };
+    if (fragment.startsWith("/")) parentURL = new URL("/", parentURL);
+    if ("." === fragment || fragment.startsWith("./") || fragment.startsWith("/") || fragment.startsWith("../")) {
+        const asFile = yield* loadAsFile(fs, fragment, parentURL, extensions);
+        if (asFile) return asFile;
+        const asDirectory = yield* loadAsDirectory(fs, new URL(`${encodeFragment(fragment)}/`, parentURL), extensions);
+        if (asDirectory) return asDirectory;
+        throw new Error("not found");
+    }
+    const conditions = context?.conditions ?? cjs_defaultConditions;
+    if (fragment.startsWith("#")) {
+        const asPackageImports = yield* loadPackageImports(fs, fragment, new URL(".", parentURL), conditions);
+        if (asPackageImports) return asPackageImports;
+    }
+    const asSelf = yield* loadPackageSelf(fs, fragment, new URL(".", parentURL), conditions);
+    if (asSelf) return asSelf;
+    const asNodeModules = yield* loadNodeModules(fs, fragment, new URL(".", parentURL), context);
+    if (asNodeModules) return asNodeModules;
+    throw new Error("not found");
+}
+function maybeDetectAndLoad(fs, file) {
+    return loadWithFormat(fs, file);
+}
+function* loadAsFile(fs, fragment, parentURL, extensions) {
+    const encodedFragment = encodeFragment(fragment);
+    const asFile = new URL(encodedFragment, parentURL);
+    if (yield* fs.fileExists(asFile)) {
+        const realname = yield* resolveFileLinks(fs, asFile);
+        return yield* loadWithFormat(fs, realname);
+    }
+    for (const extension of extensions){
+        const withExtension = new URL(encodedFragment + extension, parentURL);
+        if (yield* fs.fileExists(withExtension)) {
+            const realname = yield* resolveFileLinks(fs, withExtension);
+            switch(extension){
+                case ".js":
+                    {
+                        const packageURL = yield* lookupPackageScope(fs, parentURL);
+                        if (null === packageURL) return yield* maybeDetectAndLoad(fs, realname);
+                        const pjson = yield* readPackageJson(fs, packageURL);
+                        if (pjson?.type === "module") return {
+                            format: "module",
+                            url: realname
+                        };
+                        if (pjson?.type === "commonjs") return {
+                            format: "commonjs",
+                            url: realname
+                        };
+                        return yield* maybeDetectAndLoad(fs, realname);
+                    }
+                case ".json":
+                    return {
+                        format: "json",
+                        url: realname
+                    };
+                case ".node":
+                    return {
+                        format: "builtin",
+                        url: realname
+                    };
+                default:
+                    return {
+                        format: void 0,
+                        url: realname
+                    };
+            }
+        }
+    }
+}
+function* loadIndex(fs, fragment, parentURL, extensions) {
+    const encodedFragment = encodeFragment(fragment);
+    for (const extension of extensions){
+        const withIndex = new URL(`${encodedFragment}/index${extension}`, parentURL);
+        if (yield* fs.fileExists(withIndex)) {
+            const realname = yield* resolveFileLinks(fs, withIndex);
+            switch(extension){
+                case ".js":
+                    {
+                        const packageURL = yield* lookupPackageScope(fs, parentURL);
+                        if (null === packageURL) return {
+                            format: "commonjs",
+                            url: realname
+                        };
+                        const pjson = yield* readPackageJson(fs, packageURL);
+                        if (pjson?.type === "module") return {
+                            format: "module",
+                            url: realname
+                        };
+                        return {
+                            format: "commonjs",
+                            url: realname
+                        };
+                    }
+                case ".json":
+                    return {
+                        format: "json",
+                        url: realname
+                    };
+                case ".node":
+                    return {
+                        format: "addon",
+                        url: realname
+                    };
+                default:
+                    return {
+                        format: void 0,
+                        url: realname
+                    };
+            }
+        }
+    }
+}
+function* loadAsDirectory(fs, path, extensions) {
+    const pjson = yield* readPackageJson(fs, path);
+    if ("string" == typeof pjson?.main) {
+        const asFile = yield* loadAsFile(fs, pjson.main, path, extensions);
+        if (asFile) return asFile;
+        const asIndex = yield* loadIndex(fs, pjson.main, path, extensions);
+        if (asIndex) return asIndex;
+        const asDeprecatedIndex = yield* loadIndex(fs, ".", path, extensions);
+        if (asDeprecatedIndex) return asDeprecatedIndex;
+        throw new Error("not found");
+    }
+    return yield* loadIndex(fs, ".", path, extensions);
+}
+function* loadWithFormat(fs, url) {
+    const format = yield* esmFileFormat(fs, url);
+    return {
+        format,
+        url
+    };
+}
+function* loadNodeModules(fs, fragment, parentURL, context) {
+    const nameAndSubpath = function() {
+        const matches = /^(?<name>(?:@[^/]+\/)?[^@][^/]*)(?<subpath>.*)$/.exec(fragment);
+        if (null === matches) return;
+        return matches.groups;
+    }();
+    const subpathFragment = nameAndSubpath ? `.${nameAndSubpath.subpath}` : ".";
+    const conditions = context?.conditions ?? cjs_defaultConditions;
+    const extensions = context?.extensions ?? defaultExtensions;
+    for (const dir of nodeModulesPaths(parentURL)){
+        if (!(yield* fs.directoryExists(dir))) continue;
+        const realname = yield* resolveDirectoryLinks(fs, new URL(encodeFragment(`${nameAndSubpath ? nameAndSubpath.name : fragment}/`), dir));
+        if (nameAndSubpath) {
+            const asPackageExports = yield* loadPackageExports(fs, nameAndSubpath.subpath, realname, conditions);
+            if (asPackageExports) return asPackageExports;
+        }
+        const asFile = yield* loadAsFile(fs, subpathFragment, realname, extensions);
+        if (asFile) return asFile;
+        const asDirectory = yield* loadAsDirectory(fs, new URL(`${encodeFragment(subpathFragment)}/`, realname), extensions);
+        if (asDirectory) return asDirectory;
+    }
+}
+function* nodeModulesPaths(path) {
+    const sentinel = new URL("/", path);
+    do {
+        if (!path.pathname.endsWith("/node_modules/")) yield new URL("node_modules/", path);
+        path = new URL("..", path);
+    }while (path.href !== sentinel.href);
+}
+function* loadPackageImports(fs, fragment, parentURL, conditions) {
+    const packageURL = yield* lookupPackageScope(fs, parentURL);
+    if (null === packageURL) return;
+    const pjson = yield* readPackageJson(fs, packageURL);
+    if (pjson?.imports == null) return;
+    const match = yield* packageImportsResolve(fs, fragment, packageURL, conditions);
+    return yield* resolveEsmMatch(fs, match);
+}
+function* loadPackageExports(fs, subpath, parentURL, conditions) {
+    const pjson = yield* readPackageJson(fs, parentURL);
+    if (null === pjson) return;
+    if (null == pjson.exports) return;
+    const match = yield* packageExportsResolve(fs, parentURL, `.${subpath}`, pjson.exports, conditions);
+    return yield* resolveEsmMatch(fs, match);
+}
+function* loadPackageSelf(fs, fragment, parentURL, conditions) {
+    const packageURL = yield* lookupPackageScope(fs, parentURL);
+    if (null === packageURL) return;
+    const pjson = yield* readPackageJson(fs, packageURL);
+    if (pjson?.exports == null) return;
+    if ("string" != typeof pjson.name || fragment !== pjson.name && !fragment.startsWith(`${pjson.name}/`)) return;
+    const match = yield* packageExportsResolve(fs, packageURL, `.${fragment.slice(pjson.name.length)}`, pjson.exports, conditions);
+    return yield* resolveEsmMatch(fs, match);
+}
+function* resolveEsmMatch(fs, match) {
+    if (yield* fs.fileExists(match)) {
+        const realname = yield* resolveFileLinks(fs, match);
+        return yield* loadWithFormat(fs, realname);
+    }
+    throw new Error("not found");
+}
+function encodeFragment(fragment) {
+    const encodeOneCharacter = (char)=>`%${char.charCodeAt(0).toString(16)}`;
+    const encodeOneOrMoreCharacters = (string)=>1 === string.length ? encodeOneCharacter(string) : string.replace(/[^]/g, encodeOneCharacter);
+    return fragment.replace(/^[\x00-\x20%]+|[\r\n\t%]/g, encodeOneOrMoreCharacters);
+}
+function makeFileSystemAdapter(fs) {
+    return {
+        directoryExists: (url)=>fs.directoryExists(url.pathname),
+        fileExists: (url)=>fs.fileExists(url.pathname),
+        readFileJSON: (url)=>JSON.parse(fs.readFile(url.pathname)),
+        readLink: ()=>void 0
+    };
+}
+function cjsResolve(fs, specifier, parentURL) {
+    return cjs_resolveSync(makeFileSystemAdapter(fs), specifier, parentURL);
+}
+function esmResolve(fs, specifier, parentURL) {
+    return resolveSync(makeFileSystemAdapter(fs), specifier, parentURL);
+}
+function getCjsModuleNamespace(fs, file, seen = new Set()) {
+    seen.add(file.pathname);
+    const exports = new Set();
+    const bindings = getCjsModuleBindings(fs.readFile(file.pathname));
+    bindings.exports.forEach((name)=>exports.add(name));
+    if (!exports.has("default")) exports.add("default");
+    for (const source of bindings.reexports.reverse())try {
+        const { format, url } = cjsResolve(fs, source, file);
+        if ("commonjs" === format && !seen.has(url.pathname)) {
+            const reexported = getCjsModuleNamespace(fs, url, seen);
+            reexported.forEach((name)=>exports.add(name));
+        }
+    } catch  {}
+    return exports;
+}
+function getEsmModuleNamespace(fs, specifier, parentURL = new URL("file:///"), seen = new Set()) {
+    const { format, url } = esmResolve(fs, specifier, parentURL);
+    if (seen.has(url.pathname)) return [];
+    seen.add(url.pathname);
+    if ("commonjs" === format) return [
+        ...getCjsModuleNamespace(fs, url)
+    ];
+    const bindings = (null != format ? format : "module") === "module" ? getEsmModuleBindings(fs.readFile(url.pathname)) : {
+        exports: [
+            "default"
+        ],
+        reexports: []
+    };
+    const indirect = bindings.reexports.flatMap((specifier)=>getEsmModuleNamespace(fs, specifier, url, seen)).filter((name)=>"default" !== name);
+    return [
+        ...new Set([
+            ...bindings.exports,
+            ...indirect
+        ])
+    ];
+}
+const namedExports = defineCheck({
+    name: "NamedExports",
+    dependencies: ({ entrypoints, subpath, resolutionKind, programInfo })=>{
+        var _a, _b, _c, _d;
+        const entrypoint = entrypoints[subpath].resolutions[resolutionKind];
+        const typesFileName = (null == (_a = entrypoint.resolution) ? void 0 : _a.isTypeScript) && entrypoint.resolution.fileName;
+        const resolutionOption = getResolutionOption(resolutionKind);
+        const typesModuleKind = typesFileName ? null == (_b = programInfo[resolutionOption].moduleKinds) ? void 0 : _b[typesFileName] : void 0;
+        const implementationFileName = null == (_c = entrypoint.implementationResolution) ? void 0 : _c.fileName;
+        const implementationModuleKind = implementationFileName ? null == (_d = programInfo[resolutionOption].moduleKinds) ? void 0 : _d[implementationFileName] : void 0;
+        return [
+            implementationFileName,
+            implementationModuleKind,
+            typesFileName,
+            typesModuleKind,
+            resolutionKind
+        ];
+    },
+    execute: ([implementationFileName, implementationModuleKind, typesFileName, typesModuleKind, resolutionKind], context)=>{
+        if (!implementationFileName || !typesFileName || "node16-esm" !== resolutionKind || (null == typesModuleKind ? void 0 : typesModuleKind.detectedKind) !== typescript.ModuleKind.CommonJS || (null == implementationModuleKind ? void 0 : implementationModuleKind.detectedKind) !== typescript.ModuleKind.CommonJS) return;
+        const host = context.hosts.findHostForFiles([
+            typesFileName
+        ]);
+        const typesSourceFile = host.getSourceFile(typesFileName);
+        if (typesSourceFile.scriptKind === typescript.ScriptKind.JSON || !typesSourceFile.symbol) return;
+        const typeChecker = host.createAuxiliaryProgram([
+            typesFileName
+        ]).getTypeChecker();
+        const moduleType = typeChecker.getTypeOfSymbol(typeChecker.resolveExternalModuleSymbol(typesSourceFile.symbol));
+        if (typeChecker.isArrayLikeType(moduleType) || typeChecker.getPropertyOfType(moduleType, "0")) return;
+        const expectedNames = Array.from(new Set(typeChecker.getExportsAndPropertiesOfModule(typesSourceFile.symbol).filter((symbol)=>"prototype" !== symbol.name && typeChecker.getSymbolFlags(symbol, true) & typescript.SymbolFlags.Value).map((symbol)=>symbol.name)));
+        let exports;
+        try {
+            exports = getEsmModuleNamespace(context.pkg, implementationFileName);
+        } catch  {
+            return;
+        }
+        const missing = expectedNames.filter((name)=>!exports.includes(name));
+        if (missing.length > 0) {
+            const lengthWithoutDefault = (names)=>names.length - (names.includes("default") ? 1 : 0);
+            return {
+                kind: "NamedExports",
+                implementationFileName,
+                typesFileName,
+                isMissingAllNamed: lengthWithoutDefault(missing) === lengthWithoutDefault(expectedNames),
+                missing
+            };
+        }
+    }
+});
+const checks_entrypointResolutions = defineCheck({
+    name: "EntrypointResolutions",
+    dependencies: ({ subpath, resolutionKind })=>[
+            subpath,
+            resolutionKind
+        ],
+    execute: ([subpath, resolutionKind], context)=>{
+        var _a, _b;
+        const problems = [];
+        const entrypoint = context.entrypoints[subpath].resolutions[resolutionKind];
+        if (entrypoint.isWildcard) return;
+        if (entrypoint.resolution) {
+            if (!entrypoint.resolution.isTypeScript && !entrypoint.resolution.isJson) problems.push({
+                kind: "UntypedResolution",
+                entrypoint: subpath,
+                resolutionKind
+            });
+        } else problems.push({
+            kind: "NoResolution",
+            entrypoint: subpath,
+            resolutionKind
+        });
+        if ("node16-cjs" === resolutionKind && (!entrypoint.implementationResolution && entrypoint.resolution && (null == (_a = context.programInfo["node16"].moduleKinds[entrypoint.resolution.fileName]) ? void 0 : _a.detectedKind) === typescript.ModuleKind.ESNext || entrypoint.implementationResolution && (null == (_b = context.programInfo["node16"].moduleKinds[entrypoint.implementationResolution.fileName]) ? void 0 : _b.detectedKind) === typescript.ModuleKind.ESNext)) problems.push({
+            kind: "CJSResolvesToESM",
+            entrypoint: subpath,
+            resolutionKind
+        });
+        if (entrypoint.resolution && resolvedThroughFallback(entrypoint.resolution.trace)) problems.push({
+            kind: "FallbackCondition",
+            entrypoint: subpath,
+            resolutionKind
+        });
+        return problems;
+    }
+});
+const minifiedVariableAssignmentPattern = /[^\s];(?:var|let|const) [a-zA-Z0-9_]=[^\s]/;
+function getProbableExports(sourceFile) {
+    var _a;
+    return null != (_a = getEsbuildBabelSwcExports(sourceFile)) ? _a : [];
+}
+function getEsbuildBabelSwcExports(sourceFile) {
+    var _a, _b;
+    let possibleIndex = sourceFile.text.indexOf("\n__export(");
+    if (-1 === possibleIndex) possibleIndex = sourceFile.text.indexOf("\n_export(");
+    if (-1 === possibleIndex && !isProbablyMinified(sourceFile.text)) return;
+    for (const statement of sourceFile.statements)if (-1 === possibleIndex || !(statement.end < possibleIndex)) {
+        if (-1 !== possibleIndex && statement.pos > possibleIndex) break;
+        if (typescript.isExpressionStatement(statement) && typescript.isCallExpression(statement.expression) && typescript.isIdentifier(statement.expression.expression) && 2 === statement.expression.arguments.length && typescript.isIdentifier(statement.expression.arguments[0]) && typescript.isObjectLiteralExpression(statement.expression.arguments[1])) {
+            const callTarget = statement.expression.expression;
+            const isExport = "__export" === typescript.unescapeLeadingUnderscores(callTarget.escapedText) || "_export" === callTarget.escapedText || isEsbuildExportFunction(null == (_b = null == (_a = sourceFile.locals) ? void 0 : _a.get(callTarget.escapedText)) ? void 0 : _b.valueDeclaration);
+            if (isExport) return statement.expression.arguments[1].properties.flatMap((prop)=>{
+                if (typescript.isPropertyAssignment(prop) && (typescript.isIdentifier(prop.name) || typescript.isStringOrNumericLiteralLike(prop.name))) return [
+                    {
+                        name: prop.name.text,
+                        node: prop
+                    }
+                ];
+                if (typescript.isShorthandPropertyAssignment(prop)) return [
+                    {
+                        name: prop.name.text,
+                        node: prop
+                    }
+                ];
+                return [];
+            });
+        }
+    }
+}
+function isEsbuildExportFunction(decl) {
+    if (!decl) return false;
+    return typescript.isVariableDeclaration(decl) && decl.initializer && typescript.isFunctionExpressionOrArrowFunction(decl.initializer) && typescript.isBlock(decl.initializer.body) && 1 == decl.initializer.body.statements.length && typescript.isForInStatement(decl.initializer.body.statements[0]);
+}
+function isProbablyMinified(text) {
+    return minifiedVariableAssignmentPattern.test(text);
+}
+const bindOptions = {
+    target: typescript.ScriptTarget.Latest,
+    allowJs: true,
+    checkJs: true
+};
+const exportDefaultDisagreement = defineCheck({
+    name: "ExportDefaultDisagreement",
+    dependencies: ({ entrypoints, subpath, resolutionKind, programInfo })=>{
+        var _a, _b, _c, _d, _e, _f;
+        const entrypoint = entrypoints[subpath].resolutions[resolutionKind];
+        const typesFileName = null == (_a = entrypoint.resolution) ? void 0 : _a.fileName;
+        const implementationFileName = null == (_b = entrypoint.implementationResolution) ? void 0 : _b.fileName;
+        if (typesFileName && (null == (_d = null == (_c = programInfo[getResolutionOption(resolutionKind)].moduleKinds) ? void 0 : _c[typesFileName]) ? void 0 : _d.detectedKind) === typescript.ModuleKind.ESNext || implementationFileName && (null == (_f = null == (_e = programInfo[getResolutionOption(resolutionKind)].moduleKinds) ? void 0 : _e[implementationFileName]) ? void 0 : _f.detectedKind) === typescript.ModuleKind.ESNext) return [];
+        return [
+            typesFileName,
+            implementationFileName
+        ];
+    },
+    execute: ([typesFileName, implementationFileName], context)=>{
+        var _a, _b;
+        if (!typesFileName || !implementationFileName || !typescript.hasTSFileExtension(typesFileName)) return;
+        const host = context.hosts.findHostForFiles([
+            typesFileName
+        ]);
+        const typesSourceFile = host.getSourceFile(typesFileName);
+        typescript.bindSourceFile(typesSourceFile, bindOptions);
+        if (!(null == (_a = typesSourceFile.symbol) ? void 0 : _a.exports)) return;
+        const implementationSourceFile = host.getSourceFile(implementationFileName);
+        typescript.bindSourceFile(implementationSourceFile, bindOptions);
+        if (!(null == (_b = implementationSourceFile.symbol) ? void 0 : _b.exports) || implementationSourceFile.externalModuleIndicator) return;
+        const typesHaveSyntacticDefault = typesSourceFile.symbol.exports.has(typescript.InternalSymbolName.Default);
+        if (typesHaveSyntacticDefault && !getImplHasDefault() && implIsAnalyzable()) return {
+            kind: "FalseExportDefault",
+            typesFileName,
+            implementationFileName
+        };
+        if (!getImplHasDefault() || !implIsAnalyzable()) return;
+        if (!typesSourceFile.symbol.exports.has(typescript.InternalSymbolName.ExportEquals) && implementationSourceFile.symbol.exports.has(typescript.InternalSymbolName.ExportEquals) && getTypesDefaultSymbol() && (getImplExportEqualsIsExportDefault() && getTypesChecker().typeHasCallOrConstructSignatures(getTypesTypeOfDefault()) || getImplChecker().typeHasCallOrConstructSignatures(getImplTypeOfModuleExports()))) return {
+            kind: "MissingExportEquals",
+            typesFileName,
+            implementationFileName
+        };
+        const typesHaveNonDefaultValueExport = Array.from(typesSourceFile.symbol.exports.values()).some((s)=>{
+            if ("default" === s.escapedName) return false;
+            if (s.flags & typescript.SymbolFlags.Value) return true;
+            while(s.flags & typescript.SymbolFlags.Alias){
+                s = getTypesChecker().getAliasedSymbol(s);
+                if (s.flags & typescript.SymbolFlags.Value) return true;
+            }
+        });
+        if (!typesHaveNonDefaultValueExport && typeIsObjecty(getTypesTypeOfDefault(), getTypesChecker()) && (Array.from(implementationSourceFile.symbol.exports.keys()).some((name)=>isNotDefaultOrEsModule(typescript.unescapeLeadingUnderscores(name))) || getImplProbableExports().some(({ name })=>isNotDefaultOrEsModule(name))) && getTypesDefaultSymbol()) return {
+            kind: "MissingExportEquals",
+            typesFileName,
+            implementationFileName
+        };
+        var implProbableExports, implChecker, implHasDefault, implTypeOfModuleExports, implExportEqualsIsExportDefault, typesChecker, typesDefaultSymbol, typesTypeOfDefault;
+        function getImplProbableExports() {
+            var _a;
+            return null != (_a = implProbableExports) ? _a : implProbableExports = getProbableExports(implementationSourceFile);
+        }
+        function getImplChecker() {
+            var _a;
+            return null != (_a = implChecker) ? _a : implChecker = host.createAuxiliaryProgram([
+                implementationFileName
+            ]).getTypeChecker();
+        }
+        function getImplHasDefault() {
+            var _a, _b, _c, _d, _e, _f;
+            return null != (_a = implHasDefault) ? _a : implHasDefault = (null == (_c = null == (_b = null == implementationSourceFile ? void 0 : implementationSourceFile.symbol) ? void 0 : _b.exports) ? void 0 : _c.has(typescript.InternalSymbolName.Default)) || (null == (_d = getImplProbableExports()) ? void 0 : _d.some((s)=>"default" === s.name)) || !!(null == (_f = null == (_e = implementationSourceFile.symbol) ? void 0 : _e.exports) ? void 0 : _f.size) && getImplChecker().getExportsAndPropertiesOfModule(implementationSourceFile.symbol).some((s)=>"default" === s.name);
+        }
+        function getTypesChecker() {
+            var _a;
+            return null != (_a = typesChecker) ? _a : typesChecker = host.createAuxiliaryProgram([
+                typesFileName
+            ]).getTypeChecker();
+        }
+        function getTypesDefaultSymbol() {
+            var _a, _b;
+            return null != (_a = typesDefaultSymbol) ? _a : typesDefaultSymbol = null != (_b = typesSourceFile.symbol.exports.get(typescript.InternalSymbolName.Default)) ? _b : getTypesChecker().getExportsAndPropertiesOfModule(typesSourceFile.symbol).find((s)=>"default" === s.escapedName);
+        }
+        function getTypesTypeOfDefault() {
+            var _a;
+            const symbol = getTypesDefaultSymbol();
+            return null != (_a = typesTypeOfDefault) ? _a : typesTypeOfDefault = symbol ? getTypesChecker().getTypeOfSymbol(symbol) : getTypesChecker().getAnyType();
+        }
+        function getImplTypeOfModuleExports() {
+            if (implTypeOfModuleExports) return implTypeOfModuleExports;
+            const type = getImplChecker().getTypeOfSymbol(getImplChecker().resolveExternalModuleSymbol(implementationSourceFile.symbol));
+            if (type.flags & typescript.TypeFlags.Any && getImplExportEqualsIsExportDefault()) return implTypeOfModuleExports = getImplChecker().getTypeOfSymbol(implementationSourceFile.symbol.exports.get(typescript.InternalSymbolName.Default));
+            return implTypeOfModuleExports = type;
+        }
+        function getImplExportEqualsIsExportDefault() {
+            var _a;
+            if (void 0 !== implExportEqualsIsExportDefault) return implExportEqualsIsExportDefault;
+            const exportEquals = implementationSourceFile.symbol.exports.get(typescript.InternalSymbolName.ExportEquals);
+            if (!exportEquals) return implExportEqualsIsExportDefault = false;
+            const exportDefault = implementationSourceFile.symbol.exports.get(typescript.InternalSymbolName.Default);
+            if (!exportDefault) return implExportEqualsIsExportDefault = false;
+            for (const assignment of [
+                exportEquals.valueDeclaration,
+                typescript.findAncestor(null == (_a = exportDefault.declarations) ? void 0 : _a[0], typescript.isBinaryExpression)
+            ]){
+                let seenModuleExports = false, seenExportsDefault = false;
+                if (assignment && typescript.isBinaryExpression(assignment) && assignment.operatorToken.kind === typescript.SyntaxKind.EqualsToken) {
+                    const res = !!forEachAssignmentTarget(assignment, (target)=>{
+                        if (!seenExportsDefault && isExportsDefault(target)) seenExportsDefault = true;
+                        else if (!seenModuleExports && isModuleExports(target)) seenModuleExports = true;
+                        return seenExportsDefault && seenModuleExports;
+                    });
+                    if (res) return implExportEqualsIsExportDefault = true;
+                }
+            }
+            return implExportEqualsIsExportDefault = false;
+        }
+        function implIsAnalyzable() {
+            var _a, _b, _c;
+            if ((null == (_b = null == (_a = implementationSourceFile.symbol.exports.get(typescript.InternalSymbolName.ExportEquals)) ? void 0 : _a.declarations) ? void 0 : _b.length) > 1) {
+                let commonContainer;
+                for (const decl of implementationSourceFile.symbol.exports.get(typescript.InternalSymbolName.ExportEquals).declarations){
+                    const container = typescript.findAncestor(decl, (node)=>typescript.isFunctionBlock(node) || typescript.isSourceFile(node));
+                    if (void 0 === commonContainer) commonContainer = container;
+                    else if (commonContainer !== container) return false;
+                }
+            }
+            return !!(implementationSourceFile.symbol.exports.size || (null == (_c = getImplProbableExports()) ? void 0 : _c.length));
+        }
+    }
+});
+function typeIsObjecty(type, checker) {
+    return type.flags & typescript.TypeFlags.Object && !(type.flags & typescript.TypeFlags.Primitive) && !checker.typeHasCallOrConstructSignatures(type);
+}
+function isModuleExports(target) {
+    return typescript.isAccessExpression(target) && typescript.isIdentifier(target.expression) && "module" === target.expression.text && "exports" === getNameOfAccessExpression(target) || typescript.isIdentifier(target) && "exports" === target.text;
+}
+function isExportsDefault(target) {
+    return typescript.isAccessExpression(target) && typescript.isIdentifier(target.expression) && "exports" === target.expression.text && "default" === getNameOfAccessExpression(target) || typescript.isAccessExpression(target) && typescript.isAccessExpression(target.expression) && typescript.isIdentifier(target.expression.expression) && "module" === target.expression.expression.text && "exports" === getNameOfAccessExpression(target.expression) && "default" === getNameOfAccessExpression(target);
+}
+function isNotDefaultOrEsModule(name) {
+    return "default" !== name && "__esModule" !== name;
+}
+function forEachAssignmentTarget(assignment, cb) {
+    const target = typescript.skipParentheses(assignment.right);
+    if (typescript.isBinaryExpression(target) && target.operatorToken.kind === typescript.SyntaxKind.EqualsToken) {
+        const res = forEachAssignmentTarget(target, cb);
+        if (res) return res;
+    } else {
+        const res = cb(target);
+        if (res) return res;
+    }
+    return cb(typescript.skipParentheses(assignment.left));
+}
+function getNameOfAccessExpression(accessExpression) {
+    const node = typescript.getNameOfAccessExpression(accessExpression);
+    if (typescript.isIdentifier(node) || typescript.isStringLiteralLike(node)) return node.text;
+}
+const internalResolutionError = defineCheck({
+    name: "InternalResolutionError",
+    enumerateFiles: true,
+    dependencies: ({ resolutionOption, fileName })=>[
+            resolutionOption,
+            fileName
+        ],
+    execute: ([resolutionOption, fileName], context)=>{
+        if (!typescript.hasTSFileExtension(fileName)) return;
+        const host = context.hosts[resolutionOption];
+        const sourceFile = host.getSourceFile(fileName);
+        if (null == sourceFile ? void 0 : sourceFile.imports) {
+            const problems = [];
+            for (const moduleSpecifier of sourceFile.imports){
+                const reference = moduleSpecifier.text;
+                if (reference !== context.pkg.packageName && !reference.startsWith(`${context.pkg.packageName}/`) && "#" !== reference[0] && !typescript.pathIsRelative(reference)) continue;
+                const resolutionMode = typescript.getModeForUsageLocation(sourceFile, moduleSpecifier, host.getCompilerOptions());
+                const resolution = host.getResolvedModule(sourceFile, moduleSpecifier.text, resolutionMode);
+                if (!resolution) throw new Error(`Expected resolution for '${moduleSpecifier.text}' in ${fileName}`);
+                if (!resolution.resolvedModule) problems.push({
+                    kind: "InternalResolutionError",
+                    resolutionOption,
+                    fileName,
+                    moduleSpecifier: reference,
+                    pos: moduleSpecifier.pos,
+                    end: moduleSpecifier.end,
+                    resolutionMode,
+                    trace: host.getTrace(fileName, moduleSpecifier.text, resolutionMode)
+                });
+            }
+            return problems;
+        }
+    }
+});
+const moduleKindDisagreement = defineCheck({
+    name: "ModuleKindDisagreement",
+    dependencies: ({ entrypoints, subpath, resolutionKind, resolutionOption, programInfo })=>{
+        var _a, _b, _c, _d, _e, _f;
+        const entrypoint = entrypoints[subpath].resolutions[resolutionKind];
+        const typesFileName = null == (_a = entrypoint.resolution) ? void 0 : _a.fileName;
+        const implementationFileName = null == (_b = entrypoint.implementationResolution) ? void 0 : _b.fileName;
+        return [
+            typesFileName,
+            implementationFileName,
+            typesFileName ? null == (_d = null == (_c = programInfo[resolutionOption]) ? void 0 : _c.moduleKinds) ? void 0 : _d[typesFileName] : void 0,
+            implementationFileName ? null == (_f = null == (_e = programInfo[resolutionOption]) ? void 0 : _e.moduleKinds) ? void 0 : _f[implementationFileName] : void 0
+        ];
+    },
+    execute: ([typesFileName, implementationFileName, typesModuleKind, implementationModuleKind])=>{
+        if (typesFileName && implementationFileName && typesModuleKind && implementationModuleKind) {
+            if (typesModuleKind.detectedKind === typescript.ModuleKind.ESNext && implementationModuleKind.detectedKind === typescript.ModuleKind.CommonJS) return {
+                kind: "FalseESM",
+                typesFileName,
+                implementationFileName,
+                typesModuleKind,
+                implementationModuleKind
+            };
+            else if (typesModuleKind.detectedKind === typescript.ModuleKind.CommonJS && implementationModuleKind.detectedKind === typescript.ModuleKind.ESNext) return {
+                kind: "FalseCJS",
+                typesFileName,
+                implementationFileName,
+                typesModuleKind,
+                implementationModuleKind
+            };
+        }
+    }
+});
+const unexpectedModuleSyntax = defineCheck({
+    name: "UnexpectedModuleSyntax",
+    enumerateFiles: true,
+    dependencies: ({ fileName, resolutionOption, programInfo })=>{
+        var _a;
+        return [
+            fileName,
+            null == (_a = programInfo[resolutionOption].moduleKinds) ? void 0 : _a[fileName]
+        ];
+    },
+    execute: ([fileName, expectedModuleKind], context)=>{
+        var _a, _b;
+        if (!expectedModuleKind || !typescript.hasJSFileExtension(fileName)) return;
+        const host = null != (_a = context.hosts.findHostForFiles([
+            fileName
+        ])) ? _a : context.hosts.bundler;
+        const sourceFile = host.getSourceFile(fileName);
+        const syntaxImpliedModuleKind = sourceFile.externalModuleIndicator ? typescript.ModuleKind.ESNext : sourceFile.commonJsModuleIndicator ? typescript.ModuleKind.CommonJS : void 0;
+        if (void 0 !== syntaxImpliedModuleKind && expectedModuleKind.detectedKind !== syntaxImpliedModuleKind) {
+            const syntax = null != (_b = sourceFile.externalModuleIndicator) ? _b : sourceFile.commonJsModuleIndicator;
+            return {
+                kind: "UnexpectedModuleSyntax",
+                fileName,
+                moduleKind: expectedModuleKind,
+                syntax: syntaxImpliedModuleKind,
+                pos: syntax.getStart(sourceFile),
+                end: syntax.end
+            };
+        }
+    }
+});
+const checks = [
+    checks_entrypointResolutions,
+    moduleKindDisagreement,
+    exportDefaultDisagreement,
+    namedExports,
+    cjsOnlyExportsDefault,
+    unexpectedModuleSyntax,
+    internalResolutionError
+];
+const perf = 'object' == typeof performance && performance && 'function' == typeof performance.now ? performance : Date;
+const warned = new Set();
+const PROCESS = 'object' == typeof process && process ? process : {};
+const emitWarning = (msg, type, code, fn)=>{
+    'function' == typeof PROCESS.emitWarning ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+};
+let AC = globalThis.AbortController;
+let AS = globalThis.AbortSignal;
+if (void 0 === AC) {
+    AS = class {
+        onabort;
+        _onabort = [];
+        reason;
+        aborted = false;
+        addEventListener(_, fn) {
+            this._onabort.push(fn);
+        }
+    };
+    AC = class {
+        constructor(){
+            warnACPolyfill();
+        }
+        signal = new AS();
+        abort(reason) {
+            if (this.signal.aborted) return;
+            this.signal.reason = reason;
+            this.signal.aborted = true;
+            for (const fn of this.signal._onabort)fn(reason);
+            this.signal.onabort?.(reason);
+        }
+    };
+    let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1';
+    const warnACPolyfill = ()=>{
+        if (!printACPolyfillWarning) return;
+        printACPolyfillWarning = false;
+        emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", 'NO_ABORT_CONTROLLER', 'ENOTSUP', warnACPolyfill);
+    };
+}
+const shouldWarn = (code)=>!warned.has(code);
+Symbol('type');
+const isPosInt = (n)=>n && n === Math.floor(n) && n > 0 && isFinite(n);
+const getUintArray = (max)=>isPosInt(max) ? max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null : null;
+class ZeroArray extends Array {
+    constructor(size){
+        super(size);
+        this.fill(0);
+    }
+}
+class Stack {
+    heap;
+    length;
+    static #constructing = false;
+    static create(max) {
+        const HeapCls = getUintArray(max);
+        if (!HeapCls) return [];
+        Stack.#constructing = true;
+        const s = new Stack(max, HeapCls);
+        Stack.#constructing = false;
+        return s;
+    }
+    constructor(max, HeapCls){
+        if (!Stack.#constructing) throw new TypeError('instantiate Stack using Stack.create(n)');
+        this.heap = new HeapCls(max);
+        this.length = 0;
+    }
+    push(n) {
+        this.heap[this.length++] = n;
+    }
+    pop() {
+        return this.heap[--this.length];
+    }
+}
+class LRUCache {
+    #max;
+    #maxSize;
+    #dispose;
+    #onInsert;
+    #disposeAfter;
+    #fetchMethod;
+    #memoMethod;
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    #hasOnInsert;
+    static unsafeExposeInternals(c) {
+        return {
+            starts: c.#starts,
+            ttls: c.#ttls,
+            sizes: c.#sizes,
+            keyMap: c.#keyMap,
+            keyList: c.#keyList,
+            valList: c.#valList,
+            next: c.#next,
+            prev: c.#prev,
+            get head () {
+                return c.#head;
+            },
+            get tail () {
+                return c.#tail;
+            },
+            free: c.#free,
+            isBackgroundFetch: (p)=>c.#isBackgroundFetch(p),
+            backgroundFetch: (k, index, options, context)=>c.#backgroundFetch(k, index, options, context),
+            moveToTail: (index)=>c.#moveToTail(index),
+            indexes: (options)=>c.#indexes(options),
+            rindexes: (options)=>c.#rindexes(options),
+            isStale: (index)=>c.#isStale(index)
+        };
+    }
+    get max() {
+        return this.#max;
+    }
+    get maxSize() {
+        return this.#maxSize;
+    }
+    get calculatedSize() {
+        return this.#calculatedSize;
+    }
+    get size() {
+        return this.#size;
+    }
+    get fetchMethod() {
+        return this.#fetchMethod;
+    }
+    get memoMethod() {
+        return this.#memoMethod;
+    }
+    get dispose() {
+        return this.#dispose;
+    }
+    get onInsert() {
+        return this.#onInsert;
+    }
+    get disposeAfter() {
+        return this.#disposeAfter;
+    }
+    constructor(options){
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+        if (0 !== max && !isPosInt(max)) throw new TypeError('max option must be a nonnegative integer');
+        const UintArray = max ? getUintArray(max) : Array;
+        if (!UintArray) throw new Error('invalid max value: ' + max);
+        this.#max = max;
+        this.#maxSize = maxSize;
+        this.maxEntrySize = maxEntrySize || this.#maxSize;
+        this.sizeCalculation = sizeCalculation;
+        if (this.sizeCalculation) {
+            if (!this.#maxSize && !this.maxEntrySize) throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
+            if ('function' != typeof this.sizeCalculation) throw new TypeError('sizeCalculation set to non-function');
+        }
+        if (void 0 !== memoMethod && 'function' != typeof memoMethod) throw new TypeError('memoMethod must be a function if defined');
+        this.#memoMethod = memoMethod;
+        if (void 0 !== fetchMethod && 'function' != typeof fetchMethod) throw new TypeError('fetchMethod must be a function if specified');
+        this.#fetchMethod = fetchMethod;
+        this.#hasFetchMethod = !!fetchMethod;
+        this.#keyMap = new Map();
+        this.#keyList = new Array(max).fill(void 0);
+        this.#valList = new Array(max).fill(void 0);
+        this.#next = new UintArray(max);
+        this.#prev = new UintArray(max);
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free = Stack.create(max);
+        this.#size = 0;
+        this.#calculatedSize = 0;
+        if ('function' == typeof dispose) this.#dispose = dispose;
+        if ('function' == typeof onInsert) this.#onInsert = onInsert;
+        if ('function' == typeof disposeAfter) {
+            this.#disposeAfter = disposeAfter;
+            this.#disposed = [];
+        } else {
+            this.#disposeAfter = void 0;
+            this.#disposed = void 0;
+        }
+        this.#hasDispose = !!this.#dispose;
+        this.#hasOnInsert = !!this.#onInsert;
+        this.#hasDisposeAfter = !!this.#disposeAfter;
+        this.noDisposeOnSet = !!noDisposeOnSet;
+        this.noUpdateTTL = !!noUpdateTTL;
+        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+        this.ignoreFetchAbort = !!ignoreFetchAbort;
+        if (0 !== this.maxEntrySize) {
+            if (0 !== this.#maxSize) {
+                if (!isPosInt(this.#maxSize)) throw new TypeError('maxSize must be a positive integer if specified');
+            }
+            if (!isPosInt(this.maxEntrySize)) throw new TypeError('maxEntrySize must be a positive integer if specified');
+            this.#initializeSizeTracking();
+        }
+        this.allowStale = !!allowStale;
+        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+        this.updateAgeOnGet = !!updateAgeOnGet;
+        this.updateAgeOnHas = !!updateAgeOnHas;
+        this.ttlResolution = isPosInt(ttlResolution) || 0 === ttlResolution ? ttlResolution : 1;
+        this.ttlAutopurge = !!ttlAutopurge;
+        this.ttl = ttl || 0;
+        if (this.ttl) {
+            if (!isPosInt(this.ttl)) throw new TypeError('ttl must be a positive integer if specified');
+            this.#initializeTTLTracking();
+        }
+        if (0 === this.#max && 0 === this.ttl && 0 === this.#maxSize) throw new TypeError('At least one of max, maxSize, or ttl is required');
+        if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+            const code = 'LRU_CACHE_UNBOUNDED';
+            if (shouldWarn(code)) {
+                warned.add(code);
+                const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
+                emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
+            }
+        }
+    }
+    getRemainingTTL(key) {
+        return this.#keyMap.has(key) ? 1 / 0 : 0;
+    }
+    #initializeTTLTracking() {
+        const ttls = new ZeroArray(this.#max);
+        const starts = new ZeroArray(this.#max);
+        this.#ttls = ttls;
+        this.#starts = starts;
+        this.#setItemTTL = (index, ttl, start = perf.now())=>{
+            starts[index] = 0 !== ttl ? start : 0;
+            ttls[index] = ttl;
+            if (0 !== ttl && this.ttlAutopurge) {
+                const t = setTimeout(()=>{
+                    if (this.#isStale(index)) this.#delete(this.#keyList[index], 'expire');
+                }, ttl + 1);
+                if (t.unref) t.unref();
+            }
+        };
+        this.#updateItemAge = (index)=>{
+            starts[index] = 0 !== ttls[index] ? perf.now() : 0;
+        };
+        this.#statusTTL = (status, index)=>{
+            if (ttls[index]) {
+                const ttl = ttls[index];
+                const start = starts[index];
+                if (!ttl || !start) return;
+                status.ttl = ttl;
+                status.start = start;
+                status.now = cachedNow || getNow();
+                const age = status.now - start;
+                status.remainingTTL = ttl - age;
+            }
+        };
+        let cachedNow = 0;
+        const getNow = ()=>{
+            const n = perf.now();
+            if (this.ttlResolution > 0) {
+                cachedNow = n;
+                const t = setTimeout(()=>cachedNow = 0, this.ttlResolution);
+                if (t.unref) t.unref();
+            }
+            return n;
+        };
+        this.getRemainingTTL = (key)=>{
+            const index = this.#keyMap.get(key);
+            if (void 0 === index) return 0;
+            const ttl = ttls[index];
+            const start = starts[index];
+            if (!ttl || !start) return 1 / 0;
+            const age = (cachedNow || getNow()) - start;
+            return ttl - age;
+        };
+        this.#isStale = (index)=>{
+            const s = starts[index];
+            const t = ttls[index];
+            return !!t && !!s && (cachedNow || getNow()) - s > t;
+        };
+    }
+    #updateItemAge = ()=>{};
+    #statusTTL = ()=>{};
+    #setItemTTL = ()=>{};
+    #isStale = ()=>false;
+    #initializeSizeTracking() {
+        const sizes = new ZeroArray(this.#max);
+        this.#calculatedSize = 0;
+        this.#sizes = sizes;
+        this.#removeItemSize = (index)=>{
+            this.#calculatedSize -= sizes[index];
+            sizes[index] = 0;
+        };
+        this.#requireSize = (k, v, size, sizeCalculation)=>{
+            if (this.#isBackgroundFetch(v)) return 0;
+            if (!isPosInt(size)) if (sizeCalculation) {
+                if ('function' != typeof sizeCalculation) throw new TypeError('sizeCalculation must be a function');
+                size = sizeCalculation(v, k);
+                if (!isPosInt(size)) throw new TypeError('sizeCalculation return invalid (expect positive integer)');
+            } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+            return size;
+        };
+        this.#addItemSize = (index, size, status)=>{
+            sizes[index] = size;
+            if (this.#maxSize) {
+                const maxSize = this.#maxSize - sizes[index];
+                while(this.#calculatedSize > maxSize)this.#evict(true);
+            }
+            this.#calculatedSize += sizes[index];
+            if (status) {
+                status.entrySize = size;
+                status.totalCalculatedSize = this.#calculatedSize;
+            }
+        };
+    }
+    #removeItemSize = (_i)=>{};
+    #addItemSize = (_i, _s, _st)=>{};
+    #requireSize = (_k, _v, size, sizeCalculation)=>{
+        if (size || sizeCalculation) throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
+        return 0;
+    };
+    *#indexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) for(let i = this.#tail; true;){
+            if (!this.#isValidIndex(i)) break;
+            if (allowStale || !this.#isStale(i)) yield i;
+            if (i === this.#head) break;
+            i = this.#prev[i];
+        }
+    }
+    *#rindexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) for(let i = this.#head; true;){
+            if (!this.#isValidIndex(i)) break;
+            if (allowStale || !this.#isStale(i)) yield i;
+            if (i === this.#tail) break;
+            i = this.#next[i];
+        }
+    }
+    #isValidIndex(index) {
+        return void 0 !== index && this.#keyMap.get(this.#keyList[index]) === index;
+    }
+    *entries() {
+        for (const i of this.#indexes())if (void 0 !== this.#valList[i] && void 0 !== this.#keyList[i] && !this.#isBackgroundFetch(this.#valList[i])) yield [
+            this.#keyList[i],
+            this.#valList[i]
+        ];
+    }
+    *rentries() {
+        for (const i of this.#rindexes())if (void 0 !== this.#valList[i] && void 0 !== this.#keyList[i] && !this.#isBackgroundFetch(this.#valList[i])) yield [
+            this.#keyList[i],
+            this.#valList[i]
+        ];
+    }
+    *keys() {
+        for (const i of this.#indexes()){
+            const k = this.#keyList[i];
+            if (void 0 !== k && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+        }
+    }
+    *rkeys() {
+        for (const i of this.#rindexes()){
+            const k = this.#keyList[i];
+            if (void 0 !== k && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+        }
+    }
+    *values() {
+        for (const i of this.#indexes()){
+            const v = this.#valList[i];
+            if (void 0 !== v && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
+        }
+    }
+    *rvalues() {
+        for (const i of this.#rindexes()){
+            const v = this.#valList[i];
+            if (void 0 !== v && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag] = 'LRUCache';
+    find(fn, getOptions = {}) {
+        for (const i of this.#indexes()){
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (void 0 !== value) {
+                if (fn(value, this.#keyList[i], this)) return this.get(this.#keyList[i], getOptions);
+            }
+        }
+    }
+    forEach(fn, thisp = this) {
+        for (const i of this.#indexes()){
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (void 0 !== value) fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    rforEach(fn, thisp = this) {
+        for (const i of this.#rindexes()){
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (void 0 !== value) fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    purgeStale() {
+        let deleted = false;
+        for (const i of this.#rindexes({
+            allowStale: true
+        }))if (this.#isStale(i)) {
+            this.#delete(this.#keyList[i], 'expire');
+            deleted = true;
+        }
+        return deleted;
+    }
+    info(key) {
+        const i = this.#keyMap.get(key);
+        if (void 0 === i) return;
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (void 0 === value) return;
+        const entry = {
+            value
+        };
+        if (this.#ttls && this.#starts) {
+            const ttl = this.#ttls[i];
+            const start = this.#starts[i];
+            if (ttl && start) {
+                const remain = ttl - (perf.now() - start);
+                entry.ttl = remain;
+                entry.start = Date.now();
+            }
+        }
+        if (this.#sizes) entry.size = this.#sizes[i];
+        return entry;
+    }
+    dump() {
+        const arr = [];
+        for (const i of this.#indexes({
+            allowStale: true
+        })){
+            const key = this.#keyList[i];
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (void 0 === value || void 0 === key) continue;
+            const entry = {
+                value
+            };
+            if (this.#ttls && this.#starts) {
+                entry.ttl = this.#ttls[i];
+                const age = perf.now() - this.#starts[i];
+                entry.start = Math.floor(Date.now() - age);
+            }
+            if (this.#sizes) entry.size = this.#sizes[i];
+            arr.unshift([
+                key,
+                entry
+            ]);
+        }
+        return arr;
+    }
+    load(arr) {
+        this.clear();
+        for (const [key, entry] of arr){
+            if (entry.start) {
+                const age = Date.now() - entry.start;
+                entry.start = perf.now() - age;
+            }
+            this.set(key, entry.value, entry);
+        }
+    }
+    set(k, v, setOptions = {}) {
+        if (void 0 === v) {
+            this.delete(k);
+            return this;
+        }
+        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
+        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
+        if (this.maxEntrySize && size > this.maxEntrySize) {
+            if (status) {
+                status.set = 'miss';
+                status.maxEntrySizeExceeded = true;
+            }
+            this.#delete(k, 'set');
+            return this;
+        }
+        let index = 0 === this.#size ? void 0 : this.#keyMap.get(k);
+        if (void 0 === index) {
+            index = 0 === this.#size ? this.#tail : 0 !== this.#free.length ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
+            this.#keyList[index] = k;
+            this.#valList[index] = v;
+            this.#keyMap.set(k, index);
+            this.#next[this.#tail] = index;
+            this.#prev[index] = this.#tail;
+            this.#tail = index;
+            this.#size++;
+            this.#addItemSize(index, size, status);
+            if (status) status.set = 'add';
+            noUpdateTTL = false;
+            if (this.#hasOnInsert) this.#onInsert?.(v, k, 'add');
+        } else {
+            this.#moveToTail(index);
+            const oldVal = this.#valList[index];
+            if (v !== oldVal) {
+                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
+                    oldVal.__abortController.abort(new Error('replaced'));
+                    const { __staleWhileFetching: s } = oldVal;
+                    if (void 0 !== s && !noDisposeOnSet) {
+                        if (this.#hasDispose) this.#dispose?.(s, k, 'set');
+                        if (this.#hasDisposeAfter) this.#disposed?.push([
+                            s,
+                            k,
+                            'set'
+                        ]);
+                    }
+                } else if (!noDisposeOnSet) {
+                    if (this.#hasDispose) this.#dispose?.(oldVal, k, 'set');
+                    if (this.#hasDisposeAfter) this.#disposed?.push([
+                        oldVal,
+                        k,
+                        'set'
+                    ]);
+                }
+                this.#removeItemSize(index);
+                this.#addItemSize(index, size, status);
+                this.#valList[index] = v;
+                if (status) {
+                    status.set = 'replace';
+                    const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
+                    if (void 0 !== oldValue) status.oldValue = oldValue;
+                }
+            } else if (status) status.set = 'update';
+            if (this.#hasOnInsert) this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
+        }
+        if (0 !== ttl && !this.#ttls) this.#initializeTTLTracking();
+        if (this.#ttls) {
+            if (!noUpdateTTL) this.#setItemTTL(index, ttl, start);
+            if (status) this.#statusTTL(status, index);
+        }
+        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while(task = dt?.shift())this.#disposeAfter?.(...task);
+        }
+        return this;
+    }
+    pop() {
+        try {
+            while(this.#size){
+                const val = this.#valList[this.#head];
+                this.#evict(true);
+                if (this.#isBackgroundFetch(val)) {
+                    if (val.__staleWhileFetching) return val.__staleWhileFetching;
+                } else if (void 0 !== val) return val;
+            }
+        } finally{
+            if (this.#hasDisposeAfter && this.#disposed) {
+                const dt = this.#disposed;
+                let task;
+                while(task = dt?.shift())this.#disposeAfter?.(...task);
+            }
+        }
+    }
+    #evict(free) {
+        const head = this.#head;
+        const k = this.#keyList[head];
+        const v = this.#valList[head];
+        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('evicted'));
+        else if (this.#hasDispose || this.#hasDisposeAfter) {
+            if (this.#hasDispose) this.#dispose?.(v, k, 'evict');
+            if (this.#hasDisposeAfter) this.#disposed?.push([
+                v,
+                k,
+                'evict'
+            ]);
+        }
+        this.#removeItemSize(head);
+        if (free) {
+            this.#keyList[head] = void 0;
+            this.#valList[head] = void 0;
+            this.#free.push(head);
+        }
+        if (1 === this.#size) {
+            this.#head = this.#tail = 0;
+            this.#free.length = 0;
+        } else this.#head = this.#next[head];
+        this.#keyMap.delete(k);
+        this.#size--;
+        return head;
+    }
+    has(k, hasOptions = {}) {
+        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+        const index = this.#keyMap.get(k);
+        if (void 0 !== index) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v) && void 0 === v.__staleWhileFetching) return false;
+            if (this.#isStale(index)) {
+                if (status) {
+                    status.has = 'stale';
+                    this.#statusTTL(status, index);
+                }
+            } else {
+                if (updateAgeOnHas) this.#updateItemAge(index);
+                if (status) {
+                    status.has = 'hit';
+                    this.#statusTTL(status, index);
+                }
+                return true;
+            }
+        } else if (status) status.has = 'miss';
+        return false;
+    }
+    peek(k, peekOptions = {}) {
+        const { allowStale = this.allowStale } = peekOptions;
+        const index = this.#keyMap.get(k);
+        if (void 0 === index || !allowStale && this.#isStale(index)) return;
+        const v = this.#valList[index];
+        return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+    }
+    #backgroundFetch(k, index, options, context) {
+        const v = void 0 === index ? void 0 : this.#valList[index];
+        if (this.#isBackgroundFetch(v)) return v;
+        const ac = new AC();
+        const { signal } = options;
+        signal?.addEventListener('abort', ()=>ac.abort(signal.reason), {
+            signal: ac.signal
+        });
+        const fetchOpts = {
+            signal: ac.signal,
+            options,
+            context
+        };
+        const cb = (v, updateCache = false)=>{
+            const { aborted } = ac.signal;
+            const ignoreAbort = options.ignoreFetchAbort && void 0 !== v;
+            if (options.status) if (aborted && !updateCache) {
+                options.status.fetchAborted = true;
+                options.status.fetchError = ac.signal.reason;
+                if (ignoreAbort) options.status.fetchAbortIgnored = true;
+            } else options.status.fetchResolved = true;
+            if (aborted && !ignoreAbort && !updateCache) return fetchFail(ac.signal.reason);
+            const bf = p;
+            if (this.#valList[index] === p) if (void 0 === v) if (bf.__staleWhileFetching) this.#valList[index] = bf.__staleWhileFetching;
+            else this.#delete(k, 'fetch');
+            else {
+                if (options.status) options.status.fetchUpdated = true;
+                this.set(k, v, fetchOpts.options);
+            }
+            return v;
+        };
+        const eb = (er)=>{
+            if (options.status) {
+                options.status.fetchRejected = true;
+                options.status.fetchError = er;
+            }
+            return fetchFail(er);
+        };
+        const fetchFail = (er)=>{
+            const { aborted } = ac.signal;
+            const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+            const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+            const noDelete = allowStale || options.noDeleteOnFetchRejection;
+            const bf = p;
+            if (this.#valList[index] === p) {
+                const del = !noDelete || void 0 === bf.__staleWhileFetching;
+                if (del) this.#delete(k, 'fetch');
+                else if (!allowStaleAborted) this.#valList[index] = bf.__staleWhileFetching;
+            }
+            if (allowStale) {
+                if (options.status && void 0 !== bf.__staleWhileFetching) options.status.returnedStale = true;
+                return bf.__staleWhileFetching;
+            }
+            if (bf.__returned === bf) throw er;
+        };
+        const pcall = (res, rej)=>{
+            const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+            if (fmp && fmp instanceof Promise) fmp.then((v)=>res(void 0 === v ? void 0 : v), rej);
+            ac.signal.addEventListener('abort', ()=>{
+                if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+                    res(void 0);
+                    if (options.allowStaleOnFetchAbort) res = (v)=>cb(v, true);
+                }
+            });
+        };
+        if (options.status) options.status.fetchDispatched = true;
+        const p = new Promise(pcall).then(cb, eb);
+        const bf = Object.assign(p, {
+            __abortController: ac,
+            __staleWhileFetching: v,
+            __returned: void 0
+        });
+        if (void 0 === index) {
+            this.set(k, bf, {
+                ...fetchOpts.options,
+                status: void 0
+            });
+            index = this.#keyMap.get(k);
+        } else this.#valList[index] = bf;
+        return bf;
+    }
+    #isBackgroundFetch(p) {
+        if (!this.#hasFetchMethod) return false;
+        const b = p;
+        return !!b && b instanceof Promise && b.hasOwnProperty('__staleWhileFetching') && b.__abortController instanceof AC;
+    }
+    async fetch(k, fetchOptions = {}) {
+        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal } = fetchOptions;
+        if (!this.#hasFetchMethod) {
+            if (status) status.fetch = 'get';
+            return this.get(k, {
+                allowStale,
+                updateAgeOnGet,
+                noDeleteOnStaleGet,
+                status
+            });
+        }
+        const options = {
+            allowStale,
+            updateAgeOnGet,
+            noDeleteOnStaleGet,
+            ttl,
+            noDisposeOnSet,
+            size,
+            sizeCalculation,
+            noUpdateTTL,
+            noDeleteOnFetchRejection,
+            allowStaleOnFetchRejection,
+            allowStaleOnFetchAbort,
+            ignoreFetchAbort,
+            status,
+            signal
+        };
+        let index = this.#keyMap.get(k);
+        if (void 0 === index) {
+            if (status) status.fetch = 'miss';
+            const p = this.#backgroundFetch(k, index, options, context);
+            return p.__returned = p;
+        }
+        {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                const stale = allowStale && void 0 !== v.__staleWhileFetching;
+                if (status) {
+                    status.fetch = 'inflight';
+                    if (stale) status.returnedStale = true;
+                }
+                return stale ? v.__staleWhileFetching : v.__returned = v;
+            }
+            const isStale = this.#isStale(index);
+            if (!forceRefresh && !isStale) {
+                if (status) status.fetch = 'hit';
+                this.#moveToTail(index);
+                if (updateAgeOnGet) this.#updateItemAge(index);
+                if (status) this.#statusTTL(status, index);
+                return v;
+            }
+            const p = this.#backgroundFetch(k, index, options, context);
+            const hasStale = void 0 !== p.__staleWhileFetching;
+            const staleVal = hasStale && allowStale;
+            if (status) {
+                status.fetch = isStale ? 'stale' : 'refresh';
+                if (staleVal && isStale) status.returnedStale = true;
+            }
+            return staleVal ? p.__staleWhileFetching : p.__returned = p;
+        }
+    }
+    async forceFetch(k, fetchOptions = {}) {
+        const v = await this.fetch(k, fetchOptions);
+        if (void 0 === v) throw new Error('fetch() returned undefined');
+        return v;
+    }
+    memo(k, memoOptions = {}) {
+        const memoMethod = this.#memoMethod;
+        if (!memoMethod) throw new Error('no memoMethod provided to constructor');
+        const { context, forceRefresh, ...options } = memoOptions;
+        const v = this.get(k, options);
+        if (!forceRefresh && void 0 !== v) return v;
+        const vv = memoMethod(k, v, {
+            options,
+            context
+        });
+        this.set(k, vv, options);
+        return vv;
+    }
+    get(k, getOptions = {}) {
+        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+        const index = this.#keyMap.get(k);
+        if (void 0 !== index) {
+            const value = this.#valList[index];
+            const fetching = this.#isBackgroundFetch(value);
+            if (status) this.#statusTTL(status, index);
+            if (this.#isStale(index)) {
+                if (status) status.get = 'stale';
+                if (fetching) {
+                    if (status && allowStale && void 0 !== value.__staleWhileFetching) status.returnedStale = true;
+                    return allowStale ? value.__staleWhileFetching : void 0;
+                }
+                if (!noDeleteOnStaleGet) this.#delete(k, 'expire');
+                if (status && allowStale) status.returnedStale = true;
+                return allowStale ? value : void 0;
+            }
+            if (status) status.get = 'hit';
+            if (fetching) return value.__staleWhileFetching;
+            this.#moveToTail(index);
+            if (updateAgeOnGet) this.#updateItemAge(index);
+            return value;
+        }
+        if (status) status.get = 'miss';
+    }
+    #connect(p, n) {
+        this.#prev[n] = p;
+        this.#next[p] = n;
+    }
+    #moveToTail(index) {
+        if (index !== this.#tail) {
+            if (index === this.#head) this.#head = this.#next[index];
+            else this.#connect(this.#prev[index], this.#next[index]);
+            this.#connect(this.#tail, index);
+            this.#tail = index;
+        }
+    }
+    delete(k) {
+        return this.#delete(k, 'delete');
+    }
+    #delete(k, reason) {
+        let deleted = false;
+        if (0 !== this.#size) {
+            const index = this.#keyMap.get(k);
+            if (void 0 !== index) {
+                deleted = true;
+                if (1 === this.#size) this.#clear(reason);
+                else {
+                    this.#removeItemSize(index);
+                    const v = this.#valList[index];
+                    if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('deleted'));
+                    else if (this.#hasDispose || this.#hasDisposeAfter) {
+                        if (this.#hasDispose) this.#dispose?.(v, k, reason);
+                        if (this.#hasDisposeAfter) this.#disposed?.push([
+                            v,
+                            k,
+                            reason
+                        ]);
+                    }
+                    this.#keyMap.delete(k);
+                    this.#keyList[index] = void 0;
+                    this.#valList[index] = void 0;
+                    if (index === this.#tail) this.#tail = this.#prev[index];
+                    else if (index === this.#head) this.#head = this.#next[index];
+                    else {
+                        const pi = this.#prev[index];
+                        this.#next[pi] = this.#next[index];
+                        const ni = this.#next[index];
+                        this.#prev[ni] = this.#prev[index];
+                    }
+                    this.#size--;
+                    this.#free.push(index);
+                }
+            }
+        }
+        if (this.#hasDisposeAfter && this.#disposed?.length) {
+            const dt = this.#disposed;
+            let task;
+            while(task = dt?.shift())this.#disposeAfter?.(...task);
+        }
+        return deleted;
+    }
+    clear() {
+        return this.#clear('delete');
+    }
+    #clear(reason) {
+        for (const index of this.#rindexes({
+            allowStale: true
+        })){
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('deleted'));
+            else {
+                const k = this.#keyList[index];
+                if (this.#hasDispose) this.#dispose?.(v, k, reason);
+                if (this.#hasDisposeAfter) this.#disposed?.push([
+                    v,
+                    k,
+                    reason
+                ]);
+            }
+        }
+        this.#keyMap.clear();
+        this.#valList.fill(void 0);
+        this.#keyList.fill(void 0);
+        if (this.#ttls && this.#starts) {
+            this.#ttls.fill(0);
+            this.#starts.fill(0);
+        }
+        if (this.#sizes) this.#sizes.fill(0);
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free.length = 0;
+        this.#calculatedSize = 0;
+        this.#size = 0;
+        if (this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while(task = dt?.shift())this.#disposeAfter?.(...task);
+        }
+    }
+}
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */ const minimalLibDts = `
+interface ReadonlyArray<T> {
+  readonly length: number;
+  toString(): string;
+  toLocaleString(): string;
+  concat(...items: ConcatArray<T>[]): T[];
+  concat(...items: (T | ConcatArray<T>)[]): T[];
+  join(separator?: string): string;
+  slice(start?: number, end?: number): T[];
+  indexOf(searchElement: T, fromIndex?: number): number;
+  lastIndexOf(searchElement: T, fromIndex?: number): number;
+  every<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): this is readonly S[];
+  every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+  some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+  forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
+  map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+  filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
+  filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+  reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+  readonly [n: number]: T;
+}
+
+interface Array<T> {
+  length: number;
+  toString(): string;
+  toLocaleString(): string;
+  pop(): T | undefined;
+  push(...items: T[]): number;
+  concat(...items: ConcatArray<T>[]): T[];
+  concat(...items: (T | ConcatArray<T>)[]): T[];
+  join(separator?: string): string;
+  reverse(): T[];
+  shift(): T | undefined;
+  slice(start?: number, end?: number): T[];
+  sort(compareFn?: (a: T, b: T) => number): this;
+  splice(start: number, deleteCount?: number): T[];
+  splice(start: number, deleteCount: number, ...items: T[]): T[];
+  unshift(...items: T[]): number;
+  indexOf(searchElement: T, fromIndex?: number): number;
+  lastIndexOf(searchElement: T, fromIndex?: number): number;
+  every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
+  every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+  some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+  forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
+  map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
+  filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
+  filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+  reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+  [n: number]: T;
+}
+`;
+function createCompilerHosts(fs) {
+    const node10 = new CompilerHostWrapper(fs, typescript.ModuleResolutionKind.Node10, typescript.ModuleKind.CommonJS);
+    const node16 = new CompilerHostWrapper(fs, typescript.ModuleResolutionKind.Node16, typescript.ModuleKind.Node16);
+    const bundler = new CompilerHostWrapper(fs, typescript.ModuleResolutionKind.Bundler, typescript.ModuleKind.ESNext);
+    return {
+        node10,
+        node16,
+        bundler,
+        findHostForFiles (files) {
+            for (const host of [
+                node10,
+                node16,
+                bundler
+            ])if (files.every((f)=>void 0 !== host.getSourceFileFromCache(f))) return host;
+        }
+    };
+}
+const getCanonicalFileName = typescript.createGetCanonicalFileName(false);
+const toPath = (fileName)=>typescript.toPath(fileName, "/", getCanonicalFileName);
+class CompilerHostWrapper {
+    constructor(fs, moduleResolution, moduleKind){
+        this.programCache = new LRUCache({
+            max: 2
+        });
+        this.moduleResolutionCache = {};
+        this.traceCollector = new TraceCollector();
+        this.sourceFileCache = new Map();
+        this.resolvedModules = new Map();
+        this.languageVersion = typescript.ScriptTarget.Latest;
+        this.compilerOptions = {
+            moduleResolution,
+            module: moduleKind,
+            moduleDetection: typescript.ModuleDetectionKind.Legacy,
+            target: typescript.ScriptTarget.Latest,
+            resolveJsonModule: true,
+            traceResolution: true
+        };
+        this.normalModuleResolutionCache = typescript.createModuleResolutionCache("/", getCanonicalFileName, this.compilerOptions);
+        this.noDtsResolutionModuleResolutionCache = typescript.createModuleResolutionCache("/", getCanonicalFileName, this.compilerOptions);
+        this.compilerHost = this.createCompilerHost(fs, this.sourceFileCache);
+    }
+    getCompilerOptions() {
+        return this.compilerOptions;
+    }
+    getSourceFile(fileName) {
+        return this.compilerHost.getSourceFile(fileName, this.languageVersion);
+    }
+    getSourceFileFromCache(fileName) {
+        return this.sourceFileCache.get(toPath(fileName));
+    }
+    getModuleKindForFile(fileName) {
+        var _a;
+        const kind = this.getImpliedNodeFormatForFile(fileName);
+        if (kind) {
+            const extension = typescript.getAnyExtensionFromPath(fileName);
+            const isExtension = extension === typescript.Extension.Cjs || extension === typescript.Extension.Cts || extension === typescript.Extension.Dcts || extension === typescript.Extension.Mjs || extension === typescript.Extension.Mts || extension === typescript.Extension.Dmts;
+            const reasonPackageJsonInfo = isExtension ? void 0 : this.getPackageScopeForPath(fileName);
+            const reasonFileName = isExtension ? fileName : reasonPackageJsonInfo ? reasonPackageJsonInfo.packageDirectory + "/package.json" : fileName;
+            const reasonPackageJsonType = null == (_a = null == reasonPackageJsonInfo ? void 0 : reasonPackageJsonInfo.contents) ? void 0 : _a.packageJsonContent.type;
+            return {
+                detectedKind: kind,
+                detectedReason: isExtension ? "extension" : reasonPackageJsonType ? "type" : "no:type",
+                reasonFileName
+            };
+        }
+    }
+    resolveModuleName(moduleName, containingFile, resolutionMode, noDtsResolution, allowJs) {
+        var _a, _b, _c;
+        var _d;
+        const moduleKey = this.getModuleKey(moduleName, resolutionMode, noDtsResolution, allowJs);
+        if (null == (_a = this.moduleResolutionCache[containingFile]) ? void 0 : _a[moduleKey]) {
+            const { resolution, trace } = this.moduleResolutionCache[containingFile][moduleKey];
+            return {
+                resolution,
+                trace
+            };
+        }
+        this.traceCollector.clear();
+        const resolution = typescript.resolveModuleName(moduleName, containingFile, noDtsResolution ? {
+            ...this.compilerOptions,
+            noDtsResolution,
+            allowJs
+        } : this.compilerOptions, this.compilerHost, noDtsResolution ? this.noDtsResolutionModuleResolutionCache : this.normalModuleResolutionCache, void 0, resolutionMode);
+        const trace = this.traceCollector.read();
+        if (!(null == (_b = this.moduleResolutionCache[containingFile]) ? void 0 : _b[moduleKey])) (null != (_c = (_d = this.moduleResolutionCache)[containingFile]) ? _c : _d[containingFile] = {})[moduleKey] = {
+            resolution,
+            trace
+        };
+        return {
+            resolution,
+            trace
+        };
+    }
+    getTrace(fromFileName, moduleSpecifier, resolutionMode) {
+        var _a, _b;
+        return null == (_b = null == (_a = this.moduleResolutionCache[fromFileName]) ? void 0 : _a[this.getModuleKey(moduleSpecifier, resolutionMode, void 0, void 0)]) ? void 0 : _b.trace;
+    }
+    getModuleKey(moduleSpecifier, resolutionMode, noDtsResolution, allowJs) {
+        return `${null != resolutionMode ? resolutionMode : 1}:${+!!noDtsResolution}:${+!!allowJs}:${moduleSpecifier}`;
+    }
+    getProgram(rootNames, options) {
+        const key = programKey(rootNames, options);
+        let program = this.programCache.get(key);
+        if (!program) this.programCache.set(key, program = typescript.createProgram({
+            rootNames,
+            options,
+            host: this.compilerHost
+        }));
+        return program;
+    }
+    createPrimaryProgram(rootName) {
+        var _a;
+        const program = this.getProgram([
+            rootName
+        ], this.compilerOptions);
+        null == (_a = program.resolvedModules) || _a.forEach((cache, path)=>{
+            let ownCache = this.resolvedModules.get(path);
+            if (!ownCache) this.resolvedModules.set(path, ownCache = typescript.createModeAwareCache());
+            cache.forEach((resolution, key, mode)=>{
+                ownCache.set(key, mode, resolution);
+            });
+        });
+        return program;
+    }
+    createAuxiliaryProgram(rootNames, extraOptions) {
+        if (extraOptions && typescript.changesAffectModuleResolution({
+            ...this.compilerOptions,
+            allowJs: extraOptions.allowJs,
+            checkJs: extraOptions.checkJs,
+            noDtsResolution: extraOptions.noDtsResolution
+        }, {
+            ...this.compilerOptions,
+            ...extraOptions
+        })) throw new Error("Cannot override resolution-affecting options for host due to potential cache pollution");
+        const options = extraOptions ? {
+            ...this.compilerOptions,
+            ...extraOptions
+        } : this.compilerOptions;
+        return this.getProgram(rootNames, options);
+    }
+    getResolvedModule(sourceFile, moduleName, resolutionMode) {
+        var _a;
+        return null == (_a = this.resolvedModules.get(sourceFile.path)) ? void 0 : _a.get(moduleName, resolutionMode);
+    }
+    createCompilerHost(fs, sourceFileCache) {
+        return {
+            fileExists: fs.fileExists.bind(fs),
+            readFile: fs.readFile.bind(fs),
+            directoryExists: fs.directoryExists.bind(fs),
+            getSourceFile: (fileName)=>{
+                const path = toPath(fileName);
+                const cached = sourceFileCache.get(path);
+                if (cached) return cached;
+                const content = "/node_modules/typescript/lib/lib.d.ts" === fileName ? minimalLibDts : fs.tryReadFile(fileName);
+                if (void 0 === content) return;
+                const sourceFile = typescript.createSourceFile(fileName, content, {
+                    languageVersion: this.languageVersion,
+                    impliedNodeFormat: this.getImpliedNodeFormatForFile(fileName)
+                }, true);
+                sourceFileCache.set(path, sourceFile);
+                return sourceFile;
+            },
+            getDefaultLibFileName: ()=>"/node_modules/typescript/lib/lib.d.ts",
+            getCurrentDirectory: ()=>"/",
+            writeFile: ()=>{
+                throw new Error("Not implemented");
+            },
+            getCanonicalFileName: getCanonicalFileName,
+            useCaseSensitiveFileNames: ()=>false,
+            getNewLine: ()=>"\n",
+            trace: this.traceCollector.trace,
+            resolveModuleNameLiterals: (moduleLiterals, containingFile, _redirectedReference, options, containingSourceFile)=>moduleLiterals.map((literal)=>this.resolveModuleName(literal.text, containingFile, typescript.getModeForUsageLocation(containingSourceFile, literal, this.compilerOptions), options.noDtsResolution).resolution)
+        };
+    }
+    getImpliedNodeFormatForFile(fileName) {
+        return typescript.getImpliedNodeFormatForFile(toPath(fileName), this.normalModuleResolutionCache.getPackageJsonInfoCache(), this.compilerHost, this.compilerOptions);
+    }
+    getPackageScopeForPath(fileName) {
+        return typescript.getPackageScopeForPath(fileName, typescript.getTemporaryModuleResolutionState(this.normalModuleResolutionCache.getPackageJsonInfoCache(), this.compilerHost, this.compilerOptions));
+    }
+}
+class TraceCollector {
+    constructor(){
+        this.traces = [];
+        this.trace = (message)=>{
+            this.traces.push(message);
+        };
+    }
+    read() {
+        const result = this.traces.slice();
+        this.clear();
+        return result;
+    }
+    clear() {
+        this.traces.length = 0;
+    }
+}
+function programKey(rootNames, options) {
+    return JSON.stringify([
+        rootNames,
+        Object.entries(options).sort(([k1], [k2])=>k1.localeCompare(k2))
+    ]);
+}
+const getEntrypointInfo_extensions = new Set([
+    ".jsx",
+    ".tsx",
+    ".js",
+    ".ts",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cjs"
+]);
+function getEntrypoints(fs, exportsObject, options) {
+    var _a, _b;
+    if (null == options ? void 0 : options.entrypoints) return options.entrypoints.map((e)=>formatEntrypointString(e, fs.packageName));
+    if (void 0 === exportsObject && fs) {
+        const rootDir = `/node_modules/${fs.packageName}`;
+        const proxies = getProxyDirectories(rootDir, fs);
+        if (0 === proxies.length) {
+            if (null == options ? void 0 : options.entrypointsLegacy) return fs.listFiles().filter((f)=>!typescript.isDeclarationFileName(f) && getEntrypointInfo_extensions.has(f.slice(f.lastIndexOf(".")))).map((f)=>"." + f.slice(rootDir.length));
+            return [
+                "."
+            ];
+        }
+        return proxies;
+    }
+    const detectedSubpaths = getSubpaths(exportsObject);
+    if (0 === detectedSubpaths.length) detectedSubpaths.push(".");
+    const included = unique([
+        ...detectedSubpaths,
+        ...null != (_b = null == (_a = null == options ? void 0 : options.includeEntrypoints) ? void 0 : _a.map((e)=>formatEntrypointString(e, fs.packageName))) ? _b : []
+    ]);
+    if (!(null == options ? void 0 : options.excludeEntrypoints)) return included;
+    return included.filter((entrypoint)=>!options.excludeEntrypoints.some((exclusion)=>{
+            if ("string" == typeof exclusion) return formatEntrypointString(exclusion, fs.packageName) === entrypoint;
+            return exclusion.test(entrypoint);
+        }));
+}
+function formatEntrypointString(path, packageName) {
+    return ("." === path || path.startsWith("./") ? path : path === packageName ? "." : path.startsWith(`${packageName}/`) ? `.${path.slice(packageName.length)}` : `./${path}`).trim();
+}
+function getSubpaths(exportsObject) {
+    if (!exportsObject || "object" != typeof exportsObject || Array.isArray(exportsObject)) return [];
+    const keys = Object.keys(exportsObject);
+    if (keys[0].startsWith(".")) return keys;
+    return keys.flatMap((key)=>getSubpaths(exportsObject[key]));
+}
+function getProxyDirectories(rootDir, fs) {
+    const vendorDirectories = new Set();
+    const proxyDirectories = [];
+    const files = fs.listFiles().sort((a, b)=>a.length - b.length);
+    for (const file of files)if (file.startsWith(rootDir) && file.endsWith("/package.json")) try {
+        const packageJson = JSON.parse(fs.readFile(file));
+        if (packageJson.name && !packageJson.name.startsWith(fs.packageName)) {
+            const vendorDir = file.slice(0, file.lastIndexOf("/"));
+            vendorDirectories.add(vendorDir);
+        } else if ("main" in packageJson && !isInsideVendorDirectory(file)) {
+            const proxyDir = "." + file.slice(rootDir.length, file.lastIndexOf("/"));
+            proxyDirectories.push(proxyDir);
+        }
+    } catch  {}
+    return proxyDirectories.sort((a, b)=>typescript.comparePathsCaseInsensitive(a, b));
+    function isInsideVendorDirectory(file) {
+        return !!typescript.forEachAncestorDirectory(file, (dir)=>{
+            if (vendorDirectories.has(dir)) return true;
+        });
+    }
+}
+function getEntrypointInfo(packageName, fs, hosts, options) {
+    const packageJson = JSON.parse(fs.readFile(`/node_modules/${packageName}/package.json`));
+    let entrypoints = getEntrypoints(fs, packageJson.exports, options);
+    if (fs.typesPackage) {
+        const typesPackageJson = JSON.parse(fs.readFile(`/node_modules/${fs.typesPackage.packageName}/package.json`));
+        const typesEntrypoints = getEntrypoints(fs, typesPackageJson.exports, options);
+        entrypoints = unique([
+            ...entrypoints,
+            ...typesEntrypoints
+        ]);
+    }
+    const result = {};
+    for (const entrypoint of entrypoints){
+        const resolutions = {
+            node10: getEntrypointResolution(packageName, hosts.node10, "node10", entrypoint),
+            "node16-cjs": getEntrypointResolution(packageName, hosts.node16, "node16-cjs", entrypoint),
+            "node16-esm": getEntrypointResolution(packageName, hosts.node16, "node16-esm", entrypoint),
+            bundler: getEntrypointResolution(packageName, hosts.bundler, "bundler", entrypoint)
+        };
+        result[entrypoint] = {
+            subpath: entrypoint,
+            resolutions,
+            hasTypes: Object.values(resolutions).some((r)=>{
+                var _a;
+                return null == (_a = r.resolution) ? void 0 : _a.isTypeScript;
+            }),
+            isWildcard: !!resolutions.bundler.isWildcard
+        };
+    }
+    return result;
+}
+function getEntrypointResolution(packageName, host, resolutionKind, entrypoint) {
+    if (entrypoint.includes("*")) return {
+        name: entrypoint,
+        resolutionKind,
+        isWildcard: true
+    };
+    const moduleSpecifier = packageName + entrypoint.substring(1);
+    const importingFileName = "node16-esm" === resolutionKind ? "/index.mts" : "/index.ts";
+    const resolutionMode = "node16-esm" === resolutionKind ? typescript.ModuleKind.ESNext : "node16-cjs" === resolutionKind ? typescript.ModuleKind.CommonJS : void 0;
+    const resolution = tryResolve();
+    const implementationResolution = tryResolve(true);
+    const files = resolution ? host.createPrimaryProgram(resolution.fileName).getSourceFiles().map((f)=>f.fileName) : void 0;
+    return {
+        name: entrypoint,
+        resolutionKind,
+        resolution,
+        implementationResolution,
+        files
+    };
+    function tryResolve(noDtsResolution) {
+        var _a;
+        const { resolution, trace } = host.resolveModuleName(moduleSpecifier, importingFileName, resolutionMode, noDtsResolution);
+        const fileName = null == (_a = resolution.resolvedModule) ? void 0 : _a.resolvedFileName;
+        if (!fileName) return;
+        return {
+            fileName,
+            isJson: resolution.resolvedModule.extension === typescript.Extension.Json,
+            isTypeScript: typescript.hasTSFileExtension(resolution.resolvedModule.resolvedFileName),
+            trace
+        };
+    }
+}
+function unique(array) {
+    return array.filter((value, index)=>array.indexOf(value) === index);
+}
+function getBuildTools(packageJson) {
+    if (!packageJson.devDependencies) return {};
+    const result = {};
+    for (const buildTool of allBuildTools)if (buildTool in packageJson.devDependencies) result[buildTool] = packageJson.devDependencies[buildTool];
+    return result;
+}
+function getModuleKinds(entrypoints, resolutionOption, hosts) {
+    var _a;
+    const host = hosts[resolutionOption];
+    const result = {};
+    for (const resolutionKind of getResolutionKinds(resolutionOption))for (const entrypoint of Object.values(entrypoints)){
+        const resolution = entrypoint.resolutions[resolutionKind];
+        for (const fileName of null != (_a = resolution.files) ? _a : [])if (!result[fileName]) result[fileName] = host.getModuleKindForFile(fileName);
+        if (resolution.implementationResolution) {
+            const fileName = resolution.implementationResolution.fileName;
+            if (!result[fileName]) result[fileName] = host.getModuleKindForFile(fileName);
+        }
+    }
+    return result;
+}
+async function checkPackage(pkg, options) {
+    const types = pkg.typesPackage ? {
+        kind: "@types",
+        ...pkg.typesPackage,
+        definitelyTypedUrl: JSON.parse(pkg.readFile(`/node_modules/${pkg.typesPackage.packageName}/package.json`)).homepage
+    } : pkg.containsTypes() ? {
+        kind: "included"
+    } : false;
+    const { packageName, packageVersion } = pkg;
+    if (!types) return {
+        packageName,
+        packageVersion,
+        types
+    };
+    const hosts = createCompilerHosts(pkg);
+    const entrypointResolutions = getEntrypointInfo(packageName, pkg, hosts, options);
+    const programInfo = {
+        node10: {},
+        node16: {
+            moduleKinds: getModuleKinds(entrypointResolutions, "node16", hosts)
+        },
+        bundler: {}
+    };
+    await lexer_init();
+    const problems = [];
+    const problemIdsToIndices = new Map();
+    visitResolutions(entrypointResolutions, (analysis, info)=>{
+        var _a;
+        for (const check of checks){
+            const context = {
+                pkg,
+                hosts,
+                entrypoints: entrypointResolutions,
+                programInfo,
+                subpath: info.subpath,
+                resolutionKind: analysis.resolutionKind,
+                resolutionOption: getResolutionOption(analysis.resolutionKind),
+                fileName: void 0
+            };
+            if (check.enumerateFiles) {
+                for (const fileName of null != (_a = analysis.files) ? _a : [])runCheck(check, {
+                    ...context,
+                    fileName
+                }, analysis);
+                if (analysis.implementationResolution) runCheck(check, {
+                    ...context,
+                    fileName: analysis.implementationResolution.fileName
+                }, analysis);
+            } else runCheck(check, context, analysis);
+        }
+    });
+    return {
+        packageName,
+        packageVersion,
+        types,
+        buildTools: getBuildTools(JSON.parse(pkg.readFile(`/node_modules/${packageName}/package.json`))),
+        entrypoints: entrypointResolutions,
+        programInfo,
+        problems
+    };
+    function runCheck(check, context, analysis) {
+        var _a, _b;
+        const dependencies = check.dependencies(context);
+        const id = check.name + JSON.stringify(dependencies, (_, value)=>{
+            if ("function" == typeof value) throw new Error("Encountered unexpected function in check dependencies");
+            return value;
+        });
+        let indices = problemIdsToIndices.get(id);
+        if (indices) (null != (_a = analysis.visibleProblems) ? _a : analysis.visibleProblems = []).push(...indices);
+        else {
+            indices = [];
+            const checkProblems = check.execute(dependencies, context);
+            for (const problem of Array.isArray(checkProblems) ? checkProblems : checkProblems ? [
+                checkProblems
+            ] : []){
+                indices.push(problems.length);
+                problems.push(problem);
+            }
+            problemIdsToIndices.set(id, indices);
+            (null != (_b = analysis.visibleProblems) ? _b : analysis.visibleProblems = []).push(...indices);
+        }
+    }
+}
+export { checkPackage, createPackageFromTarballData };