lumen-plus 0.0.4 → 0.0.5

package/dist/utils/node_modules/svelte/src/index-client.js

@@ -1,255 +0,0 @@
-/** @import { ComponentContext, ComponentContextLegacy } from '#client' */
-/** @import { EventDispatcher } from './index.js' */
-/** @import { NotFunction } from './internal/types.js' */
-import { active_reaction, untrack } from './internal/client/runtime.js';
-import { is_array } from './internal/shared/utils.js';
-import { user_effect } from './internal/client/index.js';
-import * as e from './internal/client/errors.js';
-import { legacy_mode_flag } from './internal/flags/index.js';
-import { component_context } from './internal/client/context.js';
-import { DEV } from 'esm-env';
-
-if (DEV) {
-	/**
-	 * @param {string} rune
-	 */
-	function throw_rune_error(rune) {
-		if (!(rune in globalThis)) {
-			// TODO if people start adjusting the "this can contain runes" config through v-p-s more, adjust this message
-			/** @type {any} */
-			let value; // let's hope noone modifies this global, but belts and braces
-			Object.defineProperty(globalThis, rune, {
-				configurable: true,
-				// eslint-disable-next-line getter-return
-				get: () => {
-					if (value !== undefined) {
-						return value;
-					}
-
-					e.rune_outside_svelte(rune);
-				},
-				set: (v) => {
-					value = v;
-				}
-			});
-		}
-	}
-
-	throw_rune_error('$state');
-	throw_rune_error('$effect');
-	throw_rune_error('$derived');
-	throw_rune_error('$inspect');
-	throw_rune_error('$props');
-	throw_rune_error('$bindable');
-}
-
-/**
- * Returns an [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that aborts when the current [derived](https://svelte.dev/docs/svelte/$derived) or [effect](https://svelte.dev/docs/svelte/$effect) re-runs or is destroyed.
- *
- * Must be called while a derived or effect is running.
- *
- * ```svelte
- * <script>
- * 	import { getAbortSignal } from 'svelte';
- *
- * 	let { id } = $props();
- *
- * 	async function getData(id) {
- * 		const response = await fetch(`/items/${id}`, {
- * 			signal: getAbortSignal()
- * 		});
- *
- * 		return await response.json();
- * 	}
- *
- * 	const data = $derived(await getData(id));
- * </script>
- * ```
- */
-export function getAbortSignal() {
-	if (active_reaction === null) {
-		e.get_abort_signal_outside_reaction();
-	}
-
-	return (active_reaction.ac ??= new AbortController()).signal;
-}
-
-/**
- * `onMount`, like [`$effect`](https://svelte.dev/docs/svelte/$effect), schedules a function to run as soon as the component has been mounted to the DOM.
- * Unlike `$effect`, the provided function only runs once.
- *
- * It must be called during the component's initialisation (but doesn't need to live _inside_ the component;
- * it can be called from an external module). If a function is returned _synchronously_ from `onMount`,
- * it will be called when the component is unmounted.
- *
- * `onMount` functions do not run during [server-side rendering](https://svelte.dev/docs/svelte/svelte-server#render).
- *
- * @template T
- * @param {() => NotFunction<T> | Promise<NotFunction<T>> | (() => any)} fn
- * @returns {void}
- */
-export function onMount(fn) {
-	if (component_context === null) {
-		e.lifecycle_outside_component('onMount');
-	}
-
-	if (legacy_mode_flag && component_context.l !== null) {
-		init_update_callbacks(component_context).m.push(fn);
-	} else {
-		user_effect(() => {
-			const cleanup = untrack(fn);
-			if (typeof cleanup === 'function') return /** @type {() => void} */ (cleanup);
-		});
-	}
-}
-
-/**
- * Schedules a callback to run immediately before the component is unmounted.
- *
- * Out of `onMount`, `beforeUpdate`, `afterUpdate` and `onDestroy`, this is the
- * only one that runs inside a server-side component.
- *
- * @param {() => any} fn
- * @returns {void}
- */
-export function onDestroy(fn) {
-	if (component_context === null) {
-		e.lifecycle_outside_component('onDestroy');
-	}
-
-	onMount(() => () => untrack(fn));
-}
-
-/**
- * @template [T=any]
- * @param {string} type
- * @param {T} [detail]
- * @param {any}params_0
- * @returns {CustomEvent<T>}
- */
-function create_custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
-	return new CustomEvent(type, { detail, bubbles, cancelable });
-}
-
-/**
- * Creates an event dispatcher that can be used to dispatch [component events](https://svelte.dev/docs/svelte/legacy-on#Component-events).
- * Event dispatchers are functions that can take two arguments: `name` and `detail`.
- *
- * Component events created with `createEventDispatcher` create a
- * [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).
- * These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).
- * The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)
- * property and can contain any type of data.
- *
- * The event dispatcher can be typed to narrow the allowed event names and the type of the `detail` argument:
- * ```ts
- * const dispatch = createEventDispatcher<{
- *  loaded: null; // does not take a detail argument
- *  change: string; // takes a detail argument of type string, which is required
- *  optional: number | null; // takes an optional detail argument of type number
- * }>();
- * ```
- *
- * @deprecated Use callback props and/or the `$host()` rune instead — see [migration guide](https://svelte.dev/docs/svelte/v5-migration-guide#Event-changes-Component-events)
- * @template {Record<string, any>} [EventMap = any]
- * @returns {EventDispatcher<EventMap>}
- */
-export function createEventDispatcher() {
-	const active_component_context = component_context;
-	if (active_component_context === null) {
-		e.lifecycle_outside_component('createEventDispatcher');
-	}
-
-	/**
-	 * @param [detail]
-	 * @param [options]
-	 */
-	return (type, detail, options) => {
-		const events = /** @type {Record<string, Function | Function[]>} */ (
-			active_component_context.s.$$events
-		)?.[/** @type {string} */ (type)];
-
-		if (events) {
-			const callbacks = is_array(events) ? events.slice() : [events];
-			// TODO are there situations where events could be dispatched
-			// in a server (non-DOM) environment?
-			const event = create_custom_event(/** @type {string} */ (type), detail, options);
-			for (const fn of callbacks) {
-				fn.call(active_component_context.x, event);
-			}
-			return !event.defaultPrevented;
-		}
-
-		return true;
-	};
-}
-
-// TODO mark beforeUpdate and afterUpdate as deprecated in Svelte 6
-
-/**
- * Schedules a callback to run immediately before the component is updated after any state change.
- *
- * The first time the callback runs will be before the initial `onMount`.
- *
- * In runes mode use `$effect.pre` instead.
- *
- * @deprecated Use [`$effect.pre`](https://svelte.dev/docs/svelte/$effect#$effect.pre) instead
- * @param {() => void} fn
- * @returns {void}
- */
-export function beforeUpdate(fn) {
-	if (component_context === null) {
-		e.lifecycle_outside_component('beforeUpdate');
-	}
-
-	if (component_context.l === null) {
-		e.lifecycle_legacy_only('beforeUpdate');
-	}
-
-	init_update_callbacks(component_context).b.push(fn);
-}
-
-/**
- * Schedules a callback to run immediately after the component has been updated.
- *
- * The first time the callback runs will be after the initial `onMount`.
- *
- * In runes mode use `$effect` instead.
- *
- * @deprecated Use [`$effect`](https://svelte.dev/docs/svelte/$effect) instead
- * @param {() => void} fn
- * @returns {void}
- */
-export function afterUpdate(fn) {
-	if (component_context === null) {
-		e.lifecycle_outside_component('afterUpdate');
-	}
-
-	if (component_context.l === null) {
-		e.lifecycle_legacy_only('afterUpdate');
-	}
-
-	init_update_callbacks(component_context).a.push(fn);
-}
-
-/**
- * Legacy-mode: Init callbacks object for onMount/beforeUpdate/afterUpdate
- * @param {ComponentContext} context
- */
-function init_update_callbacks(context) {
-	var l = /** @type {ComponentContextLegacy} */ (context).l;
-	return (l.u ??= { a: [], b: [], m: [] });
-}
-
-export { flushSync, fork } from './internal/client/reactivity/batch.js';
-export {
-	createContext,
-	getContext,
-	getAllContexts,
-	hasContext,
-	setContext
-} from './internal/client/context.js';
-export { hydratable } from './internal/client/hydratable.js';
-export { hydrate, mount, unmount } from './internal/client/render.js';
-export { tick, untrack, settled } from './internal/client/runtime.js';
-export { createRawSnippet } from './internal/client/dom/blocks/snippet.js';

package/dist/utils/node_modules/svelte/src/index-server.js

@@ -1,56 +0,0 @@
-/** @import { SSRContext } from '#server' */
-/** @import { Renderer } from './internal/server/renderer.js' */
-import { ssr_context } from './internal/server/context.js';
-import { noop } from './internal/shared/utils.js';
-import * as e from './internal/server/errors.js';
-
-/** @param {() => void} fn */
-export function onDestroy(fn) {
-	/** @type {Renderer} */ (/** @type {SSRContext} */ (ssr_context).r).on_destroy(fn);
-}
-
-export {
-	noop as beforeUpdate,
-	noop as afterUpdate,
-	noop as onMount,
-	noop as flushSync,
-	run as untrack
-} from './internal/shared/utils.js';
-
-export function createEventDispatcher() {
-	return noop;
-}
-
-export function mount() {
-	e.lifecycle_function_unavailable('mount');
-}
-
-export function hydrate() {
-	e.lifecycle_function_unavailable('hydrate');
-}
-
-export function unmount() {
-	e.lifecycle_function_unavailable('unmount');
-}
-
-export function fork() {
-	e.lifecycle_function_unavailable('fork');
-}
-
-export async function tick() {}
-
-export async function settled() {}
-
-export { getAbortSignal } from './internal/server/abort-signal.js';
-
-export {
-	createContext,
-	getAllContexts,
-	getContext,
-	hasContext,
-	setContext
-} from './internal/server/context.js';
-
-export { hydratable } from './internal/server/hydratable.js';
-
-export { createRawSnippet } from './internal/server/blocks/snippet.js';

package/dist/utils/node_modules/svelte/src/internal/client/constants.js

@@ -1,73 +0,0 @@
-// General flags
-export const DERIVED = 1 << 1;
-export const EFFECT = 1 << 2;
-export const RENDER_EFFECT = 1 << 3;
-/**
- * An effect that does not destroy its child effects when it reruns.
- * Runs as part of render effects, i.e. not eagerly as part of tree traversal or effect flushing.
- */
-export const MANAGED_EFFECT = 1 << 24;
-/**
- * An effect that does not destroy its child effects when it reruns (like MANAGED_EFFECT).
- * Runs eagerly as part of tree traversal or effect flushing.
- */
-export const BLOCK_EFFECT = 1 << 4;
-export const BRANCH_EFFECT = 1 << 5;
-export const ROOT_EFFECT = 1 << 6;
-export const BOUNDARY_EFFECT = 1 << 7;
-/**
- * Indicates that a reaction is connected to an effect root — either it is an effect,
- * or it is a derived that is depended on by at least one effect. If a derived has
- * no dependents, we can disconnect it from the graph, allowing it to either be
- * GC'd or reconnected later if an effect comes to depend on it again
- */
-export const CONNECTED = 1 << 9;
-export const CLEAN = 1 << 10;
-export const DIRTY = 1 << 11;
-export const MAYBE_DIRTY = 1 << 12;
-export const INERT = 1 << 13;
-export const DESTROYED = 1 << 14;
-
-// Flags exclusive to effects
-/** Set once an effect that should run synchronously has run */
-export const EFFECT_RAN = 1 << 15;
-/**
- * 'Transparent' effects do not create a transition boundary.
- * This is on a block effect 99% of the time but may also be on a branch effect if its parent block effect was pruned
- */
-export const EFFECT_TRANSPARENT = 1 << 16;
-export const EAGER_EFFECT = 1 << 17;
-export const HEAD_EFFECT = 1 << 18;
-export const EFFECT_PRESERVED = 1 << 19;
-export const USER_EFFECT = 1 << 20;
-export const EFFECT_OFFSCREEN = 1 << 25;
-
-// Flags exclusive to deriveds
-/**
- * Tells that we marked this derived and its reactions as visited during the "mark as (maybe) dirty"-phase.
- * Will be lifted during execution of the derived and during checking its dirty state (both are necessary
- * because a derived might be checked but not executed).
- */
-export const WAS_MARKED = 1 << 15;
-
-// Flags used for async
-export const REACTION_IS_UPDATING = 1 << 21;
-export const ASYNC = 1 << 22;
-
-export const ERROR_VALUE = 1 << 23;
-
-export const STATE_SYMBOL = Symbol('$state');
-export const LEGACY_PROPS = Symbol('legacy props');
-export const LOADING_ATTR_SYMBOL = Symbol('');
-export const PROXY_PATH_SYMBOL = Symbol('proxy path');
-
-/** allow users to ignore aborted signal errors if `reason.name === 'StaleReactionError` */
-export const STALE_REACTION = new (class StaleReactionError extends Error {
-	name = 'StaleReactionError';
-	message = 'The reaction that called `getAbortSignal()` was re-run or destroyed';
-})();
-
-export const ELEMENT_NODE = 1;
-export const TEXT_NODE = 3;
-export const COMMENT_NODE = 8;
-export const DOCUMENT_FRAGMENT_NODE = 11;

package/dist/utils/node_modules/svelte/src/internal/client/context.js

@@ -1,258 +0,0 @@
-/** @import { ComponentContext, DevStackEntry, Effect } from '#client' */
-import { DEV } from 'esm-env';
-import * as e from './errors.js';
-import { active_effect, active_reaction } from './runtime.js';
-import { create_user_effect } from './reactivity/effects.js';
-import { async_mode_flag, legacy_mode_flag } from '../flags/index.js';
-import { FILENAME } from '../../constants.js';
-import { BRANCH_EFFECT, EFFECT_RAN } from './constants.js';
-
-/** @type {ComponentContext | null} */
-export let component_context = null;
-
-/** @param {ComponentContext | null} context */
-export function set_component_context(context) {
-	component_context = context;
-}
-
-/** @type {DevStackEntry | null} */
-export let dev_stack = null;
-
-/** @param {DevStackEntry | null} stack */
-export function set_dev_stack(stack) {
-	dev_stack = stack;
-}
-
-/**
- * Execute a callback with a new dev stack entry
- * @param {() => any} callback - Function to execute
- * @param {DevStackEntry['type']} type - Type of block/component
- * @param {any} component - Component function
- * @param {number} line - Line number
- * @param {number} column - Column number
- * @param {Record<string, any>} [additional] - Any additional properties to add to the dev stack entry
- * @returns {any}
- */
-export function add_svelte_meta(callback, type, component, line, column, additional) {
-	const parent = dev_stack;
-
-	dev_stack = {
-		type,
-		file: component[FILENAME],
-		line,
-		column,
-		parent,
-		...additional
-	};
-
-	try {
-		return callback();
-	} finally {
-		dev_stack = parent;
-	}
-}
-
-/**
- * The current component function. Different from current component context:
- * ```html
- * <!-- App.svelte -->
- * <Foo>
- *   <Bar /> <!-- context == Foo.svelte, function == App.svelte -->
- * </Foo>
- * ```
- * @type {ComponentContext['function']}
- */
-export let dev_current_component_function = null;
-
-/** @param {ComponentContext['function']} fn */
-export function set_dev_current_component_function(fn) {
-	dev_current_component_function = fn;
-}
-
-/**
- * Returns a `[get, set]` pair of functions for working with context in a type-safe way.
- *
- * `get` will throw an error if no parent component called `set`.
- *
- * @template T
- * @returns {[() => T, (context: T) => T]}
- * @since 5.40.0
- */
-export function createContext() {
-	const key = {};
-
-	return [
-		() => {
-			if (!hasContext(key)) {
-				e.missing_context();
-			}
-
-			return getContext(key);
-		},
-		(context) => setContext(key, context)
-	];
-}
-
-/**
- * Retrieves the context that belongs to the closest parent component with the specified `key`.
- * Must be called during component initialisation.
- *
- * [`createContext`](https://svelte.dev/docs/svelte/svelte#createContext) is a type-safe alternative.
- *
- * @template T
- * @param {any} key
- * @returns {T}
- */
-export function getContext(key) {
-	const context_map = get_or_init_context_map('getContext');
-	const result = /** @type {T} */ (context_map.get(key));
-	return result;
-}
-
-/**
- * Associates an arbitrary `context` object with the current component and the specified `key`
- * and returns that object. The context is then available to children of the component
- * (including slotted content) with `getContext`.
- *
- * Like lifecycle functions, this must be called during component initialisation.
- *
- * [`createContext`](https://svelte.dev/docs/svelte/svelte#createContext) is a type-safe alternative.
- *
- * @template T
- * @param {any} key
- * @param {T} context
- * @returns {T}
- */
-export function setContext(key, context) {
-	const context_map = get_or_init_context_map('setContext');
-
-	if (async_mode_flag) {
-		var flags = /** @type {Effect} */ (active_effect).f;
-		var valid =
-			!active_reaction &&
-			(flags & BRANCH_EFFECT) !== 0 &&
-			// pop() runs synchronously, so this indicates we're setting context after an await
-			!(/** @type {ComponentContext} */ (component_context).i);
-
-		if (!valid) {
-			e.set_context_after_init();
-		}
-	}
-
-	context_map.set(key, context);
-	return context;
-}
-
-/**
- * Checks whether a given `key` has been set in the context of a parent component.
- * Must be called during component initialisation.
- *
- * @param {any} key
- * @returns {boolean}
- */
-export function hasContext(key) {
-	const context_map = get_or_init_context_map('hasContext');
-	return context_map.has(key);
-}
-
-/**
- * Retrieves the whole context map that belongs to the closest parent component.
- * Must be called during component initialisation. Useful, for example, if you
- * programmatically create a component and want to pass the existing context to it.
- *
- * @template {Map<any, any>} [T=Map<any, any>]
- * @returns {T}
- */
-export function getAllContexts() {
-	const context_map = get_or_init_context_map('getAllContexts');
-	return /** @type {T} */ (context_map);
-}
-
-/**
- * @param {Record<string, unknown>} props
- * @param {any} runes
- * @param {Function} [fn]
- * @returns {void}
- */
-export function push(props, runes = false, fn) {
-	component_context = {
-		p: component_context,
-		i: false,
-		c: null,
-		e: null,
-		s: props,
-		x: null,
-		l: legacy_mode_flag && !runes ? { s: null, u: null, $: [] } : null
-	};
-
-	if (DEV) {
-		// component function
-		component_context.function = fn;
-		dev_current_component_function = fn;
-	}
-}
-
-/**
- * @template {Record<string, any>} T
- * @param {T} [component]
- * @returns {T}
- */
-export function pop(component) {
-	var context = /** @type {ComponentContext} */ (component_context);
-	var effects = context.e;
-
-	if (effects !== null) {
-		context.e = null;
-
-		for (var fn of effects) {
-			create_user_effect(fn);
-		}
-	}
-
-	if (component !== undefined) {
-		context.x = component;
-	}
-
-	context.i = true;
-
-	component_context = context.p;
-
-	if (DEV) {
-		dev_current_component_function = component_context?.function ?? null;
-	}
-
-	return component ?? /** @type {T} */ ({});
-}
-
-/** @returns {boolean} */
-export function is_runes() {
-	return !legacy_mode_flag || (component_context !== null && component_context.l === null);
-}
-
-/**
- * @param {string} name
- * @returns {Map<unknown, unknown>}
- */
-function get_or_init_context_map(name) {
-	if (component_context === null) {
-		e.lifecycle_outside_component(name);
-	}
-
-	return (component_context.c ??= new Map(get_parent_context(component_context) || undefined));
-}
-
-/**
- * @param {ComponentContext} component_context
- * @returns {Map<unknown, unknown> | null}
- */
-function get_parent_context(component_context) {
-	let parent = component_context.p;
-	while (parent !== null) {
-		const context_map = parent.c;
-		if (context_map !== null) {
-			return context_map;
-		}
-		parent = parent.p;
-	}
-	return null;
-}