svelte 3.44.3 → 3.45.0

package/compiler.mjs

@@ -6993,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),
@@ -19217,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';
@@ -19849,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();
     }
@@ -20140,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)
@@ -21452,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);
         });
@@ -22057,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};`)}
 				}
 			`);
@@ -22160,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;`}
@@ -22638,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'
@@ -25971,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') {
@@ -25991,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
+                });
             }
         });
     }
@@ -26006,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;
@@ -26014,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
+                    });
                 }
             }
         });
@@ -26048,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) {
@@ -26057,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);
@@ -26157,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);
         });
@@ -26492,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',
@@ -26515,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) {
@@ -26720,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') {
@@ -30149,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.3'}`;
+            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) => {
@@ -31640,7 +31793,7 @@ async function preprocess(source, preprocessor, options) {
     return result.to_processed();
 }
 
-const VERSION = '3.44.3';
+const VERSION = '3.45.0';
 
 export { VERSION, compile, parse$3 as parse, preprocess, walk };
 //# sourceMappingURL=compiler.mjs.map