@galacean/engine-shader-compiler 0.0.0-experimental-2.0-skill.0 → 0.0.0-experimental-2.0-migrate.7

package/dist/browser.js

@@ -87,61 +87,6 @@
         throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
     }
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __decorate(decorators, target, key, desc) {
-      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-      return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-
-    function __generator(thisArg, body) {
-      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-      return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-      function verb(n) { return function (v) { return step([n, v]); }; }
-      function step(op) {
-          if (f) throw new TypeError("Generator is already executing.");
-          while (g && (g = 0, op[0] && (_ = 0)), _) try {
-              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-              if (y = 0, t) op = [op[0] & 2, t.value];
-              switch (op[0]) {
-                  case 0: case 1: t = op; break;
-                  case 4: _.label++; return { value: op[1], done: false };
-                  case 5: _.label++; y = op[1]; op = [0]; continue;
-                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                  default:
-                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                      if (t[2]) _.ops.pop();
-                      _.trys.pop(); continue;
-              }
-              op = body.call(thisArg, _);
-          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-      }
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-      var e = new Error(message);
-      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
     var ShaderRange = /*#__PURE__*/ function() {
         function ShaderRange() {}
         var _proto = ShaderRange.prototype;
@@ -362,6 +307,11 @@
                 ShaderCompilerUtils._shaderCompilerObjectPoolSet[i].clear();
             }
         };
+        /** Release all objects retained by the compiler pools. */ ShaderCompilerUtils.releaseAllShaderCompilerObjectPool = function releaseAllShaderCompilerObjectPool() {
+            for(var i = 0, n = ShaderCompilerUtils._shaderCompilerObjectPoolSet.length; i < n; i++){
+                ShaderCompilerUtils._shaderCompilerObjectPoolSet[i].garbageCollection();
+            }
+        };
         ShaderCompilerUtils.createGSError = function createGSError(message, errorName, source, location, file) {
             console.error(message);
             var err = new Error(message);
@@ -602,6 +552,54 @@
         return ParserUtils;
     }();
 
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __generator(thisArg, body) {
+      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+      return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+      function verb(n) { return function (v) { return step([n, v]); }; }
+      function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (g && (g = 0, op[0] && (_ = 0)), _) try {
+              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+              if (y = 0, t) op = [op[0] & 2, t.value];
+              switch (op[0]) {
+                  case 0: case 1: t = op; break;
+                  case 4: _.label++; return { value: op[1], done: false };
+                  case 5: _.label++; y = op[1]; op = [0]; continue;
+                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                  default:
+                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                      if (t[2]) _.ops.pop();
+                      _.trys.pop(); continue;
+              }
+              op = body.call(thisArg, _);
+          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
     function _is_native_reflect_construct() {
         // Since Reflect.construct can't be properly polyfilled, some
         // implementations (e.g. core-js@2) don't set the correct internal slots.
@@ -2703,12 +2701,6 @@
         this.isInMacroBranch = isInMacroBranch;
     };
 
-    function ASTNodeDecorator(nonTerminal) {
-        return function(ASTNode) {
-            ASTNode.prototype.nt = nonTerminal;
-            ASTNode.pool = ShaderCompilerUtils.createObjectPool(ASTNode);
-        };
-    }
     var TreeNode = /*#__PURE__*/ function() {
         function TreeNode() {}
         var _proto = TreeNode.prototype;
@@ -2742,6 +2734,12 @@
        * Do semantic analyze right after the ast node is generated.
        */ _proto.semanticAnalyze = function semanticAnalyze(sa) {};
         _create_class(TreeNode, [
+            {
+                key: "nt",
+                get: /** The non-terminal in grammar. */ function get() {
+                    return this.constructor.nonTerminal;
+                }
+            },
             {
                 key: "parent",
                 get: /**
@@ -2766,9 +2764,22 @@
                     return this._location;
                 }
             }
+        ], [
+            {
+                key: "pool",
+                get: function get() {
+                    var pool = TreeNode._pools.get(this);
+                    if (!pool) {
+                        pool = ShaderCompilerUtils.createObjectPool(this);
+                        TreeNode._pools.set(this, pool);
+                    }
+                    return pool;
+                }
+            }
         ]);
         return TreeNode;
     }();
+    TreeNode._pools = new WeakMap();
     (function(ASTNode) {
         function _unwrapToken(node) {
             if (_instanceof(node, BaseToken)) {
@@ -2791,10 +2802,8 @@
             }
             return TrivialNode;
         }(TreeNode);
+        TrivialNode.nonTerminal = NoneTerminal._ignore;
         ASTNode.TrivialNode = TrivialNode;
-        TrivialNode = __decorate([
-            ASTNodeDecorator(NoneTerminal._ignore)
-        ], TrivialNode);
         var ScopeBrace = /*#__PURE__*/ function(TreeNode) {
             _inherits(ScopeBrace, TreeNode);
             function ScopeBrace() {
@@ -2806,10 +2815,8 @@
             };
             return ScopeBrace;
         }(TreeNode);
+        ScopeBrace.nonTerminal = NoneTerminal.scope_brace;
         ASTNode.ScopeBrace = ScopeBrace;
-        ScopeBrace = __decorate([
-            ASTNodeDecorator(NoneTerminal.scope_brace)
-        ], ScopeBrace);
         var ScopeEndBrace = /*#__PURE__*/ function(TreeNode) {
             _inherits(ScopeEndBrace, TreeNode);
             function ScopeEndBrace() {
@@ -2821,10 +2828,8 @@
             };
             return ScopeEndBrace;
         }(TreeNode);
+        ScopeEndBrace.nonTerminal = NoneTerminal.scope_end_brace;
         ASTNode.ScopeEndBrace = ScopeEndBrace;
-        ScopeEndBrace = __decorate([
-            ASTNodeDecorator(NoneTerminal.scope_end_brace)
-        ], ScopeEndBrace);
         var JumpStatement = /*#__PURE__*/ function(TreeNode) {
             _inherits(JumpStatement, TreeNode);
             function JumpStatement() {
@@ -2844,10 +2849,8 @@
             };
             return JumpStatement;
         }(TreeNode);
+        JumpStatement.nonTerminal = NoneTerminal.jump_statement;
         ASTNode.JumpStatement = JumpStatement;
-        JumpStatement = __decorate([
-            ASTNodeDecorator(NoneTerminal.jump_statement)
-        ], JumpStatement);
         var ExpressionAstNode = /*#__PURE__*/ function(TreeNode) {
             _inherits(ExpressionAstNode, TreeNode);
             function ExpressionAstNode() {
@@ -2909,10 +2912,8 @@
             };
             return SingleDeclaration;
         }(TreeNode);
+        SingleDeclaration.nonTerminal = NoneTerminal.single_declaration;
         ASTNode.SingleDeclaration = SingleDeclaration;
-        SingleDeclaration = __decorate([
-            ASTNodeDecorator(NoneTerminal.single_declaration)
-        ], SingleDeclaration);
         var FullySpecifiedType = /*#__PURE__*/ function(TreeNode) {
             _inherits(FullySpecifiedType, TreeNode);
             function FullySpecifiedType() {
@@ -2926,10 +2927,8 @@
             };
             return FullySpecifiedType;
         }(TreeNode);
+        FullySpecifiedType.nonTerminal = NoneTerminal.fully_specified_type;
         ASTNode.FullySpecifiedType = FullySpecifiedType;
-        FullySpecifiedType = __decorate([
-            ASTNodeDecorator(NoneTerminal.fully_specified_type)
-        ], FullySpecifiedType);
         var TypeQualifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(TypeQualifier, TreeNode);
             function TypeQualifier() {
@@ -2937,10 +2936,8 @@
             }
             return TypeQualifier;
         }(TreeNode);
+        TypeQualifier.nonTerminal = NoneTerminal.type_qualifier;
         ASTNode.TypeQualifier = TypeQualifier;
-        TypeQualifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.type_qualifier)
-        ], TypeQualifier);
         var SingleTypeQualifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(SingleTypeQualifier, TreeNode);
             function SingleTypeQualifier() {
@@ -2959,10 +2956,8 @@
             };
             return SingleTypeQualifier;
         }(TreeNode);
+        SingleTypeQualifier.nonTerminal = NoneTerminal.single_type_qualifier;
         ASTNode.SingleTypeQualifier = SingleTypeQualifier;
-        SingleTypeQualifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.single_type_qualifier)
-        ], SingleTypeQualifier);
         var TypeSpecifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(TypeSpecifier, TreeNode);
             function TypeSpecifier() {
@@ -2991,10 +2986,8 @@
             ]);
             return TypeSpecifier;
         }(TreeNode);
+        TypeSpecifier.nonTerminal = NoneTerminal.type_specifier;
         ASTNode.TypeSpecifier = TypeSpecifier;
-        TypeSpecifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.type_specifier)
-        ], TypeSpecifier);
         var ArraySpecifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(ArraySpecifier, TreeNode);
             function ArraySpecifier() {
@@ -3007,10 +3000,8 @@
             };
             return ArraySpecifier;
         }(TreeNode);
+        ArraySpecifier.nonTerminal = NoneTerminal.array_specifier;
         ASTNode.ArraySpecifier = ArraySpecifier;
-        ArraySpecifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.array_specifier)
-        ], ArraySpecifier);
         var IntegerConstantExpressionOperator = /*#__PURE__*/ function(TreeNode) {
             _inherits(IntegerConstantExpressionOperator, TreeNode);
             function IntegerConstantExpressionOperator() {
@@ -3052,10 +3043,8 @@
             };
             return IntegerConstantExpressionOperator;
         }(TreeNode);
+        IntegerConstantExpressionOperator.nonTerminal = NoneTerminal.integer_constant_expression_operator;
         ASTNode.IntegerConstantExpressionOperator = IntegerConstantExpressionOperator;
-        IntegerConstantExpressionOperator = __decorate([
-            ASTNodeDecorator(NoneTerminal.integer_constant_expression_operator)
-        ], IntegerConstantExpressionOperator);
         var IntegerConstantExpression = /*#__PURE__*/ function(TreeNode) {
             _inherits(IntegerConstantExpression, TreeNode);
             function IntegerConstantExpression() {
@@ -3075,10 +3064,8 @@
             };
             return IntegerConstantExpression;
         }(TreeNode);
+        IntegerConstantExpression.nonTerminal = NoneTerminal.integer_constant_expression;
         ASTNode.IntegerConstantExpression = IntegerConstantExpression;
-        IntegerConstantExpression = __decorate([
-            ASTNodeDecorator(NoneTerminal.integer_constant_expression)
-        ], IntegerConstantExpression);
         var TypeSpecifierNonArray = /*#__PURE__*/ function(TreeNode) {
             _inherits(TypeSpecifierNonArray, TreeNode);
             function TypeSpecifierNonArray() {
@@ -3102,10 +3089,8 @@
             };
             return TypeSpecifierNonArray;
         }(TreeNode);
+        TypeSpecifierNonArray.nonTerminal = NoneTerminal.type_specifier_nonarray;
         ASTNode.TypeSpecifierNonArray = TypeSpecifierNonArray;
-        TypeSpecifierNonArray = __decorate([
-            ASTNodeDecorator(NoneTerminal.type_specifier_nonarray)
-        ], TypeSpecifierNonArray);
         var ExtBuiltinTypeSpecifierNonArray = /*#__PURE__*/ function(TreeNode) {
             _inherits(ExtBuiltinTypeSpecifierNonArray, TreeNode);
             function ExtBuiltinTypeSpecifierNonArray() {
@@ -3119,10 +3104,8 @@
             };
             return ExtBuiltinTypeSpecifierNonArray;
         }(TreeNode);
+        ExtBuiltinTypeSpecifierNonArray.nonTerminal = NoneTerminal.ext_builtin_type_specifier_nonarray;
         ASTNode.ExtBuiltinTypeSpecifierNonArray = ExtBuiltinTypeSpecifierNonArray;
-        ExtBuiltinTypeSpecifierNonArray = __decorate([
-            ASTNodeDecorator(NoneTerminal.ext_builtin_type_specifier_nonarray)
-        ], ExtBuiltinTypeSpecifierNonArray);
         var InitDeclaratorList = /*#__PURE__*/ function(TreeNode) {
             _inherits(InitDeclaratorList, TreeNode);
             function InitDeclaratorList() {
@@ -3155,10 +3138,8 @@
             };
             return InitDeclaratorList;
         }(TreeNode);
+        InitDeclaratorList.nonTerminal = NoneTerminal.init_declarator_list;
         ASTNode.InitDeclaratorList = InitDeclaratorList;
-        InitDeclaratorList = __decorate([
-            ASTNodeDecorator(NoneTerminal.init_declarator_list)
-        ], InitDeclaratorList);
         var IdentifierList = /*#__PURE__*/ function(TreeNode) {
             _inherits(IdentifierList, TreeNode);
             function IdentifierList() {
@@ -3187,10 +3168,8 @@
             };
             return IdentifierList;
         }(TreeNode);
+        IdentifierList.nonTerminal = NoneTerminal.identifier_list;
         ASTNode.IdentifierList = IdentifierList;
-        IdentifierList = __decorate([
-            ASTNodeDecorator(NoneTerminal.identifier_list)
-        ], IdentifierList);
         var Declaration = /*#__PURE__*/ function(TreeNode) {
             _inherits(Declaration, TreeNode);
             function Declaration() {
@@ -3202,10 +3181,8 @@
             };
             return Declaration;
         }(TreeNode);
+        Declaration.nonTerminal = NoneTerminal.declaration;
         ASTNode.Declaration = Declaration;
-        Declaration = __decorate([
-            ASTNodeDecorator(NoneTerminal.declaration)
-        ], Declaration);
         var FunctionProtoType = /*#__PURE__*/ function(TreeNode) {
             _inherits(FunctionProtoType, TreeNode);
             function FunctionProtoType() {
@@ -3221,10 +3198,8 @@
             };
             return FunctionProtoType;
         }(TreeNode);
+        FunctionProtoType.nonTerminal = NoneTerminal.function_prototype;
         ASTNode.FunctionProtoType = FunctionProtoType;
-        FunctionProtoType = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_prototype)
-        ], FunctionProtoType);
         var FunctionDeclarator = /*#__PURE__*/ function(TreeNode) {
             _inherits(FunctionDeclarator, TreeNode);
             function FunctionDeclarator() {
@@ -3244,10 +3219,8 @@
             };
             return FunctionDeclarator;
         }(TreeNode);
+        FunctionDeclarator.nonTerminal = NoneTerminal.function_declarator;
         ASTNode.FunctionDeclarator = FunctionDeclarator;
-        FunctionDeclarator = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_declarator)
-        ], FunctionDeclarator);
         var FunctionHeader = /*#__PURE__*/ function(TreeNode) {
             _inherits(FunctionHeader, TreeNode);
             function FunctionHeader() {
@@ -3265,10 +3238,8 @@
             };
             return FunctionHeader;
         }(TreeNode);
+        FunctionHeader.nonTerminal = NoneTerminal.function_header;
         ASTNode.FunctionHeader = FunctionHeader;
-        FunctionHeader = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_header)
-        ], FunctionHeader);
         var FunctionParameterList = /*#__PURE__*/ function(TreeNode) {
             _inherits(FunctionParameterList, TreeNode);
             function FunctionParameterList() {
@@ -3332,10 +3303,8 @@
             };
             return FunctionParameterList;
         }(TreeNode);
+        FunctionParameterList.nonTerminal = NoneTerminal.function_parameter_list;
         ASTNode.FunctionParameterList = FunctionParameterList;
-        FunctionParameterList = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_parameter_list)
-        ], FunctionParameterList);
         var MacroParamCaseList = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroParamCaseList, TreeNode);
             function MacroParamCaseList() {
@@ -3343,10 +3312,8 @@
             }
             return MacroParamCaseList;
         }(TreeNode);
+        MacroParamCaseList.nonTerminal = NoneTerminal.macro_param_case_list;
         ASTNode.MacroParamCaseList = MacroParamCaseList;
-        MacroParamCaseList = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_param_case_list)
-        ], MacroParamCaseList);
         var MacroParamBlock = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroParamBlock, TreeNode);
             function MacroParamBlock() {
@@ -3354,10 +3321,8 @@
             }
             return MacroParamBlock;
         }(TreeNode);
+        MacroParamBlock.nonTerminal = NoneTerminal.macro_param_block;
         ASTNode.MacroParamBlock = MacroParamBlock;
-        MacroParamBlock = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_param_block)
-        ], MacroParamBlock);
         var MacroParameterBranch = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroParameterBranch, TreeNode);
             function MacroParameterBranch() {
@@ -3365,10 +3330,8 @@
             }
             return MacroParameterBranch;
         }(TreeNode);
+        MacroParameterBranch.nonTerminal = NoneTerminal.macro_parameter_branch;
         ASTNode.MacroParameterBranch = MacroParameterBranch;
-        MacroParameterBranch = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_parameter_branch)
-        ], MacroParameterBranch);
         var ParameterDeclaration = /*#__PURE__*/ function(TreeNode) {
             _inherits(ParameterDeclaration, TreeNode);
             function ParameterDeclaration() {
@@ -3396,10 +3359,8 @@
             };
             return ParameterDeclaration;
         }(TreeNode);
+        ParameterDeclaration.nonTerminal = NoneTerminal.parameter_declaration;
         ASTNode.ParameterDeclaration = ParameterDeclaration;
-        ParameterDeclaration = __decorate([
-            ASTNodeDecorator(NoneTerminal.parameter_declaration)
-        ], ParameterDeclaration);
         var ParameterDeclarator = /*#__PURE__*/ function(TreeNode) {
             _inherits(ParameterDeclarator, TreeNode);
             function ParameterDeclarator() {
@@ -3415,10 +3376,8 @@
             };
             return ParameterDeclarator;
         }(TreeNode);
+        ParameterDeclarator.nonTerminal = NoneTerminal.parameter_declarator;
         ASTNode.ParameterDeclarator = ParameterDeclarator;
-        ParameterDeclarator = __decorate([
-            ASTNodeDecorator(NoneTerminal.parameter_declarator)
-        ], ParameterDeclarator);
         var CompoundStatementNoScope = /*#__PURE__*/ function(TreeNode) {
             _inherits(CompoundStatementNoScope, TreeNode);
             function CompoundStatementNoScope() {
@@ -3426,10 +3385,8 @@
             }
             return CompoundStatementNoScope;
         }(TreeNode);
+        CompoundStatementNoScope.nonTerminal = NoneTerminal.compound_statement_no_scope;
         ASTNode.CompoundStatementNoScope = CompoundStatementNoScope;
-        CompoundStatementNoScope = __decorate([
-            ASTNodeDecorator(NoneTerminal.compound_statement_no_scope)
-        ], CompoundStatementNoScope);
         var StatementList = /*#__PURE__*/ function(TreeNode) {
             _inherits(StatementList, TreeNode);
             function StatementList() {
@@ -3441,10 +3398,8 @@
             };
             return StatementList;
         }(TreeNode);
+        StatementList.nonTerminal = NoneTerminal.statement_list;
         ASTNode.StatementList = StatementList;
-        StatementList = __decorate([
-            ASTNodeDecorator(NoneTerminal.statement_list)
-        ], StatementList);
         var FunctionDefinition = /*#__PURE__*/ function(TreeNode) {
             _inherits(FunctionDefinition, TreeNode);
             function FunctionDefinition() {
@@ -3483,10 +3438,8 @@
             };
             return FunctionDefinition;
         }(TreeNode);
+        FunctionDefinition.nonTerminal = NoneTerminal.function_definition;
         ASTNode.FunctionDefinition = FunctionDefinition;
-        FunctionDefinition = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_definition)
-        ], FunctionDefinition);
         var FunctionCall = /*#__PURE__*/ function(ExpressionAstNode) {
             _inherits(FunctionCall, ExpressionAstNode);
             function FunctionCall() {
@@ -3501,10 +3454,8 @@
             };
             return FunctionCall;
         }(ExpressionAstNode);
+        FunctionCall.nonTerminal = NoneTerminal.function_call;
         ASTNode.FunctionCall = FunctionCall;
-        FunctionCall = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_call)
-        ], FunctionCall);
         var FunctionCallGeneric = /*#__PURE__*/ function(ExpressionAstNode) {
             _inherits(FunctionCallGeneric, ExpressionAstNode);
             function FunctionCallGeneric() {
@@ -3541,10 +3492,8 @@
             };
             return FunctionCallGeneric;
         }(ExpressionAstNode);
+        FunctionCallGeneric.nonTerminal = NoneTerminal.function_call_generic;
         ASTNode.FunctionCallGeneric = FunctionCallGeneric;
-        FunctionCallGeneric = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_call_generic)
-        ], FunctionCallGeneric);
         var FunctionCallParameterList = /*#__PURE__*/ function(TreeNode) {
             _inherits(FunctionCallParameterList, TreeNode);
             function FunctionCallParameterList() {
@@ -3588,10 +3537,8 @@
             };
             return FunctionCallParameterList;
         }(TreeNode);
+        FunctionCallParameterList.nonTerminal = NoneTerminal.function_call_parameter_list;
         ASTNode.FunctionCallParameterList = FunctionCallParameterList;
-        FunctionCallParameterList = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_call_parameter_list)
-        ], FunctionCallParameterList);
         var MacroCallArgCaseList = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroCallArgCaseList, TreeNode);
             function MacroCallArgCaseList() {
@@ -3599,10 +3546,8 @@
             }
             return MacroCallArgCaseList;
         }(TreeNode);
+        MacroCallArgCaseList.nonTerminal = NoneTerminal.macro_call_arg_case_list;
         ASTNode.MacroCallArgCaseList = MacroCallArgCaseList;
-        MacroCallArgCaseList = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_call_arg_case_list)
-        ], MacroCallArgCaseList);
         var MacroCallArgBlock = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroCallArgBlock, TreeNode);
             function MacroCallArgBlock() {
@@ -3610,10 +3555,8 @@
             }
             return MacroCallArgBlock;
         }(TreeNode);
+        MacroCallArgBlock.nonTerminal = NoneTerminal.macro_call_arg_block;
         ASTNode.MacroCallArgBlock = MacroCallArgBlock;
-        MacroCallArgBlock = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_call_arg_block)
-        ], MacroCallArgBlock);
         var MacroCallArgBranch = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroCallArgBranch, TreeNode);
             function MacroCallArgBranch() {
@@ -3621,10 +3564,8 @@
             }
             return MacroCallArgBranch;
         }(TreeNode);
+        MacroCallArgBranch.nonTerminal = NoneTerminal.macro_call_arg_branch;
         ASTNode.MacroCallArgBranch = MacroCallArgBranch;
-        MacroCallArgBranch = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_call_arg_branch)
-        ], MacroCallArgBranch);
         var PrecisionSpecifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(PrecisionSpecifier, TreeNode);
             function PrecisionSpecifier() {
@@ -3638,10 +3579,8 @@
             };
             return PrecisionSpecifier;
         }(TreeNode);
+        PrecisionSpecifier.nonTerminal = NoneTerminal.precision_specifier;
         ASTNode.PrecisionSpecifier = PrecisionSpecifier;
-        PrecisionSpecifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.precision_specifier)
-        ], PrecisionSpecifier);
         var FunctionIdentifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(FunctionIdentifier, TreeNode);
             function FunctionIdentifier() {
@@ -3659,10 +3598,8 @@
             };
             return FunctionIdentifier;
         }(TreeNode);
+        FunctionIdentifier.nonTerminal = NoneTerminal.function_identifier;
         ASTNode.FunctionIdentifier = FunctionIdentifier;
-        FunctionIdentifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.function_identifier)
-        ], FunctionIdentifier);
         var AssignmentExpression = /*#__PURE__*/ function(ExpressionAstNode) {
             _inherits(AssignmentExpression, ExpressionAstNode);
             function AssignmentExpression() {
@@ -3682,10 +3619,8 @@
             };
             return AssignmentExpression;
         }(ExpressionAstNode);
+        AssignmentExpression.nonTerminal = NoneTerminal.assignment_expression;
         ASTNode.AssignmentExpression = AssignmentExpression;
-        AssignmentExpression = __decorate([
-            ASTNodeDecorator(NoneTerminal.assignment_expression)
-        ], AssignmentExpression);
         var Expression = /*#__PURE__*/ function(ExpressionAstNode) {
             _inherits(Expression, ExpressionAstNode);
             function Expression() {
@@ -3703,10 +3638,8 @@
             };
             return Expression;
         }(ExpressionAstNode);
+        Expression.nonTerminal = NoneTerminal.expression;
         ASTNode.Expression = Expression;
-        Expression = __decorate([
-            ASTNodeDecorator(NoneTerminal.expression)
-        ], Expression);
         var PrimaryExpression = /*#__PURE__*/ function(ExpressionAstNode) {
             _inherits(PrimaryExpression, ExpressionAstNode);
             function PrimaryExpression() {
@@ -3740,10 +3673,8 @@
             };
             return PrimaryExpression;
         }(ExpressionAstNode);
+        PrimaryExpression.nonTerminal = NoneTerminal.primary_expression;
         ASTNode.PrimaryExpression = PrimaryExpression;
-        PrimaryExpression = __decorate([
-            ASTNodeDecorator(NoneTerminal.primary_expression)
-        ], PrimaryExpression);
         var PostfixExpression = /*#__PURE__*/ function(ExpressionAstNode) {
             _inherits(PostfixExpression, ExpressionAstNode);
             function PostfixExpression() {
@@ -3762,10 +3693,8 @@
             };
             return PostfixExpression;
         }(ExpressionAstNode);
+        PostfixExpression.nonTerminal = NoneTerminal.postfix_expression;
         ASTNode.PostfixExpression = PostfixExpression;
-        PostfixExpression = __decorate([
-            ASTNodeDecorator(NoneTerminal.postfix_expression)
-        ], PostfixExpression);
         var StructSpecifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(StructSpecifier, TreeNode);
             function StructSpecifier() {
@@ -3793,10 +3722,8 @@
             };
             return StructSpecifier;
         }(TreeNode);
+        StructSpecifier.nonTerminal = NoneTerminal.struct_specifier;
         ASTNode.StructSpecifier = StructSpecifier;
-        StructSpecifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.struct_specifier)
-        ], StructSpecifier);
         var StructDeclarationList = /*#__PURE__*/ function(TreeNode) {
             _inherits(StructDeclarationList, TreeNode);
             function StructDeclarationList() {
@@ -3825,10 +3752,8 @@
             };
             return StructDeclarationList;
         }(TreeNode);
+        StructDeclarationList.nonTerminal = NoneTerminal.struct_declaration_list;
         ASTNode.StructDeclarationList = StructDeclarationList;
-        StructDeclarationList = __decorate([
-            ASTNodeDecorator(NoneTerminal.struct_declaration_list)
-        ], StructDeclarationList);
         var StructDeclaration = /*#__PURE__*/ function(TreeNode) {
             _inherits(StructDeclaration, TreeNode);
             function StructDeclaration() {
@@ -3885,10 +3810,8 @@
             };
             return StructDeclaration;
         }(TreeNode);
+        StructDeclaration.nonTerminal = NoneTerminal.struct_declaration;
         ASTNode.StructDeclaration = StructDeclaration;
-        StructDeclaration = __decorate([
-            ASTNodeDecorator(NoneTerminal.struct_declaration)
-        ], StructDeclaration);
         var MacroStructDeclaration = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroStructDeclaration, TreeNode);
             function MacroStructDeclaration() {
@@ -3918,10 +3841,8 @@
             };
             return MacroStructDeclaration;
         }(TreeNode);
+        MacroStructDeclaration.nonTerminal = NoneTerminal.macro_struct_declaration;
         ASTNode.MacroStructDeclaration = MacroStructDeclaration;
-        MacroStructDeclaration = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_struct_declaration)
-        ], MacroStructDeclaration);
         var MacroStructBranch = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroStructBranch, TreeNode);
             function MacroStructBranch() {
@@ -3954,10 +3875,8 @@
             };
             return MacroStructBranch;
         }(TreeNode);
+        MacroStructBranch.nonTerminal = NoneTerminal.macro_struct_branch;
         ASTNode.MacroStructBranch = MacroStructBranch;
-        MacroStructBranch = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_struct_branch)
-        ], MacroStructBranch);
         var LayoutQualifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(LayoutQualifier, TreeNode);
             function LayoutQualifier() {
@@ -3969,10 +3888,8 @@
             };
             return LayoutQualifier;
         }(TreeNode);
+        LayoutQualifier.nonTerminal = NoneTerminal.layout_qualifier;
         ASTNode.LayoutQualifier = LayoutQualifier;
-        LayoutQualifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.layout_qualifier)
-        ], LayoutQualifier);
         var StructDeclaratorList = /*#__PURE__*/ function(TreeNode) {
             _inherits(StructDeclaratorList, TreeNode);
             function StructDeclaratorList() {
@@ -4001,10 +3918,8 @@
             };
             return StructDeclaratorList;
         }(TreeNode);
+        StructDeclaratorList.nonTerminal = NoneTerminal.struct_declarator_list;
         ASTNode.StructDeclaratorList = StructDeclaratorList;
-        StructDeclaratorList = __decorate([
-            ASTNodeDecorator(NoneTerminal.struct_declarator_list)
-        ], StructDeclaratorList);
         var StructDeclarator = /*#__PURE__*/ function(TreeNode) {
             _inherits(StructDeclarator, TreeNode);
             function StructDeclarator() {
@@ -4021,10 +3936,8 @@
             };
             return StructDeclarator;
         }(TreeNode);
+        StructDeclarator.nonTerminal = NoneTerminal.struct_declarator;
         ASTNode.StructDeclarator = StructDeclarator;
-        StructDeclarator = __decorate([
-            ASTNodeDecorator(NoneTerminal.struct_declarator)
-        ], StructDeclarator);
         var VariableDeclaration = /*#__PURE__*/ function(TreeNode) {
             _inherits(VariableDeclaration, TreeNode);
             function VariableDeclaration() {
@@ -4054,10 +3967,8 @@
             };
             return VariableDeclaration;
         }(TreeNode);
+        VariableDeclaration.nonTerminal = NoneTerminal.variable_declaration;
         ASTNode.VariableDeclaration = VariableDeclaration;
-        VariableDeclaration = __decorate([
-            ASTNodeDecorator(NoneTerminal.variable_declaration)
-        ], VariableDeclaration);
         var VariableDeclarationList = /*#__PURE__*/ function(TreeNode) {
             _inherits(VariableDeclarationList, TreeNode);
             function VariableDeclarationList() {
@@ -4102,10 +4013,8 @@
             };
             return VariableDeclarationList;
         }(TreeNode);
+        VariableDeclarationList.nonTerminal = NoneTerminal.variable_declaration_list;
         ASTNode.VariableDeclarationList = VariableDeclarationList;
-        VariableDeclarationList = __decorate([
-            ASTNodeDecorator(NoneTerminal.variable_declaration_list)
-        ], VariableDeclarationList);
         var VariableIdentifier = /*#__PURE__*/ function(TreeNode) {
             _inherits(VariableIdentifier, TreeNode);
             function VariableIdentifier() {
@@ -4205,10 +4114,8 @@
             };
             return VariableIdentifier;
         }(TreeNode);
+        VariableIdentifier.nonTerminal = NoneTerminal.variable_identifier;
         ASTNode.VariableIdentifier = VariableIdentifier;
-        VariableIdentifier = __decorate([
-            ASTNodeDecorator(NoneTerminal.variable_identifier)
-        ], VariableIdentifier);
         var GLShaderProgram = /*#__PURE__*/ function(TreeNode) {
             _inherits(GLShaderProgram, TreeNode);
             function GLShaderProgram() {
@@ -4221,10 +4128,8 @@
             };
             return GLShaderProgram;
         }(TreeNode);
+        GLShaderProgram.nonTerminal = NoneTerminal.gs_shader_program;
         ASTNode.GLShaderProgram = GLShaderProgram;
-        GLShaderProgram = __decorate([
-            ASTNodeDecorator(NoneTerminal.gs_shader_program)
-        ], GLShaderProgram);
         var GlobalDeclaration = /*#__PURE__*/ function(TreeNode) {
             _inherits(GlobalDeclaration, TreeNode);
             function GlobalDeclaration() {
@@ -4250,10 +4155,8 @@
             };
             return GlobalDeclaration;
         }(TreeNode);
+        GlobalDeclaration.nonTerminal = NoneTerminal.global_declaration;
         ASTNode.GlobalDeclaration = GlobalDeclaration;
-        GlobalDeclaration = __decorate([
-            ASTNodeDecorator(NoneTerminal.global_declaration)
-        ], GlobalDeclaration);
         var MacroUndef = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroUndef, TreeNode);
             function MacroUndef() {
@@ -4265,10 +4168,8 @@
             };
             return MacroUndef;
         }(TreeNode);
+        MacroUndef.nonTerminal = NoneTerminal.macro_undef;
         ASTNode.MacroUndef = MacroUndef;
-        MacroUndef = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_undef)
-        ], MacroUndef);
         var MacroPushContext = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroPushContext, TreeNode);
             function MacroPushContext() {
@@ -4283,10 +4184,8 @@
             };
             return MacroPushContext;
         }(TreeNode);
+        MacroPushContext.nonTerminal = NoneTerminal.macro_push_context;
         ASTNode.MacroPushContext = MacroPushContext;
-        MacroPushContext = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_push_context)
-        ], MacroPushContext);
         var MacroPopContext = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroPopContext, TreeNode);
             function MacroPopContext() {
@@ -4301,10 +4200,8 @@
             };
             return MacroPopContext;
         }(TreeNode);
+        MacroPopContext.nonTerminal = NoneTerminal.macro_pop_context;
         ASTNode.MacroPopContext = MacroPopContext;
-        MacroPopContext = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_pop_context)
-        ], MacroPopContext);
         var MacroElifExpression = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroElifExpression, TreeNode);
             function MacroElifExpression() {
@@ -4316,10 +4213,8 @@
             };
             return MacroElifExpression;
         }(TreeNode);
+        MacroElifExpression.nonTerminal = NoneTerminal.macro_elif_expression;
         ASTNode.MacroElifExpression = MacroElifExpression;
-        MacroElifExpression = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_elif_expression)
-        ], MacroElifExpression);
         var MacroElseExpression = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroElseExpression, TreeNode);
             function MacroElseExpression() {
@@ -4331,10 +4226,8 @@
             };
             return MacroElseExpression;
         }(TreeNode);
+        MacroElseExpression.nonTerminal = NoneTerminal.macro_else_expression;
         ASTNode.MacroElseExpression = MacroElseExpression;
-        MacroElseExpression = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_else_expression)
-        ], MacroElseExpression);
         var GlobalMacroDeclaration = /*#__PURE__*/ function(TreeNode) {
             _inherits(GlobalMacroDeclaration, TreeNode);
             function GlobalMacroDeclaration() {
@@ -4368,10 +4261,8 @@
             };
             return GlobalMacroDeclaration;
         }(TreeNode);
+        GlobalMacroDeclaration.nonTerminal = NoneTerminal.global_macro_declaration;
         ASTNode.GlobalMacroDeclaration = GlobalMacroDeclaration;
-        GlobalMacroDeclaration = __decorate([
-            ASTNodeDecorator(NoneTerminal.global_macro_declaration)
-        ], GlobalMacroDeclaration);
         var GlobalMacroIfStatement = /*#__PURE__*/ function(TreeNode) {
             _inherits(GlobalMacroIfStatement, TreeNode);
             function GlobalMacroIfStatement() {
@@ -4399,10 +4290,8 @@
             };
             return GlobalMacroIfStatement;
         }(TreeNode);
+        GlobalMacroIfStatement.nonTerminal = NoneTerminal.global_macro_if_statement;
         ASTNode.GlobalMacroIfStatement = GlobalMacroIfStatement;
-        GlobalMacroIfStatement = __decorate([
-            ASTNodeDecorator(NoneTerminal.global_macro_if_statement)
-        ], GlobalMacroIfStatement);
         var GlobalMacroBranch = /*#__PURE__*/ function(TreeNode) {
             _inherits(GlobalMacroBranch, TreeNode);
             function GlobalMacroBranch() {
@@ -4433,10 +4322,8 @@
             };
             return GlobalMacroBranch;
         }(TreeNode);
+        GlobalMacroBranch.nonTerminal = NoneTerminal.global_macro_branch;
         ASTNode.GlobalMacroBranch = GlobalMacroBranch;
-        GlobalMacroBranch = __decorate([
-            ASTNodeDecorator(NoneTerminal.global_macro_branch)
-        ], GlobalMacroBranch);
         var MacroIfStatement = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroIfStatement, TreeNode);
             function MacroIfStatement() {
@@ -4444,10 +4331,8 @@
             }
             return MacroIfStatement;
         }(TreeNode);
+        MacroIfStatement.nonTerminal = NoneTerminal.macro_if_statement;
         ASTNode.MacroIfStatement = MacroIfStatement;
-        MacroIfStatement = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_if_statement)
-        ], MacroIfStatement);
         var MacroBranch = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroBranch, TreeNode);
             function MacroBranch() {
@@ -4455,10 +4340,8 @@
             }
             return MacroBranch;
         }(TreeNode);
+        MacroBranch.nonTerminal = NoneTerminal.macro_branch;
         ASTNode.MacroBranch = MacroBranch;
-        MacroBranch = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_branch)
-        ], MacroBranch);
         var MacroCallSymbol = /*#__PURE__*/ function(TreeNode1) {
             _inherits(MacroCallSymbol, TreeNode1);
             function MacroCallSymbol() {
@@ -4556,10 +4439,8 @@
             };
             return MacroCallSymbol;
         }(TreeNode);
+        MacroCallSymbol.nonTerminal = NoneTerminal.macro_call_symbol;
         ASTNode.MacroCallSymbol = MacroCallSymbol;
-        MacroCallSymbol = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_call_symbol)
-        ], MacroCallSymbol);
         var MacroCallFunction = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroCallFunction, TreeNode);
             function MacroCallFunction() {
@@ -4588,10 +4469,8 @@
             };
             return MacroCallFunction;
         }(TreeNode);
+        MacroCallFunction.nonTerminal = NoneTerminal.macro_call_function;
         ASTNode.MacroCallFunction = MacroCallFunction;
-        MacroCallFunction = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_call_function)
-        ], MacroCallFunction);
         var MacroDefine = /*#__PURE__*/ function(TreeNode) {
             _inherits(MacroDefine, TreeNode);
             function MacroDefine() {
@@ -4671,10 +4550,19 @@
             };
             return MacroDefine;
         }(TreeNode);
-        ASTNode.MacroDefine = MacroDefine;
-        MacroDefine = __decorate([
-            ASTNodeDecorator(NoneTerminal.macro_define)
-        ], MacroDefine);
+        MacroDefine.nonTerminal = NoneTerminal.macro_define;
+        /**
+       * `#define NAME [(params)] [value]` — expression-style macro.
+       *
+       * Expression-form macros are parsed into AST rather than kept as raw lexemes. The
+       * optional `valueExpression` is an `AssignmentExpression` subtree that participates
+       * in normal codegen — so `v.v_normal.xyz` inside a `#define` flows through
+       * `visitPostfixExpression` just like an inline expression would, and varying
+       * flattening/type inference/reference tracking all come for free.
+       *
+       * Semantic analysis does not resolve symbols inside the value (the definition-site
+       * scope is not the call-site scope). Lookup happens lazily during codegen.
+       */ ASTNode.MacroDefine = MacroDefine;
     })(ASTNode || (ASTNode = {}));
     var ASTNode;
 
@@ -6219,6 +6107,10 @@
             this._stateItemPool.set(mapId, newItem);
             return newItem;
         };
+        /** Release the state graph after the action/goto tables have been generated. */ State.clearPool = function clearPool() {
+            this.closureMap.clear();
+            this.pool.clear();
+        };
         State.create = function create(cores) {
             var cacheKey = this.getMapKey(cores);
             var state = this.closureMap.get(cacheKey);
@@ -6353,6 +6245,9 @@
         _proto.generate = function generate() {
             this.computeFirstSet();
             this.buildStateTable();
+            // Runtime parsing only needs the numeric action/goto tables. The state closure graph is
+            // construction-only data and otherwise keeps thousands of StateItem/Set objects alive.
+            State.clearPool();
         };
         _proto.buildStateTable = function buildStateTable() {
             var startStateItemCore = [
@@ -6391,7 +6286,7 @@
                 var terminalExist = false;
                 // when A :=> a.BC, a;  ==》 B :=> .xy, First(Ca)
                 // newLookAhead = First(Ca)
-                for(var i = 1, nextSymbol = item.symbolByOffset(1); !!nextSymbol; nextSymbol = item.symbolByOffset(++i)){
+                for(var i = 1, nextSymbol = item.symbolByOffset(1); nextSymbol; nextSymbol = item.symbolByOffset(++i)){
                     if (GrammarUtils.isTerminal(nextSymbol)) {
                         newLookaheadSet.add(nextSymbol);
                         terminalExist = true;
@@ -8906,6 +8801,13 @@
                 variableMap: renderStates.variableMap
             };
         };
+        /**
+       * Release token and AST pools retained at their compilation-time peak.
+       * Call this after shader warm-up when no further compilation is expected soon.
+       * Later compilation remains supported and will allocate pool entries on demand.
+       */ ShaderCompiler.releaseCompilationCache = function releaseCompilationCache() {
+            ShaderCompilerUtils.releaseAllShaderCompilerObjectPool();
+        };
         ShaderCompiler.createPosition = function createPosition(index, line, column) {
             var position = this._shaderPositionPool.get();
             position.set(index);
@@ -8923,7 +8825,7 @@
     ShaderCompiler._shaderRangePool = ShaderCompilerUtils.createObjectPool(ShaderRange);
 
     //@ts-ignore
-    var version = "0.0.0-experimental-2.0-skill.0";
+    var version = "0.0.0-experimental-2.0-migrate.7";
     var mode = "Release";
     console.log("Galacean Engine Shader Compiler Version: " + version + " | Mode: " + mode);