token-usage-dashboard 1.0.9 → 1.0.10

package/build/server/chunks/chunks/{server.js-mTMwhapa.js → server.js-DxWEh0qK.js}

@@ -1722,13 +1722,6 @@ var DESTROYING = 1 << 25;
 var EFFECT_TRANSPARENT = 65536;
 var EFFECT_PRESERVED = 1 << 19;
 var USER_EFFECT = 1 << 20;
-/**
-* 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). This is a pure performance optimization flag and
-* should not be used for any other purpose!
-*/
-var WAS_MARKED = 65536;
 var REACTION_IS_UPDATING = 1 << 21;
 var ERROR_VALUE = 1 << 23;
 var STATE_SYMBOL = Symbol("$state");
@@ -1852,6 +1845,13 @@ function missing_context() {
 	throw new Error(`https://svelte.dev/e/missing_context`);
 }
 /**
+* `setContext` must be called when a component first initializes, not in a subsequent effect or after an `await` expression
+* @returns {never}
+*/
+function set_context_after_init() {
+	throw new Error(`https://svelte.dev/e/set_context_after_init`);
+}
+/**
 * Maximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state
 * @returns {never}
 */
@@ -2037,21 +2037,7 @@ function update_derived_status(derived) {
 }
 //#endregion
 //#region node_modules/svelte/src/internal/client/reactivity/utils.js
-/** @import { Derived, Effect, Value } from '#client' */
-/**
-* @param {Value[] | null} deps
-*/
-function clear_marked(deps) {
-	if (deps === null) return;
-	for (const dep of deps) {
-		if ((dep.f & 2) === 0 || (dep.f & 65536) === 0) continue;
-		dep.f ^= WAS_MARKED;
-		clear_marked(
-			/** @type {Derived} */
-			dep.deps
-		);
-	}
-}
+/** @import { Effect } from '#client' */
 /**
 * @param {Effect} effect
 * @param {Set<Effect>} dirty_effects
@@ -2060,7 +2046,6 @@ function clear_marked(deps) {
 function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
 	if ((effect.f & 2048) !== 0) dirty_effects.add(effect);
 	else if ((effect.f & 4096) !== 0) maybe_dirty_effects.add(effect);
-	clear_marked(effect.deps);
 	set_signal_status(effect, CLEAN);
 }
 //#endregion
@@ -2108,7 +2093,6 @@ function execute_derived(derived) {
 	}
 	set_active_effect(parent);
 	try {
-		derived.f &= ~WAS_MARKED;
 		destroy_derived_effects(derived);
 		value = update_reaction(derived);
 	} finally {
@@ -2257,10 +2241,17 @@ var Batch = class Batch {
 	*/
 	#deferred = null;
 	/**
-	* The root effects that need to be flushed
+	* Effects that were scheduled in this batch but not yet 'resolved' into the
+	* root effects that need to be flushed. Resolving — the upwards traversal that
+	* marks the path to each effect on the shared effect tree (see #resolve) — is
+	* deferred until the batch is processed, so that the markers are created and
+	* consumed within a single traversal. Scheduling into other batches (which can
+	* happen concurrently, e.g. while a batch is committed) can therefore never
+	* observe (and be confused by) this batch's markers.
+	* May contain duplicates — deduplication happens during resolving
 	* @type {Effect[]}
 	*/
-	#roots = [];
+	#scheduled = [];
 	/**
 	* Effects created while this batch was active.
 	* @type {Effect[]}
@@ -2347,12 +2338,40 @@ var Batch = class Batch {
 		}
 		this.#unskipped_branches.add(effect);
 	}
+	/**
+	* Convert the effects that were scheduled in this batch into the root effects
+	* that need to be traversed, marking the path to each effect (by clearing the
+	* `CLEAN` flag on ancestor branches) so that the traversal can find them.
+	* This happens right before traversal rather than at scheduling time, so that
+	* the markers left on the (shared) effect tree are created and consumed within
+	* a single traversal — scheduling into other batches can never observe them
+	* @returns {Effect[]}
+	*/
+	#resolve() {
+		/** @type {Effect[]} */
+		var roots = [];
+		for (const effect of this.#scheduled) {
+			if ((effect.f & 16384) !== 0 || (effect.f & 6144) === 0) continue;
+			var e = effect;
+			var covered = false;
+			while (e.parent !== null) {
+				e = e.parent;
+				var flags = e.f;
+				if ((flags & 96) !== 0) {
+					if ((flags & 1024) === 0) {
+						covered = true;
+						break;
+					}
+					e.f ^= CLEAN;
+				}
+			}
+			if (!covered) roots.push(e);
+		}
+		this.#scheduled = [];
+		return roots;
+	}
 	#process() {
 		this.#started = true;
-		if (flush_count++ > 1e3) {
-			this.#unlink();
-			infinite_loop_guard();
-		}
 		for (const e of this.#dirty_effects) {
 			this.#maybe_dirty_effects.delete(e);
 			set_signal_status(e, DIRTY);
@@ -2362,8 +2381,6 @@ var Batch = class Batch {
 			set_signal_status(e, MAYBE_DIRTY);
 			this.schedule(e);
 		}
-		const roots = this.#roots;
-		this.#roots = [];
 		this.apply();
 		/** @type {Effect[]} */
 		var effects = collected_effects = [];
@@ -2374,12 +2391,18 @@ var Batch = class Batch {
 		* @deprecated when we get rid of legacy mode and stores, we can get rid of this
 		*/
 		var updates = legacy_updates = [];
-		for (const root of roots) try {
-			this.#traverse(root, effects, render_effects);
-		} catch (e) {
-			reset_all(root);
-			if (!this.#is_deferred()) this.discard();
-			throw e;
+		while (this.#scheduled.length > 0) {
+			if (flush_count++ > 1e3) {
+				this.#unlink();
+				infinite_loop_guard();
+			}
+			for (const root of this.#resolve()) try {
+				this.#traverse(root, effects, render_effects);
+			} catch (e) {
+				reset_all(root);
+				if (!this.#is_deferred()) this.discard();
+				throw e;
+			}
 		}
 		current_batch = null;
 		if (updates.length > 0) {
@@ -2413,13 +2436,13 @@ var Batch = class Batch {
 		previous_batch = null;
 		this.#deferred?.resolve();
 		var next_batch = current_batch;
-		if (this.#pending === 0 && (this.#roots.length === 0 || next_batch !== null)) {
+		if (this.#pending === 0 && (this.#scheduled.length === 0 || next_batch !== null)) {
 			this.#unlink();
 		}
-		if (this.#roots.length > 0) {
+		if (this.#scheduled.length > 0) {
 			if (next_batch !== null) {
-				const batch = next_batch;
-				batch.#roots.push(...this.#roots.filter((r) => !batch.#roots.includes(r)));
+				for (const e of this.#scheduled) next_batch.#scheduled.push(e);
+				this.#scheduled = [];
 			} else next_batch = this;
 		}
 		if (next_batch !== null) {
@@ -2622,10 +2645,9 @@ var Batch = class Batch {
 						} else batch.#dirty_effects.add(effect);
 					}
 				}
-				if (batch.#roots.length > 0 && !batch.#decrement_queued) {
+				if (batch.#scheduled.length > 0 && !batch.#decrement_queued) {
 					batch.apply();
-					for (var root of batch.#roots) batch.#traverse(root, [], []);
-					batch.#roots = [];
+					for (var root of batch.#resolve()) batch.#traverse(root, [], []);
 				}
 				batch.deactivate();
 			}
@@ -2706,19 +2728,7 @@ var Batch = class Batch {
 			effect.b.defer_effect(effect);
 			return;
 		}
-		var e = effect;
-		while (e.parent !== null) {
-			e = e.parent;
-			var flags = e.f;
-			if (collected_effects !== null && e === active_effect) {
-				if ((active_reaction === null || (active_reaction.f & 2) === 0) && true) return;
-			}
-			if ((flags & 96) !== 0) {
-				if ((flags & 1024) === 0) return;
-				e.f ^= CLEAN;
-			}
-		}
-		this.#roots.push(e);
+		this.#scheduled.push(effect);
 	}
 	#unlink() {
 		if (!this.linked) return;
@@ -2937,6 +2947,16 @@ function set(source, value, should_proxy = false) {
 	return internal_set(source, should_proxy ? proxy(value) : value, legacy_updates);
 }
 /**
+* A set of signals we have already seen while traversing in mark_reactions.
+* Not always set to balance the common case of sources only having a couple
+* of (transitive) dependencies (where always creating a Set would be bad for perf)
+* with the edge case of extremely deep or wide dependency arrays with cycles.
+* @type {Set<any> | null}
+*/
+var seen = null;
+/** Number of transitive dependencies, see {@link seen} for more info */
+var count_deps = 0;
+/**
 * @template V
 * @param {Source<V>} source
 * @param {V} value
@@ -2955,7 +2975,10 @@ function internal_set(source, value, updated_during_traversal = null) {
 			if (batch_values === null) update_derived_status(derived);
 		}
 		source.wv = increment_write_version();
+		seen = null;
+		count_deps = 0;
 		mark_reactions(source, DIRTY, updated_during_traversal);
+		seen = null;
 		if (active_effect !== null && (active_effect.f & 1024) !== 0 && (active_effect.f & 96) === 0) {
 			if (untracked_writes === null) set_untracked_writes([source]);
 			else untracked_writes.push(source);
@@ -2995,6 +3018,12 @@ function mark_reactions(signal, status, updated_during_traversal) {
 	var reactions = signal.reactions;
 	if (reactions === null) return;
 	var length = reactions.length;
+	count_deps += length;
+	if (count_deps > 1e5 && seen === null) seen = /* @__PURE__ */ new Set();
+	if (seen !== null) {
+		if (seen.has(signal)) return;
+		seen.add(signal);
+	}
 	for (var i = 0; i < length; i++) {
 		var reaction = reactions[i];
 		var flags = reaction.f;
@@ -3004,10 +3033,7 @@ function mark_reactions(signal, status, updated_during_traversal) {
 		else if ((flags & 2) !== 0) {
 			var derived = reaction;
 			batch_values?.delete(derived);
-			if ((flags & 65536) === 0) {
-				if (flags & 512 && (active_effect === null || (active_effect.f & 2097152) === 0)) reaction.f |= WAS_MARKED;
-				mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
-			}
+			mark_reactions(derived, MAYBE_DIRTY, updated_during_traversal);
 		} else if (not_dirty) {
 			var effect = reaction;
 			if ((flags & 16) !== 0 && eager_block_effects !== null) eager_block_effects.add(effect);
@@ -3092,14 +3118,14 @@ function proxy(value) {
 			return Reflect.get(target, prop, receiver);
 		},
 		getOwnPropertyDescriptor(target, prop) {
+			this.has?.(target, prop);
 			var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-			if (descriptor && "value" in descriptor) {
-				var s = sources.get(prop);
-				if (s) descriptor.value = get(s);
-			} else if (descriptor === void 0) {
-				var source = sources.get(prop);
-				var value = source?.v;
-				if (source !== void 0 && value !== UNINITIALIZED) return {
+			var s = sources.get(prop);
+			if (s !== void 0) {
+				var value = get(s);
+				if (value === UNINITIALIZED) return;
+				if (descriptor && "value" in descriptor) descriptor.value = value;
+				else return {
 					enumerable: true,
 					configurable: true,
 					value,
@@ -3585,7 +3611,7 @@ function set_active_effect(effect) {
 var current_sources = null;
 /** @param {Value} value */
 function push_reaction_value(value) {
-	if (active_reaction !== null && (true)) (current_sources ??= /* @__PURE__ */ new Set()).add(value);
+	if (active_reaction !== null && ((active_reaction.f & 2097152) !== 0 || (active_reaction.f & 2) !== 0)) (current_sources ??= /* @__PURE__ */ new Set()).add(value);
 }
 /**
 * The dependencies of the reaction that is currently being executed. In many cases,
@@ -3629,7 +3655,6 @@ function increment_write_version() {
 function is_dirty(reaction) {
 	var flags = reaction.f;
 	if ((flags & 2048) !== 0) return true;
-	if (flags & 2) reaction.f &= ~WAS_MARKED;
 	if ((flags & 4096) !== 0) {
 		var dependencies = reaction.deps;
 		var length = dependencies.length;
@@ -3760,10 +3785,7 @@ function remove_reaction(signal, dependency) {
 	}
 	if (reactions === null && (dependency.f & 2) !== 0 && (new_deps === null || !includes.call(new_deps, dependency))) {
 		var derived = dependency;
-		if ((derived.f & 512) !== 0) {
-			derived.f ^= 512;
-			derived.f &= ~WAS_MARKED;
-		}
+		if ((derived.f & 512) !== 0) derived.f ^= 512;
 		if (derived.v !== UNINITIALIZED) update_derived_status(derived);
 		if (derived.ac !== null) without_reactive_context(() => {
 			/** @type {AbortController} */ derived.ac.abort(STALE_REACTION);
@@ -3910,90 +3932,6 @@ function untrack(fn) {
 	}
 }
 //#endregion
-//#region node_modules/svelte/src/store/shared/index.js
-/** @import { Readable, StartStopNotifier, Subscriber, Unsubscriber, Updater, Writable } from '../public.js' */
-/** @import { Stores, StoresValues, SubscribeInvalidateTuple } from '../private.js' */
-/**
-* @type {Array<SubscribeInvalidateTuple<any> | any>}
-*/
-var subscriber_queue = [];
-/**
-* Creates a `Readable` store that allows reading by subscription.
-*
-* @template T
-* @param {T} [value] initial value
-* @param {StartStopNotifier<T>} [start]
-* @returns {Readable<T>}
-*/
-function readable(value, start) {
-	return { subscribe: writable(value, start).subscribe };
-}
-/**
-* Create a `Writable` store that allows both updating and reading by subscription.
-*
-* @template T
-* @param {T} [value] initial value
-* @param {StartStopNotifier<T>} [start]
-* @returns {Writable<T>}
-*/
-function writable(value, start = noop) {
-	/** @type {Unsubscriber | null} */
-	let stop = null;
-	/** @type {Set<SubscribeInvalidateTuple<T>>} */
-	const subscribers = /* @__PURE__ */ new Set();
-	/**
-	* @param {T} new_value
-	* @returns {void}
-	*/
-	function set(new_value) {
-		if (safe_not_equal(value, new_value)) {
-			value = new_value;
-			if (stop) {
-				const run_queue = !subscriber_queue.length;
-				for (const subscriber of subscribers) {
-					subscriber[1]();
-					subscriber_queue.push(subscriber, value);
-				}
-				if (run_queue) {
-					for (let i = 0; i < subscriber_queue.length; i += 2) subscriber_queue[i][0](subscriber_queue[i + 1]);
-					subscriber_queue.length = 0;
-				}
-			}
-		}
-	}
-	/**
-	* @param {Updater<T>} fn
-	* @returns {void}
-	*/
-	function update(fn) {
-		set(fn(value));
-	}
-	/**
-	* @param {Subscriber<T>} run
-	* @param {() => void} [invalidate]
-	* @returns {Unsubscriber}
-	*/
-	function subscribe(run, invalidate = noop) {
-		/** @type {SubscribeInvalidateTuple<T>} */
-		const subscriber = [run, invalidate];
-		subscribers.add(subscriber);
-		if (subscribers.size === 1) stop = start(set, update) || noop;
-		run(value);
-		return () => {
-			subscribers.delete(subscriber);
-			if (subscribers.size === 0 && stop) {
-				stop();
-				stop = null;
-			}
-		};
-	}
-	return {
-		set,
-		update,
-		subscribe
-	};
-}
-//#endregion
 //#region node_modules/svelte/src/utils.js
 var VOID_ELEMENT_NAMES = [
 	"area",
@@ -4257,63 +4195,15 @@ var BLOCK_OPEN = `<!--[-->`;
 var BLOCK_CLOSE = `<!--]-->`;
 var EMPTY_COMMENT = `<!---->`;
 //#endregion
-//#region node_modules/svelte/src/internal/server/context.js
-/** @import { SSRContext } from '#server' */
-/** @type {SSRContext | null} */
-var ssr_context = null;
-/** @param {SSRContext | null} v */
-function set_ssr_context(v) {
-	ssr_context = v;
-}
-/**
-* @template T
-* @returns {[() => T, (context: T) => T, () => boolean]}
-* @since 5.40.0
-*/
-function createContext() {
-	return create_context(getContext, setContext, hasContext);
-}
-/**
-* @template T
-* @param {any} key
-* @returns {T}
-*/
-function getContext(key) {
-	return get_or_init_context_map(ssr_context).get(key);
-}
+//#region node_modules/svelte/src/internal/server/errors.js
 /**
-* @template T
-* @param {any} key
-* @param {T} context
-* @returns {T}
-*/
-function setContext(key, context) {
-	get_or_init_context_map(ssr_context).set(key, context);
-	return context;
-}
-/**
-* @param {any} key
-* @returns {boolean}
-*/
-function hasContext(key) {
-	return get_or_init_context_map(ssr_context).has(key);
-}
-/** @returns {Map<any, any>} */
-function getAllContexts() {
-	return get_or_init_context_map(ssr_context);
-}
-/**
-* @param {Function} [fn]
+* The node API `AsyncLocalStorage` is not available, but is required to use async server rendering.
+* @returns {never}
 */
-function push(fn) {
-	ssr_context = {
-		p: ssr_context,
-		c: null,
-		r: null
-	};
-}
-function pop() {
-	ssr_context = ssr_context.p;
+function async_local_storage_unavailable() {
+	const error = /* @__PURE__ */ 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.
@@ -4392,6 +4282,68 @@ function server_context_required() {
 	error.name = "Svelte error";
 	throw error;
 }
+//#endregion
+//#region node_modules/svelte/src/internal/server/context.js
+/** @import { SSRContext } from '#server' */
+/** @type {SSRContext | null} */
+var ssr_context = null;
+/** @param {SSRContext | null} v */
+function set_ssr_context(v) {
+	ssr_context = v;
+}
+/**
+* @template T
+* @returns {[() => T, (context: T) => T, () => boolean]}
+* @since 5.40.0
+*/
+function createContext() {
+	return create_context(getContext, setContext, hasContext);
+}
+/**
+* @template T
+* @param {any} key
+* @returns {T}
+*/
+function getContext(key) {
+	return get_or_init_context_map(ssr_context).get(key);
+}
+/**
+* @template T
+* @param {any} key
+* @param {T} context
+* @returns {T}
+*/
+function setContext(key, context) {
+	const context_map = get_or_init_context_map(ssr_context);
+	if (ssr_context.i) set_context_after_init();
+	context_map.set(key, context);
+	return context;
+}
+/**
+* @param {any} key
+* @returns {boolean}
+*/
+function hasContext(key) {
+	return get_or_init_context_map(ssr_context).has(key);
+}
+/** @returns {Map<any, any>} */
+function getAllContexts() {
+	return get_or_init_context_map(ssr_context);
+}
+/**
+* @param {Function} [fn]
+*/
+function push(fn) {
+	ssr_context = {
+		p: ssr_context,
+		c: null,
+		r: null,
+		i: false
+	};
+}
+function pop() {
+	ssr_context = ssr_context.p;
+}
 /**
 * A `hydratable` value with key `%key%` was created, but at least part of it was not used during the render.
 * 
@@ -4403,14 +4355,62 @@ function server_context_required() {
 function unresolved_hydratable(key, stack) {
 	console.warn(`https://svelte.dev/e/unresolved_hydratable`);
 }
+//#endregion
+//#region node_modules/svelte/src/internal/server/render-context.js
+/** @import { AsyncLocalStorage } from 'node:async_hooks' */
+/** @import { RenderContext } from '#server' */
+/** @type {Promise<void> | null} */
+var current_render = null;
+/** @type {RenderContext | null} */
+var context = null;
 /** @returns {RenderContext} */
 function get_render_context() {
-	const store = als?.getStore();
-	server_context_required();
+	const store = context ?? als?.getStore();
+	if (!store) server_context_required();
 	return store;
 }
+/**
+* @template T
+* @param {() => Promise<T>} fn
+* @returns {Promise<T>}
+*/
+async function with_render_context(fn) {
+	context = { hydratable: {
+		lookup: /* @__PURE__ */ new Map(),
+		comparisons: [],
+		unresolved_promises: /* @__PURE__ */ new Map()
+	} };
+	if (in_webcontainer()) {
+		const { promise, resolve } = deferred();
+		const previous_render = current_render;
+		current_render = promise;
+		await previous_render;
+		return fn().finally(resolve);
+	}
+	try {
+		if (als === null) async_local_storage_unavailable();
+		return als.run(context, fn);
+	} finally {
+		context = null;
+	}
+}
 /** @type {AsyncLocalStorage<RenderContext | null> | null} */
 var als = null;
+/** @type {Promise<void> | null} */
+var als_import = null;
+/**
+*
+* @returns {Promise<void>}
+*/
+function init_render_context() {
+	als_import ??= import('node:async_hooks').then((hooks) => {
+		als = new hooks.AsyncLocalStorage();
+	}).then(noop, noop);
+	return als_import;
+}
+function in_webcontainer() {
+	return !!globalThis.process?.versions?.webcontainer;
+}
 //#endregion
 //#region node_modules/svelte/src/internal/server/crypto.js
 var text_encoder;
@@ -4447,6 +4447,61 @@ function base64_encode(bytes) {
 /**
 * @typedef {string | Renderer} RendererItem
 */
+var RenderResult = class {
+	/** @type {() => AccumulatedContent} */
+	#render;
+	/** @type {() => Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }>} */
+	#render_async;
+	/** @type {AccumulatedContent | undefined} */
+	#sync;
+	/** @type {{ script: '' }} */
+	#hashes = { script: "" };
+	/** @type {Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }> | undefined} */
+	#promise;
+	/**
+	* @param {() => AccumulatedContent} render
+	* @param {() => Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }>} render_async
+	*/
+	constructor(render, render_async) {
+		this.#render = render;
+		this.#render_async = render_async;
+	}
+	#get() {
+		return this.#sync ??= this.#render();
+	}
+	get html() {
+		return this.#get().body;
+	}
+	get head() {
+		return this.#get().head;
+	}
+	get body() {
+		return this.#get().body;
+	}
+	get hashes() {
+		return this.#hashes;
+	}
+	/**
+	* This is not type-safe, but honestly it's the best I can do right now, and it's a straightforward function.
+	*
+	* @template TResult1
+	* @template [TResult2=never]
+	* @param {(value: SyncRenderOutput) => TResult1} onfulfilled
+	* @param {(reason: unknown) => TResult2} onrejected
+	*/
+	then(onfulfilled, onrejected) {
+		{
+			const result = this.#get();
+			const user_result = onfulfilled({
+				head: result.head,
+				body: result.body,
+				html: result.body,
+				hashes: { script: [] }
+			});
+			return Promise.resolve(user_result);
+		}
+	}
+};
 /**
 * Renderers are basically a tree of `string | Renderer`s, where each `Renderer` in the tree represents
 * work that may or may not have completed. A renderer can be {@link collect}ed to aggregate the
@@ -4568,6 +4623,7 @@ var Renderer = class Renderer {
 		const context = ssr_context;
 		let promise = Promise.resolve(thunks[0]());
 		const promises = [promise];
+		if (context !== null && thunks.length > 1) context.i = true;
 		for (const fn of thunks.slice(1)) {
 			promise = promise.then(() => {
 				const previous_context = ssr_context;
@@ -4605,7 +4661,8 @@ var Renderer = class Renderer {
 			...ssr_context,
 			p: parent,
 			c: null,
-			r: child
+			r: child,
+			i: ssr_context?.i ?? false
 		});
 		const result = fn(child);
 		set_ssr_context(parent);
@@ -4638,7 +4695,8 @@ var Renderer = class Renderer {
 			...ssr_context,
 			p: parent_context,
 			c: null,
-			r: child
+			r: child,
+			i: ssr_context?.i ?? false
 		});
 		try {
 			const result = children_fn(child);
@@ -4838,43 +4896,7 @@ var Renderer = class Renderer {
 	* @returns {RenderOutput}
 	*/
 	static render(component, options = {}) {
-		/** @type {AccumulatedContent | undefined} */
-		let sync;
-		const result = {};
-		Object.defineProperties(result, {
-			html: { get: () => {
-				return (sync ??= Renderer.#render(component, options)).body;
-			} },
-			head: { get: () => {
-				return (sync ??= Renderer.#render(component, options)).head;
-			} },
-			body: { get: () => {
-				return (sync ??= Renderer.#render(component, options)).body;
-			} },
-			hashes: { value: { script: "" } },
-			then: { value: 
-			/**
-			* this is not type-safe, but honestly it's the best I can do right now, and it's a straightforward function.
-			*
-			* @template TResult1
-			* @template [TResult2=never]
-			* @param { (value: SyncRenderOutput) => TResult1 } onfulfilled
-			* @param { (reason: unknown) => TResult2 } onrejected
-			*/
-			(onfulfilled, onrejected) => {
-				{
-					const result = sync ??= Renderer.#render(component, options);
-					const user_result = onfulfilled({
-						head: result.head,
-						body: result.body,
-						html: result.body,
-						hashes: { script: [] }
-					});
-					return Promise.resolve(user_result);
-				}
-			} }
-		});
-		return result;
+		return new RenderResult(() => Renderer.#render(component, options), () => init_render_context().then(() => with_render_context(() => Renderer.#render_async(component, options))));
 	}
 	/**
 	* Collect all of the `onDestroy` callbacks registered during rendering. In an async context, this is only safe to call
@@ -5068,7 +5090,8 @@ var Renderer = class Renderer {
 			set_ssr_context({
 				p: null,
 				c: options.context ?? null,
-				r: renderer
+				r: renderer,
+				i: false
 			});
 			renderer.push(BLOCK_OPEN);
 			component(renderer, options.props ?? {});
@@ -5283,7 +5306,9 @@ function attributes(attrs, css_hash, classes, styles, flags = 0) {
 	const is_html = (flags & 1) === 0;
 	const lowercase = (flags & 2) === 0;
 	const is_input = (flags & 4) !== 0;
-	for (name of Object.keys(attrs)) {
+	const names = Object.keys(attrs);
+	outer: for (let i = 0; i < names.length; i++) {
+		name = names[i];
 		if (typeof attrs[name] === "function") continue;
 		if (name[0] === "$" && name[1] === "$") continue;
 		if (name === "" || INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
@@ -5294,7 +5319,8 @@ function attributes(attrs, css_hash, classes, styles, flags = 0) {
 		if (is_input) {
 			if (name === "defaultvalue" || name === "defaultchecked") {
 				name = name === "defaultvalue" ? "value" : "checked";
-				if (attrs[name]) continue;
+				if (name in attrs) continue;
+				for (let j = 0; j < names.length; j++) if (names[j].toLowerCase() === name) continue outer;
 			}
 		}
 		attr_str += attr(name, value, is_html && is_boolean_attribute(name));
@@ -5370,5 +5396,5 @@ function derived(fn) {
 	};
 }
 
-export { pop$1 as $, queue_micro_task as A, invoke_error_boundary as B, current_batch as C, pause_effect as D, move_effect as E, defer_effect as F, set_component_context as G, HYDRATION_ERROR as H, Batch as I, component_context as J, internal_set as K, LEGACY_PROPS as L, destroy_effect as M, next as N, skip_nodes as O, derived as P, effect_tracking as Q, render_effect as R, svelte_boundary_reset_noop as S, svelte_boundary_reset_onerror as T, source as U, untrack as V, increment as W, hydrate_next as X, push$1 as Y, mark_as_component as Z, hydration_mismatch as _, get_first_child as a, run as a0, noop as a1, hasContext as a2, getContext as a3, getAllContexts as a4, createContext as a5, ssr_context as a6, lifecycle_function_unavailable as a7, EFFECT_TRANSPARENT as a8, EFFECT_PRESERVED as a9, experimental_async_required as aa, get_render_context as ab, uneval as ac, hydratable_serialization_failed as ad, parse as ae, stringify$1 as af, writable as ag, readable as ah, escape_html as ai, head as aj, attr_class as ak, attr as al, ensure_array_like as am, bind_props as an, stringify as ao, attr_style as ap, element as aq, get_next_sibling as b, set_hydrating as c, define_property as d, set_hydrate_node as e, flushSync as f, get as g, hydration_failed as h, init_operations as i, clear_text_content as j, component_root as k, hydrate_node as l, mutable_source as m, create_text as n, array_from as o, is_passive_event as p, set_active_reaction as q, render as r, set as s, set_active_effect as t, active_reaction as u, active_effect as v, setContext as w, hydrating as x, block as y, branch as z };
-//# sourceMappingURL=server.js-mTMwhapa.js.map
+export { pop$1 as $, queue_micro_task as A, invoke_error_boundary as B, current_batch as C, pause_effect as D, move_effect as E, defer_effect as F, set_component_context as G, HYDRATION_ERROR as H, Batch as I, component_context as J, internal_set as K, LEGACY_PROPS as L, destroy_effect as M, next as N, skip_nodes as O, derived as P, effect_tracking as Q, render_effect as R, svelte_boundary_reset_noop as S, svelte_boundary_reset_onerror as T, source as U, untrack as V, increment as W, hydrate_next as X, push$1 as Y, mark_as_component as Z, hydration_mismatch as _, get_first_child as a, run as a0, noop as a1, hasContext as a2, getContext as a3, getAllContexts as a4, createContext as a5, ssr_context as a6, lifecycle_function_unavailable as a7, EFFECT_TRANSPARENT as a8, EFFECT_PRESERVED as a9, experimental_async_required as aa, get_render_context as ab, uneval as ac, hydratable_serialization_failed as ad, parse as ae, stringify$1 as af, safe_not_equal as ag, escape_html as ah, head as ai, attr_class as aj, attr as ak, ensure_array_like as al, bind_props as am, stringify as an, attr_style as ao, element as ap, get_next_sibling as b, set_hydrating as c, define_property as d, set_hydrate_node as e, flushSync as f, get as g, hydration_failed as h, init_operations as i, clear_text_content as j, component_root as k, hydrate_node as l, mutable_source as m, create_text as n, array_from as o, is_passive_event as p, set_active_reaction as q, render as r, set as s, set_active_effect as t, active_reaction as u, active_effect as v, setContext as w, hydrating as x, block as y, branch as z };
+//# sourceMappingURL=server.js-DxWEh0qK.js.map