@shaderfrog/core 2.0.0-beta.3 → 3.0.0

package/strategy/stratgies.test.js

@@ -20,6 +20,8 @@ import { generate } from '@shaderfrog/glsl-parser';
 import { applyStrategy, StrategyType } from '.';
 import { makeExpression } from '../util/ast';
 import preprocess from '@shaderfrog/glsl-parser/preprocessor';
+import { NodeType } from '../graph/graph-types';
+import { mangleEntireProgram } from '../graph';
 it('named attribute strategy`', function () {
     var source = "\nin vec3 replaceThisAtrribute;\nvoid main() {\n  vec2 y = replaceThisAtrribute;\n}\n";
     var ast = parser.parse(source, { quiet: true });
@@ -30,11 +32,11 @@ it('named attribute strategy`', function () {
         },
     }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
-    fillers[0][1]({
+    fillers[0][1](function () { return ({
         type: 'literal',
         literal: "myFiller()",
         whitespace: '',
-    });
+    }); });
     var result = generate(ast);
     // Should replace the use of the filler, but not the declaration
     expect(result).toBe("\nin vec3 replaceThisAtrribute;\nvoid main() {\n  vec2 y = myFiller();\n}\n");
@@ -51,11 +53,11 @@ it('inject strategy after', function () {
         },
     }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
-    fillers[0][1]({
+    fillers[0][1](function () { return ({
         type: 'literal',
         literal: "someOtherCall(x, y, z);\nsomeOtherCall(x, y, z);",
         whitespace: '',
-    });
+    }); });
     var result = generate(ast);
     // Should fill references
     expect(result).toBe("\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\n// Middle comment\nre(x, y, z);\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\n// Final comment\n}");
@@ -72,11 +74,11 @@ it('inject strategy before', function () {
         },
     }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
-    fillers[0][1]({
+    fillers[0][1](function () { return ({
         type: 'literal',
         literal: "someOtherCall(x, y, z);\nsomeOtherCall(x, y, z);",
         whitespace: '\n',
-    });
+    }); });
     var result = generate(ast);
     // Should fill references
     expect(result).toBe("\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\nre(x, y, z);\n// Middle comment\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\nre(x, y, z);\n// Final comment\n}");
@@ -91,7 +93,7 @@ var constructor = function () { return ({
     id: '1',
     name: '1',
     engine: true,
-    type: '',
+    type: NodeType.SOURCE,
     inputs: [],
     outputs: [],
     position: { x: 0, y: 0 },
@@ -122,25 +124,7 @@ var engine = {
 it('correctly fills with uniform strategy', function () {
     var _a, _b, _c;
     var ast = parser.parse("\nlayout(std140,column_major) uniform;\nuniform sampler2D image;\nuniform vec4 input, output, other;\nuniform vec4 zenput;\nuniform Light0 { vec4 y; } x;\nvec3 topLevel = vec3(0.0);\nvoid other(in vec3 param) {}\nvoid main() {\n  vec4 computed = texture2D(image, uvPow * 1.0);\n  vec4 x = input;\n  vec4 y = output;\n  vec4 z = zenput;\n}", { quiet: true });
-    // TODO: Experimenting with strategy tests where we mangle in the test to
-    // avoid having to mangle in the strategy, in service of maybe mangling the
-    // AST as part of producing context. But as the test shows -
-    // mangleEntireProgram does NOT modify binding names
-    //
-    // You started updating binding names in the parser but realized that
-    // technically a mangler can produce different results for different nodes
-    // during the rename, since the parser takes in the node to mangle.
-    //
-    // which raised the question about why pass in the node at all to the mangler?
-    // looks like it's for "doNotDescope" hack to avoid renaming a specific
-    // varaible.
-    //
-    // But maybe that could be done here instead? And mangleEntireProgram could be
-    // aware of the output varaibles to ignore? Which means we need to track the
-    // output varialbe names somewhere... do we alredy?
-    var node = { name: 'fake', id: '1' };
-    // mangleEntireProgram(engine, ast, node);
-    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, {}, {});
+    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, {});
     // It should find uniforms with simple types, excluding sampler2D
     expect(fillers.map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
@@ -155,15 +139,21 @@ it('correctly fills with uniform strategy', function () {
     (_a = fillers.find(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name === 'input';
-    })) === null || _a === void 0 ? void 0 : _a[1](makeExpression('a'));
+    })) === null || _a === void 0 ? void 0 : _a[1](function () {
+        return makeExpression('a');
+    });
     (_b = fillers.find(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name === 'output';
-    })) === null || _b === void 0 ? void 0 : _b[1](makeExpression('b'));
+    })) === null || _b === void 0 ? void 0 : _b[1](function () {
+        return makeExpression('b');
+    });
     (_c = fillers.find(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name === 'zenput';
-    })) === null || _c === void 0 ? void 0 : _c[1](makeExpression('c'));
+    })) === null || _c === void 0 ? void 0 : _c[1](function () {
+        return makeExpression('c');
+    });
     var result = generate(ast);
     // Should fill references
     expect(result).toContain('vec4 x = a;');
@@ -178,6 +168,44 @@ it('correctly fills with uniform strategy', function () {
     // Should remove uniform lines
     expect(result).not.toContain('uniform vec4 zenput');
 });
+it('correctly fills with uniform strategy through mangling', function () {
+    var _a, _b, _c;
+    var ast = parser.parse("\nuniform sampler2D image;\nuniform vec4 input, output;\nvoid main() {\n  vec4 computed = texture2D(image, uvPow * 1.0);\n  vec4 x = input;\n  vec4 y = output;\n}", { quiet: true });
+    var node = { id: '1', name: 'fake' };
+    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, node);
+    mangleEntireProgram(engine, ast, node);
+    // It should find uniforms with simple types, excluding sampler2D
+    expect(fillers.map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual([
+        'image',
+        'input',
+        'output',
+    ]);
+    var a = (_a = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'input';
+    })) === null || _a === void 0 ? void 0 : _a[1];
+    (_b = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'input';
+    })) === null || _b === void 0 ? void 0 : _b[1](function () {
+        return makeExpression('a');
+    });
+    (_c = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'output';
+    })) === null || _c === void 0 ? void 0 : _c[1](function () {
+        return makeExpression('b');
+    });
+    var result = generate(ast);
+    // Should fill references
+    expect(result).toContain('vec4 x = a;');
+    expect(result).toContain('vec4 y = b;');
+    // Should preserve things it shouldn't touch
+    expect(result).toContain("uniform sampler2D image_".concat(node.id, ";"));
+});
 it('uses name without suffix for single call', function () {
     var ast = parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n}", { quiet: true });
     expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
@@ -185,12 +213,12 @@ it('uses name without suffix for single call', function () {
         return name;
     })).toEqual(['noiseImage']);
 });
-it('finds multiple texture2D inputs for one uniform', function () {
+it('finds one texture2D input for one texture2D() call', function () {
     var ast = parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n  computed += texture2D(noiseImage, uvPow * 2.0);\n}", { quiet: true });
     expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;
-    })).toEqual(['noiseImage_0', 'noiseImage_1']);
+    })).toEqual(['noiseImage']);
 });
 it('Make sure texture2D finds preprocessed texture() call', function () {
     // I thought this was a regression, but it wasn't a real bug, but tests seems

package/strategy/texture2D.js

@@ -33,7 +33,7 @@ export var texture2DStrategy = function () { return ({
 }); };
 export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingNode) {
     var texture2Dcalls = [];
-    var seen = {};
+    var references = {};
     var visitors = {
         function_call: {
             enter: function (path) {
@@ -47,36 +47,34 @@ export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingN
                         throw new Error('This error is impossible. A function call always has a parent.');
                     }
                     var name = generate(path.node.args[0]);
-                    seen[name] = (seen[name] || 0) + 1;
-                    texture2Dcalls.push([
-                        name,
-                        path.parent,
-                        path.key,
-                        // Remove the first argument and comma
-                        path.node.args.slice(2),
-                    ]);
+                    if (!(name in references)) {
+                        references[name] = [];
+                        texture2Dcalls.push(name);
+                    }
+                    references[name].push({
+                        parent: path.parent,
+                        key: path.key,
+                        args: path.node.args.slice(2),
+                    });
                 }
             },
         },
     };
     visit(ast, visitors);
-    var names = new Set(Object.entries(seen).reduce(function (arr, _a) {
-        var _b = __read(_a, 2), name = _b[0], count = _b[1];
-        return __spreadArray(__spreadArray([], __read(arr), false), __read((count > 1 ? [name] : [])), false);
-    }, []));
-    var inputs = texture2Dcalls.map(function (_a, index) {
-        var _b = __read(_a, 4), name = _b[0], parent = _b[1], key = _b[2], texture2dArgs = _b[3];
-        // Suffix input name if it's used more than once
-        var iName = names.has(name) ? "".concat(name, "_").concat(index) : name;
+    var inputs = texture2Dcalls.map(function (name) {
         return [
-            nodeInput(iName, "filler_".concat(iName), 'filler', 'vector4', // Data type for what plugs into this filler
+            nodeInput(name, "filler_".concat(name), 'filler', 'vector4', // Data type for what plugs into this filler
             ['code', 'data'], false),
-            function (fillerAst) {
-                // @ts-ignore
-                parent[key] = fillerAst;
+            function (filler) {
+                references[name].forEach(function (_a) {
+                    var parent = _a.parent, key = _a.key, args = _a.args;
+                    // Backfilling into the filler! Similar to parsers.ts filler
+                    var f = filler.apply(void 0, __spreadArray([], __read(args.map(generate)), false));
+                    // @ts-ignore
+                    parent[key] = f;
+                });
                 return ast;
             },
-            texture2dArgs,
         ];
     });
     return inputs;

package/strategy/uniform.js

@@ -1,3 +1,14 @@
+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;
@@ -17,6 +28,7 @@ var __read = (this && this.__read) || function (o, n) {
 import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 import { generateFiller } from '../util/ast';
+import { renameBinding } from '@shaderfrog/glsl-parser/parser/utils';
 export var uniformStrategy = function () { return ({
     type: StrategyType.UNIFORM,
     config: {},
@@ -127,64 +139,50 @@ var mapUniformType = function (type) {
     }
     // console.log(`Unknown uniform type, can't map to graph: ${type}`);
 };
-export var applyUniformStrategy = function (strategy, ast, graphNode, siblingNode) {
+var isUniformDeclaration = function (node) {
+    var _a, _b, _c;
+    return node.type === 'declaration_statement' &&
+        node.declaration.type === 'declarator_list' &&
+        !!((_c = (_b = (_a = node.declaration) === null || _a === void 0 ? void 0 : _a.specified_type) === null || _b === void 0 ? void 0 : _b.qualifiers) === null || _c === void 0 ? void 0 : _c.find(function (n) { return n.token === 'uniform'; }));
+};
+// commented this out to allow for sampler2D uniforms to appear as inputs
+// && uniformType !== 'sampler2D'
+export var applyUniformStrategy = function (strategy, ast, graphNode) {
     var program = ast;
-    return (program.program || []).flatMap(function (node) {
-        var _a, _b, _c, _d, _e, _f, _g;
+    return (program.program || [])
+        .filter(isUniformDeclaration)
+        .flatMap(function (node) {
+        var _a, _b, _c;
+        var declaration = node.declaration;
         // The uniform declaration type, like vec4
-        var uniformType = (_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.token;
+        // TODO: File VSCode bug, this is highlighted like a function
+        var uniformType = (_c = (_b = (_a = declaration === null || declaration === void 0 ? void 0 : declaration.specified_type) === null || _a === void 0 ? void 0 : _a.specifier) === null || _b === void 0 ? void 0 : _b.specifier) === null || _c === void 0 ? void 0 : _c.token;
         var graphDataType = mapUniformType(uniformType);
-        // If this is a uniform declaration line
-        if (node.type === 'declaration_statement' &&
-            node.declaration.type === 'declarator_list' &&
-            ((_g = (_f = (_e = node.declaration) === null || _e === void 0 ? void 0 : _e.specified_type) === null || _f === void 0 ? void 0 : _f.qualifiers) === null || _g === void 0 ? void 0 : _g.find(function (n) { return n.token === 'uniform'; }))
-        // commented this out to allow for sampler2D uniforms to appear as inputs
-        // && uniformType !== 'sampler2D'
-        ) {
-            // Capture all the declared names, removing mangling suffix
-            var declarations_1 = node.declaration.declarations;
-            var names = declarations_1.map(function (d) { return d.identifier.identifier; });
-            // Tricky code warning: The flow of preparing a node for the graph is:
-            // 1. Produce/mangle the AST (with unmangled names)
-            // 2. findInputs() (with unmangled names)
-            // 3. The AST is *then* mangled in graph.ts
-            // 4. Later, the inputs are filled in, and now, we have an input with
-            //    the name "x" but the ast now has the mangled name "x_1". So
-            //    here, we look for the *mangled* name in the strategy runner
-            return names.map(function (name) { return [
-                nodeInput(name, "uniform_".concat(name), 'uniform', graphDataType, ['code', 'data'], true),
-                function (filler) {
-                    //const mangledName = mangleName(name, graphNode, siblingNode);
-                    var mangledName = name;
-                    // Remove the declaration line, or the declared uniform
-                    if (declarations_1.length === 1) {
-                        program.program.splice(program.program.indexOf(node), 1);
-                    }
-                    else {
-                        var decl = node.declaration;
-                        decl.declarations = decl.declarations.filter(function (d) { return d.identifier.identifier !== mangledName; });
-                    }
-                    // And rename all the references to said uniform
-                    program.scopes[0].bindings[name].references.forEach(function (ref) {
-                        if (ref.type === 'identifier' && ref.identifier === mangledName) {
-                            ref.identifier = generateFiller(filler);
-                        }
-                        else if (ref.type === 'parameter_declaration' &&
-                            'identifier' in ref &&
-                            ref.identifier.identifier === mangledName) {
-                            ref.identifier.identifier = generateFiller(filler);
-                        }
-                        else if ('identifier' in ref) {
-                            ref.identifier = generateFiller(filler);
-                        }
-                        else {
-                            console.warn('Unknown uniform reference for', graphNode.name, 'ref');
-                        }
-                    });
-                    return ast;
-                },
-            ]; });
-        }
-        return [];
+        var declarations = declaration.declarations;
+        // Capture the uniform names, and then capture their references in the
+        // closure. This allows the scope binding to be renamed when the AST is
+        // mangled, but this strategy can still find the original named variables
+        // to work with
+        var names = declarations.map(function (d) { return d.identifier.identifier; });
+        var references = names.reduce(function (acc, name) {
+            var _a;
+            return (__assign(__assign({}, acc), (_a = {}, _a[name] = program.scopes[0].bindings[name], _a)));
+        }, {});
+        return names.map(function (name) { return [
+            nodeInput(name, "uniform_".concat(name), 'uniform', graphDataType, ['code', 'data'], true),
+            function (filler) {
+                // Remove the declaration line, or the declared uniform
+                if (declarations.length === 1) {
+                    program.program.splice(program.program.indexOf(node), 1);
+                }
+                else {
+                    var decl = node.declaration;
+                    decl.declarations = decl.declarations.filter(function (d) { return d.identifier.identifier !== name; });
+                }
+                // Rename all the references to said uniform
+                renameBinding(references[name], generateFiller(filler()));
+                return ast;
+            },
+        ]; });
     });
 };

package/strategy/variable.js

@@ -35,7 +35,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { nodeInput } from '../graph/base-node';
-import { StrategyType } from '.';
+import { StrategyType, } from '.';
 import { generateFiller } from '../util/ast';
 export var variableStrategy = function () { return ({
     type: StrategyType.VARIABLE,
@@ -48,15 +48,15 @@ export var applyVariableStrategy = function (strategy, ast, graphNode, siblingNo
             var identifier, replacer;
             if (ref.type === 'declaration') {
                 identifier = ref.identifier.identifier;
-                replacer = function (fillerAst) {
-                    ref.identifier.identifier = generateFiller(fillerAst);
+                replacer = function (filler) {
+                    ref.identifier.identifier = generateFiller(filler());
                     return ast;
                 };
             }
             else if (ref.type === 'identifier') {
                 identifier = ref.identifier;
-                replacer = function (fillerAst) {
-                    ref.identifier = generateFiller(fillerAst);
+                replacer = function (filler) {
+                    ref.identifier = generateFiller(filler());
                     return ast;
                 };
                 // } else if (ref.type === 'parameter_declaration') {

package/util/ast.d.ts

@@ -1,16 +1,19 @@
-import { AstNode, ExpressionStatementNode, FunctionNode, DeclarationStatementNode, DeclarationNode } from '@shaderfrog/glsl-parser/ast';
+/**
+ * Utility functions to work with ASTs
+ */
+import { AstNode, ExpressionStatementNode, FunctionNode, DeclarationStatementNode, DeclarationNode, LiteralNode } from '@shaderfrog/glsl-parser/ast';
 import { Program } from '@shaderfrog/glsl-parser/ast';
 import { ShaderStage } from '../graph/graph-types';
 import { Scope } from '@shaderfrog/glsl-parser/parser/scope';
-import { Filler } from '../graph/parsers';
 export interface FrogProgram extends Program {
     outVar?: string;
 }
+export declare const makeLiteral: (literal: string, whitespace?: string) => LiteralNode;
 export declare const findVec4Constructor: (ast: AstNode) => AstNode | undefined;
 export declare const findAssignmentTo: (ast: AstNode | Program, assignTo: string, nth?: number) => DeclarationNode | ExpressionStatementNode | undefined;
 export declare const findDeclarationOf: (ast: AstNode | Program, declarationOf: string) => DeclarationNode | undefined;
 export declare const from2To3: (ast: Program, stage: ShaderStage) => void;
-export declare const makeStatement: (stmt: string) => readonly [DeclarationStatementNode | FunctionNode | import("@shaderfrog/glsl-parser/ast").PreprocessorNode, Scope];
+export declare const makeStatement: (stmt: string, ws?: string) => readonly [import("@shaderfrog/glsl-parser/ast").ProgramStatement, Scope];
 export declare const makeFnStatement: (fnStmt: string) => readonly [AstNode, Scope];
 /**
  * Add a new scope into an existing one. Meant to be used for adding net new
@@ -46,4 +49,6 @@ export declare const returnGlPositionVec3Right: (fnName: string, ast: Program) =
  * returns a vec4.
  */
 export declare const convert300MainToReturn: (ast: FrogProgram) => void;
-export declare const generateFiller: (filler: Filler) => string;
+export declare const generateFiller: (ast: AstNode | AstNode[] | void) => string;
+export declare const isDeclarationStatement: (node: Program["program"][0]) => node is DeclarationStatementNode;
+export declare const backfillAst: (ast: Program, fromType: string, targetVariable: string, mainFn?: FunctionNode) => Program;

package/util/ast.js

@@ -1,3 +1,6 @@
+/**
+ * Utility functions to work with ASTs
+ */
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -37,7 +40,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import { parser, generate } from '@shaderfrog/glsl-parser';
 import { visit, } from '@shaderfrog/glsl-parser/ast';
 import { addFnStmtWithIndent } from './whitespace';
-import { renameBinding, } from '@shaderfrog/glsl-parser/parser/utils';
+import { renameBinding } from '@shaderfrog/glsl-parser/parser/utils';
 var log = function () {
     var _a;
     var args = [];
@@ -46,6 +49,14 @@ var log = function () {
     }
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[31m(core.manipulate)\x1b[0m'], __read(args), false));
 };
+export var makeLiteral = function (literal, whitespace) {
+    if (whitespace === void 0) { whitespace = ''; }
+    return ({
+        type: 'literal',
+        literal: literal,
+        whitespace: whitespace,
+    });
+};
 export var findVec4Constructor = function (ast) {
     var parent;
     var visitors = {
@@ -159,11 +170,12 @@ export var from2To3 = function (ast, stage) {
         },
     });
 };
-export var makeStatement = function (stmt) {
+export var makeStatement = function (stmt, ws) {
+    if (ws === void 0) { ws = ''; }
     // log(`Parsing "${stmt}"`);
     var ast;
     try {
-        ast = parser.parse("".concat(stmt, ";\n"), { quiet: true });
+        ast = parser.parse("".concat(stmt, ";").concat(ws, "\n"), { quiet: true });
     }
     catch (error) {
         console.error({ stmt: stmt, error: error });
@@ -366,11 +378,28 @@ export var convert300MainToReturn = function (ast) {
     main.body.statements = addFnStmtWithIndent(main, rtn);
     ast.scopes[0].bindings[replacedReturn].references.push(rtn.expression);
 };
-export var generateFiller = function (filler) {
-    if (!filler) {
+export var generateFiller = function (ast) {
+    if (!ast) {
         throw new Error('Cannot generate void filler!');
     }
-    return Array.isArray(filler)
-        ? filler.map(generate).join('')
-        : generate(filler);
+    return Array.isArray(ast) ? ast.map(generate).join('') : generate(ast);
+};
+export var isDeclarationStatement = function (node) {
+    return node.type === 'declaration_statement' &&
+        node.declaration.type === 'declarator_list';
+};
+export var backfillAst = function (ast, fromType, targetVariable, mainFn) {
+    if (!ast.scopes[0].bindings[targetVariable]) {
+        console.warn("Variable \"".concat(targetVariable, "\" not found in global program scope to backfill! Variables: ").concat(Object.keys(ast.scopes[0].bindings)));
+    }
+    // Inject the backfill param as the arg
+    if (mainFn) {
+        mainFn.prototype.parameters = (mainFn.prototype.parameters || [])
+            .filter(
+        // Watch out for the main(void){} case!
+        function (arg) { return arg.specifier.specifier.token !== 'void'; })
+            .concat(parser.parse("void x(".concat(fromType, " ").concat(targetVariable, ") {}"))
+            .program[0].prototype.parameters);
+    }
+    return ast;
 };

package/util/ast.test.d.ts

@@ -0,0 +1 @@
+export {};

package/util/ast.test.js

@@ -0,0 +1,14 @@
+import { expect, it } from 'vitest';
+import { parser } from '@shaderfrog/glsl-parser';
+import { generate } from '@shaderfrog/glsl-parser';
+import { backfillAst, findMain } from '../util/ast';
+it('backfillAst', function () {
+    var source = parser.parse("\nattribute vec2 vUv, xx;\nvoid main() {\n    gl_FragColor = vec4(vUv, xx);\n}");
+    var result = backfillAst(source, 'vec2', 'vUv', findMain(source));
+    expect(generate(result)).toBe("\nattribute vec2 vUv, xx;\nvoid main(vec2 vUv) {\n    gl_FragColor = vec4(vUv, xx);\n}");
+});
+it('backfillAst with void main fn', function () {
+    var source = parser.parse("\nattribute vec2 vUv;\nvoid main(void) {\n    gl_FragColor = vec4(vUv, 1.0, 1.0);\n}");
+    var result = backfillAst(source, 'vec2', 'vUv', findMain(source));
+    expect(generate(result)).toBe("\nattribute vec2 vUv;\nvoid main(vec2 vUv) {\n    gl_FragColor = vec4(vUv, 1.0, 1.0);\n}");
+});

package/util/indexByid.d.ts

@@ -0,0 +1,4 @@
+declare const indexById: <T extends {
+    id: string | number;
+}>(records: T[]) => Record<string, T>;
+export default indexById;

package/util/indexByid.js

@@ -0,0 +1,18 @@
+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 indexById = function (records) {
+    return records.reduce(function (acc, record) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[record.id] = record, _a)));
+    }, {});
+};
+export default indexById;

package/util/whitespace.d.ts

@@ -16,3 +16,5 @@ export declare const getLiteralIndent: (node: {
 export declare const tryAddTrailingWhitespace: <T extends AstNode>(node: T, ws: string) => T;
 export declare const guessFnIndent: (fnBody: FunctionNode) => string;
 export declare const addFnStmtWithIndent: (fnBody: FunctionNode, newNode: string | AstNode) => AstNode[];
+export declare const unshiftFnStmtWithIndent: (fnBody: FunctionNode, newNode: string | AstNode) => AstNode[];
+export declare const spliceFnStmtWithIndent: (fnBody: FunctionNode, index: number, ...newNodes: (string | AstNode)[]) => AstNode[];

package/util/whitespace.js

@@ -34,7 +34,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { makeFnStatement } from './ast';
+import { makeFnStatement, makeLiteral } from './ast';
 var log = function () {
     var _a;
     var args = [];
@@ -79,13 +79,32 @@ export var guessFnIndent = function (fnBody) {
             return ws || getLiteralIndent(n.semi) || '';
         }, '');
 };
+var addWs = function (node, ws) {
+    return tryAddTrailingWhitespace(typeof node === 'string' ? makeFnStatement(node)[0] : node, ws);
+};
 export var addFnStmtWithIndent = function (fnBody, newNode) {
     var statements = fnBody.body.statements;
     var indent = guessFnIndent(fnBody);
     return __spreadArray(__spreadArray([], __read(statements), false), [
         // This simple hack is way easier than trying to modify the function body
         // opening brace and/or the previous statement
-        { type: 'literal', literal: '', whitespace: indent },
-        tryAddTrailingWhitespace(typeof newNode === 'string' ? makeFnStatement(newNode)[0] : newNode, "\n"),
+        makeLiteral('', indent),
+        addWs(newNode, "\n"),
     ], false);
 };
+export var unshiftFnStmtWithIndent = function (fnBody, newNode) {
+    var statements = fnBody.body.statements;
+    var indent = guessFnIndent(fnBody);
+    return __spreadArray([addWs(newNode, "\n"), makeLiteral('', indent)], __read(statements), false);
+};
+export var spliceFnStmtWithIndent = function (fnBody, index) {
+    var newNodes = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        newNodes[_i - 2] = arguments[_i];
+    }
+    var statements = fnBody.body.statements;
+    var indent = guessFnIndent(fnBody);
+    return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(statements.slice(0, index)), false), __read(newNodes.map(function (n) { return addWs(n, "\n"); })), false), [
+        makeLiteral('', indent)
+    ], false), __read(statements.slice(index)), false);
+};