@depup/svelte 5.53.3-depup.0

package/src/compiler/phases/2-analyze/visitors/SpreadAttribute.js

@@ -0,0 +1,13 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.SpreadAttribute} node
+ * @param {Context} context
+ */
+export function SpreadAttribute(node, context) {
+	mark_subtree_dynamic(context.path);
+	context.next({ ...context.state, expression: node.metadata.expression });
+}

package/src/compiler/phases/2-analyze/visitors/SpreadElement.js

@@ -0,0 +1,16 @@
+/** @import { SpreadElement } from 'estree' */
+/** @import { Context } from '../types' */
+
+/**
+ * @param {SpreadElement} node
+ * @param {Context} context
+ */
+export function SpreadElement(node, context) {
+	if (context.state.expression) {
+		// treat e.g. `[...x]` the same as `[...x.values()]`
+		context.state.expression.has_call = true;
+		context.state.expression.has_state = true;
+	}
+
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/StyleDirective.js

@@ -0,0 +1,39 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { get_attribute_chunks } from '../../../utils/ast.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.StyleDirective} node
+ * @param {Context} context
+ */
+export function StyleDirective(node, context) {
+	if (node.modifiers.length > 1 || (node.modifiers.length && node.modifiers[0] !== 'important')) {
+		e.style_directive_invalid_modifier(node);
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	if (node.value === true) {
+		// get the binding for node.name and change the binding to state
+		let binding = context.state.scope.get(node.name);
+
+		if (binding) {
+			if (binding.kind !== 'normal') {
+				node.metadata.expression.has_state = true;
+			}
+			if (binding.blocker) {
+				node.metadata.expression.dependencies.add(binding);
+			}
+		}
+	} else {
+		context.next();
+
+		for (const chunk of get_attribute_chunks(node.value)) {
+			if (chunk.type !== 'ExpressionTag') continue;
+
+			node.metadata.expression.merge(chunk.metadata.expression);
+		}
+	}
+}

package/src/compiler/phases/2-analyze/visitors/SvelteBody.js

@@ -0,0 +1,22 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { is_event_attribute } from '../../../utils/ast.js';
+import { disallow_children } from './shared/special-element.js';
+
+/**
+ * @param {AST.SvelteBody} node
+ * @param {Context} context
+ */
+export function SvelteBody(node, context) {
+	disallow_children(node);
+	for (const attribute of node.attributes) {
+		if (
+			attribute.type === 'SpreadAttribute' ||
+			(attribute.type === 'Attribute' && !is_event_attribute(attribute))
+		) {
+			e.svelte_body_illegal_attribute(attribute);
+		}
+	}
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/SvelteBoundary.js

@@ -0,0 +1,30 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+const valid = ['onerror', 'failed', 'pending'];
+
+/**
+ * @param {AST.SvelteBoundary} node
+ * @param {Context} context
+ */
+export function SvelteBoundary(node, context) {
+	for (const attribute of node.attributes) {
+		if (attribute.type !== 'Attribute' || !valid.includes(attribute.name)) {
+			e.svelte_boundary_invalid_attribute(attribute);
+		}
+
+		if (
+			attribute.value === true ||
+			(Array.isArray(attribute.value) &&
+				(attribute.value.length !== 1 || attribute.value[0].type !== 'ExpressionTag'))
+		) {
+			e.svelte_boundary_invalid_attribute_value(attribute);
+		}
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/SvelteComponent.js

@@ -0,0 +1,18 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as w from '../../../warnings.js';
+import { visit_component } from './shared/component.js';
+
+/**
+ * @param {AST.SvelteComponent} node
+ * @param {Context} context
+ */
+export function SvelteComponent(node, context) {
+	if (context.state.analysis.runes) {
+		w.svelte_component_deprecated(node);
+	}
+
+	context.visit(node.expression, { ...context.state, expression: node.metadata.expression });
+
+	visit_component(node, context);
+}

package/src/compiler/phases/2-analyze/visitors/SvelteDocument.js

@@ -0,0 +1,24 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { disallow_children } from './shared/special-element.js';
+import * as e from '../../../errors.js';
+import { is_event_attribute } from '../../../utils/ast.js';
+
+/**
+ * @param {AST.SvelteDocument} node
+ * @param {Context} context
+ */
+export function SvelteDocument(node, context) {
+	disallow_children(node);
+
+	for (const attribute of node.attributes) {
+		if (
+			attribute.type === 'SpreadAttribute' ||
+			(attribute.type === 'Attribute' && !is_event_attribute(attribute))
+		) {
+			e.illegal_element_attribute(attribute, 'svelte:document');
+		}
+	}
+
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/SvelteElement.js

@@ -0,0 +1,78 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { NAMESPACE_MATHML, NAMESPACE_SVG } from '../../../../constants.js';
+import { is_text_attribute } from '../../../utils/ast.js';
+import { check_element } from './shared/a11y/index.js';
+import { validate_element } from './shared/element.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.SvelteElement} node
+ * @param {Context} context
+ */
+export function SvelteElement(node, context) {
+	validate_element(node, context);
+	check_element(node, context);
+
+	node.metadata.path = [...context.path];
+	context.state.analysis.elements.push(node);
+
+	const xmlns = /** @type {AST.Attribute & { value: [AST.Text] } | undefined} */ (
+		node.attributes.find(
+			(a) => a.type === 'Attribute' && a.name === 'xmlns' && is_text_attribute(a)
+		)
+	);
+
+	if (xmlns) {
+		node.metadata.svg = xmlns.value[0].data === NAMESPACE_SVG;
+		node.metadata.mathml = xmlns.value[0].data === NAMESPACE_MATHML;
+	} else {
+		let i = context.path.length;
+		while (i--) {
+			const ancestor = context.path[i];
+
+			if (
+				ancestor.type === 'Component' ||
+				ancestor.type === 'SvelteComponent' ||
+				ancestor.type === 'SvelteFragment' ||
+				ancestor.type === 'SnippetBlock' ||
+				i === 0
+			) {
+				// Root element, or inside a slot or a snippet -> this resets the namespace, so assume the component namespace
+				node.metadata.svg = context.state.options.namespace === 'svg';
+				node.metadata.mathml = context.state.options.namespace === 'mathml';
+				break;
+			}
+
+			if (ancestor.type === 'SvelteElement' || ancestor.type === 'RegularElement') {
+				node.metadata.svg =
+					ancestor.type === 'RegularElement' && ancestor.name === 'foreignObject'
+						? false
+						: ancestor.metadata.svg;
+
+				node.metadata.mathml =
+					ancestor.type === 'RegularElement' && ancestor.name === 'foreignObject'
+						? false
+						: ancestor.metadata.mathml;
+
+				break;
+			}
+		}
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	context.visit(node.tag, {
+		...context.state,
+		expression: node.metadata.expression
+	});
+
+	for (const attribute of node.attributes) {
+		context.visit(attribute);
+	}
+
+	context.visit(node.fragment, {
+		...context.state,
+		parent_element: null
+	});
+}

package/src/compiler/phases/2-analyze/visitors/SvelteFragment.js

@@ -0,0 +1,27 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { validate_slot_attribute } from './shared/attribute.js';
+
+/**
+ * @param {AST.SvelteFragment} node
+ * @param {Context} context
+ */
+export function SvelteFragment(node, context) {
+	const parent = context.path.at(-2);
+	if (parent?.type !== 'Component' && parent?.type !== 'SvelteComponent') {
+		e.svelte_fragment_invalid_placement(node);
+	}
+
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'Attribute') {
+			if (attribute.name === 'slot') {
+				validate_slot_attribute(context, attribute);
+			}
+		} else if (attribute.type !== 'LetDirective') {
+			e.svelte_fragment_invalid_attribute(attribute);
+		}
+	}
+
+	context.next({ ...context.state, parent_element: null });
+}

package/src/compiler/phases/2-analyze/visitors/SvelteHead.js

@@ -0,0 +1,18 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.SvelteHead} node
+ * @param {Context} context
+ */
+export function SvelteHead(node, context) {
+	for (const attribute of node.attributes) {
+		e.svelte_head_illegal_attribute(attribute);
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/SvelteSelf.js

@@ -0,0 +1,36 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { visit_component } from './shared/component.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import { filename, UNKNOWN_FILENAME } from '../../../state.js';
+
+/**
+ * @param {AST.SvelteSelf} node
+ * @param {Context} context
+ */
+export function SvelteSelf(node, context) {
+	const valid = context.path.some(
+		(node) =>
+			node.type === 'IfBlock' ||
+			node.type === 'EachBlock' ||
+			node.type === 'Component' ||
+			node.type === 'SnippetBlock'
+	);
+
+	if (!valid) {
+		e.svelte_self_invalid_placement(node);
+	}
+
+	if (context.state.analysis.runes) {
+		const name = filename === UNKNOWN_FILENAME ? 'Self' : context.state.analysis.name;
+		const basename =
+			filename === UNKNOWN_FILENAME
+				? 'Self.svelte'
+				: /** @type {string} */ (filename.split(/[/\\]/).pop());
+
+		w.svelte_self_deprecated(node, name, basename);
+	}
+
+	visit_component(node, context);
+}

package/src/compiler/phases/2-analyze/visitors/SvelteWindow.js

@@ -0,0 +1,24 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { disallow_children } from './shared/special-element.js';
+import * as e from '../../../errors.js';
+import { is_event_attribute } from '../../../utils/ast.js';
+
+/**
+ * @param {AST.SvelteWindow} node
+ * @param {Context} context
+ */
+export function SvelteWindow(node, context) {
+	disallow_children(node);
+
+	for (const attribute of node.attributes) {
+		if (
+			attribute.type === 'SpreadAttribute' ||
+			(attribute.type === 'Attribute' && !is_event_attribute(attribute))
+		) {
+			e.illegal_element_attribute(attribute, 'svelte:window');
+		}
+	}
+
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/TaggedTemplateExpression.js

@@ -0,0 +1,16 @@
+/** @import { TaggedTemplateExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import { is_pure } from './shared/utils.js';
+
+/**
+ * @param {TaggedTemplateExpression} node
+ * @param {Context} context
+ */
+export function TaggedTemplateExpression(node, context) {
+	if (context.state.expression && !is_pure(node.tag, context)) {
+		context.state.expression.has_call = true;
+		context.state.expression.has_state = true;
+	}
+
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/TemplateElement.js

@@ -0,0 +1,12 @@
+/** @import { TemplateElement } from 'estree' */
+import * as w from '../../../warnings.js';
+import { regex_bidirectional_control_characters } from '../../patterns.js';
+
+/**
+ * @param {TemplateElement} node
+ */
+export function TemplateElement(node) {
+	if (regex_bidirectional_control_characters.test(node.value.cooked ?? '')) {
+		w.bidirectional_control_characters(node);
+	}
+}

package/src/compiler/phases/2-analyze/visitors/Text.js

@@ -0,0 +1,52 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { is_tag_valid_with_parent } from '../../../../html-tree-validation.js';
+import { regex_bidirectional_control_characters, regex_not_whitespace } from '../../patterns.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import { extract_svelte_ignore } from '../../../utils/extract_svelte_ignore.js';
+
+/**
+ * @param {AST.Text} node
+ * @param {Context} context
+ */
+export function Text(node, context) {
+	const parent = /** @type {AST.SvelteNode} */ (context.path.at(-1));
+
+	if (
+		parent.type === 'Fragment' &&
+		context.state.parent_element &&
+		regex_not_whitespace.test(node.data)
+	) {
+		const message = is_tag_valid_with_parent('#text', context.state.parent_element);
+		if (message) {
+			e.node_invalid_placement(node, message);
+		}
+	}
+
+	regex_bidirectional_control_characters.lastIndex = 0;
+	for (const match of node.data.matchAll(regex_bidirectional_control_characters)) {
+		let is_ignored = false;
+
+		// if we have a svelte-ignore comment earlier in the text, bail
+		// (otherwise we can only use svelte-ignore on parent elements/blocks)
+		if (parent.type === 'Fragment') {
+			for (const child of parent.nodes) {
+				if (child === node) break;
+
+				if (child.type === 'Comment') {
+					is_ignored ||= extract_svelte_ignore(
+						child.start + 4,
+						child.data,
+						context.state.analysis.runes
+					).includes('bidirectional_control_characters');
+				}
+			}
+		}
+
+		if (!is_ignored) {
+			let start = match.index + node.start;
+			w.bidirectional_control_characters({ start, end: start + match[0].length });
+		}
+	}
+}

package/src/compiler/phases/2-analyze/visitors/TitleElement.js

@@ -0,0 +1,21 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {AST.TitleElement} node
+ * @param {Context} context
+ */
+export function TitleElement(node, context) {
+	for (const attribute of node.attributes) {
+		e.title_illegal_attribute(attribute);
+	}
+
+	for (const child of node.fragment.nodes) {
+		if (child.type !== 'Text' && child.type !== 'ExpressionTag') {
+			e.title_invalid_content(child);
+		}
+	}
+
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/TransitionDirective.js

@@ -0,0 +1,19 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.TransitionDirective} node
+ * @param {Context} context
+ */
+export function TransitionDirective(node, context) {
+	mark_subtree_dynamic(context.path);
+
+	context.next({ ...context.state, expression: node.metadata.expression });
+
+	if (node.metadata.expression.has_await) {
+		e.illegal_await_expression(node);
+	}
+}

package/src/compiler/phases/2-analyze/visitors/UpdateExpression.js

@@ -0,0 +1,29 @@
+/** @import { UpdateExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import { object } from '../../../utils/ast.js';
+import { validate_assignment } from './shared/utils.js';
+
+/**
+ * @param {UpdateExpression} node
+ * @param {Context} context
+ */
+export function UpdateExpression(node, context) {
+	validate_assignment(node, node.argument, context);
+
+	if (context.state.reactive_statement) {
+		const id = node.argument.type === 'MemberExpression' ? object(node.argument) : node.argument;
+		if (id?.type === 'Identifier') {
+			const binding = context.state.scope.get(id.name);
+
+			if (binding) {
+				context.state.reactive_statement.assignments.add(binding);
+			}
+		}
+	}
+
+	if (context.state.expression) {
+		context.state.expression.has_assignment = true;
+	}
+
+	context.next();
+}

package/src/compiler/phases/2-analyze/visitors/UseDirective.js

@@ -0,0 +1,18 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { mark_subtree_dynamic } from './shared/fragment.js';
+import * as e from '../../../errors.js';
+
+/**
+ * @param {AST.UseDirective} node
+ * @param {Context} context
+ */
+export function UseDirective(node, context) {
+	mark_subtree_dynamic(context.path);
+
+	context.next({ ...context.state, expression: node.metadata.expression });
+
+	if (node.metadata.expression.has_await) {
+		e.illegal_await_expression(node);
+	}
+}