@holoscript/core 6.0.4 → 6.1.2

package/dist/{chunk-V3NN3HPP.js → chunk-YIMN575O.js}

@@ -1,5 +1,5 @@
-import { ErrorRecovery, generateQuickFixes, enrichErrorWithSuggestions, LIFECYCLE_HOOKS, STRUCTURAL_DIRECTIVES } from './chunk-MPXBVFHQ.js';
-import { VR_TRAITS } from './chunk-NDQNIJEH.js';
+import { ErrorRecovery, generateQuickFixes, enrichErrorWithSuggestions, LIFECYCLE_HOOKS, STRUCTURAL_DIRECTIVES } from './chunk-4N4SXXWF.js';
+import { VR_TRAITS } from './chunk-2BSMSUCE.js';
 import * as crypto from 'crypto';
 
 // src/parser/HybridChunker.ts
@@ -660,6 +660,220 @@ var ParseCache = class {
 };
 var globalParseCache = new ParseCache();
 
+// src/parser/IncrementalParser.ts
+var ChunkBasedIncrementalParser = class {
+  constructor(cache = globalParseCache) {
+    this.lastSource = "";
+    this.lastChunks = /* @__PURE__ */ new Map();
+    this.cache = cache;
+    this.parser = new HoloScriptPlusParser({
+      enableVRTraits: true,
+      enableTypeScriptImports: true,
+      strict: false
+    });
+  }
+  /**
+   * Parse source with incremental caching
+   */
+  parse(source) {
+    const startTime = Date.now();
+    let cached = 0;
+    let parsed = 0;
+    const changedChunks = [];
+    const currentChunks = this.detectChunks(source);
+    const chunkMap = new Map(currentChunks.map((c) => [c.id, c]));
+    const changedIds = this.identifyChangedChunks(currentChunks);
+    changedChunks.push(...changedIds);
+    const dependentIds = this.findDependents(changedIds, currentChunks);
+    const toParseIds = /* @__PURE__ */ new Set([...changedIds, ...dependentIds]);
+    const chunkNodes = /* @__PURE__ */ new Map();
+    for (const chunk of currentChunks) {
+      const hash = ParseCache.hash(chunk.content);
+      if (toParseIds.has(chunk.id)) {
+        const chunkNode = this.parseChunk(chunk);
+        if (chunkNode) {
+          chunkNodes.set(chunk.id, chunkNode);
+          this.cache.set(chunk.id, hash, chunkNode);
+          parsed++;
+        }
+      } else {
+        const cached_node = this.cache.get(chunk.id, hash);
+        if (cached_node) {
+          chunkNodes.set(chunk.id, cached_node);
+          cached++;
+        } else {
+          const chunkNode = this.parseChunk(chunk);
+          if (chunkNode) {
+            chunkNodes.set(chunk.id, chunkNode);
+            this.cache.set(chunk.id, hash, chunkNode);
+            parsed++;
+          }
+        }
+      }
+    }
+    const ast = this.assembleAST(chunkNodes, currentChunks);
+    this.lastSource = source;
+    this.lastChunks = chunkMap;
+    const duration = Date.now() - startTime;
+    return {
+      ast,
+      cached,
+      parsed,
+      duration,
+      changedChunks
+    };
+  }
+  /**
+   * Detects top-level chunks in the source
+   */
+  detectChunks(source) {
+    return ChunkDetector.detect(source);
+  }
+  /**
+   * Identifies which chunks have changed by comparing hashes
+   */
+  identifyChangedChunks(currentChunks) {
+    const changed = [];
+    for (const chunk of currentChunks) {
+      const hash = ParseCache.hash(chunk.content);
+      const lastChunk = this.lastChunks.get(chunk.id);
+      if (!lastChunk) {
+        changed.push(chunk.id);
+      } else {
+        const lastHash = ParseCache.hash(lastChunk.content);
+        if (hash !== lastHash) {
+          changed.push(chunk.id);
+        }
+      }
+    }
+    for (const [id, _lastChunk] of this.lastChunks.entries()) {
+      const currentChunk = this.detectChunks(this.lastSource).find((c) => c.id === id);
+      if (!currentChunk) {
+        changed.push(id);
+      }
+    }
+    return changed;
+  }
+  /**
+   * Finds chunks that depend on the changed ones
+   */
+  findDependents(changedIds, chunks) {
+    const dependents = /* @__PURE__ */ new Set();
+    const changeSet = new Set(changedIds);
+    const references = /* @__PURE__ */ new Map();
+    for (const chunk of chunks) {
+      const refs = this.extractReferences(chunk.content);
+      if (refs.size > 0) {
+        references.set(chunk.id, refs);
+      }
+    }
+    for (const [chunkId, refs] of references.entries()) {
+      if (!changeSet.has(chunkId)) {
+        for (const ref of refs) {
+          if (changeSet.has(ref) || dependents.has(ref)) {
+            dependents.add(chunkId);
+            break;
+          }
+        }
+      }
+    }
+    return Array.from(dependents);
+  }
+  /**
+   * Extracts referenced identifiers from a chunk (templates, orbs, logic)
+   */
+  extractReferences(content) {
+    const refs = /* @__PURE__ */ new Set();
+    const templateRefs = content.match(/using\s+"([^"]+)"/g);
+    if (templateRefs) {
+      templateRefs.forEach((ref) => {
+        const name = ref.match(/"([^"]+)"/)[1];
+        refs.add(`template:${name}`);
+      });
+    }
+    const spreadRefs = content.match(/\.\.\.\s*([a-zA-Z0-9_]+)/g);
+    if (spreadRefs) {
+      spreadRefs.forEach((ref) => {
+        const name = ref.replace(/\.\.\./, "").trim();
+        refs.add(`identifier:${name}`);
+      });
+    }
+    const compRefs = content.match(/@composition\s+"([^"]+)"/g);
+    if (compRefs) {
+      compRefs.forEach((ref) => {
+        const name = ref.match(/"([^"]+)"/)[1];
+        refs.add(`composition:${name}`);
+      });
+    }
+    return refs;
+  }
+  /**
+   * Parses a single chunk
+   */
+  parseChunk(chunk) {
+    try {
+      const content = this.wrapChunkForParsing(chunk);
+      const result = this.parser.parse(content);
+      if (result.success && result.ast) {
+        return result.ast;
+      }
+      return null;
+    } catch (error) {
+      console.warn(`Failed to parse chunk ${chunk.id}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Wraps chunk content to make it parseable in isolation
+   */
+  wrapChunkForParsing(chunk) {
+    return chunk.content;
+  }
+  /**
+   * Assembles final AST from parsed chunks
+   */
+  assembleAST(chunkNodes, chunks) {
+    const children = [];
+    for (const chunk of chunks) {
+      const node = chunkNodes.get(chunk.id);
+      if (node) {
+        children.push(node);
+      }
+    }
+    if (children.length === 1) {
+      return children[0];
+    }
+    return {
+      type: "fragment",
+      children,
+      properties: {},
+      directives: [],
+      traits: /* @__PURE__ */ new Map(),
+      loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } }
+    };
+  }
+  /**
+   * Clears the internal cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.lastChunks.clear();
+  }
+  /**
+   * Gets cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.lastChunks.size,
+      maxSize: 500
+    };
+  }
+};
+function parseIncrementalChunks(source, cache = globalParseCache) {
+  const parser = new ChunkBasedIncrementalParser(cache);
+  return parser.parse(source);
+}
+
 // src/parser/RichErrors.ts
 var HSPLUS_ERROR_CODES = {
   // Syntax Errors (HSP001-HSP099)
@@ -1553,6 +1767,17 @@ var HoloScriptPlusParser = class {
     this.hasControlFlow = false;
     this.compiledExpressions = /* @__PURE__ */ new Map();
     this.errorRecovery = new ErrorRecovery();
+    /**
+     * Internal incremental parser for parseIncremental.
+     * Uses ChunkBasedIncrementalParser with AST-aware chunking and
+     * dependency tracking — no fallback to full re-parse for unchanged chunks.
+     */
+    this._incrementalParser = null;
+    /**
+     * Per-cache incremental parser map so callers can supply their own cache
+     * and still get a dedicated ChunkBasedIncrementalParser instance.
+     */
+    this._incrementalParserCache = /* @__PURE__ */ new Map();
     this.options = {
       enableVRTraits: true,
       enableTypeScriptImports: true,
@@ -1617,9 +1842,33 @@ var HoloScriptPlusParser = class {
     return this.buildResult(root);
   }
   /**
-   * Performs an incremental parse using cached nodes for unchanged chunks
+   * Performs an incremental parse using ChunkBasedIncrementalParser with
+   * AST-aware chunking, hash-based caching, and dependency tracking.
+   *
+   * Unchanged chunks are served from cache (zero re-parse cost). Only chunks
+   * whose content hash changed — plus chunks that reference changed ones via
+   * `using`, spread, or `@composition` — are re-parsed.
+   *
+   * Previous implementation fell back to a full re-parse per chunk because it
+   * used `ChunkDetector.detect()` inline without the stateful comparison that
+   * `ChunkBasedIncrementalParser` provides. This is now wired through the
+   * superior engine (APL WIT audit gap #3, 2026-05-21).
    */
   parseIncremental(source, cache = globalParseCache) {
+    let incrementalParser = this._incrementalParserCache.get(cache);
+    if (!incrementalParser) {
+      incrementalParser = new ChunkBasedIncrementalParser(cache);
+      this._incrementalParserCache.set(cache, incrementalParser);
+    }
+    const incrementalResult = incrementalParser.parse(source);
+    const chunks = ChunkDetector.detect(source);
+    const children = incrementalResult.ast.type === "fragment" ? incrementalResult.ast.children || [] : [incrementalResult.ast];
+    for (let i = 0; i < children.length; i++) {
+      const chunk = chunks[i];
+      if (chunk && chunk.startLine > 1) {
+        this.offsetNodeLoc(children[i], chunk.startLine - 1);
+      }
+    }
     this.source = source;
     this.errors = [];
     this.warnings = [];
@@ -1628,46 +1877,43 @@ var HoloScriptPlusParser = class {
     this.hasVRTraits = false;
     this.hasControlFlow = false;
     this.compiledExpressions = /* @__PURE__ */ new Map();
-    const chunks = ChunkDetector.detect(source);
-    const topLevelNodes = [];
-    const globalDirectives = [];
-    for (const chunk of chunks) {
-      const hash = ParseCache.hash(chunk.content);
-      const cachedNode = cache.get(chunk.id, hash);
-      if (cachedNode) {
-        topLevelNodes.push(cachedNode);
-      } else {
-        const chunkResult = this.parse(chunk.content);
-        const chunkAst = chunkResult.ast;
-        const chunkFeatures = chunkResult.features;
-        if (chunkAst?.root) {
-          const node = chunkAst.root;
-          this.offsetNodeLoc(node, chunk.startLine - 1);
-          topLevelNodes.push(node);
-          cache.set(chunk.id, hash, node);
-          this.hasState = this.hasState || !!chunkFeatures?.state;
-          this.hasVRTraits = this.hasVRTraits || !!chunkFeatures?.vrTraits;
-          this.hasControlFlow = this.hasControlFlow || !!chunkFeatures?.loops || !!chunkFeatures?.conditionals;
-          this.imports.push(...chunkAst.imports);
+    for (const node of children) {
+      if (node && typeof node === "object") {
+        const nodeAny = node;
+        if (nodeAny.traits instanceof Map) {
+          for (const [traitName] of nodeAny.traits) {
+            const name = String(traitName);
+            if (name === "state") this.hasState = true;
+            if (name === "grabbable" || name === "throwable" || name === "hoverable" || name === "clickable" || name === "collidable") {
+              this.hasVRTraits = true;
+            }
+          }
         }
-        this.errors.push(...chunkResult.errors);
-        this.warnings.push(...chunkResult.warnings || []);
       }
     }
-    const root = {
+    const root = incrementalResult.ast.type === "fragment" ? incrementalResult.ast : {
       type: "fragment",
       id: "root",
       properties: {},
-      directives: globalDirectives,
-      children: topLevelNodes,
+      directives: [],
+      children: [incrementalResult.ast],
       traits: /* @__PURE__ */ new Map(),
-      loc: {
-        start: { line: 1, column: 1 },
-        end: { line: chunks.length > 0 ? chunks[chunks.length - 1].endLine : 1, column: 1 }
-      },
-      body: topLevelNodes
+      loc: incrementalResult.ast.loc || { start: { line: 1, column: 1 }, end: { line: 1, column: 1 } },
+      body: [incrementalResult.ast]
     };
+    if (root.type === "fragment" && root.loc) {
+      root.loc.start = { line: 1, column: 1 };
+      if (chunks.length > 0) {
+        root.loc.end = { line: chunks[chunks.length - 1].endLine, column: 1 };
+      }
+    }
     const result = this.buildResult(root);
+    result.incrementalMetrics = {
+      cached: incrementalResult.cached,
+      parsed: incrementalResult.parsed,
+      duration: incrementalResult.duration,
+      changedChunks: incrementalResult.changedChunks
+    };
     return result;
   }
   buildResult(root) {
@@ -1687,15 +1933,24 @@ var HoloScriptPlusParser = class {
       }
     }
     if (version === void 0) version = "1.0";
+    const children = isFragment ? root.children || [] : [root];
+    const worlds = children.filter((c) => c.type === "world");
+    const compositions = children.filter((c) => c.type === "composition");
+    const templates = children.filter((c) => c.type === "template");
+    const npcs = children.filter((c) => c.type === "npc");
     const ast = {
       type: "Program",
       id: "root",
       properties: isFragment ? root.properties || {} : {},
       directives,
-      children: isFragment ? root.children || [] : [root],
+      children,
+      worlds,
+      compositions,
+      templates,
+      npcs,
       traits: isFragment ? root.traits || /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(),
       loc: root.loc,
-      body: isFragment ? root.children || [] : [root],
+      body: children,
       version,
       migrations: migrations.length > 0 ? migrations : void 0,
       root,
@@ -1780,14 +2035,14 @@ var HoloScriptPlusParser = class {
               globalDirectives.push(...currentDirectives);
             } else {
               this.error(
-                `Expected node after directives, got ${this.current().type}. Valid nodes: orb, template, logic, object, composition, scene, group`,
+                `Expected node after directives, got ${this.current().type}. Valid nodes: orb, template, logic, object, world, composition, scene, group`,
                 "HSP003"
               );
               globalDirectives.push(...currentDirectives);
             }
           } else if (!this.check("EOF")) {
             this.error(
-              `Unexpected token ${this.current().type} "${this.current().value}" at top level. Expected: composition, object, template, logic, or @directive`,
+              `Unexpected token ${this.current().type} "${this.current().value}" at top level. Expected: composition, object, world, template, logic, or @directive`,
               "HSP001"
             );
             throw new Error("ParseError");
@@ -1976,7 +2231,7 @@ var HoloScriptPlusParser = class {
         }
       };
     }
-    if (type === "composition") {
+    if (type === "composition" || type === "world") {
       let id2;
       if (this.check("HASH")) {
         this.advance();
@@ -1989,14 +2244,25 @@ var HoloScriptPlusParser = class {
         id2 = this.advance().value;
       }
       const compBody = this.parseCompositionBlock();
+      const traits2 = /* @__PURE__ */ new Map();
+      for (const child of compBody.children) {
+        if (child.type === "fragment" && Array.isArray(child.directives)) {
+          for (const d of child.directives) {
+            if (d.type === "trait") {
+              traits2.set(d.name, d.config);
+              this.hasVRTraits = true;
+            }
+          }
+        }
+      }
       return {
-        type: "composition",
+        type: type === "composition" ? "composition" : "world",
         name: id2,
         id: id2,
         properties: compBody.properties || {},
         directives: [],
         children: compBody.children,
-        traits: /* @__PURE__ */ new Map(),
+        traits: traits2,
         body: compBody,
         loc: {
           start: { line: startToken.line, column: startToken.column },
@@ -2148,7 +2414,7 @@ var HoloScriptPlusParser = class {
             properties[key] = spreadNode;
           } else {
             const token = this.current();
-            const isKeyToken = token.type === "IDENTIFIER" || token.type === "STRING" || token.type === "STATE" || token.type === "STATE_MACHINE" || token.type === "INITIAL" || token.type === "ON_ENTRY" || token.type === "ON_EXIT" || token.type === "TRANSITION";
+            const isKeyToken = token.type === "IDENTIFIER" || token.type === "STRING" || token.type === "HASH" || token.type === "STATE" || token.type === "STATE_MACHINE" || token.type === "INITIAL" || token.type === "ON_ENTRY" || token.type === "ON_EXIT" || token.type === "TRANSITION";
             if (isKeyToken) {
               const saved = this.pos;
               const name = this.advance().value;
@@ -2170,6 +2436,7 @@ var HoloScriptPlusParser = class {
                 "spatial_group",
                 "scene",
                 "group",
+                "world",
                 "module",
                 "struct",
                 "orb",
@@ -2177,7 +2444,9 @@ var HoloScriptPlusParser = class {
                 "assert",
                 "transition",
                 "on_entry",
-                "on_exit"
+                "on_exit",
+                "page",
+                "include"
               ];
               if (name === "transition" && this.check("STRING")) {
                 const event = this.advance().value;
@@ -2352,7 +2621,7 @@ var HoloScriptPlusParser = class {
       } else if (this.check("LBRACE")) {
         config2 = this.parseBlockContent();
       }
-      return { type: "trait", name, config: config2 };
+      return this.parseTraitSumTail({ type: "trait", name, config: config2 });
     }
     if (LIFECYCLE_HOOKS.includes(name)) {
       const params = [];
@@ -2690,7 +2959,35 @@ var HoloScriptPlusParser = class {
         config.body = this.parseCodeBlock();
       }
     }
-    return { type: "trait", name, config };
+    return this.parseTraitSumTail({ type: "trait", name, config });
+  }
+  parseTraitSumTail(first) {
+    if (!this.check("PLUS")) {
+      return first;
+    }
+    const alternatives = [
+      { type: "trait_atom", name: first.name, config: first.config ?? {} }
+    ];
+    while (this.check("PLUS")) {
+      this.advance();
+      alternatives.push(this.parseTraitAtom());
+    }
+    return {
+      type: "trait_sum",
+      operation: "additive",
+      alternatives
+    };
+  }
+  parseTraitAtom() {
+    this.expect("AT", "Expected @ in trait sum alternative");
+    const name = this.expect("IDENTIFIER", "Expected trait name in trait sum alternative").value;
+    let config = {};
+    if (this.check("LPAREN")) {
+      config = this.parseTraitConfig();
+    } else if (this.check("LBRACE")) {
+      config = this.parseBlockContent();
+    }
+    return { type: "trait_atom", name, config };
   }
   /**
    * Parse a string inside parentheses: ("name")
@@ -2878,6 +3175,7 @@ var HoloScriptPlusParser = class {
       "spatial_group",
       "scene",
       "group",
+      "world",
       "module",
       "struct",
       "orb",
@@ -2891,7 +3189,9 @@ var HoloScriptPlusParser = class {
       "light",
       "npc",
       "camera",
-      "timeline"
+      "timeline",
+      "page",
+      "include"
     ];
     while (!this.check("RBRACE") && !this.check("EOF")) {
       const currentDirectives = [];
@@ -2908,11 +3208,69 @@ var HoloScriptPlusParser = class {
       if (isNodeStart) {
         const token = this.current();
         const next = this.peek(1);
-        if (next.type === "COLON" || next.type === "EQUALS") {
+        if (token.type === "IDENTIFIER" && token.value === "system" && (next.type === "IDENTIFIER" || next.type === "STRING") && this.peek(2).type !== "LBRACE") {
+          const startToken = this.advance();
+          const name = this.advance().value;
+          result.systems.push({
+            type: "system",
+            name,
+            id: name,
+            properties: {},
+            directives: currentDirectives,
+            children: [],
+            traits: /* @__PURE__ */ new Map(),
+            loc: {
+              start: { line: startToken.line, column: startToken.column },
+              end: { line: this.current().line, column: this.current().column }
+            }
+          });
+        } else if (token.type === "IDENTIFIER" && token.value === "page" && next.type === "STRING") {
+          const startToken = this.advance();
+          const name = this.advance().value;
+          const properties = {};
+          if (this.check("LBRACE")) {
+            this.advance();
+            this.skipNewlines();
+            while (!this.check("RBRACE") && !this.check("EOF")) {
+              this.skipNewlines();
+              if (this.check("RBRACE") || this.check("EOF")) break;
+              if (this.check("IDENTIFIER")) {
+                const key = this.advance().value;
+                if (this.check("COLON") || this.check("EQUALS")) {
+                  this.advance();
+                  properties[key] = this.parseValue();
+                } else if (this.check("STRING")) {
+                  properties[key] = this.advance().value;
+                } else {
+                  properties[key] = true;
+                }
+              } else if (this.check("COMMA")) {
+                this.advance();
+              } else {
+                this.advance();
+              }
+              this.skipNewlines();
+            }
+            this.expect("RBRACE", "Expected }");
+          }
+          result.children.push({
+            type: "page",
+            name,
+            id: name,
+            properties,
+            directives: currentDirectives,
+            children: [],
+            traits: /* @__PURE__ */ new Map(),
+            loc: {
+              start: { line: startToken.line, column: startToken.column },
+              end: { line: this.current().line, column: this.current().column }
+            }
+          });
+        } else if (next.type === "COLON" || next.type === "EQUALS") {
           const key = this.advance().value;
           this.advance();
           result.properties[key] = this.parseValue();
-        } else if (childNodeKeywords.includes(token.value) && (next.type === "LBRACE" || next.type === "STRING" || next.type === "IDENTIFIER")) {
+        } else if (childNodeKeywords.includes(token.value) && (next.type === "LBRACE" || next.type === "STRING" || next.type === "IDENTIFIER" || next.type === "HASH")) {
           const keyword = this.current().value;
           const node = this.parseNode();
           node.directives = [...currentDirectives, ...node.directives || []];
@@ -2926,7 +3284,7 @@ var HoloScriptPlusParser = class {
         } else if (!childNodeKeywords.includes(token.value) && (next.type === "STRING" || next.type === "NUMBER" || next.type === "BOOLEAN" || next.type === "NULL")) {
           const key = this.advance().value;
           result.properties[key] = this.parseValue();
-        } else if (next.type === "LBRACE" || next.type === "IDENTIFIER" || next.type === "STRING") {
+        } else if (next.type === "LBRACE" || next.type === "IDENTIFIER" || next.type === "STRING" || next.type === "HASH") {
           const keyword = this.current().value;
           const node = this.parseNode();
           node.directives = [...currentDirectives, ...node.directives || []];
@@ -3022,6 +3380,7 @@ var HoloScriptPlusParser = class {
   parseLogicBlock() {
     const result = {
       functions: [],
+      actions: [],
       eventHandlers: [],
       tickHandlers: []
     };
@@ -3057,6 +3416,32 @@ var HoloScriptPlusParser = class {
           }
           const body = this.parseCodeBlock();
           result.functions.push({ name: funcName, params, body });
+        } else if (keyword === "action") {
+          this.advance();
+          const actionName = this.check("IDENTIFIER") || this.check("STRING") ? this.advance().value : "anonymous";
+          const params = [];
+          if (this.check("LPAREN")) {
+            this.advance();
+            while (!this.check("RPAREN") && !this.check("EOF")) {
+              if (this.check("IDENTIFIER")) {
+                params.push(this.advance().value);
+                if (this.check("COLON")) {
+                  this.advance();
+                  while (!this.check("COMMA") && !this.check("RPAREN") && !this.check("EOF")) {
+                    this.advance();
+                  }
+                }
+                if (this.check("COMMA")) {
+                  this.advance();
+                }
+              } else {
+                this.advance();
+              }
+            }
+            this.expect("RPAREN", "Expected )");
+          }
+          const body = this.check("LBRACE") ? this.parseCodeBlock() : "";
+          result.actions.push({ name: actionName, params, body });
         } else if (keyword === "on_tick") {
           this.advance();
           let interval = 1;
@@ -4457,6 +4842,6 @@ function parse(source, options) {
   return parser.parse(source);
 }
 
-export { ChunkDetector, HSPLUS_ERROR_CODES, HoloScriptPlusParser, ParseCache, createKeywordError, createParser, createRichError, createTraitError, findSimilarKeyword, findSimilarTrait, formatRichError, formatRichErrors, getErrorCodeDocumentation, getSourceContext, globalParseCache, parse };
-//# sourceMappingURL=chunk-V3NN3HPP.js.map
-//# sourceMappingURL=chunk-V3NN3HPP.js.map
+export { ChunkBasedIncrementalParser, HSPLUS_ERROR_CODES, HoloScriptPlusParser, ParseCache, createKeywordError, createParser, createRichError, createTraitError, findSimilarKeyword, findSimilarTrait, formatRichError, formatRichErrors, getErrorCodeDocumentation, getSourceContext, globalParseCache, parse, parseIncrementalChunks };
+//# sourceMappingURL=chunk-YIMN575O.js.map
+//# sourceMappingURL=chunk-YIMN575O.js.map