lumen-plus 0.0.5 → 0.0.6

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

@@ -0,0 +1,115 @@
+/** @import { SSRContext } from '#server' */
+import { FILENAME } from '../../constants.js';
+import {
+	is_tag_valid_with_ancestor,
+	is_tag_valid_with_parent
+} from '../../html-tree-validation.js';
+import { get_stack } from '../shared/dev.js';
+import { set_ssr_context, ssr_context } from './context.js';
+import * as e from './errors.js';
+import { Renderer } from './renderer.js';
+
+// TODO move this
+/**
+ * @typedef {{
+ * 	tag: string;
+ * 	parent: undefined | Element;
+ *  filename: undefined | string;
+ *  line: number;
+ *  column: number;
+ * }} Element
+ */
+
+/**
+ * This is exported so that it can be cleared between tests
+ * @type {Set<string>}
+ */
+export let seen;
+
+/**
+ * @param {Renderer} renderer
+ * @param {string} message
+ */
+function print_error(renderer, message) {
+	message =
+		`node_invalid_placement_ssr: ${message}\n\n` +
+		'This can cause content to shift around as the browser repairs the HTML, and will likely result in a `hydration_mismatch` warning.';
+
+	if ((seen ??= new Set()).has(message)) return;
+	seen.add(message);
+
+	// eslint-disable-next-line no-console
+	console.error(message);
+	renderer.head((r) =>
+		r.push(
+			// ensure that `</script>` can't leak in to the script contents
+			`<script>console.error(${JSON.stringify(message).replaceAll('</', '<\\u002f')})</script>`
+		)
+	);
+}
+
+/**
+ * @param {Renderer} renderer
+ * @param {string} tag
+ * @param {number} line
+ * @param {number} column
+ */
+export function push_element(renderer, tag, line, column) {
+	var context = /** @type {SSRContext} */ (ssr_context);
+	var filename = context.function[FILENAME];
+	var parent = context.element;
+	var element = { tag, parent, filename, line, column };
+
+	if (parent !== undefined) {
+		var ancestor = parent.parent;
+		var ancestors = [parent.tag];
+
+		const child_loc = filename ? `${filename}:${line}:${column}` : undefined;
+		const parent_loc = parent.filename
+			? `${parent.filename}:${parent.line}:${parent.column}`
+			: undefined;
+
+		const message = is_tag_valid_with_parent(tag, parent.tag, child_loc, parent_loc);
+		if (message) print_error(renderer, message);
+
+		while (ancestor != null) {
+			ancestors.push(ancestor.tag);
+			const ancestor_loc = ancestor.filename
+				? `${ancestor.filename}:${ancestor.line}:${ancestor.column}`
+				: undefined;
+
+			const message = is_tag_valid_with_ancestor(tag, ancestors, child_loc, ancestor_loc);
+			if (message) print_error(renderer, message);
+
+			ancestor = ancestor.parent;
+		}
+	}
+
+	set_ssr_context({ ...context, p: context, element });
+}
+
+export function pop_element() {
+	set_ssr_context(/** @type {SSRContext} */ (ssr_context).p);
+}
+
+/**
+ * @param {Renderer} renderer
+ */
+export function validate_snippet_args(renderer) {
+	if (
+		typeof renderer !== 'object' ||
+		// for some reason typescript consider the type of renderer as never after the first instanceof
+		!(renderer instanceof Renderer)
+	) {
+		e.invalid_snippet_arguments();
+	}
+}
+
+export function get_user_code_location() {
+	const stack = get_stack();
+
+	return stack
+		.filter((line) => line.trim().startsWith('at '))
+		.map((line) => line.replace(/\((.*):\d+:\d+\)$/, (_, file) => `(${file})`))
+		.join('\n');
+}

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

@@ -0,0 +1,118 @@
+/* This file is generated by scripts/process-messages/index.js. Do not edit! */
+
+export *  from '../shared/errors.js';
+
+/**
+ * The node API `AsyncLocalStorage` is not available, but is required to use async server rendering.
+ * @returns {never}
+ */
+export function async_local_storage_unavailable() {
+	const error = new Error(`async_local_storage_unavailable\nThe node API \`AsyncLocalStorage\` is not available, but is required to use async server rendering.\nhttps://svelte.dev/e/async_local_storage_unavailable`);
+
+	error.name = 'Svelte error';
+
+	throw error;
+}
+
+/**
+ * Encountered asynchronous work while rendering synchronously.
+ * @returns {never}
+ */
+export function await_invalid() {
+	const error = new Error(`await_invalid\nEncountered asynchronous work while rendering synchronously.\nhttps://svelte.dev/e/await_invalid`);
+
+	error.name = 'Svelte error';
+
+	throw error;
+}
+
+/**
+ * The `html` property of server render results has been deprecated. Use `body` instead.
+ * @returns {never}
+ */
+export function html_deprecated() {
+	const error = new Error(`html_deprecated\nThe \`html\` property of server render results has been deprecated. Use \`body\` instead.\nhttps://svelte.dev/e/html_deprecated`);
+
+	error.name = 'Svelte error';
+
+	throw error;
+}
+
+/**
+ * Attempted to set `hydratable` with key `%key%` twice with different values.
+ * 
+ * %stack%
+ * @param {string} key
+ * @param {string} stack
+ * @returns {never}
+ */
+export function hydratable_clobbering(key, stack) {
+	const error = new Error(`hydratable_clobbering\nAttempted to set \`hydratable\` with key \`${key}\` twice with different values.
+
+${stack}\nhttps://svelte.dev/e/hydratable_clobbering`);
+
+	error.name = 'Svelte error';
+
+	throw error;
+}
+
+/**
+ * Failed to serialize `hydratable` data for key `%key%`.
+ * 
+ * `hydratable` can serialize anything [`uneval` from `devalue`](https://npmjs.com/package/uneval) can, plus Promises.
+ * 
+ * Cause:
+ * %stack%
+ * @param {string} key
+ * @param {string} stack
+ * @returns {never}
+ */
+export function hydratable_serialization_failed(key, stack) {
+	const error = new Error(`hydratable_serialization_failed\nFailed to serialize \`hydratable\` data for key \`${key}\`.
+
+\`hydratable\` can serialize anything [\`uneval\` from \`devalue\`](https://npmjs.com/package/uneval) can, plus Promises.
+
+Cause:
+${stack}\nhttps://svelte.dev/e/hydratable_serialization_failed`);
+
+	error.name = 'Svelte error';
+
+	throw error;
+}
+
+/**
+ * `csp.nonce` was set while `csp.hash` was `true`. These options cannot be used simultaneously.
+ * @returns {never}
+ */
+export function invalid_csp() {
+	const error = new Error(`invalid_csp\n\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.\nhttps://svelte.dev/e/invalid_csp`);
+
+	error.name = 'Svelte error';
+
+	throw error;
+}
+
+/**
+ * `%name%(...)` is not available on the server
+ * @param {string} name
+ * @returns {never}
+ */
+export function lifecycle_function_unavailable(name) {
+	const error = new Error(`lifecycle_function_unavailable\n\`${name}(...)\` is not available on the server\nhttps://svelte.dev/e/lifecycle_function_unavailable`);
+
+	error.name = 'Svelte error';
+
+	throw error;
+}
+
+/**
+ * Could not resolve `render` context.
+ * @returns {never}
+ */
+export function server_context_required() {
+	const error = new Error(`server_context_required\nCould not resolve \`render\` context.\nhttps://svelte.dev/e/server_context_required`);
+
+	error.name = 'Svelte error';
+
+	throw error;
+}

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

@@ -0,0 +1,142 @@
+/** @import { HydratableLookupEntry } from '#server' */
+import { async_mode_flag } from '../flags/index.js';
+import { get_render_context } from './render-context.js';
+import * as e from './errors.js';
+import * as devalue from 'devalue';
+import { get_stack } from '../shared/dev.js';
+import { DEV } from 'esm-env';
+import { get_user_code_location } from './dev.js';
+
+/**
+ * @template T
+ * @param {string} key
+ * @param {() => T} fn
+ * @returns {T}
+ */
+export function hydratable(key, fn) {
+	if (!async_mode_flag) {
+		e.experimental_async_required('hydratable');
+	}
+
+	const { hydratable } = get_render_context();
+
+	let entry = hydratable.lookup.get(key);
+
+	if (entry !== undefined) {
+		if (DEV) {
+			const comparison = compare(key, entry, encode(key, fn()));
+			comparison.catch(() => {});
+			hydratable.comparisons.push(comparison);
+		}
+
+		return /** @type {T} */ (entry.value);
+	}
+
+	const value = fn();
+
+	entry = encode(key, value, hydratable.unresolved_promises);
+	hydratable.lookup.set(key, entry);
+
+	return value;
+}
+
+/**
+ * @param {string} key
+ * @param {any} value
+ * @param {Map<Promise<any>, string>} [unresolved]
+ */
+function encode(key, value, unresolved) {
+	/** @type {HydratableLookupEntry} */
+	const entry = { value, serialized: '' };
+
+	if (DEV) {
+		entry.stack = get_user_code_location();
+	}
+
+	let uid = 1;
+
+	entry.serialized = devalue.uneval(entry.value, (value, uneval) => {
+		if (is_promise(value)) {
+			// we serialize promises as `"${i}"`, because it's impossible for that string
+			// to occur 'naturally' (since the quote marks would have to be escaped)
+			// this placeholder is returned synchronously from `uneval`, which includes it in the
+			// serialized string. Later (at least one microtask from now), when `p.then` runs, it'll
+			// be replaced.
+			const placeholder = `"${uid++}"`;
+			const p = value
+				.then((v) => {
+					entry.serialized = entry.serialized.replace(placeholder, `r(${uneval(v)})`);
+				})
+				.catch((devalue_error) =>
+					e.hydratable_serialization_failed(
+						key,
+						serialization_stack(entry.stack, devalue_error?.stack)
+					)
+				);
+
+			unresolved?.set(p, key);
+			// prevent unhandled rejections from crashing the server, track which promises are still resolving when render is complete
+			p.catch(() => {}).finally(() => unresolved?.delete(p));
+
+			(entry.promises ??= []).push(p);
+			return placeholder;
+		}
+	});
+
+	return entry;
+}
+
+/**
+ * @param {any} value
+ * @returns {value is Promise<any>}
+ */
+function is_promise(value) {
+	// we use this check rather than `instanceof Promise`
+	// because it works cross-realm
+	return Object.prototype.toString.call(value) === '[object Promise]';
+}
+
+/**
+ * @param {string} key
+ * @param {HydratableLookupEntry} a
+ * @param {HydratableLookupEntry} b
+ */
+async function compare(key, a, b) {
+	// note: these need to be loops (as opposed to Promise.all) because
+	// additional promises can get pushed to them while we're awaiting
+	// an earlier one
+	for (const p of a?.promises ?? []) {
+		await p;
+	}
+
+	for (const p of b?.promises ?? []) {
+		await p;
+	}
+
+	if (a.serialized !== b.serialized) {
+		const a_stack = /** @type {string} */ (a.stack);
+		const b_stack = /** @type {string} */ (b.stack);
+
+		const stack =
+			a_stack === b_stack
+				? `Occurred at:\n${a_stack}`
+				: `First occurrence at:\n${a_stack}\n\nSecond occurrence at:\n${b_stack}`;
+
+		e.hydratable_clobbering(key, stack);
+	}
+}
+
+/**
+ * @param {string | undefined} root_stack
+ * @param {string | undefined} uneval_stack
+ */
+function serialization_stack(root_stack, uneval_stack) {
+	let out = '';
+	if (root_stack) {
+		out += root_stack + '\n';
+	}
+	if (uneval_stack) {
+		out += 'Caused by:\n' + uneval_stack + '\n';
+	}
+	return out || '<missing stack trace>';
+}

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

@@ -0,0 +1,6 @@
+import { HYDRATION_END, HYDRATION_START, HYDRATION_START_ELSE } from '../../constants.js';
+
+export const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
+export const BLOCK_OPEN_ELSE = `<!--${HYDRATION_START_ELSE}-->`;
+export const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
+export const EMPTY_COMMENT = `<!---->`;