@awesome-flow/noise 0.9.4 → 0.10.0

package/dist/abstract-3knbwDkz.cjs

@@ -0,0 +1,1768 @@
+const require_generators = require('./generators-BF_0y3pd.cjs');
+const require_groups = require('./groups-DF2FTSBC.cjs');
+const require_modifiers = require('./modifiers-BLV074OG.cjs');
+const require_selectors = require('./selectors-35pwVJ7Z.cjs');
+const require_transformers = require('./transformers-D9SfPky8.cjs');
+const require_modules_index = require('./modules/index.cjs');
+let _awesome_flow_core_components = require("@awesome-flow/core/components");
+let _awesome_flow_core_layout = require("@awesome-flow/core/layout");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _awesome_flow_core_hooks = require("@awesome-flow/core/hooks");
+let _mantine_core = require("@mantine/core");
+let _awesome_flow_core_abstract = require("@awesome-flow/core/abstract");
+let _awesome_flow_core_factories = require("@awesome-flow/core/factories");
+let _awesome_flow_core_utils = require("@awesome-flow/core/utils");
+let _xyflow_system = require("@xyflow/system");
+let libnoise_simplex_ts = require("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 noise = ((0, _awesome_flow_core_hooks.useNodeContext)(id)?.incoming?.[NoiseHandleType.noise])?.filter((c) => c.computed?.noise).flatMap((c) => c.computed.noise) || [];
+	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 = (0, react.memo)(NoiseLoggerNode);
+
+//#endregion
+//#region src/nodes/output/noise-output-node.tsx
+function NoiseOutputNode({ id, selected, data, type }) {
+	const context = (0, _awesome_flow_core_hooks.useNodeContext)(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
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_mantine_core.Text, {
+			mt: 5,
+			children: ["Noise points: ", context?.computed?.noise?.length || 0]
+		})]
+	});
+}
+var noise_output_node_default = (0, react.memo)(NoiseOutputNode);
+
+//#endregion
+//#region src/nodes/output/noise-texture-data-node.tsx
+function NoiseTextureDataNode({ id, selected, data, type }) {
+	const context = (0, _awesome_flow_core_hooks.useNodeContext)(id)?.computed;
+	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: ",
+				context?.textureResolutionX,
+				"x",
+				context?.textureResolutionY
+			] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_mantine_core.Group, { children: ["Input Length: ", context?.textureData?.length || 0] }),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_mantine_core.Group, { children: [
+				"Output Length (",
+				context?.textureResolutionX,
+				"*",
+				context?.textureResolutionY,
+				"*4): ",
+				context?.textureData?.length || 0
+			] })
+		] })
+	});
+}
+var noise_texture_data_node_default = (0, react.memo)(NoiseTextureDataNode);
+
+//#endregion
+//#region src/nodes/output/positions-logger-node.tsx
+function PositionsLoggerNode({ id, selected, data, type }) {
+	const positions = ((0, _awesome_flow_core_hooks.useNodeContext)(id)?.incoming[NoiseHandleType.position])?.filter((p) => !!p.computed?.positions?.length).flatMap((p) => p.computed.positions);
+	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 = (0, react.memo)(PositionsLoggerNode);
+
+//#endregion
+//#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/middleware/incoming-property-value.ts
+var IncomingPropertyValueMiddleware = class {
+	action(context) {
+		const incoming = context.incoming?.[_awesome_flow_core_abstract.CoreHandleType.variableProperty] ?? [];
+		const properties = { ...context.data };
+		for (const connection of incoming) {
+			const overwrite = connection.computed;
+			if (overwrite) Object.assign(properties, { [overwrite.property]: overwrite.value });
+		}
+		context.properties = properties;
+	}
+};
+
+//#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: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new libnoise_simplex_ts.Billow(properties.frequency, properties.lacunarity, properties.octaves, properties.persistence, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.PipelineFactory.create({
+		action: (context) => {
+			context.computed = { module: new libnoise_simplex_ts.Checkerboard() };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.PipelineFactory.create({
+		shouldRun(context) {
+			return context.data.noise !== void 0 && context.data.noise !== null;
+		},
+		action(context) {
+			context.computed = { module: new libnoise_simplex_ts.Const(context.data.noise) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new libnoise_simplex_ts.Cylinders(properties.frequency) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new libnoise_simplex_ts.Perlin(properties.frequency, properties.lacunarity, properties.octaves, properties.persistence, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new libnoise_simplex_ts.RidgedMulti(properties.frequency, properties.lacunarity, properties.octaves, properties.offset, properties.gain, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new libnoise_simplex_ts.Spheres(properties.frequency) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.PipelineFactory.create(new IncomingPropertyValueMiddleware(), {
+		action: (context) => {
+			const { properties } = context;
+			context.computed = { module: new libnoise_simplex_ts.Voronoi(properties.frequency, properties.displacement, properties.distance, properties.seed) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.position,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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
+//#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: NoiseHandleType.position,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1,
+			hideOnCollapse: true
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.Abs(module) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.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]: libnoise_simplex_ts.Add,
+	[NoiseCombineType.max]: libnoise_simplex_ts.Max,
+	[NoiseCombineType.min]: libnoise_simplex_ts.Min,
+	[NoiseCombineType.multiply]: libnoise_simplex_ts.Multiply,
+	[NoiseCombineType.power]: libnoise_simplex_ts.Power
+};
+
+//#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: _xyflow_system.Position.Left,
+			dataType: NoiseHandleType.module,
+			connection: "target",
+			minConnections: 2,
+			maxConnections: 2
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.Curve(module, context.data.points.map((p) => new libnoise_simplex_ts.Tuple(p.input, p.output))) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.Exponent(module, context.data.exponent) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.Invert(module) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 require_modules_index.NormalizeNoiseModule(module, context.data.intervalStart, context.data.intervalEnd) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.ScaleBias(module, context.data.scale, context.data.bias) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.Terrace(module, context.data.points) };
+		},
+		cleanup(context) {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: 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: NoiseHandleType.position,
+				connection: "target"
+			},
+			{
+				position: _xyflow_system.Position.Left,
+				dataType: NoiseHandleType.module,
+				connection: "target",
+				maxConnections: 1
+			},
+			{
+				position: _xyflow_system.Position.Right,
+				dataType: NoiseHandleType.noise,
+				connection: "source"
+			}
+		]
+	};
+	pipeline = _awesome_flow_core_factories.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-texture-data-template.ts
+var NoiseTextureDataTemplateFactory = class {
+	template = {
+		type: NoiseNodeType.textureData,
+		group: NoiseTemplateGroup.output,
+		data: { title: "Texture Data" },
+		handles: [{
+			position: _xyflow_system.Position.Left,
+			dataType: NoiseHandleType.noise,
+			connection: "target",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.textureData,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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
+//#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: 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: NoiseHandleType.module,
+				connection: "target",
+				label: "Source Modules",
+				dataId: NoiseSourceControlHandle.source,
+				groupBy: "dataId",
+				maxConnections: 2,
+				minConnections: 2
+			},
+			{
+				position: _xyflow_system.Position.Left,
+				dataType: NoiseHandleType.module,
+				dataId: NoiseSourceControlHandle.control,
+				groupBy: "dataId",
+				connection: "target",
+				label: "Control Module",
+				maxConnections: 1
+			},
+			{
+				position: _xyflow_system.Position.Right,
+				dataType: NoiseHandleType.module,
+				dataId: NoiseSourceControlHandle.output,
+				connection: "source"
+			}
+		]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.Blend(incomingSources[0].computed.module, incomingSources[1].computed.module, incomingControl.computed.module) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+				dataId: NoiseSourceControlHandle.source,
+				groupBy: "dataId",
+				connection: "target",
+				label: "Source Modules",
+				maxConnections: 2,
+				minConnections: 2
+			},
+			{
+				position: _xyflow_system.Position.Left,
+				dataType: NoiseHandleType.module,
+				dataId: NoiseSourceControlHandle.control,
+				groupBy: "dataId",
+				connection: "target",
+				label: "Control Module",
+				maxConnections: 1
+			},
+			{
+				position: _xyflow_system.Position.Right,
+				dataType: NoiseHandleType.module,
+				dataId: NoiseSourceControlHandle.output,
+				connection: "source"
+			}
+		]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.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
+//#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: NoiseHandleType.module,
+				dataId: DisplacementHandle.sourceModule,
+				groupBy: "dataId",
+				maxConnections: 1
+			},
+			{
+				position: _xyflow_system.Position.Left,
+				connection: "target",
+				label: "X Module",
+				dataType: NoiseHandleType.module,
+				dataId: DisplacementHandle.xModule,
+				groupBy: "dataId",
+				maxConnections: 1
+			},
+			{
+				position: _xyflow_system.Position.Left,
+				connection: "target",
+				label: "Y Module",
+				dataType: NoiseHandleType.module,
+				dataId: DisplacementHandle.yModule,
+				groupBy: "dataId",
+				maxConnections: 1
+			},
+			{
+				position: _xyflow_system.Position.Left,
+				connection: "target",
+				label: "Z Module",
+				dataType: NoiseHandleType.module,
+				dataId: DisplacementHandle.zModule,
+				groupBy: "dataId",
+				maxConnections: 1
+			},
+			{
+				position: _xyflow_system.Position.Right,
+				dataType: NoiseHandleType.module,
+				dataId: DisplacementHandle.output,
+				connection: "source"
+			}
+		]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.Displace(sourceModule, xModule, yModule, zModule) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.RotatePoint(sourceModule, xAngle, yAngle, zAngle) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.ScalePoint(sourceModule, xScale, yScale, zScale) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: NoiseHandleType.module,
+			connection: "target",
+			label: "Source Module",
+			maxConnections: 1
+		}, {
+			position: _xyflow_system.Position.Right,
+			dataType: NoiseHandleType.module,
+			connection: "source"
+		}]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.TranslatePoint(sourceModule, translateX, translateY, translateZ) };
+		},
+		cleanup: (context) => {
+			context.computed = null;
+		}
+	});
+};
+
+//#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: 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: NoiseHandleType.module,
+				connection: "source"
+			}
+		]
+	};
+	pipeline = _awesome_flow_core_factories.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 libnoise_simplex_ts.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) {
+	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]: 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_texture_data_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]: require_selectors.noise_blend_node_default,
+	[NoiseNodeType.noiseSelect]: require_selectors.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 NoiseTextureDataTemplateFactory(),
+	[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, 'DisplacementHandle', {
+  enumerable: true,
+  get: function () {
+    return DisplacementHandle;
+  }
+});
+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, 'NoiseCombineType', {
+  enumerable: true,
+  get: function () {
+    return NoiseCombineType;
+  }
+});
+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, 'NoiseHandleType', {
+  enumerable: true,
+  get: function () {
+    return NoiseHandleType;
+  }
+});
+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, '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, 'NoiseSourceControlHandle', {
+  enumerable: true,
+  get: function () {
+    return NoiseSourceControlHandle;
+  }
+});
+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, 'NoiseTextureDataTemplateFactory', {
+  enumerable: true,
+  get: function () {
+    return NoiseTextureDataTemplateFactory;
+  }
+});
+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, 'noiseCombineModuleMap', {
+  enumerable: true,
+  get: function () {
+    return noiseCombineModuleMap;
+  }
+});
+Object.defineProperty(exports, 'noiseNodeTemplates', {
+  enumerable: true,
+  get: function () {
+    return noiseNodeTemplates;
+  }
+});
+Object.defineProperty(exports, 'noiseNodeTypes', {
+  enumerable: true,
+  get: function () {
+    return noiseNodeTypes;
+  }
+});
+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_texture_data_node_default', {
+  enumerable: true,
+  get: function () {
+    return noise_texture_data_node_default;
+  }
+});
+Object.defineProperty(exports, 'positions_logger_node_default', {
+  enumerable: true,
+  get: function () {
+    return positions_logger_node_default;
+  }
+});
+//# sourceMappingURL=abstract-3knbwDkz.cjs.map