lumen-plus 0.0.2 → 0.0.4

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/LabeledStatement.js

@@ -0,0 +1,95 @@
+/** @import { Expression, LabeledStatement } from 'estree' */
+/** @import { AST, ReactiveStatement } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { extract_identifiers, object } from '../../../utils/ast.js';
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {LabeledStatement} node
+ * @param {Context} context
+ */
+export function LabeledStatement(node, context) {
+	if (node.label.name === '$') {
+		const parent = /** @type {AST.SvelteNode} */ (context.path.at(-1));
+
+		const is_reactive_statement =
+			context.state.ast_type === 'instance' && parent.type === 'Program';
+
+		if (is_reactive_statement) {
+			if (context.state.analysis.runes) {
+				e.legacy_reactive_statement_invalid(node);
+			}
+
+			// Find all dependencies of this `$: {...}` statement
+			/** @type {ReactiveStatement} */
+			const reactive_statement = {
+				assignments: new Set(),
+				dependencies: []
+			};
+
+			context.next({
+				...context.state,
+				reactive_statement,
+				function_depth: context.state.scope.function_depth + 1
+			});
+
+			// Every referenced binding becomes a dependency, unless it's on
+			// the left-hand side of an `=` assignment
+			for (const [name, nodes] of context.state.scope.references) {
+				const binding = context.state.scope.get(name);
+				if (binding === null) continue;
+
+				for (const { node, path } of nodes) {
+					/** @type {Expression} */
+					let left = node;
+
+					let i = path.length - 1;
+					let parent = /** @type {Expression} */ (path.at(i));
+					while (parent.type === 'MemberExpression') {
+						left = parent;
+						parent = /** @type {Expression} */ (path.at(--i));
+					}
+
+					if (
+						parent.type === 'AssignmentExpression' &&
+						parent.operator === '=' &&
+						parent.left === left
+					) {
+						continue;
+					}
+
+					reactive_statement.dependencies.push(binding);
+					break;
+				}
+			}
+
+			context.state.analysis.reactive_statements.set(node, reactive_statement);
+
+			if (
+				node.body.type === 'ExpressionStatement' &&
+				node.body.expression.type === 'AssignmentExpression'
+			) {
+				let ids = extract_identifiers(node.body.expression.left);
+				if (node.body.expression.left.type === 'MemberExpression') {
+					const id = object(node.body.expression.left);
+					if (id !== null) {
+						ids = [id];
+					}
+				}
+
+				for (const id of ids) {
+					const binding = context.state.scope.get(id.name);
+					if (binding?.kind === 'legacy_reactive') {
+						// TODO does this include `let double; $: double = x * 2`?
+						binding.legacy_dependencies = Array.from(reactive_statement.dependencies);
+					}
+				}
+			}
+		} else if (!context.state.analysis.runes) {
+			w.reactive_declaration_invalid_placement(node);
+		}
+	}
+
+	context.next();
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/LetDirective.js

@@ -0,0 +1,24 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+
+/**
+ * @param {AST.LetDirective} node
+ * @param {Context} context
+ */
+export function LetDirective(node, context) {
+	const parent = context.path.at(-1);
+
+	if (
+		parent === undefined ||
+		(parent.type !== 'Component' &&
+			parent.type !== 'RegularElement' &&
+			parent.type !== 'SlotElement' &&
+			parent.type !== 'SvelteElement' &&
+			parent.type !== 'SvelteComponent' &&
+			parent.type !== 'SvelteSelf' &&
+			parent.type !== 'SvelteFragment')
+	) {
+		e.let_directive_invalid_placement(node);
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/Literal.js

@@ -0,0 +1,14 @@
+/** @import { Literal } from 'estree' */
+import * as w from '../../../warnings.js';
+import { regex_bidirectional_control_characters } from '../../patterns.js';
+
+/**
+ * @param {Literal} node
+ */
+export function Literal(node) {
+	if (typeof node.value === 'string') {
+		if (regex_bidirectional_control_characters.test(node.value)) {
+			w.bidirectional_control_characters(node);
+		}
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/MemberExpression.js

@@ -0,0 +1,28 @@
+/** @import { MemberExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { is_pure, is_safe_identifier } from './shared/utils.js';
+
+/**
+ * @param {MemberExpression} node
+ * @param {Context} context
+ */
+export function MemberExpression(node, context) {
+	if (node.object.type === 'Identifier' && node.property.type === 'Identifier') {
+		const binding = context.state.scope.get(node.object.name);
+		if (binding?.kind === 'rest_prop' && node.property.name.startsWith('$$')) {
+			e.props_illegal_name(node.property);
+		}
+	}
+
+	if (context.state.expression) {
+		context.state.expression.has_member_expression = true;
+		context.state.expression.has_state ||= !is_pure(node, context);
+	}
+
+	if (!is_safe_identifier(node, context.state.scope)) {
+		context.state.analysis.needs_context = true;
+	}
+
+	context.next();
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/NewExpression.js

@@ -0,0 +1,17 @@
+/** @import { NewExpression } from 'estree' */
+/** @import { Context } from '../types' */
+import * as w from '../../../warnings.js';
+
+/**
+ * @param {NewExpression} node
+ * @param {Context} context
+ */
+export function NewExpression(node, context) {
+	if (node.callee.type === 'ClassExpression' && context.state.scope.function_depth > 0) {
+		w.perf_avoid_inline_class(node);
+	}
+
+	context.state.analysis.needs_context = true;
+
+	context.next();
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/OnDirective.js

@@ -0,0 +1,28 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import * as w from '../../../warnings.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.OnDirective} node
+ * @param {Context} context
+ */
+export function OnDirective(node, context) {
+	if (context.state.analysis.runes) {
+		const parent_type = context.path.at(-1)?.type;
+
+		// Don't warn on component events; these might not be under the author's control so the warning would be unactionable
+		if (parent_type === 'RegularElement' || parent_type === 'SvelteElement') {
+			w.event_directive_deprecated(node, node.name);
+		}
+	}
+
+	const parent = context.path.at(-1);
+	if (parent?.type === 'SvelteElement' || parent?.type === 'RegularElement') {
+		context.state.analysis.event_directive_node ??= node;
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	context.next({ ...context.state, expression: node.metadata.expression });
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/PropertyDefinition.js

@@ -0,0 +1,21 @@
+/** @import { PropertyDefinition } from 'estree' */
+/** @import { Context } from '../types' */
+import * as e from '../../../errors.js';
+import { get_name } from '../../nodes.js';
+
+/**
+ * @param {PropertyDefinition} node
+ * @param {Context} context
+ */
+export function PropertyDefinition(node, context) {
+	const name = get_name(node.key);
+	const field = name && context.state.state_fields.get(name);
+
+	if (field && node !== field.node && node.value) {
+		if (/** @type {number} */ (node.start) < /** @type {number} */ (field.node.start)) {
+			e.state_field_invalid_assignment(node);
+		}
+	}
+
+	context.next();
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/RegularElement.js

@@ -0,0 +1,210 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { is_mathml, is_svg, is_void } from '../../../../utils.js';
+import {
+	is_tag_valid_with_ancestor,
+	is_tag_valid_with_parent
+} from '../../../../html-tree-validation.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import {
+	create_attribute,
+	is_custom_element_node,
+	is_customizable_select_element
+} from '../../nodes.js';
+import { regex_starts_with_newline } from '../../patterns.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.RegularElement} node
+ * @param {Context} context
+ */
+export function RegularElement(node, context) {
+	validate_element(node, context);
+	check_element(node, context);
+
+	node.metadata.path = [...context.path];
+	context.state.analysis.elements.push(node);
+
+	// Special case: Move the children of <textarea> into a value attribute if they are dynamic
+	if (node.name === 'textarea' && node.fragment.nodes.length > 0) {
+		for (const attribute of node.attributes) {
+			if (attribute.type === 'Attribute' && attribute.name === 'value') {
+				e.textarea_invalid_content(node);
+			}
+		}
+
+		if (node.fragment.nodes.length > 1 || node.fragment.nodes[0].type !== 'Text') {
+			const first = node.fragment.nodes[0];
+			if (first.type === 'Text') {
+				// The leading newline character needs to be stripped because of a qirk:
+				// It is ignored by browsers if the tag and its contents are set through
+				// innerHTML, but we're now setting it through the value property at which
+				// point it is _not_ ignored, so we need to strip it ourselves.
+				// see https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions
+				// see https://html.spec.whatwg.org/multipage/grouping-content.html#the-pre-element
+				first.data = first.data.replace(regex_starts_with_newline, '');
+				first.raw = first.raw.replace(regex_starts_with_newline, '');
+			}
+
+			node.attributes.push(
+				create_attribute(
+					'value',
+					null,
+					-1,
+					-1,
+					// @ts-ignore
+					node.fragment.nodes
+				)
+			);
+
+			node.fragment.nodes = [];
+		}
+	}
+
+	// Special case: single expression tag child of option element -> add "fake" attribute
+	// to ensure that value types are the same (else for example numbers would be strings)
+	if (
+		node.name === 'option' &&
+		node.fragment.nodes?.length === 1 &&
+		node.fragment.nodes[0].type === 'ExpressionTag' &&
+		!node.attributes.some(
+			(attribute) => attribute.type === 'Attribute' && attribute.name === 'value'
+		)
+	) {
+		const child = node.fragment.nodes[0];
+		node.metadata.synthetic_value_node = child;
+	}
+
+	// Special case: <select>, <option> or <optgroup> with rich content needs special hydration handling
+	// We mark the subtree as dynamic so parent elements properly include the child init code
+	if (is_customizable_select_element(node) || node.name === 'selectedcontent') {
+		// Mark the element's own fragment as dynamic so it's not treated as static
+		node.fragment.metadata.dynamic = true;
+		// Also mark ancestor fragments so parents properly include the child init code
+		mark_subtree_dynamic(context.path);
+	}
+
+	const binding = context.state.scope.get(node.name);
+	if (
+		binding !== null &&
+		binding.declaration_kind === 'import' &&
+		binding.references.length === 0
+	) {
+		w.component_name_lowercase(node, node.name);
+	}
+
+	node.metadata.has_spread = node.attributes.some(
+		(attribute) => attribute.type === 'SpreadAttribute'
+	);
+
+	const is_svg_element = () => {
+		if (is_svg(node.name)) {
+			return true;
+		}
+
+		if (node.name === 'a' || node.name === 'title') {
+			let i = context.path.length;
+
+			while (i--) {
+				const ancestor = context.path[i];
+				if (ancestor.type === 'RegularElement') {
+					return ancestor.metadata.svg;
+				}
+			}
+		}
+
+		return false;
+	};
+
+	node.metadata.svg = is_svg_element();
+	node.metadata.mathml = is_mathml(node.name);
+
+	if (is_custom_element_node(node) && node.attributes.length > 0) {
+		// we're setting all attributes on custom elements through properties
+		mark_subtree_dynamic(context.path);
+	}
+
+	if (context.state.parent_element) {
+		let past_parent = false;
+		let only_warn = false;
+		const ancestors = [context.state.parent_element];
+
+		for (let i = context.path.length - 1; i >= 0; i--) {
+			const ancestor = context.path[i];
+
+			if (
+				ancestor.type === 'IfBlock' ||
+				ancestor.type === 'EachBlock' ||
+				ancestor.type === 'AwaitBlock' ||
+				ancestor.type === 'KeyBlock'
+			) {
+				// We're creating a separate template string inside blocks, which means client-side this would work
+				only_warn = true;
+			}
+
+			if (!past_parent) {
+				if (ancestor.type === 'RegularElement' && ancestor.name === context.state.parent_element) {
+					const message = is_tag_valid_with_parent(node.name, context.state.parent_element);
+					if (message) {
+						if (only_warn) {
+							w.node_invalid_placement_ssr(node, message);
+						} else {
+							e.node_invalid_placement(node, message);
+						}
+					}
+
+					past_parent = true;
+				}
+			} else if (ancestor.type === 'RegularElement') {
+				ancestors.push(ancestor.name);
+
+				const message = is_tag_valid_with_ancestor(node.name, ancestors);
+				if (message) {
+					if (only_warn) {
+						w.node_invalid_placement_ssr(node, message);
+					} else {
+						e.node_invalid_placement(node, message);
+					}
+				}
+			} else if (
+				ancestor.type === 'Component' ||
+				ancestor.type === 'SvelteComponent' ||
+				ancestor.type === 'SvelteElement' ||
+				ancestor.type === 'SvelteSelf' ||
+				ancestor.type === 'SnippetBlock'
+			) {
+				break;
+			}
+		}
+	}
+
+	// Strip off any namespace from the beginning of the node name.
+	const node_name = node.name.replace(/[a-zA-Z-]*:/g, '');
+
+	if (
+		context.state.analysis.source[node.end - 2] === '/' &&
+		!is_void(node_name) &&
+		!is_svg(node_name) &&
+		!is_mathml(node_name)
+	) {
+		w.element_invalid_self_closing_tag(node, node.name);
+	}
+
+	context.next({ ...context.state, parent_element: node.name });
+
+	// Special case: <a> tags are valid in both the SVG and HTML namespace.
+	// If there's no parent, look downwards to see if it's the parent of a SVG or HTML element.
+	if (node.name === 'a' && !context.state.parent_element) {
+		for (const child of node.fragment.nodes) {
+			if (child.type === 'RegularElement') {
+				if (child.metadata.svg && child.name !== 'svg') {
+					node.metadata.svg = true;
+					break;
+				}
+			}
+		}
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/RenderTag.js

@@ -0,0 +1,68 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { unwrap_optional } from '../../../utils/ast.js';
+import * as e from '../../../errors.js';
+import { validate_opening_tag } from './shared/utils.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+import { is_resolved_snippet } from './shared/snippets.js';
+import { ExpressionMetadata } from '../../nodes.js';
+
+/**
+ * @param {AST.RenderTag} node
+ * @param {Context} context
+ */
+export function RenderTag(node, context) {
+	validate_opening_tag(node, context.state, '@');
+
+	node.metadata.path = [...context.path];
+
+	const expression = unwrap_optional(node.expression);
+	const callee = expression.callee;
+
+	const binding = callee.type === 'Identifier' ? context.state.scope.get(callee.name) : null;
+
+	node.metadata.dynamic = binding?.kind !== 'normal';
+
+	/**
+	 * If we can't unambiguously resolve this to a declaration, we
+	 * must assume the worst and link the render tag to every snippet
+	 */
+	let resolved = callee.type === 'Identifier' && is_resolved_snippet(binding);
+
+	if (binding?.initial?.type === 'SnippetBlock') {
+		// if this render tag unambiguously references a local snippet, our job is easy
+		node.metadata.snippets.add(binding.initial);
+	}
+
+	context.state.analysis.snippet_renderers.set(node, resolved);
+	context.state.analysis.uses_render_tags = true;
+
+	const raw_args = unwrap_optional(node.expression).arguments;
+	for (const arg of raw_args) {
+		if (arg.type === 'SpreadElement') {
+			e.render_tag_invalid_spread_argument(arg);
+		}
+	}
+
+	if (
+		callee.type === 'MemberExpression' &&
+		callee.property.type === 'Identifier' &&
+		['bind', 'apply', 'call'].includes(callee.property.name)
+	) {
+		e.render_tag_invalid_call_expression(node);
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	context.visit(callee, { ...context.state, expression: node.metadata.expression });
+
+	for (const arg of expression.arguments) {
+		const metadata = new ExpressionMetadata();
+		node.metadata.arguments.push(metadata);
+
+		context.visit(arg, {
+			...context.state,
+			expression: metadata
+		});
+	}
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/SlotElement.js

@@ -0,0 +1,42 @@
+/** @import { AST } from '#compiler' */
+/** @import { Context } from '../types' */
+import { is_text_attribute } from '../../../utils/ast.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import { mark_subtree_dynamic } from './shared/fragment.js';
+
+/**
+ * @param {AST.SlotElement} node
+ * @param {Context} context
+ */
+export function SlotElement(node, context) {
+	if (context.state.analysis.runes && !context.state.analysis.custom_element) {
+		w.slot_element_deprecated(node);
+	}
+
+	mark_subtree_dynamic(context.path);
+
+	/** @type {string} */
+	let name = 'default';
+
+	for (const attribute of node.attributes) {
+		if (attribute.type === 'Attribute') {
+			if (attribute.name === 'name') {
+				if (!is_text_attribute(attribute)) {
+					e.slot_element_invalid_name(attribute);
+				}
+
+				name = attribute.value[0].data;
+				if (name === 'default') {
+					e.slot_element_invalid_name_default(attribute);
+				}
+			}
+		} else if (attribute.type !== 'SpreadAttribute' && attribute.type !== 'LetDirective') {
+			e.slot_element_invalid_attribute(attribute);
+		}
+	}
+
+	context.state.analysis.slot_names.set(name, node);
+
+	context.next();
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js

@@ -0,0 +1,113 @@
+/** @import { AST, Binding } from '#compiler' */
+/** @import { Scope } from '../../scope' */
+/** @import { Context } from '../types' */
+import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
+import * as e from '../../../errors.js';
+
+/**
+ * @param {AST.SnippetBlock} node
+ * @param {Context} context
+ */
+export function SnippetBlock(node, context) {
+	context.state.analysis.snippets.add(node);
+
+	validate_block_not_empty(node.body, context);
+
+	if (context.state.analysis.runes) {
+		validate_opening_tag(node, context.state, '#');
+	}
+
+	for (const arg of node.parameters) {
+		if (arg.type === 'RestElement') {
+			e.snippet_invalid_rest_parameter(arg);
+		}
+	}
+
+	context.next({ ...context.state, parent_element: null });
+
+	const can_hoist =
+		context.path.length === 1 &&
+		context.path[0].type === 'Fragment' &&
+		can_hoist_snippet(context.state.scope, context.state.scopes);
+
+	const name = node.expression.name;
+
+	if (can_hoist) {
+		const binding = /** @type {Binding} */ (context.state.scope.get(name));
+		context.state.analysis.module.scope.declarations.set(name, binding);
+	}
+
+	node.metadata.can_hoist = can_hoist;
+
+	const { path } = context;
+	const parent = path.at(-2);
+	if (!parent) return;
+
+	if (
+		parent.type === 'Component' &&
+		parent.attributes.some(
+			(attribute) =>
+				(attribute.type === 'Attribute' || attribute.type === 'BindDirective') &&
+				attribute.name === node.expression.name
+		)
+	) {
+		e.snippet_shadowing_prop(node, node.expression.name);
+	}
+
+	if (node.expression.name !== 'children') return;
+
+	if (
+		parent.type === 'Component' ||
+		parent.type === 'SvelteComponent' ||
+		parent.type === 'SvelteSelf'
+	) {
+		if (
+			parent.fragment.nodes.some(
+				(node) =>
+					node.type !== 'SnippetBlock' &&
+					(node.type !== 'Text' || node.data.trim()) &&
+					node.type !== 'Comment'
+			)
+		) {
+			e.snippet_conflict(node);
+		}
+	}
+}
+
+/**
+ * @param {Map<AST.SvelteNode, Scope>} scopes
+ * @param {Scope} scope
+ */
+function can_hoist_snippet(scope, scopes, visited = new Set()) {
+	for (const [reference] of scope.references) {
+		const binding = scope.get(reference);
+		if (!binding) continue;
+
+		if (binding.blocker) {
+			return false;
+		}
+
+		if (binding.scope.function_depth === 0) {
+			continue;
+		}
+
+		// ignore bindings declared inside the snippet (e.g. the snippet's own parameters)
+		if (binding.scope.function_depth >= scope.function_depth) {
+			continue;
+		}
+
+		if (binding.initial?.type === 'SnippetBlock') {
+			if (visited.has(binding)) continue;
+			visited.add(binding);
+			const snippet_scope = /** @type {Scope} */ (scopes.get(binding.initial));
+
+			if (can_hoist_snippet(snippet_scope, scopes, visited)) {
+				continue;
+			}
+		}
+
+		return false;
+	}
+
+	return true;
+}

package/dist/utils/node_modules/svelte/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 });
+}