svelte 5.57.0 → 5.57.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "svelte",
   "description": "Cybernetically enhanced web apps",
   "license": "MIT",
-  "version": "5.57.0",
+  "version": "5.57.1",
   "type": "module",
   "types": "./types/index.d.ts",
   "engines": {
@@ -158,17 +158,17 @@
     "web-features": "^3.29.0"
   },
   "dependencies": {
-    "@jridgewell/remapping": "^2.3.4",
-    "@jridgewell/sourcemap-codec": "^1.5.0",
-    "@sveltejs/acorn-typescript": "^1.0.10",
-    "@types/estree": "^1.0.5",
-    "acorn": "^8.12.1",
+    "@jridgewell/remapping": "^2.3.5",
+    "@jridgewell/sourcemap-codec": "^1.6.0",
+    "@sveltejs/acorn-typescript": "^1.0.13",
+    "@types/estree": "^1.0.9",
+    "acorn": "^8.18.0",
     "aria-query": "5.3.1",
     "axobject-query": "^4.1.0",
     "clsx": "^2.1.1",
-    "devalue": "^5.8.1",
+    "devalue": "^5.9.2",
     "esm-env": "^1.2.1",
-    "esrap": "^2.2.12",
+    "esrap": "^2.3.6",
     "is-reference": "^3.0.3",
     "locate-character": "^3.0.0",
     "magic-string": "^0.30.11",

package/src/compiler/phases/1-parse/acorn.js

@@ -5,6 +5,7 @@ import * as acorn from 'acorn';
 import { walk } from 'zimmerframe';
 import { tsPlugin } from '@sveltejs/acorn-typescript';
 import * as e from '../../errors.js';
+import { locator } from '../../state.js';
 
 const JSParser = acorn.Parser;
 const TSParser = JSParser.extend(tsPlugin());
@@ -87,7 +88,8 @@ export function parse_expression_at(parser, source, index) {
 			sourceType: 'module',
 			ecmaVersion: 16,
 			locations: true,
-			preserveParens: true
+			preserveParens: true,
+			startLocation: start_location(parser, index)
 		});
 
 		add_comments(ast);
@@ -112,7 +114,13 @@ export function parse_statement_at(parser, source, index) {
 	try {
 		// This is like parseExpressionAt but for statements
 		const p = new acorn(
-			{ onComment, sourceType: 'module', ecmaVersion: 16, locations: true },
+			{
+				onComment,
+				sourceType: 'module',
+				ecmaVersion: 16,
+				locations: true,
+				startLocation: start_location(parser, index)
+			},
 			source,
 			index
 		);
@@ -128,6 +136,32 @@ export function parse_statement_at(parser, source, index) {
 	}
 }
 
+const regex_non_lf_line_break = /\r(?!\n)|[\u2028\u2029]/;
+
+let last_template = '';
+let lf_only = true;
+
+/**
+ * Without `startLocation`, acorn counts the lines before `index` on every call
+ * @param {Parser} parser
+ * @param {number} index
+ */
+function start_location(parser, index) {
+	return has_lf_line_breaks_only(parser) ? locator(index) : undefined;
+}
+
+/**
+ * acorn breaks lines on bare `\r`, `\u2028` and `\u2029`, which the locator doesn't
+ * @param {Parser} parser
+ */
+export function has_lf_line_breaks_only(parser) {
+	if (parser.template !== last_template) {
+		last_template = parser.template;
+		lf_only = !regex_non_lf_line_break.test(last_template);
+	}
+	return lf_only;
+}
+
 const regex_position_indicator = / \(\d+:\d+\)$/;
 
 /**

package/src/compiler/phases/1-parse/index.js

@@ -5,30 +5,11 @@
 import { isIdentifierStart, isIdentifierChar } from 'acorn';
 import fragment from './state/fragment.js';
 import * as e from '../../errors.js';
-import { create_fragment } from './utils/create.js';
+import { create_fragment, disallow_children } from '../nodes.js';
 import read_options from './read/options.js';
 import { is_reserved } from '../../../utils.js';
-import { disallow_children } from '../2-analyze/visitors/shared/special-element.js';
 import * as state from '../../state.js';
-
-/** @param {number} cc */
-function is_whitespace(cc) {
-	// fast path for common whitespace
-	if (cc === 32 || (cc <= 13 && cc >= 9)) return true;
-	// rare whitespace — \u00a0, \u1680, \u2000-\u200a, \u2028, \u2029, \u202f, \u205f, \u3000, \ufeff
-	if (cc < 160) return false;
-	return (
-		cc === 160 ||
-		cc === 5760 ||
-		(cc >= 8192 && cc <= 8202) ||
-		cc === 8232 ||
-		cc === 8233 ||
-		cc === 8239 ||
-		cc === 8287 ||
-		cc === 12288 ||
-		cc === 65279
-	);
-}
+import { is_whitespace } from './utils/whitespace.js';
 
 const regex_lang_attribute =
 	/<!--[^]*?-->|<script\s+(?:[^>]*|(?:[^=>'"/]+=(?:"[^"]*"|'[^']*'|[^>\s]+)\s+)*)lang=(["'])?([^"' >]+)\1[^>]*>/g;
@@ -278,8 +259,27 @@ export class Parser {
 		};
 	}
 
+	/** @param {string} delimiter */
+	read_until(delimiter) {
+		if (this.index >= this.template.length) {
+			if (this.loose) return '';
+			e.unexpected_eof(this.template.length);
+		}
+
+		const start = this.index;
+		const index = this.template.indexOf(delimiter, start);
+
+		if (index !== -1) {
+			this.index = index;
+			return this.template.slice(start, this.index);
+		}
+
+		this.index = this.template.length;
+		return this.template.slice(start);
+	}
+
 	/** @param {RegExp} pattern */
-	read_until(pattern) {
+	read_until_regex(pattern) {
 		if (this.index >= this.template.length) {
 			if (this.loose) return '';
 			e.unexpected_eof(this.template.length);
@@ -302,6 +302,7 @@ export class Parser {
 			e.expected_whitespace(this.index);
 		}
 
+		this.index++;
 		this.allow_whitespace();
 	}
 

package/src/compiler/phases/1-parse/read/context.js

@@ -2,7 +2,6 @@
 /** @import { Parser } from '../index.js' */
 import { match_bracket } from '../utils/bracket.js';
 import { parse_expression_at, remove_parens } from '../acorn.js';
-import { regex_not_newline_characters } from '../../patterns.js';
 import * as e from '../../../errors.js';
 
 /**
@@ -33,24 +32,10 @@ export default function read_pattern(parser) {
 	i = match_bracket(parser, start);
 	parser.index = i;
 
-	const pattern_string = parser.template.slice(start, i);
-
-	// the length of the `space_with_newline` has to be start - 1
-	// because we added a `(` in front of the pattern_string,
-	// which shifted the entire string to right by 1
-	// so we offset it by removing 1 character in the `space_with_newline`
-	// to achieve that, we remove the 1st space encountered,
-	// so it will not affect the `column` of the node
-	let space_with_newline = parser.template
-		.slice(0, start)
-		.replace(regex_not_newline_characters, ' ');
-	const first_space = space_with_newline.indexOf(' ');
-	space_with_newline =
-		space_with_newline.slice(0, first_space) + space_with_newline.slice(first_space + 1);
-
+	// acorn never reads before `start`, so the template itself can serve as the prefix
 	/** @type {any} */
 	let expression = remove_parens(
-		parse_expression_at(parser, `${space_with_newline}(${pattern_string} = 1)`, start - 1)
+		parse_expression_at(parser, parser.template.slice(0, i) + ' = 1', start)
 	);
 
 	expression = expression.left;
@@ -80,7 +65,7 @@ function read_type_annotation(parser) {
 	const insert = '_ as ';
 	let a = parser.index - insert.length;
 	const template =
-		parser.template.slice(0, a).replace(/[^\n]/g, ' ') +
+		parser.template.slice(0, a) +
 		insert +
 		// If this is a type annotation for a function parameter, Acorn-TS will treat subsequent
 		// parameters as part of a sequence expression instead, and will then error on optional

package/src/compiler/phases/1-parse/read/expression.js

@@ -1,9 +1,13 @@
-/** @import { Expression } from 'estree' */
+/** @import { Expression, Identifier } from 'estree' */
 /** @import { Parser } from '../index.js' */
-import { parse_expression_at, remove_parens } from '../acorn.js';
+// @ts-expect-error acorn type definitions are borked in the release we use
+import { isIdentifierStart, isIdentifierChar } from 'acorn';
+import { has_lf_line_breaks_only, parse_expression_at, remove_parens } from '../acorn.js';
 import { regex_whitespace } from '../../patterns.js';
 import * as e from '../../../errors.js';
 import { find_matching_bracket } from '../utils/bracket.js';
+import { is_reserved } from '../../../../utils.js';
+import { locator } from '../../../state.js';
 
 /**
  * @param {Parser} parser
@@ -33,6 +37,9 @@ export function get_loose_identifier(parser, opening_token) {
  * @returns {Expression}
  */
 export default function read_expression(parser, opening_token, disallow_loose) {
+	const simple = read_simple_expression(parser);
+	if (simple) return simple;
+
 	try {
 		const node = parse_expression_at(parser, parser.template, parser.index);
 
@@ -57,3 +64,104 @@ export default function read_expression(parser, opening_token, disallow_loose) {
 		throw err;
 	}
 }
+
+/**
+ * Most template expressions are an identifier or a `a.b.c` member chain followed by `}`.
+ * Those are built directly for better parse performance, with the same shape acorn would produce; anything else goes to acorn
+ * @param {Parser} parser
+ * @returns {Expression | null}
+ */
+function read_simple_expression(parser) {
+	if (!has_lf_line_breaks_only(parser)) return null;
+
+	const template = parser.template;
+	const index = parser.index;
+
+	parser.allow_whitespace();
+	const start = parser.index;
+
+	let end = read_word(template, start);
+	if (end === -1 || is_reserved(template.slice(start, end))) {
+		parser.index = index;
+		return null;
+	}
+
+	/** @type {Expression} */
+	let node = identifier(template, start, end);
+
+	while (template[end] === '.') {
+		const property_end = read_word(template, end + 1);
+		if (property_end === -1) {
+			parser.index = index;
+			return null;
+		}
+
+		node = {
+			type: 'MemberExpression',
+			start,
+			end: property_end,
+			loc: { start: position(start), end: position(property_end) },
+			object: node,
+			property: identifier(template, end + 1, property_end),
+			computed: false,
+			optional: false
+		};
+
+		end = property_end;
+	}
+
+	parser.index = end;
+	parser.allow_whitespace();
+
+	if (!parser.match('}')) {
+		parser.index = index;
+		return null;
+	}
+
+	parser.index = end;
+	return node;
+}
+
+/**
+ * @param {string} template
+ * @param {number} start
+ * @returns {number} the end of the identifier starting at `start`, or -1
+ */
+function read_word(template, start) {
+	if (start >= template.length) return -1;
+
+	const code = /** @type {number} */ (template.codePointAt(start));
+	if (!isIdentifierStart(code, true)) return -1;
+
+	let end = start + (code <= 0xffff ? 1 : 2);
+
+	while (end < template.length) {
+		const code = /** @type {number} */ (template.codePointAt(end));
+		if (!isIdentifierChar(code, true)) break;
+		end += code <= 0xffff ? 1 : 2;
+	}
+
+	return end;
+}
+
+/**
+ * @param {string} template
+ * @param {number} start
+ * @param {number} end
+ * @returns {Identifier}
+ */
+function identifier(template, start, end) {
+	return {
+		type: 'Identifier',
+		start,
+		end,
+		loc: { start: position(start), end: position(end) },
+		name: template.slice(start, end)
+	};
+}
+
+/** @param {number} index */
+function position(index) {
+	const { line, column } = locator(index);
+	return { line, column };
+}

package/src/compiler/phases/1-parse/read/script.js

@@ -22,7 +22,7 @@ const ALLOWED_ATTRIBUTES = ['context', 'generics', 'lang', 'module'];
  */
 export function read_script(parser, start, attributes) {
 	const script_start = parser.index;
-	const data = parser.read_until(regex_closing_script_tag);
+	const data = parser.read_until_regex(regex_closing_script_tag);
 	if (parser.index >= parser.template.length) {
 		e.element_unclosed(parser.template.length, 'script');
 	}

package/src/compiler/phases/1-parse/read/style.js

@@ -16,8 +16,6 @@ const REGEX_WHITESPACE_OR_COLON = /[\s:]/;
 const REGEX_LEADING_HYPHEN_OR_DIGIT = /-?\d/y;
 const REGEX_VALID_IDENTIFIER_CHAR = /[a-zA-Z0-9_-]/;
 const REGEX_UNICODE_SEQUENCE = /\\[0-9a-fA-F]{1,6}(\r\n|\s)?/y;
-const REGEX_COMMENT_CLOSE = /\*\//;
-const REGEX_HTML_COMMENT_CLOSE = /-->/;
 
 /**
  * @param {Parser} parser
@@ -478,7 +476,7 @@ function read_block_item(parser) {
 function read_declaration(parser) {
 	const start = parser.index;
 
-	const property = parser.read_until(REGEX_WHITESPACE_OR_COLON);
+	const property = parser.read_until_regex(REGEX_WHITESPACE_OR_COLON);
 	parser.allow_whitespace();
 	parser.eat(':');
 	let index = parser.index;
@@ -661,7 +659,7 @@ function allow_comment_or_whitespace(parser, capture_comments = true) {
 		}
 
 		if (parser.eat('<!--')) {
-			parser.read_until(REGEX_HTML_COMMENT_CLOSE);
+			parser.read_until('-->');
 			parser.eat('-->', true);
 		}
 
@@ -676,7 +674,7 @@ function allow_comment_or_whitespace(parser, capture_comments = true) {
 function read_comment(parser) {
 	const start = parser.index;
 	parser.eat('/*', true);
-	const value = parser.read_until(REGEX_COMMENT_CLOSE);
+	const value = parser.read_until('*/');
 	parser.eat('*/', true);
 	const end = parser.index;
 

package/src/compiler/phases/1-parse/state/element.js

@@ -9,19 +9,20 @@ import read_style from '../read/style.js';
 import { decode_character_references } from '../utils/html.js';
 import * as e from '../../../errors.js';
 import * as w from '../../../warnings.js';
-import { create_fragment } from '../utils/create.js';
-import { create_attribute, ExpressionMetadata, is_element_node } from '../../nodes.js';
+import {
+	create_attribute,
+	create_fragment,
+	ExpressionMetadata,
+	is_element_node
+} from '../../nodes.js';
 import { get_attribute_expression, is_expression_attribute } from '../../../utils/ast.js';
 import { closing_tag_omitted } from '../../../../html-tree-validation.js';
 import { list } from '../../../utils/string.js';
 import { locator } from '../../../state.js';
-import * as b from '#compiler/builders';
+import { is_whitespace } from '../utils/whitespace.js';
 
 const regex_invalid_unquoted_attribute_value = /(\/>|[\s"'=<>`])/y;
 const regex_closing_textarea_tag = /<\/textarea(\s[^>]*)?>/iy;
-const regex_closing_comment = /-->/;
-const regex_whitespace_or_slash_or_closing_tag = /(\s|\/|>)/;
-const regex_token_ending_character = /[\s=/>"']/;
 const regex_starts_with_quote_characters = /["']/y;
 const regex_attribute_value = /(?:"([^"]*)"|'([^'])*'|([^>\s]+))/y;
 const regex_doctype_name = /^![a-zA-Z]+$/;
@@ -67,7 +68,7 @@ export default function element(parser) {
 	let parent = parser.current();
 
 	if (parser.eat('!--')) {
-		const data = parser.read_until(regex_closing_comment);
+		const data = parser.read_until('-->');
 		parser.eat('-->', true);
 
 		parser.append({
@@ -81,7 +82,7 @@ export default function element(parser) {
 	}
 
 	if (parser.eat('/')) {
-		const name = parser.read_until(regex_whitespace_or_slash_or_closing_tag);
+		const name = read_tag_name(parser);
 
 		parser.allow_whitespace();
 		parser.eat('>', true);
@@ -137,7 +138,7 @@ export default function element(parser) {
 		return;
 	}
 
-	const tag = read_tag(parser, regex_whitespace_or_slash_or_closing_tag);
+	const tag = read_tag(parser);
 
 	if (tag.name.startsWith('svelte:') && !meta_tags.has(tag.name)) {
 		const bounds = { start: start + 1, end: start + 1 + tag.name.length };
@@ -475,7 +476,7 @@ function parent_is_shadowroot_template(stack) {
 function read_static_attribute(parser) {
 	const start = parser.index;
 
-	const tag = read_tag(parser, regex_token_ending_character);
+	const tag = read_tag(parser, true);
 	if (!tag.name) return null;
 
 	/** @type {true | Array<AST.Text | AST.ExpressionTag>} */
@@ -607,7 +608,7 @@ function read_attribute(parser) {
 		}
 	}
 
-	const tag = read_tag(parser, regex_token_ending_character);
+	const tag = read_tag(parser, true);
 
 	if (!tag.name) return null;
 
@@ -731,7 +732,7 @@ function read_comment(parser) {
 	const start = parser.index;
 
 	if (parser.eat('//')) {
-		const value = parser.read_until(/\n/);
+		const value = parser.read_until('\n');
 		const end = parser.index;
 
 		return {
@@ -747,7 +748,7 @@ function read_comment(parser) {
 	}
 
 	if (parser.eat('/*')) {
-		const value = parser.read_until(/\*\//);
+		const value = parser.read_until('*/');
 
 		parser.eat('*/');
 		const end = parser.index;
@@ -847,25 +848,21 @@ function read_attribute_value(parser) {
  * @returns {any[]}
  */
 function read_sequence(parser, done, location) {
-	/** @type {AST.Text} */
-	let current_chunk = {
-		start: parser.index,
-		end: -1,
-		type: 'Text',
-		raw: '',
-		data: ''
-	};
-
 	/** @type {Array<AST.Text | AST.ExpressionTag>} */
 	const chunks = [];
+	let chunk_start = parser.index;
 
 	/** @param {number} end */
 	function flush(end) {
-		if (end > current_chunk.start) {
-			current_chunk.raw = parser.template.slice(current_chunk.start, end);
-			current_chunk.data = decode_character_references(current_chunk.raw, true);
-			current_chunk.end = end;
-			chunks.push(current_chunk);
+		if (end > chunk_start) {
+			const raw = parser.template.slice(chunk_start, end);
+			chunks.push({
+				start: chunk_start,
+				end,
+				type: 'Text',
+				raw,
+				data: decode_character_references(raw, true)
+			});
 		}
 	}
 
@@ -879,12 +876,14 @@ function read_sequence(parser, done, location) {
 			if (parser.match('#')) {
 				const index = parser.index - 1;
 				parser.eat('#');
-				const name = parser.read_until(/[^a-z]/);
+				// const name = parser.read_until_regex(/[^a-z]/);
+				const name = read_lowercase_name(parser);
 				e.block_invalid_placement(index, name, location);
 			} else if (parser.match('@')) {
 				const index = parser.index - 1;
 				parser.eat('@');
-				const name = parser.read_until(/[^a-z]/);
+				// const name = parser.read_until_regex(/[^a-z]/);
+				const name = read_lowercase_name(parser);
 				e.tag_invalid_placement(index, name, location);
 			}
 
@@ -907,14 +906,7 @@ function read_sequence(parser, done, location) {
 			};
 
 			chunks.push(chunk);
-
-			current_chunk = {
-				start: parser.index,
-				end: -1,
-				type: 'Text',
-				raw: '',
-				data: ''
-			};
+			chunk_start = parser.index;
 		} else {
 			parser.index++;
 		}
@@ -929,12 +921,36 @@ function read_sequence(parser, done, location) {
 
 /**
  * @param {Parser} parser
- * @param {RegExp} regex
+ * @param {boolean} [attribute]
+ */
+function read_tag_name(parser, attribute = false) {
+	const start = parser.index;
+	if (start >= parser.template.length && !parser.loose) e.unexpected_eof(parser.template.length);
+
+	while (parser.index < parser.template.length) {
+		const cc = parser.template.charCodeAt(parser.index);
+		if (
+			is_whitespace(cc) ||
+			cc === 47 || // /
+			cc === 62 || // >
+			(attribute && (cc === 34 || cc === 39 || cc === 61)) // " ' =
+		) {
+			break;
+		}
+		parser.index += 1;
+	}
+
+	return parser.template.slice(start, parser.index);
+}
+
+/**
+ * @param {Parser} parser
+ * @param {boolean} [attribute]
  * @returns {Identifier & { start: number, end: number, loc: SourceLocation }}
  */
-function read_tag(parser, regex) {
+function read_tag(parser, attribute = false) {
 	const start = parser.index;
-	const name = parser.read_until(regex);
+	const name = read_tag_name(parser, attribute);
 	const end = parser.index;
 
 	return {
@@ -948,3 +964,15 @@ function read_tag(parser, regex) {
 		}
 	};
 }
+
+/** @param {Parser} parser */
+function read_lowercase_name(parser) {
+	const start = parser.index;
+	while (parser.index < parser.template.length) {
+		const cc = parser.template.charCodeAt(parser.index);
+		// a-z
+		if (cc < 97 || cc > 122) break;
+		parser.index += 1;
+	}
+	return parser.template.slice(start, parser.index);
+}

package/src/compiler/phases/1-parse/state/tag.js

@@ -3,11 +3,10 @@
 /** @import { Parser } from '../index.js' */
 import { walk } from 'zimmerframe';
 import * as e from '../../../errors.js';
-import { ExpressionMetadata } from '../../nodes.js';
+import { create_fragment, ExpressionMetadata } from '../../nodes.js';
 import { parse_expression_at, parse_statement_at } from '../acorn.js';
 import read_pattern from '../read/context.js';
 import read_expression, { get_loose_identifier } from '../read/expression.js';
-import { create_fragment } from '../utils/create.js';
 import { find_matching_bracket, match_bracket } from '../utils/bracket.js';
 
 const regex_whitespace_with_closing_curly_brace = /\s*}/y;
@@ -488,12 +487,13 @@ function open(parser) {
 			parser.eat(')', true);
 		}
 
-		const prelude = parser.template.slice(0, params_start).replace(/\S/g, ' ');
-		const params = parser.template.slice(params_start, parser.index);
-
 		let function_expression = matched
 			? /** @type {ArrowFunctionExpression} */ (
-					parse_expression_at(parser, prelude + `${params} => {}`, params_start)
+					parse_expression_at(
+						parser,
+						parser.template.slice(0, parser.index) + ' => {}',
+						params_start
+					)
 				)
 			: { params: [] };
 

package/src/compiler/phases/1-parse/utils/html.js

@@ -38,6 +38,8 @@ const entity_pattern_attr_value = get_entity_pattern(true);
  * @param {boolean} is_attribute_value
  */
 export function decode_character_references(html, is_attribute_value) {
+	if (html.indexOf('&') === -1) return html; // fast path
+
 	const entity_pattern = is_attribute_value ? entity_pattern_attr_value : entity_pattern_content;
 	return html.replace(
 		entity_pattern,

package/src/compiler/phases/1-parse/utils/whitespace.js

@@ -0,0 +1,18 @@
+/** @param {number} cc */
+export function is_whitespace(cc) {
+	// fast path for common whitespace
+	if (cc === 32 || (cc <= 13 && cc >= 9)) return true;
+	// rare whitespace — \u00a0, \u1680, \u2000-\u200a, \u2028, \u2029, \u202f, \u205f, \u3000, \ufeff
+	if (cc < 160) return false;
+	return (
+		cc === 160 ||
+		cc === 5760 ||
+		(cc >= 8192 && cc <= 8202) ||
+		cc === 8232 ||
+		cc === 8233 ||
+		cc === 8239 ||
+		cc === 8287 ||
+		cc === 12288 ||
+		cc === 65279
+	);
+}

package/src/compiler/phases/2-analyze/css/css-prune.js

@@ -145,6 +145,12 @@ export function prune(stylesheet, elements) {
 		},
 		ComplexSelector(node) {
 			const selectors = get_relative_selectors(node);
+			const rule = /** @type {Compiler.AST.CSS.Rule} */ (node.metadata.rule);
+
+			// Global and ICSS export rules do not depend on an element in this component
+			if (every_is_global(selectors, 0, selectors.length, rule)) {
+				node.metadata.used = true;
+			}
 
 			for (const element of elements) {
 				seen.clear();
@@ -153,12 +159,7 @@ export function prune(stylesheet, elements) {
 					// Elements rendered through <svelte:head> are not style-scopable.
 					// Prevent css hash injection (class="s-...") on tags like <meta>, <link>, <script>.
 					!is_inside_svelte_head(element) &&
-					apply_selector(
-						selectors,
-						/** @type {Compiler.AST.CSS.Rule} */ (node.metadata.rule),
-						element,
-						BACKWARD
-					)
+					apply_selector(selectors, rule, element, BACKWARD)
 				) {
 					node.metadata.used = true;
 				}