@shaderfrog/core 1.1.0 → 1.1.2

package/{dist/strategy → strategy}/namedAttribute.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;
@@ -14,19 +15,22 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-import { nodeInput } from '../graph/base-node';
-import { StrategyType } from '.';
-import { generateFiller } from '../util/ast';
-export var namedAttributeStrategy = function (attributeName) { return ({
-    type: StrategyType.NAMED_ATTRIBUTE,
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyNamedAttributeStrategy = exports.namedAttributeStrategy = void 0;
+var base_node_1 = require("../graph/base-node");
+var _1 = require(".");
+var ast_1 = require("../util/ast");
+var namedAttributeStrategy = function (attributeName) { return ({
+    type: _1.StrategyType.NAMED_ATTRIBUTE,
     config: { attributeName: attributeName },
 }); };
-export var applyNamedAttributeStrategy = function (strategy, ast, graphNode, siblingNode) {
+exports.namedAttributeStrategy = namedAttributeStrategy;
+var applyNamedAttributeStrategy = function (strategy, ast, graphNode, siblingNode) {
     var program = ast;
     var attributeName = strategy.config.attributeName;
     return [
         [
-            nodeInput(attributeName, "filler_".concat(attributeName), 'filler', undefined, // Data type for what plugs into this filler
+            (0, base_node_1.nodeInput)(attributeName, "filler_".concat(attributeName), 'filler', undefined, // Data type for what plugs into this filler
             ['code', 'data'], true),
             function (fillerAst) {
                 Object.entries(program.scopes[0].bindings).forEach(function (_a) {
@@ -37,7 +41,7 @@ export var applyNamedAttributeStrategy = function (strategy, ast, graphNode, sib
                         if (ref.type === 'identifier' &&
                             ref !== binding.declaration &&
                             ref.identifier === attributeName) {
-                            ref.identifier = generateFiller(fillerAst);
+                            ref.identifier = (0, ast_1.generateFiller)(fillerAst);
                         }
                     });
                 });
@@ -46,3 +50,4 @@ export var applyNamedAttributeStrategy = function (strategy, ast, graphNode, sib
         ],
     ];
 };
+exports.applyNamedAttributeStrategy = applyNamedAttributeStrategy;

package/strategy/strategy.js

@@ -0,0 +1,35 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyStrategy = exports.StrategyType = void 0;
+var hardCode_1 = require("./hardCode");
+var uniform_1 = require("./uniform");
+var assignemntTo_1 = require("./assignemntTo");
+var declarationOf_1 = require("./declarationOf");
+var texture2D_1 = require("./texture2D");
+var namedAttribute_1 = require("./namedAttribute");
+var variable_1 = require("./variable");
+var inject_1 = require("./inject");
+var StrategyType;
+(function (StrategyType) {
+    StrategyType["VARIABLE"] = "Variable Names";
+    StrategyType["ASSIGNMENT_TO"] = "Assignment To";
+    StrategyType["DECLARATION_OF"] = "Variable Declaration";
+    StrategyType["TEXTURE_2D"] = "Texture2D";
+    StrategyType["NAMED_ATTRIBUTE"] = "Named Attribute";
+    StrategyType["UNIFORM"] = "Uniform";
+    StrategyType["INJECT"] = "Inject";
+    StrategyType["HARD_CODE_INPUTS"] = "Hard Code Inputs";
+})(StrategyType = exports.StrategyType || (exports.StrategyType = {}));
+var strategyRunners = (_a = {},
+    _a[StrategyType.INJECT] = inject_1.applyInjectStrategy,
+    _a[StrategyType.HARD_CODE_INPUTS] = hardCode_1.applyHardCodeStrategy,
+    _a[StrategyType.UNIFORM] = uniform_1.applyUniformStrategy,
+    _a[StrategyType.ASSIGNMENT_TO] = assignemntTo_1.applyAssignmentToStrategy,
+    _a[StrategyType.DECLARATION_OF] = declarationOf_1.constApplyDeclarationOf,
+    _a[StrategyType.TEXTURE_2D] = texture2D_1.applyTexture2DStrategy,
+    _a[StrategyType.NAMED_ATTRIBUTE] = namedAttribute_1.applyNamedAttributeStrategy,
+    _a[StrategyType.VARIABLE] = variable_1.applyVariableStrategy,
+    _a);
+var applyStrategy = function (strategy, ast, node, sibling) { return strategyRunners[strategy.type](strategy, ast, node, sibling); };
+exports.applyStrategy = applyStrategy;

package/{dist/strategy → strategy}/stratgies.test.js

@@ -1,3 +1,27 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -14,12 +38,16 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-import { parser } from '@shaderfrog/glsl-parser';
-import { generate } from '@shaderfrog/glsl-parser';
-import { applyStrategy, StrategyType } from '.';
-import * as graphModule from '../graph/graph';
-import { makeExpression } from '../util/ast';
-import preprocess from '@shaderfrog/glsl-parser/preprocessor';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var glsl_parser_1 = require("@shaderfrog/glsl-parser");
+var glsl_parser_2 = require("@shaderfrog/glsl-parser");
+var _1 = require(".");
+var graphModule = __importStar(require("../graph/graph"));
+var ast_1 = require("../util/ast");
+var preprocessor_1 = __importDefault(require("@shaderfrog/glsl-parser/preprocessor"));
 var orig;
 beforeEach(function () {
     orig = graphModule.mangleName;
@@ -33,9 +61,9 @@ afterEach(function () {
 });
 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 fillers = applyStrategy({
-        type: StrategyType.NAMED_ATTRIBUTE,
+    var ast = glsl_parser_1.parser.parse(source, { quiet: true });
+    var fillers = (0, _1.applyStrategy)({
+        type: _1.StrategyType.NAMED_ATTRIBUTE,
         config: {
             attributeName: 'replaceThisAtrribute',
         },
@@ -46,15 +74,15 @@ it('named attribute strategy`', function () {
         literal: "myFiller()",
         whitespace: '',
     });
-    var result = generate(ast);
+    var result = (0, glsl_parser_2.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");
 });
 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 fillers = applyStrategy({
-        type: StrategyType.INJECT,
+    var ast = glsl_parser_1.parser.parse(source, { quiet: true });
+    var fillers = (0, _1.applyStrategy)({
+        type: _1.StrategyType.INJECT,
         config: {
             find: 're(x, y, z);',
             insert: 'after',
@@ -67,15 +95,15 @@ it('inject strategy after', function () {
         literal: "someOtherCall(x, y, z);\nsomeOtherCall(x, y, z);",
         whitespace: '',
     });
-    var result = generate(ast);
+    var result = (0, glsl_parser_2.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}");
 });
 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 fillers = applyStrategy({
-        type: StrategyType.INJECT,
+    var ast = glsl_parser_1.parser.parse(source, { quiet: true });
+    var fillers = (0, _1.applyStrategy)({
+        type: _1.StrategyType.INJECT,
         config: {
             find: 're(x, y, z);',
             insert: 'before',
@@ -88,14 +116,14 @@ it('inject strategy before', function () {
         literal: "someOtherCall(x, y, z);\nsomeOtherCall(x, y, z);",
         whitespace: '\n',
     });
-    var result = generate(ast);
+    var result = (0, glsl_parser_2.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}");
 });
 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 fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, {}, {});
+    var ast = glsl_parser_1.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 fillers = (0, _1.applyStrategy)({ type: _1.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;
@@ -110,16 +138,16 @@ 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]((0, ast_1.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]((0, ast_1.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'));
-    var result = generate(ast);
+    })) === null || _c === void 0 ? void 0 : _c[1]((0, ast_1.makeExpression)('c'));
+    var result = (0, glsl_parser_2.generate)(ast);
     // Should fill references
     expect(result).toContain('vec4 x = a;');
     expect(result).toContain('vec4 y = b;');
@@ -134,15 +162,15 @@ it('correctly fills with uniform strategy', function () {
     expect(result).not.toContain('uniform vec4 zenput');
 });
 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) {
+    var ast = glsl_parser_1.parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n}", { quiet: true });
+    expect((0, _1.applyStrategy)({ type: _1.StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;
     })).toEqual(['noiseImage']);
 });
 it('finds multiple texture2D inputs for one uniform', 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 ast = glsl_parser_1.parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n  computed += texture2D(noiseImage, uvPow * 2.0);\n}", { quiet: true });
+    expect((0, _1.applyStrategy)({ type: _1.StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;
     })).toEqual(['noiseImage_0', 'noiseImage_1']);
@@ -151,13 +179,13 @@ 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
     // benign to keep anyway
     var program = "\n#define texture2DBias texture\n\nuniform sampler2D normalMap;\n\nvoid getNormal() {\n    vec3 normalMap = unpackNormal(texture2DBias(normalMap, vUv0, textureBias));\n}";
-    var pp = preprocess(program, {
+    var pp = (0, preprocessor_1.default)(program, {
         preserve: {
             version: function () { return true; },
         },
     });
-    var ast = parser.parse(pp, { quiet: true });
-    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
+    var ast = glsl_parser_1.parser.parse(pp, { quiet: true });
+    expect((0, _1.applyStrategy)({ type: _1.StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;
     })).toEqual(['normalMapx']);

package/{dist/strategy → strategy}/texture2D.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,15 +24,18 @@ 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 { visit, } from '@shaderfrog/glsl-parser/ast';
-import { nodeInput } from '../graph/base-node';
-import { StrategyType } from '.';
-export var texture2DStrategy = function () { return ({
-    type: StrategyType.TEXTURE_2D,
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTexture2DStrategy = exports.texture2DStrategy = void 0;
+var glsl_parser_1 = require("@shaderfrog/glsl-parser");
+var ast_1 = require("@shaderfrog/glsl-parser/ast");
+var base_node_1 = require("../graph/base-node");
+var _1 = require(".");
+var texture2DStrategy = function () { return ({
+    type: _1.StrategyType.TEXTURE_2D,
     config: {},
 }); };
-export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingNode) {
+exports.texture2DStrategy = texture2DStrategy;
+var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingNode) {
     var texture2Dcalls = [];
     var seen = {};
     var visitors = {
@@ -46,7 +50,7 @@ export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingN
                     if (!path.parent) {
                         throw new Error('This error is impossible. A function call always has a parent.');
                     }
-                    var name = generate(path.node.args[0]);
+                    var name = (0, glsl_parser_1.generate)(path.node.args[0]);
                     seen[name] = (seen[name] || 0) + 1;
                     texture2Dcalls.push([
                         name,
@@ -59,7 +63,7 @@ export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingN
             },
         },
     };
-    visit(ast, visitors);
+    (0, ast_1.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);
@@ -69,7 +73,7 @@ export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingN
         // Suffix input name if it's used more than once
         var iName = names.has(name) ? "".concat(name, "_").concat(index) : name;
         return [
-            nodeInput(iName, "filler_".concat(iName), 'filler', 'vector4', // Data type for what plugs into this filler
+            (0, base_node_1.nodeInput)(iName, "filler_".concat(iName), 'filler', 'vector4', // Data type for what plugs into this filler
             ['code', 'data'], false),
             function (fillerAst) {
                 // @ts-ignore
@@ -81,3 +85,4 @@ export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingN
     });
     return inputs;
 };
+exports.applyTexture2DStrategy = applyTexture2DStrategy;

package/{dist/strategy → strategy}/uniform.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;
@@ -14,14 +15,17 @@ var __read = (this && this.__read) || function (o, n) {
     }
     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,
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyUniformStrategy = exports.uniformStrategy = void 0;
+var graph_1 = require("../graph/graph");
+var base_node_1 = require("../graph/base-node");
+var _1 = require(".");
+var ast_1 = require("../util/ast");
+var uniformStrategy = function () { return ({
+    type: _1.StrategyType.UNIFORM,
     config: {},
 }); };
+exports.uniformStrategy = uniformStrategy;
 var DATA_TYPE_MAP = [
     ['vector2', new Set(['bvec2', 'dvec2', 'ivec2', 'uvec2', 'vec2'])],
     ['number', new Set(['float', 'double', 'int', 'uint', 'atomic_uint'])],
@@ -128,7 +132,7 @@ var mapUniformType = function (type) {
     }
     // console.log(`Unknown uniform type, can't map to graph: ${type}`);
 };
-export var applyUniformStrategy = function (strategy, ast, graphNode, siblingNode) {
+var applyUniformStrategy = function (strategy, ast, graphNode, siblingNode) {
     var program = ast;
     return (program.program || []).flatMap(function (node) {
         var _a, _b, _c, _d, _e, _f, _g;
@@ -153,9 +157,9 @@ export var applyUniformStrategy = function (strategy, ast, graphNode, siblingNod
             //    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),
+                (0, base_node_1.nodeInput)(name, "uniform_".concat(name), 'uniform', graphDataType, ['code', 'data'], true),
                 function (filler) {
-                    var mangledName = mangleName(name, graphNode, siblingNode);
+                    var mangledName = (0, graph_1.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);
@@ -167,15 +171,15 @@ export var applyUniformStrategy = function (strategy, ast, graphNode, siblingNod
                     // 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);
+                            ref.identifier = (0, ast_1.generateFiller)(filler);
                         }
                         else if (ref.type === 'parameter_declaration' &&
                             'identifier' in ref &&
                             ref.identifier.identifier === mangledName) {
-                            ref.identifier.identifier = generateFiller(filler);
+                            ref.identifier.identifier = (0, ast_1.generateFiller)(filler);
                         }
                         else if ('identifier' in ref) {
-                            ref.identifier = generateFiller(filler);
+                            ref.identifier = (0, ast_1.generateFiller)(filler);
                         }
                         else {
                             console.warn('Unknown uniform reference for', graphNode.name, 'ref');
@@ -188,3 +192,4 @@ export var applyUniformStrategy = function (strategy, ast, graphNode, siblingNod
         return [];
     });
 };
+exports.applyUniformStrategy = applyUniformStrategy;

package/{dist/strategy → strategy}/variable.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,14 +35,17 @@ 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 { generateFiller } from '../util/ast';
-export var variableStrategy = function () { return ({
-    type: StrategyType.VARIABLE,
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyVariableStrategy = exports.variableStrategy = void 0;
+var base_node_1 = require("../graph/base-node");
+var _1 = require(".");
+var ast_1 = require("../util/ast");
+var variableStrategy = function () { return ({
+    type: _1.StrategyType.VARIABLE,
     config: {},
 }); };
-export var applyVariableStrategy = function (strategy, ast, graphNode, siblingNode) {
+exports.variableStrategy = variableStrategy;
+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) {
@@ -49,14 +53,14 @@ export var applyVariableStrategy = function (strategy, ast, graphNode, siblingNo
             if (ref.type === 'declaration') {
                 identifier = ref.identifier.identifier;
                 replacer = function (fillerAst) {
-                    ref.identifier.identifier = generateFiller(fillerAst);
+                    ref.identifier.identifier = (0, ast_1.generateFiller)(fillerAst);
                     return ast;
                 };
             }
             else if (ref.type === 'identifier') {
                 identifier = ref.identifier;
                 replacer = function (fillerAst) {
-                    ref.identifier = generateFiller(fillerAst);
+                    ref.identifier = (0, ast_1.generateFiller)(fillerAst);
                     return ast;
                 };
                 // } else if (ref.type === 'parameter_declaration') {
@@ -70,7 +74,7 @@ export var applyVariableStrategy = function (strategy, ast, graphNode, siblingNo
             }
             return __spreadArray(__spreadArray([], __read(acc), false), [
                 [
-                    nodeInput(identifier, "filler_".concat(identifier), 'filler', undefined, // Data type for what plugs into this filler
+                    (0, base_node_1.nodeInput)(identifier, "filler_".concat(identifier), 'filler', undefined, // Data type for what plugs into this filler
                     ['code', 'data'], false),
                     replacer,
                 ],
@@ -78,3 +82,4 @@ export var applyVariableStrategy = function (strategy, ast, graphNode, siblingNo
         }, []);
     });
 };
+exports.applyVariableStrategy = applyVariableStrategy;