lumen-plus 0.0.4 → 0.0.5

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

@@ -1,47 +0,0 @@
-/**
- * @template T
- * @param {Array<[T, T]>} edges
- * @returns {Array<T>|undefined}
- */
-export default function check_graph_for_cycles(edges) {
-	/** @type {Map<T, T[]>} */
-	const graph = edges.reduce((g, edge) => {
-		const [u, v] = edge;
-		if (!g.has(u)) g.set(u, []);
-		if (!g.has(v)) g.set(v, []);
-		g.get(u).push(v);
-		return g;
-	}, new Map());
-
-	const visited = new Set();
-	/** @type {Set<T>} */
-	const on_stack = new Set();
-	/** @type {Array<Array<T>>} */
-	const cycles = [];
-
-	/**
-	 * @param {T} v
-	 */
-	function visit(v) {
-		visited.add(v);
-		on_stack.add(v);
-
-		graph.get(v)?.forEach((w) => {
-			if (!visited.has(w)) {
-				visit(w);
-			} else if (on_stack.has(w)) {
-				cycles.push([...on_stack, w]);
-			}
-		});
-
-		on_stack.delete(v);
-	}
-
-	graph.forEach((_, v) => {
-		if (!visited.has(v)) {
-			visit(v);
-		}
-	});
-
-	return cycles[0];
-}

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

@@ -1,15 +0,0 @@
-/** @import { Context } from '../types' */
-/** @import { AST } from '#compiler'; */
-import * as e from '../../../errors.js';
-
-/**
- * @param {AST.AnimateDirective} node
- * @param {Context} context
- */
-export function AnimateDirective(node, context) {
-	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/ArrowFunctionExpression.js

@@ -1,11 +0,0 @@
-/** @import { ArrowFunctionExpression } from 'estree' */
-/** @import { Context } from '../types' */
-import { visit_function } from './shared/function.js';
-
-/**
- * @param {ArrowFunctionExpression} node
- * @param {Context} context
- */
-export function ArrowFunctionExpression(node, context) {
-	visit_function(node, context);
-}

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

@@ -1,31 +0,0 @@
-/** @import { AssignmentExpression } from 'estree' */
-/** @import { Context } from '../types' */
-import { extract_identifiers, object } from '../../../utils/ast.js';
-import { validate_assignment } from './shared/utils.js';
-
-/**
- * @param {AssignmentExpression} node
- * @param {Context} context
- */
-export function AssignmentExpression(node, context) {
-	validate_assignment(node, node.left, context);
-
-	if (context.state.reactive_statement) {
-		const id = node.left.type === 'MemberExpression' ? object(node.left) : node.left;
-		if (id !== null) {
-			for (const id of extract_identifiers(node.left)) {
-				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/AttachTag.js

@@ -1,17 +0,0 @@
-/** @import { AST } from '#compiler' */
-/** @import { Context } from '../types' */
-import { mark_subtree_dynamic } from './shared/fragment.js';
-import * as e from '../../../errors.js';
-
-/**
- * @param {AST.AttachTag} node
- * @param {Context} context
- */
-export function AttachTag(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/Attribute.js

@@ -1,66 +0,0 @@
-/** @import { AST } from '#compiler' */
-/** @import { Context } from '../types' */
-import { cannot_be_set_statically, can_delegate_event } from '../../../../utils.js';
-import { get_attribute_chunks, is_event_attribute } from '../../../utils/ast.js';
-import { mark_subtree_dynamic } from './shared/fragment.js';
-
-/**
- * @param {AST.Attribute} node
- * @param {Context} context
- */
-export function Attribute(node, context) {
-	context.next();
-
-	const parent = /** @type {AST.SvelteNode} */ (context.path.at(-1));
-
-	if (parent.type === 'RegularElement') {
-		// special case <option value="" />
-		if (node.name === 'value' && parent.name === 'option') {
-			mark_subtree_dynamic(context.path);
-		}
-	}
-
-	if (is_event_attribute(node)) {
-		mark_subtree_dynamic(context.path);
-	}
-
-	if (cannot_be_set_statically(node.name)) {
-		mark_subtree_dynamic(context.path);
-	}
-
-	// class={[...]} or class={{...}} or `class={x}` need clsx to resolve the classes
-	if (
-		node.name === 'class' &&
-		!Array.isArray(node.value) &&
-		node.value !== true &&
-		node.value.expression.type !== 'Literal' &&
-		node.value.expression.type !== 'TemplateLiteral' &&
-		node.value.expression.type !== 'BinaryExpression'
-	) {
-		mark_subtree_dynamic(context.path);
-		node.metadata.needs_clsx = true;
-	}
-
-	if (node.value !== true) {
-		for (const chunk of get_attribute_chunks(node.value)) {
-			if (chunk.type !== 'ExpressionTag') continue;
-
-			if (
-				chunk.expression.type === 'FunctionExpression' ||
-				chunk.expression.type === 'ArrowFunctionExpression'
-			) {
-				continue;
-			}
-		}
-
-		if (is_event_attribute(node)) {
-			const parent = context.path.at(-1);
-			if (parent?.type === 'RegularElement' || parent?.type === 'SvelteElement') {
-				context.state.analysis.uses_event_attributes = true;
-			}
-
-			node.metadata.delegated =
-				parent?.type === 'RegularElement' && can_delegate_event(node.name.slice(2));
-		}
-	}
-}

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

@@ -1,48 +0,0 @@
-/** @import { AST } from '#compiler' */
-/** @import { Context } from '../types' */
-import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
-import * as e from '../../../errors.js';
-import { mark_subtree_dynamic } from './shared/fragment.js';
-
-/**
- * @param {AST.AwaitBlock} node
- * @param {Context} context
- */
-export function AwaitBlock(node, context) {
-	validate_block_not_empty(node.pending, context);
-	validate_block_not_empty(node.then, context);
-	validate_block_not_empty(node.catch, context);
-
-	if (context.state.analysis.runes) {
-		validate_opening_tag(node, context.state, '#');
-
-		if (node.value) {
-			const start = /** @type {number} */ (node.value.start);
-			const match = context.state.analysis.source
-				.substring(start - 10, start)
-				.match(/{(\s*):then\s+$/);
-
-			if (match && match[1] !== '') {
-				e.block_unexpected_character({ start: start - 10, end: start }, ':');
-			}
-		}
-
-		if (node.error) {
-			const start = /** @type {number} */ (node.error.start);
-			const match = context.state.analysis.source
-				.substring(start - 10, start)
-				.match(/{(\s*):catch\s+$/);
-
-			if (match && match[1] !== '') {
-				e.block_unexpected_character({ start: start - 10, end: start }, ':');
-			}
-		}
-	}
-
-	mark_subtree_dynamic(context.path);
-
-	context.visit(node.expression, { ...context.state, expression: node.metadata.expression });
-	if (node.pending) context.visit(node.pending);
-	if (node.then) context.visit(node.then);
-	if (node.catch) context.visit(node.catch);
-}

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

@@ -1,150 +0,0 @@
-/** @import { AwaitExpression, Expression, SpreadElement, Property } from 'estree' */
-/** @import { Context } from '../types' */
-/** @import { AST } from '#compiler' */
-import * as e from '../../../errors.js';
-
-/**
- * @param {AwaitExpression} node
- * @param {Context} context
- */
-export function AwaitExpression(node, context) {
-	const tla = context.state.ast_type === 'instance' && context.state.function_depth === 1;
-
-	// preserve context for awaits that precede other expressions in template or `$derived(...)`
-	if (
-		is_reactive_expression(
-			context.path,
-			context.state.derived_function_depth === context.state.function_depth
-		) &&
-		!is_last_evaluated_expression(context.path, node)
-	) {
-		context.state.analysis.pickled_awaits.add(node);
-	}
-
-	let suspend = tla;
-
-	if (context.state.expression) {
-		context.state.expression.has_await = true;
-
-		suspend = true;
-	}
-
-	// disallow top-level `await` or `await` in template expressions
-	// unless a) in runes mode and b) opted into `experimental.async`
-	if (suspend) {
-		if (!context.state.options.experimental.async) {
-			e.experimental_async(node);
-		}
-
-		if (!context.state.analysis.runes) {
-			e.legacy_await_invalid(node);
-		}
-	}
-
-	context.next();
-}
-
-/**
- * @param {AST.SvelteNode[]} path
- * @param {boolean} in_derived
- */
-export function is_reactive_expression(path, in_derived) {
-	if (in_derived) return true;
-
-	let i = path.length;
-
-	while (i--) {
-		const parent = path[i];
-
-		if (
-			parent.type === 'ArrowFunctionExpression' ||
-			parent.type === 'FunctionExpression' ||
-			parent.type === 'FunctionDeclaration'
-		) {
-			// No reactive expression found between function and await
-			return false;
-		}
-
-		// @ts-expect-error we could probably use a neater/more robust mechanism
-		if (parent.metadata) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * @param {AST.SvelteNode[]} path
- * @param {Expression | SpreadElement | Property} node
- */
-function is_last_evaluated_expression(path, node) {
-	let i = path.length;
-
-	while (i--) {
-		const parent = path[i];
-
-		if (parent.type === 'ConstTag') {
-			// {@const ...} tags are treated as deriveds and its contents should all get the preserve-reactivity treatment
-			return false;
-		}
-
-		// @ts-expect-error we could probably use a neater/more robust mechanism
-		if (parent.metadata) {
-			return true;
-		}
-
-		switch (parent.type) {
-			case 'ArrayExpression':
-				if (node !== parent.elements.at(-1)) return false;
-				break;
-
-			case 'AssignmentExpression':
-			case 'BinaryExpression':
-			case 'LogicalExpression':
-				if (node === parent.left) return false;
-				break;
-
-			case 'CallExpression':
-			case 'NewExpression':
-				if (node !== parent.arguments.at(-1)) return false;
-				break;
-
-			case 'ConditionalExpression':
-				if (node === parent.test) return false;
-				break;
-
-			case 'MemberExpression':
-				if (parent.computed && node === parent.object) return false;
-				break;
-
-			case 'ObjectExpression':
-				if (node !== parent.properties.at(-1)) return false;
-				break;
-
-			case 'Property':
-				if (node === parent.key) return false;
-				break;
-
-			case 'SequenceExpression':
-				if (node !== parent.expressions.at(-1)) return false;
-				break;
-
-			case 'TaggedTemplateExpression':
-				if (node !== parent.quasi.expressions.at(-1)) return false;
-				break;
-
-			case 'TemplateLiteral':
-				if (node !== parent.expressions.at(-1)) return false;
-				break;
-
-			case 'VariableDeclarator':
-				return true;
-
-			default:
-				return false;
-		}
-
-		node = parent;
-	}
-}

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

@@ -1,280 +0,0 @@
-/** @import { AST } from '#compiler' */
-/** @import { Context } from '../types' */
-import {
-	extract_all_identifiers_from_expression,
-	is_text_attribute,
-	object
-} from '../../../utils/ast.js';
-import { validate_assignment } from './shared/utils.js';
-import * as e from '../../../errors.js';
-import * as w from '../../../warnings.js';
-import { binding_properties } from '../../bindings.js';
-import fuzzymatch from '../../1-parse/utils/fuzzymatch.js';
-import { is_content_editable_binding, is_svg } from '../../../../utils.js';
-import { mark_subtree_dynamic } from './shared/fragment.js';
-
-/**
- * @param {AST.BindDirective} node
- * @param {Context} context
- */
-export function BindDirective(node, context) {
-	const parent = context.path.at(-1);
-
-	if (
-		parent?.type === 'RegularElement' ||
-		parent?.type === 'SvelteElement' ||
-		parent?.type === 'SvelteWindow' ||
-		parent?.type === 'SvelteDocument' ||
-		parent?.type === 'SvelteBody'
-	) {
-		if (node.name in binding_properties) {
-			const property = binding_properties[node.name];
-			if (property.valid_elements && !property.valid_elements.includes(parent.name)) {
-				e.bind_invalid_target(
-					node,
-					node.name,
-					property.valid_elements.map((valid_element) => `\`<${valid_element}>\``).join(', ')
-				);
-			}
-
-			if (property.invalid_elements && property.invalid_elements.includes(parent.name)) {
-				const valid_bindings = Object.entries(binding_properties)
-					.filter(([_, binding_property]) => {
-						return (
-							binding_property.valid_elements?.includes(parent.name) ||
-							(!binding_property.valid_elements &&
-								!binding_property.invalid_elements?.includes(parent.name))
-						);
-					})
-					.map(([property_name]) => property_name)
-					.sort();
-
-				e.bind_invalid_name(
-					node,
-					node.name,
-					`Possible bindings for <${parent.name}> are ${valid_bindings.join(', ')}`
-				);
-			}
-
-			if (parent.name === 'input' && node.name !== 'this') {
-				const type = /** @type {AST.Attribute | undefined} */ (
-					parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'type')
-				);
-
-				if (type && !is_text_attribute(type)) {
-					if (node.name !== 'value' || type.value === true) {
-						e.attribute_invalid_type(type);
-					}
-				} else {
-					if (node.name === 'checked' && type?.value[0].data !== 'checkbox') {
-						e.bind_invalid_target(
-							node,
-							node.name,
-							`\`<input type="checkbox">\`${type?.value[0].data === 'radio' ? ` — for \`<input type="radio">\`, use \`bind:group\`` : ''}`
-						);
-					}
-
-					if (node.name === 'files' && type?.value[0].data !== 'file') {
-						e.bind_invalid_target(node, node.name, '`<input type="file">`');
-					}
-				}
-			}
-
-			if (parent.name === 'select' && node.name !== 'this') {
-				const multiple = parent.attributes.find(
-					(a) =>
-						a.type === 'Attribute' &&
-						a.name === 'multiple' &&
-						!is_text_attribute(a) &&
-						a.value !== true
-				);
-
-				if (multiple) {
-					e.attribute_invalid_multiple(multiple);
-				}
-			}
-
-			if (node.name === 'offsetWidth' && is_svg(parent.name)) {
-				e.bind_invalid_target(
-					node,
-					node.name,
-					`non-\`<svg>\` elements. Use \`bind:clientWidth\` for \`<svg>\` instead`
-				);
-			}
-
-			if (is_content_editable_binding(node.name)) {
-				const contenteditable = /** @type {AST.Attribute} */ (
-					parent.attributes.find((a) => a.type === 'Attribute' && a.name === 'contenteditable')
-				);
-
-				if (!contenteditable) {
-					e.attribute_contenteditable_missing(node);
-				} else if (!is_text_attribute(contenteditable) && contenteditable.value !== true) {
-					e.attribute_contenteditable_dynamic(contenteditable);
-				}
-			}
-		} else {
-			const match = fuzzymatch(node.name, Object.keys(binding_properties));
-
-			if (match) {
-				const property = binding_properties[match];
-				if (!property.valid_elements || property.valid_elements.includes(parent.name)) {
-					e.bind_invalid_name(node, node.name, `Did you mean '${match}'?`);
-				}
-			}
-
-			e.bind_invalid_name(node, node.name);
-		}
-	}
-
-	// When dealing with bind getters/setters skip the specific binding validation
-	// Group bindings aren't supported for getter/setters so we don't need to handle
-	// the metadata
-	if (node.expression.type === 'SequenceExpression') {
-		if (node.name === 'group') {
-			e.bind_group_invalid_expression(node);
-		}
-
-		let i = /** @type {number} */ (node.expression.start);
-		let leading_comments_start = /**@type {any}*/ (node.expression.leadingComments?.at(0))?.start;
-		let leading_comments_end = /**@type {any}*/ (node.expression.leadingComments?.at(-1))?.end;
-		while (context.state.analysis.source[--i] !== '{') {
-			if (
-				context.state.analysis.source[i] === '(' &&
-				// if the parenthesis is in a leading comment we don't need to throw the error
-				!(
-					leading_comments_start &&
-					leading_comments_end &&
-					i <= leading_comments_end &&
-					i >= leading_comments_start
-				)
-			) {
-				e.bind_invalid_parens(node, node.name);
-			}
-		}
-
-		if (node.expression.expressions.length !== 2) {
-			e.bind_invalid_expression(node);
-		}
-
-		mark_subtree_dynamic(context.path);
-
-		const [get, set] = node.expression.expressions;
-		// We gotta jump across the getter/setter functions to avoid the expression metadata field being reset to null
-		// as we want to collect the functions' blocker/async info
-		context.visit(get.type === 'ArrowFunctionExpression' ? get.body : get, {
-			...context.state,
-			expression: node.metadata.expression
-		});
-		context.visit(set.type === 'ArrowFunctionExpression' ? set.body : set, {
-			...context.state,
-			expression: node.metadata.expression
-		});
-
-		if (node.metadata.expression.has_await) {
-			e.illegal_await_expression(node);
-		}
-
-		return;
-	}
-
-	validate_assignment(node, node.expression, context);
-
-	const assignee = node.expression;
-	const left = object(assignee);
-
-	if (left === null) {
-		e.bind_invalid_expression(node);
-	}
-
-	const binding = context.state.scope.get(left.name);
-	node.metadata.binding = binding;
-
-	if (assignee.type === 'Identifier') {
-		// reassignment
-		if (
-			node.name !== 'this' && // bind:this also works for regular variables
-			(!binding ||
-				(binding.kind !== 'state' &&
-					binding.kind !== 'raw_state' &&
-					binding.kind !== 'prop' &&
-					binding.kind !== 'bindable_prop' &&
-					binding.kind !== 'each' &&
-					binding.kind !== 'store_sub' &&
-					!binding.updated)) // TODO wut?
-		) {
-			e.bind_invalid_value(node.expression);
-		}
-	}
-
-	if (node.name === 'group') {
-		if (!binding) {
-			throw new Error('Cannot find declaration for bind:group');
-		}
-
-		if (binding.kind === 'snippet') {
-			e.bind_group_invalid_snippet_parameter(node);
-		}
-
-		// Traverse the path upwards and find all EachBlocks who are (indirectly) contributing to bind:group,
-		// i.e. one of their declarations is referenced in the binding. This allows group bindings to work
-		// correctly when referencing a variable declared in an EachBlock by using the index of the each block
-		// entries as keys.
-		const each_blocks = [];
-		const [keypath, expression_ids] = extract_all_identifiers_from_expression(node.expression);
-		let ids = expression_ids;
-
-		let i = context.path.length;
-		while (i--) {
-			const parent = context.path[i];
-
-			if (parent.type === 'EachBlock') {
-				const references = ids.filter((id) => parent.metadata.declarations.has(id.name));
-
-				if (references.length > 0) {
-					parent.metadata.contains_group_binding = true;
-
-					each_blocks.push(parent);
-					ids = ids.filter((id) => !references.includes(id));
-					ids.push(...extract_all_identifiers_from_expression(parent.expression)[1]);
-				}
-			}
-		}
-
-		// The identifiers that make up the binding expression form they key for the binding group.
-		// If the same identifiers in the same order are used in another bind:group, they will be in the same group.
-		// (there's an edge case where `bind:group={a[i]}` will be in a different group than `bind:group={a[j]}` even when i == j,
-		//  but this is a limitation of the current static analysis we do; it also never worked in Svelte 4)
-		const bindings = expression_ids.map((id) => context.state.scope.get(id.name));
-		let group_name;
-
-		outer: for (const [[key, b], group] of context.state.analysis.binding_groups) {
-			if (b.length !== bindings.length || key !== keypath) continue;
-			for (let i = 0; i < bindings.length; i++) {
-				if (bindings[i] !== b[i]) continue outer;
-			}
-			group_name = group;
-		}
-
-		if (!group_name) {
-			group_name = context.state.scope.root.unique('binding_group');
-			context.state.analysis.binding_groups.set([keypath, bindings], group_name);
-		}
-
-		node.metadata = {
-			binding_group_name: group_name,
-			parent_each_blocks: each_blocks,
-			expression: node.metadata.expression
-		};
-	}
-
-	if (binding?.kind === 'each' && binding.metadata?.inside_rest) {
-		w.bind_invalid_each_rest(binding.node, binding.node.name);
-	}
-
-	context.next({ ...context.state, expression: node.metadata.expression });
-
-	if (node.metadata.expression.has_await) {
-		e.illegal_await_expression(node);
-	}
-}