chore: adhere to naming conventions

packages/svelte/src/internal/client/custom-renderer/state.js

@@ -5,27 +5,27 @@
 /**
  * @type {Renderer<any, any, any, any> | null}
  */
-export let renderer = null;
+export let current_renderer = null;
 
 // allow for a "window" for each custom renderer...to use with `$props.id`
 export let custom_renderer_window_map = new WeakMap();
 
 /**
- * @param {Renderer<any, any, any, any> | null} $renderer
+ * @param {Renderer<any, any, any, any> | null} value
  */
-export function set_renderer($renderer) {
-	renderer = $renderer;
+export function set_renderer(value) {
+	current_renderer = value;
 }
 
 /**
  *
- * @param {Renderer<any, any, any, any>} $renderer
+ * @param {Renderer<any, any, any, any> | null} value
  */
-export function push_renderer($renderer) {
-	let old_renderer = renderer;
-	renderer = $renderer;
+export function push_renderer(value) {
+	let old_renderer = current_renderer;
+	current_renderer = value;
 	return () => {
-		renderer = old_renderer;
+		current_renderer = old_renderer;
 	};
 }
 
@@ -35,12 +35,12 @@ export function push_renderer($renderer) {
  * @returns {T}
  */
 export function without_renderer(fn) {
-	if (renderer === null) return fn();
-	let old_renderer = renderer;
-	renderer = null;
+	if (current_renderer === null) return fn();
+	let previous_renderer = current_renderer;
+	current_renderer = null;
 	try {
 		return fn();
 	} finally {
-		renderer = old_renderer;
+		current_renderer = previous_renderer;
 	}
 }

packages/svelte/src/internal/client/dev/validation.js

@@ -1,11 +1,11 @@
-import { renderer } from '../custom-renderer/state.js';
+import { current_renderer } from '../custom-renderer/state.js';
 import * as e from '../errors.js';
 /**
  * @param {Node} anchor
  * @param {...(()=>any)[]} args
  */
 export function validate_snippet_args(anchor, ...args) {
-	if (!renderer && (typeof anchor !== 'object' || !(anchor instanceof Node))) {
+	if (!current_renderer && (typeof anchor !== 'object' || !(anchor instanceof Node))) {
 		e.invalid_snippet_arguments();
 	}
 

packages/svelte/src/internal/client/dom/blocks/branches.js

@@ -20,7 +20,7 @@ import {
 	get_last_child
 } from '../operations.js';
 import { DEV } from 'esm-env';
-import { push_renderer, renderer as current_renderer } from '../../custom-renderer/state.js';
+import { push_renderer, current_renderer } from '../../custom-renderer/state.js';
 
 /**
  * @typedef {{ effect: Effect, fragment: DocumentFragment }} Branch

packages/svelte/src/internal/client/dom/blocks/each.js

@@ -50,7 +50,7 @@ import { current_batch } from '../../reactivity/batch.js';
 import * as e from '../../errors.js';
 import { tag } from '../../dev/tracing.js';
 
-import { push_renderer, renderer } from '../../custom-renderer/state.js';
+import { push_renderer, current_renderer } from '../../custom-renderer/state.js';
 
 // When making substantive changes to this file, validate them with the each block stress test:
 // https://svelte.dev/playground/1972b2cf46564476ad8c8c6405b23b7b
@@ -184,17 +184,17 @@ var dom_weak_key = {};
  */
 function get_offscreen_anchor() {
 	// not doing it inline to please typescript
-	var cached = offscreen_anchors.get(renderer ?? dom_weak_key);
+	var cached = offscreen_anchors.get(current_renderer ?? dom_weak_key);
 	if (cached) return cached;
 
 	var offscreen_anchor = create_text();
 
-	if (renderer) {
+	if (current_renderer) {
 		var fragment = create_fragment();
 		append_child(fragment, offscreen_anchor);
 	}
 
-	offscreen_anchors.set(renderer ?? dom_weak_key, offscreen_anchor);
+	offscreen_anchors.set(current_renderer ?? dom_weak_key, offscreen_anchor);
 	return offscreen_anchor;
 }
 
@@ -219,7 +219,7 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 	// Capture the renderer that was active when this each block was created.
 	// Needed so that the commit callback can push the correct renderer when doing
 	// DOM operations outside of an effect context (e.g. as a batch commit callback).
-	var captured_renderer = renderer;
+	var captured_renderer = current_renderer;
 
 	if (is_controlled) {
 		var parent_node = /** @type {Element} */ (node);

packages/svelte/src/internal/client/dom/blocks/snippet.js

@@ -16,7 +16,7 @@ import { DEV } from 'esm-env';
 import { get_first_child, get_next_sibling, insert_before, node_type } from '../operations.js';
 import { prevent_snippet_stringification } from '../../../shared/validate.js';
 import { BranchManager } from './branches.js';
-import { renderer } from '../../custom-renderer/state.js';
+import { current_renderer } from '../../custom-renderer/state.js';
 
 /**
  * @template {(node: TemplateNode, ...args: any[]) => void} SnippetFn
@@ -73,7 +73,7 @@ export function wrap_snippet(component, fn) {
 export function renderer_snippet(expected_renderer, fn) {
 	var wrapped = /** @type {T} */ (
 		(.../** @type {any[]} */ args) => {
-			if (renderer !== expected_renderer) {
+			if (current_renderer !== expected_renderer) {
 				e.snippet_renderer_mismatch();
 			}
 			return fn(...args);
@@ -116,7 +116,7 @@ export function validate_snippet_renderer(expected_renderer, fn) {
 export function createRawSnippet(fn) {
 	// @ts-expect-error the types are a lie
 	return (/** @type {TemplateNode} */ anchor, /** @type {Getters<Params>} */ ...params) => {
-		if (renderer != null) {
+		if (current_renderer != null) {
 			e.invalid_snippet_in_custom_renderer();
 		}
 		var snippet = fn(...params);

packages/svelte/src/internal/client/dom/elements/attributes.js

@@ -35,7 +35,7 @@ import {
 	set_element_default_value,
 	set_element_default_checked
 } from '../operations.js';
-import { renderer } from '../../custom-renderer/state.js';
+import { current_renderer } from '../../custom-renderer/state.js';
 
 export const CLASS = Symbol('class');
 export const STYLE = Symbol('style');
@@ -364,7 +364,8 @@ function set_attributes(
 		}
 
 		if (key === 'class') {
-			var is_html = element.namespaceURI === 'http://www.w3.org/1999/xhtml' && renderer != null;
+			var is_html =
+				element.namespaceURI === 'http://www.w3.org/1999/xhtml' && current_renderer != null;
 			set_class(element, is_html, value, css_hash, prev?.[CLASS], next[CLASS]);
 			current[key] = value;
 			current[CLASS] = next[CLASS];
@@ -395,7 +396,7 @@ function set_attributes(
 			const opts = {};
 			const event_handle_key = '$$' + key;
 			let event_name = key.slice(2);
-			var is_delegated = renderer == null && can_delegate_event(event_name);
+			var is_delegated = current_renderer == null && can_delegate_event(event_name);
 
 			if (is_capture_event(event_name)) {
 				event_name = event_name.slice(0, -7);
@@ -431,7 +432,7 @@ function set_attributes(
 			// avoid using the setter
 			set_attribute(element, key, value);
 		} else if (key === 'autofocus') {
-			if (renderer == null) {
+			if (current_renderer == null) {
 				autofocus(/** @type {HTMLElement} */ (element), Boolean(value));
 			} else {
 				// In custom renderer mode, just set autofocus as a regular attribute
@@ -458,7 +459,7 @@ function set_attributes(
 
 			if (value == null && !is_custom_element && !is_default) {
 				attributes[key] = null;
-				if ((name === 'value' || name === 'checked') && renderer == null) {
+				if ((name === 'value' || name === 'checked') && current_renderer == null) {
 					// removing value/checked also removes defaultValue/defaultChecked — preserve
 					let input = /** @type {HTMLInputElement} */ (element);
 					const use_default = prev === undefined;
@@ -481,7 +482,7 @@ function set_attributes(
 						element.__value = null;
 					}
 				}
-			} else if (is_default && renderer != null) {
+			} else if (is_default && current_renderer != null) {
 				// Route through the renderer-aware abstraction so custom renderers
 				// see defaultValue/defaultChecked as proper attributes
 				if (name === 'defaultValue') {
@@ -609,7 +610,7 @@ var setters_cache = new Map();
 /** @param {Element} element */
 function get_setters(element) {
 	// if we have a custom renderer we just skip the check all together
-	if (renderer) return [];
+	if (current_renderer) return [];
 	var cache_key = get_attribute(element, 'is') || (node_name(element) ?? '');
 	var setters = setters_cache.get(cache_key);
 	if (setters) return setters;
@@ -642,7 +643,7 @@ function get_setters(element) {
  * @param {string} value
  */
 function check_src_in_dev_hydration(element, attribute, value) {
-	if (!DEV || renderer != null) return;
+	if (!DEV || current_renderer != null) return;
 	if (attribute === 'srcset' && srcset_url_equal(element, value)) return;
 	if (src_url_equal(get_attribute(element, attribute) ?? '', value)) return;
 
@@ -659,7 +660,7 @@ function check_src_in_dev_hydration(element, attribute, value) {
  * @returns {boolean}
  */
 function src_url_equal(element_src, url) {
-	if (element_src === url || renderer != null) return true;
+	if (element_src === url || current_renderer != null) return true;
 	return new URL(element_src, document.baseURI).href === new URL(url, document.baseURI).href;
 }
 
@@ -674,7 +675,7 @@ function split_srcset(srcset) {
  * @returns {boolean}
  */
 function srcset_url_equal(element, srcset) {
-	if (renderer != null) return true;
+	if (current_renderer != null) return true;
 	var element_urls = split_srcset(element.srcset);
 	var urls = split_srcset(srcset);
 

packages/svelte/src/internal/client/dom/elements/events.js

@@ -18,7 +18,7 @@ import {
 	remove_event_listener,
 	get_parent_node
 } from '../operations.js';
-import { renderer } from '../../custom-renderer/state.js';
+import { current_renderer } from '../../custom-renderer/state.js';
 
 /**
  * Used on elements, as a map of event type -> event handler,
@@ -65,7 +65,7 @@ export function replay_events(dom) {
 export function create_event(event_name, dom, handler, options = {}) {
 	// Capture whether a custom renderer is active at creation time (during mount),
 	// since `renderer` will be null when the event actually fires
-	var is_custom_renderer = renderer != null;
+	var is_custom_renderer = current_renderer != null;
 
 	/**
 	 * @this {EventTarget}
@@ -141,7 +141,7 @@ export function event(event_name, dom, handler, capture, passive) {
 
 	if (
 		// if there's a renderer we will never add to body, window or document.
-		renderer == null &&
+		current_renderer == null &&
 		(dom === document.body ||
 			// @ts-ignore
 			dom === window ||

packages/svelte/src/internal/client/dom/operations.js

@@ -13,7 +13,7 @@ import {
 } from '#client/constants';
 import { eager_block_effects } from '../reactivity/batch.js';
 import { NAMESPACE_HTML } from '../../../constants.js';
-import { custom_renderer_window_map, renderer } from '../custom-renderer/state.js';
+import { custom_renderer_window_map, current_renderer } from '../custom-renderer/state.js';
 
 // export these for reference in the compiled code, making global name deduplication unnecessary
 /** @type {Window} */
@@ -84,7 +84,7 @@ export function init_operations() {
  * @returns {Text}
  */
 export function create_text(value = '') {
-	if (renderer) return /** @type {Text} */ (renderer.createTextNode(value));
+	if (current_renderer) return /** @type {Text} */ (current_renderer.createTextNode(value));
 	return document.createTextNode(value);
 }
 
@@ -94,7 +94,8 @@ export function create_text(value = '') {
  */
 /*@__NO_SIDE_EFFECTS__*/
 export function get_first_child(node) {
-	if (renderer) return /** @type {TemplateNode | null} */ (renderer.getFirstChild(node));
+	if (current_renderer)
+		return /** @type {TemplateNode | null} */ (current_renderer.getFirstChild(node));
 	return /** @type {TemplateNode | null} */ (first_child_getter.call(node));
 }
 
@@ -104,7 +105,8 @@ export function get_first_child(node) {
  */
 /*@__NO_SIDE_EFFECTS__*/
 export function get_next_sibling(node) {
-	if (renderer) return /** @type {TemplateNode | null} */ (renderer.getNextSibling(node));
+	if (current_renderer)
+		return /** @type {TemplateNode | null} */ (current_renderer.getNextSibling(node));
 	return /** @type {TemplateNode | null} */ (next_sibling_getter.call(node));
 }
 
@@ -223,11 +225,11 @@ export function sibling(node, count = 1, is_text = false) {
  * @returns {void}
  */
 export function clear_text_content(node) {
-	if (renderer) {
-		var child = renderer.getFirstChild(node);
+	if (current_renderer) {
+		var child = current_renderer.getFirstChild(node);
 		while (child !== null) {
-			var next = renderer.getNextSibling(child);
-			renderer.remove(child);
+			var next = current_renderer.getNextSibling(child);
+			current_renderer.remove(child);
 			child = next;
 		}
 		return;
@@ -257,9 +259,9 @@ export function should_defer_append() {
  * @returns {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element}
  */
 export function create_element(tag, namespace, is) {
-	if (renderer)
+	if (current_renderer)
 		return /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */ (
-			renderer.createElement(tag)
+			current_renderer.createElement(tag)
 		);
 	let options = is ? { is } : undefined;
 	return /** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */ (
@@ -268,7 +270,7 @@ export function create_element(tag, namespace, is) {
 }
 
 export function create_fragment() {
-	if (renderer) return /** @type {DocumentFragment} */ (renderer.createFragment());
+	if (current_renderer) return /** @type {DocumentFragment} */ (current_renderer.createFragment());
 	return document.createDocumentFragment();
 }
 
@@ -277,7 +279,7 @@ export function create_fragment() {
  * @returns
  */
 export function create_comment(data = '') {
-	if (renderer) return /** @type {Comment} */ (renderer.createComment(data));
+	if (current_renderer) return /** @type {Comment} */ (current_renderer.createComment(data));
 	return document.createComment(data);
 }
 
@@ -288,8 +290,8 @@ export function create_comment(data = '') {
  * @returns
  */
 export function set_attribute(element, key, value = '') {
-	if (renderer) {
-		renderer.setAttribute(element, key, value);
+	if (current_renderer) {
+		current_renderer.setAttribute(element, key, value);
 		return;
 	}
 	if (key.startsWith('xlink:')) {
@@ -306,7 +308,7 @@ export function set_attribute(element, key, value = '') {
  */
 export function merge_text_nodes(text) {
 	// if we have a renderer we will not hydrate so we can skip this
-	if (renderer) return;
+	if (current_renderer) return;
 
 	if (/** @type {string} */ (text.nodeValue).length < 65536) {
 		return;
@@ -328,7 +330,7 @@ export function merge_text_nodes(text) {
  * @returns {node is Comment}
  */
 function is_comment(node) {
-	if (renderer) return !!node && node_type(node) === COMMENT_NODE;
+	if (current_renderer) return !!node && node_type(node) === COMMENT_NODE;
 	return node instanceof Comment;
 }
 
@@ -337,8 +339,8 @@ function is_comment(node) {
  */
 export function node_type(node) {
 	if (node == null) return undefined;
-	if (renderer) {
-		const type = renderer.nodeType(node);
+	if (current_renderer) {
+		const type = current_renderer.nodeType(node);
 		return CUSTOM_RENDERER_NODE_TYPE_MAP[type];
 	}
 	return node?.nodeType;
@@ -349,7 +351,7 @@ export function node_type(node) {
  */
 export function node_name(node) {
 	if (node == null) return undefined;
-	if (renderer) {
+	if (current_renderer) {
 		// for custom renderers we don't need to return the node name since all the
 		// checks that we do on specific node names are meant to be for the HTML
 		return '';
@@ -362,7 +364,8 @@ export function node_name(node) {
  * @returns {TemplateNode | null}
  */
 export function get_last_child(node) {
-	if (renderer) return /** @type {TemplateNode | null} */ (renderer.getLastChild(node));
+	if (current_renderer)
+		return /** @type {TemplateNode | null} */ (current_renderer.getLastChild(node));
 	return /** @type {TemplateNode | null} */ (node.lastChild);
 }
 
@@ -371,7 +374,8 @@ export function get_last_child(node) {
  * @returns {TemplateNode | null}
  */
 export function get_parent_node(node) {
-	if (renderer) return /** @type {TemplateNode | null} */ (renderer.getParent(node));
+	if (current_renderer)
+		return /** @type {TemplateNode | null} */ (current_renderer.getParent(node));
 	return /** @type {TemplateNode | null} */ (node.parentNode);
 }
 
@@ -381,8 +385,8 @@ export function get_parent_node(node) {
  * @returns {Node}
  */
 export function append_child(parent, child) {
-	if (renderer) {
-		renderer.insert(parent, child, null);
+	if (current_renderer) {
+		current_renderer.insert(parent, child, null);
 		return child;
 	}
 	return parent.appendChild(child);
@@ -394,9 +398,9 @@ export function append_child(parent, child) {
  * @param {Node} new_node
  */
 export function insert_before(ref_node, new_node) {
-	if (renderer) {
-		var parent = renderer.getParent(ref_node);
-		renderer.insert(parent, new_node, ref_node);
+	if (current_renderer) {
+		var parent = current_renderer.getParent(ref_node);
+		current_renderer.insert(parent, new_node, ref_node);
 		return;
 	}
 	ref_node.before(new_node);
@@ -408,10 +412,10 @@ export function insert_before(ref_node, new_node) {
  * @param {Node} new_node
  */
 export function insert_after(ref_node, new_node) {
-	if (renderer) {
-		var parent = renderer.getParent(ref_node);
-		var next = renderer.getNextSibling(ref_node);
-		renderer.insert(parent, new_node, next);
+	if (current_renderer) {
+		var parent = current_renderer.getParent(ref_node);
+		var next = current_renderer.getNextSibling(ref_node);
+		current_renderer.insert(parent, new_node, next);
 		return;
 	}
 	ref_node.after(new_node);
@@ -421,8 +425,8 @@ export function insert_after(ref_node, new_node) {
  * @param {ChildNode} node
  */
 export function remove_node(node) {
-	if (renderer) {
-		renderer.remove(node);
+	if (current_renderer) {
+		current_renderer.remove(node);
 		return;
 	}
 	node.remove();
@@ -434,8 +438,8 @@ export function remove_node(node) {
  * @returns {ChildNode}
  */
 export function remove_child(parent, child) {
-	if (renderer) {
-		renderer.remove(child);
+	if (current_renderer) {
+		current_renderer.remove(child);
 		return child;
 	}
 	return /** @type {ChildNode} */ (parent.removeChild(child));
@@ -446,10 +450,10 @@ export function remove_child(parent, child) {
  * @param {Node} new_node
  */
 export function replace_with(old_node, new_node) {
-	if (renderer) {
-		var parent = renderer.getParent(old_node);
-		renderer.insert(parent, new_node, old_node);
-		renderer.remove(old_node);
+	if (current_renderer) {
+		var parent = current_renderer.getParent(old_node);
+		current_renderer.insert(parent, new_node, old_node);
+		current_renderer.remove(old_node);
 		return;
 	}
 	old_node.replaceWith(new_node);
@@ -460,8 +464,8 @@ export function replace_with(old_node, new_node) {
  * @param {string} value
  */
 export function set_text_content(node, value) {
-	if (renderer) {
-		renderer.setText(node, value);
+	if (current_renderer) {
+		current_renderer.setText(node, value);
 		return;
 	}
 	node.textContent = value;
@@ -472,8 +476,8 @@ export function set_text_content(node, value) {
  * @param {string} value
  */
 export function set_node_value(node, value) {
-	if (renderer) {
-		renderer.setText(node, value);
+	if (current_renderer) {
+		current_renderer.setText(node, value);
 		return;
 	}
 	node.nodeValue = value;
@@ -537,7 +541,7 @@ function remove_style_property_in_string(style_string, property) {
  * @returns {string | null}
  */
 export function get_node_value(node) {
-	if (renderer) return renderer.getNodeValue(node);
+	if (current_renderer) return current_renderer.getNodeValue(node);
 	return node.nodeValue;
 }
 
@@ -547,8 +551,8 @@ export function get_node_value(node) {
  * @param {any} value
  */
 export function set_element_value(element, value) {
-	if (renderer) {
-		renderer.setAttribute(element, 'value', value ?? '');
+	if (current_renderer) {
+		current_renderer.setAttribute(element, 'value', value ?? '');
 		return;
 	}
 	// @ts-expect-error
@@ -561,11 +565,11 @@ export function set_element_value(element, value) {
  * @param {boolean} checked
  */
 export function set_element_checked(element, checked) {
-	if (renderer) {
+	if (current_renderer) {
 		if (checked) {
-			renderer.setAttribute(element, 'checked', '');
+			current_renderer.setAttribute(element, 'checked', '');
 		} else {
-			renderer.removeAttribute(element, 'checked');
+			current_renderer.removeAttribute(element, 'checked');
 		}
 		return;
 	}
@@ -580,8 +584,8 @@ export function set_element_checked(element, checked) {
  * @param {string} value
  */
 export function set_element_default_value(element, value) {
-	if (renderer) {
-		renderer.setAttribute(element, 'defaultValue', value);
+	if (current_renderer) {
+		current_renderer.setAttribute(element, 'defaultValue', value);
 		return;
 	}
 	// @ts-expect-error
@@ -599,11 +603,11 @@ export function set_element_default_value(element, value) {
  * @param {boolean} checked
  */
 export function set_element_default_checked(element, checked) {
-	if (renderer) {
+	if (current_renderer) {
 		if (checked) {
-			renderer.setAttribute(element, 'defaultChecked', '');
+			current_renderer.setAttribute(element, 'defaultChecked', '');
 		} else {
-			renderer.removeAttribute(element, 'defaultChecked');
+			current_renderer.removeAttribute(element, 'defaultChecked');
 		}
 		return;
 	}
@@ -621,7 +625,7 @@ export function set_element_default_checked(element, checked) {
  * @returns {string | null}
  */
 export function get_attribute(element, name) {
-	if (renderer) return renderer.getAttribute(element, name);
+	if (current_renderer) return current_renderer.getAttribute(element, name);
 	return element.getAttribute(name);
 }
 
@@ -630,8 +634,8 @@ export function get_attribute(element, name) {
  * @param {string} name
  */
 export function remove_attribute(element, name) {
-	if (renderer) {
-		renderer.removeAttribute(element, name);
+	if (current_renderer) {
+		current_renderer.removeAttribute(element, name);
 		return;
 	}
 	element.removeAttribute(name);
@@ -643,7 +647,7 @@ export function remove_attribute(element, name) {
  * @returns {boolean}
  */
 export function has_attribute(element, name) {
-	if (renderer) return renderer.hasAttribute(element, name);
+	if (current_renderer) return current_renderer.hasAttribute(element, name);
 	return element.hasAttribute(name);
 }
 
@@ -652,7 +656,7 @@ export function has_attribute(element, name) {
  * @param {string} value
  */
 export function set_inner_html(element, value) {
-	if (renderer) {
+	if (current_renderer) {
 		throw new Error('setInnerHTML is not supported with custom renderers');
 	}
 	element.innerHTML = value;
@@ -664,7 +668,7 @@ export function set_inner_html(element, value) {
  * @returns {Node}
  */
 export function clone_node(node, deep) {
-	if (renderer) {
+	if (current_renderer) {
 		throw new Error('cloneNode is not supported with custom renderers');
 	}
 	return node.cloneNode(deep);
@@ -676,7 +680,7 @@ export function clone_node(node, deep) {
  * @returns {Node}
  */
 export function import_node(node, deep) {
-	if (renderer) {
+	if (current_renderer) {
 		throw new Error('importNode is not supported with custom renderers');
 	}
 	return document.importNode(node, deep);
@@ -689,8 +693,8 @@ export function import_node(node, deep) {
  * @param {boolean | AddEventListenerOptions} [options]
  */
 export function add_event_listener(target, type, handler, options) {
-	if (renderer) {
-		renderer.addEventListener(target, type, handler, options);
+	if (current_renderer) {
+		current_renderer.addEventListener(target, type, handler, options);
 		return;
 	}
 	target.addEventListener(type, handler, options);
@@ -703,8 +707,8 @@ export function add_event_listener(target, type, handler, options) {
  * @param {boolean | EventListenerOptions} [options]
  */
 export function remove_event_listener(target, type, handler, options) {
-	if (renderer) {
-		renderer.removeEventListener(target, type, handler, options);
+	if (current_renderer) {
+		current_renderer.removeEventListener(target, type, handler, options);
 		return;
 	}
 	target.removeEventListener(type, handler, options);
@@ -716,7 +720,7 @@ export function remove_event_listener(target, type, handler, options) {
  * @returns {boolean}
  */
 export function dispatch_event(target, event) {
-	if (renderer) {
+	if (current_renderer) {
 		// is only used in SSR which is not a thing for custom renderers
 		throw new Error('dispatchEvent is not supported with custom renderers');
 	}
@@ -730,10 +734,10 @@ export function dispatch_event(target, event) {
  * @param {string} [priority]
  */
 export function style_set_property(element, property, value, priority) {
-	if (renderer) {
-		var style = renderer.getAttribute(element, 'style') || '';
+	if (current_renderer) {
+		var style = current_renderer.getAttribute(element, 'style') || '';
 		var updated = set_style_property_in_string(style, property, value, priority);
-		renderer.setAttribute(element, 'style', updated);
+		current_renderer.setAttribute(element, 'style', updated);
 		return;
 	}
 	element.style.setProperty(property, value, priority);
@@ -744,10 +748,10 @@ export function style_set_property(element, property, value, priority) {
  * @param {string} property
  */
 export function style_remove_property(element, property) {
-	if (renderer) {
-		var style = renderer.getAttribute(element, 'style') || '';
+	if (current_renderer) {
+		var style = current_renderer.getAttribute(element, 'style') || '';
 		var updated = remove_style_property_in_string(style, property);
-		renderer.setAttribute(element, 'style', updated);
+		current_renderer.setAttribute(element, 'style', updated);
 		return;
 	}
 	element.style.removeProperty(property);
@@ -758,8 +762,8 @@ export function style_remove_property(element, property) {
  * @param {string} value
  */
 export function set_css_text(element, value) {
-	if (renderer) {
-		renderer.setAttribute(element, 'style', value);
+	if (current_renderer) {
+		current_renderer.setAttribute(element, 'style', value);
 		return;
 	}
 	element.style.cssText = value;
@@ -771,8 +775,8 @@ export function set_css_text(element, value) {
  * @param {boolean} force
  */
 export function class_list_toggle(element, name, force) {
-	if (renderer) {
-		const classes = renderer.getAttribute(element, 'class')?.split(/\s+/) ?? [];
+	if (current_renderer) {
+		const classes = current_renderer.getAttribute(element, 'class')?.split(/\s+/) ?? [];
 		const has_class = classes.includes(name);
 		if (force === has_class) {
 			return;
@@ -785,18 +789,18 @@ export function class_list_toggle(element, name, force) {
 				classes.splice(index, 1);
 			}
 		}
-		renderer.setAttribute(element, 'class', classes.join(' '));
+		current_renderer.setAttribute(element, 'class', classes.join(' '));
 		return;
 	}
 	element.classList.toggle(name, force);
 }
 
 export function get_window() {
-	if (renderer) {
-		var custom_renderer_window = custom_renderer_window_map.get(renderer);
+	if (current_renderer) {
+		var custom_renderer_window = custom_renderer_window_map.get(current_renderer);
 		if (!custom_renderer_window) {
 			custom_renderer_window = {};
-			custom_renderer_window_map.set(renderer, custom_renderer_window);
+			custom_renderer_window_map.set(current_renderer, custom_renderer_window);
 		}
 		return custom_renderer_window;
 	}

packages/svelte/src/internal/client/dom/template.js

@@ -40,7 +40,7 @@ import {
 	REACTION_RAN,
 	TEXT_NODE
 } from '#client/constants';
-import { renderer } from '../custom-renderer/state.js';
+import { current_renderer } from '../custom-renderer/state.js';
 
 const TEMPLATE_TAG = IS_XHTML ? 'template' : 'TEMPLATE';
 const SCRIPT_TAG = IS_XHTML ? 'script' : 'SCRIPT';
@@ -246,7 +246,7 @@ export function from_tree(structure, flags) {
 		// for the custom renderer we skip the cloning and create new nodes every time...a bit less efficient
 		// but save custom renderers implementors from having to implement importNode or cloneNode
 		// which can be a pain
-		if (node === undefined || renderer != null) {
+		if (node === undefined || current_renderer != null) {
 			const ns =
 				(flags & TEMPLATE_USE_SVG) !== 0
 					? NAMESPACE_SVG
@@ -259,7 +259,7 @@ export function from_tree(structure, flags) {
 		}
 
 		var clone = /** @type {TemplateNode} */ (
-			renderer != null
+			current_renderer != null
 				? node
 				: use_import_node || is_firefox
 					? import_node(node, true)

packages/svelte/src/internal/client/reactivity/async.js

@@ -9,7 +9,7 @@ import {
 	set_dev_stack
 } from '../context.js';
 import { Boundary } from '../dom/blocks/boundary.js';
-import { renderer, set_renderer } from '../custom-renderer/state.js';
+import { current_renderer, set_renderer } from '../custom-renderer/state.js';
 import { invoke_error_boundary } from '../error-handling.js';
 import {
 	active_effect,
@@ -114,7 +114,7 @@ export function capture() {
 	var previous_reaction = active_reaction;
 	var previous_component_context = component_context;
 	var previous_batch = /** @type {Batch} */ (current_batch);
-	var previous_renderer = renderer;
+	var previous_renderer = current_renderer;
 
 	if (DEV) {
 		var previous_dev_stack = dev_stack;

packages/svelte/src/internal/client/reactivity/effects.js

@@ -46,7 +46,7 @@ import { Batch, collected_effects, current_batch } from './batch.js';
 import { flatten, increment_pending } from './async.js';
 import { without_reactive_context } from '../dom/elements/bindings/shared.js';
 import { set_signal_status } from './status.js';
-import { push_renderer, renderer } from '../custom-renderer/state.js';
+import { push_renderer, current_renderer } from '../custom-renderer/state.js';
 
 /**
  * @param {'$effect' | '$effect.pre' | '$inspect'} rune
@@ -115,7 +115,7 @@ function create_effect(type, fn) {
 		teardown: null,
 		wv: 0,
 		ac: null,
-		r: renderer
+		r: current_renderer
 	};
 
 	if (DEV) {