lumen-plus 0.0.3 → 0.0.4

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

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

@@ -0,0 +1,160 @@
+/** @import { Expression, Identifier, Literal, VariableDeclarator } from 'estree' */
+/** @import { Binding } from '#compiler' */
+/** @import { Context } from '../types' */
+import { get_rune } from '../../scope.js';
+import { ensure_no_module_import_conflict, validate_identifier_name } from './shared/utils.js';
+import * as e from '../../../errors.js';
+import * as w from '../../../warnings.js';
+import { extract_paths } from '../../../utils/ast.js';
+import { equal } from '../../../utils/assert.js';
+import * as b from '#compiler/builders';
+
+/**
+ * @param {VariableDeclarator} node
+ * @param {Context} context
+ */
+export function VariableDeclarator(node, context) {
+	ensure_no_module_import_conflict(node, context.state);
+
+	if (context.state.analysis.runes) {
+		const init = node.init;
+		const rune = get_rune(init, context.state.scope);
+		const { paths } = extract_paths(node.id, b.id('dummy'));
+
+		for (const path of paths) {
+			validate_identifier_name(context.state.scope.get(/** @type {Identifier} */ (path.node).name));
+		}
+
+		// TODO feels like this should happen during scope creation?
+		if (
+			rune === '$state' ||
+			rune === '$state.raw' ||
+			rune === '$derived' ||
+			rune === '$derived.by' ||
+			rune === '$props'
+		) {
+			for (const path of paths) {
+				// @ts-ignore this fails in CI for some insane reason
+				const binding = /** @type {Binding} */ (context.state.scope.get(path.node.name));
+				binding.kind =
+					rune === '$state'
+						? 'state'
+						: rune === '$state.raw'
+							? 'raw_state'
+							: rune === '$derived' || rune === '$derived.by'
+								? 'derived'
+								: path.is_rest
+									? 'rest_prop'
+									: 'prop';
+				if (rune === '$props' && binding.kind === 'rest_prop' && node.id.type === 'ObjectPattern') {
+					const { properties } = node.id;
+					/** @type {string[]} */
+					const exclude_props = [];
+					for (const property of properties) {
+						if (property.type === 'RestElement') {
+							continue;
+						}
+						const key = /** @type {Identifier | Literal & { value: string | number }} */ (
+							property.key
+						);
+						exclude_props.push(key.type === 'Identifier' ? key.name : key.value.toString());
+					}
+					(binding.metadata ??= {}).exclude_props = exclude_props;
+				}
+			}
+		}
+
+		if (rune === '$props') {
+			if (node.id.type !== 'ObjectPattern' && node.id.type !== 'Identifier') {
+				e.props_invalid_identifier(node);
+			}
+
+			if (
+				context.state.analysis.custom_element &&
+				context.state.options.customElementOptions?.props == null
+			) {
+				let warn_on;
+				if (
+					node.id.type === 'Identifier' ||
+					(warn_on = node.id.properties.find((p) => p.type === 'RestElement')) != null
+				) {
+					w.custom_element_props_identifier(warn_on ?? node.id);
+				}
+			}
+
+			context.state.analysis.needs_props = true;
+
+			if (node.id.type === 'Identifier') {
+				const binding = /** @type {Binding} */ (context.state.scope.get(node.id.name));
+				binding.initial = null; // else would be $props()
+				binding.kind = 'rest_prop';
+			} else {
+				equal(node.id.type, 'ObjectPattern');
+
+				for (const property of node.id.properties) {
+					if (property.type !== 'Property') continue;
+
+					if (property.computed) {
+						e.props_invalid_pattern(property);
+					}
+
+					if (property.key.type === 'Identifier' && property.key.name.startsWith('$$')) {
+						e.props_illegal_name(property);
+					}
+
+					const value =
+						property.value.type === 'AssignmentPattern' ? property.value.left : property.value;
+
+					if (value.type !== 'Identifier') {
+						e.props_invalid_pattern(property);
+					}
+
+					const alias =
+						property.key.type === 'Identifier'
+							? property.key.name
+							: String(/** @type {Literal} */ (property.key).value);
+
+					let initial = property.value.type === 'AssignmentPattern' ? property.value.right : null;
+
+					const binding = /** @type {Binding} */ (context.state.scope.get(value.name));
+					binding.prop_alias = alias;
+
+					// rewire initial from $props() to the actual initial value, stripping $bindable() if necessary
+					if (
+						initial?.type === 'CallExpression' &&
+						initial.callee.type === 'Identifier' &&
+						initial.callee.name === '$bindable'
+					) {
+						binding.initial = /** @type {Expression | null} */ (initial.arguments[0] ?? null);
+						binding.kind = 'bindable_prop';
+					} else {
+						binding.initial = initial;
+					}
+				}
+			}
+		}
+	} else {
+		if (node.init?.type === 'CallExpression') {
+			const callee = node.init.callee;
+			if (
+				callee.type === 'Identifier' &&
+				(callee.name === '$state' || callee.name === '$derived' || callee.name === '$props') &&
+				context.state.scope.get(callee.name)?.kind !== 'store_sub'
+			) {
+				e.rune_invalid_usage(node.init, callee.name);
+			}
+		}
+	}
+
+	if (node.init && get_rune(node.init, context.state.scope) === '$props') {
+		// prevent erroneous `state_referenced_locally` warnings on prop fallbacks
+		context.visit(node.id, {
+			...context.state,
+			function_depth: context.state.function_depth + 1
+		});
+
+		context.visit(node.init);
+	} else {
+		context.next();
+	}
+}