ripple 0.3.8 → 0.3.9

package/src/compiler/phases/3-transform/client/index.js

@@ -58,6 +58,7 @@ import {
 	flatten_switch_consequent,
 	get_ripple_namespace_call_name,
 	is_ripple_import,
+	replace_lazy_param_pattern,
 	ripple_import_requires_block,
 } from '../../../utils.js';
 import {
@@ -111,16 +112,12 @@ function visit_function(node, context) {
 	// Replace lazy destructuring params with generated identifiers
 	const transformed_params = node.params.map((param) => {
 		const pattern = param.type === 'AssignmentPattern' ? param.left : param;
-		if (
-			(pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') &&
-			pattern.lazy &&
-			pattern.metadata?.lazy_id
-		) {
-			const id = b.id(pattern.metadata.lazy_id);
+		if (pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') {
+			const transformed_pattern = replace_lazy_param_pattern(pattern);
 			if (param.type === 'AssignmentPattern') {
-				return /** @type {AST.AssignmentPattern} */ ({ ...param, left: id });
+				return /** @type {AST.AssignmentPattern} */ ({ ...param, left: transformed_pattern });
 			}
-			return id;
+			return transformed_pattern;
 		}
 		return param;
 	});
@@ -633,7 +630,7 @@ const visitors = {
 
 		const matched_track_call = !context.state.to_ts ? is_ripple_track_call(callee, context) : null;
 		if (matched_track_call) {
-			const track_method_name = matched_track_call === 'trackSplit' ? 'track_split' : 'track';
+			const track_method_name = 'track';
 
 			if (callee.type === 'Identifier' && callee.name === 'track') {
 				if (node.arguments.length === 0) {
@@ -803,71 +800,11 @@ const visitors = {
 		return b.call('_$_.with_scope', b.id('__block'), b.thunk(new_node));
 	},
 
-	TrackedExpression(node, context) {
-		if (context.state.to_ts) {
-			const visited = /** @type {AST.Expression} */ (context.visit(node.argument));
-			const member = b.member(
-				visited,
-				b.literal('#v'),
-				true,
-				!is_inside_left_side_assignment(node),
-				/** @type {AST.NodeWithLocation} */ (node),
-			);
-			member.tracked = true;
-			return member;
-		}
-		return b.call('_$_.get', /** @type {AST.Expression} */ (context.visit(node.argument)));
-	},
-
 	MemberExpression(node, context) {
 		if (context.state.metadata?.tracking === false) {
 			context.state.metadata.tracking = true;
 		}
 
-		if (
-			node.tracked ||
-			((node.property.type === 'Identifier' || node.property.type === 'Literal') &&
-				node.property.tracked)
-		) {
-			if (context.state.to_ts) {
-				// In TypeScript mode, transform @user.@name or @user.@['name'] or @user?.@name
-				// to user['#v'].name['#v'] or user['#v']['name']['#v'] or user['#v']?.name['#v']
-				const visited_object = /** @type {AST.Expression} */ (context.visit(node.object));
-				const visited_property = /** @type {AST.Expression} */ (context.visit(node.property));
-
-				// Build the member access: object.property or object[property]
-				const member = b.member(
-					visited_object,
-					visited_property,
-					node.computed,
-					node.optional,
-					/** @type {AST.NodeWithLocation} */ (node),
-				);
-
-				// Wrap with ['#v'] access
-				const member_expanded = b.member(
-					member,
-					b.literal('#v'),
-					true,
-					!is_inside_left_side_assignment(node),
-					/** @type {AST.NodeWithLocation} */ (node),
-				);
-				member_expanded.tracked = true;
-				return member_expanded;
-			} else {
-				if (!context.state.to_ts) {
-					return b.call(
-						'_$_.get_property',
-						/** @type {AST.Expression} */ (context.visit(node.object)),
-						node.computed
-							? /** @type {AST.Expression} */ (context.visit(node.property))
-							: b.literal(/** @type {AST.Identifier} */ (node.property).name),
-						node.optional ? b.true : undefined,
-					);
-				}
-			}
-		}
-
 		if (node.object.type === 'MemberExpression' && node.object.optional) {
 			const metadata = { tracking: false, await: false };
 
@@ -1986,7 +1923,9 @@ const visitors = {
 				delete props_param.typeAnnotation;
 				if (!props_param.lazy) {
 					// Non-lazy destructuring: use the pattern directly as the function param
-					props = props_param;
+					props = /** @type {AST.ObjectPattern | AST.ArrayPattern} */ (
+						replace_lazy_param_pattern(props_param)
+					);
 				}
 				// Lazy destructuring: props stays as __props, bindings resolved via transforms
 			}
@@ -2059,56 +1998,6 @@ const visitors = {
 			}
 		}
 
-		if (
-			left.type === 'MemberExpression' &&
-			(left.tracked || (left.property.type === 'Identifier' && left.property.tracked))
-		) {
-			const operator = node.operator;
-			const right = node.right;
-
-			if (operator !== '=' && context.state.metadata?.tracking === false) {
-				context.state.metadata.tracking = true;
-			}
-
-			return b.call(
-				'_$_.set_property',
-				/** @type {AST.Expression} */ (
-					context.visit(left.object, { ...context.state, metadata: { tracking: false } })
-				),
-				left.computed
-					? /** @type {AST.Expression} */ (context.visit(left.property))
-					: b.literal(/** @type {AST.Identifier} */ (left.property).name),
-				operator === '='
-					? /** @type {AST.Expression} */ (context.visit(right))
-					: b.binary(
-							operator === '+=' ? '+' : operator === '-=' ? '-' : operator === '*=' ? '*' : '/',
-							/** @type {AST.Expression} */ (context.visit(left)),
-							/** @type {AST.Expression} */ (context.visit(right)),
-						),
-			);
-		}
-
-		if (left.type === 'Identifier' && left.tracked) {
-			const operator = node.operator;
-			const right = node.right;
-
-			return b.call(
-				'_$_.set',
-				/** @type {AST.Expression} */ (
-					context.visit(left, { ...context.state, metadata: { tracking: null } })
-				),
-				operator === '='
-					? /** @type {AST.Expression} */ (context.visit(right))
-					: b.binary(
-							operator === '+=' ? '+' : operator === '-=' ? '-' : operator === '*=' ? '*' : '/',
-							/** @type {AST.Expression} */ (
-								context.visit(left, { ...context.state, metadata: { tracking: false } })
-							),
-							/** @type {AST.Expression} */ (context.visit(right)),
-						),
-			);
-		}
-
 		return visit_assignment_expression(node, context, build_assignment) ?? context.next();
 	},
 
@@ -2126,43 +2015,6 @@ const visitors = {
 			}
 		}
 
-		if (
-			argument.type === 'MemberExpression' &&
-			(argument.tracked || (argument.property.type === 'Identifier' && argument.property.tracked))
-		) {
-			if (context.state.metadata?.tracking === false) {
-				context.state.metadata.tracking = true;
-			}
-
-			return b.call(
-				node.prefix ? '_$_.update_pre_property' : '_$_.update_property',
-				/** @type {AST.Expression} */
-				(context.visit(argument.object, { ...context.state, metadata: { tracking: false } })),
-				argument.computed
-					? /** @type {AST.Expression} */ (context.visit(argument.property))
-					: b.literal(/** @type {AST.Identifier} */ (argument.property).name),
-				node.operator === '--' ? b.literal(-1) : undefined,
-			);
-		}
-
-		if (argument.type === 'Identifier' && argument.tracked) {
-			return b.call(
-				node.prefix ? '_$_.update_pre' : '_$_.update',
-				/** @type {AST.Expression} */
-				(context.visit(argument, { ...context.state, metadata: { tracking: null } })),
-				node.operator === '--' ? b.literal(-1) : undefined,
-			);
-		}
-
-		if (argument.type === 'TrackedExpression') {
-			return b.call(
-				node.prefix ? '_$_.update_pre' : '_$_.update',
-				/** @type {AST.Expression} */
-				(context.visit(argument.argument, { ...context.state, metadata: { tracking: null } })),
-				node.operator === '--' ? b.literal(-1) : undefined,
-			);
-		}
-
 		const left = object(/** @type {AST.MemberExpression | AST.Identifier} */ (argument));
 		const binding = left && context.state.scope.get(left.name);
 		const transformers = left && binding?.transform;

package/src/compiler/phases/3-transform/segments.js

@@ -1123,13 +1123,6 @@ export function convert_source_map_to_mappings(
 						mapping_data_verify_only,
 					);
 
-					if (node.tracked) {
-						mapping.generatedLengths[0] = mapping.generatedLengths[0] + "['#v']".length;
-						if (node.optional) {
-							mapping.generatedLengths[0] = mapping.generatedLengths[0] + '.?'.length;
-						}
-					}
-
 					mappings.push(mapping);
 				}
 

package/src/compiler/phases/3-transform/server/index.js

@@ -27,7 +27,7 @@ import {
 	is_element_dynamic,
 	is_ripple_track_call,
 	is_ripple_import,
-	ripple_import_requires_block,
+	replace_lazy_param_pattern,
 	hash,
 	flatten_switch_consequent,
 	get_ripple_namespace_call_name,
@@ -355,7 +355,7 @@ const visitors = {
 					// Lazy destructuring: use __props identifier, bindings resolved via transforms
 					props_param_output = b.id('__props');
 				} else {
-					props_param_output = props_param;
+					props_param_output = replace_lazy_param_pattern(props_param);
 				}
 			} else {
 				props_param_output = props_param;
@@ -500,7 +500,7 @@ const visitors = {
 
 		const track_call_name = is_ripple_track_call(callee, context);
 		if (track_call_name) {
-			const track_method_name = track_call_name === 'trackSplit' ? 'track_split' : 'track';
+			const track_method_name = 'track';
 
 			return {
 				...node,
@@ -597,16 +597,12 @@ const visitors = {
 				}
 				// Replace lazy destructuring params with generated identifiers
 				const pattern = param.type === 'AssignmentPattern' ? param.left : param;
-				if (
-					(pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') &&
-					pattern.lazy &&
-					pattern.metadata?.lazy_id
-				) {
-					const id = b.id(pattern.metadata.lazy_id);
+				if (pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') {
+					const transformed_pattern = replace_lazy_param_pattern(pattern);
 					node.params[i] =
 						param.type === 'AssignmentPattern'
-							? /** @type {AST.AssignmentPattern} */ ({ ...param, left: id })
-							: id;
+							? /** @type {AST.AssignmentPattern} */ ({ ...param, left: transformed_pattern })
+							: transformed_pattern;
 				}
 			}
 		}
@@ -626,16 +622,12 @@ const visitors = {
 				}
 				// Replace lazy destructuring params with generated identifiers
 				const pattern = param.type === 'AssignmentPattern' ? param.left : param;
-				if (
-					(pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') &&
-					pattern.lazy &&
-					pattern.metadata?.lazy_id
-				) {
-					const id = b.id(pattern.metadata.lazy_id);
+				if (pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') {
+					const transformed_pattern = replace_lazy_param_pattern(pattern);
 					node.params[i] =
 						param.type === 'AssignmentPattern'
-							? /** @type {AST.AssignmentPattern} */ ({ ...param, left: id })
-							: id;
+							? /** @type {AST.AssignmentPattern} */ ({ ...param, left: transformed_pattern })
+							: transformed_pattern;
 				}
 			}
 		}
@@ -665,16 +657,12 @@ const visitors = {
 			}
 			// Replace lazy destructuring params with generated identifiers
 			const pattern = param.type === 'AssignmentPattern' ? param.left : param;
-			if (
-				(pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') &&
-				pattern.lazy &&
-				pattern.metadata?.lazy_id
-			) {
-				const id = b.id(pattern.metadata.lazy_id);
+			if (pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') {
+				const transformed_pattern = replace_lazy_param_pattern(pattern);
 				node.params[i] =
 					param.type === 'AssignmentPattern'
-						? /** @type {AST.AssignmentPattern} */ ({ ...param, left: id })
-						: id;
+						? /** @type {AST.AssignmentPattern} */ ({ ...param, left: transformed_pattern })
+						: transformed_pattern;
 			}
 		}
 
@@ -1429,53 +1417,6 @@ const visitors = {
 			}
 		}
 
-		if (
-			left.type === 'MemberExpression' &&
-			(left.tracked || (left.property.type === 'Identifier' && left.property.tracked))
-		) {
-			const operator = node.operator;
-			const right = node.right;
-
-			return b.call(
-				'_$_.set_property',
-				/** @type {AST.Expression} */ (context.visit(left.object)),
-				left.computed
-					? /** @type {AST.Expression} */ (context.visit(left.property))
-					: b.literal(/** @type {AST.Identifier} */ (left.property).name),
-				operator === '='
-					? /** @type {AST.Expression} */ (context.visit(right))
-					: b.binary(
-							operator === '+=' ? '+' : operator === '-=' ? '-' : operator === '*=' ? '*' : '/',
-							b.call(
-								'_$_.get_property',
-								/** @type {AST.Expression} */ (context.visit(left.object)),
-								left.computed
-									? /** @type {AST.Expression} */ (context.visit(left.property))
-									: b.literal(/** @type {AST.Identifier} */ (left.property).name),
-								undefined,
-							),
-							/** @type {AST.Expression} */ (context.visit(right)),
-						),
-			);
-		}
-
-		if (left.type === 'Identifier' && left.tracked) {
-			const operator = node.operator;
-			const right = node.right;
-
-			return b.call(
-				'_$_.set',
-				/** @type {AST.Expression} */ (context.visit(left)),
-				operator === '='
-					? /** @type {AST.Expression} */ (context.visit(right))
-					: b.binary(
-							operator === '+=' ? '+' : operator === '-=' ? '-' : operator === '*=' ? '*' : '/',
-							b.call('_$_.get', left),
-							/** @type {AST.Expression} */ (context.visit(right)),
-						),
-			);
-		}
-
 		return context.next();
 	},
 
@@ -1489,39 +1430,6 @@ const visitors = {
 				return binding.transform.update(node);
 			}
 		}
-
-		if (
-			argument.type === 'MemberExpression' &&
-			(argument.tracked || (argument.property.type === 'Identifier' && argument.property.tracked))
-		) {
-			return b.call(
-				node.prefix ? '_$_.update_pre_property' : '_$_.update_property',
-				/** @type {AST.Expression} */
-				(context.visit(argument.object, { ...context.state, metadata: { tracking: false } })),
-				argument.computed
-					? /** @type {AST.Expression} */ (context.visit(argument.property))
-					: b.literal(/** @type {AST.Identifier} */ (argument.property).name),
-				node.operator === '--' ? b.literal(-1) : undefined,
-			);
-		}
-
-		if (argument.type === 'Identifier' && argument.tracked) {
-			return b.call(
-				node.prefix ? '_$_.update_pre' : '_$_.update',
-				/** @type {AST.Expression} */
-				(context.visit(argument)),
-				node.operator === '--' ? b.literal(-1) : undefined,
-			);
-		}
-
-		if (argument.type === 'TrackedExpression') {
-			return b.call(
-				node.prefix ? '_$_.update_pre' : '_$_.update',
-				/** @type {AST.Expression} */
-				(context.visit(argument.argument)),
-				node.operator === '--' ? b.literal(-1) : undefined,
-			);
-		}
 	},
 
 	ServerIdentifier(node, context) {
@@ -1703,26 +1611,7 @@ const visitors = {
 		return b.await(/** @type {AST.AwaitExpression} */ (context.visit(node.argument)));
 	},
 
-	TrackedExpression(node, context) {
-		return b.call('_$_.get', /** @type {AST.Expression} */ (context.visit(node.argument)));
-	},
-
 	MemberExpression(node, context) {
-		if (
-			node.tracked ||
-			((node.property.type === 'Identifier' || node.property.type === 'Literal') &&
-				node.property.tracked)
-		) {
-			return b.call(
-				'_$_.get_property',
-				/** @type {AST.Expression} */ (context.visit(node.object)),
-				node.computed
-					? /** @type {AST.Expression} */ (context.visit(node.property))
-					: b.literal(/** @type {AST.Identifier} */ (node.property).name),
-				node.optional ? b.true : undefined,
-			);
-		}
-
 		return context.next();
 	},
 
@@ -1730,10 +1619,6 @@ const visitors = {
 		const metadata = { await: false };
 		let expression = /** @type {AST.Expression} */ (visit(node.expression, { ...state, metadata }));
 
-		if (expression.type === 'Identifier' && expression.tracked) {
-			expression = b.call('_$_.get', expression);
-		}
-
 		if (expression.type === 'Literal') {
 			state.init?.push(
 				b.stmt(

package/src/compiler/types/acorn.d.ts

@@ -6,6 +6,6 @@
 //
 // The relative import of './parser' loads the augmentation declarations
 // (declare module 'acorn' { ... }) so the re-exported types include
-// Ripple-specific nodes like Component, Element, TrackedExpression, etc.
+// Ripple-specific nodes like Component, Element, etc.
 import './parser.d.ts';
 export * from 'acorn';

package/src/compiler/types/estree.d.ts

@@ -6,6 +6,6 @@
 //
 // The relative import of './index' loads the augmentation declarations
 // (declare module 'estree' { ... }) so the re-exported types include
-// Ripple-specific nodes like Component, Element, TrackedExpression, etc.
+// Ripple-specific nodes like Component, Element, etc.
 import './index';
 export * from 'estree';

package/src/compiler/types/import.d.ts

@@ -41,7 +41,6 @@ import {
 	MediaQuery as _$_MediaQuery__,
 	createRefKey as _$_RefKey__create,
 	track as _$_track__,
-	trackSplit as _$_trackSplit__,
 	effect as _$_effect__,
 	untrack as _$_untrack__,
 	ripple_namespace as _$__u0023_ripple,
@@ -59,7 +58,6 @@ export {
 	_$_MediaQuery__,
 	_$_RefKey__create,
 	_$_track__,
-	_$_trackSplit__,
 	_$_effect__,
 	_$_untrack__,
 	_$__u0023_ripple,

package/src/compiler/types/index.d.ts

@@ -116,19 +116,17 @@ declare module 'estree' {
 
 	// We mark the whole node as marked when member is @[expression]
 	// Otherwise, we only mark Identifier nodes
-	interface MemberExpression extends AST.TrackedNode {}
+	interface MemberExpression {}
 
-	// These 3 are needed so that Literal can extend TrackedNode
-	// since Literal is a union type we have to extend each individually
-	interface SimpleLiteral extends AST.LiteralTrackedNode {}
-	interface RegExpLiteral extends AST.LiteralTrackedNode {}
-	interface BigIntLiteral extends AST.LiteralTrackedNode {}
+	interface SimpleLiteral extends AST.LiteralNode {}
+	interface RegExpLiteral extends AST.LiteralNode {}
+	interface BigIntLiteral extends AST.LiteralNode {}
 
 	interface TrackedNode {
 		tracked?: boolean;
 	}
 
-	interface LiteralTrackedNode extends AST.TrackedNode {
+	interface LiteralNode {
 		was_expression?: boolean;
 	}
 
@@ -143,7 +141,6 @@ declare module 'estree' {
 		ServerBlockStatement: ServerBlockStatement;
 		ServerIdentifier: ServerIdentifier;
 		StyleIdentifier: StyleIdentifier;
-		TrackedExpression: TrackedExpression;
 		Attribute: Attribute;
 		RefAttribute: RefAttribute;
 		SpreadAttribute: SpreadAttribute;
@@ -152,7 +149,6 @@ declare module 'estree' {
 	}
 
 	interface ExpressionMap {
-		TrackedExpression: TrackedExpression;
 		StyleIdentifier: StyleIdentifier;
 		ServerIdentifier: ServerIdentifier;
 		Text: TextNode;
@@ -345,14 +341,6 @@ declare module 'estree' {
 		content: string;
 	}
 
-	/**
-	 * Tracked Expressions
-	 */
-	interface TrackedExpression extends AST.BaseExpression {
-		argument: AST.Expression;
-		type: 'TrackedExpression';
-	}
-
 	/**
 	 * Ripple attribute nodes
 	 */

package/src/compiler/types/parse.d.ts

@@ -924,13 +924,7 @@ export namespace Parse {
 			refDestructuringErrors?: DestructuringErrors,
 			forInit?: ForInit,
 			forNew?: boolean,
-		):
-			| AST.ServerIdentifier
-			| AST.StyleIdentifier
-			| AST.TrackedExpression
-			| AST.Component
-			| AST.Identifier
-			| AST.Literal;
+		): AST.ServerIdentifier | AST.StyleIdentifier | AST.Component | AST.Identifier | AST.Literal;
 
 		/** Default handler for parseExprAtom when no other case matches */
 		parseExprAtomDefault(): AST.Expression;
@@ -950,8 +944,6 @@ export namespace Parse {
 		/** Parse parenthesized expression (just the expression) */
 		parseParenExpression(): AST.Expression;
 
-		parseTrackedExpression(): AST.TrackedExpression;
-
 		/**
 		 * Parse item in parentheses (can be overridden for flow/ts)
 		 */

package/src/compiler/utils.js

@@ -292,25 +292,25 @@ export function is_component_level_function(context) {
  * Returns the matched Ripple tracking call name
  * @param {AST.Expression | AST.Super} callee
  * @param {CommonContext} context
- * @returns {'track' | 'trackSplit' | null}
+ * @returns {'track' | null}
  */
 export function is_ripple_track_call(callee, context) {
 	// Super expressions cannot be Ripple track calls
 	if (callee.type === 'Super') return null;
 
-	if (callee.type === 'Identifier' && (callee.name === 'track' || callee.name === 'trackSplit')) {
-		return is_ripple_import(callee, context) ? callee.name : null;
+	if (callee.type === 'Identifier' && callee.name === 'track') {
+		return is_ripple_import(callee, context) ? 'track' : null;
 	}
 
 	if (
 		callee.type === 'MemberExpression' &&
 		callee.object.type === 'Identifier' &&
 		callee.property.type === 'Identifier' &&
-		(callee.property.name === 'track' || callee.property.name === 'trackSplit') &&
+		callee.property.name === 'track' &&
 		!callee.computed &&
 		is_ripple_import(callee, context)
 	) {
-		return callee.property.name;
+		return 'track';
 	}
 
 	return null;
@@ -606,21 +606,8 @@ export function is_element_dynamic(node) {
  * @returns {boolean}
  */
 function is_id_dynamic(node) {
-	if (node.type === 'Identifier' || node.type === 'Literal') {
-		if (node.tracked) {
-			return true;
-		}
-
-		return false;
-	} else if (node.type === 'MemberExpression') {
-		if (/** @type {AST.Identifier} */ (node.object).tracked === true) {
-			return true;
-		}
-		if (node.property.type === 'MemberExpression') {
-			return is_id_dynamic(node.property);
-		}
-
-		return !!(/** @type {AST.Identifier} */ (node.property).tracked);
+	if (node.type === 'Identifier') {
+		return !!node.tracked;
 	}
 
 	return false;
@@ -686,6 +673,52 @@ function normalize_child(node, normalized, context) {
 	}
 }
 
+/**
+ * Replaces any lazy subpatterns in a parameter pattern with their generated identifiers.
+ * This is used by client and server transforms so nested lazy destructuring can coexist
+ * with otherwise normal object/array params.
+ * @param {AST.Pattern} pattern
+ * @returns {AST.Pattern}
+ */
+export function replace_lazy_param_pattern(pattern) {
+	switch (pattern.type) {
+		case 'AssignmentPattern':
+			return { ...pattern, left: replace_lazy_param_pattern(pattern.left) };
+
+		case 'ObjectPattern':
+			if (pattern.lazy && pattern.metadata?.lazy_id) {
+				return /** @type {AST.Pattern} */ (b.id(pattern.metadata.lazy_id));
+			}
+
+			return {
+				...pattern,
+				properties: pattern.properties.map((property) =>
+					property.type === 'RestElement'
+						? { ...property, argument: replace_lazy_param_pattern(property.argument) }
+						: { ...property, value: replace_lazy_param_pattern(property.value) },
+				),
+			};
+
+		case 'ArrayPattern':
+			if (pattern.lazy && pattern.metadata?.lazy_id) {
+				return /** @type {AST.Pattern} */ (b.id(pattern.metadata.lazy_id));
+			}
+
+			return {
+				...pattern,
+				elements: pattern.elements.map((element) =>
+					element === null ? null : replace_lazy_param_pattern(element),
+				),
+			};
+
+		case 'RestElement':
+			return { ...pattern, argument: replace_lazy_param_pattern(pattern.argument) };
+
+		default:
+			return pattern;
+	}
+}
+
 /**
  * @param {CommonContext} context
  */