minecraft-datapack-language 15.4.31__py3-none-any.whl → 15.4.33__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.31'
-__version_tuple__ = version_tuple = (15, 4, 31)
+__version__ = version = '15.4.33'
+__version_tuple__ = version_tuple = (15, 4, 33)
 
 __commit_id__ = commit_id = None

minecraft_datapack_language/cli.py

@@ -26,6 +26,8 @@ Examples:
   mdl new my_project                        # Create a new project
         """
     )
+    # Global options
+    parser.add_argument('--version', action='store_true', help='Show version and exit')
     
     subparsers = parser.add_subparsers(dest='command', help='Available commands')
     
@@ -34,6 +36,7 @@ Examples:
     build_parser.add_argument('--mdl', required=True, help='MDL file(s) or directory to build')
     build_parser.add_argument('-o', '--output', required=True, help='Output directory for the datapack')
     build_parser.add_argument('--verbose', action='store_true', help='Show detailed output')
+    build_parser.add_argument('--wrapper', help='Optional wrapper directory name for the datapack output')
     
     # Check command
     check_parser = subparsers.add_parser('check', help='Check MDL files for syntax errors')
@@ -45,9 +48,19 @@ Examples:
     new_parser.add_argument('project_name', help='Name of the new project')
     new_parser.add_argument('--pack-name', help='Custom name for the datapack')
     new_parser.add_argument('--pack-format', type=int, default=82, help='Pack format number (default: 82)')
+    new_parser.add_argument('--output', help='Directory to create the project in (defaults to current directory)')
     
     args = parser.parse_args()
     
+    if args.version and not args.command:
+        # Print version and exit
+        try:
+            from . import __version__
+        except Exception:
+            __version__ = "0.0.0"
+        print(__version__)
+        return 0
+
     if not args.command:
         parser.print_help()
         return 1
@@ -133,6 +146,7 @@ def build_command(args):
             print(f"Compiling to {output_dir}...")
         
         compiler = MDLCompiler()
+        # Note: --wrapper is currently accepted for compatibility but not required by compiler
         output_path = compiler.compile(final_ast, str(output_dir))
         
         print(f"Successfully built datapack: {output_path}")
@@ -193,9 +207,10 @@ def new_command(args):
     project_name = args.project_name
     pack_name = args.pack_name or project_name
     pack_format = args.pack_format
+    base_dir = Path(args.output) if getattr(args, 'output', None) else Path('.')
+    project_dir = base_dir / project_name
     
     # Create project directory
-    project_dir = Path(project_name)
     if project_dir.exists():
         print(f"Error: Project directory '{project_name}' already exists")
         return 1
@@ -213,7 +228,7 @@ var num counter<@s> = 0;
 var num global_timer<@a> = 0;
 
 // Main function
-function {project_name}:main<@s> {{
+function {project_name}:main {{
     say "Hello from {project_name}!";
     
     // Variable example
@@ -228,13 +243,13 @@ function {project_name}:main<@s> {{
     }}
 }}
 
-// Load function
-function {project_name}:load<@s> {{
-    say "Datapack loaded successfully!";
+// Init function (avoid reserved names like 'load' or 'tick')
+function {project_name}:init {{
+    say "Datapack initialized successfully!";
 }}
 
 // Hook to run on load
-on_load {project_name}:load<@s>;
+on_load {project_name}:init;
 '''
     
     with open(mdl_file, 'w', encoding='utf-8') as f:
@@ -281,7 +296,7 @@ For more information, visit: https://www.mcmdl.com
     with open(readme_file, 'w', encoding='utf-8') as f:
         f.write(readme_content)
     
-    print(f"Created new MDL project: {project_name}/")
+    print(f"Created new MDL project: {project_dir}/")
     print(f"  - {mdl_file}")
     print(f"  - {readme_file}")
     print(f"\nNext steps:")

minecraft_datapack_language/mdl_compiler.py

@@ -16,6 +16,7 @@ from .ast_nodes import (
 )
 from .dir_map import get_dir_map, DirMap
 from .mdl_errors import MDLCompilerError
+from .mdl_lexer import TokenType
 
 
 class MDLCompiler:
@@ -147,12 +148,23 @@ class MDLCompiler:
             lines.append(f"# Scope: {func.scope}")
         lines.append("")
         
+        # Reset temporary commands for this function
+        if hasattr(self, 'temp_commands'):
+            self.temp_commands = []
+        
         # Generate commands from function body
         for statement in func.body:
             cmd = self._statement_to_command(statement)
             if cmd:
                 lines.append(cmd)
         
+        # Add any temporary commands that were generated during compilation
+        if hasattr(self, 'temp_commands') and self.temp_commands:
+            lines.append("")
+            lines.append("# Temporary variable operations:")
+            for temp_cmd in self.temp_commands:
+                lines.append(temp_cmd)
+        
         return "\n".join(lines)
     
     def _compile_hooks(self, hooks: List[HookDeclaration], namespace_dir: Path):
@@ -290,9 +302,20 @@ class MDLCompiler:
     def _variable_assignment_to_command(self, assignment: VariableAssignment) -> str:
         """Convert variable assignment to scoreboard command."""
         objective = self.variables.get(assignment.name, assignment.name)
-        value = self._expression_to_value(assignment.value)
         scope = assignment.scope.strip("<>")
-        return f"scoreboard players set {scope} {objective} {value}"
+        
+        # Check if the value is a complex expression
+        if isinstance(assignment.value, BinaryExpression):
+            # Complex expression - use temporary variable approach
+            temp_var = self._generate_temp_variable_name()
+            self._compile_expression_to_temp(assignment.value, temp_var)
+            
+            # Return the command to set the target variable from the temp
+            return f"scoreboard players operation {scope} {objective} = @s {temp_var}"
+        else:
+            # Simple value - use direct assignment
+            value = self._expression_to_value(assignment.value)
+            return f"scoreboard players set {scope} {objective} {value}"
     
     def _say_command_to_command(self, say: SayCommand) -> str:
         """Convert say command to tellraw command with JSON formatting."""
@@ -348,94 +371,172 @@ class MDLCompiler:
                 return f'tellraw @a {first_part}'
     
     def _if_statement_to_command(self, if_stmt: IfStatement) -> str:
-        """Convert if statement to comment and include actual statements."""
-        condition = self._expression_to_condition(if_stmt.condition)
-        lines = [f"# if {condition}"]
+        """Convert if statement to proper Minecraft execute if commands."""
+        condition, invert_then = self._build_condition(if_stmt.condition)
+        lines = []
         
-        # Include the actual statements from the if body for visibility
+        # Prepare function name for the then branch
+        if_function_name = self._generate_if_function_name()
+        # Generate condition command
+        if invert_then:
+            lines.append(f"execute unless {condition} run function {self.current_namespace}:{if_function_name}")
+        else:
+            lines.append(f"execute if {condition} run function {self.current_namespace}:{if_function_name}")
+        
+        # Generate the if body function content
+        if_body_lines = [f"# Function: {self.current_namespace}:{if_function_name}"]
         for stmt in if_stmt.then_body:
             if isinstance(stmt, VariableAssignment):
-                # Include variable assignments directly
                 cmd = self._variable_assignment_to_command(stmt)
-                lines.append(cmd)
+                if_body_lines.append(cmd)
             elif isinstance(stmt, SayCommand):
-                # Include say commands directly
                 cmd = self._say_command_to_command(stmt)
-                lines.append(cmd)
+                if_body_lines.append(cmd)
             elif isinstance(stmt, RawBlock):
-                # Include raw blocks directly
-                lines.append(stmt.content)
+                if_body_lines.append(stmt.content)
             elif isinstance(stmt, IfStatement):
-                # Recursively handle nested if statements
                 cmd = self._if_statement_to_command(stmt)
-                lines.append(cmd)
+                if_body_lines.append(cmd)
             elif isinstance(stmt, WhileLoop):
-                # Handle while loops
                 cmd = self._while_loop_to_command(stmt)
-                lines.append(cmd)
+                if_body_lines.append(cmd)
             elif isinstance(stmt, FunctionCall):
-                # Handle function calls
                 cmd = self._function_call_to_command(stmt)
-                lines.append(cmd)
+                if_body_lines.append(cmd)
         
         # Handle else body if it exists
         if if_stmt.else_body:
-            lines.append("")
-            lines.append("# else:")
-            for stmt in if_stmt.else_body:
-                if isinstance(stmt, VariableAssignment):
-                    cmd = self._variable_assignment_to_command(stmt)
-                    lines.append(cmd)
-                elif isinstance(stmt, SayCommand):
-                    cmd = self._say_command_to_command(stmt)
-                    lines.append(cmd)
-                elif isinstance(stmt, RawBlock):
-                    lines.append(stmt.content)
-                elif isinstance(stmt, IfStatement):
-                    cmd = self._if_statement_to_command(stmt)
-                    lines.append(cmd)
-                elif isinstance(stmt, WhileLoop):
-                    cmd = self._while_loop_to_command(stmt)
-                    lines.append(cmd)
-                elif isinstance(stmt, FunctionCall):
-                    cmd = self._function_call_to_command(stmt)
-                    lines.append(cmd)
+            if isinstance(if_stmt.else_body, list) and len(if_stmt.else_body) == 1 and isinstance(if_stmt.else_body[0], IfStatement):
+                # Else-if: create an else function wrapper that contains the nested if
+                else_function_name = self._generate_else_function_name()
+                if invert_then:
+                    lines.append(f"execute if {condition} run function {self.current_namespace}:{else_function_name}")
+                else:
+                    lines.append(f"execute unless {condition} run function {self.current_namespace}:{else_function_name}")
+                else_body_lines = [f"# Function: {self.current_namespace}:{else_function_name}"]
+                nested_cmd = self._if_statement_to_command(if_stmt.else_body[0])
+                for nested_line in nested_cmd.split('\n'):
+                    if nested_line:
+                        else_body_lines.append(nested_line)
+                self._store_generated_function(else_function_name, else_body_lines)
+            else:
+                # Regular else: compile its body into its own function
+                else_function_name = self._generate_else_function_name()
+                if invert_then:
+                    lines.append(f"execute if {condition} run function {self.current_namespace}:{else_function_name}")
+                else:
+                    lines.append(f"execute unless {condition} run function {self.current_namespace}:{else_function_name}")
+                else_body_lines = [f"# Function: {self.current_namespace}:{else_function_name}"]
+                for stmt in if_stmt.else_body:
+                    if isinstance(stmt, VariableAssignment):
+                        cmd = self._variable_assignment_to_command(stmt)
+                        else_body_lines.append(cmd)
+                    elif isinstance(stmt, SayCommand):
+                        cmd = self._say_command_to_command(stmt)
+                        else_body_lines.append(cmd)
+                    elif isinstance(stmt, RawBlock):
+                        else_body_lines.append(stmt.content)
+                    elif isinstance(stmt, IfStatement):
+                        cmd = self._if_statement_to_command(stmt)
+                        else_body_lines.append(cmd)
+                    elif isinstance(stmt, WhileLoop):
+                        cmd = self._while_loop_to_command(stmt)
+                        else_body_lines.append(cmd)
+                    elif isinstance(stmt, FunctionCall):
+                        cmd = self._function_call_to_command(stmt)
+                        else_body_lines.append(cmd)
+                self._store_generated_function(else_function_name, else_body_lines)
+        
+        # Store the if function as its own file
+        self._store_generated_function(if_function_name, if_body_lines)
         
         return "\n".join(lines)
     
     def _while_loop_to_command(self, while_loop: WhileLoop) -> str:
-        """Convert while loop to comment and include actual statements."""
+        """Convert while loop to proper Minecraft loop logic."""
         condition = self._expression_to_condition(while_loop.condition)
-        lines = [f"# while {condition}"]
+        lines = []
+        
+        # Generate the while loop using a recursive function approach
+        loop_function_name = self._generate_while_function_name()
+        
+        # First, call the loop function
+        lines.append(f"function {self.current_namespace}:{loop_function_name}")
         
-        # Include the actual statements from the while body for visibility
+        # Generate the loop function body
+        loop_body_lines = [f"# Function: {self.current_namespace}:{loop_function_name}"]
+        
+        # Add the loop body statements
         for stmt in while_loop.body:
             if isinstance(stmt, VariableAssignment):
-                # Include variable assignments directly
                 cmd = self._variable_assignment_to_command(stmt)
-                lines.append(cmd)
+                loop_body_lines.append(cmd)
             elif isinstance(stmt, SayCommand):
-                # Include say commands directly
                 cmd = self._say_command_to_command(stmt)
-                lines.append(cmd)
+                loop_body_lines.append(cmd)
             elif isinstance(stmt, RawBlock):
-                # Include raw blocks directly
-                lines.append(stmt.content)
+                loop_body_lines.append(stmt.content)
             elif isinstance(stmt, IfStatement):
-                # Recursively handle nested if statements
                 cmd = self._if_statement_to_command(stmt)
-                lines.append(cmd)
+                loop_body_lines.append(cmd)
             elif isinstance(stmt, WhileLoop):
-                # Handle nested while loops
                 cmd = self._while_loop_to_command(stmt)
-                lines.append(cmd)
+                loop_body_lines.append(cmd)
             elif isinstance(stmt, FunctionCall):
-                # Handle function calls
                 cmd = self._function_call_to_command(stmt)
-                lines.append(cmd)
+                loop_body_lines.append(cmd)
+        
+        # Add the recursive call at the end to continue the loop
+        if self._is_scoreboard_condition(while_loop.condition):
+            loop_body_lines.append(f"execute if score {condition} run function {self.current_namespace}:{loop_function_name}")
+        else:
+            loop_body_lines.append(f"execute if {condition} run function {self.current_namespace}:{loop_function_name}")
+        
+        # Store the loop function as its own file
+        self._store_generated_function(loop_function_name, loop_body_lines)
         
         return "\n".join(lines)
     
+    def _is_scoreboard_condition(self, expression: Any) -> bool:
+        """Check if an expression is a scoreboard comparison."""
+        if isinstance(expression, BinaryExpression):
+            # Check if it's comparing a scoreboard value
+            if isinstance(expression.left, VariableSubstitution) or isinstance(expression.right, VariableSubstitution):
+                return True
+        return False
+    
+    def _generate_if_function_name(self) -> str:
+        """Generate a unique name for an if function."""
+        if not hasattr(self, 'if_counter'):
+            self.if_counter = 0
+        self.if_counter += 1
+        return f"if_{self.if_counter}"
+    
+    def _generate_else_function_name(self) -> str:
+        """Generate a unique name for an else function."""
+        if not hasattr(self, 'else_counter'):
+            self.else_counter = 0
+        self.else_counter += 1
+        return f"else_{self.else_counter}"
+    
+    def _generate_while_function_name(self) -> str:
+        """Generate a unique name for a while function."""
+        if not hasattr(self, 'while_counter'):
+            self.while_counter = 0
+        self.while_counter += 1
+        return f"while_{self.while_counter}"
+    
+    def _store_generated_function(self, name: str, lines: List[str]):
+        """Store a generated function as a separate file under the same namespace."""
+        if self.dir_map:
+            functions_dir = self.output_dir / "data" / self.current_namespace / self.dir_map.function
+        else:
+            functions_dir = self.output_dir / "data" / self.current_namespace / "functions"
+        functions_dir.mkdir(parents=True, exist_ok=True)
+        func_file = functions_dir / f"{name}.mcfunction"
+        with open(func_file, 'w') as f:
+            f.write("\n".join(lines) + "\n")
+    
     def _function_call_to_command(self, func_call: FunctionCall) -> str:
         """Convert function call to execute command."""
         if func_call.scope:
@@ -446,25 +547,188 @@ class MDLCompiler:
     def _expression_to_value(self, expression: Any) -> str:
         """Convert expression to a value string."""
         if isinstance(expression, LiteralExpression):
+            # Format numbers as integers if possible
+            if isinstance(expression.value, (int, float)):
+                try:
+                    v = float(expression.value)
+                    if v.is_integer():
+                        return str(int(v))
+                    return str(v)
+                except Exception:
+                    return str(expression.value)
             return str(expression.value)
         elif isinstance(expression, VariableSubstitution):
             objective = self.variables.get(expression.name, expression.name)
             scope = expression.scope.strip("<>")
             return f"score {scope} {objective}"
         elif isinstance(expression, BinaryExpression):
-            left = self._expression_to_value(expression.left)
-            right = self._expression_to_value(expression.right)
-            return f"{left} {expression.operator} {right}"
+            # For complex expressions, we need to use temporary variables
+            temp_var = self._generate_temp_variable_name()
+            self._compile_expression_to_temp(expression, temp_var)
+            return f"score @s {temp_var}"
         elif isinstance(expression, ParenthesizedExpression):
-            return f"({self._expression_to_value(expression.expression)})"
+            return self._expression_to_value(expression.expression)
         else:
             return str(expression)
     
     def _expression_to_condition(self, expression: Any) -> str:
-        """Convert expression to a condition string."""
+        """Legacy: Convert expression to a naive condition string (internal use)."""
         if isinstance(expression, BinaryExpression):
             left = self._expression_to_value(expression.left)
             right = self._expression_to_value(expression.right)
             return f"{left} {expression.operator} {right}"
         else:
             return self._expression_to_value(expression)
+
+    def _build_condition(self, expression: Any) -> (str, bool):
+        """Build a valid Minecraft execute condition.
+        Returns (condition_string, invert_then) where invert_then True means the THEN branch should use 'unless'.
+        """
+        # Default: generic expression string, no inversion
+        invert_then = False
+        
+        if isinstance(expression, BinaryExpression):
+            left = expression.left
+            right = expression.right
+            op = expression.operator
+            # Variable vs literal
+            if isinstance(left, VariableSubstitution) and isinstance(right, LiteralExpression) and isinstance(right.value, (int, float)):
+                objective = self.variables.get(left.name, left.name)
+                scope = left.scope.strip("<>")
+                # Normalize number
+                try:
+                    v = float(right.value)
+                except Exception:
+                    v = None
+                if v is not None:
+                    n = int(v) if float(v).is_integer() else v
+                    if op == TokenType.GREATER:
+                        rng = f"{int(n)+1}.." if isinstance(n, int) else f"{v+1}.."
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.GREATER_EQUAL:
+                        rng = f"{int(n)}.."
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.LESS:
+                        rng = f"..{int(n)-1}"
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.LESS_EQUAL:
+                        rng = f"..{int(n)}"
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.EQUAL:
+                        rng = f"{int(n)}"
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.NOT_EQUAL:
+                        rng = f"{int(n)}"
+                        return (f"score {scope} {objective} matches {rng}", True)
+            # Variable vs variable
+            if isinstance(left, VariableSubstitution) and isinstance(right, VariableSubstitution):
+                lobj = self.variables.get(left.name, left.name)
+                lscope = left.scope.strip("<>")
+                robj = self.variables.get(right.name, right.name)
+                rscope = right.scope.strip("<>")
+                if op in (TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL, TokenType.EQUAL):
+                    comp_map = {
+                        TokenType.GREATER: ">",
+                        TokenType.GREATER_EQUAL: ">=",
+                        TokenType.LESS: "<",
+                        TokenType.LESS_EQUAL: "<=",
+                        TokenType.EQUAL: "="
+                    }
+                    comp = comp_map[op]
+                    return (f"score {lscope} {lobj} {comp} {rscope} {robj}", False)
+                if op == TokenType.NOT_EQUAL:
+                    # Use equals with inversion
+                    return (f"score {lscope} {lobj} = {rscope} {robj}", True)
+        
+        # Fallback: treat as generic condition string
+        return (self._expression_to_condition(expression), False)
+    
+    def _compile_expression_to_temp(self, expression: BinaryExpression, temp_var: str):
+        """Compile a complex expression to a temporary variable using valid Minecraft commands."""
+        left_temp = None
+        right_temp = None
+        
+        if isinstance(expression.left, BinaryExpression):
+            # Left side is complex - compile it first
+            left_temp = self._generate_temp_variable_name()
+            self._compile_expression_to_temp(expression.left, left_temp)
+            left_value = f"score @s {left_temp}"
+        else:
+            left_value = self._expression_to_value(expression.left)
+        
+        if isinstance(expression.right, BinaryExpression):
+            # Right side is complex - compile it first
+            right_temp = self._generate_temp_variable_name()
+            self._compile_expression_to_temp(expression.right, right_temp)
+            right_value = f"score @s {right_temp}"
+        else:
+            right_value = self._expression_to_value(expression.right)
+        
+        # Generate the operation command
+        if expression.operator == "PLUS":
+            if isinstance(expression.left, BinaryExpression):
+                self._store_temp_command(f"scoreboard players operation @s {temp_var} = @s {left_temp}")
+            else:
+                self._store_temp_command(f"scoreboard players set @s {temp_var} {left_value}")
+            
+            if isinstance(expression.right, BinaryExpression):
+                self._store_temp_command(f"scoreboard players add @s {temp_var} {right_value}")
+            else:
+                self._store_temp_command(f"scoreboard players add @s {temp_var} {right_value}")
+                
+        elif expression.operator == "MINUS":
+            if isinstance(expression.left, BinaryExpression):
+                self._store_temp_command(f"scoreboard players operation @s {temp_var} = @s {left_temp}")
+            else:
+                self._store_temp_command(f"scoreboard players set @s {temp_var} {left_value}")
+            
+            if isinstance(expression.right, BinaryExpression):
+                self._store_temp_command(f"scoreboard players remove @s {temp_var} {right_value}")
+            else:
+                self._store_temp_command(f"scoreboard players remove @s {temp_var} {right_value}")
+                
+        elif expression.operator == "MULTIPLY":
+            if isinstance(expression.left, BinaryExpression):
+                self._store_temp_command(f"scoreboard players operation @s {temp_var} = @s {left_temp}")
+            else:
+                self._store_temp_command(f"scoreboard players set @s {temp_var} {left_value}")
+            
+            if isinstance(expression.right, BinaryExpression):
+                self._store_temp_command(f"scoreboard players operation @s {temp_var} *= @s {right_temp}")
+            else:
+                # For literal values, we need to use a different approach
+                if isinstance(expression.right, LiteralExpression):
+                    self._store_temp_command(f"scoreboard players multiply @s {temp_var} {expression.right.value}")
+                else:
+                    self._store_temp_command(f"scoreboard players operation @s {temp_var} *= {right_value}")
+                
+        elif expression.operator == "DIVIDE":
+            if isinstance(expression.left, BinaryExpression):
+                self._store_temp_command(f"scoreboard players operation @s {temp_var} = @s {left_temp}")
+            else:
+                self._store_temp_command(f"scoreboard players set @s {temp_var} {left_value}")
+            
+            if isinstance(expression.right, BinaryExpression):
+                self._store_temp_command(f"scoreboard players operation @s {temp_var} /= @s {right_temp}")
+            else:
+                # For literal values, we need to use a different approach
+                if isinstance(expression.right, LiteralExpression):
+                    self._store_temp_command(f"scoreboard players divide @s {temp_var} {expression.right.value}")
+                else:
+                    self._store_temp_command(f"scoreboard players operation @s {temp_var} /= {right_value}")
+        else:
+            # For other operators, just set the value
+            self._store_temp_command(f"scoreboard players set @s {temp_var} 0")
+    
+    def _store_temp_command(self, command: str):
+        """Store a temporary command for later execution."""
+        if not hasattr(self, 'temp_commands'):
+            self.temp_commands = []
+        self.temp_commands.append(command)
+    
+    def _generate_temp_variable_name(self) -> str:
+        """Generate a unique temporary variable name."""
+        if not hasattr(self, 'temp_counter'):
+            self.temp_counter = 0
+        self.temp_counter += 1
+        return f"temp_{self.temp_counter}"

{minecraft_datapack_language-15.4.31.dist-info → minecraft_datapack_language-15.4.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.31
+Version: 15.4.33
 Summary: Compile MDL language with explicit scoping 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
@@ -28,7 +28,6 @@ A **modern, scope-aware language** that lets you write Minecraft datapacks with
 🔧 **[VS Code Extension](https://marketplace.visualstudio.com/items?itemName=mdl.minecraft-datapack-language)** - Syntax highlighting, IntelliSense, and snippets
 
 ![CI](https://github.com/aaron777collins/MinecraftDatapackLanguage/workflows/CI/badge.svg)
-![Test Examples](https://github.com/aaron777collins/MinecraftDatapackLanguage/workflows/Test%20Examples/badge.svg)
 ![Documentation](https://github.com/aaron777collins/MinecraftDatapackLanguage/workflows/Build%20and%20Deploy%20Documentation/badge.svg)
 ![PyPI](https://img.shields.io/pypi/v/minecraft-datapack-language?style=flat-square)
 ![Release](https://github.com/aaron777collins/MinecraftDatapackLanguage/workflows/Release/badge.svg)

{minecraft_datapack_language-15.4.31.dist-info → minecraft_datapack_language-15.4.33.dist-info}/RECORD

@@ -1,17 +1,17 @@
 minecraft_datapack_language/__init__.py,sha256=YoTmZWZVH6POAVYMvOTEBKdC-cxQsWi2VomSWZDgYFw,1158
-minecraft_datapack_language/_version.py,sha256=ybDeUo_pBGup1BE9UTgdEc140_gEuC_6hkQJEnPjtlE,708
+minecraft_datapack_language/_version.py,sha256=oHNM_9N4Gw1WIjw70v38mQJDgIkD6Qbx1TSXwhIvfNI,708
 minecraft_datapack_language/ast_nodes.py,sha256=nbWrRz137MGMRpmnq8QkXNzrtlaCgyPEknytbkrS_M8,3899
-minecraft_datapack_language/cli.py,sha256=dy1KBDULHpaHYYzNfL42EuhOAB5_GTfSVt7_bMImSno,9000
+minecraft_datapack_language/cli.py,sha256=-TMAL1HCCtwf0aG46x88MVBsYUswPRCVhy854li7X9c,9780
 minecraft_datapack_language/dir_map.py,sha256=HmxFkuvWGkzHF8o_GFb4BpuMCRc6QMw8UbmcAI8JVdY,1788
-minecraft_datapack_language/mdl_compiler.py,sha256=GQv2CD29aj8vxhqRczTn_2JjNn6hiHQ4XoU2qh-s1n4,20429
+minecraft_datapack_language/mdl_compiler.py,sha256=nS_D2f_G8lcDxUOiADNJWTJQwTnXoQ-W4amyhw6xJoY,34673
 minecraft_datapack_language/mdl_errors.py,sha256=r0Gu3KhoX1YLPAVW_iO7Q_fPgaf_Dv9tOGSOdKNSzmw,16114
 minecraft_datapack_language/mdl_lexer.py,sha256=CjbEUpuuF4eU_ucA_WIhw6wSMcHGk2BchtQ0bLAGvwg,22033
 minecraft_datapack_language/mdl_linter.py,sha256=z85xoAglENurCh30bR7kEHZ_JeMxcYaLDcGNRAl-RAI,17253
 minecraft_datapack_language/mdl_parser.py,sha256=aQPKcmATM9BOMzO7vCXmMdxU1qjOJNLCSAKJopu5h3g,23429
 minecraft_datapack_language/utils.py,sha256=Aq0HAGlXqj9BUTEjaEilpvzEW0EtZYYMMwOqG9db6dE,684
-minecraft_datapack_language-15.4.31.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-minecraft_datapack_language-15.4.31.dist-info/METADATA,sha256=MhDDSgOGSon07gtuGAXAgtGrQrLdMtpZ8A55adIrQFU,8475
-minecraft_datapack_language-15.4.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-minecraft_datapack_language-15.4.31.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
-minecraft_datapack_language-15.4.31.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
-minecraft_datapack_language-15.4.31.dist-info/RECORD,,
+minecraft_datapack_language-15.4.33.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+minecraft_datapack_language-15.4.33.dist-info/METADATA,sha256=-vx5gJu0ZmkHmVVnlBIaa4rtBEhhfoi32BgXl1NnAqg,8360
+minecraft_datapack_language-15.4.33.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minecraft_datapack_language-15.4.33.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
+minecraft_datapack_language-15.4.33.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
+minecraft_datapack_language-15.4.33.dist-info/RECORD,,