@rsbuild/webpack 1.0.11 → 1.1.0-beta.1

package/dist/997.cjs

@@ -0,0 +1,2349 @@
+exports.ids = [
+    '997'
+];
+exports.modules = {
+    "../../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js": function(module) {
+        "use strict";
+        const ansiEscapes = module.exports;
+        // TODO: remove this in the next major version
+        module.exports["default"] = ansiEscapes;
+        const ESC = '\u001B[';
+        const OSC = '\u001B]';
+        const BEL = '\u0007';
+        const SEP = ';';
+        const isTerminalApp = 'Apple_Terminal' === process.env.TERM_PROGRAM;
+        ansiEscapes.cursorTo = (x, y)=>{
+            if ('number' != typeof x) throw new TypeError('The `x` argument is required');
+            if ('number' != typeof y) return ESC + (x + 1) + 'G';
+            return ESC + (y + 1) + ';' + (x + 1) + 'H';
+        };
+        ansiEscapes.cursorMove = (x, y)=>{
+            if ('number' != typeof x) throw new TypeError('The `x` argument is required');
+            let ret = '';
+            if (x < 0) ret += ESC + -x + 'D';
+            else if (x > 0) ret += ESC + x + 'C';
+            if (y < 0) ret += ESC + -y + 'A';
+            else if (y > 0) ret += ESC + y + 'B';
+            return ret;
+        };
+        ansiEscapes.cursorUp = (count = 1)=>ESC + count + 'A';
+        ansiEscapes.cursorDown = (count = 1)=>ESC + count + 'B';
+        ansiEscapes.cursorForward = (count = 1)=>ESC + count + 'C';
+        ansiEscapes.cursorBackward = (count = 1)=>ESC + count + 'D';
+        ansiEscapes.cursorLeft = ESC + 'G';
+        ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
+        ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
+        ansiEscapes.cursorGetPosition = ESC + '6n';
+        ansiEscapes.cursorNextLine = ESC + 'E';
+        ansiEscapes.cursorPrevLine = ESC + 'F';
+        ansiEscapes.cursorHide = ESC + '?25l';
+        ansiEscapes.cursorShow = ESC + '?25h';
+        ansiEscapes.eraseLines = (count)=>{
+            let clear = '';
+            for(let i = 0; i < count; i++)clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
+            if (count) clear += ansiEscapes.cursorLeft;
+            return clear;
+        };
+        ansiEscapes.eraseEndLine = ESC + 'K';
+        ansiEscapes.eraseStartLine = ESC + '1K';
+        ansiEscapes.eraseLine = ESC + '2K';
+        ansiEscapes.eraseDown = ESC + 'J';
+        ansiEscapes.eraseUp = ESC + '1J';
+        ansiEscapes.eraseScreen = ESC + '2J';
+        ansiEscapes.scrollUp = ESC + 'S';
+        ansiEscapes.scrollDown = ESC + 'T';
+        ansiEscapes.clearScreen = '\u001Bc';
+        ansiEscapes.clearTerminal = 'win32' === process.platform ? `${ansiEscapes.eraseScreen}${ESC}0f` : // 1. Erases the screen (Only done in case `2` is not supported)
+        // 2. Erases the whole screen including scrollback buffer
+        // 3. Moves cursor to the top-left position
+        // More info: https://www.real-world-systems.com/docs/ANSIcode.html
+        `${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
+        ansiEscapes.beep = BEL;
+        ansiEscapes.link = (text, url)=>[
+                OSC,
+                '8',
+                SEP,
+                SEP,
+                url,
+                BEL,
+                text,
+                OSC,
+                '8',
+                SEP,
+                SEP,
+                BEL
+            ].join('');
+        ansiEscapes.image = (buffer, options = {})=>{
+            let ret = `${OSC}1337;File=inline=1`;
+            if (options.width) ret += `;width=${options.width}`;
+            if (options.height) ret += `;height=${options.height}`;
+            if (false === options.preserveAspectRatio) ret += ';preserveAspectRatio=0';
+            return ret + ':' + buffer.toString('base64') + BEL;
+        };
+        ansiEscapes.iTerm = {
+            setCwd: (cwd = process.cwd())=>`${OSC}50;CurrentDir=${cwd}${BEL}`,
+            annotation: (message, options = {})=>{
+                let ret = `${OSC}1337;`;
+                const hasX = void 0 !== options.x;
+                const hasY = void 0 !== options.y;
+                if ((hasX || hasY) && !(hasX && hasY && void 0 !== options.length)) throw new Error('`x`, `y` and `length` must be defined when `x` or `y` is defined');
+                message = message.replace(/\|/g, '');
+                ret += options.isHidden ? 'AddHiddenAnnotation=' : 'AddAnnotation=';
+                if (options.length > 0) ret += (hasX ? [
+                    message,
+                    options.length,
+                    options.x,
+                    options.y
+                ] : [
+                    options.length,
+                    message
+                ]).join('|');
+                else ret += message;
+                return ret + BEL;
+            }
+        };
+    },
+    "../../../node_modules/.pnpm/ansi-regex@5.0.1/node_modules/ansi-regex/index.js": function(module) {
+        "use strict";
+        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/ansi-styles@4.3.0/node_modules/ansi-styles/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        /* module decorator */ module = __webpack_require__.nmd(module);
+        const wrapAnsi16 = (fn, offset)=>(...args)=>{
+                const code = fn(...args);
+                return `\u001B[${code + offset}m`;
+            };
+        const wrapAnsi256 = (fn, offset)=>(...args)=>{
+                const code = fn(...args);
+                return `\u001B[${38 + offset};5;${code}m`;
+            };
+        const wrapAnsi16m = (fn, offset)=>(...args)=>{
+                const rgb = fn(...args);
+                return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+            };
+        const ansi2ansi = (n)=>n;
+        const rgb2rgb = (r, g, b)=>[
+                r,
+                g,
+                b
+            ];
+        const setLazyProperty = (object, property, get)=>{
+            Object.defineProperty(object, property, {
+                get: ()=>{
+                    const value = get();
+                    Object.defineProperty(object, property, {
+                        value,
+                        enumerable: true,
+                        configurable: true
+                    });
+                    return value;
+                },
+                enumerable: true,
+                configurable: true
+            });
+        };
+        /** @type {typeof import('color-convert')} */ let colorConvert;
+        const makeDynamicStyles = (wrap, targetSpace, identity, isBackground)=>{
+            if (void 0 === colorConvert) colorConvert = __webpack_require__("../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/index.js");
+            const offset = isBackground ? 10 : 0;
+            const styles = {};
+            for (const [sourceSpace, suite] of Object.entries(colorConvert)){
+                const name = 'ansi16' === sourceSpace ? 'ansi' : sourceSpace;
+                if (sourceSpace === targetSpace) styles[name] = wrap(identity, offset);
+                else if ('object' == typeof suite) styles[name] = wrap(suite[targetSpace], offset);
+            }
+            return styles;
+        };
+        function assembleStyles() {
+            const codes = new Map();
+            const styles = {
+                modifier: {
+                    reset: [
+                        0,
+                        0
+                    ],
+                    // 21 isn't widely supported and 22 does the same thing
+                    bold: [
+                        1,
+                        22
+                    ],
+                    dim: [
+                        2,
+                        22
+                    ],
+                    italic: [
+                        3,
+                        23
+                    ],
+                    underline: [
+                        4,
+                        24
+                    ],
+                    inverse: [
+                        7,
+                        27
+                    ],
+                    hidden: [
+                        8,
+                        28
+                    ],
+                    strikethrough: [
+                        9,
+                        29
+                    ]
+                },
+                color: {
+                    black: [
+                        30,
+                        39
+                    ],
+                    red: [
+                        31,
+                        39
+                    ],
+                    green: [
+                        32,
+                        39
+                    ],
+                    yellow: [
+                        33,
+                        39
+                    ],
+                    blue: [
+                        34,
+                        39
+                    ],
+                    magenta: [
+                        35,
+                        39
+                    ],
+                    cyan: [
+                        36,
+                        39
+                    ],
+                    white: [
+                        37,
+                        39
+                    ],
+                    // Bright color
+                    blackBright: [
+                        90,
+                        39
+                    ],
+                    redBright: [
+                        91,
+                        39
+                    ],
+                    greenBright: [
+                        92,
+                        39
+                    ],
+                    yellowBright: [
+                        93,
+                        39
+                    ],
+                    blueBright: [
+                        94,
+                        39
+                    ],
+                    magentaBright: [
+                        95,
+                        39
+                    ],
+                    cyanBright: [
+                        96,
+                        39
+                    ],
+                    whiteBright: [
+                        97,
+                        39
+                    ]
+                },
+                bgColor: {
+                    bgBlack: [
+                        40,
+                        49
+                    ],
+                    bgRed: [
+                        41,
+                        49
+                    ],
+                    bgGreen: [
+                        42,
+                        49
+                    ],
+                    bgYellow: [
+                        43,
+                        49
+                    ],
+                    bgBlue: [
+                        44,
+                        49
+                    ],
+                    bgMagenta: [
+                        45,
+                        49
+                    ],
+                    bgCyan: [
+                        46,
+                        49
+                    ],
+                    bgWhite: [
+                        47,
+                        49
+                    ],
+                    // Bright color
+                    bgBlackBright: [
+                        100,
+                        49
+                    ],
+                    bgRedBright: [
+                        101,
+                        49
+                    ],
+                    bgGreenBright: [
+                        102,
+                        49
+                    ],
+                    bgYellowBright: [
+                        103,
+                        49
+                    ],
+                    bgBlueBright: [
+                        104,
+                        49
+                    ],
+                    bgMagentaBright: [
+                        105,
+                        49
+                    ],
+                    bgCyanBright: [
+                        106,
+                        49
+                    ],
+                    bgWhiteBright: [
+                        107,
+                        49
+                    ]
+                }
+            };
+            // Alias bright black as gray (and grey)
+            styles.color.gray = styles.color.blackBright;
+            styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+            styles.color.grey = styles.color.blackBright;
+            styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+            for (const [groupName, group] of Object.entries(styles)){
+                for (const [styleName, style] of Object.entries(group)){
+                    styles[styleName] = {
+                        open: `\u001B[${style[0]}m`,
+                        close: `\u001B[${style[1]}m`
+                    };
+                    group[styleName] = styles[styleName];
+                    codes.set(style[0], style[1]);
+                }
+                Object.defineProperty(styles, groupName, {
+                    value: group,
+                    enumerable: false
+                });
+            }
+            Object.defineProperty(styles, 'codes', {
+                value: codes,
+                enumerable: false
+            });
+            styles.color.close = '\u001B[39m';
+            styles.bgColor.close = '\u001B[49m';
+            setLazyProperty(styles.color, 'ansi', ()=>makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
+            setLazyProperty(styles.color, 'ansi256', ()=>makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
+            setLazyProperty(styles.color, 'ansi16m', ()=>makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
+            setLazyProperty(styles.bgColor, 'ansi', ()=>makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
+            setLazyProperty(styles.bgColor, 'ansi256', ()=>makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
+            setLazyProperty(styles.bgColor, 'ansi16m', ()=>makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
+            return styles;
+        }
+        // Make the export immutable
+        Object.defineProperty(module, 'exports', {
+            enumerable: true,
+            get: assembleStyles
+        });
+    },
+    "../../../node_modules/.pnpm/astral-regex@2.0.0/node_modules/astral-regex/index.js": function(module) {
+        "use strict";
+        const regex = '[\uD800-\uDBFF][\uDC00-\uDFFF]';
+        const astralRegex = (options)=>options && options.exact ? new RegExp(`^${regex}$`) : new RegExp(regex, 'g');
+        module.exports = astralRegex;
+    },
+    "../../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const sliceAnsi = __webpack_require__("../../../node_modules/.pnpm/slice-ansi@3.0.0/node_modules/slice-ansi/index.js");
+        const stringWidth = __webpack_require__("../../../node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js");
+        function getIndexOfNearestSpace(string, index, shouldSearchRight) {
+            if (' ' === string.charAt(index)) return index;
+            for(let i = 1; i <= 3; i++)if (shouldSearchRight) {
+                if (' ' === string.charAt(index + i)) return index + i;
+            } else if (' ' === string.charAt(index - i)) return index - i;
+            return index;
+        }
+        module.exports = (text, columns, options)=>{
+            options = {
+                position: 'end',
+                preferTruncationOnSpace: false,
+                ...options
+            };
+            const { position, space, preferTruncationOnSpace } = options;
+            let ellipsis = '…';
+            let ellipsisWidth = 1;
+            if ('string' != typeof text) throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
+            if ('number' != typeof columns) throw new TypeError(`Expected \`columns\` to be a number, got ${typeof columns}`);
+            if (columns < 1) return '';
+            if (1 === columns) return ellipsis;
+            const length = stringWidth(text);
+            if (length <= columns) return text;
+            if ('start' === position) {
+                if (preferTruncationOnSpace) {
+                    const nearestSpace = getIndexOfNearestSpace(text, length - columns + 1, true);
+                    return ellipsis + sliceAnsi(text, nearestSpace, length).trim();
+                }
+                if (true === space) {
+                    ellipsis += ' ';
+                    ellipsisWidth = 2;
+                }
+                return ellipsis + sliceAnsi(text, length - columns + ellipsisWidth, length);
+            }
+            if ('middle' === position) {
+                if (true === space) {
+                    ellipsis = ' ' + ellipsis + ' ';
+                    ellipsisWidth = 3;
+                }
+                const half = Math.floor(columns / 2);
+                if (preferTruncationOnSpace) {
+                    const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
+                    const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + 1, true);
+                    return sliceAnsi(text, 0, spaceNearFirstBreakPoint) + ellipsis + sliceAnsi(text, spaceNearSecondBreakPoint, length).trim();
+                }
+                return sliceAnsi(text, 0, half) + ellipsis + sliceAnsi(text, length - (columns - half) + ellipsisWidth, length);
+            }
+            if ('end' === position) {
+                if (preferTruncationOnSpace) {
+                    const nearestSpace = getIndexOfNearestSpace(text, columns - 1);
+                    return sliceAnsi(text, 0, nearestSpace) + ellipsis;
+                }
+                if (true === space) {
+                    ellipsis = ' ' + ellipsis;
+                    ellipsisWidth = 2;
+                }
+                return sliceAnsi(text, 0, columns - ellipsisWidth) + ellipsis;
+            }
+            throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
+        };
+    },
+    "../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        /* MIT license */ /* eslint-disable no-mixed-operators */ const cssKeywords = __webpack_require__("../../../node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js");
+        // NOTE: conversions should only return primitive values (i.e. arrays, or
+        //       values that give correct `typeof` results).
+        //       do not use box values types (i.e. Number(), String(), etc.)
+        const reverseKeywords = {};
+        for (const key of Object.keys(cssKeywords))reverseKeywords[cssKeywords[key]] = key;
+        const convert = {
+            rgb: {
+                channels: 3,
+                labels: 'rgb'
+            },
+            hsl: {
+                channels: 3,
+                labels: 'hsl'
+            },
+            hsv: {
+                channels: 3,
+                labels: 'hsv'
+            },
+            hwb: {
+                channels: 3,
+                labels: 'hwb'
+            },
+            cmyk: {
+                channels: 4,
+                labels: 'cmyk'
+            },
+            xyz: {
+                channels: 3,
+                labels: 'xyz'
+            },
+            lab: {
+                channels: 3,
+                labels: 'lab'
+            },
+            lch: {
+                channels: 3,
+                labels: 'lch'
+            },
+            hex: {
+                channels: 1,
+                labels: [
+                    'hex'
+                ]
+            },
+            keyword: {
+                channels: 1,
+                labels: [
+                    'keyword'
+                ]
+            },
+            ansi16: {
+                channels: 1,
+                labels: [
+                    'ansi16'
+                ]
+            },
+            ansi256: {
+                channels: 1,
+                labels: [
+                    'ansi256'
+                ]
+            },
+            hcg: {
+                channels: 3,
+                labels: [
+                    'h',
+                    'c',
+                    'g'
+                ]
+            },
+            apple: {
+                channels: 3,
+                labels: [
+                    'r16',
+                    'g16',
+                    'b16'
+                ]
+            },
+            gray: {
+                channels: 1,
+                labels: [
+                    'gray'
+                ]
+            }
+        };
+        module.exports = convert;
+        // Hide .channels and .labels properties
+        for (const model of Object.keys(convert)){
+            if (!('channels' in convert[model])) throw new Error('missing channels property: ' + model);
+            if (!('labels' in convert[model])) throw new Error('missing channel labels property: ' + model);
+            if (convert[model].labels.length !== convert[model].channels) throw new Error('channel and label counts mismatch: ' + model);
+            const { channels, labels } = convert[model];
+            delete convert[model].channels;
+            delete convert[model].labels;
+            Object.defineProperty(convert[model], 'channels', {
+                value: channels
+            });
+            Object.defineProperty(convert[model], 'labels', {
+                value: labels
+            });
+        }
+        convert.rgb.hsl = function(rgb) {
+            const r = rgb[0] / 255;
+            const g = rgb[1] / 255;
+            const b = rgb[2] / 255;
+            const min = Math.min(r, g, b);
+            const max = Math.max(r, g, b);
+            const delta = max - min;
+            let h;
+            let s;
+            if (max === min) h = 0;
+            else if (r === max) h = (g - b) / delta;
+            else if (g === max) h = 2 + (b - r) / delta;
+            else if (b === max) h = 4 + (r - g) / delta;
+            h = Math.min(60 * h, 360);
+            if (h < 0) h += 360;
+            const l = (min + max) / 2;
+            s = max === min ? 0 : l <= 0.5 ? delta / (max + min) : delta / (2 - max - min);
+            return [
+                h,
+                100 * s,
+                100 * l
+            ];
+        };
+        convert.rgb.hsv = function(rgb) {
+            let rdif;
+            let gdif;
+            let bdif;
+            let h;
+            let s;
+            const r = rgb[0] / 255;
+            const g = rgb[1] / 255;
+            const b = rgb[2] / 255;
+            const v = Math.max(r, g, b);
+            const diff = v - Math.min(r, g, b);
+            const diffc = function(c) {
+                return (v - c) / 6 / diff + 0.5;
+            };
+            if (0 === diff) {
+                h = 0;
+                s = 0;
+            } else {
+                s = diff / v;
+                rdif = diffc(r);
+                gdif = diffc(g);
+                bdif = diffc(b);
+                if (r === v) h = bdif - gdif;
+                else if (g === v) h = 1 / 3 + rdif - bdif;
+                else if (b === v) h = 2 / 3 + gdif - rdif;
+                if (h < 0) h += 1;
+                else if (h > 1) h -= 1;
+            }
+            return [
+                360 * h,
+                100 * s,
+                100 * v
+            ];
+        };
+        convert.rgb.hwb = function(rgb) {
+            const r = rgb[0];
+            const g = rgb[1];
+            let b = rgb[2];
+            const h = convert.rgb.hsl(rgb)[0];
+            const w = 1 / 255 * Math.min(r, Math.min(g, b));
+            b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+            return [
+                h,
+                100 * w,
+                100 * b
+            ];
+        };
+        convert.rgb.cmyk = function(rgb) {
+            const r = rgb[0] / 255;
+            const g = rgb[1] / 255;
+            const b = rgb[2] / 255;
+            const k = Math.min(1 - r, 1 - g, 1 - b);
+            const c = (1 - r - k) / (1 - k) || 0;
+            const m = (1 - g - k) / (1 - k) || 0;
+            const y = (1 - b - k) / (1 - k) || 0;
+            return [
+                100 * c,
+                100 * m,
+                100 * y,
+                100 * k
+            ];
+        };
+        function comparativeDistance(x, y) {
+            /*
+		See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+	*/ return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
+        }
+        convert.rgb.keyword = function(rgb) {
+            const reversed = reverseKeywords[rgb];
+            if (reversed) return reversed;
+            let currentClosestDistance = 1 / 0;
+            let currentClosestKeyword;
+            for (const keyword of Object.keys(cssKeywords)){
+                const value = cssKeywords[keyword];
+                // Compute comparative distance
+                const distance = comparativeDistance(rgb, value);
+                // Check if its less, if so set as closest
+                if (distance < currentClosestDistance) {
+                    currentClosestDistance = distance;
+                    currentClosestKeyword = keyword;
+                }
+            }
+            return currentClosestKeyword;
+        };
+        convert.keyword.rgb = function(keyword) {
+            return cssKeywords[keyword];
+        };
+        convert.rgb.xyz = function(rgb) {
+            let r = rgb[0] / 255;
+            let g = rgb[1] / 255;
+            let b = rgb[2] / 255;
+            // Assume sRGB
+            r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92;
+            g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92;
+            b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
+            const x = 0.4124 * r + 0.3576 * g + 0.1805 * b;
+            const y = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+            const z = 0.0193 * r + 0.1192 * g + 0.9505 * b;
+            return [
+                100 * x,
+                100 * y,
+                100 * z
+            ];
+        };
+        convert.rgb.lab = function(rgb) {
+            const xyz = convert.rgb.xyz(rgb);
+            let x = xyz[0];
+            let y = xyz[1];
+            let z = xyz[2];
+            x /= 95.047;
+            y /= 100;
+            z /= 108.883;
+            x = x > 0.008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+            y = y > 0.008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+            z = z > 0.008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+            const l = 116 * y - 16;
+            const a = 500 * (x - y);
+            const b = 200 * (y - z);
+            return [
+                l,
+                a,
+                b
+            ];
+        };
+        convert.hsl.rgb = function(hsl) {
+            const h = hsl[0] / 360;
+            const s = hsl[1] / 100;
+            const l = hsl[2] / 100;
+            let t2;
+            let t3;
+            let val;
+            if (0 === s) {
+                val = 255 * l;
+                return [
+                    val,
+                    val,
+                    val
+                ];
+            }
+            t2 = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            const t1 = 2 * l - t2;
+            const rgb = [
+                0,
+                0,
+                0
+            ];
+            for(let i = 0; i < 3; i++){
+                t3 = h + 1 / 3 * -(i - 1);
+                if (t3 < 0) t3++;
+                if (t3 > 1) t3--;
+                val = 6 * t3 < 1 ? t1 + (t2 - t1) * 6 * t3 : 2 * t3 < 1 ? t2 : 3 * t3 < 2 ? t1 + (t2 - t1) * (2 / 3 - t3) * 6 : t1;
+                rgb[i] = 255 * val;
+            }
+            return rgb;
+        };
+        convert.hsl.hsv = function(hsl) {
+            const h = hsl[0];
+            let s = hsl[1] / 100;
+            let l = hsl[2] / 100;
+            let smin = s;
+            const lmin = Math.max(l, 0.01);
+            l *= 2;
+            s *= l <= 1 ? l : 2 - l;
+            smin *= lmin <= 1 ? lmin : 2 - lmin;
+            const v = (l + s) / 2;
+            const sv = 0 === l ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+            return [
+                h,
+                100 * sv,
+                100 * v
+            ];
+        };
+        convert.hsv.rgb = function(hsv) {
+            const h = hsv[0] / 60;
+            const s = hsv[1] / 100;
+            let v = hsv[2] / 100;
+            const hi = Math.floor(h) % 6;
+            const f = h - Math.floor(h);
+            const p = 255 * v * (1 - s);
+            const q = 255 * v * (1 - s * f);
+            const t = 255 * v * (1 - s * (1 - f));
+            v *= 255;
+            switch(hi){
+                case 0:
+                    return [
+                        v,
+                        t,
+                        p
+                    ];
+                case 1:
+                    return [
+                        q,
+                        v,
+                        p
+                    ];
+                case 2:
+                    return [
+                        p,
+                        v,
+                        t
+                    ];
+                case 3:
+                    return [
+                        p,
+                        q,
+                        v
+                    ];
+                case 4:
+                    return [
+                        t,
+                        p,
+                        v
+                    ];
+                case 5:
+                    return [
+                        v,
+                        p,
+                        q
+                    ];
+            }
+        };
+        convert.hsv.hsl = function(hsv) {
+            const h = hsv[0];
+            const s = hsv[1] / 100;
+            const v = hsv[2] / 100;
+            const vmin = Math.max(v, 0.01);
+            let sl;
+            let l;
+            l = (2 - s) * v;
+            const lmin = (2 - s) * vmin;
+            sl = s * vmin;
+            sl /= lmin <= 1 ? lmin : 2 - lmin;
+            sl = sl || 0;
+            l /= 2;
+            return [
+                h,
+                100 * sl,
+                100 * l
+            ];
+        };
+        // http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+        convert.hwb.rgb = function(hwb) {
+            const h = hwb[0] / 360;
+            let wh = hwb[1] / 100;
+            let bl = hwb[2] / 100;
+            const ratio = wh + bl;
+            let f;
+            // Wh + bl cant be > 1
+            if (ratio > 1) {
+                wh /= ratio;
+                bl /= ratio;
+            }
+            const i = Math.floor(6 * h);
+            const v = 1 - bl;
+            f = 6 * h - i;
+            if ((0x01 & i) !== 0) f = 1 - f;
+            const n = wh + f * (v - wh); // Linear interpolation
+            let r;
+            let g;
+            let b;
+            /* eslint-disable max-statements-per-line,no-multi-spaces */ switch(i){
+                default:
+                case 6:
+                case 0:
+                    r = v;
+                    g = n;
+                    b = wh;
+                    break;
+                case 1:
+                    r = n;
+                    g = v;
+                    b = wh;
+                    break;
+                case 2:
+                    r = wh;
+                    g = v;
+                    b = n;
+                    break;
+                case 3:
+                    r = wh;
+                    g = n;
+                    b = v;
+                    break;
+                case 4:
+                    r = n;
+                    g = wh;
+                    b = v;
+                    break;
+                case 5:
+                    r = v;
+                    g = wh;
+                    b = n;
+                    break;
+            }
+            /* eslint-enable max-statements-per-line,no-multi-spaces */ return [
+                255 * r,
+                255 * g,
+                255 * b
+            ];
+        };
+        convert.cmyk.rgb = function(cmyk) {
+            const c = cmyk[0] / 100;
+            const m = cmyk[1] / 100;
+            const y = cmyk[2] / 100;
+            const k = cmyk[3] / 100;
+            const r = 1 - Math.min(1, c * (1 - k) + k);
+            const g = 1 - Math.min(1, m * (1 - k) + k);
+            const b = 1 - Math.min(1, y * (1 - k) + k);
+            return [
+                255 * r,
+                255 * g,
+                255 * b
+            ];
+        };
+        convert.xyz.rgb = function(xyz) {
+            const x = xyz[0] / 100;
+            const y = xyz[1] / 100;
+            const z = xyz[2] / 100;
+            let r;
+            let g;
+            let b;
+            r = 3.2406 * x + -1.5372 * y + -0.4986 * z;
+            g = -0.9689 * x + 1.8758 * y + 0.0415 * z;
+            b = 0.0557 * x + -0.204 * y + 1.0570 * z;
+            // Assume sRGB
+            r = r > 0.0031308 ? 1.055 * r ** (1.0 / 2.4) - 0.055 : 12.92 * r;
+            g = g > 0.0031308 ? 1.055 * g ** (1.0 / 2.4) - 0.055 : 12.92 * g;
+            b = b > 0.0031308 ? 1.055 * b ** (1.0 / 2.4) - 0.055 : 12.92 * b;
+            r = Math.min(Math.max(0, r), 1);
+            g = Math.min(Math.max(0, g), 1);
+            b = Math.min(Math.max(0, b), 1);
+            return [
+                255 * r,
+                255 * g,
+                255 * b
+            ];
+        };
+        convert.xyz.lab = function(xyz) {
+            let x = xyz[0];
+            let y = xyz[1];
+            let z = xyz[2];
+            x /= 95.047;
+            y /= 100;
+            z /= 108.883;
+            x = x > 0.008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+            y = y > 0.008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+            z = z > 0.008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+            const l = 116 * y - 16;
+            const a = 500 * (x - y);
+            const b = 200 * (y - z);
+            return [
+                l,
+                a,
+                b
+            ];
+        };
+        convert.lab.xyz = function(lab) {
+            const l = lab[0];
+            const a = lab[1];
+            const b = lab[2];
+            let x;
+            let y;
+            let z;
+            y = (l + 16) / 116;
+            x = a / 500 + y;
+            z = y - b / 200;
+            const y2 = y ** 3;
+            const x2 = x ** 3;
+            const z2 = z ** 3;
+            y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+            x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+            z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+            x *= 95.047;
+            y *= 100;
+            z *= 108.883;
+            return [
+                x,
+                y,
+                z
+            ];
+        };
+        convert.lab.lch = function(lab) {
+            const l = lab[0];
+            const a = lab[1];
+            const b = lab[2];
+            let h;
+            const hr = Math.atan2(b, a);
+            h = 360 * hr / 2 / Math.PI;
+            if (h < 0) h += 360;
+            const c = Math.sqrt(a * a + b * b);
+            return [
+                l,
+                c,
+                h
+            ];
+        };
+        convert.lch.lab = function(lch) {
+            const l = lch[0];
+            const c = lch[1];
+            const h = lch[2];
+            const hr = h / 360 * 2 * Math.PI;
+            const a = c * Math.cos(hr);
+            const b = c * Math.sin(hr);
+            return [
+                l,
+                a,
+                b
+            ];
+        };
+        convert.rgb.ansi16 = function(args, saturation = null) {
+            const [r, g, b] = args;
+            let value = null === saturation ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
+            value = Math.round(value / 50);
+            if (0 === value) return 30;
+            let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+            if (2 === value) ansi += 60;
+            return ansi;
+        };
+        convert.hsv.ansi16 = function(args) {
+            // Optimization here; we already know the value and don't need to get
+            // it converted for us.
+            return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+        };
+        convert.rgb.ansi256 = function(args) {
+            const r = args[0];
+            const g = args[1];
+            const b = args[2];
+            // We use the extended greyscale palette here, with the exception of
+            // black and white. normal palette only has 4 greyscale shades.
+            if (r === g && g === b) {
+                if (r < 8) return 16;
+                if (r > 248) return 231;
+                return Math.round((r - 8) / 247 * 24) + 232;
+            }
+            const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+            return ansi;
+        };
+        convert.ansi16.rgb = function(args) {
+            let color = args % 10;
+            // Handle greyscale
+            if (0 === color || 7 === color) {
+                if (args > 50) color += 3.5;
+                color = color / 10.5 * 255;
+                return [
+                    color,
+                    color,
+                    color
+                ];
+            }
+            const mult = (~~(args > 50) + 1) * 0.5;
+            const r = (1 & color) * mult * 255;
+            const g = (color >> 1 & 1) * mult * 255;
+            const b = (color >> 2 & 1) * mult * 255;
+            return [
+                r,
+                g,
+                b
+            ];
+        };
+        convert.ansi256.rgb = function(args) {
+            // Handle greyscale
+            if (args >= 232) {
+                const c = (args - 232) * 10 + 8;
+                return [
+                    c,
+                    c,
+                    c
+                ];
+            }
+            args -= 16;
+            let rem;
+            const r = Math.floor(args / 36) / 5 * 255;
+            const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+            const b = rem % 6 / 5 * 255;
+            return [
+                r,
+                g,
+                b
+            ];
+        };
+        convert.rgb.hex = function(args) {
+            const integer = ((0xFF & Math.round(args[0])) << 16) + ((0xFF & Math.round(args[1])) << 8) + (0xFF & Math.round(args[2]));
+            const string = integer.toString(16).toUpperCase();
+            return '000000'.substring(string.length) + string;
+        };
+        convert.hex.rgb = function(args) {
+            const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+            if (!match) return [
+                0,
+                0,
+                0
+            ];
+            let colorString = match[0];
+            if (3 === match[0].length) colorString = colorString.split('').map((char)=>char + char).join('');
+            const integer = parseInt(colorString, 16);
+            const r = integer >> 16 & 0xFF;
+            const g = integer >> 8 & 0xFF;
+            const b = 0xFF & integer;
+            return [
+                r,
+                g,
+                b
+            ];
+        };
+        convert.rgb.hcg = function(rgb) {
+            const r = rgb[0] / 255;
+            const g = rgb[1] / 255;
+            const b = rgb[2] / 255;
+            const max = Math.max(Math.max(r, g), b);
+            const min = Math.min(Math.min(r, g), b);
+            const chroma = max - min;
+            let grayscale;
+            let hue;
+            grayscale = chroma < 1 ? min / (1 - chroma) : 0;
+            hue = chroma <= 0 ? 0 : max === r ? (g - b) / chroma % 6 : max === g ? 2 + (b - r) / chroma : 4 + (r - g) / chroma;
+            hue /= 6;
+            hue %= 1;
+            return [
+                360 * hue,
+                100 * chroma,
+                100 * grayscale
+            ];
+        };
+        convert.hsl.hcg = function(hsl) {
+            const s = hsl[1] / 100;
+            const l = hsl[2] / 100;
+            const c = l < 0.5 ? 2.0 * s * l : 2.0 * s * (1.0 - l);
+            let f = 0;
+            if (c < 1.0) f = (l - 0.5 * c) / (1.0 - c);
+            return [
+                hsl[0],
+                100 * c,
+                100 * f
+            ];
+        };
+        convert.hsv.hcg = function(hsv) {
+            const s = hsv[1] / 100;
+            const v = hsv[2] / 100;
+            const c = s * v;
+            let f = 0;
+            if (c < 1.0) f = (v - c) / (1 - c);
+            return [
+                hsv[0],
+                100 * c,
+                100 * f
+            ];
+        };
+        convert.hcg.rgb = function(hcg) {
+            const h = hcg[0] / 360;
+            const c = hcg[1] / 100;
+            const g = hcg[2] / 100;
+            if (0.0 === c) return [
+                255 * g,
+                255 * g,
+                255 * g
+            ];
+            const pure = [
+                0,
+                0,
+                0
+            ];
+            const hi = h % 1 * 6;
+            const v = hi % 1;
+            const w = 1 - v;
+            let mg = 0;
+            /* eslint-disable max-statements-per-line */ switch(Math.floor(hi)){
+                case 0:
+                    pure[0] = 1;
+                    pure[1] = v;
+                    pure[2] = 0;
+                    break;
+                case 1:
+                    pure[0] = w;
+                    pure[1] = 1;
+                    pure[2] = 0;
+                    break;
+                case 2:
+                    pure[0] = 0;
+                    pure[1] = 1;
+                    pure[2] = v;
+                    break;
+                case 3:
+                    pure[0] = 0;
+                    pure[1] = w;
+                    pure[2] = 1;
+                    break;
+                case 4:
+                    pure[0] = v;
+                    pure[1] = 0;
+                    pure[2] = 1;
+                    break;
+                default:
+                    pure[0] = 1;
+                    pure[1] = 0;
+                    pure[2] = w;
+            }
+            /* eslint-enable max-statements-per-line */ mg = (1.0 - c) * g;
+            return [
+                (c * pure[0] + mg) * 255,
+                (c * pure[1] + mg) * 255,
+                (c * pure[2] + mg) * 255
+            ];
+        };
+        convert.hcg.hsv = function(hcg) {
+            const c = hcg[1] / 100;
+            const g = hcg[2] / 100;
+            const v = c + g * (1.0 - c);
+            let f = 0;
+            if (v > 0.0) f = c / v;
+            return [
+                hcg[0],
+                100 * f,
+                100 * v
+            ];
+        };
+        convert.hcg.hsl = function(hcg) {
+            const c = hcg[1] / 100;
+            const g = hcg[2] / 100;
+            const l = g * (1.0 - c) + 0.5 * c;
+            let s = 0;
+            if (l > 0.0 && l < 0.5) s = c / (2 * l);
+            else if (l >= 0.5 && l < 1.0) s = c / (2 * (1 - l));
+            return [
+                hcg[0],
+                100 * s,
+                100 * l
+            ];
+        };
+        convert.hcg.hwb = function(hcg) {
+            const c = hcg[1] / 100;
+            const g = hcg[2] / 100;
+            const v = c + g * (1.0 - c);
+            return [
+                hcg[0],
+                (v - c) * 100,
+                (1 - v) * 100
+            ];
+        };
+        convert.hwb.hcg = function(hwb) {
+            const w = hwb[1] / 100;
+            const b = hwb[2] / 100;
+            const v = 1 - b;
+            const c = v - w;
+            let g = 0;
+            if (c < 1) g = (v - c) / (1 - c);
+            return [
+                hwb[0],
+                100 * c,
+                100 * g
+            ];
+        };
+        convert.apple.rgb = function(apple) {
+            return [
+                apple[0] / 65535 * 255,
+                apple[1] / 65535 * 255,
+                apple[2] / 65535 * 255
+            ];
+        };
+        convert.rgb.apple = function(rgb) {
+            return [
+                rgb[0] / 255 * 65535,
+                rgb[1] / 255 * 65535,
+                rgb[2] / 255 * 65535
+            ];
+        };
+        convert.gray.rgb = function(args) {
+            return [
+                args[0] / 100 * 255,
+                args[0] / 100 * 255,
+                args[0] / 100 * 255
+            ];
+        };
+        convert.gray.hsl = function(args) {
+            return [
+                0,
+                0,
+                args[0]
+            ];
+        };
+        convert.gray.hsv = convert.gray.hsl;
+        convert.gray.hwb = function(gray) {
+            return [
+                0,
+                100,
+                gray[0]
+            ];
+        };
+        convert.gray.cmyk = function(gray) {
+            return [
+                0,
+                0,
+                0,
+                gray[0]
+            ];
+        };
+        convert.gray.lab = function(gray) {
+            return [
+                gray[0],
+                0,
+                0
+            ];
+        };
+        convert.gray.hex = function(gray) {
+            const val = 0xFF & Math.round(gray[0] / 100 * 255);
+            const integer = (val << 16) + (val << 8) + val;
+            const string = integer.toString(16).toUpperCase();
+            return '000000'.substring(string.length) + string;
+        };
+        convert.rgb.gray = function(rgb) {
+            const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+            return [
+                val / 255 * 100
+            ];
+        };
+    },
+    "../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const conversions = __webpack_require__("../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js");
+        const route = __webpack_require__("../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/route.js");
+        const convert = {};
+        const models = Object.keys(conversions);
+        function wrapRaw(fn) {
+            const wrappedFn = function(...args) {
+                const arg0 = args[0];
+                if (null == arg0) return arg0;
+                if (arg0.length > 1) args = arg0;
+                return fn(args);
+            };
+            // Preserve .conversion property if there is one
+            if ('conversion' in fn) wrappedFn.conversion = fn.conversion;
+            return wrappedFn;
+        }
+        function wrapRounded(fn) {
+            const wrappedFn = function(...args) {
+                const arg0 = args[0];
+                if (null == arg0) return arg0;
+                if (arg0.length > 1) args = arg0;
+                const result = fn(args);
+                // We're assuming the result is an array here.
+                // see notice in conversions.js; don't use box types
+                // in conversion functions.
+                if ('object' == typeof result) for(let len = result.length, i = 0; i < len; i++)result[i] = Math.round(result[i]);
+                return result;
+            };
+            // Preserve .conversion property if there is one
+            if ('conversion' in fn) wrappedFn.conversion = fn.conversion;
+            return wrappedFn;
+        }
+        models.forEach((fromModel)=>{
+            convert[fromModel] = {};
+            Object.defineProperty(convert[fromModel], 'channels', {
+                value: conversions[fromModel].channels
+            });
+            Object.defineProperty(convert[fromModel], 'labels', {
+                value: conversions[fromModel].labels
+            });
+            const routes = route(fromModel);
+            const routeModels = Object.keys(routes);
+            routeModels.forEach((toModel)=>{
+                const fn = routes[toModel];
+                convert[fromModel][toModel] = wrapRounded(fn);
+                convert[fromModel][toModel].raw = wrapRaw(fn);
+            });
+        });
+        module.exports = convert;
+    },
+    "../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/route.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const conversions = __webpack_require__("../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js");
+        /*
+	This function routes a model to all other models.
+
+	all functions that are routed have a property `.conversion` attached
+	to the returned synthetic function. This property is an array
+	of strings, each with the steps in between the 'from' and 'to'
+	color models (inclusive).
+
+	conversions that are not possible simply are not included.
+*/ function buildGraph() {
+            const graph = {};
+            // https://jsperf.com/object-keys-vs-for-in-with-closure/3
+            const models = Object.keys(conversions);
+            for(let len = models.length, i = 0; i < len; i++)graph[models[i]] = {
+                // http://jsperf.com/1-vs-infinity
+                // micro-opt, but this is simple.
+                distance: -1,
+                parent: null
+            };
+            return graph;
+        }
+        // https://en.wikipedia.org/wiki/Breadth-first_search
+        function deriveBFS(fromModel) {
+            const graph = buildGraph();
+            const queue = [
+                fromModel
+            ]; // Unshift -> queue -> pop
+            graph[fromModel].distance = 0;
+            while(queue.length){
+                const current = queue.pop();
+                const adjacents = Object.keys(conversions[current]);
+                for(let len = adjacents.length, i = 0; i < len; i++){
+                    const adjacent = adjacents[i];
+                    const node = graph[adjacent];
+                    if (-1 === node.distance) {
+                        node.distance = graph[current].distance + 1;
+                        node.parent = current;
+                        queue.unshift(adjacent);
+                    }
+                }
+            }
+            return graph;
+        }
+        function link(from, to) {
+            return function(args) {
+                return to(from(args));
+            };
+        }
+        function wrapConversion(toModel, graph) {
+            const path = [
+                graph[toModel].parent,
+                toModel
+            ];
+            let fn = conversions[graph[toModel].parent][toModel];
+            let cur = graph[toModel].parent;
+            while(graph[cur].parent){
+                path.unshift(graph[cur].parent);
+                fn = link(conversions[graph[cur].parent][cur], fn);
+                cur = graph[cur].parent;
+            }
+            fn.conversion = path;
+            return fn;
+        }
+        module.exports = function(fromModel) {
+            const graph = deriveBFS(fromModel);
+            const conversion = {};
+            const models = Object.keys(graph);
+            for(let len = models.length, i = 0; i < len; i++){
+                const toModel = models[i];
+                const node = graph[toModel];
+                if (null !== node.parent) conversion[toModel] = wrapConversion(toModel, graph);
+            }
+            return conversion;
+        };
+    },
+    "../../../node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js": function(module) {
+        "use strict";
+        module.exports = {
+            aliceblue: [
+                240,
+                248,
+                255
+            ],
+            antiquewhite: [
+                250,
+                235,
+                215
+            ],
+            aqua: [
+                0,
+                255,
+                255
+            ],
+            aquamarine: [
+                127,
+                255,
+                212
+            ],
+            azure: [
+                240,
+                255,
+                255
+            ],
+            beige: [
+                245,
+                245,
+                220
+            ],
+            bisque: [
+                255,
+                228,
+                196
+            ],
+            black: [
+                0,
+                0,
+                0
+            ],
+            blanchedalmond: [
+                255,
+                235,
+                205
+            ],
+            blue: [
+                0,
+                0,
+                255
+            ],
+            blueviolet: [
+                138,
+                43,
+                226
+            ],
+            brown: [
+                165,
+                42,
+                42
+            ],
+            burlywood: [
+                222,
+                184,
+                135
+            ],
+            cadetblue: [
+                95,
+                158,
+                160
+            ],
+            chartreuse: [
+                127,
+                255,
+                0
+            ],
+            chocolate: [
+                210,
+                105,
+                30
+            ],
+            coral: [
+                255,
+                127,
+                80
+            ],
+            cornflowerblue: [
+                100,
+                149,
+                237
+            ],
+            cornsilk: [
+                255,
+                248,
+                220
+            ],
+            crimson: [
+                220,
+                20,
+                60
+            ],
+            cyan: [
+                0,
+                255,
+                255
+            ],
+            darkblue: [
+                0,
+                0,
+                139
+            ],
+            darkcyan: [
+                0,
+                139,
+                139
+            ],
+            darkgoldenrod: [
+                184,
+                134,
+                11
+            ],
+            darkgray: [
+                169,
+                169,
+                169
+            ],
+            darkgreen: [
+                0,
+                100,
+                0
+            ],
+            darkgrey: [
+                169,
+                169,
+                169
+            ],
+            darkkhaki: [
+                189,
+                183,
+                107
+            ],
+            darkmagenta: [
+                139,
+                0,
+                139
+            ],
+            darkolivegreen: [
+                85,
+                107,
+                47
+            ],
+            darkorange: [
+                255,
+                140,
+                0
+            ],
+            darkorchid: [
+                153,
+                50,
+                204
+            ],
+            darkred: [
+                139,
+                0,
+                0
+            ],
+            darksalmon: [
+                233,
+                150,
+                122
+            ],
+            darkseagreen: [
+                143,
+                188,
+                143
+            ],
+            darkslateblue: [
+                72,
+                61,
+                139
+            ],
+            darkslategray: [
+                47,
+                79,
+                79
+            ],
+            darkslategrey: [
+                47,
+                79,
+                79
+            ],
+            darkturquoise: [
+                0,
+                206,
+                209
+            ],
+            darkviolet: [
+                148,
+                0,
+                211
+            ],
+            deeppink: [
+                255,
+                20,
+                147
+            ],
+            deepskyblue: [
+                0,
+                191,
+                255
+            ],
+            dimgray: [
+                105,
+                105,
+                105
+            ],
+            dimgrey: [
+                105,
+                105,
+                105
+            ],
+            dodgerblue: [
+                30,
+                144,
+                255
+            ],
+            firebrick: [
+                178,
+                34,
+                34
+            ],
+            floralwhite: [
+                255,
+                250,
+                240
+            ],
+            forestgreen: [
+                34,
+                139,
+                34
+            ],
+            fuchsia: [
+                255,
+                0,
+                255
+            ],
+            gainsboro: [
+                220,
+                220,
+                220
+            ],
+            ghostwhite: [
+                248,
+                248,
+                255
+            ],
+            gold: [
+                255,
+                215,
+                0
+            ],
+            goldenrod: [
+                218,
+                165,
+                32
+            ],
+            gray: [
+                128,
+                128,
+                128
+            ],
+            green: [
+                0,
+                128,
+                0
+            ],
+            greenyellow: [
+                173,
+                255,
+                47
+            ],
+            grey: [
+                128,
+                128,
+                128
+            ],
+            honeydew: [
+                240,
+                255,
+                240
+            ],
+            hotpink: [
+                255,
+                105,
+                180
+            ],
+            indianred: [
+                205,
+                92,
+                92
+            ],
+            indigo: [
+                75,
+                0,
+                130
+            ],
+            ivory: [
+                255,
+                255,
+                240
+            ],
+            khaki: [
+                240,
+                230,
+                140
+            ],
+            lavender: [
+                230,
+                230,
+                250
+            ],
+            lavenderblush: [
+                255,
+                240,
+                245
+            ],
+            lawngreen: [
+                124,
+                252,
+                0
+            ],
+            lemonchiffon: [
+                255,
+                250,
+                205
+            ],
+            lightblue: [
+                173,
+                216,
+                230
+            ],
+            lightcoral: [
+                240,
+                128,
+                128
+            ],
+            lightcyan: [
+                224,
+                255,
+                255
+            ],
+            lightgoldenrodyellow: [
+                250,
+                250,
+                210
+            ],
+            lightgray: [
+                211,
+                211,
+                211
+            ],
+            lightgreen: [
+                144,
+                238,
+                144
+            ],
+            lightgrey: [
+                211,
+                211,
+                211
+            ],
+            lightpink: [
+                255,
+                182,
+                193
+            ],
+            lightsalmon: [
+                255,
+                160,
+                122
+            ],
+            lightseagreen: [
+                32,
+                178,
+                170
+            ],
+            lightskyblue: [
+                135,
+                206,
+                250
+            ],
+            lightslategray: [
+                119,
+                136,
+                153
+            ],
+            lightslategrey: [
+                119,
+                136,
+                153
+            ],
+            lightsteelblue: [
+                176,
+                196,
+                222
+            ],
+            lightyellow: [
+                255,
+                255,
+                224
+            ],
+            lime: [
+                0,
+                255,
+                0
+            ],
+            limegreen: [
+                50,
+                205,
+                50
+            ],
+            linen: [
+                250,
+                240,
+                230
+            ],
+            magenta: [
+                255,
+                0,
+                255
+            ],
+            maroon: [
+                128,
+                0,
+                0
+            ],
+            mediumaquamarine: [
+                102,
+                205,
+                170
+            ],
+            mediumblue: [
+                0,
+                0,
+                205
+            ],
+            mediumorchid: [
+                186,
+                85,
+                211
+            ],
+            mediumpurple: [
+                147,
+                112,
+                219
+            ],
+            mediumseagreen: [
+                60,
+                179,
+                113
+            ],
+            mediumslateblue: [
+                123,
+                104,
+                238
+            ],
+            mediumspringgreen: [
+                0,
+                250,
+                154
+            ],
+            mediumturquoise: [
+                72,
+                209,
+                204
+            ],
+            mediumvioletred: [
+                199,
+                21,
+                133
+            ],
+            midnightblue: [
+                25,
+                25,
+                112
+            ],
+            mintcream: [
+                245,
+                255,
+                250
+            ],
+            mistyrose: [
+                255,
+                228,
+                225
+            ],
+            moccasin: [
+                255,
+                228,
+                181
+            ],
+            navajowhite: [
+                255,
+                222,
+                173
+            ],
+            navy: [
+                0,
+                0,
+                128
+            ],
+            oldlace: [
+                253,
+                245,
+                230
+            ],
+            olive: [
+                128,
+                128,
+                0
+            ],
+            olivedrab: [
+                107,
+                142,
+                35
+            ],
+            orange: [
+                255,
+                165,
+                0
+            ],
+            orangered: [
+                255,
+                69,
+                0
+            ],
+            orchid: [
+                218,
+                112,
+                214
+            ],
+            palegoldenrod: [
+                238,
+                232,
+                170
+            ],
+            palegreen: [
+                152,
+                251,
+                152
+            ],
+            paleturquoise: [
+                175,
+                238,
+                238
+            ],
+            palevioletred: [
+                219,
+                112,
+                147
+            ],
+            papayawhip: [
+                255,
+                239,
+                213
+            ],
+            peachpuff: [
+                255,
+                218,
+                185
+            ],
+            peru: [
+                205,
+                133,
+                63
+            ],
+            pink: [
+                255,
+                192,
+                203
+            ],
+            plum: [
+                221,
+                160,
+                221
+            ],
+            powderblue: [
+                176,
+                224,
+                230
+            ],
+            purple: [
+                128,
+                0,
+                128
+            ],
+            rebeccapurple: [
+                102,
+                51,
+                153
+            ],
+            red: [
+                255,
+                0,
+                0
+            ],
+            rosybrown: [
+                188,
+                143,
+                143
+            ],
+            royalblue: [
+                65,
+                105,
+                225
+            ],
+            saddlebrown: [
+                139,
+                69,
+                19
+            ],
+            salmon: [
+                250,
+                128,
+                114
+            ],
+            sandybrown: [
+                244,
+                164,
+                96
+            ],
+            seagreen: [
+                46,
+                139,
+                87
+            ],
+            seashell: [
+                255,
+                245,
+                238
+            ],
+            sienna: [
+                160,
+                82,
+                45
+            ],
+            silver: [
+                192,
+                192,
+                192
+            ],
+            skyblue: [
+                135,
+                206,
+                235
+            ],
+            slateblue: [
+                106,
+                90,
+                205
+            ],
+            slategray: [
+                112,
+                128,
+                144
+            ],
+            slategrey: [
+                112,
+                128,
+                144
+            ],
+            snow: [
+                255,
+                250,
+                250
+            ],
+            springgreen: [
+                0,
+                255,
+                127
+            ],
+            steelblue: [
+                70,
+                130,
+                180
+            ],
+            tan: [
+                210,
+                180,
+                140
+            ],
+            teal: [
+                0,
+                128,
+                128
+            ],
+            thistle: [
+                216,
+                191,
+                216
+            ],
+            tomato: [
+                255,
+                99,
+                71
+            ],
+            turquoise: [
+                64,
+                224,
+                208
+            ],
+            violet: [
+                238,
+                130,
+                238
+            ],
+            wheat: [
+                245,
+                222,
+                179
+            ],
+            white: [
+                255,
+                255,
+                255
+            ],
+            whitesmoke: [
+                245,
+                245,
+                245
+            ],
+            yellow: [
+                255,
+                255,
+                0
+            ],
+            yellowgreen: [
+                154,
+                205,
+                50
+            ]
+        };
+    },
+    "../../../node_modules/.pnpm/emoji-regex@8.0.0/node_modules/emoji-regex/index.js": function(module) {
+        "use strict";
+        module.exports = function() {
+            // https://mths.be/emoji
+            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": function(module) {
+        "use strict";
+        /* eslint-disable yoda */ const isFullwidthCodePoint = (codePoint)=>{
+            if (Number.isNaN(codePoint)) return false;
+            // Code points are derived from:
+            // http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt
+            if (codePoint >= 0x1100 && (codePoint <= 0x115F || // Hangul Jamo
+            0x2329 === codePoint || // LEFT-POINTING ANGLE BRACKET
+            0x232A === codePoint || // RIGHT-POINTING ANGLE BRACKET
+            // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+            0x2E80 <= codePoint && codePoint <= 0x3247 && 0x303F !== codePoint || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+            0x3250 <= codePoint && codePoint <= 0x4DBF || // CJK Unified Ideographs .. Yi Radicals
+            0x4E00 <= codePoint && codePoint <= 0xA4C6 || // Hangul Jamo Extended-A
+            0xA960 <= codePoint && codePoint <= 0xA97C || // Hangul Syllables
+            0xAC00 <= codePoint && codePoint <= 0xD7A3 || // CJK Compatibility Ideographs
+            0xF900 <= codePoint && codePoint <= 0xFAFF || // Vertical Forms
+            0xFE10 <= codePoint && codePoint <= 0xFE19 || // CJK Compatibility Forms .. Small Form Variants
+            0xFE30 <= codePoint && codePoint <= 0xFE6B || // Halfwidth and Fullwidth Forms
+            0xFF01 <= codePoint && codePoint <= 0xFF60 || 0xFFE0 <= codePoint && codePoint <= 0xFFE6 || // Kana Supplement
+            0x1B000 <= codePoint && codePoint <= 0x1B001 || // Enclosed Ideographic Supplement
+            0x1F200 <= codePoint && codePoint <= 0x1F251 || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+            0x20000 <= codePoint && codePoint <= 0x3FFFD)) return true;
+            return false;
+        };
+        module.exports = isFullwidthCodePoint;
+        module.exports["default"] = isFullwidthCodePoint;
+    },
+    "../../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const stream_1 = __webpack_require__("stream");
+        const CONSOLE_METHODS = [
+            'assert',
+            'count',
+            'countReset',
+            'debug',
+            'dir',
+            'dirxml',
+            'error',
+            'group',
+            'groupCollapsed',
+            'groupEnd',
+            'info',
+            'log',
+            'table',
+            'time',
+            'timeEnd',
+            'timeLog',
+            'trace',
+            'warn'
+        ];
+        let originalMethods = {};
+        const patchConsole = (callback)=>{
+            const stdout = new stream_1.PassThrough();
+            const stderr = new stream_1.PassThrough();
+            stdout.write = (data)=>callback('stdout', data);
+            stderr.write = (data)=>callback('stderr', data);
+            const internalConsole = new console.Console(stdout, stderr);
+            for (const method of CONSOLE_METHODS){
+                originalMethods[method] = console[method];
+                console[method] = internalConsole[method];
+            }
+            return ()=>{
+                for (const method of CONSOLE_METHODS)console[method] = originalMethods[method];
+                originalMethods = {};
+            };
+        };
+        module.exports = patchConsole;
+    //# sourceMappingURL=index.js.map
+    },
+    "../../../node_modules/.pnpm/slice-ansi@3.0.0/node_modules/slice-ansi/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const isFullwidthCodePoint = __webpack_require__("../../../node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js");
+        const astralRegex = __webpack_require__("../../../node_modules/.pnpm/astral-regex@2.0.0/node_modules/astral-regex/index.js");
+        const ansiStyles = __webpack_require__("../../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js");
+        const ESCAPES = [
+            '\u001B',
+            '\u009B'
+        ];
+        const wrapAnsi = (code)=>`${ESCAPES[0]}[${code}m`;
+        const checkAnsi = (ansiCodes, isEscapes, endAnsiCode)=>{
+            let output = [];
+            ansiCodes = [
+                ...ansiCodes
+            ];
+            for (let ansiCode of ansiCodes){
+                const ansiCodeOrigin = ansiCode;
+                if (ansiCode.match(';')) ansiCode = ansiCode.split(';')[0][0] + '0';
+                const item = ansiStyles.codes.get(parseInt(ansiCode, 10));
+                if (item) {
+                    const indexEscape = ansiCodes.indexOf(item.toString());
+                    if (indexEscape >= 0) ansiCodes.splice(indexEscape, 1);
+                    else output.push(wrapAnsi(isEscapes ? item : ansiCodeOrigin));
+                } else if (isEscapes) {
+                    output.push(wrapAnsi(0));
+                    break;
+                } else output.push(wrapAnsi(ansiCodeOrigin));
+            }
+            if (isEscapes) {
+                output = output.filter((element, index)=>output.indexOf(element) === index);
+                if (void 0 !== endAnsiCode) {
+                    const fistEscapeCode = wrapAnsi(ansiStyles.codes.get(parseInt(endAnsiCode, 10)));
+                    output = output.reduce((current, next)=>next === fistEscapeCode ? [
+                            next,
+                            ...current
+                        ] : [
+                            ...current,
+                            next
+                        ], []);
+                }
+            }
+            return output.join('');
+        };
+        module.exports = (string, begin, end)=>{
+            const characters = [
+                ...string.normalize()
+            ];
+            const ansiCodes = [];
+            end = 'number' == typeof end ? end : characters.length;
+            let isInsideEscape = false;
+            let ansiCode;
+            let visible = 0;
+            let output = '';
+            for (const [index, character] of characters.entries()){
+                let leftEscape = false;
+                if (ESCAPES.includes(character)) {
+                    const code = /\d[^m]*/.exec(string.slice(index, index + 18));
+                    ansiCode = code && code.length > 0 ? code[0] : void 0;
+                    if (visible < end) {
+                        isInsideEscape = true;
+                        if (void 0 !== ansiCode) ansiCodes.push(ansiCode);
+                    }
+                } else if (isInsideEscape && 'm' === character) {
+                    isInsideEscape = false;
+                    leftEscape = true;
+                }
+                if (!isInsideEscape && !leftEscape) ++visible;
+                if (!astralRegex({
+                    exact: true
+                }).test(character) && isFullwidthCodePoint(character.codePointAt())) ++visible;
+                if (visible > begin && visible <= end) output += character;
+                else if (visible !== begin || isInsideEscape || void 0 === ansiCode) {
+                    if (visible >= end) {
+                        output += checkAnsi(ansiCodes, true, ansiCode);
+                        break;
+                    }
+                } else output = checkAnsi(ansiCodes);
+            }
+            return output;
+        };
+    },
+    "../../../node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        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);
+                // Ignore control characters
+                if (code <= 0x1F || code >= 0x7F && code <= 0x9F) continue;
+                // Ignore combining characters
+                if (!(code >= 0x300) || !(code <= 0x36F)) {
+                    // Surrogates
+                    if (code > 0xFFFF) i++;
+                    width += isFullwidthCodePoint(code) ? 2 : 1;
+                }
+            }
+            return width;
+        };
+        module.exports = stringWidth;
+        // TODO: remove this in the next major version
+        module.exports["default"] = stringWidth;
+    },
+    "../../../node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        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;
+    }
+};
+
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = { webpackProvider: exports.webpackProvider });