@shaderfrog/core 2.0.1 → 3.0.0

package/plugins/playcanvas/playengine.js

@@ -79,6 +79,7 @@ import importers from './importers';
 import { returnGlPositionHardCoded, returnGlPosition, returnGlPositionVec3Right, } from '../../util/ast';
 import { property, } from '../../graph/code-nodes';
 import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
+import indexById from '../../util/indexByid';
 var log = function () {
     var _a;
     var args = [];
@@ -126,12 +127,7 @@ export var defaultPropertySetting = function (app, property) {
 };
 var applyPlayMaterialProperties = function (engineContext, shaderMaterial, app, graph, node, sibling) {
     // Find inputs to this node that are dependent on a property of the material
-    var propertyInputs = node.inputs
-        .filter(function (i) { return i.property; })
-        .reduce(function (acc, input) {
-        var _a;
-        return (__assign(__assign({}, acc), (_a = {}, _a[input.id] = input, _a)));
-    }, {});
+    var propertyInputs = indexById(node.inputs.filter(function (i) { return i.property; }));
     // Then look for any edges into those inputs and set the material property
     var props = graph.edges
         .filter(function (edge) { return edge.to === node.id || edge.to === (sibling === null || sibling === void 0 ? void 0 : sibling.id); })
@@ -367,7 +363,7 @@ var onBeforeCompileMegaShader = function (engineContext, graph, node, sibling) {
         return [2 /*return*/, new Promise(function (resolve) {
                 var variants = shaderMaterial.variants;
                 if (variants.size === 1) {
-                    var _a = __read(variants.entries().next().value, 2), untypedVariant = _a[1];
+                    var _a = __read(variants.entries().next().value || [], 2), untypedVariant = _a[1];
                     var variant = untypedVariant;
                     var _b = variant.definition, fshader = _b.fshader, vshader = _b.vshader;
                     fragmentSource = fshader;
@@ -391,7 +387,7 @@ var onBeforeCompileMegaShader = function (engineContext, graph, node, sibling) {
 // TODO: NEED TO DO SAME THREE MANGLIGN STEP HERE
 var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
     var programAst = ast;
-    var mainName = 'main' || nodeName(node);
+    var mainName = nodeName(node);
     if (node.stage === 'vertex') {
         if (doesLinkThruShader(graph, node)) {
             returnGlPositionHardCoded(mainName, programAst, 'vec3', 'transformed');
@@ -491,7 +487,7 @@ export var playengine = {
         _b[NodeType.SOURCE] = {
             manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
                 var programAst = ast;
-                var mainName = 'main' || nodeName(node);
+                var mainName = nodeName(node);
                 // This hinges on the vertex shader calling vec3(p)
                 if (node.stage === 'vertex') {
                     if (doesLinkThruShader(graph, node)) {

package/plugins/three/threngine.d.ts

@@ -1,4 +1,4 @@
-import { RawShaderMaterial, Vector4, Color, Texture } from 'three';
+import { RawShaderMaterial, Vector4, Color, Texture, Scene, WebGLRenderer, PerspectiveCamera } from 'three';
 import { ShaderStage } from '../../graph/graph-types';
 import { Engine, EngineContext } from '../../engine';
 import { CompileResult } from '../../graph/graph';
@@ -9,11 +9,12 @@ export declare const phongNode: (id: string, name: string, position: NodePositio
 export declare const physicalNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
 export declare const defaultPropertySetting: (property: NodeProperty) => 0.5 | Texture | Color | Vector4 | undefined;
 export type ThreeRuntime = {
-    scene: any;
-    camera: any;
-    renderer: any;
+    scene: Scene;
+    camera: PerspectiveCamera;
+    renderer: WebGLRenderer;
     sceneData: any;
     engineMaterial: any;
+    loaded: boolean;
     index: number;
     cache: {
         data: {
@@ -29,6 +30,7 @@ export type ThreeRuntime = {
         };
     };
 };
+export declare const stringifyThreeValue: (input: any) => string;
 export declare const toonNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
 export declare const threngine: Engine;
 export declare const createMaterial: (compileResult: CompileResult, ctx: EngineContext) => RawShaderMaterial;

package/plugins/three/threngine.js

@@ -76,10 +76,11 @@ import { NodeType } from '../../graph/graph-types';
 import { prepopulatePropertyInputs, mangleMainFn } from '../../graph/graph';
 import importers from './importers';
 import { EngineNodeType } from '../../engine';
-import { doesLinkThruShader, nodeName } from '../../graph/graph';
+import { doesLinkThruShader } from '../../graph/graph';
 import { returnGlPosition, returnGlPositionHardCoded, returnGlPositionVec3Right, } from '../../util/ast';
 import { property, } from '../../graph/code-nodes';
 import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
+import indexById from '../../util/indexByid';
 var log = function () {
     var _a;
     var args = [];
@@ -117,6 +118,8 @@ export var phongNode = function (id, name, position, uniforms, stage) {
                 property('Specular Map', 'specularMap', 'texture', 'filler_specularMap'),
                 property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
                 property('Displacement Scale', 'displacementScale', 'number'),
+                property('Bump Map', 'bumpMap', 'texture', 'filler_bumpMap'),
+                property('Bump Scale', 'bumpScale', 'number'),
                 property('Env Map', 'envMap', 'samplerCube'),
             ],
             strategies: [
@@ -167,6 +170,7 @@ export var physicalNode = function (id, name, position, uniforms, stage) {
                 // MeshPhysicalMaterial gets envMap from the scene. MeshStandardMaterial
                 // gets it from the material
                 // property('Env Map', 'envMap', 'samplerCube'),
+                property('Env Map Intensity', 'envMapIntensity', 'number', 'uniform_envMapIntensity'),
                 property('Transmission', 'transmission', 'number'),
                 property('Transmission Map', 'transmissionMap', 'texture', 'filler_transmissionMap'),
                 property('Thickness', 'thickness', 'number'),
@@ -176,6 +180,7 @@ export var physicalNode = function (id, name, position, uniforms, stage) {
                 // property('Sheen', 'sheen', 'number'),
                 property('Reflectivity', 'reflectivity', 'number'),
                 property('Clearcoat', 'clearcoat', 'number'),
+                property('Clearcoat Roughness', 'clearcoatRoughness', 'number'),
                 property('Iridescence', 'iridescence', 'number'),
                 property('Iridescence IOR', 'iridescenceIOR', 'number'),
                 property('Iridescence Thickness Range', 'iridescenceThicknessRange', 'array', undefined, ['100', '400']),
@@ -213,17 +218,13 @@ var cacher = function (engineContext, graph, node, sibling, newValue) {
         log('Cache miss', cacheKey);
     }
     var materialData = engineContext.runtime.cache.data[cacheKey] || newValue();
+    // This is nasty: We mutate the runtime context here, and return the partial
+    // nodeContext later. See also the TODO: Refactor in context.ts.
     engineContext.runtime.cache.data[cacheKey] = materialData;
     engineContext.runtime.engineMaterial = materialData.material;
-    // TODO: We mutate the nodes here, can we avoid that later?
-    node.source =
-        node.stage === 'fragment' ? materialData.fragment : materialData.vertex;
-    if (sibling) {
-        sibling.source =
-            sibling.stage === 'fragment'
-                ? materialData.fragment
-                : materialData.vertex;
-    }
+    return {
+        computedSource: node.stage === 'fragment' ? materialData.fragment : materialData.vertex,
+    };
 };
 var onBeforeCompileMegaShader = function (engineContext, newMat) {
     log('compiling three megashader!');
@@ -262,7 +263,7 @@ var onBeforeCompileMegaShader = function (engineContext, newMat) {
 };
 var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
     var programAst = ast;
-    var mainName = 'main' || nodeName(node);
+    var mainName = 'main'; // || nodeName(node);
     if (node.stage === 'vertex') {
         if (doesLinkThruShader(graph, node)) {
             returnGlPositionHardCoded(mainName, programAst, 'vec3', 'transformed');
@@ -292,6 +293,7 @@ var nodeCacheKey = function (graph, node) {
     );
 };
 var programCacheKey = function (engineContext, graph, node, sibling) {
+    var _a, _b;
     // The megashader source is dependent on scene information, like the number
     // and type of lights in the scene. This kinda sucks - it's duplicating
     // three's material cache key, and is coupled to how three builds shaders
@@ -299,7 +301,7 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
     var lights = [];
     scene.traverse(function (obj) {
         if (obj instanceof Light) {
-            lights.push(obj.type);
+            lights.push(obj.uuid);
         }
     });
     return ([node, sibling]
@@ -309,8 +311,10 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
         .join('-') +
         '|Lights:' +
         lights.join(',') +
-        '|Envtex:' +
-        scene.environmentTexture);
+        '|Bg:' +
+        ((_a = scene.background) === null || _a === void 0 ? void 0 : _a.uuid) +
+        '|Env:' +
+        ((_b = scene.environment) === null || _b === void 0 ? void 0 : _b.uuid));
 };
 export var defaultPropertySetting = function (property) {
     if (property.type === 'texture') {
@@ -328,12 +332,7 @@ export var defaultPropertySetting = function (property) {
 };
 var threeMaterialProperties = function (graph, node, sibling) {
     // Find inputs to this node that are dependent on a property of the material
-    var propertyInputs = node.inputs
-        .filter(function (i) { return i.property; })
-        .reduce(function (acc, input) {
-        var _a;
-        return (__assign(__assign({}, acc), (_a = {}, _a[input.id] = input, _a)));
-    }, {});
+    var propertyInputs = indexById(node.inputs.filter(function (i) { return i.property; }));
     // Then look for any edges into those inputs and set the material property
     return graph.edges
         .filter(function (edge) { return edge.to === node.id || edge.to === (sibling === null || sibling === void 0 ? void 0 : sibling.id); })
@@ -349,6 +348,24 @@ var threeMaterialProperties = function (graph, node, sibling) {
         return acc;
     }, {});
 };
+export var stringifyThreeValue = function (input) {
+    if (input instanceof Vector2) {
+        return "new Vector2(".concat(input.x, ", ").concat(input.y, ")");
+    }
+    else if (input instanceof Vector3) {
+        return "new Vector3(".concat(input.x, ", ").concat(input.y, ", ").concat(input.z, ")");
+    }
+    else if (input instanceof Vector4) {
+        return "new Vector4(".concat(input.x, ", ").concat(input.y, ", ").concat(input.z, ", ").concat(input.w, ")");
+    }
+    else if (input instanceof Color) {
+        return "new Color(".concat(input.r, ", ").concat(input.g, ", ").concat(input.b, ")");
+    }
+    else if (input instanceof Texture) {
+        return "new Texture()";
+    }
+    return "".concat(input);
+};
 var evaluateNode = function (node) {
     if (node.type === 'number') {
         return parseFloat(node.value);
@@ -395,6 +412,7 @@ export var toonNode = function (id, name, position, uniforms, stage) {
                 property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
                 property('Displacement Scale', 'displacementScale', 'number'),
                 property('Env Map', 'envMap', 'samplerCube'),
+                property('Env Map Intensity', 'envMapIntensity', 'number'),
             ],
             strategies: [
                 uniformStrategy(),
@@ -459,6 +477,8 @@ export var threngine = {
         'shininess',
         'opacity',
         'map',
+        'IncidentLight',
+        'ReflectedLight',
         'specularTint',
         'normalScale',
         'normalMap',
@@ -510,7 +530,7 @@ export var threngine = {
         _b[NodeType.SOURCE] = {
             manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
                 var programAst = ast;
-                var mainName = 'main' || nodeName(node);
+                var mainName = 'main'; // || nodeName(node);
                 // This hinges on the vertex shader calling vec3(p)
                 if (node.stage === 'vertex') {
                     if (doesLinkThruShader(graph, node)) {
@@ -526,12 +546,11 @@ export var threngine = {
         _b[EngineNodeType.phong] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshPhongMaterial(__assign({ 
-                            // @ts-ignore
-                            isMeshPhongMaterial: true }, threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
+                    return [2 /*return*/, cacher(engineContext, graph, node, sibling, function () {
+                            return onBeforeCompileMegaShader(engineContext, new MeshPhongMaterial(__assign({ 
+                                // @ts-ignore
+                                isMeshPhongMaterial: true }, threeMaterialProperties(graph, node, sibling))));
+                        })];
                 });
             }); },
             manipulateAst: megaShaderMainpulateAst,
@@ -539,10 +558,9 @@ export var threngine = {
         _b[EngineNodeType.physical] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
+                    return [2 /*return*/, cacher(engineContext, graph, node, sibling, function () {
+                            return onBeforeCompileMegaShader(engineContext, new MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
+                        })];
                 });
             }); },
             manipulateAst: megaShaderMainpulateAst,
@@ -550,12 +568,11 @@ export var threngine = {
         _b[EngineNodeType.toon] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshToonMaterial(__assign({ gradientMap: new Texture(), 
-                            // @ts-ignore
-                            isMeshToonMaterial: true }, threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
+                    return [2 /*return*/, cacher(engineContext, graph, node, sibling, function () {
+                            return onBeforeCompileMegaShader(engineContext, new MeshToonMaterial(__assign({ gradientMap: new Texture(), 
+                                // @ts-ignore
+                                isMeshToonMaterial: true }, threeMaterialProperties(graph, node, sibling))));
+                        })];
                 });
             }); },
             manipulateAst: megaShaderMainpulateAst,

package/plugins/three/threngine.test.js

@@ -130,7 +130,6 @@ it('threngine shadertoy import', function () { return __awaiter(void 0, void 0,
         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');
-        console.log(generate(p));
         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");
         return [2 /*return*/];
     });

package/strategy/assignemntTo.js

@@ -18,14 +18,13 @@ export var applyAssignmentToStrategy = function (strategy, ast, graphNode, sibli
             [
                 nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
                 ['code', 'data'], false),
-                function (filler) {
-                    var filled = filler();
+                function (fillerAst) {
                     if ('expression' in assignNode) {
                         assignNode.expression.right =
-                            filled;
+                            fillerAst;
                     }
                     else {
-                        assignNode.initializer = filled;
+                        assignNode.initializer = fillerAst;
                     }
                     return ast;
                 },

package/strategy/assignmentTo.d.ts

@@ -0,0 +1,10 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface AssignmentToStrategy extends BaseStrategy {
+    type: StrategyType.ASSIGNMENT_TO;
+    config: {
+        assignTo: string;
+        nth?: number;
+    };
+}
+export declare const assignemntToStrategy: (assignTo: string, nth?: number) => AssignmentToStrategy;
+export declare const applyAssignmentToStrategy: ApplyStrategy<AssignmentToStrategy>;

package/strategy/assignmentTo.js

@@ -0,0 +1,35 @@
+import { findAssignmentTo } from '../util/ast';
+import { nodeInput } from '../graph/base-node';
+import { StrategyType } from '.';
+// Constructor
+export var assignemntToStrategy = function (assignTo, nth) {
+    if (nth === void 0) { nth = 1; }
+    return ({
+        type: StrategyType.ASSIGNMENT_TO,
+        config: { assignTo: assignTo, nth: nth },
+    });
+};
+// Apply the strategy
+export var applyAssignmentToStrategy = function (strategy, ast, graphNode, siblingNode) {
+    var assignNode = findAssignmentTo(ast, strategy.config.assignTo, strategy.config.nth || 1);
+    var name = strategy.config.assignTo;
+    return assignNode
+        ? [
+            [
+                nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
+                ['code', 'data'], false),
+                function (filler) {
+                    var filled = filler();
+                    if ('expression' in assignNode) {
+                        assignNode.expression.right =
+                            filled;
+                    }
+                    else {
+                        assignNode.initializer = filled;
+                    }
+                    return ast;
+                },
+            ],
+        ]
+        : [];
+};

package/strategy/index.d.ts

@@ -1,6 +1,6 @@
 export * from './hardCode';
 export * from './uniform';
-export * from './assignemntTo';
+export * from './assignmentTo';
 export * from './inject';
 export * from './declarationOf';
 export * from './texture2D';

package/strategy/index.js

@@ -1,6 +1,6 @@
 export * from './hardCode';
 export * from './uniform';
-export * from './assignemntTo';
+export * from './assignmentTo';
 export * from './inject';
 export * from './declarationOf';
 export * from './texture2D';

package/strategy/strategy.d.ts

@@ -2,7 +2,7 @@ import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
 import { SourceNode } from '../graph/code-nodes';
 import { HardCodeStrategy } from './hardCode';
 import { UniformStrategy } from './uniform';
-import { AssignemntToStrategy } from './assignemntTo';
+import { AssignmentToStrategy } from './assignmentTo';
 import { DeclarationOfStrategy } from './declarationOf';
 import { Texture2DStrategy } from './texture2D';
 import { NamedAttributeStrategy } from './namedAttribute';
@@ -48,6 +48,6 @@ export interface BaseStrategy {
     type: StrategyType;
     config: Object;
 }
-export type Strategy = UniformStrategy | AssignemntToStrategy | Texture2DStrategy | NamedAttributeStrategy | VariableStrategy | HardCodeStrategy | InjectStrategy | DeclarationOfStrategy;
+export type Strategy = UniformStrategy | AssignmentToStrategy | Texture2DStrategy | NamedAttributeStrategy | VariableStrategy | HardCodeStrategy | InjectStrategy | DeclarationOfStrategy;
 export type ApplyStrategy<T> = (strategy: T, ast: AstNode | Program, node: SourceNode, sibling?: SourceNode) => ComputedInput[];
 export declare const applyStrategy: (strategy: Strategy, ast: AstNode | Program, node: SourceNode, sibling?: SourceNode) => ComputedInput[];

package/strategy/strategy.js

@@ -1,7 +1,7 @@
 var _a;
 import { applyHardCodeStrategy } from './hardCode';
 import { applyUniformStrategy } from './uniform';
-import { applyAssignmentToStrategy, } from './assignemntTo';
+import { applyAssignmentToStrategy, } from './assignmentTo';
 import { constApplyDeclarationOf as constApplyDeclarationOfStrategy, } from './declarationOf';
 import { applyTexture2DStrategy } from './texture2D';
 import { applyNamedAttributeStrategy, } from './namedAttribute';

package/util/ast.d.ts

@@ -1,18 +1,19 @@
 /**
  * Utility functions to work with ASTs
  */
-import { AstNode, ExpressionStatementNode, FunctionNode, DeclarationStatementNode, DeclarationNode } from '@shaderfrog/glsl-parser/ast';
+import { AstNode, ExpressionStatementNode, FunctionNode, DeclarationStatementNode, DeclarationNode, LiteralNode } from '@shaderfrog/glsl-parser/ast';
 import { Program } from '@shaderfrog/glsl-parser/ast';
 import { ShaderStage } from '../graph/graph-types';
 import { Scope } from '@shaderfrog/glsl-parser/parser/scope';
 export interface FrogProgram extends Program {
     outVar?: string;
 }
+export declare const makeLiteral: (literal: string, whitespace?: string) => LiteralNode;
 export declare const findVec4Constructor: (ast: AstNode) => AstNode | undefined;
 export declare const findAssignmentTo: (ast: AstNode | Program, assignTo: string, nth?: number) => DeclarationNode | ExpressionStatementNode | undefined;
 export declare const findDeclarationOf: (ast: AstNode | Program, declarationOf: string) => DeclarationNode | undefined;
 export declare const from2To3: (ast: Program, stage: ShaderStage) => void;
-export declare const makeStatement: (stmt: string, ws?: string) => readonly [DeclarationStatementNode | FunctionNode | import("@shaderfrog/glsl-parser/ast").PreprocessorNode, Scope];
+export declare const makeStatement: (stmt: string, ws?: string) => readonly [import("@shaderfrog/glsl-parser/ast").ProgramStatement, Scope];
 export declare const makeFnStatement: (fnStmt: string) => readonly [AstNode, Scope];
 /**
  * Add a new scope into an existing one. Meant to be used for adding net new

package/util/ast.js

@@ -49,6 +49,14 @@ var log = function () {
     }
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[31m(core.manipulate)\x1b[0m'], __read(args), false));
 };
+export var makeLiteral = function (literal, whitespace) {
+    if (whitespace === void 0) { whitespace = ''; }
+    return ({
+        type: 'literal',
+        literal: literal,
+        whitespace: whitespace,
+    });
+};
 export var findVec4Constructor = function (ast) {
     var parent;
     var visitors = {

package/util/indexByid.d.ts

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

package/util/indexByid.js

@@ -0,0 +1,18 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var indexById = function (records) {
+    return records.reduce(function (acc, record) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[record.id] = record, _a)));
+    }, {});
+};
+export default indexById;

package/util/whitespace.js

@@ -34,7 +34,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { makeFnStatement } from './ast';
+import { makeFnStatement, makeLiteral } from './ast';
 var log = function () {
     var _a;
     var args = [];
@@ -88,17 +88,14 @@ export var addFnStmtWithIndent = function (fnBody, newNode) {
     return __spreadArray(__spreadArray([], __read(statements), false), [
         // This simple hack is way easier than trying to modify the function body
         // opening brace and/or the previous statement
-        { type: 'literal', literal: '', whitespace: indent },
+        makeLiteral('', indent),
         addWs(newNode, "\n"),
     ], false);
 };
 export var unshiftFnStmtWithIndent = function (fnBody, newNode) {
     var statements = fnBody.body.statements;
     var indent = guessFnIndent(fnBody);
-    return __spreadArray([
-        addWs(newNode, "\n"),
-        { type: 'literal', literal: '', whitespace: indent }
-    ], __read(statements), false);
+    return __spreadArray([addWs(newNode, "\n"), makeLiteral('', indent)], __read(statements), false);
 };
 export var spliceFnStmtWithIndent = function (fnBody, index) {
     var newNodes = [];
@@ -108,10 +105,6 @@ export var spliceFnStmtWithIndent = function (fnBody, index) {
     var statements = fnBody.body.statements;
     var indent = guessFnIndent(fnBody);
     return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(statements.slice(0, index)), false), __read(newNodes.map(function (n) { return addWs(n, "\n"); })), false), [
-        {
-            type: 'literal',
-            literal: '',
-            whitespace: indent,
-        }
+        makeLiteral('', indent)
     ], false), __read(statements.slice(index)), false);
 };