svelte-effect-runtime 4.0.0 → 4.0.1

package/.dist/chunks/source-scan-9pZxnfct.js

@@ -0,0 +1,1059 @@
+import ts from "typescript";
+import { parse } from "svelte/compiler";
+//#region src/compiler/source-scan.ts
+let latest_scan;
+function parse_svelte_source(source) {
+	let parse_source = source;
+	const max_attempts = (source.match(/\byield\s*\*/g)?.length ?? 0) + 1;
+	for (let attempt = 0; attempt < max_attempts; attempt += 1) try {
+		return parse(parse_source, {
+			modern: true,
+			loose: true
+		});
+	} catch (error) {
+		const normalized = normalize_parser_error(parse_source, error);
+		if (!normalized || normalized === parse_source) return;
+		parse_source = normalized;
+	}
+}
+function normalize_parser_error(source, error) {
+	if (!is_parser_diagnostic(error) || !is_parser_position(error.position)) return;
+	const [start, end] = error.position;
+	if (error.code === "js_parse_error") {
+		const match = source.slice(start).match(/^yield\s*\*/);
+		if (!match) return;
+		return replace_range(source, start, start + match[0].length, blank_source(match[0]));
+	}
+	if (error.code !== "render_tag_invalid_expression") return;
+	if (source.slice(start, end).search(/\byield\s*\*/) === -1) return;
+	return normalize_render_yield_expressions(source);
+}
+function normalize_render_yield_expressions(source) {
+	const replacements = [];
+	let cursor = 0;
+	while (cursor < source.length) {
+		const open = source.indexOf("{@render", cursor);
+		if (open === -1) break;
+		const close = find_closing_brace(source, open);
+		if (close === -1) {
+			cursor = open + 1;
+			continue;
+		}
+		const prefix = source.slice(open + 1, close).match(/^@render\b\s*/)?.[0];
+		const expression_start = prefix ? open + 1 + prefix.length : -1;
+		const expression = expression_start === -1 ? "" : source.slice(expression_start, close);
+		if (/\byield\s*\*/.test(expression)) {
+			const blanked = blank_source(expression);
+			replacements.push({
+				start: expression_start,
+				end: close,
+				text: "x()" + blanked.slice(3)
+			});
+		}
+		cursor = close + 1;
+	}
+	if (replacements.length === 0) return source;
+	const parts = [];
+	let source_cursor = 0;
+	for (const replacement of replacements) {
+		parts.push(source.slice(source_cursor, replacement.start), replacement.text);
+		source_cursor = replacement.end;
+	}
+	parts.push(source.slice(source_cursor));
+	return parts.join("");
+}
+function is_parser_diagnostic(error) {
+	return typeof error === "object" && error !== null;
+}
+function is_parser_position(position) {
+	return Array.isArray(position) && position.length === 2 && position.every((offset) => typeof offset === "number");
+}
+function replace_range(source, start, end, replacement) {
+	return source.slice(0, start) + replacement + source.slice(end);
+}
+function blank_source(source) {
+	return source.replace(/[^\r\n]/g, " ");
+}
+function scan_svelte_effect_source(source, filename = "unknown.svelte") {
+	if (latest_scan?.source === source && latest_scan.filename === filename) return latest_scan;
+	const scan = scan_svelte_effect_source_uncached(source, filename);
+	latest_scan = scan;
+	return scan;
+}
+function scan_svelte_effect_source_uncached(source, filename) {
+	const fast_regions = collect_fast_source_regions(source);
+	if (fast_regions) return make_source_scan(source, filename, fast_regions);
+	const ast = parse_svelte_source(make_svelte_parse_shadow(source));
+	if (!ast) return make_opaque_scan(source, filename);
+	return make_source_scan(source, filename, collect_source_regions(source, ast));
+}
+function make_source_scan(source, filename, regions) {
+	const scripts = regions.scripts;
+	const styles = regions.styles;
+	const comments = regions.comments;
+	const excluded_ranges = merge_ranges([...comments, ...regions.opaque_ranges]);
+	const markup_expressions = collect_scanned_markup_expressions(source, excluded_ranges, regions.attribute_names);
+	const bare_const_tags = markup_expressions.flatMap((expression) => make_bare_const_tag(expression));
+	const instance_script = scripts.find((script) => !script.is_module);
+	const effect_script = scripts.find((script) => !script.is_module && script.has_effect);
+	return {
+		filename,
+		source,
+		scripts,
+		styles,
+		comments,
+		excluded_ranges,
+		markup_expressions,
+		markup_binding_names: [...regions.markup_binding_names],
+		bare_const_tags,
+		instance_script,
+		effect_script
+	};
+}
+function make_opaque_scan(source, filename) {
+	return {
+		filename,
+		source,
+		scripts: [],
+		styles: [],
+		comments: [],
+		excluded_ranges: source.length === 0 ? [] : [{
+			start: 0,
+			end: source.length
+		}],
+		markup_expressions: [],
+		markup_binding_names: [],
+		bare_const_tags: [],
+		instance_script: void 0,
+		effect_script: void 0
+	};
+}
+function collect_fast_source_regions(source) {
+	const element_stack = [];
+	const scripts = [];
+	const styles = [];
+	const comments = [];
+	const opaque_ranges = [];
+	let optional_element_count = 0;
+	let cursor = 0;
+	while (cursor < source.length) {
+		if (source.startsWith("<!--", cursor)) {
+			const close = source.indexOf("-->", cursor + 4);
+			if (close === -1) return;
+			const comment = {
+				start: cursor,
+				end: close + 3
+			};
+			comments.push(comment);
+			cursor = comment.end;
+			continue;
+		}
+		const char = source[cursor];
+		if (char === "&") return;
+		if (char === "{") {
+			const close = find_fast_closing_brace(source, cursor);
+			if (close === -1 || /^\s*[#/:@]/.test(source.slice(cursor + 1, close))) return;
+			cursor = close + 1;
+			continue;
+		}
+		if (char !== "<") {
+			cursor += 1;
+			continue;
+		}
+		const raw_name = read_raw_opening_name(source, cursor);
+		if (raw_name) {
+			if (element_stack.length > 0) return;
+			const raw_tag = locate_raw_tag(source, cursor, raw_name);
+			if (!raw_tag || !is_fast_raw_opening(source, raw_tag)) return;
+			if (raw_name === "script") {
+				if (scripts.length > 0) return;
+				scripts.push(make_fast_script_region(source, raw_tag));
+			} else {
+				if (styles.length > 0) return;
+				styles.push({
+					start: raw_tag.start,
+					end: raw_tag.end
+				});
+			}
+			opaque_ranges.push({
+				start: raw_tag.start,
+				end: raw_tag.end
+			});
+			cursor = raw_tag.end;
+			continue;
+		}
+		const tag = read_fast_ordinary_tag(source, cursor);
+		if (!tag) return;
+		if (tag.is_closing) {
+			if (fast_void_tag_names.has(tag.name) || element_stack.at(-1) !== tag.name) return;
+			element_stack.pop();
+			if (fast_optional_end_tag_names.has(tag.name)) optional_element_count -= 1;
+		} else if (!tag.is_self_closing && !fast_void_tag_names.has(tag.name)) {
+			if (optional_element_count > 0) return;
+			element_stack.push(tag.name);
+			if (fast_optional_end_tag_names.has(tag.name)) optional_element_count += 1;
+		}
+		cursor = tag.end;
+	}
+	if (element_stack.length > 0) return;
+	return {
+		scripts,
+		styles,
+		comments,
+		opaque_ranges,
+		attribute_names: /* @__PURE__ */ new Map(),
+		markup_binding_names: /* @__PURE__ */ new Set()
+	};
+}
+const fast_void_tag_names = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+const fast_optional_end_tag_names = /* @__PURE__ */ new Set([
+	"colgroup",
+	"dd",
+	"dt",
+	"li",
+	"optgroup",
+	"option",
+	"p",
+	"rp",
+	"rt",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"tr"
+]);
+function read_fast_ordinary_tag(source, start) {
+	let cursor = start + 1;
+	const is_closing = source[cursor] === "/";
+	if (is_closing) cursor += 1;
+	const name_start = cursor;
+	if (!/[a-z]/.test(source[cursor] ?? "")) return;
+	while (/[a-z0-9-]/.test(source[cursor] ?? "")) cursor += 1;
+	const name = source.slice(name_start, cursor);
+	while (/\s/.test(source[cursor] ?? "")) cursor += 1;
+	const is_self_closing = !is_closing && source[cursor] === "/";
+	if (is_self_closing) cursor += 1;
+	if (source[cursor] !== ">") return;
+	return {
+		name,
+		end: cursor + 1,
+		is_closing,
+		is_self_closing
+	};
+}
+function find_fast_closing_brace(source, open) {
+	let depth = 1;
+	let cursor = open + 1;
+	while (cursor < source.length) {
+		const char = source[cursor];
+		if (char === "'" || char === "\"") {
+			const close = skip_quoted_string(source, cursor, char);
+			if (close === -1) return -1;
+			cursor = close + 1;
+			continue;
+		}
+		if (char === "`" || char === "/") return -1;
+		if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return cursor;
+		}
+		cursor += 1;
+	}
+	return -1;
+}
+function read_raw_opening_name(source, start) {
+	for (const name of ["script", "style"]) {
+		const name_end = start + name.length + 1;
+		if (source.startsWith(`<${name}`, start) && (source[name_end] === ">" || /\s/.test(source[name_end] ?? ""))) return name;
+	}
+}
+function locate_raw_tag(source, start, name) {
+	const content_start = find_static_opening_tag_end(source, start, name);
+	if (content_start === -1) return;
+	const opening_tag = source.slice(start, content_start);
+	const is_preprocessor_style = name === "style" && has_style_lang_attribute(opening_tag);
+	const parsed_style_end = name === "style" ? find_style_closing_tag(source, content_start, is_preprocessor_style) : void 0;
+	const content_end = name === "script" ? find_raw_closing_tag(source, content_start, name) : parsed_style_end ?? (is_preprocessor_style ? find_raw_closing_tag(source, content_start, name) : void 0);
+	if (!content_end) return;
+	return {
+		name,
+		start,
+		end: content_end.end,
+		content_start,
+		content_end: content_end.start
+	};
+}
+function has_style_lang_attribute(opening_tag) {
+	try {
+		return parse(`${opening_tag}</style>`, {
+			modern: true,
+			loose: true
+		}).css?.attributes.some((attribute) => attribute.name.toLowerCase() === "lang") ?? false;
+	} catch {
+		return false;
+	}
+}
+function find_raw_closing_tag(source, start, name) {
+	let cursor = start;
+	while (cursor < source.length) {
+		const closing_start = source.indexOf(`</${name}`, cursor);
+		if (closing_start === -1) return;
+		const closing_end = find_closing_tag_end_at(source, closing_start, name, false);
+		if (closing_end !== void 0) return {
+			start: closing_start,
+			end: closing_end
+		};
+		cursor = closing_start + name.length + 2;
+	}
+}
+function find_static_opening_tag_end(source, start, name) {
+	let cursor = start + name.length + 1;
+	let quote;
+	while (cursor < source.length) {
+		const char = source[cursor];
+		if (quote) {
+			if (char === quote) quote = void 0;
+			cursor += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			cursor += 1;
+			continue;
+		}
+		if (char === "{" || char === "}" || char === "<" || source.startsWith("/*", cursor) || source.startsWith("//", cursor)) return -1;
+		if (char === ">") return source.slice(start, cursor).trimEnd().endsWith("/") ? -1 : cursor + 1;
+		cursor += 1;
+	}
+	return -1;
+}
+function find_style_closing_tag(source, start, skip_line_comments) {
+	let cursor = start;
+	while (cursor < source.length) {
+		const char = source[cursor];
+		const identifier_end = skip_line_comments ? find_css_identifier_end(source, cursor) : void 0;
+		if (identifier_end !== void 0) {
+			const url_end = skip_css_url(source, cursor, identifier_end);
+			if (url_end === -1) return;
+			cursor = url_end === void 0 ? identifier_end : url_end + 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			const close = skip_quoted_string(source, cursor, char);
+			if (close === -1) return;
+			cursor = close + 1;
+			continue;
+		}
+		if (source.startsWith("/*", cursor)) {
+			const close = skip_block_comment(source, cursor);
+			if (close === -1) return;
+			cursor = close + 1;
+			continue;
+		}
+		if (skip_line_comments && source.startsWith("//", cursor)) {
+			cursor = skip_line_comment(source, cursor) + 1;
+			continue;
+		}
+		const closing_end = find_closing_tag_end_at(source, cursor, "style", false);
+		if (closing_end !== void 0) return {
+			start: cursor,
+			end: closing_end
+		};
+		cursor += 1;
+	}
+}
+function find_css_identifier_end(source, start) {
+	const first = source[start];
+	if (!is_css_identifier_start(first)) return;
+	let cursor = start;
+	while (cursor < source.length) {
+		const char = source[cursor];
+		if (is_css_identifier_character(char)) {
+			cursor += 1;
+			continue;
+		}
+		if (char === "\\") {
+			cursor = skip_css_escape(source, cursor);
+			continue;
+		}
+		break;
+	}
+	return cursor;
+}
+function skip_css_url(source, start, identifier_end) {
+	if (source.slice(start, identifier_end).toLowerCase() !== "url") return;
+	let cursor = skip_css_whitespace(source, identifier_end);
+	if (source[cursor] !== "(") return;
+	cursor = skip_css_whitespace(source, cursor + 1);
+	const quote = source[cursor];
+	if (quote === "\"" || quote === "'") {
+		const close = skip_quoted_string(source, cursor, quote);
+		if (close === -1) return -1;
+		cursor = skip_css_url_trivia(source, close + 1);
+		if (cursor === -1) return -1;
+		return source[cursor] === ")" ? cursor : -1;
+	}
+	while (cursor < source.length) {
+		const char = source[cursor];
+		if (char === "\\") {
+			cursor = skip_css_escape(source, cursor);
+			continue;
+		}
+		if (char === ")") return cursor;
+		cursor += 1;
+	}
+	return -1;
+}
+function skip_css_whitespace(source, start) {
+	let cursor = start;
+	while (cursor < source.length && /[\t\n\f\r ]/.test(source[cursor] ?? "")) cursor += 1;
+	return cursor;
+}
+function skip_css_url_trivia(source, start) {
+	let cursor = start;
+	while (cursor < source.length) {
+		cursor = skip_css_whitespace(source, cursor);
+		if (!source.startsWith("/*", cursor)) return cursor;
+		const close = skip_block_comment(source, cursor);
+		if (close === -1) return -1;
+		cursor = close + 1;
+	}
+	return cursor;
+}
+function skip_css_escape(source, start) {
+	return Math.min(start + 2, source.length);
+}
+function is_css_identifier_start(char) {
+	return char !== void 0 && (/[A-Za-z_-]/.test(char) || char === "\\" || char.charCodeAt(0) >= 128);
+}
+function is_css_identifier_character(char) {
+	return char !== void 0 && (/[A-Za-z0-9_-]/.test(char) || char.charCodeAt(0) >= 128);
+}
+function is_fast_raw_opening(source, raw_tag) {
+	const opening = source.slice(raw_tag.start, raw_tag.content_start);
+	if (raw_tag.name === "script") return opening === "<script>";
+	return /^<style(?:\s+lang=(?:"[A-Za-z0-9_-]+"|'[A-Za-z0-9_-]+'|[A-Za-z0-9_-]+))?\s*>$/.test(opening);
+}
+function make_fast_script_region(source, raw_tag) {
+	return {
+		start: raw_tag.start,
+		end: raw_tag.end,
+		opening_tag_start: raw_tag.start,
+		opening_tag_end: raw_tag.content_start,
+		tag_name_end: raw_tag.start + 7,
+		content_start: raw_tag.content_start,
+		content_end: raw_tag.content_end,
+		closing_tag_start: raw_tag.content_end,
+		closing_tag_end: raw_tag.end,
+		attributes_text: "",
+		attributes: [],
+		text: source.slice(raw_tag.content_start, raw_tag.content_end),
+		is_module: false,
+		has_lang: false,
+		lang: void 0,
+		is_typescript: false,
+		has_effect: false,
+		effect_attribute: void 0
+	};
+}
+function make_svelte_parse_shadow(source) {
+	const raw_tags = collect_shadow_raw_tags(source);
+	if (!raw_tags) return source;
+	const parts = [];
+	let cursor = 0;
+	for (const raw_tag of raw_tags) {
+		parts.push(source.slice(cursor, raw_tag.content_start));
+		parts.push(blank_source(source.slice(raw_tag.content_start, raw_tag.content_end)));
+		cursor = raw_tag.content_end;
+	}
+	parts.push(source.slice(cursor));
+	return normalize_markup_yield_operators(parts.join(""));
+}
+function normalize_markup_yield_operators(source) {
+	const replacements = [];
+	let cursor = 0;
+	while (cursor < source.length) {
+		const open = source.indexOf("{", cursor);
+		if (open === -1) break;
+		const close = find_closing_brace(source, open);
+		if (close === -1) {
+			cursor = open + 1;
+			continue;
+		}
+		const inner = source.slice(open + 1, close);
+		const trimmed = inner.trimStart();
+		if (!/\byield\s*\*/.test(inner) || /^@debug\b/.test(trimmed)) {
+			cursor = close + 1;
+			continue;
+		}
+		const render_prefix = inner.match(/^(\s*@render\b\s*)/)?.[0];
+		const text = render_prefix ? render_prefix + "x()" + blank_source(inner.slice(render_prefix.length)).slice(3) : inner.replace(/\byield\s*\*/g, blank_source);
+		replacements.push({
+			start: open + 1,
+			end: close,
+			text
+		});
+		cursor = close + 1;
+	}
+	if (replacements.length === 0) return source;
+	const parts = [];
+	let source_cursor = 0;
+	for (const replacement of replacements) {
+		parts.push(source.slice(source_cursor, replacement.start), replacement.text);
+		source_cursor = replacement.end;
+	}
+	parts.push(source.slice(source_cursor));
+	return parts.join("");
+}
+function collect_shadow_raw_tags(source) {
+	const raw_tags = [];
+	let cursor = 0;
+	while (cursor < source.length) {
+		if (source.startsWith("<!--", cursor)) {
+			const close = source.indexOf("-->", cursor + 4);
+			if (close === -1) return;
+			cursor = close + 3;
+			continue;
+		}
+		const char = source[cursor];
+		if (char === "{") {
+			const close = find_closing_brace(source, cursor);
+			if (close === -1) return;
+			cursor = close + 1;
+			continue;
+		}
+		if (char !== "<") {
+			cursor += 1;
+			continue;
+		}
+		const rcdata_name = read_rcdata_opening_name(source, cursor);
+		if (rcdata_name) {
+			const content_start = find_markup_tag_end(source, cursor);
+			const closing_tag = content_start === -1 ? void 0 : find_rcdata_closing_tag(source, content_start, rcdata_name);
+			if (!closing_tag) return;
+			cursor = closing_tag.end;
+			continue;
+		}
+		const raw_name = read_raw_opening_name(source, cursor);
+		if (raw_name) {
+			const raw_tag = locate_raw_tag(source, cursor, raw_name);
+			if (!raw_tag) return;
+			raw_tags.push(raw_tag);
+			cursor = raw_tag.end;
+			continue;
+		}
+		const tag_end = find_markup_tag_end(source, cursor);
+		if (tag_end === -1) return;
+		cursor = tag_end;
+	}
+	return raw_tags;
+}
+function read_rcdata_opening_name(source, start) {
+	for (const name of ["textarea", "title"]) {
+		const name_end = start + name.length + 1;
+		if (source.slice(start, name_end).toLowerCase() === `<${name}` && (source[name_end] === ">" || /\s/.test(source[name_end] ?? ""))) return name;
+	}
+}
+function find_rcdata_closing_tag(source, start, name) {
+	let cursor = start;
+	while (cursor < source.length) {
+		if (source[cursor] === "{") {
+			const close = find_closing_brace(source, cursor);
+			if (close === -1) return;
+			cursor = close + 1;
+			continue;
+		}
+		const closing_end = find_closing_tag_end_at(source, cursor, name, true);
+		if (closing_end !== void 0) return {
+			start: cursor,
+			end: closing_end
+		};
+		cursor += 1;
+	}
+}
+function find_closing_tag_end_at(source, start, name, case_insensitive) {
+	if (source[start] !== "<") return;
+	const prefix = source.slice(start, start + name.length + 2);
+	const expected = `</${name}`;
+	if (!(case_insensitive ? prefix.toLowerCase() === expected : prefix === expected)) return;
+	let cursor = start + expected.length;
+	while (/\s/.test(source[cursor] ?? "")) cursor += 1;
+	return source[cursor] === ">" ? cursor + 1 : void 0;
+}
+function find_markup_tag_end(source, start) {
+	let cursor = start + 1;
+	let quote;
+	while (cursor < source.length) {
+		const char = source[cursor];
+		if (quote) {
+			if (char === quote) quote = void 0;
+			cursor += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			cursor += 1;
+			continue;
+		}
+		if (char === "{") {
+			const close = find_closing_brace(source, cursor);
+			if (close === -1) return -1;
+			cursor = close + 1;
+			continue;
+		}
+		if (source.startsWith("/*", cursor)) {
+			const close = skip_block_comment(source, cursor);
+			if (close === -1) return -1;
+			cursor = close + 1;
+			continue;
+		}
+		if (source.startsWith("//", cursor)) {
+			cursor = skip_line_comment(source, cursor) + 1;
+			continue;
+		}
+		if (char === ">") return cursor + 1;
+		if (char === "<") return -1;
+		cursor += 1;
+	}
+	return -1;
+}
+function collect_source_regions(source, ast) {
+	const scripts = [ast.module, ast.instance].filter((script) => script != null).map((script) => make_ast_script_region(source, script)).sort((left, right) => left.start - right.start);
+	const styles = ast.css ? [{
+		start: ast.css.start,
+		end: ast.css.end
+	}] : [];
+	const comments = [];
+	const opaque_ranges = [
+		...scripts.map(({ start, end }) => ({
+			start,
+			end
+		})),
+		...styles,
+		...ast.comments.map(({ start, end }) => ({
+			start,
+			end
+		}))
+	];
+	const attribute_names = /* @__PURE__ */ new Map();
+	const markup_binding_names = /* @__PURE__ */ new Set();
+	collect_fragment_regions(source, ast.fragment, comments, opaque_ranges, attribute_names, markup_binding_names);
+	return {
+		scripts,
+		styles,
+		comments,
+		opaque_ranges,
+		attribute_names,
+		markup_binding_names
+	};
+}
+function collect_fragment_regions(source, fragment, comments, opaque_ranges, attribute_names, markup_binding_names) {
+	for (const node of fragment.nodes) {
+		if (node.type === "Comment") {
+			comments.push({
+				start: node.start,
+				end: node.end
+			});
+			continue;
+		}
+		if (node.type === "RegularElement" && (node.name === "script" || node.name === "style")) {
+			opaque_ranges.push({
+				start: node.start,
+				end: node.end
+			});
+			continue;
+		}
+		collect_node_markup_binding_names(node, markup_binding_names);
+		collect_node_attribute_names(source, node, attribute_names, markup_binding_names);
+		collect_node_fragments(source, node, comments, opaque_ranges, attribute_names, markup_binding_names);
+	}
+}
+function collect_node_markup_binding_names(node, markup_binding_names) {
+	switch (node.type) {
+		case "EachBlock":
+			if (node.context) collect_markup_binding_pattern_names(node.context, markup_binding_names);
+			if (node.index) markup_binding_names.add(node.index);
+			return;
+		case "AwaitBlock":
+			for (const pattern of [node.value, node.error]) if (pattern) collect_markup_binding_pattern_names(pattern, markup_binding_names);
+			return;
+		case "SnippetBlock":
+			markup_binding_names.add(node.expression.name);
+			for (const parameter of node.parameters) collect_markup_binding_pattern_names(parameter, markup_binding_names);
+			return;
+		case "ConstTag":
+		case "DeclarationTag":
+			for (const declaration of node.declaration.declarations) collect_markup_binding_pattern_names(declaration.id, markup_binding_names);
+			return;
+		default: return;
+	}
+}
+function collect_markup_binding_pattern_names(pattern, markup_binding_names) {
+	switch (pattern.type) {
+		case "Identifier":
+			markup_binding_names.add(pattern.name);
+			return;
+		case "ArrayPattern":
+			for (const element of pattern.elements) if (element) collect_markup_binding_pattern_names(element, markup_binding_names);
+			return;
+		case "ObjectPattern":
+			for (const property of pattern.properties) collect_markup_binding_pattern_names(property.type === "RestElement" ? property.argument : property.value, markup_binding_names);
+			return;
+		case "RestElement":
+			collect_markup_binding_pattern_names(pattern.argument, markup_binding_names);
+			return;
+		case "AssignmentPattern":
+			collect_markup_binding_pattern_names(pattern.left, markup_binding_names);
+			return;
+		case "MemberExpression": return;
+	}
+}
+function collect_node_fragments(source, node, comments, opaque_ranges, attribute_names, markup_binding_names) {
+	if ("fragment" in node) collect_fragment_regions(source, node.fragment, comments, opaque_ranges, attribute_names, markup_binding_names);
+	switch (node.type) {
+		case "IfBlock":
+			collect_fragment_regions(source, node.consequent, comments, opaque_ranges, attribute_names, markup_binding_names);
+			if (node.alternate) collect_fragment_regions(source, node.alternate, comments, opaque_ranges, attribute_names, markup_binding_names);
+			return;
+		case "EachBlock":
+			collect_fragment_regions(source, node.body, comments, opaque_ranges, attribute_names, markup_binding_names);
+			if (node.fallback) collect_fragment_regions(source, node.fallback, comments, opaque_ranges, attribute_names, markup_binding_names);
+			return;
+		case "AwaitBlock":
+			for (const branch of [
+				node.pending,
+				node.then,
+				node.catch
+			]) if (branch) collect_fragment_regions(source, branch, comments, opaque_ranges, attribute_names, markup_binding_names);
+			return;
+		case "SnippetBlock":
+			collect_fragment_regions(source, node.body, comments, opaque_ranges, attribute_names, markup_binding_names);
+			return;
+		default: return;
+	}
+}
+function collect_node_attribute_names(source, node, attribute_names, markup_binding_names) {
+	if (!("attributes" in node)) return;
+	for (const attribute of node.attributes) {
+		if (attribute.type === "LetDirective" && attribute.expression === null) {
+			markup_binding_names.add(attribute.name);
+			continue;
+		}
+		if (attribute.type === "Attribute") {
+			collect_attribute_value_names(attribute.value, attribute.name, attribute_names);
+			continue;
+		}
+		if (attribute.type === "StyleDirective") {
+			const source_name = read_source_attribute_name(source, attribute.start, attribute.end);
+			if (source_name) collect_attribute_value_names(attribute.value, source_name, attribute_names);
+			continue;
+		}
+		if (!("expression" in attribute) || !attribute.expression) continue;
+		const open = source.indexOf("{", attribute.start);
+		if (open < attribute.start || open >= attribute.end) continue;
+		const source_name = read_source_attribute_name(source, attribute.start, attribute.end);
+		if (source_name && source.slice(attribute.start, open).includes("=")) attribute_names.set(open, source_name);
+	}
+}
+function collect_attribute_value_names(value, attribute_name, attribute_names) {
+	if (value === true) return;
+	const parts = Array.isArray(value) ? value : [value];
+	const expression = parts.length === 1 ? parts[0] : void 0;
+	if (expression?.type !== "ExpressionTag") return;
+	attribute_names.set(expression.start, attribute_name);
+}
+function read_source_attribute_name(source, start, end) {
+	return source.slice(start, end).match(/^[^\s=]+/)?.[0];
+}
+function make_ast_script_region(source, script) {
+	const tag_name_end = script.start + 7;
+	const attributes = collect_ast_script_attributes(source, script, tag_name_end);
+	const content_start = get_program_offset(script.content, "start");
+	const content_end = get_program_offset(script.content, "end");
+	const lang = get_attribute(attributes, "lang")?.value?.toLowerCase();
+	const effect_attribute = get_attribute(attributes, "effect");
+	return {
+		start: script.start,
+		end: script.end,
+		opening_tag_start: script.start,
+		opening_tag_end: content_start,
+		tag_name_end,
+		content_start,
+		content_end,
+		closing_tag_start: content_end,
+		closing_tag_end: script.end,
+		attributes_text: source.slice(tag_name_end, content_start - 1),
+		attributes,
+		text: source.slice(content_start, content_end),
+		is_module: script.context === "module",
+		has_lang: get_attribute(attributes, "lang") !== void 0,
+		lang,
+		is_typescript: lang === "ts" || lang === "typescript",
+		has_effect: effect_attribute !== void 0,
+		effect_attribute: effect_attribute ? {
+			start: effect_attribute.start,
+			end: effect_attribute.end
+		} : void 0
+	};
+}
+function get_program_offset(program, key) {
+	if (key === "start" && "start" in program && typeof program.start === "number") return program.start;
+	if (key === "end" && "end" in program && typeof program.end === "number") return program.end;
+	throw new Error(`Svelte script content has no ${key} offset`);
+}
+function collect_ast_script_attributes(source, script, tag_name_end) {
+	let previous_end = tag_name_end;
+	return script.attributes.map((attribute) => {
+		const name_start = attribute.start;
+		const source_name = read_source_attribute_name(source, attribute.start, attribute.end);
+		const name_end = name_start + (source_name?.length ?? attribute.name.length);
+		let start = attribute.start;
+		while (start > previous_end && /\s/.test(source[start - 1] ?? "")) start -= 1;
+		previous_end = attribute.end;
+		return {
+			name: source_name ?? attribute.name,
+			start,
+			end: attribute.end,
+			name_start,
+			name_end,
+			value: get_static_attribute_value(attribute.value)
+		};
+	});
+}
+function get_static_attribute_value(value) {
+	if (value === true) return;
+	const parts = Array.isArray(value) ? value : [value];
+	if (!parts.every((part) => part.type === "Text")) return;
+	return parts.map((part) => part.data).join("");
+}
+function collect_scanned_markup_expressions(source, excluded_ranges, attribute_names) {
+	const expressions = [];
+	let cursor = 0;
+	while (cursor < source.length) {
+		const open = source.indexOf("{", cursor);
+		if (open === -1) break;
+		const excluded_range = find_range_containing(excluded_ranges, open);
+		if (excluded_range) {
+			cursor = excluded_range.end;
+			continue;
+		}
+		const close = find_closing_brace(source, open);
+		if (close === -1) {
+			cursor = open + 1;
+			continue;
+		}
+		const inner_start = open + 1;
+		const inner_end = close;
+		const inner = source.slice(inner_start, inner_end);
+		expressions.push({
+			open,
+			close,
+			inner_start,
+			inner_end,
+			inner,
+			expression_text: inner.trim(),
+			attribute_name: attribute_names.get(open)
+		});
+		cursor = close + 1;
+	}
+	return expressions;
+}
+function find_range_containing(ranges, position) {
+	let low = 0;
+	let high = ranges.length - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const range = ranges[mid];
+		if (position < range.start) {
+			high = mid - 1;
+			continue;
+		}
+		if (position >= range.end) {
+			low = mid + 1;
+			continue;
+		}
+		return range;
+	}
+}
+function make_bare_const_tag(expression) {
+	if (!/^(\s*)const\s/.test(expression.inner)) return [];
+	return [{
+		open: expression.open,
+		insert_position: expression.open + 1,
+		expression
+	}];
+}
+function merge_ranges(ranges) {
+	const sorted = [...ranges].sort((a, b) => a.start - b.start);
+	const merged = [];
+	for (const range of sorted) {
+		const previous = merged.at(-1);
+		if (!previous || range.start > previous.end) {
+			merged.push({ ...range });
+			continue;
+		}
+		previous.end = Math.max(previous.end, range.end);
+	}
+	return merged;
+}
+function get_attribute(attributes, name) {
+	const normalized_name = name.toLowerCase();
+	return attributes.find((attribute) => attribute.name.toLowerCase() === normalized_name);
+}
+function find_closing_brace(source, open) {
+	const closing_directive = source.slice(open + 1).match(/^\s*\/(?:if|each|await|key|snippet)\s*}/);
+	if (closing_directive) return open + 1 + closing_directive[0].lastIndexOf("}");
+	let depth = 1;
+	let cursor = open + 1;
+	while (cursor < source.length) {
+		const char = source[cursor];
+		if (char === "'" || char === "\"") {
+			const close = skip_quoted_string(source, cursor, char);
+			if (close === -1) return -1;
+			cursor = close + 1;
+			continue;
+		}
+		if (char === "`") {
+			const close = skip_template_literal(source, cursor);
+			if (close === -1) return -1;
+			cursor = close + 1;
+			continue;
+		}
+		if (char === "/" && source[cursor + 1] === "/") {
+			cursor = skip_line_comment(source, cursor) + 1;
+			continue;
+		}
+		if (char === "/" && source[cursor + 1] === "*") {
+			const close = skip_block_comment(source, cursor);
+			if (close === -1) return -1;
+			cursor = close + 1;
+			continue;
+		}
+		if (char === "/") return find_closing_brace_with_typescript(source, open, cursor);
+		if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return cursor;
+		}
+		cursor += 1;
+	}
+	return -1;
+}
+function find_closing_brace_with_typescript(source, open, slash) {
+	let candidate = source.indexOf("}", slash + 1);
+	let candidate_index = 0;
+	let next_probe_index = 0;
+	let last_candidate = -1;
+	let last_probed_candidate = -1;
+	while (candidate !== -1) {
+		last_candidate = candidate;
+		if (candidate_index === next_probe_index) {
+			const resolved = resolve_closing_brace_probe(source, open, slash, candidate);
+			if (resolved !== -1) return resolved;
+			last_probed_candidate = candidate;
+			next_probe_index = next_probe_index * 2 + 1;
+		}
+		candidate_index += 1;
+		candidate = source.indexOf("}", candidate + 1);
+	}
+	if (last_candidate !== last_probed_candidate) return resolve_closing_brace_probe(source, open, slash, last_candidate);
+	return -1;
+}
+function resolve_closing_brace_probe(source, open, slash, candidate) {
+	if (candidate === -1) return -1;
+	const probe = parse_closing_brace_probe(source, open, candidate);
+	if (probe.is_exact) return candidate;
+	if (probe.close < slash || probe.close >= candidate || source[probe.close] !== "}") return -1;
+	return parse_closing_brace_probe(source, open, probe.close).is_exact ? probe.close : -1;
+}
+function parse_closing_brace_probe(source, open, candidate) {
+	const generator_prefix = "function* __SER__(){";
+	const boundary_name = "__SER___expression_boundary";
+	const boundary_statement = `\nconst ${boundary_name} = 0;`;
+	const tail = adapt_svelte_directive_tail(source.slice(open + 1, candidate + 1));
+	const source_file = ts.createSourceFile("svelte-expression.ts", generator_prefix + tail + boundary_statement, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const declaration = source_file.statements[0];
+	const boundary = source_file.statements[1];
+	const boundary_declaration = boundary && ts.isVariableStatement(boundary) ? boundary.declarationList.declarations[0] : void 0;
+	const has_boundary = boundary_declaration?.name !== void 0 && ts.isIdentifier(boundary_declaration.name) && boundary_declaration.name.text === boundary_name;
+	const has_unterminated_regex = source_file.parseDiagnostics?.some((diagnostic) => diagnostic.code === 1161);
+	if (!declaration || !ts.isFunctionDeclaration(declaration) || !declaration.body) return {
+		close: -1,
+		is_exact: false
+	};
+	const close = open + declaration.body.end - 20;
+	return {
+		close,
+		is_exact: close === candidate && has_boundary && !has_unterminated_regex
+	};
+}
+function adapt_svelte_directive_tail(tail) {
+	const const_directive = tail.match(/^(\s*)@(?=const\b)/);
+	if (const_directive) {
+		const at = const_directive[1].length;
+		return tail.slice(0, at) + " " + tail.slice(at + 1);
+	}
+	const prefix = tail.match(/^\s*(?:(?:#(?:if|each|await|key|snippet)|@(?:render|html|debug|attach)|:(?:else\s+if|else|then|catch))\b\s*|\.\.\.\s*)/)?.[0];
+	if (!prefix) return tail;
+	return blank_source(prefix) + tail.slice(prefix.length);
+}
+function skip_quoted_string(source, start, quote) {
+	for (let cursor = start + 1; cursor < source.length; cursor += 1) {
+		if (source[cursor] === "\\") {
+			cursor += 1;
+			continue;
+		}
+		if (source[cursor] === quote) return cursor;
+	}
+	return -1;
+}
+function skip_template_literal(source, start) {
+	let cursor = start + 1;
+	while (cursor < source.length) {
+		if (source[cursor] === "\\") {
+			cursor += 2;
+			continue;
+		}
+		if (source[cursor] === "`") return cursor;
+		if (source[cursor] === "$" && source[cursor + 1] === "{") {
+			const close = find_closing_brace(source, cursor + 1);
+			if (close === -1) return -1;
+			cursor = close + 1;
+			continue;
+		}
+		cursor += 1;
+	}
+	return -1;
+}
+function skip_line_comment(source, start) {
+	for (let cursor = start + 2; cursor < source.length; cursor += 1) {
+		const char = source[cursor];
+		if (char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029") return cursor;
+	}
+	return source.length;
+}
+function skip_block_comment(source, start) {
+	const close = source.indexOf("*/", start + 2);
+	return close === -1 ? -1 : close + 1;
+}
+//#endregion
+export { scan_svelte_effect_source as t };
+
+//# sourceMappingURL=source-scan-9pZxnfct.js.map