@vue/compiler-sfc 3.3.8 → 3.3.10

package/README.md

@@ -4,7 +4,7 @@
 
 **Note: as of 3.2.13+, this package is included as a dependency of the main `vue` package and can be accessed as `vue/compiler-sfc`. This means you no longer need to explicitly install this package and ensure its version match that of `vue`'s. Just use the main `vue/compiler-sfc` deep import instead.**
 
-This package contains lower level utilities that you can use if you are writing a plugin / transform for a bundler or module system that compiles Vue Single File Components (SFCs) into JavaScript. It is used in [vue-loader](https://github.com/vuejs/vue-loader), [rollup-plugin-vue](https://github.com/vuejs/rollup-plugin-vue) and [vite](https://github.com/vitejs/vite).
+This package contains lower level utilities that you can use if you are writing a plugin / transform for a bundler or module system that compiles Vue Single File Components (SFCs) into JavaScript. It is used in [vue-loader](https://github.com/vuejs/vue-loader) and [@vitejs/plugin-vue](https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue).
 
 ## API
 
@@ -77,4 +77,4 @@ export default script
 
 Options needed for these APIs can be passed via the query string.
 
-For detailed API references and options, check out the source type definitions. For actual usage of these APIs, check out [rollup-plugin-vue](https://github.com/vuejs/rollup-plugin-vue/tree/next) or [vue-loader](https://github.com/vuejs/vue-loader/tree/next).
+For detailed API references and options, check out the source type definitions. For actual usage of these APIs, check out [@vitejs/plugin-vue](https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue) or [vue-loader](https://github.com/vuejs/vue-loader/tree/next).

package/dist/compiler-sfc.cjs.js

@@ -16,6 +16,7 @@ var require$$0$1 = require('postcss');
 var estreeWalker = require('estree-walker');
 var reactivityTransform = require('@vue/reactivity-transform');
 var MagicString = require('magic-string');
+var process$1 = require('process');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -30,6 +31,7 @@ function _interopNamespaceDefault(e) {
 
 var CompilerDOM__namespace = /*#__PURE__*/_interopNamespaceDefault(CompilerDOM);
 var CompilerSSR__namespace = /*#__PURE__*/_interopNamespaceDefault(CompilerSSR);
+var process__namespace = /*#__PURE__*/_interopNamespaceDefault(process$1);
 
 const UNKNOWN_TYPE = "Unknown";
 function resolveObjectKey(node, computed) {
@@ -87,9 +89,16 @@ function normalizePath(p) {
   return normalize(p.replace(windowsSlashRE, "/"));
 }
 const joinPaths = (path$3.posix || path$3).join;
-const escapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
-function getEscapedKey(key) {
-  return escapeSymbolsRE.test(key) ? JSON.stringify(key) : key;
+const propNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~\-]/;
+function getEscapedPropName(key) {
+  return propNameEscapeSymbolsRE.test(key) ? JSON.stringify(key) : key;
+}
+const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
+function getEscapedCssVarName(key, doubleEscape) {
+  return key.replace(
+    cssVarNameEscapeSymbolsRE,
+    (s) => doubleEscape ? `\\\\${s}` : `\\${s}`
+  );
 }
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -172,15 +181,15 @@ const CSS_VARS_HELPER = `useCssVars`;
 function genCssVarsFromList(vars, id, isProd, isSSR = false) {
   return `{
   ${vars.map(
-    (key) => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd)}": (${key})`
+    (key) => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd, isSSR)}": (${key})`
   ).join(",\n  ")}
 }`;
 }
-function genVarName(id, raw, isProd) {
+function genVarName(id, raw, isProd, isSSR = false) {
   if (isProd) {
     return hash$1(id + raw);
   } else {
-    return `${id}-${raw.replace(escapeSymbolsRE, (s) => `\\${s}`)}`;
+    return `${id}-${getEscapedCssVarName(raw, isSSR)}`;
   }
 }
 function normalizeExpression(exp) {
@@ -734,6 +743,9 @@ class LRUCache {
             if (ttls[index]) {
                 const ttl = ttls[index];
                 const start = starts[index];
+                /* c8 ignore next */
+                if (!ttl || !start)
+                    return;
                 status.ttl = ttl;
                 status.start = start;
                 status.now = cachedNow || getNow();
@@ -765,16 +777,16 @@ class LRUCache {
             }
             const ttl = ttls[index];
             const start = starts[index];
-            if (ttl === 0 || start === 0) {
+            if (!ttl || !start) {
                 return Infinity;
             }
             const age = (cachedNow || getNow()) - start;
             return ttl - age;
         };
         this.#isStale = index => {
-            return (ttls[index] !== 0 &&
-                starts[index] !== 0 &&
-                (cachedNow || getNow()) - starts[index] > ttls[index]);
+            const s = starts[index];
+            const t = ttls[index];
+            return !!t && !!s && (cachedNow || getNow()) - s > t;
         };
     }
     // conditionally set private methods related to TTL
@@ -1032,6 +1044,37 @@ class LRUCache {
         }
         return deleted;
     }
+    /**
+     * Get the extended info about a given entry, to get its value, size, and
+     * TTL info simultaneously. Like {@link LRUCache#dump}, but just for a
+     * single key. Always returns stale values, if their info is found in the
+     * cache, so be sure to check for expired TTLs if relevant.
+     */
+    info(key) {
+        const i = this.#keyMap.get(key);
+        if (i === undefined)
+            return undefined;
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v)
+            ? v.__staleWhileFetching
+            : v;
+        if (value === undefined)
+            return undefined;
+        const entry = { value };
+        if (this.#ttls && this.#starts) {
+            const ttl = this.#ttls[i];
+            const start = this.#starts[i];
+            if (ttl && start) {
+                const remain = ttl - (perf.now() - start);
+                entry.ttl = remain;
+                entry.start = Date.now();
+            }
+        }
+        if (this.#sizes) {
+            entry.size = this.#sizes[i];
+        }
+        return entry;
+    }
     /**
      * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
      * passed to cache.load()
@@ -1298,12 +1341,13 @@ class LRUCache {
     peek(k, peekOptions = {}) {
         const { allowStale = this.allowStale } = peekOptions;
         const index = this.#keyMap.get(k);
-        if (index !== undefined &&
-            (allowStale || !this.#isStale(index))) {
-            const v = this.#valList[index];
-            // either stale and allowed, or forcing a refresh of non-stale value
-            return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (index === undefined ||
+            (!allowStale && this.#isStale(index))) {
+            return;
         }
+        const v = this.#valList[index];
+        // either stale and allowed, or forcing a refresh of non-stale value
+        return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
     }
     #backgroundFetch(k, index, options, context) {
         const v = index === undefined ? undefined : this.#valList[index];
@@ -1639,8 +1683,10 @@ class LRUCache {
                         this.#head = this.#next[index];
                     }
                     else {
-                        this.#next[this.#prev[index]] = this.#next[index];
-                        this.#prev[this.#next[index]] = this.#prev[index];
+                        const pi = this.#prev[index];
+                        this.#next[pi] = this.#next[index];
+                        const ni = this.#next[index];
+                        this.#prev[ni] = this.#prev[index];
                     }
                     this.#size--;
                     this.#free.push(index);
@@ -1761,7 +1807,6 @@ function resolveTemplateUsageCheckString(sfc) {
   templateUsageCheckCache.set(content, code);
   return code;
 }
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
 function processExp(exp, dir) {
   if (/ as\s+\w|<.*>|:/.test(exp)) {
     if (dir === "slot") {
@@ -1769,7 +1814,7 @@ function processExp(exp, dir) {
     } else if (dir === "on") {
       exp = `()=>{return ${exp}}`;
     } else if (dir === "for") {
-      const inMatch = exp.match(forAliasRE);
+      const inMatch = exp.match(CompilerDOM.forAliasRE);
       if (inMatch) {
         let [, LHS, RHS] = inMatch;
         LHS = LHS.trim().replace(/^\(|\)$/g, "");
@@ -1924,22 +1969,29 @@ function parse$2(source, {
       descriptor.script = null;
     }
   }
+  let templateColumnOffset = 0;
+  if (descriptor.template && (descriptor.template.lang === "pug" || descriptor.template.lang === "jade")) {
+    [descriptor.template.content, templateColumnOffset] = dedent(
+      descriptor.template.content
+    );
+  }
   if (sourceMap) {
-    const genMap = (block) => {
+    const genMap = (block, columnOffset = 0) => {
       if (block && !block.src) {
         block.map = generateSourceMap(
           filename,
           source,
           block.content,
           sourceRoot,
-          !pad || block.type === "template" ? block.loc.start.line - 1 : 0
+          !pad || block.type === "template" ? block.loc.start.line - 1 : 0,
+          columnOffset
         );
       }
     };
-    genMap(descriptor.template);
+    genMap(descriptor.template, templateColumnOffset);
     genMap(descriptor.script);
-    descriptor.styles.forEach(genMap);
-    descriptor.customBlocks.forEach(genMap);
+    descriptor.styles.forEach((s) => genMap(s));
+    descriptor.customBlocks.forEach((s) => genMap(s));
   }
   descriptor.cssVars = parseCssVars(descriptor);
   const slottedRE = /(?:::v-|:)slotted\(/;
@@ -2017,7 +2069,7 @@ function createBlock(node, source, pad) {
 const splitRE = /\r?\n/g;
 const emptyRE = /^(?:\/\/)?\s*$/;
 const replaceRE = /./g;
-function generateSourceMap(filename, source, generated, sourceRoot, lineOffset) {
+function generateSourceMap(filename, source, generated, sourceRoot, lineOffset, columnOffset) {
   const map = new sourceMapJs.SourceMapGenerator({
     file: filename.replace(/\\/g, "/"),
     sourceRoot: sourceRoot.replace(/\\/g, "/")
@@ -2033,7 +2085,7 @@ function generateSourceMap(filename, source, generated, sourceRoot, lineOffset)
             source: filename,
             original: {
               line: originalLine,
-              column: i
+              column: i + columnOffset
             },
             generated: {
               line: generatedLine,
@@ -2084,6 +2136,26 @@ function hmrShouldReload(prevImports, next) {
   }
   return false;
 }
+function dedent(s) {
+  const lines = s.split("\n");
+  const minIndent = lines.reduce(function(minIndent2, line) {
+    var _a, _b;
+    if (line.trim() === "") {
+      return minIndent2;
+    }
+    const indent = ((_b = (_a = line.match(/^\s*/)) == null ? void 0 : _a[0]) == null ? void 0 : _b.length) || 0;
+    return Math.min(indent, minIndent2);
+  }, Infinity);
+  if (minIndent === 0) {
+    return [s, minIndent];
+  }
+  return [
+    lines.map(function(line) {
+      return line.slice(minIndent);
+    }).join("\n"),
+    minIndent
+  ];
+}
 
 function isRelativeUrl(url) {
   const firstChar = url.charAt(0);
@@ -7898,10 +7970,19 @@ function rewriteSelector(id, selector, selectorRoot, slotted = false) {
         return false;
       }
     }
-    if (n.type !== "pseudo" && n.type !== "combinator") {
+    if (n.type !== "pseudo" && n.type !== "combinator" || n.type === "pseudo" && (n.value === ":is" || n.value === ":where")) {
       node = n;
     }
   });
+  if (node) {
+    const { type, value } = node;
+    if (type === "pseudo" && (value === ":is" || value === ":where")) {
+      node.nodes.forEach(
+        (value2) => rewriteSelector(id, value2, selectorRoot, slotted)
+      );
+      shouldInject = false;
+    }
+  }
   if (node) {
     node.spaces.after = "";
   } else {
@@ -15673,7 +15754,7 @@ function resolveParserPlugins(lang, userPlugins, dts = false) {
   }
   if (lang === "ts" || lang === "tsx") {
     plugins.push(["typescript", { dts }]);
-    if (!plugins.includes("decorators")) {
+    if (!userPlugins || !userPlugins.includes("decorators")) {
       plugins.push("decorators-legacy");
     }
   }
@@ -17728,33 +17809,39 @@ class TypeScope {
     this.exportedDeclares = /* @__PURE__ */ Object.create(null);
   }
 }
-function resolveTypeElements(ctx, node, scope) {
+function resolveTypeElements(ctx, node, scope, typeParameters) {
   if (node._resolvedElements) {
     return node._resolvedElements;
   }
   return node._resolvedElements = innerResolveTypeElements(
     ctx,
     node,
-    node._ownerScope || scope || ctxToScope(ctx)
+    node._ownerScope || scope || ctxToScope(ctx),
+    typeParameters
   );
 }
-function innerResolveTypeElements(ctx, node, scope) {
+function innerResolveTypeElements(ctx, node, scope, typeParameters) {
   var _a, _b;
   switch (node.type) {
     case "TSTypeLiteral":
-      return typeElementsToMap(ctx, node.members, scope);
+      return typeElementsToMap(ctx, node.members, scope, typeParameters);
     case "TSInterfaceDeclaration":
-      return resolveInterfaceMembers(ctx, node, scope);
+      return resolveInterfaceMembers(ctx, node, scope, typeParameters);
     case "TSTypeAliasDeclaration":
     case "TSParenthesizedType":
-      return resolveTypeElements(ctx, node.typeAnnotation, scope);
+      return resolveTypeElements(
+        ctx,
+        node.typeAnnotation,
+        scope,
+        typeParameters
+      );
     case "TSFunctionType": {
       return { props: {}, calls: [node] };
     }
     case "TSUnionType":
     case "TSIntersectionType":
       return mergeElements(
-        node.types.map((t) => resolveTypeElements(ctx, t, scope)),
+        node.types.map((t) => resolveTypeElements(ctx, t, scope, typeParameters)),
         node.type
       );
     case "TSMappedType":
@@ -17771,20 +17858,53 @@ function innerResolveTypeElements(ctx, node, scope) {
       const typeName = getReferenceName(node);
       if ((typeName === "ExtractPropTypes" || typeName === "ExtractPublicPropTypes") && node.typeParameters && ((_a = scope.imports[typeName]) == null ? void 0 : _a.source) === "vue") {
         return resolveExtractPropTypes(
-          resolveTypeElements(ctx, node.typeParameters.params[0], scope),
+          resolveTypeElements(
+            ctx,
+            node.typeParameters.params[0],
+            scope,
+            typeParameters
+          ),
           scope
         );
       }
       const resolved = resolveTypeReference(ctx, node, scope);
       if (resolved) {
-        return resolveTypeElements(ctx, resolved, resolved._ownerScope);
+        const typeParams = /* @__PURE__ */ Object.create(null);
+        if ((resolved.type === "TSTypeAliasDeclaration" || resolved.type === "TSInterfaceDeclaration") && resolved.typeParameters && node.typeParameters) {
+          resolved.typeParameters.params.forEach((p, i) => {
+            let param = typeParameters && typeParameters[p.name];
+            if (!param)
+              param = node.typeParameters.params[i];
+            typeParams[p.name] = param;
+          });
+        }
+        return resolveTypeElements(
+          ctx,
+          resolved,
+          resolved._ownerScope,
+          typeParams
+        );
       } else {
         if (typeof typeName === "string") {
+          if (typeParameters && typeParameters[typeName]) {
+            return resolveTypeElements(
+              ctx,
+              typeParameters[typeName],
+              scope,
+              typeParameters
+            );
+          }
           if (
             // @ts-ignore
             SupportedBuiltinsSet.has(typeName)
           ) {
-            return resolveBuiltin(ctx, node, typeName, scope);
+            return resolveBuiltin(
+              ctx,
+              node,
+              typeName,
+              scope,
+              typeParameters
+            );
           } else if (typeName === "ReturnType" && node.typeParameters) {
             const ret = resolveReturnType(
               ctx,
@@ -17833,10 +17953,14 @@ function innerResolveTypeElements(ctx, node, scope) {
   }
   return ctx.error(`Unresolvable type: ${node.type}`, node, scope);
 }
-function typeElementsToMap(ctx, elements, scope = ctxToScope(ctx)) {
+function typeElementsToMap(ctx, elements, scope = ctxToScope(ctx), typeParameters) {
   const res = { props: {} };
   for (const e of elements) {
     if (e.type === "TSPropertySignature" || e.type === "TSMethodSignature") {
+      if (typeParameters) {
+        scope = createChildScope(scope);
+        Object.assign(scope.types, typeParameters);
+      }
       e._ownerScope = scope;
       const name = getId(e.key);
       if (name && !e.computed) {
@@ -17899,20 +18023,29 @@ function createProperty(key, typeAnnotation, scope, optional) {
     _ownerScope: scope
   };
 }
-function resolveInterfaceMembers(ctx, node, scope) {
-  const base = typeElementsToMap(ctx, node.body.body, node._ownerScope);
+function resolveInterfaceMembers(ctx, node, scope, typeParameters) {
+  const base = typeElementsToMap(
+    ctx,
+    node.body.body,
+    node._ownerScope,
+    typeParameters
+  );
   if (node.extends) {
     for (const ext of node.extends) {
       if (ext.leadingComments && ext.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
         continue;
       }
       try {
-        const { props } = resolveTypeElements(ctx, ext, scope);
+        const { props, calls } = resolveTypeElements(ctx, ext, scope);
         for (const key in props) {
           if (!shared.hasOwn(base.props, key)) {
             base.props[key] = props[key];
           }
         }
+        if (calls) {
+          ;
+          (base.calls || (base.calls = [])).push(...calls);
+        }
       } catch (e) {
         ctx.error(
           `Failed to resolve extends base type.
@@ -18071,8 +18204,13 @@ const SupportedBuiltinsSet = /* @__PURE__ */ new Set([
   "Pick",
   "Omit"
 ]);
-function resolveBuiltin(ctx, node, name, scope) {
-  const t = resolveTypeElements(ctx, node.typeParameters.params[0], scope);
+function resolveBuiltin(ctx, node, name, scope, typeParameters) {
+  const t = resolveTypeElements(
+    ctx,
+    node.typeParameters.params[0],
+    scope,
+    typeParameters
+  );
   switch (name) {
     case "Partial": {
       const res2 = { props: {}, calls: t.calls };
@@ -18200,7 +18338,21 @@ function resolveGlobalScope(ctx) {
 let ts;
 let loadTS;
 function registerTS(_loadTS) {
-  loadTS = _loadTS;
+  loadTS = () => {
+    try {
+      return _loadTS();
+    } catch (err) {
+      if (typeof err.message === "string" && err.message.includes("Cannot find module")) {
+        throw new Error(
+          'Failed to load TypeScript, which is required for resolving imported types. Please make sure "typescript" is installed as a project dependency.'
+        );
+      } else {
+        throw new Error(
+          "Failed to load TypeScript for resolving imported types."
+        );
+      }
+    }
+  };
 }
 function resolveFS(ctx) {
   if (ctx.fs) {
@@ -18234,7 +18386,12 @@ function resolveTypeFromImport(ctx, node, name, scope) {
   return resolveTypeReference(ctx, node, sourceScope, imported, true);
 }
 function importSourceToScope(ctx, node, scope, source) {
-  const fs = resolveFS(ctx);
+  let fs;
+  try {
+    fs = resolveFS(ctx);
+  } catch (err) {
+    return ctx.error(err.message, node, scope);
+  }
   if (!fs) {
     return ctx.error(
       `No fs option provided to \`compileScript\` in non-Node environment. File system access is required for resolving imported types.`,
@@ -18244,7 +18401,11 @@ function importSourceToScope(ctx, node, scope, source) {
   }
   let resolved = scope.resolvedImportSources[source];
   if (!resolved) {
-    if (source.startsWith(".")) {
+    if (source.startsWith("..")) {
+      const osSpecificJoinFn = process__namespace.platform === "win32" ? path$3.join : joinPaths;
+      const filename = osSpecificJoinFn(path$3.dirname(scope.filename), source);
+      resolved = resolveExt(filename, fs);
+    } else if (source.startsWith(".")) {
       const filename = joinPaths(path$3.dirname(scope.filename), source);
       resolved = resolveExt(filename, fs);
     } else {
@@ -18325,7 +18486,7 @@ function resolveWithTS(containingFile, source, ts2, fs) {
     }
     tsCompilerOptions = matchedConfig.config.options;
     tsResolveCache = matchedConfig.cache || (matchedConfig.cache = ts2.createModuleResolutionCache(
-      process.cwd(),
+      process__namespace.cwd(),
       createGetCanonicalFileName(ts2.sys.useCaseSensitiveFileNames),
       tsCompilerOptions
     ));
@@ -18439,14 +18600,7 @@ function moduleDeclToScope(ctx, node, parentScope) {
   if (node._resolvedChildScope) {
     return node._resolvedChildScope;
   }
-  const scope = new TypeScope(
-    parentScope.filename,
-    parentScope.source,
-    parentScope.offset,
-    Object.create(parentScope.imports),
-    Object.create(parentScope.types),
-    Object.create(parentScope.declares)
-  );
+  const scope = createChildScope(parentScope);
   if (node.body.type === "TSModuleDeclaration") {
     const decl = node.body;
     decl._ownerScope = scope;
@@ -18457,6 +18611,16 @@ function moduleDeclToScope(ctx, node, parentScope) {
   }
   return node._resolvedChildScope = scope;
 }
+function createChildScope(parentScope) {
+  return new TypeScope(
+    parentScope.filename,
+    parentScope.source,
+    parentScope.offset,
+    Object.create(parentScope.imports),
+    Object.create(parentScope.types),
+    Object.create(parentScope.declares)
+  );
+}
 const importExportRE = /^Import|^Export/;
 function recordTypes(ctx, body, scope, asGlobal = false) {
   const { types, declares, exportedTypes, exportedDeclares, imports } = scope;
@@ -18578,7 +18742,7 @@ function recordType(node, types, declares, overwriteId) {
         types[overwriteId || getId(node.id)] = node;
       break;
     case "TSTypeAliasDeclaration":
-      types[node.id.name] = node.typeAnnotation;
+      types[node.id.name] = node.typeParameters ? node : node.typeAnnotation;
       break;
     case "TSDeclareFunction":
       if (node.id)
@@ -19111,14 +19275,14 @@ function genRuntimeProps(ctx) {
       const defaults = [];
       for (const key in ctx.propsDestructuredBindings) {
         const d = genDestructuredDefaultValue(ctx, key);
-        const finalKey = getEscapedKey(key);
+        const finalKey = getEscapedPropName(key);
         if (d)
           defaults.push(
             `${finalKey}: ${d.valueString}${d.needSkipFactory ? `, __skip_${finalKey}: true` : ``}`
           );
       }
       if (defaults.length) {
-        propsDecls = `${ctx.helper(
+        propsDecls = `/*#__PURE__*/${ctx.helper(
           `mergeDefaults`
         )}(${propsDecls}, {
   ${defaults.join(",\n  ")}
@@ -19130,7 +19294,9 @@ function genRuntimeProps(ctx) {
   }
   const modelsDecls = genModelProps(ctx);
   if (propsDecls && modelsDecls) {
-    return `${ctx.helper("mergeModels")}(${propsDecls}, ${modelsDecls})`;
+    return `/*#__PURE__*/${ctx.helper(
+      "mergeModels"
+    )}(${propsDecls}, ${modelsDecls})`;
   } else {
     return modelsDecls || propsDecls;
   }
@@ -19152,9 +19318,9 @@ function genRuntimePropsFromTypes(ctx) {
     ${propStrings.join(",\n    ")}
   }`;
   if (ctx.propsRuntimeDefaults && !hasStaticDefaults) {
-    propsDecls = `${ctx.helper("mergeDefaults")}(${propsDecls}, ${ctx.getString(
-      ctx.propsRuntimeDefaults
-    )})`;
+    propsDecls = `/*#__PURE__*/${ctx.helper(
+      "mergeDefaults"
+    )}(${propsDecls}, ${ctx.getString(ctx.propsRuntimeDefaults)})`;
   }
   return propsDecls;
 }
@@ -19203,7 +19369,7 @@ function genRuntimePropFromType(ctx, { key, required, type, skipCheck }, hasStat
       }
     }
   }
-  const finalKey = getEscapedKey(key);
+  const finalKey = getEscapedPropName(key);
   if (!ctx.options.isProd) {
     return `${finalKey}: { ${concatStrings([
       `type: ${toRuntimeTypeString(type)}`,
@@ -19491,7 +19657,9 @@ function genRuntimeEmits(ctx) {
   }
   if (ctx.hasDefineModelCall) {
     let modelEmitsDecl = `[${Object.keys(ctx.modelDecls).map((n) => JSON.stringify(`update:${n}`)).join(", ")}]`;
-    emitsDecl = emitsDecl ? `${ctx.helper("mergeModels")}(${emitsDecl}, ${modelEmitsDecl})` : modelEmitsDecl;
+    emitsDecl = emitsDecl ? `/*#__PURE__*/${ctx.helper(
+      "mergeModels"
+    )}(${emitsDecl}, ${modelEmitsDecl})` : modelEmitsDecl;
   }
   return emitsDecl;
 }
@@ -20461,7 +20629,7 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.3.8";
+const version = "3.3.10";
 const parseCache = parseCache$1;
 const walk = estreeWalker.walk;
 

package/dist/compiler-sfc.d.ts

@@ -455,7 +455,7 @@ interface ResolvedElements {
  */
 export declare function resolveTypeElements(ctx: TypeResolveContext, node: Node & MaybeWithScope & {
     _resolvedElements?: ResolvedElements;
-}, scope?: TypeScope): ResolvedElements;
+}, scope?: TypeScope, typeParameters?: Record<string, Node>): ResolvedElements;
 /**
  * @private
  */