svelte 3.46.6 → 3.47.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Svelte changelog
 
+## 3.47.0
+
+* Add support for dynamic elements through `<svelte:element>` ([#2324](https://github.com/sveltejs/svelte/issues/2324))
+* Miscellaneous variable context fixes in `{@const}` ([#7222](https://github.com/sveltejs/svelte/pull/7222))
+* Fix `{#key}` block not being reactive when the key variable is not otherwise used ([#7408](https://github.com/sveltejs/svelte/issues/7408))
+* Add `Symbol` as a known global ([#7418](https://github.com/sveltejs/svelte/issues/7418))
+
 ## 3.46.6
 
 * Actually include action TypeScript interface in published package ([#7407](https://github.com/sveltejs/svelte/pull/7407))

package/compiler.js

@@ -5854,6 +5854,7 @@
 	    'setTimeout',
 	    'String',
 	    'SVGElement',
+	    'Symbol',
 	    'SyntaxError',
 	    'TypeError',
 	    'undefined',
@@ -6037,6 +6038,10 @@
 	        code: `invalid-${slug}-content`,
 	        message: `<${name}> cannot have children`
 	    }),
+	    invalid_element_definition: {
+	        code: 'invalid-element-definition',
+	        message: 'Invalid element definition'
+	    },
 	    invalid_element_placement: (slug, name) => ({
 	        code: `invalid-${slug}-placement`,
 	        message: `<${name}> tags cannot be inside elements or blocks`
@@ -6097,6 +6102,10 @@
 	        code: 'missing-attribute-value',
 	        message: 'Expected value for the attribute'
 	    },
+	    missing_element_definition: {
+	        code: 'missing-element-definition',
+	        message: '<svelte:element> must have a \'this\' attribute'
+	    },
 	    unclosed_script: {
 	        code: 'unclosed-script',
 	        message: '<script> must have a closing tag'
@@ -16685,7 +16694,7 @@
 	    ['svelte:window', 'Window'],
 	    ['svelte:body', 'Body']
 	]);
-	const valid_meta_tags = Array.from(meta_tags.keys()).concat('svelte:self', 'svelte:component', 'svelte:fragment');
+	const valid_meta_tags = Array.from(meta_tags.keys()).concat('svelte:self', 'svelte:component', 'svelte:fragment', 'svelte:element');
 	const specials = new Map([
 	    [
 	        'script',
@@ -16705,6 +16714,7 @@
 	const SELF = /^svelte:self(?=[\s/>])/;
 	const COMPONENT = /^svelte:component(?=[\s/>])/;
 	const SLOT = /^svelte:fragment(?=[\s/>])/;
+	const ELEMENT = /^svelte:element(?=[\s/>])/;
 	function parent_is_head(stack) {
 	    let i = stack.length;
 	    while (i--) {
@@ -16807,7 +16817,7 @@
 	    }
 	    if (name === 'svelte:component') {
 	        const index = element.attributes.findIndex(attr => attr.type === 'Attribute' && attr.name === 'this');
-	        if (!~index) {
+	        if (index === -1) {
 	            parser.error(parser_errors.missing_component_definition, start);
 	        }
 	        const definition = element.attributes.splice(index, 1)[0];
@@ -16816,6 +16826,17 @@
 	        }
 	        element.expression = definition.value[0].expression;
 	    }
+	    if (name === 'svelte:element') {
+	        const index = element.attributes.findIndex(attr => attr.type === 'Attribute' && attr.name === 'this');
+	        if (index === -1) {
+	            parser.error(parser_errors.missing_element_definition, start);
+	        }
+	        const definition = element.attributes.splice(index, 1)[0];
+	        if (definition.value === true) {
+	            parser.error(parser_errors.invalid_element_definition, definition.start);
+	        }
+	        element.tag = definition.value[0].data || definition.value[0].expression;
+	    }
 	    // special cases – top-level <script> and <style>
 	    if (specials.has(name) && parser.stack.length === 1) {
 	        const special = specials.get(name);
@@ -16872,6 +16893,8 @@
 	    }
 	    if (parser.read(COMPONENT))
 	        return 'svelte:component';
+	    if (parser.read(ELEMENT))
+	        return 'svelte:element';
 	    if (parser.read(SLOT))
 	        return 'svelte:fragment';
 	    const name = parser.read_until(/(\s|\/|>)/);
@@ -17912,6 +17935,7 @@
 	            hydrate: [],
 	            mount: [],
 	            measure: [],
+	            restore_measurements: [],
 	            fix: [],
 	            animate: [],
 	            intro: [],
@@ -18100,6 +18124,11 @@
 	            properties.measure = x `function #measure() {
 				${this.chunks.measure}
 			}`;
+	            if (this.chunks.restore_measurements.length) {
+	                properties.restore_measurements = x `function #restore_measurements(#measurement) {
+					${this.chunks.restore_measurements}
+				}`;
+	            }
 	            properties.fix = x `function #fix() {
 				${this.chunks.fix}
 			}`;
@@ -18151,6 +18180,7 @@
 			m: ${properties.mount},
 			p: ${properties.update},
 			r: ${properties.measure},
+			s: ${properties.restore_measurements},
 			f: ${properties.fix},
 			a: ${properties.animate},
 			i: ${properties.intro},
@@ -19052,6 +19082,10 @@
 	        code: 'invalid-animation',
 	        message: 'An element that uses the animate directive must be the sole child of a keyed each block'
 	    },
+	    invalid_animation_dynamic_element: {
+	        code: 'invalid-animation',
+	        message: '<svelte:element> cannot have a animate directive'
+	    },
 	    invalid_directive_value: {
 	        code: 'invalid-directive-value',
 	        message: 'Can only bind to an identifier (e.g. `foo`) or a member expression (e.g. `foo.bar` or `foo[baz]`)'
@@ -19264,11 +19298,20 @@
 	                    const id = component.get_unique_name(sanitize(get_function_name(node, owner)));
 	                    const declaration = b `const ${id} = ${node}`;
 	                    if (owner.type === 'ConstTag') {
+	                        let child_scope = scope;
 	                        walk(node, {
-	                            enter(node) {
-	                                if (node.type === 'Identifier') {
+	                            enter(node, parent) {
+	                                if (map.has(node))
+	                                    child_scope = map.get(node);
+	                                if (node.type === 'Identifier' && is_reference(node, parent)) {
+	                                    if (child_scope.has(node.name))
+	                                        return;
 	                                    this.replace(block.renderer.reference(node, ctx));
 	                                }
+	                            },
+	                            leave(node) {
+	                                if (map.has(node))
+	                                    child_scope = child_scope.parent;
 	                            }
 	                        });
 	                    }
@@ -20321,6 +20364,17 @@
 	        this.outro = null;
 	        this.animation = null;
 	        this.name = info.name;
+	        if (info.name === 'svelte:element') {
+	            if (typeof info.tag !== 'string') {
+	                this.tag_expr = new Expression(component, this, scope, info.tag);
+	            }
+	            else {
+	                this.tag_expr = new Expression(component, this, scope, string_literal(info.tag));
+	            }
+	        }
+	        else {
+	            this.tag_expr = new Expression(component, this, scope, string_literal(this.name));
+	        }
 	        this.namespace = get_namespace(parent, this, component.namespace);
 	        if (this.namespace !== namespaces.foreign) {
 	            if (this.name === 'textarea') {
@@ -20417,6 +20471,9 @@
 	        this.optimise();
 	        component.apply_stylesheet(this);
 	    }
+	    get is_dynamic_element() {
+	        return this.name === 'svelte:element';
+	    }
 	    validate() {
 	        if (this.component.var_lookup.has(this.name) && this.component.var_lookup.get(this.name).imported) {
 	            this.component.warn(this, compiler_warnings.component_name_lowercase(this.name));
@@ -23384,9 +23441,21 @@
 	        filter: (node, _name) => node.name === 'details'
 	    }
 	];
+	const CHILD_DYNAMIC_ELEMENT_BLOCK = 'child_dynamic_element';
 	class ElementWrapper extends Wrapper {
 	    constructor(renderer, block, parent, node, strip_whitespace, next_sibling) {
 	        super(renderer, block, parent, node);
+	        this.child_dynamic_element_block = null;
+	        this.child_dynamic_element = null;
+	        if (node.is_dynamic_element && block.type !== CHILD_DYNAMIC_ELEMENT_BLOCK) {
+	            this.child_dynamic_element_block = block.child({
+	                comment: create_debugging_comment(node, renderer.component),
+	                name: renderer.component.get_unique_name('create_dynamic_element'),
+	                type: CHILD_DYNAMIC_ELEMENT_BLOCK
+	            });
+	            renderer.blocks.push(this.child_dynamic_element_block);
+	            this.child_dynamic_element = new ElementWrapper(renderer, this.child_dynamic_element_block, parent, node, strip_whitespace, next_sibling);
+	        }
 	        this.var = {
 	            type: 'Identifier',
 	            name: node.name.replace(/[^a-zA-Z0-9_$]/g, '_')
@@ -23423,6 +23492,7 @@
 	        if (node.animation) {
 	            block.add_animation();
 	        }
+	        block.add_dependencies(node.tag_expr.dependencies);
 	        // add directive and handler dependencies
 	        [node.animation, node.outro, ...node.actions, ...node.classes, ...node.styles].forEach(directive => {
 	            if (directive && directive.expression) {
@@ -23443,6 +23513,7 @@
 	                node.handlers.length > 0 ||
 	                node.styles.length > 0 ||
 	                this.node.name === 'option' ||
+	                node.tag_expr.dynamic_dependencies().length ||
 	                renderer.options.dev) {
 	                this.parent.cannot_use_innerhtml(); // need to use add_location
 	                this.parent.not_static_content();
@@ -23451,6 +23522,90 @@
 	        this.fragment = new FragmentWrapper(renderer, block, node.children, this, strip_whitespace, next_sibling);
 	    }
 	    render(block, parent_node, parent_nodes) {
+	        if (this.child_dynamic_element) {
+	            this.render_dynamic_element(block, parent_node, parent_nodes);
+	        }
+	        else {
+	            this.render_element(block, parent_node, parent_nodes);
+	        }
+	    }
+	    render_dynamic_element(block, parent_node, parent_nodes) {
+	        this.child_dynamic_element.render(this.child_dynamic_element_block, null, x `#nodes`);
+	        const previous_tag = block.get_unique_name('previous_tag');
+	        const tag = this.node.tag_expr.manipulate(block);
+	        block.add_variable(previous_tag, tag);
+	        block.chunks.init.push(b `
+			${this.renderer.options.dev && b `@validate_dynamic_element(${tag});`}
+			let ${this.var} = ${tag} && ${this.child_dynamic_element_block.name}(#ctx);
+		`);
+	        block.chunks.create.push(b `
+			if (${this.var}) ${this.var}.c();
+		`);
+	        if (this.renderer.options.hydratable) {
+	            block.chunks.claim.push(b `
+				if (${this.var}) ${this.var}.l(${parent_nodes});
+			`);
+	        }
+	        block.chunks.mount.push(b `
+			if (${this.var}) ${this.var}.m(${parent_node || '#target'}, ${parent_node ? 'null' : '#anchor'});
+		`);
+	        const anchor = this.get_or_create_anchor(block, parent_node, parent_nodes);
+	        const has_transitions = !!(this.node.intro || this.node.outro);
+	        const not_equal = this.renderer.component.component_options.immutable ? x `@not_equal` : x `@safe_not_equal`;
+	        block.chunks.update.push(b `
+			if (${tag}) {
+				if (!${previous_tag}) {
+					${this.var} = ${this.child_dynamic_element_block.name}(#ctx);
+					${this.var}.c();
+					${has_transitions && b `@transition_in(${this.var})`}
+					${this.var}.m(${this.get_update_mount_node(anchor)}, ${anchor});
+				} else if (${not_equal}(${previous_tag}, ${tag})) {
+					${this.var}.d(1);
+					${this.renderer.options.dev && b `@validate_dynamic_element(${tag});`}
+					${this.var} = ${this.child_dynamic_element_block.name}(#ctx);
+					${this.var}.c();
+					${this.var}.m(${this.get_update_mount_node(anchor)}, ${anchor});
+				} else {
+					${this.var}.p(#ctx, #dirty);
+				}
+			} else if (${previous_tag}) {
+				${has_transitions
+            ? b `
+							@group_outros();
+							@transition_out(${this.var}, 1, 1, () => {
+								${this.var} = null;
+							});
+							@check_outros();
+						`
+            : b `
+							${this.var}.d(1);
+							${this.var} = null;
+						`}
+			}
+			${previous_tag} = ${tag};
+		`);
+	        if (this.child_dynamic_element_block.has_intros) {
+	            block.chunks.intro.push(b `@transition_in(${this.var});`);
+	        }
+	        if (this.child_dynamic_element_block.has_outros) {
+	            block.chunks.outro.push(b `@transition_out(${this.var});`);
+	        }
+	        block.chunks.destroy.push(b `if (${this.var}) ${this.var}.d(detaching)`);
+	        if (this.node.animation) {
+	            const measurements = block.get_unique_name('measurements');
+	            block.add_variable(measurements);
+	            block.chunks.measure.push(b `${measurements} = ${this.var}.r()`);
+	            block.chunks.fix.push(b `${this.var}.f();`);
+	            block.chunks.animate.push(b `
+				${this.var}.s(${measurements});
+				${this.var}.a()
+			`);
+	        }
+	    }
+	    is_dom_node() {
+	        return super.is_dom_node() && !this.child_dynamic_element;
+	    }
+	    render_element(block, parent_node, parent_nodes) {
 	        const { renderer } = this;
 	        if (this.node.name === 'noscript')
 	            return;
@@ -23463,7 +23618,7 @@
 	        if (renderer.options.hydratable) {
 	            if (parent_nodes) {
 	                block.chunks.claim.push(b `
-					${node} = ${this.get_claim_statement(parent_nodes)};
+					${node} = ${this.get_claim_statement(block, parent_nodes)};
 				`);
 	                if (!this.void && this.node.children.length > 0) {
 	                    block.chunks.claim.push(b `
@@ -23546,12 +23701,13 @@
 	            const loc = renderer.locate(this.node.start);
 	            block.chunks.hydrate.push(b `@add_location(${this.var}, ${renderer.file_var}, ${loc.line - 1}, ${loc.column}, ${this.node.start});`);
 	        }
+	        block.renderer.dirty(this.node.tag_expr.dynamic_dependencies());
 	    }
 	    can_use_textcontent() {
 	        return this.is_static_content && this.fragment.nodes.every(node => node.node.type === 'Text' || node.node.type === 'MustacheTag');
 	    }
 	    get_render_statement(block) {
-	        const { name, namespace } = this.node;
+	        const { name, namespace, tag_expr } = this.node;
 	        if (namespace === namespaces.svg) {
 	            return x `@svg_element("${name}")`;
 	        }
@@ -23562,20 +23718,33 @@
 	        if (is) {
 	            return x `@element_is("${name}", ${is.render_chunks(block).reduce((lhs, rhs) => x `${lhs} + ${rhs}`)})`;
 	        }
-	        return x `@element("${name}")`;
+	        const reference = tag_expr.manipulate(block);
+	        return x `@element(${reference})`;
 	    }
-	    get_claim_statement(nodes) {
+	    get_claim_statement(block, nodes) {
 	        const attributes = this.attributes
 	            .filter((attr) => !(attr instanceof SpreadAttributeWrapper) && !attr.property_name)
 	            .map((attr) => p `${attr.name}: true`);
-	        const name = this.node.namespace
-	            ? this.node.name
-	            : this.node.name.toUpperCase();
+	        let reference;
+	        if (this.node.tag_expr.node.type === 'Literal') {
+	            if (this.node.namespace) {
+	                reference = `"${this.node.tag_expr.node.value}"`;
+	            }
+	            else {
+	                reference = `"${(this.node.tag_expr.node.value || '').toUpperCase()}"`;
+	            }
+	        }
+	        else if (this.node.namespace) {
+	            reference = x `${this.node.tag_expr.manipulate(block)}`;
+	        }
+	        else {
+	            reference = x `(${this.node.tag_expr.manipulate(block)} || 'null').toUpperCase()`;
+	        }
 	        if (this.node.namespace === namespaces.svg) {
-	            return x `@claim_svg_element(${nodes}, "${name}", { ${attributes} })`;
+	            return x `@claim_svg_element(${nodes}, ${reference}, { ${attributes} })`;
 	        }
 	        else {
-	            return x `@claim_element(${nodes}, "${name}", { ${attributes} })`;
+	            return x `@claim_element(${nodes}, ${reference}, { ${attributes} })`;
 	        }
 	    }
 	    add_directives_in_order(block) {
@@ -23944,6 +24113,10 @@
 	        block.chunks.measure.push(b `
 			${rect} = ${this.var}.getBoundingClientRect();
 		`);
+	        if (block.type === CHILD_DYNAMIC_ELEMENT_BLOCK) {
+	            block.chunks.measure.push(b `return ${rect}`);
+	            block.chunks.restore_measurements.push(b `${rect} = #measurement;`);
+	        }
 	        block.chunks.fix.push(b `
 			@fix_position(${this.var});
 			${stop_animation}();
@@ -24027,7 +24200,7 @@
 	                if (should_cache) {
 	                    block.chunks.update.push(b `
 							if (${block.renderer.dirty(dependencies)} && (${cached_snippet} !== (${cached_snippet} = ${snippet}))) {
-								${updater}	
+								${updater}
 							}
 					`);
 	                }
@@ -24576,6 +24749,7 @@
 	                name: renderer.component.get_unique_name('create_key_block'),
 	                type: 'key'
 	            });
+	            block.add_dependencies(node.expression.dependencies);
 	            renderer.blocks.push(block);
 	        }
 	        this.block = block;
@@ -27727,7 +27901,8 @@
 	    const contenteditable = (node.name !== 'textarea' &&
 	        node.name !== 'input' &&
 	        node.attributes.some((attribute) => attribute.name === 'contenteditable'));
-	    renderer.add_string(`<${node.name}`);
+	    renderer.add_string('<');
+	    add_tag_name();
 	    const class_expression_list = node.classes.map(class_directive => {
 	        const { expression, name } = class_directive;
 	        const snippet = expression ? expression.node : x `#ctx.${name}`; // TODO is this right?
@@ -27867,14 +28042,25 @@
 	        else {
 	            renderer.add_expression(node_contents);
 	        }
-	        if (!is_void(node.name)) {
-	            renderer.add_string(`</${node.name}>`);
-	        }
+	        add_close_tag();
 	    }
 	    else {
 	        renderer.render(children, options);
+	        add_close_tag();
+	    }
+	    function add_close_tag() {
 	        if (!is_void(node.name)) {
-	            renderer.add_string(`</${node.name}>`);
+	            renderer.add_string('</');
+	            add_tag_name();
+	            renderer.add_string('>');
+	        }
+	    }
+	    function add_tag_name() {
+	        if (node.tag_expr.node.type === 'Literal') {
+	            renderer.add_string(node.tag_expr.node.value);
+	        }
+	        else {
+	            renderer.add_expression(node.tag_expr.node);
 	        }
 	    }
 	}
@@ -30495,7 +30681,7 @@
 	}
 
 	// This file is automatically generated
-	var internal_exports = new Set(["HtmlTag", "HtmlTagHydration", "SvelteComponent", "SvelteComponentDev", "SvelteComponentTyped", "SvelteElement", "action_destroyer", "add_attribute", "add_classes", "add_flush_callback", "add_location", "add_render_callback", "add_resize_listener", "add_styles", "add_transform", "afterUpdate", "append", "append_dev", "append_empty_stylesheet", "append_hydration", "append_hydration_dev", "append_styles", "assign", "attr", "attr_dev", "attribute_to_object", "beforeUpdate", "bind", "binding_callbacks", "blank_object", "bubble", "check_outros", "children", "claim_component", "claim_element", "claim_html_tag", "claim_space", "claim_svg_element", "claim_text", "clear_loops", "component_subscribe", "compute_rest_props", "compute_slots", "createEventDispatcher", "create_animation", "create_bidirectional_transition", "create_component", "create_in_transition", "create_out_transition", "create_slot", "create_ssr_component", "current_component", "custom_event", "dataset_dev", "debug", "destroy_block", "destroy_component", "destroy_each", "detach", "detach_after_dev", "detach_before_dev", "detach_between_dev", "detach_dev", "dirty_components", "dispatch_dev", "each", "element", "element_is", "empty", "end_hydrating", "escape", "escape_attribute_value", "escape_object", "escaped", "exclude_internal_props", "fix_and_destroy_block", "fix_and_outro_and_destroy_block", "fix_position", "flush", "getAllContexts", "getContext", "get_all_dirty_from_scope", "get_binding_group_value", "get_current_component", "get_custom_elements_slots", "get_root_for_style", "get_slot_changes", "get_spread_object", "get_spread_update", "get_store_value", "globals", "group_outros", "handle_promise", "hasContext", "has_prop", "identity", "init", "insert", "insert_dev", "insert_hydration", "insert_hydration_dev", "intros", "invalid_attribute_name_character", "is_client", "is_crossorigin", "is_empty", "is_function", "is_promise", "listen", "listen_dev", "loop", "loop_guard", "merge_ssr_styles", "missing_component", "mount_component", "noop", "not_equal", "now", "null_to_empty", "object_without_properties", "onDestroy", "onMount", "once", "outro_and_destroy_block", "prevent_default", "prop_dev", "query_selector_all", "raf", "run", "run_all", "safe_not_equal", "schedule_update", "select_multiple_value", "select_option", "select_options", "select_value", "self", "setContext", "set_attributes", "set_current_component", "set_custom_element_data", "set_data", "set_data_dev", "set_input_type", "set_input_value", "set_now", "set_raf", "set_store_value", "set_style", "set_svg_attributes", "space", "spread", "src_url_equal", "start_hydrating", "stop_propagation", "subscribe", "svg_element", "text", "tick", "time_ranges_to_array", "to_number", "toggle_class", "transition_in", "transition_out", "trusted", "update_await_block_branch", "update_keyed_each", "update_slot", "update_slot_base", "validate_component", "validate_each_argument", "validate_each_keys", "validate_slots", "validate_store", "xlink_attr"]);
+	var internal_exports = new Set(["HtmlTag", "HtmlTagHydration", "SvelteComponent", "SvelteComponentDev", "SvelteComponentTyped", "SvelteElement", "action_destroyer", "add_attribute", "add_classes", "add_flush_callback", "add_location", "add_render_callback", "add_resize_listener", "add_styles", "add_transform", "afterUpdate", "append", "append_dev", "append_empty_stylesheet", "append_hydration", "append_hydration_dev", "append_styles", "assign", "attr", "attr_dev", "attribute_to_object", "beforeUpdate", "bind", "binding_callbacks", "blank_object", "bubble", "check_outros", "children", "claim_component", "claim_element", "claim_html_tag", "claim_space", "claim_svg_element", "claim_text", "clear_loops", "component_subscribe", "compute_rest_props", "compute_slots", "createEventDispatcher", "create_animation", "create_bidirectional_transition", "create_component", "create_in_transition", "create_out_transition", "create_slot", "create_ssr_component", "current_component", "custom_event", "dataset_dev", "debug", "destroy_block", "destroy_component", "destroy_each", "detach", "detach_after_dev", "detach_before_dev", "detach_between_dev", "detach_dev", "dirty_components", "dispatch_dev", "each", "element", "element_is", "empty", "end_hydrating", "escape", "escape_attribute_value", "escape_object", "escaped", "exclude_internal_props", "fix_and_destroy_block", "fix_and_outro_and_destroy_block", "fix_position", "flush", "getAllContexts", "getContext", "get_all_dirty_from_scope", "get_binding_group_value", "get_current_component", "get_custom_elements_slots", "get_root_for_style", "get_slot_changes", "get_spread_object", "get_spread_update", "get_store_value", "globals", "group_outros", "handle_promise", "hasContext", "has_prop", "identity", "init", "insert", "insert_dev", "insert_hydration", "insert_hydration_dev", "intros", "invalid_attribute_name_character", "is_client", "is_crossorigin", "is_empty", "is_function", "is_promise", "listen", "listen_dev", "loop", "loop_guard", "merge_ssr_styles", "missing_component", "mount_component", "noop", "not_equal", "now", "null_to_empty", "object_without_properties", "onDestroy", "onMount", "once", "outro_and_destroy_block", "prevent_default", "prop_dev", "query_selector_all", "raf", "run", "run_all", "safe_not_equal", "schedule_update", "select_multiple_value", "select_option", "select_options", "select_value", "self", "setContext", "set_attributes", "set_current_component", "set_custom_element_data", "set_data", "set_data_dev", "set_input_type", "set_input_value", "set_now", "set_raf", "set_store_value", "set_style", "set_svg_attributes", "space", "spread", "src_url_equal", "start_hydrating", "stop_propagation", "subscribe", "svg_element", "text", "tick", "time_ranges_to_array", "to_number", "toggle_class", "transition_in", "transition_out", "trusted", "update_await_block_branch", "update_keyed_each", "update_slot", "update_slot_base", "validate_component", "validate_dynamic_element", "validate_each_argument", "validate_each_keys", "validate_slots", "validate_store", "xlink_attr"]);
 
 	function is_used_as_reference(node, parent) {
 	    if (!is_reference(node, parent)) {
@@ -30677,7 +30863,7 @@
 	        if (result) {
 	            const { compile_options, name } = this;
 	            const { format = 'esm' } = compile_options;
-	            const banner = `${this.file ? `${this.file} ` : ''}generated by Svelte v${'3.46.6'}`;
+	            const banner = `${this.file ? `${this.file} ` : ''}generated by Svelte v${'3.47.0'}`;
 	            const program = { type: 'Program', body: result.js };
 	            walk(program, {
 	                enter: (node, parent, key) => {
@@ -32170,7 +32356,7 @@
 	    return result.to_processed();
 	}
 
-	const VERSION = '3.46.6';
+	const VERSION = '3.47.0';
 
 	exports.VERSION = VERSION;
 	exports.compile = compile;