@awesome-flow/noise 0.9.5 → 0.11.0

package/dist/{abstract-Dhf_tSuO.js → abstract-DNmiw2MC.mjs}

@@ -1,22 +1,48 @@
-import { DisplacementHandle, NoiseHandleType, NoiseSourceControlHandle, noise_displace_node_default, noise_rotate_point_node_default, noise_scale_point_node_default, noise_translate_point_node_default, noise_turbulence_node_default } from "./transformers-Cpxm1ER8.js";
-import { noise_billow_node_default, noise_checkerboard_node_default, noise_const_node_default, noise_cylinders_node_default, noise_perlin_node_default, noise_ridgedmulti_node_default, noise_spheres_node_default, noise_voronoi_node_default, position_const_node_default, position_grid_node_default } from "./generators-BzkwG_6g.js";
-import { module_group_node_default } from "./groups-CH_lk8Aw.js";
-import { NoiseCombineType, noise_abs_node_default, noise_clamp_node_default, noise_combine_node_default, noise_curve_node_default, noise_exponent_node_default, noise_invert_node_default, noise_normalize_node_default, noise_scale_bias_node_default, noise_terrace_node_default } from "./modifiers-MSA4z6Gq.js";
+import { a as noise_ridgedmulti_node_default, c as noise_const_node_default, i as noise_spheres_node_default, l as noise_checkerboard_node_default, n as position_const_node_default, o as noise_perlin_node_default, r as noise_voronoi_node_default, s as noise_cylinders_node_default, t as position_grid_node_default, u as noise_billow_node_default } from "./generators-DSwgPqW2.mjs";
+import { t as module_group_node_default } from "./groups-BiuJL0DE.mjs";
+import { a as noise_exponent_node_default, c as noise_clamp_node_default, i as noise_invert_node_default, l as noise_abs_node_default, n as noise_scale_bias_node_default, o as noise_curve_node_default, r as noise_normalize_node_default, s as noise_combine_node_default, t as noise_terrace_node_default } from "./modifiers-I7YC0m3o.mjs";
+import { n as noise_blend_node_default, t as noise_select_node_default } from "./selectors-BHPJTidb.mjs";
+import { a as noise_displace_node_default, i as noise_rotate_point_node_default, n as noise_translate_point_node_default, r as noise_scale_point_node_default, t as noise_turbulence_node_default } from "./transformers-D9B9IjR_.mjs";
+import { NormalizeNoiseModule } from "./modules/index.mjs";
 import { HandlesIncomingDataStatus } from "@awesome-flow/core/components";
-import { useIncomingComputedData, useUpdateNodeComputedData, useUpdateNodeData } from "@awesome-flow/core/hooks";
 import { NodeContainer } from "@awesome-flow/core/layout";
-import { Blend, Select } from "libnoise-simplex-ts";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { memo } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { Divider, Group, NumberInput, Stack, Text } from "@mantine/core";
+import { useNodeContext } from "@awesome-flow/core/hooks";
+import { Divider, Group, Stack, Text } from "@mantine/core";
 import { CoreHandleType, CoreTemplateGroup } from "@awesome-flow/core/abstract";
+import { PipelineFactory } from "@awesome-flow/core/factories";
 import { IDGenerator } from "@awesome-flow/core/utils";
 import { Position } from "@xyflow/system";
+import { Abs, Add, Billow, Blend, Checkerboard, Clamp, Const, Curve, Cylinders, Displace, Exponent, Invert, Max, Min, Multiply, Perlin, Power, RidgedMulti, RotatePoint, ScaleBias, ScalePoint, Select, Spheres, Terrace, TranslatePoint, Tuple, Turbulence, Voronoi } from "libnoise-simplex-ts";
 
+//#region src/abstract/handle-types.ts
+let NoiseHandleType = /* @__PURE__ */ function(NoiseHandleType) {
+	NoiseHandleType["textureData"] = "texture-data";
+	NoiseHandleType["noise"] = "noise";
+	NoiseHandleType["position"] = "position";
+	NoiseHandleType["module"] = "module";
+	return NoiseHandleType;
+}({});
+let DisplacementHandle = /* @__PURE__ */ function(DisplacementHandle) {
+	DisplacementHandle["sourceModule"] = "source";
+	DisplacementHandle["xModule"] = "x-module";
+	DisplacementHandle["yModule"] = "y-module";
+	DisplacementHandle["zModule"] = "z-module";
+	DisplacementHandle["output"] = "output";
+	return DisplacementHandle;
+}({});
+let NoiseSourceControlHandle = /* @__PURE__ */ function(NoiseSourceControlHandle) {
+	NoiseSourceControlHandle["source"] = "source";
+	NoiseSourceControlHandle["control"] = "control";
+	NoiseSourceControlHandle["output"] = "output";
+	return NoiseSourceControlHandle;
+}({});
+
+//#endregion
 //#region src/nodes/output/noise-logger-node.tsx
 function NoiseLoggerNode({ id, selected, data, type }) {
-	const incoming = useIncomingComputedData(id);
-	const noise = useMemo(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+	const noise = (useNodeContext(id)?.incoming?.[NoiseHandleType.noise])?.filter((c) => c.computed?.noise).flatMap((c) => c.computed.noise) || [];
 	return /* @__PURE__ */ jsxs(NodeContainer, {
 		id,
 		selected,
@@ -37,33 +63,12 @@ function NoiseLoggerNode({ id, selected, data, type }) {
 		]
 	});
 }
-var noise_logger_node_default = NoiseLoggerNode;
+var noise_logger_node_default = memo(NoiseLoggerNode);
 
 //#endregion
 //#region src/nodes/output/noise-output-node.tsx
 function NoiseOutputNode({ id, selected, data, type }) {
-	const [size, setSize] = useState(0);
-	const updateComputedData = useUpdateNodeComputedData();
-	const onDataUpdated = useCallback((handleData) => {
-		const incomingPositions = handleData[NoiseHandleType.position];
-		const incomingModule = handleData[NoiseHandleType.module];
-		if (incomingPositions?.length && incomingModule?.length && incomingModule[0]?.module) {
-			const { module } = incomingModule[0];
-			const noise = [];
-			for (const input of incomingPositions) for (const position of input.positions) {
-				const value = module.getValue(position.x, position.y, position.z);
-				noise.push({
-					position,
-					value
-				});
-			}
-			updateComputedData(id, {
-				noise,
-				module
-			});
-			setSize(noise.length);
-		}
-	}, [updateComputedData, id]);
+	const context = useNodeContext(id);
 	return /* @__PURE__ */ jsxs(NodeContainer, {
 		id,
 		selected,
@@ -71,51 +76,19 @@ function NoiseOutputNode({ id, selected, data, type }) {
 		type,
 		children: [/* @__PURE__ */ jsx(HandlesIncomingDataStatus, {
 			nodeId: id,
-			handles: data.handles,
-			groupBy: "dataType",
-			onDataUpdated,
-			type: "target",
-			resetComputedData: true
+			handles: data.handles
 		}), /* @__PURE__ */ jsxs(Text, {
 			mt: 5,
-			children: ["Noise points: ", size]
+			children: ["Noise points: ", context?.computed?.noise?.length || 0]
 		})]
 	});
 }
-var noise_output_node_default = NoiseOutputNode;
+var noise_output_node_default = memo(NoiseOutputNode);
 
 //#endregion
-//#region src/nodes/output/noise-raw-texture-node.tsx
-function NoiseRawTextureNode({ id, selected, data, type }) {
-	const updateComputedData = useUpdateNodeComputedData();
-	const [dataLength, setDataLength] = useState(0);
-	const [resolution, setResolution] = useState(0);
-	const incoming = useIncomingComputedData(id);
-	const noise = useMemo(() => incoming?.map((p) => p.noise).flat(), [incoming]);
-	useEffect(() => {
-		if (noise?.length) {
-			const size = Math.ceil(Math.sqrt(noise.length));
-			const colors = noise.map((n) => [
-				n.value * 255,
-				n.value * 255,
-				n.value * 255,
-				255
-			]).flat();
-			const dataArray = new Uint8Array(size * size * 4);
-			dataArray.set(colors);
-			setResolution(size);
-			setDataLength(dataArray.length);
-			updateComputedData(id, {
-				textureData: dataArray,
-				textureResolutionX: size,
-				textureResolutionY: size
-			});
-		}
-	}, [
-		noise,
-		updateComputedData,
-		id
-	]);
+//#region src/nodes/output/noise-texture-data-node.tsx
+function NoiseTextureDataNode({ id, selected, data, type }) {
+	const context = useNodeContext(id)?.computed;
 	return /* @__PURE__ */ jsx(NodeContainer, {
 		id,
 		selected,
@@ -124,31 +97,28 @@ function NoiseRawTextureNode({ id, selected, data, type }) {
 		children: /* @__PURE__ */ jsxs(Stack, { children: [
 			/* @__PURE__ */ jsxs(Group, { children: [
 				"Resolution: ",
-				resolution,
+				context?.textureResolutionX,
 				"x",
-				resolution
+				context?.textureResolutionY
 			] }),
-			/* @__PURE__ */ jsxs(Group, { children: ["Input Length: ", noise?.length || 0] }),
+			/* @__PURE__ */ jsxs(Group, { children: ["Input Length: ", context?.textureData?.length || 0] }),
 			/* @__PURE__ */ jsxs(Group, { children: [
 				"Output Length (",
-				resolution,
+				context?.textureResolutionX,
 				"*",
-				resolution,
+				context?.textureResolutionY,
 				"*4): ",
-				dataLength
+				context?.textureData?.length || 0
 			] })
 		] })
 	});
 }
-var noise_raw_texture_node_default = NoiseRawTextureNode;
+var noise_texture_data_node_default = memo(NoiseTextureDataNode);
 
 //#endregion
 //#region src/nodes/output/positions-logger-node.tsx
 function PositionsLoggerNode({ id, selected, data, type }) {
-	const incoming = useIncomingComputedData(id);
-	const positions = useMemo(() => {
-		return incoming?.map((p) => p.positions).flat();
-	}, [incoming]);
+	const positions = (useNodeContext(id)?.incoming[NoiseHandleType.position])?.filter((p) => !!p.computed?.positions?.length).flatMap((p) => p.computed.positions);
 	return /* @__PURE__ */ jsxs(NodeContainer, {
 		id,
 		selected,
@@ -167,123 +137,33 @@ function PositionsLoggerNode({ id, selected, data, type }) {
 		]
 	});
 }
-var positions_logger_node_default = PositionsLoggerNode;
+var positions_logger_node_default = memo(PositionsLoggerNode);
 
 //#endregion
-//#region src/nodes/selectors/noise-blend-node.tsx
-function NoiseBlendNode({ id, selected, data, type }) {
-	const updateComputedData = useUpdateNodeComputedData();
-	const onDataUpdated = useCallback((incomingData) => {
-		const incomingSources = incomingData[NoiseSourceControlHandle.source];
-		const incomingControl = incomingData[NoiseSourceControlHandle.control];
-		if (incomingSources?.length >= 2 && incomingControl?.length) {
-			const module = new Blend(incomingSources[0].module, incomingSources[1].module, incomingControl[0].module);
-			updateComputedData(id, { module });
-		}
-	}, [id, updateComputedData]);
-	return /* @__PURE__ */ jsx(NodeContainer, {
-		id,
-		selected,
-		data,
-		type,
-		children: /* @__PURE__ */ jsx(HandlesIncomingDataStatus, {
-			nodeId: id,
-			handles: data.handles,
-			groupBy: "dataId",
-			onDataUpdated,
-			type: "target",
-			resetComputedData: true
-		})
-	});
-}
-var noise_blend_node_default = NoiseBlendNode;
+//#region src/abstract/templates.ts
+let NoiseTemplateGroup = /* @__PURE__ */ function(NoiseTemplateGroup) {
+	NoiseTemplateGroup["positions"] = "Positions";
+	NoiseTemplateGroup["output"] = "Output";
+	NoiseTemplateGroup["noiseGenerators"] = "Noise Generators";
+	NoiseTemplateGroup["noiseModifiers"] = "Noise Modifiers";
+	NoiseTemplateGroup["noiseSelectors"] = "Noise Selectors";
+	NoiseTemplateGroup["noiseTransformers"] = "Noise Transformers";
+	return NoiseTemplateGroup;
+}({});
 
 //#endregion
-//#region src/nodes/selectors/noise-select-node.tsx
-function NoiseSelectNode({ id, selected, data, type }) {
-	const [edgeFalloff, setEdgeFalloff] = useState(data.edgeFalloff);
-	const [lowerBound, setLowerBound] = useState(data.lowerBound);
-	const [upperBound, setUpperBound] = useState(data.upperBound);
-	const updateNodeData = useUpdateNodeData();
-	const updateComputedData = useUpdateNodeComputedData();
-	useEffect(() => {
-		updateNodeData(id, {
-			edgeFalloff,
-			lowerBound,
-			upperBound
-		});
-	}, [
-		edgeFalloff,
-		lowerBound,
-		upperBound,
-		id,
-		updateNodeData
-	]);
-	const onDataUpdated = useCallback((incomingData) => {
-		const incomingSources = incomingData[NoiseSourceControlHandle.source];
-		const incomingControl = incomingData[NoiseSourceControlHandle.control];
-		if (incomingSources?.length >= 2 && incomingControl?.length) {
-			const module = new Select(incomingSources[0].module, incomingSources[1].module, incomingControl[0].module, edgeFalloff, lowerBound, upperBound);
-			updateComputedData(id, { module });
+//#region src/middleware/incoming-property-value.ts
+var IncomingPropertyValueMiddleware = class {
+	action(context) {
+		const incoming = context.incoming?.[CoreHandleType.variableProperty] ?? [];
+		const properties = { ...context.data };
+		for (const connection of incoming) {
+			const overwrite = connection.computed;
+			if (overwrite) Object.assign(properties, { [overwrite.property]: overwrite.value });
 		}
-	}, [
-		updateComputedData,
-		id,
-		edgeFalloff,
-		lowerBound,
-		upperBound
-	]);
-	return /* @__PURE__ */ jsx(NodeContainer, {
-		id,
-		selected,
-		data,
-		type,
-		children: /* @__PURE__ */ jsxs(Stack, { children: [
-			/* @__PURE__ */ jsxs(Group, { children: ["Edge Falloff:", /* @__PURE__ */ jsx(NumberInput, {
-				size: "xs",
-				w: 100,
-				value: edgeFalloff,
-				onChange: (e) => setEdgeFalloff(Number(e)),
-				step: .1
-			})] }),
-			/* @__PURE__ */ jsxs(Group, { children: ["Lower Bound:", /* @__PURE__ */ jsx(NumberInput, {
-				size: "xs",
-				w: 100,
-				value: lowerBound,
-				onChange: (e) => setLowerBound(Number(e)),
-				step: .1
-			})] }),
-			/* @__PURE__ */ jsxs(Group, { children: ["Upper Bound:", /* @__PURE__ */ jsx(NumberInput, {
-				size: "xs",
-				w: 100,
-				value: upperBound,
-				onChange: (e) => setUpperBound(Number(e)),
-				step: .1
-			})] }),
-			/* @__PURE__ */ jsx(HandlesIncomingDataStatus, {
-				nodeId: id,
-				handles: data.handles,
-				groupBy: "dataId",
-				onDataUpdated,
-				type: "target",
-				resetComputedData: true
-			})
-		] })
-	});
-}
-var noise_select_node_default = NoiseSelectNode;
-
-//#endregion
-//#region src/abstract/templates.ts
-let NoiseTemplateGroup = /* @__PURE__ */ function(NoiseTemplateGroup$1) {
-	NoiseTemplateGroup$1["positions"] = "Positions";
-	NoiseTemplateGroup$1["output"] = "Output";
-	NoiseTemplateGroup$1["noiseGenerators"] = "Noise Generators";
-	NoiseTemplateGroup$1["noiseModifiers"] = "Noise Modifiers";
-	NoiseTemplateGroup$1["noiseSelectors"] = "Noise Selectors";
-	NoiseTemplateGroup$1["noiseTransformers"] = "Noise Transformers";
-	return NoiseTemplateGroup$1;
-}({});
+		context.properties = properties;
+	}
+};
 
 //#endregion
 //#region src/templates/generators/noise-billow-template.ts
@@ -310,6 +190,15 @@ var NoiseBillowNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new Billow(properties.frequency, properties.lacunarity, properties.octaves, properties.persistence, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -325,6 +214,14 @@ var NoiseCheckerboardNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		action: (context) => {
+			context.computed = { module: new Checkerboard() };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -345,6 +242,17 @@ var NoiseConstNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return context.data.noise !== void 0 && context.data.noise !== null;
+		},
+		action(context) {
+			context.computed = { module: new Const(context.data.noise) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -367,6 +275,15 @@ var NoiseCylindersNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new Cylinders(properties.frequency) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -393,6 +310,15 @@ var NoisePerlinNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new Perlin(properties.frequency, properties.lacunarity, properties.octaves, properties.persistence, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -420,6 +346,15 @@ var NoiseRidgedMultiNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new RidgedMulti(properties.frequency, properties.lacunarity, properties.octaves, properties.offset, properties.gain, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -442,6 +377,15 @@ var NoiseSpheresNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new Spheres(properties.frequency) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -467,6 +411,15 @@ var NoiseVoronoiNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new Voronoi(properties.frequency, properties.displacement, properties.distance, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -489,6 +442,18 @@ var PositionConstNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return context.data.position !== void 0 && context.data.position !== null;
+		},
+		action(context) {
+			const { data } = context;
+			context.computed = { positions: [data.position] };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -512,6 +477,26 @@ var PositionGridNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			const { center, radius } = context.data;
+			return center !== void 0 && radius !== void 0;
+		},
+		action(context) {
+			const { data } = context;
+			const { center, radius } = data;
+			const positions = [];
+			for (let i = -radius; i < radius; i++) for (let j = -radius; j < radius; j++) positions.push({
+				x: center.x + i,
+				y: center.y + j,
+				z: center.z
+			});
+			context.computed = { positions };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -545,6 +530,17 @@ var ModuleGroupNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action: (context) => {
+			context.computed = { module: context.incoming[NoiseHandleType.module].computed?.module };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -565,6 +561,19 @@ var NoiseAbsNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action(context) {
+			const module = context.incoming[NoiseHandleType.module].computed?.module;
+			if (module) if (context.computed?.module) context.computed.module.sourceModule = module;
+			else context.computed = { module: new Abs(module) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -589,6 +598,43 @@ var NoiseClampNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action(context) {
+			const module = context.incoming[NoiseHandleType.module].computed?.module;
+			if (module) {
+				const clampModule = context.computed?.module;
+				if (clampModule) {
+					clampModule.sourceModule = module;
+					clampModule.lowerBound = context.data.lowerBound;
+					clampModule.upperBound = context.data.upperBound;
+				} else context.computed = { module: new Clamp(module, context.data.lowerBound, context.data.upperBound) };
+			}
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#endregion
+//#region src/abstract/operations.ts
+let NoiseCombineType = /* @__PURE__ */ function(NoiseCombineType) {
+	NoiseCombineType["add"] = "add";
+	NoiseCombineType["max"] = "max";
+	NoiseCombineType["min"] = "min";
+	NoiseCombineType["multiply"] = "multiply";
+	NoiseCombineType["power"] = "power";
+	return NoiseCombineType;
+}({});
+const noiseCombineModuleMap = {
+	[NoiseCombineType.add]: Add,
+	[NoiseCombineType.max]: Max,
+	[NoiseCombineType.min]: Min,
+	[NoiseCombineType.multiply]: Multiply,
+	[NoiseCombineType.power]: Power
 };
 
 //#endregion
@@ -605,6 +651,7 @@ var NoiseCombineNodeTemplateFactory = class {
 			position: Position.Left,
 			dataType: NoiseHandleType.module,
 			connection: "target",
+			minConnections: 2,
 			maxConnections: 2
 		}, {
 			position: Position.Right,
@@ -612,6 +659,19 @@ var NoiseCombineNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return context.incoming[NoiseHandleType.module]?.length === 2;
+		},
+		action(context) {
+			const incoming = context.incoming[NoiseHandleType.module];
+			const ModuleFactory = noiseCombineModuleMap[context.data.operation];
+			context.computed = { module: new ModuleFactory(incoming[0].computed?.module, incoming[1].computed?.module) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -635,6 +695,18 @@ var NoiseCurveNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action(context) {
+			const module = context.incoming[NoiseHandleType.module].computed?.module;
+			if (module) context.computed = { module: new Curve(module, context.data.points.map((p) => new Tuple(p.input, p.output))) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -658,6 +730,19 @@ var NoiseExponentNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action(context) {
+			const module = context.incoming[NoiseHandleType.module].computed?.module;
+			if (context.computed?.module) context.computed.module.exponent = context.data.exponent;
+			else if (module) context.computed = { module: new Exponent(module, context.data.exponent) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -678,6 +763,19 @@ var NoiseInvertNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action(context) {
+			const module = context.incoming[NoiseHandleType.module].computed?.module;
+			if (context.computed?.module) context.computed.module.sourceModule = module;
+			else if (module) context.computed = { module: new Invert(module) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -703,6 +801,18 @@ var NoiseNormalizeNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action(context) {
+			const module = context.incoming[NoiseHandleType.module].computed?.module;
+			if (module) context.computed = { module: new NormalizeNoiseModule(module, context.data.intervalStart, context.data.intervalEnd) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -727,6 +837,22 @@ var NoiseScaleBiasNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action(context) {
+			const module = context.incoming[NoiseHandleType.module].computed?.module;
+			if (context.computed?.module) {
+				context.computed.module.sourceModule = module;
+				context.computed.module.scale = context.data.scale;
+				context.computed.module.bias = context.data.bias;
+			} else if (module) context.computed = { module: new ScaleBias(module, context.data.scale, context.data.bias) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -750,6 +876,18 @@ var NoiseTerraceNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun(context) {
+			return !!context.incoming[NoiseHandleType.module];
+		},
+		action(context) {
+			const module = context.incoming[NoiseHandleType.module].computed?.module;
+			if (module) context.computed = { module: new Terrace(module, context.data.points) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -793,11 +931,35 @@ var NoiseOutputNodeTemplateFactory = class {
 			}
 		]
 	};
+	pipeline = PipelineFactory.create({
+		action: (context) => {
+			const incomingPositions = context.incoming[NoiseHandleType.position];
+			const incomingModule = context.incoming[NoiseHandleType.module];
+			if (incomingPositions?.length && incomingModule?.computed?.module) {
+				const { module } = incomingModule.computed;
+				const noise = [];
+				for (const input of incomingPositions) {
+					const { positions } = input.computed;
+					for (const position of positions) {
+						const value = module.getValue(position.x, position.y, position.z);
+						noise.push({
+							position,
+							value
+						});
+					}
+				}
+				context.computed = { noise };
+			}
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
-//#region src/templates/output/noise-raw-texture-template.ts
-var NoiseRawTextureTemplateFactory = class {
+//#region src/templates/output/noise-texture-data-template.ts
+var NoiseTextureDataTemplateFactory = class {
 	template = {
 		type: NoiseNodeType.textureData,
 		group: NoiseTemplateGroup.output,
@@ -809,10 +971,35 @@ var NoiseRawTextureTemplateFactory = class {
 			maxConnections: 1
 		}, {
 			position: Position.Right,
-			dataType: NoiseHandleType.texture,
+			dataType: NoiseHandleType.textureData,
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun: (context) => {
+			return !!context.incoming[NoiseHandleType.noise]?.computed?.noise.length;
+		},
+		action: (context) => {
+			const noise = context.incoming[NoiseHandleType.noise]?.computed?.noise;
+			const size = Math.ceil(Math.sqrt(noise.length));
+			const colors = noise.flatMap((n) => [
+				n.value * 255,
+				n.value * 255,
+				n.value * 255,
+				255
+			]);
+			const dataArray = new Uint8Array(size * size * 4);
+			dataArray.set(colors);
+			context.computed = {
+				textureData: dataArray,
+				textureResolutionX: size,
+				textureResolutionY: size
+			};
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -844,6 +1031,7 @@ var NoiseBlendNodeTemplateFactory = class {
 				connection: "target",
 				label: "Source Modules",
 				dataId: NoiseSourceControlHandle.source,
+				groupBy: "dataId",
 				maxConnections: 2,
 				minConnections: 2
 			},
@@ -851,6 +1039,7 @@ var NoiseBlendNodeTemplateFactory = class {
 				position: Position.Left,
 				dataType: NoiseHandleType.module,
 				dataId: NoiseSourceControlHandle.control,
+				groupBy: "dataId",
 				connection: "target",
 				label: "Control Module",
 				maxConnections: 1
@@ -863,6 +1052,23 @@ var NoiseBlendNodeTemplateFactory = class {
 			}
 		]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun: (context) => {
+			return context.incoming[NoiseSourceControlHandle.source]?.length === 2 && !!context.incoming[NoiseSourceControlHandle.control];
+		},
+		action: (context) => {
+			const incomingSources = context.incoming[NoiseSourceControlHandle.source];
+			const incomingControl = context.incoming[NoiseSourceControlHandle.control];
+			if (context.computed?.module) {
+				context.computed.module.controlModule = incomingControl.computed.module;
+				context.computed.module.sourceModuleA = incomingSources[0].computed.module;
+				context.computed.module.sourceModuleB = incomingSources[1].computed.module;
+			} else context.computed = { module: new Blend(incomingSources[0].computed.module, incomingSources[1].computed.module, incomingControl.computed.module) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -882,6 +1088,7 @@ var NoiseSelectNodeTemplateFactory = class {
 				position: Position.Left,
 				dataType: NoiseHandleType.module,
 				dataId: NoiseSourceControlHandle.source,
+				groupBy: "dataId",
 				connection: "target",
 				label: "Source Modules",
 				maxConnections: 2,
@@ -891,6 +1098,7 @@ var NoiseSelectNodeTemplateFactory = class {
 				position: Position.Left,
 				dataType: NoiseHandleType.module,
 				dataId: NoiseSourceControlHandle.control,
+				groupBy: "dataId",
 				connection: "target",
 				label: "Control Module",
 				maxConnections: 1
@@ -903,6 +1111,26 @@ var NoiseSelectNodeTemplateFactory = class {
 			}
 		]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun: (context) => {
+			return context.incoming[NoiseSourceControlHandle.source]?.length === 2 && !!context.incoming[NoiseSourceControlHandle.control];
+		},
+		action: (context) => {
+			const incomingSources = context.incoming[NoiseSourceControlHandle.source];
+			const incomingControl = context.incoming[NoiseSourceControlHandle.control];
+			if (context.computed?.module) {
+				context.computed.module.controlModule = incomingControl.computed.module;
+				context.computed.module.sourceModuleA = incomingSources[0].computed.module;
+				context.computed.module.sourceModuleB = incomingSources[1].computed.module;
+				context.computed.module.edgeFalloff = context.data.edgeFalloff;
+				context.computed.module.lowerBound = context.data.lowerBound;
+				context.computed.module.upperBound = context.data.upperBound;
+			} else context.computed = { module: new Select(incomingSources[0].computed.module, incomingSources[1].computed.module, incomingControl.computed.module, context.data.edgeFalloff, context.data.lowerBound, context.data.upperBound) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -919,6 +1147,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
 				label: "Source Module",
 				dataType: NoiseHandleType.module,
 				dataId: DisplacementHandle.sourceModule,
+				groupBy: "dataId",
 				maxConnections: 1
 			},
 			{
@@ -927,6 +1156,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
 				label: "X Module",
 				dataType: NoiseHandleType.module,
 				dataId: DisplacementHandle.xModule,
+				groupBy: "dataId",
 				maxConnections: 1
 			},
 			{
@@ -935,6 +1165,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
 				label: "Y Module",
 				dataType: NoiseHandleType.module,
 				dataId: DisplacementHandle.yModule,
+				groupBy: "dataId",
 				maxConnections: 1
 			},
 			{
@@ -943,6 +1174,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
 				label: "Z Module",
 				dataType: NoiseHandleType.module,
 				dataId: DisplacementHandle.zModule,
+				groupBy: "dataId",
 				maxConnections: 1
 			},
 			{
@@ -953,6 +1185,29 @@ var NoiseDisplaceNodeTemplateFactory = class {
 			}
 		]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun: (context) => {
+			return !!context.incoming[DisplacementHandle.sourceModule]?.computed?.module && !!context.incoming[DisplacementHandle.xModule]?.computed?.module && !!context.incoming[DisplacementHandle.yModule]?.computed?.module && !!context.incoming[DisplacementHandle.zModule]?.computed?.module;
+		},
+		action: (context) => {
+			const sourceModule = context.incoming[DisplacementHandle.sourceModule].computed.module;
+			const xModule = context.incoming[DisplacementHandle.xModule].computed.module;
+			const yModule = context.incoming[DisplacementHandle.yModule].computed.module;
+			const zModule = context.incoming[DisplacementHandle.zModule].computed.module;
+			const hasModules = !!sourceModule && !!xModule && !!yModule && !!zModule;
+			if (context.computed?.module) {
+				if (hasModules) {
+					context.computed.module.sourceModule = sourceModule;
+					context.computed.module.xModule = xModule;
+					context.computed.module.yModule = yModule;
+					context.computed.module.zModule = zModule;
+				}
+			} else context.computed = { module: new Displace(sourceModule, xModule, yModule, zModule) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -979,6 +1234,24 @@ var NoiseRotatePointNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun: (context) => {
+			return !!context.incoming[NoiseHandleType.module]?.computed?.module;
+		},
+		action: (context) => {
+			const sourceModule = context.incoming[NoiseHandleType.module].computed.module;
+			const { xAngle, yAngle, zAngle } = context.data;
+			if (context.computed?.module) {
+				context.computed.module.sourceModule = sourceModule;
+				context.computed.module.xAngle = xAngle;
+				context.computed.module.yAngle = yAngle;
+				context.computed.module.zAngle = zAngle;
+			} else context.computed = { module: new RotatePoint(sourceModule, xAngle, yAngle, zAngle) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -1005,6 +1278,24 @@ var NoiseScalePointNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun: (context) => {
+			return !!context.incoming[NoiseHandleType.module]?.computed?.module;
+		},
+		action: (context) => {
+			const sourceModule = context.incoming[NoiseHandleType.module].computed.module;
+			const { xScale, yScale, zScale } = context.data;
+			if (context.computed?.module) {
+				context.computed.module.sourceModule = sourceModule;
+				context.computed.module.xScale = xScale;
+				context.computed.module.yScale = yScale;
+				context.computed.module.zScale = zScale;
+			} else context.computed = { module: new ScalePoint(sourceModule, xScale, yScale, zScale) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -1031,6 +1322,24 @@ var NoiseTranslatePointNodeTemplateFactory = class {
 			connection: "source"
 		}]
 	};
+	pipeline = PipelineFactory.create({
+		shouldRun: (context) => {
+			return !!context.incoming[NoiseHandleType.module]?.computed?.module;
+		},
+		action: (context) => {
+			const sourceModule = context.incoming[NoiseHandleType.module].computed.module;
+			const { translateX, translateY, translateZ } = context.data;
+			if (context.computed?.module) {
+				context.computed.module.sourceModule = sourceModule;
+				context.computed.module.translateX = translateX;
+				context.computed.module.translateY = translateY;
+				context.computed.module.translateZ = translateZ;
+			} else context.computed = { module: new TranslatePoint(sourceModule, translateX, translateY, translateZ) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
@@ -1067,50 +1376,69 @@ var NoiseTurbulenceNodeTemplateFactory = class {
 			}
 		]
 	};
+	pipeline = PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		shouldRun: (context) => {
+			return !!context.incoming[NoiseHandleType.module]?.computed?.module;
+		},
+		action: (context) => {
+			const { properties } = context;
+			const incoming = context.incoming[NoiseHandleType.module].computed.module;
+			if (context.computed?.module) {
+				context.computed.module.sourceModule = incoming;
+				context.computed.module.frequency = properties.frequency;
+				context.computed.module.power = properties.power;
+				context.computed.module.roughness = properties.roughness;
+				context.computed.module.seed = properties.seed;
+			} else context.computed = { module: new Turbulence(incoming, properties.frequency, properties.power, properties.roughness, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
 };
 
 //#endregion
 //#region src/abstract/node-types.ts
-let NoiseNodeType = /* @__PURE__ */ function(NoiseNodeType$1) {
-	NoiseNodeType$1["position"] = "position";
-	NoiseNodeType$1["grid"] = "grid";
-	NoiseNodeType$1["textureData"] = "texture-data";
-	NoiseNodeType$1["groupModule"] = "group-module";
-	NoiseNodeType$1["positionLogger"] = "position-logger";
-	NoiseNodeType$1["noiseLogger"] = "noise-logger";
-	NoiseNodeType$1["noiseOutput"] = "noise-output";
-	NoiseNodeType$1["noiseConst"] = "noise-constant";
-	NoiseNodeType$1["noiseBillow"] = "noise-billow";
-	NoiseNodeType$1["noiseCheckerboard"] = "noise-checkerboard";
-	NoiseNodeType$1["noiseNormalize"] = "noise-normalize";
-	NoiseNodeType$1["noiseCylinders"] = "noise-cylinders";
-	NoiseNodeType$1["noisePerlin"] = "noise-perlin";
-	NoiseNodeType$1["noiseRidgedMulti"] = "noise-ridged-multi";
-	NoiseNodeType$1["noiseSpheres"] = "noise-spheres";
-	NoiseNodeType$1["noiseVoronoi"] = "noise-voronoi";
-	NoiseNodeType$1["noiseCombine"] = "noise-combiner";
-	NoiseNodeType$1["noiseClamp"] = "noise-clamp";
-	NoiseNodeType$1["noiseAbs"] = "noise-abs";
-	NoiseNodeType$1["noiseCurve"] = "noise-curve";
-	NoiseNodeType$1["noiseExponent"] = "noise-exponent";
-	NoiseNodeType$1["noiseInvert"] = "noise-invert";
-	NoiseNodeType$1["noiseScaleBias"] = "noise-scale-bias";
-	NoiseNodeType$1["noiseTerrace"] = "noise-terrace";
-	NoiseNodeType$1["noiseBlend"] = "noise-blend";
-	NoiseNodeType$1["noiseSelect"] = "noise-select";
-	NoiseNodeType$1["noiseDisplace"] = "noise-displace";
-	NoiseNodeType$1["noiseRotatePoint"] = "noise-rotate-point";
-	NoiseNodeType$1["noiseScalePoint"] = "noise-scale-point";
-	NoiseNodeType$1["noiseTranslatePoint"] = "noise-translate-point";
-	NoiseNodeType$1["noiseTurbulence"] = "noise-turbulence";
-	return NoiseNodeType$1;
+let NoiseNodeType = /* @__PURE__ */ function(NoiseNodeType) {
+	NoiseNodeType["position"] = "position";
+	NoiseNodeType["grid"] = "grid";
+	NoiseNodeType["textureData"] = "texture-data";
+	NoiseNodeType["groupModule"] = "group-module";
+	NoiseNodeType["positionLogger"] = "position-logger";
+	NoiseNodeType["noiseLogger"] = "noise-logger";
+	NoiseNodeType["noiseOutput"] = "noise-output";
+	NoiseNodeType["noiseConst"] = "noise-constant";
+	NoiseNodeType["noiseBillow"] = "noise-billow";
+	NoiseNodeType["noiseCheckerboard"] = "noise-checkerboard";
+	NoiseNodeType["noiseNormalize"] = "noise-normalize";
+	NoiseNodeType["noiseCylinders"] = "noise-cylinders";
+	NoiseNodeType["noisePerlin"] = "noise-perlin";
+	NoiseNodeType["noiseRidgedMulti"] = "noise-ridged-multi";
+	NoiseNodeType["noiseSpheres"] = "noise-spheres";
+	NoiseNodeType["noiseVoronoi"] = "noise-voronoi";
+	NoiseNodeType["noiseCombine"] = "noise-combiner";
+	NoiseNodeType["noiseClamp"] = "noise-clamp";
+	NoiseNodeType["noiseAbs"] = "noise-abs";
+	NoiseNodeType["noiseCurve"] = "noise-curve";
+	NoiseNodeType["noiseExponent"] = "noise-exponent";
+	NoiseNodeType["noiseInvert"] = "noise-invert";
+	NoiseNodeType["noiseScaleBias"] = "noise-scale-bias";
+	NoiseNodeType["noiseTerrace"] = "noise-terrace";
+	NoiseNodeType["noiseBlend"] = "noise-blend";
+	NoiseNodeType["noiseSelect"] = "noise-select";
+	NoiseNodeType["noiseDisplace"] = "noise-displace";
+	NoiseNodeType["noiseRotatePoint"] = "noise-rotate-point";
+	NoiseNodeType["noiseScalePoint"] = "noise-scale-point";
+	NoiseNodeType["noiseTranslatePoint"] = "noise-translate-point";
+	NoiseNodeType["noiseTurbulence"] = "noise-turbulence";
+	return NoiseNodeType;
 }({});
 const noiseNodeTypes = {
 	[NoiseNodeType.groupModule]: module_group_node_default,
 	[NoiseNodeType.position]: position_const_node_default,
 	[NoiseNodeType.grid]: position_grid_node_default,
 	[NoiseNodeType.noiseOutput]: noise_output_node_default,
-	[NoiseNodeType.textureData]: noise_raw_texture_node_default,
+	[NoiseNodeType.textureData]: noise_texture_data_node_default,
 	[NoiseNodeType.noiseLogger]: noise_logger_node_default,
 	[NoiseNodeType.positionLogger]: positions_logger_node_default,
 	[NoiseNodeType.noiseConst]: noise_const_node_default,
@@ -1148,7 +1476,7 @@ const noiseNodeTemplates = {
 	[NoiseNodeType.position]: new PositionConstNodeTemplateFactory(),
 	[NoiseNodeType.positionLogger]: new PositionLoggerNodeTemplateFactory(),
 	[NoiseNodeType.grid]: new PositionGridNodeTemplateFactory(),
-	[NoiseNodeType.textureData]: new NoiseRawTextureTemplateFactory(),
+	[NoiseNodeType.textureData]: new NoiseTextureDataTemplateFactory(),
 	[NoiseNodeType.noiseCylinders]: new NoiseCylindersNodeTemplateFactory(),
 	[NoiseNodeType.noisePerlin]: new NoisePerlinNodeTemplateFactory(),
 	[NoiseNodeType.noiseRidgedMulti]: new NoiseRidgedMultiNodeTemplateFactory(),
@@ -1173,5 +1501,5 @@ const noiseNodeTemplates = {
 };
 
 //#endregion
-export { ModuleGroupNodeTemplateFactory, NoiseAbsNodeTemplateFactory, NoiseBillowNodeTemplateFactory, NoiseBlendNodeTemplateFactory, NoiseCheckerboardNodeTemplateFactory, NoiseClampNodeTemplateFactory, NoiseCombineNodeTemplateFactory, NoiseConstNodeTemplateFactory, NoiseCurveNodeTemplateFactory, NoiseCylindersNodeTemplateFactory, NoiseDisplaceNodeTemplateFactory, NoiseExponentNodeTemplateFactory, NoiseInvertNodeTemplateFactory, NoiseLoggerNodeTemplateFactory, NoiseNodeType, NoiseNormalizeNodeTemplateFactory, NoiseOutputNodeTemplateFactory, NoisePerlinNodeTemplateFactory, NoiseRawTextureTemplateFactory, NoiseRidgedMultiNodeTemplateFactory, NoiseRotatePointNodeTemplateFactory, NoiseScaleBiasNodeTemplateFactory, NoiseScalePointNodeTemplateFactory, NoiseSelectNodeTemplateFactory, NoiseSpheresNodeTemplateFactory, NoiseTemplateGroup, NoiseTerraceNodeTemplateFactory, NoiseTranslatePointNodeTemplateFactory, NoiseTurbulenceNodeTemplateFactory, NoiseVoronoiNodeTemplateFactory, PositionConstNodeTemplateFactory, PositionGridNodeTemplateFactory, PositionLoggerNodeTemplateFactory, noiseNodeTemplates, noiseNodeTypes, noise_blend_node_default, noise_logger_node_default, noise_output_node_default, noise_raw_texture_node_default, noise_select_node_default, positions_logger_node_default };
-//# sourceMappingURL=abstract-Dhf_tSuO.js.map
+export { NoiseSpheresNodeTemplateFactory as A, noise_output_node_default as B, noiseCombineModuleMap as C, PositionGridNodeTemplateFactory as D, ModuleGroupNodeTemplateFactory as E, NoiseCheckerboardNodeTemplateFactory as F, DisplacementHandle as H, NoiseBillowNodeTemplateFactory as I, NoiseTemplateGroup as L, NoisePerlinNodeTemplateFactory as M, NoiseCylindersNodeTemplateFactory as N, PositionConstNodeTemplateFactory as O, NoiseConstNodeTemplateFactory as P, positions_logger_node_default as R, NoiseCombineType as S, NoiseAbsNodeTemplateFactory as T, NoiseHandleType as U, noise_logger_node_default as V, NoiseSourceControlHandle as W, NoiseNormalizeNodeTemplateFactory as _, NoiseTranslatePointNodeTemplateFactory as a, NoiseCurveNodeTemplateFactory as b, NoiseDisplaceNodeTemplateFactory as c, PositionLoggerNodeTemplateFactory as d, NoiseTextureDataTemplateFactory as f, NoiseScaleBiasNodeTemplateFactory as g, NoiseTerraceNodeTemplateFactory as h, NoiseTurbulenceNodeTemplateFactory as i, NoiseRidgedMultiNodeTemplateFactory as j, NoiseVoronoiNodeTemplateFactory as k, NoiseSelectNodeTemplateFactory as l, NoiseLoggerNodeTemplateFactory as m, noiseNodeTemplates as n, NoiseScalePointNodeTemplateFactory as o, NoiseOutputNodeTemplateFactory as p, noiseNodeTypes as r, NoiseRotatePointNodeTemplateFactory as s, NoiseNodeType as t, NoiseBlendNodeTemplateFactory as u, NoiseInvertNodeTemplateFactory as v, NoiseClampNodeTemplateFactory as w, NoiseCombineNodeTemplateFactory as x, NoiseExponentNodeTemplateFactory as y, noise_texture_data_node_default as z };
+//# sourceMappingURL=abstract-DNmiw2MC.mjs.map