@galacean/engine-shader-compiler 2.0.0-alpha.52 → 2.0.0-alpha.54

package/dist/precompile.module.js

@@ -0,0 +1,2276 @@
+import { normalizeShaderIncludeMap, ShaderSourceParser, parseValidatedShaderPass, ShaderCoreInfo as ShaderCoreInfo$1, branchAnalysis, ParserObjectPool, createValidatedShaderTargetParser } from '@galacean/engine-shader-parser/internal/analyzer';
+import { ReturnableObjectPool, ShaderPreprocessorDirective, Logger, ShaderLanguage } from '@galacean/engine-core';
+import { Color } from '@galacean/engine-math';
+import { SymbolInfo, EShaderStage, VarSymbol, BaseToken, ParserUtils, ShaderStructRole, ESymbolType, FnSymbol, ASTNode, Keyword, NoneTerminal, parsePreprocessorExpression, toPreprocessorCondition, mapExpandedShaderError, GSError, GSErrorName, TreeNode, canInheritanceBranchesCover, getLexicalDeclarationCoexistence, ShaderBuiltinSemantic, GLESShaderInfo, ShaderCoreInfo } from '@galacean/engine-shader-parser/internal';
+
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+
+        return o;
+    };
+
+    return _set_prototype_of(o, p);
+}
+
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+
+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.
+    // Those polyfills don't allow us to subclass built-ins, so we need to
+    // use our fallback implementation.
+    try {
+        // If the internal slots aren't set, this throws an error similar to
+        //   TypeError: this is not a Boolean object.
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+
+            if (Class) _set_prototype_of(instance, Class.prototype);
+
+            return instance;
+        };
+    }
+
+    return _construct.apply(null, arguments);
+}
+
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+
+    return _get_prototype_of(o);
+}
+
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") throw new TypeError("Super expression must either be null or a function");
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
+
+        return _set_prototype_of(Wrapper, Class);
+    };
+
+    return _wrap_native_super(Class);
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+
+        var i = 0;
+
+        return function() {
+            if (i >= o.length) return { done: true };
+
+            return { done: false, value: o[i++] };
+        };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+
+        if ("value" in descriptor) descriptor.writable = true;
+
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+
+    return Constructor;
+}
+
+/** @internal */ var VisitorContext = /*#__PURE__*/ function() {
+    function VisitorContext() {
+        this._lookupSymbol = new SymbolInfo("", null);
+        this._structRoles = new Map();
+        this._vertexUnresolvedVariableRoles = new Map();
+        this._fragmentUnresolvedVariableRoles = new Map();
+        this._vertexAmbiguousVariableNames = new Set();
+        this._fragmentAmbiguousVariableNames = new Set();
+        this.attributeStructs = [];
+        this.attributeList = [];
+        this.varyingStructs = [];
+        this.varyingList = [];
+        this.mrtStructs = [];
+        this.mrtList = [];
+        this._referencedGlobalSymbols = new Set();
+        this._referencedGlobalMacroASTs = [];
+        this._structVariableRoles = new Map();
+        this.codeCache = new Map();
+        this.fragmentReturnModes = new Map();
+        this.terminalInterfaceReturns = new Set();
+        this.reset();
+    }
+    var _proto = VisitorContext.prototype;
+    _proto.reset = function reset(resetAll) {
+        if (resetAll === void 0) resetAll = true;
+        this.codeCache.clear();
+        this.fragmentReturnModes.clear();
+        this.terminalInterfaceReturns.clear();
+        if (resetAll) {
+            this.attributeStructs.length = 0;
+            this.attributeList.length = 0;
+            this.varyingStructs.length = 0;
+            this.varyingList.length = 0;
+            this.mrtStructs.length = 0;
+            this.mrtList.length = 0;
+            this._structRoles.clear();
+            this._vertexUnresolvedVariableRoles.clear();
+            this._fragmentUnresolvedVariableRoles.clear();
+            this._vertexAmbiguousVariableNames.clear();
+            this._fragmentAmbiguousVariableNames.clear();
+        }
+        this._referencedAttributeList = Object.create(null);
+        this._referencedVaryingList = Object.create(null);
+        this._referencedMRTList = Object.create(null);
+        this._referencedGlobals = Object.create(null);
+        this._referencedGlobalSymbols.clear();
+        this._globalSymbolQueries = Object.create(null);
+        this._referencedGlobalMacroASTs.length = 0;
+        if (resetAll) {
+            this._structVariableRoles.clear();
+            this._passSymbolTable = undefined;
+        }
+    };
+    /**
+   * Finds the shared interface role of custom-struct declaration candidates.
+   * @param declarations - Exact parser struct identities resolved at one type occurrence.
+   * @returns Interface role, or `undefined` when the type is not an unambiguous interface struct.
+   */ _proto.getStructRole = function getStructRole(declarations) {
+        var resolvedRole;
+        for(var _iterator = _create_for_of_iterator_helper_loose(declarations), _step; !(_step = _iterator()).done;){
+            var declaration = _step.value;
+            var role = this._structRoles.get(declaration);
+            if (!role || resolvedRole && resolvedRole !== role) return;
+            resolvedRole = role;
+        }
+        return resolvedRole;
+    };
+    /**
+   * Tests the exact interface role of one struct declaration.
+   * @param declaration - Parser struct identity.
+   * @param role - Expected interface role.
+   * @returns Whether the declaration owns that role.
+   */ _proto.hasStructRole = function hasStructRole(declaration, role) {
+        return this._structRoles.get(declaration) === role;
+    };
+    /**
+   * Registers stage-interface struct types for constant-time role lookup.
+   * @param role - Interface role shared by the supplied structs.
+   * @param structs - Struct declarations derived from parser IR.
+   * @internal
+   */ _proto.registerStructTypes = function registerStructTypes(role, structs) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(structs), _step; !(_step = _iterator()).done;){
+            var struct = _step.value;
+            this._structRoles.set(struct, role);
+        }
+    };
+    /**
+   * Registers a resolved variable that holds an interface struct.
+   * @param variable - Parser symbol identity for the declaration.
+   * @param role - Struct interface role.
+   * @param stage - Optional stage from whose entry the variable is reachable. Omit when only exact
+   * symbol lookup is required.
+   */ _proto.registerStructVar = function registerStructVar(variable, role, stage) {
+        this._structVariableRoles.set(variable, role);
+        if (stage === undefined) return;
+        var roles = stage === EShaderStage.VERTEX ? this._vertexUnresolvedVariableRoles : this._fragmentUnresolvedVariableRoles;
+        var ambiguous = stage === EShaderStage.VERTEX ? this._vertexAmbiguousVariableNames : this._fragmentAmbiguousVariableNames;
+        var name = variable.ident;
+        if (ambiguous.has(name)) return;
+        var existing = roles.get(name);
+        if (existing && existing !== role) {
+            roles.delete(name);
+            ambiguous.add(name);
+        } else {
+            roles.set(name, role);
+        }
+    };
+    /**
+   * Finds an interface role for a global macro value that has no lexical symbol identity.
+   * @param variableName - Bare variable name in the macro replacement AST.
+   * @returns A role only when every stage-reachable declaration with that name agrees.
+   */ _proto.getUnresolvedStructVarRole = function getUnresolvedStructVarRole(variableName) {
+        var roles = this.stage === EShaderStage.VERTEX ? this._vertexUnresolvedVariableRoles : this._fragmentUnresolvedVariableRoles;
+        var ambiguous = this.stage === EShaderStage.VERTEX ? this._vertexAmbiguousVariableNames : this._fragmentAmbiguousVariableNames;
+        return ambiguous.has(variableName) ? undefined : roles.get(variableName);
+    };
+    /**
+   * Finds the shared interface role of branch-visible variable candidates.
+   * @param symbols - Exact parser symbols resolved at one reference.
+   * @returns Interface role, or `undefined` when the reference is not an unambiguous interface value.
+   */ _proto.getStructVarRole = function getStructVarRole(symbols) {
+        var resolvedRole;
+        for(var _iterator = _create_for_of_iterator_helper_loose(symbols), _step; !(_step = _iterator()).done;){
+            var symbol = _step.value;
+            if (!_instanceof(symbol, VarSymbol)) return;
+            var role = this._structVariableRoles.get(symbol);
+            if (!role || resolvedRole && resolvedRole !== role) return;
+            resolvedRole = role;
+        }
+        return resolvedRole;
+    };
+    /**
+   * Marks a value-return belonging to a fragment entry for backend lowering.
+   * @param statement - Exact return statement identity.
+   * @param mode - Fragment output contract of the containing entry declaration.
+   */ _proto.registerFragmentReturn = function registerFragmentReturn(statement, mode) {
+        this.fragmentReturnModes.set(statement, mode);
+    };
+    /**
+   * Finds the output contract for a fragment-entry return statement.
+   * @param statement - Return statement identity.
+   * @returns Output mode, or `undefined` for ordinary helper/vertex returns.
+   */ _proto.getFragmentReturnMode = function getFragmentReturnMode(statement) {
+        return this.fragmentReturnModes.get(statement);
+    };
+    /** Marks a syntactically final interface return whose control-flow exit can be omitted. */ _proto.registerTerminalInterfaceReturn = function registerTerminalInterfaceReturn(statement) {
+        this.terminalInterfaceReturns.add(statement);
+    };
+    /**
+   * Tests whether an interface return is the final syntactic statement in its function.
+   * @param statement - Return statement identity.
+   * @returns Whether backend lowering may omit a trailing `return;`.
+   */ _proto.isTerminalInterfaceReturn = function isTerminalInterfaceReturn(statement) {
+        return this.terminalInterfaceReturns.has(statement);
+    };
+    _proto.referenceAttribute = function referenceAttribute(ident) {
+        this._referenceProp(ident.lexeme, this.attributeList, this._referencedAttributeList);
+    };
+    _proto.referenceVarying = function referenceVarying(ident) {
+        this._referenceProp(ident.lexeme, this.varyingList, this._referencedVaryingList);
+    };
+    _proto.referenceMRTProp = function referenceMRTProp(ident) {
+        this._referenceProp(ident.lexeme, this.mrtList, this._referencedMRTList);
+    };
+    _proto.referenceGlobal = function referenceGlobal(ident, type) {
+        var _this__globalSymbolQueries, _ident;
+        var _;
+        var queries = (_ = (_this__globalSymbolQueries = this._globalSymbolQueries)[_ident = ident]) != null ? _ : _this__globalSymbolQueries[_ident] = Object.create(null);
+        var symbols = queries[type];
+        if (!symbols) {
+            var _this__referencedGlobals, _ident1;
+            this._lookupSymbol.set(ident, type);
+            symbols = queries[type] = this._passSymbolTable.getSymbols(this._lookupSymbol, true, []);
+            var _1;
+            var namedSymbols = (_1 = (_this__referencedGlobals = this._referencedGlobals)[_ident1 = ident]) != null ? _1 : _this__referencedGlobals[_ident1] = [];
+            for(var _iterator = _create_for_of_iterator_helper_loose(symbols), _step; !(_step = _iterator()).done;){
+                var symbol = _step.value;
+                if (!this._referencedGlobalSymbols.has(symbol)) {
+                    this._referencedGlobalSymbols.add(symbol);
+                    namedSymbols.push(symbol);
+                }
+            }
+        }
+        // Repeated uses still establish edges from each declaration's owner.
+        this.onReferenceGlobal == null ? void 0 : this.onReferenceGlobal.call(this, symbols);
+    };
+    // Track which IO props are actually referenced (drives in/out emission). A missing member is no
+    // longer flagged here — that's the parser's struct-field check (UndeclaredStructMember).
+    _proto._referenceProp = function _referenceProp(name, list, refList) {
+        if (!refList[name]) refList[name] = list.filter(function(item) {
+            return item.ident.lexeme === name;
+        });
+        this.onReferenceStructProps == null ? void 0 : this.onReferenceStructProps.call(this, refList[name]);
+    };
+    return VisitorContext;
+}();
+
+var TempArray = /*#__PURE__*/ function() {
+    function TempArray() {
+        this.array = new Array();
+    }
+    var _proto = TempArray.prototype;
+    _proto.dispose = function dispose() {
+        this.array.length = 0;
+    };
+    return TempArray;
+}();
+
+/**
+ * @internal
+ * The code generator
+ */ var CodeGenVisitor = /*#__PURE__*/ function() {
+    function CodeGenVisitor() {
+        this.context = new VisitorContext();
+    }
+    var _proto = CodeGenVisitor.prototype;
+    _proto.cache = function cache(node, code) {
+        this.context.codeCache.set(node, code);
+        return code;
+    };
+    _proto.getCachedCode = function getCachedCode(node) {
+        return this.context.codeCache.get(node);
+    };
+    _proto.defaultCodeGen = function defaultCodeGen(children) {
+        var pool = CodeGenVisitor._tmpArrayPool;
+        var ret = pool.get();
+        ret.dispose();
+        for(var _iterator = _create_for_of_iterator_helper_loose(children), _step; !(_step = _iterator()).done;){
+            var child = _step.value;
+            if (_instanceof(child, BaseToken)) {
+                // Legacy opaque `#define` lexemes carry the directive verbatim; expression-style defines use the AST path
+                ret.array.push(child.lexeme);
+            } else {
+                ret.array.push(child.codeGen(this));
+            }
+        }
+        var result = ret.array.join(" ");
+        ret.dispose();
+        pool.return(ret);
+        return result;
+    };
+    _proto.visitPostfixExpression = function visitPostfixExpression(node) {
+        var children = node.children;
+        var derivationLength = children.length;
+        var context = this.context;
+        if (derivationLength === 3) {
+            var postExpr = children[0];
+            var prop = children[2];
+            if (_instanceof(prop, BaseToken)) {
+                // Direct variables use parser symbol identity so lexical shadowing cannot inherit an IO role
+                // from a same-named declaration. Macro-expanded identifiers can lack a resolved symbol, so
+                // only that zero-symbol path consults the current stage's unambiguous name-to-role map.
+                var role;
+                var directRoot = ParserUtils.unwrapBareIdentifier(postExpr, {
+                    allowParens: true
+                });
+                if (directRoot) {
+                    var symbols = directRoot.resolvedValueSymbols();
+                    var unresolvedName = ParserUtils.extractDirectIdentLexeme(postExpr);
+                    role = symbols.length ? context.getStructVarRole(symbols) : unresolvedName ? context.getUnresolvedStructVarRole(unresolvedName) : undefined;
+                }
+                if (role) {
+                    if (role === ShaderStructRole.Attribute) context.referenceAttribute(prop);
+                    else if (role === ShaderStructRole.Varying) context.referenceVarying(prop);
+                    else context.referenceMRTProp(prop);
+                    return prop.lexeme;
+                }
+                return postExpr.codeGen(this) + "." + prop.lexeme;
+            } else {
+                return postExpr.codeGen(this) + "." + prop.codeGen(this);
+            }
+        } else if (derivationLength === 4) {
+            var identNode = children[0];
+            var indexNode = children[2];
+            return identNode.codeGen(this) + "[" + indexNode.codeGen(this) + "]";
+        }
+        return this.defaultCodeGen(node.children);
+    };
+    _proto.visitVariableIdentifier = function visitVariableIdentifier(node) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(node.referenceGlobalSymbolNames), _step; !(_step = _iterator()).done;){
+            var name = _step.value;
+            this.context.referenceGlobal(name, ESymbolType.Any);
+        }
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(node.resolvedSymbols()), _step1; !(_step1 = _iterator1()).done;){
+            var symbol = _step1.value;
+            if (_instanceof(symbol, FnSymbol)) this.referenceFunction(symbol, node.location.start.index, node._branch);
+        }
+        return node.getLexeme(this);
+    };
+    _proto.referenceFunction = function referenceFunction(symbol, referenceIndex, branch) {
+        this.context.referenceGlobal(symbol.ident, ESymbolType.FN);
+    };
+    _proto.visitFunctionCall = function visitFunctionCall(node) {
+        var call = node.children[0];
+        if (_instanceof(call.fnSymbol, FnSymbol)) {
+            var _call_fnSymbols;
+            for(var _iterator = _create_for_of_iterator_helper_loose(((_call_fnSymbols = call.fnSymbols) == null ? void 0 : _call_fnSymbols.length) ? call.fnSymbols : [
+                call.fnSymbol
+            ]), _step; !(_step = _iterator()).done;){
+                var symbol = _step.value;
+                this.referenceFunction(symbol, node.location.start.index, node._branch);
+            }
+            var paramList = call.children[2];
+            if (_instanceof(paramList, ASTNode.FunctionCallParameterList)) {
+                var astNodes = paramList.paramNodes;
+                var finalSymbol = this.context._referencedGlobals[call.fnSymbol.ident].find(function(candidate) {
+                    return _instanceof(candidate, FnSymbol) && candidate.equal(call.fnSymbol);
+                });
+                var paramInfoList = (finalSymbol != null ? finalSymbol : call.fnSymbol).astNode.protoType.parameterList;
+                var context = this.context;
+                var params = astNodes.filter(function(_, i) {
+                    var _paramInfoList_i;
+                    var parameter = paramInfoList == null ? void 0 : (_paramInfoList_i = paramInfoList[i]) == null ? void 0 : _paramInfoList_i.astNode;
+                    // Drop struct-IO parameters (attribute/varying/mrt) — they're flattened
+                    // into top-level declarations and no longer exist as function-call args.
+                    return !_instanceof(parameter, ASTNode.ParameterDeclaration) || !parameter.symbol || !context.getStructVarRole([
+                        parameter.symbol
+                    ]);
+                });
+                var paramsCode = "";
+                for(var i = 0, length = params.length; i < length; i++){
+                    var astNode = params[i];
+                    var code = astNode.codeGen(this);
+                    if (_instanceof(astNode, ASTNode.MacroCallArgBlock) || i === 0) {
+                        paramsCode += code;
+                    } else {
+                        paramsCode += ", " + code;
+                    }
+                }
+                return call.fnSymbol.ident + "(" + paramsCode + ")";
+            }
+        }
+        return this.defaultCodeGen(node.children);
+    };
+    _proto.visitMacroCallFunction = function visitMacroCallFunction(node) {
+        var children = node.children;
+        var paramList = children[2];
+        if (_instanceof(paramList, ASTNode.FunctionCallParameterList)) {
+            var astNodes = paramList.paramNodes;
+            var context = this.context;
+            // 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 && context.getStructVarRole(variableParam.resolvedValueSymbols())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            }
+            var paramsCode = "";
+            for(var i = 0, length = params.length; i < length; i++){
+                var argNode = params[i];
+                var code = argNode.codeGen(this);
+                if (_instanceof(argNode, ASTNode.MacroCallArgBlock) || i === 0) {
+                    paramsCode += code;
+                } else {
+                    paramsCode += ", " + code;
+                }
+            }
+            return node.macroName + "(" + paramsCode + ")";
+        } else {
+            return this.defaultCodeGen(node.children);
+        }
+    };
+    _proto.visitStatementList = function visitStatementList(node) {
+        var children = node.children;
+        if (children.length === 1) {
+            return children[0].codeGen(this);
+        } else {
+            return children[0].codeGen(this) + "\n" + children[1].codeGen(this);
+        }
+    };
+    /**
+   * Code-generate a `#define` macro parsed as expression AST. Produces a `#define`
+   * directive whose value is the AST-rewritten string — so varying flattening
+   * happens naturally via `visitPostfixExpression` inside the AST walk.
+   */ _proto.visitMacroDefine = function visitMacroDefine(node) {
+        // For function-like macros, preserve the original `(params)` lexeme verbatim —
+        // the parameter list is user-authored text that shouldn't be canonicalized.
+        var paramsLexeme = "";
+        if (node.isFunction) {
+            var paramsToken = node.children[2];
+            if (_instanceof(paramsToken, BaseToken)) paramsLexeme = paramsToken.lexeme;
+        }
+        var valueCode = node.valueExpression ? node.valueExpression.codeGen(this) : "";
+        // Newlines around the directive keep `#` at the start of its physical line per
+        // GLSL ES 3.0 §3.4, regardless of how surrounding tokens are joined.
+        return "\n#define " + node.macroName + paramsLexeme + (valueCode ? " " + valueCode : "") + "\n";
+    };
+    _proto.visitSingleDeclaration = function visitSingleDeclaration(node) {
+        return this.defaultCodeGen(node.children);
+    };
+    _proto.visitGlobalVariableDeclaration = function visitGlobalVariableDeclaration(node) {
+        var children = node.children;
+        var fullType = children[0];
+        if (_instanceof(fullType, ASTNode.FullySpecifiedType) && fullType.typeSpecifier.isCustom) {
+            var context = this.context;
+            // Global interface variables are flattened and therefore are not emitted as uniforms.
+            if (context.getStructVarRole([
+                node.declarator.symbol
+            ])) {
+                return "";
+            }
+            context.referenceGlobal(fullType.type, ESymbolType.STRUCT);
+        }
+        return "uniform " + this.defaultCodeGen(children);
+    };
+    _proto.visitDeclaration = function visitDeclaration(node) {
+        var context = this.context;
+        var children = node.children;
+        var child = children[0];
+        if (_instanceof(child, ASTNode.InitDeclaratorList)) {
+            var first = child.children[0];
+            var _child_declarator;
+            var declarator = (_child_declarator = child.declarator) != null ? _child_declarator : _instanceof(first, ASTNode.SingleDeclaration) ? first.declarator : undefined;
+            var role = declarator && context.getStructVarRole([
+                declarator.symbol
+            ]);
+            if (role === ShaderStructRole.Varying || role === ShaderStructRole.Mrt) return "";
+        }
+        return this.defaultCodeGen(children);
+    };
+    _proto.visitFunctionParameterList = function visitFunctionParameterList(node) {
+        var context = this.context;
+        var params = node.parameterInfoList.filter(function(item) {
+            var parameter = item.astNode;
+            return !_instanceof(parameter, ASTNode.ParameterDeclaration) || !parameter.symbol || !context.getStructVarRole([
+                parameter.symbol
+            ]);
+        });
+        var out = "";
+        for(var i = 0, length = params.length; i < length; i++){
+            var item = params[i];
+            var astNode = item.astNode;
+            var code = astNode.codeGen(this);
+            if (_instanceof(astNode, ASTNode.MacroParamBlock) || i === 0) {
+                out += code;
+            } else {
+                out += ", " + code;
+            }
+        }
+        return out;
+    };
+    _proto.visitFunctionHeader = function visitFunctionHeader(node) {
+        var returnType = node.returnType.typeSpecifier;
+        if (this.context.getStructRole(returnType.structDeclarations) === ShaderStructRole.Varying) {
+            return "void " + node.ident.lexeme + "(";
+        }
+        return this.defaultCodeGen(node.children);
+    };
+    _proto.visitJumpStatement = function visitJumpStatement(node) {
+        var children = node.children;
+        var cmd = children[0];
+        if (cmd.type === Keyword.RETURN) {
+            var expr = children[1];
+            if (_instanceof(expr, ASTNode.Expression)) {
+                var returnVar = ParserUtils.unwrapNodeByType(expr, NoneTerminal.variable_identifier);
+                if (returnVar && this.context.getStructVarRole(returnVar.resolvedValueSymbols()) === ShaderStructRole.Varying) {
+                    return this.context.isTerminalInterfaceReturn(node) ? "" : "return;";
+                }
+                var returnFnCall = ParserUtils.unwrapNodeByType(expr, NoneTerminal.function_call);
+                var calledFunction = returnFnCall == null ? void 0 : returnFnCall.children[0];
+                var returnDeclarations = _instanceof(calledFunction == null ? void 0 : calledFunction.fnSymbol, FnSymbol) ? calledFunction.fnSymbol.astNode.protoType.returnType.typeSpecifier.structDeclarations : [];
+                if (this.context.getStructRole(returnDeclarations) === ShaderStructRole.Varying) {
+                    var call = "" + expr.codeGen(this) + ";";
+                    return this.context.isTerminalInterfaceReturn(node) ? call : "{ " + call + " return; }";
+                }
+            }
+        }
+        return this.defaultCodeGen(children);
+    };
+    _proto.visitFunctionIdentifier = function visitFunctionIdentifier(node) {
+        return this.defaultCodeGen(node.children);
+    };
+    _proto.visitTypeSpecifier = function visitTypeSpecifier(node) {
+        return this.defaultCodeGen(node.children);
+    };
+    _proto.visitStructSpecifier = function visitStructSpecifier(node) {
+        var _this = this;
+        var context = this.context;
+        var varyingStructs = context.varyingStructs, attributeStructs = context.attributeStructs, mrtStructs = context.mrtStructs;
+        var isVaryingStruct = varyingStructs.indexOf(node) !== -1;
+        var isAttributeStruct = attributeStructs.indexOf(node) !== -1;
+        var isMRTStruct = mrtStructs.indexOf(node) !== -1;
+        if (isVaryingStruct || isAttributeStruct || isMRTStruct) {
+            var _result;
+            var result = [];
+            (_result = result).push.apply(_result, [].concat(node.macroExpressions.map(function(item) {
+                return {
+                    text: _instanceof(item, BaseToken) ? item.lexeme : item.codeGen(_this),
+                    index: item.location.start.index
+                };
+            })));
+            for(var _iterator = _create_for_of_iterator_helper_loose(node.propList), _step; !(_step = _iterator()).done;){
+                var prop = _step.value;
+                var _context__referencedVaryingList_name, _context__referencedAttributeList_name, _context__referencedMRTList_name;
+                var name = prop.ident.lexeme;
+                if (isVaryingStruct && ((_context__referencedVaryingList_name = context._referencedVaryingList[name]) == null ? void 0 : _context__referencedVaryingList_name.indexOf(prop)) >= 0) {
+                    result.push({
+                        text: "" + this.getVaryingProp(prop) + "\n",
+                        index: prop.ident.location.start.index
+                    });
+                } else if (isAttributeStruct && ((_context__referencedAttributeList_name = context._referencedAttributeList[name]) == null ? void 0 : _context__referencedAttributeList_name.indexOf(prop)) >= 0) {
+                    result.push({
+                        text: "" + this.getAttributeProp(prop) + "\n",
+                        index: prop.ident.location.start.index
+                    });
+                } else if (isMRTStruct && ((_context__referencedMRTList_name = context._referencedMRTList[name]) == null ? void 0 : _context__referencedMRTList_name.indexOf(prop)) >= 0) {
+                    result.push({
+                        text: "" + this.getMRTProp(prop) + "\n",
+                        index: prop.ident.location.start.index
+                    });
+                }
+            }
+            var text = result.sort(function(a, b) {
+                return a.index - b.index;
+            }).map(function(item) {
+                return item.text;
+            }).join("");
+            return text;
+        } else {
+            return this.defaultCodeGen(node.children);
+        }
+    };
+    _proto.visitFunctionDefinition = function visitFunctionDefinition(fnNode) {
+        var fnName = fnNode.protoType.ident.lexeme;
+        var context = this.context;
+        var terminal = ParserUtils.lastStatement(fnNode.statements);
+        if (_instanceof(terminal, ASTNode.JumpStatement)) context.registerTerminalInterfaceReturn(terminal);
+        if (fnName == context.stageEntry) {
+            var statements = fnNode.statements.codeGen(this);
+            return "void main() " + statements;
+        } else {
+            return this.defaultCodeGen(fnNode.children);
+        }
+    };
+    return CodeGenVisitor;
+}();
+CodeGenVisitor._tmpArrayPool = new ReturnableObjectPool(TempArray, 10);
+
+/**
+ * @internal
+ */ var ShaderInstructionEncoder = /*#__PURE__*/ function() {
+    function ShaderInstructionEncoder() {}
+    /**
+   * Marks compiler-owned text without placing parser objects in the instruction stream.
+   * @param text - Declaration or derived declaration text.
+   * @param owner - Neutral declaration identity, if runtime selection is required.
+   * @param activate - Whether this is the declaration's original source position.
+   * @returns Intermediate source consumed by the instruction encoder.
+   * @internal
+   */ ShaderInstructionEncoder.declaration = function declaration(text, owner, activate) {
+        if (activate === void 0) activate = true;
+        if (!owner) return text;
+        var activation = activate ? "\0D" + owner.id + "," + owner.group + "," + owner.sourceScope + "\0\n" : "";
+        return text ? activation + "\0T" + owner.id + "\0\n" + text + "\n\0E\0\n" : activation;
+    };
+    /**
+   * Marks derived text shared by any selected, reachable declaration without activating an owner.
+   * @param text - Shared derived declaration text.
+   * @param owners - Declarations that require the text; an empty list never retains it.
+   * @returns Intermediate source consumed by the instruction encoder.
+   * @internal
+   */ ShaderInstructionEncoder.sharedDeclaration = function sharedDeclaration(text, owners) {
+        return text ? "\0T" + owners.map(function(owner) {
+            return owner.id;
+        }).join(",") + "\0\n" + text + "\n\0E\0\n" : "";
+    };
+    /**
+   * Records a declaration dependency for variant-time reachability after ownership selection.
+   * @param from - Referencing declaration identity, or zero for a stage root.
+   * @param to - Referenced declaration identity.
+   * @returns Intermediate source consumed by the instruction encoder.
+   * @internal
+   */ ShaderInstructionEncoder.reference = function reference(from, to) {
+        return "\0R" + from + "," + to + "\0\n";
+    };
+    /**
+   * Removes private emission markers from the public source view after instruction encoding.
+   * @param source - Encoded intermediate stage source.
+   * @returns GLSL source without compiler metadata.
+   * @internal
+   */ ShaderInstructionEncoder.source = function source(source) {
+        return source.indexOf("\0") < 0 ? source : source.replace(/\0[^\0]*\0\n?/g, "");
+    };
+    /**
+   * Encodes generated GLSL directives into runtime-selectable instructions.
+   * @param glsl - Generated stage source.
+   * @param preprocessorExpressions - Parser-owned expression trees keyed by logical directive text.
+   * @returns Runtime shader instruction stream.
+   * @throws Error when a conditional directive is malformed or has a deterministic evaluation failure.
+   * @internal
+   */ ShaderInstructionEncoder.parse = function parse(glsl, preprocessorExpressions) {
+        var instructions = [];
+        var length = glsl.length;
+        var pos = 0;
+        var owners;
+        var backfillStack = [];
+        while(pos < length){
+            var directiveStart = ShaderInstructionEncoder._findDirectiveStart(glsl, pos, length);
+            if (directiveStart === -1) {
+                ShaderInstructionEncoder._pushText(instructions, glsl, pos, length, owners);
+                break;
+            }
+            if (directiveStart > pos) {
+                ShaderInstructionEncoder._pushText(instructions, glsl, pos, directiveStart, owners);
+            }
+            var lineEnd = ShaderInstructionEncoder._findLogicalLineEnd(glsl, directiveStart, length);
+            var line = glsl.substring(directiveStart, lineEnd).replace(/\\(?:\r\n|\n|\r)/g, "");
+            pos = lineEnd < length ? lineEnd + 1 : length;
+            if (line.charCodeAt(0) === 0) {
+                var kind = line.charAt(1);
+                if (kind === "D") {
+                    var fields = line.slice(2, -1).split(",").map(Number);
+                    instructions.push([
+                        ShaderPreprocessorDirective.Declaration,
+                        fields[0],
+                        fields[1],
+                        fields[2]
+                    ]);
+                } else if (kind === "R") {
+                    var fields1 = line.slice(2, -1).split(",").map(Number);
+                    instructions.push([
+                        ShaderPreprocessorDirective.Reference,
+                        fields1[0],
+                        fields1[1]
+                    ]);
+                } else {
+                    var ids = line.slice(2, -1);
+                    owners = kind === "T" ? ids ? ids.split(",").map(Number) : [] : undefined;
+                }
+                continue;
+            }
+            var match = ShaderInstructionEncoder._DIRECTIVE_RE.exec(line);
+            if (!match) {
+                var text = lineEnd < length ? line + "\n" : line;
+                ShaderInstructionEncoder._pushText(instructions, text, 0, text.length, owners);
+                continue;
+            }
+            var keyword = match[1];
+            var rest = match[2].trim();
+            switch(keyword){
+                case "ifdef":
+                    {
+                        var idx = instructions.length;
+                        instructions.push([
+                            ShaderPreprocessorDirective.IfDef,
+                            rest,
+                            -1
+                        ]);
+                        backfillStack.push([
+                            idx
+                        ]);
+                        break;
+                    }
+                case "ifndef":
+                    {
+                        var idx1 = instructions.length;
+                        instructions.push([
+                            ShaderPreprocessorDirective.IfNdef,
+                            rest,
+                            -1
+                        ]);
+                        backfillStack.push([
+                            idx1
+                        ]);
+                        break;
+                    }
+                case "if":
+                    {
+                        var cond = ShaderInstructionEncoder._parseCondition(rest, preprocessorExpressions);
+                        var idx2 = instructions.length;
+                        ShaderInstructionEncoder._pushConditionInstruction(instructions, cond);
+                        backfillStack.push([
+                            idx2
+                        ]);
+                        break;
+                    }
+                case "elif":
+                    {
+                        var stack = backfillStack[backfillStack.length - 1];
+                        var prevIdx = stack[stack.length - 1];
+                        var elseIdx = instructions.length;
+                        instructions.push([
+                            ShaderPreprocessorDirective.Else,
+                            -1
+                        ]);
+                        stack.push(elseIdx);
+                        ShaderInstructionEncoder._backfillJump(instructions[prevIdx], instructions.length);
+                        var cond1 = ShaderInstructionEncoder._parseCondition(rest, preprocessorExpressions);
+                        var idx3 = instructions.length;
+                        ShaderInstructionEncoder._pushConditionInstruction(instructions, cond1);
+                        stack.push(idx3);
+                        break;
+                    }
+                case "else":
+                    {
+                        var stack1 = backfillStack[backfillStack.length - 1];
+                        var prevIdx1 = stack1[stack1.length - 1];
+                        var elseIdx1 = instructions.length;
+                        instructions.push([
+                            ShaderPreprocessorDirective.Else,
+                            -1
+                        ]);
+                        stack1.push(elseIdx1);
+                        ShaderInstructionEncoder._backfillJump(instructions[prevIdx1], instructions.length);
+                        break;
+                    }
+                case "endif":
+                    {
+                        var endifIdx = instructions.length;
+                        instructions.push([
+                            ShaderPreprocessorDirective.Endif
+                        ]);
+                        var stack2 = backfillStack.pop();
+                        if (stack2) {
+                            var afterEndif = endifIdx + 1;
+                            for(var j = 0; j < stack2.length; j++){
+                                var inst = instructions[stack2[j]];
+                                if (inst[0] === ShaderPreprocessorDirective.Else) {
+                                    inst[1] = afterEndif;
+                                } else {
+                                    ShaderInstructionEncoder._backfillJump(inst, afterEndif, true);
+                                }
+                            }
+                        }
+                        break;
+                    }
+                case "define":
+                    {
+                        var funcMatch = ShaderInstructionEncoder._FUNC_MACRO_RE.exec(rest);
+                        if (funcMatch) {
+                            var params = funcMatch[2].split(",").map(function(p) {
+                                return p.trim();
+                            }).filter(function(p) {
+                                return p.length > 0;
+                            });
+                            instructions.push([
+                                ShaderPreprocessorDirective.DefineFunc,
+                                funcMatch[1],
+                                params,
+                                ShaderInstructionEncoder._stripLineComment(funcMatch[3].trim())
+                            ]);
+                        } else {
+                            var separator = ShaderInstructionEncoder._findInlineWhitespace(rest);
+                            if (separator === rest.length) {
+                                instructions.push([
+                                    ShaderPreprocessorDirective.Define,
+                                    rest
+                                ]);
+                            } else {
+                                instructions.push([
+                                    ShaderPreprocessorDirective.DefineVal,
+                                    rest.substring(0, separator),
+                                    ShaderInstructionEncoder._stripLineComment(rest.substring(separator + 1).trim())
+                                ]);
+                            }
+                        }
+                        break;
+                    }
+                case "undef":
+                    {
+                        instructions.push([
+                            ShaderPreprocessorDirective.Undef,
+                            rest
+                        ]);
+                        break;
+                    }
+            }
+        }
+        return instructions;
+    };
+    ShaderInstructionEncoder._pushConditionInstruction = function _pushConditionInstruction(instructions, cond) {
+        if (cond.t === "def") {
+            instructions.push([
+                ShaderPreprocessorDirective.IfDef,
+                cond.m,
+                -1
+            ]);
+        } else if (cond.t === "ndef") {
+            instructions.push([
+                ShaderPreprocessorDirective.IfNdef,
+                cond.m,
+                -1
+            ]);
+        } else if (cond.t === "cmp") {
+            instructions.push([
+                ShaderPreprocessorDirective.IfCmp,
+                cond.m,
+                cond.op,
+                cond.v,
+                -1
+            ]);
+        } else {
+            instructions.push([
+                ShaderPreprocessorDirective.IfExpr,
+                cond,
+                -1
+            ]);
+        }
+    };
+    ShaderInstructionEncoder._parseCondition = function _parseCondition(expression, preprocessorExpressions) {
+        var _preprocessorExpressions_get;
+        var result = (_preprocessorExpressions_get = preprocessorExpressions == null ? void 0 : preprocessorExpressions.get(expression)) != null ? _preprocessorExpressions_get : parsePreprocessorExpression(expression);
+        if ("error" in result) {
+            if (!result.error.certain && result.hasExpandableIdentifier) return {
+                t: "deferred",
+                e: expression
+            };
+            throw new Error(result.error.message);
+        }
+        if (result.evaluationError) throw new Error(result.evaluationError);
+        var compact = toPreprocessorCondition(result.condition);
+        if (compact && !result.hasExpandableIdentifier) return compact;
+        return result.hasExpandableIdentifier ? {
+            t: "deferred",
+            e: expression
+        } : result.condition;
+    };
+    ShaderInstructionEncoder._findDirectiveStart = function _findDirectiveStart(source, from, length) {
+        var i = from;
+        while(i < length){
+            var j = i;
+            while(j < length){
+                var c = source.charCodeAt(j);
+                if (c === 32 /* space */  || c === 9 /* tab */ ) {
+                    j++;
+                } else {
+                    break;
+                }
+            }
+            if (j < length && (source.charCodeAt(j) === 35 /* '#' */  || source.charCodeAt(j) === 0)) return i;
+            var nl = source.indexOf("\n", i);
+            if (nl === -1) break;
+            i = nl + 1;
+        }
+        return -1;
+    };
+    ShaderInstructionEncoder._findLogicalLineEnd = function _findLogicalLineEnd(source, start, length) {
+        var lineEnd = source.indexOf("\n", start);
+        while(lineEnd !== -1){
+            var beforeBreak = source.charCodeAt(lineEnd - 1) === 13 ? lineEnd - 2 : lineEnd - 1;
+            if (beforeBreak < start || source.charCodeAt(beforeBreak) !== 92) return lineEnd;
+            lineEnd = source.indexOf("\n", lineEnd + 1);
+        }
+        return length;
+    };
+    ShaderInstructionEncoder._findInlineWhitespace = function _findInlineWhitespace(source) {
+        var index = 0;
+        while(index < source.length){
+            var charCode = source.charCodeAt(index);
+            if (charCode === 32 /* space */  || charCode === 9 /* tab */ ) break;
+            index++;
+        }
+        return index;
+    };
+    ShaderInstructionEncoder._pushText = function _pushText(instructions, source, from, to, owners) {
+        if (from >= to) return;
+        var last = instructions.length > 0 ? instructions[instructions.length - 1] : null;
+        var directive = owners === undefined ? ShaderPreprocessorDirective.Text : ShaderPreprocessorDirective.OwnedText;
+        if (last && last[0] === directive && (owners === undefined || last.length === owners.length + 2 && owners.every(function(owner, index) {
+            return last[index + 2] === owner;
+        }))) {
+            last[1] += source.substring(from, to);
+        } else {
+            instructions.push(owners === undefined ? [
+                directive,
+                source.substring(from, to)
+            ] : [].concat([
+                directive,
+                source.substring(from, to)
+            ], owners));
+        }
+    };
+    /**
+   * Backfill jump offset of an IF/ELIF instruction.
+   * When onlyPlaceholder is true, only backfill if the current value is still -1
+   */ ShaderInstructionEncoder._backfillJump = function _backfillJump(inst, target, onlyPlaceholder) {
+        if (onlyPlaceholder === void 0) onlyPlaceholder = false;
+        var directive = inst[0];
+        if (directive === ShaderPreprocessorDirective.IfDef || directive === ShaderPreprocessorDirective.IfNdef) {
+            if (!onlyPlaceholder || inst[2] === -1) inst[2] = target;
+        } else if (directive === ShaderPreprocessorDirective.IfCmp) {
+            if (!onlyPlaceholder || inst[4] === -1) inst[4] = target;
+        } else if (directive === ShaderPreprocessorDirective.IfExpr) {
+            if (!onlyPlaceholder || inst[2] === -1) inst[2] = target;
+        }
+    };
+    ShaderInstructionEncoder._stripLineComment = function _stripLineComment(s) {
+        var idx = s.indexOf("//");
+        return idx >= 0 ? s.substring(0, idx).trimEnd() : s;
+    };
+    return ShaderInstructionEncoder;
+}();
+ShaderInstructionEncoder._DIRECTIVE_RE = /^[ \t]*#[ \t]*(if|ifdef|ifndef|elif|else|endif|define|undef)\b(.*)/;
+ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
+
+/**
+ * @internal
+ */ var GLESVisitor = /*#__PURE__*/ function(CodeGenVisitor) {
+    _inherits(GLESVisitor, CodeGenVisitor);
+    function GLESVisitor() {
+        var _this;
+        _this = CodeGenVisitor.apply(this, arguments) || this, _this._globalCodeArray = [], _this._forwardFunctionDeclarations = new Map(), _this._forwardStructIndices = new Map(), _this._structCodeSegments = new Map(), _this._forwardVariableIndices = new Map(), _this._variableCodeSegments = new Map(), _this._declarationOwners = new Map(), _this._deferredPrototypes = new Map(), _this._declarationReferences = new Map(), _this._outerMacroDeclarations = [];
+        return _this;
+    }
+    var _proto = GLESVisitor.prototype;
+    /**
+   * Clears pass-local output retained by the pooled visitor.
+   */ _proto.reset = function reset() {
+        var _this = this, globalCodeArray = _this._globalCodeArray;
+        globalCodeArray.length = 0;
+        this._forwardFunctionDeclarations.clear();
+        this._forwardStructIndices.clear();
+        this._structCodeSegments.clear();
+        this._forwardVariableIndices.clear();
+        this._variableCodeSegments.clear();
+        this._deferredPrototypes.clear();
+        this._declarationReferences.clear();
+        this._currentDeclaration = undefined;
+    };
+    /**
+   * Releases references retained by an idle visitor when its pool is collected.
+   * @internal
+   */ _proto.dispose = function dispose() {
+        this.context.reset();
+        this.reset();
+    };
+    /**
+   * Emits target-specific declarations that precede generated global code.
+   * @param data - Parser-owned shader facts.
+   * @param out - Destination code segments.
+   */ _proto.getOtherGlobal = function getOtherGlobal(data, out) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(data.globalPrecisions), _step; !(_step = _iterator()).done;){
+            var precision = _step.value;
+            out.push({
+                text: precision.codeGen(this),
+                index: precision.location.start.index
+            });
+        }
+    };
+    /**
+   * Generates vertex and fragment source from neutral parser facts.
+   * @param ir - Request-owned neutral shader IR.
+   * @param coreInfo - Entry and stage-interface facts derived from the same IR.
+   * @returns Generated vertex and fragment source.
+   */ _proto.generate = function generate(ir, coreInfo) {
+        var _this = this;
+        var _context_attributeStructs, _context_attributeList, _context_varyingStructs, _context_varyingList, _context_mrtStructs, _context_mrtList;
+        this.context.reset();
+        this.reset();
+        var node = ir.program;
+        var shaderData = node.shaderData;
+        var context = this.context;
+        context._passSymbolTable = shaderData.symbolTable;
+        var outerGlobalMacroDeclarations = coreInfo.outerGlobalMacroDeclarations;
+        var io = coreInfo.io;
+        (_context_attributeStructs = context.attributeStructs).push.apply(_context_attributeStructs, [].concat(io.attributeStructs));
+        (_context_attributeList = context.attributeList).push.apply(_context_attributeList, [].concat(io.attributeList));
+        (_context_varyingStructs = context.varyingStructs).push.apply(_context_varyingStructs, [].concat(io.varyingStructs));
+        (_context_varyingList = context.varyingList).push.apply(_context_varyingList, [].concat(io.varyingList));
+        (_context_mrtStructs = context.mrtStructs).push.apply(_context_mrtStructs, [].concat(io.mrtStructs));
+        (_context_mrtList = context.mrtList).push.apply(_context_mrtList, [].concat(io.mrtList));
+        context.registerStructTypes(ShaderStructRole.Attribute, io.attributeStructs);
+        context.registerStructTypes(ShaderStructRole.Varying, io.varyingStructs);
+        context.registerStructTypes(ShaderStructRole.Mrt, io.mrtStructs);
+        io.structVariableRoles.forEach(function(role, variable) {
+            return context.registerStructVar(variable, role);
+        });
+        io.vertexStructVariableRoles.forEach(function(role, variable) {
+            context.registerStructVar(variable, role, EShaderStage.VERTEX);
+        });
+        io.fragmentStructVariableRoles.forEach(function(role, variable) {
+            context.registerStructVar(variable, role, EShaderStage.FRAGMENT);
+        });
+        this._sourceIR = ir;
+        this._outerMacroDeclarations = outerGlobalMacroDeclarations;
+        try {
+            coreInfo.deferredDeclarationOwnership.forEach(function(owner, symbol) {
+                return _this._declarationOwners.set(symbol.astNode, owner);
+            });
+            if (this._declarationOwners.size) {
+                var nextId = 0;
+                var nextGroup = 0;
+                this._declarationOwners.forEach(function(owner) {
+                    nextId = Math.max(nextId, owner.id);
+                    nextGroup = Math.max(nextGroup, owner.group);
+                });
+                // Reachability follows the selected declaration, including dependencies without an override.
+                shaderData.symbolTable.forEach(function(symbol) {
+                    if (symbol.astNode && !_this._declarationOwners.has(symbol.astNode)) {
+                        _this._declarationOwners.set(symbol.astNode, {
+                            id: ++nextId,
+                            group: ++nextGroup,
+                            sourceScope: symbol.sourceScope
+                        });
+                    }
+                });
+                context.onReferenceGlobal = function(symbols) {
+                    var _this_currentDeclarationOwner;
+                    var _this_currentDeclarationOwner_id;
+                    var from = (_this_currentDeclarationOwner_id = (_this_currentDeclarationOwner = _this.currentDeclarationOwner) == null ? void 0 : _this_currentDeclarationOwner.id) != null ? _this_currentDeclarationOwner_id : 0;
+                    for(var _iterator = _create_for_of_iterator_helper_loose(symbols), _step; !(_step = _iterator()).done;){
+                        var symbol = _step.value;
+                        _this._referenceDeclaration(from, symbol.astNode);
+                    }
+                };
+                var propDeclarations = new Map();
+                for(var _iterator = _create_for_of_iterator_helper_loose([].concat(io.attributeStructs, io.varyingStructs, io.mrtStructs)), _step; !(_step = _iterator()).done;){
+                    var struct = _step.value;
+                    for(var _iterator1 = _create_for_of_iterator_helper_loose(struct.propList), _step1; !(_step1 = _iterator1()).done;){
+                        var prop = _step1.value;
+                        propDeclarations.set(prop, struct);
+                    }
+                }
+                context.onReferenceStructProps = function(props) {
+                    var _this_currentDeclarationOwner;
+                    var _this_currentDeclarationOwner_id;
+                    var from = (_this_currentDeclarationOwner_id = (_this_currentDeclarationOwner = _this.currentDeclarationOwner) == null ? void 0 : _this_currentDeclarationOwner.id) != null ? _this_currentDeclarationOwner_id : 0;
+                    for(var _iterator = _create_for_of_iterator_helper_loose(props), _step; !(_step = _iterator()).done;){
+                        var prop = _step.value;
+                        _this._referenceDeclaration(from, propDeclarations.get(prop));
+                    }
+                };
+            }
+            if (coreInfo.unsupportedDeferredDeclarations.length) {
+                throw mapExpandedShaderError(new GSError(GSErrorName.CompilationError, "Deferred inheritance requires exact signatures and cannot resolve a known partial-coverage conflict.", coreInfo.unsupportedDeferredDeclarations[0].astNode.location, ir.source, undefined, "UnsupportedDeferredDeclaration"), ir.source, ir.sourceMap);
+            }
+            return {
+                vertex: this._vertexMain(coreInfo.vertexEntry, shaderData, outerGlobalMacroDeclarations),
+                fragment: this._fragmentMain(coreInfo.fragmentEntry, shaderData, outerGlobalMacroDeclarations)
+            };
+        } finally{
+            this._sourceIR = undefined;
+            this._outerMacroDeclarations = [];
+            this._declarationOwners.clear();
+            context.onReferenceGlobal = undefined;
+            context.onReferenceStructProps = undefined;
+        }
+    };
+    _proto._vertexMain = function _vertexMain(entryInfo, data, outerGlobalMacroDeclarations) {
+        var context = this.context;
+        context.stage = EShaderStage.VERTEX;
+        context.stageEntry = entryInfo.name;
+        // Attribute/varying structs were collected in ShaderCoreInfo
+        // Pre-walk global `#define` values so referenced struct properties emit `attribute`/`varying` declarations.
+        this._preRegisterGlobalMacroRefs(outerGlobalMacroDeclarations);
+        var globalCodeArray = this._globalCodeArray;
+        context.referenceGlobal(entryInfo.name, ESymbolType.FN);
+        this._getGlobalSymbol(globalCodeArray);
+        this._getCustomStruct(context.attributeStructs, globalCodeArray);
+        this._getCustomStruct(context.varyingStructs, globalCodeArray);
+        this._getGlobalMacroDeclarations(outerGlobalMacroDeclarations, globalCodeArray);
+        this.getOtherGlobal(data, globalCodeArray);
+        this._emitDeclarationReferences(globalCodeArray);
+        var globalCode = globalCodeArray.sort(function(a, b) {
+            return a.index - b.index;
+        }).map(function(item) {
+            return item.text;
+        }).join("\n");
+        context.reset(false);
+        this.reset();
+        return globalCode;
+    };
+    _proto._fragmentMain = function _fragmentMain(entryInfo, data, outerGlobalMacroStatements) {
+        var _this = this;
+        var context = this.context;
+        context.stage = EShaderStage.FRAGMENT;
+        context.stageEntry = entryInfo.name;
+        this.prepareFragment(entryInfo, outerGlobalMacroStatements);
+        // Every value-return must preserve early-exit control flow after entry return values are
+        // lowered into fragment outputs.
+        entryInfo.functions.forEach(function(fnSymbol) {
+            var returnType = fnSymbol.astNode.protoType.returnType;
+            var mode = returnType.type === Keyword.VEC4 ? "color" : returnType.typeSpecifier.structDeclarations.some(function(struct) {
+                return context.hasStructRole(struct, ShaderStructRole.Mrt);
+            }) ? "mrt" : undefined;
+            if (mode) {
+                var statements = fnSymbol.astNode.statements;
+                _this._registerFragmentReturns(statements, mode, ParserUtils.lastStatement(statements));
+            }
+        });
+        // Struct-variable identities are already populated from ShaderCoreInfo; just pre-walk macro
+        // refs so struct codegen sees the references.
+        this._preRegisterGlobalMacroRefs(outerGlobalMacroStatements);
+        var globalCodeArray = this._globalCodeArray;
+        context.referenceGlobal(entryInfo.name, ESymbolType.FN);
+        this._getGlobalSymbol(globalCodeArray);
+        this._getCustomStruct(context.varyingStructs, globalCodeArray);
+        this._getCustomStruct(context.mrtStructs, globalCodeArray);
+        this._getGlobalMacroDeclarations(outerGlobalMacroStatements, globalCodeArray);
+        this.getOtherGlobal(data, globalCodeArray);
+        this._emitDeclarationReferences(globalCodeArray);
+        var globalCode = globalCodeArray.sort(function(a, b) {
+            return a.index - b.index;
+        }).map(function(item) {
+            return item.text;
+        }).join("\n");
+        context.reset();
+        this.reset();
+        return globalCode;
+    };
+    _proto.prepareFragment = function prepareFragment(entryInfo, outerGlobalMacroStatements) {
+    };
+    /**
+   * Pre-walk `#define` values in global macro declarations and register any
+   * `structVar.prop` member accesses as referenced struct props. This must run before
+   * struct codegen emits the declaration lists (`attribute …`, `varying …`, `MRT …`),
+   * otherwise properties used only from macros would be missing from the output.
+   */ _proto._preRegisterGlobalMacroRefs = function _preRegisterGlobalMacroRefs(macros) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(macros), _step; !(_step = _iterator()).done;){
+            var macro = _step.value;
+            this._walkMacroDefineTokens(macro.children);
+        }
+    };
+    _proto._walkMacroDefineTokens = function _walkMacroDefineTokens(children) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(children), _step; !(_step = _iterator()).done;){
+            var child = _step.value;
+            if (_instanceof(child, ASTNode.MacroDefine)) {
+                // Codegen the value once so the enclosed `visitPostfixExpression` calls
+                // register their struct-prop references. The returned string is discarded
+                // — the real emit happens later in `_getGlobalMacroDeclarations`.
+                if (child.valueExpression) child.valueExpression.codeGen(this);
+            } else if (_instanceof(child, TreeNode)) {
+                var previous = this._currentDeclaration;
+                if (_instanceof(child, ASTNode.FunctionDefinition)) this._currentDeclaration = child;
+                this._walkMacroDefineTokens(child.children);
+                this._currentDeclaration = previous;
+            }
+        }
+    };
+    _proto._registerFragmentReturns = function _registerFragmentReturns(node, mode, terminal) {
+        if (_instanceof(node, ASTNode.JumpStatement) && node.children.length === 3) {
+            this.context.registerFragmentReturn(node, mode);
+            if (node === terminal) this.context.registerTerminalInterfaceReturn(node);
+            return;
+        }
+        for(var _iterator = _create_for_of_iterator_helper_loose(node.children), _step; !(_step = _iterator()).done;){
+            var child = _step.value;
+            if (_instanceof(child, TreeNode)) this._registerFragmentReturns(child, mode, terminal);
+        }
+    };
+    _proto._getGlobalSymbol = function _getGlobalSymbol(out) {
+        var context = this.context;
+        // Set iteration includes dependencies discovered while generating earlier declarations.
+        for(var _iterator = _create_for_of_iterator_helper_loose(context._referencedGlobalSymbols), _step; !(_step = _iterator()).done;){
+            var sm = _step.value;
+            this._currentDeclaration = sm.astNode;
+            var codeGenResult = sm.astNode.codeGen(this);
+            this._currentDeclaration = undefined;
+            if (!codeGenResult) continue;
+            var text = codeGenResult + (sm.type === ESymbolType.VAR ? ";" : "");
+            if (!sm.isInMacroBranch) {
+                var segment = {
+                    text: this._declaration(text, sm.astNode),
+                    index: sm.astNode.location.start.index
+                };
+                out.push(segment);
+                if (_instanceof(sm.astNode, ASTNode.StructSpecifier)) this._structCodeSegments.set(sm.astNode, segment);
+                if (_instanceof(sm.astNode, ASTNode.VariableDeclaration)) this._variableCodeSegments.set(sm.astNode, segment);
+            }
+        }
+        this._getForwardDeclarations(out);
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(this._deferredPrototypes.values()), _step1; !(_step1 = _iterator1()).done;){
+            var segment1 = _step1.value;
+            out.push(segment1);
+        }
+        for(var _iterator2 = _create_for_of_iterator_helper_loose(this._forwardFunctionDeclarations), _step2; !(_step2 = _iterator2()).done;){
+            var _step_value = _step2.value, definition = _step_value[0], text1 = _step_value[1];
+            if (!definition.isInMacroBranch) out.push({
+                text: text1,
+                index: definition.location.start.index
+            });
+        }
+    };
+    _proto.referenceFunction = function referenceFunction(symbol, referenceIndex, branch) {
+        var _this = this;
+        CodeGenVisitor.prototype.referenceFunction.call(this, symbol, referenceIndex, branch);
+        var definition = symbol.astNode;
+        var declarations = this._forwardFunctionDeclarations;
+        if (symbol.ident === this.context.stageEntry) return;
+        var candidates = this.context._referencedGlobals[symbol.ident].filter(function(candidate) {
+            return _instanceof(candidate, FnSymbol) && candidate.equal(symbol);
+        });
+        var owner = this._declarationOwners.get(definition);
+        if (owner) {
+            var _this1, _loop = function() {
+                var candidate = _step.value;
+                var replacement = candidate.astNode;
+                var nextOwner = _this1._declarationOwners.get(replacement);
+                if (!nextOwner || nextOwner.group !== owner.group || nextOwner.sourceScope <= owner.sourceScope || replacement.location.start.index <= referenceIndex) return "continue";
+                var prototype = replacement.protoType;
+                var anchor = definition.location.start.index;
+                var previous = _this1._deferredPrototypes.get(replacement);
+                if (previous && previous.index <= anchor) return "continue";
+                if (!_this1._isContextIndependent(prototype) || _this1._hasDeclarationContextBarrier(anchor, prototype.location.start.index, false)) {
+                    _this1._unsupportedForwardDeclaration(prototype);
+                }
+                var outer = _this1._outerMacroDeclarations.find(function(macro) {
+                    return macro.location.start.index <= anchor && macro.location.end.index >= definition.location.end.index;
+                });
+                var _outer_location_start_index;
+                var typeAnchor = (_outer_location_start_index = outer == null ? void 0 : outer.location.start.index) != null ? _outer_location_start_index : anchor;
+                _this1._prepareForwardTypes(prototype.returnType.typeSpecifier.structDeclarations, anchor, typeAnchor);
+                var _prototype_parameterList;
+                for(var _iterator = _create_for_of_iterator_helper_loose((_prototype_parameterList = prototype.parameterList) != null ? _prototype_parameterList : []), _step1; !(_step1 = _iterator()).done;){
+                    var parameter = _step1.value;
+                    var _parameter_typeInfo;
+                    var _parameter_typeInfo_structDeclarations;
+                    _this1._prepareForwardTypes((_parameter_typeInfo_structDeclarations = (_parameter_typeInfo = parameter.typeInfo) == null ? void 0 : _parameter_typeInfo.structDeclarations) != null ? _parameter_typeInfo_structDeclarations : [], anchor, typeAnchor);
+                }
+                // Selection is determined at the later definition, so the prototype must not replay its guard here.
+                _this1._deferredPrototypes.set(replacement, {
+                    text: _this1._declaration("" + prototype.codeGen(_this1) + ";", replacement, false),
+                    index: typeAnchor
+                });
+            };
+            for(var _iterator = _create_for_of_iterator_helper_loose(candidates), _step; !(_step = _iterator()).done;)_this1 = this, _loop();
+            return;
+        }
+        if (candidates.some(function(candidate) {
+            return candidate.astNode === definition;
+        })) return;
+        var compatible = candidates.filter(function(candidate) {
+            return _this._canBranchesOverlap(candidate.branchSignature, branch);
+        });
+        var preceding = compatible.filter(function(candidate) {
+            return candidate.astNode.location.start.index < referenceIndex;
+        });
+        if (canInheritanceBranchesCover(preceding.map(function(candidate) {
+            return candidate.branchSignature;
+        }), branch)) return;
+        var replacement = compatible.find(function(candidate) {
+            return candidate.astNode.location.start.index > referenceIndex;
+        });
+        if (replacement) {
+            // An inherited helper can call a declaration whose overriding body occurs later. Keep the
+            // original declaration's macro/type context and emit only the final backend signature there.
+            var prototype = replacement.astNode.protoType;
+            var anchor = definition.location.start.index;
+            var text = "" + prototype.codeGen(this) + ";";
+            var signature = this._getForwardSignature(prototype);
+            for(var _iterator1 = _create_for_of_iterator_helper_loose(candidates), _step1; !(_step1 = _iterator1()).done;){
+                var candidate = _step1.value;
+                if (this._canBranchesOverlap(candidate.branchSignature, symbol.branchSignature) && this._getForwardSignature(candidate.astNode.protoType) !== signature) {
+                    this._unsupportedForwardDeclaration(candidate.astNode.protoType);
+                }
+            }
+            if (declarations.has(definition)) return;
+            if (!this._isContextIndependent(prototype) || this._hasDeclarationContextBarrier(anchor, prototype.location.start.index, false)) {
+                this._unsupportedForwardDeclaration(prototype);
+            }
+            var outerMacro = this._outerMacroDeclarations.find(function(macro) {
+                return macro.location.start.index <= anchor && macro.location.end.index >= definition.location.end.index;
+            });
+            var _outerMacro_location_start_index;
+            var typeAnchor = (_outerMacro_location_start_index = outerMacro == null ? void 0 : outerMacro.location.start.index) != null ? _outerMacro_location_start_index : anchor;
+            this._prepareForwardTypes(prototype.returnType.typeSpecifier.structDeclarations, anchor, typeAnchor);
+            var _prototype_parameterList;
+            for(var _iterator2 = _create_for_of_iterator_helper_loose((_prototype_parameterList = prototype.parameterList) != null ? _prototype_parameterList : []), _step2; !(_step2 = _iterator2()).done;){
+                var parameter = _step2.value;
+                var _parameter_typeInfo;
+                if (_instanceof(parameter.astNode, ASTNode.ParameterDeclaration) && parameter.astNode.symbol && this.context.getStructVarRole([
+                    parameter.astNode.symbol
+                ])) {
+                    continue;
+                }
+                var _parameter_typeInfo_structDeclarations;
+                this._prepareForwardTypes((_parameter_typeInfo_structDeclarations = (_parameter_typeInfo = parameter.typeInfo) == null ? void 0 : _parameter_typeInfo.structDeclarations) != null ? _parameter_typeInfo_structDeclarations : [], anchor, typeAnchor);
+            }
+            declarations.set(definition, text);
+        }
+    };
+    _proto._getForwardSignature = function _getForwardSignature(prototype) {
+        var _this, _loop = function() {
+            var parameter = _step.value;
+            var declaration = parameter.astNode;
+            if (_instanceof(declaration, ASTNode.ParameterDeclaration) && declaration.symbol && _this.context.getStructVarRole([
+                declaration.symbol
+            ])) return "continue";
+            var tokens = [];
+            var visit = function(node) {
+                if (_instanceof(node, BaseToken)) {
+                    if (node !== parameter.ident && node.type !== Keyword.IN) tokens.push(node.lexeme);
+                } else {
+                    node.children.forEach(visit);
+                }
+            };
+            visit(declaration);
+            var text = tokens.join(" ");
+            if (text !== "void") parameters.push(text);
+        };
+        var parameters = [];
+        var _prototype_parameterList;
+        for(var _iterator = _create_for_of_iterator_helper_loose((_prototype_parameterList = prototype.parameterList) != null ? _prototype_parameterList : []), _step; !(_step = _iterator()).done;)_this = this, _loop();
+        return prototype.returnType.codeGen(this) + "(" + parameters.join(",") + ")";
+    };
+    _proto._canBranchesOverlap = function _canBranchesOverlap(left, right) {
+        return getLexicalDeclarationCoexistence(left, right) !== "exclusive" && !canInheritanceBranchesCover([], [].concat(left, right));
+    };
+    _proto.visitVariableIdentifier = function visitVariableIdentifier(node) {
+        var _this, _loop = function() {
+            var _this1, _loop = function() {
+                var candidate = _step1.value;
+                if (candidate.astNode.location.start.index <= node.location.start.index) return "continue";
+                if (owner) {
+                    var nextOwner = _this1._declarationOwners.get(candidate.astNode);
+                    if (!nextOwner || nextOwner.group !== owner.group || nextOwner.sourceScope <= owner.sourceScope) return "continue";
+                }
+                var declaration = candidate.astNode;
+                if (!_instanceof(candidate, VarSymbol) || !candidate.isUniform || !_instanceof(declaration, ASTNode.VariableDeclaration)) {
+                    _this1._unsupportedForwardDeclaration(declaration);
+                }
+                var macro = _this1._outerMacroDeclarations.find(function(item) {
+                    return item.location.start.index <= declaration.location.start.index && item.location.end.index >= declaration.location.end.index;
+                });
+                var _macro_location_end_index;
+                if (!_this1._isContextIndependent(declaration) || _this1._hasDeclarationContextBarrier(anchor, (_macro_location_end_index = macro == null ? void 0 : macro.location.end.index) != null ? _macro_location_end_index : declaration.location.end.index, true)) {
+                    _this1._unsupportedForwardDeclaration(declaration);
+                }
+                _this1._prepareForwardTypes(candidate.dataType.structDeclarations, anchor);
+                var _this__forwardVariableIndices_get;
+                _this1._forwardVariableIndices.set(declaration, Math.min((_this__forwardVariableIndices_get = _this1._forwardVariableIndices.get(declaration)) != null ? _this__forwardVariableIndices_get : Infinity, anchor));
+            };
+            var symbol = _step.value;
+            var _this_context__referencedGlobals_symbol_ident;
+            if (!_instanceof(symbol, VarSymbol) || !symbol.isUniform) return "continue";
+            var candidates = (_this_context__referencedGlobals_symbol_ident = _this.context._referencedGlobals[symbol.ident]) == null ? void 0 : _this_context__referencedGlobals_symbol_ident.filter(function(candidate) {
+                return _instanceof(candidate, VarSymbol);
+            });
+            var owner = _this._declarationOwners.get(symbol.astNode);
+            if (!candidates || !owner && candidates.includes(symbol)) return "continue";
+            var preceding = candidates.filter(function(candidate) {
+                return candidate.astNode.location.start.index < node.location.start.index;
+            });
+            if (!owner && canInheritanceBranchesCover(preceding.map(function(candidate) {
+                return candidate.branchSignature;
+            }), node._branch)) return "continue";
+            var oldMacro = _this._outerMacroDeclarations.find(function(macro) {
+                return macro.location.start.index <= symbol.astNode.location.start.index && macro.location.end.index >= symbol.astNode.location.end.index;
+            });
+            var _oldMacro_location_start_index;
+            var anchor = (_oldMacro_location_start_index = oldMacro == null ? void 0 : oldMacro.location.start.index) != null ? _oldMacro_location_start_index : symbol.astNode.location.start.index;
+            for(var _iterator = _create_for_of_iterator_helper_loose(candidates), _step1; !(_step1 = _iterator()).done;)_this1 = _this, _loop();
+        };
+        var code = CodeGenVisitor.prototype.visitVariableIdentifier.call(this, node);
+        for(var _iterator = _create_for_of_iterator_helper_loose(node.resolvedSymbols()), _step; !(_step = _iterator()).done;)_this = this, _loop();
+        return code;
+    };
+    _proto._getForwardDeclarations = function _getForwardDeclarations(out) {
+        var _this, _loop = function() {
+            var _step_value = _step1.value, declaration = _step_value[0], index = _step_value[1];
+            var owner = _this._declarationOwners.get(declaration);
+            var macro = _this._outerMacroDeclarations.find(function(item) {
+                return item.location.start.index <= declaration.location.start.index && item.location.end.index >= declaration.location.end.index;
+            });
+            if (!macro) {
+                var previous = _instanceof(declaration, ASTNode.StructSpecifier) ? _this._structCodeSegments.get(declaration) : _this._variableCodeSegments.get(declaration);
+                if (previous) {
+                    if (owner) previous.text = _this._declaration("", declaration);
+                    else out.splice(out.indexOf(previous), 1);
+                }
+                out.push({
+                    text: code(declaration),
+                    index: index
+                });
+            } else if (owner) {
+                out.push({
+                    text: code(declaration),
+                    index: index
+                });
+            } else {
+                var group = guarded.get(macro);
+                if (!group) guarded.set(macro, group = {
+                    index: index,
+                    declarations: []
+                });
+                group.index = Math.min(group.index, index);
+                group.declarations.push(declaration);
+            }
+        };
+        var _this1 = this;
+        var guarded = new Map();
+        var declarations = Array.from(this._forwardStructIndices);
+        for(var _iterator = _create_for_of_iterator_helper_loose(this._forwardVariableIndices), _step; !(_step = _iterator()).done;){
+            var entry = _step.value;
+            declarations.push(entry);
+        }
+        var code = function(declaration) {
+            return _this1._declaration(declaration.codeGen(_this1) + (_instanceof(declaration, ASTNode.VariableDeclaration) ? ";" : ""), declaration, false);
+        };
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(declarations), _step1; !(_step1 = _iterator1()).done;)_this = this, _loop();
+        for(var _iterator2 = _create_for_of_iterator_helper_loose(guarded), _step2; !(_step2 = _iterator2()).done;){
+            var _step_value = _step2.value, macro = _step_value[0], group = _step_value[1];
+            var segments = macro.macroExpressions.map(function(item) {
+                return {
+                    text: _instanceof(item, BaseToken) ? item.lexeme : item.codeGen(_this1),
+                    index: item.location.start.index
+                };
+            });
+            for(var _iterator3 = _create_for_of_iterator_helper_loose(group.declarations), _step3; !(_step3 = _iterator3()).done;){
+                var declaration = _step3.value;
+                segments.push({
+                    text: code(declaration),
+                    index: declaration.location.start.index
+                });
+            }
+            out.push({
+                text: segments.sort(function(a, b) {
+                    return a.index - b.index;
+                }).map(function(item) {
+                    return item.text;
+                }).join("\n"),
+                index: group.index
+            });
+        }
+    };
+    _proto.visitTypeSpecifier = function visitTypeSpecifier(node) {
+        var _this, _loop = function() {
+            var type = _step.value;
+            if (!type.ident || _this.context.getStructRole([
+                type
+            ])) return "continue";
+            // A function-local struct can shadow a global name without participating in inheritance.
+            var parent = type.parent;
+            while(parent && !_instanceof(parent, ASTNode.GlobalDeclaration) && !_instanceof(parent, ASTNode.FunctionDefinition)){
+                parent = parent.parent;
+            }
+            if (_instanceof(parent, ASTNode.FunctionDefinition)) return "continue";
+            _this.context.referenceGlobal(type.ident.lexeme, ESymbolType.STRUCT);
+            var final = _this.context._referencedGlobals[type.ident.lexeme];
+            var owner = _this._declarationOwners.get(type);
+            if (!owner && final.some(function(symbol) {
+                return symbol.astNode === type;
+            })) return "continue";
+            var oldMacro = _this._outerMacroDeclarations.find(function(item) {
+                return item.location.start.index <= type.location.start.index && item.location.end.index >= type.location.end.index;
+            });
+            var _oldMacro_location_start_index;
+            _this._prepareForwardTypes(final.filter(function(symbol) {
+                if (!owner) return true;
+                var nextOwner = _this1._declarationOwners.get(symbol.astNode);
+                return (nextOwner == null ? void 0 : nextOwner.group) === owner.group && nextOwner.sourceScope > owner.sourceScope;
+            }).map(function(symbol) {
+                return symbol.astNode;
+            }).filter(function(item) {
+                return _instanceof(item, ASTNode.StructSpecifier);
+            }), (_oldMacro_location_start_index = oldMacro == null ? void 0 : oldMacro.location.start.index) != null ? _oldMacro_location_start_index : type.location.start.index);
+        };
+        var _this1 = this;
+        var call = _instanceof(node.parent, ASTNode.FunctionIdentifier) ? node.parent.parent : undefined;
+        if (_instanceof(call, ASTNode.FunctionCallGeneric) && _instanceof(call.fnSymbol, FnSymbol)) {
+            return CodeGenVisitor.prototype.visitTypeSpecifier.call(this, node);
+        }
+        for(var _iterator = _create_for_of_iterator_helper_loose(node.structDependencies), _step; !(_step = _iterator()).done;)_this = this, _loop();
+        return CodeGenVisitor.prototype.visitTypeSpecifier.call(this, node);
+    };
+    _proto._prepareForwardTypes = function _prepareForwardTypes(types, anchor, hoistAnchor) {
+        var _this, _loop = function() {
+            var type = _step.value;
+            var _this__forwardStructIndices_get;
+            if (((_this__forwardStructIndices_get = _this._forwardStructIndices.get(type)) != null ? _this__forwardStructIndices_get : Infinity) <= anchor) return "continue";
+            if (type.ident) {
+                _this.context.referenceGlobal(type.ident.lexeme, ESymbolType.STRUCT);
+                var final = _this.context._referencedGlobals[type.ident.lexeme];
+                if (!final.some(function(symbol) {
+                    return symbol.astNode === type;
+                })) {
+                    _this._prepareForwardTypes(final.map(function(symbol) {
+                        return symbol.astNode;
+                    }).filter(function(item) {
+                        return _instanceof(item, ASTNode.StructSpecifier);
+                    }), anchor, hoistAnchor);
+                    return "continue";
+                }
+            }
+            var needsHoist = type.location.start.index > anchor;
+            var macro = _this._outerMacroDeclarations.find(function(item) {
+                return item.location.start.index <= type.location.start.index && item.location.end.index >= type.location.end.index;
+            });
+            var _macro_location_end_index;
+            if (needsHoist && (!_this._isContextIndependent(type) || _this._hasDeclarationContextBarrier(hoistAnchor, (_macro_location_end_index = macro == null ? void 0 : macro.location.end.index) != null ? _macro_location_end_index : type.location.end.index, true))) {
+                _this._unsupportedForwardDeclaration(type);
+            }
+            var dependencyAnchor = needsHoist ? hoistAnchor : type.location.start.index;
+            for(var _iterator = _create_for_of_iterator_helper_loose(type.propList), _step1; !(_step1 = _iterator()).done;){
+                var property = _step1.value;
+                _this._prepareForwardTypes(property.typeInfo.structDeclarations, dependencyAnchor);
+            }
+            if (needsHoist) _this._forwardStructIndices.set(type, hoistAnchor);
+        };
+        if (hoistAnchor === void 0) hoistAnchor = anchor;
+        if (this.context.getStructRole(types)) return;
+        for(var _iterator = _create_for_of_iterator_helper_loose(types), _step; !(_step = _iterator()).done;)_this = this, _loop();
+    };
+    _proto._isContextIndependent = function _isContextIndependent(node) {
+        var _this = this;
+        if (_instanceof(node, ASTNode.VariableIdentifier) || _instanceof(node, ASTNode.MacroCallSymbol) || _instanceof(node, ASTNode.MacroCallFunction)) return false;
+        if (_instanceof(node, ASTNode.TypeSpecifier) && node.isCustom && !node.structDeclarations.length) return false;
+        return node.children.every(function(child) {
+            return _instanceof(child, TreeNode) ? _this._isContextIndependent(child) : child.type < Keyword.MACRO_IF || child.type > Keyword.MACRO_DEFINE_PARAMS;
+        });
+    };
+    _proto._hasDeclarationContextBarrier = function _hasDeclarationContextBarrier(start, end, includeMacros) {
+        var visit = function(node, inFunction) {
+            if (inFunction === void 0) inFunction = false;
+            if (node.location.end.index <= start || node.location.start.index >= end) return false;
+            if (_instanceof(node, ASTNode.PrecisionSpecifier) && !inFunction) return true;
+            if (includeMacros && _instanceof(node, ASTNode.MacroDefine)) return true;
+            inFunction || (inFunction = _instanceof(node, ASTNode.FunctionDefinition));
+            return node.children.some(function(child) {
+                return _instanceof(child, TreeNode) ? visit(child, inFunction) : includeMacros && child.location.start.index > start && child.location.start.index < end && (child.type === Keyword.MACRO_UNDEF || child.type === Keyword.MACRO_DEFINE_EXPRESSION);
+            });
+        };
+        return visit(this._sourceIR.program);
+    };
+    _proto._unsupportedForwardDeclaration = function _unsupportedForwardDeclaration(node) {
+        var ir = this._sourceIR;
+        throw mapExpandedShaderError(new GSError(GSErrorName.CompilationError, "Inherited declarations require incompatible forward signatures or depend on a later macro or precision context.", node.location, ir.source, undefined, "UnsupportedForwardDeclaration"), ir.source, ir.sourceMap);
+    };
+    _proto._getCustomStruct = function _getCustomStruct(structNodes, out) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(structNodes), _step; !(_step = _iterator()).done;){
+            var node = _step.value;
+            var text = node.codeGen(this);
+            if (!node.isInMacroBranch) {
+                out.push({
+                    text: this._declaration(text, node),
+                    index: node.location.start.index
+                });
+            }
+        }
+    };
+    _proto._getGlobalMacroDeclarations = function _getGlobalMacroDeclarations(macros, out) {
+        var _this = this;
+        var context = this.context;
+        var referencedGlobalMacroASTs = context._referencedGlobalMacroASTs;
+        referencedGlobalMacroASTs.length = 0;
+        for(var _iterator = _create_for_of_iterator_helper_loose(context._referencedGlobalSymbols), _step; !(_step = _iterator()).done;){
+            var symbol = _step.value;
+            if (symbol.isInMacroBranch) referencedGlobalMacroASTs.push(symbol.astNode);
+        }
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(macros), _step1; !(_step1 = _iterator1()).done;){
+            var macro = _step1.value;
+            var text = void 0;
+            var child = macro.children[0];
+            if (_instanceof(child, ASTNode.GlobalMacroIfStatement)) {
+                var _result;
+                var result = [];
+                (_result = result).push.apply(_result, [].concat(macro.macroExpressions.map(function(item) {
+                    return {
+                        text: _instanceof(item, BaseToken) ? item.lexeme : item.codeGen(_this),
+                        index: item.location.start.index
+                    };
+                })));
+                this._visitGlobalMacroIfStatement(child, result);
+                text = result.sort(function(a, b) {
+                    return a.index - b.index;
+                }).map(function(item) {
+                    return item.text;
+                }).join("\n");
+            } else if (_instanceof(child, BaseToken) && child.type === Keyword.MACRO_DEFINE_EXPRESSION) {
+                // Legacy opaque `#define` — its lexeme is the complete directive text,
+                // newlines included; emit verbatim.
+                text = child.lexeme;
+            } else {
+                text = macro.codeGen(this);
+            }
+            out.push({
+                text: text,
+                index: macro.location.start.index
+            });
+        }
+    };
+    _proto._visitGlobalMacroIfStatement = function _visitGlobalMacroIfStatement(node, out) {
+        var children = node.children;
+        for(var i = 0; i < children.length; i++){
+            var child = children[i];
+            if (_instanceof(child, ASTNode.PrecisionSpecifier)) {
+                out.push({
+                    text: child.codeGen(this),
+                    index: child.location.start.index
+                });
+            } else if (_instanceof(child, ASTNode.FunctionDefinition)) {
+                var text = this.context._referencedGlobalMacroASTs.indexOf(child) !== -1 ? this.getCachedCode(child) : this._forwardFunctionDeclarations.get(child);
+                if (text !== undefined) {
+                    out.push({
+                        text: this._declaration(text, child),
+                        index: child.location.start.index
+                    });
+                }
+            } else if (_instanceof(child, ASTNode.StructSpecifier)) {
+                if (this._forwardStructIndices.has(child)) {
+                    var text1 = this._declaration("", child);
+                    if (text1) out.push({
+                        text: text1,
+                        index: child.location.start.index
+                    });
+                    continue;
+                }
+                var context = this.context;
+                var stage = context.stage;
+                if (context._referencedGlobalMacroASTs.indexOf(child) !== -1 || (stage === EShaderStage.VERTEX ? context.hasStructRole(child, ShaderStructRole.Attribute) || context.hasStructRole(child, ShaderStructRole.Varying) : context.hasStructRole(child, ShaderStructRole.Varying) || context.hasStructRole(child, ShaderStructRole.Mrt))) {
+                    var _this_getCachedCode;
+                    out.push({
+                        text: this._declaration((_this_getCachedCode = this.getCachedCode(child)) != null ? _this_getCachedCode : "", child),
+                        index: child.location.start.index
+                    });
+                }
+            } else if (_instanceof(child, ASTNode.VariableDeclarationList)) {
+                var variableDeclarations = child.variableDeclarations;
+                for(var i1 = 0; i1 < variableDeclarations.length; i1++){
+                    var variableDeclaration = variableDeclarations[i1];
+                    if (this.context._referencedGlobalMacroASTs.indexOf(variableDeclaration) !== -1) {
+                        var _this_getCachedCode1;
+                        out.push({
+                            text: this._declaration(this._forwardVariableIndices.has(variableDeclaration) ? "" : "" + ((_this_getCachedCode1 = this.getCachedCode(variableDeclaration)) != null ? _this_getCachedCode1 : "") + ";", variableDeclaration),
+                            index: variableDeclaration.location.start.index
+                        });
+                    }
+                }
+            }
+            if (_instanceof(child, TreeNode)) {
+                this._visitGlobalMacroIfStatement(child, out);
+            }
+        }
+    };
+    _proto._referenceDeclaration = function _referenceDeclaration(from, node) {
+        var owner = this._declarationOwners.get(node);
+        if (!owner) return;
+        var targets = this._declarationReferences.get(from);
+        if (!targets) this._declarationReferences.set(from, targets = new Set());
+        targets.add(owner.id);
+    };
+    _proto._emitDeclarationReferences = function _emitDeclarationReferences(out) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(this._declarationReferences), _step; !(_step = _iterator()).done;){
+            var _step_value = _step.value, from = _step_value[0], targets = _step_value[1];
+            for(var _iterator1 = _create_for_of_iterator_helper_loose(targets), _step1; !(_step1 = _iterator1()).done;){
+                var to = _step1.value;
+                out.push({
+                    text: ShaderInstructionEncoder.reference(from, to),
+                    index: -1
+                });
+            }
+        }
+    };
+    _proto._declaration = function _declaration(text, node, activate) {
+        if (activate === void 0) activate = true;
+        return ShaderInstructionEncoder.declaration(text, this._declarationOwners.get(node), activate);
+    };
+    _create_class(GLESVisitor, [
+        {
+            key: "currentDeclarationOwner",
+            get: /** Ownership of the declaration currently generating dependencies. @internal */ function get() {
+                return this._currentDeclaration && this._declarationOwners.get(this._currentDeclaration);
+            }
+        }
+    ]);
+    return GLESVisitor;
+}(CodeGenVisitor);
+
+var GLES100Visitor = /*#__PURE__*/ function(GLESVisitor) {
+    _inherits(GLES100Visitor, GLESVisitor);
+    function GLES100Visitor() {
+        return GLESVisitor.apply(this, arguments) || this;
+    }
+    var _proto = GLES100Visitor.prototype;
+    _proto.getAttributeProp = function getAttributeProp(prop) {
+        return "attribute " + prop.typeInfo.typeLexeme + " " + prop.ident.lexeme + ";";
+    };
+    _proto.getVaryingProp = function getVaryingProp(prop) {
+        return "varying " + prop.typeInfo.typeLexeme + " " + prop.ident.lexeme + ";";
+    };
+    _proto.getMRTProp = function getMRTProp() {
+        return "";
+    };
+    _proto.visitPostfixExpression = function visitPostfixExpression(node) {
+        var children = node.children;
+        var postExpr = children[0];
+        var context = this.context;
+        var directRoot = _instanceof(postExpr, ASTNode.PostfixExpression) ? ParserUtils.unwrapBareIdentifier(postExpr, {
+            allowParens: true
+        }) : undefined;
+        var _directRoot_resolvedValueSymbols;
+        var directSymbols = (_directRoot_resolvedValueSymbols = directRoot == null ? void 0 : directRoot.resolvedValueSymbols()) != null ? _directRoot_resolvedValueSymbols : [];
+        var unresolvedName = _instanceof(postExpr, ASTNode.PostfixExpression) ? ParserUtils.extractDirectIdentLexeme(postExpr) : null;
+        var directRole = directRoot ? directSymbols.length ? context.getStructVarRole(directSymbols) : unresolvedName ? context.getUnresolvedStructVarRole(unresolvedName) : undefined : undefined;
+        if (directRole === ShaderStructRole.Mrt) {
+            var propReferenced = children[2];
+            var prop = context.mrtList.find(function(item) {
+                return item.ident.lexeme === propReferenced.lexeme;
+            });
+            // The parser already validated struct fields (UndeclaredStructMember); a miss here is an
+            // already-errored shader, so emit nothing rather than re-report.
+            if (!prop) return "";
+            return "gl_FragData[" + prop.mrtIndex + "]";
+        }
+        return GLESVisitor.prototype.visitPostfixExpression.call(this, node);
+    };
+    _proto.visitJumpStatement = function visitJumpStatement(node) {
+        var mode = this.context.getFragmentReturnMode(node);
+        var terminal = this.context.isTerminalInterfaceReturn(node);
+        if (mode === "mrt") return terminal ? "" : "return;";
+        if (mode === "color") {
+            var expression = node.children[1];
+            var assignment = "gl_FragColor = " + expression.codeGen(this) + ";";
+            return terminal ? assignment : "{ " + assignment + " return; }";
+        }
+        return GLESVisitor.prototype.visitJumpStatement.call(this, node);
+    };
+    return GLES100Visitor;
+}(GLESVisitor);
+
+var V3_GL_FragColor = "GS_glFragColor";
+var V3_GL_FragData = "GS_glFragData";
+var GLES300Visitor = /*#__PURE__*/ function(GLESVisitor) {
+    _inherits(GLES300Visitor, GLESVisitor);
+    function GLES300Visitor() {
+        var _this;
+        _this = GLESVisitor.apply(this, arguments) || this, _this._outputDeclarations = new Map(), _this._fragDataArrayRequired = false, _this._fragDataIndices = new Map(), _this._scannedFragmentFunctions = new Set();
+        return _this;
+    }
+    var _proto = GLES300Visitor.prototype;
+    _proto.reset = function reset() {
+        GLESVisitor.prototype.reset.call(this);
+        this._outputDeclarations.clear();
+        this._fragDataArrayRequired = false;
+        this._fragDataIndices.clear();
+        this._scannedFragmentFunctions.clear();
+    };
+    _proto.getOtherGlobal = function getOtherGlobal(data, out) {
+        GLESVisitor.prototype.getOtherGlobal.call(this, data, out);
+        for(var _iterator = _create_for_of_iterator_helper_loose(this._outputDeclarations.values()), _step; !(_step = _iterator()).done;){
+            var output = _step.value;
+            out.push({
+                text: output.unconditional ? output.text : ShaderInstructionEncoder.sharedDeclaration(output.text, Array.from(output.owners.values())),
+                // A source macro block can start at zero and contain the first output use.
+                index: -1
+            });
+        }
+    };
+    _proto.getAttributeProp = function getAttributeProp(prop) {
+        return "in " + prop.typeInfo.typeLexeme + " " + prop.ident.lexeme + ";";
+    };
+    _proto.getVaryingProp = function getVaryingProp(prop) {
+        var qualifier = this.context.stage === EShaderStage.FRAGMENT ? "in" : "out";
+        return qualifier + " " + prop.typeInfo.typeLexeme + " " + prop.ident.lexeme + ";";
+    };
+    _proto.getMRTProp = function getMRTProp(prop) {
+        return "layout(location = " + prop.mrtIndex + ") out vec4 " + prop.ident.lexeme + ";";
+    };
+    _proto.visitFunctionIdentifier = function visitFunctionIdentifier(node) {
+        var children = node.children;
+        var typeSpecifier = children[0];
+        if (typeSpecifier.children.length !== 1 || typeSpecifier.structDependencies.length) {
+            // Struct constructors still need the shared type-dependency visitor.
+            return GLESVisitor.prototype.visitFunctionIdentifier.call(this, node);
+        }
+        var ident = node.lexeme;
+        switch(node.ident){
+            case "texture2D":
+            case "textureCube":
+                ident = "texture";
+                break;
+            case "texture2DProj":
+                ident = "textureProj";
+                break;
+            case "texture2DLodEXT":
+            case "textureCubeLodEXT":
+                ident = "textureLod";
+                break;
+            case "texture2DGradEXT":
+            case "textureCubeGradEXT":
+                ident = "textureGrad";
+                break;
+            case "texture2DProjLodEXT":
+                ident = "textureProjLod";
+                break;
+            case "texture2DProjGradEXT":
+                ident = "textureProjGrad";
+                break;
+        }
+        return ident;
+    };
+    _proto.visitVariableIdentifier = function visitVariableIdentifier(node) {
+        var context = this.context;
+        if (context.stage === EShaderStage.FRAGMENT && node.builtinSemantic === ShaderBuiltinSemantic.FragmentOutput0) {
+            this._registerFragColorVariable();
+            return V3_GL_FragColor;
+        }
+        if (context.stage === EShaderStage.FRAGMENT && node.builtinSemantic === ShaderBuiltinSemantic.FragmentDepth) {
+            return "gl_FragDepth";
+        }
+        if (context.stage === EShaderStage.FRAGMENT && node.builtinSemantic === ShaderBuiltinSemantic.FragmentOutputArray) {
+            this._registerFragDataArray();
+            return V3_GL_FragData;
+        }
+        return GLESVisitor.prototype.visitVariableIdentifier.call(this, node);
+    };
+    _proto.visitPostfixExpression = function visitPostfixExpression(node) {
+        if (!this._fragDataArrayRequired) {
+            var index = this._fragDataIndices.get(node);
+            if (index !== undefined) return this._registerFragDataVariable(index);
+        }
+        return GLESVisitor.prototype.visitPostfixExpression.call(this, node);
+    };
+    _proto.visitJumpStatement = function visitJumpStatement(node) {
+        var mode = this.context.getFragmentReturnMode(node);
+        var terminal = this.context.isTerminalInterfaceReturn(node);
+        if (mode === "mrt") return terminal ? "" : "return;";
+        if (mode === "color") {
+            this._registerFragColorVariable();
+            var expression = node.children[1];
+            var assignment = V3_GL_FragColor + " = " + expression.codeGen(this) + ";";
+            return terminal ? assignment : "{ " + assignment + " return; }";
+        }
+        return GLESVisitor.prototype.visitJumpStatement.call(this, node);
+    };
+    _proto._registerFragColorVariable = function _registerFragColorVariable() {
+        this._registerOutput(V3_GL_FragColor, "out vec4 " + V3_GL_FragColor + ";");
+    };
+    _proto._registerOutput = function _registerOutput(name, text) {
+        var output = this._outputDeclarations.get(name);
+        if (!output) this._outputDeclarations.set(name, output = {
+            text: text,
+            owners: new Map(),
+            unconditional: false
+        });
+        var owner = this.currentDeclarationOwner;
+        if (owner) output.owners.set(owner.id, owner);
+        else output.unconditional = true;
+    };
+    _proto.prepareFragment = function prepareFragment(entryInfo, outerGlobalMacroStatements) {
+        var pending = entryInfo.functions.slice();
+        while(pending.length){
+            var _pending;
+            var fn = pending.pop();
+            if (this._scannedFragmentFunctions.has(fn)) continue;
+            this._scannedFragmentFunctions.add(fn);
+            this._scanFragmentOutputs(fn.astNode);
+            (_pending = pending).push.apply(_pending, [].concat(fn.calledFunctions));
+        }
+        for(var _iterator = _create_for_of_iterator_helper_loose(outerGlobalMacroStatements), _step; !(_step = _iterator()).done;){
+            var macro = _step.value;
+            this._scanFragmentOutputs(macro);
+        }
+    };
+    _proto._scanFragmentOutputs = function _scanFragmentOutputs(node) {
+        if (_instanceof(node, ASTNode.PostfixExpression) && node.children.length === 4) {
+            var _ParserUtils_unwrapBareIdentifier;
+            var base = node.children[0];
+            var index = node.children[2];
+            if (_instanceof(base, TreeNode) && _instanceof(index, TreeNode) && ((_ParserUtils_unwrapBareIdentifier = ParserUtils.unwrapBareIdentifier(base, {
+                allowParens: true
+            })) == null ? void 0 : _ParserUtils_unwrapBareIdentifier.builtinSemantic) === ShaderBuiltinSemantic.FragmentOutputArray) {
+                var value = ParserUtils.constIntegerValue(index);
+                if (value === undefined || value < 0) this._fragDataArrayRequired = true;
+                else this._fragDataIndices.set(node, value);
+                this._scanFragmentOutputs(index);
+                return;
+            }
+        }
+        if (_instanceof(node, ASTNode.VariableIdentifier) && node.builtinSemantic === ShaderBuiltinSemantic.FragmentOutputArray) {
+            this._fragDataArrayRequired = true;
+            return;
+        }
+        for(var _iterator = _create_for_of_iterator_helper_loose(node.children), _step; !(_step = _iterator()).done;){
+            var child = _step.value;
+            if (_instanceof(child, TreeNode)) this._scanFragmentOutputs(child);
+        }
+    };
+    _proto._registerFragDataArray = function _registerFragDataArray() {
+        this._registerOutput(V3_GL_FragData, "layout(location = 0) out vec4 " + V3_GL_FragData + "[gl_MaxDrawBuffers];");
+    };
+    _proto._registerFragDataVariable = function _registerFragDataVariable(index) {
+        var name = "" + V3_GL_FragData + index;
+        this._registerOutput(name, "layout(location = " + index + ") out vec4 " + name + ";");
+        return name;
+    };
+    return GLES300Visitor;
+}(GLESVisitor);
+
+/**
+ * Static internal facade for GLES source generation.
+ * @internal
+ */ var GLESBackend = /*#__PURE__*/ function() {
+    function GLESBackend() {}
+    /**
+   * Generates one GLES program with request-owned visitor state.
+   * @param ir - Request-owned neutral parser IR consumed read-only.
+   * @param coreInfo - Entry and stage-interface facts derived from the same IR.
+   * @param target - GLES language version to emit.
+   * @returns Generated vertex and fragment source.
+   * @internal
+   */ GLESBackend.generate = function generate(ir, coreInfo, target) {
+        var glesInfo = new GLESShaderInfo(ir, coreInfo);
+        if (glesInfo.mrtOutputIssues.length || glesInfo.invalidMrtReturnLocations.length) {
+            Logger.error("MRT outputs require unique non-negative locations, vec4 members, and returns through an assigned struct variable.");
+            return undefined;
+        }
+        if (glesInfo.invalidVaryingReturnLocations.length) {
+            Logger.error("Varying vertex entries must return a struct variable or same-type function result.");
+            return undefined;
+        }
+        if (glesInfo.structMemberOwnerIssues.length) {
+            Logger.error("A struct member reference cannot be lowered safely across runtime macro expansion.");
+            return undefined;
+        }
+        return target === ShaderLanguage.GLSLES100 ? GLESBackend._generateWithPool(GLESBackend._gles100VisitorPool, ir, coreInfo) : GLESBackend._generateWithPool(GLESBackend._gles300VisitorPool, ir, coreInfo);
+    };
+    GLESBackend._generateWithPool = function _generateWithPool(pool, ir, coreInfo) {
+        var visitor = pool.get();
+        try {
+            return visitor.generate(ir, coreInfo);
+        } catch (error) {
+            visitor.dispose();
+            if (!_instanceof(error, GSError)) throw error;
+            Logger.error("" + (error.file ? "" + error.file + ": " : "") + (error.code ? "" + error.code + ": " : "") + error.toString());
+            return undefined;
+        } finally{
+            pool.return(visitor);
+        }
+    };
+    return GLESBackend;
+}();
+GLESBackend._gles100VisitorPool = new ReturnableObjectPool(GLES100Visitor);
+GLESBackend._gles300VisitorPool = new ReturnableObjectPool(GLES300Visitor);
+
+var ShaderSourceParseError = /*#__PURE__*/ function(Error1) {
+    _inherits(ShaderSourceParseError, Error1);
+    function ShaderSourceParseError(errors) {
+        var _this;
+        _this = Error1.call(this, errors.map(function(error) {
+            return error.toString();
+        }).join("\n")) || this, _this.errors = errors;
+        _this.name = "ShaderSourceParseError";
+        return _this;
+    }
+    return ShaderSourceParseError;
+}(_wrap_native_super(Error));
+/**
+ * Rejects a partial ShaderLab structure when source parsing produced errors.
+ * @param result - ShaderLab source-parser result.
+ * @returns Complete parsed ShaderLab structure.
+ * @throws ShaderSourceParseError when structural source diagnostics exist.
+ * @internal
+ */ function requireValidShaderSource(result) {
+    if (result.errors.length) throw new ShaderSourceParseError(result.errors);
+    return result.shaderSource;
+}
+/**
+ * Generates one backend program from a parser-owned pass without reparsing it.
+ * @param parsed - Neutral parser output.
+ * @param vertexEntry - Vertex entry name.
+ * @param fragmentEntry - Fragment entry name.
+ * @param backend - Target GLES language.
+ * @param coreInfo - Optional stage facts already derived from this exact parser result.
+ * @returns Generated program, or `undefined` when parser or entry admission fails.
+ * @internal
+ */ function generateParsedShaderPassData(parsed, vertexEntry, fragmentEntry, backend, coreInfo) {
+    if (parsed.blockingErrors.length) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(parsed.blockingErrors), _step; !(_step = _iterator()).done;){
+            var error = _step.value;
+            Logger.error(error.toString());
+        }
+        return undefined;
+    }
+    if (!parsed.ir) return undefined;
+    var resolvedCoreInfo = coreInfo != null ? coreInfo : ShaderCoreInfo.create(parsed.ir, vertexEntry, fragmentEntry);
+    return generateShaderProgram(parsed.ir, resolvedCoreInfo, backend, parsed.preprocessorExpressions);
+}
+function generateShaderProgram(ir, coreInfo, backend, preprocessorExpressions) {
+    if (!coreInfo.vertexEntry.functions.length) {
+        Logger.error("Vertex entry function '" + coreInfo.vertexEntry.name + "' not found.");
+        return undefined;
+    }
+    if (!coreInfo.fragmentEntry.functions.length) {
+        Logger.error("Fragment entry function '" + coreInfo.fragmentEntry.name + "' not found.");
+        return undefined;
+    }
+    if (coreInfo.vertexEntry.hasDefiniteAmbiguity) {
+        Logger.error("Vertex entry function '" + coreInfo.vertexEntry.name + "' resolves to multiple declarations.");
+        return undefined;
+    }
+    if (coreInfo.fragmentEntry.hasDefiniteAmbiguity) {
+        Logger.error("Fragment entry function '" + coreInfo.fragmentEntry.name + "' resolves to multiple declarations.");
+        return undefined;
+    }
+    if (coreInfo.roleConflicts.length) {
+        Logger.error("A shader IO struct cannot serve multiple stage-interface roles.");
+        return undefined;
+    }
+    var result = GLESBackend.generate(ir, coreInfo, backend);
+    if (result) {
+        result.vertexShaderInstructions = ShaderInstructionEncoder.parse(result.vertex, preprocessorExpressions);
+        result.fragmentShaderInstructions = ShaderInstructionEncoder.parse(result.fragment, preprocessorExpressions);
+        result.vertex = ShaderInstructionEncoder.source(result.vertex);
+        result.fragment = ShaderInstructionEncoder.source(result.fragment);
+    }
+    return result;
+}
+/**
+ * Converts parser-owned render states into JSON-safe precompile data.
+ * @param renderStates - Parsed render-state maps.
+ * @returns Serializable constant and variable maps.
+ * @internal
+ */ function serializeRenderStates(renderStates) {
+    var constantMap = {};
+    for(var key in renderStates.constantMap){
+        var value = renderStates.constantMap[key];
+        if (_instanceof(value, Color)) {
+            constantMap[key] = [
+                value.r,
+                value.g,
+                value.b,
+                value.a
+            ];
+        } else {
+            constantMap[key] = value;
+        }
+    }
+    return {
+        constantMap: constantMap,
+        variableMap: renderStates.variableMap
+    };
+}
+/**
+ * Formats a parser failure with include-source attribution.
+ * @param error - Parser failure.
+ * @returns User-facing error text.
+ * @internal
+ */ function formatShaderError(error) {
+    var text = error.toString();
+    return _instanceof(error, GSError) && error.file ? error.file + ": " + text : text;
+}
+
+/**
+ * Offline-only ShaderLab to `.shaderc` compiler with deterministic validation.
+ *
+ * This class is intentionally excluded from the runtime compiler entry. CLI and bundler adapters import
+ * it from `@galacean/engine-shader-compiler/precompile`.
+ */ var ShaderPrecompiler = /*#__PURE__*/ function() {
+    function ShaderPrecompiler() {
+        this._includeMap = Object.create(null);
+        this._chunkOutputCache = new Map();
+        this._sourceParserObjectPool = new ParserObjectPool();
+        this._parserObjectPool = new ParserObjectPool();
+        this._validatedParser = createValidatedShaderTargetParser(this._parserObjectPool);
+    }
+    var _proto = ShaderPrecompiler.prototype;
+    /**
+   * Replaces the logical include registry used by offline compilation.
+   * @param includeMap - Canonical or normalizable include keys mapped to chunk sources.
+   * @throws Error when multiple keys collide after normalization.
+   */ _proto.setIncludeMap = function setIncludeMap(includeMap) {
+        this._includeMap = normalizeShaderIncludeMap(includeMap);
+        this._chunkOutputCache.clear();
+    };
+    /**
+   * Compiles complete ShaderLab source into a serializable `.shaderc` structure.
+   * @param sourceCode - Complete ShaderLab source.
+   * @param platformTarget - Target GLES language.
+   * @param sourceFile - Optional logical root location used for relative includes and attribution.
+   * @returns Serializable precompiled shader.
+   * @throws Error when structural parsing, pass validation, or backend generation fails.
+   */ _proto.precompile = function precompile(sourceCode, platformTarget, sourceFile) {
+        var _this = this;
+        this._chunkOutputCache.clear();
+        var shaderSource = requireValidShaderSource(ShaderSourceParser.parseStrict(sourceCode, this._sourceParserObjectPool));
+        return {
+            name: shaderSource.name,
+            platformTarget: platformTarget,
+            subShaders: shaderSource.subShaders.map(function(subShader) {
+                return {
+                    name: subShader.name,
+                    tags: subShader.tags,
+                    passes: subShader.passes.map(function(pass) {
+                        if (pass.isUsePass) {
+                            return {
+                                name: pass.name,
+                                isUsePass: true,
+                                tags: pass.tags,
+                                renderStates: serializeRenderStates(pass.renderStates)
+                            };
+                        }
+                        var parsed = parseValidatedShaderPass(pass.contents, _this._includeMap, _this._chunkOutputCache, sourceFile, _this._parserObjectPool, _this._validatedParser, pass.contentScopeStarts);
+                        if (parsed.blockingErrors.length) {
+                            throw new Error([].concat([
+                                'Shader pass "' + shaderSource.name + "." + subShader.name + "." + pass.name + '" precompile failed:'
+                            ], parsed.blockingErrors.map(formatShaderError)).join("\n"));
+                        }
+                        var coreInfo = parsed.ir ? ShaderCoreInfo$1.create(parsed.ir, pass.vertexEntry, pass.fragmentEntry, branchAnalysis.getDeclarationCoexistence, branchAnalysis.getBranchCoverage) : undefined;
+                        var program = generateParsedShaderPassData(parsed, pass.vertexEntry, pass.fragmentEntry, platformTarget, coreInfo);
+                        if (!program) {
+                            throw new Error('Shader pass "' + shaderSource.name + "." + subShader.name + "." + pass.name + '" precompile failed, please check the shader source code.');
+                        }
+                        return {
+                            name: pass.name,
+                            isUsePass: false,
+                            tags: pass.tags,
+                            renderStates: serializeRenderStates(pass.renderStates),
+                            vertexShaderInstructions: program.vertexShaderInstructions,
+                            fragmentShaderInstructions: program.fragmentShaderInstructions
+                        };
+                    })
+                };
+            })
+        };
+    };
+    return ShaderPrecompiler;
+}();
+
+export { ShaderPrecompiler };
+//# sourceMappingURL=precompile.module.js.map