lumen-plus 0.0.5 → 0.0.7

package/dist/utils/node_modules/svelte/src/internal/server/warnings.js

@@ -0,0 +1,29 @@
+/* This file is generated by scripts/process-messages/index.js. Do not edit! */
+
+import { DEV } from 'esm-env';
+
+var bold = 'font-weight: bold';
+var normal = 'font-weight: normal';
+
+/**
+ * A `hydratable` value with key `%key%` was created, but at least part of it was not used during the render.
+ * 
+ * The `hydratable` was initialized in:
+ * %stack%
+ * @param {string} key
+ * @param {string} stack
+ */
+export function unresolved_hydratable(key, stack) {
+	if (DEV) {
+		console.warn(
+			`%c[svelte] unresolved_hydratable\n%cA \`hydratable\` value with key \`${key}\` was created, but at least part of it was not used during the render.
+
+The \`hydratable\` was initialized in:
+${stack}\nhttps://svelte.dev/e/unresolved_hydratable`,
+			bold,
+			normal
+		);
+	} else {
+		console.warn(`https://svelte.dev/e/unresolved_hydratable`);
+	}
+}

package/dist/utils/node_modules/svelte/src/internal/shared/attributes.js

@@ -0,0 +1,223 @@
+import { escape_html } from '../../escaping.js';
+import { clsx as _clsx } from 'clsx';
+
+/**
+ * `<div translate={false}>` should be rendered as `<div translate="no">` and _not_
+ * `<div translate="false">`, which is equivalent to `<div translate="yes">`. There
+ * may be other odd cases that need to be added to this list in future
+ * @type {Record<string, Map<any, string>>}
+ */
+const replacements = {
+	translate: new Map([
+		[true, 'yes'],
+		[false, 'no']
+	])
+};
+
+/**
+ * @template V
+ * @param {string} name
+ * @param {V} value
+ * @param {boolean} [is_boolean]
+ * @returns {string}
+ */
+export function attr(name, value, is_boolean = false) {
+	// attribute hidden for values other than "until-found" behaves like a boolean attribute
+	if (name === 'hidden' && value !== 'until-found') {
+		is_boolean = true;
+	}
+	if (value == null || (!value && is_boolean)) return '';
+	const normalized = (name in replacements && replacements[name].get(value)) || value;
+	const assignment = is_boolean ? '' : `="${escape_html(normalized, true)}"`;
+	return ` ${name}${assignment}`;
+}
+
+/**
+ * Small wrapper around clsx to preserve Svelte's (weird) handling of falsy values.
+ * TODO Svelte 6 revisit this, and likely turn all falsy values into the empty string (what clsx also does)
+ * @param  {any} value
+ */
+export function clsx(value) {
+	if (typeof value === 'object') {
+		return _clsx(value);
+	} else {
+		return value ?? '';
+	}
+}
+
+const whitespace = [...' \t\n\r\f\u00a0\u000b\ufeff'];
+
+/**
+ * @param {any} value
+ * @param {string | null} [hash]
+ * @param {Record<string, boolean>} [directives]
+ * @returns {string | null}
+ */
+export function to_class(value, hash, directives) {
+	var classname = value == null ? '' : '' + value;
+
+	if (hash) {
+		classname = classname ? classname + ' ' + hash : hash;
+	}
+
+	if (directives) {
+		for (var key in directives) {
+			if (directives[key]) {
+				classname = classname ? classname + ' ' + key : key;
+			} else if (classname.length) {
+				var len = key.length;
+				var a = 0;
+
+				while ((a = classname.indexOf(key, a)) >= 0) {
+					var b = a + len;
+
+					if (
+						(a === 0 || whitespace.includes(classname[a - 1])) &&
+						(b === classname.length || whitespace.includes(classname[b]))
+					) {
+						classname = (a === 0 ? '' : classname.substring(0, a)) + classname.substring(b + 1);
+					} else {
+						a = b;
+					}
+				}
+			}
+		}
+	}
+
+	return classname === '' ? null : classname;
+}
+
+/**
+ *
+ * @param {Record<string,any>} styles
+ * @param {boolean} important
+ */
+function append_styles(styles, important = false) {
+	var separator = important ? ' !important;' : ';';
+	var css = '';
+
+	for (var key in styles) {
+		var value = styles[key];
+		if (value != null && value !== '') {
+			css += ' ' + key + ': ' + value + separator;
+		}
+	}
+
+	return css;
+}
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+function to_css_name(name) {
+	if (name[0] !== '-' || name[1] !== '-') {
+		return name.toLowerCase();
+	}
+	return name;
+}
+
+/**
+ * @param {any} value
+ * @param {Record<string, any> | [Record<string, any>, Record<string, any>]} [styles]
+ * @returns {string | null}
+ */
+export function to_style(value, styles) {
+	if (styles) {
+		var new_style = '';
+
+		/** @type {Record<string,any> | undefined} */
+		var normal_styles;
+
+		/** @type {Record<string,any> | undefined} */
+		var important_styles;
+
+		if (Array.isArray(styles)) {
+			normal_styles = styles[0];
+			important_styles = styles[1];
+		} else {
+			normal_styles = styles;
+		}
+
+		if (value) {
+			value = String(value)
+				.replaceAll(/\s*\/\*.*?\*\/\s*/g, '')
+				.trim();
+
+			/** @type {boolean | '"' | "'"} */
+			var in_str = false;
+			var in_apo = 0;
+			var in_comment = false;
+
+			var reserved_names = [];
+
+			if (normal_styles) {
+				reserved_names.push(...Object.keys(normal_styles).map(to_css_name));
+			}
+			if (important_styles) {
+				reserved_names.push(...Object.keys(important_styles).map(to_css_name));
+			}
+
+			var start_index = 0;
+			var name_index = -1;
+
+			const len = value.length;
+			for (var i = 0; i < len; i++) {
+				var c = value[i];
+
+				if (in_comment) {
+					if (c === '/' && value[i - 1] === '*') {
+						in_comment = false;
+					}
+				} else if (in_str) {
+					if (in_str === c) {
+						in_str = false;
+					}
+				} else if (c === '/' && value[i + 1] === '*') {
+					in_comment = true;
+				} else if (c === '"' || c === "'") {
+					in_str = c;
+				} else if (c === '(') {
+					in_apo++;
+				} else if (c === ')') {
+					in_apo--;
+				}
+
+				if (!in_comment && in_str === false && in_apo === 0) {
+					if (c === ':' && name_index === -1) {
+						name_index = i;
+					} else if (c === ';' || i === len - 1) {
+						if (name_index !== -1) {
+							var name = to_css_name(value.substring(start_index, name_index).trim());
+
+							if (!reserved_names.includes(name)) {
+								if (c !== ';') {
+									i++;
+								}
+
+								var property = value.substring(start_index, i).trim();
+								new_style += ' ' + property + ';';
+							}
+						}
+
+						start_index = i + 1;
+						name_index = -1;
+					}
+				}
+			}
+		}
+
+		if (normal_styles) {
+			new_style += append_styles(normal_styles);
+		}
+
+		if (important_styles) {
+			new_style += append_styles(important_styles, true);
+		}
+
+		new_style = new_style.trim();
+		return new_style === '' ? null : new_style;
+	}
+
+	return value == null ? null : String(value);
+}

package/dist/utils/node_modules/svelte/src/internal/shared/clone.js

@@ -0,0 +1,137 @@
+/** @import { Snapshot } from './types' */
+import { DEV } from 'esm-env';
+import * as w from './warnings.js';
+import { get_prototype_of, is_array, object_prototype } from './utils.js';
+
+/**
+ * In dev, we keep track of which properties could not be cloned. In prod
+ * we don't bother, but we keep a dummy array around so that the
+ * signature stays the same
+ * @type {string[]}
+ */
+const empty = [];
+
+/**
+ * @template T
+ * @param {T} value
+ * @param {boolean} [skip_warning]
+ * @param {boolean} [no_tojson]
+ * @returns {Snapshot<T>}
+ */
+export function snapshot(value, skip_warning = false, no_tojson = false) {
+	if (DEV && !skip_warning) {
+		/** @type {string[]} */
+		const paths = [];
+
+		const copy = clone(value, new Map(), '', paths, null, no_tojson);
+		if (paths.length === 1 && paths[0] === '') {
+			// value could not be cloned
+			w.state_snapshot_uncloneable();
+		} else if (paths.length > 0) {
+			// some properties could not be cloned
+			const slice = paths.length > 10 ? paths.slice(0, 7) : paths.slice(0, 10);
+			const excess = paths.length - slice.length;
+
+			let uncloned = slice.map((path) => `- <value>${path}`).join('\n');
+			if (excess > 0) uncloned += `\n- ...and ${excess} more`;
+
+			w.state_snapshot_uncloneable(uncloned);
+		}
+
+		return copy;
+	}
+
+	return clone(value, new Map(), '', empty, null, no_tojson);
+}
+
+/**
+ * @template T
+ * @param {T} value
+ * @param {Map<T, Snapshot<T>>} cloned
+ * @param {string} path
+ * @param {string[]} paths
+ * @param {null | T} [original] The original value, if `value` was produced from a `toJSON` call
+ * @param {boolean} [no_tojson]
+ * @returns {Snapshot<T>}
+ */
+function clone(value, cloned, path, paths, original = null, no_tojson = false) {
+	if (typeof value === 'object' && value !== null) {
+		var unwrapped = cloned.get(value);
+		if (unwrapped !== undefined) return unwrapped;
+
+		if (value instanceof Map) return /** @type {Snapshot<T>} */ (new Map(value));
+		if (value instanceof Set) return /** @type {Snapshot<T>} */ (new Set(value));
+
+		if (is_array(value)) {
+			var copy = /** @type {Snapshot<any>} */ (Array(value.length));
+			cloned.set(value, copy);
+
+			if (original !== null) {
+				cloned.set(original, copy);
+			}
+
+			for (var i = 0; i < value.length; i += 1) {
+				var element = value[i];
+				if (i in value) {
+					copy[i] = clone(element, cloned, DEV ? `${path}[${i}]` : path, paths, null, no_tojson);
+				}
+			}
+
+			return copy;
+		}
+
+		if (get_prototype_of(value) === object_prototype) {
+			/** @type {Snapshot<any>} */
+			copy = {};
+			cloned.set(value, copy);
+
+			if (original !== null) {
+				cloned.set(original, copy);
+			}
+
+			for (var key in value) {
+				copy[key] = clone(
+					// @ts-expect-error
+					value[key],
+					cloned,
+					DEV ? `${path}.${key}` : path,
+					paths,
+					null,
+					no_tojson
+				);
+			}
+
+			return copy;
+		}
+
+		if (value instanceof Date) {
+			return /** @type {Snapshot<T>} */ (structuredClone(value));
+		}
+
+		if (typeof (/** @type {T & { toJSON?: any } } */ (value).toJSON) === 'function' && !no_tojson) {
+			return clone(
+				/** @type {T & { toJSON(): any } } */ (value).toJSON(),
+				cloned,
+				DEV ? `${path}.toJSON()` : path,
+				paths,
+				// Associate the instance with the toJSON clone
+				value
+			);
+		}
+	}
+
+	if (value instanceof EventTarget) {
+		// can't be cloned
+		return /** @type {Snapshot<T>} */ (value);
+	}
+
+	try {
+		return /** @type {Snapshot<T>} */ (structuredClone(value));
+	} catch (e) {
+		if (DEV) {
+			paths.push(path);
+		}
+
+		return /** @type {Snapshot<T>} */ (value);
+	}
+}

package/dist/utils/node_modules/svelte/src/internal/shared/dev.js

@@ -0,0 +1,65 @@
+import { define_property } from './utils.js';
+
+/**
+ * @param {string} label
+ * @returns {Error & { stack: string } | null}
+ */
+export function get_error(label) {
+	const error = new Error();
+	const stack = get_stack();
+
+	if (stack.length === 0) {
+		return null;
+	}
+
+	stack.unshift('\n');
+
+	define_property(error, 'stack', {
+		value: stack.join('\n')
+	});
+
+	define_property(error, 'name', {
+		value: label
+	});
+
+	return /** @type {Error & { stack: string }} */ (error);
+}
+
+/**
+ * @returns {string[]}
+ */
+export function get_stack() {
+	// @ts-ignore - doesn't exist everywhere
+	const limit = Error.stackTraceLimit;
+	// @ts-ignore - doesn't exist everywhere
+	Error.stackTraceLimit = Infinity;
+	const stack = new Error().stack;
+	// @ts-ignore - doesn't exist everywhere
+	Error.stackTraceLimit = limit;
+
+	if (!stack) return [];
+
+	const lines = stack.split('\n');
+	const new_lines = [];
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const posixified = line.replaceAll('\\', '/');
+
+		if (line.trim() === 'Error') {
+			continue;
+		}
+
+		if (line.includes('validate_each_keys')) {
+			return [];
+		}
+
+		if (posixified.includes('svelte/src/internal') || posixified.includes('node_modules/.vite')) {
+			continue;
+		}
+
+		new_lines.push(line);
+	}
+
+	return new_lines;
+}

package/dist/utils/node_modules/svelte/src/internal/shared/errors.js

@@ -0,0 +1,134 @@
+/* This file is generated by scripts/process-messages/index.js. Do not edit! */
+
+import { DEV } from 'esm-env';
+
+/**
+ * Cannot use `%name%(...)` unless the `experimental.async` compiler option is `true`
+ * @param {string} name
+ * @returns {never}
+ */
+export function experimental_async_required(name) {
+	if (DEV) {
+		const error = new Error(`experimental_async_required\nCannot use \`${name}(...)\` unless the \`experimental.async\` compiler option is \`true\`\nhttps://svelte.dev/e/experimental_async_required`);
+
+		error.name = 'Svelte error';
+
+		throw error;
+	} else {
+		throw new Error(`https://svelte.dev/e/experimental_async_required`);
+	}
+}
+
+/**
+ * Cannot use `{@render children(...)}` if the parent component uses `let:` directives. Consider using a named snippet instead
+ * @returns {never}
+ */
+export function invalid_default_snippet() {
+	if (DEV) {
+		const error = new Error(`invalid_default_snippet\nCannot use \`{@render children(...)}\` if the parent component uses \`let:\` directives. Consider using a named snippet instead\nhttps://svelte.dev/e/invalid_default_snippet`);
+
+		error.name = 'Svelte error';
+
+		throw error;
+	} else {
+		throw new Error(`https://svelte.dev/e/invalid_default_snippet`);
+	}
+}
+
+/**
+ * A snippet function was passed invalid arguments. Snippets should only be instantiated via `{@render ...}`
+ * @returns {never}
+ */
+export function invalid_snippet_arguments() {
+	if (DEV) {
+		const error = new Error(`invalid_snippet_arguments\nA snippet function was passed invalid arguments. Snippets should only be instantiated via \`{@render ...}\`\nhttps://svelte.dev/e/invalid_snippet_arguments`);
+
+		error.name = 'Svelte error';
+
+		throw error;
+	} else {
+		throw new Error(`https://svelte.dev/e/invalid_snippet_arguments`);
+	}
+}
+
+/**
+ * `%name%(...)` can only be used during component initialisation
+ * @param {string} name
+ * @returns {never}
+ */
+export function lifecycle_outside_component(name) {
+	if (DEV) {
+		const error = new Error(`lifecycle_outside_component\n\`${name}(...)\` can only be used during component initialisation\nhttps://svelte.dev/e/lifecycle_outside_component`);
+
+		error.name = 'Svelte error';
+
+		throw error;
+	} else {
+		throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
+	}
+}
+
+/**
+ * Context was not set in a parent component
+ * @returns {never}
+ */
+export function missing_context() {
+	if (DEV) {
+		const error = new Error(`missing_context\nContext was not set in a parent component\nhttps://svelte.dev/e/missing_context`);
+
+		error.name = 'Svelte error';
+
+		throw error;
+	} else {
+		throw new Error(`https://svelte.dev/e/missing_context`);
+	}
+}
+
+/**
+ * Attempted to render a snippet without a `{@render}` block. This would cause the snippet code to be stringified instead of its content being rendered to the DOM. To fix this, change `{snippet}` to `{@render snippet()}`.
+ * @returns {never}
+ */
+export function snippet_without_render_tag() {
+	if (DEV) {
+		const error = new Error(`snippet_without_render_tag\nAttempted to render a snippet without a \`{@render}\` block. This would cause the snippet code to be stringified instead of its content being rendered to the DOM. To fix this, change \`{snippet}\` to \`{@render snippet()}\`.\nhttps://svelte.dev/e/snippet_without_render_tag`);
+
+		error.name = 'Svelte error';
+
+		throw error;
+	} else {
+		throw new Error(`https://svelte.dev/e/snippet_without_render_tag`);
+	}
+}
+
+/**
+ * `%name%` is not a store with a `subscribe` method
+ * @param {string} name
+ * @returns {never}
+ */
+export function store_invalid_shape(name) {
+	if (DEV) {
+		const error = new Error(`store_invalid_shape\n\`${name}\` is not a store with a \`subscribe\` method\nhttps://svelte.dev/e/store_invalid_shape`);
+
+		error.name = 'Svelte error';
+
+		throw error;
+	} else {
+		throw new Error(`https://svelte.dev/e/store_invalid_shape`);
+	}
+}
+
+/**
+ * The `this` prop on `<svelte:element>` must be a string, if defined
+ * @returns {never}
+ */
+export function svelte_element_invalid_this_value() {
+	if (DEV) {
+		const error = new Error(`svelte_element_invalid_this_value\nThe \`this\` prop on \`<svelte:element>\` must be a string, if defined\nhttps://svelte.dev/e/svelte_element_invalid_this_value`);
+
+		error.name = 'Svelte error';
+
+		throw error;
+	} else {
+		throw new Error(`https://svelte.dev/e/svelte_element_invalid_this_value`);
+	}
+}

package/dist/utils/node_modules/svelte/src/internal/shared/utils.js

@@ -0,0 +1,118 @@
+// Store the references to globals in case someone tries to monkey patch these, causing the below
+// to de-opt (this occurs often when using popular extensions).
+export var is_array = Array.isArray;
+export var index_of = Array.prototype.indexOf;
+export var array_from = Array.from;
+export var object_keys = Object.keys;
+export var define_property = Object.defineProperty;
+export var get_descriptor = Object.getOwnPropertyDescriptor;
+export var get_descriptors = Object.getOwnPropertyDescriptors;
+export var object_prototype = Object.prototype;
+export var array_prototype = Array.prototype;
+export var get_prototype_of = Object.getPrototypeOf;
+export var is_extensible = Object.isExtensible;
+
+/**
+ * @param {any} thing
+ * @returns {thing is Function}
+ */
+export function is_function(thing) {
+	return typeof thing === 'function';
+}
+
+export const noop = () => {};
+
+// Adapted from https://github.com/then/is-promise/blob/master/index.js
+// Distributed under MIT License https://github.com/then/is-promise/blob/master/LICENSE
+
+/**
+ * @template [T=any]
+ * @param {any} value
+ * @returns {value is PromiseLike<T>}
+ */
+export function is_promise(value) {
+	return typeof value?.then === 'function';
+}
+
+/** @param {Function} fn */
+export function run(fn) {
+	return fn();
+}
+
+/** @param {Array<() => void>} arr */
+export function run_all(arr) {
+	for (var i = 0; i < arr.length; i++) {
+		arr[i]();
+	}
+}
+
+/**
+ * TODO replace with Promise.withResolvers once supported widely enough
+ * @template [T=void]
+ */
+export function deferred() {
+	/** @type {(value: T) => void} */
+	var resolve;
+
+	/** @type {(reason: any) => void} */
+	var reject;
+
+	/** @type {Promise<T>} */
+	var promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+
+	// @ts-expect-error
+	return { promise, resolve, reject };
+}
+
+/**
+ * @template V
+ * @param {V} value
+ * @param {V | (() => V)} fallback
+ * @param {boolean} [lazy]
+ * @returns {V}
+ */
+export function fallback(value, fallback, lazy = false) {
+	return value === undefined
+		? lazy
+			? /** @type {() => V} */ (fallback)()
+			: /** @type {V} */ (fallback)
+		: value;
+}
+
+/**
+ * When encountering a situation like `let [a, b, c] = $derived(blah())`,
+ * we need to stash an intermediate value that `a`, `b`, and `c` derive
+ * from, in case it's an iterable
+ * @template T
+ * @param {ArrayLike<T> | Iterable<T>} value
+ * @param {number} [n]
+ * @returns {Array<T>}
+ */
+export function to_array(value, n) {
+	// return arrays unchanged
+	if (Array.isArray(value)) {
+		return value;
+	}
+
+	// if value is not iterable, or `n` is unspecified (indicates a rest
+	// element, which means we're not concerned about unbounded iterables)
+	// convert to an array with `Array.from`
+	if (n === undefined || !(Symbol.iterator in value)) {
+		return Array.from(value);
+	}
+
+	// otherwise, populate an array with `n` values
+
+	/** @type {T[]} */
+	const array = [];
+
+	for (const element of value) {
+		array.push(element);
+		if (array.length === n) break;
+	}
+
+	return array;
+}