svelte 3.46.3 → 3.46.4

package/compiler.mjs

@@ -5814,6 +5814,7 @@ const globals = new Set([
     'Event',
     'EventSource',
     'fetch',
+    'FormData',
     'global',
     'globalThis',
     'history',
@@ -6704,6 +6705,19 @@ function extract_identifiers(param, nodes = []) {
 	return nodes;
 }
 
+/**
+ * Does `array.push` for all `items`. Needed because `array.push(...items)` throws
+ * "Maximum call stack size exceeded" when `items` is too big of an array.
+ *
+ * @param {any[]} array 
+ * @param {any[]} items 
+ */
+function push_array(array, items) {
+	for (let i = 0; i < items.length; i++) {
+		array.push(items[i]);
+	}
+}
+
 // heavily based on https://github.com/davidbonnet/astring
 
 /** @typedef {import('estree').ArrowFunctionExpression} ArrowFunctionExpression */
@@ -6951,7 +6965,8 @@ const join = (nodes, separator) => {
 
 	const joined = [...nodes[0]];
 	for (let i = 1; i < nodes.length; i += 1) {
-		joined.push(separator, ...nodes[i]);
+		joined.push(separator);
+		push_array(joined, nodes[i]);
 	}
 	return joined;
 };
@@ -7029,9 +7044,7 @@ const handle_body = (nodes, state) => {
 			);
 		}
 
-		chunks.push(
-			...body[i]
-		);
+		push_array(chunks, body[i]);
 
 		needed_padding = needs_padding;
 	}
@@ -7058,13 +7071,7 @@ const handle_var_declaration = (node, state) => {
 
 	const separator = c(multiple_lines ? `,\n${state.indent}\t` : ', ');
 
-	if (multiple_lines) {
-		chunks.push(...join(declarators, separator));
-	} else {
-		chunks.push(
-			...join(declarators, separator)
-		);
-	}
+	push_array(chunks, join(declarators, separator));
 
 	return chunks;
 };
@@ -7119,10 +7126,8 @@ const handlers = {
 		];
 
 		if (node.alternate) {
-			chunks.push(
-				c(' else '),
-				...handle(node.alternate, state)
-			);
+			chunks.push(c(' else '));
+			push_array(chunks, handle(node.alternate, state));
 		}
 
 		return chunks;
@@ -7166,20 +7171,16 @@ const handlers = {
 
 		node.cases.forEach(block => {
 			if (block.test) {
-				chunks.push(
-					c(`\n${state.indent}\tcase `),
-					...handle(block.test, { ...state, indent: `${state.indent}\t` }),
-					c(':')
-				);
+				chunks.push(c(`\n${state.indent}\tcase `));
+				push_array(chunks, handle(block.test, { ...state, indent: `${state.indent}\t` }));
+				chunks.push(c(':'));
 			} else {
 				chunks.push(c(`\n${state.indent}\tdefault:`));
 			}
 
 			block.consequent.forEach(statement => {
-				chunks.push(
-					c(`\n${state.indent}\t\t`),
-					...handle(statement, { ...state, indent: `${state.indent}\t\t` })
-				);
+				chunks.push(c(`\n${state.indent}\t\t`));
+				push_array(chunks, handle(statement, { ...state, indent: `${state.indent}\t\t` }));
 			});
 		});
 
@@ -7217,20 +7218,19 @@ const handlers = {
 
 		if (node.handler) {
 			if (node.handler.param) {
-				chunks.push(
-					c(' catch('),
-					...handle(node.handler.param, state),
-					c(') ')
-				);
+				chunks.push(c(' catch('));
+				push_array(chunks, handle(node.handler.param, state));
+				chunks.push(c(') '));
 			} else {
 				chunks.push(c(' catch '));
 			}
 
-			chunks.push(...handle(node.handler.body, state));
+			push_array(chunks, handle(node.handler.body, state));
 		}
 
 		if (node.finalizer) {
-			chunks.push(c(' finally '), ...handle(node.finalizer, state));
+			chunks.push(c(' finally '));
+			push_array(chunks, handle(node.finalizer, state));
 		}
 
 		return chunks;
@@ -7260,21 +7260,19 @@ const handlers = {
 
 		if (node.init) {
 			if (node.init.type === 'VariableDeclaration') {
-				chunks.push(...handle_var_declaration(node.init, state));
+				push_array(chunks, handle_var_declaration(node.init, state));
 			} else {
-				chunks.push(...handle(node.init, state));
+				push_array(chunks, handle(node.init, state));
 			}
 		}
 
 		chunks.push(c('; '));
-		if (node.test) chunks.push(...handle(node.test, state));
+		if (node.test) push_array(chunks, handle(node.test, state));
 		chunks.push(c('; '));
-		if (node.update) chunks.push(...handle(node.update, state));
+		if (node.update) push_array(chunks, handle(node.update, state));
 
-		chunks.push(
-			c(') '),
-			...handle(node.body, state)
-		);
+		chunks.push(c(') '));
+		push_array(chunks, handle(node.body, state));
 
 		return chunks;
 	}),
@@ -7285,17 +7283,15 @@ const handlers = {
 		];
 
 		if (node.left.type === 'VariableDeclaration') {
-			chunks.push(...handle_var_declaration(node.left, state));
+			push_array(chunks, handle_var_declaration(node.left, state));
 		} else {
-			chunks.push(...handle(node.left, state));
+			push_array(chunks, handle(node.left, state));
 		}
 
-		chunks.push(
-			c(node.type === 'ForInStatement' ? ` in ` : ` of `),
-			...handle(node.right, state),
-			c(') '),
-			...handle(node.body, state)
-		);
+		chunks.push(c(node.type === 'ForInStatement' ? ` in ` : ` of `));
+		push_array(chunks, handle(node.right, state));
+		chunks.push(c(') '));
+		push_array(chunks, handle(node.body, state));
 
 		return chunks;
 	}),
@@ -7309,7 +7305,7 @@ const handlers = {
 
 		if (node.async) chunks.push(c('async '));
 		chunks.push(c(node.generator ? 'function* ' : 'function '));
-		if (node.id) chunks.push(...handle(node.id, state));
+		if (node.id) push_array(chunks, handle(node.id, state));
 		chunks.push(c('('));
 
 		const params = node.params.map(p => handle(p, {
@@ -7325,21 +7321,15 @@ const handlers = {
 		const separator = c(multiple_lines ? `,\n${state.indent}` : ', ');
 
 		if (multiple_lines) {
-			chunks.push(
-				c(`\n${state.indent}\t`),
-				...join(params, separator),
-				c(`\n${state.indent}`)
-			);
+			chunks.push(c(`\n${state.indent}\t`));
+			push_array(chunks, join(params, separator));
+			chunks.push(c(`\n${state.indent}`));
 		} else {
-			chunks.push(
-				...join(params, separator)
-			);
+			push_array(chunks, join(params, separator));
 		}
 
-		chunks.push(
-			c(') '),
-			...handle(node.body, state)
-		);
+		chunks.push(c(') '));
+		push_array(chunks, handle(node.body, state));
 
 		return chunks;
 	}),
@@ -7363,17 +7353,18 @@ const handlers = {
 	ClassDeclaration(node, state) {
 		const chunks = [c('class ')];
 
-		if (node.id) chunks.push(...handle(node.id, state), c(' '));
+		if (node.id) {
+			push_array(chunks, handle(node.id, state));
+			chunks.push(c(' '));
+		}
 
 		if (node.superClass) {
-			chunks.push(
-				c('extends '),
-				...handle(node.superClass, state),
-				c(' ')
-			);
+			chunks.push(c('extends '));
+			push_array(chunks, handle(node.superClass, state));
+			chunks.push(c(' '));
 		}
 
-		chunks.push(...handle(node.body, state));
+		push_array(chunks, handle(node.body, state));
 
 		return chunks;
 	},
@@ -7421,27 +7412,21 @@ const handlers = {
 				const width = get_length(chunks) + specifiers.map(get_length).reduce(sum, 0) + (2 * specifiers.length) + 6 + get_length(source);
 
 				if (width > 80) {
-					chunks.push(
-						c(`{\n\t`),
-						...join(specifiers, c(',\n\t')),
-						c('\n}')
-					);
+					chunks.push(c(`{\n\t`));
+					push_array(chunks, join(specifiers, c(',\n\t')));
+					chunks.push(c('\n}'));
 				} else {
-					chunks.push(
-						c(`{ `),
-						...join(specifiers, c(', ')),
-						c(' }')
-					);
+					chunks.push(c(`{ `));
+					push_array(chunks, join(specifiers, c(', ')));
+					chunks.push(c(' }'));
 				}
 			}
 
 			chunks.push(c(' from '));
 		}
 
-		chunks.push(
-			...source,
-			c(';')
-		);
+		push_array(chunks, source);
+		chunks.push(c(';'));
 
 		return chunks;
 	},
@@ -7467,7 +7452,7 @@ const handlers = {
 		const chunks = [c('export ')];
 
 		if (node.declaration) {
-			chunks.push(...handle(node.declaration, state));
+			push_array(chunks, handle(node.declaration, state));
 		} else {
 			const specifiers = node.specifiers.map((/** @type {ExportSpecifier} */ specifier) => {
 				const name = handle(specifier.local, state)[0];
@@ -7483,24 +7468,18 @@ const handlers = {
 			const width = 7 + specifiers.map(get_length).reduce(sum, 0) + 2 * specifiers.length;
 
 			if (width > 80) {
-				chunks.push(
-					c('{\n\t'),
-					...join(specifiers, c(',\n\t')),
-					c('\n}')
-				);
+				chunks.push(c('{\n\t'));
+				push_array(chunks, join(specifiers, c(',\n\t')));
+				chunks.push(c('\n}'));
 			} else {
-				chunks.push(
-					c('{ '),
-					...join(specifiers, c(', ')),
-					c(' }')
-				);
+				chunks.push(c('{ '));
+				push_array(chunks, join(specifiers, c(', ')));
+				chunks.push(c(' }'));
 			}
 
 			if (node.source) {
-				chunks.push(
-					c(' from '),
-					...handle(node.source, state)
-				);
+				chunks.push(c(' from '));
+				push_array(chunks, handle(node.source, state));
 			}
 		}
 
@@ -7538,27 +7517,23 @@ const handlers = {
 		}
 
 		if (node.computed) {
-			chunks.push(
-				c('['),
-				...handle(node.key, state),
-				c(']')
-			);
+			chunks.push(c('['));
+			push_array(chunks, handle(node.key, state));
+			chunks.push(c(']'));
 		} else {
-			chunks.push(...handle(node.key, state));
+			push_array(chunks, handle(node.key, state));
 		}
 
 		chunks.push(c('('));
 
 		const { params } = node.value;
 		for (let i = 0; i < params.length; i += 1) {
-			chunks.push(...handle(params[i], state));
+			push_array(chunks, handle(params[i], state));
 			if (i < params.length - 1) chunks.push(c(', '));
 		}
 
-		chunks.push(
-			c(') '),
-			...handle(node.value.body, state)
-		);
+		chunks.push(c(') '));
+		push_array(chunks, handle(node.value.body, state));
 
 		return chunks;
 	},
@@ -7569,18 +7544,16 @@ const handlers = {
 		if (node.async) chunks.push(c('async '));
 
 		if (node.params.length === 1 && node.params[0].type === 'Identifier') {
-			chunks.push(...handle(node.params[0], state));
+			push_array(chunks, handle(node.params[0], state));
 		} else {
 			const params = node.params.map(param => handle(param, {
 				...state,
 				indent: state.indent + '\t'
 			}));
 
-			chunks.push(
-				c('('),
-				...join(params, c(', ')),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, join(params, c(', ')));
+			chunks.push(c(')'));
 		}
 
 		chunks.push(c(' => '));
@@ -7589,13 +7562,11 @@ const handlers = {
 			node.body.type === 'ObjectExpression' ||
 			(node.body.type === 'AssignmentExpression' && node.body.left.type === 'ObjectPattern')
 		) {
-			chunks.push(
-				c('('),
-				...handle(node.body, state),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, handle(node.body, state));
+			chunks.push(c(')'));
 		} else {
-			chunks.push(...handle(node.body, state));
+			push_array(chunks, handle(node.body, state));
 		}
 
 		return chunks;
@@ -7643,10 +7614,10 @@ const handlers = {
 		for (let i = 0; i < expressions.length; i++) {
 			chunks.push(
 				c(quasis[i].value.raw),
-				c('${'),
-				...handle(expressions[i], state),
-				c('}')
+				c('${')
 			);
+			push_array(chunks, handle(expressions[i], state));
+			chunks.push(c('}'));
 		}
 
 		chunks.push(
@@ -7690,14 +7661,13 @@ const handlers = {
 		);
 
 		if (multiple_lines) {
-			chunks.push(
-				c(`\n${state.indent}\t`),
-				...join(elements, c(`,\n${state.indent}\t`)),
-				c(`\n${state.indent}`),
-				...sparse_commas
-			);
+			chunks.push(c(`\n${state.indent}\t`));
+			push_array(chunks, join(elements, c(`,\n${state.indent}\t`)));
+			chunks.push(c(`\n${state.indent}`));
+			push_array(chunks, sparse_commas);
 		} else {
-			chunks.push(...join(elements, c(', ')), ...sparse_commas);
+			push_array(chunks, join(elements, c(', ')));
+			push_array(chunks, sparse_commas);
 		}
 
 		chunks.push(c(']'));
@@ -7717,7 +7687,7 @@ const handlers = {
 		const separator = c(', ');
 
 		node.properties.forEach((p, i) => {
-			chunks.push(...handle(p, {
+			push_array(chunks, handle(p, {
 				...state,
 				indent: state.indent + '\t'
 			}));
@@ -7805,13 +7775,11 @@ const handlers = {
 				chunks.push(c('*'));
 			}
 
-			chunks.push(
-				...(node.computed ? [c('['), ...key, c(']')] : key),
-				c('('),
-				...join(node.value.params.map((/** @type {Pattern} */ param) => handle(param, state)), c(', ')),
-				c(') '),
-				...handle(node.value.body, state)
-			);
+			push_array(chunks, node.computed ? [c('['), ...key, c(']')] : key);
+			chunks.push(c('('));
+			push_array(chunks, join(node.value.params.map((/** @type {Pattern} */ param) => handle(param, state)), c(', ')));
+			chunks.push(c(') '));
+			push_array(chunks, handle(node.value.body, state));
 
 			return chunks;
 		}
@@ -7836,7 +7804,7 @@ const handlers = {
 		const chunks = [c('{ ')];
 
 		for (let i = 0; i < node.properties.length; i += 1) {
-			chunks.push(...handle(node.properties[i], state));
+			push_array(chunks, handle(node.properties[i], state));
 			if (i < node.properties.length - 1) chunks.push(c(', '));
 		}
 
@@ -7866,13 +7834,11 @@ const handlers = {
 			EXPRESSIONS_PRECEDENCE[node.argument.type] <
 			EXPRESSIONS_PRECEDENCE.UnaryExpression
 		) {
-			chunks.push(
-				c('('),
-				...handle(node.argument, state),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, handle(node.argument, state));
+			chunks.push(c(')'));
 		} else {
-			chunks.push(...handle(node.argument, state));
+			push_array(chunks, handle(node.argument, state));
 		}
 
 		return chunks;
@@ -7893,6 +7859,9 @@ const handlers = {
 	},
 
 	BinaryExpression(node, state) {
+		/**
+		 * @type any[]
+		 */
 		const chunks = [];
 
 		// TODO
@@ -7903,44 +7872,41 @@ const handlers = {
 		// }
 
 		if (needs_parens(node.left, node, false)) {
-			chunks.push(
-				c('('),
-				...handle(node.left, state),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, handle(node.left, state));
+			chunks.push(c(')'));
 		} else {
-			chunks.push(...handle(node.left, state));
+			push_array(chunks, handle(node.left, state));
 		}
 
 		chunks.push(c(` ${node.operator} `));
 
 		if (needs_parens(node.right, node, true)) {
-			chunks.push(
-				c('('),
-				...handle(node.right, state),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, handle(node.right, state));
+			chunks.push(c(')'));
 		} else {
-			chunks.push(...handle(node.right, state));
+			push_array(chunks, handle(node.right, state));
 		}
 
 		return chunks;
 	},
 
 	ConditionalExpression(node, state) {
+		/**
+		 * @type any[]
+		 */
 		const chunks = [];
 
 		if (
 			EXPRESSIONS_PRECEDENCE[node.test.type] >
 			EXPRESSIONS_PRECEDENCE.ConditionalExpression
 		) {
-			chunks.push(...handle(node.test, state));
+			push_array(chunks, handle(node.test, state));
 		} else {
-			chunks.push(
-				c('('),
-				...handle(node.test, state),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, handle(node.test, state));
+			chunks.push(c(')'));
 		}
 
 		const child_state = { ...state, indent: state.indent + '\t' };
@@ -7954,19 +7920,15 @@ const handlers = {
 		);
 
 		if (multiple_lines) {
-			chunks.push(
-				c(`\n${state.indent}? `),
-				...consequent,
-				c(`\n${state.indent}: `),
-				...alternate
-			);
+			chunks.push(c(`\n${state.indent}? `));
+			push_array(chunks, consequent);
+			chunks.push(c(`\n${state.indent}: `));
+			push_array(chunks, alternate);
 		} else {
-			chunks.push(
-				c(` ? `),
-				...consequent,
-				c(` : `),
-				...alternate
-			);
+			chunks.push(c(` ? `));
+			push_array(chunks, consequent);
+			chunks.push(c(` : `));
+			push_array(chunks, alternate);
 		}
 
 		return chunks;
@@ -7979,13 +7941,11 @@ const handlers = {
 			EXPRESSIONS_PRECEDENCE[node.callee.type] <
 			EXPRESSIONS_PRECEDENCE.CallExpression || has_call_expression(node.callee)
 		) {
-			chunks.push(
-				c('('),
-				...handle(node.callee, state),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, handle(node.callee, state));
+			chunks.push(c(')'));
 		} else {
-			chunks.push(...handle(node.callee, state));
+			push_array(chunks, handle(node.callee, state));
 		}
 
 		// TODO this is copied from CallExpression — DRY it out
@@ -7998,11 +7958,9 @@ const handlers = {
 			? c(',\n' + state.indent)
 			: c(', ');
 
-		chunks.push(
-			c('('),
-			...join(args, separator),
-			c(')')
-		);
+		chunks.push(c('('));
+		push_array(chunks, join(args, separator));
+		chunks.push(c(')'));
 
 		return chunks;
 	},
@@ -8012,19 +7970,20 @@ const handlers = {
 	},
 
 	CallExpression(/** @type {CallExpression} */ node, state) {
+		/**
+		 * @type any[]
+		 */
 		const chunks = [];
 
 		if (
 			EXPRESSIONS_PRECEDENCE[node.callee.type] <
 			EXPRESSIONS_PRECEDENCE.CallExpression
 		) {
-			chunks.push(
-				c('('),
-				...handle(node.callee, state),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, handle(node.callee, state));
+			chunks.push(c(')'));
 		} else {
-			chunks.push(...handle(node.callee, state));
+			push_array(chunks, handle(node.callee, state));
 		}
 
 		if (/** @type {SimpleCallExpression} */ (node).optional) {
@@ -8042,49 +8001,42 @@ const handlers = {
 				indent: `${state.indent}\t`
 			}));
 
-			chunks.push(
-				c(`(\n${state.indent}\t`),
-				...join(args, c(`,\n${state.indent}\t`)),
-				c(`\n${state.indent})`)
-			);
+			chunks.push(c(`(\n${state.indent}\t`));
+			push_array(chunks, join(args, c(`,\n${state.indent}\t`)));
+			chunks.push(c(`\n${state.indent})`));
 		} else {
-			chunks.push(
-				c('('),
-				...join(args, c(', ')),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, join(args, c(', ')));
+			chunks.push(c(')'));
 		}
 
 		return chunks;
 	},
 
 	MemberExpression(node, state) {
+		/**
+		 * @type any[]
+		 */
 		const chunks = [];
 
 		if (EXPRESSIONS_PRECEDENCE[node.object.type] < EXPRESSIONS_PRECEDENCE.MemberExpression) {
-			chunks.push(
-				c('('),
-				...handle(node.object, state),
-				c(')')
-			);
+			chunks.push(c('('));
+			push_array(chunks, handle(node.object, state));
+			chunks.push(c(')'));
 		} else {
-			chunks.push(...handle(node.object, state));
+			push_array(chunks, handle(node.object, state));
 		}
 
 		if (node.computed) {
 			if (node.optional) {
 				chunks.push(c('?.'));
 			}
-			chunks.push(
-				c('['),
-				...handle(node.property, state),
-				c(']')
-			);
+			chunks.push(c('['));
+			push_array(chunks, handle(node.property, state));
+			chunks.push(c(']'));
 		} else {
-			chunks.push(
-				c(node.optional ? '?.' : '.'),
-				...handle(node.property, state)
-			);
+			chunks.push(c(node.optional ? '?.' : '.'));
+			push_array(chunks, handle(node.property, state));
 		}
 
 		return chunks;
@@ -19113,7 +19065,11 @@ var compiler_errors = {
     cyclical_const_tags: (cycle) => ({
         code: 'cyclical-const-tags',
         message: `Cyclical dependency detected: ${cycle.join(' → ')}`
-    })
+    }),
+    invalid_component_style_directive: {
+        code: 'invalid-component-style-directive',
+        message: 'Style directives cannot be used on components'
+    }
 };
 
 class Expression {
@@ -20137,6 +20093,21 @@ class Text extends Node$1 {
         }
         return parent_element.namespace || elements_without_text.has(parent_element.name);
     }
+    keep_space() {
+        if (this.component.component_options.preserveWhitespace)
+            return true;
+        return this.within_pre();
+    }
+    within_pre() {
+        let node = this.parent;
+        while (node) {
+            if (node.type === 'Element' && node.name === 'pre') {
+                return true;
+            }
+            node = node.parent;
+        }
+        return false;
+    }
 }
 
 // The `foreign` namespace covers all DOM implementations that aren't HTML5.
@@ -20991,6 +20962,8 @@ class InlineComponent extends Node$1 {
                     break;
                 case 'Transition':
                     return component.error(node, compiler_errors.invalid_transition);
+                case 'StyleDirective':
+                    return component.error(node, compiler_errors.invalid_component_style_directive);
                 default:
                     throw new Error(`Not implemented: ${node.type}`);
             }
@@ -21272,6 +21245,19 @@ class Window extends Node$1 {
     }
 }
 
+/**
+ * Pushes all `items` into `array` using `push`, therefore mutating the array.
+ * We do this for memory and perf reasons, and because `array.push(...items)` would
+ * run into a "max call stack size exceeded" error with too many items (~65k).
+ * @param array
+ * @param items
+ */
+function push_array$1(array, items) {
+    for (let i = 0; i < items.length; i++) {
+        array.push(items[i]);
+    }
+}
+
 function get_constructor(type) {
     switch (type) {
         case 'AwaitBlock': return AwaitBlock;
@@ -21308,7 +21294,7 @@ function map_children(component, parent, scope, children) {
         if (use_ignores)
             component.pop_ignores(), ignores = [];
         if (node.type === 'Comment' && node.ignores.length) {
-            ignores.push(...node.ignores);
+            push_array$1(ignores, node.ignores);
         }
         if (last)
             last.next = node;
@@ -22254,14 +22240,7 @@ class TextWrapper extends Wrapper {
             return false;
         if (/[\S\u00A0]/.test(this.data))
             return false;
-        let node = this.parent && this.parent.node;
-        while (node) {
-            if (node.type === 'Element' && node.name === 'pre') {
-                return false;
-            }
-            node = node.parent;
-        }
-        return true;
+        return !this.node.within_pre();
     }
     render(block, parent_node, parent_nodes) {
         if (this.skip)
@@ -23754,7 +23733,7 @@ class ElementWrapper extends Wrapper {
         this.attributes.forEach((attribute) => {
             if (attribute.node.name === 'class') {
                 const dependencies = attribute.node.get_dependencies();
-                this.class_dependencies.push(...dependencies);
+                push_array$1(this.class_dependencies, dependencies);
             }
         });
         if (this.node.attributes.some(attr => attr.is_spread)) {
@@ -24228,7 +24207,7 @@ class IfBlockWrapper extends Wrapper {
             block.has_intro_method = has_intros;
             block.has_outro_method = has_outros;
         });
-        renderer.blocks.push(...blocks);
+        push_array$1(renderer.blocks, blocks);
     }
     render(block, parent_node, parent_nodes) {
         const name = this.var;
@@ -25721,7 +25700,7 @@ class FragmentWrapper {
                 // *unless* there is no whitespace between this node and its next sibling
                 if (this.nodes.length === 0) {
                     const should_trim = (next_sibling ? (next_sibling.node.type === 'Text' && /^\s/.test(next_sibling.node.data) && trimmable_at(child, next_sibling)) : !child.has_ancestor('EachBlock'));
-                    if (should_trim) {
+                    if (should_trim && !child.keep_space()) {
                         data = trim_end(data);
                         if (!data)
                             continue;
@@ -25749,7 +25728,7 @@ class FragmentWrapper {
         }
         if (strip_whitespace) {
             const first = this.nodes[0];
-            if (first && first.node.type === 'Text') {
+            if (first && first.node.type === 'Text' && !first.node.keep_space()) {
                 first.data = trim_start(first.data);
                 if (!first.data) {
                     first.var = null;
@@ -26808,13 +26787,6 @@ function merge_tables(this_table, other_table) {
     }
     return [new_table, idx_map, val_changed, idx_changed];
 }
-function pushArray(_this, other) {
-    // We use push to mutate in place for memory and perf reasons
-    // We use the for loop instead of _this.push(...other) to avoid the JS engine's function argument limit (65,535 in JavascriptCore)
-    for (let i = 0; i < other.length; i++) {
-        _this.push(other[i]);
-    }
-}
 class MappedCode {
     constructor(string = '', map = null) {
         this.string = string;
@@ -26902,9 +26874,9 @@ class MappedCode {
             }
         }
         // combine last line + first line
-        pushArray(m1.mappings[m1.mappings.length - 1], m2.mappings.shift());
+        push_array$1(m1.mappings[m1.mappings.length - 1], m2.mappings.shift());
         // append other lines
-        pushArray(m1.mappings, m2.mappings);
+        push_array$1(m1.mappings, m2.mappings);
         return this;
     }
     static from_processed(string, map) {
@@ -27095,7 +27067,7 @@ function dom(component, options) {
     // fix order
     // TODO the deconflicted names of blocks are reversed... should set them here
     const blocks = renderer.blocks.slice().reverse();
-    body.push(...blocks.map(block => {
+    push_array$1(body, blocks.map(block => {
         // TODO this is a horrible mess — renderer.blocks
         // contains a mixture of Blocks and Nodes
         if (block.render)
@@ -27516,7 +27488,7 @@ function dom(component, options) {
 				}`
             });
         }
-        declaration.body.body.push(...accessors);
+        push_array$1(declaration.body.body, accessors);
         body.push(declaration);
         if (component.tag != null) {
             body.push(b `
@@ -27550,7 +27522,7 @@ function dom(component, options) {
 				}
 			}
 		`[0];
-        declaration.body.body.push(...accessors);
+        push_array$1(declaration.body.body, accessors);
         body.push(declaration);
     }
     return { js: flatten(body), css };
@@ -27701,7 +27673,7 @@ function remove_whitespace_children(children, next) {
                         /^\s/.test(next.data) &&
                         trimmable_at$1(child, next)
                     : !child.has_ancestor('EachBlock');
-                if (should_trim) {
+                if (should_trim && !child.keep_space()) {
                     data = trim_end(data);
                     if (!data)
                         continue;
@@ -27721,7 +27693,7 @@ function remove_whitespace_children(children, next) {
         }
     }
     const first = nodes[0];
-    if (first && first.type === 'Text') {
+    if (first && first.type === 'Text' && !first.keep_space()) {
         first.data = trim_start(first.data);
         if (!first.data) {
             first.var = null;
@@ -30370,7 +30342,7 @@ class Stylesheet {
                             const at_rule_declarations = node.block.children
                                 .filter(node => node.type === 'Declaration')
                                 .map(node => new Declaration$1(node));
-                            atrule.declarations.push(...at_rule_declarations);
+                            push_array$1(atrule.declarations, at_rule_declarations);
                         }
                         current_atrule = atrule;
                     }
@@ -30694,7 +30666,7 @@ class Component {
         if (result) {
             const { compile_options, name } = this;
             const { format = 'esm' } = compile_options;
-            const banner = `${this.file ? `${this.file} ` : ''}generated by Svelte v${'3.46.3'}`;
+            const banner = `${this.file ? `${this.file} ` : ''}generated by Svelte v${'3.46.4'}`;
             const program = { type: 'Program', body: result.js };
             walk(program, {
                 enter: (node, parent, key) => {
@@ -32187,7 +32159,7 @@ async function preprocess(source, preprocessor, options) {
     return result.to_processed();
 }
 
-const VERSION = '3.46.3';
+const VERSION = '3.46.4';
 
 export { VERSION, compile, parse$3 as parse, preprocess, walk };
 //# sourceMappingURL=compiler.mjs.map