sandstone 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/core/index.js

@@ -42,7 +42,17 @@ class MacroArgument {
       try {
         currentMCFunctionName = sandstoneCore.getCurrentMCFunctionOrThrow().resource.name;
       } catch {}
-      return `$(${this.local.get(this.sandstoneCore.currentNode) || this.local.get(currentMCFunctionName)})`;
+      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})`;
     };
   }
 }
@@ -82,6 +92,9 @@ var init_Macro = __esm(() => {
               result += `${macro}`;
             } else {
               result += macro.toMacro();
+              if (result.endsWith("}")) {
+                console.warn("what", macro);
+              }
             }
           }
         }
@@ -165,17 +178,15 @@ function randomUUID() {
   }
   return array;
 }
-function add(object) {
-  if (object === undefined) {
-    return {};
-  }
-  const output = {};
-  for (const [key, value] of object.entries()) {
+function add(obj) {
+  const filtered = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
     if (value !== undefined) {
-      output[key] = value;
+      filtered[key] = value;
     }
   }
-  return output;
+  return filtered;
 }
 async function safeWrite(...args) {
   if (typeof args[0] !== "string")
@@ -193,6 +204,14 @@ function formatDebugString(className, args, body, currentIndent) {
     argsString = args;
   } else if (Array.isArray(args)) {
     argsString = args.map((arg) => util.inspect(arg, options)).join(", ");
+    if (argsString.includes(`
+`)) {
+      argsString = `
+${nextIndent}${args.map((arg) => util.inspect(arg, options).replaceAll(`
+`, `
+${nextIndent}`)).join(`,
+${nextIndent}`)}`;
+    }
   } else if (args && typeof args === "object") {
     argsString = Object.entries(args).map(([key, value]) => `${key}: ${util.inspect(value, options)}`).join(", ");
   } else {
@@ -443,1214 +462,1215 @@ function hasContext() {
 }
 var _context;
 
-// src/variables/nbt/grammar.ts
-function id(d) {
-  return d[0];
+// src/arguments/basics.ts
+var init_basics = __esm(() => {
+  init_arguments();
+});
+// src/pack/packType.ts
+var PACK_TYPE_BRAND, PackType;
+var init_packType = __esm(() => {
+  PACK_TYPE_BRAND = Symbol.for("sandstone.PackType");
+  PackType = class PackType {
+    [PACK_TYPE_BRAND] = true;
+    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;
+    }
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[PACK_TYPE_BRAND] === true;
+    }
+  };
+});
+
+// src/pack/dependencies.ts
+var DataPackDependencies, ResourcePackDependencies;
+var init_dependencies = __esm(() => {
+  init_packType();
+  DataPackDependencies = class DataPackDependencies extends PackType {
+    constructor() {
+      super("datapack_dependencies", "saves/$worldName$/datapacks", "world/datapacks", "datapacks", "server", false, undefined, false);
+    }
+    handleOutput = async (type) => {
+      if (type === "output") {}
+    };
+  };
+  ResourcePackDependencies = class ResourcePackDependencies extends PackType {
+    constructor() {
+      super("resourcepack_dependencies", "resourcepacks", "dependency_resources", "resourcepacks", "client", false, undefined, false);
+    }
+    handleOutput = async (type) => {
+      if (type === "output") {}
+    };
+  };
+});
+
+// src/variables/Coordinates.ts
+import { inspect as inspect3 } from "util";
+function relative(...coordinates) {
+  if (coordinates.length === 0) {
+    return new VectorClass(["~", "~", "~"]);
+  }
+  if (coordinates.length === 1) {
+    return `~${coordinates[0] || ""}`;
+  }
+  return new VectorClass(coordinates.map((coord) => `~${coord || ""}`));
 }
-var isCompoundSymbol, grammar, grammar_default;
-var init_grammar = __esm(() => {
-  isCompoundSymbol = Symbol("isCompound");
-  grammar = {
-    Lexer: undefined,
-    ParserRules: [
-      { name: "_$ebnf$1", symbols: [] },
-      { name: "_$ebnf$1", symbols: ["_$ebnf$1", "wschar"], postprocess: (d) => d[0].concat([d[1]]) },
-      {
-        name: "_",
-        symbols: ["_$ebnf$1"],
-        postprocess(d) {
-          return null;
-        }
-      },
-      { name: "__$ebnf$1", symbols: ["wschar"] },
-      { name: "__$ebnf$1", symbols: ["__$ebnf$1", "wschar"], postprocess: (d) => d[0].concat([d[1]]) },
-      {
-        name: "__",
-        symbols: ["__$ebnf$1"],
-        postprocess(d) {
-          return null;
+var VECTOR_CLASS_BRAND, VectorClass;
+var init_Coordinates = __esm(() => {
+  VECTOR_CLASS_BRAND = Symbol.for("sandstone.VectorClass");
+  VectorClass = class VectorClass {
+    [VECTOR_CLASS_BRAND] = true;
+    values;
+    constructor(values) {
+      if (!Array.isArray(values) || !values.every((i) => typeof i === "string")) {
+        throw new Error(`Expected array of string for Vector values, got ${inspect3(values)}`);
+      }
+      this.values = values;
+    }
+    toString() {
+      return this.values.join(" ");
+    }
+    toJSON() {
+      return this.toString();
+    }
+    toNBT() {
+      return this.toString();
+    }
+    [Symbol.iterator]() {
+      return this.values[Symbol.iterator]();
+    }
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[VECTOR_CLASS_BRAND] === true;
+    }
+  };
+});
+
+// src/variables/parsers.ts
+function coordinatesParser(coordinates) {
+  if (Array.isArray(coordinates)) {
+    if (coordinates.length === 3 || coordinates.length === 2) {
+      return new VectorClass(coordinates.map((coord) => {
+        if (typeof coord === "string") {
+          return coord;
         }
-      },
-      { name: "wschar", symbols: [/[ \t\n\v\f]/], postprocess: id },
-      { name: "unsigned_int$ebnf$1", symbols: [/[0-9]/] },
-      { name: "unsigned_int$ebnf$1", symbols: ["unsigned_int$ebnf$1", /[0-9]/], postprocess: (d) => d[0].concat([d[1]]) },
-      {
-        name: "unsigned_int",
-        symbols: ["unsigned_int$ebnf$1"],
-        postprocess(d) {
-          return Number.parseInt(d[0].join(""));
+        if (typeof coord === "number") {
+          return `${coord}`;
         }
-      },
-      { name: "int$ebnf$1$subexpression$1", symbols: [{ literal: "-" }] },
-      { name: "int$ebnf$1$subexpression$1", symbols: [{ literal: "+" }] },
-      { name: "int$ebnf$1", symbols: ["int$ebnf$1$subexpression$1"], postprocess: id },
-      { name: "int$ebnf$1", symbols: [], postprocess: () => null },
-      { name: "int$ebnf$2", symbols: [/[0-9]/] },
-      { name: "int$ebnf$2", symbols: ["int$ebnf$2", /[0-9]/], postprocess: (d) => d[0].concat([d[1]]) },
-      {
-        name: "int",
-        symbols: ["int$ebnf$1", "int$ebnf$2"],
-        postprocess(d) {
-          if (d[0]) {
-            return Number.parseInt(d[0][0] + d[1].join(""));
-          }
-          return Number.parseInt(d[1].join(""));
+        if ("toMacro" in coord) {
+          return coord.toMacro();
         }
-      },
-      { name: "unsigned_decimal$ebnf$1", symbols: [/[0-9]/] },
-      {
-        name: "unsigned_decimal$ebnf$1",
-        symbols: ["unsigned_decimal$ebnf$1", /[0-9]/],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      { name: "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1", symbols: [/[0-9]/] },
-      {
-        name: "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1",
-        symbols: ["unsigned_decimal$ebnf$2$subexpression$1$ebnf$1", /[0-9]/],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      {
-        name: "unsigned_decimal$ebnf$2$subexpression$1",
-        symbols: [{ literal: "." }, "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1"]
-      },
-      { name: "unsigned_decimal$ebnf$2", symbols: ["unsigned_decimal$ebnf$2$subexpression$1"], postprocess: id },
-      { name: "unsigned_decimal$ebnf$2", symbols: [], postprocess: () => null },
-      {
-        name: "unsigned_decimal",
-        symbols: ["unsigned_decimal$ebnf$1", "unsigned_decimal$ebnf$2"],
-        postprocess(d) {
-          return Number.parseFloat(d[0].join("") + (d[1] ? `.${d[1][1].join("")}` : ""));
+        throw new Error(`[coordinatesParser] Unsupported vector component ${coord}`);
+      }));
+    }
+    throw new Error(`[coordinatesParser] Unsupported vector size ${coordinates.length}`);
+  } else {
+    return coordinates;
+  }
+}
+function rotationParser(rotation) {
+  if (Array.isArray(rotation)) {
+    if (rotation.length === 2) {
+      return new VectorClass(rotation.map((coord) => {
+        if (typeof coord === "string") {
+          return coord;
         }
-      },
-      { name: "decimal$ebnf$1", symbols: [{ literal: "-" }], postprocess: id },
-      { name: "decimal$ebnf$1", symbols: [], postprocess: () => null },
-      { name: "decimal$ebnf$2", symbols: [/[0-9]/] },
-      { name: "decimal$ebnf$2", symbols: ["decimal$ebnf$2", /[0-9]/], postprocess: (d) => d[0].concat([d[1]]) },
-      { name: "decimal$ebnf$3$subexpression$1$ebnf$1", symbols: [/[0-9]/] },
-      {
-        name: "decimal$ebnf$3$subexpression$1$ebnf$1",
-        symbols: ["decimal$ebnf$3$subexpression$1$ebnf$1", /[0-9]/],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      { name: "decimal$ebnf$3$subexpression$1", symbols: [{ literal: "." }, "decimal$ebnf$3$subexpression$1$ebnf$1"] },
-      { name: "decimal$ebnf$3", symbols: ["decimal$ebnf$3$subexpression$1"], postprocess: id },
-      { name: "decimal$ebnf$3", symbols: [], postprocess: () => null },
-      {
-        name: "decimal",
-        symbols: ["decimal$ebnf$1", "decimal$ebnf$2", "decimal$ebnf$3"],
-        postprocess(d) {
-          return Number.parseFloat((d[0] || "") + d[1].join("") + (d[2] ? `.${d[2][1].join("")}` : ""));
+        if (typeof coord === "number") {
+          return `${coord}`;
         }
-      },
-      {
-        name: "percentage",
-        symbols: ["decimal", { literal: "%" }],
-        postprocess(d) {
-          return d[0] / 100;
+        if ("toMacro" in coord) {
+          return coord.toMacro();
         }
-      },
-      { name: "jsonfloat$ebnf$1", symbols: [{ literal: "-" }], postprocess: id },
-      { name: "jsonfloat$ebnf$1", symbols: [], postprocess: () => null },
-      { name: "jsonfloat$ebnf$2", symbols: [/[0-9]/] },
-      { name: "jsonfloat$ebnf$2", symbols: ["jsonfloat$ebnf$2", /[0-9]/], postprocess: (d) => d[0].concat([d[1]]) },
-      { name: "jsonfloat$ebnf$3$subexpression$1$ebnf$1", symbols: [/[0-9]/] },
-      {
-        name: "jsonfloat$ebnf$3$subexpression$1$ebnf$1",
-        symbols: ["jsonfloat$ebnf$3$subexpression$1$ebnf$1", /[0-9]/],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      {
-        name: "jsonfloat$ebnf$3$subexpression$1",
-        symbols: [{ literal: "." }, "jsonfloat$ebnf$3$subexpression$1$ebnf$1"]
-      },
-      { name: "jsonfloat$ebnf$3", symbols: ["jsonfloat$ebnf$3$subexpression$1"], postprocess: id },
-      { name: "jsonfloat$ebnf$3", symbols: [], postprocess: () => null },
-      { name: "jsonfloat$ebnf$4$subexpression$1$ebnf$1", symbols: [/[+-]/], postprocess: id },
-      { name: "jsonfloat$ebnf$4$subexpression$1$ebnf$1", symbols: [], postprocess: () => null },
-      { name: "jsonfloat$ebnf$4$subexpression$1$ebnf$2", symbols: [/[0-9]/] },
-      {
-        name: "jsonfloat$ebnf$4$subexpression$1$ebnf$2",
-        symbols: ["jsonfloat$ebnf$4$subexpression$1$ebnf$2", /[0-9]/],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      {
-        name: "jsonfloat$ebnf$4$subexpression$1",
-        symbols: [/[eE]/, "jsonfloat$ebnf$4$subexpression$1$ebnf$1", "jsonfloat$ebnf$4$subexpression$1$ebnf$2"]
-      },
-      { name: "jsonfloat$ebnf$4", symbols: ["jsonfloat$ebnf$4$subexpression$1"], postprocess: id },
-      { name: "jsonfloat$ebnf$4", symbols: [], postprocess: () => null },
-      {
-        name: "jsonfloat",
-        symbols: ["jsonfloat$ebnf$1", "jsonfloat$ebnf$2", "jsonfloat$ebnf$3", "jsonfloat$ebnf$4"],
-        postprocess(d) {
-          return Number.parseFloat((d[0] || "") + d[1].join("") + (d[2] ? `.${d[2][1].join("")}` : "") + (d[3] ? `e${d[3][1] || "+"}${d[3][2].join("")}` : ""));
-        }
-      },
-      { name: "dqstring$ebnf$1", symbols: [] },
-      { name: "dqstring$ebnf$1", symbols: ["dqstring$ebnf$1", "dstrchar"], postprocess: (d) => d[0].concat([d[1]]) },
-      {
-        name: "dqstring",
-        symbols: [{ literal: '"' }, "dqstring$ebnf$1", { literal: '"' }],
-        postprocess(d) {
-          return d[1].join("");
-        }
-      },
-      { name: "sqstring$ebnf$1", symbols: [] },
-      { name: "sqstring$ebnf$1", symbols: ["sqstring$ebnf$1", "sstrchar"], postprocess: (d) => d[0].concat([d[1]]) },
-      {
-        name: "sqstring",
-        symbols: [{ literal: "'" }, "sqstring$ebnf$1", { literal: "'" }],
-        postprocess(d) {
-          return d[1].join("");
-        }
-      },
-      { name: "btstring$ebnf$1", symbols: [] },
-      { name: "btstring$ebnf$1", symbols: ["btstring$ebnf$1", /[^`]/], postprocess: (d) => d[0].concat([d[1]]) },
-      {
-        name: "btstring",
-        symbols: [{ literal: "`" }, "btstring$ebnf$1", { literal: "`" }],
-        postprocess(d) {
-          return d[1].join("");
-        }
-      },
-      { name: "dstrchar", symbols: [/[^\\"\n]/], postprocess: id },
-      {
-        name: "dstrchar",
-        symbols: [{ literal: "\\" }, "strescape"],
-        postprocess(d) {
-          return JSON.parse(`"${d.join("")}"`);
-        }
-      },
-      { name: "sstrchar", symbols: [/[^\\'\n]/], postprocess: id },
-      {
-        name: "sstrchar",
-        symbols: [{ literal: "\\" }, "strescape"],
-        postprocess(d) {
-          return JSON.parse(`"${d.join("")}"`);
-        }
-      },
-      { name: "sstrchar$string$1", symbols: [{ literal: "\\" }, { literal: "'" }], postprocess: (d) => d.join("") },
-      {
-        name: "sstrchar",
-        symbols: ["sstrchar$string$1"],
-        postprocess(d) {
-          return "'";
-        }
-      },
-      { name: "strescape", symbols: [/["\\/bfnrt]/], postprocess: id },
-      {
-        name: "strescape",
-        symbols: [{ literal: "u" }, /[a-fA-F0-9]/, /[a-fA-F0-9]/, /[a-fA-F0-9]/, /[a-fA-F0-9]/],
-        postprocess(d) {
-          return d.join("");
-        }
-      },
-      { name: "expression$subexpression$1", symbols: ["string"] },
-      { name: "expression$subexpression$1", symbols: ["typedNum"] },
-      { name: "expression$subexpression$1", symbols: ["number"] },
-      { name: "expression$subexpression$1", symbols: ["boolean"] },
-      { name: "expression$subexpression$1", symbols: ["byteArray"] },
-      { name: "expression$subexpression$1", symbols: ["intArray"] },
-      { name: "expression$subexpression$1", symbols: ["longArray"] },
-      { name: "expression$subexpression$1", symbols: ["array"] },
-      { name: "expression$subexpression$1", symbols: ["object"] },
-      {
-        name: "expression",
-        symbols: ["expression$subexpression$1"],
-        postprocess: (data) => data[0][0]
-      },
-      {
-        name: "object",
-        symbols: [{ literal: "{" }, "objectInner", { literal: "}" }],
-        postprocess: (data) => Object.fromEntries([
-          ...data[1].map(({ key, value }) => [key, value]),
-          [isCompoundSymbol, true]
-        ])
-      },
-      { name: "objectInner", symbols: ["_"], postprocess: (data) => [] },
-      { name: "objectInner$ebnf$1", symbols: [] },
-      { name: "objectInner$ebnf$1$subexpression$1", symbols: ["objectKeyValue", "_", { literal: "," }, "_"] },
-      {
-        name: "objectInner$ebnf$1",
-        symbols: ["objectInner$ebnf$1", "objectInner$ebnf$1$subexpression$1"],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      { name: "objectInner$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
-      { name: "objectInner$ebnf$2", symbols: ["objectInner$ebnf$2$subexpression$1"], postprocess: id },
-      { name: "objectInner$ebnf$2", symbols: [], postprocess: () => null },
-      {
-        name: "objectInner",
-        symbols: ["_", "objectInner$ebnf$1", "objectKeyValue", "objectInner$ebnf$2", "_"],
-        postprocess: (data) => {
-          const firstKeyValues = data[1].map(([keyValue]) => keyValue);
-          const keyValues = [...firstKeyValues, data[2]];
-          return keyValues;
-        }
-      },
-      { name: "objectKeyValue$ebnf$1", symbols: [/[a-zA-Z]/] },
-      {
-        name: "objectKeyValue$ebnf$1",
-        symbols: ["objectKeyValue$ebnf$1", /[a-zA-Z]/],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      {
-        name: "objectKeyValue",
-        symbols: ["objectKeyValue$ebnf$1", "_", { literal: ":" }, "_", "expression"],
-        postprocess: (data) => ({ key: data[0].join(""), value: data[4] })
-      },
-      {
-        name: "objectKeyValue",
-        symbols: ["string", "_", { literal: ":" }, "_", "expression"],
-        postprocess: (data) => ({ key: data[0].value, value: data[4] })
-      },
-      { name: "array$macrocall$2", symbols: ["expression"] },
-      { name: "array$macrocall$1", symbols: ["_"], postprocess: () => [] },
-      { name: "array$macrocall$1$ebnf$1", symbols: [] },
-      { name: "array$macrocall$1$ebnf$1$subexpression$1", symbols: ["array$macrocall$2", "_", { literal: "," }, "_"] },
-      {
-        name: "array$macrocall$1$ebnf$1",
-        symbols: ["array$macrocall$1$ebnf$1", "array$macrocall$1$ebnf$1$subexpression$1"],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      { name: "array$macrocall$1$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
-      { name: "array$macrocall$1$ebnf$2", symbols: ["array$macrocall$1$ebnf$2$subexpression$1"], postprocess: id },
-      { name: "array$macrocall$1$ebnf$2", symbols: [], postprocess: () => null },
-      {
-        name: "array$macrocall$1",
-        symbols: ["_", "array$macrocall$1$ebnf$1", "array$macrocall$2", "array$macrocall$1$ebnf$2", "_"],
-        postprocess: (data) => {
-          const firstArray = data[1].map(([expression]) => expression[0]);
-          return [...firstArray, data[2][0]];
-        }
-      },
-      {
-        name: "array",
-        symbols: [{ literal: "[" }, "array$macrocall$1", { literal: "]" }],
-        postprocess: (data) => data[1]
-      },
-      { name: "byteArray$macrocall$2", symbols: ["typedByte"] },
-      { name: "byteArray$macrocall$1", symbols: ["_"], postprocess: () => [] },
-      { name: "byteArray$macrocall$1$ebnf$1", symbols: [] },
-      {
-        name: "byteArray$macrocall$1$ebnf$1$subexpression$1",
-        symbols: ["byteArray$macrocall$2", "_", { literal: "," }, "_"]
-      },
-      {
-        name: "byteArray$macrocall$1$ebnf$1",
-        symbols: ["byteArray$macrocall$1$ebnf$1", "byteArray$macrocall$1$ebnf$1$subexpression$1"],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      { name: "byteArray$macrocall$1$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
-      {
-        name: "byteArray$macrocall$1$ebnf$2",
-        symbols: ["byteArray$macrocall$1$ebnf$2$subexpression$1"],
-        postprocess: id
-      },
-      { name: "byteArray$macrocall$1$ebnf$2", symbols: [], postprocess: () => null },
-      {
-        name: "byteArray$macrocall$1",
-        symbols: ["_", "byteArray$macrocall$1$ebnf$1", "byteArray$macrocall$2", "byteArray$macrocall$1$ebnf$2", "_"],
-        postprocess: (data) => {
-          const firstArray = data[1].map(([expression]) => expression[0]);
-          return [...firstArray, data[2][0]];
+        throw new Error(`[rotationParser] Unsupported vector component ${coord}`);
+      }));
+    }
+    throw new Error(`[rotationParser] Unsupported vector size ${rotation.length}`);
+  } else {
+    return rotation;
+  }
+}
+function targetParser(target) {
+  if (target === undefined) {
+    throw new Error("Target cannot be undefined.");
+  }
+  if (typeof target === "string") {
+    return target;
+  }
+  if (target._toSelector) {
+    return target._toSelector();
+  }
+  if (target.toMacro) {
+    return target;
+  }
+  return target.toString();
+}
+var sanitizeValue = (core, value) => {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isMacroArgument(core, value)) {
+    return value.toMacro();
+  }
+  if (Number.isFinite(value)) {
+    return value.toString();
+  }
+  return "";
+}, rangeParser = (core, range) => {
+  if (Array.isArray(range)) {
+    return `${sanitizeValue(core, range[0])}..${sanitizeValue(core, range[1])}`;
+  }
+  return range.toString();
+}, structureRotationParser = (rotation) => {
+  if (!rotation) {
+    return "none";
+  }
+  if (typeof rotation === "object") {
+    return rotation;
+  }
+  const numToLiteral = (angle) => {
+    switch (angle) {
+      case 0:
+        return "none";
+      case 90:
+        return "clockwise_90";
+      case 180:
+        return "180";
+      case 270:
+        return "counterclockwise_90";
+      case -90:
+        return "counterclockwise_90";
+      case -180:
+        return "180";
+      case -270:
+        return "clockwise_90";
+      default: {
+        if (!Number.isInteger(angle / 90)) {
+          throw new Error("Structure rotation must be in increments of 90!");
         }
-      },
-      {
-        name: "byteArray",
-        symbols: [
-          { literal: "[" },
-          "_",
-          { literal: "B" },
-          "_",
-          { literal: ";" },
-          "byteArray$macrocall$1",
-          { literal: "]" }
-        ],
-        postprocess: (data) => ({ dataType: "byteArray", value: data[5] })
-      },
-      { name: "intArray$macrocall$2", symbols: ["number"] },
-      { name: "intArray$macrocall$1", symbols: ["_"], postprocess: () => [] },
-      { name: "intArray$macrocall$1$ebnf$1", symbols: [] },
-      {
-        name: "intArray$macrocall$1$ebnf$1$subexpression$1",
-        symbols: ["intArray$macrocall$2", "_", { literal: "," }, "_"]
-      },
-      {
-        name: "intArray$macrocall$1$ebnf$1",
-        symbols: ["intArray$macrocall$1$ebnf$1", "intArray$macrocall$1$ebnf$1$subexpression$1"],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      { name: "intArray$macrocall$1$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
-      { name: "intArray$macrocall$1$ebnf$2", symbols: ["intArray$macrocall$1$ebnf$2$subexpression$1"], postprocess: id },
-      { name: "intArray$macrocall$1$ebnf$2", symbols: [], postprocess: () => null },
-      {
-        name: "intArray$macrocall$1",
-        symbols: ["_", "intArray$macrocall$1$ebnf$1", "intArray$macrocall$2", "intArray$macrocall$1$ebnf$2", "_"],
-        postprocess: (data) => {
-          const firstArray = data[1].map(([expression]) => expression[0]);
-          return [...firstArray, data[2][0]];
-        }
-      },
-      {
-        name: "intArray",
-        symbols: [
-          { literal: "[" },
-          "_",
-          { literal: "I" },
-          "_",
-          { literal: ";" },
-          "intArray$macrocall$1",
-          { literal: "]" }
-        ],
-        postprocess: (data) => ({ dataType: "intArray", value: data[5] })
-      },
-      { name: "longArray$macrocall$2", symbols: ["typedLong"] },
-      { name: "longArray$macrocall$1", symbols: ["_"], postprocess: () => [] },
-      { name: "longArray$macrocall$1$ebnf$1", symbols: [] },
-      {
-        name: "longArray$macrocall$1$ebnf$1$subexpression$1",
-        symbols: ["longArray$macrocall$2", "_", { literal: "," }, "_"]
-      },
-      {
-        name: "longArray$macrocall$1$ebnf$1",
-        symbols: ["longArray$macrocall$1$ebnf$1", "longArray$macrocall$1$ebnf$1$subexpression$1"],
-        postprocess: (d) => d[0].concat([d[1]])
-      },
-      { name: "longArray$macrocall$1$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
-      {
-        name: "longArray$macrocall$1$ebnf$2",
-        symbols: ["longArray$macrocall$1$ebnf$2$subexpression$1"],
-        postprocess: id
-      },
-      { name: "longArray$macrocall$1$ebnf$2", symbols: [], postprocess: () => null },
-      {
-        name: "longArray$macrocall$1",
-        symbols: ["_", "longArray$macrocall$1$ebnf$1", "longArray$macrocall$2", "longArray$macrocall$1$ebnf$2", "_"],
-        postprocess: (data) => {
-          const firstArray = data[1].map(([expression]) => expression[0]);
-          return [...firstArray, data[2][0]];
-        }
-      },
-      {
-        name: "longArray",
-        symbols: [
-          { literal: "[" },
-          "_",
-          { literal: "L" },
-          "_",
-          { literal: ";" },
-          "longArray$macrocall$1",
-          { literal: "]" }
-        ],
-        postprocess: (data) => ({ dataType: "longArray", value: data[5] })
-      },
-      { name: "string$subexpression$1", symbols: ["dqstring"] },
-      { name: "string$subexpression$1", symbols: ["sqstring"] },
-      {
-        name: "string",
-        symbols: ["string$subexpression$1"],
-        postprocess: (data) => ({ dataType: "string", value: data[0][0] })
-      },
-      { name: "typedNum$subexpression$1", symbols: ["typedByte"] },
-      { name: "typedNum$subexpression$1", symbols: ["typedShort"] },
-      { name: "typedNum$subexpression$1", symbols: ["typedLong"] },
-      { name: "typedNum$subexpression$1", symbols: ["typedFloat"] },
-      { name: "typedNum", symbols: ["typedNum$subexpression$1"], postprocess: (data) => data[0][0] },
-      {
-        name: "typedByte$subexpression$1",
-        symbols: [/[bB]/],
-        postprocess(d) {
-          return d.join("");
-        }
-      },
-      {
-        name: "typedByte",
-        symbols: ["int", "typedByte$subexpression$1"],
-        postprocess: (data) => ({ dataType: "byte", value: data[0] })
-      },
-      {
-        name: "typedShort$subexpression$1",
-        symbols: [/[sS]/],
-        postprocess(d) {
-          return d.join("");
-        }
-      },
-      {
-        name: "typedShort",
-        symbols: ["int", "typedShort$subexpression$1"],
-        postprocess: (data) => ({ dataType: "short", value: data[0] })
-      },
-      {
-        name: "typedLong$subexpression$1",
-        symbols: [/[lL]/],
-        postprocess(d) {
-          return d.join("");
-        }
-      },
-      {
-        name: "typedLong",
-        symbols: ["int", "typedLong$subexpression$1"],
-        postprocess: (data) => ({ dataType: "long", value: data[0] })
-      },
-      {
-        name: "typedFloat$subexpression$1",
-        symbols: [/[dD]/],
-        postprocess(d) {
-          return d.join("");
-        }
-      },
-      {
-        name: "typedFloat",
-        symbols: ["decimal", "typedFloat$subexpression$1"],
-        postprocess: (data) => ({ dataType: "double", value: data[0] })
-      },
-      {
-        name: "typedFloat$subexpression$2",
-        symbols: [/[fF]/],
-        postprocess(d) {
-          return d.join("");
-        }
-      },
-      {
-        name: "typedFloat",
-        symbols: ["decimal", "typedFloat$subexpression$2"],
-        postprocess: (data) => ({ dataType: "float", value: data[0] })
-      },
-      { name: "number$subexpression$1", symbols: ["decimal"] },
-      {
-        name: "number",
-        symbols: ["number$subexpression$1"],
-        postprocess: (data) => ({ dataType: "number", value: data[0][0] })
-      },
-      {
-        name: "boolean$subexpression$1$string$1",
-        symbols: [{ literal: "t" }, { literal: "r" }, { literal: "u" }, { literal: "e" }],
-        postprocess: (d) => d.join("")
-      },
-      { name: "boolean$subexpression$1", symbols: ["boolean$subexpression$1$string$1"] },
-      {
-        name: "boolean$subexpression$1$string$2",
-        symbols: [{ literal: "f" }, { literal: "a" }, { literal: "l" }, { literal: "s" }, { literal: "e" }],
-        postprocess: (d) => d.join("")
-      },
-      { name: "boolean$subexpression$1", symbols: ["boolean$subexpression$1$string$2"] },
-      {
-        name: "boolean",
-        symbols: ["boolean$subexpression$1"],
-        postprocess: (data) => ({ dataType: "boolean", value: data[0].join("") === "true" })
+        angle %= 360;
+        angle = (angle + 360) % 360;
+        if (angle > 180)
+          angle -= 360;
+        return numToLiteral(angle);
       }
-    ],
-    ParserStart: "expression"
+    }
   };
-  grammar_default = grammar;
+  if (typeof rotation === "number") {
+    return numToLiteral(rotation);
+  }
+  if (rotation === "clockwise_90" || rotation === "counterclockwise_90") {
+    return rotation;
+  }
+  return numToLiteral(Number(rotation));
+}, structureMirrorParser = (mirror) => {
+  if (typeof mirror === "object") {
+    return mirror.toMacro();
+  }
+  if (typeof mirror === "string") {
+    const lastCharacter = mirror.slice(0, -1);
+    if (lastCharacter === "x") {
+      return "left_right";
+    }
+    if (lastCharacter === "z") {
+      return "front_back";
+    }
+    return mirror;
+  }
+  if (mirror) {
+    return "left_right";
+  }
+  return "none";
+};
+var init_parsers = __esm(() => {
+  init_Macro();
+  init_Coordinates();
 });
 
-// src/variables/nbt/parser.ts
-import nearley from "nearley";
-function isCompoundNbt(nbt) {
-  return !!nbt[isCompoundSymbol];
-}
-function parseRaw(nbt) {
-  const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar_default));
-  parser.feed(nbt);
-  parser.finish();
-  return parser.results[0];
+// src/commands/helpers.ts
+class FinalCommandOutput {
+  node;
+  constructor(node) {
+    this.node = node;
+  }
 }
-function parseExpression(NBT, nbt) {
-  if (Array.isArray(nbt)) {
-    return nbt.map((x) => parseExpression(NBT, x));
+
+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;
   }
-  if (typeof nbt === "object") {
-    if (isCompoundNbt(nbt)) {
-      return Object.keys(nbt).reduce((acc, key) => {
-        acc[key] = parseExpression(NBT, nbt[key]);
-        return acc;
-      }, {});
+  getNode = () => {
+    if (this.previousNode) {
+      return this.previousNode;
     }
-    switch (nbt.dataType) {
-      case "byte":
-        return NBT.byte(nbt.value);
-      case "short":
-        return NBT.short(nbt.value);
-      case "long":
-        return NBT.long(nbt.value);
-      case "float":
-        return NBT.float(nbt.value);
-      case "double":
-        return NBT.double(nbt.value);
-      case "number":
-        return nbt.value;
-      case "string":
-        return nbt.value;
-      case "byteArray":
-        return NBT.byteArray(nbt.value.map((x) => x.value));
-      case "intArray":
-        return NBT.intArray(nbt.value.map((x) => x.value));
-      case "longArray":
-        return NBT.longArray(nbt.value.map((x) => x.value));
-    }
-  }
-  throw new Error(`Unrecognized data type: ${nbt.dataType}`);
-}
-function parseNBT(NBT, nbt) {
-  const rawResult = parseRaw(nbt);
-  return parseExpression(NBT, rawResult);
-}
-var init_parser = __esm(() => {
-  init_grammar();
-});
-
-// src/variables/nbt/NBTs.ts
-import * as util3 from "util";
-function customNumber(num, _class) {
-  if (Array.isArray(num)) {
-    return num.map((n) => new _class(n));
-  }
-  return new _class(num);
-}
-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("");
-  return parseNBT(NBT, result);
-}
-var N_B_T_CLASS_BRAND, NBTClass, N_B_T_PRIMITIVE_BRAND, NBTPrimitive, NBTLong, NBTByte, NBTShort, NBTFloat, NBTInt, NBTDouble, N_B_T_TYPED_ARRAY_BRAND, NBTTypedArray, NBTLongArray, NBTByteArray, NBTIntArray, NotNBT, NBTAnyValue, NBT, nbtStringifier = (nbt) => {
-  if (nbt === null || nbt === undefined) {
-    throw new Error("Nullish nbt values are not allowed");
-  }
-  if (typeof nbt === "number") {
-    return `${nbt}d`;
-  }
-  if (typeof nbt === "boolean") {
-    return nbt.toString();
-  }
-  if (typeof nbt === "string") {
-    const inspectedStr = util3.inspect(nbt, {
-      breakLength: Number.POSITIVE_INFINITY,
-      compact: true,
-      maxStringLength: Number.POSITIVE_INFINITY,
-      depth: Number.POSITIVE_INFINITY
-    });
-    if (inspectedStr[0] === "`") {
-      return JSON.stringify(nbt);
-    }
-    return inspectedStr;
-  }
-  if (Array.isArray(nbt)) {
-    const itemsStr = nbt.map(nbtStringifier).join(",");
-    return `[${itemsStr}]`;
-  }
-  if (nbt instanceof NBTClass) {
-    return nbt[util3.inspect.custom]();
-  }
-  if (typeof nbt === "object" || typeof nbt === "function") {
-    let failedMacro = false;
-    if ("toMacro" in nbt) {
-      const macro = nbt.toMacro();
-      if (macro === "$()") {
-        failedMacro = true;
-      } else {
-        return macro;
-      }
-    }
-    if ("toNBT" in nbt) {
-      return nbt.toNBT();
-    } else if (failedMacro) {
-      throw new Error("[nbtStringifier] 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.`);
-    }
-    if (nbt.constructor.name !== "Object") {
-      if ("toString" in nbt) {
-        return `${toString}`;
-      } 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`);
-      }
-    }
-  }
-  const objectStr = Object.entries(nbt).map(([key, value]) => `${key}:${nbtStringifier(value)}`).join(",");
-  return `{${objectStr}}`;
-};
-var init_NBTs = __esm(() => {
-  init_utils();
-  init_parser();
-  N_B_T_CLASS_BRAND = Symbol.for("sandstone.NBTClass");
-  NBTClass = class NBTClass {
-    [N_B_T_CLASS_BRAND] = true;
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[N_B_T_CLASS_BRAND] === true;
+    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");
   };
-  N_B_T_PRIMITIVE_BRAND = Symbol.for("sandstone.NBTPrimitive");
-  NBTPrimitive = class NBTPrimitive extends NBTClass {
-    [N_B_T_PRIMITIVE_BRAND] = true;
-    value;
-    unit;
-    constructor(value, unit) {
-      super();
-      this.value = value;
-      this.unit = unit;
+  finalCommand = (args, currentNode) => {
+    const node = currentNode ?? this.getNode();
+    if (args) {
+      node.args.push(...args);
     }
-    [util3.inspect.custom] = () => `${this.value}${this.unit}`;
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[N_B_T_PRIMITIVE_BRAND] === true;
+    if (this.autoCommit) {
+      node.commit();
     }
+    return new FinalCommandOutput(node);
   };
-  NBTLong = class NBTLong extends NBTPrimitive {
-    constructor(value) {
-      super(value, "l");
+  subCommand = (args, NextArgumentType, executable = false, additionalNextArgs = [], currentNode) => {
+    const node = currentNode ?? this.getNode();
+    if (args) {
+      node.args.push(...args);
     }
-  };
-  NBTByte = class NBTByte extends NBTPrimitive {
-    constructor(value) {
-      super(value, "b");
+    if (executable && this.autoCommit) {
+      node.commit();
     }
+    return new NextArgumentType(this.sandstonePack, node, this.autoCommit, ...additionalNextArgs);
   };
-  NBTShort = class NBTShort extends NBTPrimitive {
-    constructor(value) {
-      super(value, "s");
-    }
+}
+
+// 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();
+  PlaceCommandNode = class PlaceCommandNode extends CommandNode {
+    command = "place";
   };
-  NBTFloat = class NBTFloat extends NBTPrimitive {
-    constructor(value) {
-      super(value, "f");
-    }
+  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]
+      ]);
+    };
   };
-  NBTInt = class NBTInt extends NBTPrimitive {
-    constructor(value) {
-      super(value, "i");
-    }
+});
+
+// src/commands/implementations/entity/damage.ts
+var DamageCommandNode, DamageCauseCommand, DamageSourceCommand, DamageCommand;
+var init_damage = __esm(() => {
+  init_nodes();
+  init_parsers();
+  DamageCommandNode = class DamageCommandNode extends CommandNode {
+    command = "damage";
   };
-  NBTDouble = class NBTDouble extends NBTPrimitive {
-    constructor(value) {
-      super(value, "d");
-    }
+  DamageCauseCommand = class DamageCauseCommand extends CommandArguments {
+    from = (cause) => this.finalCommand(["from", targetParser(cause)]);
   };
-  N_B_T_TYPED_ARRAY_BRAND = Symbol.for("sandstone.NBTTypedArray");
-  NBTTypedArray = class NBTTypedArray extends NBTClass {
-    [N_B_T_TYPED_ARRAY_BRAND] = true;
-    values;
-    unit;
-    constructor(values, unit) {
-      super();
-      this.values = values;
-      this.unit = unit;
-    }
-    [util3.inspect.custom] = () => `[${this.unit};${this.values.length === 0 ? "" : this.values.join(",")}]`;
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[N_B_T_TYPED_ARRAY_BRAND] === true;
-    }
+  DamageSourceCommand = class DamageSourceCommand extends CommandArguments {
+    by = (entity) => this.subCommand(["by", targetParser(entity)], DamageCauseCommand, true);
+    at = (position) => this.finalCommand(["at", coordinatesParser(position)]);
   };
-  NBTLongArray = class NBTLongArray extends NBTTypedArray {
-    constructor(values) {
-      super(values, "L");
-    }
+  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);
+    };
   };
-  NBTByteArray = class NBTByteArray extends NBTTypedArray {
-    constructor(values) {
-      super(values, "B");
+});
+
+// src/commands/implementations/_fake/comment.ts
+var CommentCommandNode, CommentCommand;
+var init_comment = __esm(() => {
+  init_nodes();
+  CommentCommandNode = class CommentCommandNode extends CommandNode {
+    command = "#";
+    getValue() {
+      return this.args[0].join(" ").split(`
+`).map((line) => `# ${line}`).join(`
+`);
     }
   };
-  NBTIntArray = class NBTIntArray extends NBTTypedArray {
-    constructor(values) {
-      super(values, "I");
-    }
+  CommentCommand = class CommentCommand extends CommandArguments {
+    NodeType = CommentCommandNode;
+    comment = (...comments) => this.finalCommand([comments]);
   };
-  NotNBT = class NotNBT extends NBTClass {
-    nbt;
-    constructor(nbt) {
-      super();
-      this.nbt = nbt;
-    }
-    [util3.inspect.custom] = () => `!${nbtStringifier(this.nbt)}`;
+});
+
+// src/commands/implementations/_fake/raw.ts
+var RawCommandNode, RawCommand;
+var init_raw = __esm(() => {
+  init_nodes();
+  RawCommandNode = class RawCommandNode extends CommandNode {
+    command = "";
   };
-  NBTAnyValue = class NBTAnyValue extends NBTPrimitive {
+  RawCommand = class RawCommand extends CommandArguments {
+    NodeType = RawCommandNode;
+    raw = (...args) => this.finalCommand([...args]);
   };
-  NBT = makeCallable({
-    int: (num) => customNumber(num, NBTInt),
-    float: (num) => customNumber(num, NBTFloat),
-    double: (num) => customNumber(num, NBTDouble),
-    byte: (num) => customNumber(num, NBTByte),
-    short: (num) => customNumber(num, NBTShort),
-    long: (num) => customNumber(num, NBTLong),
-    intArray: (numbers) => new NBTIntArray(numbers),
-    longArray: (numbers) => new NBTLongArray(numbers),
-    byteArray: (numbers) => new NBTByteArray(numbers),
-    not: (nbt) => new NotNBT(nbt),
-    stringify: (nbt) => nbtStringifier(nbt),
-    parse: (nbt) => parseNBT(NBT, nbt)
-  }, dynamicNBT);
 });
 
-// src/arguments/basics.ts
-var init_basics = __esm(() => {
-  init_arguments();
-});
-// src/pack/packType.ts
-var PACK_TYPE_BRAND, PackType;
-var init_packType = __esm(() => {
-  PACK_TYPE_BRAND = Symbol.for("sandstone.PackType");
-  PackType = class PackType {
-    [PACK_TYPE_BRAND] = true;
-    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/commands/implementations/block/clone.ts
+var CloneCommandNode, CloneCommand, CloneFromDimensionCommand, CloneToDimensionCommand, CloneOptionsCommand, CloneStrictOptionsCommand, CloneModeCommand;
+var init_clone = __esm(() => {
+  init_nodes();
+  init_parsers();
+  CloneCommandNode = class CloneCommandNode extends CommandNode {
+    command = "clone";
+  };
+  CloneCommand = class CloneCommand extends CommandArguments {
+    NodeType = CloneCommandNode;
+    clone(begin, end, destination) {
+      if (begin === undefined) {
+        return this.subCommand([], CloneFromDimensionCommand, false);
+      }
+      return this.subCommand([begin, end, destination].map(coordinatesParser), CloneOptionsCommand, true);
     }
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[PACK_TYPE_BRAND] === true;
+  };
+  CloneFromDimensionCommand = class CloneFromDimensionCommand extends CommandArguments {
+    from(dimension, begin, end, destination) {
+      if (destination === undefined) {
+        return this.subCommand(["from", dimension, coordinatesParser(begin), coordinatesParser(end)], CloneToDimensionCommand, false);
+      }
+      return this.subCommand(["from", ...[begin, end, destination].map(coordinatesParser)], CloneOptionsCommand, true);
     }
   };
+  CloneToDimensionCommand = class CloneToDimensionCommand extends CommandArguments {
+    to = (dimension, destination) => this.subCommand(["to", dimension, coordinatesParser(destination)], CloneOptionsCommand, true);
+  };
+  CloneOptionsCommand = class CloneOptionsCommand extends CommandArguments {
+    replace = () => this.subCommand(["replace"], CloneModeCommand, true);
+    strict = () => this.subCommand(["strict"], CloneStrictOptionsCommand, true);
+    masked = () => this.subCommand(["masked"], CloneModeCommand, true);
+    filtered = (filter) => this.subCommand(["filtered", filter], CloneModeCommand, true);
+  };
+  CloneStrictOptionsCommand = class CloneStrictOptionsCommand extends CommandArguments {
+    replace = () => this.subCommand(["replace"], CloneModeCommand, true);
+    masked = () => this.subCommand(["masked"], CloneModeCommand, true);
+    filtered = (filter) => this.subCommand(["filtered", filter], CloneModeCommand, true);
+  };
+  CloneModeCommand = class CloneModeCommand extends CommandArguments {
+    force = () => this.finalCommand(["force"]);
+    move = () => this.finalCommand(["move"]);
+    normal = () => this.finalCommand(["normal"]);
+  };
 });
 
-// src/pack/dependencies.ts
-var DataPackDependencies, ResourcePackDependencies;
-var init_dependencies = __esm(() => {
-  init_packType();
-  DataPackDependencies = class DataPackDependencies extends PackType {
-    constructor() {
-      super("datapack_dependencies", "saves/$worldName$/datapacks", "world/datapacks", "datapacks", "server", false, undefined, false);
+// src/variables/abstractClasses.ts
+var CONDITION_CLASS_BRAND, ConditionClass, SELECTOR_PICK_CLASS_BRAND, SelectorPickClass;
+var init_abstractClasses = __esm(() => {
+  CONDITION_CLASS_BRAND = Symbol.for("sandstone.ConditionClass");
+  ConditionClass = class ConditionClass {
+    [CONDITION_CLASS_BRAND] = true;
+    _toMinecraftCondition() {
+      throw new Error("Not implemented");
+    }
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[CONDITION_CLASS_BRAND] === true;
     }
-    handleOutput = async (type) => {
-      if (type === "output") {}
-    };
   };
-  ResourcePackDependencies = class ResourcePackDependencies extends PackType {
-    constructor() {
-      super("resourcepack_dependencies", "resourcepacks", "dependency_resources", "resourcepacks", "client", false, undefined, false);
+  SELECTOR_PICK_CLASS_BRAND = Symbol.for("sandstone.SelectorPickClass");
+  SelectorPickClass = class SelectorPickClass {
+    [SELECTOR_PICK_CLASS_BRAND] = true;
+    _toSelector() {
+      throw new Error("Not implemented");
     }
-    handleOutput = async (type) => {
-      if (type === "output") {}
-    };
+    toNBT() {
+      throw new Error("Not implemented");
+    }
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[SELECTOR_PICK_CLASS_BRAND] === true;
+    }
+  };
+});
+
+// src/variables/nbt/grammar.ts
+function id(d) {
+  return d[0];
+}
+var isCompoundSymbol, grammar, grammar_default;
+var init_grammar = __esm(() => {
+  isCompoundSymbol = Symbol("isCompound");
+  grammar = {
+    Lexer: undefined,
+    ParserRules: [
+      { name: "_$ebnf$1", symbols: [] },
+      { name: "_$ebnf$1", symbols: ["_$ebnf$1", "wschar"], postprocess: (d) => d[0].concat([d[1]]) },
+      {
+        name: "_",
+        symbols: ["_$ebnf$1"],
+        postprocess(d) {
+          return null;
+        }
+      },
+      { name: "__$ebnf$1", symbols: ["wschar"] },
+      { name: "__$ebnf$1", symbols: ["__$ebnf$1", "wschar"], postprocess: (d) => d[0].concat([d[1]]) },
+      {
+        name: "__",
+        symbols: ["__$ebnf$1"],
+        postprocess(d) {
+          return null;
+        }
+      },
+      { name: "wschar", symbols: [/[ \t\n\v\f]/], postprocess: id },
+      { name: "unsigned_int$ebnf$1", symbols: [/[0-9]/] },
+      { name: "unsigned_int$ebnf$1", symbols: ["unsigned_int$ebnf$1", /[0-9]/], postprocess: (d) => d[0].concat([d[1]]) },
+      {
+        name: "unsigned_int",
+        symbols: ["unsigned_int$ebnf$1"],
+        postprocess(d) {
+          return Number.parseInt(d[0].join(""));
+        }
+      },
+      { name: "int$ebnf$1$subexpression$1", symbols: [{ literal: "-" }] },
+      { name: "int$ebnf$1$subexpression$1", symbols: [{ literal: "+" }] },
+      { name: "int$ebnf$1", symbols: ["int$ebnf$1$subexpression$1"], postprocess: id },
+      { name: "int$ebnf$1", symbols: [], postprocess: () => null },
+      { name: "int$ebnf$2", symbols: [/[0-9]/] },
+      { name: "int$ebnf$2", symbols: ["int$ebnf$2", /[0-9]/], postprocess: (d) => d[0].concat([d[1]]) },
+      {
+        name: "int",
+        symbols: ["int$ebnf$1", "int$ebnf$2"],
+        postprocess(d) {
+          if (d[0]) {
+            return Number.parseInt(d[0][0] + d[1].join(""));
+          }
+          return Number.parseInt(d[1].join(""));
+        }
+      },
+      { name: "unsigned_decimal$ebnf$1", symbols: [/[0-9]/] },
+      {
+        name: "unsigned_decimal$ebnf$1",
+        symbols: ["unsigned_decimal$ebnf$1", /[0-9]/],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      { name: "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1", symbols: [/[0-9]/] },
+      {
+        name: "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1",
+        symbols: ["unsigned_decimal$ebnf$2$subexpression$1$ebnf$1", /[0-9]/],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      {
+        name: "unsigned_decimal$ebnf$2$subexpression$1",
+        symbols: [{ literal: "." }, "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1"]
+      },
+      { name: "unsigned_decimal$ebnf$2", symbols: ["unsigned_decimal$ebnf$2$subexpression$1"], postprocess: id },
+      { name: "unsigned_decimal$ebnf$2", symbols: [], postprocess: () => null },
+      {
+        name: "unsigned_decimal",
+        symbols: ["unsigned_decimal$ebnf$1", "unsigned_decimal$ebnf$2"],
+        postprocess(d) {
+          return Number.parseFloat(d[0].join("") + (d[1] ? `.${d[1][1].join("")}` : ""));
+        }
+      },
+      { name: "decimal$ebnf$1", symbols: [{ literal: "-" }], postprocess: id },
+      { name: "decimal$ebnf$1", symbols: [], postprocess: () => null },
+      { name: "decimal$ebnf$2", symbols: [/[0-9]/] },
+      { name: "decimal$ebnf$2", symbols: ["decimal$ebnf$2", /[0-9]/], postprocess: (d) => d[0].concat([d[1]]) },
+      { name: "decimal$ebnf$3$subexpression$1$ebnf$1", symbols: [/[0-9]/] },
+      {
+        name: "decimal$ebnf$3$subexpression$1$ebnf$1",
+        symbols: ["decimal$ebnf$3$subexpression$1$ebnf$1", /[0-9]/],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      { name: "decimal$ebnf$3$subexpression$1", symbols: [{ literal: "." }, "decimal$ebnf$3$subexpression$1$ebnf$1"] },
+      { name: "decimal$ebnf$3", symbols: ["decimal$ebnf$3$subexpression$1"], postprocess: id },
+      { name: "decimal$ebnf$3", symbols: [], postprocess: () => null },
+      {
+        name: "decimal",
+        symbols: ["decimal$ebnf$1", "decimal$ebnf$2", "decimal$ebnf$3"],
+        postprocess(d) {
+          return Number.parseFloat((d[0] || "") + d[1].join("") + (d[2] ? `.${d[2][1].join("")}` : ""));
+        }
+      },
+      {
+        name: "percentage",
+        symbols: ["decimal", { literal: "%" }],
+        postprocess(d) {
+          return d[0] / 100;
+        }
+      },
+      { name: "jsonfloat$ebnf$1", symbols: [{ literal: "-" }], postprocess: id },
+      { name: "jsonfloat$ebnf$1", symbols: [], postprocess: () => null },
+      { name: "jsonfloat$ebnf$2", symbols: [/[0-9]/] },
+      { name: "jsonfloat$ebnf$2", symbols: ["jsonfloat$ebnf$2", /[0-9]/], postprocess: (d) => d[0].concat([d[1]]) },
+      { name: "jsonfloat$ebnf$3$subexpression$1$ebnf$1", symbols: [/[0-9]/] },
+      {
+        name: "jsonfloat$ebnf$3$subexpression$1$ebnf$1",
+        symbols: ["jsonfloat$ebnf$3$subexpression$1$ebnf$1", /[0-9]/],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      {
+        name: "jsonfloat$ebnf$3$subexpression$1",
+        symbols: [{ literal: "." }, "jsonfloat$ebnf$3$subexpression$1$ebnf$1"]
+      },
+      { name: "jsonfloat$ebnf$3", symbols: ["jsonfloat$ebnf$3$subexpression$1"], postprocess: id },
+      { name: "jsonfloat$ebnf$3", symbols: [], postprocess: () => null },
+      { name: "jsonfloat$ebnf$4$subexpression$1$ebnf$1", symbols: [/[+-]/], postprocess: id },
+      { name: "jsonfloat$ebnf$4$subexpression$1$ebnf$1", symbols: [], postprocess: () => null },
+      { name: "jsonfloat$ebnf$4$subexpression$1$ebnf$2", symbols: [/[0-9]/] },
+      {
+        name: "jsonfloat$ebnf$4$subexpression$1$ebnf$2",
+        symbols: ["jsonfloat$ebnf$4$subexpression$1$ebnf$2", /[0-9]/],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      {
+        name: "jsonfloat$ebnf$4$subexpression$1",
+        symbols: [/[eE]/, "jsonfloat$ebnf$4$subexpression$1$ebnf$1", "jsonfloat$ebnf$4$subexpression$1$ebnf$2"]
+      },
+      { name: "jsonfloat$ebnf$4", symbols: ["jsonfloat$ebnf$4$subexpression$1"], postprocess: id },
+      { name: "jsonfloat$ebnf$4", symbols: [], postprocess: () => null },
+      {
+        name: "jsonfloat",
+        symbols: ["jsonfloat$ebnf$1", "jsonfloat$ebnf$2", "jsonfloat$ebnf$3", "jsonfloat$ebnf$4"],
+        postprocess(d) {
+          return Number.parseFloat((d[0] || "") + d[1].join("") + (d[2] ? `.${d[2][1].join("")}` : "") + (d[3] ? `e${d[3][1] || "+"}${d[3][2].join("")}` : ""));
+        }
+      },
+      { name: "dqstring$ebnf$1", symbols: [] },
+      { name: "dqstring$ebnf$1", symbols: ["dqstring$ebnf$1", "dstrchar"], postprocess: (d) => d[0].concat([d[1]]) },
+      {
+        name: "dqstring",
+        symbols: [{ literal: '"' }, "dqstring$ebnf$1", { literal: '"' }],
+        postprocess(d) {
+          return d[1].join("");
+        }
+      },
+      { name: "sqstring$ebnf$1", symbols: [] },
+      { name: "sqstring$ebnf$1", symbols: ["sqstring$ebnf$1", "sstrchar"], postprocess: (d) => d[0].concat([d[1]]) },
+      {
+        name: "sqstring",
+        symbols: [{ literal: "'" }, "sqstring$ebnf$1", { literal: "'" }],
+        postprocess(d) {
+          return d[1].join("");
+        }
+      },
+      { name: "btstring$ebnf$1", symbols: [] },
+      { name: "btstring$ebnf$1", symbols: ["btstring$ebnf$1", /[^`]/], postprocess: (d) => d[0].concat([d[1]]) },
+      {
+        name: "btstring",
+        symbols: [{ literal: "`" }, "btstring$ebnf$1", { literal: "`" }],
+        postprocess(d) {
+          return d[1].join("");
+        }
+      },
+      { name: "dstrchar", symbols: [/[^\\"\n]/], postprocess: id },
+      {
+        name: "dstrchar",
+        symbols: [{ literal: "\\" }, "strescape"],
+        postprocess(d) {
+          return JSON.parse(`"${d.join("")}"`);
+        }
+      },
+      { name: "sstrchar", symbols: [/[^\\'\n]/], postprocess: id },
+      {
+        name: "sstrchar",
+        symbols: [{ literal: "\\" }, "strescape"],
+        postprocess(d) {
+          return JSON.parse(`"${d.join("")}"`);
+        }
+      },
+      { name: "sstrchar$string$1", symbols: [{ literal: "\\" }, { literal: "'" }], postprocess: (d) => d.join("") },
+      {
+        name: "sstrchar",
+        symbols: ["sstrchar$string$1"],
+        postprocess(d) {
+          return "'";
+        }
+      },
+      { name: "strescape", symbols: [/["\\/bfnrt]/], postprocess: id },
+      {
+        name: "strescape",
+        symbols: [{ literal: "u" }, /[a-fA-F0-9]/, /[a-fA-F0-9]/, /[a-fA-F0-9]/, /[a-fA-F0-9]/],
+        postprocess(d) {
+          return d.join("");
+        }
+      },
+      { name: "expression$subexpression$1", symbols: ["string"] },
+      { name: "expression$subexpression$1", symbols: ["typedNum"] },
+      { name: "expression$subexpression$1", symbols: ["number"] },
+      { name: "expression$subexpression$1", symbols: ["boolean"] },
+      { name: "expression$subexpression$1", symbols: ["byteArray"] },
+      { name: "expression$subexpression$1", symbols: ["intArray"] },
+      { name: "expression$subexpression$1", symbols: ["longArray"] },
+      { name: "expression$subexpression$1", symbols: ["array"] },
+      { name: "expression$subexpression$1", symbols: ["object"] },
+      {
+        name: "expression",
+        symbols: ["expression$subexpression$1"],
+        postprocess: (data) => data[0][0]
+      },
+      {
+        name: "object",
+        symbols: [{ literal: "{" }, "objectInner", { literal: "}" }],
+        postprocess: (data) => Object.fromEntries([
+          ...data[1].map(({ key, value }) => [key, value]),
+          [isCompoundSymbol, true]
+        ])
+      },
+      { name: "objectInner", symbols: ["_"], postprocess: (data) => [] },
+      { name: "objectInner$ebnf$1", symbols: [] },
+      { name: "objectInner$ebnf$1$subexpression$1", symbols: ["objectKeyValue", "_", { literal: "," }, "_"] },
+      {
+        name: "objectInner$ebnf$1",
+        symbols: ["objectInner$ebnf$1", "objectInner$ebnf$1$subexpression$1"],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      { name: "objectInner$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
+      { name: "objectInner$ebnf$2", symbols: ["objectInner$ebnf$2$subexpression$1"], postprocess: id },
+      { name: "objectInner$ebnf$2", symbols: [], postprocess: () => null },
+      {
+        name: "objectInner",
+        symbols: ["_", "objectInner$ebnf$1", "objectKeyValue", "objectInner$ebnf$2", "_"],
+        postprocess: (data) => {
+          const firstKeyValues = data[1].map(([keyValue]) => keyValue);
+          const keyValues = [...firstKeyValues, data[2]];
+          return keyValues;
+        }
+      },
+      { name: "objectKeyValue$ebnf$1", symbols: [/[a-zA-Z]/] },
+      {
+        name: "objectKeyValue$ebnf$1",
+        symbols: ["objectKeyValue$ebnf$1", /[a-zA-Z]/],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      {
+        name: "objectKeyValue",
+        symbols: ["objectKeyValue$ebnf$1", "_", { literal: ":" }, "_", "expression"],
+        postprocess: (data) => ({ key: data[0].join(""), value: data[4] })
+      },
+      {
+        name: "objectKeyValue",
+        symbols: ["string", "_", { literal: ":" }, "_", "expression"],
+        postprocess: (data) => ({ key: data[0].value, value: data[4] })
+      },
+      { name: "array$macrocall$2", symbols: ["expression"] },
+      { name: "array$macrocall$1", symbols: ["_"], postprocess: () => [] },
+      { name: "array$macrocall$1$ebnf$1", symbols: [] },
+      { name: "array$macrocall$1$ebnf$1$subexpression$1", symbols: ["array$macrocall$2", "_", { literal: "," }, "_"] },
+      {
+        name: "array$macrocall$1$ebnf$1",
+        symbols: ["array$macrocall$1$ebnf$1", "array$macrocall$1$ebnf$1$subexpression$1"],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      { name: "array$macrocall$1$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
+      { name: "array$macrocall$1$ebnf$2", symbols: ["array$macrocall$1$ebnf$2$subexpression$1"], postprocess: id },
+      { name: "array$macrocall$1$ebnf$2", symbols: [], postprocess: () => null },
+      {
+        name: "array$macrocall$1",
+        symbols: ["_", "array$macrocall$1$ebnf$1", "array$macrocall$2", "array$macrocall$1$ebnf$2", "_"],
+        postprocess: (data) => {
+          const firstArray = data[1].map(([expression]) => expression[0]);
+          return [...firstArray, data[2][0]];
+        }
+      },
+      {
+        name: "array",
+        symbols: [{ literal: "[" }, "array$macrocall$1", { literal: "]" }],
+        postprocess: (data) => data[1]
+      },
+      { name: "byteArray$macrocall$2", symbols: ["typedByte"] },
+      { name: "byteArray$macrocall$1", symbols: ["_"], postprocess: () => [] },
+      { name: "byteArray$macrocall$1$ebnf$1", symbols: [] },
+      {
+        name: "byteArray$macrocall$1$ebnf$1$subexpression$1",
+        symbols: ["byteArray$macrocall$2", "_", { literal: "," }, "_"]
+      },
+      {
+        name: "byteArray$macrocall$1$ebnf$1",
+        symbols: ["byteArray$macrocall$1$ebnf$1", "byteArray$macrocall$1$ebnf$1$subexpression$1"],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      { name: "byteArray$macrocall$1$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
+      {
+        name: "byteArray$macrocall$1$ebnf$2",
+        symbols: ["byteArray$macrocall$1$ebnf$2$subexpression$1"],
+        postprocess: id
+      },
+      { name: "byteArray$macrocall$1$ebnf$2", symbols: [], postprocess: () => null },
+      {
+        name: "byteArray$macrocall$1",
+        symbols: ["_", "byteArray$macrocall$1$ebnf$1", "byteArray$macrocall$2", "byteArray$macrocall$1$ebnf$2", "_"],
+        postprocess: (data) => {
+          const firstArray = data[1].map(([expression]) => expression[0]);
+          return [...firstArray, data[2][0]];
+        }
+      },
+      {
+        name: "byteArray",
+        symbols: [
+          { literal: "[" },
+          "_",
+          { literal: "B" },
+          "_",
+          { literal: ";" },
+          "byteArray$macrocall$1",
+          { literal: "]" }
+        ],
+        postprocess: (data) => ({ dataType: "byteArray", value: data[5] })
+      },
+      { name: "intArray$macrocall$2", symbols: ["number"] },
+      { name: "intArray$macrocall$1", symbols: ["_"], postprocess: () => [] },
+      { name: "intArray$macrocall$1$ebnf$1", symbols: [] },
+      {
+        name: "intArray$macrocall$1$ebnf$1$subexpression$1",
+        symbols: ["intArray$macrocall$2", "_", { literal: "," }, "_"]
+      },
+      {
+        name: "intArray$macrocall$1$ebnf$1",
+        symbols: ["intArray$macrocall$1$ebnf$1", "intArray$macrocall$1$ebnf$1$subexpression$1"],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      { name: "intArray$macrocall$1$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
+      { name: "intArray$macrocall$1$ebnf$2", symbols: ["intArray$macrocall$1$ebnf$2$subexpression$1"], postprocess: id },
+      { name: "intArray$macrocall$1$ebnf$2", symbols: [], postprocess: () => null },
+      {
+        name: "intArray$macrocall$1",
+        symbols: ["_", "intArray$macrocall$1$ebnf$1", "intArray$macrocall$2", "intArray$macrocall$1$ebnf$2", "_"],
+        postprocess: (data) => {
+          const firstArray = data[1].map(([expression]) => expression[0]);
+          return [...firstArray, data[2][0]];
+        }
+      },
+      {
+        name: "intArray",
+        symbols: [
+          { literal: "[" },
+          "_",
+          { literal: "I" },
+          "_",
+          { literal: ";" },
+          "intArray$macrocall$1",
+          { literal: "]" }
+        ],
+        postprocess: (data) => ({ dataType: "intArray", value: data[5] })
+      },
+      { name: "longArray$macrocall$2", symbols: ["typedLong"] },
+      { name: "longArray$macrocall$1", symbols: ["_"], postprocess: () => [] },
+      { name: "longArray$macrocall$1$ebnf$1", symbols: [] },
+      {
+        name: "longArray$macrocall$1$ebnf$1$subexpression$1",
+        symbols: ["longArray$macrocall$2", "_", { literal: "," }, "_"]
+      },
+      {
+        name: "longArray$macrocall$1$ebnf$1",
+        symbols: ["longArray$macrocall$1$ebnf$1", "longArray$macrocall$1$ebnf$1$subexpression$1"],
+        postprocess: (d) => d[0].concat([d[1]])
+      },
+      { name: "longArray$macrocall$1$ebnf$2$subexpression$1", symbols: ["_", { literal: "," }] },
+      {
+        name: "longArray$macrocall$1$ebnf$2",
+        symbols: ["longArray$macrocall$1$ebnf$2$subexpression$1"],
+        postprocess: id
+      },
+      { name: "longArray$macrocall$1$ebnf$2", symbols: [], postprocess: () => null },
+      {
+        name: "longArray$macrocall$1",
+        symbols: ["_", "longArray$macrocall$1$ebnf$1", "longArray$macrocall$2", "longArray$macrocall$1$ebnf$2", "_"],
+        postprocess: (data) => {
+          const firstArray = data[1].map(([expression]) => expression[0]);
+          return [...firstArray, data[2][0]];
+        }
+      },
+      {
+        name: "longArray",
+        symbols: [
+          { literal: "[" },
+          "_",
+          { literal: "L" },
+          "_",
+          { literal: ";" },
+          "longArray$macrocall$1",
+          { literal: "]" }
+        ],
+        postprocess: (data) => ({ dataType: "longArray", value: data[5] })
+      },
+      { name: "string$subexpression$1", symbols: ["dqstring"] },
+      { name: "string$subexpression$1", symbols: ["sqstring"] },
+      {
+        name: "string",
+        symbols: ["string$subexpression$1"],
+        postprocess: (data) => ({ dataType: "string", value: data[0][0] })
+      },
+      { name: "typedNum$subexpression$1", symbols: ["typedByte"] },
+      { name: "typedNum$subexpression$1", symbols: ["typedShort"] },
+      { name: "typedNum$subexpression$1", symbols: ["typedLong"] },
+      { name: "typedNum$subexpression$1", symbols: ["typedFloat"] },
+      { name: "typedNum", symbols: ["typedNum$subexpression$1"], postprocess: (data) => data[0][0] },
+      {
+        name: "typedByte$subexpression$1",
+        symbols: [/[bB]/],
+        postprocess(d) {
+          return d.join("");
+        }
+      },
+      {
+        name: "typedByte",
+        symbols: ["int", "typedByte$subexpression$1"],
+        postprocess: (data) => ({ dataType: "byte", value: data[0] })
+      },
+      {
+        name: "typedShort$subexpression$1",
+        symbols: [/[sS]/],
+        postprocess(d) {
+          return d.join("");
+        }
+      },
+      {
+        name: "typedShort",
+        symbols: ["int", "typedShort$subexpression$1"],
+        postprocess: (data) => ({ dataType: "short", value: data[0] })
+      },
+      {
+        name: "typedLong$subexpression$1",
+        symbols: [/[lL]/],
+        postprocess(d) {
+          return d.join("");
+        }
+      },
+      {
+        name: "typedLong",
+        symbols: ["int", "typedLong$subexpression$1"],
+        postprocess: (data) => ({ dataType: "long", value: data[0] })
+      },
+      {
+        name: "typedFloat$subexpression$1",
+        symbols: [/[dD]/],
+        postprocess(d) {
+          return d.join("");
+        }
+      },
+      {
+        name: "typedFloat",
+        symbols: ["decimal", "typedFloat$subexpression$1"],
+        postprocess: (data) => ({ dataType: "double", value: data[0] })
+      },
+      {
+        name: "typedFloat$subexpression$2",
+        symbols: [/[fF]/],
+        postprocess(d) {
+          return d.join("");
+        }
+      },
+      {
+        name: "typedFloat",
+        symbols: ["decimal", "typedFloat$subexpression$2"],
+        postprocess: (data) => ({ dataType: "float", value: data[0] })
+      },
+      { name: "number$subexpression$1", symbols: ["decimal"] },
+      {
+        name: "number",
+        symbols: ["number$subexpression$1"],
+        postprocess: (data) => ({ dataType: "number", value: data[0][0] })
+      },
+      {
+        name: "boolean$subexpression$1$string$1",
+        symbols: [{ literal: "t" }, { literal: "r" }, { literal: "u" }, { literal: "e" }],
+        postprocess: (d) => d.join("")
+      },
+      { name: "boolean$subexpression$1", symbols: ["boolean$subexpression$1$string$1"] },
+      {
+        name: "boolean$subexpression$1$string$2",
+        symbols: [{ literal: "f" }, { literal: "a" }, { literal: "l" }, { literal: "s" }, { literal: "e" }],
+        postprocess: (d) => d.join("")
+      },
+      { name: "boolean$subexpression$1", symbols: ["boolean$subexpression$1$string$2"] },
+      {
+        name: "boolean",
+        symbols: ["boolean$subexpression$1"],
+        postprocess: (data) => ({ dataType: "boolean", value: data[0].join("") === "true" })
+      }
+    ],
+    ParserStart: "expression"
   };
+  grammar_default = grammar;
 });
 
-// src/variables/Coordinates.ts
-import { inspect as inspect4 } from "util";
-function relative(...coordinates) {
-  if (coordinates.length === 0) {
-    return new VectorClass(["~", "~", "~"]);
-  }
-  if (coordinates.length === 1) {
-    return `~${coordinates[0] || ""}`;
-  }
-  return new VectorClass(coordinates.map((coord) => `~${coord || ""}`));
+// src/variables/nbt/parser.ts
+import nearley from "nearley";
+function isCompoundNbt(nbt) {
+  return !!nbt[isCompoundSymbol];
 }
-var VECTOR_CLASS_BRAND, VectorClass;
-var init_Coordinates = __esm(() => {
-  VECTOR_CLASS_BRAND = Symbol.for("sandstone.VectorClass");
-  VectorClass = class VectorClass {
-    [VECTOR_CLASS_BRAND] = true;
-    values;
-    constructor(values) {
-      if (!Array.isArray(values) || !values.every((i) => typeof i === "string")) {
-        throw new Error(`Expected array of string for Vector values, got ${inspect4(values)}`);
-      }
-      this.values = values;
-    }
-    toString() {
-      return this.values.join(" ");
-    }
-    toJSON() {
-      return this.toString();
-    }
-    toNBT() {
-      return this.toString();
-    }
-    [Symbol.iterator]() {
-      return this.values[Symbol.iterator]();
-    }
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[VECTOR_CLASS_BRAND] === true;
+function parseRaw(nbt) {
+  const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar_default));
+  parser.feed(nbt);
+  parser.finish();
+  return parser.results[0];
+}
+function parseExpression(NBT, nbt) {
+  if (Array.isArray(nbt)) {
+    return nbt.map((x) => parseExpression(NBT, x));
+  }
+  if (typeof nbt === "object") {
+    if (isCompoundNbt(nbt)) {
+      return Object.keys(nbt).reduce((acc, key) => {
+        acc[key] = parseExpression(NBT, nbt[key]);
+        return acc;
+      }, {});
     }
-  };
-});
-
-// src/variables/parsers.ts
-function coordinatesParser(coordinates) {
-  if (Array.isArray(coordinates)) {
-    if (coordinates.length === 3 || coordinates.length === 2) {
-      return new VectorClass(coordinates.map((coord) => {
-        if (typeof coord === "string") {
-          return coord;
-        }
-        if (typeof coord === "number") {
-          return `${coord}`;
-        }
-        if ("toMacro" in coord) {
-          return coord.toMacro();
-        }
-        throw new Error(`[coordinatesParser] Unsupported vector component ${coord}`);
-      }));
+    switch (nbt.dataType) {
+      case "byte":
+        return NBT.byte(nbt.value);
+      case "short":
+        return NBT.short(nbt.value);
+      case "long":
+        return NBT.long(nbt.value);
+      case "float":
+        return NBT.float(nbt.value);
+      case "double":
+        return NBT.double(nbt.value);
+      case "number":
+        return nbt.value;
+      case "string":
+        return nbt.value;
+      case "byteArray":
+        return NBT.byteArray(nbt.value.map((x) => x.value));
+      case "intArray":
+        return NBT.intArray(nbt.value.map((x) => x.value));
+      case "longArray":
+        return NBT.longArray(nbt.value.map((x) => x.value));
     }
-    throw new Error(`[coordinatesParser] Unsupported vector size ${coordinates.length}`);
-  } else {
-    return coordinates;
   }
+  throw new Error(`Unrecognized data type: ${nbt.dataType}`);
 }
-function rotationParser(rotation) {
-  if (Array.isArray(rotation)) {
-    if (rotation.length === 2) {
-      return new VectorClass(rotation.map((coord) => {
-        if (typeof coord === "string") {
-          return coord;
-        }
-        if (typeof coord === "number") {
-          return `${coord}`;
-        }
-        if ("toMacro" in coord) {
-          return coord.toMacro();
-        }
-        throw new Error(`[rotationParser] Unsupported vector component ${coord}`);
-      }));
-    }
-    throw new Error(`[rotationParser] Unsupported vector size ${rotation.length}`);
-  } else {
-    return rotation;
-  }
+function parseNBT(NBT, nbt) {
+  const rawResult = parseRaw(nbt);
+  return parseExpression(NBT, rawResult);
 }
-function targetParser(target) {
-  if (target === undefined) {
-    throw new Error("Target cannot be undefined.");
-  }
-  if (typeof target === "string") {
-    return target;
-  }
-  if (target._toSelector) {
-    return target._toSelector();
-  }
-  if (target.toMacro) {
-    return target;
+var init_parser = __esm(() => {
+  init_grammar();
+});
+
+// src/variables/nbt/NBTs.ts
+import * as util3 from "util";
+function customNumber(num, _class) {
+  if (Array.isArray(num)) {
+    return num.map((n) => new _class(n));
   }
-  return target.toString();
+  return new _class(num);
 }
-var sanitizeValue = (core, value) => {
-  if (value === undefined || value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (isMacroArgument(core, value)) {
-    return value.toMacro();
-  }
-  if (Number.isFinite(value)) {
-    return value.toString();
-  }
-  return "";
-}, rangeParser = (core, range) => {
-  if (Array.isArray(range)) {
-    return `${sanitizeValue(core, range[0])}..${sanitizeValue(core, range[1])}`;
-  }
-  return range.toString();
-}, structureRotationParser = (rotation) => {
-  if (!rotation) {
-    return "none";
-  }
-  if (typeof rotation === "object") {
-    return rotation;
-  }
-  const numToLiteral = (angle) => {
-    switch (angle) {
-      case 0:
-        return "none";
-      case 90:
-        return "clockwise_90";
-      case 180:
-        return "180";
-      case 270:
-        return "counterclockwise_90";
-      case -90:
-        return "counterclockwise_90";
-      case -180:
-        return "180";
-      case -270:
-        return "clockwise_90";
-      default: {
-        if (!Number.isInteger(angle / 90)) {
-          throw new Error("Structure rotation must be in increments of 90!");
-        }
-        angle %= 360;
-        angle = (angle + 360) % 360;
-        if (angle > 180)
-          angle -= 360;
-        return numToLiteral(angle);
-      }
-    }
-  };
-  if (typeof rotation === "number") {
-    return numToLiteral(rotation);
+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("");
+  return parseNBT(NBT, result);
+}
+var N_B_T_CLASS_BRAND, NBTClass, N_B_T_PRIMITIVE_BRAND, NBTPrimitive, NBTLong, NBTByte, NBTShort, NBTFloat, NBTInt, NBTDouble, NBTTypedArray, NBTLongArray, NBTByteArray, NBTIntArray, NotNBT, NBTAnyValue, NBT, nbtStringifier = (nbt) => {
+  if (nbt === null || nbt === undefined) {
+    throw new Error("Nullish nbt values are not allowed");
   }
-  if (rotation === "clockwise_90" || rotation === "counterclockwise_90") {
-    return rotation;
+  if (typeof nbt === "number") {
+    return `${nbt}d`;
   }
-  return numToLiteral(Number(rotation));
-}, structureMirrorParser = (mirror) => {
-  if (typeof mirror === "object") {
-    return mirror.toMacro();
+  if (typeof nbt === "boolean") {
+    return nbt.toString();
   }
-  if (typeof mirror === "string") {
-    const lastCharacter = mirror.slice(0, -1);
-    if (lastCharacter === "x") {
-      return "left_right";
-    }
-    if (lastCharacter === "z") {
-      return "front_back";
+  if (typeof nbt === "string") {
+    const inspectedStr = util3.inspect(nbt, {
+      breakLength: Number.POSITIVE_INFINITY,
+      compact: true,
+      maxStringLength: Number.POSITIVE_INFINITY,
+      depth: Number.POSITIVE_INFINITY
+    });
+    if (inspectedStr[0] === "`") {
+      return JSON.stringify(nbt);
     }
-    return mirror;
-  }
-  if (mirror) {
-    return "left_right";
+    return inspectedStr;
   }
-  return "none";
-};
-var init_parsers = __esm(() => {
-  init_Macro();
-  init_Coordinates();
-});
-
-// src/commands/helpers.ts
-class FinalCommandOutput {
-  node;
-  constructor(node) {
-    this.node = node;
+  if (Array.isArray(nbt)) {
+    const itemsStr = nbt.map(nbtStringifier).join(",");
+    return `[${itemsStr}]`;
   }
-}
-
-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;
+  if (nbt instanceof NBTClass) {
+    return nbt[util3.inspect.custom]();
   }
-  getNode = () => {
-    if (this.previousNode) {
-      return this.previousNode;
+  if (typeof nbt === "object" || typeof nbt === "function") {
+    let failedMacro = false;
+    if ("toMacro" in nbt) {
+      const macro = nbt.toMacro();
+      if (macro === "$()") {
+        failedMacro = true;
+      } else {
+        return macro;
+      }
     }
-    if (this.NodeType) {
-      return new this.NodeType(this.sandstonePack);
+    if ("toNBT" in nbt) {
+      return nbt.toNBT();
+    } else if (failedMacro) {
+      throw new Error("[nbtStringifier] A macro variable NBT insertion was attempted in an mcfunction without macros defined.");
     }
-    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 (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.`);
     }
-    if (this.autoCommit) {
-      node.commit();
+    if (nbt.constructor.name !== "Object") {
+      if ("toString" in nbt) {
+        return `${toString}`;
+      } 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`);
+      }
+    }
+  }
+  const objectStr = Object.entries(nbt).map(([key, value]) => `${key}:${nbtStringifier(value)}`).join(",");
+  return `{${objectStr}}`;
+};
+var init_NBTs = __esm(() => {
+  init_utils();
+  init_parser();
+  N_B_T_CLASS_BRAND = Symbol.for("sandstone.NBTClass");
+  NBTClass = class NBTClass {
+    [N_B_T_CLASS_BRAND] = true;
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[N_B_T_CLASS_BRAND] === true;
     }
-    return new FinalCommandOutput(node);
   };
-  subCommand = (args, NextArgumentType, executable = false, additionalNextArgs = [], currentNode) => {
-    const node = currentNode ?? this.getNode();
-    if (args) {
-      node.args.push(...args);
+  N_B_T_PRIMITIVE_BRAND = Symbol.for("sandstone.NBTPrimitive");
+  NBTPrimitive = class NBTPrimitive extends NBTClass {
+    [N_B_T_PRIMITIVE_BRAND] = true;
+    value;
+    unit;
+    constructor(value, unit) {
+      super();
+      this.value = value;
+      this.unit = unit;
     }
-    if (executable && this.autoCommit) {
-      node.commit();
+    toJSON() {
+      return this.value;
     }
-    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();
-  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]
-      ]);
-    };
-  };
-});
-
-// src/commands/implementations/entity/damage.ts
-var DamageCommandNode, DamageCauseCommand, DamageSourceCommand, DamageCommand;
-var init_damage = __esm(() => {
-  init_nodes();
-  init_parsers();
-  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);
-    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);
-    };
-  };
-});
-
-// src/commands/implementations/_fake/comment.ts
-var CommentCommandNode, CommentCommand;
-var init_comment = __esm(() => {
-  init_nodes();
-  CommentCommandNode = class CommentCommandNode extends CommandNode {
-    command = "#";
-    getValue() {
-      return this.args[0].join(" ").split(`
-`).map((line) => `# ${line}`).join(`
-`);
+    [util3.inspect.custom] = () => `${this.value}${this.unit}`;
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[N_B_T_PRIMITIVE_BRAND] === true;
     }
   };
-  CommentCommand = class CommentCommand extends CommandArguments {
-    NodeType = CommentCommandNode;
-    comment = (...comments) => this.finalCommand([comments]);
-  };
-});
-
-// src/commands/implementations/_fake/raw.ts
-var RawCommandNode, RawCommand;
-var init_raw = __esm(() => {
-  init_nodes();
-  RawCommandNode = class RawCommandNode extends CommandNode {
-    command = "";
-  };
-  RawCommand = class RawCommand extends CommandArguments {
-    NodeType = RawCommandNode;
-    raw = (...args) => this.finalCommand([...args]);
-  };
-});
-
-// src/commands/implementations/block/clone.ts
-var CloneCommandNode, CloneCommand, CloneFromDimensionCommand, CloneToDimensionCommand, CloneOptionsCommand, CloneStrictOptionsCommand, CloneModeCommand;
-var init_clone = __esm(() => {
-  init_nodes();
-  init_parsers();
-  CloneCommandNode = class CloneCommandNode extends CommandNode {
-    command = "clone";
-  };
-  CloneCommand = class CloneCommand extends CommandArguments {
-    NodeType = CloneCommandNode;
-    clone(begin, end, destination) {
-      if (begin === undefined) {
-        return this.subCommand([], CloneFromDimensionCommand, false);
-      }
-      return this.subCommand([begin, end, destination].map(coordinatesParser), CloneOptionsCommand, true);
+  NBTLong = class NBTLong extends NBTPrimitive {
+    constructor(value) {
+      super(value, "l");
     }
   };
-  CloneFromDimensionCommand = class CloneFromDimensionCommand extends CommandArguments {
-    from(dimension, begin, end, destination) {
-      if (destination === undefined) {
-        return this.subCommand(["from", dimension, coordinatesParser(begin), coordinatesParser(end)], CloneToDimensionCommand, false);
-      }
-      return this.subCommand(["from", ...[begin, end, destination].map(coordinatesParser)], CloneOptionsCommand, true);
+  NBTByte = class NBTByte extends NBTPrimitive {
+    constructor(value) {
+      super(value, "b");
     }
   };
-  CloneToDimensionCommand = class CloneToDimensionCommand extends CommandArguments {
-    to = (dimension, destination) => this.subCommand(["to", dimension, coordinatesParser(destination)], CloneOptionsCommand, true);
+  NBTShort = class NBTShort extends NBTPrimitive {
+    constructor(value) {
+      super(value, "s");
+    }
   };
-  CloneOptionsCommand = class CloneOptionsCommand extends CommandArguments {
-    replace = () => this.subCommand(["replace"], CloneModeCommand, true);
-    strict = () => this.subCommand(["strict"], CloneStrictOptionsCommand, true);
-    masked = () => this.subCommand(["masked"], CloneModeCommand, true);
-    filtered = (filter) => this.subCommand(["filtered", filter], CloneModeCommand, true);
+  NBTFloat = class NBTFloat extends NBTPrimitive {
+    constructor(value) {
+      super(value, "f");
+    }
   };
-  CloneStrictOptionsCommand = class CloneStrictOptionsCommand extends CommandArguments {
-    replace = () => this.subCommand(["replace"], CloneModeCommand, true);
-    masked = () => this.subCommand(["masked"], CloneModeCommand, true);
-    filtered = (filter) => this.subCommand(["filtered", filter], CloneModeCommand, true);
+  NBTInt = class NBTInt extends NBTPrimitive {
+    constructor(value) {
+      super(value, "i");
+    }
   };
-  CloneModeCommand = class CloneModeCommand extends CommandArguments {
-    force = () => this.finalCommand(["force"]);
-    move = () => this.finalCommand(["move"]);
-    normal = () => this.finalCommand(["normal"]);
+  NBTDouble = class NBTDouble extends NBTPrimitive {
+    constructor(value) {
+      super(value, "d");
+    }
   };
-});
-
-// src/variables/abstractClasses.ts
-var CONDITION_CLASS_BRAND, ConditionClass, SELECTOR_PICK_CLASS_BRAND, SelectorPickClass;
-var init_abstractClasses = __esm(() => {
-  CONDITION_CLASS_BRAND = Symbol.for("sandstone.ConditionClass");
-  ConditionClass = class ConditionClass {
-    [CONDITION_CLASS_BRAND] = true;
-    _toMinecraftCondition() {
-      throw new Error("Not implemented");
+  NBTTypedArray = class NBTTypedArray extends NBTClass {
+    values;
+    unit;
+    constructor(values, unit) {
+      super();
+      this.values = values;
+      this.unit = unit;
     }
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[CONDITION_CLASS_BRAND] === true;
+    toJSON() {
+      return this.values;
     }
+    [util3.inspect.custom] = () => `[${this.unit};${this.values.length === 0 ? "" : this.values.join(",")}]`;
   };
-  SELECTOR_PICK_CLASS_BRAND = Symbol.for("sandstone.SelectorPickClass");
-  SelectorPickClass = class SelectorPickClass {
-    [SELECTOR_PICK_CLASS_BRAND] = true;
-    _toSelector() {
-      throw new Error("Not implemented");
+  NBTLongArray = class NBTLongArray extends NBTTypedArray {
+    constructor(values) {
+      super(values, "L");
     }
-    toNBT() {
-      throw new Error("Not implemented");
+  };
+  NBTByteArray = class NBTByteArray extends NBTTypedArray {
+    constructor(values) {
+      super(values, "B");
     }
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[SELECTOR_PICK_CLASS_BRAND] === true;
+  };
+  NBTIntArray = class NBTIntArray extends NBTTypedArray {
+    constructor(values) {
+      super(values, "I");
+    }
+  };
+  NotNBT = class NotNBT extends NBTClass {
+    nbt;
+    constructor(nbt) {
+      super();
+      this.nbt = nbt;
     }
+    [util3.inspect.custom] = () => `!${nbtStringifier(this.nbt)}`;
+  };
+  NBTAnyValue = class NBTAnyValue extends NBTPrimitive {
   };
+  NBT = makeCallable({
+    int: (num) => customNumber(num, NBTInt),
+    float: (num) => customNumber(num, NBTFloat),
+    double: (num) => customNumber(num, NBTDouble),
+    byte: (num) => customNumber(num, NBTByte),
+    short: (num) => customNumber(num, NBTShort),
+    long: (num) => customNumber(num, NBTLong),
+    intArray: (numbers) => new NBTIntArray(numbers),
+    longArray: (numbers) => new NBTLongArray(numbers),
+    byteArray: (numbers) => new NBTByteArray(numbers),
+    not: (nbt) => new NotNBT(nbt),
+    stringify: (nbt) => nbtStringifier(nbt),
+    parse: (nbt) => parseNBT(NBT, nbt)
+  }, dynamicNBT);
 });
 
 // src/variables/Score.ts
@@ -1714,6 +1734,9 @@ var init_Score = __esm(() => {
     ]));
     unaryOperation(operation, operator, ...args) {
       if (typeof args[0] === "number") {
+        if (args[0] < 0 && operation !== "set") {
+          return this.binaryOperation(operator, args[0]);
+        }
         this.commands.scoreboard.players[operation](this, args[0]);
       } else if (args[0] instanceof Score) {
         this.commands.scoreboard.players.operation(this, operator, args[0].target, args[0].objective);
@@ -1730,7 +1753,7 @@ var init_Score = __esm(() => {
       let objective = args[1] ?? this.objective;
       if (typeof args[0] === "number") {
         this.sandstonePack.registerNewConstant(args[0]);
-        objective = "sandstone_const";
+        objective = "__sandstone";
       }
       this.commands.scoreboard.players.operation(this, operator, args[0], objective);
       return this;
@@ -1886,7 +1909,99 @@ Warning: Score.match() will have to create ${maximum - minimum} mcfunction files
       }
       return MCFunction(`__sandstone:score_match/${matcher}`, [score], () => Macro.returnCmd.run.functionCmd(Macro`__sandstone:score_match/${matcher}/${score}`));
     };
-    [util4.inspect.custom](depth, options) {
+    getDecomposer(size, splitsOrCount, componentCount = 31, includeSign = true) {
+      if (typeof this.target !== "string" || this.target.search(/-|@/) !== -1) {
+        throw new Error("[Score#getDecomposer] Must use a fake-player Score for decomposition.");
+      }
+      const { MCFunction, _, commands } = this.sandstonePack;
+      const { execute, returnCmd } = commands;
+      const newScore = this.objective.ScoreHolder;
+      const components = [];
+      const sign = includeSign ? newScore(`${this.target}._32`) : undefined;
+      let decompose;
+      if (size === "bit" || size === undefined) {
+        for (let i = 1;i <= componentCount; i++) {
+          components.push(newScore(`${this.target}._${i}`));
+        }
+        decompose = MCFunction(`__sandstone:score/decompose_bits/${componentCount}_${splitsOrCount === undefined ? 0 : splitsOrCount.size}/${this.target.replaceAll(".", "/").toLowerCase()}`, () => {
+          const resetBits = execute.store.result(components[0]);
+          for (const component of components.slice(1, -1)) {
+            resetBits.store.result(component);
+            resetBits.nestedExecute(["\\\n "], false);
+          }
+          if (includeSign) {
+            resetBits.store.result(components.at(-1));
+            resetBits.nestedExecute(["\\\n "], false);
+            resetBits.run(() => sign["="](0));
+          } else {
+            resetBits.run(() => components.at(-1)["="](0));
+          }
+          const input = newScore(`${this.target}._bf_iterator`);
+          const splits = splitsOrCount ?? new Set;
+          const bitExecute = (bit) => execute.store.success(components[bit - 1]);
+          input["="](this);
+          _.if(this["=="](0), () => {
+            returnCmd(1);
+          });
+          if (includeSign) {
+            execute.store.success(sign).if.score(input, "matches", [null, -1]).run(() => {
+              input["*="](-1);
+            });
+          }
+          input.decomposeBits(splits, componentCount, bitExecute);
+        }, {
+          creator: "sandstone",
+          onConflict: "rename",
+          addToSandstoneCore: true
+        });
+      } else {
+        throw new Error("[Score#getDecomposer(byte)] Byte decomposition is not yet supported");
+      }
+      const result = {
+        components,
+        ...add({ sign })
+      };
+      return {
+        ...result,
+        decompose: () => {
+          decompose();
+          return result;
+        }
+      };
+    }
+    decomposeBits(splits, componentCount, bitExecute, extra) {
+      const { _ } = this.sandstonePack;
+      const sortedSplits = [...splits].filter((s) => s > 0 && s < componentCount).sort((a, b) => b - a);
+      const boundaries = [componentCount, ...sortedSplits, 0];
+      const processRange = (high, low) => {
+        let halvedAgain = 2 ** high;
+        for (let bit = high;bit >= low; bit--) {
+          halvedAgain /= 2;
+          bitExecute(bit, halvedAgain).if.score(this, "matches", [halvedAgain, null]).run(() => {
+            this["-="](halvedAgain);
+            extra?.(bit, halvedAgain);
+          });
+        }
+      };
+      const buildNested = (rangeIndex) => {
+        const high = boundaries[rangeIndex];
+        const low = boundaries[rangeIndex + 1] + 1;
+        if (rangeIndex > 0) {
+          const higherMinValue = 2 ** boundaries[rangeIndex];
+          _.if(this.matches([higherMinValue, null]), () => {
+            buildNested(rangeIndex - 1);
+          });
+        }
+        processRange(high, low);
+      };
+      if (splits.size === 0) {
+        processRange(componentCount, 1);
+      } else {
+        const lowestRangeIndex = boundaries.length - 2;
+        buildNested(lowestRangeIndex);
+      }
+    }
+    [util4.inspect.custom](_depth, options) {
       return formatDebugString(this.constructor.name, {
         target: this.target,
         display: this.display,
@@ -1946,7 +2061,9 @@ class TargetlessDataClass {
     this.sandstonePack = sandstonePack;
     this.type = type;
   }
-  target = (target) => new DataClass(this.sandstonePack, this.type, target);
+  target = (target) => {
+    return new DataClass(this.sandstonePack, this.type, target);
+  };
   select = (...path) => new TargetlessDataPointClass(this.sandstonePack, this.type, path);
 }
 
@@ -1959,7 +2076,9 @@ class TargetlessDataPointClass {
     this.type = type;
     this.path = NBTpathToString(sandstonePack, path);
   }
-  target = (target) => new DataPointClass(this.sandstonePack, this.type, target, [this.path]);
+  target = (target) => {
+    return new DataPointClass(this.sandstonePack, this.type, target, [this.path]);
+  };
   select = (...path) => new TargetlessDataPointClass(this.sandstonePack, this.type, [this.path, ...path]);
 }
 
@@ -2047,7 +2166,9 @@ var init_Data = __esm(() => {
     append = (value) => this.modify((data) => data.append, value);
     prepend = (value) => this.modify((data) => data.prepend, value);
     insert = (value, index) => this.modify((data) => data.insert(index), value);
-    remove = () => this.sandstonePack.commands.data.remove[this.type](this.currentTarget, this.path);
+    remove = () => {
+      return this.sandstonePack.commands.data.remove[this.type](this.currentTarget, this.path);
+    };
     slice = (start, end) => new StringDataPointClass(this.sandstonePack, this.type, this.currentTarget, this.path, start, end);
     _toMinecraftCondition = () => new this.sandstonePack.conditions.DataPointExists(this.sandstonePack.core, this);
     equals = (value) => new this.sandstonePack.conditions.DataPointEquals(this.sandstonePack.core, this, value);
@@ -2092,7 +2213,7 @@ function isTagClass(v) {
 }
 function objectToString(value) {
   if (isMCFunctionClass(value)) {
-    if (value.node.resource.env) {
+    if (value.env && value.callback.length < 2) {
       return value.node.sandstoneCore.pack.MCFunction(`${value.name}/_env`, () => value(), {
         creator: "sandstone",
         onConflict: "rename"
@@ -2108,7 +2229,7 @@ function objectToString(value) {
   }
   if (typeof value === "object") {
     if (isMCFunctionClass(value.id)) {
-      if (value.id.node.resource.env) {
+      if (value.id.env && value.id.callback.length < 2) {
         return {
           id: value.id.node.sandstoneCore.pack.MCFunction(`${value.id.name}/_env`, () => value.id(), { creator: "sandstone", onConflict: "rename" }).name,
           required: value.required
@@ -2142,7 +2263,7 @@ var init_tag = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.tagJSON);
+    getValue = () => jsonStringify(this.resource.tagJSON, this.resource._resourceType);
   };
   TAG_CLASS_BRAND = Symbol.for("sandstone.TagClass");
   TagClass = class TagClass extends ResourceClass {
@@ -2235,7 +2356,7 @@ var init_model = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.modelJSON);
+    getValue = () => jsonStringify(this.resource.modelJSON, this.resource._resourceType);
   };
   MODEL_CLASS_BRAND = Symbol.for("sandstone.ModelClass");
   ModelClass = class ModelClass extends ResourceClass {
@@ -2439,7 +2560,7 @@ var init_itemDefinition = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.itemDefinitionJSON);
+    getValue = () => jsonStringify(this.resource.itemDefinitionJSON, this.resource._resourceType);
   };
   ItemModelDefinitionClass = class ItemModelDefinitionClass extends ResourceClass {
     static resourceType = "item_definition";
@@ -2607,7 +2728,12 @@ var init_DataSets = __esm(() => {
   init_Data();
   init_Score();
   IterableDataClass = class IterableDataClass extends ConditionalDataPointPickClass {
-    iterator(_callback) {
+    iteratorType;
+    constructor(sandstoneCore, iteratorType) {
+      super(sandstoneCore);
+      this.iteratorType = iteratorType;
+    }
+    iterator(_callback, _direction = "normal") {
       throw new Error("Not implemented");
     }
     size() {
@@ -2616,24 +2742,30 @@ var init_DataSets = __esm(() => {
     last() {
       throw new Error("Not implemented");
     }
-    get continue() {
+    continue(direction = "normal") {
       throw new Error("Not implemented");
     }
   };
   DataIndexMapClass = class DataIndexMapClass extends IterableDataClass {
     pack;
-    initialize;
     entries = {};
     dataPoint;
     constructor(pack, initialize, dataPoint) {
-      super(pack.core);
+      super(pack.core, "map");
       this.pack = pack;
-      this.initialize = initialize;
       if (dataPoint) {
         this.dataPoint = dataPoint;
       } else {
         this.dataPoint = this.pack.DataVariable(undefined, "IndexMap");
       }
+      if (pack.core.currentMCFunction) {
+        this.init(initialize);
+      } else {
+        const init = this.init;
+        pack.initMCFunction.push(() => init(initialize));
+      }
+    }
+    init(initialize) {
       for (const [i, [key, value]] of Object.entries(initialize).entries()) {
         this.dataPoint.select("Index").select(key).set(i);
         this.dataPoint.select("Entries").append([]);
@@ -2644,21 +2776,22 @@ var init_DataSets = __esm(() => {
       }
     }
     __entryIterator;
-    get entryIterator() {
+    entryIterator(direction) {
       if (!this.__entryIterator) {
-        this.__entryIterator = this.pack.DataVariable(this.dataPoint.select("Entries")).select("[-1]");
+        this.__entryIterator = this.pack.DataVariable(this.dataPoint.select("Entries")).select(`[${direction === "normal" ? 0 : -1}]`);
       }
       return this.__entryIterator;
     }
-    iterator(callback) {
+    iterator(callback, direction = "normal") {
       this.__entryIterator = undefined;
+      const entryIterator = this.entryIterator(direction);
       return () => {
-        callback([this.entryIterator.select("[0]").slice(0), this.entryIterator.select("[1]")]);
-        this.entryIterator.remove();
+        callback([entryIterator.select("[0]").slice(0), entryIterator.select("[1]")]);
+        entryIterator.remove();
       };
     }
-    get continue() {
-      return this.entryIterator._toMinecraftCondition();
+    continue(direction = "normal") {
+      return this.entryIterator(direction)._toMinecraftCondition();
     }
     size = () => this.dataPoint.select("Entries");
     last = () => [this.dataPoint.select("Entries[-1][0]").slice(0), this.dataPoint.select("Entries[-1][1]")];
@@ -2767,33 +2900,42 @@ var init_DataSets = __esm(() => {
     pack;
     dataPoint;
     constructor(pack, initialize, dataPoint) {
-      super(pack.core);
+      super(pack.core, "list");
       this.pack = pack;
       if (dataPoint) {
         this.dataPoint = dataPoint;
       } else {
         this.dataPoint = this.pack.DataVariable([], "Array");
       }
+      if (pack.core.currentMCFunction) {
+        this.init(initialize);
+      } else {
+        const init = this.init;
+        pack.initMCFunction.push(() => init(initialize));
+      }
+    }
+    init(initialize) {
       for (const entry of initialize) {
         this.dataPoint.append(entry);
       }
     }
     __entryIterator;
-    get entryIterator() {
+    entryIterator(direction) {
       if (!this.__entryIterator) {
-        this.__entryIterator = this.pack.DataVariable(this.dataPoint).select("[-1]");
+        this.__entryIterator = this.pack.DataVariable(this.dataPoint).select(`[${direction === "normal" ? 0 : -1}]`);
       }
       return this.__entryIterator;
     }
-    iterator(callback) {
+    iterator(callback, direction = "normal") {
       this.__entryIterator = undefined;
+      const entryIterator = this.entryIterator(direction);
       return () => {
-        callback([this.entryIterator]);
-        this.entryIterator.remove();
+        callback([entryIterator]);
+        entryIterator.remove();
       };
     }
-    get continue() {
-      return this.entryIterator._toMinecraftCondition();
+    continue(direction = "normal") {
+      return this.entryIterator(direction)._toMinecraftCondition();
     }
     size = () => this.dataPoint;
     last = () => this.dataPoint.select("[-1]");
@@ -2875,7 +3017,11 @@ var init_JSONTextComponentClass = __esm(() => {
       this.jsonTextComponent = jsonTextComponent;
     }
     toString() {
-      return JSON.stringify(toComponent(this.jsonTextComponent), function(key, value) {
+      const component = toComponent(this.jsonTextComponent);
+      if (typeof component === "string") {
+        return `"${component}"`;
+      }
+      return JSON.stringify(component, function(key, value) {
         if (Array.isArray(this)) {
           const realValue = this[Number.parseInt(key, 10)];
           return toComponent(realValue);
@@ -3090,14 +3236,52 @@ var init_Label = __esm(() => {
   LabelClass = makeClassCallable(_RawLabelClass);
 });
 
+// src/commands/implementations/server/function.ts
+var FUNCTION_COMMAND_NODE_BRAND, FunctionCommandNode, FunctionCommand;
+var init_function = __esm(() => {
+  init_nodes();
+  init_tag();
+  init_NBTs();
+  FUNCTION_COMMAND_NODE_BRAND = Symbol.for("sandstone.FunctionCommandNode");
+  FunctionCommandNode = class FunctionCommandNode extends CommandNode {
+    [FUNCTION_COMMAND_NODE_BRAND] = true;
+    command = "function";
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[FUNCTION_COMMAND_NODE_BRAND] === true;
+    }
+  };
+  FunctionCommand = class FunctionCommand extends CommandArguments {
+    NodeType = FunctionCommandNode;
+    function(mcFunction, params, pointOrType, target, path) {
+      const args = [];
+      if (params) {
+        if (params === "with" && pointOrType) {
+          args.push("with");
+          if (typeof pointOrType === "string") {
+            args.push(pointOrType, target, path ?? "{}");
+          } else {
+            const point = Object.hasOwn(pointOrType, "_toDataPoint") ? pointOrType._toDataPoint : pointOrType;
+            args.push(point.type, point.currentTarget, point.path);
+          }
+        } else {
+          args.push(typeof params === "object" && params.toMacro ? params : nbtStringifier(params));
+        }
+      }
+      return this.finalCommand([mcFunction instanceof TagClass ? `#${mcFunction}` : mcFunction, ...args]);
+    }
+  };
+});
+
 // src/variables/Loop.ts
 var LOOP_ARGUMENT_BRAND, LoopArgument;
 var init_Loop = __esm(() => {
+  init_function();
   init_nodes();
   LOOP_ARGUMENT_BRAND = Symbol.for("sandstone.LoopArgument");
   LoopArgument = class LoopArgument extends Node {
     pack;
     [LOOP_ARGUMENT_BRAND] = true;
+    loopIfNode = null;
     constructor(pack) {
       super(pack.core);
       this.pack = pack;
@@ -3107,7 +3291,15 @@ var init_Loop = __esm(() => {
       return this.toLoop();
     }
     toLoop() {
-      return `function ${this.pack.core.currentNode}`;
+      const loopExecute = this.loopIfNode?.resultingExecuteNode;
+      if (loopExecute?.createdMCFunction) {
+        const funcNode = new FunctionCommandNode(this.pack, loopExecute.createdMCFunction.name);
+        if (loopExecute.macroStorage) {
+          funcNode.args.push("with", "storage", loopExecute.macroStorage.currentTarget, loopExecute.macroStorage.path);
+        }
+        return funcNode.getValue();
+      }
+      return new FunctionCommandNode(this.pack, this.pack.core.currentNode);
     }
     static [Symbol.hasInstance](instance) {
       return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[LOOP_ARGUMENT_BRAND] === true;
@@ -3147,7 +3339,6 @@ var init_Objective = __esm(() => {
       return formatDebugString(this.constructor.name, {
         name: this.name,
         criteria: this.criteria,
-        display: this.display,
         creator: this.creator
       }, undefined, options.indent);
     }
@@ -3344,13 +3535,13 @@ var init_Sleep = __esm(() => {
         const { execute } = commands;
         const name = `__sandstone:asyncTimer.${currentFunction.resource.name.replace(/[:/]/g, ".")}`;
         const timer = new ObjectiveClass(core.pack, name.replace(":", "."), "dummy", undefined, { creator: "sandstone" });
-        execute.store.result.score(timer("@s")).run.time.query("gametime");
+        execute.store.result(timer("@s")).run.time.query("gametime");
         timer("@s").add(Duration);
         const label = Label(name);
         label("@s").add();
         this.mcfunction.unshift(() => label("@s").remove());
         schedule = MCFunction(`${this.mcfunction.name}/_context`, () => {
-          execute.store.result.score(timer("#current")).run.time.query("gametime");
+          execute.store.result(timer("#current")).run.time.query("gametime");
           execute.as(Selector("@e", { tag: label.fullName })).if.score(timer("@s"), "=", timer("#current")).at("@s").run.functionCmd(this.mcfunction);
         }, {
           packType: currentFunction.resource.packType
@@ -3435,7 +3626,7 @@ var init_mcfunction = __esm(() => {
       return this.body.filter((node) => node.getValue() !== null).map((node) => node.getValue()).join(`
 `);
     };
-    [util10.inspect.custom](depth, options) {
+    [util10.inspect.custom](_depth, options) {
       return formatDebugString(this.constructor.name, {
         name: this.resource.name
       }, this.body, options.indent);
@@ -3451,6 +3642,7 @@ var init_mcfunction = __esm(() => {
     tags;
     lazy;
     env;
+    macroPoint;
     constructor(core, name, args, env) {
       if (name.startsWith("./")) {
         const currentMCFunctionName = core.currentMCFunction?.resource.name;
@@ -3473,11 +3665,16 @@ var init_mcfunction = __esm(() => {
       this.lazy = !!args.lazy;
       this.addToSandstoneCore = !!args.addToSandstoneCore;
       this.tags = args.tags;
-      if (env) {
+      if (env && env.length !== 0) {
         this.env = env;
       }
+      if (this.env || this.callback.length > 1) {
+        this.macroPoint = core.pack.DataVariable();
+      } else {
+        this.macroPoint = undefined;
+      }
       if (args.runOnLoad) {
-        if (env) {
+        if (this.env) {
           core.pack.loadTags.load.push(core.pack.MCFunction(`load_${this.name.split(":")[1]}`, () => {
             this.__call__();
           }));
@@ -3531,21 +3728,25 @@ var init_mcfunction = __esm(() => {
     __call__ = (..._params) => {
       if (this.env || _params.length !== 0) {
         const args = {};
+        if (this.env) {
+          for (const [i, env] of this.env.entries()) {
+            args[`env_${i}`] = ResolveNBTPart(env);
+            env.local.set(this.name, `env_${i}`);
+          }
+        }
         if (_params.length !== 0) {
           for (const [i, param] of _params.entries()) {
             args[`param_${i}`] = ResolveNBTPart(param);
             param.local.set(this.name, `param_${i}`);
           }
           this.node.body = [];
+          this.core.enterMCFunction(this);
           this.core.insideContext(this.node, () => this.callback(makeCallable(this, this.__call__.bind(undefined, ..._params)), ..._params), false);
+          this.core.exitMCFunction();
+        } else if (this.callback.length > 1) {
+          throw new Error(`[MCFunctionClass] Function ${this.name} expects ${this.callback.length - 1} params at the call-site`);
         }
-        if (this.env) {
-          for (const [i, env] of this.env.entries()) {
-            args[`env_${i}`] = ResolveNBTPart(env);
-            env.local.set(this.name, `env_${i}`);
-          }
-        }
-        return this.commands.functionCmd(this.name, "with", this.pack.ResolveNBT(args).dataPoint);
+        return this.commands.functionCmd(this.name, "with", this.pack.ResolveNBT(args, this.macroPoint).dataPoint);
       }
       return this.commands.functionCmd(this.name);
     };
@@ -3575,12 +3776,14 @@ var init_mcfunction = __esm(() => {
       });
       if (contents[0] instanceof _RawMCFunctionClass) {
         for (const mcfunction of contents) {
+          mcfunction.generate();
           this.node.body.unshift(...mcfunction.node.body);
         }
       } else {
         this.core.enterMCFunction(fake);
         this.core.insideContext(fake.node, contents[0], false);
         this.core.exitMCFunction();
+        fake.generate();
         this.node.body.unshift(...fake.node.body);
       }
     }
@@ -3593,12 +3796,14 @@ var init_mcfunction = __esm(() => {
       const fullBody = [];
       if (contents[0] instanceof _RawMCFunctionClass) {
         for (const mcfunction of contents) {
+          mcfunction.generate();
           fullBody.push(...mcfunction.node.body);
         }
       } else {
         this.core.enterMCFunction(fake);
         this.core.insideContext(fake.node, contents[0], false);
         this.core.exitMCFunction();
+        fake.generate();
         fullBody.push(...fake.node.body);
       }
       this.node.body.splice(start, removeItems === "auto" ? fullBody.length : removeItems, ...fullBody);
@@ -3686,42 +3891,6 @@ var init_setblock = __esm(() => {
   };
 });
 
-// src/commands/implementations/server/function.ts
-var FUNCTION_COMMAND_NODE_BRAND, FunctionCommandNode, FunctionCommand;
-var init_function = __esm(() => {
-  init_nodes();
-  init_tag();
-  init_NBTs();
-  FUNCTION_COMMAND_NODE_BRAND = Symbol.for("sandstone.FunctionCommandNode");
-  FunctionCommandNode = class FunctionCommandNode extends CommandNode {
-    [FUNCTION_COMMAND_NODE_BRAND] = true;
-    command = "function";
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[FUNCTION_COMMAND_NODE_BRAND] === true;
-    }
-  };
-  FunctionCommand = class FunctionCommand extends CommandArguments {
-    NodeType = FunctionCommandNode;
-    function(mcFunction, params, pointOrType, target, path) {
-      const args = [];
-      if (params) {
-        if (params === "with" && pointOrType) {
-          args.push("with");
-          if (typeof pointOrType === "string") {
-            args.push(pointOrType, target, path ?? "{}");
-          } else {
-            const point = Object.hasOwn(pointOrType, "_toDataPoint") ? pointOrType._toDataPoint : pointOrType;
-            args.push(point.type, point.currentTarget, point.path);
-          }
-        } else {
-          args.push(typeof params === "object" && params.toMacro ? params : nbtStringifier(params));
-        }
-      }
-      return this.finalCommand([mcFunction instanceof TagClass ? `#${mcFunction}` : mcFunction, ...args]);
-    }
-  };
-});
-
 // src/commands/implementations/entity/execute.ts
 function createDeferredMacroExecute(pack, executeChain, options) {
   const { childFunctionName, prependArgs } = options;
@@ -3744,7 +3913,7 @@ function createDeferredMacroExecute(pack, executeChain, options) {
             childFunctionNode = childFunction.node;
           } else {
             const childFunction = pack.MCFunction(`${currentFunction.resource.name}/${childFunctionName}`, () => {}, { creator: "sandstone", onConflict: "rename" });
-            pack.commands.functionCmd(childFunction.name, "with", "storage", options.macroStorage);
+            pack.commands.functionCmd(childFunction.name, "with", "storage", options.macroStorage.currentTarget, options.macroStorage.path);
             childFunctionNode = childFunction.node;
           }
           childFunctionNode.body.push(macroNode);
@@ -3828,15 +3997,15 @@ var init_execute = __esm(() => {
     isSingleExecute;
     givenCallbackName;
     macroStorage;
-    constructor(sandstonePack, args = [], { isFake = false, isSingleExecute = true, givenCallbackName = undefined, body = [], macroStorage = undefined } = {}) {
+    pendingCommit;
+    createdMCFunction = null;
+    constructor(sandstonePack, args = [], { isFake = false, isSingleExecute = true, givenCallbackName = undefined, body = [], macroStorage = undefined, pendingCommit = false } = {}) {
       super(sandstonePack, ...args);
       this.givenCallbackName = givenCallbackName;
       this.isSingleExecute = isSingleExecute;
       this.isFake = isFake;
       this.macroStorage = macroStorage;
-      if (macroStorage) {
-        this.isMacro = true;
-      }
+      this.pendingCommit = pendingCommit;
       this.append(...body);
     }
     get callbackName() {
@@ -3847,6 +4016,9 @@ var init_execute = __esm(() => {
         this.body.push(node);
         if (this.isSingleExecute) {
           this.sandstoneCore.getCurrentMCFunctionOrThrow().exitContext();
+          if (this.pendingCommit && !this.commited) {
+            this.commit();
+          }
         }
       }
       return nodes.length === 1 ? nodes[0] : nodes;
@@ -3895,9 +4067,10 @@ var init_execute = __esm(() => {
       });
       const mcFunctionNode = mcFunction.node;
       mcFunctionNode.body = this.body;
+      this.createdMCFunction = mcFunction;
       const mcFunctionCall = new FunctionCommandNode(this.sandstonePack, mcFunction);
       if (this.macroStorage) {
-        mcFunctionCall.args.push("with", "storage", this.macroStorage, "");
+        mcFunctionCall.args.push("with", "storage", this.macroStorage.currentTarget, this.macroStorage.path);
       }
       this.body = [mcFunctionCall];
       return { node: this, mcFunction: mcFunctionNode };
@@ -3910,20 +4083,30 @@ var init_execute = __esm(() => {
     block = (targetPos, path, type, scale) => this.nestedExecute(["block", coordinatesParser(targetPos), path, type, scale]);
     bossbar = (id2, type) => this.nestedExecute(["bossbar", id2, type]);
     entity = (target, path, type, scale) => this.nestedExecute(["entity", targetParser(target), path, type, scale]);
-    score(...args) {
-      if (isScore(args[0])) {
-        return this.nestedExecute(["score", args[0]]);
-      }
-      return this.nestedExecute(["score", targetParser(args[0]), args[1]]);
-    }
+    score = (targets, objective) => this.nestedExecute(["score", targetParser(targets), objective]);
     storage = (target, path, type, scale = 1) => this.nestedExecute(["storage", target, path, type, scale]);
   };
   ExecuteStoreCommand = class ExecuteStoreCommand extends ExecuteCommandPart {
+    _storeCallable(cmd, target, type, scale) {
+      if (isScore(target)) {
+        return cmd.score(target.target, target.objective);
+      }
+      const resolvedType = type ?? "int";
+      if (target.type === "block") {
+        return cmd.block(coordinatesParser(target.currentTarget), target.path, resolvedType, scale);
+      }
+      if (target.type === "entity") {
+        return cmd.entity(target.currentTarget, target.path, resolvedType, scale);
+      }
+      return cmd.storage(target.currentTarget, target.path, resolvedType, scale);
+    }
     get result() {
-      return this.subCommand([["result"]], ExecuteStoreArgsCommand, false);
+      const cmd = this.subCommand([["result"]], ExecuteStoreArgsCommand, false);
+      return makeCallable(cmd, (target, type, scale) => this._storeCallable(cmd, target, type, scale), true);
     }
     get success() {
-      return this.subCommand([["success"]], ExecuteStoreArgsCommand, false);
+      const cmd = this.subCommand([["success"]], ExecuteStoreArgsCommand, false);
+      return makeCallable(cmd, (target, type, scale) => this._storeCallable(cmd, target, type, scale), true);
     }
   };
   ExecuteDataArgsCommand = class ExecuteDataArgsCommand extends ExecuteCommandPart {
@@ -4048,6 +4231,9 @@ var init_execute = __esm(() => {
       const node = this.getNode();
       const commands = new Proxy(this.sandstonePack.commands, {
         get: (_t, p, _r) => {
+          if (!node.commited) {
+            node.pendingCommit = true;
+          }
           this.sandstoneCore.getCurrentMCFunctionOrThrow().enterContext(node, false);
           return this.sandstonePack.commands[p];
         }
@@ -4058,7 +4244,7 @@ var init_execute = __esm(() => {
           node.givenCallbackName = args[0];
         }
         node.isSingleExecute = false;
-        this.sandstoneCore.insideContext(node, callback, false);
+        this.sandstoneCore.insideContext(node, callback, !node.commited);
         return new FinalCommandOutput(node);
       }, true);
     }
@@ -4278,7 +4464,7 @@ class UUIDClass {
     }
     if (this.data || this.scores) {
       const pack = this.core.pack;
-      const { MCFunction, getTempStorage, commands: commands2 } = pack;
+      const { MCFunction, getTempStorage, commands: commands2, Macro, Data } = pack;
       const { data } = commands2;
       let sourceData = this.data;
       if (!sourceData && this.scores) {
@@ -4292,15 +4478,15 @@ class UUIDClass {
       tempUUID.set(sourceData);
       const cacheKeyVar = this.primarySource === "scores" && this.scores ? this.scores[0] : tempUUID;
       const currentFunction = this.core.getCurrentMCFunctionOrThrow();
-      const lookupFunction = MCFunction(`${currentFunction.resource.name}/__uuid_lookup`, [cacheKeyVar], () => {
-        data.modify.storage("__sandstone:temp", "uuid_string").set.from.storage(UUID_CACHE.STORAGE, '"$(env_0)"');
-      }, { creator: "sandstone", onConflict: "rename" });
-      lookupFunction();
+      const uuidLookup = Data("storage", "__sandstone:temp", "uuid_lookup");
+      MCFunction(`${currentFunction.resource.name}/__uuid_lookup`, [cacheKeyVar], () => {
+        Macro.data.modify(uuidLookup.select("uuid_string")).set.from.storage(UUID_CACHE.STORAGE, Macro`"${cacheKeyVar}"`);
+      }, { creator: "sandstone", onConflict: "rename" })();
       const deferredExecute = new ExecuteCommand(pack, undefined, false);
       return createDeferredMacroExecute(pack, deferredExecute, {
         childFunctionName: "__uuid_execute",
         prependArgs: () => [["as", "$(uuid_string)"]],
-        macroStorage: "__sandstone:temp"
+        macroStorage: uuidLookup
       });
     }
     throw new Error("Cannot use execute on a UUID with no available source. " + "The UUID must have at least one of: known value, selector, data, or scores.");
@@ -5325,7 +5511,7 @@ var init_reload = __esm(() => {
 });
 
 // src/commands/implementations/server/return.ts
-var RETURN_RUN_COMMAND_NODE_BRAND, ReturnRunCommandNode, ReturnArgumentsCommand, ReturnCommandNode, ReturnCommand;
+var RETURN_RUN_COMMAND_NODE_BRAND, ReturnRunCommandNode, ReturnArgumentsCommand, RETURN_COMMAND_NODE_BRAND, ReturnCommandNode, ReturnCommand;
 var init_return = __esm(() => {
   init_nodes();
   init_utils();
@@ -5335,9 +5521,11 @@ var init_return = __esm(() => {
     [RETURN_RUN_COMMAND_NODE_BRAND] = true;
     command = "return";
     isSingleExecute;
-    constructor(sandstonePack, args = [], { isSingleExecute = true, body = [] } = {}) {
+    isFlowControl;
+    constructor(sandstonePack, args = [], { isSingleExecute = true, body = [], isFlowControl = false } = {}) {
       super(sandstonePack, ...args);
       this.isSingleExecute = isSingleExecute;
+      this.isFlowControl = isFlowControl;
       this.append(...body);
     }
     getValue = () => {
@@ -5397,8 +5585,13 @@ var init_return = __esm(() => {
       }, true);
     }
   };
+  RETURN_COMMAND_NODE_BRAND = Symbol.for("sandstone.ReturnCommandNode");
   ReturnCommandNode = class ReturnCommandNode extends CommandNode {
+    [RETURN_COMMAND_NODE_BRAND] = true;
     command = "return";
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[RETURN_COMMAND_NODE_BRAND] === true;
+    }
   };
   ReturnCommand = class ReturnCommand extends CommandArguments {
     NodeType = ReturnCommandNode;
@@ -5580,8 +5773,8 @@ var init_version = __esm(() => {
 // src/commands/implementations/world/data.ts
 var DataCommandNode, DataCommand, DataGetCommand, DataMergeCommand, DataModifyFromCommand, DataModifyValuesCommand, DataModifyTypeCommand, DataModifyCommand, DataRemoveCommand;
 var init_data = __esm(() => {
-  init_core();
   init_nodes();
+  init_utils();
   init_NBTs();
   init_parsers();
   DataCommandNode = class DataCommandNode extends CommandNode {
@@ -5590,22 +5783,55 @@ var init_data = __esm(() => {
   DataCommand = class DataCommand extends CommandArguments {
     NodeType = DataCommandNode;
     get get() {
-      return this.subCommand(["get"], DataGetCommand, false);
+      const cmd = this.subCommand(["get"], DataGetCommand, false);
+      return makeCallable(cmd, (dataPoint, scale) => {
+        if (dataPoint.type === "block") {
+          return cmd.block(coordinatesParser(dataPoint.currentTarget), dataPoint.path, scale);
+        }
+        if (dataPoint.type === "entity") {
+          return cmd.entity(dataPoint.currentTarget, dataPoint.path, scale);
+        }
+        return cmd.storage(dataPoint.currentTarget, dataPoint.path, scale);
+      });
     }
     get merge() {
       return this.subCommand(["merge"], DataMergeCommand, false);
     }
     get modify() {
-      return this.subCommand(["modify"], DataModifyCommand, false);
+      const cmd = this.subCommand(["modify"], DataModifyCommand, false);
+      return makeCallable(cmd, (dataPoint) => {
+        if (dataPoint.type === "block") {
+          return cmd.block(coordinatesParser(dataPoint.currentTarget), dataPoint.path);
+        }
+        if (dataPoint.type === "entity") {
+          return cmd.entity(dataPoint.currentTarget, dataPoint.path);
+        }
+        return cmd.storage(dataPoint.currentTarget, dataPoint.path);
+      });
     }
     get remove() {
-      return this.subCommand(["remove"], DataRemoveCommand, false);
+      const cmd = this.subCommand(["remove"], DataRemoveCommand, false);
+      return makeCallable(cmd, (dataPoint) => {
+        if (dataPoint.type === "block") {
+          return cmd.block(coordinatesParser(dataPoint.currentTarget), dataPoint.path);
+        }
+        if (dataPoint.type === "entity") {
+          return cmd.entity(dataPoint.currentTarget, dataPoint.path);
+        }
+        return cmd.storage(dataPoint.currentTarget, dataPoint.path);
+      });
     }
   };
   DataGetCommand = class DataGetCommand extends CommandArguments {
-    block = (targetPos, path, scale) => this.finalCommand(["block", coordinatesParser(targetPos), path, scale]);
-    entity = (target, path, scale) => this.finalCommand(["entity", targetParser(target), path, scale]);
-    storage = (target, path, scale) => this.finalCommand(["storage", target, path, scale]);
+    block = (targetPos, path, scale) => {
+      return this.finalCommand(["block", coordinatesParser(targetPos), path, scale]);
+    };
+    entity = (target, path, scale) => {
+      return this.finalCommand(["entity", targetParser(target), path, scale]);
+    };
+    storage = (target, path, scale) => {
+      return this.finalCommand(["storage", target, path, scale]);
+    };
   };
   DataMergeCommand = class DataMergeCommand extends CommandArguments {
     block = (targetPos, nbt2) => this.finalCommand(["block", coordinatesParser(targetPos), nbtStringifier(nbt2)]);
@@ -5615,20 +5841,22 @@ var init_data = __esm(() => {
   DataModifyFromCommand = class DataModifyFromCommand extends CommandArguments {
     block = (sourcePosition, sourcePath) => this.finalCommand(["block", coordinatesParser(sourcePosition), sourcePath]);
     entity = (source, sourcePath) => this.finalCommand(["entity", targetParser(source), sourcePath]);
-    storage(source, sourcePath) {
-      let storageArg;
-      if (isMacroArgument(this.sandstoneCore, source) || typeof source === "string") {
-        storageArg = source;
-      } else {
-        const dataPoint = source;
-        storageArg = `${dataPoint.currentTarget} ${dataPoint.path}`;
-      }
-      return this.finalCommand(["storage", storageArg, sourcePath]);
-    }
+    storage = (source, sourcePath) => {
+      return this.finalCommand(["storage", source, sourcePath]);
+    };
   };
   DataModifyValuesCommand = class DataModifyValuesCommand extends CommandArguments {
     get from() {
-      return this.subCommand(["from"], DataModifyFromCommand, false);
+      const cmd = this.subCommand(["from"], DataModifyFromCommand, false);
+      return makeCallable(cmd, (dataPoint) => {
+        if (dataPoint.type === "block") {
+          return cmd.block(coordinatesParser(dataPoint.currentTarget), dataPoint.path);
+        }
+        if (dataPoint.type === "entity") {
+          return cmd.entity(dataPoint.currentTarget, dataPoint.path);
+        }
+        return cmd.storage(dataPoint.currentTarget, dataPoint.path);
+      });
     }
     string = {
       block: (sourcePosition, sourcePath, start, end) => {
@@ -5687,14 +5915,26 @@ var init_data = __esm(() => {
     }
   };
   DataModifyCommand = class DataModifyCommand extends CommandArguments {
-    block = (targetPos, targetPath) => this.subCommand(["block", coordinatesParser(targetPos), targetPath], DataModifyTypeCommand, false);
-    entity = (target, targetPath) => this.subCommand(["entity", targetParser(target), targetPath], DataModifyTypeCommand, false);
-    storage = (target, targetPath) => this.subCommand(["storage", target, targetPath], DataModifyTypeCommand, false);
+    block = (targetPos, targetPath) => {
+      return this.subCommand(["block", coordinatesParser(targetPos), targetPath], DataModifyTypeCommand, false);
+    };
+    entity = (target, targetPath) => {
+      return this.subCommand(["entity", targetParser(target), targetPath], DataModifyTypeCommand, false);
+    };
+    storage = (target, targetPath) => {
+      return this.subCommand(["storage", target, targetPath], DataModifyTypeCommand, false);
+    };
   };
   DataRemoveCommand = class DataRemoveCommand extends CommandArguments {
-    block = (targetPos, targetPath) => this.finalCommand(["block", coordinatesParser(targetPos), targetPath]);
-    entity = (target, targetPath) => this.finalCommand(["entity", targetParser(target), targetPath]);
-    storage = (target, targetPath) => this.finalCommand(["storage", target, targetPath]);
+    block = (targetPos, targetPath) => {
+      return this.finalCommand(["block", coordinatesParser(targetPos), targetPath]);
+    };
+    entity = (target, targetPath) => {
+      return this.finalCommand(["entity", targetParser(target), targetPath]);
+    };
+    storage = (target, targetPath) => {
+      return this.finalCommand(["storage", target, targetPath]);
+    };
   };
 });
 
@@ -6580,11 +6820,11 @@ var init_dataPoint = __esm(() => {
       const { execute: execute2 } = commands2;
       const anon = DataVariable(this.dataPoint);
       this.conditional = Variable();
-      execute2.store.result.score(this.conditional).run(() => anon.set(this.value));
+      execute2.store.result(this.conditional).run(() => anon.set(this.value));
     }
     getValue = (negated) => (negated ? ["if", ...this.getCondition()] : ["unless", ...this.getCondition()]).join(" ");
     getCondition() {
-      return ["score", "matches", "0.."];
+      return ["score", this.conditional, "matches", "0.."];
     }
   };
 });
@@ -6671,7 +6911,7 @@ var init_command = __esm(() => {
       this.result = result;
       const store = sandstoneCore.pack.commands.execute.store[type];
       this.variable = sandstoneCore.pack.Variable(undefined, "condition");
-      command(store.score(this.variable));
+      command(store(this.variable));
     }
     getCondition() {
       if (this.type === "success") {
@@ -6723,11 +6963,13 @@ var init_loaded = __esm(() => {
 });
 
 // src/flow/conditions/variables/score.ts
-var ScoreConditionNode;
+var SCORE_CONDITION_NODE_BRAND, ScoreConditionNode;
 var init_score = __esm(() => {
   init_condition();
+  SCORE_CONDITION_NODE_BRAND = Symbol.for("sandstone.ScoreConditionNode");
   ScoreConditionNode = class ScoreConditionNode extends SingleConditionNode {
     args;
+    [SCORE_CONDITION_NODE_BRAND] = true;
     constructor(sandstoneCore, args) {
       super(sandstoneCore);
       this.args = args;
@@ -6735,6 +6977,9 @@ var init_score = __esm(() => {
     getCondition() {
       return ["score", ...this.args];
     }
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[SCORE_CONDITION_NODE_BRAND] === true;
+    }
   };
 });
 
@@ -6837,7 +7082,7 @@ class IfStatement {
     this.node = new IfNode(sandstoneCore, condition2, callback);
   }
   elseIf = (condition2, callback) => {
-    const statement = new IfStatement(this.sandstoneCore, this.sandstoneCore.pack.flow.conditionToNode(condition2), callback);
+    const statement = new IfStatement(this.sandstoneCore, conditionToNode(condition2), callback);
     this.node.nextFlowNode = statement.getNode();
     statement.node._isElseIf = true;
     return statement;
@@ -6865,6 +7110,7 @@ var IF_NODE_BRAND, IfNode, ELSE_NODE_BRAND, ElseNode;
 var init_if_else = __esm(() => {
   init_core();
   init_utils();
+  init_Flow();
   IF_NODE_BRAND = Symbol.for("sandstone.IfNode");
   IfNode = class IfNode extends ContainerNode {
     condition;
@@ -6872,10 +7118,14 @@ var init_if_else = __esm(() => {
     [IF_NODE_BRAND] = true;
     nextFlowNode;
     _isElseIf = false;
-    constructor(sandstoneCore, condition2, callback) {
+    parentMCFunction;
+    givenCallbackName;
+    resultingExecuteNode;
+    constructor(sandstoneCore, condition2, callback, parentMCFunction) {
       super(sandstoneCore);
       this.condition = condition2;
       this.callback = callback;
+      this.parentMCFunction = parentMCFunction ?? sandstoneCore.getCurrentMCFunctionOrThrow();
       if (callback && callback.toString() !== "() => {}") {
         this.sandstoneCore.insideContext(this, callback, true);
       }
@@ -6917,26 +7167,6 @@ ${indent}${nextFormatting}`;
 });
 
 // src/flow/loops/binary_for.ts
-function binaryFor(flow, from, to, callback, maximum = 128) {
-  if (typeof from === "number" && typeof to === "number") {
-    callback(to - from);
-  }
-  const { Variable } = flow.sandstoneCore.pack;
-  const realStart = from instanceof Score ? from : Variable(from);
-  const realEnd = to instanceof Score ? to : Variable(to);
-  const iterations = realEnd.minus(realStart);
-  const _ = flow;
-  _.while(iterations.lessThan(maximum), () => {
-    callback(maximum);
-    iterations.remove(maximum);
-  });
-  for (let i = 1;i < maximum; i *= 2) {
-    _.if(iterations.moduloBy(2).equalTo(1), () => {
-      callback(i);
-    });
-    iterations.dividedBy(2);
-  }
-}
 var init_binary_for = __esm(() => {
   init_variables();
 });
@@ -6946,16 +7176,18 @@ var LoopNode;
 var init_loop = __esm(() => {
   init_core();
   LoopNode = class LoopNode extends ContainerNode {
-    executeArgs;
+    condition;
     callback;
     loopback;
-    constructor(sandstoneCore, executeArgs, callback, loopback) {
+    parentMCFunction;
+    constructor(sandstoneCore, condition2, callback, loopback) {
       super(sandstoneCore);
-      this.executeArgs = executeArgs;
+      this.condition = condition2;
       this.callback = callback;
       this.loopback = loopback;
+      const currentNode = this.sandstoneCore.getCurrentMCFunctionOrThrow();
+      this.parentMCFunction = currentNode;
       if (callback.toString() !== "() => {}") {
-        const currentNode = this.sandstoneCore.getCurrentMCFunctionOrThrow();
         currentNode.enterContext(this);
         this.callback();
         this.loopback();
@@ -6968,6 +7200,75 @@ var init_loop = __esm(() => {
   };
 });
 
+// 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;
@@ -6988,43 +7289,64 @@ class ForIStatement {
 }
 var ForINode;
 var init_for_i = __esm(() => {
-  init_commands2();
   init_variables();
+  init_flow();
+  init_if_else();
   init_loop();
+  init_staticAnalysis();
   ForINode = class ForINode extends LoopNode {
     constructor(sandstoneCore, initialValue, endCondition, iterate, callback) {
       const iterator = sandstoneCore.pack.Variable(initialValue, "loop_iterator");
-      const condition2 = sandstoneCore.pack._.conditionToNode(endCondition(iterator));
-      const value = condition2.getValue().split(" ");
-      const conditionValue = [value[0], value.slice(1).join(" ")];
-      const _continue = () => sandstoneCore.pack.commands.returnCmd.run(() => new ExecuteCommandNode(sandstoneCore.pack, [conditionValue], {
-        body: [new LoopArgument(sandstoneCore.pack)]
-      }));
-      callback(iterator, _continue);
-      iterate(iterator);
-      super(sandstoneCore, [conditionValue], () => callback(iterator, _continue), () => {
+      const condition2 = conditionToNode(endCondition(iterator));
+      const _continue = () => sandstoneCore.pack.commands.returnCmd.run(() => new IfStatement(sandstoneCore, condition2, () => new LoopArgument(sandstoneCore.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(sandstoneCore, condition2, () => callback(iterator, _continue), () => {
         iterate(iterator);
-        return new ExecuteCommandNode(sandstoneCore.pack, [conditionValue], {
-          body: [new LoopArgument(sandstoneCore.pack)]
-        });
+        new IfStatement(sandstoneCore, condition2, () => new LoopArgument(sandstoneCore.pack));
       });
     }
   };
 });
 
 // src/flow/loops/for_of.ts
+function isMultipleVariable(iteratorType) {
+  if (Array.isArray(iteratorType)) {
+    return true;
+  }
+  return false;
+}
+function isMapIterator(iteratorType, iterable) {
+  if (isMultipleVariable(iteratorType) && iteratorType[0] === "key") {
+    if (iterable.iteratorType === "map") {
+      return true;
+    }
+    throw new Error('Attempt to use "for key value" loop with a List iterable; this is not supported. (Hint: use "for entry" or "for i entry" instead)');
+  }
+  return false;
+}
+
 class ForOfStatement {
   sandstoneCore;
   iteratorType;
+  direction;
   iterable;
   callback;
   node;
-  constructor(sandstoneCore, iteratorType, iterable, callback) {
+  constructor(sandstoneCore, iteratorType, direction, iterable, callback) {
     this.sandstoneCore = sandstoneCore;
     this.iteratorType = iteratorType;
+    this.direction = direction;
     this.iterable = iterable;
     this.callback = callback;
-    this.node = new ForOfNode(sandstoneCore, iteratorType, iterable, callback);
+    this.node = new ForOfNode(sandstoneCore, iteratorType, direction, iterable, callback);
   }
   getNode = () => this.node;
 }
@@ -7034,35 +7356,31 @@ var init_for_of = __esm(() => {
   init_if_else();
   init_loop();
   ForOfNode = class ForOfNode extends LoopNode {
-    constructor(sandstoneCore, iteratorType, iterable, callback) {
-      const _iterable = iterable._toDataPoint();
-      let startCondition;
+    constructor(sandstoneCore, iteratorType, direction, iterable, callback) {
       let iterate;
-      let continueCondition;
-      if (Array.isArray(iteratorType)) {
-        if (iteratorType[0] === "key") {
-          startCondition = ["if", "data", _iterable.type, `${_iterable.path}{}`];
+      if (isMultipleVariable(iteratorType)) {
+        if (isMapIterator(iteratorType, iterable)) {
           iterate = iterable.iterator((dataPoints) => {
-            if (dataPoints.length === 1) {
-              throw new Error('Error: Attempt to use "for key value" loop with an Array dataset; this is not supported. (Hint: use "for entry" or "for i entry" instead)');
-            }
             callback(...[dataPoints[0], dataPoints[1]]);
-          });
+          }, direction);
         } else {
-          startCondition = ["if", "data", _iterable.type, `${_iterable.path}{}`];
-          const _iterator = sandstoneCore.pack.Variable();
-          _iterator.set(iterable.size());
-          continueCondition = _iterator["!="](-1);
+          const _iterator = sandstoneCore.pack.Variable(direction === "normal" ? -1 : undefined);
+          if (direction === "reverse") {
+            _iterator.set(iterable.size());
+          }
           iterate = iterable.iterator((dataPoints) => {
-            _iterator.decrease();
+            if (direction === "normal") {
+              _iterator.increase();
+            } else {
+              _iterator.decrease();
+            }
             if (dataPoints.length === 1) {
               return callback(...[_iterator, dataPoints[0]]);
             }
             return callback(...[_iterator, dataPoints[1]]);
-          });
+          }, direction);
         }
       } else {
-        startCondition = ["if", "data", _iterable.type, `${_iterable.path}{}`];
         iterate = iterable.iterator((dataPoints) => {
           if (dataPoints.length === 1) {
             return callback(...[dataPoints[0]]);
@@ -7070,8 +7388,8 @@ var init_for_of = __esm(() => {
           return callback(...[dataPoints[1]]);
         });
       }
-      iterate();
-      super(sandstoneCore, [startCondition], () => iterate, () => new IfStatement(sandstoneCore, continueCondition || iterable.continue, () => new LoopArgument(sandstoneCore.pack)));
+      const continueCondition = iterable.continue(direction);
+      super(sandstoneCore, continueCondition, () => iterate, () => new IfStatement(sandstoneCore, continueCondition, () => new LoopArgument(sandstoneCore.pack)));
     }
   };
 });
@@ -7093,11 +7411,12 @@ var WhileNode;
 var init_while = __esm(() => {
   init_variables();
   init_if_else();
+  init_flow();
   init_loop();
   WhileNode = class WhileNode extends LoopNode {
     constructor(sandstoneCore, condition2, callback) {
-      const _condition = sandstoneCore.pack._.conditionToNode(condition2);
-      super(sandstoneCore, [_condition.getValue().split(" ")], callback, () => new IfStatement(sandstoneCore, _condition, () => new LoopArgument(sandstoneCore.pack)));
+      const _condition = conditionToNode(condition2);
+      super(sandstoneCore, _condition, callback, () => new IfStatement(sandstoneCore, _condition, () => new LoopArgument(sandstoneCore.pack)));
     }
   };
 });
@@ -7111,29 +7430,77 @@ var init_loops = __esm(() => {
 });
 
 // src/flow/switch_case.ts
-var CASE_STATEMENT_BRAND, CaseStatement;
+function isConditionCase(c) {
+  return typeof c === "function";
+}
+function executeSwitch(sandstoneCore, value, _cases) {
+  let staticCaseEntries = [];
+  let conditionCaseEntries = [];
+  let _default;
+  if (_cases instanceof CaseStatement) {
+    staticCaseEntries = _cases.getStaticCases();
+    conditionCaseEntries = _cases.getConditionCases();
+  } else if (Array.isArray(_cases)) {
+    for (const _case of _cases) {
+      if (_case[0] === "default") {
+        _default = _case;
+        continue;
+      }
+      const [, condition2, callback] = _case;
+      if (isConditionCase(condition2)) {
+        conditionCaseEntries.push({ type: "condition", condition: condition2, callback });
+      } else {
+        staticCaseEntries.push({ type: "static", value: condition2, callback });
+      }
+    }
+  } else {
+    for (const _case of _cases.entries) {
+      if (_case.type === "condition") {
+        conditionCaseEntries.push(_case);
+      } else {
+        staticCaseEntries.push(_case);
+      }
+    }
+    if (_cases.default) {
+      _default = ["default", _cases.default];
+    }
+  }
+  const staticCaseNodes = staticCaseEntries.map((c) => new StaticCaseNode(sandstoneCore, c.value, c.callback));
+  const conditionCaseNodes = conditionCaseEntries.map((c) => new ConditionCaseNode(sandstoneCore, c.condition, c.callback));
+  const defaultCaseNode = _default ? new DefaultCaseNode(sandstoneCore, _default[1]) : undefined;
+  new SwitchNode(sandstoneCore, value, staticCaseNodes, conditionCaseNodes, defaultCaseNode);
+}
+var CASE_STATEMENT_BRAND, CaseStatement, SwitchNode, StaticCaseNode, ConditionCaseNode, DefaultCaseNode;
 var init_switch_case = __esm(() => {
+  init_core();
   CASE_STATEMENT_BRAND = Symbol.for("sandstone.CaseStatement");
   CaseStatement = class CaseStatement {
-    value;
-    callback;
-    previous;
+    entries;
     [CASE_STATEMENT_BRAND] = true;
-    constructor(value, callback, previous) {
-      this.value = value;
-      this.callback = callback;
-      this.previous = previous;
+    constructor(entries = []) {
+      this.entries = entries;
     }
-    getCases = () => this.previous ? [...this.previous, this] : [this];
-    getValue() {
-      return ["case", this.value, this.callback];
+    getStaticCases() {
+      return this.entries.filter((e) => e.type === "static");
     }
-    case(value, callback) {
-      return new CaseStatement(value, callback, this.getCases());
+    getConditionCases() {
+      return this.entries.filter((e) => e.type === "condition");
+    }
+    case(valueOrCondition, callback) {
+      if (typeof valueOrCondition === "function") {
+        return new CaseStatement([
+          ...this.entries,
+          { type: "condition", condition: valueOrCondition, callback }
+        ]);
+      }
+      return new CaseStatement([
+        ...this.entries,
+        { type: "static", value: valueOrCondition, callback }
+      ]);
     }
     default(callback) {
       return {
-        cases: this.getCases(),
+        entries: this.entries,
         default: callback
       };
     }
@@ -7141,24 +7508,83 @@ var init_switch_case = __esm(() => {
       return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[CASE_STATEMENT_BRAND] === true;
     }
   };
+  SwitchNode = class SwitchNode extends ContainerNode {
+    value;
+    staticCases;
+    conditionCases;
+    defaultCase;
+    parentMCFunction;
+    constructor(sandstoneCore, value, staticCases, conditionCases, defaultCase) {
+      super(sandstoneCore);
+      this.value = value;
+      this.staticCases = staticCases;
+      this.conditionCases = conditionCases;
+      this.defaultCase = defaultCase;
+      this.parentMCFunction = sandstoneCore.getCurrentMCFunctionOrThrow();
+      this.parentMCFunction.enterContext(this);
+      for (const caseNode of [...staticCases, ...conditionCases]) {
+        this.parentMCFunction.enterContext(caseNode);
+        caseNode.callback();
+        this.parentMCFunction.exitContext();
+      }
+      if (defaultCase) {
+        this.parentMCFunction.enterContext(defaultCase);
+        defaultCase.callback();
+        this.parentMCFunction.exitContext();
+      }
+      this.parentMCFunction.exitContext();
+    }
+    getValue = () => {
+      throw new Error("SwitchNode must be transformed by SwitchTransformationVisitor");
+    };
+  };
+  StaticCaseNode = class StaticCaseNode extends ContainerNode {
+    value;
+    callback;
+    constructor(sandstoneCore, value, callback) {
+      super(sandstoneCore);
+      this.value = value;
+      this.callback = callback;
+    }
+    getValue = () => null;
+  };
+  ConditionCaseNode = class ConditionCaseNode extends ContainerNode {
+    condition;
+    callback;
+    constructor(sandstoneCore, condition2, callback) {
+      super(sandstoneCore);
+      this.condition = condition2;
+      this.callback = callback;
+    }
+    getValue = () => null;
+  };
+  DefaultCaseNode = class DefaultCaseNode extends ContainerNode {
+    callback;
+    constructor(sandstoneCore, callback) {
+      super(sandstoneCore);
+      this.callback = callback;
+    }
+    getValue = () => null;
+  };
 });
 
 // src/flow/Flow.ts
+function conditionToNode(condition2) {
+  if (!(condition2 instanceof ConditionNode)) {
+    return condition2._toMinecraftCondition();
+  }
+  return condition2;
+}
+
 class Flow {
   sandstoneCore;
   constructor(sandstoneCore) {
     this.sandstoneCore = sandstoneCore;
   }
-  conditionToNode(condition2) {
-    if (!(condition2 instanceof ConditionNode)) {
-      return condition2._toMinecraftCondition();
-    }
-    return condition2;
-  }
-  if = (condition2, callback) => new IfStatement(this.sandstoneCore, this.conditionToNode(condition2), callback);
-  and = (...conditions) => new AndNode(this.sandstoneCore, conditions.map((condition2) => this.conditionToNode(condition2)));
-  or = (...conditions) => new OrNode(this.sandstoneCore, conditions.map((condition2) => this.conditionToNode(condition2)));
-  not = (condition2) => new NotNode(this.sandstoneCore, this.conditionToNode(condition2));
+  if = (condition2, callback) => new IfStatement(this.sandstoneCore, conditionToNode(condition2), callback);
+  and = (...conditions) => new AndNode(this.sandstoneCore, conditions.map((condition2) => conditionToNode(condition2)));
+  or = (...conditions) => new OrNode(this.sandstoneCore, conditions.map((condition2) => conditionToNode(condition2)));
+  not = (condition2) => new NotNode(this.sandstoneCore, conditionToNode(condition2));
   get return() {
     return this.sandstoneCore.pack.commands.returnCmd;
   }
@@ -7181,77 +7607,56 @@ Sandstone Pack Error:
     if (broadcast !== false) {
       tellraw2(broadcast || "@a", fullError);
     }
-    const errorString = parseJSONText(this.sandstoneCore, fullError);
+    const errorSerializable = parseJSONText(this.sandstoneCore, fullError);
     if (dataPoint2 !== false) {
       let point;
       if (dataPoint2 === undefined) {
-        point = DataVariable(parseJSONText(this.sandstoneCore, fullError));
+        point = DataVariable(errorSerializable.toJSON());
       } else {
-        point = dataPoint2.set(errorString);
+        point = dataPoint2.set(errorSerializable.toJSON());
       }
       returnCmd.fail();
       return point;
     }
     returnCmd.fail();
-    return errorString;
+    return errorSerializable;
   }
   while(condition2, callback) {
-    return new WhileStatement(this.sandstoneCore, this.conditionToNode(condition2), callback);
+    return new WhileStatement(this.sandstoneCore, conditionToNode(condition2), callback);
   }
   doWhile(condition2, callback) {
     callback();
-    return new WhileStatement(this.sandstoneCore, this.conditionToNode(condition2), callback);
+    return new WhileStatement(this.sandstoneCore, conditionToNode(condition2), callback);
   }
   for(arg1, arg2, arg3, arg4) {
     if (typeof arg1 === "number" || arg1 instanceof Score) {
       return new ForIStatement(this.sandstoneCore, arg1, arg2, arg3, arg4);
     }
     if (arg1 === "entry") {
-      return new ForOfStatement(this.sandstoneCore, arg1, arg3, arg4);
+      return new ForOfStatement(this.sandstoneCore, arg1, arg2 === "of-reverse" ? "reverse" : "normal", arg3, arg4);
     }
     if (arg1[0] === "key") {
-      return new ForOfStatement(this.sandstoneCore, arg1, arg3, arg4);
+      return new ForOfStatement(this.sandstoneCore, arg1, arg2 === "of-reverse" ? "reverse" : "normal", arg3, arg4);
     }
     if (typeof arg1[0] === "number" || arg1[0] instanceof Score) {
       if (arg2 === "iterate") {
         return new ForIStatement(this.sandstoneCore, arg1[0], (i) => i["<="](arg1[1]), (i) => i["++"], arg3);
       }
-      return binaryFor(this, arg1[0], arg1[1], arg3, arg1[2]);
     }
-    return new ForOfStatement(this.sandstoneCore, arg1, arg3, arg4);
+    return new ForOfStatement(this.sandstoneCore, arg1, arg2 === "of-reverse" ? "reverse" : "normal", arg3, arg4);
   }
-  switch(value, _cases, _default) {
-    let cases;
-    if (_cases instanceof CaseStatement) {
-      cases = _cases.getCases().map((c) => c.getValue());
-    } else if (Array.isArray(_cases)) {
-      cases = _cases;
-    } else {
-      cases = _cases.cases.map((c) => c.getValue());
-      _default = ["default", _cases.default];
-    }
-    const { Data: Data2, initMCFunction, MCFunction, Macro } = this.sandstoneCore.pack;
-    const id2 = switches++;
-    const values = Data2("storage", `__sandstone:switch_${id2}`, "Values");
-    initMCFunction.push(() => values.set(cases.map(([_, v, callback], i) => {
-      MCFunction(`__sandstone:switch_${id2}_case_${i}`, [], () => callback());
-      return { Value: v, Index: i };
-    })));
-    const flow = this;
-    MCFunction(`__sandstone:switch_${id2}`, [value], () => {
-      const index = Data2("storage", `__sandstone:switch_${id2}`, "Index");
-      Macro.data.modify.storage(index.currentTarget, "Index").set.from.storage(values.currentTarget, Macro`Values[{Value:${value}}}].Index`);
-      const _if = flow.if(index, () => {
-        MCFunction(`__sandstone:switch_${id2}_inner`, [index], () => {
-          Macro.functionCmd(Macro`__sandstone:switch_${id2}_case_${index}`);
-        })();
-      });
-      if (_default)
-        _if.else(() => _default?.[1]());
-    })();
+  switch(value, cases) {
+    executeSwitch(this.sandstoneCore, value, cases);
   }
   case(value, callback) {
-    return new CaseStatement(value, callback);
+    if (typeof value === "function") {
+      return new CaseStatement([
+        { type: "condition", condition: value, callback }
+      ]);
+    }
+    return new CaseStatement([
+      { type: "static", value, callback }
+    ]);
   }
   biome = (coordinates, biome2) => {
     return new SandstoneConditions.Biome(this.sandstoneCore, coordinates, biome2);
@@ -7293,7 +7698,6 @@ Sandstone Pack Error:
     return new SandstoneConditions.Predicate(this.sandstoneCore, predicate2.name);
   };
 }
-var switches = 0;
 var init_Flow = __esm(() => {
   init_variables();
   init_conditions();
@@ -7308,6 +7712,7 @@ var init_flow = __esm(() => {
   init_Flow();
   init_if_else();
   init_loop();
+  init_switch_case();
 });
 
 // src/core/visitors.ts
@@ -7390,6 +7795,10 @@ var init_visitor = __esm(() => {
     visitIfNode;
     visitElseNode;
     visitLoopNode;
+    visitSwitchNode;
+    visitStaticCaseNode;
+    visitConditionCaseNode;
+    visitDefaultCaseNode;
     visitLoopArgumentNode;
     visitAdvancementCommandNode;
     visitAttributeCommandNode;
@@ -7419,6 +7828,7 @@ var init_addAwaitBodyToMCFunctions = __esm(() => {
 // src/pack/visitors/containerCommandsToMCFunction.ts
 var ContainerCommandsToMCFunctionVisitor;
 var init_containerCommandsToMCFunction = __esm(() => {
+  init_commands2();
   init_core();
   init_visitor();
   ContainerCommandsToMCFunctionVisitor = class ContainerCommandsToMCFunctionVisitor extends GenericSandstoneVisitor {
@@ -7438,6 +7848,14 @@ var init_containerCommandsToMCFunction = __esm(() => {
       this.currentMCFunction = node;
       this.core.currentNode = node.resource.name;
       const result = this.genericVisit(node);
+      if (node.resource.creator === "sandstone" && node.body.length > 0) {
+        const lastNode = node.body.at(-1);
+        if (lastNode instanceof FunctionCommandNode) {
+          const returnRunNode = new ReturnRunCommandNode(this.pack, ["run"]);
+          returnRunNode.body = [lastNode];
+          node.body[node.body.length - 1] = returnRunNode;
+        }
+      }
       this.core.currentNode = prev?.resource.name ?? "";
       this.currentMCFunction = prev;
       return result;
@@ -7480,7 +7898,7 @@ function* flattenIfNode(node) {
     yield next;
   }
 }
-function handleMultipleNodes(visitor, nodes) {
+function handleMultipleNodes(visitor, nodes, macroStorage) {
   return nodes.flatMap((node, i) => {
     const { body } = node;
     if (node instanceof IfNode) {
@@ -7491,25 +7909,32 @@ function handleMultipleNodes(visitor, nodes) {
         if (Array.isArray(child)) {
           actualBody = child;
         } else {
-          return new ExecuteCommandNode(visitor.pack, [[node.condition.getValue()]], {
+          return visitor.visit(new ExecuteCommandNode(visitor.pack, [[node.condition.getValue()]], {
             isSingleExecute: false,
             givenCallbackName: callbackName,
-            body: [i === nodes.length - 1 ? child : new ReturnCommandNode(visitor.pack, [`run ${child.getValue()}`])]
-          });
+            body: [i === nodes.length - 1 ? child : new ReturnRunCommandNode(visitor.pack, ["run"], {
+              isSingleExecute: false,
+              isFlowControl: true,
+              body: [child]
+            })],
+            macroStorage
+          }));
         }
       }
-      return new ExecuteCommandNode(visitor.pack, [[node.condition.getValue()]], {
+      return visitor.visit(new ExecuteCommandNode(visitor.pack, [[node.condition.getValue()]], {
         isSingleExecute: false,
         givenCallbackName: `${i}_${callbackName}`,
         body: [
           new ReturnRunCommandNode(visitor.pack, ["run"], {
             isSingleExecute: false,
+            isFlowControl: true,
             body: actualBody
           })
-        ]
-      });
+        ],
+        macroStorage
+      }));
     }
-    return body;
+    return body.flatMap((n) => visitor.visit(n));
   });
 }
 var IfElseTransformationVisitor;
@@ -7523,19 +7948,30 @@ var init_ifElseTransformationVisitor = __esm(() => {
         return [];
       }
       const nodes = Array.from(flattenIfNode(node_));
+      const { parentMCFunction, condition: condition2, givenCallbackName, body } = node_;
+      const callbackName = givenCallbackName ?? "if";
+      const macroStorage = parentMCFunction.resource.macroPoint;
       if (nodes.length === 1) {
-        return this.visit(new ExecuteCommandNode(this.pack, [[node_.condition.getValue()]], {
+        const executeNode = new ExecuteCommandNode(this.pack, [[condition2.getValue()]], {
           isSingleExecute: false,
-          givenCallbackName: "if",
-          body: node_.body
-        }));
+          givenCallbackName: callbackName,
+          body,
+          macroStorage
+        });
+        node_.resultingExecuteNode = executeNode;
+        return this.visit(executeNode);
+      }
+      if (nodes.at(-1) === parentMCFunction.body.at(-1)) {
+        return handleMultipleNodes(this, nodes, macroStorage);
       }
       const wrapper = new ExecuteCommandNode(this.pack, [], {
         isFake: true,
         isSingleExecute: false,
-        givenCallbackName: "if",
-        body: handleMultipleNodes(this, nodes)
+        givenCallbackName: callbackName,
+        body: handleMultipleNodes(this, nodes, macroStorage),
+        macroStorage
       });
+      node_.resultingExecuteNode = wrapper;
       return this.visit(wrapper);
     };
   };
@@ -7544,19 +7980,15 @@ var init_ifElseTransformationVisitor = __esm(() => {
 // src/pack/visitors/initConstantsVisitor.ts
 var InitConstantsVisitor;
 var init_initConstantsVisitor = __esm(() => {
+  init_commands2();
   init_visitor();
   InitConstantsVisitor = class InitConstantsVisitor extends GenericSandstoneVisitor {
     onStart = () => {
       const { pack } = this;
-      const { scoreboard: scoreboard2 } = pack.commands;
-      let constants = [...pack.constants.values()];
-      constants = constants.filter((item2, index) => constants.indexOf(item2) === index);
-      if (constants.length !== 0) {
-        pack.initMCFunction.unshift(() => {
-          for (const constant of constants) {
-            scoreboard2.players.set(constant, pack.rootObjective, constant);
-          }
-        });
+      if (pack.constants.size !== 0) {
+        for (const constant of pack.constants) {
+          pack.initMCFunction.node.body.push(new ScoreboardCommandNode(pack, "players", "set", constant, pack.rootObjective, constant));
+        }
       }
     };
   };
@@ -7632,15 +8064,24 @@ var init_inlineFunctionCallVisitor = __esm(() => {
 // src/pack/visitors/loopTransformationVisitor.ts
 var LoopTransformationVisitor;
 var init_loopTransformationVisitor = __esm(() => {
-  init_commands2();
+  init_flow();
   init_visitor();
   LoopTransformationVisitor = class LoopTransformationVisitor extends GenericSandstoneVisitor {
+    currentLoopIfNode = null;
     visitLoopNode = (node_) => {
-      return new ExecuteCommandNode(this.pack, node_.executeArgs, {
-        isSingleExecute: false,
-        givenCallbackName: "loop",
-        body: node_.body.map((node) => this.genericVisit(node))
-      });
+      const ifNode = new IfNode(this.core, node_.condition, undefined, node_.parentMCFunction);
+      ifNode.givenCallbackName = "loop";
+      const previousLoopIfNode = this.currentLoopIfNode;
+      this.currentLoopIfNode = ifNode;
+      ifNode.body = node_.body.flatMap((node) => this.visit(node));
+      this.currentLoopIfNode = previousLoopIfNode;
+      return ifNode;
+    };
+    visitLoopArgument = (node_) => {
+      if (this.currentLoopIfNode) {
+        node_.loopIfNode = this.currentLoopIfNode;
+      }
+      return node_;
     };
     visitWhileNode = this.visitLoopNode;
     visitForINode = this.visitLoopNode;
@@ -7739,7 +8180,7 @@ var init_simplifyExecuteFunction = __esm(() => {
         return this.genericVisit(node);
       }
       const mcFunction = functionNode.args[0];
-      if (typeof mcFunction === "string") {
+      if (typeof mcFunction === "string" || !mcFunction?.node) {
         return this.genericVisit(node);
       }
       const mcFunctionNode = mcFunction.node;
@@ -7751,11 +8192,33 @@ var init_simplifyExecuteFunction = __esm(() => {
           return this.genericVisit(node);
         }
       }
+      if (command instanceof LoopArgument) {
+        const loopExecute = command.loopIfNode?.resultingExecuteNode;
+        const loopFunctionName = loopExecute?.createdMCFunction?.name;
+        if (loopFunctionName) {
+          node.body = [new FunctionCommandNode(this.pack, loopFunctionName)];
+          if (mcFunction.creator === "sandstone") {
+            this.core.resourceNodes.delete(mcFunctionNode);
+          }
+          return this.genericVisit(node);
+        }
+        return this.genericVisit(node);
+      }
       if (!(command instanceof CommandNode)) {
         return this.genericVisit(node);
       }
-      if (command instanceof LoopArgument) {
-        return new FunctionCommandNode(this.pack, mcFunctionNode.resource.name);
+      if (command instanceof ReturnRunCommandNode) {
+        if (mcFunction.creator === "sandstone") {
+          this.core.resourceNodes.delete(mcFunctionNode);
+        }
+        if (command.isFlowControl) {
+          node.body = [this.genericVisit(command)];
+        } else {
+          const returnCmd = this.visit(command);
+          node.body = returnCmd.body;
+          return this.visitExecuteCommandNode(node);
+        }
+        return this.genericVisit(node);
       }
       if (command instanceof FunctionCommandNode) {
         const innerMCFunction = command.args[0];
@@ -7798,17 +8261,24 @@ var init_simplifyReturnRunFunction = __esm(() => {
   init_nodes();
   init_flow();
   init_visitor();
+  init_Macro();
   SimplifyReturnRunFunctionVisitor = class SimplifyReturnRunFunctionVisitor extends GenericSandstoneVisitor {
     visitReturnRunCommandNode = (node) => {
       if (node.body.length === 0 || node.body.length > 1) {
         return this.genericVisit(node);
       }
-      const functionNode = node.body[0];
-      if (!(functionNode instanceof FunctionCommandNode)) {
+      const childNode = node.body[0];
+      if (!(childNode instanceof FunctionCommandNode)) {
+        if (childNode instanceof ReturnRunCommandNode) {
+          return this.visitReturnRunCommandNode(childNode);
+        }
+        if (childNode instanceof ReturnCommandNode) {
+          return this.genericVisit(childNode);
+        }
         return this.genericVisit(node);
       }
-      const mcFunction = functionNode.args[0];
-      if (typeof mcFunction === "string") {
+      const mcFunction = childNode.args[0];
+      if (typeof mcFunction === "string" || isMacroArgument(this.core, mcFunction)) {
         return this.genericVisit(node);
       }
       const mcFunctionNode = mcFunction.node;
@@ -7824,10 +8294,6 @@ var init_simplifyReturnRunFunction = __esm(() => {
         return this.genericVisit(node);
       }
       if (command instanceof FunctionCommandNode) {
-        const innerMCFunction = command.args[0];
-        if (typeof innerMCFunction === "string") {
-          return this.genericVisit(node);
-        }
         node.body = [command];
         if (mcFunction.creator === "sandstone") {
           this.core.resourceNodes.delete(mcFunctionNode);
@@ -7835,7 +8301,18 @@ var init_simplifyReturnRunFunction = __esm(() => {
         return this.genericVisit(node);
       }
       if (command instanceof ReturnRunCommandNode) {
-        return this.genericVisit(node);
+        node.body = command.body;
+        node.isFlowControl = node.isFlowControl || command.isFlowControl;
+        if (mcFunction.creator === "sandstone") {
+          this.core.resourceNodes.delete(mcFunctionNode);
+        }
+        return this.visitReturnRunCommandNode(node);
+      }
+      if (command instanceof ReturnCommandNode) {
+        if (mcFunction.creator === "sandstone") {
+          this.core.resourceNodes.delete(mcFunctionNode);
+        }
+        return this.genericVisit(command);
       }
       node.body = [this.genericVisit(command)];
       if (mcFunction.creator === "sandstone") {
@@ -7846,6 +8323,233 @@ var init_simplifyReturnRunFunction = __esm(() => {
   };
 });
 
+// src/pack/visitors/switchTransformationVisitor.ts
+var SwitchTransformationVisitor;
+var init_switchTransformationVisitor = __esm(() => {
+  init_commands2();
+  init_core();
+  init_flow();
+  init_variables();
+  init_visitor();
+  SwitchTransformationVisitor = class SwitchTransformationVisitor extends GenericSandstoneVisitor {
+    visitSwitchNode = (node) => {
+      const { value, staticCases, conditionCases, defaultCase, parentMCFunction } = node;
+      const { Data: Data2, initMCFunction, Macro, commands: commands2 } = this.pack;
+      const { functionCmd } = commands2;
+      const parentName = parentMCFunction?.resource.name ?? "__sandstone:switch";
+      const hasStaticCases = staticCases.length > 0;
+      const switchMCFunction = new MCFunctionClass(this.core, `${parentName}/switch`, {
+        addToSandstoneCore: true,
+        creator: "sandstone",
+        onConflict: "rename"
+      }, hasStaticCases ? [value] : undefined);
+      const storageKey = `__sandstone:${switchMCFunction.name.replace(/[:/]/g, "_")}`;
+      const values = Data2("storage", storageKey, "Values");
+      if (hasStaticCases) {
+        const isScoreSwitch = value instanceof Score;
+        if (typeof value.local?.set === "function") {
+          value.local.set(switchMCFunction.name, "env_0");
+        }
+        this.core.enterMCFunction(switchMCFunction);
+        if (isScoreSwitch) {
+          for (const caseNode of staticCases) {
+            const caseMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/case_${caseNode.value}`, {
+              addToSandstoneCore: true,
+              creator: "sandstone",
+              onConflict: "rename"
+            });
+            caseMCFunction.node.body = caseNode.body.flatMap((n) => this.visit(n));
+          }
+          const hasFallback = conditionCases.length > 0 || defaultCase !== undefined;
+          if (hasFallback) {
+            const tryCaseMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/try_case`, {
+              addToSandstoneCore: true,
+              creator: "sandstone",
+              onConflict: "rename"
+            });
+            this.core.enterMCFunction(tryCaseMCFunction);
+            Macro.returnCmd.run.functionCmd(Macro`${switchMCFunction.name}/case_${value}`);
+            this.core.exitMCFunction();
+            const successScore = this.pack.rootObjective("$switch_success");
+            const resultScore = this.pack.rootObjective("$switch_result");
+            commands2.execute.store.success(successScore).store.result(resultScore).run.functionCmd(tryCaseMCFunction.name, "with", switchMCFunction.macroPoint);
+            commands2.execute.if.score(successScore, "matches", 1).run.returnCmd.run.scoreboard.players.get(resultScore);
+            this.buildFallback(undefined, value, conditionCases, defaultCase, switchMCFunction);
+          } else {
+            const dispatchMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/dispatch`, {
+              addToSandstoneCore: true,
+              creator: "sandstone",
+              onConflict: "rename"
+            });
+            this.core.enterMCFunction(dispatchMCFunction);
+            Macro.returnCmd.run.functionCmd(Macro`${switchMCFunction.name}/case_${value}`);
+            this.core.exitMCFunction();
+            commands2.returnCmd.run.functionCmd(dispatchMCFunction.name, "with", switchMCFunction.macroPoint);
+          }
+          const macroPoint = switchMCFunction.macroPoint;
+          const env0Point = macroPoint.select("env_0");
+          commands2.execute.store.result.storage(env0Point.currentTarget, env0Point.path, "int").run.scoreboard.players.get(value);
+          const copyNode = switchMCFunction.node.body.pop();
+          switchMCFunction.node.body.unshift(copyNode);
+          const canInline = parentMCFunction && node === parentMCFunction.body.at(-1);
+          if (canInline) {
+            this.core.exitMCFunction();
+            this.core.resourceNodes.delete(switchMCFunction.node);
+            return switchMCFunction.node.body;
+          }
+        } else {
+          const index = switchMCFunction.macroPoint.select("Index");
+          index.local.set(switchMCFunction.name, "Index");
+          index.remove();
+          Macro.data.modify.storage(index.currentTarget, index.path).set.from.storage(values.currentTarget, Macro`Values[{Value:${value}}].Index`);
+          const caseData = [];
+          for (let i = 0;i < staticCases.length; i++) {
+            const caseNode = staticCases[i];
+            const caseMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/case_${i}`, {
+              addToSandstoneCore: true,
+              creator: "sandstone",
+              onConflict: "rename"
+            });
+            caseMCFunction.node.body = caseNode.body.flatMap((n) => this.visit(n));
+            caseData.push({
+              Value: caseNode.value,
+              Index: NBT.int(i)
+            });
+          }
+          initMCFunction.push(() => values.set(caseData));
+          const innerMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/inner`, {
+            addToSandstoneCore: true,
+            creator: "sandstone",
+            onConflict: "rename"
+          });
+          this.core.enterMCFunction(innerMCFunction);
+          Macro.returnCmd.run.functionCmd(Macro`${switchMCFunction.name}/case_${index}`);
+          this.core.exitMCFunction();
+          const hasFallback = conditionCases.length > 0 || defaultCase !== undefined;
+          if (hasFallback) {
+            const ifNode = new IfNode(this.core, index._toMinecraftCondition(), undefined, switchMCFunction.node);
+            switchMCFunction.node.enterContext(ifNode, false);
+            functionCmd(innerMCFunction.name, "with", switchMCFunction.macroPoint);
+            switchMCFunction.node.exitContext();
+            switchMCFunction.node.body.push(ifNode);
+            this.buildFallback(ifNode, value, conditionCases, defaultCase, switchMCFunction);
+          } else {
+            this.pack.commands.execute.if.data.storage(index.currentTarget, index.path).run.returnCmd.run.functionCmd(innerMCFunction.name, "with", switchMCFunction.macroPoint);
+          }
+        }
+        this.core.exitMCFunction();
+      } else {
+        this.core.enterMCFunction(switchMCFunction);
+        this.buildFallback(undefined, value, conditionCases, defaultCase, switchMCFunction);
+        this.core.exitMCFunction();
+        const canInline = parentMCFunction && node === parentMCFunction.body.at(-1);
+        if (canInline) {
+          this.core.resourceNodes.delete(switchMCFunction.node);
+          for (const bodyNode of switchMCFunction.node.body) {
+            if (bodyNode instanceof IfNode) {
+              bodyNode.parentMCFunction = parentMCFunction;
+              let lastIfNode = bodyNode;
+              while (lastIfNode.nextFlowNode instanceof IfNode) {
+                lastIfNode.nextFlowNode.parentMCFunction = parentMCFunction;
+                lastIfNode = lastIfNode.nextFlowNode;
+              }
+              if (lastIfNode !== bodyNode) {
+                switchMCFunction.node.body.push(lastIfNode);
+              }
+            }
+          }
+          return switchMCFunction.node.body;
+        }
+      }
+      const isLastNode = parentMCFunction && node === parentMCFunction.body.at(-1);
+      if (hasStaticCases && !(value instanceof Score)) {
+        const macroPoint = switchMCFunction.macroPoint;
+        const resolvedValue = value instanceof DataPointPickClass ? value._toDataPoint() : value;
+        const env0Point = macroPoint.select("env_0");
+        const copyNode = new DataCommandNode(this.pack);
+        copyNode.args = [
+          "modify",
+          "storage",
+          env0Point.currentTarget,
+          env0Point.path,
+          "set",
+          "from",
+          resolvedValue.type,
+          resolvedValue.currentTarget,
+          resolvedValue.path
+        ];
+        const funcNode2 = new FunctionCommandNode(this.pack, switchMCFunction.name);
+        funcNode2.args.push("with", macroPoint.type, macroPoint.currentTarget, macroPoint.path);
+        if (isLastNode) {
+          const callNode = new ReturnRunCommandNode(this.pack, ["run"]);
+          callNode.body = [funcNode2];
+          return [copyNode, callNode].flatMap((n) => this.visit(n));
+        }
+        return [copyNode, funcNode2].flatMap((n) => this.visit(n));
+      }
+      const funcNode = new FunctionCommandNode(this.pack, switchMCFunction.name);
+      if (isLastNode) {
+        const callNode = new ReturnRunCommandNode(this.pack, ["run"]);
+        callNode.body = [funcNode];
+        return this.visit(callNode);
+      }
+      return this.visit(funcNode);
+    };
+    buildFallback(_if, value, conditionCases, defaultCase, switchMCFunction, targetBody) {
+      if (conditionCases.length === 0 && !defaultCase)
+        return;
+      const body = targetBody ?? switchMCFunction.node.body;
+      if (conditionCases.length > 0) {
+        const firstCondition = conditionCases[0].condition(value);
+        const firstConditionNode = conditionToNode(firstCondition);
+        let currentIfNode;
+        if (_if === undefined) {
+          currentIfNode = new IfNode(this.core, firstConditionNode, undefined, switchMCFunction.node);
+          currentIfNode.body = conditionCases[0].body.flatMap((n) => this.visit(n));
+          body.push(currentIfNode);
+        } else {
+          currentIfNode = new IfNode(this.core, firstConditionNode, undefined, switchMCFunction.node);
+          currentIfNode._isElseIf = true;
+          _if.nextFlowNode = currentIfNode;
+          currentIfNode.body = conditionCases[0].body.flatMap((n) => this.visit(n));
+        }
+        for (let i = 1;i < conditionCases.length; i++) {
+          const condition2 = conditionCases[i].condition(value);
+          const conditionNode = conditionToNode(condition2);
+          const nextIfNode = new IfNode(this.core, conditionNode, undefined, switchMCFunction.node);
+          nextIfNode._isElseIf = true;
+          currentIfNode.nextFlowNode = nextIfNode;
+          nextIfNode.body = conditionCases[i].body.flatMap((n) => this.visit(n));
+          currentIfNode = nextIfNode;
+        }
+        if (defaultCase) {
+          const elseNode = new ElseNode(this.core, () => {});
+          elseNode._body = defaultCase.body.flatMap((n) => this.visit(n));
+          currentIfNode.nextFlowNode = elseNode;
+        }
+      } else if (defaultCase) {
+        if (_if === undefined) {
+          const visitedNodes = defaultCase.body.flatMap((n) => this.visit(n));
+          body.push(...visitedNodes);
+        } else {
+          const elseNode = new ElseNode(this.core, () => {});
+          elseNode._body = defaultCase.body.flatMap((n) => this.visit(n));
+          _if.nextFlowNode = elseNode;
+        }
+      }
+    }
+    visitStaticCaseNode = (_node) => {
+      return [];
+    };
+    visitConditionCaseNode = (_node) => {
+      return [];
+    };
+    visitDefaultCaseNode = (_node) => {
+      return [];
+    };
+  };
+});
+
 // src/pack/visitors/unifyChainedExecutes.ts
 var UnifyChainedExecutesVisitor;
 var init_unifyChainedExecutes = __esm(() => {
@@ -7861,6 +8565,10 @@ var init_unifyChainedExecutes = __esm(() => {
         node.body = chainedCommand.body;
         node.args.push(...chainedCommand.args);
       }
+      const flattenedArgs = node.args.flat(1).filter((a) => a !== undefined && a !== null);
+      if (flattenedArgs.length === 0 && node.body.length === 1) {
+        return this.genericVisit(node.body[0]);
+      }
       return this.genericVisit(node);
     };
   };
@@ -7878,6 +8586,7 @@ var init_visitors2 = __esm(() => {
   init_orTransformationVisitor();
   init_simplifyExecuteFunction();
   init_simplifyReturnRunFunction();
+  init_switchTransformationVisitor();
   init_unifyChainedExecutes();
 });
 
@@ -7947,6 +8656,8 @@ class SandstonePack {
     this.__rootObjective = undefined;
     this.__initMCFunction = undefined;
     this.objectives.clear();
+    this.anonymousDataId = 0;
+    this.anonymousScoreId = 0;
     this.constants.clear();
     this.tickedLoops = {};
     this.dependencies.clear();
@@ -8009,7 +8720,7 @@ class SandstonePack {
     return [namespace, ...resourceFolders, ...fullPath];
   };
   get _() {
-    return new Flow(this.core);
+    return this.flow;
   }
   registerNewObjective = (objective) => {
     this.objectives.add(objective);
@@ -8048,7 +8759,7 @@ class SandstonePack {
       return this.Variable(undefined, name2).set(nbt2, scale);
     }
     const [initialValue, name] = args;
-    const anonymousScore = score2(`${name ?? "anon"}_${this.packUid}_${this.anonymousScoreId++}`);
+    const anonymousScore = score2(`${name ?? "anon"}_${this.packUid}${name === undefined ? `_${this.anonymousScoreId++}` : ""}`);
     if (initialValue === undefined) {
       return anonymousScore;
     }
@@ -8092,7 +8803,7 @@ class SandstonePack {
       return this.DataVariable(undefined, name2).set(score2, storeType || "int", scale || 1);
     }
     const [initialValue, name] = args;
-    const anonymousData = data2.select(`${name ?? "anon"}_${this.packUid}_${this.anonymousDataId++}`);
+    const anonymousData = data2.select(`${name ?? "anon"}_${this.packUid}${name === undefined ? `_${this.anonymousDataId++}` : ""}`);
     if (initialValue === undefined) {
       return anonymousData;
     }
@@ -8495,6 +9206,7 @@ class SandstonePack {
         new InitConstantsVisitor(this),
         new GenerateLazyMCFunction(this),
         new LoopTransformationVisitor(this),
+        new SwitchTransformationVisitor(this),
         new OrTransformationVisitor(this),
         new IfElseTransformationVisitor(this),
         new ContainerCommandsToMCFunctionVisitor(this),
@@ -8545,7 +9257,7 @@ var init_pack = __esm(() => {
     }
     handleOutput = async (type, readFile, writeFile) => {
       if (type === "output") {
-        await writeFile("pack.mcmeta", JSON.stringify(this.packMcmeta));
+        await writeFile("pack.mcmeta", JSON.stringify(this.packMcmeta, null, 2));
       }
     };
   };
@@ -8566,7 +9278,7 @@ var init_pack = __esm(() => {
     }
     handleOutput = async (type, readFile, writeFile) => {
       if (type === "output") {
-        await writeFile("pack.mcmeta", JSON.stringify(this.packMcmeta));
+        await writeFile("pack.mcmeta", JSON.stringify(this.packMcmeta, null, 2));
       }
     };
   };
@@ -8641,7 +9353,11 @@ var init_src = __esm(() => {
       return new Proxy(fn, {
         get(_target, subProp) {
           const method = sandstonePack[prop];
-          return method[subProp];
+          const value = method[subProp];
+          if (typeof value === "function") {
+            return value.bind(method);
+          }
+          return value;
         },
         apply(_target, _thisArg, args) {
           const method = sandstonePack[prop];
@@ -8901,20 +9617,16 @@ class ListResource {
   push(..._args) {}
   unshift(..._args) {}
 }
-function jsonStringify(json) {
-  return JSON.stringify(json, (_key, value) => {
-    if (value instanceof NBTPrimitive) {
-      return value.value;
-    }
-    if (value instanceof NBTTypedArray) {
-      return value.values;
+function jsonStringify(json, resourceType) {
+  return JSON.stringify(json, function(key, value) {
+    if ((typeof value === "object" || typeof value === "function") && value.constructor.name !== "Object" && "toResourceJSON" in value) {
+      return value.toResourceJSON(key, this, resourceType, json);
     }
     return value;
   }, 2);
 }
 var RESOURCE_CLASS_BRAND, ResourceClass, CallableResourceClass, ResourceNodesMap;
 var init_resource = __esm(() => {
-  init_NBTs();
   init_arguments();
   RESOURCE_CLASS_BRAND = Symbol.for("sandstone.ResourceClass");
   ResourceClass = class ResourceClass {
@@ -9018,6 +9730,9 @@ var init_resource = __esm(() => {
     toNBT() {
       return this.name;
     }
+    toJSON() {
+      return this.name;
+    }
     static [Symbol.hasInstance](instance) {
       return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[RESOURCE_CLASS_BRAND] === true;
     }
@@ -9117,7 +9832,7 @@ var init_advancement3 = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.advancementJSON);
+    getValue = () => jsonStringify(this.resource.advancementJSON, this.resource._resourceType);
   };
   ADVANCEMENT_CLASS_BRAND = Symbol.for("sandstone.AdvancementClass");
   AdvancementClass = class AdvancementClass extends ResourceClass {
@@ -9175,7 +9890,7 @@ var init_bannerPattern = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.bannerPatternJSON);
+    getValue = () => jsonStringify(this.resource.bannerPatternJSON, this.resource._resourceType);
   };
   BannerPatternClass = class BannerPatternClass extends ResourceClass {
     static resourceType = "banner_pattern";
@@ -9200,7 +9915,7 @@ var init_chatType = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.chatTypeJSON);
+    getValue = () => jsonStringify(this.resource.chatTypeJSON, this.resource._resourceType);
   };
   ChatTypeClass = class ChatTypeClass extends ResourceClass {
     static resourceType = "chat_type";
@@ -9226,7 +9941,7 @@ var init_damageType = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.damageTypeJSON);
+    getValue = () => jsonStringify(this.resource.damageTypeJSON, this.resource._resourceType);
   };
   DamageTypeClass = class DamageTypeClass extends ResourceClass {
     static resourceType = "damage_type";
@@ -9288,7 +10003,7 @@ var init_dialog2 = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.dialogJSON);
+    getValue = () => jsonStringify(this.resource.dialogJSON, this.resource._resourceType);
   };
   DialogClass = class DialogClass extends ResourceClass {
     static resourceType = "dialog";
@@ -9313,7 +10028,7 @@ var init_enchantment = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.enchantmentJSON);
+    getValue = () => jsonStringify(this.resource.enchantmentJSON, this.resource._resourceType);
   };
   EnchantmentClass = class EnchantmentClass extends ResourceClass {
     static resourceType = "enchantment";
@@ -9330,7 +10045,7 @@ var init_enchantment = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.enchantmentProviderJSON);
+    getValue = () => jsonStringify(this.resource.enchantmentProviderJSON, this.resource._resourceType);
   };
   EnchantmentProviderClass = class EnchantmentProviderClass extends ResourceClass {
     static resourceType = "enchantment_provider";
@@ -9355,7 +10070,7 @@ var init_gametest = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.testEnvironmentJSON);
+    getValue = () => jsonStringify(this.resource.testEnvironmentJSON, this.resource._resourceType);
   };
   TestEnvironmentClass = class TestEnvironmentClass extends ResourceClass {
     static resourceType = "test_environment";
@@ -9372,7 +10087,7 @@ var init_gametest = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.testInstanceJSON);
+    getValue = () => jsonStringify(this.resource.testInstanceJSON, this.resource._resourceType);
   };
   TestInstanceClass = class TestInstanceClass extends ResourceClass {
     static resourceType = "test_instance";
@@ -9397,7 +10112,7 @@ var init_instrument = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.instrumentJSON);
+    getValue = () => jsonStringify(this.resource.instrumentJSON, this.resource._resourceType);
   };
   InstrumentClass = class InstrumentClass extends ResourceClass {
     static resourceType = "instrument";
@@ -9423,7 +10138,7 @@ var init_itemModifier = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.itemModifierJSON);
+    getValue = () => jsonStringify(this.resource.itemModifierJSON, this.resource._resourceType);
   };
   ITEM_MODIFIER_CLASS_BRAND = Symbol.for("sandstone.ItemModifierClass");
   ItemModifierClass = class ItemModifierClass extends ResourceClass {
@@ -9499,7 +10214,7 @@ var init_jukeboxSong = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.jukeboxSongJSON);
+    getValue = () => jsonStringify(this.resource.jukeboxSongJSON, this.resource._resourceType);
   };
   JukeboxSongClass = class JukeboxSongClass extends ResourceClass {
     static resourceType = "jukebox_song";
@@ -9524,7 +10239,7 @@ var init_lootTable = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.lootTableJSON);
+    getValue = () => jsonStringify(this.resource.lootTableJSON, this.resource._resourceType);
   };
   LootTableClass = class LootTableClass extends ResourceClass {
     static resourceType = "loot_table";
@@ -9557,7 +10272,7 @@ var init_predicate2 = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.predicateJSON);
+    getValue = () => jsonStringify(this.resource.predicateJSON, this.resource._resourceType);
   };
   PREDICATE_CLASS_BRAND = Symbol.for("sandstone.PredicateClass");
   PredicateClass = class PredicateClass extends ResourceClass {
@@ -9627,7 +10342,7 @@ var init_recipe2 = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.recipeJSON);
+    getValue = () => jsonStringify(this.resource.recipeJSON, this.resource._resourceType);
   };
   RecipeClass = class RecipeClass extends ResourceClass {
     static resourceType = "recipe";
@@ -9865,7 +10580,7 @@ var init_structure = __esm(() => {
                   blockPos: [layer[0], row[0], entry[0]],
                   nbt: {
                     id: entity.id,
-                    ...add(entity.nbt)
+                    ...add({ ...entity.nbt })
                   }
                 });
               }
@@ -9945,7 +10660,7 @@ var init_timeline = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.timelineJSON);
+    getValue = () => jsonStringify(this.resource.timelineJSON, this.resource._resourceType);
   };
   TimelineClass = class TimelineClass extends ResourceClass {
     static resourceType = "timeline";
@@ -9962,7 +10677,7 @@ var init_timeline = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.worldClockJSON);
+    getValue = () => jsonStringify(this.resource.worldClockJSON, this.resource._resourceType);
   };
   WorldClockClass = class WorldClockClass extends ResourceClass {
     static resourceType = "world_clock";
@@ -9990,7 +10705,7 @@ var init_trialSpawner = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.trialSpawnerJSON);
+    getValue = () => jsonStringify(this.resource.trialSpawnerJSON, this.resource._resourceType);
   };
   TrialSpawnerClass = class TrialSpawnerClass extends ResourceClass {
     static resourceType = "trial_spawner";
@@ -10015,7 +10730,7 @@ var init_trimMaterial = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.trimMaterialJSON);
+    getValue = () => jsonStringify(this.resource.trimMaterialJSON, this.resource._resourceType);
   };
   TrimMaterialClass = class TrimMaterialClass extends ResourceClass {
     static resourceType = "trim_material";
@@ -10043,7 +10758,7 @@ var init_trimPattern = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.trimPatternJSON);
+    getValue = () => jsonStringify(this.resource.trimPatternJSON, this.resource._resourceType);
   };
   TrimPatternClass = class TrimPatternClass extends ResourceClass {
     static resourceType = "trim_pattern";
@@ -10067,7 +10782,7 @@ var init_variant = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.variantJSON);
+    getValue = () => jsonStringify(this.resource.variantJSON, this.resource._resourceType);
   };
   VariantClass = class VariantClass extends ResourceClass {
     variantType;
@@ -10094,7 +10809,7 @@ var init_villagerTrade = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.villagerTradeJSON);
+    getValue = () => jsonStringify(this.resource.villagerTradeJSON, this.resource._resourceType);
   };
   VillagerTradeClass = class VillagerTradeClass extends ResourceClass {
     static resourceType = "villager_trade";
@@ -10111,7 +10826,7 @@ var init_villagerTrade = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.tradeSetJSON);
+    getValue = () => jsonStringify(this.resource.tradeSetJSON, this.resource._resourceType);
   };
   TradeSetClass = class TradeSetClass extends ResourceClass {
     static resourceType = "trade_set";
@@ -10162,7 +10877,7 @@ var init_atlas = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.atlasJSON);
+    getValue = () => jsonStringify(this.resource.atlasJSON, this.resource._resourceType);
   };
   ATLAS_CLASS_BRAND = Symbol.for("sandstone.AtlasClass");
   AtlasClass = class AtlasClass extends ResourceClass {
@@ -10210,7 +10925,7 @@ var init_blockstate = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.blockStateJSON);
+    getValue = () => jsonStringify(this.resource.blockStateJSON, this.resource._resourceType);
   };
   BLOCK_STATE_CLASS_BRAND = Symbol.for("sandstone.BlockStateClass");
   BlockStateClass = class BlockStateClass extends ResourceClass {
@@ -10291,7 +11006,7 @@ var init_equipment = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.equipmentJSON);
+    getValue = () => jsonStringify(this.resource.equipmentJSON, this.resource._resourceType);
   };
   EquipmentClass = class EquipmentClass extends ResourceClass {
     static resourceType = "equipment";
@@ -10316,7 +11031,7 @@ var init_font = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.fontJSON);
+    getValue = () => jsonStringify(this.resource.fontJSON, this.resource._resourceType);
   };
   FONT_CLASS_BRAND = Symbol.for("sandstone.FontClass");
   FontClass = class FontClass extends ResourceClass {
@@ -10364,7 +11079,7 @@ var init_language = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.languageJSON);
+    getValue = () => jsonStringify(this.resource.languageJSON, this.resource._resourceType);
   };
   LANGUAGE_CLASS_BRAND = Symbol.for("sandstone.LanguageClass");
   LanguageClass = class LanguageClass extends ResourceClass {
@@ -10416,7 +11131,7 @@ var init_particle2 = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.particleJSON);
+    getValue = () => jsonStringify(this.resource.particleJSON, this.resource._resourceType);
   };
   ParticleClass = class ParticleClass extends ResourceClass {
     static resourceType = "particle";
@@ -10441,7 +11156,7 @@ var init_postEffect = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.postEffectJSON);
+    getValue = () => jsonStringify(this.resource.postEffectJSON, this.resource._resourceType);
   };
   PostEffectClass = class PostEffectClass extends ResourceClass {
     static resourceType = "post_effect";
@@ -10466,7 +11181,7 @@ var init_shader = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.shaderJSON);
+    getValue = () => jsonStringify(this.resource.shaderJSON, this.resource._resourceType);
   };
   ShaderClass = class ShaderClass extends ResourceClass {
     static resourceType = "shader";
@@ -10528,7 +11243,7 @@ var init_sound = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.soundsJSON);
+    getValue = () => jsonStringify(this.resource.soundsJSON, this.resource._resourceType);
   };
   SOUNDS_CLASS_BRAND = Symbol.for("sandstone.SoundsClass");
   SoundsClass = class SoundsClass extends ResourceClass {
@@ -10758,7 +11473,7 @@ var init_waypointStyle = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.waypointStyleJSON);
+    getValue = () => jsonStringify(this.resource.waypointStyleJSON, this.resource._resourceType);
   };
   WaypointStyleClass = class WaypointStyleClass extends ResourceClass {
     static resourceType = "waypoint_style";
@@ -11327,7 +12042,18 @@ class SandstoneCore {
         _path.splice(1, 0, packType2.resourceSubFolder);
       }
       const resourcePath = path4.join(..._path);
-      const value = await node.getValue();
+      let value;
+      try {
+        value = await node.getValue();
+      } catch (e) {
+        console.log(`
+
+
+
+`);
+        console.log(node);
+        throw e;
+      }
       if (cliOptions.verbose) {
         console.log(`Path: ${resourcePath}.${fileExtension}