rsbuild-plugin-arethetypeswrong 0.2.0 → 0.3.0

package/dist/render.js

@@ -0,0 +1,1836 @@
+/*! LICENSE: render.js.LICENSE.txt */
+import { styleText } from "node:util";
+import { __webpack_require__ } from "./453.js";
+import { problemFlags, moduleKinds, resolutionKinds, filterProblems, problemAffectsEntrypoint, problemKindInfo, problemAffectsResolutionKind } from "./854.js";
+import { allResolutionKinds, getResolutionOption, groupProblemsByKind } from "./utils.js";
+import "./453.js";
+__webpack_require__.add({
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/colors.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var colors = {};
+        module.exports = colors;
+        colors.themes = {};
+        var util = __webpack_require__("util");
+        var ansiStyles = colors.styles = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/styles.js");
+        var defineProps = Object.defineProperties;
+        var newLineRegex = new RegExp(/[\r\n]+/g);
+        colors.supportsColor = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/supports-colors.js").supportsColor;
+        if (void 0 === colors.enabled) colors.enabled = false !== colors.supportsColor();
+        colors.enable = function() {
+            colors.enabled = true;
+        };
+        colors.disable = function() {
+            colors.enabled = false;
+        };
+        colors.stripColors = colors.strip = function(str) {
+            return ('' + str).replace(/\x1B\[\d+m/g, '');
+        };
+        colors.stylize = function(str, style) {
+            if (!colors.enabled) return str + '';
+            var styleMap = ansiStyles[style];
+            if (!styleMap && style in colors) return colors[style](str);
+            return styleMap.open + str + styleMap.close;
+        };
+        var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+        var escapeStringRegexp = function(str) {
+            if ('string' != typeof str) throw new TypeError('Expected a string');
+            return str.replace(matchOperatorsRe, '\\$&');
+        };
+        function build(_styles) {
+            var builder = function builder() {
+                return applyStyle.apply(builder, arguments);
+            };
+            builder._styles = _styles;
+            builder.__proto__ = proto;
+            return builder;
+        }
+        var styles = function() {
+            var ret = {};
+            ansiStyles.grey = ansiStyles.gray;
+            Object.keys(ansiStyles).forEach(function(key) {
+                ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+                ret[key] = {
+                    get: function() {
+                        return build(this._styles.concat(key));
+                    }
+                };
+            });
+            return ret;
+        }();
+        var proto = defineProps(function() {}, styles);
+        function applyStyle() {
+            var args = Array.prototype.slice.call(arguments);
+            var str = args.map(function(arg) {
+                if (null != arg && arg.constructor === String) return arg;
+                return util.inspect(arg);
+            }).join(' ');
+            if (!colors.enabled || !str) return str;
+            var newLinesPresent = -1 != str.indexOf('\n');
+            var nestedStyles = this._styles;
+            var i = nestedStyles.length;
+            while(i--){
+                var code = ansiStyles[nestedStyles[i]];
+                str = code.open + str.replace(code.closeRe, code.open) + code.close;
+                if (newLinesPresent) str = str.replace(newLineRegex, function(match) {
+                    return code.close + match + code.open;
+                });
+            }
+            return str;
+        }
+        colors.setTheme = function(theme) {
+            if ('string' == typeof theme) return void console.log("colors.setTheme now only accepts an object, not a string.  If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file.  The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
+            for(var style in theme)(function(style) {
+                colors[style] = function(str) {
+                    if ('object' == typeof theme[style]) {
+                        var out = str;
+                        for(var i in theme[style])out = colors[theme[style][i]](out);
+                        return out;
+                    }
+                    return colors[theme[style]](str);
+                };
+            })(style);
+        };
+        function init() {
+            var ret = {};
+            Object.keys(styles).forEach(function(name) {
+                ret[name] = {
+                    get: function() {
+                        return build([
+                            name
+                        ]);
+                    }
+                };
+            });
+            return ret;
+        }
+        var sequencer = function(map, str) {
+            var exploded = str.split('');
+            exploded = exploded.map(map);
+            return exploded.join('');
+        };
+        colors.trap = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/trap.js");
+        colors.zalgo = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/zalgo.js");
+        colors.maps = {};
+        colors.maps.america = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/america.js")(colors);
+        colors.maps.zebra = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/zebra.js")(colors);
+        colors.maps.rainbow = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/rainbow.js")(colors);
+        colors.maps.random = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/random.js")(colors);
+        for(var map in colors.maps)(function(map) {
+            colors[map] = function(str) {
+                return sequencer(colors.maps[map], str);
+            };
+        })(map);
+        defineProps(colors, init());
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/trap.js" (module) {
+        module.exports = function(text, options) {
+            var result = '';
+            text = text || 'Run the trap, drop the bass';
+            text = text.split('');
+            var trap = {
+                a: [
+                    '\u0040',
+                    '\u0104',
+                    '\u023a',
+                    '\u0245',
+                    '\u0394',
+                    '\u039b',
+                    '\u0414'
+                ],
+                b: [
+                    '\u00df',
+                    '\u0181',
+                    '\u0243',
+                    '\u026e',
+                    '\u03b2',
+                    '\u0e3f'
+                ],
+                c: [
+                    '\u00a9',
+                    '\u023b',
+                    '\u03fe'
+                ],
+                d: [
+                    '\u00d0',
+                    '\u018a',
+                    '\u0500',
+                    '\u0501',
+                    '\u0502',
+                    '\u0503'
+                ],
+                e: [
+                    '\u00cb',
+                    '\u0115',
+                    '\u018e',
+                    '\u0258',
+                    '\u03a3',
+                    '\u03be',
+                    '\u04bc',
+                    '\u0a6c'
+                ],
+                f: [
+                    '\u04fa'
+                ],
+                g: [
+                    '\u0262'
+                ],
+                h: [
+                    '\u0126',
+                    '\u0195',
+                    '\u04a2',
+                    '\u04ba',
+                    '\u04c7',
+                    '\u050a'
+                ],
+                i: [
+                    '\u0f0f'
+                ],
+                j: [
+                    '\u0134'
+                ],
+                k: [
+                    '\u0138',
+                    '\u04a0',
+                    '\u04c3',
+                    '\u051e'
+                ],
+                l: [
+                    '\u0139'
+                ],
+                m: [
+                    '\u028d',
+                    '\u04cd',
+                    '\u04ce',
+                    '\u0520',
+                    '\u0521',
+                    '\u0d69'
+                ],
+                n: [
+                    '\u00d1',
+                    '\u014b',
+                    '\u019d',
+                    '\u0376',
+                    '\u03a0',
+                    '\u048a'
+                ],
+                o: [
+                    '\u00d8',
+                    '\u00f5',
+                    '\u00f8',
+                    '\u01fe',
+                    '\u0298',
+                    '\u047a',
+                    '\u05dd',
+                    '\u06dd',
+                    '\u0e4f'
+                ],
+                p: [
+                    '\u01f7',
+                    '\u048e'
+                ],
+                q: [
+                    '\u09cd'
+                ],
+                r: [
+                    '\u00ae',
+                    '\u01a6',
+                    '\u0210',
+                    '\u024c',
+                    '\u0280',
+                    '\u042f'
+                ],
+                s: [
+                    '\u00a7',
+                    '\u03de',
+                    '\u03df',
+                    '\u03e8'
+                ],
+                t: [
+                    '\u0141',
+                    '\u0166',
+                    '\u0373'
+                ],
+                u: [
+                    '\u01b1',
+                    '\u054d'
+                ],
+                v: [
+                    '\u05d8'
+                ],
+                w: [
+                    '\u0428',
+                    '\u0460',
+                    '\u047c',
+                    '\u0d70'
+                ],
+                x: [
+                    '\u04b2',
+                    '\u04fe',
+                    '\u04fc',
+                    '\u04fd'
+                ],
+                y: [
+                    '\u00a5',
+                    '\u04b0',
+                    '\u04cb'
+                ],
+                z: [
+                    '\u01b5',
+                    '\u0240'
+                ]
+            };
+            text.forEach(function(c) {
+                c = c.toLowerCase();
+                var chars = trap[c] || [
+                    ' '
+                ];
+                var rand = Math.floor(Math.random() * chars.length);
+                if (void 0 !== trap[c]) result += trap[c][rand];
+                else result += c;
+            });
+            return result;
+        };
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/zalgo.js" (module) {
+        module.exports = function(text, options) {
+            text = text || '   he is here   ';
+            var soul = {
+                up: [
+                    '̍',
+                    '̎',
+                    '̄',
+                    '̅',
+                    '̿',
+                    '̑',
+                    '̆',
+                    '̐',
+                    '͒',
+                    '͗',
+                    '͑',
+                    '̇',
+                    '̈',
+                    '̊',
+                    '͂',
+                    '̓',
+                    '̈',
+                    '͊',
+                    '͋',
+                    '͌',
+                    '̃',
+                    '̂',
+                    '̌',
+                    '͐',
+                    '̀',
+                    '́',
+                    '̋',
+                    '̏',
+                    '̒',
+                    '̓',
+                    '̔',
+                    '̽',
+                    '̉',
+                    'ͣ',
+                    'ͤ',
+                    'ͥ',
+                    'ͦ',
+                    'ͧ',
+                    'ͨ',
+                    'ͩ',
+                    'ͪ',
+                    'ͫ',
+                    'ͬ',
+                    'ͭ',
+                    'ͮ',
+                    'ͯ',
+                    '̾',
+                    '͛',
+                    '͆',
+                    '̚'
+                ],
+                down: [
+                    '̖',
+                    '̗',
+                    '̘',
+                    '̙',
+                    '̜',
+                    '̝',
+                    '̞',
+                    '̟',
+                    '̠',
+                    '̤',
+                    '̥',
+                    '̦',
+                    '̩',
+                    '̪',
+                    '̫',
+                    '̬',
+                    '̭',
+                    '̮',
+                    '̯',
+                    '̰',
+                    '̱',
+                    '̲',
+                    '̳',
+                    '̹',
+                    '̺',
+                    '̻',
+                    '̼',
+                    'ͅ',
+                    '͇',
+                    '͈',
+                    '͉',
+                    '͍',
+                    '͎',
+                    '͓',
+                    '͔',
+                    '͕',
+                    '͖',
+                    '͙',
+                    '͚',
+                    '̣'
+                ],
+                mid: [
+                    '̕',
+                    '̛',
+                    '̀',
+                    '́',
+                    '͘',
+                    '̡',
+                    '̢',
+                    '̧',
+                    '̨',
+                    '̴',
+                    '̵',
+                    '̶',
+                    '͜',
+                    '͝',
+                    '͞',
+                    '͟',
+                    '͠',
+                    '͢',
+                    '̸',
+                    '̷',
+                    '͡',
+                    ' ҉'
+                ]
+            };
+            var all = [].concat(soul.up, soul.down, soul.mid);
+            function randomNumber(range) {
+                var r = Math.floor(Math.random() * range);
+                return r;
+            }
+            function isChar(character) {
+                var bool = false;
+                all.filter(function(i) {
+                    bool = i === character;
+                });
+                return bool;
+            }
+            function heComes(text, options) {
+                var result = '';
+                var counts;
+                var l;
+                options = options || {};
+                options['up'] = void 0 !== options['up'] ? options['up'] : true;
+                options['mid'] = void 0 !== options['mid'] ? options['mid'] : true;
+                options['down'] = void 0 !== options['down'] ? options['down'] : true;
+                options['size'] = void 0 !== options['size'] ? options['size'] : 'maxi';
+                text = text.split('');
+                for(l in text)if (!isChar(l)) {
+                    result += text[l];
+                    counts = {
+                        up: 0,
+                        down: 0,
+                        mid: 0
+                    };
+                    switch(options.size){
+                        case 'mini':
+                            counts.up = randomNumber(8);
+                            counts.mid = randomNumber(2);
+                            counts.down = randomNumber(8);
+                            break;
+                        case 'maxi':
+                            counts.up = randomNumber(16) + 3;
+                            counts.mid = randomNumber(4) + 1;
+                            counts.down = randomNumber(64) + 3;
+                            break;
+                        default:
+                            counts.up = randomNumber(8) + 1;
+                            counts.mid = randomNumber(6) / 2;
+                            counts.down = randomNumber(8) + 1;
+                            break;
+                    }
+                    var arr = [
+                        'up',
+                        'mid',
+                        'down'
+                    ];
+                    for(var d in arr){
+                        var index = arr[d];
+                        for(var i = 0; i <= counts[index]; i++)if (options[index]) result += soul[index][randomNumber(soul[index].length)];
+                    }
+                }
+                return result;
+            }
+            return heComes(text, options);
+        };
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/america.js" (module) {
+        module.exports = function(colors) {
+            return function(letter, i, exploded) {
+                if (' ' === letter) return letter;
+                switch(i % 3){
+                    case 0:
+                        return colors.red(letter);
+                    case 1:
+                        return colors.white(letter);
+                    case 2:
+                        return colors.blue(letter);
+                }
+            };
+        };
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/rainbow.js" (module) {
+        module.exports = function(colors) {
+            var rainbowColors = [
+                'red',
+                'yellow',
+                'green',
+                'blue',
+                'magenta'
+            ];
+            return function(letter, i, exploded) {
+                if (' ' === letter) return letter;
+                return colors[rainbowColors[i++ % rainbowColors.length]](letter);
+            };
+        };
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/random.js" (module) {
+        module.exports = function(colors) {
+            var available = [
+                'underline',
+                'inverse',
+                'grey',
+                'yellow',
+                'red',
+                'green',
+                'blue',
+                'white',
+                'cyan',
+                'magenta',
+                'brightYellow',
+                'brightRed',
+                'brightGreen',
+                'brightBlue',
+                'brightWhite',
+                'brightCyan',
+                'brightMagenta'
+            ];
+            return function(letter, i, exploded) {
+                return ' ' === letter ? letter : colors[available[Math.round(Math.random() * (available.length - 2))]](letter);
+            };
+        };
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/zebra.js" (module) {
+        module.exports = function(colors) {
+            return function(letter, i, exploded) {
+                return i % 2 === 0 ? letter : colors.inverse(letter);
+            };
+        };
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/styles.js" (module) {
+        var styles = {};
+        module.exports = styles;
+        var codes = {
+            reset: [
+                0,
+                0
+            ],
+            bold: [
+                1,
+                22
+            ],
+            dim: [
+                2,
+                22
+            ],
+            italic: [
+                3,
+                23
+            ],
+            underline: [
+                4,
+                24
+            ],
+            inverse: [
+                7,
+                27
+            ],
+            hidden: [
+                8,
+                28
+            ],
+            strikethrough: [
+                9,
+                29
+            ],
+            black: [
+                30,
+                39
+            ],
+            red: [
+                31,
+                39
+            ],
+            green: [
+                32,
+                39
+            ],
+            yellow: [
+                33,
+                39
+            ],
+            blue: [
+                34,
+                39
+            ],
+            magenta: [
+                35,
+                39
+            ],
+            cyan: [
+                36,
+                39
+            ],
+            white: [
+                37,
+                39
+            ],
+            gray: [
+                90,
+                39
+            ],
+            grey: [
+                90,
+                39
+            ],
+            brightRed: [
+                91,
+                39
+            ],
+            brightGreen: [
+                92,
+                39
+            ],
+            brightYellow: [
+                93,
+                39
+            ],
+            brightBlue: [
+                94,
+                39
+            ],
+            brightMagenta: [
+                95,
+                39
+            ],
+            brightCyan: [
+                96,
+                39
+            ],
+            brightWhite: [
+                97,
+                39
+            ],
+            bgBlack: [
+                40,
+                49
+            ],
+            bgRed: [
+                41,
+                49
+            ],
+            bgGreen: [
+                42,
+                49
+            ],
+            bgYellow: [
+                43,
+                49
+            ],
+            bgBlue: [
+                44,
+                49
+            ],
+            bgMagenta: [
+                45,
+                49
+            ],
+            bgCyan: [
+                46,
+                49
+            ],
+            bgWhite: [
+                47,
+                49
+            ],
+            bgGray: [
+                100,
+                49
+            ],
+            bgGrey: [
+                100,
+                49
+            ],
+            bgBrightRed: [
+                101,
+                49
+            ],
+            bgBrightGreen: [
+                102,
+                49
+            ],
+            bgBrightYellow: [
+                103,
+                49
+            ],
+            bgBrightBlue: [
+                104,
+                49
+            ],
+            bgBrightMagenta: [
+                105,
+                49
+            ],
+            bgBrightCyan: [
+                106,
+                49
+            ],
+            bgBrightWhite: [
+                107,
+                49
+            ],
+            blackBG: [
+                40,
+                49
+            ],
+            redBG: [
+                41,
+                49
+            ],
+            greenBG: [
+                42,
+                49
+            ],
+            yellowBG: [
+                43,
+                49
+            ],
+            blueBG: [
+                44,
+                49
+            ],
+            magentaBG: [
+                45,
+                49
+            ],
+            cyanBG: [
+                46,
+                49
+            ],
+            whiteBG: [
+                47,
+                49
+            ]
+        };
+        Object.keys(codes).forEach(function(key) {
+            var val = codes[key];
+            var style = styles[key] = [];
+            style.open = '\u001b[' + val[0] + 'm';
+            style.close = '\u001b[' + val[1] + 'm';
+        });
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/has-flag.js" (module) {
+        module.exports = function(flag, argv) {
+            argv = argv || process.argv;
+            var terminatorPos = argv.indexOf('--');
+            var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+            var pos = argv.indexOf(prefix + flag);
+            return -1 !== pos && (-1 === terminatorPos ? true : pos < terminatorPos);
+        };
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/supports-colors.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var os = __webpack_require__("os");
+        var hasFlag = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/has-flag.js");
+        var env = process.env;
+        var forceColor = void 0;
+        if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false')) forceColor = false;
+        else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) forceColor = true;
+        if ('FORCE_COLOR' in env) forceColor = 0 === env.FORCE_COLOR.length || 0 !== parseInt(env.FORCE_COLOR, 10);
+        function translateLevel(level) {
+            if (0 === level) return false;
+            return {
+                level: level,
+                hasBasic: true,
+                has256: level >= 2,
+                has16m: level >= 3
+            };
+        }
+        function supportsColor(stream) {
+            if (false === forceColor) return 0;
+            if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) return 3;
+            if (hasFlag('color=256')) return 2;
+            if (stream && !stream.isTTY && true !== forceColor) return 0;
+            var min = forceColor ? 1 : 0;
+            if ('win32' === process.platform) {
+                var osRelease = os.release().split('.');
+                if (Number(process.versions.node.split('.')[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+                return 1;
+            }
+            if ('CI' in env) {
+                if ([
+                    'TRAVIS',
+                    'CIRCLECI',
+                    'APPVEYOR',
+                    'GITLAB_CI'
+                ].some(function(sign) {
+                    return sign in env;
+                }) || 'codeship' === env.CI_NAME) return 1;
+                return min;
+            }
+            if ('TEAMCITY_VERSION' in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+            if ('TERM_PROGRAM' in env) {
+                var version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+                switch(env.TERM_PROGRAM){
+                    case 'iTerm.app':
+                        return version >= 3 ? 3 : 2;
+                    case 'Hyper':
+                        return 3;
+                    case 'Apple_Terminal':
+                        return 2;
+                }
+            }
+            if (/-256(color)?$/i.test(env.TERM)) return 2;
+            if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+            if ('COLORTERM' in env) return 1;
+            env.TERM;
+            return min;
+        }
+        function getSupportLevel(stream) {
+            var level = supportsColor(stream);
+            return translateLevel(level);
+        }
+        module.exports = {
+            supportsColor: getSupportLevel,
+            stdout: getSupportLevel(process.stdout),
+            stderr: getSupportLevel(process.stderr)
+        };
+    },
+    "./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/safe.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var colors = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/colors.js");
+        module.exports = colors;
+    },
+    "./node_modules/.pnpm/ansi-regex@5.0.1/node_modules/ansi-regex/index.js" (module) {
+        module.exports = ({ onlyFirst = false } = {})=>{
+            const pattern = "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))";
+            return new RegExp(pattern, onlyFirst ? void 0 : 'g');
+        };
+    },
+    "./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/table.js");
+    },
+    "./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/cell.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const { info, debug } = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/debug.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/utils.js");
+        class Cell {
+            constructor(options){
+                this.setOptions(options);
+                this.x = null;
+                this.y = null;
+            }
+            setOptions(options) {
+                if (-1 !== [
+                    'boolean',
+                    'number',
+                    'bigint',
+                    'string'
+                ].indexOf(typeof options)) options = {
+                    content: '' + options
+                };
+                options = options || {};
+                this.options = options;
+                let content = options.content;
+                if (-1 !== [
+                    'boolean',
+                    'number',
+                    'bigint',
+                    'string'
+                ].indexOf(typeof content)) this.content = String(content);
+                else if (content) throw new Error('Content needs to be a primitive, got: ' + typeof content);
+                else this.content = this.options.href || '';
+                this.colSpan = options.colSpan || 1;
+                this.rowSpan = options.rowSpan || 1;
+                if (this.options.href) Object.defineProperty(this, 'href', {
+                    get () {
+                        return this.options.href;
+                    }
+                });
+            }
+            mergeTableOptions(tableOptions, cells) {
+                this.cells = cells;
+                let optionsChars = this.options.chars || {};
+                let tableChars = tableOptions.chars;
+                let chars = this.chars = {};
+                CHAR_NAMES.forEach(function(name) {
+                    setOption(optionsChars, tableChars, name, chars);
+                });
+                this.truncate = this.options.truncate || tableOptions.truncate;
+                let style = this.options.style = this.options.style || {};
+                let tableStyle = tableOptions.style;
+                setOption(style, tableStyle, 'padding-left', this);
+                setOption(style, tableStyle, 'padding-right', this);
+                this.head = style.head || tableStyle.head;
+                this.border = style.border || tableStyle.border;
+                this.fixedWidth = tableOptions.colWidths[this.x];
+                this.lines = this.computeLines(tableOptions);
+                this.desiredWidth = utils.strlen(this.content) + this.paddingLeft + this.paddingRight;
+                this.desiredHeight = this.lines.length;
+            }
+            computeLines(tableOptions) {
+                const tableWordWrap = tableOptions.wordWrap || tableOptions.textWrap;
+                const { wordWrap = tableWordWrap } = this.options;
+                if (this.fixedWidth && wordWrap) {
+                    this.fixedWidth -= this.paddingLeft + this.paddingRight;
+                    if (this.colSpan) {
+                        let i = 1;
+                        while(i < this.colSpan){
+                            this.fixedWidth += tableOptions.colWidths[this.x + i];
+                            i++;
+                        }
+                    }
+                    const { wrapOnWordBoundary: tableWrapOnWordBoundary = true } = tableOptions;
+                    const { wrapOnWordBoundary = tableWrapOnWordBoundary } = this.options;
+                    return this.wrapLines(utils.wordWrap(this.fixedWidth, this.content, wrapOnWordBoundary));
+                }
+                return this.wrapLines(this.content.split('\n'));
+            }
+            wrapLines(computedLines) {
+                const lines = utils.colorizeLines(computedLines);
+                if (this.href) return lines.map((line)=>utils.hyperlink(this.href, line));
+                return lines;
+            }
+            init(tableOptions) {
+                let x = this.x;
+                let y = this.y;
+                this.widths = tableOptions.colWidths.slice(x, x + this.colSpan);
+                this.heights = tableOptions.rowHeights.slice(y, y + this.rowSpan);
+                this.width = this.widths.reduce(sumPlusOne, -1);
+                this.height = this.heights.reduce(sumPlusOne, -1);
+                this.hAlign = this.options.hAlign || tableOptions.colAligns[x];
+                this.vAlign = this.options.vAlign || tableOptions.rowAligns[y];
+                this.drawRight = x + this.colSpan == tableOptions.colWidths.length;
+            }
+            draw(lineNum, spanningCell) {
+                if ('top' == lineNum) return this.drawTop(this.drawRight);
+                if ('bottom' == lineNum) return this.drawBottom(this.drawRight);
+                let content = utils.truncate(this.content, 10, this.truncate);
+                if (!lineNum) info(`${this.y}-${this.x}: ${this.rowSpan - lineNum}x${this.colSpan} Cell ${content}`);
+                let padLen = Math.max(this.height - this.lines.length, 0);
+                let padTop;
+                switch(this.vAlign){
+                    case 'center':
+                        padTop = Math.ceil(padLen / 2);
+                        break;
+                    case 'bottom':
+                        padTop = padLen;
+                        break;
+                    default:
+                        padTop = 0;
+                }
+                if (lineNum < padTop || lineNum >= padTop + this.lines.length) return this.drawEmpty(this.drawRight, spanningCell);
+                let forceTruncation = this.lines.length > this.height && lineNum + 1 >= this.height;
+                return this.drawLine(lineNum - padTop, this.drawRight, forceTruncation, spanningCell);
+            }
+            drawTop(drawRight) {
+                let content = [];
+                if (this.cells) this.widths.forEach(function(width, index) {
+                    content.push(this._topLeftChar(index));
+                    content.push(utils.repeat(this.chars[0 == this.y ? 'top' : 'mid'], width));
+                }, this);
+                else {
+                    content.push(this._topLeftChar(0));
+                    content.push(utils.repeat(this.chars[0 == this.y ? 'top' : 'mid'], this.width));
+                }
+                if (drawRight) content.push(this.chars[0 == this.y ? 'topRight' : 'rightMid']);
+                return this.wrapWithStyleColors('border', content.join(''));
+            }
+            _topLeftChar(offset) {
+                let x = this.x + offset;
+                let leftChar;
+                if (0 == this.y) leftChar = 0 == x ? 'topLeft' : 0 == offset ? 'topMid' : 'top';
+                else if (0 == x) leftChar = 'leftMid';
+                else {
+                    leftChar = 0 == offset ? 'midMid' : 'bottomMid';
+                    if (this.cells) {
+                        let spanAbove = this.cells[this.y - 1][x] instanceof Cell.ColSpanCell;
+                        if (spanAbove) leftChar = 0 == offset ? 'topMid' : 'mid';
+                        if (0 == offset) {
+                            let i = 1;
+                            while(this.cells[this.y][x - i] instanceof Cell.ColSpanCell)i++;
+                            if (this.cells[this.y][x - i] instanceof Cell.RowSpanCell) leftChar = 'leftMid';
+                        }
+                    }
+                }
+                return this.chars[leftChar];
+            }
+            wrapWithStyleColors(styleProperty, content) {
+                if (!this[styleProperty] || !this[styleProperty].length) return content;
+                try {
+                    let colors = __webpack_require__("./node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/safe.js");
+                    for(let i = this[styleProperty].length - 1; i >= 0; i--)colors = colors[this[styleProperty][i]];
+                    return colors(content);
+                } catch (e) {
+                    return content;
+                }
+            }
+            drawLine(lineNum, drawRight, forceTruncationSymbol, spanningCell) {
+                let left = this.chars[0 == this.x ? 'left' : 'middle'];
+                if (this.x && spanningCell && this.cells) {
+                    let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
+                    while(cellLeft instanceof ColSpanCell)cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
+                    if (!(cellLeft instanceof RowSpanCell)) left = this.chars['rightMid'];
+                }
+                let leftPadding = utils.repeat(' ', this.paddingLeft);
+                let right = drawRight ? this.chars['right'] : '';
+                let rightPadding = utils.repeat(' ', this.paddingRight);
+                let line = this.lines[lineNum];
+                let len = this.width - (this.paddingLeft + this.paddingRight);
+                if (forceTruncationSymbol) line += this.truncate || '…';
+                let content = utils.truncate(line, len, this.truncate);
+                content = utils.pad(content, len, ' ', this.hAlign);
+                content = leftPadding + content + rightPadding;
+                return this.stylizeLine(left, content, right);
+            }
+            stylizeLine(left, content, right) {
+                left = this.wrapWithStyleColors('border', left);
+                right = this.wrapWithStyleColors('border', right);
+                if (0 === this.y) content = this.wrapWithStyleColors('head', content);
+                return left + content + right;
+            }
+            drawBottom(drawRight) {
+                let left = this.chars[0 == this.x ? 'bottomLeft' : 'bottomMid'];
+                let content = utils.repeat(this.chars.bottom, this.width);
+                let right = drawRight ? this.chars['bottomRight'] : '';
+                return this.wrapWithStyleColors('border', left + content + right);
+            }
+            drawEmpty(drawRight, spanningCell) {
+                let left = this.chars[0 == this.x ? 'left' : 'middle'];
+                if (this.x && spanningCell && this.cells) {
+                    let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
+                    while(cellLeft instanceof ColSpanCell)cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
+                    if (!(cellLeft instanceof RowSpanCell)) left = this.chars['rightMid'];
+                }
+                let right = drawRight ? this.chars['right'] : '';
+                let content = utils.repeat(' ', this.width);
+                return this.stylizeLine(left, content, right);
+            }
+        }
+        class ColSpanCell {
+            draw(lineNum) {
+                if ('number' == typeof lineNum) debug(`${this.y}-${this.x}: 1x1 ColSpanCell`);
+                return '';
+            }
+            init() {}
+            mergeTableOptions() {}
+        }
+        class RowSpanCell {
+            constructor(originalCell){
+                this.originalCell = originalCell;
+            }
+            init(tableOptions) {
+                let y = this.y;
+                let originalY = this.originalCell.y;
+                this.cellOffset = y - originalY;
+                this.offset = findDimension(tableOptions.rowHeights, originalY, this.cellOffset);
+            }
+            draw(lineNum) {
+                if ('top' == lineNum) return this.originalCell.draw(this.offset, this.cellOffset);
+                if ('bottom' == lineNum) return this.originalCell.draw('bottom');
+                debug(`${this.y}-${this.x}: 1x${this.colSpan} RowSpanCell for ${this.originalCell.content}`);
+                return this.originalCell.draw(this.offset + 1 + lineNum);
+            }
+            mergeTableOptions() {}
+        }
+        function firstDefined(...args) {
+            return args.filter((v)=>null != v).shift();
+        }
+        function setOption(objA, objB, nameB, targetObj) {
+            let nameA = nameB.split('-');
+            if (nameA.length > 1) {
+                nameA[1] = nameA[1].charAt(0).toUpperCase() + nameA[1].substr(1);
+                nameA = nameA.join('');
+                targetObj[nameA] = firstDefined(objA[nameA], objA[nameB], objB[nameA], objB[nameB]);
+            } else targetObj[nameB] = firstDefined(objA[nameB], objB[nameB]);
+        }
+        function findDimension(dimensionTable, startingIndex, span) {
+            let ret = dimensionTable[startingIndex];
+            for(let i = 1; i < span; i++)ret += 1 + dimensionTable[startingIndex + i];
+            return ret;
+        }
+        function sumPlusOne(a, b) {
+            return a + b + 1;
+        }
+        let CHAR_NAMES = [
+            'top',
+            'top-mid',
+            'top-left',
+            'top-right',
+            'bottom',
+            'bottom-mid',
+            'bottom-left',
+            'bottom-right',
+            'left',
+            'left-mid',
+            'mid',
+            'mid-mid',
+            'right',
+            'right-mid',
+            'middle'
+        ];
+        module.exports = Cell;
+        module.exports.ColSpanCell = ColSpanCell;
+        module.exports.RowSpanCell = RowSpanCell;
+    },
+    "./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/debug.js" (module) {
+        let messages = [];
+        let level = 0;
+        const debug = (msg, min)=>{
+            if (level >= min) messages.push(msg);
+        };
+        debug.WARN = 1;
+        debug.INFO = 2;
+        debug.DEBUG = 3;
+        debug.reset = ()=>{
+            messages = [];
+        };
+        debug.setDebugLevel = (v)=>{
+            level = v;
+        };
+        debug.warn = (msg)=>debug(msg, debug.WARN);
+        debug.info = (msg)=>debug(msg, debug.INFO);
+        debug.debug = (msg)=>debug(msg, debug.DEBUG);
+        debug.debugMessages = ()=>messages;
+        module.exports = debug;
+    },
+    "./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/layout-manager.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const { warn, debug } = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/debug.js");
+        const Cell = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/cell.js");
+        const { ColSpanCell, RowSpanCell } = Cell;
+        (function() {
+            function next(alloc, col) {
+                if (alloc[col] > 0) return next(alloc, col + 1);
+                return col;
+            }
+            function layoutTable(table) {
+                let alloc = {};
+                table.forEach(function(row, rowIndex) {
+                    let col = 0;
+                    row.forEach(function(cell) {
+                        cell.y = rowIndex;
+                        cell.x = rowIndex ? next(alloc, col) : col;
+                        const rowSpan = cell.rowSpan || 1;
+                        const colSpan = cell.colSpan || 1;
+                        if (rowSpan > 1) for(let cs = 0; cs < colSpan; cs++)alloc[cell.x + cs] = rowSpan;
+                        col = cell.x + colSpan;
+                    });
+                    Object.keys(alloc).forEach((idx)=>{
+                        alloc[idx]--;
+                        if (alloc[idx] < 1) delete alloc[idx];
+                    });
+                });
+            }
+            function maxWidth(table) {
+                let mw = 0;
+                table.forEach(function(row) {
+                    row.forEach(function(cell) {
+                        mw = Math.max(mw, cell.x + (cell.colSpan || 1));
+                    });
+                });
+                return mw;
+            }
+            function maxHeight(table) {
+                return table.length;
+            }
+            function cellsConflict(cell1, cell2) {
+                let yMin1 = cell1.y;
+                let yMax1 = cell1.y - 1 + (cell1.rowSpan || 1);
+                let yMin2 = cell2.y;
+                let yMax2 = cell2.y - 1 + (cell2.rowSpan || 1);
+                let yConflict = !(yMin1 > yMax2 || yMin2 > yMax1);
+                let xMin1 = cell1.x;
+                let xMax1 = cell1.x - 1 + (cell1.colSpan || 1);
+                let xMin2 = cell2.x;
+                let xMax2 = cell2.x - 1 + (cell2.colSpan || 1);
+                let xConflict = !(xMin1 > xMax2 || xMin2 > xMax1);
+                return yConflict && xConflict;
+            }
+            function conflictExists(rows, x, y) {
+                let i_max = Math.min(rows.length - 1, y);
+                let cell = {
+                    x: x,
+                    y: y
+                };
+                for(let i = 0; i <= i_max; i++){
+                    let row = rows[i];
+                    for(let j = 0; j < row.length; j++)if (cellsConflict(cell, row[j])) return true;
+                }
+                return false;
+            }
+            function allBlank(rows, y, xMin, xMax) {
+                for(let x = xMin; x < xMax; x++)if (conflictExists(rows, x, y)) return false;
+                return true;
+            }
+            function addRowSpanCells(table) {
+                table.forEach(function(row, rowIndex) {
+                    row.forEach(function(cell) {
+                        for(let i = 1; i < cell.rowSpan; i++){
+                            let rowSpanCell = new RowSpanCell(cell);
+                            rowSpanCell.x = cell.x;
+                            rowSpanCell.y = cell.y + i;
+                            rowSpanCell.colSpan = cell.colSpan;
+                            insertCell(rowSpanCell, table[rowIndex + i]);
+                        }
+                    });
+                });
+            }
+            function addColSpanCells(cellRows) {
+                for(let rowIndex = cellRows.length - 1; rowIndex >= 0; rowIndex--){
+                    let cellColumns = cellRows[rowIndex];
+                    for(let columnIndex = 0; columnIndex < cellColumns.length; columnIndex++){
+                        let cell = cellColumns[columnIndex];
+                        for(let k = 1; k < cell.colSpan; k++){
+                            let colSpanCell = new ColSpanCell();
+                            colSpanCell.x = cell.x + k;
+                            colSpanCell.y = cell.y;
+                            cellColumns.splice(columnIndex + 1, 0, colSpanCell);
+                        }
+                    }
+                }
+            }
+            function insertCell(cell, row) {
+                let x = 0;
+                while(x < row.length && row[x].x < cell.x)x++;
+                row.splice(x, 0, cell);
+            }
+            function fillInTable(table) {
+                let h_max = maxHeight(table);
+                let w_max = maxWidth(table);
+                debug(`Max rows: ${h_max}; Max cols: ${w_max}`);
+                for(let y = 0; y < h_max; y++)for(let x = 0; x < w_max; x++)if (!conflictExists(table, x, y)) {
+                    let opts = {
+                        x: x,
+                        y: y,
+                        colSpan: 1,
+                        rowSpan: 1
+                    };
+                    x++;
+                    while(x < w_max && !conflictExists(table, x, y)){
+                        opts.colSpan++;
+                        x++;
+                    }
+                    let y2 = y + 1;
+                    while(y2 < h_max && allBlank(table, y2, opts.x, opts.x + opts.colSpan)){
+                        opts.rowSpan++;
+                        y2++;
+                    }
+                    let cell = new Cell(opts);
+                    cell.x = opts.x;
+                    cell.y = opts.y;
+                    warn(`Missing cell at ${cell.y}-${cell.x}.`);
+                    insertCell(cell, table[y]);
+                }
+            }
+            function generateCells(rows) {
+                return rows.map(function(row) {
+                    if (!Array.isArray(row)) {
+                        let key = Object.keys(row)[0];
+                        row = row[key];
+                        if (Array.isArray(row)) {
+                            row = row.slice();
+                            row.unshift(key);
+                        } else row = [
+                            key,
+                            row
+                        ];
+                    }
+                    return row.map(function(cell) {
+                        return new Cell(cell);
+                    });
+                });
+            }
+            function makeTableLayout(rows) {
+                let cellRows = generateCells(rows);
+                layoutTable(cellRows);
+                fillInTable(cellRows);
+                addRowSpanCells(cellRows);
+                addColSpanCells(cellRows);
+                return cellRows;
+            }
+            module.exports = {
+                makeTableLayout: makeTableLayout,
+                layoutTable: layoutTable,
+                addRowSpanCells: addRowSpanCells,
+                maxWidth: maxWidth,
+                fillInTable: fillInTable,
+                computeWidths: makeComputeWidths('colSpan', 'desiredWidth', 'x', 1),
+                computeHeights: makeComputeWidths('rowSpan', 'desiredHeight', 'y', 1)
+            };
+        })();
+        function makeComputeWidths(colSpan, desiredWidth, x, forcedMin) {
+            return function(vals, table) {
+                let result = [];
+                let spanners = [];
+                let auto = {};
+                table.forEach(function(row) {
+                    row.forEach(function(cell) {
+                        if ((cell[colSpan] || 1) > 1) spanners.push(cell);
+                        else result[cell[x]] = Math.max(result[cell[x]] || 0, cell[desiredWidth] || 0, forcedMin);
+                    });
+                });
+                vals.forEach(function(val, index) {
+                    if ('number' == typeof val) result[index] = val;
+                });
+                for(let k = spanners.length - 1; k >= 0; k--){
+                    let cell = spanners[k];
+                    let span = cell[colSpan];
+                    let col = cell[x];
+                    let existingWidth = result[col];
+                    let editableCols = 'number' == typeof vals[col] ? 0 : 1;
+                    if ('number' == typeof existingWidth) for(let i = 1; i < span; i++){
+                        existingWidth += 1 + result[col + i];
+                        if ('number' != typeof vals[col + i]) editableCols++;
+                    }
+                    else {
+                        existingWidth = 'desiredWidth' === desiredWidth ? cell.desiredWidth - 1 : 1;
+                        if (!auto[col] || auto[col] < existingWidth) auto[col] = existingWidth;
+                    }
+                    if (cell[desiredWidth] > existingWidth) {
+                        let i = 0;
+                        while(editableCols > 0 && cell[desiredWidth] > existingWidth){
+                            if ('number' != typeof vals[col + i]) {
+                                let dif = Math.round((cell[desiredWidth] - existingWidth) / editableCols);
+                                existingWidth += dif;
+                                result[col + i] += dif;
+                                editableCols--;
+                            }
+                            i++;
+                        }
+                    }
+                }
+                Object.assign(vals, result, auto);
+                for(let j = 0; j < vals.length; j++)vals[j] = Math.max(forcedMin, vals[j] || 0);
+            };
+        }
+    },
+    "./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/table.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const debug = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/debug.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/utils.js");
+        const tableLayout = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/layout-manager.js");
+        class Table extends Array {
+            constructor(opts){
+                super();
+                const options = utils.mergeOptions(opts);
+                Object.defineProperty(this, 'options', {
+                    value: options,
+                    enumerable: options.debug
+                });
+                if (options.debug) {
+                    switch(typeof options.debug){
+                        case 'boolean':
+                            debug.setDebugLevel(debug.WARN);
+                            break;
+                        case 'number':
+                            debug.setDebugLevel(options.debug);
+                            break;
+                        case 'string':
+                            debug.setDebugLevel(parseInt(options.debug, 10));
+                            break;
+                        default:
+                            debug.setDebugLevel(debug.WARN);
+                            debug.warn(`Debug option is expected to be boolean, number, or string. Received a ${typeof options.debug}`);
+                    }
+                    Object.defineProperty(this, 'messages', {
+                        get () {
+                            return debug.debugMessages();
+                        }
+                    });
+                }
+            }
+            toString() {
+                let array = this;
+                let headersPresent = this.options.head && this.options.head.length;
+                if (headersPresent) {
+                    array = [
+                        this.options.head
+                    ];
+                    if (this.length) array.push.apply(array, this);
+                } else this.options.style.head = [];
+                let cells = tableLayout.makeTableLayout(array);
+                cells.forEach(function(row) {
+                    row.forEach(function(cell) {
+                        cell.mergeTableOptions(this.options, cells);
+                    }, this);
+                }, this);
+                tableLayout.computeWidths(this.options.colWidths, cells);
+                tableLayout.computeHeights(this.options.rowHeights, cells);
+                cells.forEach(function(row) {
+                    row.forEach(function(cell) {
+                        cell.init(this.options);
+                    }, this);
+                }, this);
+                let result = [];
+                for(let rowIndex = 0; rowIndex < cells.length; rowIndex++){
+                    let row = cells[rowIndex];
+                    let heightOfRow = this.options.rowHeights[rowIndex];
+                    if (0 === rowIndex || !this.options.style.compact || 1 == rowIndex && headersPresent) doDraw(row, 'top', result);
+                    for(let lineNum = 0; lineNum < heightOfRow; lineNum++)doDraw(row, lineNum, result);
+                    if (rowIndex + 1 == cells.length) doDraw(row, 'bottom', result);
+                }
+                return result.join('\n');
+            }
+            get width() {
+                let str = this.toString().split('\n');
+                return str[0].length;
+            }
+        }
+        Table.reset = ()=>debug.reset();
+        function doDraw(row, lineNum, result) {
+            let line = [];
+            row.forEach(function(cell) {
+                line.push(cell.draw(lineNum));
+            });
+            let str = line.join('');
+            if (str.length) result.push(str);
+        }
+        module.exports = Table;
+    },
+    "./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/src/utils.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const stringWidth = __webpack_require__("./node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js");
+        function codeRegex(capture) {
+            return capture ? /\u001b\[((?:\d*;){0,5}\d*)m/g : /\u001b\[(?:\d*;){0,5}\d*m/g;
+        }
+        function strlen(str) {
+            let code = codeRegex();
+            let stripped = ('' + str).replace(code, '');
+            let split = stripped.split('\n');
+            return split.reduce(function(memo, s) {
+                return stringWidth(s) > memo ? stringWidth(s) : memo;
+            }, 0);
+        }
+        function repeat(str, times) {
+            return Array(times + 1).join(str);
+        }
+        function pad(str, len, pad, dir) {
+            let length = strlen(str);
+            if (len + 1 >= length) {
+                let padlen = len - length;
+                switch(dir){
+                    case 'right':
+                        str = repeat(pad, padlen) + str;
+                        break;
+                    case 'center':
+                        {
+                            let right = Math.ceil(padlen / 2);
+                            let left = padlen - right;
+                            str = repeat(pad, left) + str + repeat(pad, right);
+                            break;
+                        }
+                    default:
+                        str += repeat(pad, padlen);
+                        break;
+                }
+            }
+            return str;
+        }
+        let codeCache = {};
+        function addToCodeCache(name, on, off) {
+            on = '\u001b[' + on + 'm';
+            off = '\u001b[' + off + 'm';
+            codeCache[on] = {
+                set: name,
+                to: true
+            };
+            codeCache[off] = {
+                set: name,
+                to: false
+            };
+            codeCache[name] = {
+                on: on,
+                off: off
+            };
+        }
+        addToCodeCache('bold', 1, 22);
+        addToCodeCache('italics', 3, 23);
+        addToCodeCache('underline', 4, 24);
+        addToCodeCache('inverse', 7, 27);
+        addToCodeCache('strikethrough', 9, 29);
+        function updateState(state, controlChars) {
+            let controlCode = controlChars[1] ? parseInt(controlChars[1].split(';')[0]) : 0;
+            if (controlCode >= 30 && controlCode <= 39 || controlCode >= 90 && controlCode <= 97) {
+                state.lastForegroundAdded = controlChars[0];
+                return;
+            }
+            if (controlCode >= 40 && controlCode <= 49 || controlCode >= 100 && controlCode <= 107) {
+                state.lastBackgroundAdded = controlChars[0];
+                return;
+            }
+            if (0 === controlCode) {
+                for(let i in state)if (Object.prototype.hasOwnProperty.call(state, i)) delete state[i];
+                return;
+            }
+            let info = codeCache[controlChars[0]];
+            if (info) state[info.set] = info.to;
+        }
+        function readState(line) {
+            let code = codeRegex(true);
+            let controlChars = code.exec(line);
+            let state = {};
+            while(null !== controlChars){
+                updateState(state, controlChars);
+                controlChars = code.exec(line);
+            }
+            return state;
+        }
+        function unwindState(state, ret) {
+            let lastBackgroundAdded = state.lastBackgroundAdded;
+            let lastForegroundAdded = state.lastForegroundAdded;
+            delete state.lastBackgroundAdded;
+            delete state.lastForegroundAdded;
+            Object.keys(state).forEach(function(key) {
+                if (state[key]) ret += codeCache[key].off;
+            });
+            if (lastBackgroundAdded && '\u001b[49m' != lastBackgroundAdded) ret += '\u001b[49m';
+            if (lastForegroundAdded && '\u001b[39m' != lastForegroundAdded) ret += '\u001b[39m';
+            return ret;
+        }
+        function rewindState(state, ret) {
+            let lastBackgroundAdded = state.lastBackgroundAdded;
+            let lastForegroundAdded = state.lastForegroundAdded;
+            delete state.lastBackgroundAdded;
+            delete state.lastForegroundAdded;
+            Object.keys(state).forEach(function(key) {
+                if (state[key]) ret = codeCache[key].on + ret;
+            });
+            if (lastBackgroundAdded && '\u001b[49m' != lastBackgroundAdded) ret = lastBackgroundAdded + ret;
+            if (lastForegroundAdded && '\u001b[39m' != lastForegroundAdded) ret = lastForegroundAdded + ret;
+            return ret;
+        }
+        function truncateWidth(str, desiredLength) {
+            if (str.length === strlen(str)) return str.substr(0, desiredLength);
+            while(strlen(str) > desiredLength)str = str.slice(0, -1);
+            return str;
+        }
+        function truncateWidthWithAnsi(str, desiredLength) {
+            let code = codeRegex(true);
+            let split = str.split(codeRegex());
+            let splitIndex = 0;
+            let retLen = 0;
+            let ret = '';
+            let myArray;
+            let state = {};
+            while(retLen < desiredLength){
+                myArray = code.exec(str);
+                let toAdd = split[splitIndex];
+                splitIndex++;
+                if (retLen + strlen(toAdd) > desiredLength) toAdd = truncateWidth(toAdd, desiredLength - retLen);
+                ret += toAdd;
+                retLen += strlen(toAdd);
+                if (retLen < desiredLength) {
+                    if (!myArray) break;
+                    ret += myArray[0];
+                    updateState(state, myArray);
+                }
+            }
+            return unwindState(state, ret);
+        }
+        function truncate(str, desiredLength, truncateChar) {
+            truncateChar = truncateChar || '…';
+            let lengthOfStr = strlen(str);
+            if (lengthOfStr <= desiredLength) return str;
+            desiredLength -= strlen(truncateChar);
+            let ret = truncateWidthWithAnsi(str, desiredLength);
+            ret += truncateChar;
+            const hrefTag = '\x1B]8;;\x07';
+            if (str.includes(hrefTag) && !ret.includes(hrefTag)) ret += hrefTag;
+            return ret;
+        }
+        function defaultOptions() {
+            return {
+                chars: {
+                    top: '─',
+                    'top-mid': '┬',
+                    'top-left': '┌',
+                    'top-right': '┐',
+                    bottom: '─',
+                    'bottom-mid': '┴',
+                    'bottom-left': '└',
+                    'bottom-right': '┘',
+                    left: '│',
+                    'left-mid': '├',
+                    mid: '─',
+                    'mid-mid': '┼',
+                    right: '│',
+                    'right-mid': '┤',
+                    middle: '│'
+                },
+                truncate: '…',
+                colWidths: [],
+                rowHeights: [],
+                colAligns: [],
+                rowAligns: [],
+                style: {
+                    'padding-left': 1,
+                    'padding-right': 1,
+                    head: [
+                        'red'
+                    ],
+                    border: [
+                        'grey'
+                    ],
+                    compact: false
+                },
+                head: []
+            };
+        }
+        function mergeOptions(options, defaults) {
+            options = options || {};
+            defaults = defaults || defaultOptions();
+            let ret = Object.assign({}, defaults, options);
+            ret.chars = Object.assign({}, defaults.chars, options.chars);
+            ret.style = Object.assign({}, defaults.style, options.style);
+            return ret;
+        }
+        function wordWrap(maxLength, input) {
+            let lines = [];
+            let split = input.split(/(\s+)/g);
+            let line = [];
+            let lineLength = 0;
+            let whitespace;
+            for(let i = 0; i < split.length; i += 2){
+                let word = split[i];
+                let newLength = lineLength + strlen(word);
+                if (lineLength > 0 && whitespace) newLength += whitespace.length;
+                if (newLength > maxLength) {
+                    if (0 !== lineLength) lines.push(line.join(''));
+                    line = [
+                        word
+                    ];
+                    lineLength = strlen(word);
+                } else {
+                    line.push(whitespace || '', word);
+                    lineLength = newLength;
+                }
+                whitespace = split[i + 1];
+            }
+            if (lineLength) lines.push(line.join(''));
+            return lines;
+        }
+        function textWrap(maxLength, input) {
+            let lines = [];
+            let line = '';
+            function pushLine(str, ws) {
+                if (line.length && ws) line += ws;
+                line += str;
+                while(line.length > maxLength){
+                    lines.push(line.slice(0, maxLength));
+                    line = line.slice(maxLength);
+                }
+            }
+            let split = input.split(/(\s+)/g);
+            for(let i = 0; i < split.length; i += 2)pushLine(split[i], i && split[i - 1]);
+            if (line.length) lines.push(line);
+            return lines;
+        }
+        function multiLineWordWrap(maxLength, input, wrapOnWordBoundary = true) {
+            let output = [];
+            input = input.split('\n');
+            const handler = wrapOnWordBoundary ? wordWrap : textWrap;
+            for(let i = 0; i < input.length; i++)output.push.apply(output, handler(maxLength, input[i]));
+            return output;
+        }
+        function colorizeLines(input) {
+            let state = {};
+            let output = [];
+            for(let i = 0; i < input.length; i++){
+                let line = rewindState(state, input[i]);
+                state = readState(line);
+                let temp = Object.assign({}, state);
+                output.push(unwindState(temp, line));
+            }
+            return output;
+        }
+        function hyperlink(url, text) {
+            const OSC = '\u001B]';
+            const BEL = '\u0007';
+            const SEP = ';';
+            return [
+                OSC,
+                '8',
+                SEP,
+                SEP,
+                url || text,
+                BEL,
+                text,
+                OSC,
+                '8',
+                SEP,
+                SEP,
+                BEL
+            ].join('');
+        }
+        module.exports = {
+            strlen: strlen,
+            repeat: repeat,
+            pad: pad,
+            truncate: truncate,
+            mergeOptions: mergeOptions,
+            wordWrap: multiLineWordWrap,
+            colorizeLines: colorizeLines,
+            hyperlink
+        };
+    },
+    "./node_modules/.pnpm/emoji-regex@8.0.0/node_modules/emoji-regex/index.js" (module) {
+        module.exports = function() {
+            return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
+        };
+    },
+    "./node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js" (module) {
+        const isFullwidthCodePoint = (codePoint)=>{
+            if (Number.isNaN(codePoint)) return false;
+            if (codePoint >= 0x1100 && (codePoint <= 0x115F || 0x2329 === codePoint || 0x232A === codePoint || 0x2E80 <= codePoint && codePoint <= 0x3247 && 0x303F !== codePoint || 0x3250 <= codePoint && codePoint <= 0x4DBF || 0x4E00 <= codePoint && codePoint <= 0xA4C6 || 0xA960 <= codePoint && codePoint <= 0xA97C || 0xAC00 <= codePoint && codePoint <= 0xD7A3 || 0xF900 <= codePoint && codePoint <= 0xFAFF || 0xFE10 <= codePoint && codePoint <= 0xFE19 || 0xFE30 <= codePoint && codePoint <= 0xFE6B || 0xFF01 <= codePoint && codePoint <= 0xFF60 || 0xFFE0 <= codePoint && codePoint <= 0xFFE6 || 0x1B000 <= codePoint && codePoint <= 0x1B001 || 0x1F200 <= codePoint && codePoint <= 0x1F251 || 0x20000 <= codePoint && codePoint <= 0x3FFFD)) return true;
+            return false;
+        };
+        module.exports = isFullwidthCodePoint;
+        module.exports["default"] = isFullwidthCodePoint;
+    },
+    "./node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const stripAnsi = __webpack_require__("./node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js");
+        const isFullwidthCodePoint = __webpack_require__("./node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js");
+        const emojiRegex = __webpack_require__("./node_modules/.pnpm/emoji-regex@8.0.0/node_modules/emoji-regex/index.js");
+        const stringWidth = (string)=>{
+            if ('string' != typeof string || 0 === string.length) return 0;
+            string = stripAnsi(string);
+            if (0 === string.length) return 0;
+            string = string.replace(emojiRegex(), '  ');
+            let width = 0;
+            for(let i = 0; i < string.length; i++){
+                const code = string.codePointAt(i);
+                if (!(code <= 0x1F) && (!(code >= 0x7F) || !(code <= 0x9F))) {
+                    if (!(code >= 0x300) || !(code <= 0x36F)) {
+                        if (code > 0xFFFF) i++;
+                        width += isFullwidthCodePoint(code) ? 2 : 1;
+                    }
+                }
+            }
+            return width;
+        };
+        module.exports = stringWidth;
+        module.exports["default"] = stringWidth;
+    },
+    "./node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const ansiRegex = __webpack_require__("./node_modules/.pnpm/ansi-regex@5.0.1/node_modules/ansi-regex/index.js");
+        module.exports = (string)=>'string' == typeof string ? string.replace(ansiRegex(), '') : string;
+    }
+});
+const cli_table3 = __webpack_require__("./node_modules/.pnpm/cli-table3@0.6.5/node_modules/cli-table3/index.js");
+var cli_table3_default = /*#__PURE__*/ __webpack_require__.n(cli_table3);
+/**
+ * @license
+Copyright 2023 Andrew Branch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */ function renderTyped(analysis, { emoji = true, summary = true, ignoreRules = [], ignoreResolutions = [] }) {
+    let output = "";
+    const problems = analysis.problems.filter((problem)=>!ignoreRules || !ignoreRules.includes(problemFlags[problem.kind]));
+    const requiredResolutions = allResolutionKinds.filter((kind)=>!ignoreResolutions.includes(kind));
+    const ignoredResolutions = allResolutionKinds.filter((kind)=>ignoreResolutions.includes(kind));
+    const resolutions = requiredResolutions.concat(ignoredResolutions);
+    const entrypoints = Object.keys(analysis.entrypoints);
+    out(`[arethetypeswrong] ${analysis.packageName} v${analysis.packageVersion}`);
+    out();
+    if (Object.keys(analysis.buildTools).length) {
+        out("Build tools:");
+        out(Object.entries(analysis.buildTools).map(([tool, version])=>`- ${tool}@${version}`).join("\n"));
+        out();
+    }
+    if (ignoreRules && ignoreRules.length) out(styleText("gray", ` (ignoring rules: ${ignoreRules.map((rule)=>`'${rule}'`).join(", ")})\n`));
+    if (ignoreResolutions && ignoreResolutions.length) out(styleText("gray", ` (ignoring resolutions: ${ignoreResolutions.map((resolution)=>`'${resolution}'`).join(", ")})\n`));
+    if (summary) {
+        const defaultSummary = emoji ? " No problems found 🌟" : " No problems found";
+        const grouped = groupProblemsByKind(problems);
+        const summaryTexts = Object.entries(grouped).map(([kind, kindProblems])=>{
+            const info = problemKindInfo[kind];
+            const affectsRequiredResolution = kindProblems.some((p)=>requiredResolutions.some((r)=>problemAffectsResolutionKind(p, r, analysis)));
+            let description = `${info.description}${info.details ? ` Use \`-f json\` to see ${info.details}.` : ""} ${info.docsUrl}`;
+            description = description.replace(/`([^`]+)`/g, (_, code)=>styleText("cyan", code)).replace(/(?<!\x1b)\[([^\]]+)\]\(([^)]+)\)/g, (_, text, url)=>`${styleText("bold", text)} (${styleText("blue", styleText("underline", url))})`);
+            return `${affectsRequiredResolution ? "" : "(ignored per resolution) "}${emoji ? `${info.emoji} ` : ""}${description}\n\n`;
+        });
+        out(summaryTexts.join("") || defaultSummary);
+    }
+    const entrypointNames = entrypoints.map((s)=>`"${"." === s ? analysis.packageName : `${analysis.packageName}/${s.substring(2)}`}"`);
+    const entrypointHeaders = entrypoints.map((s, i)=>{
+        const hasProblems = problems.some((p)=>problemAffectsEntrypoint(p, s, analysis));
+        return styleText("bold", styleText(hasProblems ? "redBright" : "greenBright", entrypointNames[i]));
+    });
+    const getCellContents = (subpath, resolutionKind)=>{
+        const ignoredPrefix = ignoreResolutions.includes(resolutionKind) ? "(ignored) " : "";
+        const problemsForCell = groupProblemsByKind(filterProblems(problems, analysis, {
+            entrypoint: subpath,
+            resolutionKind
+        }));
+        const entrypoint = analysis.entrypoints[subpath].resolutions[resolutionKind];
+        const resolution = entrypoint.resolution;
+        const kinds = Object.keys(problemsForCell);
+        if (kinds.length) return kinds.map((kind)=>ignoredPrefix + (emoji ? `${problemKindInfo[kind].emoji} ` : "") + problemKindInfo[kind].shortDescription).join("\n");
+        const jsonResult = emoji ? "🟢 (JSON)" : "OK (JSON)";
+        const moduleResult = entrypoint.isWildcard ? "(wildcard)" : (emoji ? "🟢 " : "OK ") + moduleKinds[analysis.programInfo[getResolutionOption(resolutionKind)].moduleKinds?.[resolution?.fileName ?? ""]?.detectedKind || ""];
+        return ignoredPrefix + (resolution?.isJson ? jsonResult : moduleResult);
+    };
+    const table = new (cli_table3_default())({
+        head: [
+            "",
+            ...entrypointHeaders
+        ]
+    });
+    resolutions.forEach((kind)=>{
+        table.push([
+            resolutionKinds[kind],
+            ...entrypoints.map((entrypoint)=>getCellContents(entrypoint, kind))
+        ]);
+    });
+    out(table.toString());
+    return output.trimEnd();
+    function out(s = "") {
+        output += s + "\n";
+    }
+}
+/**
+ * @license
+Copyright 2023 Andrew Branch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */ function renderUntyped(analysis) {
+    return `[arethetypeswrong] Package ${analysis.packageName}@${analysis.packageVersion} does not contain types.`;
+}
+function render(analysis, options) {
+    if (analysis.types) return renderTyped(analysis, options);
+    return renderUntyped(analysis);
+}
+export { render };