minecraft-datapack-language 15.4.25__py3-none-any.whl → 15.4.27__py3-none-any.whl

minecraft_datapack_language/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '15.4.25'
-__version_tuple__ = version_tuple = (15, 4, 25)
+__version__ = version = '15.4.27'
+__version_tuple__ = version_tuple = (15, 4, 27)
 
 __commit_id__ = commit_id = None

minecraft_datapack_language/cli_build.py

@@ -21,6 +21,17 @@ from .cli_colors import (
 )
 
 
+def _extract_scope_selector(var_name: str) -> tuple[str, str]:
+    """Extract scope selector from variable name like 'player_score<@s>' -> ('player_score', '@s')"""
+    if '<' in var_name and var_name.endswith('>'):
+        parts = var_name.split('<', 1)
+        if len(parts) == 2:
+            base_name = parts[0]
+            scope_selector = parts[1][:-1]  # Remove trailing >
+            return base_name, scope_selector
+    return var_name, "@s"  # Default to @s if no scope specified
+
+
 class BuildContext:
     """Context for build operations to prevent race conditions."""
     
@@ -194,7 +205,13 @@ def _generate_scoreboard_objectives(ast: Dict[str, Any], output_dir: Path) -> Li
     
     # Create scoreboard objectives in the order they were found
     for var_name in variables:
-        scoreboard_commands.append(f"scoreboard objectives add {var_name} dummy")
+        # Extract base variable name from scoped variables
+        base_var_name, _ = _extract_scope_selector(var_name)
+        scoreboard_commands.append(f"scoreboard objectives add {base_var_name} dummy")
+    
+    # Add temporary variables for complex expressions (up to 10 temp variables)
+    for i in range(10):
+        scoreboard_commands.append(f"scoreboard objectives add temp_{i} dummy")
     
     return scoreboard_commands
 
@@ -299,6 +316,188 @@ def _process_say_command_with_variables(content: str, selector: str, variable_sc
     return f'tellraw @a [{components_str}]'
 
 
+def _process_complex_expression(expression: Any, target_selector: str, target_var: str, variable_scopes: Dict[str, str] = None, temp_var_counter: int = 0) -> tuple[List[str], int]:
+    """
+    Process complex expressions and break them down into intermediate variables.
+    Returns (commands, new_temp_counter)
+    """
+    if variable_scopes is None:
+        variable_scopes = {}
+    
+    commands = []
+    
+    # Handle different expression types
+    if hasattr(expression, '__class__'):
+        class_name = str(expression.__class__)
+        
+        if 'BinaryExpression' in class_name:
+            # Binary expression: left operator right
+            if hasattr(expression, 'left') and hasattr(expression, 'right') and hasattr(expression, 'operator'):
+                left = expression.left
+                right = expression.right
+                operator = expression.operator
+                
+                # Process left side
+                if hasattr(left, 'name'):
+                    # Left is a variable
+                    left_base_name, left_selector = _extract_scope_selector(left.name)
+                    if left_selector == "@s" and variable_scopes and left_base_name in variable_scopes:
+                        left_selector = variable_scopes[left_base_name]
+                        if left_selector == 'global':
+                            left_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
+                    
+                    # Process right side
+                    if hasattr(right, 'value') and isinstance(right.value, (int, str)):
+                        # Right is a literal
+                        if operator == 'PLUS':
+                            commands.append(f"scoreboard players add {target_selector} {target_var} {right.value}")
+                        elif operator == 'MINUS':
+                            commands.append(f"scoreboard players remove {target_selector} {target_var} {right.value}")
+                        elif operator == 'MULTIPLY':
+                            # For multiplication, we need to use operations
+                            temp_var = f"temp_{temp_var_counter}"
+                            temp_var_counter += 1
+                            commands.append(f"scoreboard players set {target_selector} {temp_var} {right.value}")
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} *= {target_selector} {temp_var}")
+                        elif operator == 'DIVIDE':
+                            # For division, we need to use operations
+                            temp_var = f"temp_{temp_var_counter}"
+                            temp_var_counter += 1
+                            commands.append(f"scoreboard players set {target_selector} {temp_var} {right.value}")
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} /= {target_selector} {temp_var}")
+                        else:
+                            # Other operators - use operation
+                            commands.append(f"# Complex operation: {target_var} = {left.name} {operator} {right.value}")
+                    elif hasattr(right, 'name'):
+                        # Right is also a variable - need to use operations
+                        right_base_name, right_selector = _extract_scope_selector(right.name)
+                        if right_selector == "@s" and variable_scopes and right_base_name in variable_scopes:
+                            right_selector = variable_scopes[right_base_name]
+                            if right_selector == 'global':
+                                right_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
+                        
+                        if operator == 'PLUS':
+                            # First set target to left value
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} = {left_selector} {left_base_name}")
+                            # Then add right value
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} += {right_selector} {right_base_name}")
+                        elif operator == 'MINUS':
+                            # First set target to left value
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} = {left_selector} {left_base_name}")
+                            # Then subtract right value
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} -= {right_selector} {right_base_name}")
+                        elif operator == 'MULTIPLY':
+                            # First set target to left value
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} = {left_selector} {left_base_name}")
+                            # Then multiply by right value
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} *= {right_selector} {right_base_name}")
+                        elif operator == 'DIVIDE':
+                            # First set target to left value
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} = {left_selector} {left_base_name}")
+                            # Then divide by right value
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} /= {right_selector} {right_base_name}")
+                        else:
+                            # Other operators - use operation
+                            commands.append(f"# Complex operation: {target_var} = {left.name} {operator} {right.name}")
+                    else:
+                        # Complex right side - need to process recursively
+                        temp_var = f"temp_{temp_var_counter}"
+                        temp_var_counter += 1
+                        right_commands, temp_var_counter = _process_complex_expression(right, target_selector, temp_var, variable_scopes, temp_var_counter)
+                        commands.extend(right_commands)
+                        
+                        # Now perform the operation
+                        if operator == 'PLUS':
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} += {target_selector} {temp_var}")
+                        elif operator == 'MINUS':
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} -= {target_selector} {temp_var}")
+                        elif operator == 'MULTIPLY':
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} *= {target_selector} {temp_var}")
+                        elif operator == 'DIVIDE':
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} /= {target_selector} {temp_var}")
+                        else:
+                            commands.append(f"# Complex operation: {target_var} = {left.name} {operator} {temp_var}")
+                else:
+                    # Left is not a simple variable - need to process recursively
+                    temp_var = f"temp_{temp_var_counter}"
+                    temp_var_counter += 1
+                    left_commands, temp_var_counter = _process_complex_expression(left, target_selector, temp_var, variable_scopes, temp_var_counter)
+                    commands.extend(left_commands)
+                    
+                    # Now process the right side
+                    if hasattr(right, 'value') and isinstance(right.value, (int, str)):
+                        # Right is a literal
+                        if operator == 'PLUS':
+                            commands.append(f"scoreboard players add {target_selector} {target_var} {right.value}")
+                        elif operator == 'MINUS':
+                            commands.append(f"scoreboard players remove {target_selector} {target_var} {right.value}")
+                        else:
+                            commands.append(f"# Complex operation: {target_var} = {temp_var} {operator} {right.value}")
+                    else:
+                        # Right is also complex - need to process recursively
+                        right_temp_var = f"temp_{temp_var_counter}"
+                        temp_var_counter += 1
+                        right_commands, temp_var_counter = _process_complex_expression(right, target_selector, right_temp_var, variable_scopes, temp_var_counter)
+                        commands.extend(right_commands)
+                        
+                        # Now perform the operation between the two temp variables
+                        if operator == 'PLUS':
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} = {target_selector} {temp_var}")
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} += {target_selector} {right_temp_var}")
+                        elif operator == 'MINUS':
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} = {target_selector} {temp_var}")
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} -= {target_selector} {right_temp_var}")
+                        elif operator == 'MULTIPLY':
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} = {target_selector} {temp_var}")
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} *= {target_selector} {right_temp_var}")
+                        elif operator == 'DIVIDE':
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} = {target_selector} {temp_var}")
+                            commands.append(f"scoreboard players operation {target_selector} {target_var} /= {target_selector} {right_temp_var}")
+                        else:
+                            commands.append(f"# Complex operation: {target_var} = {temp_var} {operator} {right_temp_var}")
+            else:
+                commands.append(f"# Malformed binary expression: {expression}")
+        
+        elif 'VariableExpression' in class_name:
+            # Simple variable reference
+            if hasattr(expression, 'name'):
+                var_name = expression.name
+                base_var_name, var_selector = _extract_scope_selector(var_name)
+                if var_selector == "@s" and variable_scopes and base_var_name in variable_scopes:
+                    var_selector = variable_scopes[base_var_name]
+                    if var_selector == 'global':
+                        var_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
+                
+                commands.append(f"scoreboard players operation {target_selector} {target_var} = {var_selector} {base_var_name}")
+            else:
+                commands.append(f"# Malformed variable expression: {expression}")
+        
+        elif 'LiteralExpression' in class_name:
+            # Literal value
+            if hasattr(expression, 'value'):
+                try:
+                    num_value = int(expression.value)
+                    commands.append(f"scoreboard players set {target_selector} {target_var} {num_value}")
+                except (ValueError, TypeError):
+                    commands.append(f"# Cannot convert literal to number: {expression.value}")
+            else:
+                commands.append(f"# Malformed literal expression: {expression}")
+        
+        else:
+            # Unknown expression type
+            commands.append(f"# Unknown expression type: {class_name} - {expression}")
+    
+    else:
+        # Direct value
+        try:
+            num_value = int(expression)
+            commands.append(f"scoreboard players set {target_selector} {target_var} {num_value}")
+        except (ValueError, TypeError):
+            commands.append(f"# Cannot convert expression to number: {expression}")
+    
+    return commands, temp_var_counter
+
+
 def _process_statement(statement: Any, namespace: str, function_name: str, statement_index: int = 0, is_tag_function: bool = False, selector: str = "@s", variable_scopes: Dict[str, str] = None, build_context: BuildContext = None, output_dir: Path = None) -> List[str]:
     """Process a single statement and return Minecraft commands."""
     if variable_scopes is None:
@@ -336,65 +535,68 @@ def _process_statement(statement: Any, namespace: str, function_name: str, state
         var_name = statement['name']
         value = statement['value']
         
-        # Determine the correct selector for this variable based on its declared scope
-        var_selector = selector  # Default to current selector
-        if variable_scopes and var_name in variable_scopes:
-            declared_scope = variable_scopes[var_name]
+        # Extract scope selector from variable name (e.g., 'player_score<@s>' -> 'player_score', '@s')
+        base_var_name, var_selector = _extract_scope_selector(var_name)
+        
+        # If no scope selector in name, fall back to declared scope
+        if var_selector == "@s" and variable_scopes and base_var_name in variable_scopes:
+            declared_scope = variable_scopes[base_var_name]
             if declared_scope == 'global':
                 var_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
             else:
                 var_selector = declared_scope
-        print(f"DEBUG: Variable {var_name} assignment using selector: {var_selector} (declared scope: {variable_scopes.get(var_name, 'none')})")
+        
+        print(f"DEBUG: Variable {base_var_name} assignment using selector: {var_selector} (from name: {var_name})")
         
         # Handle different value types
         if isinstance(value, int):
-            commands.append(f"scoreboard players set {var_selector} {var_name} {value}")
+            commands.append(f"scoreboard players set {var_selector} {base_var_name} {value}")
         elif isinstance(value, str) and value.startswith('$') and value.endswith('$'):
             # Variable reference
             ref_var = value[1:-1]  # Remove $ symbols
-            commands.append(f"scoreboard players operation {var_selector} {var_name} = {var_selector} {ref_var}")
-        elif hasattr(value, '__class__') and 'BinaryExpression' in str(value.__class__):
-            # Handle complex expressions (BinaryExpression, etc.)
-            # Convert to proper Minecraft scoreboard commands
-            if hasattr(value, 'left') and hasattr(value, 'right') and hasattr(value, 'operator'):
-                left = value.left
-                right = value.right
-                operator = value.operator
-                
-                # Handle different operators
-                if operator == 'PLUS':
-                    if hasattr(left, 'name') and hasattr(right, 'value'):
-                        # counter = counter + 1
-                        commands.append(f"scoreboard players add {var_selector} {var_name} {right.value}")
-                    else:
-                        # Complex case - use operation
-                        commands.append(f"# Complex addition: {var_name} = {left} + {right}")
-                elif operator == 'MINUS':
-                    if hasattr(left, 'name') and hasattr(right, 'value'):
-                        # health = health - 10
-                        commands.append(f"scoreboard players remove {var_selector} {var_name} {right.value}")
-                    else:
-                        # Complex case - use operation
-                        commands.append(f"# Complex operation: {var_name} = {left} - {right}")
+            # Extract scope from reference variable if it has one
+            ref_base_name, ref_selector = _extract_scope_selector(ref_var)
+            if ref_selector == "@s" and variable_scopes and ref_base_name in variable_scopes:
+                declared_scope = variable_scopes[ref_base_name]
+                if declared_scope == 'global':
+                    ref_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
                 else:
-                    # Other operators - use operation
-                    commands.append(f"# Complex operation: {var_name} = {left} {operator} {right}")
+                    ref_selector = declared_scope
+            commands.append(f"scoreboard players operation {var_selector} {base_var_name} = {ref_selector} {ref_base_name}")
+        elif hasattr(value, '__class__') and 'VariableExpression' in str(value.__class__):
+            # Variable expression (e.g., playerCounter<@s> = globalCounter<@a>)
+            if hasattr(value, 'name'):
+                ref_var = value.name
+                # Extract scope from reference variable
+                ref_base_name, ref_selector = _extract_scope_selector(ref_var)
+                if ref_selector == "@s" and variable_scopes and ref_base_name in variable_scopes:
+                    declared_scope = variable_scopes[ref_base_name]
+                    if declared_scope == 'global':
+                        ref_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
+                    else:
+                        ref_selector = declared_scope
+                commands.append(f"scoreboard players operation {var_selector} {base_var_name} = {ref_selector} {ref_base_name}")
             else:
-                commands.append(f"# Complex assignment: {var_name} = {value}")
+                commands.append(f"# Variable expression assignment: {base_var_name} = {value}")
+        elif hasattr(value, '__class__') and 'BinaryExpression' in str(value.__class__):
+            # Handle complex expressions using the enhanced expression processor
+            # This will break down complex expressions into intermediate variables
+            expression_commands, _ = _process_complex_expression(value, var_selector, base_var_name, variable_scopes, 0)
+            commands.extend(expression_commands)
         else:
             # Handle LiteralExpression and other value types
             try:
                 if hasattr(value, 'value'):
                     # LiteralExpression case
                     num_value = int(value.value)
-                    commands.append(f"scoreboard players set {var_selector} {var_name} {num_value}")
+                    commands.append(f"scoreboard players set {var_selector} {base_var_name} {num_value}")
                 else:
                     # Direct value case
                     num_value = int(value)
-                    commands.append(f"scoreboard players set {var_selector} {var_name} {num_value}")
+                    commands.append(f"scoreboard players set {var_selector} {base_var_name} {num_value}")
             except (ValueError, TypeError):
                 # If we can't convert to int, add a placeholder
-                commands.append(f"# Assignment: {var_name} = {value}")
+                commands.append(f"# Assignment: {base_var_name} = {value}")
     
     elif statement['type'] == 'if_statement':
         condition = statement['condition']
@@ -507,11 +709,21 @@ def _generate_function_file(ast: Dict[str, Any], output_dir: Path, namespace: st
             for var_decl in ast['variables']:
                 var_name = var_decl['name']
                 var_scope = var_decl.get('scope')
-                if var_scope:
-                    variable_scopes[var_name] = var_scope
-                    print(f"DEBUG: Variable {var_name} has scope {var_scope}")
+                
+                # Extract base variable name and scope selector
+                base_var_name, scope_selector = _extract_scope_selector(var_name)
+                
+                if scope_selector != "@s":
+                    # Variable has explicit scope selector
+                    variable_scopes[base_var_name] = scope_selector
+                    print(f"DEBUG: Variable {base_var_name} has scope {scope_selector} from name {var_name}")
+                elif var_scope:
+                    # Variable has scope from scope field (legacy support)
+                    variable_scopes[base_var_name] = var_scope
+                    print(f"DEBUG: Variable {base_var_name} has scope {var_scope} from scope field")
                 else:
-                    print(f"DEBUG: Variable {var_name} has no scope (defaults to @s)")
+                    # Variable has no scope (defaults to @s)
+                    print(f"DEBUG: Variable {base_var_name} has no scope (defaults to @s)")
         
         print(f"DEBUG: Collected variable scopes: {variable_scopes}")
         

minecraft_datapack_language/mdl_parser_js.py

@@ -317,9 +317,29 @@ class MDLParser:
                 )
             
             # Check if this is a variable assignment (identifier followed by =)
+            # Need to handle scope selectors like: identifier<scope> = ...
             if (self.current + 1 < len(self.tokens) and 
                 self.tokens[self.current + 1].type == TokenType.ASSIGN):
                 return self._parse_variable_assignment()
+            elif (self.current + 1 < len(self.tokens) and 
+                  self.tokens[self.current + 1].type == TokenType.LANGLE):
+                # This might be a scoped variable assignment: identifier<scope> = ...
+                # Look ahead to see if there's an assignment after the scope selector
+                temp_current = self.current + 1
+                while (temp_current < len(self.tokens) and 
+                       self.tokens[temp_current].type != TokenType.RANGLE and
+                       self.tokens[temp_current].type != TokenType.ASSIGN):
+                    temp_current += 1
+                
+                if (temp_current < len(self.tokens) and 
+                    self.tokens[temp_current].type == TokenType.RANGLE and
+                    temp_current + 1 < len(self.tokens) and
+                    self.tokens[temp_current + 1].type == TokenType.ASSIGN):
+                    # This is a scoped variable assignment
+                    return self._parse_variable_assignment()
+                else:
+                    # This is a command with scope selector
+                    return self._parse_command()
             else:
                 # Assume it's a command
                 return self._parse_command()
@@ -337,31 +357,29 @@ class MDLParser:
         
         # Check for scope selector after variable name
         scope = None
-        if not self._is_at_end() and self._peek().type == TokenType.SCOPE:
-            self._match(TokenType.SCOPE)  # consume 'scope'
+        if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
+            self._match(TokenType.LANGLE)  # consume '<'
             
-            # Parse scope selector in angle brackets
-            if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
-                self._match(TokenType.LANGLE)  # consume '<'
-                
-                # Parse scope selector content
-                scope_parts = []
-                while not self._is_at_end() and self._peek().type != TokenType.RANGLE:
-                    scope_parts.append(self._peek().value)
-                    self._advance()
-                
-                if self._is_at_end():
-                    raise create_parser_error(
-                        message="Unterminated scope selector",
-                        file_path=self.source_file,
-                        line=self._peek().line,
-                        column=self._peek().column,
-                        line_content=self._peek().value,
-                        suggestion="Add a closing '>' to terminate the scope selector"
-                    )
-                
-                self._match(TokenType.RANGLE)  # consume '>'
-                scope = ''.join(scope_parts)
+            # Parse scope selector content
+            scope_parts = []
+            while not self._is_at_end() and self._peek().type != TokenType.RANGLE:
+                scope_parts.append(self._peek().value)
+                self._advance()
+            
+            if self._is_at_end():
+                raise create_parser_error(
+                    message="Unterminated scope selector",
+                    file_path=self.source_file,
+                    line=self._peek().line,
+                    column=self._peek().column,
+                    line_content=self._peek().value,
+                    suggestion="Add a closing '>' to terminate the scope selector"
+                )
+            
+            self._match(TokenType.RANGLE)  # consume '>'
+            scope = ''.join(scope_parts)
+            # Update the name to include the scope selector
+            name = f"{name}<{scope}>"
         
         self._match(TokenType.ASSIGN)
         
@@ -901,15 +919,33 @@ class MDLParser:
             identifier_name = token.value
             self._advance()  # consume the identifier
             
-            # Check if the identifier contains a scope selector
-            if '<' in identifier_name and identifier_name.endswith('>'):
-                # Extract variable name and scope selector
-                parts = identifier_name.split('<', 1)
-                if len(parts) == 2:
-                    var_name = parts[0]
-                    scope_selector = parts[1][:-1]  # Remove the closing >
-                    # For variable expressions in assignments, keep the full scoped name
-                    return VariableExpression(identifier_name)
+            # Check if this identifier is followed by a scope selector
+            if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
+                # This is a scoped variable - parse the scope selector
+                self._match(TokenType.LANGLE)  # consume '<'
+                
+                # Parse scope selector content
+                scope_parts = []
+                while not self._is_at_end() and self._peek().type != TokenType.RANGLE:
+                    scope_parts.append(self._peek().value)
+                    self._advance()
+                
+                if self._is_at_end():
+                    raise create_parser_error(
+                        message="Unterminated scope selector in expression",
+                        file_path=self.source_file,
+                        line=self._peek().line,
+                        column=self._peek().column,
+                        line_content=self._peek().value,
+                        suggestion="Add a closing '>' to terminate the scope selector"
+                    )
+                
+                self._match(TokenType.RANGLE)  # consume '>'
+                scope_selector = ''.join(scope_parts)
+                
+                # Create a scoped variable expression
+                full_name = f"{identifier_name}<{scope_selector}>"
+                return VariableExpression(full_name)
             
             # Regular variable expression without scope
             return VariableExpression(identifier_name)

{minecraft_datapack_language-15.4.25.dist-info → minecraft_datapack_language-15.4.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.25
+Version: 15.4.27
 Summary: Compile JavaScript-style MDL language or Python API into a Minecraft datapack (1.21+ ready). Features variables, control flow, error handling, and VS Code extension.
 Project-URL: Homepage, https://www.mcmdl.com
 Project-URL: Documentation, https://www.mcmdl.com/docs

{minecraft_datapack_language-15.4.25.dist-info → minecraft_datapack_language-15.4.27.dist-info}/RECORD

@@ -1,8 +1,8 @@
 minecraft_datapack_language/__init__.py,sha256=i-qCchbe5b2Fshgc6yCU9mddOLs2UBt9SAcLqfUIrT0,606
-minecraft_datapack_language/_version.py,sha256=cpNlMoFPJRzh32B2Q7_IwcsrxLVLvnVsyE7jWlQC1dM,708
+minecraft_datapack_language/_version.py,sha256=LA-jQi7TFEITqcWkyJirDcPThmV9RoX2XbnqzYm2Uh8,708
 minecraft_datapack_language/ast_nodes.py,sha256=U-CB3R7p7OjaljI47BWsRrQtliw0yAWUrJVoxzOLmQw,2143
 minecraft_datapack_language/cli.py,sha256=p5A_tEEXugN2NhQFbbgfwi4FxbWYD91RWeKR_A3Vuec,6263
-minecraft_datapack_language/cli_build.py,sha256=u0XIOH_zTARPC6dvWf-411OqrF7RjT7Z9Hkp6hTeZsI,47990
+minecraft_datapack_language/cli_build.py,sha256=AfS_fQmLmpUTF_WNNT6SiA7u0vomX_eR1afq6gczQtE,62128
 minecraft_datapack_language/cli_check.py,sha256=bPq9gHsxQ1CIiftkrAtRCifWkVAyjp5c8Oay2NNQ1qs,6277
 minecraft_datapack_language/cli_colors.py,sha256=Hr8awY966bGSnVdXL3WnmRhSP1wH56vTQKGt5z-kIQM,7878
 minecraft_datapack_language/cli_help.py,sha256=Rc-v9E2kctsdN_lMunqdKuZ8EZ8rcZIjBCOPrXLBQeE,21363
@@ -14,12 +14,12 @@ minecraft_datapack_language/linter.py,sha256=7UqbygC5JPCGg-BSOq65NB2xEJBu_OUOYII
 minecraft_datapack_language/mdl_errors.py,sha256=mz6uyPkeBpbMHj4PiAyVecEVJ9_hdSfR45QAjG6oYf0,15690
 minecraft_datapack_language/mdl_lexer_js.py,sha256=VvbhKm727khdSAABxa03hoIIA7H3hWi3RLp9BSXbhY0,28277
 minecraft_datapack_language/mdl_linter.py,sha256=z85xoAglENurCh30bR7kEHZ_JeMxcYaLDcGNRAl-RAI,17253
-minecraft_datapack_language/mdl_parser_js.py,sha256=15E_OXXEHYmGAaqS-eCqI-sSIJ4LDk6soSeBbfo_qVg,43350
+minecraft_datapack_language/mdl_parser_js.py,sha256=aY841JdlXSTjR-TYb6KpmPrM87tEyb8lBqoHoB-Meng,45210
 minecraft_datapack_language/pack.py,sha256=nYiXQ3jgJlDfc4m-65f7C2LFhDRioaUU_XVy6Na4SJI,34625
 minecraft_datapack_language/utils.py,sha256=Aq0HAGlXqj9BUTEjaEilpvzEW0EtZYYMMwOqG9db6dE,684
-minecraft_datapack_language-15.4.25.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-minecraft_datapack_language-15.4.25.dist-info/METADATA,sha256=YGa1EZ268bYICR68n8J-LipaKPObtEORC5jTL4oWXro,37917
-minecraft_datapack_language-15.4.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-minecraft_datapack_language-15.4.25.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
-minecraft_datapack_language-15.4.25.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
-minecraft_datapack_language-15.4.25.dist-info/RECORD,,
+minecraft_datapack_language-15.4.27.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+minecraft_datapack_language-15.4.27.dist-info/METADATA,sha256=cChRD87FAKcP1BFBgNAESn7BKhGn4E565y2DfHQZZws,37917
+minecraft_datapack_language-15.4.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minecraft_datapack_language-15.4.27.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
+minecraft_datapack_language-15.4.27.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
+minecraft_datapack_language-15.4.27.dist-info/RECORD,,