@midscene/cli 1.8.7 → 1.8.8-beta-20260601092817.0

package/dist/lib/framework/index.js

@@ -0,0 +1,3989 @@
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        "use strict";
+        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
+            });
+        };
+        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
+                    ],
+                    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
+                    ],
+                    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
+                    ],
+                    bgBlackBright: [
+                        100,
+                        49
+                    ],
+                    bgRedBright: [
+                        101,
+                        49
+                    ],
+                    bgGreenBright: [
+                        102,
+                        49
+                    ],
+                    bgYellowBright: [
+                        103,
+                        49
+                    ],
+                    bgBlueBright: [
+                        104,
+                        49
+                    ],
+                    bgMagentaBright: [
+                        105,
+                        49
+                    ],
+                    bgCyanBright: [
+                        106,
+                        49
+                    ],
+                    bgWhiteBright: [
+                        107,
+                        49
+                    ]
+                }
+            };
+            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;
+        }
+        Object.defineProperty(module, 'exports', {
+            enumerable: true,
+            get: assembleStyles
+        });
+    },
+    "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        "use strict";
+        const ansiStyles = __webpack_require__("../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js");
+        const { stdout: stdoutColor, stderr: stderrColor } = __webpack_require__("../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js");
+        const { stringReplaceAll, stringEncaseCRLFWithFirstIndex } = __webpack_require__("../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js");
+        const { isArray } = Array;
+        const levelMapping = [
+            'ansi',
+            'ansi',
+            'ansi256',
+            'ansi16m'
+        ];
+        const styles = Object.create(null);
+        const applyOptions = (object, options = {})=>{
+            if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error('The `level` option should be an integer from 0 to 3');
+            const colorLevel = stdoutColor ? stdoutColor.level : 0;
+            object.level = void 0 === options.level ? colorLevel : options.level;
+        };
+        class ChalkClass {
+            constructor(options){
+                return chalkFactory(options);
+            }
+        }
+        const chalkFactory = (options)=>{
+            const chalk = {};
+            applyOptions(chalk, options);
+            chalk.template = (...arguments_)=>chalkTag(chalk.template, ...arguments_);
+            Object.setPrototypeOf(chalk, Chalk.prototype);
+            Object.setPrototypeOf(chalk.template, chalk);
+            chalk.template.constructor = ()=>{
+                throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
+            };
+            chalk.template.Instance = ChalkClass;
+            return chalk.template;
+        };
+        function Chalk(options) {
+            return chalkFactory(options);
+        }
+        for (const [styleName, style] of Object.entries(ansiStyles))styles[styleName] = {
+            get () {
+                const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+                Object.defineProperty(this, styleName, {
+                    value: builder
+                });
+                return builder;
+            }
+        };
+        styles.visible = {
+            get () {
+                const builder = createBuilder(this, this._styler, true);
+                Object.defineProperty(this, 'visible', {
+                    value: builder
+                });
+                return builder;
+            }
+        };
+        const usedModels = [
+            'rgb',
+            'hex',
+            'keyword',
+            'hsl',
+            'hsv',
+            'hwb',
+            'ansi',
+            'ansi256'
+        ];
+        for (const model of usedModels)styles[model] = {
+            get () {
+                const { level } = this;
+                return function(...arguments_) {
+                    const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+                    return createBuilder(this, styler, this._isEmpty);
+                };
+            }
+        };
+        for (const model of usedModels){
+            const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+            styles[bgModel] = {
+                get () {
+                    const { level } = this;
+                    return function(...arguments_) {
+                        const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+                        return createBuilder(this, styler, this._isEmpty);
+                    };
+                }
+            };
+        }
+        const proto = Object.defineProperties(()=>{}, {
+            ...styles,
+            level: {
+                enumerable: true,
+                get () {
+                    return this._generator.level;
+                },
+                set (level) {
+                    this._generator.level = level;
+                }
+            }
+        });
+        const createStyler = (open, close, parent)=>{
+            let openAll;
+            let closeAll;
+            if (void 0 === parent) {
+                openAll = open;
+                closeAll = close;
+            } else {
+                openAll = parent.openAll + open;
+                closeAll = close + parent.closeAll;
+            }
+            return {
+                open,
+                close,
+                openAll,
+                closeAll,
+                parent
+            };
+        };
+        const createBuilder = (self, _styler, _isEmpty)=>{
+            const builder = (...arguments_)=>{
+                if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) return applyStyle(builder, chalkTag(builder, ...arguments_));
+                return applyStyle(builder, 1 === arguments_.length ? '' + arguments_[0] : arguments_.join(' '));
+            };
+            Object.setPrototypeOf(builder, proto);
+            builder._generator = self;
+            builder._styler = _styler;
+            builder._isEmpty = _isEmpty;
+            return builder;
+        };
+        const applyStyle = (self, string)=>{
+            if (self.level <= 0 || !string) return self._isEmpty ? '' : string;
+            let styler = self._styler;
+            if (void 0 === styler) return string;
+            const { openAll, closeAll } = styler;
+            if (-1 !== string.indexOf('\u001B')) while(void 0 !== styler){
+                string = stringReplaceAll(string, styler.close, styler.open);
+                styler = styler.parent;
+            }
+            const lfIndex = string.indexOf('\n');
+            if (-1 !== lfIndex) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+            return openAll + string + closeAll;
+        };
+        let template;
+        const chalkTag = (chalk, ...strings)=>{
+            const [firstString] = strings;
+            if (!isArray(firstString) || !isArray(firstString.raw)) return strings.join(' ');
+            const arguments_ = strings.slice(1);
+            const parts = [
+                firstString.raw[0]
+            ];
+            for(let i = 1; i < firstString.length; i++)parts.push(String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'), String(firstString.raw[i]));
+            if (void 0 === template) template = __webpack_require__("../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js");
+            return template(chalk, parts.join(''));
+        };
+        Object.defineProperties(Chalk.prototype, styles);
+        const chalk = Chalk();
+        chalk.supportsColor = stdoutColor;
+        chalk.stderr = Chalk({
+            level: stderrColor ? stderrColor.level : 0
+        });
+        chalk.stderr.supportsColor = stderrColor;
+        module.exports = chalk;
+    },
+    "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js" (module) {
+        "use strict";
+        const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+        const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+        const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+        const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+        const ESCAPES = new Map([
+            [
+                'n',
+                '\n'
+            ],
+            [
+                'r',
+                '\r'
+            ],
+            [
+                't',
+                '\t'
+            ],
+            [
+                'b',
+                '\b'
+            ],
+            [
+                'f',
+                '\f'
+            ],
+            [
+                'v',
+                '\v'
+            ],
+            [
+                '0',
+                '\0'
+            ],
+            [
+                '\\',
+                '\\'
+            ],
+            [
+                'e',
+                '\u001B'
+            ],
+            [
+                'a',
+                '\u0007'
+            ]
+        ]);
+        function unescape(c) {
+            const u = 'u' === c[0];
+            const bracket = '{' === c[1];
+            if (u && !bracket && 5 === c.length || 'x' === c[0] && 3 === c.length) return String.fromCharCode(parseInt(c.slice(1), 16));
+            if (u && bracket) return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+            return ESCAPES.get(c) || c;
+        }
+        function parseArguments(name, arguments_) {
+            const results = [];
+            const chunks = arguments_.trim().split(/\s*,\s*/g);
+            let matches;
+            for (const chunk of chunks){
+                const number = Number(chunk);
+                if (Number.isNaN(number)) if (matches = chunk.match(STRING_REGEX)) results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character)=>escape ? unescape(escape) : character));
+                else throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+                else results.push(number);
+            }
+            return results;
+        }
+        function parseStyle(style) {
+            STYLE_REGEX.lastIndex = 0;
+            const results = [];
+            let matches;
+            while(null !== (matches = STYLE_REGEX.exec(style))){
+                const name = matches[1];
+                if (matches[2]) {
+                    const args = parseArguments(name, matches[2]);
+                    results.push([
+                        name
+                    ].concat(args));
+                } else results.push([
+                    name
+                ]);
+            }
+            return results;
+        }
+        function buildStyle(chalk, styles) {
+            const enabled = {};
+            for (const layer of styles)for (const style of layer.styles)enabled[style[0]] = layer.inverse ? null : style.slice(1);
+            let current = chalk;
+            for (const [styleName, styles] of Object.entries(enabled))if (Array.isArray(styles)) {
+                if (!(styleName in current)) throw new Error(`Unknown Chalk style: ${styleName}`);
+                current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
+            }
+            return current;
+        }
+        module.exports = (chalk, temporary)=>{
+            const styles = [];
+            const chunks = [];
+            let chunk = [];
+            temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character)=>{
+                if (escapeCharacter) chunk.push(unescape(escapeCharacter));
+                else if (style) {
+                    const string = chunk.join('');
+                    chunk = [];
+                    chunks.push(0 === styles.length ? string : buildStyle(chalk, styles)(string));
+                    styles.push({
+                        inverse,
+                        styles: parseStyle(style)
+                    });
+                } else if (close) {
+                    if (0 === styles.length) throw new Error('Found extraneous } in Chalk template literal');
+                    chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+                    chunk = [];
+                    styles.pop();
+                } else chunk.push(character);
+            });
+            chunks.push(chunk.join(''));
+            if (styles.length > 0) {
+                const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${1 === styles.length ? '' : 's'} (\`}\`)`;
+                throw new Error(errMessage);
+            }
+            return chunks.join('');
+        };
+    },
+    "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js" (module) {
+        "use strict";
+        const stringReplaceAll = (string, substring, replacer)=>{
+            let index = string.indexOf(substring);
+            if (-1 === index) return string;
+            const substringLength = substring.length;
+            let endIndex = 0;
+            let returnValue = '';
+            do {
+                returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+                endIndex = index + substringLength;
+                index = string.indexOf(substring, endIndex);
+            }while (-1 !== index);
+            returnValue += string.substr(endIndex);
+            return returnValue;
+        };
+        const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index)=>{
+            let endIndex = 0;
+            let returnValue = '';
+            do {
+                const gotCR = '\r' === string[index - 1];
+                returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+                endIndex = index + 1;
+                index = string.indexOf('\n', endIndex);
+            }while (-1 !== index);
+            returnValue += string.substr(endIndex);
+            return returnValue;
+        };
+        module.exports = {
+            stringReplaceAll,
+            stringEncaseCRLFWithFirstIndex
+        };
+    },
+    "../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const cssKeywords = __webpack_require__("../../node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js");
+        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;
+        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) {
+            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];
+                const distance = comparativeDistance(rgb, value);
+                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;
+            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
+            ];
+        };
+        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;
+            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);
+            let r;
+            let g;
+            let b;
+            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;
+            }
+            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;
+            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;
+            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) {
+            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];
+            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;
+            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) {
+            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;
+            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;
+            }
+            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" (module, __unused_rspack_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);
+            };
+            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);
+                if ('object' == typeof result) for(let len = result.length, i = 0; i < len; i++)result[i] = Math.round(result[i]);
+                return result;
+            };
+            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" (module, __unused_rspack_exports, __webpack_require__) {
+        const conversions = __webpack_require__("../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js");
+        function buildGraph() {
+            const graph = {};
+            const models = Object.keys(conversions);
+            for(let len = models.length, i = 0; i < len; i++)graph[models[i]] = {
+                distance: -1,
+                parent: null
+            };
+            return graph;
+        }
+        function deriveBFS(fromModel) {
+            const graph = buildGraph();
+            const queue = [
+                fromModel
+            ];
+            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" (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/has-flag@4.0.0/node_modules/has-flag/index.js" (module) {
+        "use strict";
+        module.exports = (flag, argv = process.argv)=>{
+            const prefix = flag.startsWith('-') ? '' : 1 === flag.length ? '-' : '--';
+            const position = argv.indexOf(prefix + flag);
+            const terminatorPosition = argv.indexOf('--');
+            return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
+        };
+    },
+    "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        "use strict";
+        const os = __webpack_require__("os");
+        const tty = __webpack_require__("tty");
+        const hasFlag = __webpack_require__("../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js");
+        const { env } = process;
+        let forceColor;
+        if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) forceColor = 0;
+        else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) forceColor = 1;
+        if ('FORCE_COLOR' in env) forceColor = 'true' === env.FORCE_COLOR ? 1 : 'false' === env.FORCE_COLOR ? 0 : 0 === env.FORCE_COLOR.length ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+        function translateLevel(level) {
+            if (0 === level) return false;
+            return {
+                level,
+                hasBasic: true,
+                has256: level >= 2,
+                has16m: level >= 3
+            };
+        }
+        function supportsColor(haveStream, streamIsTTY) {
+            if (0 === forceColor) return 0;
+            if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) return 3;
+            if (hasFlag('color=256')) return 2;
+            if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
+            const min = forceColor || 0;
+            if ('dumb' === env.TERM) return min;
+            if ('win32' === process.platform) {
+                const osRelease = os.release().split('.');
+                if (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',
+                    'GITHUB_ACTIONS',
+                    'BUILDKITE'
+                ].some((sign)=>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 ('truecolor' === env.COLORTERM) return 3;
+            if ('TERM_PROGRAM' in env) {
+                const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+                switch(env.TERM_PROGRAM){
+                    case 'iTerm.app':
+                        return version >= 3 ? 3 : 2;
+                    case 'Apple_Terminal':
+                        return 2;
+                }
+            }
+            if (/-256(color)?$/i.test(env.TERM)) return 2;
+            if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+            if ('COLORTERM' in env) return 1;
+            return min;
+        }
+        function getSupportLevel(stream) {
+            const level = supportsColor(stream, stream && stream.isTTY);
+            return translateLevel(level);
+        }
+        module.exports = {
+            supportsColor: getSupportLevel,
+            stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+            stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+        };
+    },
+    "@midscene/core/yaml" (module) {
+        "use strict";
+        module.exports = require("@midscene/core/yaml");
+    },
+    "@midscene/shared/logger" (module) {
+        "use strict";
+        module.exports = require("@midscene/shared/logger");
+    },
+    "lodash.merge" (module) {
+        "use strict";
+        module.exports = require("lodash.merge");
+    },
+    "node:fs" (module) {
+        "use strict";
+        module.exports = require("node:fs");
+    },
+    "node:path" (module) {
+        "use strict";
+        module.exports = require("node:path");
+    },
+    "node:url" (module) {
+        "use strict";
+        module.exports = require("node:url");
+    },
+    os (module) {
+        "use strict";
+        module.exports = require("os");
+    },
+    tty (module) {
+        "use strict";
+        module.exports = require("tty");
+    },
+    "../../node_modules/.pnpm/p-limit@6.2.0/node_modules/p-limit/index.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>pLimit
+        });
+        class Node {
+            value;
+            next;
+            constructor(value){
+                this.value = value;
+            }
+        }
+        class Queue {
+            #head;
+            #tail;
+            #size;
+            constructor(){
+                this.clear();
+            }
+            enqueue(value) {
+                const node = new Node(value);
+                if (this.#head) {
+                    this.#tail.next = node;
+                    this.#tail = node;
+                } else {
+                    this.#head = node;
+                    this.#tail = node;
+                }
+                this.#size++;
+            }
+            dequeue() {
+                const current = this.#head;
+                if (!current) return;
+                this.#head = this.#head.next;
+                this.#size--;
+                return current.value;
+            }
+            peek() {
+                if (!this.#head) return;
+                return this.#head.value;
+            }
+            clear() {
+                this.#head = void 0;
+                this.#tail = void 0;
+                this.#size = 0;
+            }
+            get size() {
+                return this.#size;
+            }
+            *[Symbol.iterator]() {
+                let current = this.#head;
+                while(current){
+                    yield current.value;
+                    current = current.next;
+                }
+            }
+            *drain() {
+                while(this.#head)yield this.dequeue();
+            }
+        }
+        function pLimit(concurrency) {
+            validateConcurrency(concurrency);
+            const queue = new Queue();
+            let activeCount = 0;
+            const resumeNext = ()=>{
+                if (activeCount < concurrency && queue.size > 0) {
+                    queue.dequeue()();
+                    activeCount++;
+                }
+            };
+            const next = ()=>{
+                activeCount--;
+                resumeNext();
+            };
+            const run = async (function_, resolve, arguments_)=>{
+                const result = (async ()=>function_(...arguments_))();
+                resolve(result);
+                try {
+                    await result;
+                } catch  {}
+                next();
+            };
+            const enqueue = (function_, resolve, arguments_)=>{
+                new Promise((internalResolve)=>{
+                    queue.enqueue(internalResolve);
+                }).then(run.bind(void 0, function_, resolve, arguments_));
+                (async ()=>{
+                    await Promise.resolve();
+                    if (activeCount < concurrency) resumeNext();
+                })();
+            };
+            const generator = (function_, ...arguments_)=>new Promise((resolve)=>{
+                    enqueue(function_, resolve, arguments_);
+                });
+            Object.defineProperties(generator, {
+                activeCount: {
+                    get: ()=>activeCount
+                },
+                pendingCount: {
+                    get: ()=>queue.size
+                },
+                clearQueue: {
+                    value () {
+                        queue.clear();
+                    }
+                },
+                concurrency: {
+                    get: ()=>concurrency,
+                    set (newConcurrency) {
+                        validateConcurrency(newConcurrency);
+                        concurrency = newConcurrency;
+                        queueMicrotask(()=>{
+                            while(activeCount < concurrency && queue.size > 0)resumeNext();
+                        });
+                    }
+                }
+            });
+            return generator;
+        }
+        function validateConcurrency(concurrency) {
+            if (!((Number.isInteger(concurrency) || concurrency === 1 / 0) && concurrency > 0)) throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+        }
+    },
+    "../../node_modules/.pnpm/restore-cursor@5.1.0/node_modules/restore-cursor/index.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>restore_cursor
+        });
+        const external_node_process_namespaceObject = require("node:process");
+        const copyProperty = (to, from, property, ignoreNonConfigurable)=>{
+            if ('length' === property || 'prototype' === property) return;
+            if ('arguments' === property || 'caller' === property) return;
+            const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
+            const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
+            if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) return;
+            Object.defineProperty(to, property, fromDescriptor);
+        };
+        const canCopyProperty = function(toDescriptor, fromDescriptor) {
+            return void 0 === toDescriptor || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
+        };
+        const changePrototype = (to, from)=>{
+            const fromPrototype = Object.getPrototypeOf(from);
+            if (fromPrototype === Object.getPrototypeOf(to)) return;
+            Object.setPrototypeOf(to, fromPrototype);
+        };
+        const wrappedToString = (withName, fromBody)=>`/* Wrapped ${withName}*/\n${fromBody}`;
+        const toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, 'toString');
+        const toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, 'name');
+        const changeToString = (to, from, name)=>{
+            const withName = '' === name ? '' : `with ${name.trim()}() `;
+            const newToString = wrappedToString.bind(null, withName, from.toString());
+            Object.defineProperty(newToString, 'name', toStringName);
+            const { writable, enumerable, configurable } = toStringDescriptor;
+            Object.defineProperty(to, 'toString', {
+                value: newToString,
+                writable,
+                enumerable,
+                configurable
+            });
+        };
+        function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
+            const { name } = to;
+            for (const property of Reflect.ownKeys(from))copyProperty(to, from, property, ignoreNonConfigurable);
+            changePrototype(to, from);
+            changeToString(to, from, name);
+            return to;
+        }
+        const calledFunctions = new WeakMap();
+        const onetime_onetime = (function_, options = {})=>{
+            if ('function' != typeof function_) throw new TypeError('Expected a function');
+            let returnValue;
+            let callCount = 0;
+            const functionName = function_.displayName || function_.name || '<anonymous>';
+            const onetime = function(...arguments_) {
+                calledFunctions.set(onetime, ++callCount);
+                if (1 === callCount) {
+                    returnValue = function_.apply(this, arguments_);
+                    function_ = void 0;
+                } else if (true === options.throw) throw new Error(`Function \`${functionName}\` can only be called once`);
+                return returnValue;
+            };
+            mimicFunction(onetime, function_);
+            calledFunctions.set(onetime, callCount);
+            return onetime;
+        };
+        onetime_onetime.callCount = (function_)=>{
+            if (!calledFunctions.has(function_)) throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+            return calledFunctions.get(function_);
+        };
+        const node_modules_onetime = onetime_onetime;
+        const signals = [];
+        signals.push('SIGHUP', 'SIGINT', 'SIGTERM');
+        if ('win32' !== process.platform) signals.push('SIGALRM', 'SIGABRT', 'SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT');
+        if ('linux' === process.platform) signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT');
+        const processOk = (process1)=>!!process1 && 'object' == typeof process1 && 'function' == typeof process1.removeListener && 'function' == typeof process1.emit && 'function' == typeof process1.reallyExit && 'function' == typeof process1.listeners && 'function' == typeof process1.kill && 'number' == typeof process1.pid && 'function' == typeof process1.on;
+        const kExitEmitter = Symbol.for('signal-exit emitter');
+        const global = globalThis;
+        const ObjectDefineProperty = Object.defineProperty.bind(Object);
+        class Emitter {
+            emitted = {
+                afterExit: false,
+                exit: false
+            };
+            listeners = {
+                afterExit: [],
+                exit: []
+            };
+            count = 0;
+            id = Math.random();
+            constructor(){
+                if (global[kExitEmitter]) return global[kExitEmitter];
+                ObjectDefineProperty(global, kExitEmitter, {
+                    value: this,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                });
+            }
+            on(ev, fn) {
+                this.listeners[ev].push(fn);
+            }
+            removeListener(ev, fn) {
+                const list = this.listeners[ev];
+                const i = list.indexOf(fn);
+                if (-1 === i) return;
+                if (0 === i && 1 === list.length) list.length = 0;
+                else list.splice(i, 1);
+            }
+            emit(ev, code, signal) {
+                if (this.emitted[ev]) return false;
+                this.emitted[ev] = true;
+                let ret = false;
+                for (const fn of this.listeners[ev])ret = true === fn(code, signal) || ret;
+                if ('exit' === ev) ret = this.emit('afterExit', code, signal) || ret;
+                return ret;
+            }
+        }
+        class SignalExitBase {
+        }
+        const signalExitWrap = (handler)=>({
+                onExit (cb, opts) {
+                    return handler.onExit(cb, opts);
+                },
+                load () {
+                    return handler.load();
+                },
+                unload () {
+                    return handler.unload();
+                }
+            });
+        class SignalExitFallback extends SignalExitBase {
+            onExit() {
+                return ()=>{};
+            }
+            load() {}
+            unload() {}
+        }
+        class SignalExit extends SignalExitBase {
+            #hupSig = 'win32' === mjs_process.platform ? 'SIGINT' : 'SIGHUP';
+            #emitter = new Emitter();
+            #process;
+            #originalProcessEmit;
+            #originalProcessReallyExit;
+            #sigListeners = {};
+            #loaded = false;
+            constructor(process1){
+                super();
+                this.#process = process1;
+                this.#sigListeners = {};
+                for (const sig of signals)this.#sigListeners[sig] = ()=>{
+                    const listeners = this.#process.listeners(sig);
+                    let { count } = this.#emitter;
+                    const p = process1;
+                    if ('object' == typeof p.__signal_exit_emitter__ && 'number' == typeof p.__signal_exit_emitter__.count) count += p.__signal_exit_emitter__.count;
+                    if (listeners.length === count) {
+                        this.unload();
+                        const ret = this.#emitter.emit('exit', null, sig);
+                        const s = 'SIGHUP' === sig ? this.#hupSig : sig;
+                        if (!ret) process1.kill(process1.pid, s);
+                    }
+                };
+                this.#originalProcessReallyExit = process1.reallyExit;
+                this.#originalProcessEmit = process1.emit;
+            }
+            onExit(cb, opts) {
+                if (!processOk(this.#process)) return ()=>{};
+                if (false === this.#loaded) this.load();
+                const ev = opts?.alwaysLast ? 'afterExit' : 'exit';
+                this.#emitter.on(ev, cb);
+                return ()=>{
+                    this.#emitter.removeListener(ev, cb);
+                    if (0 === this.#emitter.listeners['exit'].length && 0 === this.#emitter.listeners['afterExit'].length) this.unload();
+                };
+            }
+            load() {
+                if (this.#loaded) return;
+                this.#loaded = true;
+                this.#emitter.count += 1;
+                for (const sig of signals)try {
+                    const fn = this.#sigListeners[sig];
+                    if (fn) this.#process.on(sig, fn);
+                } catch (_) {}
+                this.#process.emit = (ev, ...a)=>this.#processEmit(ev, ...a);
+                this.#process.reallyExit = (code)=>this.#processReallyExit(code);
+            }
+            unload() {
+                if (!this.#loaded) return;
+                this.#loaded = false;
+                signals.forEach((sig)=>{
+                    const listener = this.#sigListeners[sig];
+                    if (!listener) throw new Error('Listener not defined for signal: ' + sig);
+                    try {
+                        this.#process.removeListener(sig, listener);
+                    } catch (_) {}
+                });
+                this.#process.emit = this.#originalProcessEmit;
+                this.#process.reallyExit = this.#originalProcessReallyExit;
+                this.#emitter.count -= 1;
+            }
+            #processReallyExit(code) {
+                if (!processOk(this.#process)) return 0;
+                this.#process.exitCode = code || 0;
+                this.#emitter.emit('exit', this.#process.exitCode, null);
+                return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+            }
+            #processEmit(ev, ...args) {
+                const og = this.#originalProcessEmit;
+                if (!('exit' === ev && processOk(this.#process))) return og.call(this.#process, ev, ...args);
+                {
+                    if ('number' == typeof args[0]) this.#process.exitCode = args[0];
+                    const ret = og.call(this.#process, ev, ...args);
+                    this.#emitter.emit('exit', this.#process.exitCode, null);
+                    return ret;
+                }
+            }
+        }
+        const mjs_process = globalThis.process;
+        const { onExit, load, unload } = signalExitWrap(processOk(mjs_process) ? new SignalExit(mjs_process) : new SignalExitFallback());
+        const terminal = external_node_process_namespaceObject.stderr.isTTY ? external_node_process_namespaceObject.stderr : external_node_process_namespaceObject.stdout.isTTY ? external_node_process_namespaceObject.stdout : void 0;
+        const restoreCursor = terminal ? node_modules_onetime(()=>{
+            onExit(()=>{
+                terminal.write('\u001B[?25h');
+            }, {
+                alwaysLast: true
+            });
+        }) : ()=>{};
+        const restore_cursor = restoreCursor;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        id: moduleId,
+        loaded: false,
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    module.loaded = true;
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.nmd = (module)=>{
+        module.paths = [];
+        if (!module.children) module.children = [];
+        return module;
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    "use strict";
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        createRstestYamlProject: ()=>createRstestYamlProject,
+        defineYamlBatchTest: ()=>defineYamlBatchTest,
+        resolveTestName: ()=>resolveTestName,
+        runFrameworkTestConfig: ()=>runFrameworkTestConfig,
+        runRstestYamlProject: ()=>runRstestYamlProject,
+        runYamlCase: ()=>runYamlCase,
+        defineYamlCaseTest: ()=>defineYamlCaseTest,
+        getYamlPlayerFailure: ()=>getYamlPlayerFailure,
+        runYamlCaseResult: ()=>runYamlCaseResult,
+        runYamlBatchInRstest: ()=>runYamlBatchInRstest,
+        createYamlCaseResult: ()=>createYamlCaseResult,
+        createYamlCaseFailure: ()=>createYamlCaseFailure,
+        resolveRstestCoreImportPath: ()=>resolveRstestCoreImportPath
+    });
+    var external_node_fs_ = __webpack_require__("node:fs");
+    var external_node_path_ = __webpack_require__("node:path");
+    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_);
+    const common_namespaceObject = require("@midscene/shared/common");
+    const notExecutedError = 'Not executed (previous task failed)';
+    function createNotExecutedYamlResult(file) {
+        return {
+            file,
+            success: false,
+            executed: false,
+            output: void 0,
+            report: void 0,
+            duration: 0,
+            resultType: 'notExecuted',
+            error: notExecutedError
+        };
+    }
+    function createExecutedYamlResult(options) {
+        const { file, player, duration } = options;
+        const hasFailedTasks = player.taskStatusList?.some((task)=>'error' === task.status) ?? false;
+        const hasPlayerError = 'error' === player.status;
+        let success;
+        let resultType;
+        if (hasPlayerError) {
+            success = false;
+            resultType = 'failed';
+        } else if (hasFailedTasks) {
+            success = false;
+            resultType = 'partialFailed';
+        } else {
+            success = true;
+            resultType = 'success';
+        }
+        let outputPath = player.output || void 0;
+        if (outputPath && !(0, external_node_fs_.existsSync)(outputPath)) outputPath = void 0;
+        let errorMessage;
+        if (player.errorInSetup?.message) errorMessage = player.errorInSetup.message;
+        else if (hasPlayerError || hasFailedTasks) {
+            const taskErrors = player.taskStatusList?.filter((task)=>'error' === task.status && task.error?.message).map((task)=>task.error.message);
+            errorMessage = taskErrors && taskErrors.length > 0 ? taskErrors.join('; ') : hasPlayerError ? 'Execution failed' : 'Some tasks failed';
+        }
+        return {
+            file,
+            success,
+            executed: true,
+            output: outputPath,
+            report: player.reportFile || void 0,
+            duration,
+            resultType,
+            error: errorMessage
+        };
+    }
+    function getExecutionSummary(results) {
+        return {
+            total: results.length,
+            successful: getResultsByType(results, 'success').length,
+            failed: getResultsByType(results, 'failed').length,
+            partialFailed: getResultsByType(results, 'partialFailed').length,
+            notExecuted: getResultsByType(results, 'notExecuted').length,
+            totalDuration: results.reduce((sum, r)=>sum + (r.duration || 0), 0)
+        };
+    }
+    function getResultsByType(results, resultType) {
+        return results.filter((result)=>result.resultType === resultType);
+    }
+    function getSummaryAbsolutePath(summary) {
+        return (0, external_node_path_.resolve)((0, common_namespaceObject.getMidsceneRunSubDir)('output'), summary);
+    }
+    function writeExecutionSummaryFile(summary, results) {
+        const indexPath = getSummaryAbsolutePath(summary);
+        const outputDir = (0, external_node_path_.dirname)(indexPath);
+        (0, external_node_fs_.mkdirSync)(outputDir, {
+            recursive: true
+        });
+        const executionSummary = getExecutionSummary(results);
+        const indexData = {
+            summary: {
+                ...executionSummary,
+                generatedAt: new Date().toLocaleString()
+            },
+            results: results.map((result)=>({
+                    script: (0, external_node_path_.relative)(outputDir, result.file),
+                    success: result.success,
+                    resultType: result.resultType,
+                    output: result.output ? (()=>{
+                        const relativePath = (0, external_node_path_.relative)(outputDir, result.output);
+                        return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+                    })() : void 0,
+                    report: result.report ? (0, external_node_path_.relative)(outputDir, result.report) : void 0,
+                    error: result.error,
+                    duration: result.duration
+                }))
+        };
+        (0, external_node_fs_.writeFileSync)(indexPath, JSON.stringify(indexData, null, 2));
+        return indexPath;
+    }
+    function printExecutionPlan(config) {
+        console.log('   Scripts:');
+        for (const file of config.files)console.log(`     - ${file}`);
+        console.log('📋 Execution plan');
+        console.log(`   Concurrency: ${config.concurrent}`);
+        console.log(`   Keep window: ${config.keepWindow}`);
+        console.log(`   Headed: ${config.headed}`);
+        console.log(`   Continue on error: ${config.continueOnError}`);
+        console.log(`   Share browser context: ${config.shareBrowserContext ?? false}`);
+        console.log(`   Summary output: ${config.summary}`);
+    }
+    function printExecutionFinished() {
+        console.log('Execution finished:');
+    }
+    function printExecutionSummary(results, summaryPath) {
+        const summary = getExecutionSummary(results);
+        const successfulFiles = getResultsByType(results, 'success');
+        const failedFiles = getResultsByType(results, 'failed');
+        const partialFailedFiles = getResultsByType(results, 'partialFailed');
+        const notExecutedFiles = getResultsByType(results, 'notExecuted');
+        const success = 0 === summary.failed && 0 === summary.partialFailed && 0 === summary.notExecuted;
+        console.log('\n📊 Execution Summary:');
+        console.log(`   Total files: ${summary.total}`);
+        console.log(`   Successful: ${summary.successful}`);
+        console.log(`   Failed: ${summary.failed}`);
+        console.log(`   Partial failed: ${summary.partialFailed}`);
+        console.log(`   Not executed: ${summary.notExecuted}`);
+        console.log(`   Duration: ${(summary.totalDuration / 1000).toFixed(2)}s`);
+        console.log(`   Summary: ${summaryPath}`);
+        if (successfulFiles.length > 0) {
+            console.log('\n✅ Successful files:');
+            successfulFiles.forEach((result)=>{
+                console.log(`   ${result.file}`);
+            });
+        }
+        if (failedFiles.length > 0) {
+            console.log('\n❌ Failed files');
+            failedFiles.forEach((result)=>{
+                console.log(`   ${result.file}`);
+                if (result.error) console.log(`     Error: ${result.error}`);
+            });
+        }
+        if (partialFailedFiles.length > 0) {
+            console.log('\n⚠️  Partial failed files (some tasks failed with continueOnError)');
+            partialFailedFiles.forEach((result)=>{
+                console.log(`   ${result.file}`);
+                if (result.error) console.log(`     Error: ${result.error}`);
+            });
+        }
+        if (notExecutedFiles.length > 0) {
+            console.log('\n⏸️ Not executed files');
+            notExecutedFiles.forEach((result)=>{
+                console.log(`   ${result.file}`);
+            });
+        }
+        if (success) console.log('\n🎉 All files executed successfully!');
+        else console.log('\n⚠️ Some files failed or were not executed.');
+        return success;
+    }
+    const DEFAULT_YAML_TEST_TIMEOUT = 0;
+    const toPosixPath = (value)=>value.split(external_node_path_.sep).join('/');
+    const toImportLiteral = (value)=>JSON.stringify(toPosixPath(value));
+    const toVirtualModuleId = (fileStem)=>`virtual:midscene-yaml/${fileStem}.test.ts`;
+    const safeFileStem = (file, index)=>{
+        const base = (0, external_node_path_.basename)(file, (0, external_node_path_.extname)(file)).replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+        return `${String(index + 1).padStart(3, '0')}-${base || 'case'}`;
+    };
+    const resolveTestName = (projectDir, yamlFile)=>{
+        const relativePath = (0, external_node_path_.relative)(projectDir, yamlFile);
+        return toPosixPath(relativePath.startsWith('..') ? yamlFile : relativePath);
+    };
+    const createGeneratedTestContent = (options)=>{
+        const testOptions = {
+            testName: options.testName,
+            yamlFile: options.yamlFile,
+            resultFile: options.resultFile,
+            ...options.caseOptions ? {
+                caseOptions: options.caseOptions
+            } : {},
+            ...options.webRuntimeOptions ? {
+                webRuntimeOptions: options.webRuntimeOptions
+            } : {}
+        };
+        return `import { defineYamlCaseTest } from ${toImportLiteral(options.frameworkImport)};
+
+defineYamlCaseTest(${JSON.stringify(testOptions, null, 2)});
+`;
+    };
+    const createGeneratedBatchTestContent = (options)=>{
+        const testOptions = {
+            testName: options.testName,
+            config: options.config,
+            resultFiles: options.resultFiles
+        };
+        return `import { defineYamlBatchTest } from ${toImportLiteral(options.frameworkImport)};
+
+defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
+`;
+    };
+    const resolveDefaultFrameworkImport = ()=>{
+        const entry = process.argv[1] ? (0, external_node_path_.resolve)(process.argv[1]) : '';
+        const candidates = [
+            entry ? (0, external_node_path_.join)((0, external_node_path_.dirname)(entry), 'framework', 'index.js') : '',
+            entry ? (0, external_node_path_.join)((0, external_node_path_.dirname)(entry), '..', 'dist', 'lib', 'framework', 'index.js') : ''
+        ].filter(Boolean);
+        const matched = candidates.find((candidate)=>(0, external_node_fs_.existsSync)(candidate));
+        return matched || '@midscene/cli/dist/lib/framework/index.js';
+    };
+    function createRstestYamlProject(options) {
+        const projectDir = (0, external_node_path_.resolve)(options.projectDir || process.cwd());
+        const outputDir = options.outputDir || (0, external_node_path_.join)((0, common_namespaceObject.getMidsceneRunSubDir)('tmp'), `rstest-yaml-${Date.now()}`);
+        const resultDir = options.resultDir || (0, external_node_path_.join)(outputDir, 'results');
+        const frameworkImport = options.frameworkImport || resolveDefaultFrameworkImport();
+        const testTimeout = options.testTimeout ?? DEFAULT_YAML_TEST_TIMEOUT;
+        (0, external_node_fs_.rmSync)(outputDir, {
+            recursive: true,
+            force: true
+        });
+        (0, external_node_fs_.mkdirSync)(resultDir, {
+            recursive: true
+        });
+        const virtualModules = {};
+        const cases = options.files.map((file, index)=>{
+            const yamlFile = (0, external_node_path_.resolve)(file);
+            const testName = resolveTestName(projectDir, yamlFile);
+            const fileStem = safeFileStem(yamlFile, index);
+            const resultFile = (0, external_node_path_.join)(resultDir, `${fileStem}.json`);
+            const testModule = toVirtualModuleId(fileStem);
+            virtualModules[testModule] = createGeneratedTestContent({
+                frameworkImport,
+                yamlFile,
+                resultFile,
+                testName,
+                caseOptions: options.caseOptions?.[yamlFile],
+                webRuntimeOptions: options.webRuntimeOptions?.[yamlFile]
+            });
+            return {
+                yamlFile,
+                testModule,
+                resultFile,
+                testName
+            };
+        });
+        if (options.batchConfig) {
+            const batchModule = 'virtual:midscene-yaml/batch.test.ts';
+            const resultFiles = Object.fromEntries(cases.map((item)=>[
+                    item.yamlFile,
+                    item.resultFile
+                ]));
+            return {
+                projectDir,
+                outputDir,
+                resultDir,
+                include: [
+                    batchModule
+                ],
+                virtualModules: {
+                    [batchModule]: createGeneratedBatchTestContent({
+                        frameworkImport,
+                        testName: 'midscene yaml batch',
+                        config: options.batchConfig,
+                        resultFiles
+                    })
+                },
+                cases,
+                maxConcurrency: 1,
+                testTimeout,
+                bail: options.bail
+            };
+        }
+        return {
+            projectDir,
+            outputDir,
+            resultDir,
+            include: cases.map((item)=>item.testModule),
+            virtualModules,
+            cases,
+            maxConcurrency: options.maxConcurrency,
+            testTimeout,
+            bail: options.bail
+        };
+    }
+    const external_node_module_namespaceObject = require("node:module");
+    var external_node_url_ = __webpack_require__("node:url");
+    const requireFromCliEntry = ()=>{
+        const entry = process.argv[1] ? (0, external_node_path_.resolve)(process.argv[1]) : (0, external_node_path_.join)(process.cwd(), 'midscene-cli.js');
+        return (0, external_node_module_namespaceObject.createRequire)(entry);
+    };
+    const resolvePackageFromRstestCore = (packageName)=>{
+        const require1 = requireFromCliEntry();
+        const rstestPackageJsonPath = require1.resolve('@rstest/core/package.json');
+        return (0, external_node_module_namespaceObject.createRequire)(rstestPackageJsonPath).resolve(packageName);
+    };
+    function resolveRstestCoreImportPath() {
+        const require1 = requireFromCliEntry();
+        const packageJsonPath = require1.resolve('@rstest/core/package.json');
+        return (0, external_node_path_.join)((0, external_node_path_.dirname)(packageJsonPath), 'dist', 'index.js');
+    }
+    const formatRunError = (error)=>error.stack || `${error.name}: ${error.message}`;
+    async function runRstestYamlProject(options) {
+        const [{ runRstest }, { rspack }] = await Promise.all([
+            import("@rstest/core/api"),
+            import((0, external_node_url_.pathToFileURL)(resolvePackageFromRstestCore('@rsbuild/core')).href)
+        ]);
+        const { project } = options;
+        const maxConcurrency = void 0 !== project.maxConcurrency ? Math.max(1, project.maxConcurrency) : void 0;
+        const inlineConfig = {
+            root: project.projectDir,
+            include: project.include,
+            testEnvironment: 'node',
+            testTimeout: project.testTimeout,
+            ...void 0 !== maxConcurrency ? {
+                maxConcurrency
+            } : {},
+            ...void 0 !== maxConcurrency ? {
+                pool: {
+                    maxWorkers: maxConcurrency,
+                    minWorkers: maxConcurrency
+                }
+            } : {},
+            ...void 0 !== project.bail ? {
+                bail: project.bail
+            } : {},
+            reporters: [],
+            tools: {
+                rspack: (_config, { appendPlugins })=>{
+                    appendPlugins(new rspack.experiments.VirtualModulesPlugin(project.virtualModules));
+                }
+            }
+        };
+        const result = await runRstest({
+            cwd: options.cwd || project.projectDir,
+            inlineConfig
+        });
+        if (!result.ok && 'pipe' !== options.stdio && result.unhandledErrors.length) console.error(result.unhandledErrors.map((error)=>formatRunError(error)).join('\n'));
+        return result.ok ? 0 : 1;
+    }
+    const createCaseOptions = (config)=>{
+        const caseOptions = {};
+        for (const file of config.files)caseOptions[(0, external_node_path_.resolve)(file)] = {
+            globalConfig: config.globalConfig
+        };
+        return caseOptions;
+    };
+    const createWebRuntimeOptions = (config, runtimeOptions)=>{
+        const caseOptions = {};
+        for (const file of config.files)caseOptions[(0, external_node_path_.resolve)(file)] = {
+            headed: runtimeOptions.headed ?? config.headed,
+            keepWindow: runtimeOptions.keepWindow ?? config.keepWindow
+        };
+        return caseOptions;
+    };
+    const readProjectResults = (project)=>project.cases.map((item)=>{
+            if ((0, external_node_fs_.existsSync)(item.resultFile)) return JSON.parse((0, external_node_fs_.readFileSync)(item.resultFile, 'utf8'));
+            return createNotExecutedYamlResult(item.yamlFile);
+        });
+    async function runFrameworkTestConfig(config, commandOptions = {}) {
+        printExecutionPlan(config);
+        const projectDir = (0, external_node_path_.resolve)(commandOptions.projectDir || process.cwd());
+        const project = createRstestYamlProject({
+            files: config.files,
+            projectDir,
+            outputDir: commandOptions.outputDir,
+            frameworkImport: commandOptions.frameworkImport,
+            caseOptions: createCaseOptions(config),
+            webRuntimeOptions: createWebRuntimeOptions(config, commandOptions),
+            maxConcurrency: commandOptions.concurrent ?? config.concurrent,
+            bail: config.continueOnError ? 0 : 1,
+            batchConfig: config.shareBrowserContext ? config : void 0
+        });
+        const runner = commandOptions.rstestRunner || runRstestYamlProject;
+        const exitCode = await runner({
+            project,
+            cwd: projectDir,
+            stdio: commandOptions.stdio
+        });
+        const results = readProjectResults(project);
+        const summaryPath = writeExecutionSummaryFile(config.summary, results);
+        printExecutionFinished();
+        const success = printExecutionSummary(results, summaryPath);
+        return success ? exitCode : 1;
+    }
+    const core_namespaceObject = require("@rstest/core");
+    var yaml_ = __webpack_require__("@midscene/core/yaml");
+    const puppeteer_agent_launcher_namespaceObject = require("@midscene/web/puppeteer-agent-launcher");
+    var external_lodash_merge_ = __webpack_require__("lodash.merge");
+    var external_lodash_merge_default = /*#__PURE__*/ __webpack_require__.n(external_lodash_merge_);
+    var p_limit = __webpack_require__("../../node_modules/.pnpm/p-limit@6.2.0/node_modules/p-limit/index.js");
+    const external_puppeteer_namespaceObject = require("puppeteer");
+    var external_puppeteer_default = /*#__PURE__*/ __webpack_require__.n(external_puppeteer_namespaceObject);
+    const external_http_server_namespaceObject = require("http-server");
+    const external_node_assert_namespaceObject = require("node:assert");
+    var external_node_assert_default = /*#__PURE__*/ __webpack_require__.n(external_node_assert_namespaceObject);
+    const agent_namespaceObject = require("@midscene/core/agent");
+    const utils_namespaceObject = require("@midscene/core/utils");
+    var logger_ = __webpack_require__("@midscene/shared/logger");
+    const bridge_mode_namespaceObject = require("@midscene/web/bridge-mode");
+    const debug = (0, logger_.getDebug)('create-yaml-player');
+    const launchServer = async (dir)=>new Promise((resolve)=>{
+            const server = (0, external_http_server_namespaceObject.createServer)({
+                root: dir
+            });
+            server.listen(0, '127.0.0.1', ()=>{
+                resolve(server);
+            });
+        });
+    function resolveReportFileName(yamlReportFileName, cliTestId, yamlTestId, fileName) {
+        const baseName = yamlReportFileName ?? cliTestId ?? yamlTestId ?? fileName;
+        return (0, agent_namespaceObject.getReportFileName)(baseName);
+    }
+    function buildAgentOptions(yamlAgent, reportFileName, fileName) {
+        return {
+            ...yamlAgent || {},
+            cache: (0, utils_namespaceObject.processCacheConfig)(yamlAgent?.cache, fileName),
+            reportFileName
+        };
+    }
+    async function createYamlPlayer(file, script, options) {
+        const yamlScript = script || (0, yaml_.parseYamlScript)((0, external_node_fs_.readFileSync)(file, 'utf-8'), file);
+        const clonedYamlScript = structuredClone(yamlScript);
+        const fileName = (0, external_node_path_.basename)(file, (0, external_node_path_.extname)(file));
+        const preference = {
+            headed: options?.headed,
+            keepWindow: options?.keepWindow,
+            reportFileName: resolveReportFileName(clonedYamlScript.agent?.reportFileName, options?.testId, clonedYamlScript.agent?.testId, fileName)
+        };
+        const player = new yaml_.ScriptPlayer(clonedYamlScript, async ()=>{
+            const freeFn = [];
+            const webTarget = clonedYamlScript.web || clonedYamlScript.target;
+            const targetCount = [
+                void 0 !== webTarget,
+                void 0 !== clonedYamlScript.android,
+                void 0 !== clonedYamlScript.ios,
+                void 0 !== clonedYamlScript.computer,
+                void 0 !== clonedYamlScript.interface
+            ].filter(Boolean).length;
+            if (targetCount > 1) {
+                const specifiedTargets = [
+                    void 0 !== webTarget ? 'web' : null,
+                    void 0 !== clonedYamlScript.android ? 'android' : null,
+                    void 0 !== clonedYamlScript.ios ? 'ios' : null,
+                    void 0 !== clonedYamlScript.computer ? 'computer' : null,
+                    void 0 !== clonedYamlScript.interface ? 'interface' : null
+                ].filter(Boolean);
+                throw new Error(`Only one target type can be specified, but found multiple: ${specifiedTargets.join(', ')}. Please specify only one of: web, android, ios, computer, or interface.`);
+            }
+            if (void 0 !== webTarget) {
+                if (void 0 !== clonedYamlScript.target) console.warn("target is deprecated, please use web instead. See https://midscenejs.com/automate-with-scripts-in-yaml for more information. Sorry for the inconvenience.");
+                let localServer;
+                let urlToVisit;
+                if (webTarget.serve) {
+                    external_node_assert_default()('string' == typeof webTarget.url, 'url is required in serve mode');
+                    localServer = await launchServer(webTarget.serve);
+                    const serverAddress = localServer.server.address();
+                    freeFn.push({
+                        name: 'local_server',
+                        fn: ()=>localServer?.server.close()
+                    });
+                    urlToVisit = webTarget.url.startsWith('/') ? `http://${serverAddress?.address}:${serverAddress?.port}${webTarget.url}` : `http://${serverAddress?.address}:${serverAddress?.port}/${webTarget.url}`;
+                    webTarget.url = urlToVisit;
+                }
+                if (webTarget.cdpEndpoint && webTarget.bridgeMode) throw new Error('cdpEndpoint and bridgeMode are mutually exclusive. Please specify only one.');
+                if (webTarget.cdpEndpoint) {
+                    const cdpBrowser = options?.browser ?? await external_puppeteer_default().connect({
+                        browserWSEndpoint: webTarget.cdpEndpoint,
+                        defaultViewport: null
+                    });
+                    if (webTarget.chromeArgs) console.warn('chromeArgs are not supported in CDP mode (browser is already running). They will be ignored.');
+                    const { agent, freeFn: newFreeFn } = await (0, puppeteer_agent_launcher_namespaceObject.puppeteerAgentForTarget)(webTarget, {
+                        ...preference,
+                        ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
+                    }, cdpBrowser, options?.page);
+                    const cleanFreeFn = newFreeFn.filter((f)=>'puppeteer_browser' !== f.name);
+                    if (!options?.browser) cleanFreeFn.push({
+                        name: 'cdp_browser_disconnect',
+                        fn: ()=>cdpBrowser.disconnect()
+                    });
+                    freeFn.push(...cleanFreeFn);
+                    return {
+                        agent,
+                        freeFn
+                    };
+                }
+                if (!webTarget.bridgeMode) {
+                    const { agent, freeFn: newFreeFn } = await (0, puppeteer_agent_launcher_namespaceObject.puppeteerAgentForTarget)(webTarget, {
+                        ...preference,
+                        ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
+                    }, options?.browser, options?.page);
+                    freeFn.push(...newFreeFn);
+                    return {
+                        agent,
+                        freeFn
+                    };
+                }
+                external_node_assert_default()('newTabWithUrl' === webTarget.bridgeMode || 'currentTab' === webTarget.bridgeMode, `bridgeMode config value must be either "newTabWithUrl" or "currentTab", but got ${webTarget.bridgeMode}`);
+                if (webTarget.userAgent || null != webTarget.viewportWidth || null != webTarget.viewportHeight || null != webTarget.deviceScaleFactor || webTarget.waitForNetworkIdle || webTarget.cookie || webTarget.chromeArgs) console.warn('puppeteer options (userAgent, viewportWidth, viewportHeight, deviceScaleFactor, waitForNetworkIdle, cookie, chromeArgs) are not supported in bridge mode. They will be ignored.');
+                const agent = new bridge_mode_namespaceObject.AgentOverChromeBridge({
+                    closeNewTabsAfterDisconnect: webTarget.closeNewTabsAfterDisconnect,
+                    closeConflictServer: true,
+                    ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
+                });
+                if ('newTabWithUrl' === webTarget.bridgeMode) await agent.connectNewTabWithUrl(webTarget.url);
+                else {
+                    if (webTarget.url) console.warn('url will be ignored in bridge mode with "currentTab"');
+                    await agent.connectCurrentTab();
+                }
+                freeFn.push({
+                    name: 'destroy_agent_over_chrome_bridge',
+                    fn: ()=>agent.destroy()
+                });
+                return {
+                    agent,
+                    freeFn
+                };
+            }
+            if (void 0 !== clonedYamlScript.android) {
+                const androidTarget = clonedYamlScript.android;
+                const { agentFromAdbDevice } = await import("@midscene/android");
+                const agent = await agentFromAdbDevice(androidTarget?.deviceId, {
+                    ...androidTarget,
+                    ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
+                });
+                if (androidTarget?.launch) await agent.launch(androidTarget.launch);
+                freeFn.push({
+                    name: 'destroy_android_agent',
+                    fn: ()=>agent.destroy()
+                });
+                return {
+                    agent,
+                    freeFn
+                };
+            }
+            if (void 0 !== clonedYamlScript.ios) {
+                const iosTarget = clonedYamlScript.ios;
+                const { agentFromWebDriverAgent } = await import("@midscene/ios");
+                const agent = await agentFromWebDriverAgent({
+                    ...iosTarget,
+                    ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
+                });
+                if (iosTarget?.launch) await agent.launch(iosTarget.launch);
+                freeFn.push({
+                    name: 'destroy_ios_agent',
+                    fn: ()=>agent.destroy()
+                });
+                return {
+                    agent,
+                    freeFn
+                };
+            }
+            if (void 0 !== clonedYamlScript.computer) {
+                const computerTarget = clonedYamlScript.computer;
+                const { agentForComputer } = await import("@midscene/computer");
+                const agent = await agentForComputer({
+                    ...computerTarget,
+                    ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
+                });
+                freeFn.push({
+                    name: 'destroy_computer_agent',
+                    fn: ()=>agent.destroy()
+                });
+                return {
+                    agent,
+                    freeFn
+                };
+            }
+            if (void 0 !== clonedYamlScript.interface) {
+                const interfaceTarget = clonedYamlScript.interface;
+                const moduleSpecifier = interfaceTarget.module;
+                let finalModuleSpecifier;
+                if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../') || external_node_path_default().isAbsolute(moduleSpecifier)) {
+                    const resolvedPath = (0, external_node_path_.join)(process.cwd(), moduleSpecifier);
+                    finalModuleSpecifier = resolvedPath;
+                } else finalModuleSpecifier = moduleSpecifier;
+                debug('importing module config', interfaceTarget.module, 'with export config', interfaceTarget.export, 'final module specifier', finalModuleSpecifier);
+                const importedModule = await import(finalModuleSpecifier);
+                const DeviceClass = interfaceTarget.export ? importedModule[interfaceTarget.export] : importedModule.default || importedModule;
+                debug('DeviceClass', DeviceClass, 'with param', interfaceTarget.param);
+                const device = new DeviceClass(interfaceTarget.param || {});
+                debug('creating agent from device', device);
+                const agent = (0, agent_namespaceObject.createAgent)(device, buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName));
+                freeFn.push({
+                    name: 'destroy_general_interface_agent',
+                    fn: ()=>{
+                        agent.destroy();
+                    }
+                });
+                return {
+                    agent,
+                    freeFn
+                };
+            }
+            throw new Error('No valid interface configuration found in the yaml script, should be either "web", "android", "ios", "computer", or "interface"');
+        }, void 0, file);
+        return player;
+    }
+    var source = __webpack_require__("../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js");
+    var source_default = /*#__PURE__*/ __webpack_require__.n(source);
+    const isTTY = process.env.MIDSCENE_CLI_LOG_ON_NON_TTY ? false : process.stdout.isTTY;
+    const indent = '  ';
+    const spinnerInterval = 80;
+    const spinnerFrames = [
+        '◰',
+        '◳',
+        '◲',
+        '◱'
+    ];
+    const currentSpinningFrame = ()=>spinnerFrames[Math.floor(Date.now() / spinnerInterval) % spinnerFrames.length];
+    function indicatorForStatus(status) {
+        if ('init' === status) return source_default().gray('◌');
+        if ('running' === status) return source_default().yellowBright(currentSpinningFrame());
+        if ('done' === status) return source_default().green('✔︎');
+        if ('error' === status) return source_default().red('✘');
+    }
+    const contextInfo = (context)=>{
+        const filePath = context.file;
+        const filePathToShow = (0, external_node_path_.relative)(process.cwd(), filePath);
+        const fileNameToPrint = `${source_default().gray(`${filePathToShow}`)}`;
+        const fileStatusText = indicatorForStatus(context.player.status);
+        const contextActionText = void 0 === context.player.currentTaskIndex && 'running' === context.player.status ? source_default().gray('(navigating)') : '';
+        const errorText = context.player.errorInSetup ? `\n${indent}${source_default().red('error:')} ${context.player.errorInSetup?.message}\n${indent}${indent}${context.player.errorInSetup?.stack}` : '';
+        const outputFile = context.player.output;
+        const outputText = outputFile && Object.keys(context.player.result || {}).length > 0 ? `\n${indent}${source_default().gray(`output: ${outputFile}`)}` : '';
+        const reportFile = context.player.reportFile;
+        const reportText = reportFile ? `\n${indent}${source_default().gray(`report: ${reportFile}`)}` : '';
+        const agentStatusTip = context.player.agentStatusTip;
+        const agentStatusText = agentStatusTip ? `\n${indent}${source_default().gray(`agent status: ${agentStatusTip}`)}` : '';
+        const mergedText = `${fileStatusText} ${fileNameToPrint} ${contextActionText}${outputText}${reportText}${errorText}${agentStatusText}`.trim();
+        return {
+            fileNameToPrint,
+            fileStatusText,
+            contextActionText,
+            outputText,
+            reportText,
+            mergedText
+        };
+    };
+    const singleTaskInfo = (task)=>{
+        let stepText = '';
+        if ('init' === task.status) stepText = '';
+        else if ('running' === task.status || 'error' === task.status) if (void 0 === task.currentStep) stepText = source_default().gray('(navigating)');
+        else if ('number' == typeof task.currentStep) {
+            const actionText = '';
+            stepText = source_default().gray(`(task ${task.currentStep + 1}/${task.totalSteps}${actionText})`.trim());
+        } else stepText = source_default().gray('(unknown task)');
+        const errorText = 'error' === task.status ? `\n${indent}${source_default().gray('error:')}\n${indent}${indent}${task.error?.message}` : '';
+        const statusText = indicatorForStatus(task.status);
+        const mergedLine = `${statusText} ${task.name} ${stepText}${errorText}`;
+        return {
+            nameText: task.name,
+            stepText,
+            errorText,
+            itemStatusText: statusText,
+            mergedLine
+        };
+    };
+    function paddingLines(lines) {
+        return lines.map((line)=>`${indent}${line}`);
+    }
+    const contextTaskListSummary = (taskStatusArray, context)=>{
+        const prefixLines = [];
+        const currentLine = [];
+        const suffixText = [];
+        const { mergedText: fileInfo } = contextInfo(context);
+        if (!context.player.errorInSetup) for (const task of taskStatusArray){
+            const { mergedLine } = singleTaskInfo(task);
+            if ('init' === context.player.status) suffixText.push(mergedLine);
+            else if ('running' === context.player.status) currentLine.push(mergedLine);
+            else if ('done' === context.player.status) prefixLines.push(mergedLine);
+            else if ('error' === context.player.status) prefixLines.push(mergedLine);
+        }
+        const lines = [
+            fileInfo
+        ];
+        if (prefixLines.length > 0) lines.push(...paddingLines(prefixLines));
+        if (currentLine.length > 0) lines.push(...paddingLines(currentLine));
+        if (suffixText.length > 0) lines.push(...paddingLines(suffixText));
+        return lines.join('\n');
+    };
+    const external_node_util_namespaceObject = require("node:util");
+    var restore_cursor = __webpack_require__("../../node_modules/.pnpm/restore-cursor@5.1.0/node_modules/restore-cursor/index.js");
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    const DEFAULT_RENDER_INTERVAL = 160;
+    const ESC = '\x1B[';
+    const CLEAR_LINE = `${ESC}K`;
+    const MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`;
+    const HIDE_CURSOR = `${ESC}?25l`;
+    const SHOW_CURSOR = `${ESC}?25h`;
+    const SYNC_START = `${ESC}?2026h`;
+    const SYNC_END = `${ESC}?2026l`;
+    class TTYWindowRenderer {
+        start() {
+            this.finished = false;
+            this.renderInterval = setInterval(()=>this.flushBuffer(), this.options.interval);
+        }
+        stop() {
+            this.flushBuffer();
+            this.write(SHOW_CURSOR, 'output');
+            this.cleanups.splice(0).map((fn)=>fn());
+            clearInterval(this.renderInterval);
+        }
+        finish() {
+            this.finished = true;
+            this.flushBuffer();
+            clearInterval(this.renderInterval);
+        }
+        flushBuffer() {
+            if (0 === this.buffer.length) return this.render();
+            let current;
+            for (const next of this.buffer.splice(0)){
+                if (!current) {
+                    current = next;
+                    continue;
+                }
+                if (current.type !== next.type) {
+                    this.render(current.message, current.type);
+                    current = next;
+                    continue;
+                }
+                current.message += next.message;
+            }
+            if (current) this.render(current?.message, current?.type);
+        }
+        render(message, type = 'output') {
+            if (this.finished) {
+                this.clearWindow();
+                return this.write(message || '', type);
+            }
+            const windowContent = this.options.getWindow();
+            const rowCount = getRenderedRowCount(windowContent, this.options.outputStream);
+            let padding = this.windowHeight - rowCount;
+            if (padding > 0 && message) padding -= getRenderedRowCount([
+                message
+            ], this.options.outputStream);
+            this.write(SYNC_START);
+            this.clearWindow();
+            if (message) this.write(message, type);
+            if (padding > 0) this.write('\n'.repeat(padding));
+            this.write(windowContent.join('\n'));
+            this.write(SYNC_END);
+            this.windowHeight = rowCount + Math.max(0, padding);
+        }
+        clearWindow() {
+            if (0 === this.windowHeight) return;
+            this.write(CLEAR_LINE);
+            for(let i = 1; i < this.windowHeight; i++)this.write(`${MOVE_CURSOR_ONE_ROW_UP}${CLEAR_LINE}`);
+            this.windowHeight = 0;
+        }
+        interceptStream(stream, type) {
+            const original = stream.write;
+            stream.write = (chunk, _, callback)=>{
+                if (chunk) if (this.finished) this.write(chunk.toString(), type);
+                else this.buffer.push({
+                    type,
+                    message: chunk.toString()
+                });
+                callback?.();
+            };
+            return function() {
+                stream.write = original;
+            };
+        }
+        write(message, type = 'output') {
+            this.streams[type](message);
+        }
+        constructor(options){
+            _define_property(this, "options", void 0);
+            _define_property(this, "streams", void 0);
+            _define_property(this, "buffer", []);
+            _define_property(this, "renderInterval", void 0);
+            _define_property(this, "windowHeight", 0);
+            _define_property(this, "finished", false);
+            _define_property(this, "cleanups", []);
+            this.options = {
+                interval: DEFAULT_RENDER_INTERVAL,
+                ...options
+            };
+            this.streams = {
+                output: options.outputStream.write.bind(options.outputStream),
+                error: options.errorStream.write.bind(options.errorStream)
+            };
+            this.cleanups.push(this.interceptStream(process.stdout, 'output'), this.interceptStream(process.stderr, 'error'));
+            (0, restore_cursor.A)();
+            this.write(HIDE_CURSOR, 'output');
+            this.start();
+        }
+    }
+    function getRenderedRowCount(contents, stream) {
+        let count = 0;
+        const columns = 'columns' in stream ? stream.columns : 80;
+        for (const content of contents){
+            const rows = content.split('\n');
+            for (const row of rows){
+                const text = (0, external_node_util_namespaceObject.stripVTControlCharacters)(row);
+                count += Math.max(1, Math.ceil(text.length / columns));
+            }
+        }
+        return count;
+    }
+    function yaml_batch_executor_define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    class YamlBatchExecutor {
+        async run(options = {}) {
+            const generateSummary = options.generateSummary ?? true;
+            const shouldPrintExecutionPlan = options.printExecutionPlan ?? true;
+            const { keepWindow, headed } = this.config;
+            if (shouldPrintExecutionPlan) printExecutionPlan(this.config);
+            const fileContextList = [];
+            let browser = null;
+            let sharedPage = null;
+            try {
+                for (const file of this.config.files){
+                    const fileConfig = await this.loadFileConfig(file);
+                    const context = await this.createFileContext(file, fileConfig, {
+                        headed,
+                        keepWindow
+                    });
+                    fileContextList.push(context);
+                }
+                const needsBrowser = fileContextList.some((ctx)=>Object.keys(ctx.executionConfig.web || ctx.executionConfig.target || {}).length > 0);
+                if (needsBrowser && this.config.shareBrowserContext) {
+                    const globalWebConfig = this.config.globalConfig?.web;
+                    if (globalWebConfig?.cdpEndpoint) browser = await external_puppeteer_default().connect({
+                        browserWSEndpoint: globalWebConfig.cdpEndpoint,
+                        defaultViewport: null
+                    });
+                    else {
+                        const width = globalWebConfig?.viewportWidth ?? puppeteer_agent_launcher_namespaceObject.defaultViewportWidth;
+                        const height = globalWebConfig?.viewportHeight ?? puppeteer_agent_launcher_namespaceObject.defaultViewportHeight;
+                        const args = (0, puppeteer_agent_launcher_namespaceObject.buildChromeArgs)({
+                            userAgent: globalWebConfig?.userAgent,
+                            windowSize: headed ? {
+                                width,
+                                height
+                            } : void 0,
+                            chromeArgs: globalWebConfig?.chromeArgs
+                        });
+                        browser = await external_puppeteer_default().launch({
+                            headless: !headed,
+                            defaultViewport: headed ? null : {
+                                width,
+                                height
+                            },
+                            args,
+                            acceptInsecureCerts: globalWebConfig?.acceptInsecureCerts
+                        });
+                    }
+                    sharedPage = await browser.newPage();
+                    for (const context of fileContextList){
+                        context.options.browser = browser;
+                        context.options.page = sharedPage;
+                    }
+                }
+                const { executedResults, notExecutedContexts } = await this.executeFiles(fileContextList);
+                this.results = await this.processResults(executedResults, notExecutedContexts);
+            } finally{
+                if (browser && !this.config.keepWindow) {
+                    const isCdp = !!this.config.globalConfig?.web?.cdpEndpoint;
+                    if (isCdp) browser.disconnect();
+                    else await browser.close();
+                }
+                if (generateSummary) await this.generateOutputIndex();
+            }
+            return this.results;
+        }
+        async createFileContext(file, fileConfig, options) {
+            const { globalConfig } = this.config;
+            const clonedFileConfig = JSON.parse(JSON.stringify(fileConfig));
+            if (clonedFileConfig.target) {
+                clonedFileConfig.web = {
+                    ...clonedFileConfig.target,
+                    ...clonedFileConfig.web
+                };
+                delete clonedFileConfig.target;
+            }
+            if (globalConfig?.target) {
+                globalConfig.web = {
+                    ...globalConfig.target,
+                    ...globalConfig.web
+                };
+                delete globalConfig.target;
+            }
+            const executionConfig = external_lodash_merge_default()(clonedFileConfig, globalConfig);
+            return {
+                file,
+                executionConfig,
+                options
+            };
+        }
+        async executeFiles(fileContextList) {
+            const executedResults = [];
+            const notExecutedContexts = [];
+            const allFileContexts = [];
+            for (const context of fileContextList){
+                const player = await createYamlPlayer(context.file, context.executionConfig, context.options);
+                allFileContexts.push({
+                    file: context.file,
+                    player
+                });
+            }
+            let ttyRenderer;
+            if (isTTY) {
+                const summaryContents = ()=>{
+                    const summary = [
+                        ''
+                    ];
+                    for (const context of allFileContexts)summary.push(contextTaskListSummary(context.player.taskStatusList, context));
+                    summary.push('');
+                    return summary;
+                };
+                ttyRenderer = new TTYWindowRenderer({
+                    outputStream: process.stdout,
+                    errorStream: process.stderr,
+                    getWindow: summaryContents,
+                    interval: spinnerInterval
+                });
+                ttyRenderer.start();
+            }
+            try {
+                const executeFile = async (context)=>{
+                    const allFileContext = allFileContexts.find((c)=>c.file === context.file);
+                    if (!allFileContext) throw new Error(`Player not found for file: ${context.file}`);
+                    if (!isTTY) {
+                        const { mergedText } = contextInfo(allFileContext);
+                        console.log(mergedText);
+                    }
+                    if (context.outputPath) allFileContext.player.output = context.outputPath;
+                    const startTime = Date.now();
+                    await allFileContext.player.run();
+                    const endTime = Date.now();
+                    const duration = endTime - startTime;
+                    const executedContext = {
+                        file: context.file,
+                        player: allFileContext.player,
+                        duration
+                    };
+                    if (!isTTY) console.log(contextTaskListSummary(allFileContext.player.taskStatusList, executedContext));
+                    return executedContext;
+                };
+                await this.executeConcurrently(fileContextList, executeFile, executedResults, notExecutedContexts);
+                if (!isTTY) {
+                    console.log('\n📋 Execution Results:');
+                    for (const context of executedResults)console.log(contextTaskListSummary(context.player.taskStatusList, context));
+                }
+            } finally{
+                if (ttyRenderer) ttyRenderer.stop();
+            }
+            return {
+                executedResults,
+                notExecutedContexts
+            };
+        }
+        async executeConcurrently(fileContextList, executeFile, executedResults, notExecutedContexts) {
+            const limit = (0, p_limit.A)(this.config.concurrent);
+            if (this.config.continueOnError) {
+                const tasks = fileContextList.map((context)=>limit(async ()=>{
+                        const executedContext = await executeFile(context);
+                        executedResults.push(executedContext);
+                    }));
+                await Promise.allSettled(tasks);
+            } else {
+                let shouldStop = false;
+                const stopLock = {
+                    value: false
+                };
+                const tasks = fileContextList.map((context)=>limit(async ()=>{
+                        if (stopLock.value) return void notExecutedContexts.push({
+                            file: context.file,
+                            player: null
+                        });
+                        const executedContext = await executeFile(context);
+                        executedResults.push(executedContext);
+                        if ('error' === executedContext.player.status && !stopLock.value) {
+                            stopLock.value = true;
+                            shouldStop = true;
+                        }
+                    }));
+                await Promise.allSettled(tasks);
+                if (shouldStop) {
+                    for (const context of fileContextList)if (!executedResults.some((r)=>r.file === context.file) && !notExecutedContexts.some((ctx)=>ctx.file === context.file)) notExecutedContexts.push({
+                        file: context.file,
+                        player: null
+                    });
+                }
+            }
+        }
+        async processResults(executedContexts, notExecutedContexts) {
+            const results = [];
+            for (const context of executedContexts){
+                const { file, player, duration } = context;
+                results.push(createExecutedYamlResult({
+                    file,
+                    player,
+                    duration
+                }));
+            }
+            for (const context of notExecutedContexts)results.push(createNotExecutedYamlResult(context.file));
+            return results;
+        }
+        async loadFileConfig(file) {
+            const content = (0, external_node_fs_.readFileSync)(file, 'utf8');
+            return (0, yaml_.parseYamlScript)(content, file);
+        }
+        async generateOutputIndex() {
+            try {
+                writeExecutionSummaryFile(this.config.summary, this.results);
+                printExecutionFinished();
+            } catch (error) {
+                console.error('Failed to generate output index:', error);
+            }
+        }
+        constructor(config){
+            yaml_batch_executor_define_property(this, "config", void 0);
+            yaml_batch_executor_define_property(this, "results", []);
+            this.config = config;
+        }
+    }
+    async function runYamlBatch(config, options = {}) {
+        return new YamlBatchExecutor(config).run(options);
+    }
+    const writeResultFile = (resultFile, data)=>{
+        (0, external_node_fs_.mkdirSync)((0, external_node_path_.dirname)(resultFile), {
+            recursive: true
+        });
+        (0, external_node_fs_.writeFileSync)(resultFile, JSON.stringify(data, null, 2));
+    };
+    const batchFailureMessage = (results)=>{
+        const failed = results.filter((result)=>!result.success);
+        return failed.map((result)=>`${result.file}: ${result.error || result.resultType}`).join('\n');
+    };
+    async function runYamlBatchInRstest(options) {
+        const results = await runYamlBatch(options.config, {
+            generateSummary: false,
+            printExecutionPlan: false
+        });
+        for (const result of results){
+            const resultFile = options.resultFiles[result.file] || options.resultFiles[(0, external_node_path_.resolve)(result.file)];
+            if (resultFile) writeResultFile(resultFile, result);
+        }
+        if (results.some((result)=>!result.success)) throw new Error(batchFailureMessage(results));
+        return results;
+    }
+    const taskErrorMessage = (task)=>{
+        if (task.error?.message) return task.error.message;
+        if ('error' === task.status) return `Task "${task.name}" failed`;
+    };
+    const cloneJson = (value)=>JSON.parse(JSON.stringify(value));
+    const normalizeTargetConfig = (config)=>{
+        if (config.target) {
+            config.web = {
+                ...config.target,
+                ...config.web
+            };
+            config.target = void 0;
+        }
+    };
+    const createExecutionConfig = (file, globalConfig)=>{
+        const content = (0, external_node_fs_.readFileSync)(file, 'utf8');
+        const fileConfig = cloneJson((0, yaml_.parseYamlScript)(content, file));
+        normalizeTargetConfig(fileConfig);
+        const clonedGlobalConfig = cloneJson(globalConfig);
+        normalizeTargetConfig(clonedGlobalConfig);
+        return external_lodash_merge_default()(fileConfig, clonedGlobalConfig);
+    };
+    const getYamlPlayerFailure = (player)=>{
+        if (player.errorInSetup) return player.errorInSetup;
+        const failedMessages = player.taskStatusList?.map(taskErrorMessage).filter(Boolean) || [];
+        if ('error' === player.status || failedMessages.length > 0) {
+            const details = failedMessages.length ? failedMessages.join('; ') : 'YAML case failed';
+            const reportLine = player.reportFile ? `\nReport: ${player.reportFile}` : '';
+            const outputLine = player.output ? `\nOutput: ${player.output}` : '';
+            return new Error(`${details}${reportLine}${outputLine}`);
+        }
+    };
+    const createYamlCaseResult = (file, player, duration)=>{
+        const hasFailedTasks = player.taskStatusList?.some((task)=>'error' === task.status) ?? false;
+        const hasPlayerError = 'error' === player.status;
+        const outputPath = player.output && (0, external_node_fs_.existsSync)(player.output) ? player.output : void 0;
+        const reportFile = player.reportFile || void 0;
+        let errorMessage;
+        if (player.errorInSetup?.message) errorMessage = player.errorInSetup.message;
+        else if (hasPlayerError || hasFailedTasks) {
+            const taskErrors = player.taskStatusList?.filter((task)=>'error' === task.status && task.error?.message).map((task)=>task.error.message);
+            errorMessage = taskErrors && taskErrors.length > 0 ? taskErrors.join('; ') : hasPlayerError ? 'Execution failed' : 'Some tasks failed';
+        }
+        const resultType = hasPlayerError ? 'failed' : hasFailedTasks ? 'partialFailed' : 'success';
+        return {
+            file,
+            success: 'success' === resultType,
+            executed: true,
+            output: outputPath,
+            report: reportFile,
+            duration,
+            resultType,
+            error: errorMessage
+        };
+    };
+    const createYamlCaseFailure = (result)=>{
+        const reportLine = result.report ? `\nReport: ${result.report}` : '';
+        const outputLine = result.output ? `\nOutput: ${result.output}` : '';
+        return new Error(`${result.error || 'YAML case failed'}${reportLine}${outputLine}`);
+    };
+    async function runYamlCaseResult(options) {
+        const file = (0, external_node_path_.resolve)(options.file);
+        const startTime = Date.now();
+        const executionConfig = options.executionConfig || (options.globalConfig ? createExecutionConfig(file, options.globalConfig) : void 0);
+        const player = await createYamlPlayer(file, executionConfig, {
+            headed: options.headed,
+            keepWindow: options.keepWindow
+        });
+        await player.run();
+        return createYamlCaseResult(file, player, Date.now() - startTime);
+    }
+    async function runYamlCase(options) {
+        const result = await runYamlCaseResult(options);
+        if (!result.success) throw createYamlCaseFailure(result);
+        return {
+            file: result.file,
+            output: result.output || void 0,
+            report: result.report,
+            duration: result.duration || 0
+        };
+    }
+    const errorMessageOf = (error)=>error instanceof Error ? error.message : String(error);
+    const rstest_entry_writeResultFile = (resultFile, data)=>{
+        (0, external_node_fs_.mkdirSync)((0, external_node_path_.dirname)(resultFile), {
+            recursive: true
+        });
+        (0, external_node_fs_.writeFileSync)(resultFile, JSON.stringify(data, null, 2));
+    };
+    const createRuntimeFailureResult = (file, startTime, error)=>({
+            file,
+            success: false,
+            executed: true,
+            duration: Date.now() - startTime,
+            resultType: 'failed',
+            error: errorMessageOf(error)
+        });
+    function defineYamlCaseTest(options) {
+        (0, core_namespaceObject.test)(options.testName, async ()=>{
+            const file = (0, external_node_path_.resolve)(options.yamlFile);
+            const startTime = Date.now();
+            let result;
+            try {
+                result = await runYamlCaseResult({
+                    ...options.caseOptions,
+                    ...options.webRuntimeOptions,
+                    file
+                });
+                rstest_entry_writeResultFile(options.resultFile, result);
+                if (!result.success && 'partialFailed' !== result.resultType) throw createYamlCaseFailure(result);
+            } catch (error) {
+                if (!result) rstest_entry_writeResultFile(options.resultFile, createRuntimeFailureResult(file, startTime, error));
+                throw error;
+            }
+        });
+    }
+    function defineYamlBatchTest(options) {
+        (0, core_namespaceObject.test)(options.testName, async ()=>{
+            await runYamlBatchInRstest({
+                config: options.config,
+                resultFiles: options.resultFiles
+            });
+        });
+    }
+})();
+exports.createRstestYamlProject = __webpack_exports__.createRstestYamlProject;
+exports.createYamlCaseFailure = __webpack_exports__.createYamlCaseFailure;
+exports.createYamlCaseResult = __webpack_exports__.createYamlCaseResult;
+exports.defineYamlBatchTest = __webpack_exports__.defineYamlBatchTest;
+exports.defineYamlCaseTest = __webpack_exports__.defineYamlCaseTest;
+exports.getYamlPlayerFailure = __webpack_exports__.getYamlPlayerFailure;
+exports.resolveRstestCoreImportPath = __webpack_exports__.resolveRstestCoreImportPath;
+exports.resolveTestName = __webpack_exports__.resolveTestName;
+exports.runFrameworkTestConfig = __webpack_exports__.runFrameworkTestConfig;
+exports.runRstestYamlProject = __webpack_exports__.runRstestYamlProject;
+exports.runYamlBatchInRstest = __webpack_exports__.runYamlBatchInRstest;
+exports.runYamlCase = __webpack_exports__.runYamlCase;
+exports.runYamlCaseResult = __webpack_exports__.runYamlCaseResult;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRstestYamlProject",
+    "createYamlCaseFailure",
+    "createYamlCaseResult",
+    "defineYamlBatchTest",
+    "defineYamlCaseTest",
+    "getYamlPlayerFailure",
+    "resolveRstestCoreImportPath",
+    "resolveTestName",
+    "runFrameworkTestConfig",
+    "runRstestYamlProject",
+    "runYamlBatchInRstest",
+    "runYamlCase",
+    "runYamlCaseResult"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.js.map