@awesome-flow/noise 0.1.0

package/dist/templates/output/index.cjs

@@ -0,0 +1,1696 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/templates/output/index.ts
+var output_exports = {};
+__export(output_exports, {
+  NoiseLoggerNodeTemplateFactory: () => NoiseLoggerNodeTemplateFactory,
+  NoiseOutputNodeTemplateFactory: () => NoiseOutputNodeTemplateFactory,
+  NoiseRawTextureTemplateFactory: () => NoiseRawTextureTemplateFactory,
+  PositionLoggerNodeTemplateFactory: () => PositionLoggerNodeTemplateFactory
+});
+module.exports = __toCommonJS(output_exports);
+
+// src/templates/output/noise-logger-template.ts
+var import_utils37 = require("@awesome-flow/core/utils");
+var import_system35 = require("@xyflow/system");
+
+// src/nodes/generators/noise-simplex-node.tsx
+var import_layout = require("@awesome-flow/core/layout");
+var import_react = require("react");
+var import_hooks = require("@awesome-flow/core/hooks");
+
+// src/modules/simplex-module.ts
+var import_Module = __toESM(require("libnoise-ts/module/Module"), 1);
+var import_simplex_noise = require("simplex-noise");
+
+// src/nodes/generators/noise-simplex-node.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+
+// src/nodes/generators/position-const-node.tsx
+var import_layout2 = require("@awesome-flow/core/layout");
+var import_react2 = require("react");
+var import_core = require("@mantine/core");
+var import_hooks2 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+
+// src/nodes/generators/position-grid-node.tsx
+var import_layout3 = require("@awesome-flow/core/layout");
+var import_react3 = require("react");
+var import_core2 = require("@mantine/core");
+var import_hooks3 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-normalize-node.tsx
+var import_layout4 = require("@awesome-flow/core/layout");
+var import_react4 = require("react");
+var import_core3 = require("@mantine/core");
+var import_hooks4 = require("@awesome-flow/core/hooks");
+
+// src/modules/normalize-noise-module.ts
+var import_modifier = __toESM(require("libnoise-ts/module/modifier"), 1);
+
+// src/nodes/modifiers/noise-normalize-node.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-const-node.tsx
+var import_layout5 = require("@awesome-flow/core/layout");
+var import_react5 = require("react");
+var import_core4 = require("@mantine/core");
+var import_hooks5 = require("@awesome-flow/core/hooks");
+var import_generator = require("libnoise-ts/module/generator");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-billow-node.tsx
+var import_layout6 = require("@awesome-flow/core/layout");
+var import_react7 = require("react");
+var import_generator2 = require("libnoise-ts/module/generator");
+var import_hooks7 = require("@awesome-flow/core/hooks");
+var import_abstract2 = require("@awesome-flow/core/abstract");
+
+// src/layout/node-property-variables.tsx
+var import_hooks6 = require("@awesome-flow/core/hooks");
+var import_react6 = require("react");
+var import_core6 = require("@mantine/core");
+var import_utils = require("@awesome-flow/core/utils");
+var import_abstract = require("@awesome-flow/core/abstract");
+
+// src/layout/node-value-input.tsx
+var import_core5 = require("@mantine/core");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+
+// src/layout/node-property-input.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+
+// src/layout/node-property-variables.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-billow-node.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+
+// src/nodes/output/noise-logger-node.tsx
+var import_layout7 = require("@awesome-flow/core/layout");
+var import_react8 = require("react");
+var import_core7 = require("@mantine/core");
+var import_hooks8 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+
+// src/nodes/output/noise-raw-texture-node.tsx
+var import_layout8 = require("@awesome-flow/core/layout");
+var import_react9 = require("react");
+var import_hooks9 = require("@awesome-flow/core/hooks");
+var import_core8 = require("@mantine/core");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-checkerboard-node.tsx
+var import_layout9 = require("@awesome-flow/core/layout");
+var import_react10 = require("react");
+var import_generator3 = require("libnoise-ts/module/generator");
+var import_hooks10 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+
+// src/nodes/output/positions-logger-node.tsx
+var import_layout10 = require("@awesome-flow/core/layout");
+var import_react11 = require("react");
+var import_core9 = require("@mantine/core");
+var import_hooks11 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime13 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-cylinders-node.tsx
+var import_layout11 = require("@awesome-flow/core/layout");
+var import_react12 = require("react");
+var import_generator4 = require("libnoise-ts/module/generator");
+var import_hooks12 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-perlin-node.tsx
+var import_layout12 = require("@awesome-flow/core/layout");
+var import_react13 = require("react");
+var import_generator5 = require("libnoise-ts/module/generator");
+var import_hooks13 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-ridgedmulti-node.tsx
+var import_layout13 = require("@awesome-flow/core/layout");
+var import_react14 = require("react");
+var import_generator6 = require("libnoise-ts/module/generator");
+var import_hooks14 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-spheres-node.tsx
+var import_layout14 = require("@awesome-flow/core/layout");
+var import_react15 = require("react");
+var import_generator7 = require("libnoise-ts/module/generator");
+var import_hooks15 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime17 = require("react/jsx-runtime");
+
+// src/nodes/generators/noise-voronoi-node.tsx
+var import_layout15 = require("@awesome-flow/core/layout");
+var import_react16 = require("react");
+var import_generator8 = require("libnoise-ts/module/generator");
+var import_hooks16 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime18 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-combine-node.tsx
+var import_layout16 = require("@awesome-flow/core/layout");
+var import_react17 = require("react");
+var import_hooks17 = require("@awesome-flow/core/hooks");
+var import_icons_react = require("@tabler/icons-react");
+
+// src/abstract/operations.ts
+var import_combiner = require("libnoise-ts/module/combiner");
+
+// src/nodes/modifiers/noise-combine-node.tsx
+var import_jsx_runtime19 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-clamp-node.tsx
+var import_layout17 = require("@awesome-flow/core/layout");
+var import_react18 = require("react");
+var import_core10 = require("@mantine/core");
+var import_hooks18 = require("@awesome-flow/core/hooks");
+var import_modifier2 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime20 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-abs-node.tsx
+var import_layout18 = require("@awesome-flow/core/layout");
+var import_react19 = require("react");
+var import_hooks19 = require("@awesome-flow/core/hooks");
+var import_modifier3 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime21 = require("react/jsx-runtime");
+
+// src/nodes/output/noise-output-node.tsx
+var import_layout19 = require("@awesome-flow/core/layout");
+var import_hooks20 = require("@awesome-flow/core/hooks");
+var import_core11 = require("@mantine/core");
+var import_react20 = require("react");
+var import_jsx_runtime22 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-curve-node.tsx
+var import_layout20 = require("@awesome-flow/core/layout");
+var import_core12 = require("@mantine/core");
+var import_hooks21 = require("@awesome-flow/core/hooks");
+var import_react21 = require("react");
+var import_modifier4 = require("libnoise-ts/module/modifier");
+var import_util = require("libnoise-ts/util");
+var import_icons_react2 = require("@tabler/icons-react");
+var import_hooks22 = require("@mantine/hooks");
+var import_abstract3 = require("@awesome-flow/core/abstract");
+var import_jsx_runtime23 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-exponent-node.tsx
+var import_layout21 = require("@awesome-flow/core/layout");
+var import_react22 = require("react");
+var import_core13 = require("@mantine/core");
+var import_hooks23 = require("@awesome-flow/core/hooks");
+var import_modifier5 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime24 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-invert-node.tsx
+var import_layout22 = require("@awesome-flow/core/layout");
+var import_react23 = require("react");
+var import_hooks24 = require("@awesome-flow/core/hooks");
+var import_modifier6 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime25 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-scale-bias-node.tsx
+var import_layout23 = require("@awesome-flow/core/layout");
+var import_react24 = require("react");
+var import_core14 = require("@mantine/core");
+var import_hooks25 = require("@awesome-flow/core/hooks");
+var import_modifier7 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime26 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/noise-terrace-node.tsx
+var import_layout24 = require("@awesome-flow/core/layout");
+var import_core15 = require("@mantine/core");
+var import_hooks26 = require("@awesome-flow/core/hooks");
+var import_react25 = require("react");
+var import_modifier8 = require("libnoise-ts/module/modifier");
+var import_icons_react3 = require("@tabler/icons-react");
+var import_hooks27 = require("@mantine/hooks");
+var import_abstract4 = require("@awesome-flow/core/abstract");
+var import_jsx_runtime27 = require("react/jsx-runtime");
+
+// src/nodes/selectors/noise-blend-node.tsx
+var import_layout25 = require("@awesome-flow/core/layout");
+var import_react26 = require("react");
+var import_hooks28 = require("@awesome-flow/core/hooks");
+var import_selector = require("libnoise-ts/module/selector");
+var import_core16 = require("@mantine/core");
+var import_jsx_runtime28 = require("react/jsx-runtime");
+
+// src/nodes/selectors/noise-select-node.tsx
+var import_layout26 = require("@awesome-flow/core/layout");
+var import_react27 = require("react");
+var import_hooks29 = require("@awesome-flow/core/hooks");
+var import_selector2 = require("libnoise-ts/module/selector");
+var import_core17 = require("@mantine/core");
+var import_jsx_runtime29 = require("react/jsx-runtime");
+
+// src/nodes/transformers/noise-displace-node.tsx
+var import_layout27 = require("@awesome-flow/core/layout");
+var import_react28 = require("react");
+var import_hooks30 = require("@awesome-flow/core/hooks");
+var import_transformer = require("libnoise-ts/module/transformer");
+var import_core18 = require("@mantine/core");
+var import_jsx_runtime30 = require("react/jsx-runtime");
+
+// src/nodes/transformers/noise-rotate-point-node.tsx
+var import_layout28 = require("@awesome-flow/core/layout");
+var import_react29 = require("react");
+var import_hooks31 = require("@awesome-flow/core/hooks");
+var import_core19 = require("@mantine/core");
+var import_transformer2 = require("libnoise-ts/module/transformer");
+var import_jsx_runtime31 = require("react/jsx-runtime");
+
+// src/nodes/transformers/noise-scale-point-node.tsx
+var import_layout29 = require("@awesome-flow/core/layout");
+var import_react30 = require("react");
+var import_hooks32 = require("@awesome-flow/core/hooks");
+var import_core20 = require("@mantine/core");
+var import_transformer3 = require("libnoise-ts/module/transformer");
+var import_jsx_runtime32 = require("react/jsx-runtime");
+
+// src/nodes/transformers/noise-translate-point-node.tsx
+var import_layout30 = require("@awesome-flow/core/layout");
+var import_react31 = require("react");
+var import_hooks33 = require("@awesome-flow/core/hooks");
+var import_core21 = require("@mantine/core");
+var import_transformer4 = require("libnoise-ts/module/transformer");
+var import_jsx_runtime33 = require("react/jsx-runtime");
+
+// src/nodes/transformers/noise-turbulence-node .tsx
+var import_layout31 = require("@awesome-flow/core/layout");
+var import_react32 = require("react");
+var import_hooks34 = require("@awesome-flow/core/hooks");
+var import_transformer5 = require("libnoise-ts/module/transformer");
+var import_jsx_runtime34 = require("react/jsx-runtime");
+
+// src/nodes/generators/variable-property-node.tsx
+var import_layout32 = require("@awesome-flow/core/layout");
+var import_react33 = require("react");
+var import_core22 = require("@mantine/core");
+var import_hooks35 = require("@awesome-flow/core/hooks");
+var import_utils2 = require("@awesome-flow/core/utils");
+var import_abstract5 = require("@awesome-flow/core/abstract");
+var import_jsx_runtime35 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/variable-combine-node.tsx
+var import_layout33 = require("@awesome-flow/core/layout");
+var import_react34 = require("react");
+var import_hooks36 = require("@awesome-flow/core/hooks");
+var import_icons_react4 = require("@tabler/icons-react");
+var import_jsx_runtime36 = require("react/jsx-runtime");
+
+// src/nodes/generators/variable-value-node.tsx
+var import_layout35 = require("@awesome-flow/core/layout");
+var import_react35 = require("react");
+var import_hooks37 = require("@awesome-flow/core/hooks");
+var import_jsx_runtime37 = require("react/jsx-runtime");
+
+// src/nodes/groups/node-module-group.tsx
+var import_layout36 = require("@awesome-flow/core/layout");
+var import_react36 = require("@xyflow/react");
+var import_abstract6 = require("@awesome-flow/core/abstract");
+var import_react37 = require("react");
+var import_shallow = require("zustand/shallow");
+var import_core23 = require("@mantine/core");
+var import_jsx_runtime38 = require("react/jsx-runtime");
+
+// src/templates/generators/noise-checkerboard-template.ts
+var import_utils3 = require("@awesome-flow/core/utils");
+var import_system = require("@xyflow/system");
+var NoiseCheckerboardNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils3.IDGenerator.template(),
+      type: "noise-checkerboard" /* noiseCheckerboard */,
+      removable: false,
+      data: {
+        title: "Checkerboard Noise"
+      },
+      handles: [
+        {
+          position: import_system.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-const-template.ts
+var import_utils4 = require("@awesome-flow/core/utils");
+var import_system2 = require("@xyflow/system");
+var NoiseConstNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils4.IDGenerator.template(),
+      type: "noise-constant" /* noiseConst */,
+      removable: false,
+      data: {
+        title: "Const Value Noise",
+        noise: 0,
+        min: -1,
+        max: 1
+      },
+      handles: [
+        {
+          position: import_system2.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-cylinders-template.ts
+var import_utils5 = require("@awesome-flow/core/utils");
+var import_system3 = require("@xyflow/system");
+var NoiseCylindersNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils5.IDGenerator.template(),
+      type: "noise-cylinders" /* noiseCylinders */,
+      removable: false,
+      data: {
+        title: "Cylinders Noise",
+        frequency: 0.1
+      },
+      handles: [
+        {
+          position: import_system3.Position.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: import_system3.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-perlin-template.ts
+var import_utils6 = require("@awesome-flow/core/utils");
+var import_system4 = require("@xyflow/system");
+var NoisePerlinNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils6.IDGenerator.template(),
+      type: "noise-perlin" /* noisePerlin */,
+      removable: false,
+      data: {
+        title: "Perlin Noise",
+        frequency: 0.1,
+        lacunarity: 2,
+        octaves: 5,
+        persistence: 0.5,
+        seed: 0
+      },
+      handles: [
+        {
+          position: import_system4.Position.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: import_system4.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-ridgedmulti-template.ts
+var import_utils7 = require("@awesome-flow/core/utils");
+var import_system5 = require("@xyflow/system");
+var NoiseRidgedMultiNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils7.IDGenerator.template(),
+      type: "noise-ridged-multi" /* noiseRidgedMulti */,
+      removable: false,
+      data: {
+        title: "Ridged Multi Noise",
+        frequency: 0.1,
+        lacunarity: 2,
+        octaves: 6,
+        offset: 1,
+        gain: 2,
+        seed: 0
+      },
+      handles: [
+        {
+          position: import_system5.Position.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: import_system5.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-simplex-template.ts
+var import_utils8 = require("@awesome-flow/core/utils");
+var import_system6 = require("@xyflow/system");
+var NoiseSimplexNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils8.IDGenerator.template(),
+      type: "noise-simplex" /* noiseSimplex */,
+      removable: false,
+      data: {
+        title: "Simplex Noise"
+      },
+      handles: [
+        {
+          position: import_system6.Position.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: import_system6.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-spheres-template.ts
+var import_utils9 = require("@awesome-flow/core/utils");
+var import_system7 = require("@xyflow/system");
+var NoiseSpheresNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils9.IDGenerator.template(),
+      type: "noise-spheres" /* noiseSpheres */,
+      removable: false,
+      data: {
+        title: "Spheres Noise",
+        frequency: 0.1
+      },
+      handles: [
+        {
+          position: import_system7.Position.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: import_system7.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-voronoi-template.ts
+var import_utils10 = require("@awesome-flow/core/utils");
+var import_system8 = require("@xyflow/system");
+var NoiseVoronoiNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils10.IDGenerator.template(),
+      type: "noise-voronoi" /* noiseVoronoi */,
+      removable: false,
+      data: {
+        title: "Voronoi Noise",
+        frequency: 0.1,
+        displacement: 1,
+        distance: true,
+        seed: 0
+      },
+      handles: [
+        {
+          position: import_system8.Position.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: import_system8.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/position-const-template.ts
+var import_utils11 = require("@awesome-flow/core/utils");
+var import_system9 = require("@xyflow/system");
+var PositionConstNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils11.IDGenerator.template(),
+      type: "position" /* position */,
+      removable: false,
+      data: {
+        title: "Position Output",
+        position: { x: 0, y: 0, z: 0 }
+      },
+      handles: [
+        {
+          position: import_system9.Position.Right,
+          dataType: 4 /* position */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType(type) {
+    return 4 /* position */;
+  }
+};
+
+// src/templates/generators/position-grid-template.ts
+var import_utils12 = require("@awesome-flow/core/utils");
+var import_system10 = require("@xyflow/system");
+var PositionGridNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils12.IDGenerator.template(),
+      type: "grid" /* grid */,
+      removable: false,
+      data: {
+        title: "Grid Output",
+        center: { x: 0, y: 0, z: 0 },
+        radius: 1
+      },
+      handles: [
+        {
+          position: import_system10.Position.Right,
+          dataType: 4 /* position */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType(type) {
+    return 4 /* position */;
+  }
+};
+
+// src/templates/modifiers/noise-normalize-template.ts
+var import_utils13 = require("@awesome-flow/core/utils");
+var import_system11 = require("@xyflow/system");
+var NoiseNormalizeNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils13.IDGenerator.template(),
+      type: "noise-normalize" /* noiseNormalize */,
+      data: {
+        title: "Normalize Noise",
+        intervalStart: -1,
+        intervalEnd: 1
+      },
+      handles: [
+        {
+          position: import_system11.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system11.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/output/noise-raw-texture-template.ts
+var import_utils14 = require("@awesome-flow/core/utils");
+var import_system12 = require("@xyflow/system");
+var NoiseRawTextureTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils14.IDGenerator.template(),
+      type: "texture-data" /* textureData */,
+      removable: false,
+      data: {
+        title: "Texture Data"
+      },
+      handles: [
+        {
+          position: import_system12.Position.Left,
+          dataType: 2 /* noise */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system12.Position.Right,
+          dataType: 1 /* texture */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    switch (type) {
+      case "source":
+        return 1 /* texture */;
+      case "target":
+        return 2 /* noise */;
+    }
+  }
+};
+
+// src/templates/output/position-logger-template.ts
+var import_utils15 = require("@awesome-flow/core/utils");
+var import_system13 = require("@xyflow/system");
+var PositionLoggerNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils15.IDGenerator.template(),
+      type: "position-logger" /* positionLogger */,
+      removable: false,
+      data: {
+        title: "Position Logger"
+      },
+      handles: [
+        {
+          position: import_system13.Position.Left,
+          dataType: 4 /* position */,
+          connection: "target"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "target";
+  }
+  getHandleAllowedDataType(type) {
+    return 4 /* position */;
+  }
+};
+
+// src/templates/modifiers/noise-combine-template.ts
+var import_utils16 = require("@awesome-flow/core/utils");
+var import_system14 = require("@xyflow/system");
+var NoiseCombineNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils16.IDGenerator.template(),
+      type: "noise-combiner" /* noiseCombine */,
+      removable: false,
+      data: {
+        title: "Combine Noise",
+        operation: "add" /* add */
+      },
+      handles: [
+        {
+          position: import_system14.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 2
+        },
+        {
+          position: import_system14.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-clamp-template.ts
+var import_utils17 = require("@awesome-flow/core/utils");
+var import_system15 = require("@xyflow/system");
+var NoiseClampNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils17.IDGenerator.template(),
+      type: "noise-clamp" /* noiseClamp */,
+      removable: false,
+      data: {
+        title: "Clamp Noise",
+        lowerBound: -1,
+        upperBound: 1
+      },
+      handles: [
+        {
+          position: import_system15.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system15.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-abs-template.ts
+var import_utils18 = require("@awesome-flow/core/utils");
+var import_system16 = require("@xyflow/system");
+var NoiseAbsNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils18.IDGenerator.template(),
+      type: "noise-abs" /* noiseAbs */,
+      removable: false,
+      data: {
+        title: "Abs Noise"
+      },
+      handles: [
+        {
+          position: import_system16.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system16.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/output/noise-output-template.ts
+var import_utils19 = require("@awesome-flow/core/utils");
+var import_system17 = require("@xyflow/system");
+var NoiseOutputNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils19.IDGenerator.template(),
+      type: "noise-output" /* noiseOutput */,
+      removable: false,
+      data: {
+        title: "Noise Output"
+      },
+      handles: [
+        {
+          position: import_system17.Position.Left,
+          dataType: 4 /* position */,
+          connection: "target"
+        },
+        {
+          position: import_system17.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system17.Position.Right,
+          dataType: 2 /* noise */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    switch (type) {
+      case "source":
+        return 2 /* noise */;
+      case "target":
+        return 8 /* module */ & 4 /* position */;
+    }
+  }
+};
+
+// src/templates/modifiers/noise-curve-template.ts
+var import_utils20 = require("@awesome-flow/core/utils");
+var import_system18 = require("@xyflow/system");
+var NoiseCurveNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils20.IDGenerator.template(),
+      type: "noise-curve" /* noiseCurve */,
+      removable: false,
+      data: {
+        title: "Noise Curve",
+        points: []
+      },
+      handles: [
+        {
+          position: import_system18.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system18.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-exponent-template.ts
+var import_utils21 = require("@awesome-flow/core/utils");
+var import_system19 = require("@xyflow/system");
+var NoiseExponentNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils21.IDGenerator.template(),
+      type: "noise-exponent" /* noiseExponent */,
+      removable: false,
+      data: {
+        title: "Noise Exponent",
+        exponent: 1
+      },
+      handles: [
+        {
+          position: import_system19.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system19.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-invert-template.ts
+var import_utils22 = require("@awesome-flow/core/utils");
+var import_system20 = require("@xyflow/system");
+var NoiseInvertNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils22.IDGenerator.template(),
+      type: "noise-invert" /* noiseInvert */,
+      removable: false,
+      data: {
+        title: "Invert Noise"
+      },
+      handles: [
+        {
+          position: import_system20.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system20.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-scalebias-template.ts
+var import_utils23 = require("@awesome-flow/core/utils");
+var import_system21 = require("@xyflow/system");
+var NoiseScaleBiasNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils23.IDGenerator.template(),
+      type: "noise-scale-bias" /* noiseScaleBias */,
+      removable: false,
+      data: {
+        title: "Scale/Bias Noise",
+        scale: 1,
+        bias: 0
+      },
+      handles: [
+        {
+          position: import_system21.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system21.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-terrace-template.ts
+var import_utils24 = require("@awesome-flow/core/utils");
+var import_system22 = require("@xyflow/system");
+var NoiseTerraceNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils24.IDGenerator.template(),
+      type: "noise-terrace" /* noiseTerrace */,
+      removable: false,
+      data: {
+        title: "Noise Terrace",
+        points: []
+      },
+      handles: [
+        {
+          position: import_system22.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system22.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/selectors/noise-blend-template.ts
+var import_utils25 = require("@awesome-flow/core/utils");
+var import_system23 = require("@xyflow/system");
+var NoiseBlendNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils25.IDGenerator.template(),
+      type: "noise-blend" /* noiseBlend */,
+      removable: false,
+      data: {
+        title: "Noise Blend"
+      },
+      handles: [
+        {
+          position: import_system23.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Modules",
+          maxConnections: 2
+        },
+        {
+          position: import_system23.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Control Module",
+          maxConnections: 1
+        },
+        {
+          position: import_system23.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/selectors/noise-select-template.ts
+var import_utils26 = require("@awesome-flow/core/utils");
+var import_system24 = require("@xyflow/system");
+var NoiseSelectNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils26.IDGenerator.template(),
+      type: "noise-select" /* noiseSelect */,
+      removable: false,
+      data: {
+        title: "Noise Select",
+        edgeFalloff: 0,
+        lowerBound: -1,
+        upperBound: 1
+      },
+      handles: [
+        {
+          position: import_system24.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Modules",
+          maxConnections: 2
+        },
+        {
+          position: import_system24.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Control Module",
+          maxConnections: 1
+        },
+        {
+          position: import_system24.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-displace-template.ts
+var import_utils27 = require("@awesome-flow/core/utils");
+var import_system25 = require("@xyflow/system");
+var NoiseDisplaceNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils27.IDGenerator.template(),
+      type: "noise-displace" /* noiseDisplace */,
+      data: {
+        title: "Noise Displace"
+      },
+      handles: [
+        {
+          position: import_system25.Position.Left,
+          connection: "target",
+          label: "Source Module",
+          dataType: 8 /* module */,
+          dataId: "source" /* sourceModule */,
+          maxConnections: 1
+        },
+        {
+          position: import_system25.Position.Left,
+          connection: "target",
+          label: "X Module",
+          dataType: 8 /* module */,
+          dataId: "x-module" /* xModule */,
+          maxConnections: 1
+        },
+        {
+          position: import_system25.Position.Left,
+          connection: "target",
+          label: "Y Module",
+          dataType: 8 /* module */,
+          dataId: "y-module" /* yModule */,
+          maxConnections: 1
+        },
+        {
+          position: import_system25.Position.Left,
+          connection: "target",
+          label: "Z Module",
+          dataType: 8 /* module */,
+          dataId: "z-module" /* zModule */,
+          maxConnections: 1
+        },
+        {
+          position: import_system25.Position.Right,
+          dataType: 8 /* module */,
+          dataId: "output" /* output */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-rotate-point-template.ts
+var import_utils28 = require("@awesome-flow/core/utils");
+var import_system26 = require("@xyflow/system");
+var NoiseRotatePointNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils28.IDGenerator.template(),
+      type: "noise-rotate-point" /* noiseRotatePoint */,
+      removable: false,
+      data: {
+        title: "Noise Rotate Point",
+        xAngle: 0,
+        yAngle: 0,
+        zAngle: 0
+      },
+      handles: [
+        {
+          position: import_system26.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Module",
+          maxConnections: 1
+        },
+        {
+          position: import_system26.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-scale-point-template.ts
+var import_utils29 = require("@awesome-flow/core/utils");
+var import_system27 = require("@xyflow/system");
+var NoiseScalePointNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils29.IDGenerator.template(),
+      type: "noise-scale-point" /* noiseScalePoint */,
+      data: {
+        title: "Noise Scale Point",
+        xScale: 1,
+        yScale: 1,
+        zScale: 1
+      },
+      handles: [
+        {
+          position: import_system27.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Module",
+          maxConnections: 1
+        },
+        {
+          position: import_system27.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-translate-point-template.ts
+var import_utils30 = require("@awesome-flow/core/utils");
+var import_system28 = require("@xyflow/system");
+var NoiseTranslatePointNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils30.IDGenerator.template(),
+      type: "noise-translate-point" /* noiseTranslatePoint */,
+      data: {
+        title: "Noise Translate Point",
+        translateX: 0,
+        translateY: 0,
+        translateZ: 0
+      },
+      handles: [
+        {
+          position: import_system28.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Module",
+          maxConnections: 1
+        },
+        {
+          position: import_system28.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-turbulence-template.ts
+var import_utils31 = require("@awesome-flow/core/utils");
+var import_system29 = require("@xyflow/system");
+var NoiseTurbulenceNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils31.IDGenerator.template(),
+      type: "noise-turbulence" /* noiseTurbulence */,
+      data: {
+        title: "Noise Turbulence",
+        frequency: 1,
+        power: 1,
+        roughness: 1,
+        seed: 0
+      },
+      handles: [
+        {
+          position: import_system29.Position.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Module",
+          maxConnections: 1
+        },
+        {
+          position: import_system29.Position.Left,
+          dataType: 16 /* variableProperty */,
+          label: "Variable Properties",
+          connection: "target"
+        },
+        {
+          position: import_system29.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/variable-property-template.ts
+var import_utils32 = require("@awesome-flow/core/utils");
+var import_system30 = require("@xyflow/system");
+var VariablePropertyNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils32.IDGenerator.template(),
+      type: "variable-property" /* variableProperty */,
+      data: {
+        title: "Variable Property",
+        property: null
+      },
+      handles: [
+        {
+          position: import_system30.Position.Left,
+          dataType: 32 /* variableValue */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: import_system30.Position.Right,
+          dataType: 16 /* variableProperty */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    switch (type) {
+      case "source":
+        return 16 /* variableProperty */;
+      case "target":
+        return 32 /* variableValue */;
+    }
+  }
+};
+
+// src/templates/modifiers/variable-combine-template.ts
+var import_utils33 = require("@awesome-flow/core/utils");
+var import_system31 = require("@xyflow/system");
+var VariableCombineNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils33.IDGenerator.template(),
+      type: "variable-combine" /* variableCombine */,
+      removable: false,
+      data: {
+        title: "Combine Values",
+        operation: "add" /* add */,
+        value: null
+      },
+      handles: [
+        {
+          position: import_system31.Position.Left,
+          dataType: 32 /* variableValue */,
+          connection: "target"
+        },
+        {
+          position: import_system31.Position.Right,
+          dataType: 32 /* variableValue */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/variable-value-template.ts
+var import_utils34 = require("@awesome-flow/core/utils");
+var import_system32 = require("@xyflow/system");
+var VariableValueNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils34.IDGenerator.template(),
+      type: "variable-value" /* variableValue */,
+      data: {
+        title: "Variable Value",
+        value: null
+      },
+      handles: [
+        {
+          position: import_system32.Position.Right,
+          dataType: 32 /* variableValue */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType(type) {
+    return 32 /* variableValue */;
+  }
+};
+
+// src/templates/groups/module-group-template.ts
+var import_utils35 = require("@awesome-flow/core/utils");
+var import_system33 = require("@xyflow/system");
+var ModuleGroupNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils35.IDGenerator.template(),
+      type: "group-module" /* groupModule */,
+      data: {
+        title: "Modules Group",
+        isGroup: true,
+        initialSize: {
+          width: 300,
+          height: 200
+        },
+        collapsedSize: {
+          width: 300,
+          height: 80
+        }
+      },
+      handles: [
+        {
+          position: import_system33.Position.Bottom,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1,
+          hideOnCollapse: true
+        },
+        {
+          position: import_system33.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-billow-template.ts
+var import_utils36 = require("@awesome-flow/core/utils");
+var import_system34 = require("@xyflow/system");
+var NoiseBillowNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils36.IDGenerator.template(),
+      type: "noise-billow" /* noiseBillow */,
+      removable: false,
+      data: {
+        title: "Billow Noise",
+        frequency: 0.1,
+        lacunarity: 2,
+        octaves: 5,
+        persistence: 0.5,
+        seed: 0
+      },
+      handles: [
+        {
+          position: import_system34.Position.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: import_system34.Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/abstract/node-types.ts
+var noiseNodeTemplates = {
+  ["noise-output" /* noiseOutput */]: new NoiseOutputNodeTemplateFactory(),
+  ["noise-simplex" /* noiseSimplex */]: new NoiseSimplexNodeTemplateFactory(),
+  ["noise-billow" /* noiseBillow */]: new NoiseBillowNodeTemplateFactory(),
+  ["noise-checkerboard" /* noiseCheckerboard */]: new NoiseCheckerboardNodeTemplateFactory(),
+  ["noise-normalize" /* noiseNormalize */]: new NoiseNormalizeNodeTemplateFactory(),
+  ["noise-logger" /* noiseLogger */]: new NoiseLoggerNodeTemplateFactory(),
+  ["noise-constant" /* noiseConst */]: new NoiseConstNodeTemplateFactory(),
+  ["position" /* position */]: new PositionConstNodeTemplateFactory(),
+  ["position-logger" /* positionLogger */]: new PositionLoggerNodeTemplateFactory(),
+  ["grid" /* grid */]: new PositionGridNodeTemplateFactory(),
+  ["texture-data" /* textureData */]: new NoiseRawTextureTemplateFactory(),
+  ["noise-cylinders" /* noiseCylinders */]: new NoiseCylindersNodeTemplateFactory(),
+  ["noise-perlin" /* noisePerlin */]: new NoisePerlinNodeTemplateFactory(),
+  ["noise-ridged-multi" /* noiseRidgedMulti */]: new NoiseRidgedMultiNodeTemplateFactory(),
+  ["noise-spheres" /* noiseSpheres */]: new NoiseSpheresNodeTemplateFactory(),
+  ["noise-voronoi" /* noiseVoronoi */]: new NoiseVoronoiNodeTemplateFactory(),
+  ["noise-combiner" /* noiseCombine */]: new NoiseCombineNodeTemplateFactory(),
+  ["noise-clamp" /* noiseClamp */]: new NoiseClampNodeTemplateFactory(),
+  ["noise-abs" /* noiseAbs */]: new NoiseAbsNodeTemplateFactory(),
+  ["noise-curve" /* noiseCurve */]: new NoiseCurveNodeTemplateFactory(),
+  ["noise-exponent" /* noiseExponent */]: new NoiseExponentNodeTemplateFactory(),
+  ["noise-invert" /* noiseInvert */]: new NoiseInvertNodeTemplateFactory(),
+  ["noise-scale-bias" /* noiseScaleBias */]: new NoiseScaleBiasNodeTemplateFactory(),
+  ["noise-terrace" /* noiseTerrace */]: new NoiseTerraceNodeTemplateFactory(),
+  ["noise-blend" /* noiseBlend */]: new NoiseBlendNodeTemplateFactory(),
+  ["noise-select" /* noiseSelect */]: new NoiseSelectNodeTemplateFactory(),
+  ["noise-displace" /* noiseDisplace */]: new NoiseDisplaceNodeTemplateFactory(),
+  ["noise-rotate-point" /* noiseRotatePoint */]: new NoiseRotatePointNodeTemplateFactory(),
+  ["noise-scale-point" /* noiseScalePoint */]: new NoiseScalePointNodeTemplateFactory(),
+  ["noise-translate-point" /* noiseTranslatePoint */]: new NoiseTranslatePointNodeTemplateFactory(),
+  ["noise-turbulence" /* noiseTurbulence */]: new NoiseTurbulenceNodeTemplateFactory(),
+  ["variable-property" /* variableProperty */]: new VariablePropertyNodeTemplateFactory(),
+  ["variable-combine" /* variableCombine */]: new VariableCombineNodeTemplateFactory(),
+  ["variable-value" /* variableValue */]: new VariableValueNodeTemplateFactory(),
+  ["group-module" /* groupModule */]: new ModuleGroupNodeTemplateFactory()
+};
+
+// src/templates/output/noise-logger-template.ts
+var NoiseLoggerNodeTemplateFactory = class {
+  create() {
+    return {
+      id: import_utils37.IDGenerator.template(),
+      type: "noise-logger" /* noiseLogger */,
+      removable: false,
+      data: {
+        title: "Noise Logger"
+      },
+      handles: [
+        {
+          position: import_system35.Position.Left,
+          dataType: 2 /* noise */,
+          connection: "target"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "target";
+  }
+  getHandleAllowedDataType(type) {
+    return 2 /* noise */;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoiseLoggerNodeTemplateFactory,
+  NoiseOutputNodeTemplateFactory,
+  NoiseRawTextureTemplateFactory,
+  PositionLoggerNodeTemplateFactory
+});
+//# sourceMappingURL=index.cjs.map