@shaderfrog/core 1.1.1 → 1.2.0

package/graph/graph.test.js

@@ -1,25 +1,30 @@
-import util from 'util';
-import { parser } from '@shaderfrog/glsl-parser';
-import { generate } from '@shaderfrog/glsl-parser';
-import { addNode } from './graph-node';
-import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, } from './shader-sections';
-import { numberNode } from './data-nodes';
-import { makeEdge } from './edge';
-import { evaluateNode } from './evaluate';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = __importDefault(require("util"));
+var glsl_parser_1 = require("@shaderfrog/glsl-parser");
+var glsl_parser_2 = require("@shaderfrog/glsl-parser");
+var graph_node_1 = require("./graph-node");
+var shader_sections_1 = require("./shader-sections");
+var data_nodes_1 = require("./data-nodes");
+var edge_1 = require("./edge");
+var evaluate_1 = require("./evaluate");
 var inspect = function (thing) {
-    return console.log(util.inspect(thing, false, null, true));
+    return console.log(util_1.default.inspect(thing, false, null, true));
 };
 var mergeBlocks = function (ast1, ast2) {
-    var s1 = findShaderSections(ast1);
-    var s2 = findShaderSections(ast2);
-    var merged = mergeShaderSections(s1, s2);
-    return generate(shaderSectionsToProgram(merged, {
+    var s1 = (0, shader_sections_1.findShaderSections)(ast1);
+    var s2 = (0, shader_sections_1.findShaderSections)(ast2);
+    var merged = (0, shader_sections_1.mergeShaderSections)(s1, s2);
+    return (0, glsl_parser_2.generate)((0, shader_sections_1.shaderSectionsToProgram)(merged, {
         includePrecisions: true,
         includeVersion: true,
     }));
 };
 var dedupe = function (code) {
-    return generate(shaderSectionsToProgram(findShaderSections(parser.parse(code)), {
+    return (0, glsl_parser_2.generate)((0, shader_sections_1.shaderSectionsToProgram)((0, shader_sections_1.findShaderSections)(glsl_parser_1.parser.parse(code)), {
         includePrecisions: true,
         includeVersion: true,
     }));
@@ -121,47 +126,47 @@ var engine = {
 // });
 describe('evaluateNode()', function () {
     it('evaluates binary nodes', function () {
-        var finalAdd = addNode(id(), p);
-        var add2 = addNode(id(), p);
-        var num1 = numberNode(id(), 'number', p, '3');
-        var num2 = numberNode(id(), 'number', p, '5');
-        var num3 = numberNode(id(), 'number', p, '7');
+        var finalAdd = (0, graph_node_1.addNode)(id(), p);
+        var add2 = (0, graph_node_1.addNode)(id(), p);
+        var num1 = (0, data_nodes_1.numberNode)(id(), 'number', p, '3');
+        var num2 = (0, data_nodes_1.numberNode)(id(), 'number', p, '5');
+        var num3 = (0, data_nodes_1.numberNode)(id(), 'number', p, '7');
         var graph = {
             nodes: [num1, num2, num3, finalAdd, add2],
             edges: [
-                makeEdge(id(), num1.id, finalAdd.id, 'out', 'a'),
-                makeEdge(id(), add2.id, finalAdd.id, 'out', 'b'),
-                makeEdge(id(), num2.id, add2.id, 'out', 'a'),
-                makeEdge(id(), num3.id, add2.id, 'out', 'b'),
+                (0, edge_1.makeEdge)(id(), num1.id, finalAdd.id, 'out', 'a'),
+                (0, edge_1.makeEdge)(id(), add2.id, finalAdd.id, 'out', 'b'),
+                (0, edge_1.makeEdge)(id(), num2.id, add2.id, 'out', 'a'),
+                (0, edge_1.makeEdge)(id(), num3.id, add2.id, 'out', 'b'),
             ],
         };
-        expect(evaluateNode(engine, graph, finalAdd)).toBe(15);
+        expect((0, evaluate_1.evaluateNode)(engine, graph, finalAdd)).toBe(15);
     });
 });
 it('should merge uniforms with interface blocks', function () {
-    var astX = parser.parse("uniform vec2 x;");
-    var astY = parser.parse("uniform vec2 y, z;\nuniform vec3 a;");
+    var astX = glsl_parser_1.parser.parse("uniform vec2 x;");
+    var astY = glsl_parser_1.parser.parse("uniform vec2 y, z;\nuniform vec3 a;");
     expect(mergeBlocks(astX, astY)).toEqual("uniform vec2 x, y, z;\nuniform vec3 a;\n");
-    var astL01 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
-    var astL02 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    var astL01 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    var astL02 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
     expect(mergeBlocks(astL01, astL02)).toEqual("uniform Light0 { vec4 y; } x;\n");
-    var astL001 = parser.parse("uniform Light0 { vec4 y; } x;", {
+    var astL001 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", {
         quiet: true,
     });
-    var astL002 = parser.parse("uniform Light0 x;", { quiet: true });
+    var astL002 = glsl_parser_1.parser.parse("uniform Light0 x;", { quiet: true });
     expect(mergeBlocks(astL001, astL002)).toEqual("uniform Light0 { vec4 y; } x;\n");
-    var astLo01 = parser.parse("uniform Light0 x;", { quiet: true });
-    var astLo02 = parser.parse("uniform Light0 { vec4 y; } x;", {
+    var astLo01 = glsl_parser_1.parser.parse("uniform Light0 x;", { quiet: true });
+    var astLo02 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", {
         quiet: true,
     });
     expect(mergeBlocks(astLo01, astLo02)).toEqual("uniform Light0 { vec4 y; } x;\n");
     // This may be a bug, look at how the uniforms are merged. I at least want to
     // note its current behavior in this test
-    var vec2Arr1 = parser.parse("uniform vec2 y[5];");
-    var vec2Arr2 = parser.parse("uniform vec2 y[10];");
+    var vec2Arr1 = glsl_parser_1.parser.parse("uniform vec2 y[5];");
+    var vec2Arr2 = glsl_parser_1.parser.parse("uniform vec2 y[10];");
     expect(mergeBlocks(vec2Arr1, vec2Arr2)).toEqual("uniform vec2 y[10];\n");
-    var block1 = parser.parse("uniform Scene { mat4 view; };");
-    var block2 = parser.parse("uniform Scene { mat4 view; };");
+    var block1 = glsl_parser_1.parser.parse("uniform Scene { mat4 view; };");
+    var block2 = glsl_parser_1.parser.parse("uniform Scene { mat4 view; };");
     expect(mergeBlocks(block1, block2)).toEqual("uniform Scene { mat4 view; };\n");
     // Verify these lines are preserved (they go through dedupeUniforms)
     expect(dedupe("layout(std140,column_major) uniform;")).toEqual("layout(std140,column_major) uniform;");

package/graph/index.js

@@ -1,11 +1,27 @@
-export * from './base-node';
-export * from './data-nodes';
-export * from './graph-node';
-export * from './code-nodes';
-export * from './edge';
-export * from './parsers';
-export * from './context';
-export * from './evaluate';
-export * from './graph-types';
-export * from './graph';
-export * from './shader-sections';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base-node"), exports);
+__exportStar(require("./data-nodes"), exports);
+__exportStar(require("./graph-node"), exports);
+__exportStar(require("./code-nodes"), exports);
+__exportStar(require("./edge"), exports);
+__exportStar(require("./parsers"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./evaluate"), exports);
+__exportStar(require("./graph-types"), exports);
+__exportStar(require("./graph"), exports);
+__exportStar(require("./shader-sections"), exports);

package/graph/parsers.js

@@ -1,3 +1,4 @@
+"use strict";
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -23,17 +24,22 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _a;
-import { generate, parser } from '@shaderfrog/glsl-parser';
-import { visit, } from '@shaderfrog/glsl-parser/ast';
-import preprocess from '@shaderfrog/glsl-parser/preprocessor';
-import { convert300MainToReturn, from2To3, makeExpression, makeExpressionWithScopes, makeFnBodyStatementWithScopes, makeFnStatement, } from '../util/ast';
-import { applyStrategy } from '../strategy';
-import { SourceType } from './code-nodes';
-import { nodeInput } from './base-node';
-import { MAGIC_OUTPUT_STMTS, NodeType } from './graph-types';
-import { nodeName } from './graph';
-import { generateFiller } from '../util/ast';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreParsers = exports.alphabet = void 0;
+var glsl_parser_1 = require("@shaderfrog/glsl-parser");
+var ast_1 = require("@shaderfrog/glsl-parser/ast");
+var preprocessor_1 = __importDefault(require("@shaderfrog/glsl-parser/preprocessor"));
+var ast_2 = require("../util/ast");
+var strategy_1 = require("../strategy");
+var code_nodes_1 = require("./code-nodes");
+var base_node_1 = require("./base-node");
+var graph_types_1 = require("./graph-types");
+var graph_1 = require("./graph");
+var ast_3 = require("../util/ast");
 /*
  * Core graph parsers, which is the plumbing/interface the graph and context
  * calls into, to parse, find inputs, etc, and define this per-node type.
@@ -46,19 +52,19 @@ var log = function () {
     }
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[31m(core.parsers)\x1b[0m'], __read(args), false));
 };
-export var alphabet = 'abcdefghijklmnopqrstuvwxyz';
-export var coreParsers = (_a = {},
-    _a[NodeType.SOURCE] = {
+exports.alphabet = 'abcdefghijklmnopqrstuvwxyz';
+exports.coreParsers = (_a = {},
+    _a[graph_types_1.NodeType.SOURCE] = {
         produceAst: function (engineContext, engine, graph, node, inputEdges) {
             var ast;
             // @ts-ignore
             if (node.expressionOnly) {
-                node.sourceType = SourceType.EXPRESSION;
+                node.sourceType = code_nodes_1.SourceType.EXPRESSION;
                 // @ts-ignore
                 delete node.expressionOnly;
             }
-            if (node.sourceType === SourceType.FN_BODY_FRAGMENT) {
-                var _a = makeFnBodyStatementWithScopes(node.source), statements = _a.statements, scope = _a.scope;
+            if (node.sourceType === code_nodes_1.SourceType.FN_BODY_FRAGMENT) {
+                var _a = (0, ast_2.makeFnBodyStatementWithScopes)(node.source), statements = _a.statements, scope = _a.scope;
                 ast = {
                     type: 'program',
                     scopes: [scope],
@@ -66,8 +72,8 @@ export var coreParsers = (_a = {},
                     program: statements,
                 };
             }
-            else if (node.sourceType === SourceType.EXPRESSION) {
-                var _b = makeExpressionWithScopes(node.source), expression = _b.expression, scope = _b.scope;
+            else if (node.sourceType === code_nodes_1.SourceType.EXPRESSION) {
+                var _b = (0, ast_2.makeExpressionWithScopes)(node.source), expression = _b.expression, scope = _b.scope;
                 ast = {
                     type: 'program',
                     scopes: [scope],
@@ -78,22 +84,22 @@ export var coreParsers = (_a = {},
             else {
                 var preprocessed = node.config.preprocess === false
                     ? node.source
-                    : preprocess(node.source, {
+                    : (0, preprocessor_1.default)(node.source, {
                         preserve: {
                             version: function () { return true; },
                         },
                     });
-                ast = parser.parse(preprocessed);
+                ast = glsl_parser_1.parser.parse(preprocessed);
                 if (node.config.version === 2 && node.stage) {
-                    from2To3(ast, node.stage);
+                    (0, ast_2.from2To3)(ast, node.stage);
                     log('converted ', node, 'to version 3', {
-                        code: generate(ast),
+                        code: (0, glsl_parser_1.generate)(ast),
                     });
                 }
                 // This assumes that expressionOnly nodes don't have a stage and that all
                 // fragment source code shades have main function, which is probably wrong
                 if (node.stage === 'fragment') {
-                    convert300MainToReturn(node.id, ast);
+                    (0, ast_2.convert300MainToReturn)(node.id, ast);
                 }
             }
             return ast;
@@ -101,7 +107,7 @@ export var coreParsers = (_a = {},
         findInputs: function (engineContext, ast, edges, node, sibling) {
             var seen = new Set();
             return node.config.strategies
-                .flatMap(function (strategy) { return applyStrategy(strategy, ast, node, sibling); })
+                .flatMap(function (strategy) { return (0, strategy_1.applyStrategy)(strategy, ast, node, sibling); })
                 .filter(function (_a) {
                 var _b = __read(_a, 2), input = _b[0], _ = _b[1];
                 if (!seen.has(input.id)) {
@@ -112,44 +118,44 @@ export var coreParsers = (_a = {},
             });
         },
         produceFiller: function (node, ast) {
-            return node.sourceType === SourceType.EXPRESSION
+            return node.sourceType === code_nodes_1.SourceType.EXPRESSION
                 ? ast.program[0]
-                : node.sourceType === SourceType.FN_BODY_FRAGMENT
+                : node.sourceType === code_nodes_1.SourceType.FN_BODY_FRAGMENT
                     ? ast.program
-                    : makeExpression("".concat(nodeName(node), "()"));
+                    : (0, ast_2.makeExpression)("".concat((0, graph_1.nodeName)(node), "()"));
         },
     },
     // TODO: Output node assumes strategies are still passed in on node creation,
     // which might be a little awkward for graph creators?
-    _a[NodeType.OUTPUT] = {
+    _a[graph_types_1.NodeType.OUTPUT] = {
         produceAst: function (engineContext, engine, graph, node, inputEdges) {
-            return parser.parse(node.source);
+            return glsl_parser_1.parser.parse(node.source);
         },
         findInputs: function (engineContext, ast, edges, node, sibling) {
             return __spreadArray(__spreadArray([], __read(node.config.strategies.flatMap(function (strategy) {
-                return applyStrategy(strategy, ast, node, sibling);
+                return (0, strategy_1.applyStrategy)(strategy, ast, node, sibling);
             })), false), [
                 [
-                    nodeInput(MAGIC_OUTPUT_STMTS, "filler_".concat(MAGIC_OUTPUT_STMTS), 'filler', 'rgba', ['code'], false),
+                    (0, base_node_1.nodeInput)(graph_types_1.MAGIC_OUTPUT_STMTS, "filler_".concat(graph_types_1.MAGIC_OUTPUT_STMTS), 'filler', 'rgba', ['code'], false),
                     function (fillerAst) {
                         var fn = ast.program.find(function (stmt) { return stmt.type === 'function'; });
-                        fn === null || fn === void 0 ? void 0 : fn.body.statements.unshift(makeFnStatement(generateFiller(fillerAst)));
+                        fn === null || fn === void 0 ? void 0 : fn.body.statements.unshift((0, ast_2.makeFnStatement)((0, ast_3.generateFiller)(fillerAst)));
                         return ast;
                     },
                 ],
             ], false);
         },
         produceFiller: function (node, ast) {
-            return makeExpression('impossible_call()');
+            return (0, ast_2.makeExpression)('impossible_call()');
         },
     },
-    _a[NodeType.BINARY] = {
+    _a[graph_types_1.NodeType.BINARY] = {
         produceAst: function (engineContext, engine, graph, iNode, inputEdges) {
             var node = iNode;
-            return makeExpression('(' +
+            return (0, ast_2.makeExpression)('(' +
                 (inputEdges.length
                     ? inputEdges
-                        .map(function (_, index) { return alphabet.charAt(index); })
+                        .map(function (_, index) { return exports.alphabet.charAt(index); })
                         .join(" ".concat(node.operator, " "))
                     : "a ".concat(node.operator, " b")) +
                 ')');
@@ -158,9 +164,9 @@ export var coreParsers = (_a = {},
             return new Array(Math.max(inputEdges.length + 1, 2))
                 .fill(0)
                 .map(function (_, index) {
-                var letter = alphabet.charAt(index);
+                var letter = exports.alphabet.charAt(index);
                 return [
-                    nodeInput(letter, letter, 'filler', undefined, ['data', 'code'], false),
+                    (0, base_node_1.nodeInput)(letter, letter, 'filler', undefined, ['data', 'code'], false),
                     function (fillerAst) {
                         var foundPath;
                         var visitors = {
@@ -172,7 +178,7 @@ export var coreParsers = (_a = {},
                                 },
                             },
                         };
-                        visit(ast, visitors);
+                        (0, ast_1.visit)(ast, visitors);
                         if (!foundPath) {
                             throw new Error("Im drunk and I think this case is impossible, no \"".concat(letter, "\" found in binary node?"));
                         }

package/graph/shader-sections.js

@@ -1,3 +1,4 @@
+"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -34,9 +35,11 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { generate } from '@shaderfrog/glsl-parser';
-import { makeStatement } from '../util/ast';
-export var emptyShaderSections = function () { return ({
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findShaderSections = exports.shaderSectionsToProgram = exports.mergeShaderSections = exports.dedupeUniforms = exports.dedupeQualifiedStatements = exports.highestPrecisions = exports.dedupeVersions = exports.higherPrecision = exports.emptyShaderSections = void 0;
+var glsl_parser_1 = require("@shaderfrog/glsl-parser");
+var ast_1 = require("../util/ast");
+var emptyShaderSections = function () { return ({
     precision: [],
     preprocessor: [],
     version: [],
@@ -46,26 +49,30 @@ export var emptyShaderSections = function () { return ({
     outStatements: [],
     uniforms: [],
 }); };
+exports.emptyShaderSections = emptyShaderSections;
 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) {
+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) {
+exports.higherPrecision = higherPrecision;
+var dedupeVersions = function (nodes) { return nodes[0]; };
+exports.dedupeVersions = dedupeVersions;
+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)));
+        return (__assign(__assign({}, precisions), (_a = {}, _a[stmt.declaration.specifier.specifier.token] = (0, exports.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));
+        return (0, ast_1.makeStatement)("precision ".concat(precision, " ").concat(typeName));
     });
 };
-export var dedupeQualifiedStatements = function (statements, qualifier) {
+exports.highestPrecisions = highestPrecisions;
+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) {
@@ -74,9 +81,10 @@ export var dedupeQualifiedStatements = function (statements, qualifier) {
         }, {})), _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(', ')));
+        return (0, ast_1.makeStatement)("".concat(qualifier, " ").concat(type, " ").concat(Object.keys(varNames).join(', ')));
     });
 };
+exports.dedupeQualifiedStatements = dedupeQualifiedStatements;
 /**
  * Merge uniforms together into lists of identifiers under the same type.
  * There's special case handling for mixing of uniforms with "interface blocks"
@@ -86,7 +94,7 @@ export var dedupeQualifiedStatements = function (statements, qualifier) {
  * This function consumes uniforms as found by findShaderSections, so the
  * definitions must line up
  */
-export var dedupeUniforms = function (statements) {
+var dedupeUniforms = function (statements) {
     var groupedByTypeName = Object.entries(statements.reduce(function (stmts, stmt) {
         var _a, _b, _c;
         var _d;
@@ -116,7 +124,7 @@ export var dedupeUniforms = function (statements) {
                 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)));
+                        throw new Error("Unknown expression in quantifier: ".concat((0, glsl_parser_1.generate)(decl)));
                     }
                     quantifier = "[".concat(decl.quantifier[0].expression.token, "]");
                 }
@@ -151,24 +159,25 @@ export var dedupeUniforms = function (statements) {
             };
             return __assign(__assign({}, stmts), (_b = {}, _b[interface_type.identifier] = (_c = {},
                 _c[interfaceDeclaredUniform] = {
-                    generated: "".concat(generate(node)).concat(interfaceDeclaredUniform),
+                    generated: "".concat((0, glsl_parser_1.generate)(node)).concat(interfaceDeclaredUniform),
                     hasInterface: true,
                 },
                 _c), _b));
         }
         else {
-            console.error('Unknown uniform AST', { stmt: stmt, code: generate(stmt) });
+            console.error('Unknown uniform AST', { stmt: stmt, code: (0, glsl_parser_1.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)
+        return (0, ast_1.makeStatement)("uniform ".concat(type, " ").concat(Object.values(variables)
             .map(function (v) { return v.generated; })
             .join(', ')));
     });
 };
-export var mergeShaderSections = function (s1, s2) {
+exports.dedupeUniforms = dedupeUniforms;
+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),
@@ -180,18 +189,20 @@ export var mergeShaderSections = function (s1, s2) {
         program: __spreadArray(__spreadArray([], __read(s1.program), false), __read(s2.program), false),
     };
 };
-export var shaderSectionsToProgram = function (sections, mergeOptions) { return ({
+exports.mergeShaderSections = mergeShaderSections;
+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),
+    program: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((mergeOptions.includeVersion ? [(0, exports.dedupeVersions)(sections.version)] : [])), false), __read((mergeOptions.includePrecisions
+        ? (0, exports.highestPrecisions)(sections.precision)
+        : [])), false), __read(sections.preprocessor), false), __read(sections.structs), false), __read((0, exports.dedupeQualifiedStatements)(sections.inStatements, 'in')), false), __read((0, exports.dedupeQualifiedStatements)(sections.outStatements, 'out')), false), __read((0, exports.dedupeUniforms)(sections.uniforms)), false), __read(sections.program), false),
 }); };
+exports.shaderSectionsToProgram = shaderSectionsToProgram;
 /**
  * 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 findShaderSections = function (ast) {
     var initialValue = {
         precision: [],
         preprocessor: [],
@@ -237,9 +248,9 @@ export var findShaderSections = function (ast) {
         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);
+            if ((0, glsl_parser_1.generate)(node).includes('main_Fireball')) {
+                console.log('findShaderSections\n', (0, glsl_parser_1.generate)(ast));
+                console.log("Tracking inStatement \"".concat((0, glsl_parser_1.generate)(node), "\""), node);
                 debugger;
             }
             return __assign(__assign({}, sections), { inStatements: sections.inStatements.concat(node) });
@@ -254,3 +265,4 @@ export var findShaderSections = function (ast) {
         }
     }, initialValue);
 };
+exports.findShaderSections = findShaderSections;

package/index.js

@@ -1,3 +1,19 @@
-export * from './graph';
-export * from './strategy';
-export * from './engine';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./graph"), exports);
+__exportStar(require("./strategy"), exports);
+__exportStar(require("./engine"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaderfrog/core",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Shaderfrog core",
   "scripts": {
     "prepare": "npm run build && ./prepublish.sh",