@vue/compiler-sfc 3.5.29 → 3.5.31

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.29
+* @vue/compiler-sfc v3.5.31
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -2082,7 +2082,7 @@ function dedent(s) {
 
 function isRelativeUrl(url) {
   const firstChar = url.charAt(0);
-  return firstChar === "." || firstChar === "~" || firstChar === "@";
+  return firstChar === "." || firstChar === "~" || firstChar === "@" || firstChar === "#";
 }
 const externalRE = /^(?:https?:)?\/\//;
 function isExternalUrl(url) {
@@ -2092,6 +2092,13 @@ const dataUrlRE = /^\s*data:/i;
 function isDataUrl(url) {
   return dataUrlRE.test(url);
 }
+function normalizeDecodedImportPath(source) {
+  try {
+    return decodeURIComponent(source);
+  } catch {
+    return source;
+  }
+}
 function parseUrl(url) {
   const firstChar = url.charAt(0);
   if (firstChar === "~") {
@@ -2104,14 +2111,17 @@ function parseUriParts(urlString) {
   return url.parse(shared.isString(urlString) ? urlString : "", false, true);
 }
 
+const resourceUrlTagConfig = {
+  video: ["src", "poster"],
+  source: ["src"],
+  img: ["src"],
+  image: ["xlink:href", "href"]
+};
 const defaultAssetUrlOptions = {
   base: null,
   includeAbsolute: false,
   tags: {
-    video: ["src", "poster"],
-    source: ["src"],
-    img: ["src"],
-    image: ["xlink:href", "href"],
+    ...resourceUrlTagConfig,
     use: ["xlink:href", "href"]
   }
 };
@@ -2130,6 +2140,10 @@ const normalizeOptions = (options) => {
 const createAssetUrlTransformWithOptions = (options) => {
   return (node, context) => transformAssetUrl(node, context, options);
 };
+function canTransformHashImport(tag, attrName) {
+  var _a;
+  return !!((_a = resourceUrlTagConfig[tag]) == null ? void 0 : _a.includes(attrName));
+}
 const transformAssetUrl = (node, context, options = defaultAssetUrlOptions) => {
   if (node.type === 1) {
     if (!node.props.length) {
@@ -2143,11 +2157,16 @@ const transformAssetUrl = (node, context, options = defaultAssetUrlOptions) => {
     }
     const assetAttrs = (attrs || []).concat(wildCardAttrs || []);
     node.props.forEach((attr, index) => {
-      if (attr.type !== 6 || !assetAttrs.includes(attr.name) || !attr.value || isExternalUrl(attr.value.content) || isDataUrl(attr.value.content) || attr.value.content[0] === "#" || !options.includeAbsolute && !isRelativeUrl(attr.value.content)) {
+      if (attr.type !== 6 || !assetAttrs.includes(attr.name) || !attr.value) {
+        return;
+      }
+      const urlValue = attr.value.content;
+      const isHashOnlyValue = urlValue[0] === "#";
+      if (isExternalUrl(urlValue) || isDataUrl(urlValue) || isHashOnlyValue && !canTransformHashImport(node.tag, attr.name) || !options.includeAbsolute && !isRelativeUrl(urlValue)) {
         return;
       }
-      const url = parseUrl(attr.value.content);
-      if (options.base && attr.value.content[0] === ".") {
+      const url = parseUrl(urlValue);
+      if (options.base && urlValue[0] === ".") {
         const base = parseUrl(options.base);
         const protocol = base.protocol || "";
         const host = base.host ? protocol + "//" + base.host : "";
@@ -2167,55 +2186,65 @@ const transformAssetUrl = (node, context, options = defaultAssetUrlOptions) => {
     });
   }
 };
+function resolveOrRegisterImport(source, loc, context) {
+  const normalizedSource = normalizeDecodedImportPath(source);
+  const existingIndex = context.imports.findIndex(
+    (i) => i.path === normalizedSource
+  );
+  if (existingIndex > -1) {
+    return {
+      name: `_imports_${existingIndex}`,
+      exp: context.imports[existingIndex].exp
+    };
+  }
+  const name = `_imports_${context.imports.length}`;
+  const exp = compilerCore.createSimpleExpression(
+    name,
+    false,
+    loc,
+    3
+  );
+  context.imports.push({
+    exp,
+    path: normalizedSource
+  });
+  return { name, exp };
+}
 function getImportsExpressionExp(path2, hash, loc, context) {
-  if (path2) {
-    let name;
-    let exp;
-    const existingIndex = context.imports.findIndex((i) => i.path === path2);
-    if (existingIndex > -1) {
-      name = `_imports_${existingIndex}`;
-      exp = context.imports[existingIndex].exp;
-    } else {
-      name = `_imports_${context.imports.length}`;
-      exp = compilerCore.createSimpleExpression(
-        name,
-        false,
-        loc,
-        3
-      );
-      context.imports.push({
-        exp,
-        path: decodeURIComponent(path2)
-      });
-    }
-    if (!hash) {
-      return exp;
-    }
-    const hashExp = `${name} + '${hash}'`;
-    const finalExp = compilerCore.createSimpleExpression(
-      hashExp,
+  if (!path2 && !hash) {
+    return compilerCore.createSimpleExpression(`''`, false, loc, 3);
+  }
+  if (!path2 && hash) {
+    const { exp } = resolveOrRegisterImport(hash, loc, context);
+    return exp;
+  }
+  if (path2 && !hash) {
+    const { exp } = resolveOrRegisterImport(path2, loc, context);
+    return exp;
+  }
+  const { name } = resolveOrRegisterImport(path2, loc, context);
+  const hashExp = `${name} + '${hash}'`;
+  const finalExp = compilerCore.createSimpleExpression(
+    hashExp,
+    false,
+    loc,
+    3
+  );
+  if (!context.hoistStatic) {
+    return finalExp;
+  }
+  const existingHoistIndex = context.hoists.findIndex((h) => {
+    return h && h.type === 4 && !h.isStatic && h.content === hashExp;
+  });
+  if (existingHoistIndex > -1) {
+    return compilerCore.createSimpleExpression(
+      `_hoisted_${existingHoistIndex + 1}`,
       false,
       loc,
       3
     );
-    if (!context.hoistStatic) {
-      return finalExp;
-    }
-    const existingHoistIndex = context.hoists.findIndex((h) => {
-      return h && h.type === 4 && !h.isStatic && h.content === hashExp;
-    });
-    if (existingHoistIndex > -1) {
-      return compilerCore.createSimpleExpression(
-        `_hoisted_${existingHoistIndex + 1}`,
-        false,
-        loc,
-        3
-      );
-    }
-    return context.hoist(finalExp);
-  } else {
-    return compilerCore.createSimpleExpression(`''`, false, loc, 3);
   }
+  return context.hoist(finalExp);
 }
 
 const srcsetTags = ["img", "source"];
@@ -2272,12 +2301,14 @@ const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
           const compoundExpression = compilerCore.createCompoundExpression([], attr.loc);
           imageCandidates.forEach(({ url, descriptor }, index2) => {
             if (shouldProcessUrl(url)) {
-              const { path: path2 } = parseUrl(url);
-              let exp2;
-              if (path2) {
+              const { path: path2, hash } = parseUrl(url);
+              const source = path2 ? path2 : hash;
+              if (source) {
+                const normalizedSource = normalizeDecodedImportPath(source);
                 const existingImportsIndex = context.imports.findIndex(
-                  (i) => i.path === path2
+                  (i) => i.path === normalizedSource
                 );
+                let exp2;
                 if (existingImportsIndex > -1) {
                   exp2 = compilerCore.createSimpleExpression(
                     `_imports_${existingImportsIndex}`,
@@ -2292,7 +2323,15 @@ const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
                     attr.loc,
                     3
                   );
-                  context.imports.push({ exp: exp2, path: path2 });
+                  context.imports.push({ exp: exp2, path: normalizedSource });
+                }
+                if (path2 && hash) {
+                  exp2 = compilerCore.createSimpleExpression(
+                    `${exp2.content} + '${hash}'`,
+                    false,
+                    attr.loc,
+                    3
+                  );
                 }
                 compoundExpression.children.push(exp2);
               }
@@ -19708,7 +19747,7 @@ function getObjectOrArrayExpressionKeys(value) {
   return [];
 }
 
-var _a, _b;
+var _a$1, _b;
 class ScriptCompileContext {
   constructor(descriptor, options) {
     this.descriptor = descriptor;
@@ -19717,7 +19756,7 @@ class ScriptCompileContext {
     this.source = this.descriptor.source;
     this.filename = this.descriptor.filename;
     this.s = new MagicString(this.source);
-    this.startOffset = (_a = this.descriptor.scriptSetup) == null ? void 0 : _a.loc.start.offset;
+    this.startOffset = (_a$1 = this.descriptor.scriptSetup) == null ? void 0 : _a$1.loc.start.offset;
     this.endOffset = (_b = this.descriptor.scriptSetup) == null ? void 0 : _b.loc.end.offset;
     this.userImports = /* @__PURE__ */ Object.create(null);
     // macros presence check
@@ -20024,7 +20063,7 @@ const slashPattern = /\\\\/g;
 const openPattern = /\\{/g;
 const closePattern = /\\}/g;
 const commaPattern = /\\,/g;
-const periodPattern = /\\./g;
+const periodPattern = /\\\./g;
 const EXPANSION_MAX = 100_000;
 function numeric(str) {
     return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
@@ -20394,8 +20433,110 @@ const unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true, } = {
 };
 
 // parse a single path portion
+var _a;
 const types = new Set(['!', '?', '+', '*', '@']);
 const isExtglobType = (c) => types.has(c);
+const isExtglobAST = (c) => isExtglobType(c.type);
+// Map of which extglob types can adopt the children of a nested extglob
+//
+// anything but ! can adopt a matching type:
+// +(a|+(b|c)|d) => +(a|b|c|d)
+// *(a|*(b|c)|d) => *(a|b|c|d)
+// @(a|@(b|c)|d) => @(a|b|c|d)
+// ?(a|?(b|c)|d) => ?(a|b|c|d)
+//
+// * can adopt anything, because 0 or repetition is allowed
+// *(a|?(b|c)|d) => *(a|b|c|d)
+// *(a|+(b|c)|d) => *(a|b|c|d)
+// *(a|@(b|c)|d) => *(a|b|c|d)
+//
+// + can adopt @, because 1 or repetition is allowed
+// +(a|@(b|c)|d) => +(a|b|c|d)
+//
+// + and @ CANNOT adopt *, because 0 would be allowed
+// +(a|*(b|c)|d) => would match "", on *(b|c)
+// @(a|*(b|c)|d) => would match "", on *(b|c)
+//
+// + and @ CANNOT adopt ?, because 0 would be allowed
+// +(a|?(b|c)|d) => would match "", on ?(b|c)
+// @(a|?(b|c)|d) => would match "", on ?(b|c)
+//
+// ? can adopt @, because 0 or 1 is allowed
+// ?(a|@(b|c)|d) => ?(a|b|c|d)
+//
+// ? and @ CANNOT adopt * or +, because >1 would be allowed
+// ?(a|*(b|c)|d) => would match bbb on *(b|c)
+// @(a|*(b|c)|d) => would match bbb on *(b|c)
+// ?(a|+(b|c)|d) => would match bbb on +(b|c)
+// @(a|+(b|c)|d) => would match bbb on +(b|c)
+//
+// ! CANNOT adopt ! (nothing else can either)
+// !(a|!(b|c)|d) => !(a|b|c|d) would fail to match on b (not not b|c)
+//
+// ! can adopt @
+// !(a|@(b|c)|d) => !(a|b|c|d)
+//
+// ! CANNOT adopt *
+// !(a|*(b|c)|d) => !(a|b|c|d) would match on bbb, not allowed
+//
+// ! CANNOT adopt +
+// !(a|+(b|c)|d) => !(a|b|c|d) would match on bbb, not allowed
+//
+// ! CANNOT adopt ?
+// x!(a|?(b|c)|d) => x!(a|b|c|d) would fail to match "x"
+const adoptionMap = new Map([
+    ['!', ['@']],
+    ['?', ['?', '@']],
+    ['@', ['@']],
+    ['*', ['*', '+', '?', '@']],
+    ['+', ['+', '@']],
+]);
+// nested extglobs that can be adopted in, but with the addition of
+// a blank '' element.
+const adoptionWithSpaceMap = new Map([
+    ['!', ['?']],
+    ['@', ['?']],
+    ['+', ['?', '*']],
+]);
+// union of the previous two maps
+const adoptionAnyMap = new Map([
+    ['!', ['?', '@']],
+    ['?', ['?', '@']],
+    ['@', ['?', '@']],
+    ['*', ['*', '+', '?', '@']],
+    ['+', ['+', '@', '?', '*']],
+]);
+// Extglobs that can take over their parent if they are the only child
+// the key is parent, value maps child to resulting extglob parent type
+// '@' is omitted because it's a special case. An `@` extglob with a single
+// member can always be usurped by that subpattern.
+const usurpMap = new Map([
+    ['!', new Map([['!', '@']])],
+    [
+        '?',
+        new Map([
+            ['*', '*'],
+            ['+', '*'],
+        ]),
+    ],
+    [
+        '@',
+        new Map([
+            ['!', '!'],
+            ['?', '?'],
+            ['@', '@'],
+            ['*', '*'],
+            ['+', '+'],
+        ]),
+    ],
+    [
+        '+',
+        new Map([
+            ['?', '*'],
+            ['*', '*'],
+        ]),
+    ],
+]);
 // Patterns that get prepended to bind to the start of either the
 // entire string, or just a single path portion, to prevent dots
 // and/or traversal patterns, when needed.
@@ -20419,6 +20560,7 @@ const star$1 = qmark$1 + '*?';
 const starNoEmpty = qmark$1 + '+?';
 // remove the \ chars that we added if we end up doing a nonmagic compare
 // const deslash = (s: string) => s.replace(/\\(.)/g, '$1')
+let ID = 0;
 class AST {
     type;
     #root;
@@ -20434,6 +20576,22 @@ class AST {
     // set to true if it's an extglob with no children
     // (which really means one child of '')
     #emptyExt = false;
+    id = ++ID;
+    get depth() {
+        return (this.#parent?.depth ?? -1) + 1;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return {
+            '@@type': 'AST',
+            id: this.id,
+            type: this.type,
+            root: this.#root.id,
+            parent: this.#parent?.id,
+            depth: this.depth,
+            partsLength: this.#parts.length,
+            parts: this.#parts,
+        };
+    }
     constructor(type, parent, options = {}) {
         this.type = type;
         // extglobs are inherently magical
@@ -20513,7 +20671,7 @@ class AST {
                 continue;
             /* c8 ignore start */
             if (typeof p !== 'string' &&
-                !(p instanceof AST && p.#parent === this)) {
+                !(p instanceof _a && p.#parent === this)) {
                 throw new Error('invalid part: ' + p);
             }
             /* c8 ignore stop */
@@ -20547,7 +20705,7 @@ class AST {
         const p = this.#parent;
         for (let i = 0; i < this.#parentIndex; i++) {
             const pp = p.#parts[i];
-            if (!(pp instanceof AST && pp.type === '!')) {
+            if (!(pp instanceof _a && pp.type === '!')) {
                 return false;
             }
         }
@@ -20575,13 +20733,14 @@ class AST {
             this.push(part.clone(this));
     }
     clone(parent) {
-        const c = new AST(this.type, parent);
+        const c = new _a(this.type, parent);
         for (const p of this.#parts) {
             c.copyIn(p);
         }
         return c;
     }
-    static #parseAST(str, ast, pos, opt) {
+    static #parseAST(str, ast, pos, opt, extDepth) {
+        const maxDepth = opt.maxExtglobRecursion ?? 2;
         let escaping = false;
         let inBrace = false;
         let braceStart = -1;
@@ -20618,11 +20777,17 @@ class AST {
                     acc += c;
                     continue;
                 }
-                if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {
+                // we don't have to check for adoption here, because that's
+                // done at the other recursion point.
+                const doRecurse = !opt.noext &&
+                    isExtglobType(c) &&
+                    str.charAt(i) === '(' &&
+                    extDepth <= maxDepth;
+                if (doRecurse) {
                     ast.push(acc);
                     acc = '';
-                    const ext = new AST(c, ast);
-                    i = AST.#parseAST(str, ext, i, opt);
+                    const ext = new _a(c, ast);
+                    i = _a.#parseAST(str, ext, i, opt, extDepth + 1);
                     ast.push(ext);
                     continue;
                 }
@@ -20634,7 +20799,7 @@ class AST {
         // some kind of extglob, pos is at the (
         // find the next | or )
         let i = pos + 1;
-        let part = new AST(null, ast);
+        let part = new _a(null, ast);
         const parts = [];
         let acc = '';
         while (i < str.length) {
@@ -20665,19 +20830,26 @@ class AST {
                 acc += c;
                 continue;
             }
-            if (isExtglobType(c) && str.charAt(i) === '(') {
+            const doRecurse = !opt.noext &&
+                isExtglobType(c) &&
+                str.charAt(i) === '(' &&
+                /* c8 ignore start - the maxDepth is sufficient here */
+                (extDepth <= maxDepth || (ast && ast.#canAdoptType(c)));
+            /* c8 ignore stop */
+            if (doRecurse) {
+                const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
                 part.push(acc);
                 acc = '';
-                const ext = new AST(c, part);
+                const ext = new _a(c, part);
                 part.push(ext);
-                i = AST.#parseAST(str, ext, i, opt);
+                i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
                 continue;
             }
             if (c === '|') {
                 part.push(acc);
                 acc = '';
                 parts.push(part);
-                part = new AST(null, ast);
+                part = new _a(null, ast);
                 continue;
             }
             if (c === ')') {
@@ -20699,9 +20871,82 @@ class AST {
         ast.#parts = [str.substring(pos - 1)];
         return i;
     }
+    #canAdoptWithSpace(child) {
+        return this.#canAdopt(child, adoptionWithSpaceMap);
+    }
+    #canAdopt(child, map = adoptionMap) {
+        if (!child ||
+            typeof child !== 'object' ||
+            child.type !== null ||
+            child.#parts.length !== 1 ||
+            this.type === null) {
+            return false;
+        }
+        const gc = child.#parts[0];
+        if (!gc || typeof gc !== 'object' || gc.type === null) {
+            return false;
+        }
+        return this.#canAdoptType(gc.type, map);
+    }
+    #canAdoptType(c, map = adoptionAnyMap) {
+        return !!map.get(this.type)?.includes(c);
+    }
+    #adoptWithSpace(child, index) {
+        const gc = child.#parts[0];
+        const blank = new _a(null, gc, this.options);
+        blank.#parts.push('');
+        gc.push(blank);
+        this.#adopt(child, index);
+    }
+    #adopt(child, index) {
+        const gc = child.#parts[0];
+        this.#parts.splice(index, 1, ...gc.#parts);
+        for (const p of gc.#parts) {
+            if (typeof p === 'object')
+                p.#parent = this;
+        }
+        this.#toString = undefined;
+    }
+    #canUsurpType(c) {
+        const m = usurpMap.get(this.type);
+        return !!(m?.has(c));
+    }
+    #canUsurp(child) {
+        if (!child ||
+            typeof child !== 'object' ||
+            child.type !== null ||
+            child.#parts.length !== 1 ||
+            this.type === null ||
+            this.#parts.length !== 1) {
+            return false;
+        }
+        const gc = child.#parts[0];
+        if (!gc || typeof gc !== 'object' || gc.type === null) {
+            return false;
+        }
+        return this.#canUsurpType(gc.type);
+    }
+    #usurp(child) {
+        const m = usurpMap.get(this.type);
+        const gc = child.#parts[0];
+        const nt = m?.get(gc.type);
+        /* c8 ignore start - impossible */
+        if (!nt)
+            return false;
+        /* c8 ignore stop */
+        this.#parts = gc.#parts;
+        for (const p of this.#parts) {
+            if (typeof p === 'object') {
+                p.#parent = this;
+            }
+        }
+        this.type = nt;
+        this.#toString = undefined;
+        this.#emptyExt = false;
+    }
     static fromGlob(pattern, options = {}) {
-        const ast = new AST(null, undefined, options);
-        AST.#parseAST(pattern, ast, 0, options);
+        const ast = new _a(null, undefined, options);
+        _a.#parseAST(pattern, ast, 0, options, 0);
         return ast;
     }
     // returns the regular expression if there's magic, or the unescaped
@@ -20805,16 +21050,18 @@ class AST {
     // or start or whatever) and prepend ^ or / at the Regexp construction.
     toRegExpSource(allowDot) {
         const dot = allowDot ?? !!this.#options.dot;
-        if (this.#root === this)
+        if (this.#root === this) {
+            this.#flatten();
             this.#fillNegs();
-        if (!this.type) {
+        }
+        if (!isExtglobAST(this)) {
             const noEmpty = this.isStart() &&
                 this.isEnd() &&
                 !this.#parts.some(s => typeof s !== 'string');
             const src = this.#parts
                 .map(p => {
                 const [re, _, hasMagic, uflag] = typeof p === 'string' ?
-                    AST.#parseGlob(p, this.#hasMagic, noEmpty)
+                    _a.#parseGlob(p, this.#hasMagic, noEmpty)
                     : p.toRegExpSource(allowDot);
                 this.#hasMagic = this.#hasMagic || hasMagic;
                 this.#uflag = this.#uflag || uflag;
@@ -20876,12 +21123,12 @@ class AST {
             // invalid extglob, has to at least be *something* present, if it's
             // the entire path portion.
             const s = this.toString();
-            this.#parts = [s];
-            this.type = null;
-            this.#hasMagic = undefined;
+            const me = this;
+            me.#parts = [s];
+            me.type = null;
+            me.#hasMagic = undefined;
             return [s, unescape(this.toString()), false, false];
         }
-        // XXX abstract out this map method
         let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ?
             ''
             : this.#partsToRegExp(true);
@@ -20917,6 +21164,42 @@ class AST {
             this.#uflag,
         ];
     }
+    #flatten() {
+        if (!isExtglobAST(this)) {
+            for (const p of this.#parts) {
+                if (typeof p === 'object') {
+                    p.#flatten();
+                }
+            }
+        }
+        else {
+            // do up to 10 passes to flatten as much as possible
+            let iterations = 0;
+            let done = false;
+            do {
+                done = true;
+                for (let i = 0; i < this.#parts.length; i++) {
+                    const c = this.#parts[i];
+                    if (typeof c === 'object') {
+                        c.#flatten();
+                        if (this.#canAdopt(c)) {
+                            done = false;
+                            this.#adopt(c, i);
+                        }
+                        else if (this.#canAdoptWithSpace(c)) {
+                            done = false;
+                            this.#adoptWithSpace(c, i);
+                        }
+                        else if (this.#canUsurp(c)) {
+                            done = false;
+                            this.#usurp(c);
+                        }
+                    }
+                }
+            } while (!done && ++iterations < 10);
+        }
+        this.#toString = undefined;
+    }
     #partsToRegExp(dot) {
         return this.#parts
             .map(p => {
@@ -20987,6 +21270,7 @@ class AST {
         return [re, unescape(glob), !!hasMagic, uflag];
     }
 }
+_a = AST;
 
 /**
  * Escape all magic characters in a glob pattern.
@@ -21204,11 +21488,13 @@ class Minimatch {
     isWindows;
     platform;
     windowsNoMagicRoot;
+    maxGlobstarRecursion;
     regexp;
     constructor(pattern, options = {}) {
         assertValidPattern(pattern);
         options = options || {};
         this.options = options;
+        this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
         this.pattern = pattern;
         this.platform = options.platform || defaultPlatform;
         this.isWindows = this.platform === 'win32';
@@ -21613,7 +21899,8 @@ class Minimatch {
     // out of pattern, then that's fine, as long as all
     // the parts match.
     matchOne(file, pattern, partial = false) {
-        const options = this.options;
+        let fileStartIndex = 0;
+        let patternStartIndex = 0;
         // UNC paths like //?/X:/... can match X:/... and vice versa
         // Drive letters in absolute drive or unc paths are always compared
         // case-insensitively.
@@ -21642,14 +21929,11 @@ class Minimatch {
                     file[fdi],
                     pattern[pdi],
                 ];
+                // start matching at the drive letter index of each
                 if (fd.toLowerCase() === pd.toLowerCase()) {
                     pattern[pdi] = fd;
-                    if (pdi > fdi) {
-                        pattern = pattern.slice(pdi);
-                    }
-                    else if (fdi > pdi) {
-                        file = file.slice(fdi);
-                    }
+                    patternStartIndex = pdi;
+                    fileStartIndex = fdi;
                 }
             }
         }
@@ -21659,99 +21943,185 @@ class Minimatch {
         if (optimizationLevel >= 2) {
             file = this.levelTwoFileOptimize(file);
         }
-        this.debug('matchOne', this, { file, pattern });
-        this.debug('matchOne', file.length, pattern.length);
-        for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+        if (pattern.includes(GLOBSTAR)) {
+            return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+        }
+        return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+    }
+    #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+        // split the pattern into head, tail, and middle of ** delimited parts
+        const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+        const lastgs = pattern.lastIndexOf(GLOBSTAR);
+        // split the pattern up into globstar-delimited sections
+        // the tail has to be at the end, and the others just have
+        // to be found in order from the head.
+        const [head, body, tail] = partial ? [
+            pattern.slice(patternIndex, firstgs),
+            pattern.slice(firstgs + 1),
+            [],
+        ] : [
+            pattern.slice(patternIndex, firstgs),
+            pattern.slice(firstgs + 1, lastgs),
+            pattern.slice(lastgs + 1),
+        ];
+        // check the head, from the current file/pattern index.
+        if (head.length) {
+            const fileHead = file.slice(fileIndex, fileIndex + head.length);
+            if (!this.#matchOne(fileHead, head, partial, 0, 0)) {
+                return false;
+            }
+            fileIndex += head.length;
+            patternIndex += head.length;
+        }
+        // now we know the head matches!
+        // if the last portion is not empty, it MUST match the end
+        // check the tail
+        let fileTailMatch = 0;
+        if (tail.length) {
+            // if head + tail > file, then we cannot possibly match
+            if (tail.length + fileIndex > file.length)
+                return false;
+            // try to match the tail
+            let tailStart = file.length - tail.length;
+            if (this.#matchOne(file, tail, partial, tailStart, 0)) {
+                fileTailMatch = tail.length;
+            }
+            else {
+                // affordance for stuff like a/**/* matching a/b/
+                // if the last file portion is '', and there's more to the pattern
+                // then try without the '' bit.
+                if (file[file.length - 1] !== '' ||
+                    fileIndex + tail.length === file.length) {
+                    return false;
+                }
+                tailStart--;
+                if (!this.#matchOne(file, tail, partial, tailStart, 0)) {
+                    return false;
+                }
+                fileTailMatch = tail.length + 1;
+            }
+        }
+        // now we know the tail matches!
+        // the middle is zero or more portions wrapped in **, possibly
+        // containing more ** sections.
+        // so a/**/b/**/c/**/d has become **/b/**/c/**
+        // if it's empty, it means a/**/b, just verify we have no bad dots
+        // if there's no tail, so it ends on /**, then we must have *something*
+        // after the head, or it's not a matc
+        if (!body.length) {
+            let sawSome = !!fileTailMatch;
+            for (let i = fileIndex; i < file.length - fileTailMatch; i++) {
+                const f = String(file[i]);
+                sawSome = true;
+                if (f === '.' ||
+                    f === '..' ||
+                    (!this.options.dot && f.startsWith('.'))) {
+                    return false;
+                }
+            }
+            // in partial mode, we just need to get past all file parts
+            return partial || sawSome;
+        }
+        // now we know that there's one or more body sections, which can
+        // be matched anywhere from the 0 index (because the head was pruned)
+        // through to the length-fileTailMatch index.
+        // split the body up into sections, and note the minimum index it can
+        // be found at (start with the length of all previous segments)
+        // [section, before, after]
+        const bodySegments = [[[], 0]];
+        let currentBody = bodySegments[0];
+        let nonGsParts = 0;
+        const nonGsPartsSums = [0];
+        for (const b of body) {
+            if (b === GLOBSTAR) {
+                nonGsPartsSums.push(nonGsParts);
+                currentBody = [[], 0];
+                bodySegments.push(currentBody);
+            }
+            else {
+                currentBody[0].push(b);
+                nonGsParts++;
+            }
+        }
+        let i = bodySegments.length - 1;
+        const fileLength = file.length - fileTailMatch;
+        for (const b of bodySegments) {
+            b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
+        }
+        return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+    }
+    // return false for "nope, not matching"
+    // return null for "not matching, cannot keep trying"
+    #matchGlobStarBodySections(file, 
+    // pattern section, last possible position for it
+    bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+        // take the first body segment, and walk from fileIndex to its "after"
+        // value at the end
+        // If it doesn't match at that position, we increment, until we hit
+        // that final possible position, and give up.
+        // If it does match, then advance and try to rest.
+        // If any of them fail we keep walking forward.
+        // this is still a bit recursively painful, but it's more constrained
+        // than previous implementations, because we never test something that
+        // can't possibly be a valid matching condition.
+        const bs = bodySegments[bodyIndex];
+        if (!bs) {
+            // just make sure that there's no bad dots
+            for (let i = fileIndex; i < file.length; i++) {
+                sawTail = true;
+                const f = file[i];
+                if (f === '.' ||
+                    f === '..' ||
+                    (!this.options.dot && f.startsWith('.'))) {
+                    return false;
+                }
+            }
+            return sawTail;
+        }
+        // have a non-globstar body section to test
+        const [body, after] = bs;
+        while (fileIndex <= after) {
+            const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+            // if limit exceeded, no match. intentional false negative,
+            // acceptable break in correctness for security.
+            if (m && globStarDepth < this.maxGlobstarRecursion) {
+                // match! see if the rest match. if so, we're done!
+                const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+                if (sub !== false) {
+                    return sub;
+                }
+            }
+            const f = file[fileIndex];
+            if (f === '.' ||
+                f === '..' ||
+                (!this.options.dot && f.startsWith('.'))) {
+                return false;
+            }
+            fileIndex++;
+        }
+        // walked off. no point continuing
+        return partial || null;
+    }
+    #matchOne(file, pattern, partial, fileIndex, patternIndex) {
+        let fi;
+        let pi;
+        let pl;
+        let fl;
+        for (fi = fileIndex,
+            pi = patternIndex,
+            fl = file.length,
+            pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
             this.debug('matchOne loop');
-            var p = pattern[pi];
-            var f = file[fi];
+            let p = pattern[pi];
+            let f = file[fi];
             this.debug(pattern, p, f);
             // should be impossible.
             // some invalid regexp stuff in the set.
             /* c8 ignore start */
-            if (p === false) {
+            if (p === false || p === GLOBSTAR) {
                 return false;
             }
             /* c8 ignore stop */
-            if (p === GLOBSTAR) {
-                this.debug('GLOBSTAR', [pattern, p, f]);
-                // "**"
-                // a/**/b/**/c would match the following:
-                // a/b/x/y/z/c
-                // a/x/y/z/b/c
-                // a/b/x/b/x/c
-                // a/b/c
-                // To do this, take the rest of the pattern after
-                // the **, and see if it would match the file remainder.
-                // If so, return success.
-                // If not, the ** "swallows" a segment, and try again.
-                // This is recursively awful.
-                //
-                // a/**/b/**/c matching a/b/x/y/z/c
-                // - a matches a
-                // - doublestar
-                //   - matchOne(b/x/y/z/c, b/**/c)
-                //     - b matches b
-                //     - doublestar
-                //       - matchOne(x/y/z/c, c) -> no
-                //       - matchOne(y/z/c, c) -> no
-                //       - matchOne(z/c, c) -> no
-                //       - matchOne(c, c) yes, hit
-                var fr = fi;
-                var pr = pi + 1;
-                if (pr === pl) {
-                    this.debug('** at the end');
-                    // a ** at the end will just swallow the rest.
-                    // We have found a match.
-                    // however, it will not swallow /.x, unless
-                    // options.dot is set.
-                    // . and .. are *never* matched by **, for explosively
-                    // exponential reasons.
-                    for (; fi < fl; fi++) {
-                        if (file[fi] === '.' ||
-                            file[fi] === '..' ||
-                            (!options.dot && file[fi].charAt(0) === '.'))
-                            return false;
-                    }
-                    return true;
-                }
-                // ok, let's see if we can swallow whatever we can.
-                while (fr < fl) {
-                    var swallowee = file[fr];
-                    this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
-                    // XXX remove this slice.  Just pass the start index.
-                    if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-                        this.debug('globstar found match!', fr, fl, swallowee);
-                        // found a match.
-                        return true;
-                    }
-                    else {
-                        // can't swallow "." or ".." ever.
-                        // can only swallow ".foo" when explicitly asked.
-                        if (swallowee === '.' ||
-                            swallowee === '..' ||
-                            (!options.dot && swallowee.charAt(0) === '.')) {
-                            this.debug('dot detected!', file, fr, pattern, pr);
-                            break;
-                        }
-                        // ** swallows a segment, and continue.
-                        this.debug('globstar swallow a segment, and continue');
-                        fr++;
-                    }
-                }
-                // no match was found.
-                // However, in partial mode, we can't say this is necessarily over.
-                /* c8 ignore start */
-                if (partial) {
-                    // ran out of file
-                    this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
-                    if (fr === fl) {
-                        return true;
-                    }
-                }
-                /* c8 ignore stop */
-                return false;
-            }
             // something other than **
             // non-magic patterns just have to match exactly
             // patterns with magic have been turned into regexps.
@@ -23575,9 +23945,9 @@ function processDefineModel(ctx, node, declId) {
   let modelName;
   let options;
   const arg0 = node.arguments[0] && CompilerDOM.unwrapTSNode(node.arguments[0]);
-  const hasName = arg0 && arg0.type === "StringLiteral";
+  const hasName = arg0 && (arg0.type === "StringLiteral" || arg0.type === "TemplateLiteral" && arg0.expressions.length === 0);
   if (hasName) {
-    modelName = arg0.value;
+    modelName = arg0.type === "StringLiteral" ? arg0.value : arg0.quasis[0].value.cooked;
     options = node.arguments[1];
   } else {
     modelName = "modelValue";
@@ -25213,7 +25583,7 @@ function mergeSourceMaps(scriptMap, templateMap, templateLineOffset) {
   return generator.toJSON();
 }
 
-const version = "3.5.29";
+const version = "3.5.31";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,

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

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.29
+* @vue/compiler-sfc v3.5.31
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -15949,7 +15949,7 @@ function requireLib () {
 	              this.next();
 	              return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));
 	            } else if (tokenIsIdentifier(type)) {
-	              if (this.lookaheadCharCode() === 61) {
+	              if (canBeArrow && this.lookaheadCharCode() === 61) {
 	                return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
 	              } else {
 	                return id;
@@ -26096,7 +26096,7 @@ const transformFor = createStructuralDirectiveTransform(
           loop.body = createBlockStatement([
             createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
             createCompoundExpression([
-              `if (_cached`,
+              `if (_cached && _cached.el`,
               ...keyExp ? [` && _cached.key === `, keyExp] : [],
               ` && ${context.helperString(
                 IS_MEMO_SAME
@@ -31697,7 +31697,7 @@ var _polyfillNode_url$1 = /*#__PURE__*/Object.freeze({
 
 function isRelativeUrl(url) {
   const firstChar = url.charAt(0);
-  return firstChar === "." || firstChar === "~" || firstChar === "@";
+  return firstChar === "." || firstChar === "~" || firstChar === "@" || firstChar === "#";
 }
 const externalRE = /^(?:https?:)?\/\//;
 function isExternalUrl(url) {
@@ -31707,6 +31707,13 @@ const dataUrlRE = /^\s*data:/i;
 function isDataUrl(url) {
   return dataUrlRE.test(url);
 }
+function normalizeDecodedImportPath(source) {
+  try {
+    return decodeURIComponent(source);
+  } catch (e) {
+    return source;
+  }
+}
 function parseUrl(url) {
   const firstChar = url.charAt(0);
   if (firstChar === "~") {
@@ -31738,16 +31745,18 @@ var __spreadValues$9 = (a, b) => {
   return a;
 };
 var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+const resourceUrlTagConfig = {
+  video: ["src", "poster"],
+  source: ["src"],
+  img: ["src"],
+  image: ["xlink:href", "href"]
+};
 const defaultAssetUrlOptions = {
   base: null,
   includeAbsolute: false,
-  tags: {
-    video: ["src", "poster"],
-    source: ["src"],
-    img: ["src"],
-    image: ["xlink:href", "href"],
+  tags: __spreadProps$8(__spreadValues$9({}, resourceUrlTagConfig), {
     use: ["xlink:href", "href"]
-  }
+  })
 };
 const normalizeOptions = (options) => {
   if (Object.keys(options).some((key) => isArray$3(options[key]))) {
@@ -31760,6 +31769,10 @@ const normalizeOptions = (options) => {
 const createAssetUrlTransformWithOptions = (options) => {
   return (node, context) => transformAssetUrl(node, context, options);
 };
+function canTransformHashImport(tag, attrName) {
+  var _a;
+  return !!((_a = resourceUrlTagConfig[tag]) == null ? void 0 : _a.includes(attrName));
+}
 const transformAssetUrl = (node, context, options = defaultAssetUrlOptions) => {
   if (node.type === 1) {
     if (!node.props.length) {
@@ -31773,11 +31786,16 @@ const transformAssetUrl = (node, context, options = defaultAssetUrlOptions) => {
     }
     const assetAttrs = (attrs || []).concat(wildCardAttrs || []);
     node.props.forEach((attr, index) => {
-      if (attr.type !== 6 || !assetAttrs.includes(attr.name) || !attr.value || isExternalUrl(attr.value.content) || isDataUrl(attr.value.content) || attr.value.content[0] === "#" || !options.includeAbsolute && !isRelativeUrl(attr.value.content)) {
+      if (attr.type !== 6 || !assetAttrs.includes(attr.name) || !attr.value) {
         return;
       }
-      const url = parseUrl(attr.value.content);
-      if (options.base && attr.value.content[0] === ".") {
+      const urlValue = attr.value.content;
+      const isHashOnlyValue = urlValue[0] === "#";
+      if (isExternalUrl(urlValue) || isDataUrl(urlValue) || isHashOnlyValue && !canTransformHashImport(node.tag, attr.name) || !options.includeAbsolute && !isRelativeUrl(urlValue)) {
+        return;
+      }
+      const url = parseUrl(urlValue);
+      if (options.base && urlValue[0] === ".") {
         const base = parseUrl(options.base);
         const protocol = base.protocol || "";
         const host = base.host ? protocol + "//" + base.host : "";
@@ -31797,55 +31815,65 @@ const transformAssetUrl = (node, context, options = defaultAssetUrlOptions) => {
     });
   }
 };
+function resolveOrRegisterImport(source, loc, context) {
+  const normalizedSource = normalizeDecodedImportPath(source);
+  const existingIndex = context.imports.findIndex(
+    (i) => i.path === normalizedSource
+  );
+  if (existingIndex > -1) {
+    return {
+      name: `_imports_${existingIndex}`,
+      exp: context.imports[existingIndex].exp
+    };
+  }
+  const name = `_imports_${context.imports.length}`;
+  const exp = createSimpleExpression(
+    name,
+    false,
+    loc,
+    3
+  );
+  context.imports.push({
+    exp,
+    path: normalizedSource
+  });
+  return { name, exp };
+}
 function getImportsExpressionExp(path2, hash, loc, context) {
-  if (path2) {
-    let name;
-    let exp;
-    const existingIndex = context.imports.findIndex((i) => i.path === path2);
-    if (existingIndex > -1) {
-      name = `_imports_${existingIndex}`;
-      exp = context.imports[existingIndex].exp;
-    } else {
-      name = `_imports_${context.imports.length}`;
-      exp = createSimpleExpression(
-        name,
-        false,
-        loc,
-        3
-      );
-      context.imports.push({
-        exp,
-        path: decodeURIComponent(path2)
-      });
-    }
-    if (!hash) {
-      return exp;
-    }
-    const hashExp = `${name} + '${hash}'`;
-    const finalExp = createSimpleExpression(
-      hashExp,
+  if (!path2 && !hash) {
+    return createSimpleExpression(`''`, false, loc, 3);
+  }
+  if (!path2 && hash) {
+    const { exp } = resolveOrRegisterImport(hash, loc, context);
+    return exp;
+  }
+  if (path2 && !hash) {
+    const { exp } = resolveOrRegisterImport(path2, loc, context);
+    return exp;
+  }
+  const { name } = resolveOrRegisterImport(path2, loc, context);
+  const hashExp = `${name} + '${hash}'`;
+  const finalExp = createSimpleExpression(
+    hashExp,
+    false,
+    loc,
+    3
+  );
+  if (!context.hoistStatic) {
+    return finalExp;
+  }
+  const existingHoistIndex = context.hoists.findIndex((h) => {
+    return h && h.type === 4 && !h.isStatic && h.content === hashExp;
+  });
+  if (existingHoistIndex > -1) {
+    return createSimpleExpression(
+      `_hoisted_${existingHoistIndex + 1}`,
       false,
       loc,
       3
     );
-    if (!context.hoistStatic) {
-      return finalExp;
-    }
-    const existingHoistIndex = context.hoists.findIndex((h) => {
-      return h && h.type === 4 && !h.isStatic && h.content === hashExp;
-    });
-    if (existingHoistIndex > -1) {
-      return createSimpleExpression(
-        `_hoisted_${existingHoistIndex + 1}`,
-        false,
-        loc,
-        3
-      );
-    }
-    return context.hoist(finalExp);
-  } else {
-    return createSimpleExpression(`''`, false, loc, 3);
   }
+  return context.hoist(finalExp);
 }
 
 const srcsetTags = ["img", "source"];
@@ -31902,12 +31930,14 @@ const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
           const compoundExpression = createCompoundExpression([], attr.loc);
           imageCandidates.forEach(({ url, descriptor }, index2) => {
             if (shouldProcessUrl(url)) {
-              const { path: path2 } = parseUrl(url);
-              let exp2;
-              if (path2) {
+              const { path: path2, hash } = parseUrl(url);
+              const source = path2 ? path2 : hash;
+              if (source) {
+                const normalizedSource = normalizeDecodedImportPath(source);
                 const existingImportsIndex = context.imports.findIndex(
-                  (i) => i.path === path2
+                  (i) => i.path === normalizedSource
                 );
+                let exp2;
                 if (existingImportsIndex > -1) {
                   exp2 = createSimpleExpression(
                     `_imports_${existingImportsIndex}`,
@@ -31922,7 +31952,15 @@ const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
                     attr.loc,
                     3
                   );
-                  context.imports.push({ exp: exp2, path: path2 });
+                  context.imports.push({ exp: exp2, path: normalizedSource });
+                }
+                if (path2 && hash) {
+                  exp2 = createSimpleExpression(
+                    `${exp2.content} + '${hash}'`,
+                    false,
+                    attr.loc,
+                    3
+                  );
                 }
                 compoundExpression.children.push(exp2);
               }
@@ -36442,7 +36480,15 @@ function requireMapGenerator () {
 	        }
 	      }
 	    } else if (this.css) {
-	      this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, '');
+	      let startIndex;
+	      while ((startIndex = this.css.lastIndexOf('/*#')) !== -1) {
+	        let endIndex = this.css.indexOf('*/', startIndex + 3);
+	        if (endIndex === -1) break
+	        while (startIndex > 0 && this.css[startIndex - 1] === '\n') {
+	          startIndex--;
+	        }
+	        this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2);
+	      }
 	    }
 	  }
 
@@ -36919,7 +36965,7 @@ function requireParser$1 () {
 	    node.source.end.offset++;
 
 	    let text = token[1].slice(2, -2);
-	    if (/^\s*$/.test(text)) {
+	    if (!text.trim()) {
 	      node.text = '';
 	      node.raws.left = text;
 	      node.raws.right = '';
@@ -38152,10 +38198,9 @@ function requireNoWorkResult () {
 	    this._css = css;
 	    this._opts = opts;
 	    this._map = undefined;
-	    let root;
 
 	    let str = stringify;
-	    this.result = new Result(this._processor, root, this._opts);
+	    this.result = new Result(this._processor, undefined, this._opts);
 	    this.result.css = css;
 
 	    let self = this;
@@ -38165,7 +38210,7 @@ function requireNoWorkResult () {
 	      }
 	    });
 
-	    let map = new MapGenerator(str, root, this._opts, css);
+	    let map = new MapGenerator(str, undefined, this._opts, css);
 	    if (map.isMap()) {
 	      let [generatedCSS, generatedMap] = map.generate();
 	      if (generatedCSS) {
@@ -38240,7 +38285,7 @@ function requireProcessor$1 () {
 
 	class Processor {
 	  constructor(plugins = []) {
-	    this.version = '8.5.6';
+	    this.version = '8.5.8';
 	    this.plugins = this.normalize(plugins);
 	  }
 
@@ -49110,9 +49155,9 @@ function processDefineModel(ctx, node, declId) {
   let modelName;
   let options;
   const arg0 = node.arguments[0] && unwrapTSNode(node.arguments[0]);
-  const hasName = arg0 && arg0.type === "StringLiteral";
+  const hasName = arg0 && (arg0.type === "StringLiteral" || arg0.type === "TemplateLiteral" && arg0.expressions.length === 0);
   if (hasName) {
-    modelName = arg0.value;
+    modelName = arg0.type === "StringLiteral" ? arg0.value : arg0.quasis[0].value.cooked;
     options = node.arguments[1];
   } else {
     modelName = "modelValue";
@@ -50778,7 +50823,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.5.29";
+const version = "3.5.31";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "3.5.29",
+  "version": "3.5.31",
   "description": "@vue/compiler-sfc",
   "main": "dist/compiler-sfc.cjs.js",
   "module": "dist/compiler-sfc.esm-browser.js",
@@ -42,15 +42,15 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-sfc#readme",
   "dependencies": {
-    "@babel/parser": "^7.29.0",
+    "@babel/parser": "^7.29.2",
     "estree-walker": "^2.0.2",
     "magic-string": "^0.30.21",
-    "postcss": "^8.5.6",
+    "postcss": "^8.5.8",
     "source-map-js": "^1.2.1",
-    "@vue/shared": "3.5.29",
-    "@vue/compiler-ssr": "3.5.29",
-    "@vue/compiler-core": "3.5.29",
-    "@vue/compiler-dom": "3.5.29"
+    "@vue/compiler-core": "3.5.31",
+    "@vue/compiler-dom": "3.5.31",
+    "@vue/shared": "3.5.31",
+    "@vue/compiler-ssr": "3.5.31"
   },
   "devDependencies": {
     "@babel/types": "^7.29.0",
@@ -58,10 +58,10 @@
     "hash-sum": "^2.0.0",
     "lru-cache": "10.1.0",
     "merge-source-map": "^1.1.0",
-    "minimatch": "~10.2.0",
+    "minimatch": "~10.2.4",
     "postcss-modules": "^6.0.1",
     "postcss-selector-parser": "^7.1.1",
-    "pug": "^3.0.3",
-    "sass": "^1.97.3"
+    "pug": "^3.0.4",
+    "sass": "^1.98.0"
   }
 }