lumen-plus 0.0.5 → 0.0.7

package/dist/utils/node_modules/svelte/src/internal/client/dom/blocks/html.js

@@ -0,0 +1,121 @@
+/** @import { Effect, TemplateNode } from '#client' */
+import { FILENAME, HYDRATION_ERROR } from '../../../../constants.js';
+import { remove_effect_dom, template_effect } from '../../reactivity/effects.js';
+import { hydrate_next, hydrate_node, hydrating, set_hydrate_node } from '../hydration.js';
+import { create_fragment_from_html } from '../reconciler.js';
+import { assign_nodes } from '../template.js';
+import * as w from '../../warnings.js';
+import { hash, sanitize_location } from '../../../../utils.js';
+import { DEV } from 'esm-env';
+import { dev_current_component_function } from '../../context.js';
+import { get_first_child, get_next_sibling } from '../operations.js';
+import { active_effect } from '../../runtime.js';
+import { COMMENT_NODE } from '#client/constants';
+
+/**
+ * @param {Element} element
+ * @param {string | null} server_hash
+ * @param {string} value
+ */
+function check_hash(element, server_hash, value) {
+	if (!server_hash || server_hash === hash(String(value ?? ''))) return;
+
+	let location;
+
+	// @ts-expect-error
+	const loc = element.__svelte_meta?.loc;
+	if (loc) {
+		location = `near ${loc.file}:${loc.line}:${loc.column}`;
+	} else if (dev_current_component_function?.[FILENAME]) {
+		location = `in ${dev_current_component_function[FILENAME]}`;
+	}
+
+	w.hydration_html_changed(sanitize_location(location));
+}
+
+/**
+ * @param {Element | Text | Comment} node
+ * @param {() => string} get_value
+ * @param {boolean} [svg]
+ * @param {boolean} [mathml]
+ * @param {boolean} [skip_warning]
+ * @returns {void}
+ */
+export function html(node, get_value, svg = false, mathml = false, skip_warning = false) {
+	var anchor = node;
+
+	var value = '';
+
+	template_effect(() => {
+		var effect = /** @type {Effect} */ (active_effect);
+
+		if (value === (value = get_value() ?? '')) {
+			if (hydrating) hydrate_next();
+			return;
+		}
+
+		if (effect.nodes !== null) {
+			remove_effect_dom(effect.nodes.start, /** @type {TemplateNode} */ (effect.nodes.end));
+			effect.nodes = null;
+		}
+
+		if (value === '') return;
+
+		if (hydrating) {
+			// We're deliberately not trying to repair mismatches between server and client,
+			// as it's costly and error-prone (and it's an edge case to have a mismatch anyway)
+			var hash = /** @type {Comment} */ (hydrate_node).data;
+
+			/** @type {TemplateNode | null} */
+			var next = hydrate_next();
+			var last = next;
+
+			while (
+				next !== null &&
+				(next.nodeType !== COMMENT_NODE || /** @type {Comment} */ (next).data !== '')
+			) {
+				last = next;
+				next = get_next_sibling(next);
+			}
+
+			if (next === null) {
+				w.hydration_mismatch();
+				throw HYDRATION_ERROR;
+			}
+
+			if (DEV && !skip_warning) {
+				check_hash(/** @type {Element} */ (next.parentNode), hash, value);
+			}
+
+			assign_nodes(hydrate_node, last);
+			anchor = set_hydrate_node(next);
+			return;
+		}
+
+		var html = value + '';
+		if (svg) html = `<svg>${html}</svg>`;
+		else if (mathml) html = `<math>${html}</math>`;
+
+		// Don't use create_fragment_with_script_from_html here because that would mean script tags are executed.
+		// @html is basically `.innerHTML = ...` and that doesn't execute scripts either due to security reasons.
+		/** @type {DocumentFragment | Element} */
+		var node = create_fragment_from_html(html);
+
+		if (svg || mathml) {
+			node = /** @type {Element} */ (get_first_child(node));
+		}
+
+		assign_nodes(
+			/** @type {TemplateNode} */ (get_first_child(node)),
+			/** @type {TemplateNode} */ (node.lastChild)
+		);
+
+		if (svg || mathml) {
+			while (get_first_child(node)) {
+				anchor.before(/** @type {TemplateNode} */ (get_first_child(node)));
+			}
+		} else {
+			anchor.before(node);
+		}
+	});
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/blocks/if.js

@@ -0,0 +1,70 @@
+/** @import { TemplateNode } from '#client' */
+import { EFFECT_TRANSPARENT } from '#client/constants';
+import {
+	hydrate_next,
+	hydrating,
+	read_hydration_instruction,
+	skip_nodes,
+	set_hydrate_node,
+	set_hydrating
+} from '../hydration.js';
+import { block } from '../../reactivity/effects.js';
+import { HYDRATION_START_ELSE } from '../../../../constants.js';
+import { BranchManager } from './branches.js';
+
+// TODO reinstate https://github.com/sveltejs/svelte/pull/15250
+
+/**
+ * @param {TemplateNode} node
+ * @param {(branch: (fn: (anchor: Node) => void, flag?: boolean) => void) => void} fn
+ * @param {boolean} [elseif] True if this is an `{:else if ...}` block rather than an `{#if ...}`, as that affects which transitions are considered 'local'
+ * @returns {void}
+ */
+export function if_block(node, fn, elseif = false) {
+	if (hydrating) {
+		hydrate_next();
+	}
+
+	var branches = new BranchManager(node);
+	var flags = elseif ? EFFECT_TRANSPARENT : 0;
+
+	/**
+	 * @param {boolean} condition,
+	 * @param {null | ((anchor: Node) => void)} fn
+	 */
+	function update_branch(condition, fn) {
+		if (hydrating) {
+			const is_else = read_hydration_instruction(node) === HYDRATION_START_ELSE;
+
+			if (condition === is_else) {
+				// Hydration mismatch: remove everything inside the anchor and start fresh.
+				// This could happen with `{#if browser}...{/if}`, for example
+				var anchor = skip_nodes();
+
+				set_hydrate_node(anchor);
+				branches.anchor = anchor;
+
+				set_hydrating(false);
+				branches.ensure(condition, fn);
+				set_hydrating(true);
+
+				return;
+			}
+		}
+
+		branches.ensure(condition, fn);
+	}
+
+	block(() => {
+		var has_branch = false;
+
+		fn((fn, flag = true) => {
+			has_branch = true;
+			update_branch(flag, fn);
+		});
+
+		if (!has_branch) {
+			update_branch(false, null);
+		}
+	}, flags);
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/blocks/key.js

@@ -0,0 +1,33 @@
+/** @import { TemplateNode } from '#client' */
+import { is_runes } from '../../context.js';
+import { block } from '../../reactivity/effects.js';
+import { hydrate_next, hydrating } from '../hydration.js';
+import { BranchManager } from './branches.js';
+
+/**
+ * @template V
+ * @param {TemplateNode} node
+ * @param {() => V} get_key
+ * @param {(anchor: Node) => TemplateNode | void} render_fn
+ * @returns {void}
+ */
+export function key(node, get_key, render_fn) {
+	if (hydrating) {
+		hydrate_next();
+	}
+
+	var branches = new BranchManager(node);
+
+	var legacy = !is_runes();
+
+	block(() => {
+		var key = get_key();
+
+		// key blocks in Svelte <5 had stupid semantics
+		if (legacy && key !== null && typeof key === 'object') {
+			key = /** @type {V} */ ({});
+		}
+
+		branches.ensure(key, render_fn);
+	});
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/blocks/slot.js

@@ -0,0 +1,44 @@
+import { hydrate_next, hydrating } from '../hydration.js';
+
+/**
+ * @param {Comment} anchor
+ * @param {Record<string, any>} $$props
+ * @param {string} name
+ * @param {Record<string, unknown>} slot_props
+ * @param {null | ((anchor: Comment) => void)} fallback_fn
+ */
+export function slot(anchor, $$props, name, slot_props, fallback_fn) {
+	if (hydrating) {
+		hydrate_next();
+	}
+
+	var slot_fn = $$props.$$slots?.[name];
+	// Interop: Can use snippets to fill slots
+	var is_interop = false;
+	if (slot_fn === true) {
+		slot_fn = $$props[name === 'default' ? 'children' : name];
+		is_interop = true;
+	}
+
+	if (slot_fn === undefined) {
+		if (fallback_fn !== null) {
+			fallback_fn(anchor);
+		}
+	} else {
+		slot_fn(anchor, is_interop ? () => slot_props : slot_props);
+	}
+}
+
+/**
+ * @param {Record<string, any>} props
+ * @returns {Record<string, boolean>}
+ */
+export function sanitize_slots(props) {
+	/** @type {Record<string, boolean>} */
+	const sanitized = {};
+	if (props.children) sanitized.default = true;
+	for (const key in props.$$slots) {
+		sanitized[key] = true;
+	}
+	return sanitized;
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/blocks/snippet.js

@@ -0,0 +1,103 @@
+/** @import { Snippet } from 'svelte' */
+/** @import { TemplateNode } from '#client' */
+/** @import { Getters } from '#shared' */
+import { EFFECT_TRANSPARENT, ELEMENT_NODE } from '#client/constants';
+import { block, teardown } from '../../reactivity/effects.js';
+import {
+	dev_current_component_function,
+	set_dev_current_component_function
+} from '../../context.js';
+import { hydrate_next, hydrate_node, hydrating } from '../hydration.js';
+import { create_fragment_from_html } from '../reconciler.js';
+import { assign_nodes } from '../template.js';
+import * as w from '../../warnings.js';
+import * as e from '../../errors.js';
+import { DEV } from 'esm-env';
+import { get_first_child, get_next_sibling } from '../operations.js';
+import { prevent_snippet_stringification } from '../../../shared/validate.js';
+import { BranchManager } from './branches.js';
+
+/**
+ * @template {(node: TemplateNode, ...args: any[]) => void} SnippetFn
+ * @param {TemplateNode} node
+ * @param {() => SnippetFn | null | undefined} get_snippet
+ * @param {(() => any)[]} args
+ * @returns {void}
+ */
+export function snippet(node, get_snippet, ...args) {
+	var branches = new BranchManager(node);
+
+	block(() => {
+		const snippet = get_snippet() ?? null;
+
+		if (DEV && snippet == null) {
+			e.invalid_snippet();
+		}
+
+		branches.ensure(snippet, snippet && ((anchor) => snippet(anchor, ...args)));
+	}, EFFECT_TRANSPARENT);
+}
+
+/**
+ * In development, wrap the snippet function so that it passes validation, and so that the
+ * correct component context is set for ownership checks
+ * @param {any} component
+ * @param {(node: TemplateNode, ...args: any[]) => void} fn
+ */
+export function wrap_snippet(component, fn) {
+	const snippet = (/** @type {TemplateNode} */ node, /** @type {any[]} */ ...args) => {
+		var previous_component_function = dev_current_component_function;
+		set_dev_current_component_function(component);
+
+		try {
+			return fn(node, ...args);
+		} finally {
+			set_dev_current_component_function(previous_component_function);
+		}
+	};
+
+	prevent_snippet_stringification(snippet);
+
+	return snippet;
+}
+
+/**
+ * Create a snippet programmatically
+ * @template {unknown[]} Params
+ * @param {(...params: Getters<Params>) => {
+ *   render: () => string
+ *   setup?: (element: Element) => void | (() => void)
+ * }} fn
+ * @returns {Snippet<Params>}
+ */
+export function createRawSnippet(fn) {
+	// @ts-expect-error the types are a lie
+	return (/** @type {TemplateNode} */ anchor, /** @type {Getters<Params>} */ ...params) => {
+		var snippet = fn(...params);
+
+		/** @type {Element} */
+		var element;
+
+		if (hydrating) {
+			element = /** @type {Element} */ (hydrate_node);
+			hydrate_next();
+		} else {
+			var html = snippet.render().trim();
+			var fragment = create_fragment_from_html(html);
+			element = /** @type {Element} */ (get_first_child(fragment));
+
+			if (DEV && (get_next_sibling(element) !== null || element.nodeType !== ELEMENT_NODE)) {
+				w.invalid_raw_snippet_render();
+			}
+
+			anchor.before(element);
+		}
+
+		const result = snippet.setup?.(element);
+		assign_nodes(element, element);
+
+		if (typeof result === 'function') {
+			teardown(result);
+		}
+	};
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/blocks/svelte-component.js

@@ -0,0 +1,26 @@
+/** @import { TemplateNode, Dom } from '#client' */
+import { EFFECT_TRANSPARENT } from '#client/constants';
+import { block } from '../../reactivity/effects.js';
+import { hydrate_next, hydrating } from '../hydration.js';
+import { BranchManager } from './branches.js';
+
+/**
+ * @template P
+ * @template {(props: P) => void} C
+ * @param {TemplateNode} node
+ * @param {() => C} get_component
+ * @param {(anchor: TemplateNode, component: C) => Dom | void} render_fn
+ * @returns {void}
+ */
+export function component(node, get_component, render_fn) {
+	if (hydrating) {
+		hydrate_next();
+	}
+
+	var branches = new BranchManager(node);
+
+	block(() => {
+		var component = get_component() ?? null;
+		branches.ensure(component, component && ((target) => render_fn(target, component)));
+	}, EFFECT_TRANSPARENT);
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/blocks/svelte-element.js

@@ -0,0 +1,152 @@
+/** @import { Effect, EffectNodes, TemplateNode } from '#client' */
+import { FILENAME, NAMESPACE_SVG } from '../../../../constants.js';
+import {
+	hydrate_next,
+	hydrate_node,
+	hydrating,
+	set_hydrate_node,
+	set_hydrating
+} from '../hydration.js';
+import { create_text, get_first_child } from '../operations.js';
+import { block, teardown } from '../../reactivity/effects.js';
+import { set_should_intro } from '../../render.js';
+import { active_effect } from '../../runtime.js';
+import { component_context, dev_stack } from '../../context.js';
+import { DEV } from 'esm-env';
+import { EFFECT_TRANSPARENT, ELEMENT_NODE } from '#client/constants';
+import { assign_nodes } from '../template.js';
+import { is_raw_text_element } from '../../../../utils.js';
+import { BranchManager } from './branches.js';
+import { set_animation_effect_override } from '../elements/transitions.js';
+
+/**
+ * @param {Comment | Element} node
+ * @param {() => string} get_tag
+ * @param {boolean} is_svg
+ * @param {undefined | ((element: Element, anchor: Node | null) => void)} render_fn,
+ * @param {undefined | (() => string)} get_namespace
+ * @param {undefined | [number, number]} location
+ * @returns {void}
+ */
+export function element(node, get_tag, is_svg, render_fn, get_namespace, location) {
+	let was_hydrating = hydrating;
+
+	if (hydrating) {
+		hydrate_next();
+	}
+
+	var filename = DEV && location && component_context?.function[FILENAME];
+
+	/** @type {null | Element} */
+	var element = null;
+
+	if (hydrating && hydrate_node.nodeType === ELEMENT_NODE) {
+		element = /** @type {Element} */ (hydrate_node);
+		hydrate_next();
+	}
+
+	var anchor = /** @type {TemplateNode} */ (hydrating ? hydrate_node : node);
+
+	/**
+	 * We track this so we can set it when changing the element, allowing any
+	 * `animate:` directive to bind itself to the correct block
+	 */
+	var parent_effect = /** @type {Effect} */ (active_effect);
+
+	var branches = new BranchManager(anchor, false);
+
+	block(() => {
+		const next_tag = get_tag() || null;
+		var ns = get_namespace ? get_namespace() : is_svg || next_tag === 'svg' ? NAMESPACE_SVG : null;
+
+		if (next_tag === null) {
+			branches.ensure(null, null);
+			set_should_intro(true);
+			return;
+		}
+
+		branches.ensure(next_tag, (anchor) => {
+			if (next_tag) {
+				element = hydrating
+					? /** @type {Element} */ (element)
+					: ns
+						? document.createElementNS(ns, next_tag)
+						: document.createElement(next_tag);
+
+				if (DEV && location) {
+					// @ts-expect-error
+					element.__svelte_meta = {
+						parent: dev_stack,
+						loc: {
+							file: filename,
+							line: location[0],
+							column: location[1]
+						}
+					};
+				}
+
+				assign_nodes(element, element);
+
+				if (render_fn) {
+					if (hydrating && is_raw_text_element(next_tag)) {
+						// prevent hydration glitches
+						element.append(document.createComment(''));
+					}
+
+					// If hydrating, use the existing ssr comment as the anchor so that the
+					// inner open and close methods can pick up the existing nodes correctly
+					var child_anchor = hydrating
+						? get_first_child(element)
+						: element.appendChild(create_text());
+
+					if (hydrating) {
+						if (child_anchor === null) {
+							set_hydrating(false);
+						} else {
+							set_hydrate_node(child_anchor);
+						}
+					}
+
+					set_animation_effect_override(parent_effect);
+
+					// `child_anchor` is undefined if this is a void element, but we still
+					// need to call `render_fn` in order to run actions etc. If the element
+					// contains children, it's a user error (which is warned on elsewhere)
+					// and the DOM will be silently discarded
+					render_fn(element, child_anchor);
+
+					set_animation_effect_override(null);
+				}
+
+				// we do this after calling `render_fn` so that child effects don't override `nodes.end`
+				/** @type {Effect & { nodes: EffectNodes }} */ (active_effect).nodes.end = element;
+
+				anchor.before(element);
+			}
+
+			if (hydrating) {
+				set_hydrate_node(anchor);
+			}
+		});
+
+		// revert to the default state after the effect has been created
+		set_should_intro(true);
+
+		return () => {
+			if (next_tag) {
+				// if we're in this callback because we're re-running the effect,
+				// disable intros (unless no element is currently displayed)
+				set_should_intro(false);
+			}
+		};
+	}, EFFECT_TRANSPARENT);
+
+	teardown(() => {
+		set_should_intro(true);
+	});
+
+	if (was_hydrating) {
+		set_hydrating(true);
+		set_hydrate_node(anchor);
+	}
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/blocks/svelte-head.js

@@ -0,0 +1,59 @@
+/** @import { TemplateNode } from '#client' */
+import { hydrate_node, hydrating, set_hydrate_node, set_hydrating } from '../hydration.js';
+import { create_text, get_first_child, get_next_sibling } from '../operations.js';
+import { block } from '../../reactivity/effects.js';
+import { COMMENT_NODE, HEAD_EFFECT } from '#client/constants';
+
+/**
+ * @param {string} hash
+ * @param {(anchor: Node) => void} render_fn
+ * @returns {void}
+ */
+export function head(hash, render_fn) {
+	// The head function may be called after the first hydration pass and ssr comment nodes may still be present,
+	// therefore we need to skip that when we detect that we're not in hydration mode.
+	let previous_hydrate_node = null;
+	let was_hydrating = hydrating;
+
+	/** @type {Comment | Text} */
+	var anchor;
+
+	if (hydrating) {
+		previous_hydrate_node = hydrate_node;
+
+		var head_anchor = get_first_child(document.head);
+
+		// There might be multiple head blocks in our app, and they could have been
+		// rendered in an arbitrary order — find one corresponding to this component
+		while (
+			head_anchor !== null &&
+			(head_anchor.nodeType !== COMMENT_NODE || /** @type {Comment} */ (head_anchor).data !== hash)
+		) {
+			head_anchor = get_next_sibling(head_anchor);
+		}
+
+		// If we can't find an opening hydration marker, skip hydration (this can happen
+		// if a framework rendered body but not head content)
+		if (head_anchor === null) {
+			set_hydrating(false);
+		} else {
+			var start = /** @type {TemplateNode} */ (get_next_sibling(head_anchor));
+			head_anchor.remove(); // in case this component is repeated
+
+			set_hydrate_node(start);
+		}
+	}
+
+	if (!hydrating) {
+		anchor = document.head.appendChild(create_text());
+	}
+
+	try {
+		block(() => render_fn(anchor), HEAD_EFFECT);
+	} finally {
+		if (was_hydrating) {
+			set_hydrating(true);
+			set_hydrate_node(/** @type {TemplateNode} */ (previous_hydrate_node));
+		}
+	}
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/css.js

@@ -0,0 +1,32 @@
+import { DEV } from 'esm-env';
+import { register_style } from '../dev/css.js';
+import { effect } from '../reactivity/effects.js';
+
+/**
+ * @param {Node} anchor
+ * @param {{ hash: string, code: string }} css
+ */
+export function append_styles(anchor, css) {
+	// Use `queue_micro_task` to ensure `anchor` is in the DOM, otherwise getRootNode() will yield wrong results
+	effect(() => {
+		var root = anchor.getRootNode();
+
+		var target = /** @type {ShadowRoot} */ (root).host
+			? /** @type {ShadowRoot} */ (root)
+			: /** @type {Document} */ (root).head ?? /** @type {Document} */ (root.ownerDocument).head;
+
+		// Always querying the DOM is roughly the same perf as additionally checking for presence in a map first assuming
+		// that you'll get cache hits half of the time, so we just always query the dom for simplicity and code savings.
+		if (!target.querySelector('#' + css.hash)) {
+			const style = document.createElement('style');
+			style.id = css.hash;
+			style.textContent = css.code;
+
+			target.appendChild(style);
+
+			if (DEV) {
+				register_style(css.hash, style);
+			}
+		}
+	});
+}

package/dist/utils/node_modules/svelte/src/internal/client/dom/elements/actions.js

@@ -0,0 +1,43 @@
+/** @import { ActionPayload } from '#client' */
+import { effect, render_effect } from '../../reactivity/effects.js';
+import { safe_not_equal } from '../../reactivity/equality.js';
+import { deep_read_state, untrack } from '../../runtime.js';
+
+/**
+ * @template P
+ * @param {Element} dom
+ * @param {(dom: Element, value?: P) => ActionPayload<P>} action
+ * @param {() => P} [get_value]
+ * @returns {void}
+ */
+export function action(dom, action, get_value) {
+	effect(() => {
+		var payload = untrack(() => action(dom, get_value?.()) || {});
+
+		if (get_value && payload?.update) {
+			var inited = false;
+			/** @type {P} */
+			var prev = /** @type {any} */ ({}); // initialize with something so it's never equal on first run
+
+			render_effect(() => {
+				var value = get_value();
+
+				// Action's update method is coarse-grained, i.e. when anything in the passed value changes, update.
+				// This works in legacy mode because of mutable_source being updated as a whole, but when using $state
+				// together with actions and mutation, it wouldn't notice the change without a deep read.
+				deep_read_state(value);
+
+				if (inited && safe_not_equal(prev, value)) {
+					prev = value;
+					/** @type {Function} */ (payload.update)(value);
+				}
+			});
+
+			inited = true;
+		}
+
+		if (payload?.destroy) {
+			return () => /** @type {Function} */ (payload.destroy)();
+		}
+	});
+}