@wevu/compiler 6.16.7 → 6.16.8

package/dist/index.d.mts

@@ -217,6 +217,8 @@ interface ScopedSlotComponentAsset {
   classStyleBindings?: ClassStyleBinding[];
   classStyleWxs?: boolean;
   inlineExpressions?: InlineExpressionAsset[];
+  ownerKeys?: string[];
+  ownerPropsExpression?: string;
 }
 /**
  * 内联表达式资源描述。

package/dist/index.mjs

@@ -13,7 +13,7 @@ import os from "node:os";
 import process from "node:process";
 import { collectFeatureFlagsFromCode, collectJsxImportedComponentsAndDefaultExportFromBabelAst, collectJsxTemplateTagsFromBabelExpression, getRenderPropertyFromComponentOptions, parseJsLikeWithEngine, resolveRenderExpressionFromComponentOptions, toStaticObjectKey, unwrapTypeScriptExpression } from "@weapp-vite/ast";
 import { LRUCache } from "lru-cache";
-import { WEVU_CLASS_STYLE_RUNTIME_FILE, WEVU_CLASS_STYLE_RUNTIME_MODULE, WEVU_EXPRESSION_ERROR_IDENTIFIER, WEVU_INLINE_HANDLER, WEVU_INLINE_MAP_KEY, WEVU_IS_PAGE_KEY, WEVU_LAYOUT_HOSTS_KEY, WEVU_LAYOUT_HOST_ID_PREFIX, WEVU_LAYOUT_HOST_REF_PREFIX, WEVU_MODEL_HANDLER, WEVU_OWNER_HANDLER, WEVU_PROPS_KEY, WEVU_SLOT_NAMES_ATTR, WEVU_SLOT_NAMES_PROP, WEVU_SLOT_OWNER_ATTR, WEVU_SLOT_OWNER_ID_ATTR, WEVU_SLOT_OWNER_ID_KEY, WEVU_SLOT_OWNER_ID_PROP, WEVU_SLOT_OWNER_KEY, WEVU_SLOT_PROPS_ATTR, WEVU_SLOT_PROPS_DATA_KEY, WEVU_SLOT_PROPS_KEY, WEVU_SLOT_SCOPE_ATTR, WEVU_SLOT_SCOPE_KEY, WEVU_TEMPLATE_REFS_KEY } from "@weapp-core/constants";
+import { WEVU_CLASS_STYLE_RUNTIME_FILE, WEVU_CLASS_STYLE_RUNTIME_MODULE, WEVU_EXPRESSION_ERROR_IDENTIFIER, WEVU_GENERIC_SLOT_OWNER_DATA_KEY, WEVU_GENERIC_SLOT_OWNER_ID_ATTR, WEVU_GENERIC_SLOT_OWNER_PROPS_ATTR, WEVU_GENERIC_SLOT_PROPS_ATTR, WEVU_GENERIC_SLOT_PROPS_DATA_ATTR, WEVU_GENERIC_SLOT_PROPS_DATA_KEY, WEVU_GENERIC_SLOT_SCOPE_ATTR, WEVU_INLINE_HANDLER, WEVU_INLINE_MAP_KEY, WEVU_IS_PAGE_KEY, WEVU_LAYOUT_HOSTS_KEY, WEVU_LAYOUT_HOST_ID_PREFIX, WEVU_LAYOUT_HOST_REF_PREFIX, WEVU_MODEL_HANDLER, WEVU_OWNER_HANDLER, WEVU_PROPS_KEY, WEVU_SLOT_NAMES_ATTR, WEVU_SLOT_NAMES_PROP, WEVU_SLOT_OWNER_ID_KEY, WEVU_SLOT_OWNER_KEY, WEVU_SLOT_OWNER_PROXY_KEY, WEVU_SLOT_PROPS_DATA_KEY, WEVU_SLOT_PROPS_KEY, WEVU_SLOT_SCOPE_KEY, WEVU_TEMPLATE_REFS_KEY } from "@weapp-core/constants";
 import { compileScript, parse } from "vue/compiler-sfc";
 import { fileURLToPath } from "node:url";
 import { parse as parse$1 } from "@vue/compiler-dom";
@@ -3145,11 +3145,11 @@ function normalizeJsxText(value) {
 function printExpression(exp) {
 	return generate(exp).code;
 }
-function unwrapTsExpression$2(exp) {
+function unwrapTsExpression$3(exp) {
 	return unwrapTypeScriptExpression(exp);
 }
 function normalizeInterpolationExpression(exp) {
-	return normalizeWxmlExpression(printExpression(unwrapTsExpression$2(exp)));
+	return normalizeWxmlExpression(printExpression(unwrapTsExpression$3(exp)));
 }
 function renderMustache$1(expression, context) {
 	return context.mustacheInterpolation === "spaced" ? `{{ ${expression} }}` : `{{${expression}}}`;
@@ -3701,7 +3701,7 @@ function readJsxAttributeExpression(value) {
 	if (t.isStringLiteral(value)) return value;
 	if (!t.isJSXExpressionContainer(value)) return null;
 	if (t.isJSXEmptyExpression(value.expression)) return null;
-	return unwrapTsExpression$2(value.expression);
+	return unwrapTsExpression$3(value.expression);
 }
 function extractJsxKeyExpression(node) {
 	for (const attr of node.openingElement.attributes) {
@@ -3783,10 +3783,10 @@ function compileMapExpression(exp, context) {
 	let bodyExp = null;
 	if (t.isBlockStatement(callback.body)) {
 		for (const statement of callback.body.body) if (t.isReturnStatement(statement) && statement.argument) {
-			bodyExp = unwrapTsExpression$2(statement.argument);
+			bodyExp = unwrapTsExpression$3(statement.argument);
 			break;
 		}
-	} else bodyExp = unwrapTsExpression$2(callback.body);
+	} else bodyExp = unwrapTsExpression$3(callback.body);
 	const body = bodyExp ? compileRenderableExpression(bodyExp, context) : "";
 	popScope$1(context, addedScope.length);
 	if (!body) return "";
@@ -3821,7 +3821,7 @@ function compileLogicalExpression(exp, context) {
 	return renderMustache$1(normalizeInterpolationExpression(exp), context);
 }
 function compileRenderableExpression(exp, context) {
-	const node = unwrapTsExpression$2(exp);
+	const node = unwrapTsExpression$3(exp);
 	if (t.isJSXElement(node)) return compileJsxElement(node, context);
 	if (t.isJSXFragment(node)) return compileJsxFragment(node, context);
 	if (t.isConditionalExpression(node)) return compileConditionalExpression(node, context);
@@ -4756,10 +4756,10 @@ function resolveMappedHtmlTagClassName(tag, context, resolvedTag) {
 }
 //#endregion
 //#region src/plugins/vue/compiler/template/elements/forExpression.ts
-const IDENTIFIER_RE$4 = /^[A-Z_$][\w$]*$/i;
+const IDENTIFIER_RE$5 = /^[A-Z_$][\w$]*$/i;
 const FOR_ITEM_ALIAS_PLACEHOLDER = "__wv_for_item__";
 function isIdentifier(value) {
-	return IDENTIFIER_RE$4.test(value);
+	return IDENTIFIER_RE$5.test(value);
 }
 function splitTopLevelByComma(input) {
 	const out = [];
@@ -5033,7 +5033,7 @@ function withSlotProps(context, mapping, fn) {
 		popSlotProps(context);
 	}
 }
-const IDENTIFIER_RE$3 = /^[A-Z_$][\w$]*$/i;
+const IDENTIFIER_RE$4 = /^[A-Z_$][\w$]*$/i;
 const BIND_SHORTHAND_ARG_RE = /^[A-Z_$][\w$]*(?:-[A-Z_$][\w$]*)*$/i;
 const BACKSLASH_RE$2 = /\\/g;
 const SINGLE_QUOTE_RE$2 = /'/g;
@@ -5054,7 +5054,7 @@ function collectScopePropMapping(context) {
 	const mapping = {};
 	if (!context.slotMultipleInstance) return mapping;
 	for (const scope of context.scopeStack) for (const name of scope) {
-		if (!IDENTIFIER_RE$3.test(name)) continue;
+		if (!IDENTIFIER_RE$4.test(name)) continue;
 		if (!hasOwn(mapping, name)) mapping[name] = name;
 	}
 	return mapping;
@@ -5112,8 +5112,10 @@ const SCOPED_SLOT_GLOBALS = new Set([
 	"require",
 	"arguments",
 	WEVU_SLOT_OWNER_KEY,
+	WEVU_GENERIC_SLOT_OWNER_DATA_KEY,
 	WEVU_SLOT_PROPS_KEY,
 	WEVU_SLOT_PROPS_DATA_KEY,
+	WEVU_GENERIC_SLOT_PROPS_DATA_KEY,
 	WEVU_CLASS_STYLE_RUNTIME_MODULE
 ]);
 function collectScopedSlotLocals(context) {
@@ -5143,7 +5145,11 @@ function replaceIdentifierWithExpression(path, replacement) {
 	}
 	path.replaceWith(replacement);
 }
-const IDENTIFIER_RE$2 = /^[A-Z_$][\w$]*$/i;
+const IDENTIFIER_RE$3 = /^[A-Z_$][\w$]*$/i;
+function unwrapTsExpression$2(node) {
+	if (t.isTSAsExpression(node) || t.isTSNonNullExpression(node) || t.isTSTypeAssertion(node) || t.isTSSatisfiesExpression(node)) return unwrapTsExpression$2(node.expression);
+	return node;
+}
 function rewriteScopedSlotExpression(exp, context) {
 	const normalized = normalizeWxmlExpression(exp);
 	const parsed = parseBabelExpressionFile(normalized);
@@ -5154,28 +5160,43 @@ function rewriteScopedSlotExpression(exp, context) {
 	const forAliases = collectForAliasMapping$2(context);
 	const createMemberAccess = (target, prop) => {
 		if (!prop) return t.identifier(target);
-		if (IDENTIFIER_RE$2.test(prop)) return t.memberExpression(t.identifier(target), t.identifier(prop));
+		if (IDENTIFIER_RE$3.test(prop)) return t.memberExpression(t.identifier(target), t.identifier(prop));
 		return t.memberExpression(t.identifier(target), t.stringLiteral(prop), true);
 	};
-	traverse(ast, { Identifier(path) {
-		if (!path.isReferencedIdentifier()) return;
-		const name = path.node.name;
-		if (SCOPED_SLOT_GLOBALS.has(name)) return;
-		if (path.scope.hasBinding(name)) return;
-		if (hasOwn(forAliases, name)) {
-			const aliasExp = parseBabelExpression(forAliases[name]);
-			if (aliasExp) {
-				replaceIdentifierWithExpression(path, t.cloneNode(aliasExp, true));
+	traverse(ast, {
+		TSAsExpression(path) {
+			path.replaceWith(unwrapTsExpression$2(path.node));
+		},
+		TSSatisfiesExpression(path) {
+			path.replaceWith(unwrapTsExpression$2(path.node));
+		},
+		TSTypeAssertion(path) {
+			path.replaceWith(unwrapTsExpression$2(path.node));
+		},
+		TSNonNullExpression(path) {
+			path.replaceWith(unwrapTsExpression$2(path.node));
+		},
+		Identifier(path) {
+			if (!path.isReferencedIdentifier()) return;
+			const name = path.node.name;
+			if (SCOPED_SLOT_GLOBALS.has(name)) return;
+			if (path.scope.hasBinding(name)) return;
+			if (hasOwn(forAliases, name)) {
+				const aliasExp = parseBabelExpression(forAliases[name]);
+				if (aliasExp) {
+					replaceIdentifierWithExpression(path, t.cloneNode(aliasExp, true));
+					return;
+				}
+			}
+			if (locals.has(name)) return;
+			if (hasOwn(slotProps, name)) {
+				const prop = slotProps[name];
+				replaceIdentifierWithExpression(path, createMemberAccess(WEVU_GENERIC_SLOT_PROPS_DATA_KEY, prop));
 				return;
 			}
+			replaceIdentifierWithExpression(path, createMemberAccess(WEVU_GENERIC_SLOT_PROPS_DATA_KEY, name));
 		}
-		if (locals.has(name)) return;
-		if (hasOwn(slotProps, name)) {
-			replaceIdentifierWithExpression(path, createMemberAccess(WEVU_SLOT_PROPS_DATA_KEY, slotProps[name]));
-			return;
-		}
-		replaceIdentifierWithExpression(path, createMemberAccess(WEVU_SLOT_OWNER_KEY, name));
-	} });
+	});
 	const stmt = ast.program.body[0];
 	const updatedExpression = stmt && "expression" in stmt ? stmt.expression : null;
 	return updatedExpression ? generateExpression(updatedExpression) : normalized;
@@ -5351,10 +5372,10 @@ const INLINE_GLOBALS = new Set([
 	"scope",
 	...getMiniProgramRuntimeGlobalKeys()
 ]);
-const IDENTIFIER_RE$1 = /^[A-Z_$][\w$]*$/i;
+const IDENTIFIER_RE$2 = /^[A-Z_$][\w$]*$/i;
 const SIMPLE_PATH_RE = /^[A-Z_$][\w$]*(?:\.[A-Z_$][\w$]*)*$/i;
 function createMemberAccess$1(target, prop) {
-	if (IDENTIFIER_RE$1.test(prop)) return t.memberExpression(t.identifier(target), t.identifier(prop));
+	if (IDENTIFIER_RE$2.test(prop)) return t.memberExpression(t.identifier(target), t.identifier(prop));
 	return t.memberExpression(t.identifier(target), t.stringLiteral(prop), true);
 }
 function resolveSlotPropBinding(slotProps, name) {
@@ -5536,9 +5557,22 @@ function createMemberAccess(target, prop) {
 function createThisMemberAccess(prop) {
 	return createMemberAccess(t.thisExpression(), prop);
 }
+function createScopedSlotOwnerRuntimeAccess() {
+	return t.logicalExpression("||", createThisMemberAccess(WEVU_SLOT_OWNER_PROXY_KEY), createThisMemberAccess(WEVU_SLOT_OWNER_KEY));
+}
 function createUnrefCall(exp) {
 	return t.callExpression(t.identifier("__wevuUnref"), [exp]);
 }
+function isCallCalleeIdentifier(path) {
+	const parent = path.parentPath;
+	if (parent.isCallExpression() && parent.node.callee === path.node) return true;
+	if (parent.isOptionalCallExpression() && parent.node.callee === path.node) return true;
+	if (!parent.isMemberExpression()) return false;
+	const grandParent = parent.parentPath;
+	if (grandParent.isCallExpression() && grandParent.node.callee === parent.node) return true;
+	if (grandParent.isOptionalCallExpression() && grandParent.node.callee === parent.node) return true;
+	return false;
+}
 function createHasOwnPropertyCall(target, key) {
 	return t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier("Object"), t.identifier("prototype")), t.identifier("hasOwnProperty")), t.identifier("call")), [target, t.stringLiteral(key)]);
 }
@@ -5609,7 +5643,10 @@ function normalizeJsExpressionWithContext(exp, context, options) {
 			const base = createThisMemberAccess(WEVU_SLOT_PROPS_DATA_KEY);
 			replacement = createUnrefCall(prop ? createMemberAccess(base, prop) : base);
 		} else if (name === WEVU_SLOT_OWNER_KEY || name === WEVU_SLOT_PROPS_DATA_KEY || name === WEVU_SLOT_PROPS_KEY || name === WEVU_SLOT_SCOPE_KEY) replacement = createUnrefCall(createThisMemberAccess(name));
-		else replacement = createUnrefCall(createMemberAccess(createThisMemberAccess(WEVU_SLOT_OWNER_KEY), name));
+		else {
+			const ownerAccess = createMemberAccess(createScopedSlotOwnerRuntimeAccess(), name);
+			replacement = isCallCalleeIdentifier(path) ? ownerAccess : createUnrefCall(ownerAccess);
+		}
 		else replacement = createUnrefCall(createIdentifierAccessWithPropsFallback(name));
 		const parent = path.parentPath;
 		if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path.node) {
@@ -5653,17 +5690,26 @@ function shouldFallbackToRuntimeBinding(exp) {
 * 将复杂表达式注册为 JS 运行时计算绑定，返回可用于模板 mustache 的绑定引用。
 */
 function registerRuntimeBindingExpression(exp, context, options) {
-	const expAst = normalizeJsExpressionWithContext(exp, context, options);
+	const forIndexAccess = buildForIndexAccess$1(context);
+	const bindingContext = context.rewriteScopedSlot && context.scopedSlotOwnerRuntimeBindingTarget ? context.scopedSlotOwnerRuntimeBindingTarget : context;
+	const cacheKey = context.rewriteScopedSlot && !forIndexAccess ? `${options?.prefix ?? ""}:${exp.trim()}` : void 0;
+	if (cacheKey) {
+		const cached = context.runtimeBindingCache?.get(cacheKey);
+		if (cached) return cached;
+	}
+	const expAst = normalizeJsExpressionWithContext(exp, bindingContext, options);
 	if (!expAst) return null;
 	const binding = {
-		name: `__wv_bind_${context.classStyleBindings.filter((item) => item.type === "bind").length}`,
+		name: `${options?.prefix ?? context.runtimeBindingPrefix ?? "__wv_bind_"}${bindingContext.classStyleBindings.filter((item) => item.type === "bind").length}`,
 		type: "bind",
 		exp,
 		expAst,
-		forStack: context.forStack.map((info) => ({ ...info }))
+		forStack: bindingContext.forStack.map((info) => ({ ...info }))
 	};
-	context.classStyleBindings.push(binding);
-	return `${binding.name}${buildForIndexAccess$1(context)}`;
+	bindingContext.classStyleBindings.push(binding);
+	const bindingRef = context.rewriteScopedSlot ? `${WEVU_GENERIC_SLOT_PROPS_DATA_KEY}.${binding.name}${forIndexAccess}` : `${binding.name}${forIndexAccess}`;
+	if (cacheKey) context.runtimeBindingCache?.set(cacheKey, bindingRef);
+	return bindingRef;
 }
 //#endregion
 //#region src/plugins/vue/compiler/template/mustache.ts
@@ -5880,7 +5926,7 @@ function transformBindDirective(node, context, forInfo) {
 }
 //#endregion
 //#region src/plugins/vue/compiler/template/directives/custom.ts
-const IDENTIFIER_RE = /^[a-z_$][\w$]*$/i;
+const IDENTIFIER_RE$1 = /^[a-z_$][\w$]*$/i;
 function transformCustomDirective(name, exp, arg, context) {
 	if (new Set([
 		"bind",
@@ -5900,7 +5946,7 @@ function transformCustomDirective(name, exp, arg, context) {
 	const dataAttrName = `data-v-${name}`;
 	if (exp && exp.type === NodeTypes.SIMPLE_EXPRESSION) {
 		const expValue = normalizeWxmlExpressionWithContext(exp.content, context);
-		if (IDENTIFIER_RE.test(expValue)) return `${dataAttrName}="${renderMustache(expValue, context)}"`;
+		if (IDENTIFIER_RE$1.test(expValue)) return `${dataAttrName}="${renderMustache(expValue, context)}"`;
 		return `${dataAttrName}="${renderMustache(expValue, context)}"`;
 	}
 	if (arg && arg.type === NodeTypes.SIMPLE_EXPRESSION) return `${dataAttrName}="${arg.content}"`;
@@ -5917,6 +5963,28 @@ function getElementType(element) {
 	return "";
 }
 const QUOTE_RE$1 = /"/g;
+const CAMELIZE_RE = /-([a-z0-9])/gi;
+const IDENTIFIER_RE = /^[A-Z_$][\w$]*$/i;
+const NATIVE_MODEL_TAGS = new Set([
+	"input",
+	"textarea",
+	"select",
+	"switch",
+	"checkbox",
+	"slider",
+	"picker"
+]);
+function camelize(value) {
+	return value.replace(CAMELIZE_RE, (_, char) => char.toUpperCase());
+}
+function buildModelAssignmentExpression(rawExpValue) {
+	if (IDENTIFIER_RE.test(rawExpValue)) return `ctx.${rawExpValue} = $event`;
+	return `${rawExpValue} = $event`;
+}
+function isNativeModelElement(element) {
+	if (!element || element.tag !== element.tag.toLowerCase()) return false;
+	return NATIVE_MODEL_TAGS.has(element.tag);
+}
 function transformVModel(element, expValue, context) {
 	const escapedModel = expValue.replace(QUOTE_RE$1, """);
 	const bindModel = (event) => {
@@ -5942,9 +6010,48 @@ function transformVModel(element, expValue, context) {
 			return `value="${renderMustache(expValue, context)}" ${bindModel("input")}`;
 	}
 }
-function transformModelDirective(node, context, elementNode) {
+function transformComponentModelDirective(node, context) {
+	const rawExpValue = getBindDirectiveExpression(node).trim();
+	if (!rawExpValue) return null;
+	const rawModelName = node.arg?.type === NodeTypes.SIMPLE_EXPRESSION ? node.arg.content.trim() : "";
+	if (node.arg?.type === NodeTypes.SIMPLE_EXPRESSION && !node.arg.isStatic) {
+		context.warnings.push("暂不支持动态 v-model 参数，已忽略该 v-model。");
+		return null;
+	}
+	const modelProp = rawModelName || "modelValue";
+	if (!modelProp) return null;
+	const updateEvent = `update:${camelize(modelProp)}`;
+	const eventSuffix = normalizeEventDatasetSuffix(updateEvent);
+	const bindAttr = context.platform.eventBindingAttr(updateEvent);
+	const inlineExpression = registerInlineExpression(buildModelAssignmentExpression(rawExpValue), context);
+	if (!inlineExpression) {
+		context.warnings.push(`v-model="${rawExpValue}" 需要是可赋值的成员表达式。`);
+		return null;
+	}
+	const modelAttr = modelProp === "modelValue" ? `modelValue="${renderMustache(normalizeWxmlExpressionWithContext(rawExpValue, context), context)}"` : transformBindDirective(node, context);
+	const updateAttr = [
+		`data-wd-${eventSuffix}="1"`,
+		`data-wi-${eventSuffix}="${inlineExpression.id}"`,
+		`${bindAttr}="${WEVU_INLINE_HANDLER}"`
+	].filter(Boolean).join(" ");
+	const modifierNames = node.modifiers.map((modifier) => modifier.content.trim()).filter(Boolean);
+	const modifierProperties = modifierNames.map((name) => `${JSON.stringify(name)}:true`).join(",");
+	const modifiersProp = modelProp === "modelValue" ? "modelModifiers" : `${modelProp}Modifiers`;
+	const modifiersRef = modifierNames.length ? registerRuntimeBindingExpression(`{${modifierProperties}}`, context, { hint: "v-model modifiers" }) : null;
+	return [
+		modelAttr,
+		updateAttr,
+		modifiersRef ? `${modifiersProp}="${renderMustache(modifiersRef, context)}"` : null
+	].filter(Boolean).join(" ");
+}
+function transformModelDirective(node, context, elementNode, options) {
 	const { exp } = node;
 	if (!exp) return null;
+	if (options?.isComponent === true && !isNativeModelElement(elementNode)) return transformComponentModelDirective(node, context);
+	if (node.arg) {
+		context.warnings.push("原生小程序元素不支持 v-model 参数，已忽略该 v-model。");
+		return null;
+	}
 	return transformVModel(elementNode, normalizeWxmlExpressionWithContext(exp.type === NodeTypes.SIMPLE_EXPRESSION ? exp.content : "", context), context);
 }
 //#endregion
@@ -6045,7 +6152,7 @@ function transformDirective(node, context, elementNode, forInfo, options) {
 	const { name, exp, arg } = node;
 	if (name === "bind") return transformBindDirective(node, context, forInfo);
 	if (name === "on") return transformOnDirective(node, context, options);
-	if (name === "model") return transformModelDirective(node, context, elementNode);
+	if (name === "model") return transformModelDirective(node, context, elementNode, options);
 	if (name === "show") return transformShowDirective(node, context);
 	if (name === "html") {
 		context.warnings.push("小程序不支持 v-html，请使用 rich-text 组件替代。");
@@ -6147,6 +6254,17 @@ function collectElementAttributes(node, context, options) {
 			}
 			if (prop.name === "text" && prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION) {
 				const rawExp = prop.exp.content;
+				if (context.nativeSlotScopeRuntime) {
+					const runtimeExp = registerRuntimeBindingExpression(rawExp, context.nativeSlotScopeRuntime.owner, {
+						hint: "v-text",
+						prefix: context.nativeSlotScopeRuntime.runtimeBindingPrefix
+					});
+					if (runtimeExp) {
+						context.nativeSlotScopeRuntime.bindings.set(runtimeExp, runtimeExp);
+						vTextExp = runtimeExp;
+						continue;
+					}
+				}
 				vTextExp = (shouldFallbackToRuntimeBinding(rawExp) ? registerRuntimeBindingExpression(rawExp, context, { hint: "v-text" }) : null) ?? normalizeWxmlExpressionWithContext(rawExp, context);
 				continue;
 			}
@@ -6246,7 +6364,10 @@ function parseSlotPropsExpression(exp, context) {
 	}
 	return {};
 }
-function collectSlotBindingExpression(node, context) {
+function renderObjectBindingKey(key) {
+	return /^[A-Z_$][\w$]*$/i.test(key) ? key : toWxmlStringLiteral$1(key);
+}
+function collectSlotBindingExpressions(node, context) {
 	let bindObjectExp = null;
 	const namedBindings = [];
 	for (const prop of node.props) {
@@ -6278,9 +6399,18 @@ function collectSlotBindingExpression(node, context) {
 		context.warnings.push("作用域插槽参数使用 v-bind 对象时，将忽略额外的命名绑定。");
 		namedBindings.length = 0;
 	}
-	if (bindObjectExp) return bindObjectExp;
-	if (!namedBindings.length) return null;
-	return `[${namedBindings.map((entry) => `${toWxmlStringLiteral$1(entry.key)},${entry.value}`).join(",")}]`;
+	if (bindObjectExp) return {
+		data: bindObjectExp,
+		props: bindObjectExp
+	};
+	if (!namedBindings.length) return {
+		data: null,
+		props: null
+	};
+	return {
+		data: `{${namedBindings.map((entry) => `${renderObjectBindingKey(entry.key)}:${entry.value}`).join(",")}}`,
+		props: `[${namedBindings.map((entry) => `${toWxmlStringLiteral$1(entry.key)},${entry.value}`).join(",")}]`
+	};
 }
 //#endregion
 //#region src/plugins/vue/compiler/template/elements/tag-slot.ts
@@ -6338,6 +6468,12 @@ function resolveSlotStaticName(info) {
 	if (info.type === "static") return info.value || "default";
 }
 const SLOT_PRESENCE_IDENTIFIER_RE = /^[A-Z_$][\w$]*$/i;
+const SLOT_OWNER_KEY_RE = /\bwvslotowner(?:\.([A-Z_$][\w$]*)|\[['"]([^'"]+)['"]\])/gi;
+const SLOT_OWNER_PROP_PREFIX_RE = /\bwvslotownerprop([A-Z_$][\w$]*)\b/gi;
+const SLOT_PROPS_DATA_KEY_RE = /\bwvslotpropsdata(?:\.([A-Z_$][\w$]*)|\[['"]([^'"]+)['"]\])/gi;
+function renderOwnerPropSourceExpression(key) {
+	return SLOT_PRESENCE_IDENTIFIER_RE.test(key) ? key : `${WEVU_SLOT_OWNER_ID_KEY}['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
+}
 function createSlotPresenceExpression(info) {
 	const slotName = resolveSlotStaticName(info);
 	if (!slotName) return;
@@ -6352,6 +6488,66 @@ function buildSlotDeclaration(name, propsExp, children, context, options) {
 		condition: options?.condition
 	};
 }
+function collectOwnerMemberKey(node, ownerKeys, slotPropKeys) {
+	const object = node.object;
+	if (object.type !== "Identifier" || object.name !== "wvslotowner" && object.name !== "wvslotpropsdata") return;
+	const property = node.property;
+	if (!node.computed && property.type === "Identifier") {
+		if (object.name === "wvslotpropsdata" && slotPropKeys.has(property.name)) return;
+		ownerKeys.add(property.name);
+	} else if (node.computed && property.type === "StringLiteral") {
+		if (object.name === "wvslotpropsdata" && slotPropKeys.has(property.value)) return;
+		ownerKeys.add(property.value);
+	}
+}
+function collectScopedSlotOwnerKeys(template, slotPropKeys) {
+	const ownerKeys = /* @__PURE__ */ new Set();
+	let match = SLOT_OWNER_KEY_RE.exec(template);
+	while (match) {
+		const key = match[1] ?? match[2];
+		if (key) ownerKeys.add(key);
+		match = SLOT_OWNER_KEY_RE.exec(template);
+	}
+	SLOT_OWNER_KEY_RE.lastIndex = 0;
+	match = SLOT_OWNER_PROP_PREFIX_RE.exec(template);
+	while (match) {
+		const key = match[1];
+		if (key) ownerKeys.add(key);
+		match = SLOT_OWNER_PROP_PREFIX_RE.exec(template);
+	}
+	SLOT_OWNER_PROP_PREFIX_RE.lastIndex = 0;
+	const computedExpressions = template.match(/\{\{([\s\S]*?)\}\}/g) ?? [];
+	for (const raw of computedExpressions) {
+		const parsed = parseBabelExpressionFile(raw.slice(2, -2).trim());
+		if (!parsed) continue;
+		traverse(parsed.ast, {
+			MemberExpression(path) {
+				collectOwnerMemberKey(path.node, ownerKeys, slotPropKeys);
+			},
+			OptionalMemberExpression(path) {
+				collectOwnerMemberKey(path.node, ownerKeys, slotPropKeys);
+			}
+		});
+	}
+	return ownerKeys.size ? [...ownerKeys].sort((a, b) => a.localeCompare(b)) : void 0;
+}
+function collectScopedSlotPropsDataKeys(template) {
+	const keys = /* @__PURE__ */ new Set();
+	let match = SLOT_PROPS_DATA_KEY_RE.exec(template);
+	while (match) {
+		const key = match[1] ?? match[2];
+		if (key) keys.add(key);
+		match = SLOT_PROPS_DATA_KEY_RE.exec(template);
+	}
+	SLOT_PROPS_DATA_KEY_RE.lastIndex = 0;
+	return [...keys].sort((a, b) => a.localeCompare(b));
+}
+function renderScopedSlotPropsDataReadyGuard(keys) {
+	if (!keys.length) return;
+	return keys.map((key) => {
+		return `${SLOT_PRESENCE_IDENTIFIER_RE.test(key) ? `${WEVU_GENERIC_SLOT_PROPS_DATA_KEY}.${key}` : `${WEVU_GENERIC_SLOT_PROPS_DATA_KEY}[${toWxmlStringLiteral$1(key)}]`}!==undefined`;
+	}).join("&&");
+}
 function createScopedSlotComponent(context, slotKey, props, children, transformNode) {
 	const ownerHash = hashString(context.filename);
 	const index = context.scopedSlotComponents.length;
@@ -6372,27 +6568,36 @@ function createScopedSlotComponent(context, slotKey, props, children, transformN
 		slotPropStack: [],
 		rewriteScopedSlot: true,
 		classStyleBindings: [],
+		runtimeBindingCache: /* @__PURE__ */ new Map(),
+		runtimeBindingPrefix: "wvslotbind",
 		classStyleWxs: false,
 		forStack: [],
 		forIndexSeed: 0,
 		inlineExpressions: [],
-		inlineExpressionSeed: 0
+		inlineExpressionSeed: 0,
+		scopedSlotOwnerRuntimeBindingTarget: context
 	};
-	let template = withSlotProps(scopedContext, {
+	const slotMapping = {
 		...collectScopePropMapping(context),
 		...props
-	}, () => {
+	};
+	let template = withSlotProps(scopedContext, slotMapping, () => {
 		return children.map((child) => transformNode(child, scopedContext)).join("");
 	});
+	const slotPropsDataReadyGuard = renderScopedSlotPropsDataReadyGuard(collectScopedSlotPropsDataKeys(template));
+	if (slotPropsDataReadyGuard) template = scopedContext.platform.wrapIf(slotPropsDataReadyGuard, template, (exp) => renderMustache(exp, scopedContext));
 	if (scopedContext.classStyleWxs) template = `${buildClassStyleWxsTag(scopedContext.classStyleWxsExtension || "wxs", scopedContext.classStyleWxsSrc)}\n${template}`;
 	asset.template = template;
 	asset.componentGenerics = Object.keys(scopedContext.componentGenerics).length ? scopedContext.componentGenerics : void 0;
 	asset.classStyleBindings = scopedContext.classStyleBindings.length ? scopedContext.classStyleBindings : void 0;
 	asset.classStyleWxs = scopedContext.classStyleWxs || void 0;
 	asset.inlineExpressions = scopedContext.inlineExpressions.length ? scopedContext.inlineExpressions : void 0;
+	asset.ownerKeys = collectScopedSlotOwnerKeys(template, new Set(Object.values(slotMapping)));
+	if (asset.ownerKeys?.length) asset.ownerPropsExpression = `[${asset.ownerKeys.map((key) => `'${key}',${renderOwnerPropSourceExpression(key)}`).join(",")}]`;
 	return {
 		componentName,
-		slotKey
+		slotKey,
+		asset
 	};
 }
 function injectAttributeIntoOpeningTag(source, attr) {
@@ -6406,29 +6611,79 @@ function injectAttributeIntoOpeningTag(source, attr) {
 	if (tagNameEnd <= 1) return null;
 	return `${source.slice(0, tagNameEnd)} ${attr}${source.slice(tagNameEnd)}`;
 }
+function createSlotAttributeNode(sourceNode, attr) {
+	const match = /^slot="([\s\S]*)"$/.exec(attr);
+	if (!match) return null;
+	return {
+		type: NodeTypes.ATTRIBUTE,
+		name: "slot",
+		nameLoc: sourceNode.loc,
+		value: {
+			type: NodeTypes.TEXT,
+			content: match[1],
+			loc: sourceNode.loc
+		},
+		loc: sourceNode.loc
+	};
+}
+function injectSlotAttributeIntoStructuralElementNode(child, slotAttr, transformNode, context) {
+	if (child.type !== NodeTypes.ELEMENT || child.tag === "template") return null;
+	const sourceNode = child;
+	const structural = isStructuralDirective(sourceNode);
+	if (structural.type !== "if" || structural.directive?.name !== "if" || !structural.directive.exp) return null;
+	const slotAttribute = createSlotAttributeNode(sourceNode, slotAttr);
+	if (!slotAttribute) return null;
+	const elementWithoutIf = {
+		...sourceNode,
+		props: [slotAttribute, ...sourceNode.props.filter((prop) => prop !== structural.directive)]
+	};
+	const expValue = normalizeWxmlExpressionWithContext(structural.directive.exp.type === NodeTypes.SIMPLE_EXPRESSION ? structural.directive.exp.content : "", context);
+	const tag = sourceNode.tag;
+	const { attrs, vTextExp } = collectElementAttributes(elementWithoutIf, context, { skipSlotDirective: true });
+	let children = "";
+	if (sourceNode.children.length > 0) children = sourceNode.children.map((childNode) => transformNode(childNode, context)).join("");
+	if (vTextExp !== void 0) children = renderMustache(vTextExp, context);
+	const attrString = attrs.length ? ` ${attrs.join(" ")}` : "";
+	return (children ? `<${tag}${attrString}>${children}</${tag}>` : `<${tag}${attrString} />`).replace(/^<([^\s>/]+)/, `<$1 ${context.platform.directives.ifAttr}="${renderMustache(expValue, context)}"`);
+}
+function isRenderableFallbackChild(child) {
+	if (child.type === NodeTypes.COMMENT) return false;
+	if (child.type === NodeTypes.TEXT) return child.content.trim().length > 0;
+	return true;
+}
 function renderSlotFallback(decl, context, transformNode) {
-	const rawRenderedChildren = decl.children.map((child) => ({ code: transformNode(child, context) }));
-	const rawContent = rawRenderedChildren.map((item) => item.code).join("");
-	if (!rawContent) return "";
 	const slotAttr = renderSlotNameAttribute(decl.name, context, "slot");
 	const wrapCondition = (content) => {
 		return decl.condition ? context.platform.wrapIf(decl.condition, content, (exp) => renderMustache(exp, context)) : content;
 	};
-	if (!slotAttr) return wrapCondition(rawContent);
-	if (!context.slotSingleRootNoWrapper) return wrapCondition(`<view ${slotAttr}>${rawContent}</view>`);
-	const renderedChildren = rawRenderedChildren.filter((item) => item.code.trim().length > 0);
-	if (!renderedChildren.length) return "";
-	const content = renderedChildren.map((item) => item.code).join("");
-	if (renderedChildren.length === 1) {
-		const projected = injectAttributeIntoOpeningTag(renderedChildren[0].code, slotAttr);
+	if (!slotAttr) {
+		const rawContent = decl.children.map((child) => transformNode(child, context)).join("");
+		if (!rawContent) return "";
+		return wrapCondition(rawContent);
+	}
+	const renderableChildren = decl.children.filter(isRenderableFallbackChild);
+	if (!renderableChildren.length) return "";
+	if (!context.slotSingleRootNoWrapper) {
+		const rawContent = decl.children.map((child) => transformNode(child, context)).join("");
+		if (!rawContent) return "";
+		return wrapCondition(`<view ${slotAttr}>${rawContent}</view>`);
+	}
+	if (renderableChildren.length === 1) {
+		const child = renderableChildren[0];
+		if (child.type === NodeTypes.ELEMENT && isStructuralDirective(child).type) {
+			const projected = injectSlotAttributeIntoStructuralElementNode(child, slotAttr, transformNode, context);
+			if (projected) return wrapCondition(projected);
+		}
+		const projected = injectAttributeIntoOpeningTag(transformNode(child, context), slotAttr);
 		if (projected) return wrapCondition(projected);
 	}
-	return wrapCondition(`<view ${slotAttr}>${content}</view>`);
+	return wrapCondition(`<view ${slotAttr}>${renderableChildren.map((child) => transformNode(child, context)).join("")}</view>`);
 }
 function transformSlotElement(node, context, transformNode) {
 	if (isScopedSlotsDisabled(context)) return transformSlotElementPlain(node, context, transformNode);
 	const slotNameInfo = resolveSlotNameFromSlotElement(node);
-	let slotPropsExp = collectSlotBindingExpression(node, context);
+	const slotBindingExps = collectSlotBindingExpressions(node, context);
+	const slotPropsExp = slotBindingExps.props;
 	let fallbackContent = "";
 	if (node.children.length > 0) fallbackContent = node.children.map((child) => transformNode(child, context)).join("");
 	const slotAttrs = [];
@@ -6437,22 +6692,28 @@ function transformSlotElement(node, context, transformNode) {
 	const slotAttrString = slotAttrs.length ? ` ${slotAttrs.join(" ")}` : "";
 	let slotTag = `<slot${slotAttrString} />`;
 	const slotPresentExp = fallbackContent ? createSlotPresenceExpression(slotNameInfo) : void 0;
-	if (fallbackContent) {
-		if (!slotPropsExp && slotPresentExp) slotTag = `${context.platform.wrapIf(slotPresentExp, slotTag, (exp) => renderMustache(exp, context))}${context.platform.wrapElse(fallbackContent)}`;
-		else if (!slotPropsExp) slotTag = `<slot${slotAttrString}>${fallbackContent}</slot>`;
+	if (fallbackContent && !slotPropsExp && !slotPresentExp) slotTag = `<slot${slotAttrString}>${fallbackContent}</slot>`;
+	if (!slotPropsExp && context.scopedSlotsRequireProps) {
+		if (fallbackContent && slotPresentExp) return `${context.platform.wrapIf(slotPresentExp, slotTag, (exp) => renderMustache(exp, context))}${context.platform.wrapElse(fallbackContent)}`;
+		return slotTag;
 	}
-	if (!slotPropsExp && (context.scopedSlotsRequireProps || slotNameInfo.type !== "default")) return slotTag;
 	const genericKey = `scoped-slots-${resolveSlotKey(context, slotNameInfo)}`;
 	context.componentGenerics[genericKey] = true;
-	slotPropsExp = slotPropsExp ?? "[]";
+	const slotPropsFallbackExp = slotPropsExp ?? WEVU_GENERIC_SLOT_OWNER_PROPS_ATTR;
+	const slotPropsDataExp = slotPropsExp && slotBindingExps.data ? registerRuntimeBindingExpression(slotBindingExps.data, context, {
+		hint: "scoped slot props data",
+		prefix: `${WEVU_GENERIC_SLOT_PROPS_DATA_ATTR}_`
+	}) ?? slotPropsFallbackExp : WEVU_GENERIC_SLOT_PROPS_DATA_KEY;
 	const scopedAttrs = [
-		`${context.platform.directives.ifAttr}="${renderMustache(WEVU_SLOT_OWNER_ID_PROP, context)}"`,
-		`${WEVU_SLOT_OWNER_ATTR}="${renderMustache(WEVU_SLOT_OWNER_ID_PROP, context)}"`,
-		`${WEVU_SLOT_PROPS_ATTR}="${renderMustache(slotPropsExp, context)}"`
+		`${WEVU_GENERIC_SLOT_OWNER_ID_ATTR}="${renderMustache(WEVU_GENERIC_SLOT_OWNER_ID_ATTR, context)}"`,
+		`${WEVU_GENERIC_SLOT_PROPS_ATTR}="${renderMustache(slotPropsFallbackExp, context)}"`,
+		`${WEVU_GENERIC_SLOT_PROPS_DATA_ATTR}="${renderMustache(slotPropsDataExp, context)}"`
 	];
-	if (context.slotMultipleInstance) scopedAttrs.push(`${WEVU_SLOT_SCOPE_ATTR}="${renderMustache(WEVU_SLOT_SCOPE_KEY, context)}"`);
-	const scopedTag = `<${genericKey}${scopedAttrs.length ? ` ${scopedAttrs.join(" ")}` : ""} />`;
-	const projectedContent = `${slotTag}${scopedTag}`;
+	if (context.slotMultipleInstance) scopedAttrs.push(`${WEVU_GENERIC_SLOT_SCOPE_ATTR}="${renderMustache(WEVU_SLOT_SCOPE_KEY, context)}"`);
+	scopedAttrs.push(`${WEVU_GENERIC_SLOT_OWNER_PROPS_ATTR}="${renderMustache(WEVU_GENERIC_SLOT_OWNER_PROPS_ATTR, context)}"`);
+	const scopedAttrString = scopedAttrs.length ? ` ${scopedAttrs.join(" ")}` : "";
+	const scopedTag = context.platform.wrapIf(WEVU_GENERIC_SLOT_OWNER_ID_ATTR, `<${genericKey}${scopedAttrString} />`, (exp) => renderMustache(exp, context));
+	const projectedContent = slotPropsExp ? scopedTag : `${slotTag}${scopedTag}`;
 	if (fallbackContent && slotPresentExp) return `${context.platform.wrapIf(slotPresentExp, projectedContent, (exp) => renderMustache(exp, context))}${context.platform.wrapElse(fallbackContent)}`;
 	return projectedContent;
 }
@@ -6471,6 +6732,18 @@ function transformSlotElementPlain(node, context, transformNode) {
 }
 //#endregion
 //#region src/plugins/vue/compiler/template/elements/tag-component.ts
+function createNativeSlotContext(context) {
+	return {
+		...context,
+		classStyleBindings: context.classStyleBindings,
+		runtimeBindingCache: context.runtimeBindingCache,
+		nativeSlotScopeRuntime: {
+			owner: context,
+			bindings: /* @__PURE__ */ new Map(),
+			runtimeBindingPrefix: "wvslotbind"
+		}
+	};
+}
 function hasLegacySlotAttribute(children) {
 	return children.some((child) => {
 		if (child.type !== NodeTypes.ELEMENT) return false;
@@ -6491,10 +6764,52 @@ function hasDirectComponentSlotChild(children, context) {
 		return /^[A-Z]/.test(child.tag);
 	});
 }
-function shouldAugmentPlainDefaultSlot(decl, context) {
-	if (context.scopedSlotsRequireProps || !decl.implicitDefault) return false;
-	if (context.scopedSlotsCompiler === "augmented") return true;
-	return hasDirectComponentSlotChild(decl.children, context);
+function hasComponentSlotDescendant(children, context) {
+	return children.some((child) => {
+		if (child.type !== NodeTypes.ELEMENT) return false;
+		if (child.tag === "template") return false;
+		if (child.tag === "component") return true;
+		return !isBuiltinTag(resolveTemplateTagName(child.tag, context)) || /^[A-Z]/.test(child.tag) || hasComponentSlotDescendant(child.children, context);
+	});
+}
+function hasStructuralSlotRoot(children) {
+	return children.some((child) => {
+		if (child.type !== NodeTypes.ELEMENT) return false;
+		return Boolean(isStructuralDirective(child).type);
+	});
+}
+function hasParentExpressionSlotContent(children) {
+	return children.some((child) => {
+		if (child.type === NodeTypes.INTERPOLATION) return true;
+		if (child.type !== NodeTypes.ELEMENT) return false;
+		const element = child;
+		if (element.props.some((prop) => prop.type === NodeTypes.DIRECTIVE && prop.name !== "slot")) return true;
+		return hasParentExpressionSlotContent(element.children);
+	});
+}
+function hasRuntimeOnlySlotExpression(children) {
+	return children.some((child) => {
+		if (child.type === NodeTypes.INTERPOLATION) {
+			const content = child.content;
+			return shouldFallbackToRuntimeBinding(content?.type === NodeTypes.SIMPLE_EXPRESSION ? content.content : "");
+		}
+		if (child.type !== NodeTypes.ELEMENT) return false;
+		const element = child;
+		if (element.props.some((prop) => {
+			if (prop.type !== NodeTypes.DIRECTIVE || prop.name === "slot") return false;
+			return shouldFallbackToRuntimeBinding(prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION ? prop.exp.content : "");
+		})) return true;
+		return hasRuntimeOnlySlotExpression(element.children);
+	});
+}
+function shouldAugmentPlainSlot(decl, context) {
+	if (context.scopedSlotsRequireProps) return false;
+	if (hasParentExpressionSlotContent(decl.children)) return hasComponentSlotDescendant(decl.children, context) || context.scopedSlotsCompiler === "augmented" && (hasStructuralSlotRoot(decl.children) || hasRuntimeOnlySlotExpression(decl.children));
+	if (context.scopedSlotsCompiler === "augmented" && !decl.implicitDefault && (!context.slotSingleRootNoWrapper || hasStructuralSlotRoot(decl.children))) return true;
+	if (context.scopedSlotsCompiler === "augmented" && decl.implicitDefault && hasComponentSlotDescendant(decl.children, context)) return true;
+	if (hasDirectComponentSlotChild(decl.children, context)) return true;
+	if (!decl.implicitDefault) return false;
+	return context.scopedSlotsCompiler === "augmented" && (hasStructuralSlotRoot(decl.children) || hasRuntimeOnlySlotExpression(decl.children));
 }
 function resolveTemplateSlotCondition(node, context) {
 	const ifDirective = node.props.find((prop) => prop.type === NodeTypes.DIRECTIVE && prop.name === "if" && prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION);
@@ -6535,8 +6850,19 @@ function shouldExposePlainSlotPresence(node) {
 function isWevuComponentTag(node, context) {
 	return context.wevuComponentTags ? context.wevuComponentTags.has(node.tag) : /^[A-Z]/.test(node.tag);
 }
+function buildScopedSlotOwnerIdExpression(context) {
+	return context.rewriteScopedSlot ? `${WEVU_GENERIC_SLOT_OWNER_ID_ATTR} || ${WEVU_SLOT_OWNER_ID_KEY} || ''` : `${WEVU_SLOT_OWNER_ID_KEY} || ''`;
+}
+function shouldTransformAsComponentWithSlots(node, context, resolvedTag = resolveTemplateTagName(node.tag, context)) {
+	const slotDirective = findSlotDirective(node);
+	const templateSlotChildren = node.children.filter((child) => child.type === NodeTypes.ELEMENT && child.tag === "template" && findSlotDirective(child));
+	const shouldUseAugmentedDefaultSlot = node.children.length > 0 && !context.scopedSlotsRequireProps && !isBuiltinTag(resolvedTag);
+	const shouldUseSlotPresenceMetadata = node.children.length > 0 && isWevuComponentTag(node, context);
+	return slotDirective || templateSlotChildren.length > 0 || shouldUseAugmentedDefaultSlot || shouldUseSlotPresenceMetadata;
+}
 function transformComponentWithSlots(node, context, transformNode, options) {
 	if (isScopedSlotsDisabled(context)) return transformComponentWithSlotsFallback(node, context, transformNode, options);
+	if (node.tag !== "component" && context.wevuComponentTags && !isWevuComponentTag(node, context)) return transformComponentWithSlotsFallback(node, context, transformNode, options);
 	const extraAttrs = options?.extraAttrs ?? [];
 	const slotDeclarations = [];
 	const slotDirective = findSlotDirective(node);
@@ -6569,24 +6895,32 @@ function transformComponentWithSlots(node, context, transformNode, options) {
 		let children = node.children.map((child) => transformNode(child, context)).join("");
 		if (vTextExp !== void 0) children = renderMustache(vTextExp, context);
 		if (children && defaultSlotChildren.length && !hasLegacySlotAttribute(defaultSlotChildren) && isWevuComponentTag(node, context)) pushSlotNamesAttr(attrs, [{ name: "'default'" }], context);
-		const attrString = attrs.length ? ` ${attrs.join(" ")}` : "";
+		const mergedAttrs = [...extraAttrs, ...attrs];
+		const attrString = mergedAttrs.length ? ` ${mergedAttrs.join(" ")}` : "";
 		const { tag } = node;
 		return children ? `<${tag}${attrString}>${children}</${tag}>` : `<${tag}${attrString} />`;
 	}
 	const scopedSlotDeclarations = [];
 	const plainSlotDeclarations = [];
-	for (const decl of slotDeclarations) if (Object.keys(decl.props).length > 0 || shouldAugmentPlainDefaultSlot(decl, context)) scopedSlotDeclarations.push(decl);
+	for (const decl of slotDeclarations) if (Object.keys(decl.props).length > 0 || shouldAugmentPlainSlot(decl, context)) scopedSlotDeclarations.push(decl);
 	else plainSlotDeclarations.push(decl);
 	const slotNames = [];
 	const slotGenericAttrs = [];
 	for (const decl of scopedSlotDeclarations) {
 		const slotKey = resolveSlotKey(context, decl.name);
-		const { componentName } = createScopedSlotComponent(context, slotKey, decl.props, decl.children, transformNode);
+		const { componentName, asset } = createScopedSlotComponent(context, slotKey, decl.props, decl.children, transformNode);
 		slotNames.push({
 			name: stringifySlotName(decl.name, context),
 			condition: decl.condition
 		});
 		slotGenericAttrs.push(`generic:scoped-slots-${slotKey}="${componentName}"`);
+		if (asset.ownerPropsExpression) {
+			const ownerPropsRef = registerRuntimeBindingExpression(asset.ownerPropsExpression, context, {
+				hint: "scoped slot owner props",
+				prefix: "wvslotownerprops"
+			});
+			slotGenericAttrs.push(`${WEVU_GENERIC_SLOT_OWNER_PROPS_ATTR}="${renderMustache(ownerPropsRef ?? asset.ownerPropsExpression, context)}"`);
+		}
 	}
 	if (shouldExposePlainSlotPresence(node) || isWevuComponentTag(node, context)) for (const decl of plainSlotDeclarations) slotNames.push({
 		name: stringifySlotName(decl.name, context),
@@ -6605,12 +6939,22 @@ function transformComponentWithSlots(node, context, transformNode, options) {
 	pushSlotNamesAttr(mergedAttrs, slotNames, context);
 	if (scopedSlotDeclarations.length) {
 		const scopePropsExp = buildScopePropsExpression(context);
-		if (scopePropsExp) mergedAttrs.push(`${WEVU_SLOT_SCOPE_ATTR}="${renderMustache(scopePropsExp, context)}"`);
-		mergedAttrs.push(`${WEVU_SLOT_OWNER_ID_ATTR}="${renderMustache(`${WEVU_SLOT_OWNER_ID_KEY} || ''`, context)}"`);
+		if (scopePropsExp) mergedAttrs.push(`${WEVU_GENERIC_SLOT_SCOPE_ATTR}="${renderMustache(scopePropsExp, context)}"`);
+		const ownerIdExp = renderMustache(buildScopedSlotOwnerIdExpression(context), context);
+		mergedAttrs.push(`${WEVU_GENERIC_SLOT_OWNER_ID_ATTR}="${ownerIdExp}"`);
 	}
-	const attrString = mergedAttrs.length ? ` ${mergedAttrs.join(" ")}` : "";
 	const { tag } = node;
-	const plainSlotContent = plainSlotDeclarations.map((decl) => renderSlotFallback(decl, context, transformNode)).join("");
+	const nativeSlotContext = plainSlotDeclarations.length ? createNativeSlotContext(context) : context;
+	const plainSlotContent = plainSlotDeclarations.map((decl) => renderSlotFallback(decl, nativeSlotContext, transformNode)).join("");
+	const nativeSlotBindings = nativeSlotContext.nativeSlotScopeRuntime?.bindings;
+	if (nativeSlotBindings?.size) {
+		const bindingEntries = Array.from(nativeSlotBindings);
+		const scopeExp = `[${bindingEntries.map(([key, value]) => `'${key}',${value}`).join(",")}]`;
+		mergedAttrs.push(`${WEVU_GENERIC_SLOT_SCOPE_ATTR}="${renderMustache(scopeExp, context)}"`);
+		const readyExp = bindingEntries.map(([key]) => `${key}!==undefined`).join("&&");
+		if (readyExp) mergedAttrs.push(`${context.platform.directives.ifAttr}="${renderMustache(readyExp, context)}"`);
+	}
+	const attrString = mergedAttrs.length ? ` ${mergedAttrs.join(" ")}` : "";
 	return plainSlotContent ? `<${tag}${attrString}>${plainSlotContent}</${tag}>` : `<${tag}${attrString} />`;
 }
 function transformComponentWithSlotsFallback(node, context, transformNode, options) {
@@ -6645,7 +6989,8 @@ function transformComponentWithSlotsFallback(node, context, transformNode, optio
 		let children = node.children.map((child) => transformNode(child, context)).join("");
 		if (vTextExp !== void 0) children = renderMustache(vTextExp, context);
 		if (children && defaultSlotChildren.length && !hasLegacySlotAttribute(defaultSlotChildren) && isWevuComponentTag(node, context)) pushSlotNamesAttr(attrs, [{ name: "'default'" }], context);
-		const attrString = attrs.length ? ` ${attrs.join(" ")}` : "";
+		const mergedAttrs = [...extraAttrs, ...attrs];
+		const attrString = mergedAttrs.length ? ` ${mergedAttrs.join(" ")}` : "";
 		const { tag } = node;
 		return children ? `<${tag}${attrString}>${children}</${tag}>` : `<${tag}${attrString} />`;
 	}
@@ -6707,11 +7052,7 @@ function transformComponentElement(node, context, transformNode) {
 //#region src/plugins/vue/compiler/template/elements/tag-normal.ts
 function transformNormalElement(node, context, transformNode) {
 	const tag = resolveTemplateTagName(node.tag, context);
-	const slotDirective = findSlotDirective(node);
-	const templateSlotChildren = node.children.filter((child) => child.type === NodeTypes.ELEMENT && child.tag === "template" && findSlotDirective(child));
-	const shouldUseAugmentedDefaultSlot = node.children.length > 0 && !context.scopedSlotsRequireProps && !isBuiltinTag(tag);
-	const shouldUseSlotPresenceMetadata = node.children.length > 0 && (context.wevuComponentTags ? context.wevuComponentTags.has(node.tag) : /^[A-Z]/.test(node.tag));
-	if (slotDirective || templateSlotChildren.length > 0 || shouldUseAugmentedDefaultSlot || shouldUseSlotPresenceMetadata) return transformComponentWithSlots(node, context, transformNode);
+	if (shouldTransformAsComponentWithSlots(node, context, tag)) return transformComponentWithSlots(node, context, transformNode);
 	const { attrs, vTextExp } = collectElementAttributes(node, context, { resolvedTag: tag });
 	let children = "";
 	if (node.children.length > 0) children = node.children.map((child) => transformNode(child, context)).join("");
@@ -6723,6 +7064,16 @@ function transformNormalElement(node, context, transformNode) {
 //#region src/plugins/vue/compiler/template/elements/tag-structural.ts
 const REGEX_SPECIAL_CHARS_RE = /[.*+?^${}()|[\]\\]/g;
 function resolveConditionExpression$1(rawExpValue, context, hint) {
+	if (context.nativeSlotScopeRuntime) {
+		const runtimeExp = registerRuntimeBindingExpression(rawExpValue, context.nativeSlotScopeRuntime.owner, {
+			hint,
+			prefix: context.nativeSlotScopeRuntime.runtimeBindingPrefix
+		});
+		if (runtimeExp) {
+			context.nativeSlotScopeRuntime.bindings.set(runtimeExp, runtimeExp);
+			return runtimeExp;
+		}
+	}
 	return (shouldFallbackToRuntimeBinding(rawExpValue) ? registerRuntimeBindingExpression(rawExpValue, context, { hint }) : null) ?? normalizeWxmlExpressionWithContext(rawExpValue, context);
 }
 function transformIfElement(node, context, transformNode) {
@@ -6789,21 +7140,20 @@ function transformForElement(node, context, transformNode) {
 			props: otherProps
 		};
 		const extraAttrs = listExp ? context.platform.forAttrs(listExp, renderTemplateMustache, forInfo.item, forInfo.index) : [];
-		const slotDirective = findSlotDirective(elementWithoutFor);
-		const templateSlotChildren = elementWithoutFor.children.filter((child) => child.type === NodeTypes.ELEMENT && child.tag === "template" && findSlotDirective(child));
-		if (slotDirective || templateSlotChildren.length > 0) return transformComponentWithSlots(elementWithoutFor, context, transformNode, {
+		const resolvedTag = resolveTemplateTagName(elementWithoutFor.tag, context);
+		if (shouldTransformAsComponentWithSlots(elementWithoutFor, context, resolvedTag)) return transformComponentWithSlots(elementWithoutFor, context, transformNode, {
 			extraAttrs,
 			forInfo
 		});
 		const { attrs, vTextExp } = collectElementAttributes(elementWithoutFor, context, {
 			forInfo,
 			extraAttrs,
-			resolvedTag: resolveTemplateTagName(elementWithoutFor.tag, context)
+			resolvedTag
 		});
 		let children = "";
 		if (elementWithoutFor.children.length > 0) children = elementWithoutFor.children.map((child) => transformNode(child, context)).join("");
 		if (vTextExp !== void 0) children = renderMustache(vTextExp, context);
-		const tag = resolveTemplateTagName(elementWithoutFor.tag, context);
+		const tag = resolvedTag;
 		const attrString = attrs.length ? ` ${attrs.join(" ")}` : "";
 		return children ? `<${tag}${attrString}>${children}</${tag}>` : `<${tag}${attrString} />`;
 	}));
@@ -6913,6 +7263,16 @@ function transformInterpolation(node, context) {
 	const { content } = node;
 	if (content.type === NodeTypes.SIMPLE_EXPRESSION) {
 		const rawExpValue = content.content;
+		if (context.nativeSlotScopeRuntime) {
+			const runtimeExp = registerRuntimeBindingExpression(rawExpValue, context.nativeSlotScopeRuntime.owner, {
+				hint: "插值表达式",
+				prefix: context.nativeSlotScopeRuntime.runtimeBindingPrefix
+			});
+			if (runtimeExp) {
+				context.nativeSlotScopeRuntime.bindings.set(runtimeExp, runtimeExp);
+				return renderMustache(runtimeExp, context);
+			}
+		}
 		return renderMustache((shouldFallbackToRuntimeBinding(rawExpValue) ? registerRuntimeBindingExpression(rawExpValue, context, { hint: "插值表达式" }) : null) ?? normalizeWxmlExpressionWithContext(rawExpValue, context), context);
 	}
 	/* istanbul ignore next */
@@ -6985,6 +7345,8 @@ function compileVueTemplateToWxml(template, filename, options) {
 			objectLiteralBindMode: options?.objectLiteralBindMode ?? "runtime",
 			mustacheInterpolation: options?.mustacheInterpolation ?? "compact",
 			classStyleBindings: [],
+			runtimeBindingCache: /* @__PURE__ */ new Map(),
+			runtimeBindingPrefix: "__wv_bind_",
 			classStyleWxs: false,
 			classStyleWxsExtension: wxsExtension,
 			classStyleWxsSrc: options?.classStyleWxsSrc,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wevu/compiler",
   "type": "module",
-  "version": "6.16.7",
+  "version": "6.16.8",
   "description": "wevu 编译器基础包，面向小程序模板的编译与转换",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -50,9 +50,9 @@
     "merge": "^2.1.1",
     "pathe": "^2.0.3",
     "vue": "^3.5.34",
-    "@weapp-core/constants": "^0.1.4",
+    "@weapp-core/constants": "^0.1.5",
     "@weapp-core/shared": "3.0.4",
-    "@weapp-vite/ast": "6.16.7",
+    "@weapp-vite/ast": "6.16.8",
     "rolldown-require": "2.0.15"
   },
   "publishConfig": {