ripple 0.3.6 → 0.3.8

package/src/compiler/phases/2-analyze/index.js

@@ -76,8 +76,16 @@ function mark_control_flow_has_template(path) {
  * @param {AST.Identifier} source_id - The identifier to access properties on
  * @param {AnalysisState} state - The analysis state
  * @param {boolean} writable - Whether assignments/updates should be supported (let vs const)
+ * @param {boolean} is_track_call - Whether the RHS is a Ripple track() call
  */
-function setup_lazy_transforms(pattern, source_id, state, writable) {
+function setup_lazy_transforms(pattern, source_id, state, writable, is_track_call) {
+	// For ArrayPattern from track() calls, use direct get/set calls as a fast path
+	// instead of going through prototype getters source[0]/source[1]
+	if (pattern.type === 'ArrayPattern' && is_track_call) {
+		setup_lazy_array_transforms(pattern, source_id, state, writable);
+		return;
+	}
+
 	const paths = extract_paths(pattern);
 
 	for (const path of paths) {
@@ -141,6 +149,214 @@ function setup_lazy_transforms(pattern, source_id, state, writable) {
 	}
 }
 
+/**
+ * Set up fast-path transforms for lazy array destructuring of tracked values.
+ * For index 0 (the value): uses _$_.get/set/update directly instead of source[0] getters.
+ * For index 1 (the tracked ref): returns source directly instead of source[1].
+ * @param {AST.ArrayPattern} pattern - The array destructuring pattern
+ * @param {AST.Identifier} source_id - The identifier for the tracked value
+ * @param {AnalysisState} state - The analysis state
+ * @param {boolean} writable - Whether assignments/updates should be supported
+ */
+function setup_lazy_array_transforms(pattern, source_id, state, writable) {
+	for (let i = 0; i < pattern.elements.length; i++) {
+		const element = pattern.elements[i];
+		if (!element) continue;
+
+		// Rest elements — fall back to generic source.slice(i)
+		if (element.type === 'RestElement') {
+			const rest_paths = extract_paths(pattern);
+			for (const path of rest_paths) {
+				if (!path.is_rest) continue;
+				const name = /** @type {AST.Identifier} */ (path.node).name;
+				const binding = state.scope.get(name);
+				if (binding !== null) {
+					binding.kind = path.has_default_value ? 'lazy_fallback' : 'lazy';
+					binding.transform = {
+						read: (_) => path.expression(source_id),
+					};
+				}
+			}
+			continue;
+		}
+
+		const actual = element.type === 'AssignmentPattern' ? element.left : element;
+		const has_fallback = element.type === 'AssignmentPattern';
+		const fallback_value = has_fallback
+			? /** @type {AST.AssignmentPattern} */ (element).right
+			: null;
+
+		if (actual.type === 'Identifier' && i <= 1) {
+			const name = actual.name;
+			const binding = state.scope.get(name);
+			if (binding === null) continue;
+
+			binding.kind = has_fallback ? 'lazy_fallback' : 'lazy';
+
+			if (i === 0) {
+				// Fast path for index 0: use _$_.get(source) instead of source[0]
+				const read_expr = has_fallback
+					? () => b.call('_$_.fallback', b.call('_$_.get', source_id), fallback_value)
+					: () => b.call('_$_.get', source_id);
+
+				// Signal that read already produces an unwrapped value (calls _$_.get internally)
+				binding.read_unwraps = true;
+
+				binding.transform = {
+					read: (_) => read_expr(),
+				};
+
+				if (writable) {
+					binding.transform.assign = (_, value) => {
+						return b.call('_$_.set', source_id, value);
+					};
+
+					if (has_fallback) {
+						binding.transform.update = (node) => {
+							const delta = node.operator === '++' ? b.literal(1) : b.literal(-1);
+							const temp = b.id('_v');
+
+							if (node.prefix) {
+								// ++count: compute new value and set it, return new value
+								return b.call(
+									b.arrow(
+										[],
+										b.block([
+											b.var(temp, b.binary('+', read_expr(), delta)),
+											b.stmt(b.call('_$_.set', source_id, temp)),
+											b.return(temp),
+										]),
+									),
+								);
+							} else {
+								// count++: read old value, set new value, return old value
+								return b.call(
+									b.arrow(
+										[],
+										b.block([
+											b.var(temp, read_expr()),
+											b.stmt(b.call('_$_.set', source_id, b.binary('+', temp, delta))),
+											b.return(temp),
+										]),
+									),
+								);
+							}
+						};
+					} else {
+						binding.transform.update = (node) => {
+							const fn_name = node.prefix ? '_$_.update_pre' : '_$_.update';
+							const args = [source_id];
+							if (node.operator === '--') {
+								args.push(b.literal(-1));
+							}
+							return b.call(fn_name, ...args);
+						};
+					}
+				}
+			} else {
+				// Fast path for index 1: source itself is the tracked ref
+				binding.transform = {
+					read: (_) => source_id,
+				};
+			}
+		} else {
+			// Nested patterns or indices > 1: fall back to generic source[i] access via extract_paths
+			/** @type {(object: AST.Expression) => AST.Expression} */
+			const base_expression =
+				i === 0
+					? (object) => b.call('_$_.get', object)
+					: i === 1
+						? (object) => object
+						: (object) => b.member(object, b.literal(i), true);
+
+			const inner_paths = extract_paths(element);
+			for (const path of inner_paths) {
+				const name = /** @type {AST.Identifier} */ (path.node).name;
+				const binding = state.scope.get(name);
+				if (binding === null) continue;
+
+				binding.kind = path.has_default_value ? 'lazy_fallback' : 'lazy';
+
+				binding.transform = {
+					read: (_) => path.expression(base_expression(source_id)),
+				};
+
+				if (writable) {
+					binding.transform.assign = (node, value) => {
+						return b.assignment(
+							'=',
+							/** @type {AST.MemberExpression} */ (
+								path.update_expression(base_expression(source_id))
+							),
+							value,
+						);
+					};
+
+					if (path.has_default_value) {
+						binding.transform.update = (node) => {
+							const member = path.update_expression(base_expression(source_id));
+							const fallback_read = path.expression(base_expression(source_id));
+							const delta = node.operator === '++' ? b.literal(1) : b.literal(-1);
+
+							if (node.prefix) {
+								return b.assignment('=', member, b.binary('+', fallback_read, delta));
+							} else {
+								const temp = b.id('_v');
+								return b.call(
+									b.arrow(
+										[],
+										b.block([
+											b.var(temp, fallback_read),
+											b.stmt(b.assignment('=', member, b.binary('+', temp, delta))),
+											b.return(temp),
+										]),
+									),
+								);
+							}
+						};
+					} else {
+						binding.transform.update = (node) =>
+							b.update(
+								node.operator,
+								path.update_expression(base_expression(source_id)),
+								node.prefix,
+							);
+					}
+				}
+			}
+		}
+	}
+}
+
+/**
+ * Checks if a function parameter has a Tracked<T> type annotation imported from ripple.
+ * This is used to determine if lazy array destructuring should use the track tuple fast path.
+ * @param {AST.ArrayPattern} param - The parameter pattern node
+ * @param {AnalysisContext} context - The analysis context
+ * @returns {boolean}
+ */
+function is_param_tracked_type(param, context) {
+	const annotation = param.typeAnnotation?.typeAnnotation;
+
+	if (
+		annotation?.type === 'TSTypeReference' &&
+		annotation.typeName?.type === 'Identifier' &&
+		annotation.typeName.name === 'Tracked'
+	) {
+		const binding = context.state.scope.get('Tracked');
+
+		return (
+			binding?.declaration_kind === 'import' &&
+			binding.initial !== null &&
+			binding.initial.type === 'ImportDeclaration' &&
+			binding.initial.source.type === 'Literal' &&
+			binding.initial.source.value === 'ripple'
+		);
+	}
+
+	return false;
+}
+
 /**
  * @param {AST.Function} node
  * @param {AnalysisContext} context
@@ -158,7 +374,11 @@ function visit_function(node, context) {
 
 		if ((param.type === 'ObjectPattern' || param.type === 'ArrayPattern') && param.lazy) {
 			const param_id = b.id(context.state.scope.generate('param'));
-			setup_lazy_transforms(param, param_id, context.state, true);
+			// For ArrayPattern params with a Tracked<T> type annotation from ripple,
+			// use the track tuple fast path (get/set instead of source[0]/source[1])
+			const is_tracked_type =
+				param.type === 'ArrayPattern' && is_param_tracked_type(param, context);
+			setup_lazy_transforms(param, param_id, context.state, true, is_tracked_type);
 			// Store the generated identifier name on the pattern for the transform phase
 			param.metadata = { ...param.metadata, lazy_id: param_id.name };
 		}
@@ -391,6 +611,21 @@ const visitors = {
 			}
 		}
 
+		// Lazy bindings from track() calls (read_unwraps) are inherently reactive —
+		// propagate tracking so that control flow (if/for/switch)
+		// and early returns create reactive blocks
+		if (
+			!node.tracked &&
+			binding?.read_unwraps &&
+			is_reference(node, /** @type {AST.Node} */ (parent)) &&
+			binding.node !== node
+		) {
+			mark_as_tracked(context.path);
+			if (context.state.metadata?.tracking === false) {
+				context.state.metadata.tracking = true;
+			}
+		}
+
 		context.next();
 	},
 
@@ -471,7 +706,7 @@ const visitors = {
 
 				if (propertyName && internalProperties.has(propertyName)) {
 					error(
-						`Directly accessing internal property "${propertyName}" of a tracked object is not allowed. Use \`get(${node.object.name})\` or \`@${node.object.name}\` instead.`,
+						`Directly accessing internal property "${propertyName}" of a tracked object is not allowed. Use \`${node.object.name}.value\` or \`&[]\` lazy destructuring instead.`,
 						context.state.analysis.module.filename,
 						node.property,
 						context.state.loose ? context.state.analysis.errors : undefined,
@@ -482,16 +717,32 @@ const visitors = {
 
 			if (
 				binding !== null &&
+				binding.kind !== 'lazy' &&
+				binding.kind !== 'lazy_fallback' &&
 				binding.initial?.type === 'CallExpression' &&
 				is_ripple_track_call(binding.initial.callee, context)
 			) {
-				error(
-					`Accessing a tracked object directly is not allowed, use the \`@\` prefix to read the value inside a tracked object - for example \`@${node.object.name}${node.property.type === 'Identifier' ? `.${node.property.name}` : ''}\``,
-					context.state.analysis.module.filename,
-					node.object,
-					context.state.loose ? context.state.analysis.errors : undefined,
-					context.state.analysis.comments,
-				);
+				const is_allowed_tracked_access =
+					// Allow [0] and [1] indexed access on tracked objects.
+					(node.computed &&
+						node.property.type === 'Literal' &&
+						(node.property.value === 0 || node.property.value === 1)) ||
+					// Allow .value and .length property access on tracked objects.
+					(!node.computed &&
+						node.property.type === 'Identifier' &&
+						(node.property.name === 'value' || node.property.name === 'length'));
+
+				if (is_allowed_tracked_access) {
+					// pass through
+				} else {
+					error(
+						`Accessing a tracked object directly is not allowed, use \`.value\` or \`&[]\` lazy destructuring to read the value inside a tracked object - for example \`${node.object.name}.value\``,
+						context.state.analysis.module.filename,
+						node.object,
+						context.state.loose ? context.state.analysis.errors : undefined,
+						context.state.analysis.comments,
+					);
+				}
 			}
 		}
 
@@ -570,25 +821,14 @@ const visitors = {
 				) {
 					const lazy_id = b.id(state.scope.generate('lazy'));
 					const writable = node.kind !== 'const';
-					setup_lazy_transforms(declarator.id, lazy_id, state, writable);
+					const init_is_track =
+						declarator.init?.type === 'CallExpression' &&
+						is_ripple_track_call(declarator.init.callee, context) === 'track';
+					setup_lazy_transforms(declarator.id, lazy_id, state, writable, !!init_is_track);
 					// Store the generated identifier name on the pattern for the transform phase
 					declarator.id.metadata = { ...declarator.id.metadata, lazy_id: lazy_id.name };
 				}
 
-				const paths = extract_paths(declarator.id);
-
-				for (const path of paths) {
-					if (path.node.tracked) {
-						error(
-							'Variables cannot be reactively referenced using @',
-							state.analysis.module.filename,
-							path.node,
-							context.state.loose ? context.state.analysis.errors : undefined,
-							context.state.analysis.comments,
-						);
-					}
-				}
-
 				visit(declarator, state);
 			}
 
@@ -596,6 +836,30 @@ const visitors = {
 		}
 	},
 
+	ExpressionStatement(node, context) {
+		const { state, visit } = context;
+
+		// Handle standalone lazy destructuring assignment: &[data] = track(0);
+		if (
+			node.expression.type === 'AssignmentExpression' &&
+			node.expression.operator === '=' &&
+			(node.expression.left.type === 'ObjectPattern' ||
+				node.expression.left.type === 'ArrayPattern') &&
+			node.expression.left.lazy
+		) {
+			const pattern = /** @type {AST.ObjectPattern | AST.ArrayPattern} */ (node.expression.left);
+			const lazy_id = b.id(state.scope.generate('lazy'));
+			const init = /** @type {AST.Expression} */ (node.expression.right);
+			const init_is_track =
+				init?.type === 'CallExpression' && is_ripple_track_call(init.callee, context) === 'track';
+			setup_lazy_transforms(pattern, lazy_id, state, true, !!init_is_track);
+			// Store the generated identifier name on the pattern for the transform phase
+			pattern.metadata = { ...pattern.metadata, lazy_id: lazy_id.name };
+		}
+
+		context.next();
+	},
+
 	StyleIdentifier(node, context) {
 		const component = is_inside_component(context, true);
 		const parent = context.path.at(-1);
@@ -651,7 +915,7 @@ const visitors = {
 
 			if ((props.type === 'ObjectPattern' || props.type === 'ArrayPattern') && props.lazy) {
 				// Lazy destructuring: &{...} or &[...] — set up lazy transforms
-				setup_lazy_transforms(props, b.id('__props'), context.state, true);
+				setup_lazy_transforms(props, b.id('__props'), context.state, true, false);
 			} else if (props.type === 'AssignmentPattern') {
 				error(
 					'Props are always an object, use destructured props with default values instead',

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

@@ -533,9 +533,6 @@ const visitors = {
 					if (context.state.metadata?.tracking === false) {
 						context.state.metadata.tracking = true;
 					}
-					if (node.tracked) {
-						return b.call('_$_.get', build_getter(node, context));
-					}
 				}
 				return build_getter(node, context);
 			}
@@ -634,17 +631,9 @@ const visitors = {
 			}
 		}
 
-		if (!context.state.to_ts && is_ripple_track_call(callee, context)) {
-			const track_method_name =
-				callee.type === 'Identifier'
-					? callee.name === 'trackSplit'
-						? 'track_split'
-						: 'track'
-					: callee.type === 'MemberExpression' && callee.property.type === 'Identifier'
-						? callee.property.name === 'trackSplit'
-							? 'track_split'
-							: 'track'
-						: 'track';
+		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';
 
 			if (callee.type === 'Identifier' && callee.name === 'track') {
 				if (node.arguments.length === 0) {
@@ -927,6 +916,25 @@ const visitors = {
 		return context.next();
 	},
 
+	ExpressionStatement(node, context) {
+		// Handle standalone lazy destructuring: &[data] = track(0); → const lazy0 = track(0);
+		if (
+			node.expression.type === 'AssignmentExpression' &&
+			node.expression.left.lazy &&
+			node.expression.left.metadata?.lazy_id
+		) {
+			if (context.state.to_ts) {
+				// In TypeScript mode, convert to a regular assignment (drop the pattern)
+				node.expression.left.lazy = false;
+				delete node.expression.left.metadata.lazy_id;
+				return context.next();
+			}
+			const right = /** @type {AST.Expression} */ (context.visit(node.expression.right));
+			return b.const(b.id(node.expression.left.metadata.lazy_id), right);
+		}
+		return context.next();
+	},
+
 	VariableDeclaration(node, context) {
 		for (const declarator of node.declarations) {
 			if (!context.state.to_ts) {
@@ -943,6 +951,20 @@ const visitors = {
 			}
 		}
 
+		if (context.state.to_ts) {
+			for (const declarator of node.declarations) {
+				if (
+					(declarator.id.type === 'ObjectPattern' || declarator.id.type === 'ArrayPattern') &&
+					declarator.id.lazy
+				) {
+					declarator.id.lazy = false;
+					if (declarator.id.metadata?.lazy_id) {
+						delete declarator.id.metadata.lazy_id;
+					}
+				}
+			}
+		}
+
 		return context.next();
 	},
 
@@ -2019,6 +2041,24 @@ const visitors = {
 
 		const left = node.left;
 
+		// Handle lazy binding assignments (e.g., value = 5 where value is from let &[value] = track(0))
+		// Must come before the left.tracked check to use the binding's transform
+		if (left.type === 'Identifier') {
+			const binding = context.state.scope?.get(left.name);
+			if (binding?.transform?.assign && binding.node !== left) {
+				let value = /** @type {AST.Expression} */ (context.visit(node.right));
+
+				// For compound operators (+=, -=, *=, /=), expand to read + operation
+				if (node.operator !== '=') {
+					const operator = node.operator.slice(0, -1); // '+=' -> '+'
+					const current = binding.transform.read(left);
+					value = b.binary(/** @type {AST.BinaryOperator} */ (operator), current, value);
+				}
+
+				return binding.transform.assign(left, value);
+			}
+		}
+
 		if (
 			left.type === 'MemberExpression' &&
 			(left.tracked || (left.property.type === 'Identifier' && left.property.tracked))

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

@@ -333,29 +333,7 @@ const visitors = {
 				binding.node !== node &&
 				(binding.kind === 'lazy' || binding.kind === 'lazy_fallback')
 			) {
-				const transformed = binding.transform.read(node);
-				if (node.tracked) {
-					const is_right_side_of_assignment =
-						parent.type === 'AssignmentExpression' && parent.right === node;
-					if (
-						(parent.type !== 'AssignmentExpression' && parent.type !== 'UpdateExpression') ||
-						is_right_side_of_assignment
-					) {
-						return b.call('_$_.get', transformed);
-					}
-				}
-				return transformed;
-			}
-
-			if (node.tracked) {
-				const is_right_side_of_assignment =
-					parent.type === 'AssignmentExpression' && parent.right === node;
-				if (
-					(parent.type !== 'AssignmentExpression' && parent.type !== 'UpdateExpression') ||
-					is_right_side_of_assignment
-				) {
-					return b.call('_$_.get', node);
-				}
+				return binding.transform.read(node);
 			}
 
 			return node;
@@ -520,17 +498,9 @@ const visitors = {
 			}
 		}
 
-		if (is_ripple_track_call(callee, context)) {
-			const track_method_name =
-				callee.type === 'Identifier'
-					? callee.name === 'trackSplit'
-						? 'track_split'
-						: 'track'
-					: callee.type === 'MemberExpression' && callee.property.type === 'Identifier'
-						? callee.property.name === 'trackSplit'
-							? 'track_split'
-							: 'track'
-						: 'track';
+		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';
 
 			return {
 				...node,
@@ -843,6 +813,19 @@ const visitors = {
 		return statements.length ? b.block(statements) : b.empty;
 	},
 
+	ExpressionStatement(node, context) {
+		// Handle standalone lazy destructuring: &[data] = track(0); → const lazy0 = track(0);
+		if (
+			node.expression.type === 'AssignmentExpression' &&
+			node.expression.left.lazy &&
+			node.expression.left.metadata?.lazy_id
+		) {
+			const right = /** @type {AST.Expression} */ (context.visit(node.expression.right));
+			return b.const(b.id(node.expression.left.metadata.lazy_id), right);
+		}
+		return context.next();
+	},
+
 	VariableDeclaration(node, context) {
 		for (const declarator of node.declarations) {
 			if (!context.state.to_ts) {
@@ -1210,9 +1193,10 @@ const visitors = {
 
 			/** @type {AST.Statement[]} */
 			const init = [];
+			const visited_id = /** @type {AST.Expression} */ (visit(node.id, state));
 			/** @type {AST.Statement[]} */
 			const statements = [
-				b.const(comp_id, /** @type {AST.Expression} */ (visit(node.id, state))),
+				b.const(comp_id, is_element_dynamic(node) ? b.call('_$_.get', visited_id) : visited_id),
 				b.const(args_id, b.array(args)),
 			];
 

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

@@ -1157,9 +1157,11 @@ export interface Binding {
 	/** Transform functions for reading, assigning, and updating this binding */
 	transform?: {
 		read: (node?: AST.Identifier) => AST.Expression;
-		assign?: (node: AST.Pattern, value: AST.Expression) => AST.AssignmentExpression;
+		assign?: (node: AST.Identifier, value: AST.Expression) => AST.Expression;
 		update?: (node: AST.UpdateExpression) => AST.Expression;
 	};
+	/** Whether the read transform already produces an unwrapped value (calls get() internally) */
+	read_unwraps?: boolean;
 }
 
 /**

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

@@ -543,8 +543,6 @@ export namespace Parse {
 		 */
 		finishToken(type: TokenType, val?: string | number | RegExp | bigint): void;
 
-		readAtIdentifier(): void;
-
 		/**
 		 * Read a token based on character code
 		 * Called by nextToken() for each character
@@ -930,8 +928,6 @@ export namespace Parse {
 			| AST.ServerIdentifier
 			| AST.StyleIdentifier
 			| AST.TrackedExpression
-			| AST.RippleArrayExpression
-			| AST.RippleObjectExpression
 			| AST.Component
 			| AST.Identifier
 			| AST.Literal;
@@ -954,12 +950,8 @@ export namespace Parse {
 		/** Parse parenthesized expression (just the expression) */
 		parseParenExpression(): AST.Expression;
 
-		parseRippleArrayExpression(): AST.RippleArrayExpression;
-
 		parseTrackedExpression(): AST.TrackedExpression;
 
-		parseRippleObjectExpression(): AST.RippleObjectExpression;
-
 		/**
 		 * Parse item in parentheses (can be overridden for flow/ts)
 		 */

package/src/compiler/utils.js

@@ -289,27 +289,31 @@ export function is_component_level_function(context) {
 }
 
 /**
- * Returns true if callee is a Ripple track call
+ * Returns the matched Ripple tracking call name
  * @param {AST.Expression | AST.Super} callee
  * @param {CommonContext} context
- * @returns {boolean}
+ * @returns {'track' | 'trackSplit' | null}
  */
 export function is_ripple_track_call(callee, context) {
 	// Super expressions cannot be Ripple track calls
-	if (callee.type === 'Super') return false;
+	if (callee.type === 'Super') return null;
 
 	if (callee.type === 'Identifier' && (callee.name === 'track' || callee.name === 'trackSplit')) {
-		return is_ripple_import(callee, context);
+		return is_ripple_import(callee, context) ? callee.name : null;
 	}
 
-	return (
+	if (
 		callee.type === 'MemberExpression' &&
 		callee.object.type === 'Identifier' &&
 		callee.property.type === 'Identifier' &&
 		(callee.property.name === 'track' || callee.property.name === 'trackSplit') &&
 		!callee.computed &&
 		is_ripple_import(callee, context)
-	);
+	) {
+		return callee.property.name;
+	}
+
+	return null;
 }
 
 /**

package/src/runtime/internal/client/composite.js

@@ -3,7 +3,7 @@
 import { branch, destroy_block, render, render_spread } from './blocks.js';
 import { COMPOSITE_BLOCK, DEFAULT_NAMESPACE, NAMESPACE_URI } from './constants.js';
 import { hydrate_next, hydrating } from './hydration.js';
-import { active_block, active_namespace, with_ns } from './runtime.js';
+import { active_block, active_namespace, get, with_ns } from './runtime.js';
 import { top_element_to_ns } from './utils.js';
 
 /**
@@ -29,7 +29,7 @@ export function composite(get_component, node, props) {
 
 	render(
 		() => {
-			var component = get_component();
+			var component = get(get_component());
 
 			if (b !== null) {
 				destroy_block(b);

package/src/runtime/internal/client/index.js

@@ -80,6 +80,8 @@ export { switch_block as switch } from './switch.js';
 
 export { template, append, text } from './template.js';
 
+export { array_slice } from './utils.js';
+
 export { ripple_array } from '../../array.js';
 
 export { ripple_object } from '../../object.js';