minecraft-datapack-language 15.4.34__py3-none-any.whl → 15.4.36__py3-none-any.whl

minecraft_datapack_language/__init__.py

@@ -3,6 +3,7 @@ from .mdl_lexer import MDLLexer, Token, TokenType
 from .mdl_parser import MDLParser
 from .ast_nodes import *
 from .dir_map import DirMap
+from .python_api import Pack
 
 __all__ = [
     "MDLLexer", "Token", "TokenType",
@@ -13,7 +14,8 @@ __all__ = [
     "SayCommand", "TellrawCommand", "ExecuteCommand", "ScoreboardCommand",
     "BinaryExpression", "UnaryExpression", "ParenthesizedExpression", "LiteralExpression",
     "ScopeSelector",
-    "DirMap"
+    "DirMap",
+    "Pack"
 ]
 
 # CLI entry point

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.34'
-__version_tuple__ = version_tuple = (15, 4, 34)
+__version__ = version = '15.4.36'
+__version_tuple__ = version_tuple = (15, 4, 36)
 
 __commit_id__ = commit_id = None

minecraft_datapack_language/mdl_compiler.py

@@ -148,22 +148,25 @@ class MDLCompiler:
             lines.append(f"# Scope: {func.scope}")
         lines.append("")
         
-        # Reset temporary commands for this function
-        if hasattr(self, 'temp_commands'):
-            self.temp_commands = []
-        
+        # Ensure a temp-command sink stack exists
+        if not hasattr(self, '_temp_sink_stack'):
+            self._temp_sink_stack = []
+        
+        # Set current function context and reset per-function counters
+        self._current_function_name = func.name
+        self.if_counter = 0
+        self.else_counter = 0
+        self.while_counter = 0
+        
+        # Route temp commands into this function's body by default
+        self._temp_sink_stack.append(lines)
         # 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)
+        # Done routing temp commands for this function body
+        self._temp_sink_stack.pop()
         
         return "\n".join(lines)
     
@@ -395,6 +398,10 @@ class MDLCompiler:
         
         # Generate the if body function content
         if_body_lines = [f"# Function: {self.current_namespace}:{if_function_name}"]
+        # Route temp commands to the if-body function content
+        if not hasattr(self, '_temp_sink_stack'):
+            self._temp_sink_stack = []
+        self._temp_sink_stack.append(if_body_lines)
         for stmt in if_stmt.then_body:
             if isinstance(stmt, VariableAssignment):
                 cmd = self._variable_assignment_to_command(stmt)
@@ -413,6 +420,8 @@ class MDLCompiler:
             elif isinstance(stmt, FunctionCall):
                 cmd = self._function_call_to_command(stmt)
                 if_body_lines.append(cmd)
+        # Stop routing temp commands for if-body
+        self._temp_sink_stack.pop()
         
         # Handle else body if it exists
         if if_stmt.else_body:
@@ -437,6 +446,10 @@ class MDLCompiler:
                 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}"]
+                # Route temp commands into the else-body
+                if not hasattr(self, '_temp_sink_stack'):
+                    self._temp_sink_stack = []
+                self._temp_sink_stack.append(else_body_lines)
                 for stmt in if_stmt.else_body:
                     if isinstance(stmt, VariableAssignment):
                         cmd = self._variable_assignment_to_command(stmt)
@@ -455,6 +468,8 @@ class MDLCompiler:
                     elif isinstance(stmt, FunctionCall):
                         cmd = self._function_call_to_command(stmt)
                         else_body_lines.append(cmd)
+                # Stop routing temp commands for else-body
+                self._temp_sink_stack.pop()
                 self._store_generated_function(else_function_name, else_body_lines)
         
         # Store the if function as its own file
@@ -477,6 +492,9 @@ class MDLCompiler:
         loop_body_lines = [f"# Function: {self.current_namespace}:{loop_function_name}"]
         
         # Add the loop body statements
+        if not hasattr(self, '_temp_sink_stack'):
+            self._temp_sink_stack = []
+        self._temp_sink_stack.append(loop_body_lines)
         for stmt in while_loop.body:
             if isinstance(stmt, VariableAssignment):
                 cmd = self._variable_assignment_to_command(stmt)
@@ -497,10 +515,10 @@ class MDLCompiler:
                 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}")
+        cond_str, _inv = self._build_condition(while_loop.condition)
+        loop_body_lines.append(f"execute if {cond_str} run function {self.current_namespace}:{loop_function_name}")
+        # Stop routing temp commands for while-body
+        self._temp_sink_stack.pop()
         
         # Store the loop function as its own file
         self._store_generated_function(loop_function_name, loop_body_lines)
@@ -517,24 +535,21 @@ class MDLCompiler:
     
     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}"
+        prefix = getattr(self, '_current_function_name', 'fn')
+        return f"{prefix}__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}"
+        prefix = getattr(self, '_current_function_name', 'fn')
+        return f"{prefix}__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}"
+        prefix = getattr(self, '_current_function_name', 'fn')
+        return f"{prefix}__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."""
@@ -679,10 +694,20 @@ class MDLCompiler:
             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}")
+                # Assign from left value (score or literal)
+                if isinstance(expression.left, VariableSubstitution) or (isinstance(expression.left, str) and str(left_value).startswith("score ")):
+                    parts = str(left_value).split()
+                    scope = parts[1]
+                    obj = parts[2]
+                    self._store_temp_command(f"scoreboard players operation @s {temp_var} = {scope} {obj}")
+                else:
+                    self._store_temp_command(f"scoreboard players set @s {temp_var} {left_value}")
+            # Add right value
+            if isinstance(expression.right, VariableSubstitution) or (isinstance(expression.right, str) and str(right_value).startswith("score ")):
+                parts = str(right_value).split()
+                scope = parts[1]
+                obj = parts[2]
+                self._store_temp_command(f"scoreboard players operation @s {temp_var} += {scope} {obj}")
             else:
                 self._store_temp_command(f"scoreboard players add @s {temp_var} {right_value}")
                 
@@ -690,10 +715,19 @@ class MDLCompiler:
             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}")
+                if isinstance(expression.left, VariableSubstitution) or (isinstance(expression.left, str) and str(left_value).startswith("score ")):
+                    parts = str(left_value).split()
+                    scope = parts[1]
+                    obj = parts[2]
+                    self._store_temp_command(f"scoreboard players operation @s {temp_var} = {scope} {obj}")
+                else:
+                    self._store_temp_command(f"scoreboard players set @s {temp_var} {left_value}")
+            # Subtract right value
+            if isinstance(expression.right, VariableSubstitution) or (isinstance(expression.right, str) and str(right_value).startswith("score ")):
+                parts = str(right_value).split()
+                scope = parts[1]
+                obj = parts[2]
+                self._store_temp_command(f"scoreboard players operation @s {temp_var} -= {scope} {obj}")
             else:
                 self._store_temp_command(f"scoreboard players remove @s {temp_var} {right_value}")
                 
@@ -701,12 +735,18 @@ class MDLCompiler:
             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.left, VariableSubstitution) or (isinstance(expression.left, str) and str(left_value).startswith("score ")):
+                    parts = str(left_value).split()
+                    scope = parts[1]
+                    obj = parts[2]
+                    self._store_temp_command(f"scoreboard players operation @s {temp_var} = {scope} {obj}")
+                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
+                # For literal values, keep explicit multiply command for compatibility
                 if isinstance(expression.right, LiteralExpression):
                     self._store_temp_command(f"scoreboard players multiply @s {temp_var} {expression.right.value}")
                 else:
@@ -716,12 +756,18 @@ class MDLCompiler:
             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.left, VariableSubstitution) or (isinstance(expression.left, str) and str(left_value).startswith("score ")):
+                    parts = str(left_value).split()
+                    scope = parts[1]
+                    obj = parts[2]
+                    self._store_temp_command(f"scoreboard players operation @s {temp_var} = {scope} {obj}")
+                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
+                # For literal values, keep explicit divide command for compatibility
                 if isinstance(expression.right, LiteralExpression):
                     self._store_temp_command(f"scoreboard players divide @s {temp_var} {expression.right.value}")
                 else:
@@ -731,10 +777,12 @@ class MDLCompiler:
             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)
+        """Append a temporary command into the current output sink (function/if/while body)."""
+        if hasattr(self, '_temp_sink_stack') and self._temp_sink_stack:
+            self._temp_sink_stack[-1].append(command)
+        else:
+            # Fallback: do nothing, but keep behavior predictable
+            pass
     
     def _generate_temp_variable_name(self) -> str:
         """Generate a unique temporary variable name."""

minecraft_datapack_language/python_api.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, List, Optional, Union
+
+from .ast_nodes import (
+    Program,
+    PackDeclaration,
+    NamespaceDeclaration,
+    TagDeclaration,
+    VariableDeclaration,
+    VariableAssignment,
+    VariableSubstitution,
+    FunctionDeclaration,
+    FunctionCall,
+    IfStatement,
+    WhileLoop,
+    RawBlock,
+    SayCommand,
+    BinaryExpression,
+    LiteralExpression,
+)
+from .mdl_compiler import MDLCompiler
+
+
+# ---------- Expression helpers ----------
+
+def num(value: Union[int, float]) -> LiteralExpression:
+    return LiteralExpression(value=value, type="number")
+
+
+def var_read(name: str, scope: str) -> VariableSubstitution:
+    # scope must look like <@s>, <@a>, <@e[...]>, or <global>
+    return VariableSubstitution(name=name, scope=scope)
+
+
+def binop(left, operator: str, right) -> BinaryExpression:
+    # operator one of: PLUS, MINUS, MULTIPLY, DIVIDE, GREATER, LESS, GREATER_EQUAL, LESS_EQUAL, EQUAL, NOT_EQUAL
+    return BinaryExpression(left=left, operator=operator, right=right)
+
+
+# ---------- Python Bindings ----------
+
+
+class Pack:
+    def __init__(self, name: str, description: str = "", pack_format: int = 82):
+        self._pack = PackDeclaration(name=name, description=description, pack_format=pack_format)
+        self._namespaces: List[Namespace] = []
+        self._variables: List[VariableDeclaration] = []
+        self._tags: List[TagDeclaration] = []
+        self._hooks: List = []  # HookDeclaration built by Namespace
+
+    def namespace(self, name: str) -> "Namespace":
+        ns = Namespace(self, name)
+        self._namespaces.append(ns)
+        return ns
+
+    # Lifecycle hooks reference functions by id "ns:name"
+    def on_load(self, function_id: str, scope: Optional[str] = None):
+        # defer to Namespace to create HookDeclaration during build
+        self._hooks.append(("on_load", function_id, scope))
+
+    def on_tick(self, function_id: str, scope: Optional[str] = None):
+        self._hooks.append(("on_tick", function_id, scope))
+
+    def tag(self, registry: str, name: str, values: Optional[List[str]] = None, replace: bool = False):
+        values = values or []
+        # We store TagDeclaration; the compiler writes tag files based on tag_type/name/file_path
+        # Here, we map registry + name to a tag reference name; file_path left as name for placeholder.
+        self._tags.append(TagDeclaration(tag_type=registry, name=name, file_path=name))
+
+    def declare_var(self, name: str, scope: str, initial_value: Union[int, float]) -> None:
+        self._variables.append(
+            VariableDeclaration(var_type="num", name=name, scope=scope, initial_value=num(initial_value))
+        )
+
+    def build(self, output_dir: str):
+        # Build Program AST
+        namespace_nodes: List[NamespaceDeclaration] = []
+        function_nodes: List[FunctionDeclaration] = []
+        hook_nodes: List = []
+
+        # Namespaces and functions
+        for ns in self._namespaces:
+            namespace_nodes.append(NamespaceDeclaration(name=ns.name))
+            function_nodes.extend(ns._functions)
+            hook_nodes.extend(ns._hooks)
+
+        # Hooks added via Pack-level convenience
+        for hook_type, function_id, scope in self._hooks:
+            ns_name, fn_name = function_id.split(":", 1)
+            from .ast_nodes import HookDeclaration
+
+            hook_nodes.append(
+                HookDeclaration(hook_type=hook_type, namespace=ns_name, name=fn_name, scope=scope)
+            )
+
+        program = Program(
+            pack=self._pack,
+            namespace=namespace_nodes[0] if namespace_nodes else None,
+            tags=self._tags,
+            variables=self._variables,
+            functions=function_nodes,
+            hooks=hook_nodes,
+            statements=[],
+        )
+
+        MDLCompiler(output_dir).compile(program, output_dir)
+
+
+class Namespace:
+    def __init__(self, pack: Pack, name: str):
+        self._pack = pack
+        self.name = name
+        self._functions: List[FunctionDeclaration] = []
+        self._hooks: List = []
+
+    def function(self, name: str, *commands_or_builder: Union[str, Callable[["FunctionBuilder"], None]]):
+        builder = FunctionBuilder(self._pack, self, name)
+
+        # If a single callable is given, treat it as a builder lambda
+        if len(commands_or_builder) == 1 and callable(commands_or_builder[0]):
+            commands_or_builder[0](builder)
+        else:
+            # Interpret simple strings: say "..."; exec ns:name; raw lines fall back to RawBlock
+            for cmd in commands_or_builder:
+                if not isinstance(cmd, str):
+                    continue
+                stripped = cmd.strip().rstrip(";")
+                if stripped.startswith("say "):
+                    msg = stripped[len("say ") :].strip()
+                    if msg.startswith("\"") and msg.endswith("\""):
+                        msg = msg[1:-1]
+                    builder.say(msg)
+                elif stripped.startswith("exec "):
+                    target = stripped[len("exec ") :].strip()
+                    # Optional scope in angle brackets e.g., util:helper<@s>
+                    scope = None
+                    if "<" in target and target.endswith(">"):
+                        scope = target[target.index("<") :]
+                        target = target[: target.index("<")]
+                    builder.exec(target, scope)
+                else:
+                    builder.raw(cmd)
+
+        func_node = FunctionDeclaration(namespace=self.name, name=name, scope=None, body=builder._body)
+        self._functions.append(func_node)
+        return func_node
+
+    # Convenience forwarding
+    def on_load(self, function_id: str, scope: Optional[str] = None):
+        from .ast_nodes import HookDeclaration
+
+        ns_name, fn_name = function_id.split(":", 1)
+        self._hooks.append(HookDeclaration(hook_type="on_load", namespace=ns_name, name=fn_name, scope=scope))
+
+    def on_tick(self, function_id: str, scope: Optional[str] = None):
+        from .ast_nodes import HookDeclaration
+
+        ns_name, fn_name = function_id.split(":", 1)
+        self._hooks.append(HookDeclaration(hook_type="on_tick", namespace=ns_name, name=fn_name, scope=scope))
+
+
+class FunctionBuilder:
+    def __init__(self, pack: Pack, namespace: Namespace, function_name: str):
+        self._pack = pack
+        self._namespace = namespace
+        self._name = function_name
+        self._body: List = []
+
+    # Basics
+    def say(self, message: str):
+        self._body.append(SayCommand(message=message, variables=[]))
+
+    def raw(self, content: str):
+        self._body.append(RawBlock(content=content.rstrip(";")))
+
+    def exec(self, function_id: str, scope: Optional[str] = None):
+        ns, fn = function_id.split(":", 1)
+        self._body.append(FunctionCall(namespace=ns, name=fn, scope=scope))
+
+    # Variables
+    def declare_var(self, name: str, scope: str, initial_value: Union[int, float]):
+        self._pack.declare_var(name, scope, initial_value)
+        # Also set to initial value in this function
+        self.set(name, scope, num(initial_value))
+
+    def set(self, name: str, scope: str, value_expr) -> None:
+        self._body.append(VariableAssignment(name=name, scope=scope, value=value_expr))
+
+    # Control flow
+    def if_(self, condition_expr, then_builder: Callable[["FunctionBuilder"], None], else_builder: Optional[Callable[["FunctionBuilder"], None]] = None):
+        then_fb = FunctionBuilder(self._pack, self._namespace, self._name)
+        then_builder(then_fb)
+        else_body = None
+        if else_builder:
+            else_fb = FunctionBuilder(self._pack, self._namespace, self._name)
+            else_builder(else_fb)
+            else_body = else_fb._body
+        self._body.append(IfStatement(condition=condition_expr, then_body=then_fb._body, else_body=else_body))
+
+    def while_(self, condition_expr, body_builder: Callable[["FunctionBuilder"], None]):
+        body_fb = FunctionBuilder(self._pack, self._namespace, self._name)
+        body_builder(body_fb)
+        self._body.append(WhileLoop(condition=condition_expr, body=body_fb._body))
+
+

{minecraft_datapack_language-15.4.34.dist-info → minecraft_datapack_language-15.4.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.34
+Version: 15.4.36
 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

{minecraft_datapack_language-15.4.34.dist-info → minecraft_datapack_language-15.4.36.dist-info}/RECORD

@@ -1,17 +1,18 @@
-minecraft_datapack_language/__init__.py,sha256=YoTmZWZVH6POAVYMvOTEBKdC-cxQsWi2VomSWZDgYFw,1158
-minecraft_datapack_language/_version.py,sha256=AX5FvjEPvDBWIH6kE1FoeWiGRzaIAu7H64ji0BuRH1s,708
+minecraft_datapack_language/__init__.py,sha256=0KVXBE4ScRaRUrf83aA2tVB-y8A_jplyaxVvtHH6Uw0,1199
+minecraft_datapack_language/_version.py,sha256=-lqyDIq8xZADk9VgmkKo5oD27xSGH-vH7aUZSbeWTUQ,708
 minecraft_datapack_language/ast_nodes.py,sha256=nbWrRz137MGMRpmnq8QkXNzrtlaCgyPEknytbkrS_M8,3899
 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=9wNQRZizlXqdIJcG5TQPtmAULz77hwCaPoXN9bvUo9o,35310
+minecraft_datapack_language/mdl_compiler.py,sha256=WNh1MFWyNHV0s3binx-afD_GAVGdRmG0P5id--btZxs,38393
 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/python_api.py,sha256=yU8SIhxRfCWsDW3qBheMQD2Ii0Y6-Tk9VMvVncEPlv4,8183
 minecraft_datapack_language/utils.py,sha256=Aq0HAGlXqj9BUTEjaEilpvzEW0EtZYYMMwOqG9db6dE,684
-minecraft_datapack_language-15.4.34.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-minecraft_datapack_language-15.4.34.dist-info/METADATA,sha256=A8QcpemF22cVUa-5UYxStXPZiN62FDyXEOSdGET0ffU,8360
-minecraft_datapack_language-15.4.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-minecraft_datapack_language-15.4.34.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
-minecraft_datapack_language-15.4.34.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
-minecraft_datapack_language-15.4.34.dist-info/RECORD,,
+minecraft_datapack_language-15.4.36.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+minecraft_datapack_language-15.4.36.dist-info/METADATA,sha256=7ZLAsFhF4cRd5kIMYe0MTK24UyL5dWzwK87_EJtulNU,8360
+minecraft_datapack_language-15.4.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minecraft_datapack_language-15.4.36.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
+minecraft_datapack_language-15.4.36.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
+minecraft_datapack_language-15.4.36.dist-info/RECORD,,