@depup/svelte 5.53.3-depup.0

package/src/internal/client/timing.js

@@ -0,0 +1,16 @@
+/** @import { Raf } from '#client' */
+import { noop } from '../shared/utils.js';
+
+import { BROWSER } from 'esm-env';
+
+const now = BROWSER ? () => performance.now() : () => Date.now();
+
+/** @type {Raf} */
+export const raf = {
+	// don't access requestAnimationFrame eagerly outside method
+	// this allows basic testing of user code without JSDOM
+	// bunder will eval and remove ternary when the user's app is built
+	tick: /** @param {any} _ */ (_) => (BROWSER ? requestAnimationFrame : noop)(_),
+	now: () => now(),
+	tasks: new Set()
+};

package/src/internal/client/validate.js

@@ -0,0 +1,54 @@
+/** @import { Blocker } from '#client' */
+import { dev_current_component_function } from './context.js';
+import { FILENAME } from '../../constants.js';
+import { render_effect } from './reactivity/effects.js';
+import * as w from './warnings.js';
+import { capture_store_binding } from './reactivity/store.js';
+import { run_after_blockers } from './reactivity/async.js';
+
+/**
+ * @param {string} binding
+ * @param {Blocker[]} blockers
+ * @param {() => Record<string, any>} get_object
+ * @param {() => string} get_property
+ * @param {number} line
+ * @param {number} column
+ */
+export function validate_binding(binding, blockers, get_object, get_property, line, column) {
+	run_after_blockers(blockers, () => {
+		var warned = false;
+
+		var filename = dev_current_component_function?.[FILENAME];
+
+		render_effect(() => {
+			if (warned) return;
+
+			var [object, is_store_sub] = capture_store_binding(get_object);
+
+			if (is_store_sub) return;
+
+			var property = get_property();
+
+			var ran = false;
+
+			// by making the (possibly false, but it would be an extreme edge case) assumption
+			// that a getter has a corresponding setter, we can determine if a property is
+			// reactive by seeing if this effect has dependencies
+			var effect = render_effect(() => {
+				if (ran) return;
+
+				// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+				object[property];
+			});
+
+			ran = true;
+
+			if (effect.deps === null) {
+				var location = `${filename}:${line}:${column}`;
+				w.binding_property_non_reactive(binding, location);
+
+				warned = true;
+			}
+		});
+	});
+}

package/src/internal/client/warnings.js

@@ -0,0 +1,271 @@
+/* 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';
+
+/**
+ * Assignment to `%property%` property (%location%) will evaluate to the right-hand side, not the value of `%property%` following the assignment. This may result in unexpected behaviour.
+ * @param {string} property
+ * @param {string} location
+ */
+export function assignment_value_stale(property, location) {
+	if (DEV) {
+		console.warn(`%c[svelte] assignment_value_stale\n%cAssignment to \`${property}\` property (${location}) will evaluate to the right-hand side, not the value of \`${property}\` following the assignment. This may result in unexpected behaviour.\nhttps://svelte.dev/e/assignment_value_stale`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/assignment_value_stale`);
+	}
+}
+
+/**
+ * Detected reactivity loss when reading `%name%`. This happens when state is read in an async function after an earlier `await`
+ * @param {string} name
+ */
+export function await_reactivity_loss(name) {
+	if (DEV) {
+		console.warn(`%c[svelte] await_reactivity_loss\n%cDetected reactivity loss when reading \`${name}\`. This happens when state is read in an async function after an earlier \`await\`\nhttps://svelte.dev/e/await_reactivity_loss`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/await_reactivity_loss`);
+	}
+}
+
+/**
+ * An async derived, `%name%` (%location%) was not read immediately after it resolved. This often indicates an unnecessary waterfall, which can slow down your app
+ * @param {string} name
+ * @param {string} location
+ */
+export function await_waterfall(name, location) {
+	if (DEV) {
+		console.warn(`%c[svelte] await_waterfall\n%cAn async derived, \`${name}\` (${location}) was not read immediately after it resolved. This often indicates an unnecessary waterfall, which can slow down your app\nhttps://svelte.dev/e/await_waterfall`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/await_waterfall`);
+	}
+}
+
+/**
+ * `%binding%` (%location%) is binding to a non-reactive property
+ * @param {string} binding
+ * @param {string | undefined | null} [location]
+ */
+export function binding_property_non_reactive(binding, location) {
+	if (DEV) {
+		console.warn(
+			`%c[svelte] binding_property_non_reactive\n%c${location
+				? `\`${binding}\` (${location}) is binding to a non-reactive property`
+				: `\`${binding}\` is binding to a non-reactive property`}\nhttps://svelte.dev/e/binding_property_non_reactive`,
+			bold,
+			normal
+		);
+	} else {
+		console.warn(`https://svelte.dev/e/binding_property_non_reactive`);
+	}
+}
+
+/**
+ * Your `console.%method%` contained `$state` proxies. Consider using `$inspect(...)` or `$state.snapshot(...)` instead
+ * @param {string} method
+ */
+export function console_log_state(method) {
+	if (DEV) {
+		console.warn(`%c[svelte] console_log_state\n%cYour \`console.${method}\` contained \`$state\` proxies. Consider using \`$inspect(...)\` or \`$state.snapshot(...)\` instead\nhttps://svelte.dev/e/console_log_state`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/console_log_state`);
+	}
+}
+
+/**
+ * %handler% should be a function. Did you mean to %suggestion%?
+ * @param {string} handler
+ * @param {string} suggestion
+ */
+export function event_handler_invalid(handler, suggestion) {
+	if (DEV) {
+		console.warn(`%c[svelte] event_handler_invalid\n%c${handler} should be a function. Did you mean to ${suggestion}?\nhttps://svelte.dev/e/event_handler_invalid`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/event_handler_invalid`);
+	}
+}
+
+/**
+ * Expected to find a hydratable with key `%key%` during hydration, but did not.
+ * @param {string} key
+ */
+export function hydratable_missing_but_expected(key) {
+	if (DEV) {
+		console.warn(`%c[svelte] hydratable_missing_but_expected\n%cExpected to find a hydratable with key \`${key}\` during hydration, but did not.\nhttps://svelte.dev/e/hydratable_missing_but_expected`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/hydratable_missing_but_expected`);
+	}
+}
+
+/**
+ * The `%attribute%` attribute on `%html%` changed its value between server and client renders. The client value, `%value%`, will be ignored in favour of the server value
+ * @param {string} attribute
+ * @param {string} html
+ * @param {string} value
+ */
+export function hydration_attribute_changed(attribute, html, value) {
+	if (DEV) {
+		console.warn(`%c[svelte] hydration_attribute_changed\n%cThe \`${attribute}\` attribute on \`${html}\` changed its value between server and client renders. The client value, \`${value}\`, will be ignored in favour of the server value\nhttps://svelte.dev/e/hydration_attribute_changed`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/hydration_attribute_changed`);
+	}
+}
+
+/**
+ * The value of an `{@html ...}` block %location% changed between server and client renders. The client value will be ignored in favour of the server value
+ * @param {string | undefined | null} [location]
+ */
+export function hydration_html_changed(location) {
+	if (DEV) {
+		console.warn(
+			`%c[svelte] hydration_html_changed\n%c${location
+				? `The value of an \`{@html ...}\` block ${location} changed between server and client renders. The client value will be ignored in favour of the server value`
+				: 'The value of an `{@html ...}` block changed between server and client renders. The client value will be ignored in favour of the server value'}\nhttps://svelte.dev/e/hydration_html_changed`,
+			bold,
+			normal
+		);
+	} else {
+		console.warn(`https://svelte.dev/e/hydration_html_changed`);
+	}
+}
+
+/**
+ * Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near %location%
+ * @param {string | undefined | null} [location]
+ */
+export function hydration_mismatch(location) {
+	if (DEV) {
+		console.warn(
+			`%c[svelte] hydration_mismatch\n%c${location
+				? `Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near ${location}`
+				: 'Hydration failed because the initial UI does not match what was rendered on the server'}\nhttps://svelte.dev/e/hydration_mismatch`,
+			bold,
+			normal
+		);
+	} else {
+		console.warn(`https://svelte.dev/e/hydration_mismatch`);
+	}
+}
+
+/**
+ * The `render` function passed to `createRawSnippet` should return HTML for a single element
+ */
+export function invalid_raw_snippet_render() {
+	if (DEV) {
+		console.warn(`%c[svelte] invalid_raw_snippet_render\n%cThe \`render\` function passed to \`createRawSnippet\` should return HTML for a single element\nhttps://svelte.dev/e/invalid_raw_snippet_render`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/invalid_raw_snippet_render`);
+	}
+}
+
+/**
+ * Detected a migrated `$:` reactive block in `%filename%` that both accesses and updates the same reactive value. This may cause recursive updates when converted to an `$effect`.
+ * @param {string} filename
+ */
+export function legacy_recursive_reactive_block(filename) {
+	if (DEV) {
+		console.warn(`%c[svelte] legacy_recursive_reactive_block\n%cDetected a migrated \`$:\` reactive block in \`${filename}\` that both accesses and updates the same reactive value. This may cause recursive updates when converted to an \`$effect\`.\nhttps://svelte.dev/e/legacy_recursive_reactive_block`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/legacy_recursive_reactive_block`);
+	}
+}
+
+/**
+ * Tried to unmount a component that was not mounted
+ */
+export function lifecycle_double_unmount() {
+	if (DEV) {
+		console.warn(`%c[svelte] lifecycle_double_unmount\n%cTried to unmount a component that was not mounted\nhttps://svelte.dev/e/lifecycle_double_unmount`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/lifecycle_double_unmount`);
+	}
+}
+
+/**
+ * %parent% passed property `%prop%` to %child% with `bind:`, but its parent component %owner% did not declare `%prop%` as a binding. Consider creating a binding between %owner% and %parent% (e.g. `bind:%prop%={...}` instead of `%prop%={...}`)
+ * @param {string} parent
+ * @param {string} prop
+ * @param {string} child
+ * @param {string} owner
+ */
+export function ownership_invalid_binding(parent, prop, child, owner) {
+	if (DEV) {
+		console.warn(`%c[svelte] ownership_invalid_binding\n%c${parent} passed property \`${prop}\` to ${child} with \`bind:\`, but its parent component ${owner} did not declare \`${prop}\` as a binding. Consider creating a binding between ${owner} and ${parent} (e.g. \`bind:${prop}={...}\` instead of \`${prop}={...}\`)\nhttps://svelte.dev/e/ownership_invalid_binding`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/ownership_invalid_binding`);
+	}
+}
+
+/**
+ * Mutating unbound props (`%name%`, at %location%) is strongly discouraged. Consider using `bind:%prop%={...}` in %parent% (or using a callback) instead
+ * @param {string} name
+ * @param {string} location
+ * @param {string} prop
+ * @param {string} parent
+ */
+export function ownership_invalid_mutation(name, location, prop, parent) {
+	if (DEV) {
+		console.warn(`%c[svelte] ownership_invalid_mutation\n%cMutating unbound props (\`${name}\`, at ${location}) is strongly discouraged. Consider using \`bind:${prop}={...}\` in ${parent} (or using a callback) instead\nhttps://svelte.dev/e/ownership_invalid_mutation`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/ownership_invalid_mutation`);
+	}
+}
+
+/**
+ * The `value` property of a `<select multiple>` element should be an array, but it received a non-array value. The selection will be kept as is.
+ */
+export function select_multiple_invalid_value() {
+	if (DEV) {
+		console.warn(`%c[svelte] select_multiple_invalid_value\n%cThe \`value\` property of a \`<select multiple>\` element should be an array, but it received a non-array value. The selection will be kept as is.\nhttps://svelte.dev/e/select_multiple_invalid_value`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/select_multiple_invalid_value`);
+	}
+}
+
+/**
+ * Reactive `$state(...)` proxies and the values they proxy have different identities. Because of this, comparisons with `%operator%` will produce unexpected results
+ * @param {string} operator
+ */
+export function state_proxy_equality_mismatch(operator) {
+	if (DEV) {
+		console.warn(`%c[svelte] state_proxy_equality_mismatch\n%cReactive \`$state(...)\` proxies and the values they proxy have different identities. Because of this, comparisons with \`${operator}\` will produce unexpected results\nhttps://svelte.dev/e/state_proxy_equality_mismatch`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/state_proxy_equality_mismatch`);
+	}
+}
+
+/**
+ * Tried to unmount a state proxy, rather than a component
+ */
+export function state_proxy_unmount() {
+	if (DEV) {
+		console.warn(`%c[svelte] state_proxy_unmount\n%cTried to unmount a state proxy, rather than a component\nhttps://svelte.dev/e/state_proxy_unmount`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/state_proxy_unmount`);
+	}
+}
+
+/**
+ * A `<svelte:boundary>` `reset` function only resets the boundary the first time it is called
+ */
+export function svelte_boundary_reset_noop() {
+	if (DEV) {
+		console.warn(`%c[svelte] svelte_boundary_reset_noop\n%cA \`<svelte:boundary>\` \`reset\` function only resets the boundary the first time it is called\nhttps://svelte.dev/e/svelte_boundary_reset_noop`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
+	}
+}
+
+/**
+ * The `slide` transition does not work correctly for elements with `display: %value%`
+ * @param {string} value
+ */
+export function transition_slide_display(value) {
+	if (DEV) {
+		console.warn(`%c[svelte] transition_slide_display\n%cThe \`slide\` transition does not work correctly for elements with \`display: ${value}\`\nhttps://svelte.dev/e/transition_slide_display`, bold, normal);
+	} else {
+		console.warn(`https://svelte.dev/e/transition_slide_display`);
+	}
+}

package/src/internal/disclose-version.js

@@ -0,0 +1,6 @@
+import { PUBLIC_VERSION } from '../version.js';
+
+if (typeof window !== 'undefined') {
+	// @ts-expect-error
+	((window.__svelte ??= {}).v ??= new Set()).add(PUBLIC_VERSION);
+}

package/src/internal/flags/async.js

@@ -0,0 +1,3 @@
+import { enable_async_mode_flag } from './index.js';
+
+enable_async_mode_flag();

package/src/internal/flags/index.js

@@ -0,0 +1,23 @@
+/** True if experimental.async=true */
+export let async_mode_flag = false;
+/** True if we're not certain that we only have Svelte 5 code in the compilation */
+export let legacy_mode_flag = false;
+/** True if $inspect.trace is used */
+export let tracing_mode_flag = false;
+
+export function enable_async_mode_flag() {
+	async_mode_flag = true;
+}
+
+/** ONLY USE THIS DURING TESTING */
+export function disable_async_mode_flag() {
+	async_mode_flag = false;
+}
+
+export function enable_legacy_mode_flag() {
+	legacy_mode_flag = true;
+}
+
+export function enable_tracing_mode_flag() {
+	tracing_mode_flag = true;
+}

package/src/internal/flags/legacy.js

@@ -0,0 +1,3 @@
+import { enable_legacy_mode_flag } from './index.js';
+
+enable_legacy_mode_flag();

package/src/internal/flags/tracing.js

@@ -0,0 +1,3 @@
+import { enable_tracing_mode_flag } from './index.js';
+
+enable_tracing_mode_flag();

package/src/internal/index.js

@@ -0,0 +1,5 @@
+// TODO we may, on a best-effort basis, reimplement some of the legacy private APIs here so that certain libraries continue to work. Those APIs will be marked as deprecated (and should noisily warn the user) and will be removed in a future version of Svelte.
+
+throw new Error(
+	`Your application, or one of its dependencies, imported from 'svelte/internal', which was a private module used by Svelte 4 components that no longer exists in Svelte 5. It is not intended to be public API. If you're a library author and you used 'svelte/internal' deliberately, please raise an issue on https://github.com/sveltejs/svelte/issues detailing your use case.`
+);

package/src/internal/server/abort-signal.js

@@ -0,0 +1,13 @@
+import { STALE_REACTION } from '#client/constants';
+
+/** @type {AbortController | null} */
+let controller = null;
+
+export function abort() {
+	controller?.abort(STALE_REACTION);
+	controller = null;
+}
+
+export function getAbortSignal() {
+	return (controller ??= new AbortController()).signal;
+}

package/src/internal/server/blocks/html.js

@@ -0,0 +1,11 @@
+import { DEV } from 'esm-env';
+import { hash } from '../../../utils.js';
+
+/**
+ * @param {string} value
+ */
+export function html(value) {
+	var html = String(value ?? '');
+	var open = DEV ? `<!--${hash(html)}-->` : '<!---->';
+	return open + html + '<!---->';
+}

package/src/internal/server/blocks/snippet.js

@@ -0,0 +1,24 @@
+/** @import { Snippet } from 'svelte' */
+/** @import { Renderer } from '../renderer' */
+/** @import { Getters } from '#shared' */
+
+/**
+ * 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 {Renderer} */ renderer, /** @type {Params} */ ...args) => {
+		var getters = /** @type {Getters<Params>} */ (args.map((value) => () => value));
+		renderer.push(
+			fn(...getters)
+				.render()
+				.trim()
+		);
+	};
+}

package/src/internal/server/context.js

@@ -0,0 +1,132 @@
+/** @import { SSRContext } from '#server' */
+import { DEV } from 'esm-env';
+import * as e from './errors.js';
+
+/** @type {SSRContext | null} */
+export var ssr_context = null;
+
+/** @param {SSRContext | null} v */
+export function set_ssr_context(v) {
+	ssr_context = v;
+}
+
+/**
+ * @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)
+	];
+}
+
+/**
+ * @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;
+}
+
+/**
+ * @template T
+ * @param {any} key
+ * @param {T} context
+ * @returns {T}
+ */
+export function setContext(key, context) {
+	get_or_init_context_map('setContext').set(key, context);
+	return context;
+}
+
+/**
+ * @param {any} key
+ * @returns {boolean}
+ */
+export function hasContext(key) {
+	return get_or_init_context_map('hasContext').has(key);
+}
+
+/** @returns {Map<any, any>} */
+export function getAllContexts() {
+	return get_or_init_context_map('getAllContexts');
+}
+
+/**
+ * @param {string} name
+ * @returns {Map<unknown, unknown>}
+ */
+function get_or_init_context_map(name) {
+	if (ssr_context === null) {
+		e.lifecycle_outside_component(name);
+	}
+
+	return (ssr_context.c ??= new Map(get_parent_context(ssr_context) || undefined));
+}
+
+/**
+ * @param {Function} [fn]
+ */
+export function push(fn) {
+	ssr_context = { p: ssr_context, c: null, r: null };
+
+	if (DEV) {
+		ssr_context.function = fn;
+		ssr_context.element = ssr_context.p?.element;
+	}
+}
+
+export function pop() {
+	ssr_context = /** @type {SSRContext} */ (ssr_context).p;
+}
+
+/**
+ * @param {SSRContext} ssr_context
+ * @returns {Map<unknown, unknown> | null}
+ */
+function get_parent_context(ssr_context) {
+	let parent = ssr_context.p;
+
+	while (parent !== null) {
+		const context_map = parent.c;
+		if (context_map !== null) {
+			return context_map;
+		}
+		parent = parent.p;
+	}
+
+	return null;
+}
+
+/**
+ * Wraps an `await` expression in such a way that the component context that was
+ * active before the expression evaluated can be reapplied afterwards —
+ * `await a + b()` becomes `(await $.save(a))() + b()`, meaning `b()` will have access
+ * to the context of its component.
+ * @template T
+ * @param {Promise<T>} promise
+ * @returns {Promise<() => T>}
+ */
+export async function save(promise) {
+	var previous_context = ssr_context;
+	var value = await promise;
+
+	return () => {
+		ssr_context = previous_context;
+		return value;
+	};
+}

package/src/internal/server/crypto.js

@@ -0,0 +1,45 @@
+import { BROWSER } from 'esm-env';
+
+let text_encoder;
+// TODO - remove this and use global `crypto` when we drop Node 18
+let crypto;
+
+/** @param {string} module_name */
+const obfuscated_import = (module_name) => import(/* @vite-ignore */ module_name);
+
+/** @param {string} data */
+export async function sha256(data) {
+	text_encoder ??= new TextEncoder();
+
+	// @ts-expect-error
+	crypto ??= globalThis.crypto?.subtle?.digest
+		? globalThis.crypto
+		: // @ts-ignore - we don't install node types in the prod build
+			// don't use import('node:crypto') directly because static analysers will think we rely on node when we don't
+			(await obfuscated_import('node:crypto')).webcrypto;
+
+	const hash_buffer = await crypto.subtle.digest('SHA-256', text_encoder.encode(data));
+
+	return base64_encode(hash_buffer);
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function base64_encode(bytes) {
+	// Using `Buffer` is faster than iterating
+	// @ts-ignore
+	if (!BROWSER && globalThis.Buffer) {
+		// @ts-ignore
+		return globalThis.Buffer.from(bytes).toString('base64');
+	}
+
+	let binary = '';
+
+	for (let i = 0; i < bytes.length; i++) {
+		binary += String.fromCharCode(bytes[i]);
+	}
+
+	return btoa(binary);
+}