@awesome-flow/noise 0.9.3 → 0.9.4

package/dist/abstract-Dhf_tSuO.js

@@ -0,0 +1,1177 @@
+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 { 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 { jsx, jsxs } from "react/jsx-runtime";
+import { Divider, Group, NumberInput, Stack, Text } from "@mantine/core";
+import { CoreHandleType, CoreTemplateGroup } from "@awesome-flow/core/abstract";
+import { IDGenerator } from "@awesome-flow/core/utils";
+import { Position } from "@xyflow/system";
+
+//#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]);
+	return /* @__PURE__ */ jsxs(NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: [
+			/* @__PURE__ */ jsxs(Text, { children: ["Size: ", noise?.length || 0] }),
+			/* @__PURE__ */ jsx(Divider, { h: 5 }),
+			/* @__PURE__ */ jsx(Stack, { children: noise?.map((v, i) => /* @__PURE__ */ jsxs(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] = 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]);
+	return /* @__PURE__ */ jsxs(NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: [/* @__PURE__ */ jsx(HandlesIncomingDataStatus, {
+			nodeId: id,
+			handles: data.handles,
+			groupBy: "dataType",
+			onDataUpdated,
+			type: "target",
+			resetComputedData: true
+		}), /* @__PURE__ */ jsxs(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 = 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
+	]);
+	return /* @__PURE__ */ jsx(NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: /* @__PURE__ */ jsxs(Stack, { children: [
+			/* @__PURE__ */ jsxs(Group, { children: [
+				"Resolution: ",
+				resolution,
+				"x",
+				resolution
+			] }),
+			/* @__PURE__ */ jsxs(Group, { children: ["Input Length: ", noise?.length || 0] }),
+			/* @__PURE__ */ jsxs(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 = useIncomingComputedData(id);
+	const positions = useMemo(() => {
+		return incoming?.map((p) => p.positions).flat();
+	}, [incoming]);
+	return /* @__PURE__ */ jsxs(NodeContainer, {
+		id,
+		selected,
+		data,
+		type,
+		children: [
+			/* @__PURE__ */ jsxs(Text, { children: ["Size: ", positions?.length || 0] }),
+			/* @__PURE__ */ jsx(Divider, { h: 5 }),
+			/* @__PURE__ */ jsx(Stack, { children: positions?.map((v, i) => /* @__PURE__ */ jsxs(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 = 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;
+
+//#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 });
+		}
+	}, [
+		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;
+}({});
+
+//#endregion
+//#region src/templates/generators/noise-billow-template.ts
+var NoiseBillowNodeTemplateFactory = class {
+	template = {
+		id: IDGenerator.template(),
+		type: NoiseNodeType.noiseBillow,
+		group: NoiseTemplateGroup.noiseGenerators,
+		data: {
+			title: "Billow Noise",
+			frequency: .1,
+			lacunarity: 2,
+			octaves: 5,
+			persistence: .5,
+			seed: 0
+		},
+		handles: [{
+			position: Position.Left,
+			dataType: CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Right,
+			dataType: 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: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: CoreHandleType.variableProperty,
+			connection: "target"
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Right,
+			dataType: 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: Position.Right,
+			dataType: NoiseHandleType.position,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/groups/module-group-template.ts
+var ModuleGroupNodeTemplateFactory = class {
+	template = {
+		id: IDGenerator.template(),
+		type: NoiseNodeType.groupModule,
+		group: CoreTemplateGroup.groups,
+		data: {
+			title: "Modules Group",
+			isGroup: true,
+			initialSize: {
+				width: 300,
+				height: 200
+			},
+			collapsedSize: {
+				width: 300,
+				height: 80
+			}
+		},
+		handles: [{
+			position: Position.Bottom,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1,
+			hideOnCollapse: true
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: NoiseCombineType.add
+		},
+		handles: [{
+			position: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 2
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+};
+
+//#endregion
+//#region src/templates/modifiers/noise-normalize-template.ts
+var NoiseNormalizeNodeTemplateFactory = class {
+	template = {
+		id: IDGenerator.template(),
+		type: NoiseNodeType.noiseNormalize,
+		group: NoiseTemplateGroup.noiseModifiers,
+		data: {
+			title: "Normalize Noise",
+			intervalStart: -1,
+			intervalEnd: 1
+		},
+		handles: [{
+			position: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: 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: Position.Left,
+				dataType: NoiseHandleType.position,
+				connection: "target"
+			},
+			{
+				position: Position.Left,
+				dataType: NoiseHandleType.module,
+				connection: "target",
+				maxConnections: 1
+			},
+			{
+				position: Position.Right,
+				dataType: 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: Position.Left,
+			dataType: NoiseHandleType.noise,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: 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: Position.Left,
+				dataType: NoiseHandleType.module,
+				connection: "target",
+				label: "Source Modules",
+				dataId: NoiseSourceControlHandle.source,
+				maxConnections: 2,
+				minConnections: 2
+			},
+			{
+				position: Position.Left,
+				dataType: NoiseHandleType.module,
+				dataId: NoiseSourceControlHandle.control,
+				connection: "target",
+				label: "Control Module",
+				maxConnections: 1
+			},
+			{
+				position: Position.Right,
+				dataType: NoiseHandleType.module,
+				dataId: 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: Position.Left,
+				dataType: NoiseHandleType.module,
+				dataId: NoiseSourceControlHandle.source,
+				connection: "target",
+				label: "Source Modules",
+				maxConnections: 2,
+				minConnections: 2
+			},
+			{
+				position: Position.Left,
+				dataType: NoiseHandleType.module,
+				dataId: NoiseSourceControlHandle.control,
+				connection: "target",
+				label: "Control Module",
+				maxConnections: 1
+			},
+			{
+				position: Position.Right,
+				dataType: NoiseHandleType.module,
+				dataId: 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: Position.Left,
+				connection: "target",
+				label: "Source Module",
+				dataType: NoiseHandleType.module,
+				dataId: DisplacementHandle.sourceModule,
+				maxConnections: 1
+			},
+			{
+				position: Position.Left,
+				connection: "target",
+				label: "X Module",
+				dataType: NoiseHandleType.module,
+				dataId: DisplacementHandle.xModule,
+				maxConnections: 1
+			},
+			{
+				position: Position.Left,
+				connection: "target",
+				label: "Y Module",
+				dataType: NoiseHandleType.module,
+				dataId: DisplacementHandle.yModule,
+				maxConnections: 1
+			},
+			{
+				position: Position.Left,
+				connection: "target",
+				label: "Z Module",
+				dataType: NoiseHandleType.module,
+				dataId: DisplacementHandle.zModule,
+				maxConnections: 1
+			},
+			{
+				position: Position.Right,
+				dataType: NoiseHandleType.module,
+				dataId: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: Position.Right,
+			dataType: 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: Position.Left,
+				dataType: NoiseHandleType.module,
+				connection: "target",
+				label: "Source Module",
+				maxConnections: 1
+			},
+			{
+				position: Position.Left,
+				dataType: CoreHandleType.variableProperty,
+				label: "Variable Properties",
+				connection: "target"
+			},
+			{
+				position: Position.Right,
+				dataType: 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]: 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.noiseLogger]: noise_logger_node_default,
+	[NoiseNodeType.positionLogger]: positions_logger_node_default,
+	[NoiseNodeType.noiseConst]: noise_const_node_default,
+	[NoiseNodeType.noiseBillow]: noise_billow_node_default,
+	[NoiseNodeType.noiseCheckerboard]: noise_checkerboard_node_default,
+	[NoiseNodeType.noiseCylinders]: noise_cylinders_node_default,
+	[NoiseNodeType.noisePerlin]: noise_perlin_node_default,
+	[NoiseNodeType.noiseRidgedMulti]: noise_ridgedmulti_node_default,
+	[NoiseNodeType.noiseSpheres]: noise_spheres_node_default,
+	[NoiseNodeType.noiseVoronoi]: noise_voronoi_node_default,
+	[NoiseNodeType.noiseCombine]: noise_combine_node_default,
+	[NoiseNodeType.noiseClamp]: noise_clamp_node_default,
+	[NoiseNodeType.noiseAbs]: noise_abs_node_default,
+	[NoiseNodeType.noiseNormalize]: noise_normalize_node_default,
+	[NoiseNodeType.noiseCurve]: noise_curve_node_default,
+	[NoiseNodeType.noiseExponent]: noise_exponent_node_default,
+	[NoiseNodeType.noiseInvert]: noise_invert_node_default,
+	[NoiseNodeType.noiseScaleBias]: noise_scale_bias_node_default,
+	[NoiseNodeType.noiseTerrace]: noise_terrace_node_default,
+	[NoiseNodeType.noiseBlend]: noise_blend_node_default,
+	[NoiseNodeType.noiseSelect]: noise_select_node_default,
+	[NoiseNodeType.noiseDisplace]: noise_displace_node_default,
+	[NoiseNodeType.noiseRotatePoint]: noise_rotate_point_node_default,
+	[NoiseNodeType.noiseScalePoint]: noise_scale_point_node_default,
+	[NoiseNodeType.noiseTranslatePoint]: noise_translate_point_node_default,
+	[NoiseNodeType.noiseTurbulence]: 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
+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