@midscene/cli 1.8.7-beta-20260528070149.0 → 1.8.7-beta-20260528111436.0

package/dist/es/framework/index.mjs

@@ -0,0 +1,3880 @@
+import * as __rspack_external_os from "os";
+import * as __rspack_external_tty from "tty";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import node_path, { basename, dirname, extname, join, relative, resolve as external_node_path_resolve, sep } from "node:path";
+import { getMidsceneRunSubDir } from "@midscene/shared/common";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { test } from "@rstest/core";
+import { ScriptPlayer, parseYamlScript } from "@midscene/core/yaml";
+import { buildChromeArgs, defaultViewportHeight, defaultViewportWidth, puppeteerAgentForTarget } from "@midscene/web/puppeteer-agent-launcher";
+import lodash_merge from "lodash.merge";
+import puppeteer from "puppeteer";
+import { createServer } from "http-server";
+import node_assert from "node:assert";
+import { createAgent, getReportFileName } from "@midscene/core/agent";
+import { processCacheConfig } from "@midscene/core/utils";
+import { getDebug } from "@midscene/shared/logger";
+import { AgentOverChromeBridge } from "@midscene/web/bridge-mode";
+import { stripVTControlCharacters } from "node:util";
+import node_process from "node:process";
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        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__) {
+        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) {
+        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) {
+        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) {
+        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) {
+        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__) {
+        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)))
+        };
+    },
+    os (module) {
+        module.exports = __rspack_external_os;
+    },
+    tty (module) {
+        module.exports = __rspack_external_tty;
+    }
+};
+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 = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.nmd = (module)=>{
+        module.paths = [];
+        if (!module.children) module.children = [];
+        return module;
+    };
+})();
+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 && !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 external_node_path_resolve(getMidsceneRunSubDir('output'), summary);
+}
+function writeExecutionSummaryFile(summary, results) {
+    const indexPath = getSummaryAbsolutePath(summary);
+    const outputDir = dirname(indexPath);
+    mkdirSync(outputDir, {
+        recursive: true
+    });
+    const executionSummary = getExecutionSummary(results);
+    const indexData = {
+        summary: {
+            ...executionSummary,
+            generatedAt: new Date().toLocaleString()
+        },
+        results: results.map((result)=>({
+                script: relative(outputDir, result.file),
+                success: result.success,
+                resultType: result.resultType,
+                output: result.output ? (()=>{
+                    const relativePath = relative(outputDir, result.output);
+                    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+                })() : void 0,
+                report: result.report ? relative(outputDir, result.report) : void 0,
+                error: result.error,
+                duration: result.duration
+            }))
+    };
+    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(sep).join('/');
+const toImportLiteral = (value)=>JSON.stringify(toPosixPath(value));
+const toVirtualModuleId = (fileStem)=>`virtual:midscene-yaml/${fileStem}.test.ts`;
+const safeFileStem = (file, index)=>{
+    const base = basename(file, 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 = 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] ? external_node_path_resolve(process.argv[1]) : '';
+    const candidates = [
+        entry ? join(dirname(entry), 'framework', 'index.js') : '',
+        entry ? join(dirname(entry), '..', 'dist', 'lib', 'framework', 'index.js') : ''
+    ].filter(Boolean);
+    const matched = candidates.find((candidate)=>existsSync(candidate));
+    return matched || '@midscene/cli/dist/lib/framework/index.js';
+};
+function createRstestYamlProject(options) {
+    const projectDir = external_node_path_resolve(options.projectDir || process.cwd());
+    const outputDir = options.outputDir || join(getMidsceneRunSubDir('tmp'), `rstest-yaml-${Date.now()}`);
+    const resultDir = options.resultDir || join(outputDir, 'results');
+    const frameworkImport = options.frameworkImport || resolveDefaultFrameworkImport();
+    const testTimeout = options.testTimeout ?? DEFAULT_YAML_TEST_TIMEOUT;
+    rmSync(outputDir, {
+        recursive: true,
+        force: true
+    });
+    mkdirSync(resultDir, {
+        recursive: true
+    });
+    const virtualModules = {};
+    const cases = options.files.map((file, index)=>{
+        const yamlFile = external_node_path_resolve(file);
+        const testName = resolveTestName(projectDir, yamlFile);
+        const fileStem = safeFileStem(yamlFile, index);
+        const resultFile = 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 requireFromCliEntry = ()=>{
+    const entry = process.argv[1] ? external_node_path_resolve(process.argv[1]) : join(process.cwd(), 'midscene-cli.js');
+    return createRequire(entry);
+};
+const resolvePackageFromRstestCore = (packageName)=>{
+    const require = requireFromCliEntry();
+    const rstestPackageJsonPath = require.resolve('@rstest/core/package.json');
+    return createRequire(rstestPackageJsonPath).resolve(packageName);
+};
+function resolveRstestCoreImportPath() {
+    const require = requireFromCliEntry();
+    const packageJsonPath = require.resolve('@rstest/core/package.json');
+    return join(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(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[external_node_path_resolve(file)] = {
+        globalConfig: config.globalConfig
+    };
+    return caseOptions;
+};
+const createWebRuntimeOptions = (config, runtimeOptions)=>{
+    const caseOptions = {};
+    for (const file of config.files)caseOptions[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 (existsSync(item.resultFile)) return JSON.parse(readFileSync(item.resultFile, 'utf8'));
+        return createNotExecutedYamlResult(item.yamlFile);
+    });
+async function runFrameworkTestConfig(config, commandOptions = {}) {
+    printExecutionPlan(config);
+    const projectDir = 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;
+}
+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');
+}
+const debug = getDebug('create-yaml-player');
+const launchServer = async (dir)=>new Promise((resolve)=>{
+        const server = 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 getReportFileName(baseName);
+}
+function buildAgentOptions(yamlAgent, reportFileName, fileName) {
+    return {
+        ...yamlAgent || {},
+        cache: processCacheConfig(yamlAgent?.cache, fileName),
+        reportFileName
+    };
+}
+async function createYamlPlayer(file, script, options) {
+    const yamlScript = script || parseYamlScript(readFileSync(file, 'utf-8'), file);
+    const clonedYamlScript = structuredClone(yamlScript);
+    const fileName = basename(file, extname(file));
+    const preference = {
+        headed: options?.headed,
+        keepWindow: options?.keepWindow,
+        reportFileName: resolveReportFileName(clonedYamlScript.agent?.reportFileName, options?.testId, clonedYamlScript.agent?.testId, fileName)
+    };
+    const player = new 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) {
+                node_assert('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 puppeteer.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 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 puppeteerAgentForTarget(webTarget, {
+                    ...preference,
+                    ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
+                }, options?.browser, options?.page);
+                freeFn.push(...newFreeFn);
+                return {
+                    agent,
+                    freeFn
+                };
+            }
+            node_assert('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 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('../') || node_path.isAbsolute(moduleSpecifier)) {
+                const resolvedPath = 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 = 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 = 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 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 = node_process.stderr.isTTY ? node_process.stderr : node_process.stdout.isTTY ? node_process.stdout : void 0;
+const restoreCursor = terminal ? node_modules_onetime(()=>{
+    onExit(()=>{
+        terminal.write('\u001B[?25h');
+    }, {
+        alwaysLast: true
+    });
+}) : ()=>{};
+const restore_cursor = restoreCursor;
+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'));
+        restore_cursor();
+        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 = 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 puppeteer.connect({
+                    browserWSEndpoint: globalWebConfig.cdpEndpoint,
+                    defaultViewport: null
+                });
+                else {
+                    const width = globalWebConfig?.viewportWidth ?? defaultViewportWidth;
+                    const height = globalWebConfig?.viewportHeight ?? defaultViewportHeight;
+                    const args = buildChromeArgs({
+                        userAgent: globalWebConfig?.userAgent,
+                        windowSize: headed ? {
+                            width,
+                            height
+                        } : void 0,
+                        chromeArgs: globalWebConfig?.chromeArgs
+                    });
+                    browser = await puppeteer.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 = lodash_merge(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 = pLimit(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 = readFileSync(file, 'utf8');
+        return 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)=>{
+    mkdirSync(dirname(resultFile), {
+        recursive: true
+    });
+    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[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 = readFileSync(file, 'utf8');
+    const fileConfig = cloneJson(parseYamlScript(content, file));
+    normalizeTargetConfig(fileConfig);
+    const clonedGlobalConfig = cloneJson(globalConfig);
+    normalizeTargetConfig(clonedGlobalConfig);
+    return lodash_merge(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 && 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 = 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)=>{
+    mkdirSync(dirname(resultFile), {
+        recursive: true
+    });
+    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) {
+    test(options.testName, async ()=>{
+        const file = 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) {
+    test(options.testName, async ()=>{
+        await runYamlBatchInRstest({
+            config: options.config,
+            resultFiles: options.resultFiles
+        });
+    });
+}
+export { createRstestYamlProject, createYamlCaseFailure, createYamlCaseResult, defineYamlBatchTest, defineYamlCaseTest, getYamlPlayerFailure, resolveRstestCoreImportPath, resolveTestName, runFrameworkTestConfig, runRstestYamlProject, runYamlBatchInRstest, runYamlCase, runYamlCaseResult };
+
+//# sourceMappingURL=index.mjs.map