svelte 3.44.0 → 3.45.0

package/compiler.mjs

@@ -6492,7 +6492,7 @@ const handlers = {
 	}),
 
 	EmptyStatement(node, state) {
-		return [];
+		return [c(';')];
 	},
 
 	ParenthesizedExpression(node, state) {
@@ -6598,10 +6598,11 @@ const handlers = {
 
 	ReturnStatement(node, state) {
 		if (node.argument) {
+			const contains_comment = node.argument.leadingComments && node.argument.leadingComments.some((/** @type import('../utils/comments.js').CommentWithLocation */ comment) => comment.has_trailing_newline);
 			return [
-				c('return '),
+				c(contains_comment ? 'return (' : 'return '),
 				...handle(node.argument, state),
-				c(';')
+				c(contains_comment ? ');' : ';')
 			];
 		} else {
 			return [c('return;')];
@@ -6992,7 +6993,10 @@ const handlers = {
 
 		chunks.push(c(' => '));
 
-		if (node.body.type === 'ObjectExpression') {
+		if (
+			node.body.type === 'ObjectExpression' ||
+			(node.body.type === 'AssignmentExpression' && node.body.left.type === 'ObjectPattern')
+		) {
 			chunks.push(
 				c('('),
 				...handle(node.body, state),
@@ -7955,7 +7959,7 @@ const inject = (raw, node, values, comments) => {
 
 	const { enter, leave } = get_comment_handlers(comments, raw);
 
-	walk(node, {
+	return walk(node, {
 		enter,
 
 		/** @param {any} node */
@@ -8057,7 +8061,6 @@ const inject = (raw, node, values, comments) => {
 				node.update = node.update === EMPTY ? null : node.update;
 			}
 
-			// @ts-ignore
 			leave(node);
 		}
 	});
@@ -8076,11 +8079,11 @@ function b(strings, ...values) {
 	const comments = [];
 
 	try {
-		const ast = /** @type {any} */ (
+		let ast = /** @type {any} */ (
 			parse(str, acorn_opts(comments, str))
 		);
 
-		inject(str, ast, values, comments);
+		ast = inject(str, ast, values, comments);
 
 		return ast.body;
 	} catch (err) {
@@ -8101,7 +8104,7 @@ function x(strings, ...values) {
 	const comments = [];
 
 	try {
-		const expression =
+		let expression =
 			/** @type {Expression & { start: Number, end: number }} */ (
 				parseExpressionAt(str, 0, acorn_opts(comments, str))
 			);
@@ -8110,7 +8113,9 @@ function x(strings, ...values) {
 			throw new Error(`Unexpected token '${match[0]}'`);
 		}
 
-		inject(str, expression, values, comments);
+		expression = /** @type {Expression & { start: Number, end: number }} */ (
+			inject(str, expression, values, comments)
+		);
 
 		return expression;
 	} catch (err) {
@@ -8131,11 +8136,11 @@ function p(strings, ...values) {
 	const comments = [];
 
 	try {
-		const expression = /** @type {any} */ (
+		let expression = /** @type {any} */ (
 			parseExpressionAt(str, 0, acorn_opts(comments, str))
 		);
 
-		inject(str, expression, values, comments);
+		expression = inject(str, expression, values, comments);
 
 		return expression.properties[0];
 	} catch (err) {
@@ -8204,6 +8209,8 @@ const parse_expression_at = (source, index) => parseExpressionAt$1(source, index
 });
 
 const whitespace = /[ \t\r\n]/;
+const start_whitespace = /^[ \t\r\n]*/;
+const end_whitespace = /[ \t\r\n]*$/;
 const dimensions = /^(?:offset|client)(?:Width|Height)$/;
 
 function list(items, conjunction = 'or') {
@@ -16390,6 +16397,7 @@ const globals = new Set([
     'undefined',
     'URIError',
     'URL',
+    'URLSearchParams',
     'window'
 ]);
 const reserved = new Set([
@@ -17218,16 +17226,10 @@ function read_context(parser) {
 }
 
 function trim_start(str) {
-    let i = 0;
-    while (whitespace.test(str[i]))
-        i += 1;
-    return str.slice(i);
+    return str.replace(start_whitespace, '');
 }
 function trim_end(str) {
-    let i = str.length;
-    while (whitespace.test(str[i - 1]))
-        i -= 1;
-    return str.slice(0, i);
+    return str.replace(end_whitespace, '');
 }
 
 function to_string(node) {
@@ -19218,7 +19220,7 @@ function fix_attribute_casing(name) {
 
 // The `foreign` namespace covers all DOM implementations that aren't HTML5.
 // It opts out of HTML5-specific a11y checks and case-insensitive attribute names.
-const foreign = 'https://svelte.dev/docs#svelte_options';
+const foreign = 'https://svelte.dev/docs#template-syntax-svelte-options';
 const html = 'http://www.w3.org/1999/xhtml';
 const mathml = 'http://www.w3.org/1998/Math/MathML';
 const svg = 'http://www.w3.org/2000/svg';
@@ -19253,6 +19255,20 @@ function handle_select_value_binding(attr, dependencies) {
     }
 }
 
+const non_textlike_input_types = new Set([
+    'button',
+    'checkbox',
+    'color',
+    'date',
+    'datetime-local',
+    'file',
+    'hidden',
+    'image',
+    'radio',
+    'range',
+    'reset',
+    'submit'
+]);
 class BaseAttributeWrapper {
     constructor(parent, block, node) {
         this.node = node;
@@ -19399,7 +19415,7 @@ class AttributeWrapper extends BaseAttributeWrapper {
         }
         if (this.is_input_value) {
             const type = element.node.get_static_attribute_value('type');
-            if (type === null || type === '' || type === 'text' || type === 'email' || type === 'password') {
+            if (type !== true && !non_textlike_input_types.has(type)) {
                 condition = x `${condition} && ${element.var}.${property_name} !== ${should_cache ? last : value}`;
             }
         }
@@ -19836,6 +19852,28 @@ class BindingWrapper {
         });
         return dependencies;
     }
+    get_update_dependencies() {
+        const object = this.object;
+        const dependencies = new Set();
+        if (this.node.expression.template_scope.names.has(object)) {
+            this.node.expression.template_scope.dependencies_for_name
+                .get(object)
+                .forEach((name) => dependencies.add(name));
+        }
+        else {
+            dependencies.add(object);
+        }
+        const result = new Set(dependencies);
+        dependencies.forEach((dependency) => {
+            const indirect_dependencies = this.parent.renderer.component.indirect_dependencies.get(dependency);
+            if (indirect_dependencies) {
+                indirect_dependencies.forEach(indirect_dependency => {
+                    result.add(indirect_dependency);
+                });
+            }
+        });
+        return result;
+    }
     is_readonly_media_attribute() {
         return this.node.is_readonly_media_attribute();
     }
@@ -20127,7 +20165,7 @@ function bind_this(component, block, binding, variable) {
     block.renderer.add_to_context(fn.name);
     const callee = block.renderer.reference(fn.name);
     const { contextual_dependencies, mutation } = binding.handler;
-    const dependencies = binding.get_dependencies();
+    const dependencies = binding.get_update_dependencies();
     const body = b `
 		${mutation}
 		${Array.from(dependencies)
@@ -21439,7 +21477,7 @@ class ElementWrapper extends Wrapper {
         const contextual_dependencies = new Set();
         binding_group.bindings.forEach(binding => {
             // TODO this is a mess
-            add_to_set(dependencies, binding.get_dependencies());
+            add_to_set(dependencies, binding.get_update_dependencies());
             add_to_set(contextual_dependencies, binding.handler.contextual_dependencies);
             binding.render(block, lock);
         });
@@ -22044,12 +22082,13 @@ class IfBlockWrapper extends Wrapper {
         if (this.needs_update) {
             block.chunks.init.push(b `
 				function ${select_block_type}(#ctx, #dirty) {
-					${this.branches.map(({ dependencies, condition, snippet, block }) => condition
+					${this.branches.map(({ dependencies, condition, snippet }) => {
+                return b `${snippet && dependencies.length > 0 ? b `if (${block.renderer.dirty(dependencies)}) ${condition} = null;` : null}`;
+            })}
+					${this.branches.map(({ condition, snippet, block }) => condition
                 ? b `
-					${snippet && (dependencies.length > 0
-                    ? b `if (${condition} == null || ${block.renderer.dirty(dependencies)}) ${condition} = !!${snippet}`
-                    : b `if (${condition} == null) ${condition} = !!${snippet}`)}
-					if (${condition}) return ${block.name};`
+						${snippet && b `if (${condition} == null) ${condition} = !!${snippet}`}
+						if (${condition}) return ${block.name};`
                 : b `return ${block.name};`)}
 				}
 			`);
@@ -22147,11 +22186,12 @@ class IfBlockWrapper extends Wrapper {
 			${this.needs_update
             ? b `
 					function ${select_block_type}(#ctx, #dirty) {
-						${this.branches.map(({ dependencies, condition, snippet }, i) => condition
+						${this.branches.map(({ dependencies, condition, snippet }) => {
+                return b `${snippet && dependencies.length > 0 ? b `if (${block.renderer.dirty(dependencies)}) ${condition} = null;` : null}`;
+            })}
+						${this.branches.map(({ condition, snippet }, i) => condition
                 ? b `
-						${snippet && (dependencies.length > 0
-                    ? b `if (${condition} == null || ${block.renderer.dirty(dependencies)}) ${condition} = !!${snippet}`
-                    : b `if (${condition} == null) ${condition} = !!${snippet}`)}
+						${snippet && b `if (${condition} == null) ${condition} = !!${snippet}`}
 						if (${condition}) return ${i};`
                 : b `return ${i};`)}
 						${!has_else && b `return -1;`}
@@ -22625,6 +22665,10 @@ var compiler_warnings = {
         code: 'a11y-unknown-role',
         message: `A11y: Unknown role '${role}'` + (suggestion ? ` (did you mean '${suggestion}'?)` : '')
     }),
+    a11y_no_redundant_roles: (role) => ({
+        code: 'a11y-no-redundant-roles',
+        message: `A11y: Redundant role '${role}'`
+    }),
     a11y_accesskey: {
         code: 'a11y-accesskey',
         message: 'A11y: Avoid using accesskey'
@@ -25958,7 +26002,7 @@ class CatchBlock extends AbstractBlock {
     }
 }
 
-function unpack_destructuring(contexts, node, modifier = node => node, default_modifier = node => node) {
+function unpack_destructuring({ contexts, node, modifier = (node) => node, default_modifier = (node) => node, scope, component }) {
     if (!node)
         return;
     if (node.type === 'Identifier') {
@@ -25978,14 +26022,36 @@ function unpack_destructuring(contexts, node, modifier = node => node, default_m
     else if (node.type === 'ArrayPattern') {
         node.elements.forEach((element, i) => {
             if (element && element.type === 'RestElement') {
-                unpack_destructuring(contexts, element, node => x `${modifier(node)}.slice(${i})`, default_modifier);
+                unpack_destructuring({
+                    contexts,
+                    node: element,
+                    modifier: (node) => x `${modifier(node)}.slice(${i})`,
+                    default_modifier,
+                    scope,
+                    component
+                });
             }
             else if (element && element.type === 'AssignmentPattern') {
                 const n = contexts.length;
-                unpack_destructuring(contexts, element.left, node => x `${modifier(node)}[${i}]`, (node, to_ctx) => x `${node} !== undefined ? ${node} : ${update_reference(contexts, n, element.right, to_ctx)}`);
+                mark_referenced(element.right, scope, component);
+                unpack_destructuring({
+                    contexts,
+                    node: element.left,
+                    modifier: (node) => x `${modifier(node)}[${i}]`,
+                    default_modifier: (node, to_ctx) => x `${node} !== undefined ? ${node} : ${update_reference(contexts, n, element.right, to_ctx)}`,
+                    scope,
+                    component
+                });
             }
             else {
-                unpack_destructuring(contexts, element, node => x `${modifier(node)}[${i}]`, default_modifier);
+                unpack_destructuring({
+                    contexts,
+                    node: element,
+                    modifier: (node) => x `${modifier(node)}[${i}]`,
+                    default_modifier,
+                    scope,
+                    component
+                });
             }
         });
     }
@@ -25993,7 +26059,14 @@ function unpack_destructuring(contexts, node, modifier = node => node, default_m
         const used_properties = [];
         node.properties.forEach((property) => {
             if (property.type === 'RestElement') {
-                unpack_destructuring(contexts, property.argument, node => x `@object_without_properties(${modifier(node)}, [${used_properties}])`, default_modifier);
+                unpack_destructuring({
+                    contexts,
+                    node: property.argument,
+                    modifier: (node) => x `@object_without_properties(${modifier(node)}, [${used_properties}])`,
+                    default_modifier,
+                    scope,
+                    component
+                });
             }
             else {
                 const key = property.key;
@@ -26001,10 +26074,25 @@ function unpack_destructuring(contexts, node, modifier = node => node, default_m
                 used_properties.push(x `"${key.name}"`);
                 if (value.type === 'AssignmentPattern') {
                     const n = contexts.length;
-                    unpack_destructuring(contexts, value.left, node => x `${modifier(node)}.${key.name}`, (node, to_ctx) => x `${node} !== undefined ? ${node} : ${update_reference(contexts, n, value.right, to_ctx)}`);
+                    mark_referenced(value.right, scope, component);
+                    unpack_destructuring({
+                        contexts,
+                        node: value.left,
+                        modifier: (node) => x `${modifier(node)}.${key.name}`,
+                        default_modifier: (node, to_ctx) => x `${node} !== undefined ? ${node} : ${update_reference(contexts, n, value.right, to_ctx)}`,
+                        scope,
+                        component
+                    });
                 }
                 else {
-                    unpack_destructuring(contexts, value, node => x `${modifier(node)}.${key.name}`, default_modifier);
+                    unpack_destructuring({
+                        contexts,
+                        node: value,
+                        modifier: (node) => x `${modifier(node)}.${key.name}`,
+                        default_modifier,
+                        scope,
+                        component
+                    });
                 }
             }
         });
@@ -26035,6 +26123,18 @@ function update_reference(contexts, n, expression, to_ctx) {
     });
     return expression;
 }
+function mark_referenced(node, scope, component) {
+    walk(node, {
+        enter(node, parent) {
+            if (is_reference(node, parent)) {
+                const { name } = flatten_reference(node);
+                if (!scope.is_let(name) && !scope.names.has(name)) {
+                    component.add_reference(name);
+                }
+            }
+        }
+    });
+}
 
 class AwaitBlock$1 extends Node$1 {
     constructor(component, parent, scope, info) {
@@ -26044,11 +26144,11 @@ class AwaitBlock$1 extends Node$1 {
         this.catch_node = info.error;
         if (this.then_node) {
             this.then_contexts = [];
-            unpack_destructuring(this.then_contexts, info.value);
+            unpack_destructuring({ contexts: this.then_contexts, node: info.value, scope, component });
         }
         if (this.catch_node) {
             this.catch_contexts = [];
-            unpack_destructuring(this.catch_contexts, info.error);
+            unpack_destructuring({ contexts: this.catch_contexts, node: info.error, scope, component });
         }
         this.pending = new PendingBlock(component, this, scope, info.pending);
         this.then = new ThenBlock(component, this, scope, info.then);
@@ -26144,7 +26244,7 @@ class EachBlock$1 extends AbstractBlock {
         this.index = info.index;
         this.scope = scope.child();
         this.contexts = [];
-        unpack_destructuring(this.contexts, info.context);
+        unpack_destructuring({ contexts: this.contexts, node: info.context, scope, component });
         this.contexts.forEach(context => {
             this.scope.add(context.key.name, this.expression.dependencies, this);
         });
@@ -26479,6 +26579,44 @@ const a11y_labelable = new Set([
     'select',
     'textarea'
 ]);
+const a11y_nested_implicit_semantics = new Map([
+    ['header', 'banner'],
+    ['footer', 'contentinfo']
+]);
+const a11y_implicit_semantics = new Map([
+    ['a', 'link'],
+    ['aside', 'complementary'],
+    ['body', 'document'],
+    ['datalist', 'listbox'],
+    ['dd', 'definition'],
+    ['dfn', 'term'],
+    ['details', 'group'],
+    ['dt', 'term'],
+    ['fieldset', 'group'],
+    ['form', 'form'],
+    ['h1', 'heading'],
+    ['h2', 'heading'],
+    ['h3', 'heading'],
+    ['h4', 'heading'],
+    ['h5', 'heading'],
+    ['h6', 'heading'],
+    ['hr', 'separator'],
+    ['li', 'listitem'],
+    ['menu', 'list'],
+    ['nav', 'navigation'],
+    ['ol', 'list'],
+    ['optgroup', 'group'],
+    ['output', 'status'],
+    ['progress', 'progressbar'],
+    ['section', 'region'],
+    ['summary', 'button'],
+    ['tbody', 'rowgroup'],
+    ['textarea', 'textbox'],
+    ['tfoot', 'rowgroup'],
+    ['thead', 'rowgroup'],
+    ['tr', 'row'],
+    ['ul', 'list']
+]);
 const invisible_elements = new Set(['meta', 'html', 'script', 'style']);
 const valid_modifiers = new Set([
     'preventDefault',
@@ -26502,6 +26640,21 @@ const react_attributes = new Map([
     ['htmlFor', 'for']
 ]);
 const attributes_to_compact_whitespace = ['class', 'style'];
+function is_parent(parent, elements) {
+    let check = false;
+    while (parent) {
+        const parent_name = parent.name;
+        if (elements.includes(parent_name)) {
+            check = true;
+            break;
+        }
+        if (parent.type === 'Element') {
+            break;
+        }
+        parent = parent.parent;
+    }
+    return check;
+}
 function get_namespace(parent, element, explicit_namespace) {
     const parent_element = parent.find_nearest(/^Element/);
     if (!parent_element) {
@@ -26707,6 +26860,19 @@ class Element$1 extends Node$1 {
                     const match = fuzzymatch(value, aria_roles);
                     component.warn(attribute, compiler_warnings.a11y_unknown_role(value, match));
                 }
+                // no-redundant-roles
+                const has_redundant_role = value === a11y_implicit_semantics.get(this.name);
+                if (this.name === value || has_redundant_role) {
+                    component.warn(attribute, compiler_warnings.a11y_no_redundant_roles(value));
+                }
+                // Footers and headers are special cases, and should not have redundant roles unless they are the children of sections or articles.
+                const is_parent_section_or_article = is_parent(this.parent, ['section', 'article']);
+                if (!is_parent_section_or_article) {
+                    const has_nested_redundant_role = value === a11y_nested_implicit_semantics.get(this.name);
+                    if (has_nested_redundant_role) {
+                        component.warn(attribute, compiler_warnings.a11y_no_redundant_roles(value));
+                    }
+                }
             }
             // no-access-key
             if (name === 'accesskey') {
@@ -30136,7 +30302,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.44.0'}`;
+            const banner = `${this.file ? `${this.file} ` : ''}generated by Svelte v${'3.45.0'}`;
             const program = { type: 'Program', body: result.js };
             walk(program, {
                 enter: (node, parent, key) => {
@@ -30560,11 +30726,12 @@ class Component {
             to_remove.unshift([parent, prop, index]);
         };
         let scope_updated = false;
-        let generator_count = 0;
+        const current_function_stack = [];
+        let current_function = null;
         walk(content, {
             enter(node, parent, prop, index) {
-                if ((node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') && node.generator === true) {
-                    generator_count++;
+                if ((node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression')) {
+                    current_function_stack.push(current_function = node);
                 }
                 if (map.has(node)) {
                     scope = map.get(node);
@@ -30589,11 +30756,12 @@ class Component {
                 component.warn_on_undefined_store_value_references(node, parent, prop, scope);
             },
             leave(node) {
-                if ((node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') && node.generator === true) {
-                    generator_count--;
+                if ((node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression')) {
+                    current_function_stack.pop();
+                    current_function = current_function_stack[current_function_stack.length - 1];
                 }
                 // do it on leave, to prevent infinite loop
-                if (component.compile_options.dev && component.compile_options.loopGuardTimeout > 0 && generator_count <= 0) {
+                if (component.compile_options.dev && component.compile_options.loopGuardTimeout > 0 && (!current_function || (!current_function.generator && !current_function.async))) {
                     const to_replace_for_loop_protect = component.loop_protect(node, scope, component.compile_options.loopGuardTimeout);
                     if (to_replace_for_loop_protect) {
                         this.replace(to_replace_for_loop_protect);
@@ -31583,10 +31751,10 @@ async function process_tag(tag_name, preprocessor, source) {
     const { string, map } = await replace_in_code(tag_regex, process_single_tag, source);
     return { string, map, dependencies };
 }
-async function process_markup(filename, process, source) {
+async function process_markup(process, source) {
     const processed = await process({
         content: source.source,
-        filename
+        filename: source.filename
     });
     if (processed) {
         return {
@@ -31605,7 +31773,6 @@ async function process_markup(filename, process, source) {
     }
 }
 async function preprocess(source, preprocessor, options) {
-    // @ts-ignore todo: doublecheck
     const filename = (options && options.filename) || preprocessor.filename; // legacy
     const preprocessors = preprocessor ? (Array.isArray(preprocessor) ? preprocessor : [preprocessor]) : [];
     const markup = preprocessors.map(p => p.markup).filter(Boolean);
@@ -31615,7 +31782,7 @@ async function preprocess(source, preprocessor, options) {
     // TODO keep track: what preprocessor generated what sourcemap?
     // to make debugging easier = detect low-resolution sourcemaps in fn combine_mappings
     for (const process of markup) {
-        result.update_source(await process_markup(filename, process, result));
+        result.update_source(await process_markup(process, result));
     }
     for (const process of script) {
         result.update_source(await process_tag('script', process, result));
@@ -31626,7 +31793,7 @@ async function preprocess(source, preprocessor, options) {
     return result.to_processed();
 }
 
-const VERSION = '3.44.0';
+const VERSION = '3.45.0';
 
 export { VERSION, compile, parse$3 as parse, preprocess, walk };
 //# sourceMappingURL=compiler.mjs.map