@holoscript/core 8.0.8 → 8.0.10

package/dist/{chunk-MDR235RZ.js → chunk-734OB5SK.js}

@@ -1,4 +1,5 @@
 import { logger } from './chunk-PHENW4MQ.js';
+import { LOCOMOTION_REACTION_TRIGGERS, isLocomotionReactionTrigger } from './chunk-63AUAIL6.js';
 
 // src/HoloScriptPersistenceParser.ts
 var HoloScriptPersistenceParser = class {
@@ -143,8 +144,10 @@ var CODE_SECURITY_CONFIG = {
     "__proto__",
     "fs",
     "child_process",
-    "exec",
-    "spawn"
+    "exec"
+    // NOTE: 'spawn' is intentionally excluded — it is a valid .hs game-logic keyword
+    // (MMO entity spawn rules). The security gate uses word-boundary regex, so
+    // node-API 'spawn' from child_process cannot slip through via game code anyway.
   ]
 };
 function stripCommentsAndStrings(code) {
@@ -303,11 +306,41 @@ var HoloScriptCodeParser = class {
       "on_collision",
       "on_enter",
       "on_exit",
+      // Domain-neutral interaction / lifecycle reaction triggers
+      "on_grab",
+      "on_release",
+      "on_use",
+      "on_hover",
+      "on_proximity",
+      "on_signal",
+      "on_input",
+      "on_tick",
+      // Movement statement clause keywords (`move x to [..] over 2 via glide`)
+      "over",
+      "via",
+      "easing",
+      // Movement reaction triggers (routes to ReactionCategory 'movement').
+      // Sourced from the locomotion SSOT so the keyword set and reactionCategory()
+      // share exactly one list — never edit these names in two places.
+      ...LOCOMOTION_REACTION_TRIGGERS,
       "using",
       "memory",
       "semantic",
       "episodic",
-      "procedural"
+      "procedural",
+      "pcg_graph",
+      "density_filter",
+      "slope_mask",
+      "snap_to_terrain",
+      // MMO / game-logic keywords (Phase: game-logic constructs)
+      "ability",
+      "loot_table",
+      "authority",
+      "on_combat",
+      "on_death",
+      "on_spawn",
+      "on_cast"
+      // 'spawn' already present above (line ~304); Set deduplicates, listed here for readability
     ]);
   }
   /**
@@ -768,6 +801,48 @@ var HoloScriptCodeParser = class {
           return this.parseZone();
         case "memory":
           return this.parseMemory();
+        // MMO / game-logic constructs
+        case "ability":
+          return this.parseAbility();
+        case "loot_table":
+          return this.parseLootTable();
+        case "spawn":
+          return this.parseSpawnRule();
+        case "authority":
+          return this.parseAuthorityBlock();
+        // Reactions — domain-neutral event blocks. Combat triggers kept for
+        // back-compat; interaction & lifecycle triggers generalize the layer.
+        case "on_combat":
+        case "on_death":
+        case "on_spawn":
+        case "on_cast":
+        case "on_interact":
+        case "on_collision":
+        case "on_proximity":
+        case "on_grab":
+        case "on_release":
+        case "on_use":
+        case "on_hover":
+        case "on_enter":
+        case "on_exit":
+        case "on_signal":
+        case "on_input":
+        case "on_tick":
+        // Movement reactions
+        case "on_move":
+        case "on_walk":
+        case "on_run":
+        case "on_jump":
+        case "on_land":
+        case "on_strafe":
+        case "on_teleport":
+          return this.parseGameEventBlock();
+        // Movements — first-class movement statement (serves F.118 VR locomotion)
+        case "move":
+          return this.parseMove();
+        // Actions — domain-neutral verb declaration (general form of `ability`)
+        case "action":
+          return this.parseActionDecl();
         default:
           return this.parseExpressionStatement();
       }
@@ -969,19 +1044,19 @@ var HoloScriptCodeParser = class {
         position: [0, 0, 0]
       };
     }
-    const exports$1 = [];
+    const exports = [];
     if (this.check("punctuation", "{")) {
       this.advance();
       while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
         const name = this.expectIdentifier();
-        if (name) exports$1.push(name);
+        if (name) exports.push(name);
         if (this.check("punctuation", ",")) this.advance();
       }
       this.expect("punctuation", "}");
     }
     return {
       type: "export",
-      exports: exports$1,
+      exports,
       position: [0, 0, 0]
     };
   }
@@ -1142,6 +1217,41 @@ var HoloScriptCodeParser = class {
       const bindings = this.parseBindingsBlock();
       return { type: "bindings", bindings };
     }
+    const GAME_LOGIC_ANNOTATIONS = /* @__PURE__ */ new Set([
+      "server_side",
+      "client_side",
+      "replicated",
+      "cooldown",
+      "mana_cost",
+      "damage_type",
+      "drop_chance",
+      // Ability-stat annotations carrying an inline value (e.g. `@range 30`,
+      // `@gcd 1.5s`, `@cast_time 2s`, `@authority server`).
+      "range",
+      "gcd",
+      "cast_time",
+      "authority",
+      "authority_envelope"
+    ]);
+    if (GAME_LOGIC_ANNOTATIONS.has(name)) {
+      let value;
+      const next = this.currentToken();
+      if (next && next.type !== "newline" && next.value !== "{" && next.value !== "}") {
+        let raw = "";
+        while (this.position < this.tokens.length) {
+          const t = this.currentToken();
+          if (!t || t.type === "newline" || t.value === ";" || t.value === "{") break;
+          raw += t.value;
+          this.advance();
+        }
+        value = raw.trim() || void 0;
+      }
+      return {
+        type: "trait",
+        name,
+        config: value !== void 0 ? { value } : {}
+      };
+    }
     if (name.startsWith("on_")) {
       let body = "";
       if (this.check("punctuation", "{")) {
@@ -2068,6 +2178,609 @@ var HoloScriptCodeParser = class {
   /**
    * Parse generic expression statement (e.g. function call or assignment)
    */
+  // ===========================================================================
+  // MMO / GAME-LOGIC PARSERS
+  // ===========================================================================
+  /**
+   * Parse ability declaration.
+   *
+   * Syntax:
+   *   ability <name> {
+   *     @cooldown 5s
+   *     @mana_cost 30
+   *     @damage_type fire
+   *     @range 30
+   *     on_cast(target) { ... }
+   *     on_hit { ... }
+   *     on_miss { ... }
+   *     <key>: <value>
+   *   }
+   *
+   * Compiles to a generic `game-ability` AST node. The downstream compiler maps
+   * this to CombatAbilityTrait handler entries.
+   */
+  parseAbility() {
+    this.expect("keyword", "ability");
+    const name = this.expectName() || `ability_${Date.now()}`;
+    const properties = {};
+    const directives = [];
+    const eventBlocks = [];
+    let damageFormula;
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const token = this.currentToken();
+        if (token?.type === "punctuation" && token.value === "@") {
+          const dir = this.parseDirective();
+          if (dir) directives.push(dir);
+          this.skipNewlines();
+          continue;
+        }
+        if ((token?.type === "keyword" || token?.type === "identifier") && token.value === "damage_formula") {
+          damageFormula = this.parseDamageFormula();
+          this.skipNewlines();
+          continue;
+        }
+        const nextAfterIdent = (token?.type === "keyword" || token?.type === "identifier") && this.tokens[this.position + 1]?.value === "{";
+        if (nextAfterIdent) {
+          const blockKey = token.value;
+          this.advance();
+          let raw = "";
+          if (this.check("punctuation", "{")) {
+            this.advance();
+            let depth = 1;
+            while (depth > 0 && this.position < this.tokens.length) {
+              const t = this.advance();
+              if (t.value === "{") depth++;
+              else if (t.value === "}") {
+                depth--;
+                if (depth === 0) break;
+              }
+              raw += (t.type === "string" ? JSON.stringify(t.value) : t.value) + " ";
+            }
+          }
+          properties[blockKey] = raw.trim();
+          this.skipNewlines();
+          continue;
+        }
+        if ((token?.type === "keyword" || token?.type === "identifier") && token.value.startsWith("on_")) {
+          const event = token.value;
+          this.advance();
+          const params = [];
+          if (this.check("punctuation", "(")) {
+            this.advance();
+            while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+              const p = this.expectIdentifier();
+              if (p) params.push(p);
+              if (this.check("punctuation", ",")) this.advance();
+            }
+            this.expect("punctuation", ")");
+          }
+          let body = "";
+          if (this.check("punctuation", "{")) {
+            this.advance();
+            let depth = 1;
+            while (depth > 0 && this.position < this.tokens.length) {
+              const t = this.advance();
+              if (t.value === "{") depth++;
+              else if (t.value === "}") {
+                depth--;
+                if (depth === 0) break;
+              }
+              body += (t.type === "string" ? JSON.stringify(t.value) : t.value) + " ";
+            }
+          }
+          eventBlocks.push({ event, params, body: body.trim() });
+          this.skipNewlines();
+          continue;
+        }
+        const prop = this.parseProperty();
+        if (prop) {
+          properties[prop.key] = prop.value;
+        } else {
+          this.advance();
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    const abilityNode = {
+      type: "game-ability",
+      name,
+      properties,
+      directives: directives.length > 0 ? directives : void 0,
+      eventBlocks: eventBlocks.length > 0 ? eventBlocks : void 0,
+      damageFormula,
+      position: [0, 0, 0]
+    };
+    return abilityNode;
+  }
+  /**
+   * Parse a `damage_formula { ... }` sub-block inside an ability declaration.
+   *
+   * Accepted fields (all optional; safe defaults apply):
+   *   base:            number  — flat pre-scaling damage (default 0)
+   *   scaling:         string  — expression emitted verbatim (default "0")
+   *   crit_multiplier: number  — damage multiplier on crit (default 1.5)
+   *   crit_chance:     string  — 0-1 expression (default "0.05")
+   *   resist_school:   string  — elemental school name (default "")
+   *
+   * Any other key-value pairs are collected into the `raw` bag for
+   * forward-compatibility and passed through to the compiler.
+   */
+  parseDamageFormula() {
+    this.advance();
+    const raw = {};
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const prop = this.parseProperty();
+        if (prop) {
+          raw[prop.key] = prop.value;
+        } else {
+          this.advance();
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    const coerceNum = (v, fallback) => {
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+      if (typeof v === "string") {
+        const n = Number(v.trim());
+        if (Number.isFinite(n)) return n;
+      }
+      return fallback;
+    };
+    const coerceStr = (v, fallback) => {
+      if (typeof v === "string" && v.trim().length > 0) return v.trim();
+      if (typeof v === "number") return String(v);
+      return fallback;
+    };
+    return {
+      base: coerceNum(raw["base"], 0),
+      scaling: coerceStr(raw["scaling"], "0"),
+      critMultiplier: coerceNum(raw["crit_multiplier"] ?? raw["critMultiplier"], 1.5),
+      critChance: coerceStr(raw["crit_chance"] ?? raw["critChance"], "0.05"),
+      resistSchool: coerceStr(raw["resist_school"] ?? raw["resistSchool"], ""),
+      raw
+    };
+  }
+  /**
+   * Parse spawn declaration.
+   *
+   * Syntax:
+   *   spawn <name> {
+   *     entity: goblin_warrior
+   *     zone: ironveil_outskirts
+   *     max_count: 8
+   *     respawn_interval: 120s
+   *     loot_table: goblin_drops
+   *     faction: goblin_clan
+   *   }
+   *
+   * Compiles to a generic `game-spawn` AST node. The MMO compiler uses this
+   * for load-balancing across shards.
+   */
+  parseSpawnRule() {
+    this.expect("keyword", "spawn");
+    const name = this.expectName() || `spawn_${Date.now()}`;
+    const properties = {};
+    const directives = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const t = this.currentToken();
+        if (t?.type === "punctuation" && t.value === "@") {
+          const dir = this.parseDirective();
+          if (dir) directives.push(dir);
+        } else {
+          const prop = this.parseProperty();
+          if (prop) {
+            properties[prop.key] = prop.value;
+          } else {
+            this.advance();
+          }
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    const spawnNode = {
+      type: "game-spawn",
+      name,
+      properties,
+      directives: directives.length > 0 ? directives : void 0,
+      position: [0, 0, 0]
+    };
+    return spawnNode;
+  }
+  /**
+   * Parse loot_table declaration.
+   *
+   * Syntax:
+   *   loot_table <name> {
+   *     item <item_name> { @drop_chance 0.15 }
+   *     gold { @amount 50..200 }
+   *   }
+   *
+   * Compiles to a generic `game-loot-table` AST node.
+   */
+  parseLootTable() {
+    this.expect("keyword", "loot_table");
+    const name = this.expectName() || `loot_${Date.now()}`;
+    const entries = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const token = this.currentToken();
+        if (!token) break;
+        const kind = token.value;
+        this.advance();
+        let entryName = kind;
+        const next = this.currentToken();
+        if (next && (next.type === "identifier" || next.type === "keyword") && next.value !== "{") {
+          entryName = next.value;
+          this.advance();
+        }
+        const entryProps = {};
+        const entryDirs = [];
+        if (this.check("punctuation", "{")) {
+          this.advance();
+          while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+            this.skipNewlines();
+            if (this.check("punctuation", "}")) break;
+            const t = this.currentToken();
+            if (t?.type === "punctuation" && t.value === "@") {
+              const dir = this.parseDirective();
+              if (dir) entryDirs.push(dir);
+            } else {
+              const prop = this.parseProperty();
+              if (prop) {
+                entryProps[prop.key] = prop.value;
+              } else {
+                this.advance();
+              }
+            }
+            this.skipNewlines();
+          }
+          this.expect("punctuation", "}");
+        }
+        entries.push({ kind, name: entryName, properties: entryProps, directives: entryDirs });
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    const lootNode = {
+      type: "game-loot-table",
+      name,
+      entries,
+      position: [0, 0, 0]
+    };
+    return lootNode;
+  }
+  /**
+   * Parse authority declaration.
+   *
+   * Syntax:
+   *   authority <name> {
+   *     model: server_authoritative
+   *     sync_rate: 20hz
+   *     server_reconcile: true
+   *   }
+   *
+   * Compiles to a generic `game-authority` AST node. The networked compilation
+   * pass maps this to the correct authority model per target runtime.
+   */
+  parseAuthorityBlock() {
+    this.expect("keyword", "authority");
+    const name = this.expectName() || `authority_${Date.now()}`;
+    const properties = {};
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const prop = this.parseProperty();
+        if (prop) {
+          properties[prop.key] = prop.value;
+        } else {
+          this.advance();
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    const authorityNode = {
+      type: "game-authority",
+      name,
+      properties,
+      position: [0, 0, 0]
+    };
+    return authorityNode;
+  }
+  /**
+   * Parse top-level game event blocks: on_combat, on_death, on_spawn, on_cast.
+   *
+   * Syntax:
+   *   on_death { drop_loot: goblin_drops; trigger_event: "mob_killed" }
+   *   on_spawn { set_state: alive }
+   *
+   * These may appear as top-level declarations on entity/npc blocks or inside
+   * ability blocks. Returns a generic `game-event-block` AST node.
+   */
+  parseGameEventBlock() {
+    const token = this.currentToken();
+    const eventName = token?.value || "on_unknown";
+    this.advance();
+    const params = [];
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+        const p = this.expectIdentifier();
+        if (p) params.push(p);
+        if (this.check("punctuation", ",")) this.advance();
+      }
+      this.expect("punctuation", ")");
+    }
+    const properties = {};
+    let body = "";
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let depth = 1;
+      while (depth > 0 && this.position < this.tokens.length) {
+        const t = this.currentToken();
+        if (t.value === "{") depth++;
+        else if (t.value === "}") {
+          depth--;
+          if (depth === 0) {
+            this.advance();
+            break;
+          }
+        }
+        body += (t.type === "string" ? JSON.stringify(t.value) : t.value) + " ";
+        this.advance();
+      }
+    }
+    const eventNode = {
+      type: "game-event-block",
+      name: eventName,
+      params,
+      body: body.trim(),
+      category: this.reactionCategory(eventName),
+      properties,
+      position: [0, 0, 0]
+    };
+    return eventNode;
+  }
+  /** Map a trigger keyword to its routing bucket (see ReactionCategory). */
+  reactionCategory(trigger) {
+    if (isLocomotionReactionTrigger(trigger)) return "movement";
+    switch (trigger) {
+      case "on_interact":
+      case "on_grab":
+      case "on_release":
+      case "on_use":
+      case "on_hover":
+        return "interaction";
+      case "on_collision":
+      case "on_proximity":
+        return "collision";
+      case "on_spawn":
+      case "on_death":
+      case "on_enter":
+      case "on_exit":
+      case "on_tick":
+        return "lifecycle";
+      case "on_combat":
+      case "on_cast":
+        return "combat";
+      case "on_signal":
+      case "on_input":
+        return "signal";
+      default:
+        return "custom";
+    }
+  }
+  /**
+   * Parse a movement statement:
+   *   move <target> to [x, y, z]            // move to a position
+   *   move <target> to otherEntity          // follow / seek an entity
+   *   move <target> to [..] over 2 via glide easing ease_in_out
+   *
+   * `target` is optional and defaults to `self`. Clause order after `to` is
+   * free (`over` / `via` / `easing` may appear in any order).
+   */
+  parseMove() {
+    this.expect("keyword", "move");
+    let target = "self";
+    if (!this.check("keyword", "to")) {
+      const tt = this.currentToken();
+      if (tt && (tt.type === "identifier" || tt.type === "keyword")) {
+        target = tt.value;
+        this.advance();
+      }
+    }
+    if (!this.check("keyword", "to")) {
+      this.errors.push(this.createError("HS001", "Expected 'to' in move statement", this.currentToken()));
+      return null;
+    }
+    this.advance();
+    let destination;
+    if (this.check("punctuation", "[")) {
+      destination = this.parseVector3OrZero();
+    } else {
+      destination = this.expectIdentifier() || "origin";
+    }
+    let duration;
+    let mode;
+    let easing;
+    let guard = 0;
+    while (this.position < this.tokens.length && guard++ < 8) {
+      if (this.check("keyword", "over")) {
+        this.advance();
+        const n = this.currentToken();
+        if (n && n.type === "number") {
+          duration = parseFloat(n.value);
+          this.advance();
+        }
+      } else if (this.check("keyword", "via")) {
+        this.advance();
+        mode = this.expectIdentifier() || void 0;
+      } else if (this.check("keyword", "easing")) {
+        this.advance();
+        easing = this.expectIdentifier() || void 0;
+      } else {
+        break;
+      }
+    }
+    const node = {
+      type: "movement",
+      target,
+      destination,
+      duration,
+      mode,
+      easing,
+      properties: {},
+      position: [0, 0, 0]
+    };
+    return node;
+  }
+  /** Parse a `[x, y, z]` literal, tolerating missing components as 0. */
+  parseVector3OrZero() {
+    const out = [];
+    if (this.check("punctuation", "[")) {
+      this.advance();
+      while (!this.check("punctuation", "]") && this.position < this.tokens.length) {
+        const t = this.currentToken();
+        if (t && t.type === "number") out.push(parseFloat(t.value));
+        this.advance();
+        if (this.check("punctuation", ",")) this.advance();
+      }
+      if (this.check("punctuation", "]")) this.advance();
+    }
+    return [out[0] ?? 0, out[1] ?? 0, out[2] ?? 0];
+  }
+  /**
+   * Parse a domain-neutral action declaration:
+   *   action open(target) {
+   *     @requires { distance < 2 }
+   *     @cooldown 1s
+   *     effect { state.open = true }
+   *     animation: door_swing
+   *     @server_side
+   *   }
+   *
+   * This is the general form of the MMO `ability`: any verb with preconditions,
+   * cost, cooldown, effects, and an animation binding. `@server_side` /
+   * `@client_side` / `@replicated` are collected as directive flags.
+   */
+  parseActionDecl() {
+    this.expect("keyword", "action");
+    const name = this.expectIdentifier();
+    if (!name) return null;
+    const params = [];
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+        const p = this.expectIdentifier();
+        if (p) params.push(p);
+        if (this.check("punctuation", ",")) this.advance();
+      }
+      this.expect("punctuation", ")");
+    }
+    const clauses = [];
+    const flags = [];
+    const properties = {};
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const t = this.currentToken();
+        if (!t) break;
+        if (t.value === "@") {
+          this.advance();
+          const dirName = this.expectIdentifier() || "";
+          if (this.check("punctuation", "{")) {
+            clauses.push({ kind: dirName, body: this.consumeBracedBody() });
+          } else {
+            let raw = "";
+            while (this.position < this.tokens.length) {
+              const n = this.currentToken();
+              if (!n || n.type === "newline" || n.value === ";" || n.value === "{" || n.value === "}") break;
+              if (n.type === "keyword" && this.keywordSet.has(n.value.toLowerCase())) break;
+              raw += n.value;
+              this.advance();
+            }
+            if (raw.trim()) {
+              clauses.push({ kind: dirName, body: raw.trim() });
+            } else {
+              flags.push(dirName);
+            }
+          }
+          continue;
+        }
+        if (t.type === "identifier" && this.tokens[this.position + 1]?.value === "{") {
+          const clauseName = t.value;
+          this.advance();
+          clauses.push({ kind: clauseName, body: this.consumeBracedBody() });
+          continue;
+        }
+        const prop = this.parseProperty();
+        if (prop) {
+          properties[prop.key] = prop.value;
+        } else {
+          this.advance();
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    const node = {
+      type: "action-decl",
+      name,
+      params,
+      clauses,
+      flags,
+      properties,
+      position: [0, 0, 0]
+    };
+    return node;
+  }
+  /** Consume a `{ ... }` block (assumes the `{` is current) and return its raw inner text. */
+  consumeBracedBody() {
+    let body = "";
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let depth = 1;
+      while (depth > 0 && this.position < this.tokens.length) {
+        const t = this.currentToken();
+        if (t.value === "{") depth++;
+        else if (t.value === "}") {
+          depth--;
+          if (depth === 0) {
+            this.advance();
+            break;
+          }
+        }
+        body += (t.type === "string" ? JSON.stringify(t.value) : t.value) + " ";
+        this.advance();
+      }
+    }
+    return body.trim();
+  }
+  // ===========================================================================
+  // END MMO / GAME-LOGIC PARSERS
+  // ===========================================================================
   parseExpressionStatement() {
     let expression = "";
     let parenDepth = 0;
@@ -2513,5 +3226,5 @@ var HoloScriptCodeParser = class {
 };
 
 export { ERROR_CODES, HoloScriptCodeParser, ParserPools };
-//# sourceMappingURL=chunk-MDR235RZ.js.map
-//# sourceMappingURL=chunk-MDR235RZ.js.map
+//# sourceMappingURL=chunk-734OB5SK.js.map
+//# sourceMappingURL=chunk-734OB5SK.js.map