@shaderfrog/core 1.2.0 → 1.3.1

package/esm/strategy/uniform.js

@@ -0,0 +1,190 @@
+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;
+};
+import { mangleName } from '../graph/graph';
+import { nodeInput } from '../graph/base-node';
+import { StrategyType } from '.';
+import { generateFiller } from '../util/ast';
+export var uniformStrategy = function () { return ({
+    type: StrategyType.UNIFORM,
+    config: {},
+}); };
+var DATA_TYPE_MAP = [
+    ['vector2', new Set(['bvec2', 'dvec2', 'ivec2', 'uvec2', 'vec2'])],
+    ['number', new Set(['float', 'double', 'int', 'uint', 'atomic_uint'])],
+    ['vector3', new Set(['bvec3', 'dvec3', 'ivec3', 'uvec3', 'vec3'])],
+    ['vector4', new Set(['bvec4', 'dvec4', 'ivec4', 'uvec4', 'vec4'])],
+    ['texture', new Set(['sampler2D'])],
+    ['mat2', new Set(['mat2', 'dmat2'])],
+    ['mat3', new Set(['mat3', 'dmat3'])],
+    ['mat4', new Set(['mat4', 'dmat4'])],
+    ['mat2x2', new Set(['mat2x2', 'dmat2x2'])],
+    ['mat2x3', new Set(['mat2x3', 'dmat2x3'])],
+    ['mat2x4', new Set(['mat2x4', 'dmat2x4'])],
+    ['mat3x2', new Set(['mat3x2', 'dmat3x2'])],
+    ['mat3x3', new Set(['mat3x3', 'dmat3x3'])],
+    ['mat3x4', new Set(['mat3x4', 'dmat3x4'])],
+    ['mat4x2', new Set(['mat4x2', 'dmat4x2'])],
+    ['mat4x3', new Set(['mat4x3', 'dmat4x3'])],
+    ['mat4x4', new Set(['mat4x4', 'dmat4x4'])],
+];
+/**
+ * Uncategorized:
+ *
+"sampler1D"
+"sampler3D"
+"samplerCube"
+"sampler1DShadow"
+"sampler2DShadow"
+"samplerCubeShadow"
+"sampler1DArray"
+"sampler2DArray"
+"sampler1DArrayShadow"
+"sampler2DArrayshadow"
+"isampler1D"
+"isampler2D"
+"isampler3D"
+"isamplerCube"
+"isampler1Darray"
+"isampler2DArray"
+"usampler1D"
+"usampler2D"
+"usampler3D"
+"usamplerCube"
+"usampler1DArray"
+"usampler2DArray"
+"sampler2DRect"
+"sampler2DRectshadow"
+"isampler2DRect"
+"usampler2DRect"
+"samplerBuffer"
+"isamplerBuffer"
+"usamplerBuffer"
+"samplerCubeArray"
+"samplerCubeArrayShadow"
+"isamplerCubeArray"
+"usamplerCubeArray"
+"sampler2DMS"
+"isampler2DMS"
+"usampler2DMS"
+"sampler2DMSArray"
+"isampler2DMSArray"
+"usampler2DMSArray"
+"image1D"
+"iimage1D"
+"uimage1D"
+"image2D"
+"iimage2D"
+"uimage2D"
+"image3D"
+"iimage3D"
+"uimage3D"
+"image2DRect"
+"iimage2DRect"
+"uimage2DRect"
+"imageCube"
+"iimageCube"
+"uimageCube"
+"imageBuffer"
+"iimageBuffer"
+"uimageBuffer"
+"image1DArray"
+"iimage1DArray"
+"uimage1DArray"
+"image2DArray"
+"iimage2DArray"
+"uimage2DArray"
+"imageCubeArray"
+"iimageCubeArray"
+"uimageCubeArray"
+"image2DMS"
+"iimage2DMS"
+"uimage2DMS"
+"image2DMArray"
+"iimage2DMSArray"
+"uimage2DMSArray"
+"struct"
+ */
+var mapUniformType = function (type) {
+    var found = DATA_TYPE_MAP.find(function (_a) {
+        var _b = __read(_a, 2), _ = _b[0], set = _b[1];
+        return set.has(type);
+    });
+    if (found) {
+        return found[0];
+    }
+    // console.log(`Unknown uniform type, can't map to graph: ${type}`);
+};
+export var applyUniformStrategy = function (strategy, ast, graphNode, siblingNode) {
+    var program = ast;
+    return (program.program || []).flatMap(function (node) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // 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;
+        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) {
+                    var mangledName = mangleName(name, graphNode, siblingNode);
+                    // 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 [];
+    });
+};

package/esm/strategy/variable.d.ts

@@ -0,0 +1,6 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface VariableStrategy extends BaseStrategy {
+    type: StrategyType.VARIABLE;
+}
+export declare const variableStrategy: () => VariableStrategy;
+export declare const applyVariableStrategy: ApplyStrategy<VariableStrategy>;

package/esm/strategy/variable.js

@@ -0,0 +1,80 @@
+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 { nodeInput } from '../graph/base-node';
+import { StrategyType } from '.';
+import { generateFiller } from '../util/ast';
+export var variableStrategy = function () { return ({
+    type: StrategyType.VARIABLE,
+    config: {},
+}); };
+export var applyVariableStrategy = function (strategy, ast, graphNode, siblingNode) {
+    var program = ast;
+    return Object.values(program.scopes.reduce(function (acc, scope) { return (__assign(__assign({}, acc), scope.bindings)); }, {})).flatMap(function (binding) {
+        return binding.references.reduce(function (acc, ref) {
+            var identifier, replacer;
+            if (ref.type === 'declaration') {
+                identifier = ref.identifier.identifier;
+                replacer = function (fillerAst) {
+                    ref.identifier.identifier = generateFiller(fillerAst);
+                    return ast;
+                };
+            }
+            else if (ref.type === 'identifier') {
+                identifier = ref.identifier;
+                replacer = function (fillerAst) {
+                    ref.identifier = generateFiller(fillerAst);
+                    return ast;
+                };
+                // } else if (ref.type === 'parameter_declaration') {
+                //   identifier = ref.declaration.identifier.identifier;
+                //   replacer = (fillerAst: AstNode) => {
+                //     ref.declaration.identifier.identifier = generate(fillerAst);
+                //   };
+            }
+            else {
+                return acc;
+            }
+            return __spreadArray(__spreadArray([], __read(acc), false), [
+                [
+                    nodeInput(identifier, "filler_".concat(identifier), 'filler', undefined, // Data type for what plugs into this filler
+                    ['code', 'data'], false),
+                    replacer,
+                ],
+            ], false);
+        }, []);
+    });
+};

package/esm/util/ast.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Utility functions to work with ASTs
+ */
+import { Filler } from '../graph/parsers';
+import { AstNode, ExpressionStatementNode, FunctionNode, DeclarationNode } 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';
+export declare const findVec4Constructor: (ast: AstNode) => AstNode | undefined;
+export declare const findAssignmentTo: (ast: AstNode | Program, assignTo: string) => 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 outDeclaration: (name: string) => Object;
+export declare const makeStatement: (stmt: string) => AstNode;
+export declare const makeFnStatement: (fnStmt: string) => AstNode;
+export declare const makeExpression: (expr: string) => AstNode;
+export declare const makeExpressionWithScopes: (expr: string) => {
+    scope: Scope;
+    expression: AstNode;
+};
+export declare const makeFnBodyStatementWithScopes: (body: string) => {
+    scope: Scope;
+    statements: AstNode[];
+};
+export declare const findFn: (ast: Program, name: string) => FunctionNode | undefined;
+export declare const returnGlPosition: (fnName: string, ast: Program) => void;
+export declare const returnGlPositionHardCoded: (fnName: string, ast: Program, returnType: string, hardCodedReturn: string) => void;
+export declare const returnGlPositionVec3Right: (fnName: string, ast: Program) => void;
+export declare const convert300MainToReturn: (suffix: string, ast: Program) => void;
+export declare const generateFiller: (filler: Filler) => string;

package/esm/util/ast.js

@@ -0,0 +1,332 @@
+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 { 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;
+                    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)));
+                }
+            },
+        },
+    });
+};
+export var generateFiller = function (filler) {
+    if (!filler) {
+        throw new Error('Cannot generate void filler!');
+    }
+    return Array.isArray(filler)
+        ? filler.map(generate).join('')
+        : generate(filler);
+};

package/esm/util/ensure.d.ts

@@ -0,0 +1 @@
+export declare const ensure: <T>(argument: T, message?: string) => T;

package/esm/util/ensure.js

@@ -0,0 +1,7 @@
+export var ensure = function (argument, message) {
+    if (message === void 0) { message = 'This value was promised to be there.'; }
+    if (argument === undefined || argument === null) {
+        throw new TypeError(message);
+    }
+    return argument;
+};

package/esm/util/id.d.ts

@@ -0,0 +1 @@
+export declare const makeId: () => string;

package/esm/util/id.js

@@ -0,0 +1,2 @@
+var counter = 0;
+export var makeId = function () { return "".concat(Date.now(), "_").concat(counter++); };