sandstone 1.1.3 → 1.1.5

package/dist/_internal/types/variables/abstractClasses.d.ts

@@ -1,3 +1,4 @@
+import type { Node } from '../core/index.js';
 import type { NBTSerializable } from '../arguments/index.js';
 export declare class TextComponentClass {
     /**
@@ -12,6 +13,14 @@ export declare class ConditionClass {
      * (and subclasses). Does not exist at runtime.
      */
     readonly __conditionClassBrand: true;
+    /**
+     * Optional commands that must run before this condition's predicate is evaluated.
+     * Conditions that emit side-effect commands at construction (e.g. `data.equals`
+     * building `execute store result ...`) capture them here so the visitor pass can
+     * re-emit them at the right location — inline before the IfNode, or inside the
+     * child MCFunction when AND/OR extracts. Optional; pure predicates leave it unset.
+     */
+    preNodes?: Node[];
 }
 export declare class SelectorPickClass<IsSingle extends boolean, IsPlayer extends boolean> implements NBTSerializable, TextComponentClass {
     /**

package/dist/_internal/types/variables/abstractClasses.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abstractClasses.d.ts","sourceRoot":"","sources":["../../../../src/variables/abstractClasses.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,qBAAa,kBAAkB;IAC7B;;;OAGG;IACH,SAAiB,yBAAyB,EAAE,IAAI,CAAA;CAQjD;AACD,qBAAa,cAAc;IACzB;;;OAGG;IACH,SAAiB,qBAAqB,EAAE,IAAI,CAAA;CAQ7C;AAED,qBAAa,iBAAiB,CAAC,QAAQ,SAAS,OAAO,EAAE,QAAQ,SAAS,OAAO,CAAE,YAAW,eAAe,EAAE,kBAAkB;IAC/H;;;OAGG;IACH,SAAiB,mBAAmB,EAAE;QAAE,MAAM,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAA;KAAE,CAAA;IAE5E;;;OAGG;IACH,SAAiB,yBAAyB,EAAE,IAAI,CAAA;CAoBjD;AAED,qBAAa,2BAA4B,SAAQ,kBAAmB,YAAW,cAAc;IAC3F;;;OAGG;IACH,SAAiB,yBAAyB,EAAE,IAAI,CAAA;IAEhD;;;OAGG;IACH,SAAiB,qBAAqB,EAAE,IAAI,CAAA;CAe7C"}
+{"version":3,"file":"abstractClasses.d.ts","sourceRoot":"","sources":["../../../../src/variables/abstractClasses.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAG1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,qBAAa,kBAAkB;IAC7B;;;OAGG;IACH,SAAiB,yBAAyB,EAAE,IAAI,CAAA;CAQjD;AACD,qBAAa,cAAc;IACzB;;;OAGG;IACH,SAAiB,qBAAqB,EAAE,IAAI,CAAA;IAE5C;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAA;CAQlB;AAED,qBAAa,iBAAiB,CAAC,QAAQ,SAAS,OAAO,EAAE,QAAQ,SAAS,OAAO,CAAE,YAAW,eAAe,EAAE,kBAAkB;IAC/H;;;OAGG;IACH,SAAiB,mBAAmB,EAAE;QAAE,MAAM,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAA;KAAE,CAAA;IAE5E;;;OAGG;IACH,SAAiB,yBAAyB,EAAE,IAAI,CAAA;CAoBjD;AAED,qBAAa,2BAA4B,SAAQ,kBAAmB,YAAW,cAAc;IAC3F;;;OAGG;IACH,SAAiB,yBAAyB,EAAE,IAAI,CAAA;IAEhD;;;OAGG;IACH,SAAiB,qBAAqB,EAAE,IAAI,CAAA;CAe7C"}

package/dist/browser/sandstone.esm.js

@@ -2538,68 +2538,68 @@ AtlasClass = class AtlasClass extends ResourceClass {
       }
     }
   };
-BlockStateNode = class BlockStateNode extends ContainerNode {
+BlockStateDefinitionNode = class BlockStateDefinitionNode extends ContainerNode {
     resource;
     constructor(sandstoneCore, resource) {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.blockStateJSON, this.resource._resourceType);
+    getValue = () => jsonStringify(this.resource.blockStateDefinitionJSON, this.resource._resourceType);
   };
-BlockStateClass = class BlockStateClass extends ResourceClass {
+BlockStateDefinitionClass = class BlockStateDefinitionClass extends ResourceClass {
     static resourceType = "block_definition";
-    blockStateJSON;
+    blockStateDefinitionJSON;
     type;
     constructor(core, name, args) {
-      super(core, { packType: core.pack.resourcePack() }, BlockStateNode, BlockStateClass.resourceType, core.pack.resourceToPath(name, RESOURCE_PATHS[BlockStateClass.resourceType].path), args);
-      this.blockStateJSON = args.json;
-      this.type = Object.keys(this.blockStateJSON)[0];
+      super(core, { packType: core.pack.resourcePack() }, BlockStateDefinitionNode, BlockStateDefinitionClass.resourceType, core.pack.resourceToPath(name, RESOURCE_PATHS[BlockStateDefinitionClass.resourceType].path), args);
+      this.blockStateDefinitionJSON = args.json;
+      this.type = Object.keys(this.blockStateDefinitionJSON)[0];
       this.handleConflicts();
     }
     push(...states) {
       if (this.type === "variants") {
-        if (states[0] instanceof BlockStateClass) {
+        if (states[0] instanceof BlockStateDefinitionClass) {
           for (const state of states) {
-            this.blockStateJSON.variants = { ...this.blockStateJSON.variants, ...state.blockStateJSON.variants };
+            this.blockStateDefinitionJSON.variants = { ...this.blockStateDefinitionJSON.variants, ...state.blockStateDefinitionJSON.variants };
           }
         } else {
           for (const state of states) {
-            this.blockStateJSON.variants = { ...this.blockStateJSON.variants, ...state.variants };
+            this.blockStateDefinitionJSON.variants = { ...this.blockStateDefinitionJSON.variants, ...state.variants };
           }
         }
       }
       if (this.type === "multipart") {
-        if (states[0] instanceof BlockStateClass) {
+        if (states[0] instanceof BlockStateDefinitionClass) {
           for (const state of states) {
-            this.blockStateJSON.multipart.push(...state.blockStateJSON.multipart);
+            this.blockStateDefinitionJSON.multipart.push(...state.blockStateDefinitionJSON.multipart);
           }
         } else {
           for (const state of states) {
-            this.blockStateJSON.multipart.push(...state.multipart);
+            this.blockStateDefinitionJSON.multipart.push(...state.multipart);
           }
         }
       }
     }
     unshift(...states) {
       if (this.type === "variants") {
-        if (states[0] instanceof BlockStateClass) {
+        if (states[0] instanceof BlockStateDefinitionClass) {
           for (const state of states) {
-            this.blockStateJSON.variants = { ...state.blockStateJSON.variants, ...this.blockStateJSON.variants };
+            this.blockStateDefinitionJSON.variants = { ...state.blockStateDefinitionJSON.variants, ...this.blockStateDefinitionJSON.variants };
           }
         } else {
           for (const state of states) {
-            this.blockStateJSON.variants = { ...state.variants, ...this.blockStateJSON.variants };
+            this.blockStateDefinitionJSON.variants = { ...state.variants, ...this.blockStateDefinitionJSON.variants };
           }
         }
       }
       if (this.type === "multipart") {
-        if (states[0] instanceof BlockStateClass) {
+        if (states[0] instanceof BlockStateDefinitionClass) {
           for (const state of states) {
-            this.blockStateJSON.multipart.unshift(...state.blockStateJSON.multipart);
+            this.blockStateDefinitionJSON.multipart.unshift(...state.blockStateDefinitionJSON.multipart);
           }
         } else {
           for (const state of states) {
-            this.blockStateJSON.multipart.unshift(...state.multipart);
+            this.blockStateDefinitionJSON.multipart.unshift(...state.multipart);
           }
         }
       }
@@ -4438,6 +4438,7 @@ WorldBorderCommand = class WorldBorderCommand extends CommandArguments {
     };
   };
 ConditionNode = class ConditionNode extends Node {
+    preNodes;
   };
 SingleConditionNode = class SingleConditionNode extends ConditionNode {
     getValue = (negated = false) => {
@@ -4594,9 +4595,13 @@ DataPointEqualsConditionNode = class DataPointEqualsConditionNode extends Single
       this.value = value2;
       const { DataVariable, Variable, commands: commands2 } = sandstoneCore2.pack;
       const { execute: execute2 } = commands2;
+      const mcFunction = sandstoneCore2.getCurrentMCFunctionOrThrow();
+      const before = mcFunction.body.length;
       const anon = DataVariable(this.dataPoint);
       this.conditional = Variable();
       execute2.store.result(this.conditional).run(() => anon.set(this.value));
+      const after = mcFunction.body.length;
+      this.preNodes = mcFunction.body.splice(before, after - before);
     }
     getValue = (negated) => (negated ? ["if", ...this.getCondition()] : ["unless", ...this.getCondition()]).join(" ");
     getCondition() {
@@ -4661,7 +4666,11 @@ CommandConditionNode = class CommandConditionNode extends SingleConditionNode {
       this.result = result;
       const store = sandstoneCore2.pack.commands.execute.store[type4];
       this.variable = sandstoneCore2.pack.Variable(undefined, "condition");
+      const mcFunction = sandstoneCore2.getCurrentMCFunctionOrThrow();
+      const before = mcFunction.body.length;
       command(store(this.variable));
+      const after = mcFunction.body.length;
+      this.preNodes = mcFunction.body.splice(before, after - before);
     }
     getCondition() {
       if (this.type === "success") {
@@ -5158,54 +5167,186 @@ LoopTransformationVisitor = class LoopTransformationVisitor extends GenericSands
     visitForINode = this.visitLoopNode;
     visitForOfNode = this.visitLoopNode;
   };
+FunctionReturnConditionNode = class FunctionReturnConditionNode extends ConditionNode {
+    sandstoneCore;
+    functionName;
+    constructor(sandstoneCore2, functionName) {
+      super(sandstoneCore2);
+      this.sandstoneCore = sandstoneCore2;
+      this.functionName = functionName;
+    }
+    getValue = () => `if function ${this.functionName}`;
+  };
 OrTransformationVisitor = class OrTransformationVisitor extends GenericSandstoneVisitor {
     visitIfNode = (node_) => {
-      const { preNodes, conditionNode } = this.parseConditionNode(node_.condition);
+      const { preNodes, conditionNode } = this.parseConditionNode(node_.condition, node_.parentMCFunction);
       node_.condition = conditionNode;
       return [...preNodes, this.genericVisit(node_)];
     };
-    parseConditionNode = (node) => {
+    parseConditionNode = (node, parentMCFunction) => {
       if (node instanceof OrNode) {
-        return this.parseOrNode(node);
+        return this.parseOrNode(node, parentMCFunction);
       }
       if (node instanceof AndNode) {
-        return this.parseAndNode(node);
+        return this.parseAndNode(node, parentMCFunction);
       }
       if (node instanceof NotNode) {
-        return this.parseNotNode(node);
+        return this.parseNotNode(node, parentMCFunction);
       }
-      return { preNodes: [], conditionNode: node };
+      return { preNodes: [...node.preNodes ?? []], conditionNode: node };
     };
-    parseOrNode = (node) => {
-      const variable = this.core.pack.Variable(undefined, "condition");
-      const conditionNode = variable.equalTo(1)._toMinecraftCondition();
-      const realPreNodes = [new ScoreboardCommandNode(this.pack, "players", "reset", variable)];
-      const orExecuteNodes = node.conditions.map((condition2) => {
-        const { preNodes, conditionNode: parsedConditionNode } = this.parseConditionNode(condition2);
-        realPreNodes.push(...preNodes);
-        const ifNode = new IfNode(this.core, parsedConditionNode);
-        ifNode.body = [new ScoreboardCommandNode(this.pack, "players", "set", variable, 1)];
-        return ifNode;
+    parseOrNode = (node, parentMCFunction) => {
+      if (node.conditions.length === 1) {
+        return this.parseConditionNode(node.conditions[0], parentMCFunction);
+      }
+      const parentName = parentMCFunction?.resource.name ?? "__sandstone";
+      const orMCFunction = new MCFunctionClass(this.core, `${parentName}/or_check`, {
+        addToSandstoneCore: true,
+        creator: "sandstone",
+        onConflict: "rename"
       });
+      this.core.enterMCFunction(orMCFunction);
+      try {
+        for (const condition2 of node.conditions) {
+          this.pushCheckBranch(orMCFunction.node, this.parseConditionNode(condition2, orMCFunction.node), false, new ReturnCommandNode(this.pack, [1]));
+        }
+        orMCFunction.node.body.push(new ReturnCommandNode(this.pack, [0]));
+      } finally {
+        this.core.exitMCFunction();
+      }
       return {
-        preNodes: [...realPreNodes, ...orExecuteNodes],
-        conditionNode
+        preNodes: [],
+        conditionNode: new FunctionReturnConditionNode(this.core, orMCFunction.name)
       };
     };
-    parseAndNode = (node) => {
-      const finalPreNodes = [];
-      const conditionNode = new AndNode(node.sandstoneCore, node.conditions.map((condition2) => {
-        const { preNodes, conditionNode: conditionNode2 } = this.parseConditionNode(condition2);
-        finalPreNodes.push(...preNodes);
-        return conditionNode2;
-      }));
+    parseAndNode = (node, parentMCFunction) => {
+      if (node.conditions.length === 1) {
+        return this.parseConditionNode(node.conditions[0], parentMCFunction);
+      }
+      const parsed = node.conditions.map((condition2) => this.parseConditionNode(condition2, parentMCFunction));
+      const anyHasCommands = parsed.some((p) => (p.preNodes ?? []).length > 0);
+      if (!anyHasCommands) {
+        const finalPreNodes = [];
+        const conditionNode = new AndNode(node.sandstoneCore, parsed.map((p) => {
+          finalPreNodes.push(...p.preNodes);
+          return p.conditionNode;
+        }));
+        return { preNodes: finalPreNodes, conditionNode };
+      }
+      const parentName = parentMCFunction?.resource.name ?? "__sandstone";
+      const andMCFunction = new MCFunctionClass(this.core, `${parentName}/and_check`, {
+        addToSandstoneCore: true,
+        creator: "sandstone",
+        onConflict: "rename"
+      });
+      this.core.enterMCFunction(andMCFunction);
+      try {
+        let batch = { preNodes: [], conditionNodes: [] };
+        const flushBatch = () => {
+          if (batch.conditionNodes.length === 0 && batch.preNodes.every((pn) => pn.length === 0)) {
+            batch = { preNodes: [], conditionNodes: [] };
+            return;
+          }
+          const tracker = this.core.pack.Variable(undefined, "and_batch");
+          this.pushBatchedCheckBranch(andMCFunction.node, batch.preNodes.flat(), batch.conditionNodes, tracker);
+          batch = { preNodes: [], conditionNodes: [] };
+        };
+        for (const p of parsed) {
+          if (p.preNodes.length === 0) {
+            batch.preNodes.push(p.preNodes);
+            batch.conditionNodes.push(p.conditionNode);
+          } else {
+            flushBatch();
+            this.pushFailFastBranch(andMCFunction.node, p, new ReturnCommandNode(this.pack, [0]));
+          }
+        }
+        flushBatch();
+        andMCFunction.node.body.push(new ReturnCommandNode(this.pack, [1]));
+      } finally {
+        this.core.exitMCFunction();
+      }
       return {
-        preNodes: finalPreNodes,
-        conditionNode
+        preNodes: [],
+        conditionNode: new FunctionReturnConditionNode(this.core, andMCFunction.name)
       };
     };
-    parseNotNode = (node) => {
-      const { preNodes, conditionNode } = this.parseConditionNode(node.condition);
+    pushBatchedCheckBranch = (targetMCFunction, preNodes, conditionNodes, tracker) => {
+      for (const n of preNodes) {
+        targetMCFunction.body.push(n);
+      }
+      targetMCFunction.body.push(new ScoreboardCommandNode(this.pack, "players", "reset", tracker));
+      const args = [];
+      for (const c of conditionNodes) {
+        const condStr = c.getValue(false);
+        const match = condStr.match(/^(if|unless)\s+([\s\S]+)$/);
+        if (!match) {
+          throw new Error(`OrTransformationVisitor: unexpected condition getValue() shape: ${condStr}`);
+        }
+        const [, keyword, condBody] = match;
+        args.push([keyword, condBody]);
+      }
+      if (args.length === 0) {
+        targetMCFunction.body.push(new ScoreboardCommandNode(this.pack, "players", "set", tracker, 1));
+      } else {
+        const executeNode = new ExecuteCommandNode(this.pack, args, {
+          isSingleExecute: true,
+          body: []
+        });
+        targetMCFunction.enterContext(executeNode, false);
+        executeNode.body = [new ScoreboardCommandNode(this.pack, "players", "set", tracker, 1)];
+        targetMCFunction.body.push(executeNode);
+        targetMCFunction.exitContext();
+      }
+      const failCheckNode = new ExecuteCommandNode(this.pack, [["unless", `score ${tracker} matches 1`]], {
+        isSingleExecute: true,
+        body: []
+      });
+      targetMCFunction.enterContext(failCheckNode, false);
+      failCheckNode.body = [new ReturnCommandNode(this.pack, [0])];
+      targetMCFunction.body.push(failCheckNode);
+      targetMCFunction.exitContext();
+    };
+    pushCheckBranch = (targetMCFunction, parsed, negated, bodyNode) => {
+      for (const n of parsed.preNodes) {
+        targetMCFunction.body.push(n);
+      }
+      const condStr = parsed.conditionNode.getValue(negated);
+      const match = condStr.match(/^(if|unless)\s+([\s\S]+)$/);
+      if (!match) {
+        throw new Error(`OrTransformationVisitor: unexpected condition getValue() shape: ${condStr}`);
+      }
+      const [, keyword, condBody] = match;
+      const executeNode = new ExecuteCommandNode(this.pack, [[keyword, condBody]], {
+        isSingleExecute: true,
+        body: []
+      });
+      targetMCFunction.enterContext(executeNode, false);
+      executeNode.body = [bodyNode];
+      targetMCFunction.body.push(executeNode);
+      targetMCFunction.exitContext();
+    };
+    pushFailFastBranch = (targetMCFunction, parsed, bodyNode) => {
+      for (const n of parsed.preNodes) {
+        targetMCFunction.body.push(n);
+      }
+      const condStr = parsed.conditionNode.getValue(true);
+      const match = condStr.match(/^(if|unless)\s+([\s\S]+)$/);
+      if (!match) {
+        throw new Error(`OrTransformationVisitor: unexpected condition getValue() shape: ${condStr}`);
+      }
+      const flippedKeyword = match[1] === "if" ? "unless" : "if";
+      const condBody = match[2];
+      const executeNode = new ExecuteCommandNode(this.pack, [[flippedKeyword, condBody]], {
+        isSingleExecute: true,
+        body: []
+      });
+      targetMCFunction.enterContext(executeNode, false);
+      executeNode.body = [bodyNode];
+      targetMCFunction.body.push(executeNode);
+      targetMCFunction.exitContext();
+    };
+    parseNotNode = (node, parentMCFunction) => {
+      const { preNodes, conditionNode } = this.parseConditionNode(node.condition, parentMCFunction);
       return {
         preNodes,
         conditionNode: new NotNode(node.sandstoneCore, conditionNode)
@@ -6459,6 +6600,7 @@ SleepClass = class SleepClass extends AwaitNode {
 // src/variables/abstractClasses.ts
 
 class ConditionClass {
+  preNodes;
   _toMinecraftCondition() {
     throw new Error("Not implemented");
   }
@@ -17564,7 +17706,7 @@ var init_atlas = __esm(() => {
     });
 
 // src/core/resources/resourcepack/blockstate.ts
-var BlockStateNode, BlockStateClass;
+var BlockStateDefinitionNode, BlockStateDefinitionClass;
 var init_blockstate = __esm(() => {
   init_arguments();
   init_nodes();
@@ -19661,8 +19803,14 @@ class Flow {
     this.sandstoneCore = sandstoneCore2;
   }
   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)));
+  and(...args) {
+    const conditions = args[0] instanceof Array ? args[0] : args;
+    return new AndNode(this.sandstoneCore, conditions.map((condition2) => conditionToNode(condition2)));
+  }
+  or(...args) {
+    const conditions = args[0] instanceof Array ? args[0] : args;
+    return 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;
@@ -19922,12 +20070,13 @@ var init_loopTransformationVisitor = __esm(() => {
   });
 
 // src/pack/visitors/orTransformationVisitor.ts
-var OrTransformationVisitor;
+var FunctionReturnConditionNode, OrTransformationVisitor;
 var init_orTransformationVisitor = __esm(() => {
   init_commands2();
+  init_core();
   init_flow();
   init_visitor();
-  });
+    });
 
 // src/pack/visitors/optimizeMacroTemporaries.ts
 var flattenArgs = (args) => args.flatMap((arg) => Array.isArray(arg) ? flattenArgs(arg) : [arg]), referencesStoragePoint = (node, point) => {
@@ -20074,11 +20223,11 @@ class SandstonePack {
     }
     return {
       datapack: {
-        packFormat: 61,
+        packFormat: 111,
         description: "A Sandstone datapack"
       },
       resourcepack: {
-        packFormat: 46,
+        packFormat: 92,
         description: "A Sandstone resource pack"
       }
     };
@@ -20155,7 +20304,7 @@ class SandstonePack {
   dataPack() {
     let pack = this.packTypes.get("datapack");
     if (!pack) {
-      const options = this.packOptions.datapack ?? { packFormat: 98, description: "A Sandstone datapack" };
+      const options = this.packOptions.datapack ?? { packFormat: 111, description: "A Sandstone datapack" };
       pack = this.packTypes.set("datapack", new DataPack(false, options)).get("datapack");
     }
     return pack;
@@ -20163,16 +20312,17 @@ class SandstonePack {
   resourcePack() {
     let pack = this.packTypes.get("resourcepack");
     if (!pack) {
-      const options = this.packOptions.resourcepack ?? { packFormat: 79, description: "A Sandstone resource pack" };
+      const options = this.packOptions.resourcepack ?? { packFormat: 92, description: "A Sandstone resource pack" };
       pack = this.packTypes.set("resourcepack", new ResourcePack(options)).get("resourcepack");
     }
     return pack;
   }
   setupLantern = () => {
-    const loadStatus = this.Objective.create("load.status", "dummy", undefined, { useDefaultNamespace: false });
+    const loadStatus = this.Objective.create("load.status", "dummy", undefined, { useDefaultNamespace: false, alreadyExists: true });
     const privateInit = this.Tag("function", "load:_private/init", [
       this.MCFunction("load:_private/init", () => {
         this.commands.comment("Reset scoreboards so packs can set values accurate for current load.");
+        this.commands.scoreboard.objectives.add(loadStatus.name, "dummy");
         loadStatus.reset();
       })
     ]);
@@ -20309,10 +20459,10 @@ class SandstonePack {
     return anonymousData;
   }
   DataIndexMap(initialize, dataPoint2) {
-    return DataIndexMap(this, initialize, dataPoint2);
+    return DataIndexMapInternal(this, initialize, dataPoint2);
   }
   DataArray(initialize, dataPoint2) {
-    return DataArray(this, initialize, dataPoint2);
+    return DataArrayInternal(this, initialize, dataPoint2);
   }
   getTempStorage = (name) => {
     if (tempStorage) {
@@ -20619,12 +20769,12 @@ class SandstonePack {
     onConflict: conflictDefaults("atlas"),
     ...options
   });
-  BlockState(name, json, options) {
-    return new BlockStateClass(this.core, name, {
+  BlockStateDefinition(name, json, options) {
+    return new BlockStateDefinitionClass(this.core, name, {
       json,
       creator: "user",
       addToSandstoneCore: true,
-      onConflict: conflictDefaults("blockstate"),
+      onConflict: conflictDefaults("block_definition"),
       ...options
     });
   }
@@ -61929,7 +62079,7 @@ var init_resources3 = __esm(() => {
     [VillagerTradeClass, "villager_trade"],
     [WorldClockClass, "world_clock"],
     [AtlasClass, "atlas"],
-    [BlockStateClass, "block_definition"],
+    [BlockStateDefinitionClass, "block_definition"],
     [EquipmentClass, "equipment"],
     [FontClass, "font"],
     [ItemModelDefinitionClass, "item_definition"],
@@ -61983,7 +62133,7 @@ var init_ItemPredicate = __esm(() => {
   });
 
 // src/variables/DataSets.ts
-function DataIndexMap(pack2, initialize, dataPoint2) {
+function DataIndexMapInternal(pack2, initialize, dataPoint2) {
   const indexMap = new DataIndexMapClass(pack2, initialize, dataPoint2);
   return new Proxy(indexMap, {
     get(target, p, receiver) {
@@ -62001,7 +62151,7 @@ function DataIndexMap(pack2, initialize, dataPoint2) {
     }
   });
 }
-function DataArray(pack2, initialize, dataPoint2) {
+function DataArrayInternal(pack2, initialize, dataPoint2) {
   const array3 = new DataArrayClass(pack2, initialize, dataPoint2);
   return new Proxy(array3, {
     get(target, p, receiver) {
@@ -62692,7 +62842,7 @@ var {
   VillagerTrade,
   WorldClock,
   Atlas,
-  BlockState,
+  BlockStateDefinition,
   Equipment,
   Font,
   ItemModelDefinition,
@@ -62716,8 +62866,8 @@ var {
   DataVariable,
   getTempStorage,
   ResolveNBT: ResolveNBT2,
-  DataIndexMap: DataIndexMap2,
-  DataArray: DataArray2,
+  DataIndexMap,
+  DataArray,
   Selector: Selector2,
   UUID: UUID2,
   ItemPredicate: ItemPredicate2,
@@ -63379,14 +63529,16 @@ export {
   DataModifyFromCommand,
   DataModifyCommand,
   DataMergeCommand,
+  DataIndexMapInternal,
   DataIndexMapClass,
-  DataIndexMap2 as DataIndexMap,
+  DataIndexMap,
   DataGetCommand,
   DataCommandNode,
   DataCommand,
   DataClass,
+  DataArrayInternal,
   DataArrayClass,
-  DataArray2 as DataArray,
+  DataArray,
   Data2 as Data,
   DamageTypeNode,
   DamageTypeClass,
@@ -63450,9 +63602,9 @@ export {
   BossBarCommandNode,
   BossBarCommand,
   BlocksConditionNode,
-  BlockStateNode,
-  BlockStateClass,
-  BlockState,
+  BlockStateDefinitionNode,
+  BlockStateDefinitionClass,
+  BlockStateDefinition,
   BlockConditionNode,
   BiomeConditionNode,
   BannerPatternNode,
@@ -63486,5 +63638,5 @@ export {
   ACTIVITIES_SET
 };
 
-//# debugId=E27C63D507A308F364756E2164756E21
+//# debugId=D77F3F3DCD4BFA5364756E2164756E21
 //# sourceMappingURL=sandstone.esm.js.map