@galacean/engine-shader-compiler 2.0.0-alpha.32 → 2.0.0-alpha.33

package/dist/browser.js

@@ -364,6 +364,9 @@
         };
         ShaderCompilerUtils.createGSError = function createGSError(message, errorName, source, location, file) {
             console.error(message);
+            var err = new Error(message);
+            err.name = errorName;
+            return err;
         };
         return ShaderCompilerUtils;
     }();
@@ -552,36 +555,46 @@
             }).filter(Boolean);
         };
         /**
-       * Return the lexeme of `expr` when it is (transitively) a single bare identifier
-       * wrapped in primary/postfix expression nodes, e.g. `o` → "o". Returns null for
-       * compound expressions (`o.x`, `foo(..)`, `arr[0]`, …). Useful for callers that
-       * want to apply a substitution rule only at the root of an expression, never on
-       * swizzles or nested member access.
-       */ ParserUtils.extractDirectIdentLexeme = function extractDirectIdentLexeme(expr) {
-            var cur = expr;
-            while(cur){
-                if (_instanceof(cur, ASTNode.VariableIdentifier)) {
-                    var child = cur.children[0];
-                    return _instanceof(child, BaseToken) ? child.lexeme : null;
-                }
-                // `( expression )` form on PrimaryExpression — descend through the
-                // wrapped Expression so `(v)` resolves to `v`. All other compound
-                // forms (member access, function call, comma, …) bail out.
-                if (_instanceof(cur, ASTNode.PrimaryExpression) && cur.children.length === 3) {
-                    cur = cur.children[1];
+       * Walk single-child precedence-chain wrappers down to a `VariableIdentifier`,
+       * returning the leaf node (or `undefined` for any compound expression).
+       *
+       * `allowParens` chooses between two callers' needs:
+       *   - `true` — descend through `( expression )` form, so `(v)` resolves to
+       *     `v`. Use when the caller substitutes at the expression root
+       *     (aliasing, renaming); user-written parens carry no extra meaning.
+       *   - `false` — any 3-child `PrimaryExpression` aborts; `(v)` stays
+       *     compound. Use when the caller treats the unwrapped node as a single
+       *     token (IO-struct arg drop, alias detection); user-written parens
+       *     must not collapse.
+       */ ParserUtils.unwrapBareIdentifier = function unwrapBareIdentifier(node, options) {
+            var cur = node;
+            while(true){
+                if (_instanceof(cur, ASTNode.VariableIdentifier)) return cur;
+                if (options.allowParens && _instanceof(cur, ASTNode.PrimaryExpression) && cur.children.length === 3) {
+                    var inner = cur.children[1];
+                    if (!_instanceof(inner, TreeNode)) return undefined;
+                    cur = inner;
                     continue;
                 }
-                // Any precedence-chain wrapper with a single child forwards through.
-                // Covers PostfixExpression / PrimaryExpression(len=1) / Assignment /
-                // Conditional / LogicalOr / … all the way down — including the verbose
-                // build's full chain and the release build's elision-flattened chain.
                 if (_instanceof(cur, ASTNode.ExpressionAstNode) && cur.children.length === 1) {
-                    cur = cur.children[0];
+                    var child = cur.children[0];
+                    if (!_instanceof(child, TreeNode)) return undefined;
+                    cur = child;
                     continue;
                 }
-                return null;
+                return undefined;
             }
-            return null;
+        };
+        /**
+       * Lexeme variant of `unwrapBareIdentifier({ allowParens: true })` for callers
+       * that already work with strings. Returns `null` for compound expressions.
+       */ ParserUtils.extractDirectIdentLexeme = function extractDirectIdentLexeme(expr) {
+            var ident = ParserUtils.unwrapBareIdentifier(expr, {
+                allowParens: true
+            });
+            if (!ident) return null;
+            var child = ident.children[0];
+            return _instanceof(child, BaseToken) ? child.lexeme : null;
         };
         ParserUtils.isTerminal = function isTerminal(sm) {
             return sm < NoneTerminal.START;
@@ -891,7 +904,7 @@
         _inherits(Lexer, BaseLexer1);
         function Lexer(source, macroDefineList) {
             var _this;
-            _this = BaseLexer1.call(this, source) || this, _this.macroDefineList = macroDefineList, _this._needScanMacroConditionExpression = false, _this._inMacroDefineValue = false, _this._macroDefineExpectsNameToken = false, _this._macroDefineExpectsParamsToken = false, _this._macroDefineDirectiveStart = -1, _this._branchStack = [], _this._pendingBranchPushDefined = null;
+            _this = BaseLexer1.call(this, source) || this, _this.macroDefineList = macroDefineList, _this._needScanMacroConditionExpression = false, _this._inMacroDefineValue = false, _this._macroDefineExpectsNameToken = false, _this._macroDefineExpectsParamsToken = false, _this._currentMacroName = "", _this._currentMacroParamsLexeme = undefined, _this._currentMacroValueStart = -1, _this._branchStack = [], _this._pendingBranchPushDefined = null;
             return _this;
         }
         var _proto = Lexer.prototype;
@@ -1287,11 +1300,12 @@
             var token = BaseToken.pool.get();
             var word = buffer.join("");
             if (word === "#define") {
-                // Mark the directive's start offset (the `#`) so the regex-based
-                // registrar can later slice out the full directive text from `_source`.
-                // Two paths share the same registrar — single source of truth.
-                this._macroDefineDirectiveStart = start.index;
-                if (this._defineHasValue()) {
+                var peek = this._peekMacroDefine();
+                if (peek && peek.isExpression) {
+                    // AST path: the value will be tokenized by the lexer's `_inMacroDefineValue`
+                    // state machine and re-parsed by the expression grammar. State machine
+                    // fills `_currentMacroName` / `_currentMacroParamsLexeme` / `_currentMacroValueStart`
+                    // as it walks the value; `_emitMacroDefineEnd` consumes them.
                     this._inMacroDefineValue = true;
                     // The next word is the macro name: force ID type even if a prior `#define`
                     // has already registered the name into `macroDefineList` (redefinition or
@@ -1299,10 +1313,13 @@
                     this._macroDefineExpectsNameToken = true;
                     token.set(Keyword.MACRO_DEFINE, "#define", start);
                 } else {
+                    // Legacy path: opaque token sequence. Register directly from the peek
+                    // result without re-walking the directive.
                     this._scanUtilBreakLine(buffer);
                     var lexeme = "\n" + buffer.join("") + "\n";
-                    // Legacy path: register immediately by parsing the buffered directive.
-                    this._registerMacroDefine(this._source.slice(this._macroDefineDirectiveStart, this._currentIndex));
+                    if (peek) {
+                        this._registerMacroDefine(peek.name, peek.paramsLexeme, peek.valueStart, peek.valueEnd);
+                    }
                     token.set(Keyword.MACRO_DEFINE_EXPRESSION, lexeme, start);
                 }
             } else {
@@ -1319,66 +1336,151 @@
             return c === "\n" || c === "\r";
         };
         /**
-       * Peek forward from `#define` and decide whether this directive should use the
-       * expression-AST path or the legacy opaque path.
+       * Walk a `#define` directive head once and produce everything both routing
+       * and registration need: name range, optional params range, value range,
+       * and whether the value parses as an `expression`.
+       *
+       * The replacement list is split three ways:
        *
-       * The AST path's only purpose is to enable the shader compiler's structural rewrites
-       * (varying flatten, struct-property reference tracking) on macro values that
-       * mention struct members. Every other shape — bare identifiers, numeric
-       * literals, type-alias keywords (`#define FxaaFloat2 vec2`), constructor
-       * calls, qualifier fragments, `#define COMMA ,` etc. — is correctly handled
-       * by the GLSL driver via textual substitution and needs no AST.
+       *  - **AST path** (`isExpression = true`): value parses as `expression`.
+       *    Covers identifiers, literals, parenthesized sub-expressions, operator
+       *    expressions, function calls, top-level comma lists (per C99 §6.10.3).
        *
-       * So the routing rule is positive and information-driven: **AST iff the
-       * replacement list contains a `.` member-access operator**. This is robust
-       * against new GLSL keywords / extensions and incidentally moves all simple
-       * constants and type aliases off the 18-layer expression precedence chain.
-       */ _proto._defineHasValue = function _defineHasValue() {
+       *  - **Legacy opaque path** (`isExpression = false`, no throw): the three
+       *    GLSL-ES-§3.4-legal-but-not-an-expression shapes with real-world use —
+       *      1. empty value                       e.g. `#define COMMON_INCLUDED`
+       *      2. single type/qualifier keyword     e.g. `#define FxaaFloat float`
+       *      3. type-qualifier list               e.g. `#define TEX_PARAM(s) mediump sampler2D s`
+       *
+       *    Note on X-macro support: the classical C X-macro pattern (a list
+       *    macro re-expanded with redefined `X(...)`) works fine — it uses
+       *    function-like macros + `\` line-continuation + `#undef`, all of
+       *    which Galacean supports. It does NOT require unbalanced parens.
+       *
+       *  - **Authoring error** (throws): every other shape that's not a valid
+       *    `expression`. Legal token sequences in theory but not used in real
+       *    GLSL — almost always author mistakes. We surface one uniform
+       *    diagnostic with the macro name and value text and let the user fix
+       *    their code instead of routing politely.
+       *
+       *    Unsupported shapes that throw (non-exhaustive — the predicate is
+       *    "the value doesn't reduce as `expression` and isn't one of the three
+       *    legacy shapes above"):
+       *      - leading bare punctuation       `,` `;` `:` `?` `)` `]`
+       *      - trailing `,` or `;`            e.g. `#define X a, b,`
+       *      - trailing binary / unary op     `+` `-` `*` `/` `%` `&` `|` `^`
+       *                                       `<` `>` `=` `!` `~`
+       *      - trailing ternary fragment      `?` or `:`
+       *      - unbalanced `[` / `]`           e.g. `#define X a[b`
+       *      - unbalanced `(` / `)`           e.g. `#define PAREN (`
+       *
+       * Returns `null` if the directive is malformed before the name. `cursor` is
+       * the position past the last non-newline char (caller advances from there).
+       */ _proto._peekMacroDefine = function _peekMacroDefine() {
             var src = this._source;
             var len = src.length;
-            // All position advancement goes through `_skipNonSemantic`, which honors
-            // line-continuation (`\` + newline) and skips comments. This is critical:
-            // `#define UV foo \\\n  .field` is one logical directive whose value
-            // contains `.field`, and `#define HP /* a.b */ highp` must not let the
-            // `.` inside the comment trigger AST routing.
             var i = Lexer._skipNonSemantic(src, this._currentIndex, len);
-            // Skip macro name
-            if (!(i < len && BaseLexer.isAlpha(src.charCodeAt(i)))) return false;
+            if (!(i < len && BaseLexer.isAlpha(src.charCodeAt(i)))) return null;
+            var nameStart = i;
             while(i < len && BaseLexer.isAlnum(src.charCodeAt(i)))i++;
-            i = Lexer._skipNonSemantic(src, i, len);
-            // Optional `(params)`: scan past a balanced pair on the same logical line
-            if (src.charCodeAt(i) === 40 /* '(' */ ) {
+            var name = src.slice(nameStart, i);
+            // Optional `(params)` glued to the name (function-like per C99 §6.10.3/10;
+            // whitespace before `(` makes it object-like — `(` becomes part of value).
+            var paramsLexeme;
+            if (i < len && src.charCodeAt(i) === 40 /* '(' */ ) {
+                var paramsStart = i;
                 var depth = 1;
                 i++;
                 while(i < len && depth > 0){
                     i = Lexer._skipNonSemantic(src, i, len);
+                    if (i >= len) break;
                     var c = src.charCodeAt(i);
-                    if (c === 10 || c === 13) return false; // malformed: stay legacy
+                    if (c === 10 || c === 13) {
+                        // Unbalanced before newline — treat as malformed function-like.
+                        return {
+                            name: name,
+                            paramsLexeme: undefined,
+                            valueStart: i,
+                            valueEnd: i,
+                            cursor: i,
+                            isExpression: false
+                        };
+                    }
                     if (c === 40) depth++;
                     else if (c === 41 /* ')' */ ) depth--;
                     i++;
                 }
+                paramsLexeme = src.slice(paramsStart, i);
             }
-            // Scan to end-of-directive looking for a `.` member-access operator.
-            // A `.` is member-access unless it's a decimal point inside a numeric
-            // literal — the latter has digits on both physical sides (`3.14`).
-            // Edge cases like `.5` go AST too (false positive, but AST path
-            // handles bare floats correctly).
+            // Walk the value once tracking what routing needs.
+            var valueStart = i;
+            var parenDepth = 0;
+            var bracketDepth = 0;
+            var firstStart = -1;
+            var firstEnd = -1;
+            var firstFollowedByParen = false;
+            var topLevelLast = -1;
             while(i < len){
-                i = Lexer._skipNonSemantic(src, i, len);
-                if (i >= len) break;
+                var skipped = Lexer._skipNonSemantic(src, i, len);
+                if (skipped !== i) {
+                    i = skipped;
+                    continue;
+                }
                 var c1 = src.charCodeAt(i);
-                if (c1 === 10 || c1 === 13) break; // real newline ends directive
-                if (c1 === 46 /* '.' */ ) {
-                    var prev = i > 0 ? src.charCodeAt(i - 1) : 0;
-                    var next = i + 1 < len ? src.charCodeAt(i + 1) : 0;
-                    var prevIsDigit = prev >= 48 && prev <= 57;
-                    var nextIsDigit = next >= 48 && next <= 57;
-                    if (!(prevIsDigit && nextIsDigit)) return true;
+                if (c1 === 10 || c1 === 13) break;
+                if (firstStart === -1) {
+                    firstStart = i;
+                    if (BaseLexer.isAlpha(c1)) {
+                        while(i < len && BaseLexer.isAlnum(src.charCodeAt(i)))i++;
+                        firstEnd = i;
+                        var after = Lexer._skipNonSemantic(src, i, len);
+                        firstFollowedByParen = after < len && src.charCodeAt(after) === 40;
+                        topLevelLast = firstEnd - 1;
+                        continue;
+                    }
                 }
+                if (c1 === 40) parenDepth++;
+                else if (c1 === 41) parenDepth--;
+                else if (c1 === 91 /* [ */ ) bracketDepth++;
+                else if (c1 === 93 /* ] */ ) bracketDepth--;
+                if (parenDepth === 0 && bracketDepth === 0) topLevelLast = i;
                 i++;
             }
-            return false;
+            var result = {
+                name: name,
+                paramsLexeme: paramsLexeme,
+                valueStart: valueStart,
+                valueEnd: i,
+                cursor: i,
+                isExpression: false
+            };
+            // Real-world legacy shapes:
+            //   1. empty value, 2. single type/qualifier kw, 3. type-qualifier list.
+            if (firstStart === -1) return result;
+            if (firstEnd !== -1 && !firstFollowedByParen && Lexer._isNonExpressionLeadingKeyword(src.slice(firstStart, firstEnd))) {
+                return result;
+            }
+            // Authoring errors. Anything that's neither a legal `expression` nor one
+            // of the three legacy shapes above gets a single uniform diagnostic —
+            // the user sees the macro name and the value text, that's enough to
+            // locate and fix. We don't categorize further; the rule for users is
+            // simply "value must be a valid GLSL expression".
+            //
+            // Legal expression starts: alnum (identifier / literal), `(` (group),
+            // `.` (GLSL ES §4.1.4 leading-dot float literal like `.5`), `-`/`+`/`!`/`~`
+            // (unary). Legal expression ends: alnum (identifier / literal), `)` (group
+            // close), `]` (array-index close). Everything else at the head or
+            // top-level tail is an authoring error.
+            var head = src.charCodeAt(firstStart);
+            var tail = topLevelLast >= 0 ? src.charCodeAt(topLevelLast) : 0;
+            var headIllegal = !BaseLexer.isAlnum(head) && head !== 40 /* ( */  && head !== 46 /* . */  && head !== 45 /* - */  && head !== 43 /* + */  && head !== 33 /* ! */  && head !== 126; /* ~ */ 
+            var tailIllegal = !BaseLexer.isAlnum(tail) && tail !== 41 /* ) */  && tail !== 93; /* ] */ 
+            if (parenDepth !== 0 || bracketDepth !== 0 || headIllegal || tailIllegal) {
+                var valueText = src.slice(firstStart, i).replace(/\s+/g, " ").trim();
+                this.throwError(this.getShaderPosition(0), "#define " + name + ': invalid replacement list — not a valid GLSL expression ("' + valueText + '")');
+            }
+            result.isExpression = true;
+            return result;
         };
         /** Consuming wrapper around `_skipNonSemantic` operating on the lexer's
        *  current position. Used by the `#define`-value scan state machine. Goes
@@ -1422,11 +1524,16 @@
                 this.advance(1);
             }
             var token = BaseToken.pool.get();
-            token.set(Keyword.MACRO_DEFINE_PARAMS, buffer.join(""), start);
+            var lexeme = buffer.join("");
+            this._currentMacroParamsLexeme = lexeme;
+            // Value starts after the `)` we just consumed.
+            this._currentMacroValueStart = this._currentIndex;
+            token.set(Keyword.MACRO_DEFINE_PARAMS, lexeme, start);
             return token;
         };
         /** Emit `MACRO_DEFINE_END` at the end of a `#define` value, consuming the newline. */ _proto._emitMacroDefineEnd = function _emitMacroDefineEnd() {
             var start = this.getShaderPosition();
+            var valueEnd = this._currentIndex;
             var source = this._source;
             if (this._currentIndex < source.length) {
                 var c = source.charCodeAt(this._currentIndex);
@@ -1436,37 +1543,29 @@
                     this.advance(1);
                 }
             }
-            // Register the directive into macroDefineList — single source of truth.
-            this._registerMacroDefine(this._source.slice(this._macroDefineDirectiveStart, this._currentIndex));
+            this._registerMacroDefine(this._currentMacroName, this._currentMacroParamsLexeme, this._currentMacroValueStart, valueEnd);
             this._inMacroDefineValue = false;
             var token = BaseToken.pool.get();
             token.set(Keyword.MACRO_DEFINE_END, "\n", start);
             return token;
         };
-        // Parse a `#define <name>[(params)] [value]` directive (already lexed to
-        // its newline) and register it. Both AST and legacy paths funnel through
-        // here — single source of truth, no drift between two analyzers.
-        _proto._registerMacroDefine = function _registerMacroDefine(directive) {
-            // Fold line-continuations before matching: per C/GLSL preprocessor rules
-            // `\` immediately before a newline removes both characters and stitches
-            // the next physical line onto this one. The regex's value group rejects
-            // newlines, so without folding any multi-line directive (`#define X a \\\n + b`)
-            // would NO MATCH and registration would silently fail.
-            var folded = directive.replace(Lexer._lineContinuationReg, "");
-            var m = Lexer._defineDirectiveReg.exec(folded);
-            if (!m) return;
-            var name = m[1];
-            var paramsStr = m[3];
-            var valueRaw = m[4];
-            var params = paramsStr ? paramsStr.split(",").map(function(p) {
+        // Register a `#define` directive. Both AST and legacy paths funnel through
+        // here using ranges already extracted by `_peekMacroDefine` / the value
+        // state machine — no re-parsing the directive text.
+        _proto._registerMacroDefine = function _registerMacroDefine(name, paramsLexeme, valueStart, valueEnd) {
+            var params = paramsLexeme ? paramsLexeme.slice(1, -1) // strip enclosing `(` `)`
+            .split(",").map(function(p) {
                 return p.trim();
             }).filter(Boolean) : [];
-            var refMatch = valueRaw ? Lexer._referenceReg.exec(valueRaw.trim()) : null;
+            // Dedup key: normalized value text (same lexical view the token-stream
+            // path sees — comments stripped, whitespace collapsed). Two `#define`s
+            // with the same name but different value text produce different keys,
+            // so disjoint-branch entries stay separate.
+            var dedupKey = (paramsLexeme != null ? paramsLexeme : "") + "=" + Lexer._normalizeValueText(this._source, valueStart, valueEnd);
             var info = {
-                isFunction: m[2] !== undefined,
-                name: name,
+                isFunction: paramsLexeme !== undefined,
                 params: params,
-                referenceName: refMatch ? refMatch[1] : "",
+                dedupKey: dedupKey,
                 branch: this._branchStack.length === 0 ? EMPTY_BRANCH : this._branchStack.slice()
             };
             var arr = this.macroDefineList[name];
@@ -1476,14 +1575,11 @@
                 ];
                 return;
             }
-            // Skip duplicates from re-includes / re-definitions in the same `#ifdef`
-            // branch. Different branches → different entries (the call-site filter
-            // picks the visible one); same branch + same shape → drop.
+            // Same key + same branch → duplicate (re-include). Different branches stay
+            // separate so the visibility filter picks the right entry at each call site.
             for(var i = 0, n = arr.length; i < n; i++){
                 var e = arr[i];
-                if (e.isFunction === info.isFunction && e.referenceName === info.referenceName && e.params.length === info.params.length && e.params.every(function(p, idx) {
-                    return p === info.params[idx];
-                }) && Lexer.sameBranch(e.branch, info.branch)) return;
+                if (e.dedupKey === dedupKey && Lexer.sameBranch(e.branch, info.branch)) return;
             }
             arr.push(info);
         };
@@ -1513,6 +1609,8 @@
                 // Bypass MACRO_CALL classification for this one word. Used for the name of
                 // a `#define` directive so redefining a known macro still yields a declarer ID.
                 this._macroDefineExpectsNameToken = false;
+                this._currentMacroName = word;
+                this._currentMacroParamsLexeme = undefined;
                 // C99 §6.10.3/3: the macro is function-like only when `(` appears *immediately*
                 // after the name (no intervening whitespace). `#define FOO (1+2)` is
                 // object-like with value `(1+2)`, not a function-like macro `FOO()` with
@@ -1520,6 +1618,10 @@
                 // on the next `scanToken`, so a space-separated `(` stays part of the value.
                 if (this._inMacroDefineValue) {
                     this._macroDefineExpectsParamsToken = this.getCurChar() === "(";
+                    // For object-like macros, the value begins where the cursor is now
+                    // (after the name, before whitespace skipping). Function-like macros
+                    // overwrite this in `_scanMacroDefineParams` after capturing `(...)`.
+                    this._currentMacroValueStart = this._currentIndex;
                 }
                 token.set(ETokenType.ID, word, start);
             } else if (this._isVisibleMacro(word)) {
@@ -1659,6 +1761,12 @@
             }
             return true;
         };
+        /** GLSL type / qualifier keywords that aren't expression starters when standing alone.
+       *  `true` / `false` are excluded — they're `primary_expression` literals.
+       *  `#`-prefixed entries are excluded — they're preprocessor directive names. */ Lexer._isNonExpressionLeadingKeyword = function _isNonExpressionLeadingKeyword(lexeme) {
+            var kw = Lexer._lexemeTable[lexeme];
+            return kw !== undefined && kw !== Keyword.True && kw !== Keyword.False && !lexeme.startsWith("#");
+        };
         /**
        * If `i` points at a `\` immediately followed by a newline (`\n`, `\r`, or
        * `\r\n`), return the index just past the pair (a single atom in the C/GLSL
@@ -1666,8 +1774,7 @@
        * source of truth for line-continuation detection — callers along the
        * directive-scanning path (`_skipNonSemantic`, `_scanUtilBreakLine`,
        * `_scanMacroDefineParams`) all delegate here so the rule stays in one
-       * place. The string-level `_lineContinuationReg` covers the regex path
-       * used by `_registerMacroDefine` for one-shot folding.
+       * place.
        */ Lexer._skipLineContinuation = function _skipLineContinuation(src, i, len) {
             if (src.charCodeAt(i) !== 92 /* '\\' */  || i + 1 >= len) return i;
             var n = src.charCodeAt(i + 1);
@@ -1710,6 +1817,34 @@
             }
             return i;
         };
+        /** Render a `[start, end)` value range as space-separated significant chars,
+       *  using the same comment / line-continuation rules `_skipNonSemantic`
+       *  applies on the token-stream path. Used as the dedup key body. */ Lexer._normalizeValueText = function _normalizeValueText(src, start, end) {
+            var out = "";
+            var i = start;
+            var pendingSpace = false;
+            while(i < end){
+                var skipped = Lexer._skipNonSemantic(src, i, end);
+                if (skipped !== i) {
+                    pendingSpace = out.length > 0;
+                    i = skipped;
+                    continue;
+                }
+                var c = src.charCodeAt(i);
+                if (c === 32 || c === 9) {
+                    pendingSpace = out.length > 0;
+                    i++;
+                    continue;
+                }
+                if (pendingSpace) {
+                    out += " ";
+                    pendingSpace = false;
+                }
+                out += src[i];
+                i++;
+            }
+            return out;
+        };
         return Lexer;
     }(BaseLexer);
     Lexer._lexemeTable = {
@@ -1786,12 +1921,6 @@
         "#endif": Keyword.MACRO_ENDIF,
         "#undef": Keyword.MACRO_UNDEF
     };
-    // Single source of truth for `#define` parsing — fed from both AST and legacy paths.
-    Lexer._defineDirectiveReg = /^\s*#define\s+(\w+)[ ]*(\(([^)]*)\))?(?:[ \t]+([^\n\r]*?))?\s*$/;
-    // Bare identifier or call form only — mixed-operator values reject.
-    Lexer._referenceReg = /^([a-zA-Z_]\w*)(?:\s*\(.*\))?$/;
-    // C preprocessor line continuation.
-    Lexer._lineContinuationReg = /\\(?:\r\n|\n|\r)/g;
     // Synthetic `__if_<n>` per `#if` — polarity flip makes `#else` mutually exclusive in `isVisibleFrom`.
     Lexer._ifCounter = 0;
 
@@ -3994,34 +4123,13 @@
                 var child = this.children[0];
                 var referenceGlobalSymbolNames = this.referenceGlobalSymbolNames;
                 var symbols = this._symbols;
-                var lookupSymbol = SemanticAnalyzer._lookupSymbol;
-                var needFindNames;
-                // FXAA-style cross-arm shadowing: same name is a macro in one
-                // preprocessor arm and a variable in the mutually-exclusive arm.
-                // At a MACRO_CALL use site, also probe the macro name itself so
-                // the sibling-arm declaration is marked as referenced and codegen
-                // keeps it. Grammar half of the fix is in 87cb2b5f0.
-                var macroNameAsVarLookup = null;
-                if (_instanceof(child, BaseToken)) {
-                    needFindNames = [
-                        child.lexeme
-                    ];
-                } else {
-                    var callSymbol = child;
-                    needFindNames = callSymbol.referenceSymbolNames;
-                    var macroName = callSymbol.macroName;
-                    if (macroName && needFindNames.indexOf(macroName) === -1) {
-                        needFindNames = needFindNames.concat(macroName);
-                        macroNameAsVarLookup = macroName;
-                    }
-                }
+                // Real references — every name must resolve; miss is an authoring error.
+                var needFindNames = _instanceof(child, BaseToken) ? [
+                    child.lexeme
+                ] : child.referenceSymbolNames;
                 for(var i = 0; i < needFindNames.length; i++){
                     var name = needFindNames[i];
-                    // `macroDefineList` short-circuit; bypass for the macro name itself
-                    // so cross-arm shadowing can resolve the sibling-arm declaration.
-                    if (sa.macroDefineList[name] && name !== macroNameAsVarLookup) {
-                        continue;
-                    }
+                    if (sa.macroDefineList[name]) continue;
                     // only `macro_call` CFG can reference fnSymbols, others fnSymbols are referenced in `function_call_generic` CFG
                     if (!_instanceof(child, BaseToken) && BuiltinFunction.isExist(name)) {
                         continue;
@@ -4031,29 +4139,24 @@
                         this.typeInfo = builtinVar.type;
                         continue;
                     }
-                    lookupSymbol.set(name, ESymbolType.Any);
-                    sa.symbolTableStack.lookupAll(lookupSymbol, true, symbols);
-                    if (!symbols.length) ; else {
-                        // Expression-style macros have their own value AST; its real type isn't
-                        // the type of any single `referenceSymbolNames` entry (`v` in `v.v_uv`
-                        // is a `Varyings` struct but the macro call site's type should be the
-                        // member type). Skip type inference for those and keep TypeAny.
-                        if (_instanceof(child, BaseToken) || !child.hasAstValue) {
-                            var _symbols__dataType;
-                            this.typeInfo = (_symbols__dataType = symbols[0].dataType) == null ? void 0 : _symbols__dataType.type;
-                        }
-                        var currentScopeSymbol = sa.symbolTableStack.scope.getSymbol(lookupSymbol, true);
-                        if (currentScopeSymbol) {
-                            if ((_instanceof(currentScopeSymbol, FnSymbol) || currentScopeSymbol.isGlobalVariable) && referenceGlobalSymbolNames.indexOf(name) === -1) {
-                                referenceGlobalSymbolNames.push(name);
-                            }
-                        } else if (symbols.some(function(s) {
-                            return _instanceof(s, FnSymbol) || s.isGlobalVariable;
-                        }) && referenceGlobalSymbolNames.indexOf(name) === -1) {
-                            referenceGlobalSymbolNames.push(name);
-                        }
+                    var hit = VariableIdentifier._lookupAndMarkGlobalReference(sa, name, symbols, referenceGlobalSymbolNames, this.location);
+                    // Expression-style macros have their own value AST; its real type isn't
+                    // the type of any single `referenceSymbolNames` entry (`v` in `v.v_uv`
+                    // is a `Varyings` struct but the macro call site's type should be the
+                    // member type). Skip type inference for those and keep TypeAny.
+                    if (hit && (_instanceof(child, BaseToken) || !child.hasAstValue)) {
+                        var _symbols__dataType;
+                        this.typeInfo = (_symbols__dataType = symbols[0].dataType) == null ? void 0 : _symbols__dataType.type;
                     }
                 }
+                // FXAA-style cross-arm shadowing: at a MACRO_CALL use site, silently
+                // probe the macro name itself so any sibling-arm `var` declaration is
+                // marked as referenced and codegen keeps it. Miss is the common
+                // single-arm case — no warning, no type inference. Grammar half of the
+                // cross-arm fix is in 87cb2b5f0.
+                if (!_instanceof(child, BaseToken)) {
+                    VariableIdentifier._probeCrossArmShadowing(sa, child, needFindNames, symbols, referenceGlobalSymbolNames);
+                }
             };
             _proto.codeGen = function codeGen(visitor) {
                 return this.setCache(visitor.visitVariableIdentifier(this));
@@ -4066,6 +4169,40 @@
                     return child.codeGen(visitor);
                 }
             };
+            /** Run the cross-arm shadowing probe for a MACRO_CALL site. No-op when the
+         *  probe isn't meaningful: no macro name, name already resolved as a real
+         *  reference, or name is a builtin (builtins can't be shadowed by a
+         *  sibling-arm decl). */ VariableIdentifier._probeCrossArmShadowing = function _probeCrossArmShadowing(sa, child, needFindNames, symbols, referenceGlobalSymbolNames) {
+                var macroName = child.macroName;
+                if (!macroName) return;
+                if (needFindNames.indexOf(macroName) !== -1) return; // already looked up as a real reference
+                if (BuiltinFunction.isExist(macroName) || BuiltinVariable.getVar(macroName)) return; // builtins can't be shadowed
+                VariableIdentifier._lookupAndMarkGlobalReference(sa, macroName, symbols, referenceGlobalSymbolNames, null);
+            };
+            /** Look up `name` in the symbol stack and, if a global var/fn declaration
+         *  exists, push it into `referenceGlobalSymbolNames`. Returns `true` iff
+         *  the lookup hit (caller can then derive type info). When `missWarnLoc`
+         *  is non-null, a miss reports a "declared before used" warning; pass
+         *  `null` for silent probes (e.g. FXAA-style cross-arm shadowing).
+         *
+         *  Mutation contract: `symbols` is used as scratch storage — `lookupAll`
+         *  clears and refills it. On hit, the caller may read `symbols[0]` for
+         *  type info before the next call overwrites the contents. */ VariableIdentifier._lookupAndMarkGlobalReference = function _lookupAndMarkGlobalReference(sa, name, symbols, referenceGlobalSymbolNames, missWarnLoc) {
+                var lookupSymbol = SemanticAnalyzer._lookupSymbol;
+                lookupSymbol.set(name, ESymbolType.Any);
+                sa.symbolTableStack.lookupAll(lookupSymbol, true, symbols);
+                if (!symbols.length) {
+                    return false;
+                }
+                var currentScopeSymbol = sa.symbolTableStack.scope.getSymbol(lookupSymbol, true);
+                var isGlobal = currentScopeSymbol ? _instanceof(currentScopeSymbol, FnSymbol) || currentScopeSymbol.isGlobalVariable : symbols.some(function(s) {
+                    return _instanceof(s, FnSymbol) || s.isGlobalVariable;
+                });
+                if (isGlobal && referenceGlobalSymbolNames.indexOf(name) === -1) {
+                    referenceGlobalSymbolNames.push(name);
+                }
+                return true;
+            };
             return VariableIdentifier;
         }(TreeNode);
         ASTNode.VariableIdentifier = VariableIdentifier;
@@ -4322,18 +4459,16 @@
         MacroBranch = __decorate([
             ASTNodeDecorator(NoneTerminal.macro_branch)
         ], MacroBranch);
-        var MacroCallSymbol = /*#__PURE__*/ function(TreeNode) {
-            _inherits(MacroCallSymbol, TreeNode);
+        var MacroCallSymbol = /*#__PURE__*/ function(TreeNode1) {
+            _inherits(MacroCallSymbol, TreeNode1);
             function MacroCallSymbol() {
                 var _this;
-                _this = TreeNode.apply(this, arguments) || this, _this.referenceSymbolNames = [], /** True iff every `MacroDefineInfo` visible from this call site's branch
+                _this = TreeNode1.apply(this, arguments) || this, _this.referenceSymbolNames = [], /** True iff every `MacroDefineInfo` visible from this call site's branch
          *  has a `valueAst` (i.e. was parsed via the `macro_define` CFG rule).
          *  Call sites use this to skip naive type inference: an AST-form macro
          *  drives the call site's type through its own value subtree, not through
          *  a root of `referenceSymbolNames`. Mixed forms across branches → false,
-         *  fall back to legacy inference. */ _this.hasAstValue = false, /** True when the macro is defined as function-like (`#define NAME(params) …`).
-         *  Used by `MacroCallFunction` codegen to pick between the two call shapes
-         *  — object-like-macro-as-function-name vs true function-like macro. */ _this.isFunctionLikeMacro = false;
+         *  fall back to legacy inference. */ _this.hasAstValue = false, /** `#define NAME(params) …` form — drives function-like vs object-like codegen. */ _this.isFunctionLikeMacro = false, /** Every visible replacement is a non-builtin identifier — assume user fn alias. */ _this.aliasesNonBuiltinIdent = false;
                 return _this;
             }
             var _proto = MacroCallSymbol.prototype;
@@ -4341,6 +4476,7 @@
                 this.referenceSymbolNames.length = 0;
                 this.hasAstValue = false;
                 this.isFunctionLikeMacro = false;
+                this.aliasesNonBuiltinIdent = false;
             };
             _proto.semanticAnalyze = function semanticAnalyze(sa) {
                 var nameToken = this.children[0];
@@ -4358,6 +4494,7 @@
                 var visibleCount = 0;
                 var allAst = true;
                 var isFn = false;
+                var allAliasNonBuiltinIdent = true;
                 if (defList) {
                     for(var i = 0, n = defList.length; i < n; i++){
                         var info = defList[i];
@@ -4365,8 +4502,30 @@
                         visibleCount++;
                         if (info.valueAst == null) allAst = false;
                         if (info.isFunction) isFn = true;
-                        var ref = info.referenceName;
-                        if (ref && info.params.indexOf(ref) === -1 && refs.indexOf(ref) === -1) refs.push(ref);
+                        // Harvest references from the value AST. Legacy-form macros (no
+                        // `valueAst`) hold non-expression token sequences with no user
+                        // identifiers, so nothing to collect.
+                        if (info.valueAst) {
+                            MacroCallSymbol._collectIdentifierRefs(info.valueAst, info.params, refs);
+                        }
+                        // aliasesNonBuiltinIdent: macro replacement is a single non-builtin
+                        // identifier — best-effort proxy for "this macro call site aliases a
+                        // user fn", since uniform/const aliases would surface as a GLSL
+                        // compile error later anyway. Keyword replacements (`vec3`, `mat4`)
+                        // reach here with `valueAst === undefined` (opaque path), so they
+                        // automatically fail without an explicit keyword guard.
+                        if (info.isFunction || !info.valueAst) {
+                            allAliasNonBuiltinIdent = false;
+                        } else {
+                            var leadingIdent = ParserUtils.unwrapBareIdentifier(info.valueAst, {
+                                allowParens: false
+                            });
+                            var leadingChild = leadingIdent == null ? void 0 : leadingIdent.children[0];
+                            var leadingId = _instanceof(leadingChild, BaseToken) ? leadingChild.lexeme : undefined;
+                            if (!leadingId || BuiltinFunction.isExist(leadingId)) {
+                                allAliasNonBuiltinIdent = false;
+                            }
+                        }
                     }
                 }
                 // Require *every* visible entry to be AST-form before taking the AST
@@ -4375,6 +4534,25 @@
                 // instead of polluting the call site with TypeAny.
                 this.hasAstValue = visibleCount > 0 && allAst;
                 this.isFunctionLikeMacro = isFn;
+                this.aliasesNonBuiltinIdent = visibleCount > 0 && allAliasNonBuiltinIdent;
+            };
+            /** Push every leaf `VariableIdentifier`'s lexeme into `out`, skipping
+         *  function-like parameter names (local to the macro, not call-site refs)
+         *  and duplicates. */ MacroCallSymbol._collectIdentifierRefs = function _collectIdentifierRefs(node, params, out) {
+                if (_instanceof(node, VariableIdentifier)) {
+                    var child = node.children[0];
+                    if (_instanceof(child, BaseToken)) {
+                        var name = child.lexeme;
+                        if (params.indexOf(name) === -1 && out.indexOf(name) === -1) out.push(name);
+                    }
+                    return;
+                }
+                var children = node.children;
+                if (!children) return;
+                for(var i = 0, n = children.length; i < n; i++){
+                    var c = children[i];
+                    if (_instanceof(c, TreeNode)) MacroCallSymbol._collectIdentifierRefs(c, params, out);
+                }
             };
             return MacroCallSymbol;
         }(TreeNode);
@@ -4386,7 +4564,7 @@
             _inherits(MacroCallFunction, TreeNode);
             function MacroCallFunction() {
                 var _this;
-                _this = TreeNode.apply(this, arguments) || this, _this.referenceSymbolNames = [], _this.macroName = "", _this.hasAstValue = false, _this.isFunctionLikeMacro = false;
+                _this = TreeNode.apply(this, arguments) || this, _this.referenceSymbolNames = [], _this.macroName = "", _this.hasAstValue = false, _this.isFunctionLikeMacro = false, _this.aliasesNonBuiltinIdent = false;
                 return _this;
             }
             var _proto = MacroCallFunction.prototype;
@@ -4395,6 +4573,7 @@
                 this.macroName = "";
                 this.hasAstValue = false;
                 this.isFunctionLikeMacro = false;
+                this.aliasesNonBuiltinIdent = false;
             };
             _proto.semanticAnalyze = function semanticAnalyze(sa) {
                 var child = this.children[0];
@@ -4402,6 +4581,7 @@
                 this.macroName = child.macroName;
                 this.hasAstValue = child.hasAstValue;
                 this.isFunctionLikeMacro = child.isFunctionLikeMacro;
+                this.aliasesNonBuiltinIdent = child.aliasesNonBuiltinIdent;
             };
             _proto.codeGen = function codeGen(visitor) {
                 return this.setCache(visitor.visitMacroCallFunction(this));
@@ -4437,7 +4617,10 @@
                     params = ParserUtils.parseMacroParamList(children[2].lexeme);
                     valueIdx = 3;
                 }
-                if (_instanceof(children[valueIdx], AssignmentExpression)) {
+                // Grammar's macro_define value is `expression` (not `assignment_expression`),
+                // so the value child is always an `Expression` wrapper — even for a single
+                // assignment-expression value, which appears as `Expression > AssignmentExpression`.
+                if (_instanceof(children[valueIdx], Expression)) {
                     this.valueExpression = children[valueIdx];
                 }
                 // The Lexer already registered a regex-derived entry for this directive.
@@ -4460,14 +4643,14 @@
                 if (upgradable) {
                     upgradable.valueAst = this.valueExpression;
                 } else {
-                    // No matching preprocessor entry (e.g. the lexer was fed the directive
-                    // directly without a `Preprocessor.parse` pass). Push a fresh entry.
+                    // No matching preprocessor entry (lexer fed directly, no
+                    // `Preprocessor.parse` pass). Synthetic key based on shape is enough
+                    // — this path's only dedup unit is this AST-direct registration.
                     var info = {
                         isFunction: this.isFunction,
-                        name: this.macroName,
                         params: params,
                         valueAst: this.valueExpression,
-                        referenceName: "",
+                        dedupKey: this.macroName + "#ast/" + (this.isFunction ? params.join(",") : ""),
                         branch: definingBranch
                     };
                     if (entries) entries.push(info);
@@ -4475,6 +4658,13 @@
                         info
                     ];
                 }
+                // Close the form-param scope pushed at `MACRO_DEFINE_PARAMS` shift. By
+                // the time this reduce fires, every `VariableIdentifier` inside the
+                // value expression has already resolved against the params. Object-like
+                // macros never pushed a scope, so nothing to pop.
+                if (this.isFunction) {
+                    sa.popScope();
+                }
             };
             _proto.codeGen = function codeGen(visitor) {
                 return this.setCache(visitor.visitMacroDefine(this));
@@ -4699,30 +4889,24 @@
             if (_instanceof(paramList, ASTNode.FunctionCallParameterList)) {
                 var astNodes = paramList.paramNodes;
                 var context = VisitorContext.context;
-                // `MacroCallFunction` covers two call shapes sharing the same AST:
-                //   (a) object-like macro whose value is a function name, used as a call —
-                //       `#define FN foo` + `FN(varyings, …)`. The driver expands `FN` to
-                //       `foo`, and `foo` is a shader function whose IO-struct params
-                //       have been flattened. The call site must drop IO-struct args to
-                //       match the flattened signature — same rule as `visitFunctionCall`.
-                //   (b) true function-like macro — `#define MAX3(a,b,c) …` + `MAX3(v.x, …)`.
-                //       The shader compiler doesn't expand the macro; the driver does, and the
-                //       `#define` fixes the parameter count. Args must be preserved
-                //       verbatim — a member-access arg like `v.v_uv` unwraps to a root
-                //       identifier whose type is an IO struct, but dropping the arg
-                //       would change the macro's arity.
-                //
-                // `isFunctionLikeMacro` is set by `MacroCallSymbol.semanticAnalyze` from
-                // `macroDefineList[name][*].isFunction` and carries the definition shape.
-                var params = node.isFunctionLikeMacro ? astNodes : astNodes.filter(function(arg) {
-                    if (_instanceof(arg, ASTNode.AssignmentExpression)) {
-                        var variableParam = ParserUtils.unwrapNodeByType(arg, NoneTerminal.variable_identifier);
-                        if (variableParam && typeof variableParam.typeInfo === "string" && context.getStructRole(variableParam.typeInfo)) {
-                            return false;
+                // Drop bare IO-struct args only when the macro aliases a user fn (whose
+                // formal was flattened). All other shapes preserve args verbatim.
+                var params;
+                if (node.isFunctionLikeMacro || !node.aliasesNonBuiltinIdent) {
+                    params = astNodes;
+                } else {
+                    params = astNodes.filter(function(arg) {
+                        if (_instanceof(arg, ASTNode.AssignmentExpression)) {
+                            var variableParam = ParserUtils.unwrapBareIdentifier(arg, {
+                                allowParens: false
+                            });
+                            if (variableParam && typeof variableParam.typeInfo === "string" && context.getStructRole(variableParam.typeInfo)) {
+                                return false;
+                            }
                         }
-                    }
-                    return true;
-                });
+                        return true;
+                    });
+                }
                 var paramsCode = "";
                 for(var i = 0, length = params.length; i < length; i++){
                     var argNode = params[i];
@@ -5927,6 +6111,15 @@
     ShaderInstructionEncoder._DIRECTIVE_RE = /^[ \t]*#[ \t]*(if|ifdef|ifndef|elif|else|endif|define|undef)\b(.*)/;
     ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
 
+    var Production = function Production(goal, derivation) {
+        this.goal = goal;
+        this.derivation = derivation;
+        this.id = Production._id++;
+        Production.pool.set(this.id, this);
+    };
+    Production._id = 0;
+    Production.pool = new Map();
+
     var StateItem = /*#__PURE__*/ function() {
         function StateItem(production, position, lookahead) {
             this._needReInfer = true;
@@ -6289,9 +6482,14 @@
         /** Resolve shift-reduce/reduce-reduce conflict detect */ _proto._addAction = function _addAction(table, terminal, action) {
             var exist = table.get(terminal);
             if (exist && !GrammarUtils.isActionEqual(exist, action)) {
-                // Resolve dangling else ambiguity
-                if (terminal === Keyword.ELSE && exist.action === EAction.Shift && action.action === EAction.Reduce) {
-                    return;
+                // Known shift-preferred conflicts (see TargetParser.y `%expect 2`).
+                // Enforce shift regardless of the order `_inferNextState` registers
+                // actions: when `exist` is already Shift and `action` is Reduce, keep
+                // `exist` (early-return); the reverse order (`exist` Reduce, `action`
+                // Shift) falls through to `table.set` below and Shift overwrites
+                // Reduce. Order-independent by construction.
+                if (LALR1._isKnownShiftPreferred(terminal, exist, action)) {
+                    if (exist.action === EAction.Shift && action.action === EAction.Reduce) return;
                 }
             }
             table.set(terminal, action);
@@ -6343,18 +6541,25 @@
             this._firstSetNTStack.pop();
             return firstSet;
         };
+        // Catalog of expected shift/reduce conflicts. Each entry must correspond to
+        // one of TargetParser.y's `%expect`-ed conflicts; any new conflict not in
+        // this list falls through to the verbose `conflict detect` warning so the
+        // grammar/runtime drift is loud rather than silent.
+        //   - ELSE: dangling-else, bind to nearest `if`
+        //   - '(' + `type_specifier_nonarray → macro_call_symbol`: macro-as-type-alias
+        //     (#2974), prefer the expression-position `macro_call_function` over the
+        //     type-position reduce
+        LALR1._isKnownShiftPreferred = function _isKnownShiftPreferred(terminal, exist, action) {
+            if (terminal === Keyword.ELSE) return true;
+            if (terminal !== ETokenType.LEFT_PAREN) return false;
+            var reduce = exist.action === EAction.Reduce ? exist : action.action === EAction.Reduce ? action : null;
+            if (!reduce) return false;
+            var prod = Production.pool.get(reduce.target);
+            return !!prod && prod.goal === NoneTerminal.type_specifier_nonarray && prod.derivation.length === 1 && prod.derivation[0] === NoneTerminal.macro_call_symbol;
+        };
         return LALR1;
     }();
 
-    var Production = function Production(goal, derivation) {
-        this.goal = goal;
-        this.derivation = derivation;
-        this.id = Production._id++;
-        Production.pool.set(this.id, this);
-    };
-    Production._id = 0;
-    Production.pool = new Map();
-
     var Grammar = /*#__PURE__*/ function() {
         function Grammar(start, productions) {
             this.startSymbol = start;
@@ -6424,14 +6629,14 @@
         [
             Keyword.MACRO_DEFINE,
             ETokenType.ID,
-            NoneTerminal.assignment_expression,
+            NoneTerminal.expression,
             Keyword.MACRO_DEFINE_END
         ],
         [
             Keyword.MACRO_DEFINE,
             ETokenType.ID,
             Keyword.MACRO_DEFINE_PARAMS,
-            NoneTerminal.assignment_expression,
+            NoneTerminal.expression,
             Keyword.MACRO_DEFINE_END
         ]
     ], ASTNode.MacroDefine.pool), GrammarUtils.createProductionWithOptions(NoneTerminal.macro_call_symbol, [
@@ -7798,6 +8003,19 @@
                 var actionInfo = this.stateActionTable.get(token.type);
                 if ((actionInfo == null ? void 0 : actionInfo.action) === EAction.Shift) {
                     traceBackStack.push(token, actionInfo.target);
+                    // Function-like `#define` form params live in a scope wrapping the
+                    // value AST, mirroring how `function_header` opens a scope for GLSL
+                    // function parameters. Push on shift of `MACRO_DEFINE_PARAMS`; the
+                    // matching `popScope` runs when `MacroDefine.semanticAnalyze` reduces
+                    // the production (only the function-like alternative needs it, and
+                    // it knows that from its own children).
+                    if (token.type === Keyword.MACRO_DEFINE_PARAMS) {
+                        sematicAnalyzer.pushScope();
+                        for(var _iterator = _create_for_of_iterator_helper_loose(ParserUtils.parseMacroParamList(token.lexeme)), _step; !(_step = _iterator()).done;){
+                            var p = _step.value;
+                            sematicAnalyzer.symbolTableStack.insert(new SymbolInfo(p, ESymbolType.VAR));
+                        }
+                    }
                     nextToken = tokens.next();
                 } else if ((actionInfo == null ? void 0 : actionInfo.action) === EAction.Accept) {
                     sematicAnalyzer.acceptRule == null ? void 0 : sematicAnalyzer.acceptRule.call(sematicAnalyzer, sematicAnalyzer);
@@ -8705,7 +8923,7 @@
     ShaderCompiler._shaderRangePool = ShaderCompilerUtils.createObjectPool(ShaderRange);
 
     //@ts-ignore
-    var version = "2.0.0-alpha.32";
+    var version = "2.0.0-alpha.33";
     var mode = "Release";
     console.log("Galacean Engine Shader Compiler Version: " + version + " | Mode: " + mode);