@shaderfrog/core 3.0.0 → 3.0.2

package/engine.d.ts

@@ -77,7 +77,9 @@ export declare const extendNodesContext: (context: EngineContext, nodesContext:
     };
 };
 export type EngineImporter = {
-    convertAst(ast: Program, type?: ShaderStage): void;
+    convertAst(ast: Program, options?: Record<string, unknown> & {
+        type?: ShaderStage;
+    }): void;
     nodeInputMap: Partial<Record<EngineNodeType, Record<string, string | null>>>;
     edgeMap: {
         [oldInput: string]: string;

package/engine.js

@@ -35,7 +35,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import preprocess from '@shaderfrog/glsl-parser/preprocessor';
-import { generate, parser } from '@shaderfrog/glsl-parser';
+import { generate, parse } from '@shaderfrog/glsl-parser';
 import { NodeType } from './graph/graph-types';
 import groupBy from 'lodash.groupby';
 import { collectNodeProperties } from './graph/graph';
@@ -71,8 +71,8 @@ export var convertNode = function (node, converter) {
             define: function () { return true; },
         },
     });
-    var ast = parser.parse(preprocessed);
-    converter.convertAst(ast, node.stage);
+    var ast = parse(preprocessed, { stage: node.stage });
+    converter.convertAst(ast, { type: node.stage });
     var source = generate(ast);
     return __assign(__assign({}, node), { source: source });
 };

package/graph/context.d.ts

@@ -1,4 +1,4 @@
-import { type GlslSyntaxError } from '@shaderfrog/glsl-parser';
+import { GlslSyntaxError } from '@shaderfrog/glsl-parser';
 import { AstNode, FunctionNode, Program } from '@shaderfrog/glsl-parser/ast';
 import { Engine, EngineContext } from '../engine';
 import { NodeInput } from './base-node';

package/graph/graph.test.js

@@ -47,8 +47,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import { expect, describe, it } from 'vitest';
 import util from 'util';
-import { parser } from '@shaderfrog/glsl-parser';
-import { generate } from '@shaderfrog/glsl-parser';
+import { generate, parse } from '@shaderfrog/glsl-parser';
 import { addNode, outputNode, sourceNode } from './graph-node';
 import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, extractSource, filterUniformNames, filterQualifiedStatements, } from './shader-sections';
 import { numberNode } from './data-nodes';
@@ -73,7 +72,7 @@ var mergeBlocks = function (ast1, ast2) {
     }));
 };
 var dedupe = function (code) {
-    return generate(shaderSectionsToProgram(findShaderSections('', parser.parse(code)), {
+    return generate(shaderSectionsToProgram(findShaderSections('', parse(code)), {
         includePrecisions: true,
         includeVersion: true,
     }));
@@ -408,44 +407,40 @@ describe('evaluateNode()', function () {
     });
 });
 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 = parse("uniform vec2 x;");
+    var astY = 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 = parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    var astL02 = 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 = parse("uniform Light0 { vec4 y; } x;", {
         quiet: true,
     });
-    var astL002 = parser.parse("uniform Light0 x;", { quiet: true });
+    var astL002 = 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 = parse("uniform Light0 x;", { quiet: true });
+    var astLo02 = 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 = parse("uniform vec2 y[5];");
+    var vec2Arr2 = 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 = parse("uniform Scene { mat4 view; };");
+    var block2 = 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;");
 });
 it('filterUniformNames', function () {
-    var stmts = parser
-        .parse("uniform vec4 x,y;\nuniform vec2 x, y[5];\nuniform Light0 { vec4 y; } x;\nuniform Light0 { vec4 x; } y;\n")
-        .program.filter(function (s) { return s.type === 'declaration_statement'; });
+    var stmts = parse("uniform vec4 x,y;\nuniform vec2 x, y[5];\nuniform Light0 { vec4 y; } x;\nuniform Light0 { vec4 x; } y;\n").program.filter(function (s) { return s.type === 'declaration_statement'; });
     var filtered = filterUniformNames(stmts.map(function (x) { return ({ nodeId: '', source: x }); }), function (name) { return name !== 'x'; });
     expect(generate(extractSource(filtered))).toEqual("uniform vec4 y;\nuniform vec2 y[5];\nuniform Light0 { vec4 x; } y;\n");
 });
 it('filterQualifiedStatements', function () {
-    var stmts = parser
-        .parse("in vec2 x, y;\nout vec2 x;\n")
-        .program.filter(function (s) { return s.type === 'declaration_statement'; });
+    var stmts = parse("in vec2 x, y;\nout vec2 x;\n").program.filter(function (s) { return s.type === 'declaration_statement'; });
     var filtered = filterQualifiedStatements(stmts.map(function (x) { return ({ nodeId: '', source: x }); }), function (name) { return name !== 'x'; });
     expect(generate(extractSource(filtered))).toEqual("in vec2 y;\n");
 });

package/graph/parsers.js

@@ -24,7 +24,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 var _a;
-import { parser } from '@shaderfrog/glsl-parser';
+import { parse } from '@shaderfrog/glsl-parser';
 import { visit, } from '@shaderfrog/glsl-parser/ast';
 import preprocess from '@shaderfrog/glsl-parser/preprocessor';
 import { convert300MainToReturn, findMainOrThrow, from2To3, makeExpression, makeExpressionWithScopes, makeFnBodyStatementWithScopes, } from '../util/ast';
@@ -88,7 +88,7 @@ export var coreParsers = (_a = {},
                             version: function () { return true; },
                         },
                     });
-                ast = parser.parse(preprocessed);
+                ast = parse(preprocessed, { stage: node.stage });
                 if (node.config.version === 2 && node.stage) {
                     from2To3(ast, node.stage);
                 }
@@ -134,7 +134,7 @@ export var coreParsers = (_a = {},
     // which might be a little awkward for graph creators?
     _a[NodeType.OUTPUT] = {
         produceAst: function (engineContext, engine, graph, node, inputEdges) {
-            return parser.parse(node.source);
+            return parse(node.source);
         },
         findInputs: function (engineContext, ast, edges, node, sibling) {
             return __spreadArray(__spreadArray([], __read(node.config.strategies.flatMap(function (strategy) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaderfrog/core",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Shaderfrog core",
   "type": "module",
   "files": [
@@ -34,7 +34,7 @@
     "@babel/core": "^7.21.8",
     "@babel/preset-env": "^7.21.5",
     "@babel/preset-typescript": "^7.21.5",
-    "@shaderfrog/glsl-parser": "^5.3.2",
+    "@shaderfrog/glsl-parser": "^6.0.0-beta.9",
     "@swc/core": "^1.6.7",
     "@types/lodash.groupby": "^4.6.7",
     "@types/three": "^0.169.0",
@@ -48,7 +48,7 @@
     "lodash.groupby": "^4.6.0"
   },
   "peerDependencies": {
-    "@shaderfrog/glsl-parser": "^5.0.0-beta.4",
+    "@shaderfrog/glsl-parser": "^6.0.0-beta.7",
     "babylonjs": ">=4",
     "playcanvas": "^1.65.3",
     "three": ">=0.50"

package/plugins/babylon/importers.js

@@ -18,7 +18,7 @@ var importers = {
         // from the original shader and the right imports added
         //
         // Also need to show babylon compile errors in the UI
-        convertAst: function (ast, type) {
+        convertAst: function (ast, options) {
             // Babylon has no normalmatrix. They do have a normal attribute. So undo any
             // multiplication by normalMatrix?
             var seen = {};

package/plugins/playcanvas/importers.js

@@ -10,7 +10,7 @@ var nodeInputMap = {
 };
 var importers = {
     three: {
-        convertAst: function (ast, type) {
+        convertAst: function (ast, options) {
             throw new Error('Not implemented');
         },
         nodeInputMap: (_a = {},

package/plugins/three/importers.d.ts

@@ -1,4 +1,4 @@
 import { EngineImporters } from '../../engine';
-export declare const defaultShadertoyVertex = "\nprecision highp float;\nprecision highp int;\n\nattribute vec3 position;\nattribute vec2 uv;\nvarying vec2 vUv;\n\nvoid main() {\n  vUv = uv;\n  gl_Position = vec4(position * 2.0, 1.0);\n}\n";
+export declare const defaultShadertoyVertex = "\nprecision highp float;\nprecision highp int;\n\nuniform mat4 modelMatrix;\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform mat4 viewMatrix;\nuniform mat3 normalMatrix;\n\nattribute vec3 position;\nattribute vec3 normal;\nattribute vec2 uv;\nattribute vec2 uv2;\n\nvarying vec2 vUv;\nvarying vec3 vPosition;\nvarying vec3 vNormal;\n\nvoid main() {\n  vUv = uv;\n  vPosition = position;\n  vNormal = normal;\n  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n}\n";
 declare const importers: EngineImporters;
 export default importers;

package/plugins/three/importers.js

@@ -1,20 +1,33 @@
 import { renameBindings, renameFunction, } from '@shaderfrog/glsl-parser/parser/utils';
 import { findMainOrThrow, makeStatement } from '../../util/ast';
-export var defaultShadertoyVertex = "\nprecision highp float;\nprecision highp int;\n\nattribute vec3 position;\nattribute vec2 uv;\nvarying vec2 vUv;\n\nvoid main() {\n  vUv = uv;\n  gl_Position = vec4(position * 2.0, 1.0);\n}\n";
+import { range } from '../../util/math';
+export var defaultShadertoyVertex = "\nprecision highp float;\nprecision highp int;\n\nuniform mat4 modelMatrix;\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform mat4 viewMatrix;\nuniform mat3 normalMatrix;\n\nattribute vec3 position;\nattribute vec3 normal;\nattribute vec2 uv;\nattribute vec2 uv2;\n\nvarying vec2 vUv;\nvarying vec3 vPosition;\nvarying vec3 vNormal;\n\nvoid main() {\n  vUv = uv;\n  vPosition = position;\n  vNormal = normal;\n  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n}\n";
 var importers = {
     shadertoy: {
         code: {
             defaultShadertoyVertex: defaultShadertoyVertex,
         },
-        convertAst: function (ast, type) {
-            ast.program.unshift(makeStatement('uniform vec2 renderResolution', '\n')[0]);
+        convertAst: function (ast, options) {
+            var isUv = (options === null || options === void 0 ? void 0 : options.importType) === 'uv';
+            var isScreen = !isUv;
+            if (isScreen) {
+                ast.program.unshift(makeStatement('uniform vec2 renderResolution', '\n')[0]);
+            }
+            else {
+                ast.program.unshift(makeStatement('varying vec2 vUv', '\n')[0]);
+            }
             // These do not catch variables in preprocessor definitions! See "SAD HACK"
-            //if (ast.scopes.some((s) => 'iTime' in s.bindings)) {
-            ast.program.unshift(makeStatement('uniform float time')[0]);
-            //}
-            //if (ast.scopes.some((s) => 'iMouse' in s.bindings)) {
-            ast.program.unshift(makeStatement('uniform vec2 mouse')[0]);
-            //}
+            if (ast.scopes.some(function (s) { return 'iTime' in s.bindings; })) {
+                ast.program.unshift(makeStatement('uniform float time')[0]);
+            }
+            if (ast.scopes.some(function (s) { return 'iMouse' in s.bindings; })) {
+                ast.program.unshift(makeStatement('uniform vec2 mouse')[0]);
+            }
+            range(0, 9).forEach(function (i) {
+                if (ast.scopes.some(function (s) { return "iChannel".concat(i) in s.bindings; })) {
+                    ast.program.unshift(makeStatement("uniform sampler2D iChannel".concat(i))[0]);
+                }
+            });
             ast.program.unshift(makeStatement('precision highp int', '\n')[0]);
             ast.program.unshift(makeStatement('precision highp float')[0]);
             ast.scopes[0].functions.main = renameFunction(ast.scopes[0].functions.mainImage, 'main');
@@ -33,13 +46,23 @@ var importers = {
                         return 'mouse';
                     }
                     if (name === 'iResolution') {
-                        return 'renderResolution';
+                        if (isUv) {
+                            return 'vec2(1.0)';
+                        }
+                        else {
+                            return 'renderResolution';
+                        }
                     }
                     if (name === 'fragColor') {
                         return 'gl_FragColor';
                     }
                     if (name === 'fragCoord') {
-                        return 'gl_FragCoord.xy';
+                        if (isUv) {
+                            return 'vUv';
+                        }
+                        else {
+                            return 'gl_FragCoord.xy';
+                        }
                     }
                     return name;
                 });
@@ -49,7 +72,7 @@ var importers = {
         edgeMap: {},
     },
     babylon: {
-        convertAst: function (ast, type) {
+        convertAst: function (ast, options) {
             ast.scopes[0].bindings = renameBindings(ast.scopes[0].bindings, function (name) {
                 return name === 'vMainUV1' ? 'vUv' : name === 'vNormalW' ? 'vNormal' : name;
             });

package/plugins/three/threngine.test.js

@@ -44,7 +44,7 @@ import { threngine } from './threngine';
 import { makeId } from '../../util/id';
 import { fail } from '../../test-util';
 import importers from './importers';
-import { generate, parser } from '@shaderfrog/glsl-parser';
+import { generate, parse } from '@shaderfrog/glsl-parser';
 var p = { x: 0, y: 0 };
 var makeSourceNode = function (id, source, stage, strategies) {
     if (strategies === void 0) { strategies = [texture2DStrategy(), namedAttributeStrategy('position')]; }
@@ -128,9 +128,9 @@ it('threngine shadertoy import', function () { return __awaiter(void 0, void 0,
     var testImport, p;
     return __generator(this, function (_a) {
         testImport = "\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord ){\n  vec3 rd = normalize(vec3(2.*fragCoord - iResolution.xy, iResolution.y));\n  fragColor = vec4(sqrt(clamp(col, 0., 1.)), 1.0 * iTime);\n}\n";
-        p = parser.parse(testImport);
-        importers.shadertoy.convertAst(p, 'fragment');
-        expect(generate(p)).toContain("\nprecision highp float;\nprecision highp int;\n\nuniform vec2 mouse;\nuniform float time;\nuniform vec2 renderResolution;\n\nvoid main() {\n  vec3 rd = normalize(vec3(2.*gl_FragCoord.xy - renderResolution.xy, renderResolution.y));\n  gl_FragColor = vec4(sqrt(clamp(col, 0., 1.)), 1.0 * time);\n}\n");
+        p = parse(testImport);
+        importers.shadertoy.convertAst(p, { type: 'fragment' });
+        expect(generate(p)).toContain("\nprecision highp float;\nprecision highp int;\n\nuniform float time;\nuniform vec2 renderResolution;\n\nvoid main() {\n  vec3 rd = normalize(vec3(2.*gl_FragCoord.xy - renderResolution.xy, renderResolution.y));\n  gl_FragColor = vec4(sqrt(clamp(col, 0., 1.)), 1.0 * time);\n}\n");
         return [2 /*return*/];
     });
 }); });

package/strategy/stratgies.test.js

@@ -15,7 +15,7 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 import { expect, it } from 'vitest';
-import { parser } from '@shaderfrog/glsl-parser';
+import { parse } from '@shaderfrog/glsl-parser';
 import { generate } from '@shaderfrog/glsl-parser';
 import { applyStrategy, StrategyType } from '.';
 import { makeExpression } from '../util/ast';
@@ -24,7 +24,7 @@ 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 });
+    var ast = parse(source, { quiet: true });
     var fillers = applyStrategy({
         type: StrategyType.NAMED_ATTRIBUTE,
         config: {
@@ -43,7 +43,7 @@ it('named attribute strategy`', function () {
 });
 it('inject strategy after', function () {
     var source = "\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\n// Middle comment\nre(x, y, z);\n// Final comment\n}";
-    var ast = parser.parse(source, { quiet: true });
+    var ast = parse(source, { quiet: true });
     var fillers = applyStrategy({
         type: StrategyType.INJECT,
         config: {
@@ -64,7 +64,7 @@ it('inject strategy after', function () {
 });
 it('inject strategy before', function () {
     var source = "\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\n// Middle comment\nre(x, y, z);\n// Final comment\n}";
-    var ast = parser.parse(source, { quiet: true });
+    var ast = parse(source, { quiet: true });
     var fillers = applyStrategy({
         type: StrategyType.INJECT,
         config: {
@@ -123,7 +123,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 });
+    var ast = 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 });
     var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, {});
     // It should find uniforms with simple types, excluding sampler2D
     expect(fillers.map(function (_a) {
@@ -170,7 +170,7 @@ it('correctly fills with uniform strategy', function () {
 });
 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 ast = 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);
@@ -207,14 +207,14 @@ it('correctly fills with uniform strategy through mangling', function () {
     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 });
+    var ast = 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) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;
     })).toEqual(['noiseImage']);
 });
 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 });
+    var ast = 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;
@@ -229,7 +229,7 @@ it('Make sure texture2D finds preprocessed texture() call', function () {
             version: function () { return true; },
         },
     });
-    var ast = parser.parse(pp, { quiet: true });
+    var ast = parse(pp, { quiet: true });
     expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;

package/util/ast.js

@@ -37,7 +37,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { parser, generate } from '@shaderfrog/glsl-parser';
+import { parse, generate } from '@shaderfrog/glsl-parser';
 import { visit, } from '@shaderfrog/glsl-parser/ast';
 import { addFnStmtWithIndent } from './whitespace';
 import { renameBinding } from '@shaderfrog/glsl-parser/parser/utils';
@@ -175,7 +175,7 @@ export var makeStatement = function (stmt, ws) {
     // log(`Parsing "${stmt}"`);
     var ast;
     try {
-        ast = parser.parse("".concat(stmt, ";").concat(ws, "\n"), { quiet: true });
+        ast = parse("".concat(stmt, ";").concat(ws, "\n"), { quiet: true });
     }
     catch (error) {
         console.error({ stmt: stmt, error: error });
@@ -188,7 +188,7 @@ export var makeFnStatement = function (fnStmt) {
     var ast;
     try {
         // Create a statement with no trailing nor leading whitespace
-        ast = parser.parse("void main() {".concat(fnStmt, ";}"), { quiet: true });
+        ast = parse("void main() {".concat(fnStmt, ";}"), { quiet: true });
     }
     catch (error) {
         console.error({ fnStmt: fnStmt, error: error });
@@ -217,7 +217,7 @@ export var addNewScope = function (left, right) { return (__assign(__assign({},
 export var makeExpression = function (expr) {
     var ast;
     try {
-        ast = parser.parse("void main() {\n          a = ".concat(expr, ";\n        }"), { quiet: true });
+        ast = parse("void main() {\n          a = ".concat(expr, ";\n        }"), { quiet: true });
     }
     catch (error) {
         console.error({ expr: expr, error: error });
@@ -229,7 +229,7 @@ export var makeExpression = function (expr) {
 export var makeExpressionWithScopes = function (expr) {
     var ast;
     try {
-        ast = parser.parse("void main() {\n          ".concat(expr, ";\n        }"), { quiet: true });
+        ast = parse("void main() {\n          ".concat(expr, ";\n        }"), { quiet: true });
     }
     catch (error) {
         console.error({ expr: expr, error: error });
@@ -245,7 +245,7 @@ export var makeExpressionWithScopes = function (expr) {
 export var makeFnBodyStatementWithScopes = function (body) {
     var ast;
     try {
-        ast = parser.parse("void main() {\n".concat(body, "\n        }"), { quiet: true });
+        ast = parse("void main() {\n".concat(body, "\n        }"), { quiet: true });
     }
     catch (error) {
         console.error({ body: body, error: error });
@@ -398,7 +398,7 @@ export var backfillAst = function (ast, fromType, targetVariable, mainFn) {
             .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, ") {}"))
+            .concat(parse("void x(".concat(fromType, " ").concat(targetVariable, ") {}"))
             .program[0].prototype.parameters);
     }
     return ast;

package/util/ast.test.js

@@ -1,14 +1,14 @@
 import { expect, it } from 'vitest';
-import { parser } from '@shaderfrog/glsl-parser';
+import { parse } 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 source = 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 source = 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/math.d.ts

@@ -0,0 +1,2 @@
+export declare const randomBetween: (min: number, max: number) => number;
+export declare const range: (start: number, end: number) => number[];

package/util/math.js

@@ -0,0 +1,6 @@
+export var randomBetween = function (min, max) {
+    return Math.random() * (max - min) + min;
+};
+export var range = function (start, end) {
+    return Array.from({ length: end - start }, function (_, i) { return i + start; });
+};

package/util/whitespace.test.js

@@ -1,11 +1,10 @@
 import { expect, it } from 'vitest';
-import { parser } from '@shaderfrog/glsl-parser';
-import { generate } from '@shaderfrog/glsl-parser';
+import { parse, generate } from '@shaderfrog/glsl-parser';
 import { addFnStmtWithIndent } from './whitespace';
 import { findMainOrThrow } from './ast';
 it("addFnStmtWithIndent", function () {
     var source = "void main() {\n  vec2 y;\n}\n";
-    var ast = parser.parse(source, { quiet: true });
+    var ast = parse(source, { quiet: true });
     var m = findMainOrThrow(ast);
     m.body.statements = addFnStmtWithIndent(m, "return x");
     // Should line up the whitespace properly!