@awesome-flow/noise 0.6.0 → 0.7.0

package/dist/abstract/index.js

@@ -29,38 +29,28 @@ var require_fast_deep_equal = __commonJS({
   "../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js"(exports, module) {
     "use strict";
     module.exports = function equal(a, b) {
-      if (a === b)
-        return true;
+      if (a === b) return true;
       if (a && b && typeof a == "object" && typeof b == "object") {
-        if (a.constructor !== b.constructor)
-          return false;
+        if (a.constructor !== b.constructor) return false;
         var length, i, keys;
         if (Array.isArray(a)) {
           length = a.length;
-          if (length != b.length)
-            return false;
+          if (length != b.length) return false;
           for (i = length; i-- !== 0; )
-            if (!equal(a[i], b[i]))
-              return false;
+            if (!equal(a[i], b[i])) return false;
           return true;
         }
-        if (a.constructor === RegExp)
-          return a.source === b.source && a.flags === b.flags;
-        if (a.valueOf !== Object.prototype.valueOf)
-          return a.valueOf() === b.valueOf();
-        if (a.toString !== Object.prototype.toString)
-          return a.toString() === b.toString();
+        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
         keys = Object.keys(a);
         length = keys.length;
-        if (length !== Object.keys(b).length)
-          return false;
+        if (length !== Object.keys(b).length) return false;
         for (i = length; i-- !== 0; )
-          if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
-            return false;
+          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
         for (i = length; i-- !== 0; ) {
           var key = keys[i];
-          if (!equal(a[key], b[key]))
-            return false;
+          if (!equal(a[key], b[key])) return false;
         }
         return true;
       }
@@ -92,51 +82,20 @@ var NoiseSourceControlHandle = /* @__PURE__ */ ((NoiseSourceControlHandle2) => {
   return NoiseSourceControlHandle2;
 })(NoiseSourceControlHandle || {});
 
-// src/nodes/generators/noise-simplex-node.tsx
-import { NodeContainer } from "@awesome-flow/core/layout";
-import { useEffect, useMemo } from "react";
-import { useUpdateNodeComputedData } from "@awesome-flow/core/hooks";
-
-// src/modules/simplex-module.ts
-import Module from "libnoise-ts/module/Module";
-import { createNoise3D } from "simplex-noise";
-var SimplexModule = class extends Module {
-  noise;
-  constructor(random) {
-    super();
-    this.noise = createNoise3D(random);
-  }
-  getValue(x, y, z) {
-    return this.noise(x, y, z);
-  }
-};
-
-// src/nodes/generators/noise-simplex-node.tsx
-import { jsx } from "react/jsx-runtime";
-function NoiseSimplexNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData();
-  const module = useMemo(() => new SimplexModule(), []);
-  useEffect(() => {
-    updateComputedData(id, { module });
-  }, []);
-  return /* @__PURE__ */ jsx(NodeContainer, { id, selected, data, type });
-}
-var noise_simplex_node_default = NoiseSimplexNode;
-
 // src/nodes/generators/position-const-node.tsx
-import { NodeContainer as NodeContainer2 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect2, useState } from "react";
+import { NodeContainer } from "@awesome-flow/core/layout";
+import { useEffect, useState } from "react";
 import { Group, NumberInput, Stack } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData2, useUpdateNodeData } from "@awesome-flow/core/hooks";
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+import { useUpdateNodeComputedData, useUpdateNodeData } from "@awesome-flow/core/hooks";
+import { jsx, jsxs } from "react/jsx-runtime";
 function PositionConstNode({ id, selected, data, type }) {
   const position = data.position ?? { x: 0, y: 0, z: 0 };
   const [x, setX] = useState(position.x);
   const [y, setY] = useState(position.y);
   const [z, setZ] = useState(position.z);
   const updateNodeData = useUpdateNodeData();
-  const updateComputedData = useUpdateNodeComputedData2();
-  useEffect2(() => {
+  const updateComputedData = useUpdateNodeComputedData();
+  useEffect(() => {
     const position2 = { x, y, z };
     updateNodeData(id, {
       position: position2
@@ -145,47 +104,47 @@ function PositionConstNode({ id, selected, data, type }) {
       positions: [position2]
     });
   }, [x, y, z]);
-  return /* @__PURE__ */ jsx2(NodeContainer2, { id, selected, data, type, children: /* @__PURE__ */ jsxs(Stack, { children: [
+  return /* @__PURE__ */ jsx(NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ jsxs(Stack, { children: [
     /* @__PURE__ */ jsxs(Group, { children: [
       "x: ",
-      /* @__PURE__ */ jsx2(NumberInput, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+      /* @__PURE__ */ jsx(NumberInput, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
     ] }),
     /* @__PURE__ */ jsxs(Group, { children: [
       "y: ",
-      /* @__PURE__ */ jsx2(NumberInput, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+      /* @__PURE__ */ jsx(NumberInput, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
     ] }),
     /* @__PURE__ */ jsxs(Group, { children: [
       "z: ",
-      /* @__PURE__ */ jsx2(NumberInput, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+      /* @__PURE__ */ jsx(NumberInput, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
     ] })
   ] }) });
 }
 var position_const_node_default = PositionConstNode;
 
 // src/nodes/generators/position-grid-node.tsx
-import { NodeContainer as NodeContainer3 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect3, useState as useState2 } from "react";
+import { NodeContainer as NodeContainer2 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect2, useState as useState2 } from "react";
 import { Group as Group2, NumberInput as NumberInput2, Stack as Stack2 } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData3, useUpdateNodeData as useUpdateNodeData2 } from "@awesome-flow/core/hooks";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData2, useUpdateNodeData as useUpdateNodeData2 } from "@awesome-flow/core/hooks";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function PositionGridNode({ id, selected, data, type }) {
   const [x, setX] = useState2(data.center?.x);
   const [y, setY] = useState2(data.center?.y);
   const [z, setZ] = useState2(data.center?.z);
   const [radius, setRadius] = useState2(data.radius);
   const updateNodeData = useUpdateNodeData2();
-  const updateComputedData = useUpdateNodeComputedData3();
-  useEffect3(() => {
+  const updateComputedData = useUpdateNodeComputedData2();
+  useEffect2(() => {
     updateNodeData(id, {
       center: { x, y, z }
     });
   }, [x, y, z]);
-  useEffect3(() => {
+  useEffect2(() => {
     updateNodeData(id, {
       radius
     });
   }, [radius]);
-  useEffect3(() => {
+  useEffect2(() => {
     const positions = [];
     for (let i = -radius; i < radius; i++) {
       for (let j = -radius; j < radius; j++) {
@@ -196,39 +155,39 @@ function PositionGridNode({ id, selected, data, type }) {
       positions
     });
   }, [x, y, z, radius]);
-  return /* @__PURE__ */ jsx3(NodeContainer3, { id, selected, data, type, children: /* @__PURE__ */ jsxs2(Stack2, { children: [
+  return /* @__PURE__ */ jsx2(NodeContainer2, { id, selected, data, type, children: /* @__PURE__ */ jsxs2(Stack2, { children: [
     /* @__PURE__ */ jsxs2(Group2, { children: [
       "x: ",
-      /* @__PURE__ */ jsx3(NumberInput2, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
+      /* @__PURE__ */ jsx2(NumberInput2, { size: "xs", w: 100, value: x, onChange: (e) => setX(Number(e)) })
     ] }),
     /* @__PURE__ */ jsxs2(Group2, { children: [
       "y: ",
-      /* @__PURE__ */ jsx3(NumberInput2, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
+      /* @__PURE__ */ jsx2(NumberInput2, { size: "xs", w: 100, value: y, onChange: (e) => setY(Number(e)) })
     ] }),
     /* @__PURE__ */ jsxs2(Group2, { children: [
       "z: ",
-      /* @__PURE__ */ jsx3(NumberInput2, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
+      /* @__PURE__ */ jsx2(NumberInput2, { size: "xs", w: 100, value: z, onChange: (e) => setZ(Number(e)) })
     ] }),
     /* @__PURE__ */ jsxs2(Group2, { children: [
       "r: ",
-      /* @__PURE__ */ jsx3(NumberInput2, { size: "xs", w: 100, value: radius, onChange: (e) => setRadius(Number(e)) })
+      /* @__PURE__ */ jsx2(NumberInput2, { size: "xs", w: 100, value: radius, onChange: (e) => setRadius(Number(e)) })
     ] })
   ] }) });
 }
 var position_grid_node_default = PositionGridNode;
 
 // src/nodes/modifiers/noise-normalize-node.tsx
-import { NodeContainer as NodeContainer4, NodeTrackConnections } from "@awesome-flow/core/layout";
-import { useEffect as useEffect4, useState as useState3 } from "react";
+import { NodeContainer as NodeContainer3, NodeTrackConnections } from "@awesome-flow/core/layout";
+import { useEffect as useEffect3, useState as useState3 } from "react";
 import { Group as Group3, NumberInput as NumberInput3, Stack as Stack3 } from "@mantine/core";
 import {
   useIncomingComputedData,
-  useUpdateNodeComputedData as useUpdateNodeComputedData4,
+  useUpdateNodeComputedData as useUpdateNodeComputedData3,
   useUpdateNodeData as useUpdateNodeData3
 } from "@awesome-flow/core/hooks";
 
 // src/modules/normalize-noise-module.ts
-import ModifierModule from "libnoise-ts/module/modifier";
+import { ModifierModule } from "libnoise-simplex-ts";
 var NormalizeNoiseModule = class extends ModifierModule {
   constructor(source, lowerBound, upperBound) {
     super(source);
@@ -244,14 +203,14 @@ function normalize(value, min, max) {
 }
 
 // src/nodes/modifiers/noise-normalize-node.tsx
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function NoiseNormalizeNode({ id, selected, data, type }) {
   const [intervalStart, setIntervalStart] = useState3(data.intervalStart);
   const [intervalEnd, setIntervalEnd] = useState3(data.intervalEnd);
   const incoming = useIncomingComputedData(id);
   const updateNodeData = useUpdateNodeData3();
-  const updateComputedData = useUpdateNodeComputedData4();
-  useEffect4(() => {
+  const updateComputedData = useUpdateNodeComputedData3();
+  useEffect3(() => {
     if (incoming?.length) {
       const source = incoming[0].module;
       const module = new NormalizeNoiseModule(source, intervalStart, intervalEnd);
@@ -259,9 +218,9 @@ function NoiseNormalizeNode({ id, selected, data, type }) {
     }
     updateNodeData(id, { intervalStart, intervalEnd });
   }, [incoming, intervalStart, intervalEnd]);
-  return /* @__PURE__ */ jsxs3(NodeContainer4, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx4(Stack3, { children: /* @__PURE__ */ jsxs3(Group3, { children: [
-      /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsxs3(NodeContainer3, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx3(Stack3, { children: /* @__PURE__ */ jsxs3(Group3, { children: [
+      /* @__PURE__ */ jsx3(
         NumberInput3,
         {
           size: "xs",
@@ -270,7 +229,7 @@ function NoiseNormalizeNode({ id, selected, data, type }) {
           onChange: (e) => setIntervalStart(Number(e))
         }
       ),
-      /* @__PURE__ */ jsx4(
+      /* @__PURE__ */ jsx3(
         NumberInput3,
         {
           size: "xs",
@@ -280,38 +239,38 @@ function NoiseNormalizeNode({ id, selected, data, type }) {
         }
       )
     ] }) }),
-    /* @__PURE__ */ jsx4(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx3(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_normalize_node_default = NoiseNormalizeNode;
 
 // src/nodes/generators/noise-const-node.tsx
-import { NodeContainer as NodeContainer5 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect5, useMemo as useMemo2, useState as useState4 } from "react";
+import { NodeContainer as NodeContainer4 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect4, useMemo, useState as useState4 } from "react";
 import { Group as Group4, NumberInput as NumberInput4, Stack as Stack4 } from "@mantine/core";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData5, useUpdateNodeData as useUpdateNodeData4 } from "@awesome-flow/core/hooks";
-import { Const } from "libnoise-ts/module/generator";
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData4, useUpdateNodeData as useUpdateNodeData4 } from "@awesome-flow/core/hooks";
+import { Const } from "libnoise-simplex-ts";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function NoiseConstNode({ id, selected, data, type }) {
   const [min, setMin] = useState4(data.min);
   const [max, setMax] = useState4(data.max);
   const [noise, setNoise] = useState4(data.noise);
   const updateNodeData = useUpdateNodeData4();
-  const updateComputedData = useUpdateNodeComputedData5();
-  const module = useMemo2(() => new Const(), []);
-  useEffect5(() => {
+  const updateComputedData = useUpdateNodeComputedData4();
+  const module = useMemo(() => new Const(), []);
+  useEffect4(() => {
     module.value = noise;
     updateNodeData(id, { noise, min, max });
     updateComputedData(id, { module });
   }, [noise, min, max, module, updateNodeData, id, updateComputedData]);
-  return /* @__PURE__ */ jsx5(NodeContainer5, { id, selected, data, type, children: /* @__PURE__ */ jsxs4(Stack4, { children: [
+  return /* @__PURE__ */ jsx4(NodeContainer4, { id, selected, data, type, children: /* @__PURE__ */ jsxs4(Stack4, { children: [
     /* @__PURE__ */ jsxs4(Group4, { children: [
-      /* @__PURE__ */ jsx5(NumberInput4, { size: "xs", w: 100, value: min, onChange: (e) => setMin(Number(e)) }),
-      /* @__PURE__ */ jsx5(NumberInput4, { size: "xs", w: 100, value: max, onChange: (e) => setMax(Number(e)) })
+      /* @__PURE__ */ jsx4(NumberInput4, { size: "xs", w: 100, value: min, onChange: (e) => setMin(Number(e)) }),
+      /* @__PURE__ */ jsx4(NumberInput4, { size: "xs", w: 100, value: max, onChange: (e) => setMax(Number(e)) })
     ] }),
     /* @__PURE__ */ jsxs4(Group4, { children: [
       "noise:",
-      /* @__PURE__ */ jsx5(
+      /* @__PURE__ */ jsx4(
         NumberInput4,
         {
           size: "xs",
@@ -328,15 +287,15 @@ function NoiseConstNode({ id, selected, data, type }) {
 var noise_const_node_default = NoiseConstNode;
 
 // src/nodes/generators/noise-billow-node.tsx
-import { NodeContainer as NodeContainer6, NodeTrackConnections as NodeTrackConnections2 } from "@awesome-flow/core/layout";
-import { useCallback, useMemo as useMemo3 } from "react";
-import { Billow } from "libnoise-ts/module/generator";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData6 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer5, NodeTrackConnections as NodeTrackConnections2 } from "@awesome-flow/core/layout";
+import { useCallback, useMemo as useMemo2 } from "react";
+import { Billow } from "libnoise-simplex-ts";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData5 } from "@awesome-flow/core/hooks";
 import { NodePropertyVariables } from "@awesome-flow/core/components";
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function NoiseBillowNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData6();
-  const module = useMemo3(() => new Billow(), []);
+  const updateComputedData = useUpdateNodeComputedData5();
+  const module = useMemo2(() => new Billow(), []);
   const onPropertiesChange = useCallback(
     (properties) => {
       Object.keys(properties).forEach((k) => {
@@ -346,29 +305,29 @@ function NoiseBillowNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs5(NodeContainer6, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx6(NodePropertyVariables, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx6(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs5(NodeContainer5, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx5(NodePropertyVariables, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx5(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_billow_node_default = NoiseBillowNode;
 
 // src/nodes/output/noise-logger-node.tsx
-import { NodeContainer as NodeContainer7, NodeTrackConnections as NodeTrackConnections3 } from "@awesome-flow/core/layout";
-import { useMemo as useMemo4 } from "react";
+import { NodeContainer as NodeContainer6, NodeTrackConnections as NodeTrackConnections3 } from "@awesome-flow/core/layout";
+import { useMemo as useMemo3 } from "react";
 import { Divider, Stack as Stack5, Text } from "@mantine/core";
 import { useIncomingComputedData as useIncomingComputedData2 } from "@awesome-flow/core/hooks";
-import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function NoiseLoggerNode({ id, selected, data, type }) {
   const incoming = useIncomingComputedData2(id);
-  const noise = useMemo4(() => incoming?.map((p) => p.noise).flat(), [incoming]);
-  return /* @__PURE__ */ jsxs6(NodeContainer7, { id, selected, data, type, children: [
+  const noise = useMemo3(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+  return /* @__PURE__ */ jsxs6(NodeContainer6, { id, selected, data, type, children: [
     /* @__PURE__ */ jsxs6(Text, { children: [
       "Size: ",
       noise?.length || 0
     ] }),
-    /* @__PURE__ */ jsx7(Divider, { h: 5 }),
-    /* @__PURE__ */ jsx7(Stack5, { children: noise?.map((v, i) => /* @__PURE__ */ jsxs6(Text, { children: [
+    /* @__PURE__ */ jsx6(Divider, { h: 5 }),
+    /* @__PURE__ */ jsx6(Stack5, { children: noise?.map((v, i) => /* @__PURE__ */ jsxs6(Text, { children: [
       v.position?.x,
       ":",
       v.position?.y,
@@ -377,24 +336,24 @@ function NoiseLoggerNode({ id, selected, data, type }) {
       ": ",
       v.value
     ] }, i)) }),
-    /* @__PURE__ */ jsx7(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx6(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_logger_node_default = NoiseLoggerNode;
 
 // src/nodes/output/noise-raw-texture-node.tsx
-import { NodeContainer as NodeContainer8, NodeTrackConnections as NodeTrackConnections4 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect6, useMemo as useMemo5, useState as useState5 } from "react";
-import { useIncomingComputedData as useIncomingComputedData3, useUpdateNodeComputedData as useUpdateNodeComputedData7 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer7, NodeTrackConnections as NodeTrackConnections4 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect5, useMemo as useMemo4, useState as useState5 } from "react";
+import { useIncomingComputedData as useIncomingComputedData3, useUpdateNodeComputedData as useUpdateNodeComputedData6 } from "@awesome-flow/core/hooks";
 import { Group as Group5, Stack as Stack6 } from "@mantine/core";
-import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 function NoiseRawTextureNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData7();
+  const updateComputedData = useUpdateNodeComputedData6();
   const [dataLength, setDataLength] = useState5(0);
   const [resolution, setResolution] = useState5(0);
   const incoming = useIncomingComputedData3(id);
-  const noise = useMemo5(() => incoming?.map((p) => p.noise).flat(), [incoming]);
-  useEffect6(() => {
+  const noise = useMemo4(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+  useEffect5(() => {
     if (noise?.length) {
       const size = Math.ceil(Math.sqrt(noise.length));
       const colors = noise.map((n) => [n.value * 255, n.value * 255, n.value * 255, 255]).flat();
@@ -402,10 +361,14 @@ function NoiseRawTextureNode({ id, selected, data, type }) {
       dataArray.set(colors);
       setResolution(size);
       setDataLength(dataArray.length);
-      updateComputedData(id, { textureData: dataArray, textureResolution: size });
+      updateComputedData(id, {
+        textureData: dataArray,
+        textureResolutionX: size,
+        textureResolutionY: size
+      });
     }
   }, [noise]);
-  return /* @__PURE__ */ jsxs7(NodeContainer8, { id, selected, data, type, children: [
+  return /* @__PURE__ */ jsxs7(NodeContainer7, { id, selected, data, type, children: [
     /* @__PURE__ */ jsxs7(Stack6, { children: [
       /* @__PURE__ */ jsxs7(Group5, { children: [
         "Resolution: ",
@@ -426,66 +389,66 @@ function NoiseRawTextureNode({ id, selected, data, type }) {
         dataLength
       ] })
     ] }),
-    /* @__PURE__ */ jsx8(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx7(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_raw_texture_node_default = NoiseRawTextureNode;
 
 // src/nodes/generators/noise-checkerboard-node.tsx
-import { NodeContainer as NodeContainer9 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect7, useMemo as useMemo6 } from "react";
-import { Checkerboard } from "libnoise-ts/module/generator";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData8 } from "@awesome-flow/core/hooks";
-import { jsx as jsx9 } from "react/jsx-runtime";
+import { NodeContainer as NodeContainer8 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect6, useMemo as useMemo5 } from "react";
+import { Checkerboard } from "libnoise-simplex-ts";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData7 } from "@awesome-flow/core/hooks";
+import { jsx as jsx8 } from "react/jsx-runtime";
 function NoiseCheckerboardNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData8();
-  const module = useMemo6(() => new Checkerboard(), []);
-  useEffect7(() => {
+  const updateComputedData = useUpdateNodeComputedData7();
+  const module = useMemo5(() => new Checkerboard(), []);
+  useEffect6(() => {
     updateComputedData(id, { module });
   }, [id, module, updateComputedData]);
-  return /* @__PURE__ */ jsx9(NodeContainer9, { id, selected, data, type });
+  return /* @__PURE__ */ jsx8(NodeContainer8, { id, selected, data, type });
 }
 var noise_checkerboard_node_default = NoiseCheckerboardNode;
 
 // src/nodes/output/positions-logger-node.tsx
-import { NodeContainer as NodeContainer10, NodeTrackConnections as NodeTrackConnections5 } from "@awesome-flow/core/layout";
-import { useMemo as useMemo7 } from "react";
+import { NodeContainer as NodeContainer9, NodeTrackConnections as NodeTrackConnections5 } from "@awesome-flow/core/layout";
+import { useMemo as useMemo6 } from "react";
 import { Divider as Divider2, Stack as Stack7, Text as Text2 } from "@mantine/core";
 import { useIncomingComputedData as useIncomingComputedData4 } from "@awesome-flow/core/hooks";
-import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
 function PositionsLoggerNode({ id, selected, data, type }) {
   const incoming = useIncomingComputedData4(id);
-  const positions = useMemo7(() => {
+  const positions = useMemo6(() => {
     return incoming?.map((p) => p.positions).flat();
   }, [incoming]);
-  return /* @__PURE__ */ jsxs8(NodeContainer10, { id, selected, data, type, children: [
+  return /* @__PURE__ */ jsxs8(NodeContainer9, { id, selected, data, type, children: [
     /* @__PURE__ */ jsxs8(Text2, { children: [
       "Size: ",
       positions?.length || 0
     ] }),
-    /* @__PURE__ */ jsx10(Divider2, { h: 5 }),
-    /* @__PURE__ */ jsx10(Stack7, { children: positions?.map((v, i) => /* @__PURE__ */ jsxs8(Text2, { children: [
+    /* @__PURE__ */ jsx9(Divider2, { h: 5 }),
+    /* @__PURE__ */ jsx9(Stack7, { children: positions?.map((v, i) => /* @__PURE__ */ jsxs8(Text2, { children: [
       v.x,
       ":",
       v.y,
       ":",
       v.z
     ] }, i)) }),
-    /* @__PURE__ */ jsx10(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx9(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var positions_logger_node_default = PositionsLoggerNode;
 
 // src/nodes/generators/noise-cylinders-node.tsx
-import { NodeContainer as NodeContainer11, NodeTrackConnections as NodeTrackConnections6 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback2, useMemo as useMemo8 } from "react";
-import { Cylinders } from "libnoise-ts/module/generator";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData9 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer10, NodeTrackConnections as NodeTrackConnections6 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback2, useMemo as useMemo7 } from "react";
+import { Cylinders } from "libnoise-simplex-ts";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData8 } from "@awesome-flow/core/hooks";
 import { NodePropertyVariables as NodePropertyVariables2 } from "@awesome-flow/core/components";
-import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 function NoiseCylindersNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData9();
-  const module = useMemo8(() => new Cylinders(), []);
+  const updateComputedData = useUpdateNodeComputedData8();
+  const module = useMemo7(() => new Cylinders(), []);
   const onPropertiesChange = useCallback2(
     (properties) => {
       Object.keys(properties).forEach((k) => {
@@ -495,23 +458,23 @@ function NoiseCylindersNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs9(NodeContainer11, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx11(NodePropertyVariables2, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx11(NodeTrackConnections6, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs9(NodeContainer10, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx10(NodePropertyVariables2, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx10(NodeTrackConnections6, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_cylinders_node_default = NoiseCylindersNode;
 
 // src/nodes/generators/noise-perlin-node.tsx
-import { NodeContainer as NodeContainer12, NodeTrackConnections as NodeTrackConnections7 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback3, useMemo as useMemo9 } from "react";
-import { Perlin } from "libnoise-ts/module/generator";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData10 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer11, NodeTrackConnections as NodeTrackConnections7 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback3, useMemo as useMemo8 } from "react";
+import { Perlin } from "libnoise-simplex-ts";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData9 } from "@awesome-flow/core/hooks";
 import { NodePropertyVariables as NodePropertyVariables3 } from "@awesome-flow/core/components";
-import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
 function NoisePerlinNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData10();
-  const module = useMemo9(() => new Perlin(), []);
+  const updateComputedData = useUpdateNodeComputedData9();
+  const module = useMemo8(() => new Perlin(), []);
   const onPropertiesChange = useCallback3(
     (properties) => {
       Object.keys(properties).forEach((k) => {
@@ -521,64 +484,64 @@ function NoisePerlinNode({ id, selected, data, type }) {
     },
     [id, module, updateComputedData]
   );
-  return /* @__PURE__ */ jsxs10(NodeContainer12, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx12(NodePropertyVariables3, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx12(NodeTrackConnections7, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs10(NodeContainer11, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx11(NodePropertyVariables3, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx11(NodeTrackConnections7, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_perlin_node_default = NoisePerlinNode;
 
 // src/nodes/generators/noise-ridgedmulti-node.tsx
-import { NodeContainer as NodeContainer13, NodeTrackConnections as NodeTrackConnections8 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback4, useMemo as useMemo10 } from "react";
-import { RidgedMulti } from "libnoise-ts/module/generator";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData11 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer12, NodeTrackConnections as NodeTrackConnections8 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback4, useMemo as useMemo9 } from "react";
+import { RidgedMulti } from "libnoise-simplex-ts";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData10 } from "@awesome-flow/core/hooks";
 import { NodePropertyVariables as NodePropertyVariables4 } from "@awesome-flow/core/components";
-import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
 function NoiseRidgedMultiNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData11();
-  const module = useMemo10(() => new RidgedMulti(), []);
+  const updateComputedData = useUpdateNodeComputedData10();
+  const module = useMemo9(() => new RidgedMulti(), []);
   const onPropertiesChange = useCallback4((properties) => {
     Object.keys(properties).forEach((k) => module[k] = properties[k].value);
     updateComputedData(id, { module });
   }, []);
-  return /* @__PURE__ */ jsxs11(NodeContainer13, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx13(NodePropertyVariables4, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx13(NodeTrackConnections8, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs11(NodeContainer12, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx12(NodePropertyVariables4, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx12(NodeTrackConnections8, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_ridgedmulti_node_default = NoiseRidgedMultiNode;
 
 // src/nodes/generators/noise-spheres-node.tsx
-import { NodeContainer as NodeContainer14, NodeTrackConnections as NodeTrackConnections9 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback5, useMemo as useMemo11 } from "react";
-import { Spheres } from "libnoise-ts/module/generator";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData12 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer13, NodeTrackConnections as NodeTrackConnections9 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback5, useMemo as useMemo10 } from "react";
+import { Spheres } from "libnoise-simplex-ts";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData11 } from "@awesome-flow/core/hooks";
 import { NodePropertyVariables as NodePropertyVariables5 } from "@awesome-flow/core/components";
-import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
 function NoiseSpheresNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData12();
-  const module = useMemo11(() => new Spheres(), []);
+  const updateComputedData = useUpdateNodeComputedData11();
+  const module = useMemo10(() => new Spheres(), []);
   const onPropertiesChange = useCallback5((properties) => {
     Object.keys(properties).forEach((k) => module[k] = properties[k].value);
     updateComputedData(id, { module });
   }, []);
-  return /* @__PURE__ */ jsxs12(NodeContainer14, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx14(NodePropertyVariables5, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx14(NodeTrackConnections9, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs12(NodeContainer13, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx13(NodePropertyVariables5, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx13(NodeTrackConnections9, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_spheres_node_default = NoiseSpheresNode;
 
 // src/nodes/generators/noise-voronoi-node.tsx
-import { NodeContainer as NodeContainer15, NodeTrackConnections as NodeTrackConnections10 } from "@awesome-flow/core/layout";
+import { NodeContainer as NodeContainer14, NodeTrackConnections as NodeTrackConnections10 } from "@awesome-flow/core/layout";
 import { useCallback as useCallback6 } from "react";
-import { Voronoi } from "libnoise-ts/module/generator";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData13 } from "@awesome-flow/core/hooks";
+import { Voronoi } from "libnoise-simplex-ts";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData12 } from "@awesome-flow/core/hooks";
 import { NodePropertyVariables as NodePropertyVariables6 } from "@awesome-flow/core/components";
-import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
 function NoiseVoronoiNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData13();
+  const updateComputedData = useUpdateNodeComputedData12();
   const onPropertiesChange = useCallback6(
     (properties) => {
       const module = new Voronoi(
@@ -591,19 +554,19 @@ function NoiseVoronoiNode({ id, selected, data, type }) {
     },
     []
   );
-  return /* @__PURE__ */ jsxs13(NodeContainer15, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx15(NodePropertyVariables6, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx15(NodeTrackConnections10, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs13(NodeContainer14, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx14(NodePropertyVariables6, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx14(NodeTrackConnections10, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_voronoi_node_default = NoiseVoronoiNode;
 
 // src/nodes/modifiers/noise-combine-node.tsx
-import { NodeCombobox, NodeContainer as NodeContainer16, NodeTrackConnections as NodeTrackConnections11 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback7, useEffect as useEffect8 } from "react";
+import { NodeCombobox, NodeContainer as NodeContainer15, NodeTrackConnections as NodeTrackConnections11 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback7, useEffect as useEffect7 } from "react";
 import {
   useIncomingComputedData as useIncomingComputedData5,
-  useUpdateNodeComputedData as useUpdateNodeComputedData14,
+  useUpdateNodeComputedData as useUpdateNodeComputedData13,
   useUpdateNodeData as useUpdateNodeData5
 } from "@awesome-flow/core/hooks";
 import {
@@ -615,7 +578,7 @@ import {
 } from "@tabler/icons-react";
 
 // src/abstract/operations.ts
-import { Add, Max, Min, Multiply, Power } from "libnoise-ts/module/combiner";
+import { Add, Max, Min, Multiply, Power } from "libnoise-simplex-ts";
 var NoiseCombineType = /* @__PURE__ */ ((NoiseCombineType3) => {
   NoiseCombineType3["add"] = "add";
   NoiseCombineType3["max"] = "max";
@@ -633,19 +596,19 @@ var noiseCombineModuleMap = {
 };
 
 // src/nodes/modifiers/noise-combine-node.tsx
-import { jsx as jsx16, jsxs as jsxs14 } from "react/jsx-runtime";
+import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
 var options = {
-  add: /* @__PURE__ */ jsx16(IconPlus, {}),
-  min: /* @__PURE__ */ jsx16(IconChevronLeft, {}),
-  max: /* @__PURE__ */ jsx16(IconChevronRight, {}),
-  multiply: /* @__PURE__ */ jsx16(IconAsterisk, {}),
-  power: /* @__PURE__ */ jsx16(IconChevronUp, {})
+  add: /* @__PURE__ */ jsx15(IconPlus, {}),
+  min: /* @__PURE__ */ jsx15(IconChevronLeft, {}),
+  max: /* @__PURE__ */ jsx15(IconChevronRight, {}),
+  multiply: /* @__PURE__ */ jsx15(IconAsterisk, {}),
+  power: /* @__PURE__ */ jsx15(IconChevronUp, {})
 };
 function NoiseCombineNode({ id, selected, data, type }) {
   const updateNodeData = useUpdateNodeData5();
-  const updateComputedData = useUpdateNodeComputedData14();
+  const updateComputedData = useUpdateNodeComputedData13();
   const incoming = useIncomingComputedData5(id);
-  useEffect8(() => {
+  useEffect7(() => {
     const ModuleFactory = noiseCombineModuleMap[data.operation];
     if (incoming?.length > 1) {
       const module = new ModuleFactory(incoming[0].module, incoming[1].module);
@@ -655,40 +618,40 @@ function NoiseCombineNode({ id, selected, data, type }) {
   const onChange = useCallback7((operation) => {
     updateNodeData(id, { operation });
   }, []);
-  return /* @__PURE__ */ jsxs14(NodeContainer16, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx16(NodeCombobox, { options, selected: data.operation, onChange, width: 150 }),
-    /* @__PURE__ */ jsx16(NodeTrackConnections11, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs14(NodeContainer15, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx15(NodeCombobox, { options, selected: data.operation, onChange, width: 150 }),
+    /* @__PURE__ */ jsx15(NodeTrackConnections11, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_combine_node_default = NoiseCombineNode;
 
 // src/nodes/modifiers/noise-clamp-node.tsx
-import { NodeContainer as NodeContainer17, NodeTrackConnections as NodeTrackConnections12 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect9, useState as useState6 } from "react";
+import { NodeContainer as NodeContainer16, NodeTrackConnections as NodeTrackConnections12 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect8, useState as useState6 } from "react";
 import { Group as Group6, NumberInput as NumberInput5, Stack as Stack8 } from "@mantine/core";
 import {
   useIncomingComputedData as useIncomingComputedData6,
-  useUpdateNodeComputedData as useUpdateNodeComputedData15,
+  useUpdateNodeComputedData as useUpdateNodeComputedData14,
   useUpdateNodeData as useUpdateNodeData6
 } from "@awesome-flow/core/hooks";
-import { Clamp } from "libnoise-ts/module/modifier";
-import { jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
+import { Clamp } from "libnoise-simplex-ts";
+import { jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
 function NoiseClampNode({ id, selected, data, type }) {
   const [lowerBound, setLowerBound] = useState6(data.lowerBound);
   const [upperBound, setUpperBound] = useState6(data.upperBound);
   const incoming = useIncomingComputedData6(id);
   const updateNodeData = useUpdateNodeData6();
-  const updateComputedData = useUpdateNodeComputedData15();
-  useEffect9(() => {
+  const updateComputedData = useUpdateNodeComputedData14();
+  useEffect8(() => {
     if (incoming?.length) {
       const module = new Clamp(incoming[0].module, lowerBound, upperBound);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { lowerBound, upperBound });
   }, [incoming, lowerBound, upperBound]);
-  return /* @__PURE__ */ jsxs15(NodeContainer17, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx17(Stack8, { children: /* @__PURE__ */ jsxs15(Group6, { children: [
-      /* @__PURE__ */ jsx17(
+  return /* @__PURE__ */ jsxs15(NodeContainer16, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx16(Stack8, { children: /* @__PURE__ */ jsxs15(Group6, { children: [
+      /* @__PURE__ */ jsx16(
         NumberInput5,
         {
           size: "xs",
@@ -698,7 +661,7 @@ function NoiseClampNode({ id, selected, data, type }) {
           step: 0.1
         }
       ),
-      /* @__PURE__ */ jsx17(
+      /* @__PURE__ */ jsx16(
         NumberInput5,
         {
           size: "xs",
@@ -709,40 +672,40 @@ function NoiseClampNode({ id, selected, data, type }) {
         }
       )
     ] }) }),
-    /* @__PURE__ */ jsx17(NodeTrackConnections12, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx16(NodeTrackConnections12, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_clamp_node_default = NoiseClampNode;
 
 // src/nodes/modifiers/noise-abs-node.tsx
-import { NodeContainer as NodeContainer18, NodeTrackConnections as NodeTrackConnections13 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect10 } from "react";
-import { useIncomingComputedData as useIncomingComputedData7, useUpdateNodeComputedData as useUpdateNodeComputedData16 } from "@awesome-flow/core/hooks";
-import { Abs } from "libnoise-ts/module/modifier";
-import { jsx as jsx18 } from "react/jsx-runtime";
+import { NodeContainer as NodeContainer17, NodeTrackConnections as NodeTrackConnections13 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect9 } from "react";
+import { useIncomingComputedData as useIncomingComputedData7, useUpdateNodeComputedData as useUpdateNodeComputedData15 } from "@awesome-flow/core/hooks";
+import { Abs } from "libnoise-simplex-ts";
+import { jsx as jsx17 } from "react/jsx-runtime";
 function NoiseAbsNode({ id, selected, data, type }) {
   const incoming = useIncomingComputedData7(id);
-  const updateComputedData = useUpdateNodeComputedData16();
-  useEffect10(() => {
+  const updateComputedData = useUpdateNodeComputedData15();
+  useEffect9(() => {
     if (incoming?.length > 0) {
       const module = new Abs(incoming[0].module);
       updateComputedData(id, { module });
     }
   }, [incoming]);
-  return /* @__PURE__ */ jsx18(NodeContainer18, { id, selected, data, type, children: /* @__PURE__ */ jsx18(NodeTrackConnections13, { handles: data.handles, nodeId: id, type: "target" }) });
+  return /* @__PURE__ */ jsx17(NodeContainer17, { id, selected, data, type, children: /* @__PURE__ */ jsx17(NodeTrackConnections13, { handles: data.handles, nodeId: id, type: "target" }) });
 }
 var noise_abs_node_default = NoiseAbsNode;
 
 // src/nodes/output/noise-output-node.tsx
-import { NodeContainer as NodeContainer19, NodeTrackConnections as NodeTrackConnections14 } from "@awesome-flow/core/layout";
+import { NodeContainer as NodeContainer18, NodeTrackConnections as NodeTrackConnections14 } from "@awesome-flow/core/layout";
 import { useCallback as useCallback8, useState as useState7 } from "react";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData17 } from "@awesome-flow/core/hooks";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData16 } from "@awesome-flow/core/hooks";
 import { HandlesIncomingDataStatus } from "@awesome-flow/core/components";
 import { Text as Text3 } from "@mantine/core";
-import { jsx as jsx19, jsxs as jsxs16 } from "react/jsx-runtime";
+import { jsx as jsx18, jsxs as jsxs16 } from "react/jsx-runtime";
 function NoiseOutputNode({ id, selected, data, type }) {
   const [size, setSize] = useState7(0);
-  const updateComputedData = useUpdateNodeComputedData17();
+  const updateComputedData = useUpdateNodeComputedData16();
   const onDataUpdated = useCallback8(
     (handleData) => {
       const incomingPositions = handleData["position" /* position */];
@@ -765,8 +728,8 @@ function NoiseOutputNode({ id, selected, data, type }) {
     },
     []
   );
-  return /* @__PURE__ */ jsxs16(NodeContainer19, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx19(
+  return /* @__PURE__ */ jsxs16(NodeContainer18, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx18(
       HandlesIncomingDataStatus,
       {
         nodeId: id,
@@ -781,17 +744,17 @@ function NoiseOutputNode({ id, selected, data, type }) {
       "Noise points: ",
       size
     ] }),
-    /* @__PURE__ */ jsx19(NodeTrackConnections14, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx18(NodeTrackConnections14, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_output_node_default = NoiseOutputNode;
 
 // src/nodes/modifiers/noise-curve-node.tsx
-import { NodeContainer as NodeContainer20, NodeTrackConnections as NodeTrackConnections15 } from "@awesome-flow/core/layout";
+import { NodeContainer as NodeContainer19, NodeTrackConnections as NodeTrackConnections15 } from "@awesome-flow/core/layout";
 import { ActionIcon, Button, Group as Group7, NumberInput as NumberInput6, Space } from "@mantine/core";
 import {
   useIncomingComputedData as useIncomingComputedData8,
-  useUpdateNodeComputedData as useUpdateNodeComputedData18,
+  useUpdateNodeComputedData as useUpdateNodeComputedData17,
   useUpdateNodeData as useUpdateNodeData7
 } from "@awesome-flow/core/hooks";
 
@@ -799,7 +762,7 @@ import {
 import { useState as useState11, useCallback as useCallback14 } from "react";
 
 // ../../node_modules/.pnpm/@mantine+form@7.10.1_react@18.3.1/node_modules/@mantine/form/esm/actions/actions.mjs
-import { useLayoutEffect, useEffect as useEffect11 } from "react";
+import { useLayoutEffect, useEffect as useEffect10 } from "react";
 function validateFormName(name) {
   if (!/^[0-9a-zA-Z-]+$/.test(name)) {
     throw new Error(
@@ -807,7 +770,7 @@ function validateFormName(name) {
     );
   }
 }
-var useIsomorphicEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect11;
+var useIsomorphicEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect10;
 function useFormEvent(eventKey, handler) {
   useIsomorphicEffect(() => {
     if (eventKey) {
@@ -1051,16 +1014,13 @@ function reorderErrors(path, { from, to }, errors) {
 
 // ../../node_modules/.pnpm/klona@2.0.6/node_modules/klona/full/index.mjs
 function set(obj, key, val) {
-  if (typeof val.value === "object")
-    val.value = klona(val.value);
+  if (typeof val.value === "object") val.value = klona(val.value);
   if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") {
     Object.defineProperty(obj, key, val);
-  } else
-    obj[key] = val.value;
+  } else obj[key] = val.value;
 }
 function klona(x) {
-  if (typeof x !== "object")
-    return x;
+  if (typeof x !== "object") return x;
   var i = 0, k, list, tmp, str = Object.prototype.toString.call(x);
   if (str === "[object Object]") {
     tmp = Object.create(x.__proto__ || null);
@@ -1092,8 +1052,7 @@ function klona(x) {
       set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
     }
     for (i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++) {
-      if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k])
-        continue;
+      if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k]) continue;
       set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
     }
   }
@@ -1408,7 +1367,7 @@ function useFormValues({
 }
 
 // ../../node_modules/.pnpm/@mantine+form@7.10.1_react@18.3.1/node_modules/@mantine/form/esm/hooks/use-form-watch/use-form-watch.mjs
-import { useRef as useRef4, useCallback as useCallback13, useEffect as useEffect12 } from "react";
+import { useRef as useRef4, useCallback as useCallback13, useEffect as useEffect11 } from "react";
 function useFormWatch({
   $status
 }) {
@@ -1416,7 +1375,7 @@ function useFormWatch({
     {}
   );
   const watch = useCallback13((path, callback) => {
-    useEffect12(() => {
+    useEffect11(() => {
       subscribers.current[path] = subscribers.current[path] || [];
       subscribers.current[path].push(callback);
       return () => {
@@ -1705,17 +1664,16 @@ function useForm({
 }
 
 // src/nodes/modifiers/noise-curve-node.tsx
-import { useCallback as useCallback15, useEffect as useEffect13, useState as useState12 } from "react";
-import { Curve } from "libnoise-ts/module/modifier";
-import { Tuple } from "libnoise-ts/util";
+import { useCallback as useCallback15, useEffect as useEffect12, useState as useState12 } from "react";
+import { Curve, Tuple } from "libnoise-simplex-ts";
 import { IconX } from "@tabler/icons-react";
 import { randomId } from "@mantine/hooks";
 import { NodeState } from "@awesome-flow/core/abstract";
-import { Fragment, jsx as jsx20, jsxs as jsxs17 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx19, jsxs as jsxs17 } from "react/jsx-runtime";
 function NoiseCurveNode({ id, selected, data, type }) {
   const incoming = useIncomingComputedData8(id);
   const updateNodeData = useUpdateNodeData7();
-  const updateComputedData = useUpdateNodeComputedData18();
+  const updateComputedData = useUpdateNodeComputedData17();
   const [values, setValues] = useState12([]);
   const form = useForm({
     mode: "uncontrolled",
@@ -1744,11 +1702,11 @@ function NoiseCurveNode({ id, selected, data, type }) {
       form.validate();
     }, [])
   });
-  useEffect13(() => {
+  useEffect12(() => {
     const points = data.points?.length ? data.points.map((v) => ({ input: v.input, output: v.output, key: randomId() })) : [1, 2, 3, 4].map(() => ({ input: 0, output: 0, key: randomId() }));
     form.initialize({ points });
   }, []);
-  useEffect13(() => {
+  useEffect12(() => {
     if (incoming?.length && values?.length >= 4) {
       const module = new Curve(
         incoming[0].module,
@@ -1758,7 +1716,7 @@ function NoiseCurveNode({ id, selected, data, type }) {
     }
   }, [values, incoming]);
   const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs17(Group7, { mt: "xs", children: [
-    /* @__PURE__ */ jsx20(
+    /* @__PURE__ */ jsx19(
       NumberInput6,
       {
         size: "xs",
@@ -1769,7 +1727,7 @@ function NoiseCurveNode({ id, selected, data, type }) {
       },
       form.key(`points.${index}.input`)
     ),
-    /* @__PURE__ */ jsx20(
+    /* @__PURE__ */ jsx19(
       NumberInput6,
       {
         size: "xs",
@@ -1780,22 +1738,22 @@ function NoiseCurveNode({ id, selected, data, type }) {
       },
       form.key(`points.${index}.output`)
     ),
-    data.state === NodeState.edit && values.length > 4 && /* @__PURE__ */ jsx20(
+    data.state === NodeState.edit && values.length > 4 && /* @__PURE__ */ jsx19(
       ActionIcon,
       {
         color: "red",
         variant: "outline",
         size: "sm",
         onClick: () => form.removeListItem("points", index),
-        children: /* @__PURE__ */ jsx20(IconX, { size: "1rem" })
+        children: /* @__PURE__ */ jsx19(IconX, { size: "1rem" })
       }
     )
   ] }, item.key));
-  return /* @__PURE__ */ jsxs17(NodeContainer20, { id, selected, type, data, children: [
+  return /* @__PURE__ */ jsxs17(NodeContainer19, { id, selected, type, data, children: [
     fields,
     data.state === NodeState.edit && /* @__PURE__ */ jsxs17(Fragment, { children: [
-      /* @__PURE__ */ jsx20(Space, { h: 10 }),
-      /* @__PURE__ */ jsx20(
+      /* @__PURE__ */ jsx19(Space, { h: 10 }),
+      /* @__PURE__ */ jsx19(
         Button,
         {
           variant: "outline",
@@ -1806,38 +1764,38 @@ function NoiseCurveNode({ id, selected, data, type }) {
         }
       )
     ] }),
-    /* @__PURE__ */ jsx20(NodeTrackConnections15, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx19(NodeTrackConnections15, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_curve_node_default = NoiseCurveNode;
 
 // src/nodes/modifiers/noise-exponent-node.tsx
-import { NodeContainer as NodeContainer21, NodeTrackConnections as NodeTrackConnections16 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect14, useState as useState13 } from "react";
+import { NodeContainer as NodeContainer20, NodeTrackConnections as NodeTrackConnections16 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect13, useState as useState13 } from "react";
 import { Group as Group8, NumberInput as NumberInput7, Stack as Stack9 } from "@mantine/core";
 import {
   useIncomingComputedData as useIncomingComputedData9,
-  useUpdateNodeComputedData as useUpdateNodeComputedData19,
+  useUpdateNodeComputedData as useUpdateNodeComputedData18,
   useUpdateNodeData as useUpdateNodeData8
 } from "@awesome-flow/core/hooks";
-import { Exponent } from "libnoise-ts/module/modifier";
-import { jsx as jsx21, jsxs as jsxs18 } from "react/jsx-runtime";
+import { Exponent } from "libnoise-simplex-ts";
+import { jsx as jsx20, jsxs as jsxs18 } from "react/jsx-runtime";
 function NoiseExponentNode({ id, selected, data, type }) {
   const [exponent, setExponent] = useState13(data.exponent);
   const incoming = useIncomingComputedData9(id);
   const updateNodeData = useUpdateNodeData8();
-  const updateComputedData = useUpdateNodeComputedData19();
-  useEffect14(() => {
+  const updateComputedData = useUpdateNodeComputedData18();
+  useEffect13(() => {
     if (incoming?.length > 0) {
       const module = new Exponent(incoming[0].module, exponent);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { exponent });
   }, [incoming, exponent]);
-  return /* @__PURE__ */ jsxs18(NodeContainer21, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx21(Stack9, { children: /* @__PURE__ */ jsxs18(Group8, { children: [
+  return /* @__PURE__ */ jsxs18(NodeContainer20, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx20(Stack9, { children: /* @__PURE__ */ jsxs18(Group8, { children: [
       "Exponent:",
-      /* @__PURE__ */ jsx21(
+      /* @__PURE__ */ jsx20(
         NumberInput7,
         {
           size: "xs",
@@ -1847,59 +1805,59 @@ function NoiseExponentNode({ id, selected, data, type }) {
         }
       )
     ] }) }),
-    /* @__PURE__ */ jsx21(NodeTrackConnections16, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx20(NodeTrackConnections16, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_exponent_node_default = NoiseExponentNode;
 
 // src/nodes/modifiers/noise-invert-node.tsx
-import { NodeContainer as NodeContainer22, NodeTrackConnections as NodeTrackConnections17 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect15 } from "react";
-import { useIncomingComputedData as useIncomingComputedData10, useUpdateNodeComputedData as useUpdateNodeComputedData20 } from "@awesome-flow/core/hooks";
-import { Invert } from "libnoise-ts/module/modifier";
-import { jsx as jsx22 } from "react/jsx-runtime";
+import { NodeContainer as NodeContainer21, NodeTrackConnections as NodeTrackConnections17 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect14 } from "react";
+import { useIncomingComputedData as useIncomingComputedData10, useUpdateNodeComputedData as useUpdateNodeComputedData19 } from "@awesome-flow/core/hooks";
+import { Invert } from "libnoise-simplex-ts";
+import { jsx as jsx21 } from "react/jsx-runtime";
 function NoiseInvertNode({ id, selected, data, type }) {
   const incoming = useIncomingComputedData10(id);
-  const updateComputedData = useUpdateNodeComputedData20();
-  useEffect15(() => {
+  const updateComputedData = useUpdateNodeComputedData19();
+  useEffect14(() => {
     if (incoming?.length > 0) {
       const module = new Invert(incoming[0].module);
       updateComputedData(id, { module });
     }
   }, [incoming]);
-  return /* @__PURE__ */ jsx22(NodeContainer22, { id, selected, data, type, children: /* @__PURE__ */ jsx22(NodeTrackConnections17, { handles: data.handles, nodeId: id, type: "target" }) });
+  return /* @__PURE__ */ jsx21(NodeContainer21, { id, selected, data, type, children: /* @__PURE__ */ jsx21(NodeTrackConnections17, { handles: data.handles, nodeId: id, type: "target" }) });
 }
 var noise_invert_node_default = NoiseInvertNode;
 
 // src/nodes/modifiers/noise-scale-bias-node.tsx
-import { NodeContainer as NodeContainer23, NodeTrackConnections as NodeTrackConnections18 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect16, useState as useState14 } from "react";
+import { NodeContainer as NodeContainer22, NodeTrackConnections as NodeTrackConnections18 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect15, useState as useState14 } from "react";
 import { Group as Group9, NumberInput as NumberInput8, Stack as Stack10 } from "@mantine/core";
 import {
   useIncomingComputedData as useIncomingComputedData11,
-  useUpdateNodeComputedData as useUpdateNodeComputedData21,
+  useUpdateNodeComputedData as useUpdateNodeComputedData20,
   useUpdateNodeData as useUpdateNodeData9
 } from "@awesome-flow/core/hooks";
-import { ScaleBias } from "libnoise-ts/module/modifier";
-import { jsx as jsx23, jsxs as jsxs19 } from "react/jsx-runtime";
+import { ScaleBias } from "libnoise-simplex-ts";
+import { jsx as jsx22, jsxs as jsxs19 } from "react/jsx-runtime";
 function NoiseScaleBiasNode({ id, selected, data, type }) {
   const [scale, setScale] = useState14(data.scale);
   const [bias, setBias] = useState14(data.bias);
   const incoming = useIncomingComputedData11(id);
   const updateNodeData = useUpdateNodeData9();
-  const updateComputedData = useUpdateNodeComputedData21();
-  useEffect16(() => {
+  const updateComputedData = useUpdateNodeComputedData20();
+  useEffect15(() => {
     if (incoming?.length > 0) {
       const module = new ScaleBias(incoming[0].module, scale, bias);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { scale, bias });
   }, [incoming, scale, bias]);
-  return /* @__PURE__ */ jsxs19(NodeContainer23, { id, selected, data, type, children: [
+  return /* @__PURE__ */ jsxs19(NodeContainer22, { id, selected, data, type, children: [
     /* @__PURE__ */ jsxs19(Stack10, { children: [
       /* @__PURE__ */ jsxs19(Group9, { children: [
         "Scale:",
-        /* @__PURE__ */ jsx23(
+        /* @__PURE__ */ jsx22(
           NumberInput8,
           {
             size: "xs",
@@ -1912,7 +1870,7 @@ function NoiseScaleBiasNode({ id, selected, data, type }) {
       ] }),
       /* @__PURE__ */ jsxs19(Group9, { children: [
         "Bias:",
-        /* @__PURE__ */ jsx23(
+        /* @__PURE__ */ jsx22(
           NumberInput8,
           {
             size: "xs",
@@ -1924,29 +1882,29 @@ function NoiseScaleBiasNode({ id, selected, data, type }) {
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsx23(NodeTrackConnections18, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx22(NodeTrackConnections18, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_scale_bias_node_default = NoiseScaleBiasNode;
 
 // src/nodes/modifiers/noise-terrace-node.tsx
-import { NodeContainer as NodeContainer24, NodeTrackConnections as NodeTrackConnections19 } from "@awesome-flow/core/layout";
+import { NodeContainer as NodeContainer23, NodeTrackConnections as NodeTrackConnections19 } from "@awesome-flow/core/layout";
 import { ActionIcon as ActionIcon2, Button as Button2, Group as Group10, NumberInput as NumberInput9, Space as Space2 } from "@mantine/core";
 import {
   useIncomingComputedData as useIncomingComputedData12,
-  useUpdateNodeComputedData as useUpdateNodeComputedData22,
+  useUpdateNodeComputedData as useUpdateNodeComputedData21,
   useUpdateNodeData as useUpdateNodeData10
 } from "@awesome-flow/core/hooks";
-import { useCallback as useCallback16, useEffect as useEffect17, useState as useState15 } from "react";
-import { Terrace } from "libnoise-ts/module/modifier";
+import { useCallback as useCallback16, useEffect as useEffect16, useState as useState15 } from "react";
+import { Terrace } from "libnoise-simplex-ts";
 import { IconX as IconX2 } from "@tabler/icons-react";
 import { randomId as randomId2 } from "@mantine/hooks";
 import { NodeState as NodeState2 } from "@awesome-flow/core/abstract";
-import { Fragment as Fragment2, jsx as jsx24, jsxs as jsxs20 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx23, jsxs as jsxs20 } from "react/jsx-runtime";
 function NoiseTerraceNode({ id, selected, data, type }) {
   const incoming = useIncomingComputedData12(id);
   const updateNodeData = useUpdateNodeData10();
-  const updateComputedData = useUpdateNodeComputedData22();
+  const updateComputedData = useUpdateNodeComputedData21();
   const [values, setValues] = useState15([]);
   const form = useForm({
     mode: "uncontrolled",
@@ -1964,18 +1922,18 @@ function NoiseTerraceNode({ id, selected, data, type }) {
       form.validate();
     }, [])
   });
-  useEffect17(() => {
+  useEffect16(() => {
     const points = data.points?.length ? data.points.map((v) => ({ value: v, key: randomId2() })) : [1, 2].map(() => ({ value: 0, key: randomId2() }));
     form.initialize({ points });
   }, []);
-  useEffect17(() => {
+  useEffect16(() => {
     if (incoming?.length && values?.length >= 2) {
       const module = new Terrace(incoming[0].module, values);
       updateComputedData(id, { module });
     }
   }, [values, incoming]);
   const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs20(Group10, { mt: "xs", children: [
-    /* @__PURE__ */ jsx24(
+    /* @__PURE__ */ jsx23(
       NumberInput9,
       {
         size: "xs",
@@ -1985,22 +1943,22 @@ function NoiseTerraceNode({ id, selected, data, type }) {
       },
       form.key(`points.${index}.value`)
     ),
-    data.state === NodeState2.edit && values.length > 2 && /* @__PURE__ */ jsx24(
+    data.state === NodeState2.edit && values.length > 2 && /* @__PURE__ */ jsx23(
       ActionIcon2,
       {
         color: "red",
         variant: "outline",
         size: "sm",
         onClick: () => form.removeListItem("points", index),
-        children: /* @__PURE__ */ jsx24(IconX2, { size: "1rem" })
+        children: /* @__PURE__ */ jsx23(IconX2, { size: "1rem" })
       }
     )
   ] }, item.key));
-  return /* @__PURE__ */ jsxs20(NodeContainer24, { id, selected, type, data, children: [
+  return /* @__PURE__ */ jsxs20(NodeContainer23, { id, selected, type, data, children: [
     fields,
     data.state === NodeState2.edit && /* @__PURE__ */ jsxs20(Fragment2, { children: [
-      /* @__PURE__ */ jsx24(Space2, { h: 10 }),
-      /* @__PURE__ */ jsx24(
+      /* @__PURE__ */ jsx23(Space2, { h: 10 }),
+      /* @__PURE__ */ jsx23(
         Button2,
         {
           variant: "outline",
@@ -2011,20 +1969,20 @@ function NoiseTerraceNode({ id, selected, data, type }) {
         }
       )
     ] }),
-    /* @__PURE__ */ jsx24(NodeTrackConnections19, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx23(NodeTrackConnections19, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_terrace_node_default = NoiseTerraceNode;
 
 // src/nodes/selectors/noise-blend-node.tsx
-import { NodeContainer as NodeContainer25, NodeTrackConnections as NodeTrackConnections20 } from "@awesome-flow/core/layout";
+import { NodeContainer as NodeContainer24, NodeTrackConnections as NodeTrackConnections20 } from "@awesome-flow/core/layout";
 import { useCallback as useCallback17 } from "react";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData23 } from "@awesome-flow/core/hooks";
-import { Blend } from "libnoise-ts/module/selector";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData22 } from "@awesome-flow/core/hooks";
+import { Blend } from "libnoise-simplex-ts";
 import { HandlesIncomingDataStatus as HandlesIncomingDataStatus2 } from "@awesome-flow/core/components";
-import { jsx as jsx25, jsxs as jsxs21 } from "react/jsx-runtime";
+import { jsx as jsx24, jsxs as jsxs21 } from "react/jsx-runtime";
 function NoiseBlendNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData23();
+  const updateComputedData = useUpdateNodeComputedData22();
   const onDataUpdated = useCallback17(
     (incomingData) => {
       const incomingSources = incomingData["source" /* source */];
@@ -2040,8 +1998,8 @@ function NoiseBlendNode({ id, selected, data, type }) {
     },
     []
   );
-  return /* @__PURE__ */ jsxs21(NodeContainer25, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx25(
+  return /* @__PURE__ */ jsxs21(NodeContainer24, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx24(
       HandlesIncomingDataStatus2,
       {
         nodeId: id,
@@ -2052,26 +2010,26 @@ function NoiseBlendNode({ id, selected, data, type }) {
         resetComputedData: true
       }
     ),
-    /* @__PURE__ */ jsx25(NodeTrackConnections20, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx24(NodeTrackConnections20, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_blend_node_default = NoiseBlendNode;
 
 // src/nodes/selectors/noise-select-node.tsx
-import { NodeContainer as NodeContainer26, NodeTrackConnections as NodeTrackConnections21 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback18, useEffect as useEffect18, useState as useState16 } from "react";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData24, useUpdateNodeData as useUpdateNodeData11 } from "@awesome-flow/core/hooks";
-import { Select } from "libnoise-ts/module/selector";
+import { NodeContainer as NodeContainer25, NodeTrackConnections as NodeTrackConnections21 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback18, useEffect as useEffect17, useState as useState16 } from "react";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData23, useUpdateNodeData as useUpdateNodeData11 } from "@awesome-flow/core/hooks";
+import { Select } from "libnoise-simplex-ts";
 import { Group as Group11, NumberInput as NumberInput10, Stack as Stack11 } from "@mantine/core";
 import { HandlesIncomingDataStatus as HandlesIncomingDataStatus3 } from "@awesome-flow/core/components";
-import { jsx as jsx26, jsxs as jsxs22 } from "react/jsx-runtime";
+import { jsx as jsx25, jsxs as jsxs22 } from "react/jsx-runtime";
 function NoiseSelectNode({ id, selected, data, type }) {
   const [edgeFalloff, setEdgeFalloff] = useState16(data.edgeFalloff);
   const [lowerBound, setLowerBound] = useState16(data.lowerBound);
   const [upperBound, setUpperBound] = useState16(data.upperBound);
   const updateNodeData = useUpdateNodeData11();
-  const updateComputedData = useUpdateNodeComputedData24();
-  useEffect18(() => {
+  const updateComputedData = useUpdateNodeComputedData23();
+  useEffect17(() => {
     updateNodeData(id, { edgeFalloff, lowerBound, upperBound });
   }, [edgeFalloff, lowerBound, upperBound]);
   const onDataUpdated = useCallback18(
@@ -2092,11 +2050,11 @@ function NoiseSelectNode({ id, selected, data, type }) {
     },
     []
   );
-  return /* @__PURE__ */ jsxs22(NodeContainer26, { id, selected, data, type, children: [
+  return /* @__PURE__ */ jsxs22(NodeContainer25, { id, selected, data, type, children: [
     /* @__PURE__ */ jsxs22(Stack11, { children: [
       /* @__PURE__ */ jsxs22(Group11, { children: [
         "Edge Falloff:",
-        /* @__PURE__ */ jsx26(
+        /* @__PURE__ */ jsx25(
           NumberInput10,
           {
             size: "xs",
@@ -2109,7 +2067,7 @@ function NoiseSelectNode({ id, selected, data, type }) {
       ] }),
       /* @__PURE__ */ jsxs22(Group11, { children: [
         "Lower Bound:",
-        /* @__PURE__ */ jsx26(
+        /* @__PURE__ */ jsx25(
           NumberInput10,
           {
             size: "xs",
@@ -2122,7 +2080,7 @@ function NoiseSelectNode({ id, selected, data, type }) {
       ] }),
       /* @__PURE__ */ jsxs22(Group11, { children: [
         "Upper Bound:",
-        /* @__PURE__ */ jsx26(
+        /* @__PURE__ */ jsx25(
           NumberInput10,
           {
             size: "xs",
@@ -2133,7 +2091,7 @@ function NoiseSelectNode({ id, selected, data, type }) {
           }
         )
       ] }),
-      /* @__PURE__ */ jsx26(
+      /* @__PURE__ */ jsx25(
         HandlesIncomingDataStatus3,
         {
           nodeId: id,
@@ -2145,20 +2103,20 @@ function NoiseSelectNode({ id, selected, data, type }) {
         }
       )
     ] }),
-    /* @__PURE__ */ jsx26(NodeTrackConnections21, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx25(NodeTrackConnections21, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_select_node_default = NoiseSelectNode;
 
 // src/nodes/transformers/noise-displace-node.tsx
-import { NodeContainer as NodeContainer27, NodeTrackConnections as NodeTrackConnections22 } from "@awesome-flow/core/layout";
+import { NodeContainer as NodeContainer26, NodeTrackConnections as NodeTrackConnections22 } from "@awesome-flow/core/layout";
 import { useCallback as useCallback19 } from "react";
-import { useUpdateNodeComputedData as useUpdateNodeComputedData25 } from "@awesome-flow/core/hooks";
-import { Displace } from "libnoise-ts/module/transformer";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData24 } from "@awesome-flow/core/hooks";
+import { Displace } from "libnoise-simplex-ts";
 import { HandlesIncomingDataStatus as HandlesIncomingDataStatus4 } from "@awesome-flow/core/components";
-import { jsx as jsx27, jsxs as jsxs23 } from "react/jsx-runtime";
+import { jsx as jsx26, jsxs as jsxs23 } from "react/jsx-runtime";
 function NoiseDisplaceNode({ id, selected, data, type }) {
-  const updateComputedData = useUpdateNodeComputedData25();
+  const updateComputedData = useUpdateNodeComputedData24();
   const onDataUpdated = useCallback19(
     (handleData) => {
       const sourceModule = handleData["source" /* sourceModule */];
@@ -2177,8 +2135,8 @@ function NoiseDisplaceNode({ id, selected, data, type }) {
     },
     []
   );
-  return /* @__PURE__ */ jsxs23(NodeContainer27, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx27(
+  return /* @__PURE__ */ jsxs23(NodeContainer26, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx26(
       HandlesIncomingDataStatus4,
       {
         nodeId: id,
@@ -2189,22 +2147,22 @@ function NoiseDisplaceNode({ id, selected, data, type }) {
         resetComputedData: true
       }
     ),
-    /* @__PURE__ */ jsx27(NodeTrackConnections22, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx26(NodeTrackConnections22, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_displace_node_default = NoiseDisplaceNode;
 
 // src/nodes/transformers/noise-rotate-point-node.tsx
-import { NodeContainer as NodeContainer28, NodeTrackConnections as NodeTrackConnections23 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect19, useState as useState17 } from "react";
+import { NodeContainer as NodeContainer27, NodeTrackConnections as NodeTrackConnections23 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect18, useState as useState17 } from "react";
 import {
   useIncomingComputedData as useIncomingComputedData13,
-  useUpdateNodeComputedData as useUpdateNodeComputedData26,
+  useUpdateNodeComputedData as useUpdateNodeComputedData25,
   useUpdateNodeData as useUpdateNodeData12
 } from "@awesome-flow/core/hooks";
 import { Group as Group12, NumberInput as NumberInput11, Stack as Stack12 } from "@mantine/core";
-import { RotatePoint } from "libnoise-ts/module/transformer";
-import { jsx as jsx28, jsxs as jsxs24 } from "react/jsx-runtime";
+import { RotatePoint } from "libnoise-simplex-ts";
+import { jsx as jsx27, jsxs as jsxs24 } from "react/jsx-runtime";
 function NoiseRotatePointNode({
   id,
   selected,
@@ -2216,19 +2174,19 @@ function NoiseRotatePointNode({
   const [zAngle, setZAngle] = useState17(data.zAngle);
   const incoming = useIncomingComputedData13(id);
   const updateNodeData = useUpdateNodeData12();
-  const updateComputedData = useUpdateNodeComputedData26();
-  useEffect19(() => {
+  const updateComputedData = useUpdateNodeComputedData25();
+  useEffect18(() => {
     if (incoming?.length) {
       const module = new RotatePoint(incoming[0].module, xAngle, yAngle, zAngle);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { xAngle, yAngle, zAngle });
   }, [id, updateComputedData, updateNodeData, incoming, xAngle, yAngle, zAngle]);
-  return /* @__PURE__ */ jsxs24(NodeContainer28, { id, selected, data, type, children: [
+  return /* @__PURE__ */ jsxs24(NodeContainer27, { id, selected, data, type, children: [
     /* @__PURE__ */ jsxs24(Stack12, { children: [
       /* @__PURE__ */ jsxs24(Group12, { children: [
         "X Angle:",
-        /* @__PURE__ */ jsx28(
+        /* @__PURE__ */ jsx27(
           NumberInput11,
           {
             size: "xs",
@@ -2241,7 +2199,7 @@ function NoiseRotatePointNode({
       ] }),
       /* @__PURE__ */ jsxs24(Group12, { children: [
         "Y Angle:",
-        /* @__PURE__ */ jsx28(
+        /* @__PURE__ */ jsx27(
           NumberInput11,
           {
             size: "xs",
@@ -2254,7 +2212,7 @@ function NoiseRotatePointNode({
       ] }),
       /* @__PURE__ */ jsxs24(Group12, { children: [
         "Z Angle:",
-        /* @__PURE__ */ jsx28(
+        /* @__PURE__ */ jsx27(
           NumberInput11,
           {
             size: "xs",
@@ -2266,22 +2224,22 @@ function NoiseRotatePointNode({
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsx28(NodeTrackConnections23, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx27(NodeTrackConnections23, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_rotate_point_node_default = NoiseRotatePointNode;
 
 // src/nodes/transformers/noise-scale-point-node.tsx
-import { NodeContainer as NodeContainer29, NodeTrackConnections as NodeTrackConnections24 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect20, useState as useState18 } from "react";
+import { NodeContainer as NodeContainer28, NodeTrackConnections as NodeTrackConnections24 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect19, useState as useState18 } from "react";
 import {
   useIncomingComputedData as useIncomingComputedData14,
-  useUpdateNodeComputedData as useUpdateNodeComputedData27,
+  useUpdateNodeComputedData as useUpdateNodeComputedData26,
   useUpdateNodeData as useUpdateNodeData13
 } from "@awesome-flow/core/hooks";
 import { Group as Group13, NumberInput as NumberInput12, Stack as Stack13 } from "@mantine/core";
-import { ScalePoint } from "libnoise-ts/module/transformer";
-import { jsx as jsx29, jsxs as jsxs25 } from "react/jsx-runtime";
+import { ScalePoint } from "libnoise-simplex-ts";
+import { jsx as jsx28, jsxs as jsxs25 } from "react/jsx-runtime";
 function NoiseScalePointNode({
   id,
   selected,
@@ -2293,19 +2251,19 @@ function NoiseScalePointNode({
   const [zScale, setZScale] = useState18(data.zScale);
   const incoming = useIncomingComputedData14(id);
   const updateNodeData = useUpdateNodeData13();
-  const updateComputedData = useUpdateNodeComputedData27();
-  useEffect20(() => {
+  const updateComputedData = useUpdateNodeComputedData26();
+  useEffect19(() => {
     if (incoming?.length) {
       const module = new ScalePoint(incoming[0].module, xScale, yScale, zScale);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { xScale, yScale, zScale });
   }, [id, incoming, updateComputedData, updateNodeData, xScale, yScale, zScale]);
-  return /* @__PURE__ */ jsxs25(NodeContainer29, { id, selected, data, type, children: [
+  return /* @__PURE__ */ jsxs25(NodeContainer28, { id, selected, data, type, children: [
     /* @__PURE__ */ jsxs25(Stack13, { children: [
       /* @__PURE__ */ jsxs25(Group13, { children: [
         "X Scale:",
-        /* @__PURE__ */ jsx29(
+        /* @__PURE__ */ jsx28(
           NumberInput12,
           {
             size: "xs",
@@ -2318,7 +2276,7 @@ function NoiseScalePointNode({
       ] }),
       /* @__PURE__ */ jsxs25(Group13, { children: [
         "Y Scale:",
-        /* @__PURE__ */ jsx29(
+        /* @__PURE__ */ jsx28(
           NumberInput12,
           {
             size: "xs",
@@ -2331,7 +2289,7 @@ function NoiseScalePointNode({
       ] }),
       /* @__PURE__ */ jsxs25(Group13, { children: [
         "Z Scale:",
-        /* @__PURE__ */ jsx29(
+        /* @__PURE__ */ jsx28(
           NumberInput12,
           {
             size: "xs",
@@ -2343,22 +2301,22 @@ function NoiseScalePointNode({
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsx29(NodeTrackConnections24, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx28(NodeTrackConnections24, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_scale_point_node_default = NoiseScalePointNode;
 
 // src/nodes/transformers/noise-translate-point-node.tsx
-import { NodeContainer as NodeContainer30, NodeTrackConnections as NodeTrackConnections25 } from "@awesome-flow/core/layout";
-import { useEffect as useEffect21, useState as useState19 } from "react";
+import { NodeContainer as NodeContainer29, NodeTrackConnections as NodeTrackConnections25 } from "@awesome-flow/core/layout";
+import { useEffect as useEffect20, useState as useState19 } from "react";
 import {
   useIncomingComputedData as useIncomingComputedData15,
-  useUpdateNodeComputedData as useUpdateNodeComputedData28,
+  useUpdateNodeComputedData as useUpdateNodeComputedData27,
   useUpdateNodeData as useUpdateNodeData14
 } from "@awesome-flow/core/hooks";
 import { Group as Group14, NumberInput as NumberInput13, Stack as Stack14 } from "@mantine/core";
-import { TranslatePoint } from "libnoise-ts/module/transformer";
-import { jsx as jsx30, jsxs as jsxs26 } from "react/jsx-runtime";
+import { TranslatePoint } from "libnoise-simplex-ts";
+import { jsx as jsx29, jsxs as jsxs26 } from "react/jsx-runtime";
 function NoiseTranslatePointNode({
   id,
   selected,
@@ -2370,19 +2328,19 @@ function NoiseTranslatePointNode({
   const [translateZ, setTranslateZ] = useState19(data.translateZ);
   const incoming = useIncomingComputedData15(id);
   const updateNodeData = useUpdateNodeData14();
-  const updateComputedData = useUpdateNodeComputedData28();
-  useEffect21(() => {
+  const updateComputedData = useUpdateNodeComputedData27();
+  useEffect20(() => {
     if (incoming?.length) {
       const module = new TranslatePoint(incoming[0].module, translateX, translateY, translateZ);
       updateComputedData(id, { module });
     }
     updateNodeData(id, { translateX, translateY, translateZ });
   }, [id, incoming, translateX, translateY, translateZ, updateComputedData, updateNodeData]);
-  return /* @__PURE__ */ jsxs26(NodeContainer30, { id, selected, data, type, children: [
+  return /* @__PURE__ */ jsxs26(NodeContainer29, { id, selected, data, type, children: [
     /* @__PURE__ */ jsxs26(Stack14, { children: [
       /* @__PURE__ */ jsxs26(Group14, { children: [
         "Translate X:",
-        /* @__PURE__ */ jsx30(
+        /* @__PURE__ */ jsx29(
           NumberInput13,
           {
             size: "xs",
@@ -2395,7 +2353,7 @@ function NoiseTranslatePointNode({
       ] }),
       /* @__PURE__ */ jsxs26(Group14, { children: [
         "Translate Y:",
-        /* @__PURE__ */ jsx30(
+        /* @__PURE__ */ jsx29(
           NumberInput13,
           {
             size: "xs",
@@ -2408,7 +2366,7 @@ function NoiseTranslatePointNode({
       ] }),
       /* @__PURE__ */ jsxs26(Group14, { children: [
         "Translate Z:",
-        /* @__PURE__ */ jsx30(
+        /* @__PURE__ */ jsx29(
           NumberInput13,
           {
             size: "xs",
@@ -2420,18 +2378,18 @@ function NoiseTranslatePointNode({
         )
       ] })
     ] }),
-    /* @__PURE__ */ jsx30(NodeTrackConnections25, { handles: data.handles, nodeId: id, type: "target" })
+    /* @__PURE__ */ jsx29(NodeTrackConnections25, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_translate_point_node_default = NoiseTranslatePointNode;
 
 // src/nodes/transformers/noise-turbulence-node .tsx
-import { NodeContainer as NodeContainer31, NodeTrackConnections as NodeTrackConnections26 } from "@awesome-flow/core/layout";
-import { useCallback as useCallback20, useEffect as useEffect22, useState as useState20 } from "react";
-import { useIncomingComputedData as useIncomingComputedData16, useUpdateNodeComputedData as useUpdateNodeComputedData29 } from "@awesome-flow/core/hooks";
-import { Turbulence } from "libnoise-ts/module/transformer";
+import { NodeContainer as NodeContainer30, NodeTrackConnections as NodeTrackConnections26 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback20, useEffect as useEffect21, useState as useState20 } from "react";
+import { useIncomingComputedData as useIncomingComputedData16, useUpdateNodeComputedData as useUpdateNodeComputedData28 } from "@awesome-flow/core/hooks";
+import { Turbulence } from "libnoise-simplex-ts";
 import { NodePropertyVariables as NodePropertyVariables7 } from "@awesome-flow/core/components";
-import { jsx as jsx31, jsxs as jsxs27 } from "react/jsx-runtime";
+import { jsx as jsx30, jsxs as jsxs27 } from "react/jsx-runtime";
 function NoiseTurbulenceNode({
   id,
   selected,
@@ -2440,11 +2398,11 @@ function NoiseTurbulenceNode({
 }) {
   const [properties, setProperties] = useState20(null);
   const incoming = useIncomingComputedData16(id);
-  const updateComputedData = useUpdateNodeComputedData29();
+  const updateComputedData = useUpdateNodeComputedData28();
   const onPropertiesChange = useCallback20((props) => {
     setProperties(props);
   }, []);
-  useEffect22(() => {
+  useEffect21(() => {
     if (incoming?.length && properties) {
       const module = new Turbulence(
         incoming[0].module,
@@ -2456,9 +2414,9 @@ function NoiseTurbulenceNode({
       updateComputedData(id, { module });
     }
   }, [id, incoming, properties]);
-  return /* @__PURE__ */ jsxs27(NodeContainer31, { id, selected, data, type, children: [
-    /* @__PURE__ */ jsx31(NodePropertyVariables7, { data, nodeId: id, onPropertiesChange }),
-    /* @__PURE__ */ jsx31(NodeTrackConnections26, { handles: data.handles, nodeId: id, type: "target" })
+  return /* @__PURE__ */ jsxs27(NodeContainer30, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx30(NodePropertyVariables7, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx30(NodeTrackConnections26, { handles: data.handles, nodeId: id, type: "target" })
   ] });
 }
 var noise_turbulence_node_default = NoiseTurbulenceNode;
@@ -2604,36 +2562,9 @@ var NoiseRidgedMultiNodeTemplateFactory = class {
   };
 };
 
-// src/templates/generators/noise-simplex-template.ts
-import {
-  CoreHandleType as CoreHandleType4
-} from "@awesome-flow/core/abstract";
-import { Position as Position6 } from "@xyflow/system";
-var NoiseSimplexNodeTemplateFactory = class {
-  template = {
-    type: "noise-simplex" /* noiseSimplex */,
-    group: "Noise Generators" /* noiseGenerators */,
-    data: {
-      title: "Simplex Noise"
-    },
-    handles: [
-      {
-        position: Position6.Left,
-        dataType: CoreHandleType4.variableProperty,
-        connection: "target"
-      },
-      {
-        position: Position6.Right,
-        dataType: "module" /* module */,
-        connection: "source"
-      }
-    ]
-  };
-};
-
 // src/templates/generators/noise-spheres-template.ts
-import { CoreHandleType as CoreHandleType5 } from "@awesome-flow/core/abstract";
-import { Position as Position7 } from "@xyflow/system";
+import { CoreHandleType as CoreHandleType4 } from "@awesome-flow/core/abstract";
+import { Position as Position6 } from "@xyflow/system";
 var NoiseSpheresNodeTemplateFactory = class {
   template = {
     type: "noise-spheres" /* noiseSpheres */,
@@ -2644,12 +2575,12 @@ var NoiseSpheresNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position7.Left,
-        dataType: CoreHandleType5.variableProperty,
+        position: Position6.Left,
+        dataType: CoreHandleType4.variableProperty,
         connection: "target"
       },
       {
-        position: Position7.Right,
+        position: Position6.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -2658,8 +2589,8 @@ var NoiseSpheresNodeTemplateFactory = class {
 };
 
 // src/templates/generators/noise-voronoi-template.ts
-import { CoreHandleType as CoreHandleType6 } from "@awesome-flow/core/abstract";
-import { Position as Position8 } from "@xyflow/system";
+import { CoreHandleType as CoreHandleType5 } from "@awesome-flow/core/abstract";
+import { Position as Position7 } from "@xyflow/system";
 var NoiseVoronoiNodeTemplateFactory = class {
   template = {
     type: "noise-voronoi" /* noiseVoronoi */,
@@ -2673,12 +2604,12 @@ var NoiseVoronoiNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position8.Left,
-        dataType: CoreHandleType6.variableProperty,
+        position: Position7.Left,
+        dataType: CoreHandleType5.variableProperty,
         connection: "target"
       },
       {
-        position: Position8.Right,
+        position: Position7.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -2687,7 +2618,7 @@ var NoiseVoronoiNodeTemplateFactory = class {
 };
 
 // src/templates/generators/position-const-template.ts
-import { Position as Position9 } from "@xyflow/system";
+import { Position as Position8 } from "@xyflow/system";
 var PositionConstNodeTemplateFactory = class {
   template = {
     type: "position" /* position */,
@@ -2698,7 +2629,7 @@ var PositionConstNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position9.Right,
+        position: Position8.Right,
         dataType: "position" /* position */,
         connection: "source"
       }
@@ -2707,7 +2638,7 @@ var PositionConstNodeTemplateFactory = class {
 };
 
 // src/templates/generators/position-grid-template.ts
-import { Position as Position10 } from "@xyflow/system";
+import { Position as Position9 } from "@xyflow/system";
 var PositionGridNodeTemplateFactory = class {
   template = {
     type: "grid" /* grid */,
@@ -2719,7 +2650,7 @@ var PositionGridNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position10.Right,
+        position: Position9.Right,
         dataType: "position" /* position */,
         connection: "source"
       }
@@ -2729,7 +2660,7 @@ var PositionGridNodeTemplateFactory = class {
 
 // src/templates/modifiers/noise-normalize-template.ts
 import { IDGenerator } from "@awesome-flow/core/utils";
-import { Position as Position11 } from "@xyflow/system";
+import { Position as Position10 } from "@xyflow/system";
 var NoiseNormalizeNodeTemplateFactory = class {
   template = {
     id: IDGenerator.template(),
@@ -2742,13 +2673,13 @@ var NoiseNormalizeNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position11.Left,
+        position: Position10.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position11.Right,
+        position: Position10.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -2757,7 +2688,7 @@ var NoiseNormalizeNodeTemplateFactory = class {
 };
 
 // src/templates/output/noise-logger-template.ts
-import { Position as Position12 } from "@xyflow/system";
+import { Position as Position11 } from "@xyflow/system";
 var NoiseLoggerNodeTemplateFactory = class {
   template = {
     type: "noise-logger" /* noiseLogger */,
@@ -2767,7 +2698,7 @@ var NoiseLoggerNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position12.Left,
+        position: Position11.Left,
         dataType: "noise" /* noise */,
         connection: "target"
       }
@@ -2776,7 +2707,7 @@ var NoiseLoggerNodeTemplateFactory = class {
 };
 
 // src/templates/output/noise-raw-texture-template.ts
-import { Position as Position13 } from "@xyflow/system";
+import { Position as Position12 } from "@xyflow/system";
 var NoiseRawTextureTemplateFactory = class {
   template = {
     type: "texture-data" /* textureData */,
@@ -2786,13 +2717,13 @@ var NoiseRawTextureTemplateFactory = class {
     },
     handles: [
       {
-        position: Position13.Left,
+        position: Position12.Left,
         dataType: "noise" /* noise */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position13.Right,
+        position: Position12.Right,
         dataType: "texture" /* texture */,
         connection: "source"
       }
@@ -2801,7 +2732,7 @@ var NoiseRawTextureTemplateFactory = class {
 };
 
 // src/templates/output/position-logger-template.ts
-import { Position as Position14 } from "@xyflow/system";
+import { Position as Position13 } from "@xyflow/system";
 var PositionLoggerNodeTemplateFactory = class {
   template = {
     type: "position-logger" /* positionLogger */,
@@ -2811,7 +2742,7 @@ var PositionLoggerNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position14.Left,
+        position: Position13.Left,
         dataType: "position" /* position */,
         connection: "target"
       }
@@ -2820,7 +2751,7 @@ var PositionLoggerNodeTemplateFactory = class {
 };
 
 // src/templates/modifiers/noise-combine-template.ts
-import { Position as Position15 } from "@xyflow/system";
+import { Position as Position14 } from "@xyflow/system";
 var NoiseCombineNodeTemplateFactory = class {
   template = {
     type: "noise-combiner" /* noiseCombine */,
@@ -2831,13 +2762,13 @@ var NoiseCombineNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position15.Left,
+        position: Position14.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 2
       },
       {
-        position: Position15.Right,
+        position: Position14.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -2846,7 +2777,7 @@ var NoiseCombineNodeTemplateFactory = class {
 };
 
 // src/templates/modifiers/noise-clamp-template.ts
-import { Position as Position16 } from "@xyflow/system";
+import { Position as Position15 } from "@xyflow/system";
 var NoiseClampNodeTemplateFactory = class {
   template = {
     type: "noise-clamp" /* noiseClamp */,
@@ -2858,13 +2789,13 @@ var NoiseClampNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position16.Left,
+        position: Position15.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position16.Right,
+        position: Position15.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -2873,7 +2804,7 @@ var NoiseClampNodeTemplateFactory = class {
 };
 
 // src/templates/modifiers/noise-abs-template.ts
-import { Position as Position17 } from "@xyflow/system";
+import { Position as Position16 } from "@xyflow/system";
 var NoiseAbsNodeTemplateFactory = class {
   template = {
     type: "noise-abs" /* noiseAbs */,
@@ -2883,13 +2814,13 @@ var NoiseAbsNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position17.Left,
+        position: Position16.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position17.Right,
+        position: Position16.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -2898,7 +2829,7 @@ var NoiseAbsNodeTemplateFactory = class {
 };
 
 // src/templates/output/noise-output-template.ts
-import { Position as Position18 } from "@xyflow/system";
+import { Position as Position17 } from "@xyflow/system";
 var NoiseOutputNodeTemplateFactory = class {
   template = {
     type: "noise-output" /* noiseOutput */,
@@ -2908,18 +2839,18 @@ var NoiseOutputNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position18.Left,
+        position: Position17.Left,
         dataType: "position" /* position */,
         connection: "target"
       },
       {
-        position: Position18.Left,
+        position: Position17.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position18.Right,
+        position: Position17.Right,
         dataType: "noise" /* noise */,
         connection: "source"
       }
@@ -2928,8 +2859,7 @@ var NoiseOutputNodeTemplateFactory = class {
 };
 
 // src/templates/modifiers/noise-curve-template.ts
-import { CoreHandleType as CoreHandleType7 } from "@awesome-flow/core/abstract";
-import { Position as Position19 } from "@xyflow/system";
+import { Position as Position18 } from "@xyflow/system";
 var NoiseCurveNodeTemplateFactory = class {
   template = {
     type: "noise-curve" /* noiseCurve */,
@@ -2940,18 +2870,18 @@ var NoiseCurveNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position19.Left,
+        position: Position18.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
+      // {
+      //   position: Position.Left,
+      //   dataType: CoreHandleType.variableProperty,
+      //   connection: 'target',
+      // },
       {
-        position: Position19.Left,
-        dataType: CoreHandleType7.variableProperty,
-        connection: "target"
-      },
-      {
-        position: Position19.Right,
+        position: Position18.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -2960,7 +2890,7 @@ var NoiseCurveNodeTemplateFactory = class {
 };
 
 // src/templates/modifiers/noise-exponent-template.ts
-import { Position as Position20 } from "@xyflow/system";
+import { Position as Position19 } from "@xyflow/system";
 var NoiseExponentNodeTemplateFactory = class {
   template = {
     type: "noise-exponent" /* noiseExponent */,
@@ -2971,13 +2901,13 @@ var NoiseExponentNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position20.Left,
+        position: Position19.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position20.Right,
+        position: Position19.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -2986,7 +2916,7 @@ var NoiseExponentNodeTemplateFactory = class {
 };
 
 // src/templates/modifiers/noise-invert-template.ts
-import { Position as Position21 } from "@xyflow/system";
+import { Position as Position20 } from "@xyflow/system";
 var NoiseInvertNodeTemplateFactory = class {
   template = {
     type: "noise-invert" /* noiseInvert */,
@@ -2996,13 +2926,13 @@ var NoiseInvertNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position21.Left,
+        position: Position20.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position21.Right,
+        position: Position20.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3011,7 +2941,7 @@ var NoiseInvertNodeTemplateFactory = class {
 };
 
 // src/templates/modifiers/noise-scalebias-template.ts
-import { Position as Position22 } from "@xyflow/system";
+import { Position as Position21 } from "@xyflow/system";
 var NoiseScaleBiasNodeTemplateFactory = class {
   template = {
     type: "noise-scale-bias" /* noiseScaleBias */,
@@ -3023,13 +2953,13 @@ var NoiseScaleBiasNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position22.Left,
+        position: Position21.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position22.Right,
+        position: Position21.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3038,7 +2968,7 @@ var NoiseScaleBiasNodeTemplateFactory = class {
 };
 
 // src/templates/modifiers/noise-terrace-template.ts
-import { Position as Position23 } from "@xyflow/system";
+import { Position as Position22 } from "@xyflow/system";
 var NoiseTerraceNodeTemplateFactory = class {
   template = {
     type: "noise-terrace" /* noiseTerrace */,
@@ -3049,13 +2979,13 @@ var NoiseTerraceNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position23.Left,
+        position: Position22.Left,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1
       },
       {
-        position: Position23.Right,
+        position: Position22.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3064,7 +2994,7 @@ var NoiseTerraceNodeTemplateFactory = class {
 };
 
 // src/templates/selectors/noise-blend-template.ts
-import { Position as Position24 } from "@xyflow/system";
+import { Position as Position23 } from "@xyflow/system";
 var NoiseBlendNodeTemplateFactory = class {
   template = {
     type: "noise-blend" /* noiseBlend */,
@@ -3074,7 +3004,7 @@ var NoiseBlendNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position24.Left,
+        position: Position23.Left,
         dataType: "module" /* module */,
         connection: "target",
         label: "Source Modules",
@@ -3083,7 +3013,7 @@ var NoiseBlendNodeTemplateFactory = class {
         minConnections: 2
       },
       {
-        position: Position24.Left,
+        position: Position23.Left,
         dataType: "module" /* module */,
         dataId: "control" /* control */,
         connection: "target",
@@ -3091,7 +3021,7 @@ var NoiseBlendNodeTemplateFactory = class {
         maxConnections: 1
       },
       {
-        position: Position24.Right,
+        position: Position23.Right,
         dataType: "module" /* module */,
         dataId: "output" /* output */,
         connection: "source"
@@ -3101,7 +3031,7 @@ var NoiseBlendNodeTemplateFactory = class {
 };
 
 // src/templates/selectors/noise-select-template.ts
-import { Position as Position25 } from "@xyflow/system";
+import { Position as Position24 } from "@xyflow/system";
 var NoiseSelectNodeTemplateFactory = class {
   template = {
     type: "noise-select" /* noiseSelect */,
@@ -3114,7 +3044,7 @@ var NoiseSelectNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position25.Left,
+        position: Position24.Left,
         dataType: "module" /* module */,
         dataId: "source" /* source */,
         connection: "target",
@@ -3123,7 +3053,7 @@ var NoiseSelectNodeTemplateFactory = class {
         minConnections: 2
       },
       {
-        position: Position25.Left,
+        position: Position24.Left,
         dataType: "module" /* module */,
         dataId: "control" /* control */,
         connection: "target",
@@ -3131,7 +3061,7 @@ var NoiseSelectNodeTemplateFactory = class {
         maxConnections: 1
       },
       {
-        position: Position25.Right,
+        position: Position24.Right,
         dataType: "module" /* module */,
         dataId: "output" /* output */,
         connection: "source"
@@ -3141,7 +3071,7 @@ var NoiseSelectNodeTemplateFactory = class {
 };
 
 // src/templates/transformers/noise-displace-template.ts
-import { Position as Position26 } from "@xyflow/system";
+import { Position as Position25 } from "@xyflow/system";
 var NoiseDisplaceNodeTemplateFactory = class {
   template = {
     type: "noise-displace" /* noiseDisplace */,
@@ -3151,7 +3081,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position26.Left,
+        position: Position25.Left,
         connection: "target",
         label: "Source Module",
         dataType: "module" /* module */,
@@ -3159,7 +3089,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
         maxConnections: 1
       },
       {
-        position: Position26.Left,
+        position: Position25.Left,
         connection: "target",
         label: "X Module",
         dataType: "module" /* module */,
@@ -3167,7 +3097,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
         maxConnections: 1
       },
       {
-        position: Position26.Left,
+        position: Position25.Left,
         connection: "target",
         label: "Y Module",
         dataType: "module" /* module */,
@@ -3175,7 +3105,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
         maxConnections: 1
       },
       {
-        position: Position26.Left,
+        position: Position25.Left,
         connection: "target",
         label: "Z Module",
         dataType: "module" /* module */,
@@ -3183,7 +3113,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
         maxConnections: 1
       },
       {
-        position: Position26.Right,
+        position: Position25.Right,
         dataType: "module" /* module */,
         dataId: "output" /* output */,
         connection: "source"
@@ -3193,7 +3123,7 @@ var NoiseDisplaceNodeTemplateFactory = class {
 };
 
 // src/templates/transformers/noise-rotate-point-template.ts
-import { Position as Position27 } from "@xyflow/system";
+import { Position as Position26 } from "@xyflow/system";
 var NoiseRotatePointNodeTemplateFactory = class {
   template = {
     type: "noise-rotate-point" /* noiseRotatePoint */,
@@ -3206,14 +3136,14 @@ var NoiseRotatePointNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position27.Left,
+        position: Position26.Left,
         dataType: "module" /* module */,
         connection: "target",
         label: "Source Module",
         maxConnections: 1
       },
       {
-        position: Position27.Right,
+        position: Position26.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3222,7 +3152,7 @@ var NoiseRotatePointNodeTemplateFactory = class {
 };
 
 // src/templates/transformers/noise-scale-point-template.ts
-import { Position as Position28 } from "@xyflow/system";
+import { Position as Position27 } from "@xyflow/system";
 var NoiseScalePointNodeTemplateFactory = class {
   template = {
     type: "noise-scale-point" /* noiseScalePoint */,
@@ -3235,14 +3165,14 @@ var NoiseScalePointNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position28.Left,
+        position: Position27.Left,
         dataType: "module" /* module */,
         connection: "target",
         label: "Source Module",
         maxConnections: 1
       },
       {
-        position: Position28.Right,
+        position: Position27.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3251,7 +3181,7 @@ var NoiseScalePointNodeTemplateFactory = class {
 };
 
 // src/templates/transformers/noise-translate-point-template.ts
-import { Position as Position29 } from "@xyflow/system";
+import { Position as Position28 } from "@xyflow/system";
 var NoiseTranslatePointNodeTemplateFactory = class {
   template = {
     type: "noise-translate-point" /* noiseTranslatePoint */,
@@ -3264,14 +3194,14 @@ var NoiseTranslatePointNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position29.Left,
+        position: Position28.Left,
         dataType: "module" /* module */,
         connection: "target",
         label: "Source Module",
         maxConnections: 1
       },
       {
-        position: Position29.Right,
+        position: Position28.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3280,8 +3210,8 @@ var NoiseTranslatePointNodeTemplateFactory = class {
 };
 
 // src/templates/transformers/noise-turbulence-template.ts
-import { CoreHandleType as CoreHandleType8 } from "@awesome-flow/core/abstract";
-import { Position as Position30 } from "@xyflow/system";
+import { CoreHandleType as CoreHandleType6 } from "@awesome-flow/core/abstract";
+import { Position as Position29 } from "@xyflow/system";
 var NoiseTurbulenceNodeTemplateFactory = class {
   template = {
     type: "noise-turbulence" /* noiseTurbulence */,
@@ -3295,20 +3225,20 @@ var NoiseTurbulenceNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position30.Left,
+        position: Position29.Left,
         dataType: "module" /* module */,
         connection: "target",
         label: "Source Module",
         maxConnections: 1
       },
       {
-        position: Position30.Left,
-        dataType: CoreHandleType8.variableProperty,
+        position: Position29.Left,
+        dataType: CoreHandleType6.variableProperty,
         label: "Variable Properties",
         connection: "target"
       },
       {
-        position: Position30.Right,
+        position: Position29.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3317,9 +3247,9 @@ var NoiseTurbulenceNodeTemplateFactory = class {
 };
 
 // src/templates/generators/noise-billow-template.ts
-import { CoreHandleType as CoreHandleType9 } from "@awesome-flow/core/abstract";
+import { CoreHandleType as CoreHandleType7 } from "@awesome-flow/core/abstract";
 import { IDGenerator as IDGenerator2 } from "@awesome-flow/core/utils";
-import { Position as Position31 } from "@xyflow/system";
+import { Position as Position30 } from "@xyflow/system";
 var NoiseBillowNodeTemplateFactory = class {
   template = {
     id: IDGenerator2.template(),
@@ -3335,12 +3265,12 @@ var NoiseBillowNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position31.Left,
-        dataType: CoreHandleType9.variableProperty,
+        position: Position30.Left,
+        dataType: CoreHandleType7.variableProperty,
         connection: "target"
       },
       {
-        position: Position31.Right,
+        position: Position30.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3353,7 +3283,7 @@ import {
   CoreTemplateGroup
 } from "@awesome-flow/core/abstract";
 import { IDGenerator as IDGenerator3 } from "@awesome-flow/core/utils";
-import { Position as Position32 } from "@xyflow/system";
+import { Position as Position31 } from "@xyflow/system";
 var ModuleGroupNodeTemplateFactory = class {
   template = {
     id: IDGenerator3.template(),
@@ -3373,14 +3303,14 @@ var ModuleGroupNodeTemplateFactory = class {
     },
     handles: [
       {
-        position: Position32.Bottom,
+        position: Position31.Bottom,
         dataType: "module" /* module */,
         connection: "target",
         maxConnections: 1,
         hideOnCollapse: true
       },
       {
-        position: Position32.Right,
+        position: Position31.Right,
         dataType: "module" /* module */,
         connection: "source"
       }
@@ -3389,18 +3319,18 @@ var ModuleGroupNodeTemplateFactory = class {
 };
 
 // src/nodes/groups/module-group-node.tsx
-import { NodeContainer as NodeContainer32, NodeCollapse, NodeTrackConnections as NodeTrackConnections27 } from "@awesome-flow/core/layout";
+import { NodeContainer as NodeContainer31, NodeCollapse, NodeTrackConnections as NodeTrackConnections27 } from "@awesome-flow/core/layout";
 import { NodeResizer, useStore, useUpdateNodeInternals } from "@xyflow/react";
-import { useCallback as useCallback21, useEffect as useEffect23, useMemo as useMemo12 } from "react";
+import { useCallback as useCallback21, useEffect as useEffect22, useMemo as useMemo11 } from "react";
 import { shallow } from "zustand/shallow";
 import { Badge, Group as Group15 } from "@mantine/core";
 import {
   useFlowStore,
   useIncomingComputedData as useIncomingComputedData17,
   useInteractiveStore,
-  useUpdateNodeComputedData as useUpdateNodeComputedData30
+  useUpdateNodeComputedData as useUpdateNodeComputedData29
 } from "@awesome-flow/core/hooks";
-import { jsx as jsx32, jsxs as jsxs28 } from "react/jsx-runtime";
+import { jsx as jsx31, jsxs as jsxs28 } from "react/jsx-runtime";
 function ModuleGroupNode({
   id,
   selected,
@@ -3421,10 +3351,10 @@ function ModuleGroupNode({
     useCallback21((state) => state.nodeIntersectionTargets[id], [id]),
     shallow
   );
-  useEffect23(() => {
+  useEffect22(() => {
     updateNodeInternals(id);
   }, [width, height]);
-  useEffect23(() => {
+  useEffect22(() => {
     triggerNodeChanges([
       {
         id,
@@ -3436,33 +3366,33 @@ function ModuleGroupNode({
   const onCollapsed = useCallback21((collapsed) => {
     setGroupCollapsed(id, collapsed);
   }, []);
-  const size = useMemo12(() => {
+  const size = useMemo11(() => {
     return {
       width: data.initialSize?.width || 100,
       height: data.initialSize?.height || 50
     };
   }, [data.initialSize]);
   const incomingModules = useIncomingComputedData17(id);
-  const updateComputedData = useUpdateNodeComputedData30();
-  useEffect23(() => {
+  const updateComputedData = useUpdateNodeComputedData29();
+  useEffect22(() => {
     if (incomingModules?.length) {
       const { module } = incomingModules[0];
       updateComputedData(id, { module });
     }
   }, [incomingModules]);
   return /* @__PURE__ */ jsxs28(
-    NodeContainer32,
+    NodeContainer31,
     {
       id,
       selected,
       data,
-      title: /* @__PURE__ */ jsx32(Group15, { justify: "space-between", children: /* @__PURE__ */ jsxs28(Group15, { gap: "xs", children: [
-        /* @__PURE__ */ jsx32(Badge, { size: "xs", variant: "outline", radius: "xs", color: "gray", children: groupNodes?.length || 0 }),
-        /* @__PURE__ */ jsx32(NodeCollapse, { nodeId: id, isCollapsed: data.isCollapsed, onCollapsed })
+      title: /* @__PURE__ */ jsx31(Group15, { justify: "space-between", children: /* @__PURE__ */ jsxs28(Group15, { gap: "xs", children: [
+        /* @__PURE__ */ jsx31(Badge, { size: "xs", variant: "outline", radius: "xs", color: "gray", children: groupNodes?.length || 0 }),
+        /* @__PURE__ */ jsx31(NodeCollapse, { nodeId: id, isCollapsed: data.isCollapsed, onCollapsed })
       ] }) }),
       type,
       children: [
-        /* @__PURE__ */ jsx32(
+        /* @__PURE__ */ jsx31(
           NodeResizer,
           {
             nodeId: id,
@@ -3471,7 +3401,7 @@ function ModuleGroupNode({
             isVisible: selected && !data.isCollapsed
           }
         ),
-        /* @__PURE__ */ jsx32(NodeTrackConnections27, { handles: data.handles, nodeId: id, type: "target" })
+        /* @__PURE__ */ jsx31(NodeTrackConnections27, { handles: data.handles, nodeId: id, type: "target" })
       ]
     }
   );
@@ -3488,7 +3418,6 @@ var NoiseNodeType = /* @__PURE__ */ ((NoiseNodeType2) => {
   NoiseNodeType2["noiseLogger"] = "noise-logger";
   NoiseNodeType2["noiseOutput"] = "noise-output";
   NoiseNodeType2["noiseConst"] = "noise-constant";
-  NoiseNodeType2["noiseSimplex"] = "noise-simplex";
   NoiseNodeType2["noiseBillow"] = "noise-billow";
   NoiseNodeType2["noiseCheckerboard"] = "noise-checkerboard";
   NoiseNodeType2["noiseNormalize"] = "noise-normalize";
@@ -3524,7 +3453,6 @@ var noiseNodeTypes = {
   ["position-logger" /* positionLogger */]: positions_logger_node_default,
   ["noise-constant" /* noiseConst */]: noise_const_node_default,
   ["noise-billow" /* noiseBillow */]: noise_billow_node_default,
-  ["noise-simplex" /* noiseSimplex */]: noise_simplex_node_default,
   ["noise-checkerboard" /* noiseCheckerboard */]: noise_checkerboard_node_default,
   ["noise-cylinders" /* noiseCylinders */]: noise_cylinders_node_default,
   ["noise-perlin" /* noisePerlin */]: noise_perlin_node_default,
@@ -3550,7 +3478,6 @@ var noiseNodeTypes = {
 };
 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(),