sandstone 1.0.0-beta.4 → 1.0.0

package/dist/_internal/index.js

@@ -40,6 +40,11 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // Hoisted class definitions
 
+class ComponentClass {
+  _toChatComponent() {
+    throw new Error("Not implemented");
+  }
+}
 ConditionTextComponentClass = class ConditionTextComponentClass extends ComponentClass {
     _toChatComponent() {
       throw new Error("Not implemented");
@@ -69,6 +74,32 @@ VectorClass = class VectorClass {
       return this.values[Symbol.iterator]();
     }
   };
+class MacroArgument {
+  sandstoneCore;
+  local;
+  toMacro;
+  constructor(sandstoneCore) {
+    this.sandstoneCore = sandstoneCore;
+    this.local = new Map;
+    this.toMacro = () => {
+      let currentMCFunctionName = "";
+      try {
+        currentMCFunctionName = sandstoneCore.getCurrentMCFunctionOrThrow().resource.name;
+      } catch {}
+      let result = this.local.get(this.sandstoneCore.currentNode) || this.local.get(currentMCFunctionName);
+      if (!result) {
+        let path = this.sandstoneCore.currentNode;
+        while (path.includes("/")) {
+          path = path.substring(0, path.lastIndexOf("/"));
+          result = this.local.get(path);
+          if (result)
+            break;
+        }
+      }
+      return `$(${result})`;
+    };
+  }
+}
 MacroLiteral = class MacroLiteral extends MacroArgument {
     sandstoneCore;
     strings;
@@ -117,6 +148,8 @@ Set2 = class Set2 extends global.Set {
       return super.has(value);
     }
   };
+class NBTClass {
+}
 NBTPrimitive = class NBTPrimitive extends NBTClass {
     value;
     unit;
@@ -194,7 +227,7 @@ NotNBT = class NotNBT extends NBTClass {
       super();
       this.nbt = nbt;
     }
-    [util2.inspect.custom] = () => `!${nbtStringifier(this.nbt)}`;
+    [util2.inspect.custom] = () => `!${nbtResolver(this.nbt)}`;
   };
 NBTString = class NBTString extends NBTPrimitive {
   };
@@ -225,7 +258,7 @@ Score = class Score extends MacroArgument {
       return `${this.target} ${this.objective}`;
     }
     toNBT() {
-      return nbtStringifier(this._toChatComponent());
+      return nbtResolver(this._toChatComponent()).toString();
     }
     toJSON() {
       return this._toChatComponent();
@@ -326,6 +359,7 @@ Score = class Score extends MacroArgument {
     modulo(...args) {
       return this.binaryOperation("%=", ...args);
     }
+    mod = this.modulo;
     "%=" = this.modulo;
     swap(...args) {
       this.binaryOperation("><", ...args);
@@ -342,6 +376,7 @@ Score = class Score extends MacroArgument {
     multipliedBy(...args) {
       return createVariable(this.sandstonePack, this).binaryOperation("*=", ...args);
     }
+    times = this.multipliedBy;
     "*" = this.multipliedBy;
     dividedBy(...args) {
       return createVariable(this.sandstonePack, this).binaryOperation("/=", ...args);
@@ -350,6 +385,7 @@ Score = class Score extends MacroArgument {
     moduloBy(...args) {
       return createVariable(this.sandstonePack, this).binaryOperation("%=", ...args);
     }
+    modBy = this.moduloBy;
     "%" = this.moduloBy;
     comparison(operator, matchesRange, args) {
       const playerScore = this;
@@ -377,21 +413,22 @@ Score = class Score extends MacroArgument {
       return this.comparison(">", `${typeof args[0] === "number" ? args[0] + 1 : null}..`, args);
     }
     ">" = this.greaterThan;
-    greaterOrEqualThan(...args) {
+    greaterThanOrEqualTo(...args) {
       return this.comparison(">=", `${args[0]}..`, args);
     }
-    ">=" = this.greaterOrEqualThan;
+    ">=" = this.greaterThanOrEqualTo;
     lessThan(...args) {
       return this.comparison("<", `..${typeof args[0] === "number" ? args[0] - 1 : null}`, args);
     }
     "<" = this.lessThan;
-    lessOrEqualThan(...args) {
+    lessThanOrEqualTo(...args) {
       return this.comparison("<=", `..${args[0]}`, args);
     }
-    "<=" = this.lessOrEqualThan;
+    "<=" = this.lessThanOrEqualTo;
     equalTo(...args) {
       return this.comparison("=", args[0].toString(), args);
     }
+    equals = this.equalTo;
     "==" = this.equalTo;
     notEqualTo(...args) {
       return this.sandstonePack._.not(this.comparison("=", args[0].toString(), args));
@@ -588,7 +625,7 @@ DataPointClass = class DataPointClass extends MacroArgument {
       nbt: this.path,
       [this.type]: this.currentTarget
     });
-    toNBT = () => nbtStringifier(this._toChatComponent());
+    toNBT = () => nbtResolver(this._toChatComponent()).toString();
   };
 StringDataPointClass = class StringDataPointClass extends DataPointClass {
     sandstonePack;
@@ -603,6 +640,27 @@ StringDataPointClass = class StringDataPointClass extends DataPointClass {
         this.sliceBounds.push(end);
     }
   };
+class PackType {
+  type;
+  clientPath;
+  serverPath;
+  rootPath;
+  networkSides;
+  resourceSubFolder;
+  namespaced;
+  archiveOutput;
+  handleOutput;
+  constructor(type, clientPath, serverPath, rootPath, networkSides, archiveOutput = false, resourceSubFolder, namespaced = false) {
+    this.type = type;
+    this.clientPath = clientPath;
+    this.serverPath = serverPath;
+    this.rootPath = rootPath;
+    this.networkSides = networkSides;
+    this.archiveOutput = archiveOutput;
+    this.resourceSubFolder = resourceSubFolder;
+    this.namespaced = namespaced;
+  }
+}
 DataPackDependencies = class DataPackDependencies extends PackType {
     constructor() {
       super("datapack_dependencies", "saves/$worldName$/datapacks", "world/datapacks", "datapacks", "server", false, undefined, false);
@@ -674,9 +732,17 @@ CommandNode = class CommandNode extends Node {
       for (const arg of this.args) {
         if (arg !== undefined && arg !== null) {
           if (typeof arg === "object") {
-            if (isMacroArgument(this.sandstoneCore, arg)) {
+            if (arg instanceof ResolvedNBT) {
+              if (arg.containsMacro) {
+                this.isMacro = true;
+              }
+              filteredArgs.push(arg);
+            } else if (isMacroArgument(this.sandstoneCore, arg)) {
               this.isMacro = true;
               filteredArgs.push(arg.toMacro());
+            } else if (Object.hasOwn(arg, "_hasMacro") && arg._hasMacro) {
+              this.isMacro = true;
+              filteredArgs.push(arg);
             } else if (Object.hasOwn(arg, "toLoop")) {
               filteredArgs.push(arg.toLoop());
             } else {
@@ -735,50 +801,6 @@ ContainerCommandNode = class ContainerCommandNode extends CommandNode {
 AwaitNode = class AwaitNode extends ContainerCommandNode {
     mcfunction = undefined;
   };
-PlaceCommandNode = class PlaceCommandNode extends CommandNode {
-    command = "place";
-  };
-PlaceCommand = class PlaceCommand extends CommandArguments {
-    NodeType = PlaceCommandNode;
-    feature = (feature, pos = "~ ~ ~") => this.finalCommand(["feature", feature, coordinatesParser(pos)]);
-    jigsaw = (pool, target, maxDepth, pos = "~ ~ ~") => this.finalCommand([
-      "jigsaw",
-      pool,
-      target,
-      `${validateIntegerRange(maxDepth, "Jigsaw max depth", 0, 7)}`,
-      coordinatesParser(pos)
-    ]);
-    structure = (configuredStructure, pos = "~ ~ ~") => this.finalCommand(["structure", configuredStructure, coordinatesParser(pos)]);
-    template = (structure, pos = "~ ~ ~", rotation, mirror, integrity = 1, seed = 0, mode) => {
-      this.finalCommand([
-        "template",
-        `${structure}`,
-        coordinatesParser(pos),
-        structureRotationParser(rotation),
-        structureMirrorParser(mirror),
-        `${integrity}`,
-        `${seed}`,
-        ...mode === undefined ? [] : [mode]
-      ]);
-    };
-  };
-DamageCommandNode = class DamageCommandNode extends CommandNode {
-    command = "damage";
-  };
-DamageCauseCommand = class DamageCauseCommand extends CommandArguments {
-    from = (cause) => this.finalCommand(["from", targetParser(cause)]);
-  };
-DamageSourceCommand = class DamageSourceCommand extends CommandArguments {
-    by = (entity) => this.subCommand(["by", targetParser(entity)], DamageCauseCommand, true);
-    at = (position) => this.finalCommand(["at", coordinatesParser(position)]);
-  };
-DamageCommand = class DamageCommand extends CommandArguments {
-    NodeType = DamageCommandNode;
-    damage = (target, amount, damageType) => {
-      validateIntegerRange(amount, "amount", 0, 1e6);
-      return this.subCommand([targetParser(target), amount, damageType], DamageSourceCommand, true);
-    };
-  };
 CommentCommandNode = class CommentCommandNode extends CommandNode {
     command = "#";
     getValue() {
@@ -787,6 +809,50 @@ CommentCommandNode = class CommentCommandNode extends CommandNode {
 `);
     }
   };
+class CommandArguments {
+  sandstonePack;
+  previousNode;
+  autoCommit;
+  NodeType;
+  sandstoneCore;
+  sandstoneCommands;
+  constructor(sandstonePack, previousNode, autoCommit = true) {
+    this.sandstonePack = sandstonePack;
+    this.previousNode = previousNode;
+    this.autoCommit = autoCommit;
+    this.sandstoneCore = sandstonePack.core;
+    this.sandstoneCommands = sandstonePack.commands;
+  }
+  getNode = () => {
+    if (this.previousNode) {
+      return this.previousNode;
+    }
+    if (this.NodeType) {
+      return new this.NodeType(this.sandstonePack);
+    }
+    throw new Error("No node type specified & no previous node for a non-root-level command");
+  };
+  finalCommand = (args, currentNode) => {
+    const node = currentNode ?? this.getNode();
+    if (args) {
+      node.args.push(...args);
+    }
+    if (this.autoCommit) {
+      node.commit();
+    }
+    return new FinalCommandOutput(node);
+  };
+  subCommand = (args, NextArgumentType, executable = false, additionalNextArgs = [], currentNode) => {
+    const node = currentNode ?? this.getNode();
+    if (args) {
+      node.args.push(...args);
+    }
+    if (executable && this.autoCommit) {
+      node.commit();
+    }
+    return new NextArgumentType(this.sandstonePack, node, this.autoCommit, ...additionalNextArgs);
+  };
+}
 CommentCommand = class CommentCommand extends CommandArguments {
     NodeType = CommentCommandNode;
     comment = (...comments) => this.finalCommand([comments]);
@@ -847,7 +913,7 @@ SetBlockCommand = class SetBlockCommand extends CommandArguments {
         return this.finalCommand([coordinatesParser(pos), block, arg5]);
       }
       const state = typeof arg3 === "undefined" ? "" : blockStateStringifier(arg3);
-      const nbt = typeof arg4 === "string" || arg4 === undefined ? "" : nbtStringifier(arg4);
+      const nbt = typeof arg4 === "string" || arg4 === undefined ? "" : nbtResolver(arg4).toString();
       const setblockType = typeof arg4 === "string" ? arg4 : arg5;
       return this.finalCommand([coordinatesParser(pos), `${block}${state}${nbt}`, setblockType]);
     }
@@ -859,7 +925,7 @@ FillCommand = class FillCommand extends CommandArguments {
     NodeType = FillCommandNode;
     fill(from, to, block, state, nbt) {
       const stateStr = state && Object.keys(state).length > 0 ? blockStateStringifier(state) : "";
-      const nbtStr = nbt ? nbtStringifier(nbt) : "";
+      const nbtStr = nbt ? nbtResolver(nbt).toString() : "";
       const blockArg = `${block}${stateStr}${nbtStr}`;
       return this.subCommand([coordinatesParser(from), coordinatesParser(to), blockArg], FillArgumentsCommand, true);
     }
@@ -875,7 +941,7 @@ FillArgumentsCommand = class FillArgumentsCommand extends CommandArguments {
         return this.finalCommand(["replace"]);
       }
       const stateStr = filterState && Object.keys(filterState).length > 0 ? blockStateStringifier(filterState) : "";
-      const nbtStr = filterNbt ? nbtStringifier(filterNbt) : "";
+      const nbtStr = filterNbt ? nbtResolver(filterNbt).toString() : "";
       return this.subCommand(["replace", `${filter}${stateStr}${nbtStr}`], FillReplaceFilterCommand, true);
     }
   };
@@ -885,6 +951,33 @@ FillReplaceFilterCommand = class FillReplaceFilterCommand extends CommandArgumen
     outline = () => this.finalCommand(["outline"]);
     strict = () => this.finalCommand(["strict"]);
   };
+PlaceCommandNode = class PlaceCommandNode extends CommandNode {
+    command = "place";
+  };
+PlaceCommand = class PlaceCommand extends CommandArguments {
+    NodeType = PlaceCommandNode;
+    feature = (feature, pos = "~ ~ ~") => this.finalCommand(["feature", feature, coordinatesParser(pos)]);
+    jigsaw = (pool, target, maxDepth, pos = "~ ~ ~") => this.finalCommand([
+      "jigsaw",
+      pool,
+      target,
+      `${validateIntegerRange(maxDepth, "Jigsaw max depth", 0, 7)}`,
+      coordinatesParser(pos)
+    ]);
+    structure = (configuredStructure, pos = "~ ~ ~") => this.finalCommand(["structure", configuredStructure, coordinatesParser(pos)]);
+    template = (structure, pos = "~ ~ ~", rotation, mirror, integrity = 1, seed = 0, mode) => {
+      this.finalCommand([
+        "template",
+        `${structure}`,
+        coordinatesParser(pos),
+        structureRotationParser(rotation),
+        structureMirrorParser(mirror),
+        `${integrity}`,
+        `${seed}`,
+        ...mode === undefined ? [] : [mode]
+      ]);
+    };
+  };
 AttributeCommandNode = class AttributeCommandNode extends CommandNode {
     command = "attribute";
   };
@@ -907,9 +1000,27 @@ ClearCommandNode = class ClearCommandNode extends CommandNode {
 ClearCommand = class ClearCommand extends CommandArguments {
     NodeType = ClearCommandNode;
     clear(targets, itemOrPredicate, maxCount) {
-      return this.finalCommand([targetParser(targets), `${itemOrPredicate}`, maxCount]);
+      const itemArg = isMacroArgument(this.sandstoneCore, itemOrPredicate) ? itemOrPredicate : `${itemOrPredicate}`;
+      return this.finalCommand([targetParser(targets), itemArg, maxCount]);
     }
   };
+DamageCommandNode = class DamageCommandNode extends CommandNode {
+    command = "damage";
+  };
+DamageCauseCommand = class DamageCauseCommand extends CommandArguments {
+    from = (cause) => this.finalCommand(["from", targetParser(cause)]);
+  };
+DamageSourceCommand = class DamageSourceCommand extends CommandArguments {
+    by = (entity) => this.subCommand(["by", targetParser(entity)], DamageCauseCommand, true);
+    at = (position) => this.finalCommand(["at", coordinatesParser(position)]);
+  };
+DamageCommand = class DamageCommand extends CommandArguments {
+    NodeType = DamageCommandNode;
+    damage = (target, amount, damageType) => {
+      validateIntegerRange(amount, "amount", 0, 1e6);
+      return this.subCommand([targetParser(target), amount, damageType], DamageSourceCommand, true);
+    };
+  };
 EffectCommandNode = class EffectCommandNode extends CommandNode {
     command = "effect";
   };
@@ -935,6 +1046,110 @@ EnchantCommand = class EnchantCommand extends CommandArguments {
       return this.finalCommand([targetParser(targets), enchantment, level]);
     };
   };
+class ResourceClass {
+  core;
+  _resourceType;
+  node;
+  packType;
+  fileExtension;
+  fileEncoding;
+  creator;
+  commands;
+  pack;
+  path;
+  addToSandstoneCore;
+  onConflict;
+  renameIndex = 2;
+  constructor(core, file, NodeType, _resourceType, path, args) {
+    this.core = core;
+    this._resourceType = _resourceType;
+    this.node = new NodeType(core, this);
+    this.packType = args.packType || file.packType;
+    this.fileExtension = file.extension || "json";
+    this.fileEncoding = file.encoding ?? "utf8";
+    this.pack = core.pack;
+    this.commands = core.pack.commands;
+    this.path = path;
+    this.addToSandstoneCore = args.addToSandstoneCore;
+    this.creator = args.creator ?? "sandstone";
+    const conflictStrategies = hasContext() ? getSandstoneContext().conflictStrategies : undefined;
+    const scopedStrategy = conflictStrategies?.[_resourceType];
+    const defaultStrategy = conflictStrategies?.default;
+    this.onConflict = args.onConflict ?? scopedStrategy ?? defaultStrategy ?? "throw";
+  }
+  handleConflicts() {
+    const conflict = this.core.resourceNodes.get(this.node);
+    let add2 = false;
+    if (conflict) {
+      const oldResource = conflict.resource;
+      const newResource = this.node.resource;
+      switch (this.onConflict) {
+        case "throw": {
+          throw new Error(`Created a ${this._resourceType} with the duplicate name ${newResource.name}, and onConflict was set to "throw".`);
+        }
+        case "replace":
+          {
+            this.core.resourceNodes.delete(conflict);
+            add2 = true;
+          }
+          break;
+        case "warn":
+          {
+            console.warn([
+              "Warning:",
+              `Tried to create a ${this._resourceType} named "${newResource.name}", but found an already existing one.`,
+              "The new one has replaced the old one. To remove this warning, please change the options of the resource to { onConflict: '/* other option */' }."
+            ].join(`
+`));
+            this.core.resourceNodes.delete(conflict);
+            add2 = true;
+          }
+          break;
+        case "rename":
+          {
+            this.path[this.path.length - 1] += oldResource.renameIndex.toString();
+            oldResource.renameIndex += 1;
+            add2 = true;
+          }
+          break;
+        case "prepend":
+          {
+            oldResource.unshift(newResource);
+          }
+          break;
+        case "append":
+          {
+            oldResource.push(newResource);
+          }
+          break;
+        default:
+          break;
+      }
+    } else {
+      add2 = true;
+    }
+    if (this.addToSandstoneCore && add2) {
+      this.core.resourceNodes.add(this.node);
+    }
+  }
+  getNode = () => this.node;
+  get name() {
+    return `${this.path[0]}:${this.path.slice(this._resourceType in RESOURCE_PATHS ? RESOURCE_PATHS[this._resourceType].path.length + 1 : 2).join("/")}`;
+  }
+  get namespace() {
+    return this.path[0];
+  }
+  generate = () => {};
+  toString() {
+    return this.name;
+  }
+  toNBT() {
+    return this.name;
+  }
+  toJSON() {
+    return this.name;
+  }
+}
 CallableResourceClass = class CallableResourceClass extends ResourceClass {
     _that;
     get asCallable() {
@@ -1672,15 +1887,17 @@ _RawMCFunctionClass = class _RawMCFunctionClass extends CallableResourceClass {
         func = this;
       }
       if (typeof tag === "string") {
-        if (tags[tag]) {
-          tags[tag].push(func);
+        const existing = this.core.functionTags.get(tag);
+        if (existing) {
+          existing.push(func);
         } else {
-          tags[tag] = new TagClass(this.core, "function", tag, {
+          const newTag = new TagClass(this.core, "function", tag, {
             values: [func],
             addToSandstoneCore: true,
             creator: "sandstone",
             onConflict: "append"
           });
+          this.core.functionTags.set(tag, newTag);
         }
       } else {
         tag.push(func);
@@ -1704,6 +1921,7 @@ _RawMCFunctionClass = class _RawMCFunctionClass extends CallableResourceClass {
           this.core.enterMCFunction(this);
           this.core.insideContext(this.node, () => this.callback(makeCallable(this, this.__call__.bind(undefined, ..._params)), ..._params), false);
           this.core.exitMCFunction();
+          this.generated = true;
         } else if (this.callback.length > 1) {
           throw new Error(`[MCFunctionClass] Function ${this.name} expects ${this.callback.length - 1} params at the call-site`);
         }
@@ -2524,9 +2742,9 @@ SoundEventClass = class SoundEventClass extends ResourceClass {
           this.buffer = args.sound;
         }
         if (args.addToSounds) {
-          let def = sounds.get(this.path[0]);
+          let def = this.core.sounds.get(this.path[0]);
           if (!def) {
-            def = sounds.set(this.path[0], new SoundsClass(this.core, this.path[0], {
+            def = this.core.sounds.set(this.path[0], new SoundsClass(this.core, this.path[0], {
               addToSandstoneCore: true,
               creator: "sandstone"
             })).get(this.path[0]);
@@ -2803,10 +3021,11 @@ FunctionCommand = class FunctionCommand extends CommandArguments {
             args.push(point.type, point.currentTarget, point.path);
           }
         } else {
-          args.push(typeof params === "object" && params.toMacro ? params : nbtStringifier(params));
+          args.push(typeof params === "object" && params.toMacro ? params : nbtResolver(params));
         }
       }
-      return this.finalCommand([`${mcFunction}`, ...args]);
+      const mcFunctionArg = isMacroArgument(this.sandstoneCore, mcFunction) ? mcFunction : `${mcFunction}`;
+      return this.finalCommand([mcFunctionArg, ...args]);
     }
   };
 ExecuteCommandPart = class ExecuteCommandPart extends CommandArguments {
@@ -2886,6 +3105,9 @@ ExecuteCommandNode = class ExecuteCommandNode extends ContainerCommandNode {
       return `${this.isMacro ? "$" : ""}${executeString} run ${command}`;
     };
     createMCFunction = (currentMCFunction) => {
+      if (this.createdMCFunction) {
+        return { node: this, mcFunction: this.createdMCFunction.node };
+      }
       if (this.isSingleExecute || !currentMCFunction) {
         return { node: this };
       }
@@ -2908,7 +3130,15 @@ ExecuteStoreArgsCommand = class ExecuteStoreArgsCommand extends ExecuteCommandPa
     block = (targetPos, path5, type, scale) => this.nestedExecute(["block", coordinatesParser(targetPos), path5, type, scale]);
     bossbar = (id2, type) => this.nestedExecute(["bossbar", id2, type]);
     entity = (target, path5, type, scale) => this.nestedExecute(["entity", targetParser(target), path5, type, scale]);
-    score = (targets, objective) => this.nestedExecute(["score", targetParser(targets), objective]);
+    score(...args) {
+      const finalArgs = ["score"];
+      if (isScore(args[0])) {
+        finalArgs.push(args[0].target, args[0].objective.name);
+      } else {
+        finalArgs.push(targetParser(args[0]), args[1]);
+      }
+      return this.nestedExecute(finalArgs);
+    }
     storage = (target, path5, type, scale = 1) => this.nestedExecute(["storage", target, path5, type, scale]);
   };
 ExecuteStoreCommand = class ExecuteStoreCommand extends ExecuteCommandPart {
@@ -2946,7 +3176,7 @@ ExecuteItemsCommand = class ExecuteItemsCommand extends ExecuteCommandPart {
 ExecuteIfUnlessCommand = class ExecuteIfUnlessCommand extends ExecuteCommandPart {
     block(pos, block, state, nbt) {
       const stateStr = state && typeof state === "object" && Object.keys(state).length > 0 ? blockStateStringifier(state) : "";
-      const nbtStr = nbt ? nbtStringifier(nbt) : "";
+      const nbtStr = nbt ? nbtResolver(nbt).toString() : "";
       return this.nestedExecute(["block", coordinatesParser(pos), `${block}${stateStr}${nbtStr}`], true);
     }
     blocks = (start, end, destination, scan_mode) => this.nestedExecute(["blocks", coordinatesParser(start), coordinatesParser(end), coordinatesParser(destination), scan_mode], true);
@@ -3196,7 +3426,7 @@ SummonCommand = class SummonCommand extends CommandArguments {
         args.push(coordinatesParser(pos));
       }
       if (nbt !== undefined) {
-        args.push(nbtStringifier(nbt));
+        args.push(nbtResolver(nbt));
       }
       return this.finalCommand(args);
     }
@@ -3296,7 +3526,7 @@ DialogCommandNode = class DialogCommandNode extends CommandNode {
 DialogCommand = class DialogCommand extends CommandArguments {
     NodeType = DialogCommandNode;
     show(targets, dialog2) {
-      const dialogArg = typeof dialog2 === "string" || dialog2 instanceof ResourceClass ? dialog2 : nbtStringifier(dialog2);
+      const dialogArg = typeof dialog2 === "string" || dialog2 instanceof ResourceClass ? dialog2 : nbtResolver(dialog2);
       return this.finalCommand(["show", targetParser(targets), dialogArg]);
     }
     clear = (targets) => this.finalCommand(["clear", targetParser(targets)]);
@@ -3342,7 +3572,7 @@ ParticleCommand = class ParticleCommand extends CommandArguments {
     NodeType = ParticleCommandNode;
     particle(name, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
       const hasOptions = arg2 !== undefined && typeof arg2 === "object" && !isCoordinates(arg2);
-      const [particleName, pos, delta, speed, count, mode, viewers] = hasOptions ? [`${name}${nbtStringifier(arg2)}`, arg3, arg4, arg5, arg6, arg7, arg8] : [name, arg2, arg3, arg4, arg5, arg6, arg7];
+      const [particleName, pos, delta, speed, count, mode, viewers] = hasOptions ? [`${name}${nbtResolver(arg2)}`, arg3, arg4, arg5, arg6, arg7, arg8] : [name, arg2, arg3, arg4, arg5, arg6, arg7];
       return this.finalCommand([
         particleName,
         pos === undefined ? "~ ~ ~" : coordinatesParser(pos),
@@ -3522,7 +3752,8 @@ DebugCommand = class DebugCommand extends CommandArguments {
         this.sandstoneCore.insideContext(node, func, false);
         return this.finalCommand(["function", undefined], node);
       }
-      return this.finalCommand(["function", `${func}`], node);
+      const funcArg = isMacroArgument(this.sandstoneCore, func) ? func : `${func}`;
+      return this.finalCommand(["function", funcArg], node);
     }
   };
 DefaultGameModeCommandNode = class DefaultGameModeCommandNode extends CommandNode {
@@ -3729,7 +3960,8 @@ ScheduleCommandNode = class ScheduleCommandNode extends ContainerCommandNode {
 ScheduleCommand = class ScheduleCommand extends CommandArguments {
     NodeType = ScheduleCommandNode;
     clear = (func) => {
-      const result = this.finalCommand(["clear", `${func}`]);
+      const funcArg = isMacroArgument(this.sandstoneCore, func) ? func : `${func}`;
+      const result = this.finalCommand(["clear", funcArg]);
       return result;
     };
     function = (func, delay, type) => {
@@ -3741,7 +3973,8 @@ ScheduleCommand = class ScheduleCommand extends CommandArguments {
         this.sandstoneCore.insideContext(node, func, false);
         return this.finalCommand(["function", undefined, delay, type], node);
       }
-      return this.finalCommand(["function", `${func}`, delay, type], node);
+      const funcArg = isMacroArgument(this.sandstoneCore, func) ? func : `${func}`;
+      return this.finalCommand(["function", funcArg, delay, type], node);
     };
   };
 SetIdleTimeoutCommandNode = class SetIdleTimeoutCommandNode extends CommandNode {
@@ -3857,9 +4090,9 @@ DataGetCommand = class DataGetCommand extends CommandArguments {
     };
   };
 DataMergeCommand = class DataMergeCommand extends CommandArguments {
-    block = (targetPos, nbt) => this.finalCommand(["block", coordinatesParser(targetPos), nbtStringifier(nbt)]);
-    entity = (target, nbt) => this.finalCommand(["entity", targetParser(target), nbtStringifier(nbt)]);
-    storage = (target, nbt) => this.finalCommand(["storage", target, nbtStringifier(nbt)]);
+    block = (targetPos, nbt) => this.finalCommand(["block", coordinatesParser(targetPos), nbtResolver(nbt)]);
+    entity = (target, nbt) => this.finalCommand(["entity", targetParser(target), nbtResolver(nbt)]);
+    storage = (target, nbt) => this.finalCommand(["storage", target, nbtResolver(nbt)]);
   };
 DataModifyFromCommand = class DataModifyFromCommand extends CommandArguments {
     block = (sourcePosition, sourcePath) => this.finalCommand(["block", coordinatesParser(sourcePosition), sourcePath]);
@@ -3920,7 +4153,7 @@ DataModifyValuesCommand = class DataModifyValuesCommand extends CommandArguments
         this.finalCommand(command);
       }
     };
-    value = (value) => this.finalCommand(["value", nbtStringifier(value)]);
+    value = (value) => this.finalCommand(["value", nbtResolver(value)]);
   };
 DataModifyTypeCommand = class DataModifyTypeCommand extends CommandArguments {
     get append() {
@@ -3993,7 +4226,7 @@ ItemCommandNode = class ItemCommandNode extends CommandNode {
 ItemSourceCommand = class ItemSourceCommand extends CommandArguments {
     with(item, countOrNBT, count) {
       if (typeof countOrNBT === "object") {
-        return this.finalCommand(["with", `${item}${nbtStringifier(countOrNBT)}`, count]);
+        return this.finalCommand(["with", `${item}${nbtResolver(countOrNBT)}`, count]);
       }
       return this.finalCommand(["with", item, countOrNBT]);
     }
@@ -4264,7 +4497,7 @@ BlockConditionNode = class BlockConditionNode extends SingleConditionNode {
     }
     getCondition() {
       const stateStr = this.state && Object.keys(this.state).length > 0 ? blockStateStringifier(this.state) : "";
-      const nbtStr = this.nbt ? nbtStringifier(this.nbt) : "";
+      const nbtStr = this.nbt ? nbtResolver(this.nbt).toString() : "";
       return ["block", coordinatesParser(this.position), `${this.block}${stateStr}${nbtStr}`];
     }
   };
@@ -4516,15 +4749,6 @@ ForINode = class ForINode extends LoopNode {
       const iterator = sandstoneCore2.pack.Variable(initialValue, "loop_iterator");
       const condition2 = conditionToNode(endCondition(iterator));
       const _continue = () => sandstoneCore2.pack.commands.returnCmd.run(() => new IfStatement(sandstoneCore2, condition2, () => new LoopArgument(sandstoneCore2.pack)));
-      const analysisResult = typeof initialValue === "number" ? analyzeCondition(condition2, iterator, initialValue) : { canAnalyze: false };
-      if (analysisResult.canAnalyze) {
-        if (analysisResult.result) {
-          callback(iterator, _continue);
-          iterate(iterator);
-        } else {
-          warnStaticallyFalseCondition("for", `initial value ${initialValue} does not satisfy condition`);
-        }
-      }
       super(sandstoneCore2, condition2, () => callback(iterator, _continue), () => {
         iterate(iterator);
         new IfStatement(sandstoneCore2, condition2, () => new LoopArgument(sandstoneCore2.pack));
@@ -4632,6 +4856,61 @@ DefaultCaseNode = class DefaultCaseNode extends ContainerNode {
     }
     getValue = () => null;
   };
+class GenericCoreVisitor {
+  core;
+  methodCache;
+  constructor(core) {
+    this.core = core;
+    this.methodCache = new Map;
+  }
+  getSingleNodeMethod = (nodeName) => {
+    const methodName = `visit${nodeName}`;
+    const that = this;
+    const method = that[methodName];
+    return method;
+  };
+  getNodeMethods = (prototype) => {
+    const key = prototype.name;
+    const cachedResult = this.methodCache.get(key);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    const names = ancestors(prototype);
+    for (const name of names) {
+      const method = this.getSingleNodeMethod(name);
+      if (method) {
+        this.methodCache.set(key, method);
+        return method;
+      }
+    }
+    const result = (node_) => node_;
+    this.methodCache.set(key, result);
+    return result;
+  };
+  visit = (node) => this.getNodeMethods(node.constructor)(node);
+  genericVisit = (node) => {
+    if (node instanceof ContainerNode || node instanceof ContainerCommandNode) {
+      node.body = node.body.flatMap((n) => this.visit(n));
+    }
+    return node;
+  };
+  onStart = () => {};
+  onEnd = () => {};
+  genericNodeVisitor = () => (node) => this.genericVisit(node);
+  visitCommandNode = this.genericNodeVisitor();
+  visitContainerCommandNode = this.genericNodeVisitor();
+  visitContainerNode = this.genericNodeVisitor();
+  visitNode;
+  visitMCFunctionNode;
+  visitAdvancementNode;
+  visitItemModifierNode;
+  visitLootTableNode;
+  visitPredicateNode;
+  visitRecipeNode;
+  visitTagNode;
+  visitTrimMaterialNode;
+  visitTrimPatternNode;
+}
 GenericSandstoneVisitor = class GenericSandstoneVisitor extends GenericCoreVisitor {
     pack;
     constructor(pack) {
@@ -5357,7 +5636,7 @@ ItemPredicateClass = class ItemPredicateClass {
       if (test2.operator === "exists") {
         return `${prefix}${test2.component}`;
       }
-      const valueStr = nbtStringifier(test2.value);
+      const valueStr = nbtResolver(test2.value).toString();
       return `${prefix}${test2.component}${test2.operator}${valueStr}`;
     }
     stringifyOrGroup(group) {
@@ -5826,6 +6105,7 @@ SelectorClass = class SelectorClass {
     sandstonePack;
     target;
     arguments;
+    _hasMacro = false;
     constructor(sandstonePack2, target, selectorArguments) {
       this.sandstonePack = sandstonePack2;
       this.target = target;
@@ -5836,6 +6116,7 @@ SelectorClass = class SelectorClass {
     };
     toString() {
       if (!this.arguments || !Object.keys(this.arguments).length) {
+        this._hasMacro = false;
         return this.target;
       }
       const result = [];
@@ -5844,12 +6125,18 @@ SelectorClass = class SelectorClass {
         scores: (scores) => result.push(["scores", parseScore(this.sandstonePack.core, scores)]),
         nbt: (nbt2) => {
           const nbts = Array.isArray(nbt2) ? nbt2 : [nbt2];
-          result.push(...nbts.map((nbt_) => ["nbt", nbtStringifier(nbt_)]));
+          for (const nbt_ of nbts) {
+            const resolved = nbtResolver(nbt_);
+            if (resolved.containsMacro) {
+              this._hasMacro = true;
+            }
+            result.push(["nbt", resolved]);
+          }
         },
         advancements: (advancements) => result.push(["advancements", parseAdvancements(advancements)]),
         tag: (tag4) => {
-          const tags2 = Array.isArray(tag4) ? tag4 : [tag4];
-          result.push(...tags2.map((tag_) => ["tag", tag_]));
+          const tags = Array.isArray(tag4) ? tag4 : [tag4];
+          result.push(...tags.map((tag_) => ["tag", tag_]));
         },
         gamemode: (gamemode2) => {
           const gamemodes = Array.isArray(gamemode2) ? gamemode2 : [gamemode2];
@@ -5907,6 +6194,32 @@ SelectorClass = class SelectorClass {
       return formatDebugString(this.constructor.name, this.toString(), undefined, undefined);
     }
   };
+class _RawLabelClass {
+  pack;
+  name;
+  fullName;
+  description;
+  constructor(pack2, name, description) {
+    this.pack = pack2;
+    if (name.includes(":")) {
+      this.name = name.split(":")[1];
+      this.fullName = name.replace(":", ".");
+    } else {
+      this.name = name;
+      this.fullName = `${pack2.defaultNamespace}.${name}`;
+    }
+    if (description)
+      this.description = description;
+  }
+  LabelHolder = (entity) => {
+    if (typeof entity === "string")
+      return new EntityLabel(this.pack, new SelectorClass(this.pack, entity), this);
+    return new EntityLabel(this.pack, entity, this);
+  };
+  toString = () => `${this.fullName}${this.description ? `; ${this.description}` : ""}`;
+  toNBT = () => `'${this.fullName}'`;
+  __call__ = (entity) => this.LabelHolder(entity);
+}
 LabelClass = makeClassCallable(_RawLabelClass);
 LoopArgument = class LoopArgument extends Node {
     pack;
@@ -6003,6 +6316,7 @@ SleepClass = class SleepClass extends AwaitNode {
         const { execute: execute2 } = commands2;
         const name = `__sandstone:asyncTimer.${currentFunction.resource.name.replace(/[:/]/g, ".")}`;
         const timer = new ObjectiveClass(core.pack, name.replace(":", "."), "dummy", undefined, { creator: "sandstone" });
+        core.pack.registerNewObjective(timer);
         execute2.store.result(timer("@s")).run.time.query("gametime");
         timer("@s").add(Duration);
         const label2 = Label(name);
@@ -6019,23 +6333,10 @@ SleepClass = class SleepClass extends AwaitNode {
       currentFunction.enterContext(this);
       core.awaitNodes.add(this);
     }
-    promise() {
-      return {
-        then: async (onfullfilled) => {
-          await onfullfilled?.();
-          return this;
-        }
-      };
-    }
   };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/variables/abstractClasses.ts
-class ComponentClass {
-  _toChatComponent() {
-    throw new Error("Not implemented");
-  }
-}
 
 class ConditionClass {
   _toMinecraftCondition() {
@@ -6093,32 +6394,6 @@ var init_Coordinates = __esm(() => {
   });
 
 // src/core/Macro.ts
-class MacroArgument {
-  sandstoneCore;
-  local;
-  toMacro;
-  constructor(sandstoneCore) {
-    this.sandstoneCore = sandstoneCore;
-    this.local = new Map;
-    this.toMacro = () => {
-      let currentMCFunctionName = "";
-      try {
-        currentMCFunctionName = sandstoneCore.getCurrentMCFunctionOrThrow().resource.name;
-      } catch {}
-      let result = this.local.get(this.sandstoneCore.currentNode) || this.local.get(currentMCFunctionName);
-      if (!result) {
-        let path = this.sandstoneCore.currentNode;
-        while (path.includes("/")) {
-          path = path.substring(0, path.lastIndexOf("/"));
-          result = this.local.get(path);
-          if (result)
-            break;
-        }
-      }
-      return `$(${result})`;
-    };
-  }
-}
 function isMacroArgument(core, arg) {
   if (typeof arg === "object" && Object.hasOwn(arg, "toMacro")) {
     const local2 = arg.local;
@@ -6876,8 +7151,6 @@ var init_parser = __esm(() => {
 // src/variables/nbt/NBTs.ts
 import * as util2 from "util";
 
-class NBTClass {
-}
 function customNumber(num, _class) {
   if (Array.isArray(num)) {
     return num.map((n) => new _class(n));
@@ -6886,18 +7159,30 @@ function customNumber(num, _class) {
 }
 function dynamicNBT(template, ...args) {
   const mixedArgs = template.flatMap((s, i) => [s, args[i]]).slice(0, -1);
-  const result = mixedArgs.map((element) => element instanceof NBTClass ? nbtStringifier(element) : element.toString()).join("");
+  const result = mixedArgs.map((element) => element instanceof NBTClass ? nbtResolver(element).toString() : element.toString()).join("");
   return parseNBT(NBT, result);
 }
-var NBTPrimitive, NBTLong, NBTByte, NBTShort, NBTFloat, NBTInt, NBTDouble, NBTTypedArray, NBTLongArray, NBTByteArray, NBTIntArray, NotNBT, NBTString, NBTAnyValue, NBT, nbtStringifier = (nbt) => {
+
+class ResolvedNBT {
+  value;
+  containsMacro;
+  constructor(value, containsMacro) {
+    this.value = value;
+    this.containsMacro = containsMacro;
+  }
+  toString() {
+    return this.value;
+  }
+}
+var NBTPrimitive, NBTLong, NBTByte, NBTShort, NBTFloat, NBTInt, NBTDouble, NBTTypedArray, NBTLongArray, NBTByteArray, NBTIntArray, NotNBT, NBTString, NBTAnyValue, NBT, resolve = (nbt) => {
   if (nbt === null || nbt === undefined) {
     throw new Error("Nullish nbt values are not allowed");
   }
   if (typeof nbt === "number") {
-    return `${nbt}d`;
+    return new ResolvedNBT(`${nbt}d`, false);
   }
   if (typeof nbt === "boolean") {
-    return nbt.toString();
+    return new ResolvedNBT(nbt.toString(), false);
   }
   if (typeof nbt === "string") {
     const inspectedStr = util2.inspect(nbt, {
@@ -6907,16 +7192,22 @@ var NBTPrimitive, NBTLong, NBTByte, NBTShort, NBTFloat, NBTInt, NBTDouble, NBTTy
       depth: Number.POSITIVE_INFINITY
     });
     if (inspectedStr[0] === "`") {
-      return JSON.stringify(nbt);
+      return new ResolvedNBT(JSON.stringify(nbt), false);
     }
-    return inspectedStr;
+    return new ResolvedNBT(inspectedStr, false);
   }
   if (Array.isArray(nbt)) {
-    const itemsStr = nbt.map(nbtStringifier).join(",");
-    return `[${itemsStr}]`;
+    let containsMacro2 = false;
+    const itemsStr = nbt.map((item) => {
+      const resolved = resolve(item);
+      if (resolved.containsMacro)
+        containsMacro2 = true;
+      return resolved.value;
+    }).join(",");
+    return new ResolvedNBT(`[${itemsStr}]`, containsMacro2);
   }
   if (nbt instanceof NBTClass) {
-    return nbt[util2.inspect.custom]();
+    return new ResolvedNBT(nbt[util2.inspect.custom](), false);
   }
   if (typeof nbt === "object" || typeof nbt === "function") {
     let failedMacro = false;
@@ -6925,28 +7216,38 @@ var NBTPrimitive, NBTLong, NBTByte, NBTShort, NBTFloat, NBTInt, NBTDouble, NBTTy
       if (macro === "$()") {
         failedMacro = true;
       } else {
-        return macro;
+        return new ResolvedNBT(macro, true);
       }
     }
     if ("toNBT" in nbt) {
-      return nbt.toNBT();
+      const toNbtResult = nbt.toNBT();
+      if (toNbtResult instanceof ResolvedNBT) {
+        return toNbtResult;
+      }
+      return new ResolvedNBT(String(toNbtResult), false);
     } else if (failedMacro) {
-      throw new Error("[nbtStringifier] A macro variable NBT insertion was attempted in an mcfunction without macros defined.");
+      throw new Error("[nbtResolver] A macro variable NBT insertion was attempted in an mcfunction without macros defined.");
     }
     if (typeof nbt === "function") {
-      throw new Error(`[nbtStringifier] This should never happen. A function or callable instance (${nbt.constructor?.name}) without toNBT was passed in as an NBT value.`);
+      throw new Error(`[nbtResolver] This should never happen. A function or callable instance (${nbt.constructor?.name}) without toNBT was passed in as an NBT value.`);
     }
     if (nbt.constructor.name !== "Object") {
       if ("toString" in nbt) {
-        return `${toString}`;
+        return new ResolvedNBT(`${toString}`, false);
       } else {
-        throw new Error(`[nbtStringifier] A ${nbt.constructor?.name} was passed in as an NBT value. Hint: define toNBT or toString if this was intentional`);
+        throw new Error(`[nbtResolver] A ${nbt.constructor?.name} was passed in as an NBT value. Hint: define toNBT or toString if this was intentional`);
       }
     }
   }
-  const objectStr = Object.entries(nbt).map(([key, value]) => `${key}:${nbtStringifier(value)}`).join(",");
-  return `{${objectStr}}`;
-};
+  let containsMacro = false;
+  const objectStr = Object.entries(nbt).map(([key, value]) => {
+    const resolved = resolve(value);
+    if (resolved.containsMacro)
+      containsMacro = true;
+    return `${key}:${resolved.value}`;
+  }).join(",");
+  return new ResolvedNBT(`{${objectStr}}`, containsMacro);
+}, nbtResolver = (nbt) => resolve(nbt);
 var init_NBTs = __esm(() => {
   init_utils();
   init_parser();
@@ -6961,7 +7262,7 @@ var init_NBTs = __esm(() => {
     longArray: (numbers) => new NBTLongArray(numbers),
     byteArray: (numbers) => new NBTByteArray(numbers),
     not: (nbt) => new NotNBT(nbt),
-    stringify: (nbt) => nbtStringifier(nbt),
+    stringify: (nbt) => nbtResolver(nbt).toString(),
     parse: (nbt) => parseNBT(NBT, nbt)
   }, dynamicNBT);
 });
@@ -7155,7 +7456,7 @@ function NBTpathToString(pack, paths) {
       } else if (Array.isArray(path) && path.length === 1 && typeof path[0] === "number" && Number.isInteger(path[0])) {
         parsedPaths.push(`[${path[0]}]`);
       } else {
-        parsedPaths.push(nbtStringifier(path));
+        parsedPaths.push(nbtResolver(path).toString());
       }
     } else if (path !== "") {
       parsedPaths.push(`${path}${i === paths.length - 1 ? "" : "."}`);
@@ -7236,27 +7537,6 @@ var init_basics = __esm(() => {
   init_arguments();
 });
 // src/pack/packType.ts
-class PackType {
-  type;
-  clientPath;
-  serverPath;
-  rootPath;
-  networkSides;
-  resourceSubFolder;
-  namespaced;
-  archiveOutput;
-  handleOutput;
-  constructor(type, clientPath, serverPath, rootPath, networkSides, archiveOutput = false, resourceSubFolder, namespaced = false) {
-    this.type = type;
-    this.clientPath = clientPath;
-    this.serverPath = serverPath;
-    this.rootPath = rootPath;
-    this.networkSides = networkSides;
-    this.archiveOutput = archiveOutput;
-    this.resourceSubFolder = resourceSubFolder;
-    this.namespaced = namespaced;
-  }
-}
 
 // src/pack/dependencies.ts
 var DataPackDependencies, ResourcePackDependencies;
@@ -7267,6 +7547,7 @@ var init_dependencies = __esm(() => {
 import * as util4 from "util";
 var Node, ContainerNode, CommandNode, ContainerCommandNode, AwaitNode;
 var init_nodes = __esm(() => {
+  init_NBTs();
   init_utils();
   init_Macro();
           });
@@ -7279,78 +7560,6 @@ class FinalCommandOutput {
   }
 }
 
-class CommandArguments {
-  sandstonePack;
-  previousNode;
-  autoCommit;
-  NodeType;
-  sandstoneCore;
-  sandstoneCommands;
-  constructor(sandstonePack, previousNode, autoCommit = true) {
-    this.sandstonePack = sandstonePack;
-    this.previousNode = previousNode;
-    this.autoCommit = autoCommit;
-    this.sandstoneCore = sandstonePack.core;
-    this.sandstoneCommands = sandstonePack.commands;
-  }
-  getNode = () => {
-    if (this.previousNode) {
-      return this.previousNode;
-    }
-    if (this.NodeType) {
-      return new this.NodeType(this.sandstonePack);
-    }
-    throw new Error("No node type specified & no previous node for a non-root-level command");
-  };
-  finalCommand = (args, currentNode) => {
-    const node = currentNode ?? this.getNode();
-    if (args) {
-      node.args.push(...args);
-    }
-    if (this.autoCommit) {
-      node.commit();
-    }
-    return new FinalCommandOutput(node);
-  };
-  subCommand = (args, NextArgumentType, executable = false, additionalNextArgs = [], currentNode) => {
-    const node = currentNode ?? this.getNode();
-    if (args) {
-      node.args.push(...args);
-    }
-    if (executable && this.autoCommit) {
-      node.commit();
-    }
-    return new NextArgumentType(this.sandstonePack, node, this.autoCommit, ...additionalNextArgs);
-  };
-}
-
-// src/commands/validators.ts
-function validateIntegerRange(integer, name, minimum = 0, maximum = 2147483647) {
-  if (typeof integer !== "number") {
-    return integer;
-  }
-  if (integer && integer <= minimum) {
-    throw new Error(`\`${name}\` must be greater than or equal to ${minimum.toLocaleString()}, got \`${integer.toLocaleString()}\`.`);
-  }
-  if (integer && integer >= maximum) {
-    throw new Error(`\`${name}\` must be lower than or equal to ${maximum.toLocaleString()}, got \`${integer.toLocaleString()}\`.`);
-  }
-  return integer;
-}
-
-// src/commands/implementations/block/place.ts
-var PlaceCommandNode, PlaceCommand;
-var init_place = __esm(() => {
-  init_nodes();
-  init_parsers();
-    });
-
-// src/commands/implementations/entity/damage.ts
-var DamageCommandNode, DamageCauseCommand, DamageSourceCommand, DamageCommand;
-var init_damage = __esm(() => {
-  init_nodes();
-  init_parsers();
-        });
 
 // src/commands/implementations/_fake/comment.ts
 var CommentCommandNode, CommentCommand;
@@ -7393,6 +7602,27 @@ var init_fill = __esm(() => {
   init_setblock();
         });
 
+// src/commands/validators.ts
+function validateIntegerRange(integer, name, minimum = 0, maximum = 2147483647) {
+  if (typeof integer !== "number") {
+    return integer;
+  }
+  if (integer && integer <= minimum) {
+    throw new Error(`\`${name}\` must be greater than or equal to ${minimum.toLocaleString()}, got \`${integer.toLocaleString()}\`.`);
+  }
+  if (integer && integer >= maximum) {
+    throw new Error(`\`${name}\` must be lower than or equal to ${maximum.toLocaleString()}, got \`${integer.toLocaleString()}\`.`);
+  }
+  return integer;
+}
+
+// src/commands/implementations/block/place.ts
+var PlaceCommandNode, PlaceCommand;
+var init_place = __esm(() => {
+  init_nodes();
+  init_parsers();
+    });
+
 // src/commands/implementations/entity/attribute.ts
 var AttributeCommandNode, AttributeCommand, AttributeOperationCommand;
 var init_attribute = __esm(() => {
@@ -7403,10 +7633,18 @@ var init_attribute = __esm(() => {
 // src/commands/implementations/entity/clear.ts
 var ClearCommandNode, ClearCommand;
 var init_clear = __esm(() => {
+  init_Macro();
   init_nodes();
   init_parsers();
     });
 
+// src/commands/implementations/entity/damage.ts
+var DamageCommandNode, DamageCauseCommand, DamageSourceCommand, DamageCommand;
+var init_damage = __esm(() => {
+  init_nodes();
+  init_parsers();
+        });
+
 // src/commands/implementations/entity/effect.ts
 var EffectCommandNode, EffectCommand;
 var init_effect = __esm(() => {
@@ -7506,110 +7744,6 @@ var init_resource_paths = __esm(() => {
 });
 
 // src/core/resources/resource.ts
-class ResourceClass {
-  core;
-  _resourceType;
-  node;
-  packType;
-  fileExtension;
-  fileEncoding;
-  creator;
-  commands;
-  pack;
-  path;
-  addToSandstoneCore;
-  onConflict;
-  renameIndex = 2;
-  constructor(core, file, NodeType, _resourceType, path, args) {
-    this.core = core;
-    this._resourceType = _resourceType;
-    this.node = new NodeType(core, this);
-    this.packType = args.packType || file.packType;
-    this.fileExtension = file.extension || "json";
-    this.fileEncoding = file.encoding ?? "utf8";
-    this.pack = core.pack;
-    this.commands = core.pack.commands;
-    this.path = path;
-    this.addToSandstoneCore = args.addToSandstoneCore;
-    this.creator = args.creator ?? "sandstone";
-    const conflictStrategies = hasContext() ? getSandstoneContext().conflictStrategies : undefined;
-    const scopedStrategy = conflictStrategies?.[_resourceType];
-    const defaultStrategy = conflictStrategies?.default;
-    this.onConflict = args.onConflict ?? scopedStrategy ?? defaultStrategy ?? "throw";
-  }
-  handleConflicts() {
-    const conflict = this.core.resourceNodes.get(this.node);
-    let add2 = false;
-    if (conflict) {
-      const oldResource = conflict.resource;
-      const newResource = this.node.resource;
-      switch (this.onConflict) {
-        case "throw": {
-          throw new Error(`Created a ${this._resourceType} with the duplicate name ${newResource.name}, and onConflict was set to "throw".`);
-        }
-        case "replace":
-          {
-            this.core.resourceNodes.delete(conflict);
-            add2 = true;
-          }
-          break;
-        case "warn":
-          {
-            console.warn([
-              "Warning:",
-              `Tried to create a ${this._resourceType} named "${newResource.name}", but found an already existing one.`,
-              "The new one has replaced the old one. To remove this warning, please change the options of the resource to { onConflict: '/* other option */' }."
-            ].join(`
-`));
-            this.core.resourceNodes.delete(conflict);
-            add2 = true;
-          }
-          break;
-        case "rename":
-          {
-            this.path[this.path.length - 1] += oldResource.renameIndex.toString();
-            oldResource.renameIndex += 1;
-            add2 = true;
-          }
-          break;
-        case "prepend":
-          {
-            oldResource.unshift(newResource);
-          }
-          break;
-        case "append":
-          {
-            oldResource.push(newResource);
-          }
-          break;
-        default:
-          break;
-      }
-    } else {
-      add2 = true;
-    }
-    if (this.addToSandstoneCore && add2) {
-      this.core.resourceNodes.add(this.node);
-    }
-  }
-  getNode = () => this.node;
-  get name() {
-    return `${this.path[0]}:${this.path.slice(this._resourceType in RESOURCE_PATHS ? RESOURCE_PATHS[this._resourceType].path.length + 1 : 2).join("/")}`;
-  }
-  get namespace() {
-    return this.path[0];
-  }
-  generate = () => {};
-  toString() {
-    return this.name;
-  }
-  toNBT() {
-    return this.name;
-  }
-  toJSON() {
-    return this.name;
-  }
-}
 
 class ListResource {
   push(..._args) {}
@@ -7811,14 +7945,13 @@ var init_tag = __esm(() => {
 
 // src/core/resources/datapack/mcfunction.ts
 import * as util6 from "util";
-var tags, MCFunctionNode, _RawMCFunctionClass, MCFunctionClass;
+var MCFunctionNode, _RawMCFunctionClass, MCFunctionClass;
 var init_mcfunction = __esm(() => {
   init_utils();
   init_ResolveNBT();
   init_nodes();
   init_resource();
   init_tag();
-  tags = {};
       });
 
 // src/core/resources/datapack/predicate.ts
@@ -8027,12 +8160,11 @@ var init_shader = __esm(() => {
 
 // src/core/resources/resourcepack/sound.ts
 import path from "node:path";
-var sounds, SoundEventNode, SoundEventClass, SoundsNode, SoundsClass;
+var SoundEventNode, SoundEventClass, SoundsNode, SoundsClass;
 var init_sound = __esm(() => {
   init_arguments();
   init_nodes();
   init_resource();
-  sounds = new Map;
         });
 
 // src/core/resources/resourcepack/text.ts
@@ -8452,11 +8584,17 @@ class SandstoneCore {
   _mcMetaCache = false;
   _smithed = false;
   dependencies = [];
+  functionTags = new Map;
+  sounds = new Map;
+  checkTriggers = {};
   constructor(pack) {
     this.pack = pack;
     this.resourceNodes = new ResourceNodesMap;
     this.mcfunctionStack = [];
     this.awaitNodes = new Set;
+    this.functionTags = new Map;
+    this.sounds = new Map;
+    this.checkTriggers = {};
     for (const method of Object.getOwnPropertyNames(Object.getPrototypeOf(this))) {
       if (method !== "constructor" && typeof this[method] === "function" && typeof this[method].bind === "function") {
         this[method] = this[method].bind(this);
@@ -8471,6 +8609,9 @@ class SandstoneCore {
     this._mcMetaCache = undefined;
     this._smithed = undefined;
     this.dependencies = [];
+    this.functionTags.clear();
+    this.sounds.clear();
+    this.checkTriggers = {};
   };
   get currentMCFunction() {
     return this.mcfunctionStack[this.mcfunctionStack.length - 1];
@@ -8624,6 +8765,7 @@ var init_core = __esm(() => {
 // src/commands/implementations/server/function.ts
 var FunctionCommandNode, FunctionCommand;
 var init_function = __esm(() => {
+  init_Macro();
   init_nodes();
   init_NBTs();
     });
@@ -8891,7 +9033,7 @@ function componentPatchStringifier(components) {
         throw new Error(`Attempted to insert a negation component patch of ${key} with a value, use {} instead.`);
       }
     } else {
-      resultPairs.push(`${key}=${nbtStringifier(value)}`);
+      resultPairs.push(`${key}=${nbtResolver(value).toString()}`);
     }
   }
   return `[${resultPairs.join(",")}]`;
@@ -8979,6 +9121,7 @@ var init_datapack2 = __esm(() => {
 var DebugCommandNode, DebugCommand;
 var init_debug = __esm(() => {
   init_nodes();
+  init_Macro();
     });
 
 // src/commands/implementations/server/defaultgamemode.ts
@@ -9054,6 +9197,7 @@ var init_say = __esm(() => {
 // src/commands/implementations/server/schedule.ts
 var ScheduleCommandNode, ScheduleCommand;
 var init_schedule = __esm(() => {
+  init_Macro();
   init_nodes();
     });
 
@@ -9532,10 +9676,7 @@ class SandstoneCommands {
   }
 }
 var init_commands = __esm(() => {
-  init_place();
-  init_damage();
   init_implementations();
-  init_random();
 });
 
 // src/commands/index.ts
@@ -9789,75 +9930,6 @@ var init_loop = __esm(() => {
   init_core();
   });
 
-// src/flow/loops/staticAnalysis.ts
-function valueMatchesRange(value, rangeStr) {
-  if (rangeStr.includes("..")) {
-    const [minStr, maxStr] = rangeStr.split("..");
-    const min = minStr !== "" ? parseInt(minStr, 10) : Number.NEGATIVE_INFINITY;
-    const max = maxStr !== "" ? parseInt(maxStr, 10) : Number.POSITIVE_INFINITY;
-    return value >= min && value <= max;
-  }
-  return value === parseInt(rangeStr, 10);
-}
-function analyzeCondition(condition2, targetScore, value, negated = false) {
-  if (condition2 instanceof ScoreConditionNode) {
-    const args = condition2.args;
-    if (args.length >= 4 && args[2] === "matches") {
-      const [target, objective, , rangeStr] = args;
-      if (target !== `${targetScore.target}` || objective !== `${targetScore.objective}`) {
-        return { canAnalyze: false };
-      }
-      let result = valueMatchesRange(value, rangeStr);
-      if (negated)
-        result = !result;
-      return { canAnalyze: true, result };
-    }
-    return { canAnalyze: false };
-  }
-  if (condition2 instanceof AndNode) {
-    for (const subCondition of condition2.conditions) {
-      const subResult = analyzeCondition(subCondition, targetScore, value, negated);
-      if (!subResult.canAnalyze)
-        return { canAnalyze: false };
-      if (!subResult.result)
-        return { canAnalyze: true, result: false };
-    }
-    return { canAnalyze: true, result: true };
-  }
-  if (condition2 instanceof OrNode) {
-    let anyTrue = false;
-    for (const subCondition of condition2.conditions) {
-      const subResult = analyzeCondition(subCondition, targetScore, value, negated);
-      if (!subResult.canAnalyze)
-        return { canAnalyze: false };
-      if (subResult.result)
-        anyTrue = true;
-    }
-    return { canAnalyze: true, result: anyTrue };
-  }
-  if (condition2 instanceof NotNode) {
-    return analyzeCondition(condition2.condition, targetScore, value, !negated);
-  }
-  return { canAnalyze: false };
-}
-function getDeclarationLocation() {
-  const stack = new Error().stack;
-  const locationMatch = stack?.split(`
-`).find((line) => line.includes(".ts:") && !line.includes("/loops/") && !line.includes("node_modules"));
-  return locationMatch?.trim() || "unknown location";
-}
-function warnStaticallyFalseCondition(loopType, details) {
-  const location = getDeclarationLocation();
-  console.warn(`[Sandstone] Warning: ${loopType} loop condition is statically false (${details}). ` + `The loop body will never execute. If this is intentional, you can ignore this warning.
-` + `  at ${location}`);
-}
-var init_staticAnalysis = __esm(() => {
-  init_score();
-  init_and();
-  init_or();
-  init_not();
-});
-
 // src/flow/loops/for_i.ts
 class ForIStatement {
   sandstoneCore;
@@ -9882,7 +9954,6 @@ var init_for_i = __esm(() => {
   init_flow();
   init_if_else();
   init_loop();
-  init_staticAnalysis();
   });
 
 // src/flow/loops/for_of.ts
@@ -10186,61 +10257,6 @@ function ancestors(prototype) {
   return [prototype.name, ...ancestors(Object.getPrototypeOf(prototype))];
 }
 
-class GenericCoreVisitor {
-  core;
-  methodCache;
-  constructor(core) {
-    this.core = core;
-    this.methodCache = new Map;
-  }
-  getSingleNodeMethod = (nodeName) => {
-    const methodName = `visit${nodeName}`;
-    const that = this;
-    const method = that[methodName];
-    return method;
-  };
-  getNodeMethods = (prototype) => {
-    const key = prototype.name;
-    const cachedResult = this.methodCache.get(key);
-    if (cachedResult) {
-      return cachedResult;
-    }
-    const names = ancestors(prototype);
-    for (const name of names) {
-      const method = this.getSingleNodeMethod(name);
-      if (method) {
-        this.methodCache.set(key, method);
-        return method;
-      }
-    }
-    const result = (node_) => node_;
-    this.methodCache.set(key, result);
-    return result;
-  };
-  visit = (node) => this.getNodeMethods(node.constructor)(node);
-  genericVisit = (node) => {
-    if (node instanceof ContainerNode || node instanceof ContainerCommandNode) {
-      node.body = node.body.flatMap((n) => this.visit(n));
-    }
-    return node;
-  };
-  onStart = () => {};
-  onEnd = () => {};
-  genericNodeVisitor = () => (node) => this.genericVisit(node);
-  visitCommandNode = this.genericNodeVisitor();
-  visitContainerCommandNode = this.genericNodeVisitor();
-  visitContainerNode = this.genericNodeVisitor();
-  visitNode;
-  visitMCFunctionNode;
-  visitAdvancementNode;
-  visitItemModifierNode;
-  visitLootTableNode;
-  visitPredicateNode;
-  visitRecipeNode;
-  visitTagNode;
-  visitTrimMaterialNode;
-  visitTrimPatternNode;
-}
 var init_visitors = __esm(() => {
   init_core();
 });
@@ -10564,6 +10580,9 @@ class SandstonePack {
     this.initMCFunction.push(() => loadStatus(this.defaultNamespace).set(loadVersion));
   };
   resourceToPath = (name, resourceFolders) => {
+    if (name === "") {
+      throw new Error("A resource name must not be empty!");
+    }
     let namespace = this.defaultNamespace;
     let fullName = name;
     if (name.includes(":")) {
@@ -10579,6 +10598,11 @@ class SandstonePack {
     return this.flow;
   }
   registerNewObjective = (objective) => {
+    for (const obj of this.objectives) {
+      if (obj.name === objective.name) {
+        return;
+      }
+    }
     this.objectives.add(objective);
   };
   registerNewConstant(amount) {
@@ -10613,7 +10637,7 @@ class SandstonePack {
       return `anon_${this.packUid}_${this.anonymousScoreId++}`;
     } else {
       this.namedVariableIds[name] ??= 0;
-      return `${name}_${this.namedVariableIds[name]}_${this.packUid}`;
+      return `${name}_${this.namedVariableIds[name]++}_${this.packUid}`;
     }
   }
   Variable(...args) {
@@ -10725,7 +10749,7 @@ class SandstonePack {
     const tag4 = this.ticked[runEvery] ?? (() => {
       const name = `__sandstone:ticked/${runEvery}`;
       this.ticked[runEvery] = this.Tag("function", name, []);
-      this.MCFunction(name, (self) => {
+      const looped = this.MCFunction(name, (self) => {
         this.commands.functionCmd(this.ticked[runEvery]);
         self.schedule.function(runEvery, "replace");
       });
@@ -10733,7 +10757,7 @@ class SandstonePack {
         this.startAllTicked = this.MCFunction(`__sandstone:ticked/start/${this.packUid.toLowerCase()}`);
         this.loadTags.load.push(this.startAllTicked);
       }
-      this.startAllTicked.push(() => this.commands.schedule.function(this.ticked[runEvery], runEvery, "replace"));
+      this.startAllTicked.push(() => looped());
       return this.ticked[runEvery];
     })();
     if (func.env === undefined) {
@@ -10752,7 +10776,7 @@ class SandstonePack {
     }
     this.tickedCommands[runEvery].push(callback);
   }
-  sleep = (delay) => new SleepClass(this.core, delay).promise();
+  sleep = (delay) => new SleepClass(this.core, delay);
   Loop = () => new LoopArgument(this);
   __customResourceTypes = [];
   registerCustomResource(type) {
@@ -50817,32 +50841,6 @@ var init_Selector = __esm(() => {
   });
 
 // src/variables/Label.ts
-class _RawLabelClass {
-  pack;
-  name;
-  fullName;
-  description;
-  constructor(pack2, name, description) {
-    this.pack = pack2;
-    if (name.includes(":")) {
-      this.name = name.split(":")[1];
-      this.fullName = name.replace(":", ".");
-    } else {
-      this.name = name;
-      this.fullName = `${pack2.defaultNamespace}.${name}`;
-    }
-    if (description)
-      this.description = description;
-  }
-  LabelHolder = (entity) => {
-    if (typeof entity === "string")
-      return new EntityLabel(this.pack, new SelectorClass(this.pack, entity), this);
-    return new EntityLabel(this.pack, entity, this);
-  };
-  toString = () => `${this.fullName}${this.description ? `; ${this.description}` : ""}`;
-  toNBT = () => `'${this.fullName}'`;
-  __call__ = (entity) => this.LabelHolder(entity);
-}
 
 class EntityLabel {
   pack;
@@ -50933,13 +50931,13 @@ class TriggerClass {
     this.objective = new ObjectiveClass(sandstoneCore2.pack, name, "dummy", undefined, { creator: "sandstone" });
     const { registerNewObjective, MCFunction, commands: commands2 } = sandstoneCore2.pack;
     registerNewObjective(this.objective);
-    if (!checkTriggers[pollingEvery]) {
-      checkTriggers[pollingEvery] = MCFunction(`triggers/check/${pollingEvery}`, {
+    if (!sandstoneCore2.checkTriggers[pollingEvery]) {
+      sandstoneCore2.checkTriggers[pollingEvery] = MCFunction(`triggers/check/${pollingEvery}`, {
         creator: "sandstone",
         runEvery: pollingEvery
       });
     }
-    checkTriggers[pollingEvery].push(() => {
+    sandstoneCore2.checkTriggers[pollingEvery].push(() => {
       commands2.execute.as(`@a[scores={${name}=1..}]`).run(() => {
         const score2 = this.objective("@s");
         if (callback instanceof _RawMCFunctionClass || typeof callback === "function") {
@@ -50955,11 +50953,9 @@ class TriggerClass {
   }
   toString = () => this.name;
 }
-var checkTriggers;
 var init_Trigger = __esm(() => {
   init_mcfunction();
   init_Objective();
-  checkTriggers = {};
 });
 
 // src/variables/UUID.ts
@@ -51573,6 +51569,7 @@ export {
   recipe3 as recipe,
   raw2 as raw,
   rangeParser,
+  randomUUID,
   random2 as random,
   playsound2 as playsound,
   place2 as place,
@@ -51580,7 +51577,7 @@ export {
   particle3 as particle,
   parseNBT,
   parseJSONText,
-  nbtStringifier,
+  nbtResolver,
   msg,
   me2 as me,
   mcMetaCache2 as mcMetaCache,
@@ -51886,6 +51883,7 @@ export {
   ResourcePack,
   ResourceNodesMap,
   ResourceClass,
+  ResolvedNBT,
   ResolveNBTPartClass,
   ResolveNBTPart,
   ResolveNBTClass,
@@ -52260,5 +52258,5 @@ export {
   ACTIVITIES_SET
 };
 
-//# debugId=097BEFB5602A878F64756E2164756E21
+//# debugId=CD6B0FD0ECC93B9764756E2164756E21
 //# sourceMappingURL=index.js.map