@vue/compiler-sfc 3.5.39 → 3.5.41

package/dist/compiler-sfc.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.39
+* @vue/compiler-sfc v3.5.41
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -216,8 +216,11 @@ const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
 
 const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
 const isBooleanAttr = /* @__PURE__ */ makeMap(
-  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
 );
+function includeBooleanAttr(value) {
+  return !!value || value === "";
+}
 const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
 const attrValidationCache = {};
 function isSSRSafeAttrName(name) {
@@ -4764,6 +4767,7 @@ function requireLib () {
 	  SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
 	  SourcePhaseImportRequiresDefault: 'Only `import source x from "./module"` is valid.',
 	  StaticPrototype: "Classes may not have static property named prototype.",
+	  SuperCallNotNewExpression: "Cannot use new with super(...).",
 	  SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
 	  SuperPrivateField: "Private fields can't be accessed on super.",
 	  TrailingDecorator: "Decorators must be attached to a class element.",
@@ -4793,7 +4797,6 @@ function requireLib () {
 	  UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
 	  UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.",
 	  UnexpectedVoidPattern: "Unexpected void binding.",
-	  UnsupportedBind: "Binding should be performed on object property.",
 	  UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
 	  UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
 	  UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
@@ -4861,6 +4864,10 @@ function requireLib () {
 	  PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
 	  PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
 	});
+	var FunctionBindErrors = {
+	  UnsupportedBind: "Binding should be performed on object property.",
+	  UnsupportedBindRHS: "The right-hand side of binding can not be super or import."
+	};
 	const _excluded = ["message"];
 	function defineHidden(obj, key, value) {
 	  Object.defineProperty(obj, key, {
@@ -4951,7 +4958,7 @@ function requireLib () {
 	  }
 	  return ParseErrorConstructors;
 	}
-	const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(ParseExpressionErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
+	const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(ParseExpressionErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors), ParseErrorEnum`functionBind`(FunctionBindErrors));
 	function createDefaultOptions() {
 	  return {
 	    sourceType: "script",
@@ -15644,7 +15651,7 @@ function requireLib () {
 	      type
 	    } = this.state;
 	    if (!noCalls && type === 15) {
-	      return this.parseBind(base, startLoc, noCalls, state);
+	      return this.parseBind(base, startLoc, state);
 	    } else if (tokenIsTemplate(type)) {
 	      return this.parseTaggedTemplateExpression(base, startLoc, state);
 	    }
@@ -15697,13 +15704,18 @@ function requireLib () {
 	      return this.finishNode(node, "MemberExpression");
 	    }
 	  }
-	  parseBind(base, startLoc, noCalls, state) {
+	  parseBind(base, startLoc, state) {
 	    const node = this.startNodeAt(startLoc);
 	    node.object = base;
 	    this.next();
-	    node.callee = this.parseNoCallExpr();
+	    const isImport = this.match(83);
+	    const callee = this.parseNoCallExpr();
+	    if (callee.type === "Super" || isImport && callee.type === "ImportExpression" || callee.type === "Import") {
+	      throw this.raise(Errors.UnsupportedBindRHS, callee);
+	    }
+	    node.callee = callee;
 	    state.stop = true;
-	    return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, noCalls);
+	    return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, false);
 	  }
 	  parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) {
 	    const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
@@ -16299,9 +16311,12 @@ function requireLib () {
 	    const isImport = this.match(83);
 	    const callee = this.parseNoCallExpr();
 	    node.callee = callee;
-	    if (isImport && (callee.type === "Import" || callee.type === "ImportExpression")) {
+	    if (isImport && callee.type === "ImportExpression" || callee.type === "Import") {
 	      this.raise(Errors.ImportCallNotNewExpression, callee);
 	    }
+	    if (callee.type === "Super") {
+	      this.raise(Errors.SuperCallNotNewExpression, callee);
+	    }
 	  }
 	  parseTemplateElement(isTagged) {
 	    const {
@@ -19931,6 +19946,9 @@ function getUnnormalizedProps(props, callPath = []) {
   return [props, callPath];
 }
 function injectProp(node, prop, context) {
+  if (node.type !== 13 && injectSlotKey(node, prop)) {
+    return;
+  }
   let propsWithInjection;
   let props = node.type === 13 ? node.props : node.arguments[2];
   let callPath = [];
@@ -19988,6 +20006,24 @@ function injectProp(node, prop, context) {
     }
   }
 }
+function injectSlotKey(node, prop) {
+  var _a, _b, _c;
+  if (prop.key.type !== 4 || prop.key.content !== "key") {
+    return false;
+  }
+  const props = node.arguments[2];
+  if (props && !isString$1(props)) {
+    const [unnormalizedProps] = getUnnormalizedProps(props);
+    if (unnormalizedProps && !isString$1(unnormalizedProps) && unnormalizedProps.type === 15 && hasProp(prop, unnormalizedProps)) {
+      return true;
+    }
+  }
+  (_a = node.arguments)[2] || (_a[2] = "{}");
+  (_b = node.arguments)[3] || (_b[3] = "undefined");
+  (_c = node.arguments)[4] || (_c[4] = "undefined");
+  node.arguments[5] = prop.value;
+  return true;
+}
 function hasProp(prop, props) {
   let result = false;
   if (prop.key.type === 4) {
@@ -26037,6 +26073,7 @@ const transformFor = createStructuralDirectiveTransform(
         node.loc
       );
       return () => {
+        var _a;
         let childBlock;
         const { children } = forNode;
         if (isTemplate) {
@@ -26080,7 +26117,8 @@ const transformFor = createStructuralDirectiveTransform(
           if (isTemplate && keyProperty) {
             injectProp(childBlock, keyProperty, context);
           }
-          if (childBlock.isBlock !== !isStableFragment) {
+          const shouldUseBlock = !isStableFragment || childBlock.isBlockRequired === true;
+          if (childBlock.isBlock !== shouldUseBlock) {
             if (childBlock.isBlock) {
               removeHelper(OPEN_BLOCK);
               removeHelper(
@@ -26092,12 +26130,15 @@ const transformFor = createStructuralDirectiveTransform(
               );
             }
           }
-          childBlock.isBlock = !isStableFragment;
+          childBlock.isBlock = shouldUseBlock;
           if (childBlock.isBlock) {
             helper(OPEN_BLOCK);
             helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
           } else {
             helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
+            if (childBlock.needsPatch) {
+              childBlock.patchFlag = ((_a = childBlock.patchFlag) != null ? _a : 0) | 512;
+            }
           }
         }
         if (memo) {
@@ -26516,6 +26557,8 @@ const transformElement = (node, context) => {
     let vnodeDynamicProps;
     let dynamicPropNames;
     let vnodeDirectives;
+    let needsPatch = false;
+    let isBlockRequired = false;
     let shouldUseBlock = (
       // dynamic component may resolve to plain elements
       isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block
@@ -26535,6 +26578,8 @@ const transformElement = (node, context) => {
       vnodeProps = propsBuildResult.props;
       patchFlag = propsBuildResult.patchFlag;
       dynamicPropNames = propsBuildResult.dynamicPropNames;
+      needsPatch = propsBuildResult.needsPatch;
+      isBlockRequired = propsBuildResult.isBlockRequired;
       const directives = propsBuildResult.directives;
       vnodeDirectives = directives && directives.length ? createArrayExpression(
         directives.map((dir) => buildDirectiveArgs(dir, context))
@@ -26585,7 +26630,7 @@ const transformElement = (node, context) => {
     if (dynamicPropNames && dynamicPropNames.length) {
       vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
     }
-    node.codegenNode = createVNodeCall(
+    const vnodeCall = node.codegenNode = createVNodeCall(
       context,
       vnodeTag,
       vnodeProps,
@@ -26598,6 +26643,13 @@ const transformElement = (node, context) => {
       isComponent,
       node.loc
     );
+    needsPatch = needsPatch && (patchFlag === 0 || patchFlag === 32);
+    if (needsPatch) {
+      vnodeCall.needsPatch = true;
+    }
+    if (isBlockRequired) {
+      vnodeCall.isBlockRequired = true;
+    }
   };
 };
 function resolveComponentType(node, context, ssr = false) {
@@ -26704,6 +26756,7 @@ function buildProps(node, context, props = node.props, isComponent, isDynamicCom
   const runtimeDirectives = [];
   const hasChildren = children.length > 0;
   let shouldUseBlock = false;
+  let isBlockRequired = false;
   let patchFlag = 0;
   let hasRef = false;
   let hasClassBinding = false;
@@ -26745,19 +26798,20 @@ function buildProps(node, context, props = node.props, isComponent, isDynamicCom
       if (isEventHandler && isReservedProp(name)) {
         hasVnodeHook = true;
       }
+      if (name === "ref") {
+        hasRef = true;
+      }
       if (isEventHandler && value.type === 14) {
         value = value.arguments[0];
       }
       if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
         return;
       }
-      if (name === "ref") {
-        hasRef = true;
-      } else if (name === "class") {
+      if (name === "class") {
         hasClassBinding = true;
       } else if (name === "style") {
         hasStyleBinding = true;
-      } else if (name !== "key" && !dynamicPropNames.includes(name)) {
+      } else if (name !== "ref" && name !== "key" && !dynamicPropNames.includes(name)) {
         dynamicPropNames.push(name);
       }
       if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) {
@@ -26822,13 +26876,12 @@ function buildProps(node, context, props = node.props, isComponent, isDynamicCom
       if (isVOn && ssr) {
         continue;
       }
-      if (
-        // #938: elements with dynamic keys should be forced into blocks
-        isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked
-        // before children
-        isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
-      ) {
+      if (isVBind && isStaticArgOf(arg, "key")) {
+        shouldUseBlock = true;
+      }
+      if (isVOn && hasChildren && arg && isStaticExp(arg) && camelize(arg.content) === "vue:beforeUpdate") {
         shouldUseBlock = true;
+        isBlockRequired = true;
       }
       if (isVBind && isStaticArgOf(arg, "ref")) {
         pushRefVForMarker();
@@ -26880,6 +26933,7 @@ function buildProps(node, context, props = node.props, isComponent, isDynamicCom
         runtimeDirectives.push(prop);
         if (hasChildren) {
           shouldUseBlock = true;
+          isBlockRequired = true;
         }
       }
     }
@@ -26918,7 +26972,8 @@ function buildProps(node, context, props = node.props, isComponent, isDynamicCom
       patchFlag |= 32;
     }
   }
-  if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {
+  const needsPatch = (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0);
+  if (!shouldUseBlock && needsPatch) {
     patchFlag |= 512;
   }
   if (!context.inSSR && propsExpression) {
@@ -26984,7 +27039,9 @@ function buildProps(node, context, props = node.props, isComponent, isDynamicCom
     directives: runtimeDirectives,
     patchFlag,
     dynamicPropNames,
-    shouldUseBlock
+    shouldUseBlock,
+    needsPatch,
+    isBlockRequired
   };
 }
 function dedupeProperties(properties) {
@@ -28247,12 +28304,15 @@ function stringifyElement(node, context) {
           res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
           continue;
         }
-        if (isBooleanAttr(p.arg.content) && exp.content === "false") {
+        if ((isBooleanAttr(p.arg.content) || p.arg.content === "hidden") && exp.content === "false") {
           continue;
         }
         let evaluated = evaluateConstant(exp);
         if (evaluated != null) {
           const arg = p.arg && p.arg.content;
+          if (arg === "hidden" && typeof evaluated === "number" && !includeBooleanAttr(evaluated)) {
+            continue;
+          }
           if (arg === "class") {
             evaluated = normalizeClass(evaluated);
           } else if (arg === "style") {
@@ -29150,17 +29210,53 @@ function createCache(max = 500) {
   }
 }
 
-function isImportUsed(local, sfc) {
-  return resolveTemplateUsedIdentifiers(sfc).has(local);
+var __defProp$b = Object.defineProperty;
+var __defProps$a = Object.defineProperties;
+var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
+var __hasOwnProp$b = Object.prototype.hasOwnProperty;
+var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$b = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$b.call(b, prop))
+      __defNormalProp$b(a, prop, b[prop]);
+  if (__getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(b)) {
+      if (__propIsEnum$b.call(b, prop))
+        __defNormalProp$b(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+function resolveTemplateAST(inAST, options) {
+  if (!(inAST == null ? void 0 : inAST.transformed)) {
+    return inAST;
+  }
+  const { compiler = CompilerDOM, compilerOptions, ssr, onError } = options;
+  const newAST = (ssr ? CompilerDOM : compiler).parse(inAST.source, __spreadProps$a(__spreadValues$b({
+    prefixIdentifiers: true
+  }, compilerOptions), {
+    parseMode: "sfc",
+    onError
+  }));
+  const template = newAST.children.find(
+    (node) => node.type === 1 && node.tag === "template"
+  );
+  return createRoot(template.children, inAST.source);
+}
+
+function isImportUsed(local, sfc, options) {
+  return resolveTemplateUsedIdentifiers(sfc, options).has(local);
 }
 const templateAnalysisCache = createCache();
-function resolveTemplateVModelIdentifiers(sfc) {
-  return resolveTemplateAnalysisResult(sfc, false).vModelIds;
+function resolveTemplateVModelIdentifiers(sfc, options) {
+  return resolveTemplateAnalysisResult(sfc, false, options).vModelIds;
 }
-function resolveTemplateUsedIdentifiers(sfc) {
-  return resolveTemplateAnalysisResult(sfc).usedIds;
+function resolveTemplateUsedIdentifiers(sfc, options) {
+  return resolveTemplateAnalysisResult(sfc, true, options).usedIds;
 }
-function resolveTemplateAnalysisResult(sfc, collectUsedIds = true) {
+function resolveTemplateAnalysisResult(sfc, collectUsedIds = true, options) {
   const { content, ast } = sfc.template;
   const cached = templateAnalysisCache.get(content);
   if (cached && (!collectUsedIds || cached.usedIds)) {
@@ -29168,7 +29264,15 @@ function resolveTemplateAnalysisResult(sfc, collectUsedIds = true) {
   }
   const ids = collectUsedIds ? /* @__PURE__ */ new Set() : void 0;
   const vModelIds = /* @__PURE__ */ new Set();
-  ast.children.forEach(walk);
+  const root = resolveTemplateAST(ast, {
+    compiler: options == null ? void 0 : options.compiler,
+    compilerOptions: options == null ? void 0 : options.compilerOptions,
+    ssr: options == null ? void 0 : options.ssr,
+    // ignore errors since they were already reported by the SFC parser
+    onError: () => {
+    }
+  });
+  root.children.forEach(walk);
   function walk(node) {
     var _a;
     switch (node.type) {
@@ -32481,6 +32585,13 @@ const ssrTransformElement = (node, context) => {
                         false
                       )
                     );
+                  } else if (attrName === "hidden") {
+                    openTag.push(
+                      createCallExpression(
+                        context.helper(SSR_RENDER_DYNAMIC_ATTR),
+                        [key, value]
+                      )
+                    );
                   } else if (isSSRSafeAttrName(attrName)) {
                     openTag.push(
                       createCallExpression(context.helper(SSR_RENDER_ATTR), [
@@ -33588,18 +33699,12 @@ function doCompileTemplate({
   if (compiler !== defaultCompiler) {
     inAST = void 0;
   }
-  if (inAST == null ? void 0 : inAST.transformed) {
-    const newAST = (ssr ? CompilerDOM : compiler).parse(inAST.source, __spreadProps$5(__spreadValues$6({
-      prefixIdentifiers: true
-    }, compilerOptions), {
-      parseMode: "sfc",
-      onError: (e) => errors.push(e)
-    }));
-    const template = newAST.children.find(
-      (node) => node.type === 1 && node.tag === "template"
-    );
-    inAST = createRoot(template.children, inAST.source);
-  }
+  inAST = resolveTemplateAST(inAST, {
+    compiler,
+    compilerOptions,
+    ssr,
+    onError: (e) => errors.push(e)
+  });
   let { code, ast, preamble, map } = compiler.compile(inAST || source, __spreadProps$5(__spreadValues$6({
     mode: "module",
     prefixIdentifiers: true,
@@ -34294,6 +34399,10 @@ function requireStringifier () {
 	const STYLE_TAG = /(<)(\/?style\b)/gi;
 	const COMMENT_OPEN = /(<)(!--)/g;
 
+	// Characters that end an at-rule name, mirroring RE_AT_END in the tokenizer.
+	// Params starting with anything else need a space to stay separate tokens.
+	const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
+
 	function escapeHTMLInCSS(str) {
 	  if (typeof str !== 'string') return str
 	  if (!str.includes('<')) return str
@@ -34319,27 +34428,89 @@ function requireStringifier () {
 	  return str[0].toUpperCase() + str.slice(1)
 	}
 
+	function atruleStart(str, node) {
+	  let name = '@' + node.name;
+	  let params = node.params ? str.rawValue(node, 'params') : '';
+	  let afterName = node.raws.afterName;
+
+	  if (typeof afterName === 'undefined') {
+	    afterName = params ? ' ' : '';
+	  } else if (afterName === '' && params && !AT_NAME_END.test(params[0])) {
+	    afterName = ' ';
+	  }
+
+	  return name + afterName + params
+	}
+
+	function pushBody(str, stack, node) {
+	  let nodes = node.nodes;
+	  let last = nodes.length - 1;
+	  while (last > 0) {
+	    if (nodes[last].type !== 'comment') break
+	    last -= 1;
+	  }
+
+	  let semicolon = str.raw(node, 'semicolon');
+	  let isDocument = node.type === 'document';
+	  for (let i = nodes.length - 1; i >= 0; i--) {
+	    let child = nodes[i];
+	    let childSemicolon = last !== i || semicolon;
+	    // A childless at-rule or a custom property declaration that still has
+	    // following siblings must be terminated. Without the semicolon those
+	    // trailing comments are folded into the at-rule's prelude or the custom
+	    // property's value and disappear when the output is re-parsed.
+	    if (
+	      !childSemicolon &&
+	      i < nodes.length - 1 &&
+	      ((child.type === 'atrule' && !child.nodes) ||
+	        (child.type === 'decl' && child.prop.startsWith('--')))
+	    ) {
+	      childSemicolon = true;
+	    }
+	    stack.push({
+	      document: isDocument,
+	      node: child,
+	      semicolon: childSemicolon
+	    });
+	  }
+	}
+
+	function pushBlock(str, stack, node, start) {
+	  let between = str.raw(node, 'between', 'beforeOpen');
+	  str.builder(escapeHTMLInCSS(start + between) + '{', node, 'start');
+
+	  let hasNodes = node.nodes && node.nodes.length;
+	  let close = () => {
+	    let after = hasNodes
+	      ? str.raw(node, 'after')
+	      : str.raw(node, 'after', 'emptyBody');
+	    if (after) str.builder(escapeHTMLInCSS(after));
+	    str.builder('}', node, 'end');
+	    if (node.type === 'rule' && node.raws.ownSemicolon) {
+	      str.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end');
+	    }
+	  };
+
+	  if (hasNodes) {
+	    stack.push(close);
+	    pushBody(str, stack, node);
+	  } else {
+	    close();
+	  }
+	}
+
 	class Stringifier {
 	  constructor(builder) {
 	    this.builder = builder;
 	  }
 
 	  atrule(node, semicolon) {
-	    let raws = node.raws;
-	    let name = '@' + node.name;
-	    let params = node.params ? this.rawValue(node, 'params') : '';
-
-	    if (typeof raws.afterName !== 'undefined') {
-	      name += raws.afterName;
-	    } else if (params) {
-	      name += ' ';
-	    }
-
+	    let start = atruleStart(this, node);
 	    if (node.nodes) {
-	      this.block(node, name + params);
+	      this.block(node, start);
 	    } else {
-	      let end = (raws.between || '') + (semicolon ? ';' : '');
-	      this.builder(escapeHTMLInCSS(name + params + end), node);
+	      let end = (node.raws.between || '') + (semicolon ? ';' : '');
+	      this.builder(escapeHTMLInCSS(start + end), node);
 	    }
 	  }
 
@@ -34389,20 +34560,38 @@ function requireStringifier () {
 	  }
 
 	  body(node) {
-	    let nodes = node.nodes;
-	    let last = nodes.length - 1;
-	    while (last > 0) {
-	      if (nodes[last].type !== 'comment') break
-	      last -= 1;
-	    }
+	    // Rules and at-rules are expanded into an explicit stack instead of
+	    // recursive `stringify()` calls to survive deeply nested trees.
+	    // If a subclass changes the traversal methods, its children go
+	    // through `stringify()` to keep the override in charge.
+	    let proto = Stringifier.prototype;
+	    let expandable = ['atrule', 'block', 'body', 'rule', 'stringify'].every(
+	      method => this[method] === proto[method]
+	    );
 
-	    let semicolon = this.raw(node, 'semicolon');
-	    let isDocument = node.type === 'document';
-	    for (let i = 0; i < nodes.length; i++) {
-	      let child = nodes[i];
+	    let stack = [];
+	    pushBody(this, stack, node);
+
+	    while (stack.length > 0) {
+	      let entry = stack.pop();
+	      if (typeof entry === 'function') {
+	        entry();
+	        continue
+	      }
+
+	      let child = entry.node;
 	      let before = this.raw(child, 'before');
-	      if (before) this.builder(isDocument ? before : escapeHTMLInCSS(before));
-	      this.stringify(child, last !== i || semicolon);
+	      if (before) {
+	        this.builder(entry.document ? before : escapeHTMLInCSS(before));
+	      }
+
+	      if (expandable && child.type === 'rule') {
+	        pushBlock(this, stack, child, this.rawValue(child, 'selector'));
+	      } else if (expandable && child.type === 'atrule' && child.nodes) {
+	        pushBlock(this, stack, child, atruleStart(this, child));
+	      } else {
+	        this.stringify(child, entry.semicolon);
+	      }
 	    }
 	  }
 
@@ -34710,25 +34899,41 @@ function requireNode$2 () {
 
 	function cloneNode(obj, parent) {
 	  let cloned = new obj.constructor();
-
-	  for (let i in obj) {
-	    if (!Object.prototype.hasOwnProperty.call(obj, i)) {
-	      /* c8 ignore next 2 */
-	      continue
-	    }
-	    if (i === 'proxyCache') continue
-	    let value = obj[i];
-	    let type = typeof value;
-
-	    if (i === 'parent' && type === 'object') {
-	      if (parent) cloned[i] = parent;
-	    } else if (i === 'source') {
-	      cloned[i] = value;
-	    } else if (Array.isArray(value)) {
-	      cloned[i] = value.map(j => cloneNode(j, cloned));
-	    } else {
-	      if (type === 'object' && value !== null) value = cloneNode(value);
-	      cloned[i] = value;
+	  // An explicit stack instead of recursive calls to survive deeply
+	  // nested trees. Each entry is [source, its clone, clone's parent].
+	  let stack = [[obj, cloned, parent]];
+
+	  while (stack.length > 0) {
+	    let [source, target, targetParent] = stack.pop();
+	    for (let i in source) {
+	      if (!Object.prototype.hasOwnProperty.call(source, i)) {
+	        /* c8 ignore next 2 */
+	        continue
+	      }
+	      if (i === 'proxyCache') continue
+	      let value = source[i];
+	      let type = typeof value;
+
+	      if (i === 'parent' && type === 'object') {
+	        if (targetParent) target[i] = targetParent;
+	      } else if (i === 'source') {
+	        target[i] = value;
+	      } else if (Array.isArray(value)) {
+	        let children = [];
+	        target[i] = children;
+	        for (let j of value) {
+	          let childClone = new j.constructor();
+	          children.push(childClone);
+	          stack.push([j, childClone, target]);
+	        }
+	      } else {
+	        if (type === 'object' && value !== null) {
+	          let valueClone = new value.constructor();
+	          stack.push([value, valueClone, undefined]);
+	          value = valueClone;
+	        }
+	        target[i] = value;
+	      }
 	    }
 	  }
 
@@ -34772,11 +34977,15 @@ function requireNode$2 () {
 	    this[isClean] = false;
 	    this[my] = true;
 
-	    for (let name in defaults) {
+	    for (let name of Object.keys(defaults)) {
+	      if (name === '__proto__') continue
 	      if (name === 'nodes') {
 	        this.nodes = [];
 	        for (let node of defaults[name]) {
-	          if (typeof node.clone === 'function') {
+	          // Clone only nodes that already belong to another tree, so passing a
+	          // freshly created (parent-less) node adopts that instance instead of
+	          // a copy and keeps the caller's reference usable. See #1987.
+	          if (typeof node.clone === 'function' && node.parent) {
 	            this.append(node.clone());
 	          } else {
 	            this.append(node);
@@ -34909,14 +35118,18 @@ function requireNode$2 () {
 	  }
 
 	  positionBy(opts = {}) {
-	    let pos = this.source.start;
+	    let inputString =
+	      'document' in this.source.input
+	        ? this.source.input.document
+	        : this.source.input.css;
+	    let pos = {
+	      column: this.source.start.column,
+	      line: this.source.start.line,
+	      offset: sourceOffset(inputString, this.source.start)
+	    };
 	    if (opts.index) {
 	      pos = this.positionInside(opts.index);
 	    } else if (opts.word) {
-	      let inputString =
-	        'document' in this.source.input
-	          ? this.source.input.document
-	          : this.source.input.css;
 	      let stringRepresentation = inputString.slice(
 	        sourceOffset(inputString, this.source.start),
 	        sourceOffset(inputString, this.source.end)
@@ -35001,7 +35214,7 @@ function requireNode$2 () {
 	          line: opts.start.line,
 	          offset: sourceOffset(inputString, opts.start)
 	        };
-	      } else if (opts.index) {
+	      } else if (typeof opts.index === 'number') {
 	        start = this.positionInside(opts.index);
 	      }
 
@@ -35013,7 +35226,7 @@ function requireNode$2 () {
 	        };
 	      } else if (typeof opts.endIndex === 'number') {
 	        end = this.positionInside(opts.endIndex);
-	      } else if (opts.index) {
+	      } else if (typeof opts.index === 'number') {
 	        end = this.positionInside(opts.index + 1);
 	      }
 	    }
@@ -35077,47 +35290,68 @@ function requireNode$2 () {
 	  }
 
 	  toJSON(_, inputs) {
-	    let fixed = {};
 	    let emitInputs = inputs == null;
 	    inputs = inputs || new Map();
-	    let inputsNextIndex = 0;
 
-	    for (let name in this) {
-	      if (!Object.prototype.hasOwnProperty.call(this, name)) {
-	        /* c8 ignore next 2 */
-	        continue
-	      }
-	      if (name === 'parent' || name === 'proxyCache') continue
-	      let value = this[name];
+	    // A worklist instead of recursive `toJSON()` calls to survive deeply
+	    // nested trees. Each entry converts one node and writes the result
+	    // into the already converted parent by [holder, key].
+	    let holderOfRoot = [];
+	    let queue = [[this, holderOfRoot, 0]];
 
-	      if (Array.isArray(value)) {
-	        fixed[name] = value.map(i => {
-	          if (typeof i === 'object' && i.toJSON) {
-	            return i.toJSON(null, inputs)
+	    for (let step = 0; step < queue.length; step++) {
+	      let [node, holder, key] = queue[step];
+	      let fixed = {};
+	      holder[key] = fixed;
+
+	      for (let name in node) {
+	        if (!Object.prototype.hasOwnProperty.call(node, name)) {
+	          /* c8 ignore next 2 */
+	          continue
+	        }
+	        if (name === 'parent' || name === 'proxyCache') continue
+	        let value = node[name];
+
+	        if (Array.isArray(value)) {
+	          let fixedArray = [];
+	          fixed[name] = fixedArray;
+	          for (let i = 0; i < value.length; i++) {
+	            let item = value[i];
+	            if (typeof item === 'object' && item.toJSON) {
+	              if (item.toJSON === Node.prototype.toJSON) {
+	                queue.push([item, fixedArray, i]);
+	              } else {
+	                fixedArray[i] = item.toJSON(null, inputs);
+	              }
+	            } else {
+	              fixedArray[i] = item;
+	            }
+	          }
+	        } else if (typeof value === 'object' && value.toJSON) {
+	          if (value.toJSON === Node.prototype.toJSON) {
+	            queue.push([value, fixed, name]);
 	          } else {
-	            return i
+	            fixed[name] = value.toJSON(null, inputs);
 	          }
-	        });
-	      } else if (typeof value === 'object' && value.toJSON) {
-	        fixed[name] = value.toJSON(null, inputs);
-	      } else if (name === 'source') {
-	        if (value == null) continue
-	        let inputId = inputs.get(value.input);
-	        if (inputId == null) {
-	          inputId = inputsNextIndex;
-	          inputs.set(value.input, inputsNextIndex);
-	          inputsNextIndex++;
-	        }
-	        fixed[name] = {
-	          end: value.end,
-	          inputId,
-	          start: value.start
-	        };
-	      } else {
-	        fixed[name] = value;
+	        } else if (name === 'source') {
+	          if (value == null) continue
+	          let inputId = inputs.get(value.input);
+	          if (inputId == null) {
+	            inputId = inputs.size;
+	            inputs.set(value.input, inputId);
+	          }
+	          fixed[name] = {
+	            end: value.end,
+	            inputId,
+	            start: value.start
+	          };
+	        } else {
+	          fixed[name] = value;
+	        }
 	      }
 	    }
 
+	    let fixed = holderOfRoot[0];
 	    if (emitInputs) {
 	      fixed.inputs = [...inputs.keys()].map(input => input.toJSON());
 	    }
@@ -35221,18 +35455,25 @@ function requireContainer$1 () {
 	let AtRule, parse, Root, Rule;
 
 	function cleanSource(nodes) {
-	  return nodes.map(i => {
-	    if (i.nodes) i.nodes = cleanSource(i.nodes);
-	    delete i.source;
-	    return i
-	  })
+	  let stack = nodes.slice();
+	  while (stack.length > 0) {
+	    let node = stack.pop();
+	    delete node.source;
+	    if (node.nodes) {
+	      node.nodes = node.nodes.slice();
+	      for (let i of node.nodes) stack.push(i);
+	    }
+	  }
+	  return nodes.slice()
 	}
 
 	function markTreeDirty(node) {
-	  node[isClean] = false;
-	  if (node.proxyOf.nodes) {
-	    for (let i of node.proxyOf.nodes) {
-	      markTreeDirty(i);
+	  let stack = [node];
+	  while (stack.length > 0) {
+	    let next = stack.pop();
+	    next[isClean] = false;
+	    if (next.proxyOf.nodes) {
+	      for (let i of next.proxyOf.nodes) stack.push(i);
 	    }
 	  }
 	}
@@ -35260,9 +35501,18 @@ function requireContainer$1 () {
 	  }
 
 	  cleanRaws(keepBetween) {
-	    super.cleanRaws(keepBetween);
-	    if (this.nodes) {
-	      for (let node of this.nodes) node.cleanRaws(keepBetween);
+	    let stack = [this];
+	    while (stack.length > 0) {
+	      let node = stack.pop();
+	      if (node !== this && node.cleanRaws !== Container.prototype.cleanRaws) {
+	        // Subclass with own logic; let it handle its subtree
+	        node.cleanRaws(keepBetween);
+	        continue
+	      }
+	      Node.prototype.cleanRaws.call(node, keepBetween);
+	      if (node.nodes) {
+	        for (let child of node.nodes) stack.push(child);
+	      }
 	    }
 	  }
 
@@ -35522,19 +35772,48 @@ function requireContainer$1 () {
 	  }
 
 	  walk(callback) {
-	    return this.each((child, i) => {
+	    if (!this.proxyOf.nodes) return undefined
+
+	    // An explicit stack instead of recursive `each()` calls to survive
+	    // deeply nested trees. Each frame keeps a live `indexes` slot, so
+	    // insertion and removal during the walk behave like `each()`: the
+	    // slot stays at the current child until its subtree is finished.
+	    let stack = [{ iterator: this.getIterator(), node: this.proxyOf }];
+
+	    while (stack.length > 0) {
+	      let { iterator, node } = stack[stack.length - 1];
+	      let index = node.indexes[iterator];
+
+	      if (index >= node.proxyOf.nodes.length) {
+	        delete node.indexes[iterator];
+	        stack.pop();
+	        let parent = stack[stack.length - 1];
+	        // Finish the parent’s step for the child subtree we just left
+	        if (parent) parent.node.indexes[parent.iterator] += 1;
+	        continue
+	      }
+
+	      let child = node.proxyOf.nodes[index];
 	      let result;
 	      try {
-	        result = callback(child, i);
+	        result = callback(child, index);
 	      } catch (e) {
 	        throw child.addToError(e)
 	      }
-	      if (result !== false && child.walk) {
-	        result = child.walk(callback);
+	      if (result === false) {
+	        for (let opened of stack) {
+	          delete opened.node.indexes[opened.iterator];
+	        }
+	        return false
+	      }
+	      if (child.walk && child.proxyOf.nodes) {
+	        stack.push({ iterator: child.getIterator(), node: child });
+	      } else {
+	        node.indexes[iterator] += 1;
 	      }
+	    }
 
-	      return result
-	    })
+	    return undefined
 	  }
 
 	  walkAtRules(name, callback) {
@@ -35637,24 +35916,26 @@ function requireContainer$1 () {
 
 	/* c8 ignore start */
 	Container.rebuild = node => {
-	  if (node.type === 'atrule') {
-	    Object.setPrototypeOf(node, AtRule.prototype);
-	  } else if (node.type === 'rule') {
-	    Object.setPrototypeOf(node, Rule.prototype);
-	  } else if (node.type === 'decl') {
-	    Object.setPrototypeOf(node, Declaration.prototype);
-	  } else if (node.type === 'comment') {
-	    Object.setPrototypeOf(node, Comment.prototype);
-	  } else if (node.type === 'root') {
-	    Object.setPrototypeOf(node, Root.prototype);
-	  }
+	  let stack = [node];
+	  while (stack.length > 0) {
+	    let next = stack.pop();
+	    if (next.type === 'atrule') {
+	      Object.setPrototypeOf(next, AtRule.prototype);
+	    } else if (next.type === 'rule') {
+	      Object.setPrototypeOf(next, Rule.prototype);
+	    } else if (next.type === 'decl') {
+	      Object.setPrototypeOf(next, Declaration.prototype);
+	    } else if (next.type === 'comment') {
+	      Object.setPrototypeOf(next, Comment.prototype);
+	    } else if (next.type === 'root') {
+	      Object.setPrototypeOf(next, Root.prototype);
+	    }
 
-	  node[my] = true;
+	    next[my] = true;
 
-	  if (node.nodes) {
-	    node.nodes.forEach(child => {
-	      Container.rebuild(child);
-	    });
+	    if (next.nodes) {
+	      for (let child of next.nodes) stack.push(child);
+	    }
 	  }
 	};
 	/* c8 ignore stop */
@@ -35741,22 +36022,14 @@ var hasRequiredNonSecure;
 function requireNonSecure () {
 	if (hasRequiredNonSecure) return nonSecure;
 	hasRequiredNonSecure = 1;
-	// This alphabet uses `A-Za-z0-9_-` symbols.
-	// The order of characters is optimized for better gzip and brotli compression.
-	// References to the same file (works both for gzip and brotli):
-	// `'use`, `andom`, and `rict'`
-	// References to the brotli default dictionary:
-	// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
 	let urlAlphabet =
 	  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
 
 	let customAlphabet = (alphabet, defaultSize = 21) => {
 	  return (size = defaultSize) => {
 	    let id = '';
-	    // A compact alternative for `for (var i = 0; i < step; i++)`.
 	    let i = size | 0;
-	    while (i--) {
-	      // `| 0` is more compact and faster than `Math.floor()`.
+	    while (i-- > 0) {
 	      id += alphabet[(Math.random() * alphabet.length) | 0];
 	    }
 	    return id
@@ -35765,10 +36038,8 @@ function requireNonSecure () {
 
 	let nanoid = (size = 21) => {
 	  let id = '';
-	  // A compact alternative for `for (var i = 0; i < step; i++)`.
 	  let i = size | 0;
-	  while (i--) {
-	    // `| 0` is more compact and faster than `Math.floor()`.
+	  while (i-- > 0) {
 	    id += urlAlphabet[(Math.random() * 64) | 0];
 	  }
 	  return id
@@ -35788,7 +36059,7 @@ function requirePreviousMap () {
 	hasRequiredPreviousMap = 1;
 
 	let { existsSync, readFileSync } = require$$0$1;
-	let { dirname, join } = require$$1;
+	let { dirname, isAbsolute, join, relative, sep } = require$$1;
 	let { SourceMapConsumer, SourceMapGenerator } = /*@__PURE__*/ requireSourceMap$1();
 
 	function fromBase64(str) {
@@ -35872,9 +36143,12 @@ function requirePreviousMap () {
 	  }
 
 	  loadFile(path, cssFile, trusted) {
-	    /* c8 ignore next 5 */
 	    if (!trusted && !this.unsafeMap) {
-	      if (!/\.map$/i.test(path)) {
+	      if (!/\.map$/i.test(path)) return undefined
+	      if (!cssFile) return undefined
+
+	      let rel = relative(dirname(cssFile), path);
+	      if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel)) {
 	        return undefined
 	      }
 	    }
@@ -36162,12 +36436,21 @@ function requireInput () {
 	    if (!this.map) return false
 	    let consumer = this.map.consumer();
 
-	    let from = consumer.originalPositionFor({ column, line });
+	    let from = consumer.originalPositionFor({ column: column - 1, line });
 	    if (!from.source) return false
 
 	    let to;
 	    if (typeof endLine === 'number') {
-	      to = consumer.originalPositionFor({ column: endColumn, line: endLine });
+	      let toPosition = consumer.originalPositionFor({
+	        column: endColumn - 1,
+	        line: endLine
+	      });
+	      // The source map may not have a mapping that covers the end position
+	      // (`originalPositionFor()` then returns `null` for `line`/`column`
+	      // instead of omitting them). Treat that the same as not requesting
+	      // an end position at all, so `endLine`/`endColumn` stay a consistent
+	      // `undefined` pair instead of a mix of `null` and a bogus number.
+	      if (toPosition.source) to = toPosition;
 	    }
 
 	    let fromUrl;
@@ -36182,8 +36465,8 @@ function requireInput () {
 	    }
 
 	    let result = {
-	      column: from.column,
-	      endColumn: to && to.column,
+	      column: from.column + 1,
+	      endColumn: to && to.column + 1,
 	      endLine: to && to.line,
 	      line: from.line,
 	      url: fromUrl.toString()
@@ -36249,6 +36532,19 @@ function requireRoot$1 () {
 	  }
 
 	  normalize(child, sample, type) {
+	    let keepBefore = new Set();
+	    for (let node of Array.isArray(child) ? child : [child]) {
+	      if (
+	        node &&
+	        typeof node === 'object' &&
+	        !node.parent &&
+	        node.raws &&
+	        typeof node.raws.before !== 'undefined'
+	      ) {
+	        keepBefore.add(node.raws);
+	      }
+	    }
+
 	    let nodes = super.normalize(child);
 
 	    if (sample) {
@@ -36260,7 +36556,9 @@ function requireRoot$1 () {
 	        }
 	      } else if (this.first !== sample) {
 	        for (let node of nodes) {
-	          node.raws.before = sample.raws.before;
+	          if (!keepBefore.has(node.raws)) {
+	            node.raws.before = sample.raws.before;
+	          }
 	        }
 	      }
 	    }
@@ -36415,26 +36713,24 @@ function requireFromJSON () {
 	let Root = /*@__PURE__*/ requireRoot$1();
 	let Rule = /*@__PURE__*/ requireRule();
 
-	function fromJSON(json, inputs) {
-	  if (Array.isArray(json)) return json.map(n => fromJSON(n))
-
-	  let { inputs: ownInputs, ...defaults } = json;
-	  if (ownInputs) {
-	    inputs = [];
-	    for (let input of ownInputs) {
-	      let inputHydrated = { ...input, __proto__: Input.prototype };
-	      if (inputHydrated.map) {
-	        inputHydrated.map = {
-	          ...inputHydrated.map,
-	          __proto__: PreviousMap.prototype
-	        };
-	      }
-	      inputs.push(inputHydrated);
+	function hydrateInputs(json, inputs) {
+	  if (!json.inputs) return inputs
+	  return json.inputs.map(input => {
+	    let inputHydrated = { ...input, __proto__: Input.prototype };
+	    if (inputHydrated.map) {
+	      inputHydrated.map = {
+	        ...inputHydrated.map,
+	        __proto__: PreviousMap.prototype
+	      };
 	    }
-	  }
-	  if (defaults.nodes) {
-	    defaults.nodes = json.nodes.map(n => fromJSON(n, inputs));
-	  }
+	    return inputHydrated
+	  })
+	}
+
+	function constructNode(json, inputs, children) {
+	  let defaults = { ...json };
+	  delete defaults.inputs;
+	  delete defaults.nodes;
 	  if (defaults.source) {
 	    let { inputId, ...source } = defaults.source;
 	    defaults.source = source;
@@ -36442,19 +36738,74 @@ function requireFromJSON () {
 	      defaults.source.input = inputs[inputId];
 	    }
 	  }
+
+	  let node;
 	  if (defaults.type === 'root') {
-	    return new Root(defaults)
+	    node = new Root(defaults);
 	  } else if (defaults.type === 'decl') {
-	    return new Declaration(defaults)
+	    node = new Declaration(defaults);
 	  } else if (defaults.type === 'rule') {
-	    return new Rule(defaults)
+	    node = new Rule(defaults);
 	  } else if (defaults.type === 'comment') {
-	    return new Comment(defaults)
+	    node = new Comment(defaults);
 	  } else if (defaults.type === 'atrule') {
-	    return new AtRule(defaults)
+	    node = new AtRule(defaults);
 	  } else {
 	    throw new Error('Unknown node type: ' + json.type)
 	  }
+
+	  // Rehydrated children are attached after construction. Passing them
+	  // through the container constructor would re-run insertion spacing
+	  // normalization and overwrite each child's own `raws.before`.
+	  if (children) {
+	    node.nodes = children;
+	    for (let child of children) child.parent = node;
+	  }
+
+	  return node
+	}
+
+	function fromJSON(json, inputs) {
+	  if (Array.isArray(json)) return json.map(n => fromJSON(n))
+
+	  // An explicit stack instead of recursive calls to survive deeply
+	  // nested trees. Children are rehydrated before their parent node
+	  // is constructed.
+	  let result;
+	  let stack = [
+	    { childIndex: 0, children: [], inputs: hydrateInputs(json, inputs), json }
+	  ];
+
+	  while (stack.length > 0) {
+	    let frame = stack[stack.length - 1];
+	    let jsonNodes = frame.json.nodes;
+
+	    if (jsonNodes && frame.childIndex < jsonNodes.length) {
+	      let childJson = jsonNodes[frame.childIndex];
+	      frame.childIndex += 1;
+	      stack.push({
+	        childIndex: 0,
+	        children: [],
+	        inputs: hydrateInputs(childJson, frame.inputs),
+	        json: childJson
+	      });
+	      continue
+	    }
+
+	    stack.pop();
+	    let node = constructNode(
+	      frame.json,
+	      frame.inputs,
+	      jsonNodes ? frame.children : undefined
+	    );
+	    if (stack.length > 0) {
+	      stack[stack.length - 1].children.push(node);
+	    } else {
+	      result = node;
+	    }
+	  }
+
+	  return result
 	}
 
 	fromJSON_1 = fromJSON;
@@ -37529,12 +37880,22 @@ function requireWarning () {
 	if (hasRequiredWarning) return warning;
 	hasRequiredWarning = 1;
 
+	let Container = /*@__PURE__*/ requireContainer$1();
+	let { my } = /*@__PURE__*/ requireSymbols();
+
 	class Warning {
 	  constructor(text, opts = {}) {
 	    this.type = 'warning';
 	    this.text = text;
 
 	    if (opts.node && opts.node.source) {
+	      if (!opts.node[my]) {
+	        // The node comes from another PostCSS copy in node_modules, so it does
+	        // not have this copy’s methods. Container#normalize() rebuilds such
+	        // nodes on insert, but a node passed straight to Result#warn() never
+	        // goes through it.
+	        Container.rebuild(opts.node);
+	      }
 	      let range = opts.node.rangeBy(opts);
 	      this.line = range.start.line;
 	      this.column = range.start.column;
@@ -37743,8 +38104,14 @@ function requireLazyResult () {
 	}
 
 	function cleanMarks(node) {
-	  node[isClean] = false;
-	  if (node.nodes) node.nodes.forEach(i => cleanMarks(i));
+	  let stack = [node];
+	  while (stack.length > 0) {
+	    let next = stack.pop();
+	    next[isClean] = false;
+	    if (next.nodes) {
+	      for (let i of next.nodes) stack.push(i);
+	    }
+	  }
 	  return node
 	}
 
@@ -38175,21 +38542,57 @@ function requireLazyResult () {
 	  }
 
 	  walkSync(node) {
+	    // An explicit stack like in async `visitTick()` to survive deeply
+	    // nested trees. Unlike `visitTick()`, nodes are marked clean only
+	    // on entering, so a node dirtied by its own visitors is revisited
+	    // on the next pass.
 	    node[isClean] = true;
-	    let events = getEvents(node);
-	    for (let event of events) {
-	      if (event === CHILDREN) {
-	        if (node.nodes) {
-	          node.each(child => {
-	            if (!child[isClean]) this.walkSync(child);
-	          });
+	    let stack = [{ eventIndex: 0, events: getEvents(node), iterator: 0, node }];
+
+	    while (stack.length > 0) {
+	      let visit = stack[stack.length - 1];
+	      let visitNode = visit.node;
+
+	      if (visit.iterator !== 0) {
+	        let iterator = visit.iterator;
+	        let child;
+	        let descended = false;
+	        while ((child = visitNode.nodes[visitNode.indexes[iterator]])) {
+	          visitNode.indexes[iterator] += 1;
+	          if (!child[isClean]) {
+	            child[isClean] = true;
+	            stack.push({
+	              eventIndex: 0,
+	              events: getEvents(child),
+	              iterator: 0,
+	              node: child
+	            });
+	            descended = true;
+	            break
+	          }
 	        }
-	      } else {
-	        let visitors = this.listeners[event];
-	        if (visitors) {
-	          if (this.visitSync(visitors, node.toProxy())) return
+	        if (descended) continue
+	        visit.iterator = 0;
+	        delete visitNode.indexes[iterator];
+	      }
+
+	      if (visit.eventIndex < visit.events.length) {
+	        let event = visit.events[visit.eventIndex];
+	        visit.eventIndex += 1;
+	        if (event === CHILDREN) {
+	          if (visitNode.nodes && visitNode.nodes.length) {
+	            visit.iterator = visitNode.getIterator();
+	          }
+	        } else {
+	          let visitors = this.listeners[event];
+	          if (visitors) {
+	            if (this.visitSync(visitors, visitNode.toProxy())) stack.pop();
+	          }
 	        }
+	        continue
 	      }
+
+	      stack.pop();
 	    }
 	  }
 
@@ -38369,7 +38772,7 @@ function requireProcessor$1 () {
 
 	class Processor {
 	  constructor(plugins = []) {
-	    this.version = '8.5.15';
+	    this.version = '8.5.23';
 	    this.plugins = this.normalize(plugins);
 	  }
 
@@ -50645,7 +51048,7 @@ Upgrade your vite or vue-loader version for compatibility with the latest experi
   function registerUserImport(source2, local, imported, isType, isFromSetup, needTemplateUsageCheck) {
     let isUsedInTemplate = needTemplateUsageCheck;
     if (needTemplateUsageCheck && ctx.isTS && sfc.template && !sfc.template.src && !sfc.template.lang) {
-      isUsedInTemplate = isImportUsed(local, sfc);
+      isUsedInTemplate = isImportUsed(local, sfc, options.templateOptions);
     }
     ctx.userImports[local] = {
       isType,
@@ -50992,7 +51395,10 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
     ctx.bindingMetadata[key] = setupBindings[key];
   }
   if (sfc.template && !sfc.template.src && sfc.template.ast) {
-    const vModelIds = resolveTemplateVModelIdentifiers(sfc);
+    const vModelIds = resolveTemplateVModelIdentifiers(
+      sfc,
+      options.templateOptions
+    );
     if (vModelIds.size) {
       const toDemote = /* @__PURE__ */ new Set();
       for (const id of vModelIds) {
@@ -51470,7 +51876,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.5.39";
+const version = "3.5.41";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;