add to server, add stack overflow guard

Author: Ocean-OS

packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/element.js

@@ -6,12 +6,8 @@ import { is_ignored } from '../../../../../state.js';
 import { is_event_attribute } from '../../../../../utils/ast.js';
 import * as b from '../../../../../utils/builders.js';
 import { build_getter } from '../../utils.js';
-import {
-	build_template_chunk,
-	get_expression_id,
-	DYNAMIC,
-	evaluate_static_expression
-} from './utils.js';
+import { build_template_chunk, get_expression_id } from './utils.js';
+import { evaluate_static_expression, DYNAMIC } from '../../../shared/static-evaluation.js';
 
 /**
  * @param {Array<AST.Attribute | AST.SpreadAttribute>} attributes

packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/utils.js

@@ -1,4 +1,4 @@
-/** @import { Expression, ExpressionStatement, Identifier, MemberExpression, SequenceExpression, Statement, Super, Node, UnaryExpression, TemplateLiteral, BinaryExpression, LogicalExpression, ConditionalExpression } from 'estree' */
+/** @import { Expression, ExpressionStatement, Identifier, MemberExpression, SequenceExpression, Statement, Super } from 'estree' */
 /** @import { AST, ExpressionMetadata } from '#compiler' */
 /** @import { ComponentClientTransformState } from '../../types' */
 import { walk } from 'zimmerframe';
@@ -9,6 +9,7 @@ import { regex_is_valid_identifier } from '../../../../patterns.js';
 import is_reference from 'is-reference';
 import { locator } from '../../../../../state.js';
 import { create_derived } from '../../utils.js';
+import { evaluate_static_expression, DYNAMIC } from '../../../shared/static-evaluation.js';
 
 /**
  * @param {ComponentClientTransformState} state
@@ -74,201 +75,6 @@ function compare_expressions(a, b) {
 
 	return true;
 }
-export const DYNAMIC = Symbol('DYNAMIC');
-
-/**
- * @param {Node} node
- * @param {ComponentClientTransformState} state
- * @returns {any}
- */
-export function evaluate_static_expression(node, state) {
-	if (node == undefined) return DYNAMIC;
-	/**
-	 * @param {BinaryExpression | LogicalExpression} node
-	 */
-	function handle_left_right(node) {
-		const left = evaluate_static_expression(node?.left, state);
-		const right = evaluate_static_expression(node?.right, state);
-		if (left === DYNAMIC || right === DYNAMIC) {
-			return DYNAMIC;
-		}
-		switch (node.operator) {
-			case '+':
-				return left + right;
-			case '-':
-				return left - right;
-			case '&':
-				return left & right;
-			case '|':
-				return left | right;
-			case '<<':
-				return left << right;
-			case '>>':
-				return left >> right;
-			case '>':
-				return left > right;
-			case '<':
-				return left < right;
-			case '>=':
-				return left >= right;
-			case '<=':
-				return left <= right;
-			case '==':
-				return left == right;
-			case '===':
-				return left === right;
-			case '||':
-				return left || right;
-			case '??':
-				return left ?? right;
-			case '&&':
-				return left && right;
-			case '%':
-				return left % right;
-			case '>>>':
-				return left >>> right;
-			case '^':
-				return left ^ right;
-			case '**':
-				return left ** right;
-			case '*':
-				return left * right;
-			case '/':
-				return left / right;
-			case '!=':
-				return left != right;
-			case '!==':
-				return left !== right;
-			default:
-				return DYNAMIC;
-		}
-	}
-	/**
-	 * @param {UnaryExpression} node
-	 */
-	function handle_unary(node) {
-		const argument = evaluate_static_expression(node?.argument, state);
-		if (argument === DYNAMIC) return DYNAMIC;
-		/**
-		 * @param {Expression} argument
-		 */
-		function handle_void(argument) {
-			//@ts-ignore
-			const evaluated = evaluate_static_expression(argument);
-			if (evaluated !== DYNAMIC) {
-				return undefined;
-			}
-			return DYNAMIC;
-		}
-		switch (node.operator) {
-			case '!':
-				return !argument;
-			case '-':
-				return -argument;
-			case 'typeof':
-				return typeof argument;
-			case '~':
-				return ~argument;
-			case '+':
-				return +argument;
-			case 'void':
-				return handle_void(argument);
-			default:
-				// `delete` is ignored, since it may have side effects
-				return DYNAMIC;
-		}
-	}
-	/**
-	 * @param {SequenceExpression} node
-	 */
-	function handle_sequence(node) {
-		const is_static = node.expressions.reduce(
-			(a, b) => a && evaluate_static_expression(b, state) !== DYNAMIC,
-			true
-		);
-		if (is_static) {
-			//@ts-ignore
-			return evaluate_static_expression(node.expressions.at(-1), state);
-		}
-		return DYNAMIC;
-	}
-	/**
-	 * @param {string} name
-	 */
-	function handle_ident(name) {
-		const scope = state.scope.get(name);
-		if (scope?.kind === 'normal' && scope?.declaration_kind !== 'import') {
-			if (scope.initial && !scope.mutated && !scope.reassigned && !scope.updated) {
-				//@ts-ignore
-				let evaluated = evaluate_static_expression(scope.initial, state);
-				return evaluated;
-			}
-		}
-		return DYNAMIC;
-	}
-	/**
-	 * @param {TemplateLiteral} node
-	 */
-	function handle_template(node) {
-		const expressions = node.expressions;
-		const quasis = node.quasis;
-		const is_static = expressions.reduce(
-			(a, b) => a && evaluate_static_expression(b, state) !== DYNAMIC,
-			true
-		);
-		if (is_static) {
-			let res = '';
-			let last_was_quasi = false;
-			let expr_index = 0;
-			let quasi_index = 0;
-			for (let index = 0; index < quasis.length + expressions.length; index++) {
-				if (last_was_quasi) {
-					res += evaluate_static_expression(expressions[expr_index++], state);
-					last_was_quasi = false;
-				} else {
-					res += quasis[quasi_index++].value.cooked;
-					last_was_quasi = true;
-				}
-			}
-			return res;
-		}
-		return DYNAMIC;
-	}
-	/**
-	 * @param {ConditionalExpression} node
-	 */
-	function handle_ternary(node) {
-		const test = evaluate_static_expression(node.test, state);
-		if (test !== DYNAMIC) {
-			if (test) {
-				return evaluate_static_expression(node.consequent, state);
-			} else {
-				return evaluate_static_expression(node.alternate, state);
-			}
-		}
-		return DYNAMIC;
-	}
-	switch (node.type) {
-		case 'Literal':
-			return node.value;
-		case 'BinaryExpression':
-			return handle_left_right(node);
-		case 'LogicalExpression':
-			return handle_left_right(node);
-		case 'UnaryExpression':
-			return handle_unary(node);
-		case 'Identifier':
-			return handle_ident(node.name);
-		case 'SequenceExpression':
-			return handle_sequence(node);
-		case 'TemplateLiteral':
-			return handle_template(node);
-		case 'ConditionalExpression':
-			return handle_ternary(node);
-		default:
-			return DYNAMIC;
-	}
-}
 
 /**
  * @param {Array<AST.Text | AST.ExpressionTag>} values

packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/utils.js

@@ -11,6 +11,7 @@ import {
 import * as b from '../../../../../utils/builders.js';
 import { sanitize_template_string } from '../../../../../utils/sanitize_template_string.js';
 import { regex_whitespaces_strict } from '../../../../patterns.js';
+import { evaluate_static_expression, DYNAMIC } from '../../../shared/static-evaluation.js';
 
 /** Opens an if/each block, so that we can remove nodes in the case of a mismatch */
 export const block_open = b.literal(BLOCK_OPEN);
@@ -49,7 +50,15 @@ export function process_children(nodes, { visit, state }) {
 					quasi.value.cooked += escape_html(node.expression.value + '');
 				}
 			} else {
-				expressions.push(b.call('$.escape', /** @type {Expression} */ (visit(node.expression))));
+				let evaluated = evaluate_static_expression(node.expression, state, true);
+				if (evaluated === DYNAMIC) {
+					expressions.push(b.call('$.escape', /** @type {Expression} */ (visit(node.expression))));
+				} else {
+					if (evaluated != null) {
+						quasi.value.cooked += escape_html(evaluated + '');
+					}
+					continue;
+				}
 
 				quasi = b.quasi('', i + 1 === sequence.length);
 				quasis.push(quasi);