cypress 13.17.0 → 14.0.0

package/vue/vue/dist/cypress-vue.cjs.js

@@ -1,7 +1,7 @@
 
 /**
  * @cypress/vue v0.0.0-development
- * (c) 2024 Cypress.io
+ * (c) 2025 Cypress.io
  * Released under the MIT License
  */
 
@@ -44,8 +44,6 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
 
 function __rest(s, e) {
   var t = {};
@@ -77,13 +75,6 @@ const getContainerEl = () => {
     }
     throw Error(`No element found that matches selector ${ROOT_SELECTOR}. Please add a root element with data-cy-root attribute to your "component-index.html" file so that Cypress can attach your component to the DOM.`);
 };
-function checkForRemovedStyleOptions(mountingOptions) {
-    for (const key of ['cssFile', 'cssFiles', 'style', 'styles', 'stylesheet', 'stylesheets']) {
-        if (mountingOptions[key]) {
-            Cypress.utils.throwErrByPath('mount.removed_style_mounting_options', key);
-        }
-    }
-}
 /**
  * Utility function to register CT side effects and run cleanup code during the "test:before:run" Cypress hook
  * @param optionalCallback Callback to be called before the next test runs
@@ -127,7 +118,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise */
+/* global Reflect, Promise, SuppressedError, Symbol */
 
 var extendStatics = function(d, b) {
     extendStatics = Object.setPrototypeOf ||
@@ -201,7 +192,12 @@ function __spreadArray(to, from, pack) {
         }
     }
     return to.concat(ar || Array.prototype.slice.call(from));
-}
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
 var Pluggable = /** @class */ (function () {
     function Pluggable() {
@@ -301,12 +297,30 @@ function mergeGlobalProperties(mountGlobal) {
 var isObject = function (obj) {
     return !!obj && typeof obj === 'object';
 };
+function isClass(obj) {
+    if (!(obj instanceof Object))
+        return;
+    var isCtorClass = obj.constructor && obj.constructor.toString().substring(0, 5) === 'class';
+    if (!('prototype' in obj)) {
+        return isCtorClass;
+    }
+    var prototype = obj.prototype;
+    var isPrototypeCtorClass = prototype.constructor &&
+        prototype.constructor.toString &&
+        prototype.constructor.toString().substring(0, 5) === 'class';
+    return isCtorClass || isPrototypeCtorClass;
+}
 // https://stackoverflow.com/a/48218209
 var mergeDeep = function (target, source) {
+    var _a;
     if (!isObject(target) || !isObject(source)) {
         return source;
     }
-    Object.keys(source).forEach(function (key) {
+    Object.keys(source)
+        .concat(isClass(source)
+        ? Object.getOwnPropertyNames((_a = Object.getPrototypeOf(source)) !== null && _a !== void 0 ? _a : {})
+        : Object.getOwnPropertyNames(source))
+        .forEach(function (key) {
         var targetValue = target[key];
         var sourceValue = source[key];
         if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
@@ -391,6 +405,20 @@ function hasSetupState(vm) {
 function isScriptSetup(vm) {
     return (vm && vm.$.setupState.__isScriptSetup);
 }
+var _globalThis;
+var getGlobalThis = function () {
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
 
 var ignorableKeyModifiers = [
     'stop',
@@ -1675,19 +1703,15 @@ function stringifyNode(node) {
         : new XMLSerializer().serializeToString(node);
 }
 
-var jsExports = {};
-var js = {
-  get exports(){ return jsExports; },
-  set exports(v){ jsExports = v; },
-};
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var js = {exports: {}};
 
 var src = {};
 
-var javascriptExports = {};
-var javascript = {
-  get exports(){ return javascriptExports; },
-  set exports(v){ javascriptExports = v; },
-};
+var javascript = {exports: {}};
 
 var beautifier$2 = {};
 
@@ -2179,8 +2203,8 @@ function requireAcorn () {
 		// in javascript, these two differ
 		// in python they are the same, different methods are called on them
 		exports.lineBreak = new RegExp('\r\n|' + exports.newline.source);
-		exports.allLineBreaks = new RegExp(exports.lineBreak.source, 'g');
-} (acorn));
+		exports.allLineBreaks = new RegExp(exports.lineBreak.source, 'g'); 
+	} (acorn));
 	return acorn;
 }
 
@@ -3348,6 +3372,7 @@ function requireTokenizer$1 () {
 
 	  token = token || this._read_non_javascript(c);
 	  token = token || this._read_string(c);
+	  token = token || this._read_pair(c, this._input.peek(1)); // Issue #2062 hack for record type '#{'
 	  token = token || this._read_word(previous_token);
 	  token = token || this._read_singles(c);
 	  token = token || this._read_comment(c);
@@ -3406,6 +3431,19 @@ function requireTokenizer$1 () {
 	  return token;
 	};
 
+	Tokenizer.prototype._read_pair = function(c, d) {
+	  var token = null;
+	  if (c === '#' && d === '{') {
+	    token = this._create_token(TOKEN.START_BLOCK, c + d);
+	  }
+
+	  if (token) {
+	    this._input.next();
+	    this._input.next();
+	  }
+	  return token;
+	};
+
 	Tokenizer.prototype._read_punctuation = function() {
 	  var resulting_string = this.__patterns.punct.read();
 
@@ -4492,7 +4530,7 @@ function requireBeautifier$2 () {
 	      }
 	    }
 	    if (this._flags.last_token.type !== TOKEN.OPERATOR && this._flags.last_token.type !== TOKEN.START_EXPR) {
-	      if (this._flags.last_token.type === TOKEN.START_BLOCK && !this._flags.inline_frame) {
+	      if (in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.SEMICOLON]) && !this._flags.inline_frame) {
 	        this.print_newline();
 	      } else {
 	        this._output.space_before_token = true;
@@ -5195,7 +5233,7 @@ function requireBeautifier$2 () {
 var hasRequiredJavascript;
 
 function requireJavascript () {
-	if (hasRequiredJavascript) return javascriptExports;
+	if (hasRequiredJavascript) return javascript.exports;
 	hasRequiredJavascript = 1;
 
 	var Beautifier = requireBeautifier$2().Beautifier,
@@ -5207,17 +5245,13 @@ function requireJavascript () {
 	}
 
 	javascript.exports = js_beautify;
-	javascriptExports.defaultOptions = function() {
+	javascript.exports.defaultOptions = function() {
 	  return new Options();
 	};
-	return javascriptExports;
+	return javascript.exports;
 }
 
-var cssExports = {};
-var css = {
-  get exports(){ return cssExports; },
-  set exports(v){ cssExports = v; },
-};
+var css = {exports: {}};
 
 var beautifier$1 = {};
 
@@ -5294,18 +5328,18 @@ function requireBeautifier$1 () {
 
 	  // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule
 	  this.NESTED_AT_RULE = {
-	    "@page": true,
-	    "@font-face": true,
-	    "@keyframes": true,
+	    "page": true,
+	    "font-face": true,
+	    "keyframes": true,
 	    // also in CONDITIONAL_GROUP_RULE below
-	    "@media": true,
-	    "@supports": true,
-	    "@document": true
+	    "media": true,
+	    "supports": true,
+	    "document": true
 	  };
 	  this.CONDITIONAL_GROUP_RULE = {
-	    "@media": true,
-	    "@supports": true,
-	    "@document": true
+	    "media": true,
+	    "supports": true,
+	    "document": true
 	  };
 	  this.NON_SEMICOLON_NEWLINE_PROPERTY = [
 	    "grid-template-areas",
@@ -5433,8 +5467,7 @@ function requireBeautifier$1 () {
 	  // label { content: blue }
 	  var insidePropertyValue = false;
 	  var enteringConditionalGroup = false;
-	  var insideAtExtend = false;
-	  var insideAtImport = false;
+	  var insideNonNestedAtRule = false;
 	  var insideScssMap = false;
 	  var topCharacter = this._ch;
 	  var insideNonSemiColonValues = false;
@@ -5489,10 +5522,32 @@ function requireBeautifier$1 () {
 
 	      // Ensures any new lines following the comment are preserved
 	      this.eatWhitespace(true);
-	    } else if (this._ch === '@' || this._ch === '$') {
+	    } else if (this._ch === '$') {
+	      this.preserveSingleSpace(isAfterSpace);
+
+	      this.print_string(this._ch);
+
+	      // strip trailing space, if present, for hash property checks
+	      var variable = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g);
+
+	      if (variable.match(/[ :]$/)) {
+	        // we have a variable or pseudo-class, add it and insert one space before continuing
+	        variable = this.eatString(": ").replace(/\s$/, '');
+	        this.print_string(variable);
+	        this._output.space_before_token = true;
+	      }
+
+	      variable = variable.replace(/\s$/, '');
+
+	      // might be sass variable
+	      if (parenLevel === 0 && variable.indexOf(':') !== -1) {
+	        insidePropertyValue = true;
+	        this.indent();
+	      }
+	    } else if (this._ch === '@') {
 	      this.preserveSingleSpace(isAfterSpace);
 
-	      // deal with less propery mixins @{...}
+	      // deal with less property mixins @{...}
 	      if (this._input.peek() === '{') {
 	        this.print_string(this._ch + this.eatString('}'));
 	      } else {
@@ -5510,22 +5565,21 @@ function requireBeautifier$1 () {
 
 	        variableOrRule = variableOrRule.replace(/\s$/, '');
 
-	        if (variableOrRule === 'extend') {
-	          insideAtExtend = true;
-	        } else if (variableOrRule === 'import') {
-	          insideAtImport = true;
-	        }
+	        // might be less variable
+	        if (parenLevel === 0 && variableOrRule.indexOf(':') !== -1) {
+	          insidePropertyValue = true;
+	          this.indent();
 
-	        // might be a nesting at-rule
-	        if (variableOrRule in this.NESTED_AT_RULE) {
+	          // might be a nesting at-rule
+	        } else if (variableOrRule in this.NESTED_AT_RULE) {
 	          this._nestedLevel += 1;
 	          if (variableOrRule in this.CONDITIONAL_GROUP_RULE) {
 	            enteringConditionalGroup = true;
 	          }
-	          // might be less variable
-	        } else if (!insideRule && parenLevel === 0 && variableOrRule.indexOf(':') !== -1) {
-	          insidePropertyValue = true;
-	          this.indent();
+
+	          // might be a non-nested at-rule
+	        } else if (parenLevel === 0 && !insidePropertyValue) {
+	          insideNonNestedAtRule = true;
 	        }
 	      }
 	    } else if (this._ch === '#' && this._input.peek() === '{') {
@@ -5537,6 +5591,9 @@ function requireBeautifier$1 () {
 	        this.outdent();
 	      }
 
+	      // non nested at rule becomes nested
+	      insideNonNestedAtRule = false;
+
 	      // when entering conditional groups, only rulesets are allowed
 	      if (enteringConditionalGroup) {
 	        enteringConditionalGroup = false;
@@ -5577,8 +5634,7 @@ function requireBeautifier$1 () {
 	      if (previous_ch === '{') {
 	        this._output.trim(true);
 	      }
-	      insideAtImport = false;
-	      insideAtExtend = false;
+
 	      if (insidePropertyValue) {
 	        this.outdent();
 	        insidePropertyValue = false;
@@ -5612,9 +5668,10 @@ function requireBeautifier$1 () {
 	        }
 	      }
 
-	      if ((insideRule || enteringConditionalGroup) && !(this._input.lookBack("&") || this.foundNestedPseudoClass()) && !this._input.lookBack("(") && !insideAtExtend && parenLevel === 0) {
+	      if ((insideRule || enteringConditionalGroup) && !(this._input.lookBack("&") || this.foundNestedPseudoClass()) && !this._input.lookBack("(") && !insideNonNestedAtRule && parenLevel === 0) {
 	        // 'property: value' delimiter
 	        // which could be in a conditional group query
+
 	        this.print_string(':');
 	        if (!insidePropertyValue) {
 	          insidePropertyValue = true;
@@ -5651,8 +5708,7 @@ function requireBeautifier$1 () {
 	          this.outdent();
 	          insidePropertyValue = false;
 	        }
-	        insideAtExtend = false;
-	        insideAtImport = false;
+	        insideNonNestedAtRule = false;
 	        this.print_string(this._ch);
 	        this.eatWhitespace(true);
 
@@ -5717,7 +5773,7 @@ function requireBeautifier$1 () {
 	    } else if (this._ch === ',') {
 	      this.print_string(this._ch);
 	      this.eatWhitespace(true);
-	      if (this._options.selector_separator_newline && (!insidePropertyValue || insideScssMap) && parenLevel === 0 && !insideAtImport && !insideAtExtend) {
+	      if (this._options.selector_separator_newline && (!insidePropertyValue || insideScssMap) && parenLevel === 0 && !insideNonNestedAtRule) {
 	        this._output.add_new_line();
 	      } else {
 	        this._output.space_before_token = true;
@@ -5775,7 +5831,7 @@ function requireBeautifier$1 () {
 var hasRequiredCss;
 
 function requireCss () {
-	if (hasRequiredCss) return cssExports;
+	if (hasRequiredCss) return css.exports;
 	hasRequiredCss = 1;
 
 	var Beautifier = requireBeautifier$1().Beautifier,
@@ -5787,17 +5843,13 @@ function requireCss () {
 	}
 
 	css.exports = css_beautify;
-	cssExports.defaultOptions = function() {
+	css.exports.defaultOptions = function() {
 	  return new Options();
 	};
-	return cssExports;
+	return css.exports;
 }
 
-var htmlExports = {};
-var html = {
-  get exports(){ return htmlExports; },
-  set exports(v){ htmlExports = v; },
-};
+var html = {exports: {}};
 
 var beautifier = {};
 
@@ -5826,6 +5878,7 @@ function requireOptions () {
 	  this.indent_handlebars = this._get_boolean('indent_handlebars', true);
 	  this.wrap_attributes = this._get_selection('wrap_attributes',
 	    ['auto', 'force', 'force-aligned', 'force-expand-multiline', 'aligned-multiple', 'preserve', 'preserve-aligned']);
+	  this.wrap_attributes_min_attrs = this._get_number('wrap_attributes_min_attrs', 2);
 	  this.wrap_attributes_indent_size = this._get_number('wrap_attributes_indent_size', this.indent_size);
 	  this.extra_liners = this._get_array('extra_liners', ['head', 'body', '/html']);
 
@@ -5843,6 +5896,7 @@ function requireOptions () {
 	    // obsolete inline tags
 	    'acronym', 'big', 'strike', 'tt'
 	  ]);
+	  this.inline_custom_elements = this._get_boolean('inline_custom_elements', true);
 	  this.void_elements = this._get_array('void_elements', [
 	    // HTLM void elements - aka self-closing tags - aka singletons
 	    // https://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements
@@ -6466,11 +6520,11 @@ function requireBeautifier () {
 	  while (raw_token.type !== TOKEN.EOF) {
 
 	    if (raw_token.type === TOKEN.TAG_OPEN || raw_token.type === TOKEN.COMMENT) {
-	      parser_token = this._handle_tag_open(printer, raw_token, last_tag_token, last_token);
+	      parser_token = this._handle_tag_open(printer, raw_token, last_tag_token, last_token, tokens);
 	      last_tag_token = parser_token;
 	    } else if ((raw_token.type === TOKEN.ATTRIBUTE || raw_token.type === TOKEN.EQUALS || raw_token.type === TOKEN.VALUE) ||
 	      (raw_token.type === TOKEN.TEXT && !last_tag_token.tag_complete)) {
-	      parser_token = this._handle_inside_tag(printer, raw_token, last_tag_token, tokens);
+	      parser_token = this._handle_inside_tag(printer, raw_token, last_tag_token, last_token);
 	    } else if (raw_token.type === TOKEN.TAG_CLOSE) {
 	      parser_token = this._handle_tag_close(printer, raw_token, last_tag_token);
 	    } else if (raw_token.type === TOKEN.TEXT) {
@@ -6527,7 +6581,7 @@ function requireBeautifier () {
 	  return parser_token;
 	};
 
-	Beautifier.prototype._handle_inside_tag = function(printer, raw_token, last_tag_token, tokens) {
+	Beautifier.prototype._handle_inside_tag = function(printer, raw_token, last_tag_token, last_token) {
 	  var wrapped = last_tag_token.has_wrapped_attrs;
 	  var parser_token = {
 	    text: raw_token.text,
@@ -6548,7 +6602,6 @@ function requireBeautifier () {
 	  } else {
 	    if (raw_token.type === TOKEN.ATTRIBUTE) {
 	      printer.set_space_before_token(true);
-	      last_tag_token.attr_count += 1;
 	    } else if (raw_token.type === TOKEN.EQUALS) { //no space before =
 	      printer.set_space_before_token(false);
 	    } else if (raw_token.type === TOKEN.VALUE && raw_token.previous.type === TOKEN.EQUALS) { //no space before value
@@ -6561,29 +6614,15 @@ function requireBeautifier () {
 	        wrapped = wrapped || raw_token.newlines !== 0;
 	      }
 
-
-	      if (this._is_wrap_attributes_force) {
-	        var force_attr_wrap = last_tag_token.attr_count > 1;
-	        if (this._is_wrap_attributes_force_expand_multiline && last_tag_token.attr_count === 1) {
-	          var is_only_attribute = true;
-	          var peek_index = 0;
-	          var peek_token;
-	          do {
-	            peek_token = tokens.peek(peek_index);
-	            if (peek_token.type === TOKEN.ATTRIBUTE) {
-	              is_only_attribute = false;
-	              break;
-	            }
-	            peek_index += 1;
-	          } while (peek_index < 4 && peek_token.type !== TOKEN.EOF && peek_token.type !== TOKEN.TAG_CLOSE);
-
-	          force_attr_wrap = !is_only_attribute;
-	        }
-
-	        if (force_attr_wrap) {
-	          printer.print_newline(false);
-	          wrapped = true;
-	        }
+	      // Wrap for 'force' options, and if the number of attributes is at least that specified in 'wrap_attributes_min_attrs':
+	      // 1. always wrap the second and beyond attributes
+	      // 2. wrap the first attribute only if 'force-expand-multiline' is specified
+	      if (this._is_wrap_attributes_force &&
+	        last_tag_token.attr_count >= this._options.wrap_attributes_min_attrs &&
+	        (last_token.type !== TOKEN.TAG_OPEN || // ie. second attribute and beyond
+	          this._is_wrap_attributes_force_expand_multiline)) {
+	        printer.print_newline(false);
+	        wrapped = true;
 	      }
 	    }
 	    printer.print_token(raw_token);
@@ -6712,12 +6751,12 @@ function requireBeautifier () {
 	  }
 	};
 
-	Beautifier.prototype._handle_tag_open = function(printer, raw_token, last_tag_token, last_token) {
+	Beautifier.prototype._handle_tag_open = function(printer, raw_token, last_tag_token, last_token, tokens) {
 	  var parser_token = this._get_tag_open_token(raw_token);
 
 	  if ((last_tag_token.is_unformatted || last_tag_token.is_content_unformatted) &&
 	    !last_tag_token.is_empty_element &&
-	    raw_token.type === TOKEN.TAG_OPEN && raw_token.text.indexOf('</') === 0) {
+	    raw_token.type === TOKEN.TAG_OPEN && !parser_token.is_start_tag) {
 	    // End element tags for unformatted or content_unformatted elements
 	    // are printed raw to keep any newlines inside them exactly the same.
 	    printer.add_raw_token(raw_token);
@@ -6731,6 +6770,19 @@ function requireBeautifier () {
 	    printer.print_token(raw_token);
 	  }
 
+	  // count the number of attributes
+	  if (parser_token.is_start_tag && this._is_wrap_attributes_force) {
+	    var peek_index = 0;
+	    var peek_token;
+	    do {
+	      peek_token = tokens.peek(peek_index);
+	      if (peek_token.type === TOKEN.ATTRIBUTE) {
+	        parser_token.attr_count += 1;
+	      }
+	      peek_index += 1;
+	    } while (peek_token.type !== TOKEN.EOF && peek_token.type !== TOKEN.TAG_CLOSE);
+	  }
+
 	  //indent attributes an auto, forced, aligned or forced-align line-wrap
 	  if (this._is_wrap_attributes_force_aligned || this._is_wrap_attributes_aligned_multiple || this._is_wrap_attributes_preserve_aligned) {
 	    parser_token.alignment_size = raw_token.text.length + 1;
@@ -6828,7 +6880,7 @@ function requireBeautifier () {
 
 	  parser_token.is_unformatted = !parser_token.tag_complete && in_array(parser_token.tag_check, this._options.unformatted);
 	  parser_token.is_content_unformatted = !parser_token.is_empty_element && in_array(parser_token.tag_check, this._options.content_unformatted);
-	  parser_token.is_inline_element = in_array(parser_token.tag_name, this._options.inline) || parser_token.tag_start_char === '{';
+	  parser_token.is_inline_element = in_array(parser_token.tag_name, this._options.inline) || (this._options.inline_custom_elements && parser_token.tag_name.includes("-")) || parser_token.tag_start_char === '{';
 
 	  return parser_token;
 	};
@@ -6933,7 +6985,7 @@ function requireBeautifier () {
 	};
 
 	//To be used for <p> tag special case:
-	var p_closers = ['address', 'article', 'aside', 'blockquote', 'details', 'div', 'dl', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hr', 'main', 'nav', 'ol', 'p', 'pre', 'section', 'table', 'ul'];
+	var p_closers = ['address', 'article', 'aside', 'blockquote', 'details', 'div', 'dl', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hr', 'main', 'menu', 'nav', 'ol', 'p', 'pre', 'section', 'table', 'ul'];
 	var p_parent_excludes = ['a', 'audio', 'del', 'ins', 'map', 'noscript', 'video'];
 
 	Beautifier.prototype._do_optional_end_element = function(parser_token) {
@@ -6956,7 +7008,7 @@ function requireBeautifier () {
 
 	  } else if (parser_token.tag_name === 'li') {
 	    // An li element’s end tag may be omitted if the li element is immediately followed by another li element or if there is no more content in the parent element.
-	    result = result || this._tag_stack.try_pop('li', ['ol', 'ul']);
+	    result = result || this._tag_stack.try_pop('li', ['ol', 'ul', 'menu']);
 
 	  } else if (parser_token.tag_name === 'dd' || parser_token.tag_name === 'dt') {
 	    // A dd element’s end tag may be omitted if the dd element is immediately followed by another dd element or a dt element, or if there is no more content in the parent element.
@@ -7052,7 +7104,7 @@ function requireBeautifier () {
 var hasRequiredHtml;
 
 function requireHtml () {
-	if (hasRequiredHtml) return htmlExports;
+	if (hasRequiredHtml) return html.exports;
 	hasRequiredHtml = 1;
 
 	var Beautifier = requireBeautifier().Beautifier,
@@ -7064,10 +7116,10 @@ function requireHtml () {
 	}
 
 	html.exports = style_html;
-	htmlExports.defaultOptions = function() {
+	html.exports.defaultOptions = function() {
 	  return new Options();
 	};
-	return htmlExports;
+	return html.exports;
 }
 
 /*jshint node:true */
@@ -7144,10 +7196,11 @@ function requireSrc () {
 	    mod.exports = get_beautify(beautifier, beautifier, beautifier);
 
 	  })(module);
-	}
+	} 
 } (js));
 
-var beautify = jsExports;
+var jsExports = js.exports;
+var beautify = /*@__PURE__*/getDefaultExportFromCjs(jsExports);
 
 var BaseWrapper = /** @class */ (function () {
     function BaseWrapper(element) {
@@ -7232,7 +7285,9 @@ var BaseWrapper = /** @class */ (function () {
         }
         if (matches(currentComponent.vnode, selector) &&
             this.element.contains(currentComponent.vnode.el)) {
-            return createVueWrapper(null, currentComponent.proxy);
+            return createVueWrapper(null, currentComponent.subTree.component
+                ? currentComponent.subTree.component.proxy
+                : currentComponent.proxy);
         }
         var result = this.findAllComponents(selector)[0];
         return result !== null && result !== void 0 ? result : createWrapperError('VueWrapper');
@@ -7258,7 +7313,9 @@ var BaseWrapper = /** @class */ (function () {
             return beautify.html(node, {
                 unformatted: ['code', 'pre', 'em', 'strong', 'span'],
                 indent_inner_html: true,
-                indent_size: 2
+                indent_size: 2,
+                inline_custom_elements: false
+                // TODO the cast can be removed when @types/js-beautify will be up-to-date
             });
         })
             .join('\n');
@@ -7283,7 +7340,7 @@ var BaseWrapper = /** @class */ (function () {
         return key ? attributeMap[key] : attributeMap;
     };
     BaseWrapper.prototype.text = function () {
-        return textContent(this.element);
+        return this.getRootNodes().map(textContent).join('');
     };
     BaseWrapper.prototype.exists = function () {
         return true;
@@ -7389,10 +7446,10 @@ var DOMWrapper = /** @class */ (function (_super) {
         var results = _super.prototype.findAllComponents.call(this, selector);
         return results.filter(function (r) { return _this.element.contains(r.element); });
     };
-    DOMWrapper.prototype.setChecked = function (checked) {
-        if (checked === void 0) { checked = true; }
-        return __awaiter(this, void 0, void 0, function () {
+    DOMWrapper.prototype.setChecked = function () {
+        return __awaiter(this, arguments, void 0, function (checked) {
             var element, type;
+            if (checked === void 0) { checked = true; }
             return __generator(this, function (_a) {
                 element = this.element;
                 type = this.attributes().type;
@@ -7407,6 +7464,7 @@ var DOMWrapper = /** @class */ (function (_super) {
                     return [2 /*return*/];
                 }
                 element.checked = checked;
+                this.trigger('input');
                 return [2 /*return*/, this.trigger('change')];
             });
         });
@@ -7436,6 +7494,7 @@ var DOMWrapper = /** @class */ (function (_super) {
             else {
                 element.value = value;
             }
+            this.trigger('input');
             return this.trigger('change');
         }
         else if (tagName === 'INPUT' || tagName === 'TEXTAREA') {
@@ -7460,7 +7519,9 @@ var DOMWrapper = /** @class */ (function (_super) {
         if (parentElement.tagName === 'OPTGROUP') {
             parentElement = parentElement.parentElement;
         }
-        return new DOMWrapper(parentElement).trigger('change');
+        var parentWrapper = new DOMWrapper(parentElement);
+        parentWrapper.trigger('input');
+        return parentWrapper.trigger('change');
     };
     return DOMWrapper;
 }(BaseWrapper));
@@ -7513,9 +7574,30 @@ function emitted(vm, eventName) {
     return vmEvents;
 }
 var attachEmitListener = function () {
-    // use devtools to capture this "emit"
-    Vue.setDevtoolsHook(createDevTools(), {});
+    var target = getGlobalThis();
+    // override emit to capture events when devtools is defined
+    if (target.__VUE_DEVTOOLS_GLOBAL_HOOK__) {
+        var _emit_1 = target.__VUE_DEVTOOLS_GLOBAL_HOOK__.emit;
+        target.__VUE_DEVTOOLS_GLOBAL_HOOK__.emit = function (eventType) {
+            var payload = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                payload[_i - 1] = arguments[_i];
+            }
+            _emit_1.call.apply(_emit_1, __spreadArray([target.__VUE_DEVTOOLS_GLOBAL_HOOK__, eventType], payload, false));
+            captureDevtoolsVueComponentEmitEvent(eventType, payload);
+        };
+    }
+    else {
+        // use devtools to capture this "emit"
+        Vue.setDevtoolsHook(createDevTools(), {});
+    }
 };
+function captureDevtoolsVueComponentEmitEvent(eventType, payload) {
+    if (eventType === "component:emit" /* DevtoolsHooks.COMPONENT_EMIT */) {
+        payload[0]; var componentVM = payload[1], event_1 = payload[2], eventArgs = payload[3];
+        recordEvent(componentVM, event_1, eventArgs);
+    }
+}
 // devtools hook only catches Vue component custom events
 function createDevTools() {
     return {
@@ -7524,10 +7606,7 @@ function createDevTools() {
             for (var _i = 1; _i < arguments.length; _i++) {
                 payload[_i - 1] = arguments[_i];
             }
-            if (eventType !== "component:emit" /* DevtoolsHooks.COMPONENT_EMIT */)
-                return;
-            var componentVM = payload[1], event = payload[2], eventArgs = payload[3];
-            recordEvent(componentVM, event, eventArgs);
+            captureDevtoolsVueComponentEmitEvent(eventType, payload);
         }
     };
 }
@@ -7559,9 +7638,18 @@ var removeEventHistory = function (vm) {
 function createVMProxy(vm, setupState) {
     return new Proxy(vm, {
         get: function (vm, key, receiver) {
-            if (key in setupState) {
+            if (vm.$.exposed && vm.$.exposeProxy && key in vm.$.exposeProxy) {
+                // first if the key is exposed
+                return Reflect.get(vm.$.exposeProxy, key, receiver);
+            }
+            else if (key in setupState) {
+                // second if the key is acccessible from the setupState
                 return Reflect.get(setupState, key, receiver);
             }
+            else if (key in vm.$.appContext.config.globalProperties) {
+                // third if the key is a global property
+                return Reflect.get(vm.$.appContext.config.globalProperties, key, receiver);
+            }
             else {
                 // vm.$.ctx is the internal context of the vm
                 // with all variables, methods and props
@@ -7780,30 +7868,6 @@ var VueWrapper = /** @class */ (function (_super) {
 }(BaseWrapper));
 registerFactory(WrapperType.VueWrapper, function (app, vm, setProps) { return new VueWrapper(app, vm, setProps); });
 
-var isEnabled = false;
-var wrapperInstances = [];
-function disableAutoUnmount() {
-    isEnabled = false;
-    wrapperInstances.length = 0;
-}
-function enableAutoUnmount(hook) {
-    if (isEnabled) {
-        throw new Error('enableAutoUnmount cannot be called more than once');
-    }
-    isEnabled = true;
-    hook(function () {
-        wrapperInstances.forEach(function (wrapper) {
-            wrapper.unmount();
-        });
-        wrapperInstances.length = 0;
-    });
-}
-function trackInstance(wrapper) {
-    if (!isEnabled)
-        return;
-    wrapperInstances.push(wrapper);
-}
-
 function processSlot(source, Vue$1) {
     if (source === void 0) { source = ''; }
     if (Vue$1 === void 0) { Vue$1 = Vue__namespace; }
@@ -7837,24 +7901,30 @@ function processSlot(source, Vue$1) {
 
 var isTeleport = function (type) { return type.__isTeleport; };
 var isKeepAlive = function (type) { return type.__isKeepAlive; };
+var isRootComponent = function (rootComponents, type, instance) {
+    return !!(!instance ||
+        // Don't stub mounted component on root level
+        (rootComponents.component === type && !(instance === null || instance === void 0 ? void 0 : instance.parent)) ||
+        // Don't stub component with compat wrapper
+        (rootComponents.functional && rootComponents.functional === type));
+};
 var createVNodeTransformer = function (_a) {
-    var transformers = _a.transformers;
+    var rootComponents = _a.rootComponents, transformers = _a.transformers;
     var transformationCache = new WeakMap();
     return function (args, instance) {
         var originalType = args[0], props = args[1], children = args[2], restVNodeArgs = args.slice(3);
         if (!isComponent(originalType)) {
             return __spreadArray([originalType, props, children], restVNodeArgs, true);
         }
+        var componentType = originalType;
         var cachedTransformation = transformationCache.get(originalType);
-        if (cachedTransformation) {
-            // https://github.com/vuejs/test-utils/issues/1829 & https://github.com/vuejs/test-utils/issues/1888
-            // Teleport/KeepAlive should return child nodes as a function
-            if (isTeleport(originalType) || isKeepAlive(originalType)) {
-                return __spreadArray([cachedTransformation, props, function () { return children; }], restVNodeArgs, true);
-            }
+        if (cachedTransformation &&
+            // Don't use cache for root component, as it could use stubbed recursive component
+            !isRootComponent(rootComponents, componentType, instance) &&
+            !isTeleport(originalType) &&
+            !isKeepAlive(originalType)) {
             return __spreadArray([cachedTransformation, props, children], restVNodeArgs, true);
         }
-        var componentType = originalType;
         var transformedType = transformers.reduce(function (type, transformer) { return transformer(type, instance); }, componentType);
         if (originalType !== transformedType) {
             transformationCache.set(originalType, transformedType);
@@ -7876,14 +7946,40 @@ var normalizeStubProps = function (props) {
         var _a, _b, _c;
         var _d;
         if (typeof $props[key] === 'symbol') {
-            return __assign(__assign({}, acc), (_a = {}, _a[key] = (_d = $props[key]) === null || _d === void 0 ? void 0 : _d.toString(), _a));
+            return __assign(__assign({}, acc), (_a = {}, _a[key] = [(_d = $props[key]) === null || _d === void 0 ? void 0 : _d.toString()], _a));
         }
         if (typeof $props[key] === 'function') {
-            return __assign(__assign({}, acc), (_b = {}, _b[key] = '[Function]', _b));
+            return __assign(__assign({}, acc), (_b = {}, _b[key] = ['[Function]'], _b));
         }
         return __assign(__assign({}, acc), (_c = {}, _c[key] = $props[key], _c));
     }, {});
 };
+var clearAndUpper = function (text) { return text.replace(/-/, '').toUpperCase(); };
+var kebabToPascalCase = function (tag) {
+    return tag.replace(/(^\w|-\w)/g, clearAndUpper);
+};
+var DEFAULT_STUBS = {
+    teleport: isTeleport,
+    'keep-alive': isKeepAlive,
+    transition: function (type) { return type === Vue.Transition || type === Vue.BaseTransition; },
+    'transition-group': function (type) { return type === Vue.TransitionGroup; }
+};
+var createDefaultStub = function (kebabTag, predicate, type, stubs) {
+    var pascalTag = kebabToPascalCase(kebabTag);
+    if (predicate(type) && (pascalTag in stubs || kebabTag in stubs)) {
+        if (kebabTag in stubs && stubs[kebabTag] === false)
+            return type;
+        if (pascalTag in stubs && stubs[pascalTag] === false)
+            return type;
+        if (stubs[kebabTag] === true || stubs[pascalTag] === true) {
+            return createStub({
+                name: kebabTag,
+                type: type,
+                renderStubDefaultSlot: true
+            });
+        }
+    }
+};
 var createStub = function (_a) {
     var name = _a.name, type = _a.type, renderStubDefaultSlot = _a.renderStubDefaultSlot;
     var anonName = 'anonymous-stub';
@@ -7891,7 +7987,7 @@ var createStub = function (_a) {
     var componentOptions = type
         ? unwrapLegacyVueExtendComponent(type) || {}
         : {};
-    return Vue.defineComponent({
+    var stub = Vue.defineComponent({
         name: name || anonName,
         props: componentOptions.props || {},
         // fix #1550 - respect old-style v-model for shallow mounted components with @vue/compat
@@ -7909,10 +8005,26 @@ var createStub = function (_a) {
                 // Also having function text as attribute is useless and annoying so
                 // we replace it with "[Function]""
                 var stubProps = normalizeStubProps(props);
-                return Vue.h(tag, stubProps, renderStubDefaultSlot ? slots : undefined);
+                // if renderStubDefaultSlot is true, we render the default slot
+                if (renderStubDefaultSlot && slots.default) {
+                    // we explicitly call the default slot with an empty object
+                    // so scope slots destructuring works
+                    return Vue.h(tag, stubProps, slots.default({}));
+                }
+                return Vue.h(tag, stubProps);
             };
         }
     });
+    var asyncLoader = type.__asyncLoader;
+    if (asyncLoader) {
+        asyncLoader().then(function () {
+            registerStub({
+                source: type.__asyncResolved,
+                stub: stub
+            });
+        });
+    }
+    return stub;
 };
 var resolveComponentStubByName = function (componentName, stubs) {
     for (var _i = 0, _a = Object.entries(stubs); _i < _a.length; _i++) {
@@ -7926,56 +8038,14 @@ function createStubComponentsTransformer(_a) {
     var rootComponents = _a.rootComponents, _b = _a.stubs, stubs = _b === void 0 ? {} : _b, _c = _a.shallow, shallow = _c === void 0 ? false : _c, _d = _a.renderStubDefaultSlot, renderStubDefaultSlot = _d === void 0 ? false : _d;
     return function componentsTransformer(type, instance) {
         var _a, _b, _c;
-        // stub teleport by default via config.global.stubs
-        if (isTeleport(type) && 'teleport' in stubs) {
-            if (stubs.teleport === false)
-                return type;
-            return createStub({
-                name: 'teleport',
-                type: type,
-                renderStubDefaultSlot: true
-            });
-        }
-        // stub keep-alive/KeepAlive by default via config.global.stubs
-        if (isKeepAlive(type) && ('keep-alive' in stubs || 'KeepAlive' in stubs)) {
-            if ('keep-alive' in stubs && stubs['keep-alive'] === false)
-                return type;
-            if ('KeepAlive' in stubs && stubs['KeepAlive'] === false)
-                return type;
-            return createStub({
-                name: 'keep-alive',
-                type: type,
-                renderStubDefaultSlot: true
-            });
-        }
-        // stub transition by default via config.global.stubs
-        if ((type === Vue.Transition || type === Vue.BaseTransition) &&
-            'transition' in stubs) {
-            if (stubs.transition === false)
-                return type;
-            return createStub({
-                name: 'transition',
-                type: type,
-                renderStubDefaultSlot: true
-            });
+        for (var tag in DEFAULT_STUBS) {
+            var predicate = DEFAULT_STUBS[tag];
+            var defaultStub = createDefaultStub(tag, predicate, type, stubs);
+            if (defaultStub)
+                return defaultStub;
         }
-        // stub transition-group by default via config.global.stubs
-        if (type === Vue.TransitionGroup && 'transition-group' in stubs) {
-            if (stubs['transition-group'] === false)
-                return type;
-            return createStub({
-                name: 'transition-group',
-                type: type,
-                renderStubDefaultSlot: true
-            });
-        }
-        if (
-        // Don't stub VTU_ROOT component
-        !instance ||
-            // Don't stub mounted component on root level
-            (rootComponents.component === type && !(instance === null || instance === void 0 ? void 0 : instance.parent)) ||
-            // Don't stub component with compat wrapper
-            (rootComponents.functional && rootComponents.functional === type)) {
+        // Don't stub root components
+        if (isRootComponent(rootComponents, type, instance)) {
             return type;
         }
         var registeredName = getComponentRegisteredName(instance, type);
@@ -8028,7 +8098,8 @@ function createStubComponentsTransformer(_a) {
             var stubName = name || registeredName || componentName;
             return ((_c = (_b = (_a = config.plugins).createStubs) === null || _b === void 0 ? void 0 : _b.call(_a, {
                 name: stubName,
-                component: type
+                component: type,
+                registerStub: registerStub
             })) !== null && _c !== void 0 ? _c : createStub({
                 name: stubName,
                 type: type,
@@ -8063,6 +8134,38 @@ function createStubDirectivesTransformer(_a) {
     };
 }
 
+/**
+ * Implementation details of isDeepRef to avoid circular dependencies.
+ * It keeps track of visited objects to avoid infinite recursion.
+ *
+ * @param r The value to check for a Ref.
+ * @param visitedObjects a weak map to keep track of visited objects and avoid infinite recursion
+ * @returns returns true if the value is a Ref, false otherwise
+ */
+var deeplyCheckForRef = function (r, visitedObjects) {
+    if (Vue.isRef(r))
+        return true;
+    if (!isObject(r))
+        return false;
+    if (visitedObjects.has(r))
+        return false;
+    visitedObjects.set(r, true);
+    return Object.values(r).some(function (val) { return deeplyCheckForRef(val, visitedObjects); });
+};
+/**
+ * Checks if the given value is a DeepRef.
+ *
+ * For both arrays and objects, it will recursively check
+ * if any of their values is a Ref.
+ *
+ * @param {DeepRef<T> | unknown} r - The value to check.
+ * @returns {boolean} Returns true if the value is a DeepRef, false otherwise.
+ */
+var isDeepRef = function (r) {
+    var visitedObjects = new WeakMap();
+    return deeplyCheckForRef(r, visitedObjects);
+};
+
 var MOUNT_OPTIONS = [
     'attachTo',
     'attrs',
@@ -8120,20 +8223,6 @@ function createInstance(inputComponent, options) {
     // We've just replaced our component with its copy
     // Let's register it as a stub so user can find it
     registerStub({ source: originalComponent, stub: component });
-    var el = document.createElement('div');
-    if (options === null || options === void 0 ? void 0 : options.attachTo) {
-        var to = void 0;
-        if (typeof options.attachTo === 'string') {
-            to = document.querySelector(options.attachTo);
-            if (!to) {
-                throw new Error("Unable to find the element matching the selector ".concat(options.attachTo, " given as the `attachTo` option"));
-            }
-        }
-        else {
-            to = options.attachTo;
-        }
-        to.appendChild(el);
-    }
     function slotToFunction(slot) {
         switch (typeof slot) {
             case 'function':
@@ -8178,7 +8267,7 @@ function createInstance(inputComponent, options) {
     var props = Vue.reactive({});
     Object.entries(__assign(__assign(__assign(__assign({}, options === null || options === void 0 ? void 0 : options.attrs), options === null || options === void 0 ? void 0 : options.propsData), options === null || options === void 0 ? void 0 : options.props), { ref: MOUNT_COMPONENT_REF })).forEach(function (_a) {
         var k = _a[0], v = _a[1];
-        if (Vue.isRef(v)) {
+        if (isDeepRef(v)) {
             refs[k] = v;
         }
         else {
@@ -8210,7 +8299,7 @@ function createInstance(inputComponent, options) {
     attachEmitListener();
     // global mocks mixin
     if (global === null || global === void 0 ? void 0 : global.mocks) {
-        var mixin = Vue.defineComponent({
+        var mixin = {
             beforeCreate: function () {
                 // we need to differentiate components that are or not not `script setup`
                 // otherwise we run into a proxy set error
@@ -8246,7 +8335,7 @@ function createInstance(inputComponent, options) {
                     }
                 }
             }
-        });
+        };
         app.mixin(mixin);
     }
     // AppConfig
@@ -8258,10 +8347,18 @@ function createInstance(inputComponent, options) {
                 : v;
         }
     }
+    // provide any values passed via provides mounting option
+    if (global.provide) {
+        for (var _c = 0, _d = Reflect.ownKeys(global.provide); _c < _d.length; _c++) {
+            var key = _d[_c];
+            // @ts-ignore: https://github.com/microsoft/TypeScript/issues/1863
+            app.provide(key, global.provide[key]);
+        }
+    }
     // use and plugins from mounting options
     if (global.plugins) {
-        for (var _c = 0, _d = global.plugins; _c < _d.length; _c++) {
-            var plugin = _d[_c];
+        for (var _e = 0, _f = global.plugins; _e < _f.length; _e++) {
+            var plugin = _f[_e];
             if (Array.isArray(plugin)) {
                 app.use.apply(app, __spreadArray([plugin[0]], plugin.slice(1), false));
                 continue;
@@ -8271,14 +8368,14 @@ function createInstance(inputComponent, options) {
     }
     // use any mixins from mounting options
     if (global.mixins) {
-        for (var _e = 0, _f = global.mixins; _e < _f.length; _e++) {
-            var mixin = _f[_e];
+        for (var _g = 0, _h = global.mixins; _g < _h.length; _g++) {
+            var mixin = _h[_g];
             app.mixin(mixin);
         }
     }
     if (global.components) {
-        for (var _g = 0, _h = Object.keys(global.components); _g < _h.length; _g++) {
-            var key = _h[_g];
+        for (var _j = 0, _k = Object.keys(global.components); _j < _k.length; _j++) {
+            var key = _k[_j];
             // avoid registering components that are stubbed twice
             if (!(key in global.stubs)) {
                 app.component(key, global.components[key]);
@@ -8286,23 +8383,16 @@ function createInstance(inputComponent, options) {
         }
     }
     if (global.directives) {
-        for (var _j = 0, _k = Object.keys(global.directives); _j < _k.length; _j++) {
-            var key = _k[_j];
-            app.directive(key, global.directives[key]);
-        }
-    }
-    // provide any values passed via provides mounting option
-    if (global.provide) {
-        for (var _l = 0, _m = Reflect.ownKeys(global.provide); _l < _m.length; _l++) {
+        for (var _l = 0, _m = Object.keys(global.directives); _l < _m.length; _l++) {
             var key = _m[_l];
-            // @ts-ignore: https://github.com/microsoft/TypeScript/issues/1863
-            app.provide(key, global.provide[key]);
+            app.directive(key, global.directives[key]);
         }
     }
     // stubs
     // even if we are using `mount`, we will still
     // stub out Transition and Transition Group by default.
     Vue.transformVNodeArgs(createVNodeTransformer({
+        rootComponents: rootComponents,
         transformers: [
             createStubComponentsTransformer({
                 rootComponents: rootComponents,
@@ -8335,15 +8425,38 @@ function createInstance(inputComponent, options) {
     }
     return {
         app: app,
-        el: el,
         props: props,
         componentRef: componentRef
     };
 }
 
+var isEnabled = false;
+var wrapperInstances = [];
+function disableAutoUnmount() {
+    isEnabled = false;
+    wrapperInstances.length = 0;
+}
+function enableAutoUnmount(hook) {
+    if (isEnabled) {
+        throw new Error('enableAutoUnmount cannot be called more than once');
+    }
+    isEnabled = true;
+    hook(function () {
+        wrapperInstances.forEach(function (wrapper) {
+            wrapper.unmount();
+        });
+        wrapperInstances.length = 0;
+    });
+}
+function trackInstance(wrapper) {
+    if (!isEnabled)
+        return;
+    wrapperInstances.push(wrapper);
+}
+
 // implementation
 function mount$1(inputComponent, options) {
-    var _a = createInstance(inputComponent, options), app = _a.app, props = _a.props, el = _a.el, componentRef = _a.componentRef;
+    var _a = createInstance(inputComponent, options), app = _a.app, props = _a.props, componentRef = _a.componentRef;
     var setProps = function (newProps) {
         for (var _i = 0, _a = Object.entries(newProps); _i < _a.length; _i++) {
             var _b = _a[_i], k = _b[0], v = _b[1];
@@ -8353,15 +8466,30 @@ function mount$1(inputComponent, options) {
     };
     // Workaround for https://github.com/vuejs/core/issues/7020
     var originalErrorHandler = app.config.errorHandler;
-    var errorOnMount = null;
+    var errorsOnMount = [];
     app.config.errorHandler = function (err, instance, info) {
-        errorOnMount = err;
+        errorsOnMount.push(err);
         return originalErrorHandler === null || originalErrorHandler === void 0 ? void 0 : originalErrorHandler(err, instance, info);
     };
     // mount the app!
+    var el = document.createElement('div');
+    if (options === null || options === void 0 ? void 0 : options.attachTo) {
+        var to = void 0;
+        if (typeof options.attachTo === 'string') {
+            to = document.querySelector(options.attachTo);
+            if (!to) {
+                throw new Error("Unable to find the element matching the selector ".concat(options.attachTo, " given as the `attachTo` option"));
+            }
+        }
+        else {
+            to = options.attachTo;
+        }
+        to.appendChild(el);
+    }
     var vm = app.mount(el);
-    if (errorOnMount) {
-        throw errorOnMount;
+    if (errorsOnMount.length) {
+        // If several errors are thrown during mount, then throw the first one
+        throw errorsOnMount[0];
     }
     app.config.errorHandler = originalErrorHandler;
     var appRef = componentRef.value;
@@ -8381,6 +8509,9 @@ var shallowMount$1 = function (component, options) {
 };
 
 function renderToString(component, options) {
+    if (options === null || options === void 0 ? void 0 : options.attachTo) {
+        console.warn('attachTo option is not available for renderToString');
+    }
     var app = createInstance(component, options).app;
     return serverRenderer.renderToString(app);
 }
@@ -8489,7 +8620,6 @@ const cleanup = () => {
  * })
  */
 function mount(componentOptions, options = {}) {
-    checkForRemovedStyleOptions(options);
     // Remove last mounted component if cy.mount is called more than once in a test
     cleanup();
     // then wait for cypress to load
@@ -8526,16 +8656,7 @@ function mount(componentOptions, options = {}) {
                 wrapper,
                 component: wrapper.vm,
             };
-            return new Proxy(Object.create(returnVal), {
-                get(obj, prop) {
-                    // throw an error if it looks like the caller is trying to call a method on the VueWrapper that was originally returned
-                    if (Reflect.get(wrapper, prop)) {
-                        // @ts-expect-error - internal API
-                        Cypress.utils.throwErrByPath('mount.vue_yielded_value');
-                    }
-                    return Reflect.get(obj, prop);
-                },
-            });
+            return returnVal;
         });
     });
 }
@@ -8559,21 +8680,6 @@ function getComponentDisplayName(componentOptions) {
     }
     return DEFAULT_COMP_NAME;
 }
-/**
- * Helper function for mounting a component quickly in test hooks.
- * @example
- *  import {mountCallback} from '@cypress/vue'
- *  beforeEach(mountVue(component, options))
- *
- * Removed as of Cypress 11.0.0.
- * @see https://on.cypress.io/migration-11-0-0-component-testing-updates
- */
-function mountCallback(component, options = {}) {
-    return () => {
-        // @ts-expect-error - undocumented API
-        Cypress.utils.throwErrByPath('mount.mount_callback');
-    };
-}
 // Side effects from "import { mount } from '@cypress/<my-framework>'" are annoying, we should avoid doing this
 // by creating an explicit function/import that the user can register in their 'component.js' support file,
 // such as:
@@ -8586,4 +8692,3 @@ setupHooks(cleanup);
 
 exports.VueTestUtils = VueTestUtils;
 exports.mount = mount;
-exports.mountCallback = mountCallback;