@awesome-flow/noise 0.9.3 → 0.9.4

package/dist/abstract-Db8fFoLp.cjs

@@ -0,0 +1,1423 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_transformers = require('./transformers-C-NV_u9j.cjs');
+const require_generators = require('./generators-D3RjZdMN.cjs');
+const require_groups = require('./groups-BIS2AF5M.cjs');
+const require_modifiers = require('./modifiers-DU7AkD-K.cjs');
+const __awesome_flow_core_components = require_chunk.__toESM(require("@awesome-flow/core/components"));
+const __awesome_flow_core_hooks = require_chunk.__toESM(require("@awesome-flow/core/hooks"));
+const __awesome_flow_core_layout = require_chunk.__toESM(require("@awesome-flow/core/layout"));
+const libnoise_simplex_ts = require_chunk.__toESM(require("libnoise-simplex-ts"));
+const react = require_chunk.__toESM(require("react"));
+const react_jsx_runtime = require_chunk.__toESM(require("react/jsx-runtime"));
+const __mantine_core = require_chunk.__toESM(require("@mantine/core"));
+const __awesome_flow_core_abstract = require_chunk.__toESM(require("@awesome-flow/core/abstract"));
+const __awesome_flow_core_utils = require_chunk.__toESM(require("@awesome-flow/core/utils"));
+const __xyflow_system = require_chunk.__toESM(require("@xyflow/system"));
+
+//#region src/nodes/output/noise-logger-node.tsx
+function NoiseLoggerNode({ id, selected, data, type }) {
+	const incoming = (0, __awesome_flow_core_hooks.useIncomingComputedData)(id);
+	const noise = (0, react.useMemo)(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__awesome_flow_core_layout.NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Text, { children: ["Size: ", noise?.length || 0] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__mantine_core.Divider, { h: 5 }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__mantine_core.Stack, { children: noise?.map((v, i) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Text, { children: [
+				v.position?.x,
+				":",
+				v.position?.y,
+				":",
+				v.position?.z,
+				": ",
+				v.value
+			] }, i)) })
+		]
+	});
+}
+var noise_logger_node_default = NoiseLoggerNode;
+
+//#endregion
+//#region src/nodes/output/noise-output-node.tsx
+function NoiseOutputNode({ id, selected, data, type }) {
+	const [size, setSize] = (0, react.useState)(0);
+	const updateComputedData = (0, __awesome_flow_core_hooks.useUpdateNodeComputedData)();
+	const onDataUpdated = (0, react.useCallback)((handleData) => {
+		const incomingPositions = handleData[require_transformers.NoiseHandleType.position];
+		const incomingModule = handleData[require_transformers.NoiseHandleType.module];
+		if (incomingPositions?.length && incomingModule?.length && incomingModule[0]?.module) {
+			const { module: module$1 } = incomingModule[0];
+			const noise = [];
+			for (const input of incomingPositions) for (const position of input.positions) {
+				const value = module$1.getValue(position.x, position.y, position.z);
+				noise.push({
+					position,
+					value
+				});
+			}
+			updateComputedData(id, {
+				noise,
+				module: module$1
+			});
+			setSize(noise.length);
+		}
+	}, [updateComputedData, id]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__awesome_flow_core_layout.NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__awesome_flow_core_components.HandlesIncomingDataStatus, {
+			nodeId: id,
+			handles: data.handles,
+			groupBy: "dataType",
+			onDataUpdated,
+			type: "target",
+			resetComputedData: true
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Text, {
+			mt: 5,
+			children: ["Noise points: ", size]
+		})]
+	});
+}
+var noise_output_node_default = NoiseOutputNode;
+
+//#endregion
+//#region src/nodes/output/noise-raw-texture-node.tsx
+function NoiseRawTextureNode({ id, selected, data, type }) {
+	const updateComputedData = (0, __awesome_flow_core_hooks.useUpdateNodeComputedData)();
+	const [dataLength, setDataLength] = (0, react.useState)(0);
+	const [resolution, setResolution] = (0, react.useState)(0);
+	const incoming = (0, __awesome_flow_core_hooks.useIncomingComputedData)(id);
+	const noise = (0, react.useMemo)(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+	(0, react.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
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__awesome_flow_core_layout.NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Stack, { children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Group, { children: [
+				"Resolution: ",
+				resolution,
+				"x",
+				resolution
+			] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Group, { children: ["Input Length: ", noise?.length || 0] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Group, { children: [
+				"Output Length (",
+				resolution,
+				"*",
+				resolution,
+				"*4): ",
+				dataLength
+			] })
+		] })
+	});
+}
+var noise_raw_texture_node_default = NoiseRawTextureNode;
+
+//#endregion
+//#region src/nodes/output/positions-logger-node.tsx
+function PositionsLoggerNode({ id, selected, data, type }) {
+	const incoming = (0, __awesome_flow_core_hooks.useIncomingComputedData)(id);
+	const positions = (0, react.useMemo)(() => {
+		return incoming?.map((p) => p.positions).flat();
+	}, [incoming]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__awesome_flow_core_layout.NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Text, { children: ["Size: ", positions?.length || 0] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__mantine_core.Divider, { h: 5 }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__mantine_core.Stack, { children: positions?.map((v, i) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Text, { children: [
+				v.x,
+				":",
+				v.y,
+				":",
+				v.z
+			] }, i)) })
+		]
+	});
+}
+var positions_logger_node_default = PositionsLoggerNode;
+
+//#endregion
+//#region src/nodes/selectors/noise-blend-node.tsx
+function NoiseBlendNode({ id, selected, data, type }) {
+	const updateComputedData = (0, __awesome_flow_core_hooks.useUpdateNodeComputedData)();
+	const onDataUpdated = (0, react.useCallback)((incomingData) => {
+		const incomingSources = incomingData[require_transformers.NoiseSourceControlHandle.source];
+		const incomingControl = incomingData[require_transformers.NoiseSourceControlHandle.control];
+		if (incomingSources?.length >= 2 && incomingControl?.length) {
+			const module$1 = new libnoise_simplex_ts.Blend(incomingSources[0].module, incomingSources[1].module, incomingControl[0].module);
+			updateComputedData(id, { module: module$1 });
+		}
+	}, [id, updateComputedData]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__awesome_flow_core_layout.NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__awesome_flow_core_components.HandlesIncomingDataStatus, {
+			nodeId: id,
+			handles: data.handles,
+			groupBy: "dataId",
+			onDataUpdated,
+			type: "target",
+			resetComputedData: true
+		})
+	});
+}
+var noise_blend_node_default = NoiseBlendNode;
+
+//#endregion
+//#region src/nodes/selectors/noise-select-node.tsx
+function NoiseSelectNode({ id, selected, data, type }) {
+	const [edgeFalloff, setEdgeFalloff] = (0, react.useState)(data.edgeFalloff);
+	const [lowerBound, setLowerBound] = (0, react.useState)(data.lowerBound);
+	const [upperBound, setUpperBound] = (0, react.useState)(data.upperBound);
+	const updateNodeData = (0, __awesome_flow_core_hooks.useUpdateNodeData)();
+	const updateComputedData = (0, __awesome_flow_core_hooks.useUpdateNodeComputedData)();
+	(0, react.useEffect)(() => {
+		updateNodeData(id, {
+			edgeFalloff,
+			lowerBound,
+			upperBound
+		});
+	}, [
+		edgeFalloff,
+		lowerBound,
+		upperBound,
+		id,
+		updateNodeData
+	]);
+	const onDataUpdated = (0, react.useCallback)((incomingData) => {
+		const incomingSources = incomingData[require_transformers.NoiseSourceControlHandle.source];
+		const incomingControl = incomingData[require_transformers.NoiseSourceControlHandle.control];
+		if (incomingSources?.length >= 2 && incomingControl?.length) {
+			const module$1 = new libnoise_simplex_ts.Select(incomingSources[0].module, incomingSources[1].module, incomingControl[0].module, edgeFalloff, lowerBound, upperBound);
+			updateComputedData(id, { module: module$1 });
+		}
+	}, [
+		updateComputedData,
+		id,
+		edgeFalloff,
+		lowerBound,
+		upperBound
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__awesome_flow_core_layout.NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Stack, { children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Group, { children: ["Edge Falloff:", /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__mantine_core.NumberInput, {
+				size: "xs",
+				w: 100,
+				value: edgeFalloff,
+				onChange: (e) => setEdgeFalloff(Number(e)),
+				step: .1
+			})] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Group, { children: ["Lower Bound:", /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__mantine_core.NumberInput, {
+				size: "xs",
+				w: 100,
+				value: lowerBound,
+				onChange: (e) => setLowerBound(Number(e)),
+				step: .1
+			})] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__mantine_core.Group, { children: ["Upper Bound:", /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__mantine_core.NumberInput, {
+				size: "xs",
+				w: 100,
+				value: upperBound,
+				onChange: (e) => setUpperBound(Number(e)),
+				step: .1
+			})] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__awesome_flow_core_components.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;
+}({});
+
+//#endregion
+//#region src/templates/generators/noise-billow-template.ts
+var NoiseBillowNodeTemplateFactory = class {
+	template = {
+		id: __awesome_flow_core_utils.IDGenerator.template(),
+		type: NoiseNodeType.noiseBillow,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: {
+			title: "Billow Noise",
+			frequency: .1,
+			lacunarity: 2,
+			octaves: 5,
+			persistence: .5,
+			seed: 0
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: __awesome_flow_core_abstract.CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/noise-checkerboard-template.ts
+var NoiseCheckerboardNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseCheckerboard,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: { title: "Checkerboard Noise" },
+		handles: [{
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/noise-const-template.ts
+var NoiseConstNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseConst,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: {
+			title: "Const Value Noise",
+			noise: 0,
+			min: -1,
+			max: 1
+		},
+		handles: [{
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/noise-cylinders-template.ts
+var NoiseCylindersNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseCylinders,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: {
+			title: "Cylinders Noise",
+			frequency: .1
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: __awesome_flow_core_abstract.CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/noise-perlin-template.ts
+var NoisePerlinNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noisePerlin,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: {
+			title: "Perlin Noise",
+			frequency: .1,
+			lacunarity: 2,
+			octaves: 5,
+			persistence: .5,
+			seed: 0
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: __awesome_flow_core_abstract.CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/noise-ridgedmulti-template.ts
+var NoiseRidgedMultiNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseRidgedMulti,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: {
+			title: "Ridged Multi Noise",
+			frequency: .1,
+			lacunarity: 2,
+			octaves: 6,
+			offset: 1,
+			gain: 2,
+			seed: 0
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: __awesome_flow_core_abstract.CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/noise-spheres-template.ts
+var NoiseSpheresNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseSpheres,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: {
+			title: "Spheres Noise",
+			frequency: .1
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: __awesome_flow_core_abstract.CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/noise-voronoi-template.ts
+var NoiseVoronoiNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseVoronoi,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: {
+			title: "Voronoi Noise",
+			frequency: .1,
+			displacement: 1,
+			distance: true,
+			seed: 0
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: __awesome_flow_core_abstract.CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/position-const-template.ts
+var PositionConstNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.position,
+		group: NoiseTemplateGroup.positions,
+		data: {
+			title: "Position Output",
+			position: {
+				x: 0,
+				y: 0,
+				z: 0
+			}
+		},
+		handles: [{
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.position,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/generators/position-grid-template.ts
+var PositionGridNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.grid,
+		group: NoiseTemplateGroup.positions,
+		data: {
+			title: "Grid Output",
+			center: {
+				x: 0,
+				y: 0,
+				z: 0
+			},
+			radius: 1
+		},
+		handles: [{
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.position,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/groups/module-group-template.ts
+var ModuleGroupNodeTemplateFactory = class {
+	template = {
+		id: __awesome_flow_core_utils.IDGenerator.template(),
+		type: NoiseNodeType.groupModule,
+		group: __awesome_flow_core_abstract.CoreTemplateGroup.groups,
+		data: {
+			title: "Modules Group",
+			isGroup: true,
+			initialSize: {
+				width: 300,
+				height: 200
+			},
+			collapsedSize: {
+				width: 300,
+				height: 80
+			}
+		},
+		handles: [{
+			position: __xyflow_system.Position.Bottom,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1,
+			hideOnCollapse: true
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-abs-template.ts
+var NoiseAbsNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseAbs,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: { title: "Abs Noise" },
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-clamp-template.ts
+var NoiseClampNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseClamp,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: {
+			title: "Clamp Noise",
+			lowerBound: -1,
+			upperBound: 1
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-combine-template.ts
+var NoiseCombineNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseCombine,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: {
+			title: "Combine Noise",
+			operation: require_modifiers.NoiseCombineType.add
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 2
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-curve-template.ts
+var NoiseCurveNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseCurve,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: {
+			title: "Noise Curve",
+			points: []
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-exponent-template.ts
+var NoiseExponentNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseExponent,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: {
+			title: "Noise Exponent",
+			exponent: 1
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-invert-template.ts
+var NoiseInvertNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseInvert,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: { title: "Invert Noise" },
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-normalize-template.ts
+var NoiseNormalizeNodeTemplateFactory = class {
+	template = {
+		id: __awesome_flow_core_utils.IDGenerator.template(),
+		type: NoiseNodeType.noiseNormalize,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: {
+			title: "Normalize Noise",
+			intervalStart: -1,
+			intervalEnd: 1
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-scalebias-template.ts
+var NoiseScaleBiasNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseScaleBias,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: {
+			title: "Scale/Bias Noise",
+			scale: 1,
+			bias: 0
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-terrace-template.ts
+var NoiseTerraceNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseTerrace,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: {
+			title: "Noise Terrace",
+			points: []
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/output/noise-logger-template.ts
+var NoiseLoggerNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseLogger,
+		group: NoiseTemplateGroup.output,
+		data: { title: "Noise Logger" },
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.noise,
+			connection: "target"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/output/noise-output-template.ts
+var NoiseOutputNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseOutput,
+		group: NoiseTemplateGroup.output,
+		data: { title: "Noise Output" },
+		handles: [
+			{
+				position: __xyflow_system.Position.Left,
+				dataType: require_transformers.NoiseHandleType.position,
+				connection: "target"
+			},
+			{
+				position: __xyflow_system.Position.Left,
+				dataType: require_transformers.NoiseHandleType.module,
+				connection: "target",
+				maxConnections: 1
+			},
+			{
+				position: __xyflow_system.Position.Right,
+				dataType: require_transformers.NoiseHandleType.noise,
+				connection: "source"
+			}
+		]
+	};
+};
+
+//#endregion
+//#region src/templates/output/noise-raw-texture-template.ts
+var NoiseRawTextureTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.textureData,
+		group: NoiseTemplateGroup.output,
+		data: { title: "Texture Data" },
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.noise,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.texture,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/output/position-logger-template.ts
+var PositionLoggerNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.positionLogger,
+		group: NoiseTemplateGroup.positions,
+		data: { title: "Position Logger" },
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.position,
+			connection: "target"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/selectors/noise-blend-template.ts
+var NoiseBlendNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseBlend,
+		group: NoiseTemplateGroup.noiseSelectors,
+		data: { title: "Noise Blend" },
+		handles: [
+			{
+				position: __xyflow_system.Position.Left,
+				dataType: require_transformers.NoiseHandleType.module,
+				connection: "target",
+				label: "Source Modules",
+				dataId: require_transformers.NoiseSourceControlHandle.source,
+				maxConnections: 2,
+				minConnections: 2
+			},
+			{
+				position: __xyflow_system.Position.Left,
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.NoiseSourceControlHandle.control,
+				connection: "target",
+				label: "Control Module",
+				maxConnections: 1
+			},
+			{
+				position: __xyflow_system.Position.Right,
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.NoiseSourceControlHandle.output,
+				connection: "source"
+			}
+		]
+	};
+};
+
+//#endregion
+//#region src/templates/selectors/noise-select-template.ts
+var NoiseSelectNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseSelect,
+		group: NoiseTemplateGroup.noiseSelectors,
+		data: {
+			title: "Noise Select",
+			edgeFalloff: 0,
+			lowerBound: -1,
+			upperBound: 1
+		},
+		handles: [
+			{
+				position: __xyflow_system.Position.Left,
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.NoiseSourceControlHandle.source,
+				connection: "target",
+				label: "Source Modules",
+				maxConnections: 2,
+				minConnections: 2
+			},
+			{
+				position: __xyflow_system.Position.Left,
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.NoiseSourceControlHandle.control,
+				connection: "target",
+				label: "Control Module",
+				maxConnections: 1
+			},
+			{
+				position: __xyflow_system.Position.Right,
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.NoiseSourceControlHandle.output,
+				connection: "source"
+			}
+		]
+	};
+};
+
+//#endregion
+//#region src/templates/transformers/noise-displace-template.ts
+var NoiseDisplaceNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseDisplace,
+		group: NoiseTemplateGroup.noiseTransformers,
+		data: { title: "Noise Displace" },
+		handles: [
+			{
+				position: __xyflow_system.Position.Left,
+				connection: "target",
+				label: "Source Module",
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.DisplacementHandle.sourceModule,
+				maxConnections: 1
+			},
+			{
+				position: __xyflow_system.Position.Left,
+				connection: "target",
+				label: "X Module",
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.DisplacementHandle.xModule,
+				maxConnections: 1
+			},
+			{
+				position: __xyflow_system.Position.Left,
+				connection: "target",
+				label: "Y Module",
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.DisplacementHandle.yModule,
+				maxConnections: 1
+			},
+			{
+				position: __xyflow_system.Position.Left,
+				connection: "target",
+				label: "Z Module",
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.DisplacementHandle.zModule,
+				maxConnections: 1
+			},
+			{
+				position: __xyflow_system.Position.Right,
+				dataType: require_transformers.NoiseHandleType.module,
+				dataId: require_transformers.DisplacementHandle.output,
+				connection: "source"
+			}
+		]
+	};
+};
+
+//#endregion
+//#region src/templates/transformers/noise-rotate-point-template.ts
+var NoiseRotatePointNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseRotatePoint,
+		group: NoiseTemplateGroup.noiseTransformers,
+		data: {
+			title: "Noise Rotate Point",
+			xAngle: 0,
+			yAngle: 0,
+			zAngle: 0
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/transformers/noise-scale-point-template.ts
+var NoiseScalePointNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseScalePoint,
+		group: NoiseTemplateGroup.noiseTransformers,
+		data: {
+			title: "Noise Scale Point",
+			xScale: 1,
+			yScale: 1,
+			zScale: 1
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/transformers/noise-translate-point-template.ts
+var NoiseTranslatePointNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseTranslatePoint,
+		group: NoiseTemplateGroup.noiseTransformers,
+		data: {
+			title: "Noise Translate Point",
+			translateX: 0,
+			translateY: 0,
+			translateZ: 0
+		},
+		handles: [{
+			position: __xyflow_system.Position.Left,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: __xyflow_system.Position.Right,
+			dataType: require_transformers.NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/transformers/noise-turbulence-template.ts
+var NoiseTurbulenceNodeTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.noiseTurbulence,
+		group: NoiseTemplateGroup.noiseTransformers,
+		data: {
+			title: "Noise Turbulence",
+			frequency: 1,
+			power: 1,
+			roughness: 1,
+			seed: 0
+		},
+		handles: [
+			{
+				position: __xyflow_system.Position.Left,
+				dataType: require_transformers.NoiseHandleType.module,
+				connection: "target",
+				label: "Source Module",
+				maxConnections: 1
+			},
+			{
+				position: __xyflow_system.Position.Left,
+				dataType: __awesome_flow_core_abstract.CoreHandleType.variableProperty,
+				label: "Variable Properties",
+				connection: "target"
+			},
+			{
+				position: __xyflow_system.Position.Right,
+				dataType: require_transformers.NoiseHandleType.module,
+				connection: "source"
+			}
+		]
+	};
+};
+
+//#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;
+}({});
+const noiseNodeTypes = {
+	[NoiseNodeType.groupModule]: require_groups.module_group_node_default,
+	[NoiseNodeType.position]: require_generators.position_const_node_default,
+	[NoiseNodeType.grid]: require_generators.position_grid_node_default,
+	[NoiseNodeType.noiseOutput]: noise_output_node_default,
+	[NoiseNodeType.textureData]: noise_raw_texture_node_default,
+	[NoiseNodeType.noiseLogger]: noise_logger_node_default,
+	[NoiseNodeType.positionLogger]: positions_logger_node_default,
+	[NoiseNodeType.noiseConst]: require_generators.noise_const_node_default,
+	[NoiseNodeType.noiseBillow]: require_generators.noise_billow_node_default,
+	[NoiseNodeType.noiseCheckerboard]: require_generators.noise_checkerboard_node_default,
+	[NoiseNodeType.noiseCylinders]: require_generators.noise_cylinders_node_default,
+	[NoiseNodeType.noisePerlin]: require_generators.noise_perlin_node_default,
+	[NoiseNodeType.noiseRidgedMulti]: require_generators.noise_ridgedmulti_node_default,
+	[NoiseNodeType.noiseSpheres]: require_generators.noise_spheres_node_default,
+	[NoiseNodeType.noiseVoronoi]: require_generators.noise_voronoi_node_default,
+	[NoiseNodeType.noiseCombine]: require_modifiers.noise_combine_node_default,
+	[NoiseNodeType.noiseClamp]: require_modifiers.noise_clamp_node_default,
+	[NoiseNodeType.noiseAbs]: require_modifiers.noise_abs_node_default,
+	[NoiseNodeType.noiseNormalize]: require_modifiers.noise_normalize_node_default,
+	[NoiseNodeType.noiseCurve]: require_modifiers.noise_curve_node_default,
+	[NoiseNodeType.noiseExponent]: require_modifiers.noise_exponent_node_default,
+	[NoiseNodeType.noiseInvert]: require_modifiers.noise_invert_node_default,
+	[NoiseNodeType.noiseScaleBias]: require_modifiers.noise_scale_bias_node_default,
+	[NoiseNodeType.noiseTerrace]: require_modifiers.noise_terrace_node_default,
+	[NoiseNodeType.noiseBlend]: noise_blend_node_default,
+	[NoiseNodeType.noiseSelect]: noise_select_node_default,
+	[NoiseNodeType.noiseDisplace]: require_transformers.noise_displace_node_default,
+	[NoiseNodeType.noiseRotatePoint]: require_transformers.noise_rotate_point_node_default,
+	[NoiseNodeType.noiseScalePoint]: require_transformers.noise_scale_point_node_default,
+	[NoiseNodeType.noiseTranslatePoint]: require_transformers.noise_translate_point_node_default,
+	[NoiseNodeType.noiseTurbulence]: require_transformers.noise_turbulence_node_default
+};
+const noiseNodeTemplates = {
+	[NoiseNodeType.noiseOutput]: new NoiseOutputNodeTemplateFactory(),
+	[NoiseNodeType.noiseBillow]: new NoiseBillowNodeTemplateFactory(),
+	[NoiseNodeType.noiseCheckerboard]: new NoiseCheckerboardNodeTemplateFactory(),
+	[NoiseNodeType.noiseNormalize]: new NoiseNormalizeNodeTemplateFactory(),
+	[NoiseNodeType.noiseLogger]: new NoiseLoggerNodeTemplateFactory(),
+	[NoiseNodeType.noiseConst]: new NoiseConstNodeTemplateFactory(),
+	[NoiseNodeType.position]: new PositionConstNodeTemplateFactory(),
+	[NoiseNodeType.positionLogger]: new PositionLoggerNodeTemplateFactory(),
+	[NoiseNodeType.grid]: new PositionGridNodeTemplateFactory(),
+	[NoiseNodeType.textureData]: new NoiseRawTextureTemplateFactory(),
+	[NoiseNodeType.noiseCylinders]: new NoiseCylindersNodeTemplateFactory(),
+	[NoiseNodeType.noisePerlin]: new NoisePerlinNodeTemplateFactory(),
+	[NoiseNodeType.noiseRidgedMulti]: new NoiseRidgedMultiNodeTemplateFactory(),
+	[NoiseNodeType.noiseSpheres]: new NoiseSpheresNodeTemplateFactory(),
+	[NoiseNodeType.noiseVoronoi]: new NoiseVoronoiNodeTemplateFactory(),
+	[NoiseNodeType.noiseCombine]: new NoiseCombineNodeTemplateFactory(),
+	[NoiseNodeType.noiseClamp]: new NoiseClampNodeTemplateFactory(),
+	[NoiseNodeType.noiseAbs]: new NoiseAbsNodeTemplateFactory(),
+	[NoiseNodeType.noiseCurve]: new NoiseCurveNodeTemplateFactory(),
+	[NoiseNodeType.noiseExponent]: new NoiseExponentNodeTemplateFactory(),
+	[NoiseNodeType.noiseInvert]: new NoiseInvertNodeTemplateFactory(),
+	[NoiseNodeType.noiseScaleBias]: new NoiseScaleBiasNodeTemplateFactory(),
+	[NoiseNodeType.noiseTerrace]: new NoiseTerraceNodeTemplateFactory(),
+	[NoiseNodeType.noiseBlend]: new NoiseBlendNodeTemplateFactory(),
+	[NoiseNodeType.noiseSelect]: new NoiseSelectNodeTemplateFactory(),
+	[NoiseNodeType.noiseDisplace]: new NoiseDisplaceNodeTemplateFactory(),
+	[NoiseNodeType.noiseRotatePoint]: new NoiseRotatePointNodeTemplateFactory(),
+	[NoiseNodeType.noiseScalePoint]: new NoiseScalePointNodeTemplateFactory(),
+	[NoiseNodeType.noiseTranslatePoint]: new NoiseTranslatePointNodeTemplateFactory(),
+	[NoiseNodeType.noiseTurbulence]: new NoiseTurbulenceNodeTemplateFactory(),
+	[NoiseNodeType.groupModule]: new ModuleGroupNodeTemplateFactory()
+};
+
+//#endregion
+Object.defineProperty(exports, 'ModuleGroupNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return ModuleGroupNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseAbsNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseAbsNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseBillowNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseBillowNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseBlendNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseBlendNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseCheckerboardNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseCheckerboardNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseClampNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseClampNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseCombineNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseCombineNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseConstNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseConstNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseCurveNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseCurveNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseCylindersNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseCylindersNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseDisplaceNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseDisplaceNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseExponentNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseExponentNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseInvertNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseInvertNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseLoggerNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseLoggerNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseNodeType', {
+  enumerable: true,
+  get: function () {
+    return NoiseNodeType;
+  }
+});
+Object.defineProperty(exports, 'NoiseNormalizeNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseNormalizeNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseOutputNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseOutputNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoisePerlinNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoisePerlinNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseRawTextureTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseRawTextureTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseRidgedMultiNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseRidgedMultiNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseRotatePointNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseRotatePointNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseScaleBiasNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseScaleBiasNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseScalePointNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseScalePointNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseSelectNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseSelectNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseSpheresNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseSpheresNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseTemplateGroup', {
+  enumerable: true,
+  get: function () {
+    return NoiseTemplateGroup;
+  }
+});
+Object.defineProperty(exports, 'NoiseTerraceNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseTerraceNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseTranslatePointNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseTranslatePointNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseTurbulenceNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseTurbulenceNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'NoiseVoronoiNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseVoronoiNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'PositionConstNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return PositionConstNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'PositionGridNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return PositionGridNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'PositionLoggerNodeTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return PositionLoggerNodeTemplateFactory;
+  }
+});
+Object.defineProperty(exports, 'noiseNodeTemplates', {
+  enumerable: true,
+  get: function () {
+    return noiseNodeTemplates;
+  }
+});
+Object.defineProperty(exports, 'noiseNodeTypes', {
+  enumerable: true,
+  get: function () {
+    return noiseNodeTypes;
+  }
+});
+Object.defineProperty(exports, 'noise_blend_node_default', {
+  enumerable: true,
+  get: function () {
+    return noise_blend_node_default;
+  }
+});
+Object.defineProperty(exports, 'noise_logger_node_default', {
+  enumerable: true,
+  get: function () {
+    return noise_logger_node_default;
+  }
+});
+Object.defineProperty(exports, 'noise_output_node_default', {
+  enumerable: true,
+  get: function () {
+    return noise_output_node_default;
+  }
+});
+Object.defineProperty(exports, 'noise_raw_texture_node_default', {
+  enumerable: true,
+  get: function () {
+    return noise_raw_texture_node_default;
+  }
+});
+Object.defineProperty(exports, 'noise_select_node_default', {
+  enumerable: true,
+  get: function () {
+    return noise_select_node_default;
+  }
+});
+Object.defineProperty(exports, 'positions_logger_node_default', {
+  enumerable: true,
+  get: function () {
+    return positions_logger_node_default;
+  }
+});
+//# sourceMappingURL=abstract-Db8fFoLp.cjs.map