lumen-plus 0.0.4 → 0.0.5

package/dist/utils/node_modules/svelte/src/compiler/phases/3-transform/utils.js

@@ -1,451 +0,0 @@
-/** @import { TransformState } from './types.js' */
-/** @import { AST, Binding, Namespace, ValidatedCompileOptions } from '#compiler' */
-/** @import { Node, Expression, CallExpression, MemberExpression } from 'estree' */
-import {
-	regex_ends_with_whitespaces,
-	regex_not_whitespace,
-	regex_starts_with_whitespaces
-} from '../patterns.js';
-import * as e from '../../errors.js';
-import { walk } from 'zimmerframe';
-import { extract_identifiers } from '../../utils/ast.js';
-import check_graph_for_cycles from '../2-analyze/utils/check_graph_for_cycles.js';
-import is_reference from 'is-reference';
-import { set_scope } from '../scope.js';
-
-/**
- * Match Svelte 4 behaviour by sorting ConstTag nodes in topological order
- * @param {AST.SvelteNode[]} nodes
- * @param {TransformState} state
- */
-function sort_const_tags(nodes, state) {
-	/**
-	 * @typedef {{
-	 *   node: AST.ConstTag;
-	 *   deps: Set<Binding>;
-	 * }} Tag
-	 */
-
-	const other = [];
-
-	/** @type {Map<Binding, Tag>} */
-	const tags = new Map();
-
-	for (const node of nodes) {
-		if (node.type === 'ConstTag') {
-			const declaration = node.declaration.declarations[0];
-
-			const bindings = extract_identifiers(declaration.id).map((id) => {
-				return /** @type {Binding} */ (state.scope.get(id.name));
-			});
-
-			/** @type {Set<Binding>} */
-			const deps = new Set();
-
-			walk(declaration.init, state, {
-				// @ts-expect-error don't know, don't care
-				_: set_scope,
-				Identifier(node, context) {
-					const parent = /** @type {Expression} */ (context.path.at(-1));
-
-					if (is_reference(node, parent)) {
-						const binding = context.state.scope.get(node.name);
-						if (binding) deps.add(binding);
-					}
-				}
-			});
-
-			for (const binding of bindings) {
-				tags.set(binding, { node, deps });
-			}
-		} else {
-			other.push(node);
-		}
-	}
-
-	if (tags.size === 0) {
-		return nodes;
-	}
-
-	/** @type {Array<[Binding, Binding]>} */
-	const edges = [];
-
-	for (const [id, tag] of tags) {
-		for (const dep of tag.deps) {
-			if (tags.has(dep)) {
-				edges.push([id, dep]);
-			}
-		}
-	}
-
-	const cycle = check_graph_for_cycles(edges);
-	if (cycle?.length) {
-		const tag = /** @type {Tag} */ (tags.get(cycle[0]));
-		e.const_tag_cycle(tag.node, cycle.map((binding) => binding.node.name).join(' → '));
-	}
-
-	/** @type {AST.ConstTag[]} */
-	const sorted = [];
-
-	/** @param {Tag} tag */
-	function add(tag) {
-		if (sorted.includes(tag.node)) {
-			return;
-		}
-
-		for (const dep of tag.deps) {
-			const dep_tag = tags.get(dep);
-			if (dep_tag) add(dep_tag);
-		}
-
-		sorted.push(tag.node);
-	}
-
-	for (const tag of tags.values()) {
-		add(tag);
-	}
-
-	return [...sorted, ...other];
-}
-
-/**
- * Extract nodes that are hoisted and trim whitespace according to the following rules:
- * - trim leading and trailing whitespace, regardless of surroundings
- * - keep leading / trailing whitespace of inbetween text nodes,
- *   unless it's whitespace-only, in which case collapse to a single whitespace for all cases
- *   except when it's children of certain elements where we know ignore whitespace (like td/option/head),
- *   in which case we remove it entirely
- * @param {AST.SvelteNode} parent
- * @param {AST.SvelteNode[]} nodes
- * @param {AST.SvelteNode[]} path
- * @param {Namespace} namespace
- * @param {TransformState & { options: ValidatedCompileOptions }} state
- * @param {boolean} preserve_whitespace
- * @param {boolean} preserve_comments
- */
-export function clean_nodes(
-	parent,
-	nodes,
-	path,
-	namespace = 'html',
-	state,
-	// TODO give these defaults (state.options.preserveWhitespace and state.options.preserveComments).
-	// first, we need to make `Component(Client|Server)TransformState` inherit from a new `ComponentTransformState`
-	// rather than from `ClientTransformState` and `ServerTransformState`
-	preserve_whitespace,
-	preserve_comments
-) {
-	if (!state.analysis.runes) {
-		nodes = sort_const_tags(nodes, state);
-	}
-
-	/** @type {AST.SvelteNode[]} */
-	const hoisted = [];
-
-	/** @type {AST.SvelteNode[]} */
-	const regular = [];
-
-	for (const node of nodes) {
-		if (node.type === 'Comment' && !preserve_comments) {
-			continue;
-		}
-
-		if (
-			node.type === 'ConstTag' ||
-			node.type === 'DebugTag' ||
-			node.type === 'SvelteBody' ||
-			node.type === 'SvelteWindow' ||
-			node.type === 'SvelteDocument' ||
-			node.type === 'SvelteHead' ||
-			node.type === 'TitleElement' ||
-			node.type === 'SnippetBlock'
-		) {
-			// TODO others?
-			hoisted.push(node);
-		} else {
-			regular.push(node);
-		}
-	}
-
-	let trimmed = regular;
-
-	if (!preserve_whitespace) {
-		trimmed = [];
-
-		let first, last;
-
-		while (
-			(first = regular[0]) &&
-			first.type === 'Text' &&
-			!regex_not_whitespace.test(first.data)
-		) {
-			regular.shift();
-		}
-
-		if (first?.type === 'Text') {
-			first.raw = first.raw.replace(regex_starts_with_whitespaces, '');
-			first.data = first.data.replace(regex_starts_with_whitespaces, '');
-		}
-
-		while (
-			(last = regular.at(-1)) &&
-			last.type === 'Text' &&
-			!regex_not_whitespace.test(last.data)
-		) {
-			regular.pop();
-		}
-
-		if (last?.type === 'Text') {
-			last.raw = last.raw.replace(regex_ends_with_whitespaces, '');
-			last.data = last.data.replace(regex_ends_with_whitespaces, '');
-		}
-
-		const can_remove_entirely =
-			(namespace === 'svg' &&
-				(parent.type !== 'RegularElement' || parent.name !== 'text') &&
-				!path.some((n) => n.type === 'RegularElement' && n.name === 'text')) ||
-			(parent.type === 'RegularElement' &&
-				// TODO others?
-				(parent.name === 'select' ||
-					parent.name === 'tr' ||
-					parent.name === 'table' ||
-					parent.name === 'tbody' ||
-					parent.name === 'thead' ||
-					parent.name === 'tfoot' ||
-					parent.name === 'colgroup' ||
-					parent.name === 'datalist'));
-
-		// Replace any whitespace between a text and non-text node with a single spaceand keep whitespace
-		// as-is within text nodes, or between text nodes and expression tags (because in the end they count
-		// as one text). This way whitespace is mostly preserved when using CSS with `white-space: pre-line`
-		// and default slot content going into a pre tag (which we can't see).
-		for (let i = 0; i < regular.length; i++) {
-			const prev = regular[i - 1];
-			const node = regular[i];
-			const next = regular[i + 1];
-
-			if (node.type === 'Text') {
-				if (prev?.type !== 'ExpressionTag') {
-					const prev_is_text_ending_with_whitespace =
-						prev?.type === 'Text' && regex_ends_with_whitespaces.test(prev.data);
-					node.data = node.data.replace(
-						regex_starts_with_whitespaces,
-						prev_is_text_ending_with_whitespace ? '' : ' '
-					);
-					node.raw = node.raw.replace(
-						regex_starts_with_whitespaces,
-						prev_is_text_ending_with_whitespace ? '' : ' '
-					);
-				}
-				if (next?.type !== 'ExpressionTag') {
-					node.data = node.data.replace(regex_ends_with_whitespaces, ' ');
-					node.raw = node.raw.replace(regex_ends_with_whitespaces, ' ');
-				}
-				if (node.data && (node.data !== ' ' || !can_remove_entirely)) {
-					trimmed.push(node);
-				}
-			} else {
-				trimmed.push(node);
-			}
-		}
-	}
-
-	var first = trimmed[0];
-
-	// if first text node inside a <pre> is a single newline, discard it, because otherwise
-	// the browser will do it for us which could break hydration
-	if (parent.type === 'RegularElement' && parent.name === 'pre' && first?.type === 'Text') {
-		if (first.data === '\n' || first.data === '\r\n') {
-			trimmed.shift();
-			first = trimmed[0];
-		}
-	}
-
-	// Special case: Add a comment if this is a lone script tag. This ensures that our run_scripts logic in template.js
-	// will always be able to call node.replaceWith() on the script tag in order to make it run. If we don't add this
-	// and would still call node.replaceWith() on the script tag, it would be a no-op because the script tag has no parent.
-	if (trimmed.length === 1 && first.type === 'RegularElement' && first.name === 'script') {
-		trimmed.push({
-			type: 'Comment',
-			data: '',
-			start: -1,
-			end: -1
-		});
-	}
-
-	return {
-		hoisted,
-		trimmed,
-		/**
-		 * In a case like `{#if x}<Foo />{/if}`, we don't need to wrap the child in
-		 * comments — we can just use the parent block's anchor for the component.
-		 * TODO extend this optimisation to other cases
-		 */
-		is_standalone:
-			trimmed.length === 1 &&
-			((first.type === 'RenderTag' && !first.metadata.dynamic) ||
-				(first.type === 'Component' &&
-					!state.options.hmr &&
-					!first.metadata.dynamic &&
-					!first.attributes.some(
-						(attribute) => attribute.type === 'Attribute' && attribute.name.startsWith('--')
-					))),
-		/** if a component/snippet/each block starts with text, we need to add an anchor comment so that its text node doesn't get fused with its surroundings */
-		is_text_first:
-			(parent.type === 'Fragment' ||
-				parent.type === 'SnippetBlock' ||
-				parent.type === 'EachBlock' ||
-				parent.type === 'SvelteComponent' ||
-				parent.type === 'SvelteBoundary' ||
-				parent.type === 'Component' ||
-				parent.type === 'SvelteSelf') &&
-			first &&
-			(first?.type === 'Text' || first?.type === 'ExpressionTag')
-	};
-}
-
-/**
- * Infers the namespace for the children of a node that should be used when creating the fragment
- * @param {Namespace} namespace
- * @param {AST.SvelteNode} parent
- * @param {AST.SvelteNode[]} nodes
- */
-export function infer_namespace(namespace, parent, nodes) {
-	if (parent.type === 'RegularElement' && parent.name === 'foreignObject') {
-		return 'html';
-	}
-
-	if (parent.type === 'RegularElement' || parent.type === 'SvelteElement') {
-		if (parent.metadata.svg) {
-			return 'svg';
-		}
-		return parent.metadata.mathml ? 'mathml' : 'html';
-	}
-
-	// Re-evaluate the namespace inside slot nodes that reset the namespace
-	if (
-		parent.type === 'Fragment' ||
-		parent.type === 'Root' ||
-		parent.type === 'Component' ||
-		parent.type === 'SvelteComponent' ||
-		parent.type === 'SvelteFragment' ||
-		parent.type === 'SnippetBlock' ||
-		parent.type === 'SlotElement'
-	) {
-		const new_namespace = check_nodes_for_namespace(nodes, 'keep');
-		if (new_namespace !== 'keep' && new_namespace !== 'maybe_html') {
-			return new_namespace;
-		}
-	}
-
-	/** @type {Namespace | null} */
-	let new_namespace = null;
-
-	// Check the elements within the fragment and look for consistent namespaces.
-	// If we have no namespaces or they are mixed, then fallback to existing namespace
-	for (const node of nodes) {
-		if (node.type !== 'RegularElement') continue;
-
-		if (node.metadata.mathml) {
-			new_namespace = new_namespace === null || new_namespace === 'mathml' ? 'mathml' : 'html';
-		} else if (node.metadata.svg) {
-			new_namespace = new_namespace === null || new_namespace === 'svg' ? 'svg' : 'html';
-		} else {
-			return 'html';
-		}
-	}
-
-	return new_namespace ?? namespace;
-}
-
-/**
- * Heuristic: Keep current namespace, unless we find a regular element,
- * in which case we always want html, or we only find svg nodes,
- * in which case we assume svg.
- * @param {AST.SvelteNode[]} nodes
- * @param {Namespace | 'keep' | 'maybe_html'} namespace
- */
-function check_nodes_for_namespace(nodes, namespace) {
-	/**
-	 * @param {AST.SvelteElement | AST.RegularElement} node}
-	 * @param {{stop: () => void}} context
-	 */
-	const RegularElement = (node, { stop }) => {
-		if (!node.metadata.svg && !node.metadata.mathml) {
-			namespace = 'html';
-			stop();
-		} else if (namespace === 'keep') {
-			namespace = node.metadata.svg ? 'svg' : 'mathml';
-		}
-	};
-
-	for (const node of nodes) {
-		walk(
-			node,
-			{},
-			{
-				_(node, { next }) {
-					if (
-						node.type === 'EachBlock' ||
-						node.type === 'IfBlock' ||
-						node.type === 'AwaitBlock' ||
-						node.type === 'Fragment' ||
-						node.type === 'KeyBlock' ||
-						node.type === 'RegularElement' ||
-						node.type === 'SvelteElement' ||
-						node.type === 'Text'
-					) {
-						next();
-					}
-				},
-				SvelteElement: RegularElement,
-				RegularElement,
-				Text(node) {
-					if (node.data.trim() !== '') {
-						namespace = 'maybe_html';
-					}
-				}
-			}
-		);
-
-		if (namespace === 'html') return namespace;
-	}
-
-	return namespace;
-}
-
-/**
- * Determines the namespace the children of this node are in.
- * @param {AST.RegularElement | AST.SvelteElement} node
- * @param {Namespace} namespace
- * @returns {Namespace}
- */
-export function determine_namespace_for_children(node, namespace) {
-	if (node.name === 'foreignObject') {
-		return 'html';
-	}
-
-	if (node.metadata.svg) {
-		return 'svg';
-	}
-
-	return node.metadata.mathml ? 'mathml' : 'html';
-}
-
-/**
- * @param {'$inspect' | '$inspect().with'} rune
- * @param {CallExpression} node
- * @param {(node: AST.SvelteNode) => AST.SvelteNode} visit
- */
-export function get_inspect_args(rune, node, visit) {
-	const call =
-		rune === '$inspect'
-			? node
-			: /** @type {CallExpression} */ (/** @type {MemberExpression} */ (node.callee).object);
-
-	return {
-		args: call.arguments.map((arg) => /** @type {Expression} */ (visit(arg))),
-		inspector:
-			rune === '$inspect' ? 'console.log' : /** @type {Expression} */ (visit(node.arguments[0]))
-	};
-}

package/dist/utils/node_modules/svelte/src/compiler/phases/bindings.js

@@ -1,227 +0,0 @@
-/**
- * @typedef BindingProperty
- * @property {string} [event] This is set if the binding corresponds to the property name on the dom element it's bound to
- * 							  and there's an event that notifies of a change to that property
- * @property {boolean} [bidirectional] Set this to `true` if updates are written to the dom property
- * @property {boolean} [omit_in_ssr] Set this to true if the binding should not be included in SSR
- * @property {string[]} [valid_elements] If this is set, the binding is only valid on the given elements
- * @property {string[]} [invalid_elements] If this is set, the binding is invalid on the given elements
- */
-
-/**
- * @type {Record<string, BindingProperty>}
- */
-export const binding_properties = {
-	// media
-	currentTime: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true,
-		bidirectional: true
-	},
-	duration: {
-		valid_elements: ['audio', 'video'],
-		event: 'durationchange',
-		omit_in_ssr: true
-	},
-	focused: {},
-	paused: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true,
-		bidirectional: true
-	},
-	buffered: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true
-	},
-	seekable: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true
-	},
-	played: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true
-	},
-	volume: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true,
-		bidirectional: true
-	},
-	muted: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true,
-		bidirectional: true
-	},
-	playbackRate: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true,
-		bidirectional: true
-	},
-	seeking: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true
-	},
-	ended: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true
-	},
-	readyState: {
-		valid_elements: ['audio', 'video'],
-		omit_in_ssr: true
-	},
-	// video
-	videoHeight: {
-		valid_elements: ['video'],
-		event: 'resize',
-		omit_in_ssr: true
-	},
-	videoWidth: {
-		valid_elements: ['video'],
-		event: 'resize',
-		omit_in_ssr: true
-	},
-	// img
-	naturalWidth: {
-		valid_elements: ['img'],
-		event: 'load',
-		omit_in_ssr: true
-	},
-	naturalHeight: {
-		valid_elements: ['img'],
-		event: 'load',
-		omit_in_ssr: true
-	},
-	// document
-	activeElement: {
-		valid_elements: ['svelte:document'],
-		omit_in_ssr: true
-	},
-	fullscreenElement: {
-		valid_elements: ['svelte:document'],
-		event: 'fullscreenchange',
-		omit_in_ssr: true
-	},
-	pointerLockElement: {
-		valid_elements: ['svelte:document'],
-		event: 'pointerlockchange',
-		omit_in_ssr: true
-	},
-	visibilityState: {
-		valid_elements: ['svelte:document'],
-		event: 'visibilitychange',
-		omit_in_ssr: true
-	},
-	// window
-	innerWidth: {
-		valid_elements: ['svelte:window'],
-		omit_in_ssr: true
-	},
-	innerHeight: {
-		valid_elements: ['svelte:window'],
-		omit_in_ssr: true
-	},
-	outerWidth: {
-		valid_elements: ['svelte:window'],
-		omit_in_ssr: true
-	},
-	outerHeight: {
-		valid_elements: ['svelte:window'],
-		omit_in_ssr: true
-	},
-	scrollX: {
-		valid_elements: ['svelte:window'],
-		omit_in_ssr: true,
-		bidirectional: true
-	},
-	scrollY: {
-		valid_elements: ['svelte:window'],
-		omit_in_ssr: true,
-		bidirectional: true
-	},
-	online: {
-		valid_elements: ['svelte:window'],
-		omit_in_ssr: true
-	},
-	devicePixelRatio: {
-		valid_elements: ['svelte:window'],
-		event: 'resize',
-		omit_in_ssr: true
-	},
-	// dimensions
-	clientWidth: {
-		omit_in_ssr: true,
-		invalid_elements: ['svelte:window', 'svelte:document']
-	},
-	clientHeight: {
-		omit_in_ssr: true,
-		invalid_elements: ['svelte:window', 'svelte:document']
-	},
-	offsetWidth: {
-		omit_in_ssr: true,
-		invalid_elements: ['svelte:window', 'svelte:document']
-	},
-	offsetHeight: {
-		omit_in_ssr: true,
-		invalid_elements: ['svelte:window', 'svelte:document']
-	},
-	contentRect: {
-		omit_in_ssr: true,
-		invalid_elements: ['svelte:window', 'svelte:document']
-	},
-	contentBoxSize: {
-		omit_in_ssr: true,
-		invalid_elements: ['svelte:window', 'svelte:document']
-	},
-	borderBoxSize: {
-		omit_in_ssr: true,
-		invalid_elements: ['svelte:window', 'svelte:document']
-	},
-	devicePixelContentBoxSize: {
-		omit_in_ssr: true,
-		invalid_elements: ['svelte:window', 'svelte:document']
-	},
-	// checkbox/radio
-	indeterminate: {
-		event: 'change',
-		bidirectional: true,
-		valid_elements: ['input'],
-		omit_in_ssr: true // no corresponding attribute
-	},
-	checked: {
-		valid_elements: ['input'],
-		bidirectional: true
-	},
-	group: {
-		valid_elements: ['input'],
-		bidirectional: true
-	},
-	// various
-	this: {
-		omit_in_ssr: true
-	},
-	innerText: {
-		invalid_elements: ['svelte:window', 'svelte:document'],
-		bidirectional: true
-	},
-	innerHTML: {
-		invalid_elements: ['svelte:window', 'svelte:document'],
-		bidirectional: true
-	},
-	textContent: {
-		invalid_elements: ['svelte:window', 'svelte:document'],
-		bidirectional: true
-	},
-	open: {
-		event: 'toggle',
-		bidirectional: true,
-		valid_elements: ['details']
-	},
-	value: {
-		valid_elements: ['input', 'textarea', 'select'],
-		bidirectional: true
-	},
-	files: {
-		valid_elements: ['input'],
-		omit_in_ssr: true,
-		bidirectional: true
-	}
-};

package/dist/utils/node_modules/svelte/src/compiler/phases/css.js

@@ -1,14 +0,0 @@
-/** @import { AST } from '#compiler' */
-const regex_css_browser_prefix = /^-((webkit)|(moz)|(o)|(ms))-/;
-export const regex_css_name_boundary = /^[\s,;}]$/;
-
-/**
- * @param {string} name
- * @returns {string}
- */
-export function remove_css_prefix(name) {
-	return name.replace(regex_css_browser_prefix, '');
-}
-
-/** @param {AST.CSS.Atrule} node */
-export const is_keyframes_node = (node) => remove_css_prefix(node.name) === 'keyframes';