@shaderfrog/core 0.1.0 → 0.1.1

package/dist/ast/manipulate.js

@@ -0,0 +1,328 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * Utility functions to work with ASTs
+ */
+import { parser, generate } from '@shaderfrog/glsl-parser';
+import { visit, } from '@shaderfrog/glsl-parser/ast';
+var log = function () {
+    var _a;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[31m(core.manipulate)\x1b[0m'], __read(args), false));
+};
+export var findVec4Constructor = function (ast) {
+    var parent;
+    var visitors = {
+        function_call: {
+            enter: function (path) {
+                var _a, _b;
+                if (((_a = path.node.identifier) === null || _a === void 0 ? void 0 : _a.specifier).token === 'vec4') {
+                    parent = (_b = path.findParent(function (p) { return 'right' in p.node; })) === null || _b === void 0 ? void 0 : _b.node;
+                    path.skip();
+                }
+            },
+        },
+    };
+    visit(ast, visitors);
+    return parent;
+};
+export var findAssignmentTo = function (ast, assignTo) {
+    var assign;
+    var visitors = {
+        expression_statement: {
+            enter: function (path) {
+                var _a, _b;
+                if (((_b = (_a = path.node.expression) === null || _a === void 0 ? void 0 : _a.left) === null || _b === void 0 ? void 0 : _b.identifier) === assignTo) {
+                    assign = path.node;
+                }
+                path.skip();
+            },
+        },
+    };
+    visit(ast, visitors);
+    return assign;
+};
+export var findDeclarationOf = function (ast, declarationOf) {
+    var declaration;
+    var visitors = {
+        declaration_statement: {
+            enter: function (path) {
+                var _a, _b;
+                var foundDecl = (_b = (_a = path.node.declaration) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b.find(function (decl) { var _a; return ((_a = decl === null || decl === void 0 ? void 0 : decl.identifier) === null || _a === void 0 ? void 0 : _a.identifier) === declarationOf; });
+                if (foundDecl) {
+                    declaration = foundDecl;
+                }
+                path.skip();
+            },
+        },
+    };
+    visit(ast, visitors);
+    return declaration;
+};
+export var from2To3 = function (ast, stage) {
+    var glOut = 'fragmentColor';
+    // TODO: add this back in when there's only one after the merge
+    // ast.program.unshift({
+    //   type: 'preprocessor',
+    //   line: '#version 300 es',
+    //   _: '\n',
+    // });
+    if (stage === 'fragment') {
+        ast.program.unshift(makeStatement("out vec4 ".concat(glOut)));
+    }
+    visit(ast, {
+        function_call: {
+            enter: function (path) {
+                var identifier = path.node.identifier;
+                if (identifier.type === 'identifier' &&
+                    identifier.identifier === 'texture2D') {
+                    identifier.identifier = 'texture';
+                }
+            },
+        },
+        identifier: {
+            enter: function (path) {
+                if (path.node.identifier === 'gl_FragColor') {
+                    path.node.identifier = glOut;
+                }
+            },
+        },
+        keyword: {
+            enter: function (path) {
+                if ((path.node.token === 'attribute' || path.node.token === 'varying') &&
+                    path.findParent(function (path) { return path.node.type === 'declaration_statement'; })) {
+                    path.node.token =
+                        stage === 'vertex' && path.node.token === 'varying' ? 'out' : 'in';
+                }
+            },
+        },
+    });
+};
+export var outDeclaration = function (name) { return ({
+    type: 'declaration_statement',
+    declaration: {
+        type: 'declarator_list',
+        specified_type: {
+            type: 'fully_specified_type',
+            qualifiers: [{ type: 'keyword', token: 'out', whitespace: ' ' }],
+            specifier: {
+                type: 'type_specifier',
+                specifier: { type: 'keyword', token: 'vec4', whitespace: ' ' },
+                quantifier: null,
+            },
+        },
+        declarations: [
+            {
+                type: 'declaration',
+                identifier: {
+                    type: 'identifier',
+                    identifier: name,
+                    whitespace: undefined,
+                },
+                quantifier: null,
+                operator: undefined,
+                initializer: undefined,
+            },
+        ],
+        commas: [],
+    },
+    semi: { type: 'literal', literal: ';', whitespace: '\n    ' },
+}); };
+export var makeStatement = function (stmt) {
+    // log(`Parsing "${stmt}"`);
+    var ast;
+    try {
+        ast = parser.parse("".concat(stmt, ";\n"), { quiet: true });
+    }
+    catch (error) {
+        console.error({ stmt: stmt, error: error });
+        throw new Error("Error parsing stmt \"".concat(stmt, "\": ").concat(error === null || error === void 0 ? void 0 : error.message));
+    }
+    // log(util.inspect(ast, false, null, true));
+    return ast.program[0];
+};
+export var makeFnStatement = function (fnStmt) {
+    var ast;
+    try {
+        ast = parser.parse("\n  void main() {\n      ".concat(fnStmt, ";\n    }"), { quiet: true });
+    }
+    catch (error) {
+        console.error({ fnStmt: fnStmt, error: error });
+        throw new Error("Error parsing fnStmt \"".concat(fnStmt, "\": ").concat(error === null || error === void 0 ? void 0 : error.message));
+    }
+    // log(util.inspect(ast, false, null, true));
+    return ast.program[0].body.statements[0];
+};
+export var makeExpression = function (expr) {
+    var ast;
+    try {
+        ast = parser.parse("void main() {\n          a = ".concat(expr, ";\n        }"), { quiet: true });
+    }
+    catch (error) {
+        console.error({ expr: expr, error: error });
+        throw new Error("Error parsing expr \"".concat(expr, "\": ").concat(error === null || error === void 0 ? void 0 : error.message));
+    }
+    return ast.program[0].body
+        .statements[0].expression.right;
+};
+export var makeExpressionWithScopes = function (expr) {
+    var ast;
+    try {
+        ast = parser.parse("void main() {\n          ".concat(expr, ";\n        }"), { quiet: true });
+    }
+    catch (error) {
+        console.error({ expr: expr, error: error });
+        throw new Error("Error parsing expr \"".concat(expr, "\": ").concat(error === null || error === void 0 ? void 0 : error.message));
+    }
+    // log(util.inspect(ast, false, null, true));
+    return {
+        scope: ast.scopes[1],
+        expression: ast.program[0].body
+            .statements[0].expression,
+    };
+};
+export var makeFnBodyStatementWithScopes = function (body) {
+    var ast;
+    try {
+        ast = parser.parse("void main() {\n".concat(body, "\n        }"), { quiet: true });
+    }
+    catch (error) {
+        console.error({ body: body, error: error });
+        throw new Error("Error parsing body \"".concat(body, "\": ").concat(error === null || error === void 0 ? void 0 : error.message));
+    }
+    // log(util.inspect(ast, false, null, true));
+    return {
+        scope: ast.scopes[1],
+        statements: ast.program[0].body.statements,
+    };
+};
+export var findFn = function (ast, name) {
+    return ast.program.find(function (stmt) {
+        return stmt.type === 'function' && stmt.prototype.header.name.identifier === name;
+    });
+};
+export var returnGlPosition = function (fnName, ast) {
+    return convertVertexMain(fnName, ast, 'vec4', function (assign) { return assign.expression.right; });
+};
+export var returnGlPositionHardCoded = function (fnName, ast, returnType, hardCodedReturn) {
+    return convertVertexMain(fnName, ast, returnType, function () {
+        return makeExpression(hardCodedReturn);
+    });
+};
+export var returnGlPositionVec3Right = function (fnName, ast) {
+    return convertVertexMain(fnName, ast, 'vec3', function (assign) {
+        var found;
+        visit(assign, {
+            function_call: {
+                enter: function (path) {
+                    var _a, _b, _c, _d, _e;
+                    log('returnGlPositionVec3Right', path.node);
+                    var node = path.node;
+                    if (((_b = (_a = node === null || node === void 0 ? void 0 : node.identifier) === null || _a === void 0 ? void 0 : _a.specifier) === null || _b === void 0 ? void 0 : _b.token) === 'vec4' &&
+                        ((_e = (_d = (_c = node === null || node === void 0 ? void 0 : node.args) === null || _c === void 0 ? void 0 : _c[2]) === null || _d === void 0 ? void 0 : _d.token) === null || _e === void 0 ? void 0 : _e.includes('1.'))) {
+                        found = node.args[0];
+                    }
+                },
+            },
+        });
+        if (!found) {
+            console.error(generate(ast));
+            throw new Error('Could not find position assignment to convert to return!');
+        }
+        return found;
+    });
+};
+var convertVertexMain = function (fnName, ast, returnType, generateRight) {
+    var mainReturnVar = "frogOut";
+    var main = findFn(ast, fnName);
+    if (!main) {
+        throw new Error("No ".concat(fnName, " fn found!"));
+    }
+    // Convert the main function to one that returns
+    main.prototype.header.returnType.specifier.specifier.token =
+        returnType;
+    // Find the gl_position assignment line
+    var assign = main.body.statements.find(function (stmt) {
+        var _a;
+        return stmt.type === 'expression_statement' &&
+            ((_a = stmt.expression.left) === null || _a === void 0 ? void 0 : _a.identifier) === 'gl_Position';
+    });
+    if (!assign) {
+        throw new Error("No gl position assign found in main fn!");
+    }
+    var rtnStmt = makeFnStatement("".concat(returnType, " ").concat(mainReturnVar, " = 1.0"));
+    rtnStmt.declaration.declarations[0].initializer =
+        generateRight(assign);
+    main.body.statements.splice(main.body.statements.indexOf(assign), 1, rtnStmt);
+    main.body.statements.push(makeFnStatement("return ".concat(mainReturnVar)));
+};
+export var convert300MainToReturn = function (suffix, ast) {
+    var mainReturnVar = "frogOut_".concat(suffix);
+    // Find the output variable, as in "pc_fragColor" from  "out highp vec4 pc_fragColor;"
+    var outName;
+    ast.program.find(function (line, index) {
+        var _a, _b;
+        var declaration = line === null || line === void 0 ? void 0 : line.declaration;
+        if (
+        // line.type === 'declaration_statement' &&
+        ((_b = (_a = declaration === null || declaration === void 0 ? void 0 : declaration.specified_type) === null || _a === void 0 ? void 0 : _a.qualifiers) === null || _b === void 0 ? void 0 : _b.find(function (n) { return n.token === 'out'; })) &&
+            declaration.specified_type.specifier.specifier.token ===
+                'vec4') {
+            // Remove the out declaration
+            ast.program.splice(index, 1);
+            outName = declaration.declarations[0].identifier.identifier;
+            return true;
+        }
+    });
+    if (!outName) {
+        console.error(generate(ast));
+        throw new Error('No "out vec4" line found in the fragment shader');
+    }
+    ast.program.unshift(makeStatement("vec4 ".concat(mainReturnVar)));
+    visit(ast, {
+        identifier: {
+            enter: function (path) {
+                if (path.node.identifier === outName) {
+                    path.node.identifier = mainReturnVar;
+                    // @ts-ignore
+                    path.node.doNotDescope = true; // hack because this var is in the scope which gets renamed later
+                }
+            },
+        },
+        function: {
+            enter: function (path) {
+                if (path.node.prototype.header.name.identifier === 'main') {
+                    path.node.prototype.header.returnType.specifier
+                        .specifier.token = 'vec4';
+                    path.node.body.statements.push(makeFnStatement("return ".concat(mainReturnVar)));
+                }
+            },
+        },
+    });
+};

package/dist/ast/shader-sections.js

@@ -0,0 +1,256 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { generate } from '@shaderfrog/glsl-parser';
+import { makeStatement } from './manipulate';
+export var emptyShaderSections = function () { return ({
+    precision: [],
+    preprocessor: [],
+    version: [],
+    structs: [],
+    program: [],
+    inStatements: [],
+    outStatements: [],
+    uniforms: [],
+}); };
+var Precision;
+(function (Precision) {
+    Precision[Precision["highp"] = 2] = "highp";
+    Precision[Precision["mediump"] = 1] = "mediump";
+    Precision[Precision["lowp"] = 0] = "lowp";
+})(Precision || (Precision = {}));
+export var higherPrecision = function (p1, p2) {
+    return Precision[p1] > Precision[p2] ? p1 : p2;
+};
+export var dedupeVersions = function (nodes) { return nodes[0]; };
+export var highestPrecisions = function (nodes) {
+    return Object.entries(nodes.reduce(function (precisions, stmt) {
+        var _a;
+        return (__assign(__assign({}, precisions), (_a = {}, _a[stmt.declaration.specifier.specifier.token] = higherPrecision(precisions[stmt.declaration.specifier.specifier.token], stmt.declaration.qualifier.token), _a)));
+    }, {})).map(function (_a) {
+        var _b = __read(_a, 2), typeName = _b[0], precision = _b[1];
+        return makeStatement("precision ".concat(precision, " ").concat(typeName));
+    });
+};
+export var dedupeQualifiedStatements = function (statements, qualifier) {
+    return Object.entries(statements.reduce(function (stmts, stmt) {
+        var _a;
+        return (__assign(__assign({}, stmts), (_a = {}, _a[stmt.declaration.specified_type.specifier.specifier.token] = __assign(__assign({}, (stmts[stmt.declaration.specified_type.specifier.specifier.token] || {})), stmt.declaration.declarations.reduce(function (types, decl) {
+            var _a;
+            return (__assign(__assign({}, types), (_a = {}, _a[decl.identifier.identifier] = true, _a)));
+        }, {})), _a)));
+    }, {})).map(function (_a) {
+        var _b = __read(_a, 2), type = _b[0], varNames = _b[1];
+        return makeStatement("".concat(qualifier, " ").concat(type, " ").concat(Object.keys(varNames).join(', ')));
+    });
+};
+/**
+ * Merge uniforms together into lists of identifiers under the same type.
+ * There's special case handling for mixing of uniforms with "interface blocks"
+ * and those without when merging to make sure the interface block definition is
+ * preserved. Check out the tests for more.
+ *
+ * This function consumes uniforms as found by findShaderSections, so the
+ * definitions must line up
+ */
+export var dedupeUniforms = function (statements) {
+    var groupedByTypeName = Object.entries(statements.reduce(function (stmts, stmt) {
+        var _a, _b, _c;
+        var _d;
+        var decl = stmt.declaration;
+        // This is the standard case, a uniform like "uniform vec2 x"
+        if ('specified_type' in decl) {
+            var specified_type = decl.specified_type;
+            var specifier = specified_type.specifier.specifier;
+            // Token is for "vec2", "identifier" is for custom names like struct
+            var type_1 = 'token' in specifier
+                ? specifier.token
+                : 'identifier' in specifier
+                    ? specifier.identifier
+                    : undefined;
+            if (!type_1) {
+                console.error('Unknown statement: ', stmt);
+                throw new Error("Unknown specifier: ".concat(specifier.type));
+            }
+            // Groups uniforms into their return type, and for each type, collapses
+            // uniform names into an object where the keys determine uniqueness
+            // "vec2": { x: x[1] }
+            var grouped = decl.declarations.reduce(function (types, decl) {
+                var _a;
+                var _b, _c, _d;
+                var identifier = decl.identifier;
+                var quantifier = '';
+                if (decl.quantifier) {
+                    if (!('token' in decl.quantifier[0].expression)) {
+                        console.error('Unknown expression in quantifier: ', decl);
+                        throw new Error("Unknown expression in quantifier: ".concat(generate(decl)));
+                    }
+                    quantifier = "[".concat(decl.quantifier[0].expression.token, "]");
+                }
+                return __assign(__assign({}, types), (_a = {}, _a[identifier.identifier] = ((_c = (_b = stmts[type_1]) === null || _b === void 0 ? void 0 : _b[identifier.identifier]) === null || _c === void 0 ? void 0 : _c.hasInterface)
+                    ? (_d = stmts[type_1]) === null || _d === void 0 ? void 0 : _d[identifier.identifier]
+                    : {
+                        hasInterface: false,
+                        generated: identifier.identifier + quantifier,
+                    }, _a));
+            }, {});
+            return __assign(__assign({}, stmts), (_a = {}, _a[type_1] = __assign(__assign({}, (stmts[type_1] || {})), grouped), _a));
+            // This is the less common case, a uniform like "uniform Light { vec3 position; } name"
+        }
+        else if ('interface_type' in decl) {
+            var interface_type = decl.interface_type, identifier = decl.identifier;
+            // If this is an interface block only, like uniform Scene { mat4 view; };
+            // then group the interface block declaration under ''
+            var interfaceDeclaredUniform = ((_d = identifier === null || identifier === void 0 ? void 0 : identifier.identifier) === null || _d === void 0 ? void 0 : _d.identifier) || '';
+            var node = {
+                type: 'interface_declarator',
+                lp: decl.lp,
+                declarations: decl.declarations,
+                qualifiers: [],
+                // This is non-nullable, to produce "X" in "uniform X { ... } varName"
+                // But it appears "X" is in declarations above
+                interface_type: {
+                    type: 'identifier',
+                    identifier: '',
+                    whitespace: '',
+                },
+                rp: decl.rp,
+            };
+            return __assign(__assign({}, stmts), (_b = {}, _b[interface_type.identifier] = (_c = {},
+                _c[interfaceDeclaredUniform] = {
+                    generated: "".concat(generate(node)).concat(interfaceDeclaredUniform),
+                    hasInterface: true,
+                },
+                _c), _b));
+        }
+        else {
+            console.error('Unknown uniform AST', { stmt: stmt, code: generate(stmt) });
+            throw new Error('Unknown uniform AST encountered when merging uniforms');
+        }
+    }, {}));
+    return groupedByTypeName.map(function (_a) {
+        var _b = __read(_a, 2), type = _b[0], variables = _b[1];
+        return makeStatement("uniform ".concat(type, " ").concat(Object.values(variables)
+            .map(function (v) { return v.generated; })
+            .join(', ')));
+    });
+};
+export var mergeShaderSections = function (s1, s2) {
+    return {
+        version: __spreadArray(__spreadArray([], __read(s1.version), false), __read(s2.version), false),
+        precision: __spreadArray(__spreadArray([], __read(s1.precision), false), __read(s2.precision), false),
+        preprocessor: __spreadArray(__spreadArray([], __read(s1.preprocessor), false), __read(s2.preprocessor), false),
+        inStatements: __spreadArray(__spreadArray([], __read(s1.inStatements), false), __read(s2.inStatements), false),
+        outStatements: __spreadArray(__spreadArray([], __read(s1.outStatements), false), __read(s2.outStatements), false),
+        structs: __spreadArray(__spreadArray([], __read(s1.structs), false), __read(s2.structs), false),
+        uniforms: __spreadArray(__spreadArray([], __read(s1.uniforms), false), __read(s2.uniforms), false),
+        program: __spreadArray(__spreadArray([], __read(s1.program), false), __read(s2.program), false),
+    };
+};
+export var shaderSectionsToProgram = function (sections, mergeOptions) { return ({
+    type: 'program',
+    scopes: [],
+    program: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((mergeOptions.includeVersion ? [dedupeVersions(sections.version)] : [])), false), __read((mergeOptions.includePrecisions
+        ? highestPrecisions(sections.precision)
+        : [])), false), __read(sections.preprocessor), false), __read(sections.structs), false), __read(dedupeQualifiedStatements(sections.inStatements, 'in')), false), __read(dedupeQualifiedStatements(sections.outStatements, 'out')), false), __read(dedupeUniforms(sections.uniforms)), false), __read(sections.program), false),
+}); };
+/**
+ * Group an AST into logical sections. The output of this funciton is consumed
+ * by the dedupe methods, namely dedupeUniforms, so the data shapes are coupled
+ */
+export var findShaderSections = function (ast) {
+    var initialValue = {
+        precision: [],
+        preprocessor: [],
+        version: [],
+        structs: [],
+        inStatements: [],
+        outStatements: [],
+        uniforms: [],
+        program: [],
+    };
+    return ast.program.reduce(function (sections, node) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        if (node.type === 'preprocessor' && node.line.startsWith('#version')) {
+            return __assign(__assign({}, sections), { version: sections.version.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            node.declaration.type === 'precision') {
+            return __assign(__assign({}, sections), { precision: sections.precision.concat(node) });
+        }
+        else if (node.type === 'preprocessor') {
+            return __assign(__assign({}, sections), { preprocessor: sections.preprocessor.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            node.declaration.type === 'declarator_list' &&
+            ((_d = (_c = (_b = (_a = node.declaration) === null || _a === void 0 ? void 0 : _a.specified_type) === null || _b === void 0 ? void 0 : _b.specifier) === null || _c === void 0 ? void 0 : _c.specifier) === null || _d === void 0 ? void 0 : _d.type) === 'struct') {
+            return __assign(__assign({}, sections), { structs: sections.structs.concat(node) });
+            // This definition of a uniform lines up with the processing we do in
+            // dedupeUniforms
+        }
+        else if (node.type === 'declaration_statement' &&
+            // Ignore lines like "layout(std140,column_major) uniform;"
+            !('qualifiers' in node.declaration &&
+                ((_f = (_e = node.declaration) === null || _e === void 0 ? void 0 : _e.qualifiers) === null || _f === void 0 ? void 0 : _f.find(function (q) { return 'layout' in q; }))) &&
+            // One of these checks is for a uniform with an interface block, and the
+            // other is for vanilla uniforms. I don't remember which is which
+            (('specified_type' in node.declaration &&
+                'qualifiers' in node.declaration.specified_type &&
+                ((_g = node.declaration.specified_type.qualifiers) === null || _g === void 0 ? void 0 : _g.find(function (n) { return 'token' in n && n.token === 'uniform'; }))) ||
+                ('qualifiers' in node.declaration &&
+                    ((_j = (_h = node.declaration) === null || _h === void 0 ? void 0 : _h.qualifiers) === null || _j === void 0 ? void 0 : _j.find(function (n) { return 'token' in n && n.token === 'uniform'; }))))) {
+            return __assign(__assign({}, sections), { uniforms: sections.uniforms.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            'specified_type' in node.declaration &&
+            ((_m = (_l = (_k = node.declaration) === null || _k === void 0 ? void 0 : _k.specified_type) === null || _l === void 0 ? void 0 : _l.qualifiers) === null || _m === void 0 ? void 0 : _m.find(function (n) { return 'token' in n && n.token === 'in'; }))) {
+            if (generate(node).includes('main_Fireball')) {
+                console.log('findShaderSections\n', generate(ast));
+                console.log("Tracking inStatement \"".concat(generate(node), "\""), node);
+                debugger;
+            }
+            return __assign(__assign({}, sections), { inStatements: sections.inStatements.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            'specified_type' in node.declaration &&
+            ((_q = (_p = (_o = node.declaration) === null || _o === void 0 ? void 0 : _o.specified_type) === null || _p === void 0 ? void 0 : _p.qualifiers) === null || _q === void 0 ? void 0 : _q.find(function (n) { return 'token' in n && n.token === 'out'; }))) {
+            return __assign(__assign({}, sections), { outStatements: sections.outStatements.concat(node) });
+        }
+        else {
+            return __assign(__assign({}, sections), { program: sections.program.concat(node) });
+        }
+    }, initialValue);
+};