pulse-framework 0.1.73__py3-none-any.whl → 0.1.75__py3-none-any.whl

pulse/transpiler/transpiler.py

@@ -10,8 +10,9 @@ from __future__ import annotations
 import ast
 import re
 from collections.abc import Callable, Mapping
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, cast, override
 
 from pulse.transpiler.builtins import BUILTINS, emit_method
 from pulse.transpiler.errors import TranspileError
@@ -30,6 +31,7 @@ from pulse.transpiler.nodes import (
 	Function,
 	Identifier,
 	If,
+	LetDecl,
 	Literal,
 	Member,
 	New,
@@ -78,6 +80,228 @@ ALLOWED_CMPOPS: dict[type[ast.cmpop], str] = {
 }
 
 
+def _collect_param_names(args: ast.arguments) -> list[str]:
+	"""Collect argument names (regular, vararg, kwonly, kwarg)."""
+	names: list[str] = [arg.arg for arg in args.args]
+	if args.vararg:
+		names.append(args.vararg.arg)
+	names.extend(arg.arg for arg in args.kwonlyargs)
+	if args.kwarg:
+		names.append(args.kwarg.arg)
+	return names
+
+
+@dataclass(slots=True)
+class Scope:
+	locals: set[str]
+	params: set[str]
+	parent: "Scope | None" = None
+
+
+class ScopeAnalyzer(ast.NodeVisitor):
+	"""Collect locals per scope (function/lambda/comprehension)."""
+
+	_scopes: dict[ast.AST, Scope]
+	_stack: list[Scope]
+	_global_scope: Scope
+
+	def __init__(self) -> None:
+		self._scopes = {}
+		self._stack = []
+		self._global_scope = Scope(locals=set(), params=set(), parent=None)
+
+	def analyze(
+		self, node: ast.FunctionDef | ast.AsyncFunctionDef
+	) -> dict[ast.AST, Scope]:
+		self._stack.append(self._global_scope)
+		self._visit_defaults(node.args)
+		scope = self._new_scope(
+			node, _collect_param_names(node.args), parent=self._global_scope
+		)
+		self._stack.append(scope)
+		for stmt in node.body:
+			self.visit(stmt)
+		self._stack.pop()
+		self._stack.pop()
+		return self._scopes
+
+	def _new_scope(
+		self,
+		node: ast.AST,
+		params: list[str],
+		*,
+		parent: Scope | None,
+	) -> Scope:
+		param_set = set(params)
+		scope = Scope(locals=set(param_set), params=param_set, parent=parent)
+		self._scopes[node] = scope
+		return scope
+
+	def _current_scope(self) -> Scope:
+		return self._stack[-1]
+
+	def _add_local(self, name: str) -> None:
+		self._current_scope().locals.add(name)
+
+	def _add_targets(self, target: ast.expr) -> None:
+		if isinstance(target, ast.Name):
+			self._add_local(target.id)
+			return
+		if isinstance(target, (ast.Tuple, ast.List)):
+			for elt in target.elts:
+				if isinstance(elt, ast.Name):
+					self._add_local(elt.id)
+
+	def _visit_target_expr(self, target: ast.expr) -> None:
+		if isinstance(target, (ast.Tuple, ast.List)):
+			for elt in target.elts:
+				self._visit_target_expr(elt)
+			return
+		self.visit(target)
+
+	def _analyze_function(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
+		self._visit_defaults(node.args)
+		scope = self._new_scope(
+			node,
+			_collect_param_names(node.args),
+			parent=self._current_scope(),
+		)
+		self._stack.append(scope)
+		for stmt in node.body:
+			self.visit(stmt)
+		self._stack.pop()
+
+	@property
+	def global_scope(self) -> Scope:
+		return self._global_scope
+
+	def _visit_defaults(self, args: ast.arguments) -> None:
+		for default in args.defaults:
+			self.visit(default)
+		for default in args.kw_defaults:
+			if default is not None:
+				self.visit(default)
+
+	@override
+	def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+		self._add_local(node.name)
+		self._analyze_function(node)
+
+	@override
+	def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+		self._add_local(node.name)
+		self._analyze_function(node)
+
+	@override
+	def visit_Lambda(self, node: ast.Lambda) -> None:
+		scope = self._new_scope(
+			node,
+			_collect_param_names(node.args),
+			parent=self._current_scope(),
+		)
+		self._stack.append(scope)
+		self.visit(node.body)
+		self._stack.pop()
+
+	def _visit_comprehension(
+		self,
+		node: ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp,
+		*,
+		elt: ast.expr,
+		key: ast.expr | None = None,
+	) -> None:
+		scope = self._new_scope(node, [], parent=self._current_scope())
+		self._stack.append(scope)
+		if key is not None:
+			self.visit(key)
+		self.visit(elt)
+		for gen in node.generators:
+			self.visit(gen.iter)
+			for if_node in gen.ifs:
+				self.visit(if_node)
+		self._stack.pop()
+
+	@override
+	def visit_ListComp(self, node: ast.ListComp) -> None:
+		self._visit_comprehension(node, elt=node.elt)
+
+	@override
+	def visit_SetComp(self, node: ast.SetComp) -> None:
+		self._visit_comprehension(node, elt=node.elt)
+
+	@override
+	def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
+		self._visit_comprehension(node, elt=node.elt)
+
+	@override
+	def visit_DictComp(self, node: ast.DictComp) -> None:
+		self._visit_comprehension(node, elt=node.value, key=node.key)
+
+	@override
+	def visit_Assign(self, node: ast.Assign) -> None:
+		for target in node.targets:
+			if isinstance(target, (ast.Name, ast.Tuple, ast.List)):
+				self._add_targets(target)
+			self._visit_target_expr(target)
+		self.visit(node.value)
+
+	@override
+	def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
+		if isinstance(node.target, (ast.Name, ast.Tuple, ast.List)):
+			self._add_targets(node.target)
+		self._visit_target_expr(node.target)
+		if node.value is not None:
+			self.visit(node.value)
+
+	@override
+	def visit_AugAssign(self, node: ast.AugAssign) -> None:
+		if isinstance(node.target, (ast.Name, ast.Tuple, ast.List)):
+			self._add_targets(node.target)
+		self._visit_target_expr(node.target)
+		self.visit(node.value)
+
+	@override
+	def visit_For(self, node: ast.For) -> None:
+		if isinstance(node.target, (ast.Name, ast.Tuple, ast.List)):
+			self._add_targets(node.target)
+		self._visit_target_expr(node.target)
+		self.visit(node.iter)
+		for stmt in node.body:
+			self.visit(stmt)
+		for stmt in node.orelse:
+			self.visit(stmt)
+
+	@override
+	def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+		if node.name:
+			self._add_local(node.name)
+		if node.type is not None:
+			self.visit(node.type)
+		for stmt in node.body:
+			self.visit(stmt)
+
+	@override
+	def visit_With(self, node: ast.With) -> None:
+		for item in node.items:
+			if item.optional_vars and isinstance(
+				item.optional_vars, (ast.Name, ast.Tuple, ast.List)
+			):
+				self._add_targets(item.optional_vars)
+			if item.optional_vars is not None:
+				self._visit_target_expr(item.optional_vars)
+			self.visit(item.context_expr)
+		for stmt in node.body:
+			self.visit(stmt)
+
+	@override
+	def visit_Global(self, node: ast.Global) -> None:
+		raise TranspileError("global is not supported", node=node)
+
+	@override
+	def visit_Nonlocal(self, node: ast.Nonlocal) -> None:
+		raise TranspileError("nonlocal is not supported", node=node)
+
+
 class Transpiler:
 	"""Transpile Python AST to v2 Expr/Stmt AST nodes.
 
@@ -93,10 +317,12 @@ class Transpiler:
 	fndef: ast.FunctionDef | ast.AsyncFunctionDef
 	args: list[str]
 	deps: Mapping[str, Expr]
-	locals: set[str]
 	jsx: bool
 	source_file: Path | None
 	_temp_counter: int
+	_scope_map: dict[ast.AST, Scope]
+	_scope_stack: list[Scope]
+	_global_scope: Scope
 
 	def __init__(
 		self,
@@ -109,22 +335,21 @@ class Transpiler:
 		self.fndef = fndef
 		self.source_file = source_file
 		# Collect all argument names (regular, vararg, kwonly, kwarg)
-		args: list[str] = [arg.arg for arg in fndef.args.args]
-		if fndef.args.vararg:
-			args.append(fndef.args.vararg.arg)
-		args.extend(arg.arg for arg in fndef.args.kwonlyargs)
-		if fndef.args.kwarg:
-			args.append(fndef.args.kwarg.arg)
-		self.args = args
+		self.args = _collect_param_names(fndef.args)
 		self.deps = deps
 		self.jsx = jsx
-		self.locals = set(self.args)
 		self._temp_counter = 0
+		analyzer = ScopeAnalyzer()
+		self._scope_map = analyzer.analyze(fndef)
+		self._global_scope = analyzer.global_scope
+		self._scope_stack = [self._scope_map[fndef]]
 		self.init_temp_counter()
 
 	def init_temp_counter(self) -> None:
 		"""Initialize temp counter to avoid collisions with args or globals."""
-		all_names = set(self.args) | set(self.deps.keys())
+		all_names = set(self.deps.keys())
+		for scope in self._scope_map.values():
+			all_names.update(scope.locals)
 		counter = 0
 		while f"$tmp{counter}" in all_names:
 			counter += 1
@@ -136,6 +361,38 @@ class Transpiler:
 		self._temp_counter += 1
 		return name
 
+	def _current_scope(self) -> Scope:
+		return self._scope_stack[-1]
+
+	def _push_scope(self, node: ast.AST) -> None:
+		self._scope_stack.append(self._scope_map[node])
+
+	def _pop_scope(self) -> None:
+		self._scope_stack.pop()
+
+	def _is_local_here(self, name: str) -> bool:
+		return name in self._current_scope().locals
+
+	def _is_local(self, name: str) -> bool:
+		scope: Scope | None = self._current_scope()
+		while scope is not None:
+			if name in scope.locals:
+				return True
+			scope = scope.parent
+		return False
+
+	def _require_local(
+		self, name: str, *, node: ast.expr | ast.stmt | ast.excepthandler
+	) -> None:
+		if not self._is_local_here(name):
+			raise TranspileError(f"Assignment to unknown local: {name}", node=node)
+
+	def _function_prelude(self, scope: Scope) -> list[Stmt]:
+		names = sorted(scope.locals - scope.params)
+		if not names:
+			return []
+		return [LetDecl(names)]
+
 	# --- Entrypoint ---------------------------------------------------------
 
 	def transpile(self) -> Function | Arrow:
@@ -176,7 +433,8 @@ class Transpiler:
 					return Arrow(self.args, expr)
 
 		# General case: Function (for JSX or multi-statement)
-		stmts = [self.emit_stmt(s) for s in body]
+		prelude = self._function_prelude(self._current_scope())
+		stmts = prelude + [self.emit_stmt(s) for s in body]
 		is_async = isinstance(self.fndef, ast.AsyncFunctionDef)
 		args = [self._jsx_args()] if self.jsx else self.args
 		return Function(args, stmts, is_async=is_async)
@@ -202,7 +460,7 @@ class Transpiler:
 			if default_idx >= 0:
 				# Has a default value
 				default_node = args.defaults[default_idx]
-				default_expr = self.emit_expr(default_node)
+				default_expr = self._emit_default_expr(default_node)
 				default_out.clear()
 				default_expr.emit(default_out)
 				destructure_parts.append(f"{param_name} = {''.join(default_out)}")
@@ -220,7 +478,7 @@ class Transpiler:
 			default_node = args.kw_defaults[i]
 			if default_node is not None:
 				# Has a default value
-				default_expr = self.emit_expr(default_node)
+				default_expr = self._emit_default_expr(default_node)
 				default_out.clear()
 				default_expr.emit(default_out)
 				destructure_parts.append(f"{param_name} = {''.join(default_out)}")
@@ -234,6 +492,14 @@ class Transpiler:
 
 		return "{" + ", ".join(destructure_parts) + "}"
 
+	def _emit_default_expr(self, node: ast.expr) -> Expr:
+		"""Emit defaults in defining-scope context."""
+		self._scope_stack.append(self._global_scope)
+		try:
+			return self.emit_expr(node)
+		finally:
+			self._scope_stack.pop()
+
 	# --- Statements ----------------------------------------------------------
 
 	def emit_stmt(self, node: ast.stmt) -> Stmt:
@@ -262,6 +528,7 @@ class Transpiler:
 					"Only simple augmented assignments supported", node=node
 				)
 			target = node.target.id
+			self._require_local(target, node=node)
 			op_type = type(node.op)
 			if op_type not in ALLOWED_BINOPS:
 				raise TranspileError(
@@ -296,22 +563,16 @@ class Transpiler:
 			target = target_node.id
 			value_expr = self.emit_expr(node.value)
 
-			if target in self.locals:
-				return Assign(target, value_expr)
-			else:
-				self.locals.add(target)
-				return Assign(target, value_expr, declare="let")
+			self._require_local(target, node=node)
+			return Assign(target, value_expr)
 
 		if isinstance(node, ast.AnnAssign):
 			if not isinstance(node.target, ast.Name):
 				raise TranspileError("Only simple annotated assignments supported")
 			target = node.target.id
 			value = Literal(None) if node.value is None else self.emit_expr(node.value)
-			if target in self.locals:
-				return Assign(target, value)
-			else:
-				self.locals.add(target)
-				return Assign(target, value, declare="let")
+			self._require_local(target, node=node)
+			return Assign(target, value)
 
 		if isinstance(node, ast.If):
 			cond = self.emit_expr(node.test)
@@ -358,11 +619,8 @@ class Transpiler:
 			assert isinstance(e, ast.Name)
 			name = e.id
 			sub = Subscript(Identifier(tmp_name), Literal(idx))
-			if name in self.locals:
-				stmts.append(Assign(name, sub))
-			else:
-				self.locals.add(name)
-				stmts.append(Assign(name, sub, declare="let"))
+			self._require_local(name, node=target)
+			stmts.append(Assign(name, sub))
 
 		return StmtSequence(stmts)
 
@@ -453,7 +711,7 @@ class Transpiler:
 						"Only simple name targets supported in for-loop unpacking"
 					)
 				names.append(e.id)
-				self.locals.add(e.id)
+				self._require_local(e.id, node=node)
 			iter_expr = self.emit_expr(node.iter)
 			body = [self.emit_stmt(s) for s in node.body]
 			# Use array pattern for destructuring
@@ -464,7 +722,7 @@ class Transpiler:
 			raise TranspileError("Only simple name targets supported in for-loops")
 
 		target = node.target.id
-		self.locals.add(target)
+		self._require_local(target, node=node)
 		iter_expr = self.emit_expr(node.iter)
 		body = [self.emit_stmt(s) for s in node.body]
 		return ForOf(target, iter_expr, body)
@@ -474,31 +732,29 @@ class Transpiler:
 	) -> Stmt:
 		"""Emit a nested function definition."""
 		name = node.name
-		params = [arg.arg for arg in node.args.args]
-
-		# Save current locals and extend with params
-		saved_locals = set(self.locals)
-		self.locals.update(params)
-
-		# Skip docstrings and emit body
-		body_stmts = node.body
-		if (
-			body_stmts
-			and isinstance(body_stmts[0], ast.Expr)
-			and isinstance(body_stmts[0].value, ast.Constant)
-			and isinstance(body_stmts[0].value.value, str)
-		):
-			body_stmts = body_stmts[1:]
+		params = _collect_param_names(node.args)
+		self._require_local(name, node=node)
 
-		stmts: list[Stmt] = [self.emit_stmt(s) for s in body_stmts]
+		self._push_scope(node)
+		try:
+			# Skip docstrings and emit body
+			body_stmts = node.body
+			if (
+				body_stmts
+				and isinstance(body_stmts[0], ast.Expr)
+				and isinstance(body_stmts[0].value, ast.Constant)
+				and isinstance(body_stmts[0].value.value, str)
+			):
+				body_stmts = body_stmts[1:]
 
-		# Restore outer locals and add function name
-		self.locals = saved_locals
-		self.locals.add(name)
+			prelude = self._function_prelude(self._current_scope())
+			stmts: list[Stmt] = prelude + [self.emit_stmt(s) for s in body_stmts]
+		finally:
+			self._pop_scope()
 
 		is_async = isinstance(node, ast.AsyncFunctionDef)
 		fn = Function(params, stmts, is_async=is_async)
-		return Assign(name, fn, declare="const")
+		return Assign(name, fn)
 
 	def _emit_try(self, node: ast.Try) -> Stmt:
 		"""Emit a try/except/finally statement."""
@@ -517,7 +773,6 @@ class Transpiler:
 			handler = node.handlers[0]
 			if handler.name:
 				catch_param = handler.name
-				self.locals.add(catch_param)
 			catch_body = [self.emit_stmt(s) for s in handler.body]
 
 		# Handle finally
@@ -594,23 +849,21 @@ class Transpiler:
 
 		if isinstance(node, ast.ListComp):
 			return self._emit_comprehension_chain(
-				node.generators, lambda: self.emit_expr(node.elt)
+				node, lambda: self.emit_expr(node.elt)
 			)
 
 		if isinstance(node, ast.GeneratorExp):
 			return self._emit_comprehension_chain(
-				node.generators, lambda: self.emit_expr(node.elt)
+				node, lambda: self.emit_expr(node.elt)
 			)
 
 		if isinstance(node, ast.SetComp):
-			arr = self._emit_comprehension_chain(
-				node.generators, lambda: self.emit_expr(node.elt)
-			)
+			arr = self._emit_comprehension_chain(node, lambda: self.emit_expr(node.elt))
 			return New(Identifier("Set"), [arr])
 
 		if isinstance(node, ast.DictComp):
 			pairs = self._emit_comprehension_chain(
-				node.generators,
+				node,
 				lambda: Array([self.emit_expr(node.key), self.emit_expr(node.value)]),
 			)
 			return New(Identifier("Map"), [pairs])
@@ -648,14 +901,14 @@ class Transpiler:
 		"""Emit a name reference."""
 		name = node.id
 
-		# Check deps first
+		# Local variable (current or enclosing scope)
+		if self._is_local(name):
+			return Identifier(name)
+
+		# Check deps
 		if name in self.deps:
 			return self.deps[name]
 
-		# Local variable
-		if name in self.locals:
-			return Identifier(name)
-
 		# Check builtins
 		if name in BUILTINS:
 			return BUILTINS[name]
@@ -1093,29 +1346,26 @@ class Transpiler:
 
 	def _emit_lambda(self, node: ast.Lambda) -> Expr:
 		"""Emit a lambda expression as an arrow function."""
-		params = [arg.arg for arg in node.args.args]
-
-		# Add params to locals temporarily
-		saved_locals = set(self.locals)
-		self.locals.update(params)
-
-		body = self.emit_expr(node.body)
+		params = _collect_param_names(node.args)
 
-		self.locals = saved_locals
+		self._push_scope(node)
+		try:
+			body = self.emit_expr(node.body)
+		finally:
+			self._pop_scope()
 
 		return Arrow(params, body)
 
 	def _emit_comprehension_chain(
 		self,
-		generators: list[ast.comprehension],
+		node: ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp,
 		build_last: Callable[[], Expr],
 	) -> Expr:
 		"""Build a flatMap/map chain for comprehensions."""
+		generators = node.generators
 		if len(generators) == 0:
 			raise TranspileError("Empty comprehension")
 
-		saved_locals = set(self.locals)
-
 		def build_chain(gen_index: int) -> Expr:
 			gen = generators[gen_index]
 			if gen.is_async:
@@ -1139,7 +1389,7 @@ class Transpiler:
 				)
 
 			for nm in names:
-				self.locals.add(nm)
+				self._current_scope().locals.add(nm)
 
 			base = iter_expr
 
@@ -1159,10 +1409,11 @@ class Transpiler:
 			inner = build_chain(gen_index + 1)
 			return Call(Member(base, "flatMap"), [Arrow(params, inner)])
 
+		self._push_scope(node)
 		try:
 			return build_chain(0)
 		finally:
-			self.locals = saved_locals
+			self._pop_scope()
 
 
 def transpile(

{pulse_framework-0.1.73.dist-info → pulse_framework-0.1.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pulse-framework
-Version: 0.1.73
+Version: 0.1.75
 Summary: Pulse - Full-stack framework for building real-time React applications in Python
 Requires-Dist: fastapi>=0.128.0
 Requires-Dist: uvicorn>=0.24.0

{pulse_framework-0.1.73.dist-info → pulse_framework-0.1.75.dist-info}/RECORD

@@ -48,27 +48,44 @@ pulse/hooks/runtime.py,sha256=ogrm4Prvr9ZNaBb5bLfZBHrzbJuYe1zKpIPkbdnIzsw,12286
 pulse/hooks/setup.py,sha256=NcQPKnMV5dO0vUsWi4u9c9LB0wqFstrtiPGdvihtGiQ,6872
 pulse/hooks/stable.py,sha256=hLCOl_oAbgdNwiaWwwUTk7ZsHvMqXFFozFztJZMyGbQ,3627
 pulse/hooks/state.py,sha256=zRFlcOUdl-SBkJ-EzVXRLrLXzAc4-uRzgH4hD9rM1oU,5251
-pulse/js/__init__.py,sha256=tj1A6-eR5WS83UNgHb3Dw23m37oJsEuyV0ezUB6kXbg,3636
-pulse/js/__init__.pyi,sha256=WN22WsJB-XFk6auL9zklwG2Kof3zeOsc56A56dJ3MWg,3097
+pulse/js/__init__.py,sha256=csEWvFon_ayAiR6OVQl2wnukaLWLK1_PPodVlcY_EvY,5062
+pulse/js/__init__.pyi,sha256=DCgO3uNh6dQLVd9QD3I-LyiPP9VrtE7MZYYHr-8EvVg,5479
 pulse/js/_types.py,sha256=F4Go2JtJ2dbxq1fXpc2ablG_nyvhvHzOlZLlEv0VmyU,7421
+pulse/js/abort_controller.py,sha256=nKiUgS_uy2Rgh-MNG7fcGIm8Qd6g7hNV_UVk7OgK3qg,1161
 pulse/js/array.py,sha256=_tC6QZlflWCXOXXUMMtowM3UK7iDWAtFM8BKqR5rjKk,8883
+pulse/js/array_buffer.py,sha256=-iuiSZuv-rx3d0jpQtQYZLXZ2nLuMF93QrQBO-HXv5o,4100
+pulse/js/blob.py,sha256=XiI4g_fKaKtB8OPzS6D4rFG0fRBZlCl9kbO7a5IFPPk,981
 pulse/js/console.py,sha256=A-GNKEnPby10gdcTdYsBPVfz4m94PYzTXRwGhfaPRpc,1775
+pulse/js/crypto.py,sha256=Atxtc2oqb4xnW9nQV3ruamQhCAl2O_H2XiECspN1JvI,1245
+pulse/js/custom_event.py,sha256=SxtzPQJwgSXRmesd3SiaVdCGYHsFcrnAiPZA63YuunA,901
 pulse/js/date.py,sha256=qJjdwupuUtKS95u8N8C8FKMKOIB8qjVMsYA3VYfe-tA,3363
 pulse/js/document.py,sha256=SBinVGfb05jFpeyxAE0yk5Z__dkdW_mFsTI-rvgc-S8,3004
+pulse/js/dom_parser.py,sha256=0qRlAHVr1gDphCPUOSJRcZR94giJF6JmsWOJv4I6p80,818
 pulse/js/error.py,sha256=v0_DmpN5ESt_CJTrIYfy8980eerjK8mHhQatNV_1M_8,2611
+pulse/js/fetch_api.py,sha256=-4qy5DkQcCeE9CvFMtq-by-WgA7PirgOrmgMflMsluQ,2342
+pulse/js/file.py,sha256=LDoAUXyq82VUULVkIeSjcIj1Vvy2hCi_LRUWh8THyP8,1177
+pulse/js/file_reader.py,sha256=-Y5rfjb2j9tQ-NDX-mWgERC6Alfllh2VvRr6rzXoII0,664
+pulse/js/form_data.py,sha256=_NKZZmD4G4gHsq-QKFMAFwU73ZatGK06p6_oUdQnh_U,1258
+pulse/js/intersection_observer.py,sha256=ZcNV1qyiXjKPOKz5zUQTMZ3oCpfxxSRxLCEDHS_5aKY,1672
+pulse/js/intl.py,sha256=Y_a1YvdQPzOpJAnpPiyM7Ip03L5mh-noChRDeDneVjU,2034
 pulse/js/json.py,sha256=P8nxOANjIxrzUA1XkBrd0SmNyAGyB3pVXZDPnA1OKks,1908
 pulse/js/map.py,sha256=bhw75CUMIearH4JACCs9zAffdzfla3Rae7SKGcCLGoc,2243
 pulse/js/math.py,sha256=OBbMlgoa6ZHLDgmXGNKMj5wYrvroV5ICIx-VsSE5_II,1757
+pulse/js/mutation_observer.py,sha256=7Ai74vHZFkAnVS-OrGYRanY9TpJZmHJ4PrKpz8jmTTU,1831
 pulse/js/navigator.py,sha256=2QWSr9xyyBfgd76P472qmayXQRYXIEo-b8zLzvfhHfg,1517
 pulse/js/number.py,sha256=fX2M6hZ5ry2FPsYaHhGlqgO6reBEXw7C-gtu0-8_Zyw,1262
 pulse/js/obj.py,sha256=8JG9OZZ1CNqAFoMTdYtxWhTmb6zs1BqxC-nLT7KYMF8,2030
 pulse/js/object.py,sha256=95WvnGWgB-PL-D7l12UgdxNy_fxO5sJXool3Rx5ahUQ,4433
+pulse/js/performance_observer.py,sha256=uletaqnJ6kvJqFSSFtmNo0j--FduK4uZHd8cfRqeN3A,1156
 pulse/js/promise.py,sha256=vBXcL-U9BuZN-q1jbYhyzQaOL2niDPw4LsD7q7Y_yco,4670
 pulse/js/pulse.py,sha256=m-LgqwhYygVBj7GzjeO-uo8fK5ThyVe7c3QvOJt_vc0,2962
 pulse/js/react.py,sha256=eRMrgM8RsoAIn2lcHDoUYas3l4tImLOW51dwmw9AxQU,12057
 pulse/js/regexp.py,sha256=qO-3nmt7uGN7V_bwimPCN-2RSsPfE6YiY7G1MjoP3YY,1055
+pulse/js/resize_observer.py,sha256=MN0pqnBETmI7bSrWT1bus4_vTZKmJ0jwBoW-cYQWoT4,1162
 pulse/js/set.py,sha256=omG3g-25GRHxgoKISSB4x-M8UDFlaXtFV9cSIpd5uB0,3017
 pulse/js/string.py,sha256=VsvDF_ve8R9QIiBdDotLP2KpCKwmpEfGgRQWckOCmHk,813
+pulse/js/text_encoding.py,sha256=5Qvl4XRva9m6tz9NKlv9Nej-O92epMG-y_bu6vCNHwI,1291
+pulse/js/url.py,sha256=-sOthAlPOhJvkXh4hhNLOuWbPKd_ICnG7u--yHDPzY4,2200
 pulse/js/weakmap.py,sha256=HACZEZ8EZk1xoaCmTXk__opvJLxlJ9_0U3y-01KQkHU,1412
 pulse/js/weakset.py,sha256=jerMG9ubroR29HvOLIm6lkLxMj-GGWbiE57U9F6zRuQ,1256
 pulse/js/window.py,sha256=yC1BjyH2jqp1x-CXJCUFta-ASyZ5668ozQ0AmAjZcxA,4097
@@ -101,13 +118,13 @@ pulse/state/property.py,sha256=pitudvCGBNqK6lePdPrs4Inyy7szo8qcR_0BI30veek,6274
 pulse/state/query_param.py,sha256=7faf244_KJ3yrsBimKTBlNLg6wP96FUuWoZl40oxpyY,14478
 pulse/state/state.py,sha256=_4DcB-og2s5Ui01kDx9HzpNwmAVD_pdCLB0TfYbcnzM,11603
 pulse/test_helpers.py,sha256=4iO5Ymy3SMvSjh-UaAaSdqm1I_SAJMNjdY2iYVro5f8,436
-pulse/transpiler/__init__.py,sha256=wDDnzqxgHpp_OLtcgyrJEg2jVoTnFIe3SSSTOsMDW8w,4700
+pulse/transpiler/__init__.py,sha256=0UqeEQ2dMD2tDDkzTASv-StQfKZkPuSvbYTqjkNk-3A,4895
 pulse/transpiler/assets.py,sha256=digd5hKYPEgLOzMtDBHULX3Adj1sfngdvnx3quQmgPY,2299
 pulse/transpiler/builtins.py,sha256=QZrow7XJ2wxGMAE-mgZmaUD03egOnXCbikOg8yMx9vQ,30807
 pulse/transpiler/dynamic_import.py,sha256=1AmBl6agGSoTZBp_94seXH733fewLOULUix9BOBPtKI,3372
 pulse/transpiler/emit_context.py,sha256=GyK6VdsBSTVIewQRhBagaV0hlqLTlPZ1i8EAZGi8SaY,1321
 pulse/transpiler/errors.py,sha256=LSBjLBnMglbl2D94p9JR4y-3jDefk6iHSlUVBaBOTu4,2823
-pulse/transpiler/function.py,sha256=a871LZFergCmjs1vr-XlOx4eU1FQKAuYxSLJej-LHHc,17036
+pulse/transpiler/function.py,sha256=8-WZC2VcPTGfFeWWQpCltOVPLyr4f1H8pWoCvSnI654,18105
 pulse/transpiler/id.py,sha256=CdgA1NndBpZjv0Hp4XiYbKn7wi-x4zWsFSjEiViKxVk,434
 pulse/transpiler/imports.py,sha256=gWLjRr9jakbUzBGDEepE2RI5Xn_UZwOD4TmlqjNIapM,10302
 pulse/transpiler/js_module.py,sha256=OcIgmrfiA6Hh6aukzgkyX63KsVSHdLzx5ezdKiJFUaQ,11093
@@ -118,15 +135,16 @@ pulse/transpiler/modules/math.py,sha256=8gjvdYTMqtuOnXrvX_Lwuo0ywAdSl7cpss4TMk6m
 pulse/transpiler/modules/pulse/__init__.py,sha256=TfMsiiB53ZFlxdNl7jfCAiMZs-vSRUTxUmqzkLTj-po,91
 pulse/transpiler/modules/pulse/tags.py,sha256=FMN1mWMlnsXa2qO6VmXxUAhFn1uOfGoKPQOjH4ZPlRE,6218
 pulse/transpiler/modules/typing.py,sha256=J9QCkXE6zzwMjiprX2q1BtK-iKLIiS21sQ78JH4RSMc,1716
-pulse/transpiler/nodes.py,sha256=vebA81QXkWoJMygX2CHH_94azKPRATaB6eBs5wdX4rE,52420
+pulse/transpiler/nodes.py,sha256=ObdCFIEvtKMVRO8iy1hIN4L-vC4yPqRvhPS6E344-bE,52673
+pulse/transpiler/parse.py,sha256=uz_KDnjmjzFSjGtVKRznWg95P0NHM8CafWgvqrqJcOs,1622
 pulse/transpiler/py_module.py,sha256=um4BYLrbs01bpgv2LEBHTbhXXh8Bs174c3ygv5tHHOg,4410
-pulse/transpiler/transpiler.py,sha256=pxNFVnJB_zpUnp12cfzeOqUINAb1ZKhlU2E1gYUE6mk,35752
+pulse/transpiler/transpiler.py,sha256=bu33-wGNqHGheT_ZqMnQgEARyPG6xyOvuLuixjxIZnI,42761
 pulse/transpiler/vdom.py,sha256=Bf1yw10hQl8BXa6rhr5byRa5ua3qgRsVGNgEtQneA2A,6460
 pulse/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/types/event_handler.py,sha256=psQCydj-WEtBcFU5JU4mDwvyzkW8V2O0g_VFRU2EOHI,1618
 pulse/user_session.py,sha256=nsnsMgqq2xGJZLpbHRMHUHcLrElMP8WcA4gjGMrcoBk,10208
 pulse/version.py,sha256=711vaM1jVIQPgkisGgKZqwmw019qZIsc_QTae75K2pg,1895
-pulse_framework-0.1.73.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-pulse_framework-0.1.73.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
-pulse_framework-0.1.73.dist-info/METADATA,sha256=PIqxEHW98zMJlT1C_cLNisDzX73GDvGKFW8e4UtVTfk,8299
-pulse_framework-0.1.73.dist-info/RECORD,,
+pulse_framework-0.1.75.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pulse_framework-0.1.75.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
+pulse_framework-0.1.75.dist-info/METADATA,sha256=Y2M3HpMari75ZADpqGSxEfyP5YGCnRS2AkZ3tE3lmpA,8299
+pulse_framework-0.1.75.dist-info/RECORD,,