@awesome-flow/noise 0.1.0

package/dist/abstract/index.js

@@ -0,0 +1,4271 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = __commonJS({
+  "../../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 && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor)
+          return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+          length = a.length;
+          if (length != b.length)
+            return false;
+          for (i = length; i-- !== 0; )
+            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();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length)
+          return false;
+        for (i = length; i-- !== 0; )
+          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;
+        }
+        return true;
+      }
+      return a !== a && b !== b;
+    };
+  }
+});
+
+// src/abstract/handle-types.ts
+var NoiseHandleFlag = /* @__PURE__ */ ((NoiseHandleFlag2) => {
+  NoiseHandleFlag2[NoiseHandleFlag2["texture"] = 1] = "texture";
+  NoiseHandleFlag2[NoiseHandleFlag2["noise"] = 2] = "noise";
+  NoiseHandleFlag2[NoiseHandleFlag2["position"] = 4] = "position";
+  NoiseHandleFlag2[NoiseHandleFlag2["module"] = 8] = "module";
+  NoiseHandleFlag2[NoiseHandleFlag2["variableProperty"] = 16] = "variableProperty";
+  NoiseHandleFlag2[NoiseHandleFlag2["variableValue"] = 32] = "variableValue";
+  return NoiseHandleFlag2;
+})(NoiseHandleFlag || {});
+var DisplacementModule = /* @__PURE__ */ ((DisplacementModule2) => {
+  DisplacementModule2["sourceModule"] = "source";
+  DisplacementModule2["xModule"] = "x-module";
+  DisplacementModule2["yModule"] = "y-module";
+  DisplacementModule2["zModule"] = "z-module";
+  DisplacementModule2["output"] = "output";
+  return DisplacementModule2;
+})(DisplacementModule || {});
+
+// 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 { 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";
+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 position2 = { x, y, z };
+    updateNodeData(id, {
+      position: position2
+    });
+    updateComputedData(id, {
+      positions: [position2]
+    });
+  }, [x, y, z]);
+  return /* @__PURE__ */ jsx2(NodeContainer2, { 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__ */ jsxs(Group, { children: [
+      "y: ",
+      /* @__PURE__ */ jsx2(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)) })
+    ] })
+  ] }) });
+}
+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 { 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";
+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(() => {
+    updateNodeData(id, {
+      center: { x, y, z }
+    });
+  }, [x, y, z]);
+  useEffect3(() => {
+    updateNodeData(id, {
+      radius
+    });
+  }, [radius]);
+  useEffect3(() => {
+    const positions = [];
+    for (let i = -radius; i < radius; i++) {
+      for (let j = -radius; j < radius; j++) {
+        positions.push({ x: x + i, y: y + j, z });
+      }
+    }
+    updateComputedData(id, {
+      positions
+    });
+  }, [x, y, z, radius]);
+  return /* @__PURE__ */ jsx3(NodeContainer3, { 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__ */ jsxs2(Group2, { children: [
+      "y: ",
+      /* @__PURE__ */ jsx3(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__ */ jsxs2(Group2, { children: [
+      "r: ",
+      /* @__PURE__ */ jsx3(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 { Group as Group3, NumberInput as NumberInput3, Stack as Stack3 } from "@mantine/core";
+import {
+  useIncomingComputedData,
+  useUpdateNodeComputedData as useUpdateNodeComputedData4,
+  useUpdateNodeData as useUpdateNodeData3
+} from "@awesome-flow/core/hooks";
+
+// src/modules/normalize-noise-module.ts
+import ModifierModule from "libnoise-ts/module/modifier";
+var NormalizeNoiseModule = class extends ModifierModule {
+  constructor(source, lowerBound, upperBound) {
+    super(source);
+    this.lowerBound = lowerBound;
+    this.upperBound = upperBound;
+  }
+  getValue(x, y, z) {
+    return normalize(this.sourceModule.getValue(x, y, z), this.lowerBound, this.upperBound);
+  }
+};
+function normalize(value, min, max) {
+  return (value - min) / (max - min);
+}
+
+// src/nodes/modifiers/noise-normalize-node.tsx
+import { jsx as jsx4, 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(() => {
+    if (incoming?.length) {
+      const source = incoming[0].module;
+      const module = new NormalizeNoiseModule(source, intervalStart, intervalEnd);
+      updateComputedData(id, { module });
+    }
+    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(
+        NumberInput3,
+        {
+          size: "xs",
+          w: 100,
+          value: intervalStart,
+          onChange: (e) => setIntervalStart(Number(e))
+        }
+      ),
+      /* @__PURE__ */ jsx4(
+        NumberInput3,
+        {
+          size: "xs",
+          w: 100,
+          value: intervalEnd,
+          onChange: (e) => setIntervalEnd(Number(e))
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx4(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 { 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";
+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(() => {
+    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: [
+    /* @__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__ */ jsxs4(Group4, { children: [
+      "noise:",
+      /* @__PURE__ */ jsx5(
+        NumberInput4,
+        {
+          size: "xs",
+          value: noise,
+          onChange: (e) => setNoise(Number(e)),
+          max,
+          min,
+          step: 0.1
+        }
+      )
+    ] })
+  ] }) });
+}
+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 as useCallback2, useMemo as useMemo4 } from "react";
+import { Billow } from "libnoise-ts/module/generator";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData6 } from "@awesome-flow/core/hooks";
+import { nodeDataPropertyExcept as nodeDataPropertyExcept2 } from "@awesome-flow/core/abstract";
+
+// src/layout/node-property-variables.tsx
+import { useIncomingNodeData, useUpdateNodeData as useUpdateNodeData5 } from "@awesome-flow/core/hooks";
+import { useCallback, useEffect as useEffect6, useMemo as useMemo3, useState as useState5 } from "react";
+import { Group as Group5, Stack as Stack5 } from "@mantine/core";
+import { getObjectKeys } from "@awesome-flow/core/utils";
+import { nodeDataPropertyExcept } from "@awesome-flow/core/abstract";
+
+// src/layout/node-value-input.tsx
+import { Input, NumberInput as NumberInput5, Switch } from "@mantine/core";
+import { Fragment, jsx as jsx6 } from "react/jsx-runtime";
+function NodeValueInput({ value, disabled, step, onChange }) {
+  if (value === void 0 || value === null) {
+    return /* @__PURE__ */ jsx6(Fragment, {});
+  }
+  switch (typeof value) {
+    case "boolean": {
+      return /* @__PURE__ */ jsx6(
+        Switch,
+        {
+          checked: value,
+          disabled,
+          onChange: (e) => onChange(e.currentTarget.checked)
+        }
+      );
+    }
+    case "number": {
+      return /* @__PURE__ */ jsx6(NumberInput5, { value, disabled, step, onChange: (e) => onChange(e) });
+    }
+    case "string": {
+      return /* @__PURE__ */ jsx6(
+        Input,
+        {
+          value,
+          disabled,
+          onChange: (e) => onChange(e.currentTarget.value)
+        }
+      );
+    }
+    default:
+      throw new Error(`Unknown input node for value of type: ${typeof value} (${value})`);
+  }
+}
+var node_value_input_default = NodeValueInput;
+
+// src/layout/node-property-input.tsx
+import { Fragment as Fragment2, jsx as jsx7 } from "react/jsx-runtime";
+function NodePropertyInput({ property, onChange }) {
+  if (!property) {
+    return /* @__PURE__ */ jsx7(Fragment2, {});
+  }
+  return /* @__PURE__ */ jsx7(
+    node_value_input_default,
+    {
+      value: property.value,
+      disabled: property.disabled,
+      step: property.step,
+      onChange: (value) => onChange(property.name, value)
+    }
+  );
+}
+var node_property_input_default = NodePropertyInput;
+
+// src/layout/node-property-variables.tsx
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+function NodePropertyVariables({
+  data,
+  nodeId,
+  onPropertiesChange,
+  except = nodeDataPropertyExcept
+}) {
+  const [properties, setProperties] = useState5(() => {
+    const keys = getObjectKeys(data, except);
+    const dataProps = {};
+    for (const key of keys) {
+      dataProps[key] = {
+        name: key,
+        value: data[key]
+      };
+    }
+    return dataProps;
+  });
+  const updateNodeData = useUpdateNodeData5();
+  const incoming = useIncomingNodeData(nodeId);
+  const resetAllDisabled = useCallback(() => {
+    const keys = Object.keys(properties);
+    keys.forEach((k) => {
+      properties[k].disabled = false;
+    });
+    setProperties(properties);
+  }, []);
+  const updatePropertyValue = useCallback((name, value, disabled) => {
+    let property = properties[name];
+    if (property) {
+      property.value = value;
+    } else {
+      property = {
+        name,
+        value
+      };
+    }
+    property.disabled = disabled;
+    setProperties({ ...properties, [name]: property });
+    updateNodeData(nodeId, { [name]: value });
+  }, []);
+  useEffect6(() => {
+    resetAllDisabled();
+    if (incoming?.length) {
+      for (const connection of incoming) {
+        if (connection.property && properties[connection.property.name] !== void 0) {
+          updatePropertyValue(connection.property.name, connection.property.value, true);
+        }
+      }
+    }
+  }, [incoming]);
+  useEffect6(() => {
+    if (onPropertiesChange) {
+      onPropertiesChange(properties);
+    }
+  }, [onPropertiesChange, properties]);
+  const nodes = useMemo3(() => {
+    return Object.keys(properties).map((key) => {
+      const property = properties[key];
+      return /* @__PURE__ */ jsxs5(Group5, { children: [
+        property.name,
+        ":",
+        /* @__PURE__ */ jsx8(node_property_input_default, { property, onChange: updatePropertyValue })
+      ] }, key);
+    });
+  }, [properties, updatePropertyValue]);
+  return /* @__PURE__ */ jsx8(Stack5, { children: nodes });
+}
+var node_property_variables_default = NodePropertyVariables;
+
+// src/nodes/generators/noise-billow-node.tsx
+import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+function NoiseBillowNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData6();
+  const module = useMemo4(() => new Billow(), []);
+  const onPropertiesChange = useCallback2(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module[k] = properties[k].value;
+      });
+      updateComputedData(id, { module });
+    },
+    [id, module, updateComputedData]
+  );
+  return /* @__PURE__ */ jsxs6(NodeContainer6, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx9(
+      node_property_variables_default,
+      {
+        data,
+        except: nodeDataPropertyExcept2,
+        nodeId: id,
+        onPropertiesChange
+      }
+    ),
+    /* @__PURE__ */ jsx9(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 useMemo5 } from "react";
+import { Divider, Stack as Stack6, Text } from "@mantine/core";
+import { useIncomingComputedData as useIncomingComputedData2 } from "@awesome-flow/core/hooks";
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+function NoiseLoggerNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData2(id);
+  const noise = useMemo5(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+  return /* @__PURE__ */ jsxs7(NodeContainer7, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs7(Text, { children: [
+      "Size: ",
+      noise?.length || 0
+    ] }),
+    /* @__PURE__ */ jsx10(Divider, { h: 5 }),
+    /* @__PURE__ */ jsx10(Stack6, { children: noise?.map((v, i) => /* @__PURE__ */ jsxs7(Text, { children: [
+      v.position?.x,
+      ":",
+      v.position?.y,
+      ":",
+      v.position?.z,
+      ": ",
+      v.value
+    ] }, i)) }),
+    /* @__PURE__ */ jsx10(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 useEffect7, useMemo as useMemo6, useState as useState6 } from "react";
+import { useIncomingComputedData as useIncomingComputedData3, useUpdateNodeComputedData as useUpdateNodeComputedData7 } from "@awesome-flow/core/hooks";
+import { Group as Group6, Stack as Stack7 } from "@mantine/core";
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+function NoiseRawTextureNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData7();
+  const [dataLength, setDataLength] = useState6(0);
+  const [resolution, setResolution] = useState6(0);
+  const incoming = useIncomingComputedData3(id);
+  const noise = useMemo6(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+  useEffect7(() => {
+    if (noise?.length) {
+      const size = Math.ceil(Math.sqrt(noise.length));
+      const colors = noise.map((n) => [n.value * 255, n.value * 255, n.value * 255, 255]).flat();
+      const dataArray = new Uint8Array(size * size * 4);
+      dataArray.set(colors);
+      setResolution(size);
+      setDataLength(dataArray.length);
+      updateComputedData(id, { textureData: dataArray, textureResolution: size });
+    }
+  }, [noise]);
+  return /* @__PURE__ */ jsxs8(NodeContainer8, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs8(Stack7, { children: [
+      /* @__PURE__ */ jsxs8(Group6, { children: [
+        "Resolution: ",
+        resolution,
+        "x",
+        resolution
+      ] }),
+      /* @__PURE__ */ jsxs8(Group6, { children: [
+        "Input Length: ",
+        noise?.length || 0
+      ] }),
+      /* @__PURE__ */ jsxs8(Group6, { children: [
+        "Output Length (",
+        resolution,
+        "*",
+        resolution,
+        "*4): ",
+        dataLength
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx11(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 useEffect8, useMemo as useMemo7 } from "react";
+import { Checkerboard } from "libnoise-ts/module/generator";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData8 } from "@awesome-flow/core/hooks";
+import { jsx as jsx12 } from "react/jsx-runtime";
+function NoiseCheckerboardNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData8();
+  const module = useMemo7(() => new Checkerboard(), []);
+  useEffect8(() => {
+    updateComputedData(id, { module });
+  }, [id, module, updateComputedData]);
+  return /* @__PURE__ */ jsx12(NodeContainer9, { 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 useMemo8 } from "react";
+import { Divider as Divider2, Stack as Stack8, Text as Text2 } from "@mantine/core";
+import { useIncomingComputedData as useIncomingComputedData4 } from "@awesome-flow/core/hooks";
+import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+function PositionsLoggerNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData4(id);
+  const positions = useMemo8(() => {
+    return incoming?.map((p) => p.positions).flat();
+  }, [incoming]);
+  return /* @__PURE__ */ jsxs9(NodeContainer10, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs9(Text2, { children: [
+      "Size: ",
+      positions?.length || 0
+    ] }),
+    /* @__PURE__ */ jsx13(Divider2, { h: 5 }),
+    /* @__PURE__ */ jsx13(Stack8, { children: positions?.map((v, i) => /* @__PURE__ */ jsxs9(Text2, { children: [
+      v.x,
+      ":",
+      v.y,
+      ":",
+      v.z
+    ] }, i)) }),
+    /* @__PURE__ */ jsx13(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 useCallback3, useMemo as useMemo9 } from "react";
+import { Cylinders } from "libnoise-ts/module/generator";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData9 } from "@awesome-flow/core/hooks";
+import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+function NoiseCylindersNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData9();
+  const module = useMemo9(() => new Cylinders(), []);
+  const onPropertiesChange = useCallback3(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module[k] = properties[k].value;
+      });
+      updateComputedData(id, { module });
+    },
+    [id, module, updateComputedData]
+  );
+  return /* @__PURE__ */ jsxs10(NodeContainer11, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx14(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx14(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 useCallback4, useMemo as useMemo10 } from "react";
+import { Perlin } from "libnoise-ts/module/generator";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData10 } from "@awesome-flow/core/hooks";
+import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+function NoisePerlinNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData10();
+  const module = useMemo10(() => new Perlin(), []);
+  const onPropertiesChange = useCallback4(
+    (properties) => {
+      Object.keys(properties).forEach((k) => {
+        module[k] = properties[k].value;
+      });
+      updateComputedData(id, { module });
+    },
+    [id, module, updateComputedData]
+  );
+  return /* @__PURE__ */ jsxs11(NodeContainer12, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx15(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx15(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 useCallback5, useMemo as useMemo11 } from "react";
+import { RidgedMulti } from "libnoise-ts/module/generator";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData11 } from "@awesome-flow/core/hooks";
+import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+function NoiseRidgedMultiNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData11();
+  const module = useMemo11(() => new RidgedMulti(), []);
+  const onPropertiesChange = useCallback5((properties) => {
+    Object.keys(properties).forEach((k) => module[k] = properties[k].value);
+    updateComputedData(id, { module });
+  }, []);
+  return /* @__PURE__ */ jsxs12(NodeContainer13, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx16(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx16(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 useCallback6, useMemo as useMemo12 } from "react";
+import { Spheres } from "libnoise-ts/module/generator";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData12 } from "@awesome-flow/core/hooks";
+import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+function NoiseSpheresNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData12();
+  const module = useMemo12(() => new Spheres(), []);
+  const onPropertiesChange = useCallback6((properties) => {
+    Object.keys(properties).forEach((k) => module[k] = properties[k].value);
+    updateComputedData(id, { module });
+  }, []);
+  return /* @__PURE__ */ jsxs13(NodeContainer14, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx17(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx17(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 { useCallback as useCallback7 } from "react";
+import { Voronoi } from "libnoise-ts/module/generator";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData13 } from "@awesome-flow/core/hooks";
+import { jsx as jsx18, jsxs as jsxs14 } from "react/jsx-runtime";
+function NoiseVoronoiNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData13();
+  const onPropertiesChange = useCallback7(
+    (properties) => {
+      const module = new Voronoi(
+        properties.frequency.value,
+        properties.displacement.value,
+        properties.distance.value,
+        properties.seed.value
+      );
+      updateComputedData(id, { module });
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs14(NodeContainer15, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx18(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx18(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 useCallback8, useEffect as useEffect9 } from "react";
+import {
+  useIncomingComputedData as useIncomingComputedData5,
+  useUpdateNodeComputedData as useUpdateNodeComputedData14,
+  useUpdateNodeData as useUpdateNodeData6
+} from "@awesome-flow/core/hooks";
+import {
+  IconAsterisk,
+  IconChevronLeft,
+  IconChevronRight,
+  IconChevronUp,
+  IconPlus
+} from "@tabler/icons-react";
+
+// src/abstract/operations.ts
+import { Add, Max, Min, Multiply, Power } from "libnoise-ts/module/combiner";
+var NoiseCombineType = /* @__PURE__ */ ((NoiseCombineType3) => {
+  NoiseCombineType3["add"] = "add";
+  NoiseCombineType3["max"] = "max";
+  NoiseCombineType3["min"] = "min";
+  NoiseCombineType3["multiply"] = "multiply";
+  NoiseCombineType3["power"] = "power";
+  return NoiseCombineType3;
+})(NoiseCombineType || {});
+var VariableCombineType = /* @__PURE__ */ ((VariableCombineType2) => {
+  VariableCombineType2["add"] = "add";
+  VariableCombineType2["divide"] = "divide";
+  VariableCombineType2["max"] = "max";
+  VariableCombineType2["min"] = "min";
+  VariableCombineType2["multiply"] = "multiply";
+  VariableCombineType2["power"] = "power";
+  return VariableCombineType2;
+})(VariableCombineType || {});
+var noiseCombineModuleMap = {
+  ["add" /* add */]: Add,
+  ["max" /* max */]: Max,
+  ["min" /* min */]: Min,
+  ["multiply" /* multiply */]: Multiply,
+  ["power" /* power */]: Power
+};
+
+// src/nodes/modifiers/noise-combine-node.tsx
+import { jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
+var options = {
+  add: /* @__PURE__ */ jsx19(IconPlus, {}),
+  min: /* @__PURE__ */ jsx19(IconChevronLeft, {}),
+  max: /* @__PURE__ */ jsx19(IconChevronRight, {}),
+  multiply: /* @__PURE__ */ jsx19(IconAsterisk, {}),
+  power: /* @__PURE__ */ jsx19(IconChevronUp, {})
+};
+function NoiseCombineNode({ id, selected, data, type }) {
+  const updateNodeData = useUpdateNodeData6();
+  const updateComputedData = useUpdateNodeComputedData14();
+  const incoming = useIncomingComputedData5(id);
+  useEffect9(() => {
+    const ModuleFactory = noiseCombineModuleMap[data.operation];
+    if (incoming?.length > 1) {
+      const module = new ModuleFactory(incoming[0].module, incoming[1].module);
+      updateComputedData(id, { module });
+    }
+  }, [data.operation, incoming]);
+  const onChange = useCallback8((operation) => {
+    updateNodeData(id, { operation });
+  }, []);
+  return /* @__PURE__ */ jsxs15(NodeContainer16, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx19(NodeCombobox, { options, selected: data.operation, onChange }),
+    /* @__PURE__ */ jsx19(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 useEffect10, useState as useState7 } from "react";
+import { Group as Group7, NumberInput as NumberInput6, Stack as Stack9 } from "@mantine/core";
+import {
+  useIncomingComputedData as useIncomingComputedData6,
+  useUpdateNodeComputedData as useUpdateNodeComputedData15,
+  useUpdateNodeData as useUpdateNodeData7
+} from "@awesome-flow/core/hooks";
+import { Clamp } from "libnoise-ts/module/modifier";
+import { jsx as jsx20, jsxs as jsxs16 } from "react/jsx-runtime";
+function NoiseClampNode({ id, selected, data, type }) {
+  const [lowerBound, setLowerBound] = useState7(data.lowerBound);
+  const [upperBound, setUpperBound] = useState7(data.upperBound);
+  const incoming = useIncomingComputedData6(id);
+  const updateNodeData = useUpdateNodeData7();
+  const updateComputedData = useUpdateNodeComputedData15();
+  useEffect10(() => {
+    if (incoming?.length) {
+      const module = new Clamp(incoming[0].module, lowerBound, upperBound);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { lowerBound, upperBound });
+  }, [incoming, lowerBound, upperBound]);
+  return /* @__PURE__ */ jsxs16(NodeContainer17, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx20(Stack9, { children: /* @__PURE__ */ jsxs16(Group7, { children: [
+      /* @__PURE__ */ jsx20(
+        NumberInput6,
+        {
+          size: "xs",
+          w: 100,
+          value: lowerBound,
+          onChange: (e) => setLowerBound(Number(e)),
+          step: 0.1
+        }
+      ),
+      /* @__PURE__ */ jsx20(
+        NumberInput6,
+        {
+          size: "xs",
+          w: 100,
+          value: upperBound,
+          onChange: (e) => setUpperBound(Number(e)),
+          step: 0.1
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx20(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 useEffect11 } from "react";
+import { useIncomingComputedData as useIncomingComputedData7, useUpdateNodeComputedData as useUpdateNodeComputedData16 } from "@awesome-flow/core/hooks";
+import { Abs } from "libnoise-ts/module/modifier";
+import { jsx as jsx21 } from "react/jsx-runtime";
+function NoiseAbsNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData7(id);
+  const updateComputedData = useUpdateNodeComputedData16();
+  useEffect11(() => {
+    if (incoming?.length > 0) {
+      const module = new Abs(incoming[0].module);
+      updateComputedData(id, { module });
+    }
+  }, [incoming]);
+  return /* @__PURE__ */ jsx21(NodeContainer18, { id, selected, data, type, children: /* @__PURE__ */ jsx21(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 { useIncomingComputedData as useIncomingComputedData8, useUpdateNodeComputedData as useUpdateNodeComputedData17 } from "@awesome-flow/core/hooks";
+import { Box, Group as Group8, LoadingOverlay, Stack as Stack10 } from "@mantine/core";
+import { useEffect as useEffect12, useState as useState8 } from "react";
+import { jsx as jsx22, jsxs as jsxs17 } from "react/jsx-runtime";
+function NoiseOutputNode({ id, selected, data, type }) {
+  const [generating, setGenerating] = useState8(false);
+  const updateComputedData = useUpdateNodeComputedData17();
+  const incomingModules = useIncomingComputedData8(id, 8 /* module */);
+  const incomingPositions = useIncomingComputedData8(
+    id,
+    4 /* position */
+  );
+  useEffect12(() => {
+    if (incomingPositions?.length && incomingModules?.length) {
+      const { module } = incomingModules[0];
+      if (module) {
+        setGenerating(true);
+      }
+    }
+  }, [incomingModules, incomingPositions]);
+  useEffect12(() => {
+    if (incomingPositions?.length && incomingModules?.length) {
+      const { module } = incomingModules[0];
+      if (module && generating) {
+        const noise = [];
+        for (const input of incomingPositions) {
+          for (const position of input.positions) {
+            const value = module.getValue(position.x, position.y, position.z);
+            noise.push({
+              position,
+              value
+            });
+          }
+        }
+        console.log("SET COMPUTED DATA");
+        updateComputedData(id, { noise, module });
+        setGenerating(false);
+      }
+    }
+  }, [generating]);
+  return /* @__PURE__ */ jsxs17(NodeContainer19, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs17(Box, { pos: "relative", children: [
+      /* @__PURE__ */ jsx22(
+        LoadingOverlay,
+        {
+          visible: generating,
+          zIndex: 1e3,
+          overlayProps: { radius: "sm", blur: 2 }
+        }
+      ),
+      /* @__PURE__ */ jsxs17(Stack10, { children: [
+        /* @__PURE__ */ jsxs17(Group8, { children: [
+          "Position Inputs: ",
+          incomingPositions?.length
+        ] }),
+        /* @__PURE__ */ jsxs17(Group8, { children: [
+          "Module Inputs: ",
+          incomingModules?.length
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx22(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 { ActionIcon, Button, Group as Group9, NumberInput as NumberInput7, Space } from "@mantine/core";
+import {
+  useIncomingComputedData as useIncomingComputedData9,
+  useUpdateNodeComputedData as useUpdateNodeComputedData18,
+  useUpdateNodeData as useUpdateNodeData8
+} from "@awesome-flow/core/hooks";
+
+// ../../node_modules/@mantine/form/esm/use-form.mjs
+import { useState as useState12, useCallback as useCallback14 } from "react";
+
+// ../../node_modules/@mantine/form/esm/actions/actions.mjs
+import { useLayoutEffect, useEffect as useEffect13 } from "react";
+function validateFormName(name) {
+  if (!/^[0-9a-zA-Z-]+$/.test(name)) {
+    throw new Error(
+      `[@mantine/use-form] Form name "${name}" is invalid, it should contain only letters, numbers and dashes`
+    );
+  }
+}
+var useIsomorphicEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect13;
+function useFormEvent(eventKey, handler) {
+  useIsomorphicEffect(() => {
+    if (eventKey) {
+      window.addEventListener(eventKey, handler);
+      return () => window.removeEventListener(eventKey, handler);
+    }
+    return void 0;
+  }, [eventKey]);
+}
+function useFormActions(name, form) {
+  if (name) {
+    validateFormName(name);
+  }
+  useFormEvent(
+    `mantine-form:${name}:set-field-value`,
+    (event) => form.setFieldValue(event.detail.path, event.detail.value)
+  );
+  useFormEvent(
+    `mantine-form:${name}:set-values`,
+    (event) => form.setValues(event.detail)
+  );
+  useFormEvent(
+    `mantine-form:${name}:set-initial-values`,
+    (event) => form.setInitialValues(event.detail)
+  );
+  useFormEvent(
+    `mantine-form:${name}:set-errors`,
+    (event) => form.setErrors(event.detail)
+  );
+  useFormEvent(
+    `mantine-form:${name}:set-field-error`,
+    (event) => form.setFieldError(event.detail.path, event.detail.error)
+  );
+  useFormEvent(
+    `mantine-form:${name}:clear-field-error`,
+    (event) => form.clearFieldError(event.detail)
+  );
+  useFormEvent(`mantine-form:${name}:clear-errors`, form.clearErrors);
+  useFormEvent(`mantine-form:${name}:reset`, form.reset);
+  useFormEvent(`mantine-form:${name}:validate`, form.validate);
+  useFormEvent(
+    `mantine-form:${name}:validate-field`,
+    (event) => form.validateField(event.detail)
+  );
+  useFormEvent(
+    `mantine-form:${name}:reorder-list-item`,
+    (event) => form.reorderListItem(event.detail.path, event.detail.payload)
+  );
+  useFormEvent(
+    `mantine-form:${name}:remove-list-item`,
+    (event) => form.removeListItem(event.detail.path, event.detail.index)
+  );
+  useFormEvent(
+    `mantine-form:${name}:insert-list-item`,
+    (event) => form.insertListItem(event.detail.path, event.detail.item, event.detail.index)
+  );
+  useFormEvent(
+    `mantine-form:${name}:set-dirty`,
+    (event) => form.setDirty(event.detail)
+  );
+  useFormEvent(
+    `mantine-form:${name}:set-touched`,
+    (event) => form.setTouched(event.detail)
+  );
+  useFormEvent(
+    `mantine-form:${name}:reset-dirty`,
+    (event) => form.resetDirty(event.detail)
+  );
+  useFormEvent(`mantine-form:${name}:reset-touched`, form.resetTouched);
+}
+
+// ../../node_modules/@mantine/form/esm/get-input-on-change/get-input-on-change.mjs
+function getInputOnChange(setValue) {
+  return (val) => {
+    if (!val) {
+      setValue(val);
+    } else if (typeof val === "function") {
+      setValue(val);
+    } else if (typeof val === "object" && "nativeEvent" in val) {
+      const { currentTarget } = val;
+      if (currentTarget instanceof HTMLInputElement) {
+        if (currentTarget.type === "checkbox") {
+          setValue(currentTarget.checked);
+        } else {
+          setValue(currentTarget.value);
+        }
+      } else if (currentTarget instanceof HTMLTextAreaElement || currentTarget instanceof HTMLSelectElement) {
+        setValue(currentTarget.value);
+      }
+    } else {
+      setValue(val);
+    }
+  };
+}
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-errors/use-form-errors.mjs
+import { useState as useState9, useCallback as useCallback9 } from "react";
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-errors/filter-errors/filter-errors.mjs
+function filterErrors(errors) {
+  if (errors === null || typeof errors !== "object") {
+    return {};
+  }
+  return Object.keys(errors).reduce((acc, key) => {
+    const errorValue = errors[key];
+    if (errorValue !== void 0 && errorValue !== null && errorValue !== false) {
+      acc[key] = errorValue;
+    }
+    return acc;
+  }, {});
+}
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-errors/use-form-errors.mjs
+function useFormErrors(initialErrors) {
+  const [errorsState, setErrorsState] = useState9(filterErrors(initialErrors));
+  const setErrors = useCallback9((errors) => {
+    setErrorsState(
+      (current) => filterErrors(typeof errors === "function" ? errors(current) : errors)
+    );
+  }, []);
+  const clearErrors = useCallback9(() => setErrorsState({}), []);
+  const clearFieldError = useCallback9(
+    (path) => {
+      if (errorsState[path] === void 0) {
+        return;
+      }
+      setErrors((current) => {
+        const errors = { ...current };
+        delete errors[path];
+        return errors;
+      });
+    },
+    [errorsState]
+  );
+  const setFieldError = useCallback9(
+    (path, error) => {
+      if (error == null || error === false) {
+        clearFieldError(path);
+      } else if (errorsState[path] !== error) {
+        setErrors((current) => ({ ...current, [path]: error }));
+      }
+    },
+    [errorsState]
+  );
+  return {
+    errorsState,
+    setErrors,
+    clearErrors,
+    setFieldError,
+    clearFieldError
+  };
+}
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-list/use-form-list.mjs
+import { useCallback as useCallback10 } from "react";
+
+// ../../node_modules/@mantine/form/esm/lists/clear-list-state.mjs
+function clearListState(field, state) {
+  if (state === null || typeof state !== "object") {
+    return {};
+  }
+  const clone = { ...state };
+  Object.keys(state).forEach((errorKey) => {
+    if (errorKey.includes(`${String(field)}.`)) {
+      delete clone[errorKey];
+    }
+  });
+  return clone;
+}
+
+// ../../node_modules/@mantine/form/esm/lists/change-error-indices.mjs
+function getIndexFromKeyAfterPath(key, path) {
+  const split = key.substring(path.length + 1).split(".")[0];
+  return parseInt(split, 10);
+}
+function changeErrorIndices(path, index, errors, change) {
+  if (index === void 0) {
+    return errors;
+  }
+  const pathString = `${String(path)}`;
+  let clearedErrors = errors;
+  if (change === -1) {
+    clearedErrors = clearListState(`${pathString}.${index}`, clearedErrors);
+  }
+  const cloned = { ...clearedErrors };
+  const changedKeys = /* @__PURE__ */ new Set();
+  Object.entries(clearedErrors).filter(([key]) => {
+    if (!key.startsWith(`${pathString}.`)) {
+      return false;
+    }
+    const currIndex = getIndexFromKeyAfterPath(key, pathString);
+    if (Number.isNaN(currIndex)) {
+      return false;
+    }
+    return currIndex >= index;
+  }).forEach(([key, value]) => {
+    const currIndex = getIndexFromKeyAfterPath(key, pathString);
+    const newKey = key.replace(
+      `${pathString}.${currIndex}`,
+      `${pathString}.${currIndex + change}`
+    );
+    cloned[newKey] = value;
+    changedKeys.add(newKey);
+    if (!changedKeys.has(key)) {
+      delete cloned[key];
+    }
+  });
+  return cloned;
+}
+
+// ../../node_modules/@mantine/form/esm/lists/reorder-errors.mjs
+function reorderErrors(path, { from, to }, errors) {
+  const oldKeyStart = `${path}.${from}`;
+  const newKeyStart = `${path}.${to}`;
+  const clone = { ...errors };
+  Object.keys(errors).every((key) => {
+    let oldKey;
+    let newKey;
+    if (key.startsWith(oldKeyStart)) {
+      oldKey = key;
+      newKey = key.replace(oldKeyStart, newKeyStart);
+    }
+    if (key.startsWith(newKeyStart)) {
+      oldKey = key.replace(newKeyStart, oldKeyStart);
+      newKey = key;
+    }
+    if (oldKey && newKey) {
+      const value1 = clone[oldKey];
+      const value2 = clone[newKey];
+      value2 === void 0 ? delete clone[oldKey] : clone[oldKey] = value2;
+      value1 === void 0 ? delete clone[newKey] : clone[newKey] = value1;
+      return false;
+    }
+    return true;
+  });
+  return clone;
+}
+
+// ../../node_modules/klona/full/index.mjs
+function set(obj, key, val) {
+  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;
+}
+function klona(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);
+  } else if (str === "[object Array]") {
+    tmp = Array(x.length);
+  } else if (str === "[object Set]") {
+    tmp = /* @__PURE__ */ new Set();
+    x.forEach(function(val) {
+      tmp.add(klona(val));
+    });
+  } else if (str === "[object Map]") {
+    tmp = /* @__PURE__ */ new Map();
+    x.forEach(function(val, key) {
+      tmp.set(klona(key), klona(val));
+    });
+  } else if (str === "[object Date]") {
+    tmp = /* @__PURE__ */ new Date(+x);
+  } else if (str === "[object RegExp]") {
+    tmp = new RegExp(x.source, x.flags);
+  } else if (str === "[object DataView]") {
+    tmp = new x.constructor(klona(x.buffer));
+  } else if (str === "[object ArrayBuffer]") {
+    tmp = x.slice(0);
+  } else if (str.slice(-6) === "Array]") {
+    tmp = new x.constructor(x);
+  }
+  if (tmp) {
+    for (list = Object.getOwnPropertySymbols(x); i < list.length; i++) {
+      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;
+      set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
+    }
+  }
+  return tmp || x;
+}
+
+// ../../node_modules/@mantine/form/esm/paths/get-splitted-path.mjs
+function getSplittedPath(path) {
+  if (typeof path !== "string") {
+    return [];
+  }
+  return path.split(".");
+}
+
+// ../../node_modules/@mantine/form/esm/paths/get-path.mjs
+function getPath(path, values) {
+  const splittedPath = getSplittedPath(path);
+  if (splittedPath.length === 0 || typeof values !== "object" || values === null) {
+    return void 0;
+  }
+  let value = values[splittedPath[0]];
+  for (let i = 1; i < splittedPath.length; i += 1) {
+    if (value === void 0) {
+      break;
+    }
+    value = value[splittedPath[i]];
+  }
+  return value;
+}
+
+// ../../node_modules/@mantine/form/esm/paths/set-path.mjs
+function setPath(path, value, values) {
+  const splittedPath = getSplittedPath(path);
+  if (splittedPath.length === 0) {
+    return values;
+  }
+  const cloned = klona(values);
+  if (splittedPath.length === 1) {
+    cloned[splittedPath[0]] = value;
+    return cloned;
+  }
+  let val = cloned[splittedPath[0]];
+  for (let i = 1; i < splittedPath.length - 1; i += 1) {
+    if (val === void 0) {
+      return cloned;
+    }
+    val = val[splittedPath[i]];
+  }
+  val[splittedPath[splittedPath.length - 1]] = value;
+  return cloned;
+}
+
+// ../../node_modules/@mantine/form/esm/paths/reorder-path.mjs
+function reorderPath(path, { from, to }, values) {
+  const currentValue = getPath(path, values);
+  if (!Array.isArray(currentValue)) {
+    return values;
+  }
+  const cloned = [...currentValue];
+  const item = currentValue[from];
+  cloned.splice(from, 1);
+  cloned.splice(to, 0, item);
+  return setPath(path, cloned, values);
+}
+
+// ../../node_modules/@mantine/form/esm/paths/insert-path.mjs
+function insertPath(path, value, index, values) {
+  const currentValue = getPath(path, values);
+  if (!Array.isArray(currentValue)) {
+    return values;
+  }
+  const cloned = [...currentValue];
+  cloned.splice(typeof index === "number" ? index : cloned.length, 0, value);
+  return setPath(path, cloned, values);
+}
+
+// ../../node_modules/@mantine/form/esm/paths/remove-path.mjs
+function removePath(path, index, values) {
+  const currentValue = getPath(path, values);
+  if (!Array.isArray(currentValue)) {
+    return values;
+  }
+  return setPath(
+    path,
+    currentValue.filter((_, itemIndex) => itemIndex !== index),
+    values
+  );
+}
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-list/use-form-list.mjs
+function useFormList({
+  $values,
+  $errors,
+  $status
+}) {
+  const reorderListItem = useCallback10((path, payload) => {
+    $status.clearFieldDirty(path);
+    $errors.setErrors((errs) => reorderErrors(path, payload, errs));
+    $values.setValues({
+      values: reorderPath(path, payload, $values.refValues.current),
+      updateState: true
+    });
+  }, []);
+  const removeListItem = useCallback10((path, index) => {
+    $status.clearFieldDirty(path);
+    $errors.setErrors((errs) => changeErrorIndices(path, index, errs, -1));
+    $values.setValues({
+      values: removePath(path, index, $values.refValues.current),
+      updateState: true
+    });
+  }, []);
+  const insertListItem = useCallback10((path, item, index) => {
+    $status.clearFieldDirty(path);
+    $errors.setErrors((errs) => changeErrorIndices(path, index, errs, 1));
+    $values.setValues({
+      values: insertPath(path, item, index, $values.refValues.current),
+      updateState: true
+    });
+  }, []);
+  return { reorderListItem, removeListItem, insertListItem };
+}
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-status/use-form-status.mjs
+var import_fast_deep_equal = __toESM(require_fast_deep_equal(), 1);
+import { useState as useState10, useRef, useCallback as useCallback11 } from "react";
+
+// ../../node_modules/@mantine/form/esm/get-status/get-status.mjs
+function getStatus(status, path) {
+  const paths = Object.keys(status);
+  if (typeof path === "string") {
+    const nestedPaths = paths.filter((statusPath) => statusPath.startsWith(`${path}.`));
+    return status[path] || nestedPaths.some((statusPath) => status[statusPath]) || false;
+  }
+  return paths.some((statusPath) => status[statusPath]);
+}
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-status/use-form-status.mjs
+function useFormStatus({
+  initialDirty,
+  initialTouched,
+  mode,
+  $values
+}) {
+  const [touchedState, setTouchedState] = useState10(initialTouched);
+  const [dirtyState, setDirtyState] = useState10(initialDirty);
+  const touchedRef = useRef(initialTouched);
+  const dirtyRef = useRef(initialDirty);
+  const setTouched = useCallback11((values) => {
+    const resolvedValues = typeof values === "function" ? values(touchedRef.current) : values;
+    touchedRef.current = resolvedValues;
+    if (mode === "controlled") {
+      setTouchedState(resolvedValues);
+    }
+  }, []);
+  const setDirty = useCallback11((values) => {
+    const resolvedValues = typeof values === "function" ? values(dirtyRef.current) : values;
+    dirtyRef.current = resolvedValues;
+    if (mode === "controlled") {
+      setDirtyState(resolvedValues);
+    }
+  }, []);
+  const resetTouched = useCallback11(() => setTouched({}), []);
+  const resetDirty = (values) => {
+    const newSnapshot = values ? { ...values, ...$values.refValues.current } : $values.refValues.current;
+    $values.setValuesSnapshot(newSnapshot);
+    setDirty({});
+  };
+  const setFieldTouched = useCallback11((path, touched) => {
+    setTouched((currentTouched) => {
+      if (getStatus(currentTouched, path) === touched) {
+        return currentTouched;
+      }
+      return { ...currentTouched, [path]: touched };
+    });
+  }, []);
+  const setFieldDirty = useCallback11((path, dirty) => {
+    setDirty((currentDirty) => {
+      if (getStatus(currentDirty, path) === dirty) {
+        return currentDirty;
+      }
+      return { ...currentDirty, [path]: dirty };
+    });
+  }, []);
+  const isTouched = useCallback11(
+    (path) => getStatus(touchedRef.current, path),
+    []
+  );
+  const clearFieldDirty = useCallback11(
+    (path) => setDirty((current) => {
+      if (typeof path !== "string") {
+        return current;
+      }
+      const result = clearListState(path, current);
+      delete result[path];
+      if ((0, import_fast_deep_equal.default)(result, current)) {
+        return current;
+      }
+      return result;
+    }),
+    []
+  );
+  const isDirty = useCallback11((path) => {
+    if (path) {
+      const overriddenValue = getPath(path, dirtyRef.current);
+      if (typeof overriddenValue === "boolean") {
+        return overriddenValue;
+      }
+      const sliceOfValues = getPath(path, $values.refValues.current);
+      const sliceOfInitialValues = getPath(path, $values.valuesSnapshot.current);
+      return !(0, import_fast_deep_equal.default)(sliceOfValues, sliceOfInitialValues);
+    }
+    const isOverridden = Object.keys(dirtyRef.current).length > 0;
+    if (isOverridden) {
+      return getStatus(dirtyRef.current);
+    }
+    return !(0, import_fast_deep_equal.default)($values.refValues.current, $values.valuesSnapshot.current);
+  }, []);
+  const getDirty = useCallback11(() => dirtyRef.current, []);
+  const getTouched = useCallback11(() => touchedRef.current, []);
+  return {
+    touchedState,
+    dirtyState,
+    touchedRef,
+    dirtyRef,
+    setTouched,
+    setDirty,
+    resetDirty,
+    resetTouched,
+    isTouched,
+    setFieldTouched,
+    setFieldDirty,
+    setTouchedState,
+    setDirtyState,
+    clearFieldDirty,
+    isDirty,
+    getDirty,
+    getTouched
+  };
+}
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-values/use-form-values.mjs
+import { useRef as useRef2, useState as useState11, useCallback as useCallback12 } from "react";
+function useFormValues({
+  initialValues,
+  onValuesChange,
+  mode
+}) {
+  const initialized = useRef2(false);
+  const [stateValues, setStateValues] = useState11(initialValues || {});
+  const refValues = useRef2(stateValues);
+  const valuesSnapshot = useRef2(stateValues);
+  const setValues = useCallback12(
+    ({
+      values,
+      subscribers,
+      updateState = true,
+      mergeWithPreviousValues = true
+    }) => {
+      const previousValues = refValues.current;
+      const resolvedValues = values instanceof Function ? values(refValues.current) : values;
+      const updatedValues = mergeWithPreviousValues ? { ...previousValues, ...resolvedValues } : resolvedValues;
+      refValues.current = updatedValues;
+      updateState && setStateValues(updatedValues);
+      onValuesChange?.(updatedValues, previousValues);
+      subscribers?.filter(Boolean).forEach((subscriber) => subscriber({ updatedValues, previousValues }));
+    },
+    [onValuesChange]
+  );
+  const setFieldValue = useCallback12((payload) => {
+    const currentValue = getPath(payload.path, refValues.current);
+    const updatedValue = payload.value instanceof Function ? payload.value(currentValue) : payload.value;
+    if (currentValue !== updatedValue) {
+      const previousValues = refValues.current;
+      const updatedValues = setPath(payload.path, updatedValue, refValues.current);
+      setValues({ values: updatedValues, updateState: payload.updateState });
+      payload.subscribers?.filter(Boolean).forEach(
+        (subscriber) => subscriber({ path: payload.path, updatedValues, previousValues })
+      );
+    }
+  }, []);
+  const setValuesSnapshot = useCallback12((payload) => {
+    valuesSnapshot.current = payload;
+  }, []);
+  const initialize = useCallback12((values, onInitialize) => {
+    if (!initialized.current) {
+      initialized.current = true;
+      setValues({ values, updateState: mode === "controlled" });
+      setValuesSnapshot(values);
+      onInitialize();
+    }
+  }, []);
+  const resetValues = useCallback12(() => {
+    setValues({
+      values: valuesSnapshot.current,
+      updateState: true,
+      mergeWithPreviousValues: false
+    });
+  }, []);
+  const getValues = useCallback12(() => refValues.current, []);
+  return {
+    initialized,
+    stateValues,
+    refValues,
+    valuesSnapshot,
+    setValues,
+    setFieldValue,
+    resetValues,
+    setValuesSnapshot,
+    initialize,
+    getValues
+  };
+}
+
+// ../../node_modules/@mantine/form/esm/hooks/use-form-watch/use-form-watch.mjs
+import { useRef as useRef3, useCallback as useCallback13, useEffect as useEffect14 } from "react";
+function useFormWatch({
+  $status
+}) {
+  const subscribers = useRef3(
+    {}
+  );
+  const watch = useCallback13((path, callback) => {
+    useEffect14(() => {
+      subscribers.current[path] = subscribers.current[path] || [];
+      subscribers.current[path].push(callback);
+      return () => {
+        subscribers.current[path] = subscribers.current[path].filter((cb) => cb !== callback);
+      };
+    }, [callback]);
+  }, []);
+  const getFieldSubscribers = useCallback13((path) => {
+    if (!subscribers.current[path]) {
+      return [];
+    }
+    return subscribers.current[path].map(
+      (callback) => (input) => callback({
+        previousValue: getPath(path, input.previousValues),
+        value: getPath(path, input.updatedValues),
+        touched: $status.isTouched(path),
+        dirty: $status.isDirty(path)
+      })
+    );
+  }, []);
+  return {
+    subscribers,
+    watch,
+    getFieldSubscribers
+  };
+}
+
+// ../../node_modules/@mantine/form/esm/validate/validate-values.mjs
+function getValidationResults(errors) {
+  const filteredErrors = filterErrors(errors);
+  return { hasErrors: Object.keys(filteredErrors).length > 0, errors: filteredErrors };
+}
+function validateRulesRecord(rules, values, path = "", errors = {}) {
+  if (typeof rules !== "object" || rules === null) {
+    return errors;
+  }
+  return Object.keys(rules).reduce((acc, ruleKey) => {
+    const rule = rules[ruleKey];
+    const rulePath = `${path === "" ? "" : `${path}.`}${ruleKey}`;
+    const value = getPath(rulePath, values);
+    let arrayValidation = false;
+    if (typeof rule === "function") {
+      acc[rulePath] = rule(value, values, rulePath);
+    }
+    if (typeof rule === "object" && Array.isArray(value)) {
+      arrayValidation = true;
+      value.forEach(
+        (_item, index) => validateRulesRecord(rule, values, `${rulePath}.${index}`, acc)
+      );
+    }
+    if (typeof rule === "object" && typeof value === "object" && value !== null) {
+      if (!arrayValidation) {
+        validateRulesRecord(rule, values, rulePath, acc);
+      }
+    }
+    return acc;
+  }, errors);
+}
+function validateValues(validate, values) {
+  if (typeof validate === "function") {
+    return getValidationResults(validate(values));
+  }
+  return getValidationResults(validateRulesRecord(validate, values));
+}
+
+// ../../node_modules/@mantine/form/esm/validate/validate-field-value.mjs
+function validateFieldValue(path, rules, values) {
+  if (typeof path !== "string") {
+    return { hasError: false, error: null };
+  }
+  const results = validateValues(rules, values);
+  const pathInError = Object.keys(results.errors).find(
+    (errorKey) => path.split(".").every((pathPart, i) => pathPart === errorKey.split(".")[i])
+  );
+  return { hasError: !!pathInError, error: pathInError ? results.errors[pathInError] : null };
+}
+
+// ../../node_modules/@mantine/form/esm/form-index.mjs
+var FORM_INDEX = "__MANTINE_FORM_INDEX__";
+
+// ../../node_modules/@mantine/form/esm/validate/should-validate-on-change.mjs
+function shouldValidateOnChange(path, validateInputOnChange) {
+  if (!validateInputOnChange) {
+    return false;
+  }
+  if (typeof validateInputOnChange === "boolean") {
+    return validateInputOnChange;
+  }
+  if (Array.isArray(validateInputOnChange)) {
+    return validateInputOnChange.includes(path.replace(/[.][0-9]/g, `.${FORM_INDEX}`));
+  }
+  return false;
+}
+
+// ../../node_modules/@mantine/form/esm/use-form.mjs
+function useForm({
+  name,
+  mode = "controlled",
+  initialValues,
+  initialErrors = {},
+  initialDirty = {},
+  initialTouched = {},
+  clearInputErrorOnChange = true,
+  validateInputOnChange = false,
+  validateInputOnBlur = false,
+  onValuesChange,
+  transformValues = (values) => values,
+  enhanceGetInputProps,
+  validate: rules
+} = {}) {
+  const $errors = useFormErrors(initialErrors);
+  const $values = useFormValues({ initialValues, onValuesChange, mode });
+  const $status = useFormStatus({ initialDirty, initialTouched, $values, mode });
+  const $list = useFormList({ $values, $errors, $status });
+  const $watch = useFormWatch({ $status });
+  const [formKey, setFormKey] = useState12(0);
+  const [fieldKeys, setFieldKeys] = useState12({});
+  const reset = useCallback14(() => {
+    $values.resetValues();
+    $errors.clearErrors();
+    $status.resetDirty();
+    $status.resetTouched();
+    mode === "uncontrolled" && setFormKey((key2) => key2 + 1);
+  }, []);
+  const initialize = useCallback14((values) => {
+    $values.initialize(values, () => mode === "uncontrolled" && setFormKey((key2) => key2 + 1));
+  }, []);
+  const setFieldValue = useCallback14(
+    (path, value, options3) => {
+      const shouldValidate = shouldValidateOnChange(path, validateInputOnChange);
+      $status.clearFieldDirty(path);
+      $status.setFieldTouched(path, true);
+      !shouldValidate && clearInputErrorOnChange && $errors.clearFieldError(path);
+      $values.setFieldValue({
+        path,
+        value,
+        updateState: mode === "controlled",
+        subscribers: [
+          ...$watch.getFieldSubscribers(path),
+          shouldValidate ? (payload) => {
+            const validationResults = validateFieldValue(path, rules, payload.updatedValues);
+            validationResults.hasError ? $errors.setFieldError(path, validationResults.error) : $errors.clearFieldError(path);
+          } : null,
+          options3?.forceUpdate !== false && mode !== "controlled" ? () => setFieldKeys((keys) => ({
+            ...keys,
+            [path]: (keys[path] || 0) + 1
+          })) : null
+        ]
+      });
+    },
+    [onValuesChange, rules]
+  );
+  const setValues = useCallback14(
+    (values) => {
+      const previousValues = $values.refValues.current;
+      $values.setValues({ values, updateState: mode === "controlled" });
+      clearInputErrorOnChange && $errors.clearErrors();
+      mode === "uncontrolled" && setFormKey((key2) => key2 + 1);
+      Object.keys($watch.subscribers.current).forEach((path) => {
+        const value = getPath(path, $values.refValues.current);
+        const previousValue = getPath(path, previousValues);
+        if (value !== previousValue) {
+          $watch.getFieldSubscribers(path).forEach((cb) => cb({ previousValues, updatedValues: $values.refValues.current }));
+        }
+      });
+    },
+    [onValuesChange, clearInputErrorOnChange]
+  );
+  const validate = useCallback14(() => {
+    const results = validateValues(rules, $values.refValues.current);
+    $errors.setErrors(results.errors);
+    return results;
+  }, [rules]);
+  const validateField = useCallback14(
+    (path) => {
+      const results = validateFieldValue(path, rules, $values.refValues.current);
+      results.hasError ? $errors.setFieldError(path, results.error) : $errors.clearFieldError(path);
+      return results;
+    },
+    [rules]
+  );
+  const getInputProps = (path, { type = "input", withError = true, withFocus = true, ...otherOptions } = {}) => {
+    const onChange = getInputOnChange(
+      (value) => setFieldValue(path, value, { forceUpdate: false })
+    );
+    const payload = { onChange };
+    if (withError) {
+      payload.error = $errors.errorsState[path];
+    }
+    if (type === "checkbox") {
+      payload[mode === "controlled" ? "checked" : "defaultChecked"] = getPath(
+        path,
+        $values.refValues.current
+      );
+    } else {
+      payload[mode === "controlled" ? "value" : "defaultValue"] = getPath(
+        path,
+        $values.refValues.current
+      );
+    }
+    if (withFocus) {
+      payload.onFocus = () => $status.setFieldTouched(path, true);
+      payload.onBlur = () => {
+        if (shouldValidateOnChange(path, validateInputOnBlur)) {
+          const validationResults = validateFieldValue(path, rules, $values.refValues.current);
+          validationResults.hasError ? $errors.setFieldError(path, validationResults.error) : $errors.clearFieldError(path);
+        }
+      };
+    }
+    return Object.assign(
+      payload,
+      enhanceGetInputProps?.({
+        inputProps: payload,
+        field: path,
+        options: { type, withError, withFocus, ...otherOptions },
+        form
+      })
+    );
+  };
+  const onSubmit = (handleSubmit, handleValidationFailure) => (event) => {
+    event?.preventDefault();
+    const results = validate();
+    if (results.hasErrors) {
+      handleValidationFailure?.(results.errors, $values.refValues.current, event);
+    } else {
+      handleSubmit?.(transformValues($values.refValues.current), event);
+    }
+  };
+  const getTransformedValues = (input) => transformValues(input || $values.refValues.current);
+  const onReset = useCallback14((event) => {
+    event.preventDefault();
+    reset();
+  }, []);
+  const isValid = useCallback14(
+    (path) => path ? !validateFieldValue(path, rules, $values.refValues.current).hasError : !validateValues(rules, $values.refValues.current).hasErrors,
+    [rules]
+  );
+  const key = (path) => `${formKey}-${path}-${fieldKeys[path] || 0}`;
+  const form = {
+    watch: $watch.watch,
+    initialized: $values.initialized.current,
+    values: $values.stateValues,
+    getValues: $values.getValues,
+    setInitialValues: $values.setValuesSnapshot,
+    initialize,
+    setValues,
+    setFieldValue,
+    errors: $errors.errorsState,
+    setErrors: $errors.setErrors,
+    setFieldError: $errors.setFieldError,
+    clearFieldError: $errors.clearFieldError,
+    clearErrors: $errors.clearErrors,
+    resetDirty: $status.resetDirty,
+    setTouched: $status.setTouched,
+    setDirty: $status.setDirty,
+    isTouched: $status.isTouched,
+    resetTouched: $status.resetTouched,
+    isDirty: $status.isDirty,
+    getTouched: $status.getTouched,
+    getDirty: $status.getDirty,
+    reorderListItem: $list.reorderListItem,
+    insertListItem: $list.insertListItem,
+    removeListItem: $list.removeListItem,
+    reset,
+    validate,
+    validateField,
+    getInputProps,
+    onSubmit,
+    onReset,
+    isValid,
+    getTransformedValues,
+    key
+  };
+  useFormActions(name, form);
+  return form;
+}
+
+// src/nodes/modifiers/noise-curve-node.tsx
+import { useCallback as useCallback15, useEffect as useEffect15, useState as useState13 } from "react";
+import { Curve } from "libnoise-ts/module/modifier";
+import { Tuple } from "libnoise-ts/util";
+import { IconX } from "@tabler/icons-react";
+import { randomId } from "@mantine/hooks";
+import { NodeState } from "@awesome-flow/core/abstract";
+import { Fragment as Fragment3, jsx as jsx23, jsxs as jsxs18 } from "react/jsx-runtime";
+function NoiseCurveNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData9(id);
+  const updateNodeData = useUpdateNodeData8();
+  const updateComputedData = useUpdateNodeComputedData18();
+  const [values, setValues] = useState13([]);
+  const form = useForm({
+    mode: "uncontrolled",
+    initialValues: {
+      points: []
+    },
+    validateInputOnChange: [`points.${FORM_INDEX}.input`],
+    clearInputErrorOnChange: true,
+    validate: {
+      points: {
+        input: (value, values2) => {
+          const counts = {};
+          values2.points.forEach((x) => {
+            counts[x.input] = (counts[x.input] || 0) + 1;
+          });
+          return counts[value] > 1;
+        }
+      }
+    },
+    onValuesChange: useCallback15((values2) => {
+      if (form.isValid()) {
+        const points = values2.points.map((v) => ({ input: v.input, output: v.output }));
+        setValues(points);
+        updateNodeData(id, { points });
+      }
+      form.validate();
+    }, [])
+  });
+  useEffect15(() => {
+    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 });
+  }, []);
+  useEffect15(() => {
+    if (incoming?.length && values?.length >= 4) {
+      const module = new Curve(
+        incoming[0].module,
+        values.map((p) => new Tuple(p.input, p.output))
+      );
+      updateComputedData(id, { module });
+    }
+  }, [values, incoming]);
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ jsxs18(Group9, { mt: "xs", children: [
+    /* @__PURE__ */ jsx23(
+      NumberInput7,
+      {
+        size: "xs",
+        w: 100,
+        placeholder: "Input Value",
+        ...form.getInputProps(`points.${index}.input`),
+        step: 0.1
+      },
+      form.key(`points.${index}.input`)
+    ),
+    /* @__PURE__ */ jsx23(
+      NumberInput7,
+      {
+        size: "xs",
+        w: 100,
+        placeholder: "Output Value",
+        ...form.getInputProps(`points.${index}.output`),
+        step: 0.1
+      },
+      form.key(`points.${index}.output`)
+    ),
+    data.state === NodeState.edit && values.length > 4 && /* @__PURE__ */ jsx23(
+      ActionIcon,
+      {
+        color: "red",
+        variant: "outline",
+        size: "sm",
+        onClick: () => form.removeListItem("points", index),
+        children: /* @__PURE__ */ jsx23(IconX, { size: "1rem" })
+      }
+    )
+  ] }, item.key));
+  return /* @__PURE__ */ jsxs18(NodeContainer20, { id, selected, type, data, children: [
+    fields,
+    data.state === NodeState.edit && /* @__PURE__ */ jsxs18(Fragment3, { children: [
+      /* @__PURE__ */ jsx23(Space, { h: 10 }),
+      /* @__PURE__ */ jsx23(
+        Button,
+        {
+          variant: "outline",
+          size: "xs",
+          fullWidth: true,
+          onClick: () => form.insertListItem("points", { input: 0, output: 0, key: randomId() }),
+          children: "Add control point"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx23(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 useEffect16, useState as useState14 } from "react";
+import { Group as Group10, NumberInput as NumberInput8, Stack as Stack11 } from "@mantine/core";
+import {
+  useIncomingComputedData as useIncomingComputedData10,
+  useUpdateNodeComputedData as useUpdateNodeComputedData19,
+  useUpdateNodeData as useUpdateNodeData9
+} from "@awesome-flow/core/hooks";
+import { Exponent } from "libnoise-ts/module/modifier";
+import { jsx as jsx24, jsxs as jsxs19 } from "react/jsx-runtime";
+function NoiseExponentNode({ id, selected, data, type }) {
+  const [exponent, setExponent] = useState14(data.exponent);
+  const incoming = useIncomingComputedData10(id);
+  const updateNodeData = useUpdateNodeData9();
+  const updateComputedData = useUpdateNodeComputedData19();
+  useEffect16(() => {
+    if (incoming?.length > 0) {
+      const module = new Exponent(incoming[0].module, exponent);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { exponent });
+  }, [incoming, exponent]);
+  return /* @__PURE__ */ jsxs19(NodeContainer21, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx24(Stack11, { children: /* @__PURE__ */ jsxs19(Group10, { children: [
+      "Exponent:",
+      /* @__PURE__ */ jsx24(
+        NumberInput8,
+        {
+          size: "xs",
+          value: exponent,
+          onChange: (e) => setExponent(Number(e)),
+          step: 0.1
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx24(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 useEffect17 } from "react";
+import { useIncomingComputedData as useIncomingComputedData11, useUpdateNodeComputedData as useUpdateNodeComputedData20 } from "@awesome-flow/core/hooks";
+import { Invert } from "libnoise-ts/module/modifier";
+import { jsx as jsx25 } from "react/jsx-runtime";
+function NoiseInvertNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData11(id);
+  const updateComputedData = useUpdateNodeComputedData20();
+  useEffect17(() => {
+    if (incoming?.length > 0) {
+      const module = new Invert(incoming[0].module);
+      updateComputedData(id, { module });
+    }
+  }, [incoming]);
+  return /* @__PURE__ */ jsx25(NodeContainer22, { id, selected, data, type, children: /* @__PURE__ */ jsx25(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 useEffect18, useState as useState15 } from "react";
+import { Group as Group11, NumberInput as NumberInput9, Stack as Stack12 } from "@mantine/core";
+import {
+  useIncomingComputedData as useIncomingComputedData12,
+  useUpdateNodeComputedData as useUpdateNodeComputedData21,
+  useUpdateNodeData as useUpdateNodeData10
+} from "@awesome-flow/core/hooks";
+import { ScaleBias } from "libnoise-ts/module/modifier";
+import { jsx as jsx26, jsxs as jsxs20 } from "react/jsx-runtime";
+function NoiseScaleBiasNode({ id, selected, data, type }) {
+  const [scale, setScale] = useState15(data.scale);
+  const [bias, setBias] = useState15(data.bias);
+  const incoming = useIncomingComputedData12(id);
+  const updateNodeData = useUpdateNodeData10();
+  const updateComputedData = useUpdateNodeComputedData21();
+  useEffect18(() => {
+    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__ */ jsxs20(NodeContainer23, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs20(Stack12, { children: [
+      /* @__PURE__ */ jsxs20(Group11, { children: [
+        "Scale:",
+        /* @__PURE__ */ jsx26(
+          NumberInput9,
+          {
+            size: "xs",
+            w: 100,
+            value: scale,
+            onChange: (e) => setScale(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs20(Group11, { children: [
+        "Bias:",
+        /* @__PURE__ */ jsx26(
+          NumberInput9,
+          {
+            size: "xs",
+            w: 100,
+            value: bias,
+            onChange: (e) => setBias(Number(e)),
+            step: 0.1
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx26(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 { ActionIcon as ActionIcon2, Button as Button2, Group as Group12, NumberInput as NumberInput10, Space as Space2 } from "@mantine/core";
+import {
+  useIncomingComputedData as useIncomingComputedData13,
+  useUpdateNodeComputedData as useUpdateNodeComputedData22,
+  useUpdateNodeData as useUpdateNodeData11
+} from "@awesome-flow/core/hooks";
+import { useCallback as useCallback16, useEffect as useEffect19, useState as useState16 } from "react";
+import { Terrace } from "libnoise-ts/module/modifier";
+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 Fragment4, jsx as jsx27, jsxs as jsxs21 } from "react/jsx-runtime";
+function NoiseTerraceNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData13(id);
+  const updateNodeData = useUpdateNodeData11();
+  const updateComputedData = useUpdateNodeComputedData22();
+  const [values, setValues] = useState16([]);
+  const form = useForm({
+    mode: "uncontrolled",
+    initialValues: {
+      points: []
+    },
+    validateInputOnChange: [`points.${FORM_INDEX}.input`],
+    clearInputErrorOnChange: true,
+    onValuesChange: useCallback16((values2) => {
+      if (form.isValid()) {
+        const points = values2.points.map((v) => v.value);
+        setValues(points);
+        updateNodeData(id, { points });
+      }
+      form.validate();
+    }, [])
+  });
+  useEffect19(() => {
+    const points = data.points?.length ? data.points.map((v) => ({ value: v, key: randomId2() })) : [1, 2].map(() => ({ value: 0, key: randomId2() }));
+    form.initialize({ points });
+  }, []);
+  useEffect19(() => {
+    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__ */ jsxs21(Group12, { mt: "xs", children: [
+    /* @__PURE__ */ jsx27(
+      NumberInput10,
+      {
+        size: "xs",
+        placeholder: "Input Value",
+        ...form.getInputProps(`points.${index}.value`),
+        step: 0.1
+      },
+      form.key(`points.${index}.value`)
+    ),
+    data.state === NodeState2.edit && values.length > 2 && /* @__PURE__ */ jsx27(
+      ActionIcon2,
+      {
+        color: "red",
+        variant: "outline",
+        size: "sm",
+        onClick: () => form.removeListItem("points", index),
+        children: /* @__PURE__ */ jsx27(IconX2, { size: "1rem" })
+      }
+    )
+  ] }, item.key));
+  return /* @__PURE__ */ jsxs21(NodeContainer24, { id, selected, type, data, children: [
+    fields,
+    data.state === NodeState2.edit && /* @__PURE__ */ jsxs21(Fragment4, { children: [
+      /* @__PURE__ */ jsx27(Space2, { h: 10 }),
+      /* @__PURE__ */ jsx27(
+        Button2,
+        {
+          variant: "outline",
+          size: "xs",
+          fullWidth: true,
+          onClick: () => form.insertListItem("points", { value: 0, key: randomId2() }),
+          children: "Add control point"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx27(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 { useEffect as useEffect20 } from "react";
+import { useIncomingComputedData as useIncomingComputedData14, useUpdateNodeComputedData as useUpdateNodeComputedData23 } from "@awesome-flow/core/hooks";
+import { Blend } from "libnoise-ts/module/selector";
+import { Group as Group13 } from "@mantine/core";
+import { jsx as jsx28, jsxs as jsxs22 } from "react/jsx-runtime";
+function NoiseBlendNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData14(id);
+  const updateComputedData = useUpdateNodeComputedData23();
+  useEffect20(() => {
+    if (incoming?.length > 2) {
+      const module = new Blend(incoming[0].module, incoming[1].module, incoming[2].module);
+      updateComputedData(id, { module });
+    }
+  }, [id, incoming, updateComputedData]);
+  return /* @__PURE__ */ jsxs22(NodeContainer25, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs22(Group13, { children: [
+      "Modules: ",
+      incoming?.length
+    ] }),
+    /* @__PURE__ */ jsx28(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 { useEffect as useEffect21, useState as useState17 } from "react";
+import {
+  useIncomingComputedData as useIncomingComputedData15,
+  useUpdateNodeComputedData as useUpdateNodeComputedData24,
+  useUpdateNodeData as useUpdateNodeData12
+} from "@awesome-flow/core/hooks";
+import { Select } from "libnoise-ts/module/selector";
+import { Group as Group14, NumberInput as NumberInput11, Stack as Stack13 } from "@mantine/core";
+import { jsx as jsx29, jsxs as jsxs23 } from "react/jsx-runtime";
+function NoiseSelectNode({ id, selected, data, type }) {
+  const [edgeFalloff, setEdgeFalloff] = useState17(data.edgeFalloff);
+  const [lowerBound, setLowerBound] = useState17(data.lowerBound);
+  const [upperBound, setUpperBound] = useState17(data.upperBound);
+  const incoming = useIncomingComputedData15(id);
+  const updateNodeData = useUpdateNodeData12();
+  const updateComputedData = useUpdateNodeComputedData24();
+  useEffect21(() => {
+    if (incoming?.length > 2) {
+      const module = new Select(
+        incoming[0].module,
+        incoming[1].module,
+        incoming[2].module,
+        edgeFalloff,
+        lowerBound,
+        upperBound
+      );
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { edgeFalloff, lowerBound, upperBound });
+  }, [incoming, edgeFalloff, lowerBound, upperBound, updateNodeData, id, updateComputedData]);
+  return /* @__PURE__ */ jsxs23(NodeContainer26, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs23(Stack13, { children: [
+      /* @__PURE__ */ jsxs23(Group14, { children: [
+        "Edge Falloff:",
+        /* @__PURE__ */ jsx29(
+          NumberInput11,
+          {
+            size: "xs",
+            w: 100,
+            value: edgeFalloff,
+            onChange: (e) => setEdgeFalloff(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs23(Group14, { children: [
+        "Lower Bound:",
+        /* @__PURE__ */ jsx29(
+          NumberInput11,
+          {
+            size: "xs",
+            w: 100,
+            value: lowerBound,
+            onChange: (e) => setLowerBound(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs23(Group14, { children: [
+        "Upper Bound:",
+        /* @__PURE__ */ jsx29(
+          NumberInput11,
+          {
+            size: "xs",
+            w: 100,
+            value: upperBound,
+            onChange: (e) => setUpperBound(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs23(Group14, { children: [
+        "Modules: ",
+        incoming?.length
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx29(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 { useEffect as useEffect22, useMemo as useMemo13 } from "react";
+import { useIncomingHandleData, useUpdateNodeComputedData as useUpdateNodeComputedData25 } from "@awesome-flow/core/hooks";
+import { Displace } from "libnoise-ts/module/transformer";
+import { Badge, Stack as Stack14 } from "@mantine/core";
+import { jsx as jsx30, jsxs as jsxs24 } from "react/jsx-runtime";
+function NoiseDisplaceNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData25();
+  const incomingHandleData = useIncomingHandleData(id, data.handles);
+  const { sourceModule, xModule, yModule, zModule } = useMemo13(() => {
+    return {
+      sourceModule: incomingHandleData["source" /* sourceModule */],
+      xModule: incomingHandleData["x-module" /* xModule */],
+      yModule: incomingHandleData["y-module" /* yModule */],
+      zModule: incomingHandleData["z-module" /* zModule */]
+    };
+  }, [incomingHandleData]);
+  useEffect22(() => {
+    if (sourceModule && xModule && yModule && zModule) {
+      const module = new Displace(
+        sourceModule[0].module,
+        xModule[0].module,
+        yModule[0].module,
+        zModule[0].module
+      );
+      updateComputedData(id, { module });
+    }
+  }, [id, updateComputedData, sourceModule, xModule, yModule, zModule]);
+  const { sourceColor, xColor, yColor, zColor } = useMemo13(() => {
+    return {
+      sourceColor: sourceModule ? "green" : "orange",
+      xColor: xModule ? "green" : "orange",
+      yColor: yModule ? "green" : "orange",
+      zColor: zModule ? "green" : "orange"
+    };
+  }, [sourceModule, xModule, yModule, zModule]);
+  return /* @__PURE__ */ jsxs24(NodeContainer27, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs24(Stack14, { align: "center", children: [
+      /* @__PURE__ */ jsx30(Badge, { color: sourceColor, children: "Source Module" }),
+      /* @__PURE__ */ jsx30(Badge, { color: xColor, children: "X Module" }),
+      /* @__PURE__ */ jsx30(Badge, { color: yColor, children: "Y Module" }),
+      /* @__PURE__ */ jsx30(Badge, { color: zColor, children: "Z Module" })
+    ] }),
+    /* @__PURE__ */ jsx30(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 useEffect23, useState as useState18 } from "react";
+import {
+  useIncomingComputedData as useIncomingComputedData16,
+  useUpdateNodeComputedData as useUpdateNodeComputedData26,
+  useUpdateNodeData as useUpdateNodeData13
+} from "@awesome-flow/core/hooks";
+import { Group as Group15, NumberInput as NumberInput12, Stack as Stack15 } from "@mantine/core";
+import { RotatePoint } from "libnoise-ts/module/transformer";
+import { jsx as jsx31, jsxs as jsxs25 } from "react/jsx-runtime";
+function NoiseRotatePointNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [xAngle, setXAngle] = useState18(data.xAngle);
+  const [yAngle, setYAngle] = useState18(data.yAngle);
+  const [zAngle, setZAngle] = useState18(data.zAngle);
+  const incoming = useIncomingComputedData16(id);
+  const updateNodeData = useUpdateNodeData13();
+  const updateComputedData = useUpdateNodeComputedData26();
+  useEffect23(() => {
+    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__ */ jsxs25(NodeContainer28, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs25(Stack15, { children: [
+      /* @__PURE__ */ jsxs25(Group15, { children: [
+        "X Angle:",
+        /* @__PURE__ */ jsx31(
+          NumberInput12,
+          {
+            size: "xs",
+            w: 100,
+            value: xAngle,
+            onChange: (e) => setXAngle(Number(e)),
+            step: 0.01
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs25(Group15, { children: [
+        "Y Angle:",
+        /* @__PURE__ */ jsx31(
+          NumberInput12,
+          {
+            size: "xs",
+            w: 100,
+            value: yAngle,
+            onChange: (e) => setYAngle(Number(e)),
+            step: 0.01
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs25(Group15, { children: [
+        "Z Angle:",
+        /* @__PURE__ */ jsx31(
+          NumberInput12,
+          {
+            size: "xs",
+            w: 100,
+            value: zAngle,
+            onChange: (e) => setZAngle(Number(e)),
+            step: 0.01
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx31(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 useEffect24, useState as useState19 } from "react";
+import {
+  useIncomingComputedData as useIncomingComputedData17,
+  useUpdateNodeComputedData as useUpdateNodeComputedData27,
+  useUpdateNodeData as useUpdateNodeData14
+} from "@awesome-flow/core/hooks";
+import { Group as Group16, NumberInput as NumberInput13, Stack as Stack16 } from "@mantine/core";
+import { ScalePoint } from "libnoise-ts/module/transformer";
+import { jsx as jsx32, jsxs as jsxs26 } from "react/jsx-runtime";
+function NoiseScalePointNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [xScale, setXScale] = useState19(data.xScale);
+  const [yScale, setYScale] = useState19(data.yScale);
+  const [zScale, setZScale] = useState19(data.zScale);
+  const incoming = useIncomingComputedData17(id);
+  const updateNodeData = useUpdateNodeData14();
+  const updateComputedData = useUpdateNodeComputedData27();
+  useEffect24(() => {
+    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__ */ jsxs26(NodeContainer29, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs26(Stack16, { children: [
+      /* @__PURE__ */ jsxs26(Group16, { children: [
+        "X Scale:",
+        /* @__PURE__ */ jsx32(
+          NumberInput13,
+          {
+            size: "xs",
+            w: 100,
+            value: xScale,
+            onChange: (e) => setXScale(Number(e)),
+            step: 0.01
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs26(Group16, { children: [
+        "Y Scale:",
+        /* @__PURE__ */ jsx32(
+          NumberInput13,
+          {
+            size: "xs",
+            w: 100,
+            value: yScale,
+            onChange: (e) => setYScale(Number(e)),
+            step: 0.01
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs26(Group16, { children: [
+        "Z Scale:",
+        /* @__PURE__ */ jsx32(
+          NumberInput13,
+          {
+            size: "xs",
+            w: 100,
+            value: zScale,
+            onChange: (e) => setZScale(Number(e)),
+            step: 0.01
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx32(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 useEffect25, useState as useState20 } from "react";
+import {
+  useIncomingComputedData as useIncomingComputedData18,
+  useUpdateNodeComputedData as useUpdateNodeComputedData28,
+  useUpdateNodeData as useUpdateNodeData15
+} from "@awesome-flow/core/hooks";
+import { Group as Group17, NumberInput as NumberInput14, Stack as Stack17 } from "@mantine/core";
+import { TranslatePoint } from "libnoise-ts/module/transformer";
+import { jsx as jsx33, jsxs as jsxs27 } from "react/jsx-runtime";
+function NoiseTranslatePointNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [translateX, setTranslateX] = useState20(data.translateX);
+  const [translateY, setTranslateY] = useState20(data.translateY);
+  const [translateZ, setTranslateZ] = useState20(data.translateZ);
+  const incoming = useIncomingComputedData18(id);
+  const updateNodeData = useUpdateNodeData15();
+  const updateComputedData = useUpdateNodeComputedData28();
+  useEffect25(() => {
+    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__ */ jsxs27(NodeContainer30, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs27(Stack17, { children: [
+      /* @__PURE__ */ jsxs27(Group17, { children: [
+        "Translate X:",
+        /* @__PURE__ */ jsx33(
+          NumberInput14,
+          {
+            size: "xs",
+            w: 100,
+            value: translateX,
+            onChange: (e) => setTranslateX(Number(e)),
+            step: 1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs27(Group17, { children: [
+        "Translate Y:",
+        /* @__PURE__ */ jsx33(
+          NumberInput14,
+          {
+            size: "xs",
+            w: 100,
+            value: translateY,
+            onChange: (e) => setTranslateY(Number(e)),
+            step: 1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs27(Group17, { children: [
+        "Translate Z:",
+        /* @__PURE__ */ jsx33(
+          NumberInput14,
+          {
+            size: "xs",
+            w: 100,
+            value: translateZ,
+            onChange: (e) => setTranslateZ(Number(e)),
+            step: 1
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx33(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 useCallback17, useEffect as useEffect26, useState as useState21 } from "react";
+import { useIncomingComputedData as useIncomingComputedData19, useUpdateNodeComputedData as useUpdateNodeComputedData29 } from "@awesome-flow/core/hooks";
+import { Turbulence } from "libnoise-ts/module/transformer";
+import { jsx as jsx34, jsxs as jsxs28 } from "react/jsx-runtime";
+function NoiseTurbulenceNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [properties, setProperties] = useState21(null);
+  const incoming = useIncomingComputedData19(id);
+  const updateComputedData = useUpdateNodeComputedData29();
+  const onPropertiesChange = useCallback17((props) => {
+    setProperties(props);
+  }, []);
+  useEffect26(() => {
+    if (incoming?.length) {
+      const module = new Turbulence(
+        incoming[0].module,
+        properties.frequency.value,
+        properties.power.value,
+        properties.roughness.value,
+        properties.seed.value
+      );
+      updateComputedData(id, { module });
+    }
+  }, [id, incoming, properties, updateComputedData]);
+  return /* @__PURE__ */ jsxs28(NodeContainer31, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx34(node_property_variables_default, { data, nodeId: id, onPropertiesChange }),
+    /* @__PURE__ */ jsx34(NodeTrackConnections26, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_turbulence_node_default = NoiseTurbulenceNode;
+
+// src/nodes/generators/variable-property-node.tsx
+import { NodeCombobox as NodeCombobox2, NodeContainer as NodeContainer32, NodeTrackConnections as NodeTrackConnections27 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback18, useEffect as useEffect27, useState as useState22 } from "react";
+import { Stack as Stack18 } from "@mantine/core";
+import { useIncomingNodeData as useIncomingNodeData2, useOutgoingNodes, useUpdateNodeData as useUpdateNodeData16 } from "@awesome-flow/core/hooks";
+import { getObjectPropertyMap } from "@awesome-flow/core/utils";
+import { nodeDataPropertyExcept as nodeDataPropertyExcept3 } from "@awesome-flow/core/abstract";
+import { jsx as jsx35, jsxs as jsxs29 } from "react/jsx-runtime";
+function VariablePropertyNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [options3, setOptions] = useState22({});
+  const [selectedProperty, setSelectedProperty] = useState22(data.property);
+  const updateNodeData = useUpdateNodeData16();
+  const outgoing = useOutgoingNodes(id);
+  const incoming = useIncomingNodeData2(id);
+  useEffect27(() => {
+    if (outgoing?.length) {
+      const { data: data2 } = outgoing[0];
+      const properties = getObjectPropertyMap(data2, nodeDataPropertyExcept3);
+      setOptions(properties);
+      if (!selectedProperty) {
+        const keys = Object.keys(properties);
+        if (keys.length) {
+          setSelectedProperty({
+            name: keys[0],
+            value: properties[keys[0]]
+          });
+        }
+      }
+    } else {
+      setSelectedProperty(null);
+    }
+  }, [outgoing]);
+  useEffect27(() => {
+    if (!incoming?.length && selectedProperty?.disabled) {
+      setSelectedProperty({ ...selectedProperty, disabled: false });
+    } else if (incoming?.length && selectedProperty) {
+      const incomingValue = incoming[0].value;
+      if (incomingValue !== void 0 && incomingValue !== null) {
+        setSelectedProperty({
+          name: selectedProperty.name,
+          value: incomingValue,
+          disabled: true
+        });
+      }
+    }
+  }, [incoming]);
+  useEffect27(() => {
+    if (selectedProperty) {
+      updateNodeData(id, { property: selectedProperty });
+    }
+  }, [selectedProperty]);
+  const onPropertyChange = useCallback18(
+    (selected2) => {
+      setSelectedProperty({
+        name: selected2,
+        value: options3[selected2]
+      });
+    },
+    [options3]
+  );
+  const onValueChange = useCallback18((name, value) => {
+    setSelectedProperty({
+      name,
+      value
+    });
+  }, []);
+  return /* @__PURE__ */ jsxs29(NodeContainer32, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs29(Stack18, { align: "center", children: [
+      /* @__PURE__ */ jsx35(
+        NodeCombobox2,
+        {
+          options: options3,
+          onChange: onPropertyChange,
+          selected: selectedProperty?.name,
+          hideListValues: true
+        }
+      ),
+      /* @__PURE__ */ jsx35(node_property_input_default, { property: selectedProperty, onChange: onValueChange })
+    ] }),
+    /* @__PURE__ */ jsx35(NodeTrackConnections27, { handles: data.handles, nodeId: id })
+  ] });
+}
+var variable_property_node_default = VariablePropertyNode;
+
+// src/nodes/modifiers/variable-combine-node.tsx
+import { NodeCombobox as NodeCombobox3, NodeContainer as NodeContainer33, NodeTrackConnections as NodeTrackConnections28 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback19, useEffect as useEffect28, useState as useState23 } from "react";
+import { useIncomingNodeData as useIncomingNodeData3, useUpdateNodeData as useUpdateNodeData17 } from "@awesome-flow/core/hooks";
+import {
+  IconAsterisk as IconAsterisk2,
+  IconChevronLeft as IconChevronLeft2,
+  IconChevronRight as IconChevronRight2,
+  IconChevronUp as IconChevronUp2,
+  IconDivide,
+  IconPlus as IconPlus2
+} from "@tabler/icons-react";
+import { jsx as jsx36, jsxs as jsxs30 } from "react/jsx-runtime";
+var options2 = {
+  add: /* @__PURE__ */ jsx36(IconPlus2, {}),
+  divide: /* @__PURE__ */ jsx36(IconDivide, {}),
+  min: /* @__PURE__ */ jsx36(IconChevronLeft2, {}),
+  max: /* @__PURE__ */ jsx36(IconChevronRight2, {}),
+  multiply: /* @__PURE__ */ jsx36(IconAsterisk2, {}),
+  power: /* @__PURE__ */ jsx36(IconChevronUp2, {})
+};
+function VariableCombineNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [operation, setOperation] = useState23(data.operation);
+  const [value, setValue] = useState23(data.value);
+  const updateNodeData = useUpdateNodeData17();
+  const incoming = useIncomingNodeData3(id);
+  useEffect28(() => {
+    if (incoming?.length > 1) {
+      const result = getOperationResult(operation, incoming[0].value, incoming[1].value);
+      setValue(result);
+      updateNodeData(id, { value: result });
+    }
+  }, [operation, incoming]);
+  const onChange = useCallback19((op) => {
+    updateNodeData(id, { operation: op });
+    setOperation(op);
+  }, []);
+  return /* @__PURE__ */ jsxs30(NodeContainer33, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx36(NodeCombobox3, { options: options2, selected: operation, onChange }),
+    /* @__PURE__ */ jsx36(node_value_input_default, { value, onChange: () => {
+    }, disabled: true }),
+    /* @__PURE__ */ jsx36(NodeTrackConnections28, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+function getOperationResult(operation, value1, value2) {
+  switch (operation) {
+    case "add" /* add */:
+      return Number(value1) + Number(value2);
+    case "divide" /* divide */:
+      return Number(value1) / (Number(value2) || 1);
+    case "max" /* max */:
+      return Number(value1) > Number(value2) ? value1 : value2;
+    case "min" /* min */:
+      return Number(value1) < Number(value2) ? value1 : value2;
+    case "multiply" /* multiply */:
+      return Number(value1) * Number(value2);
+    case "power" /* power */:
+      return Number(value1) ** Number(value2);
+  }
+}
+var variable_combine_node_default = VariableCombineNode;
+
+// src/nodes/generators/variable-value-node.tsx
+import { NodeContainer as NodeContainer34, NodeTrackConnections as NodeTrackConnections29 } from "@awesome-flow/core/layout";
+import { useCallback as useCallback20, useState as useState24 } from "react";
+import { useUpdateNodeData as useUpdateNodeData18 } from "@awesome-flow/core/hooks";
+import { jsx as jsx37, jsxs as jsxs31 } from "react/jsx-runtime";
+function VariableValueNode({ id, selected, data, type }) {
+  const [value, setValue] = useState24(data.value || 0);
+  const updateNodeData = useUpdateNodeData18();
+  const onValueChange = useCallback20((newValue) => {
+    updateNodeData(id, { value: newValue });
+    setValue(newValue);
+  }, []);
+  return /* @__PURE__ */ jsxs31(NodeContainer34, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx37(node_value_input_default, { value, onChange: onValueChange }),
+    /* @__PURE__ */ jsx37(NodeTrackConnections29, { handles: data.handles, nodeId: id, type: "source" })
+  ] });
+}
+var variable_value_node_default = VariableValueNode;
+
+// src/nodes/groups/node-module-group.tsx
+import { NodeContainer as NodeContainer35, NodeCollapse } from "@awesome-flow/core/layout";
+import { NodeResizer, useStore, useUpdateNodeInternals } from "@xyflow/react";
+import { FlowContext } from "@awesome-flow/core/abstract";
+import { useCallback as useCallback21, useContext, useEffect as useEffect29, useMemo as useMemo14 } from "react";
+import { shallow } from "zustand/shallow";
+import { Badge as Badge2, Group as Group18 } from "@mantine/core";
+import { jsx as jsx38, jsxs as jsxs32 } from "react/jsx-runtime";
+function ModuleGroupNode({
+  id,
+  selected,
+  data,
+  type,
+  width,
+  height
+}) {
+  const context = useContext(FlowContext);
+  const updateNodeInternals = useUpdateNodeInternals();
+  const triggerNodeChanges = useStore((s) => s.triggerNodeChanges);
+  const { groupNodes, setGroupCollapsed } = context.useFlowStore(
+    useCallback21(
+      (state) => ({ groupNodes: state.groups[id], setGroupCollapsed: state.setGroupCollapsed }),
+      []
+    )
+  );
+  const intersectingNode = context.useInteractivityStore(
+    useCallback21((state) => state.nodeIntersectionTargets[id], [id]),
+    shallow
+  );
+  useEffect29(() => {
+    updateNodeInternals(id);
+  }, [width, height]);
+  useEffect29(() => {
+    triggerNodeChanges([
+      {
+        id,
+        type: "select",
+        selected: !!intersectingNode
+      }
+    ]);
+  }, [intersectingNode]);
+  const onCollapsed = useCallback21((collapsed) => {
+    setGroupCollapsed(id, collapsed);
+  }, []);
+  const size = useMemo14(() => {
+    return {
+      width: data.initialSize?.width || 100,
+      height: data.initialSize?.height || 50
+    };
+  }, [data.initialSize]);
+  return /* @__PURE__ */ jsx38(
+    NodeContainer35,
+    {
+      id,
+      selected,
+      data,
+      title: /* @__PURE__ */ jsx38(Group18, { justify: "space-between", children: /* @__PURE__ */ jsxs32(Group18, { gap: "xs", children: [
+        /* @__PURE__ */ jsx38(Badge2, { size: "xs", variant: "outline", radius: "xs", color: "gray", children: groupNodes?.length || 0 }),
+        /* @__PURE__ */ jsx38(NodeCollapse, { nodeId: id, isCollapsed: data.isCollapsed, onCollapsed })
+      ] }) }),
+      type,
+      children: /* @__PURE__ */ jsx38(
+        NodeResizer,
+        {
+          nodeId: id,
+          minWidth: size.width,
+          minHeight: size.height,
+          isVisible: selected && !data.isCollapsed
+        }
+      )
+    }
+  );
+}
+var node_module_group_default = ModuleGroupNode;
+
+// src/templates/generators/noise-checkerboard-template.ts
+import { IDGenerator } from "@awesome-flow/core/utils";
+import { Position } from "@xyflow/system";
+var NoiseCheckerboardNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator.template(),
+      type: "noise-checkerboard" /* noiseCheckerboard */,
+      removable: false,
+      data: {
+        title: "Checkerboard Noise"
+      },
+      handles: [
+        {
+          position: Position.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-const-template.ts
+import { IDGenerator as IDGenerator2 } from "@awesome-flow/core/utils";
+import { Position as Position2 } from "@xyflow/system";
+var NoiseConstNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator2.template(),
+      type: "noise-constant" /* noiseConst */,
+      removable: false,
+      data: {
+        title: "Const Value Noise",
+        noise: 0,
+        min: -1,
+        max: 1
+      },
+      handles: [
+        {
+          position: Position2.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-cylinders-template.ts
+import { IDGenerator as IDGenerator3 } from "@awesome-flow/core/utils";
+import { Position as Position3 } from "@xyflow/system";
+var NoiseCylindersNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator3.template(),
+      type: "noise-cylinders" /* noiseCylinders */,
+      removable: false,
+      data: {
+        title: "Cylinders Noise",
+        frequency: 0.1
+      },
+      handles: [
+        {
+          position: Position3.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: Position3.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-perlin-template.ts
+import { IDGenerator as IDGenerator4 } from "@awesome-flow/core/utils";
+import { Position as Position4 } from "@xyflow/system";
+var NoisePerlinNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator4.template(),
+      type: "noise-perlin" /* noisePerlin */,
+      removable: false,
+      data: {
+        title: "Perlin Noise",
+        frequency: 0.1,
+        lacunarity: 2,
+        octaves: 5,
+        persistence: 0.5,
+        seed: 0
+      },
+      handles: [
+        {
+          position: Position4.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: Position4.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-ridgedmulti-template.ts
+import { IDGenerator as IDGenerator5 } from "@awesome-flow/core/utils";
+import { Position as Position5 } from "@xyflow/system";
+var NoiseRidgedMultiNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator5.template(),
+      type: "noise-ridged-multi" /* noiseRidgedMulti */,
+      removable: false,
+      data: {
+        title: "Ridged Multi Noise",
+        frequency: 0.1,
+        lacunarity: 2,
+        octaves: 6,
+        offset: 1,
+        gain: 2,
+        seed: 0
+      },
+      handles: [
+        {
+          position: Position5.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: Position5.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-simplex-template.ts
+import { IDGenerator as IDGenerator6 } from "@awesome-flow/core/utils";
+import { Position as Position6 } from "@xyflow/system";
+var NoiseSimplexNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator6.template(),
+      type: "noise-simplex" /* noiseSimplex */,
+      removable: false,
+      data: {
+        title: "Simplex Noise"
+      },
+      handles: [
+        {
+          position: Position6.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: Position6.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-spheres-template.ts
+import { IDGenerator as IDGenerator7 } from "@awesome-flow/core/utils";
+import { Position as Position7 } from "@xyflow/system";
+var NoiseSpheresNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator7.template(),
+      type: "noise-spheres" /* noiseSpheres */,
+      removable: false,
+      data: {
+        title: "Spheres Noise",
+        frequency: 0.1
+      },
+      handles: [
+        {
+          position: Position7.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: Position7.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-voronoi-template.ts
+import { IDGenerator as IDGenerator8 } from "@awesome-flow/core/utils";
+import { Position as Position8 } from "@xyflow/system";
+var NoiseVoronoiNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator8.template(),
+      type: "noise-voronoi" /* noiseVoronoi */,
+      removable: false,
+      data: {
+        title: "Voronoi Noise",
+        frequency: 0.1,
+        displacement: 1,
+        distance: true,
+        seed: 0
+      },
+      handles: [
+        {
+          position: Position8.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: Position8.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/position-const-template.ts
+import { IDGenerator as IDGenerator9 } from "@awesome-flow/core/utils";
+import { Position as Position9 } from "@xyflow/system";
+var PositionConstNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator9.template(),
+      type: "position" /* position */,
+      removable: false,
+      data: {
+        title: "Position Output",
+        position: { x: 0, y: 0, z: 0 }
+      },
+      handles: [
+        {
+          position: Position9.Right,
+          dataType: 4 /* position */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType(type) {
+    return 4 /* position */;
+  }
+};
+
+// src/templates/generators/position-grid-template.ts
+import { IDGenerator as IDGenerator10 } from "@awesome-flow/core/utils";
+import { Position as Position10 } from "@xyflow/system";
+var PositionGridNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator10.template(),
+      type: "grid" /* grid */,
+      removable: false,
+      data: {
+        title: "Grid Output",
+        center: { x: 0, y: 0, z: 0 },
+        radius: 1
+      },
+      handles: [
+        {
+          position: Position10.Right,
+          dataType: 4 /* position */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType(type) {
+    return 4 /* position */;
+  }
+};
+
+// src/templates/modifiers/noise-normalize-template.ts
+import { IDGenerator as IDGenerator11 } from "@awesome-flow/core/utils";
+import { Position as Position11 } from "@xyflow/system";
+var NoiseNormalizeNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator11.template(),
+      type: "noise-normalize" /* noiseNormalize */,
+      data: {
+        title: "Normalize Noise",
+        intervalStart: -1,
+        intervalEnd: 1
+      },
+      handles: [
+        {
+          position: Position11.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position11.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/output/noise-logger-template.ts
+import { IDGenerator as IDGenerator12 } from "@awesome-flow/core/utils";
+import { Position as Position12 } from "@xyflow/system";
+var NoiseLoggerNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator12.template(),
+      type: "noise-logger" /* noiseLogger */,
+      removable: false,
+      data: {
+        title: "Noise Logger"
+      },
+      handles: [
+        {
+          position: Position12.Left,
+          dataType: 2 /* noise */,
+          connection: "target"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "target";
+  }
+  getHandleAllowedDataType(type) {
+    return 2 /* noise */;
+  }
+};
+
+// src/templates/output/noise-raw-texture-template.ts
+import { IDGenerator as IDGenerator13 } from "@awesome-flow/core/utils";
+import { Position as Position13 } from "@xyflow/system";
+var NoiseRawTextureTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator13.template(),
+      type: "texture-data" /* textureData */,
+      removable: false,
+      data: {
+        title: "Texture Data"
+      },
+      handles: [
+        {
+          position: Position13.Left,
+          dataType: 2 /* noise */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position13.Right,
+          dataType: 1 /* texture */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    switch (type) {
+      case "source":
+        return 1 /* texture */;
+      case "target":
+        return 2 /* noise */;
+    }
+  }
+};
+
+// src/templates/output/position-logger-template.ts
+import { IDGenerator as IDGenerator14 } from "@awesome-flow/core/utils";
+import { Position as Position14 } from "@xyflow/system";
+var PositionLoggerNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator14.template(),
+      type: "position-logger" /* positionLogger */,
+      removable: false,
+      data: {
+        title: "Position Logger"
+      },
+      handles: [
+        {
+          position: Position14.Left,
+          dataType: 4 /* position */,
+          connection: "target"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "target";
+  }
+  getHandleAllowedDataType(type) {
+    return 4 /* position */;
+  }
+};
+
+// src/templates/modifiers/noise-combine-template.ts
+import { IDGenerator as IDGenerator15 } from "@awesome-flow/core/utils";
+import { Position as Position15 } from "@xyflow/system";
+var NoiseCombineNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator15.template(),
+      type: "noise-combiner" /* noiseCombine */,
+      removable: false,
+      data: {
+        title: "Combine Noise",
+        operation: "add" /* add */
+      },
+      handles: [
+        {
+          position: Position15.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 2
+        },
+        {
+          position: Position15.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-clamp-template.ts
+import { IDGenerator as IDGenerator16 } from "@awesome-flow/core/utils";
+import { Position as Position16 } from "@xyflow/system";
+var NoiseClampNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator16.template(),
+      type: "noise-clamp" /* noiseClamp */,
+      removable: false,
+      data: {
+        title: "Clamp Noise",
+        lowerBound: -1,
+        upperBound: 1
+      },
+      handles: [
+        {
+          position: Position16.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position16.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-abs-template.ts
+import { IDGenerator as IDGenerator17 } from "@awesome-flow/core/utils";
+import { Position as Position17 } from "@xyflow/system";
+var NoiseAbsNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator17.template(),
+      type: "noise-abs" /* noiseAbs */,
+      removable: false,
+      data: {
+        title: "Abs Noise"
+      },
+      handles: [
+        {
+          position: Position17.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position17.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/output/noise-output-template.ts
+import { IDGenerator as IDGenerator18 } from "@awesome-flow/core/utils";
+import { Position as Position18 } from "@xyflow/system";
+var NoiseOutputNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator18.template(),
+      type: "noise-output" /* noiseOutput */,
+      removable: false,
+      data: {
+        title: "Noise Output"
+      },
+      handles: [
+        {
+          position: Position18.Left,
+          dataType: 4 /* position */,
+          connection: "target"
+        },
+        {
+          position: Position18.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position18.Right,
+          dataType: 2 /* noise */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    switch (type) {
+      case "source":
+        return 2 /* noise */;
+      case "target":
+        return 8 /* module */ & 4 /* position */;
+    }
+  }
+};
+
+// src/templates/modifiers/noise-curve-template.ts
+import { IDGenerator as IDGenerator19 } from "@awesome-flow/core/utils";
+import { Position as Position19 } from "@xyflow/system";
+var NoiseCurveNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator19.template(),
+      type: "noise-curve" /* noiseCurve */,
+      removable: false,
+      data: {
+        title: "Noise Curve",
+        points: []
+      },
+      handles: [
+        {
+          position: Position19.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position19.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-exponent-template.ts
+import { IDGenerator as IDGenerator20 } from "@awesome-flow/core/utils";
+import { Position as Position20 } from "@xyflow/system";
+var NoiseExponentNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator20.template(),
+      type: "noise-exponent" /* noiseExponent */,
+      removable: false,
+      data: {
+        title: "Noise Exponent",
+        exponent: 1
+      },
+      handles: [
+        {
+          position: Position20.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position20.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-invert-template.ts
+import { IDGenerator as IDGenerator21 } from "@awesome-flow/core/utils";
+import { Position as Position21 } from "@xyflow/system";
+var NoiseInvertNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator21.template(),
+      type: "noise-invert" /* noiseInvert */,
+      removable: false,
+      data: {
+        title: "Invert Noise"
+      },
+      handles: [
+        {
+          position: Position21.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position21.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-scalebias-template.ts
+import { IDGenerator as IDGenerator22 } from "@awesome-flow/core/utils";
+import { Position as Position22 } from "@xyflow/system";
+var NoiseScaleBiasNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator22.template(),
+      type: "noise-scale-bias" /* noiseScaleBias */,
+      removable: false,
+      data: {
+        title: "Scale/Bias Noise",
+        scale: 1,
+        bias: 0
+      },
+      handles: [
+        {
+          position: Position22.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position22.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/modifiers/noise-terrace-template.ts
+import { IDGenerator as IDGenerator23 } from "@awesome-flow/core/utils";
+import { Position as Position23 } from "@xyflow/system";
+var NoiseTerraceNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator23.template(),
+      type: "noise-terrace" /* noiseTerrace */,
+      removable: false,
+      data: {
+        title: "Noise Terrace",
+        points: []
+      },
+      handles: [
+        {
+          position: Position23.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position23.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/selectors/noise-blend-template.ts
+import { IDGenerator as IDGenerator24 } from "@awesome-flow/core/utils";
+import { Position as Position24 } from "@xyflow/system";
+var NoiseBlendNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator24.template(),
+      type: "noise-blend" /* noiseBlend */,
+      removable: false,
+      data: {
+        title: "Noise Blend"
+      },
+      handles: [
+        {
+          position: Position24.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Modules",
+          maxConnections: 2
+        },
+        {
+          position: Position24.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Control Module",
+          maxConnections: 1
+        },
+        {
+          position: Position24.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/selectors/noise-select-template.ts
+import { IDGenerator as IDGenerator25 } from "@awesome-flow/core/utils";
+import { Position as Position25 } from "@xyflow/system";
+var NoiseSelectNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator25.template(),
+      type: "noise-select" /* noiseSelect */,
+      removable: false,
+      data: {
+        title: "Noise Select",
+        edgeFalloff: 0,
+        lowerBound: -1,
+        upperBound: 1
+      },
+      handles: [
+        {
+          position: Position25.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Modules",
+          maxConnections: 2
+        },
+        {
+          position: Position25.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Control Module",
+          maxConnections: 1
+        },
+        {
+          position: Position25.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-displace-template.ts
+import { IDGenerator as IDGenerator26 } from "@awesome-flow/core/utils";
+import { Position as Position26 } from "@xyflow/system";
+var NoiseDisplaceNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator26.template(),
+      type: "noise-displace" /* noiseDisplace */,
+      data: {
+        title: "Noise Displace"
+      },
+      handles: [
+        {
+          position: Position26.Left,
+          connection: "target",
+          label: "Source Module",
+          dataType: 8 /* module */,
+          dataId: "source" /* sourceModule */,
+          maxConnections: 1
+        },
+        {
+          position: Position26.Left,
+          connection: "target",
+          label: "X Module",
+          dataType: 8 /* module */,
+          dataId: "x-module" /* xModule */,
+          maxConnections: 1
+        },
+        {
+          position: Position26.Left,
+          connection: "target",
+          label: "Y Module",
+          dataType: 8 /* module */,
+          dataId: "y-module" /* yModule */,
+          maxConnections: 1
+        },
+        {
+          position: Position26.Left,
+          connection: "target",
+          label: "Z Module",
+          dataType: 8 /* module */,
+          dataId: "z-module" /* zModule */,
+          maxConnections: 1
+        },
+        {
+          position: Position26.Right,
+          dataType: 8 /* module */,
+          dataId: "output" /* output */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-rotate-point-template.ts
+import { IDGenerator as IDGenerator27 } from "@awesome-flow/core/utils";
+import { Position as Position27 } from "@xyflow/system";
+var NoiseRotatePointNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator27.template(),
+      type: "noise-rotate-point" /* noiseRotatePoint */,
+      removable: false,
+      data: {
+        title: "Noise Rotate Point",
+        xAngle: 0,
+        yAngle: 0,
+        zAngle: 0
+      },
+      handles: [
+        {
+          position: Position27.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Module",
+          maxConnections: 1
+        },
+        {
+          position: Position27.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-scale-point-template.ts
+import { IDGenerator as IDGenerator28 } from "@awesome-flow/core/utils";
+import { Position as Position28 } from "@xyflow/system";
+var NoiseScalePointNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator28.template(),
+      type: "noise-scale-point" /* noiseScalePoint */,
+      data: {
+        title: "Noise Scale Point",
+        xScale: 1,
+        yScale: 1,
+        zScale: 1
+      },
+      handles: [
+        {
+          position: Position28.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Module",
+          maxConnections: 1
+        },
+        {
+          position: Position28.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-translate-point-template.ts
+import { IDGenerator as IDGenerator29 } from "@awesome-flow/core/utils";
+import { Position as Position29 } from "@xyflow/system";
+var NoiseTranslatePointNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator29.template(),
+      type: "noise-translate-point" /* noiseTranslatePoint */,
+      data: {
+        title: "Noise Translate Point",
+        translateX: 0,
+        translateY: 0,
+        translateZ: 0
+      },
+      handles: [
+        {
+          position: Position29.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Module",
+          maxConnections: 1
+        },
+        {
+          position: Position29.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/transformers/noise-turbulence-template.ts
+import { IDGenerator as IDGenerator30 } from "@awesome-flow/core/utils";
+import { Position as Position30 } from "@xyflow/system";
+var NoiseTurbulenceNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator30.template(),
+      type: "noise-turbulence" /* noiseTurbulence */,
+      data: {
+        title: "Noise Turbulence",
+        frequency: 1,
+        power: 1,
+        roughness: 1,
+        seed: 0
+      },
+      handles: [
+        {
+          position: Position30.Left,
+          dataType: 8 /* module */,
+          connection: "target",
+          label: "Source Module",
+          maxConnections: 1
+        },
+        {
+          position: Position30.Left,
+          dataType: 16 /* variableProperty */,
+          label: "Variable Properties",
+          connection: "target"
+        },
+        {
+          position: Position30.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/variable-property-template.ts
+import { IDGenerator as IDGenerator31 } from "@awesome-flow/core/utils";
+import { Position as Position31 } from "@xyflow/system";
+var VariablePropertyNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator31.template(),
+      type: "variable-property" /* variableProperty */,
+      data: {
+        title: "Variable Property",
+        property: null
+      },
+      handles: [
+        {
+          position: Position31.Left,
+          dataType: 32 /* variableValue */,
+          connection: "target",
+          maxConnections: 1
+        },
+        {
+          position: Position31.Right,
+          dataType: 16 /* variableProperty */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    switch (type) {
+      case "source":
+        return 16 /* variableProperty */;
+      case "target":
+        return 32 /* variableValue */;
+    }
+  }
+};
+
+// src/templates/modifiers/variable-combine-template.ts
+import { IDGenerator as IDGenerator32 } from "@awesome-flow/core/utils";
+import { Position as Position32 } from "@xyflow/system";
+var VariableCombineNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator32.template(),
+      type: "variable-combine" /* variableCombine */,
+      removable: false,
+      data: {
+        title: "Combine Values",
+        operation: "add" /* add */,
+        value: null
+      },
+      handles: [
+        {
+          position: Position32.Left,
+          dataType: 32 /* variableValue */,
+          connection: "target"
+        },
+        {
+          position: Position32.Right,
+          dataType: 32 /* variableValue */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed() {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/variable-value-template.ts
+import { IDGenerator as IDGenerator33 } from "@awesome-flow/core/utils";
+import { Position as Position33 } from "@xyflow/system";
+var VariableValueNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator33.template(),
+      type: "variable-value" /* variableValue */,
+      data: {
+        title: "Variable Value",
+        value: null
+      },
+      handles: [
+        {
+          position: Position33.Right,
+          dataType: 32 /* variableValue */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType(type) {
+    return 32 /* variableValue */;
+  }
+};
+
+// src/templates/groups/module-group-template.ts
+import { IDGenerator as IDGenerator34 } from "@awesome-flow/core/utils";
+import { Position as Position34 } from "@xyflow/system";
+var ModuleGroupNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator34.template(),
+      type: "group-module" /* groupModule */,
+      data: {
+        title: "Modules Group",
+        isGroup: true,
+        initialSize: {
+          width: 300,
+          height: 200
+        },
+        collapsedSize: {
+          width: 300,
+          height: 80
+        }
+      },
+      handles: [
+        {
+          position: Position34.Bottom,
+          dataType: 8 /* module */,
+          connection: "target",
+          maxConnections: 1,
+          hideOnCollapse: true
+        },
+        {
+          position: Position34.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return true;
+  }
+  getHandleAllowedDataType(type) {
+    return 8 /* module */;
+  }
+};
+
+// src/templates/generators/noise-billow-template.ts
+import { IDGenerator as IDGenerator35 } from "@awesome-flow/core/utils";
+import { Position as Position35 } from "@xyflow/system";
+var NoiseBillowNodeTemplateFactory = class {
+  create() {
+    return {
+      id: IDGenerator35.template(),
+      type: "noise-billow" /* noiseBillow */,
+      removable: false,
+      data: {
+        title: "Billow Noise",
+        frequency: 0.1,
+        lacunarity: 2,
+        octaves: 5,
+        persistence: 0.5,
+        seed: 0
+      },
+      handles: [
+        {
+          position: Position35.Left,
+          dataType: 16 /* variableProperty */,
+          connection: "target"
+        },
+        {
+          position: Position35.Right,
+          dataType: 8 /* module */,
+          connection: "source"
+        }
+      ]
+    };
+  }
+  isHandleAllowed(type) {
+    return type === "source";
+  }
+  getHandleAllowedDataType() {
+    return 8 /* module */;
+  }
+};
+
+// src/abstract/node-types.ts
+var NoiseNodeType = /* @__PURE__ */ ((NoiseNodeType2) => {
+  NoiseNodeType2["position"] = "position";
+  NoiseNodeType2["grid"] = "grid";
+  NoiseNodeType2["noiseOutput"] = "noise-output";
+  NoiseNodeType2["noiseConst"] = "noise-constant";
+  NoiseNodeType2["noiseSimplex"] = "noise-simplex";
+  NoiseNodeType2["noiseBillow"] = "noise-billow";
+  NoiseNodeType2["noiseCheckerboard"] = "noise-checkerboard";
+  NoiseNodeType2["noiseNormalize"] = "noise-normalize";
+  NoiseNodeType2["noiseCylinders"] = "noise-cylinders";
+  NoiseNodeType2["noisePerlin"] = "noise-perlin";
+  NoiseNodeType2["noiseRidgedMulti"] = "noise-ridged-multi";
+  NoiseNodeType2["noiseSpheres"] = "noise-spheres";
+  NoiseNodeType2["noiseVoronoi"] = "noise-voronoi";
+  NoiseNodeType2["textureData"] = "texture-data";
+  NoiseNodeType2["noiseLogger"] = "noise-logger";
+  NoiseNodeType2["positionLogger"] = "position-logger";
+  NoiseNodeType2["noiseCombine"] = "noise-combiner";
+  NoiseNodeType2["noiseClamp"] = "noise-clamp";
+  NoiseNodeType2["noiseAbs"] = "noise-abs";
+  NoiseNodeType2["noiseCurve"] = "noise-curve";
+  NoiseNodeType2["noiseExponent"] = "noise-exponent";
+  NoiseNodeType2["noiseInvert"] = "noise-invert";
+  NoiseNodeType2["noiseScaleBias"] = "noise-scale-bias";
+  NoiseNodeType2["noiseTerrace"] = "noise-terrace";
+  NoiseNodeType2["noiseBlend"] = "noise-blend";
+  NoiseNodeType2["noiseSelect"] = "noise-select";
+  NoiseNodeType2["noiseDisplace"] = "noise-displace";
+  NoiseNodeType2["noiseRotatePoint"] = "noise-rotate-point";
+  NoiseNodeType2["noiseScalePoint"] = "noise-scale-point";
+  NoiseNodeType2["noiseTranslatePoint"] = "noise-translate-point";
+  NoiseNodeType2["noiseTurbulence"] = "noise-turbulence";
+  NoiseNodeType2["variableProperty"] = "variable-property";
+  NoiseNodeType2["variableValue"] = "variable-value";
+  NoiseNodeType2["variableCombine"] = "variable-combine";
+  NoiseNodeType2["groupModule"] = "group-module";
+  return NoiseNodeType2;
+})(NoiseNodeType || {});
+var noiseNodeTypes = {
+  ["variable-value" /* variableValue */]: variable_value_node_default,
+  ["variable-property" /* variableProperty */]: variable_property_node_default,
+  ["variable-combine" /* variableCombine */]: variable_combine_node_default,
+  ["group-module" /* groupModule */]: node_module_group_default,
+  ["position" /* position */]: position_const_node_default,
+  ["grid" /* grid */]: position_grid_node_default,
+  ["noise-output" /* noiseOutput */]: noise_output_node_default,
+  ["texture-data" /* textureData */]: noise_raw_texture_node_default,
+  ["noise-logger" /* noiseLogger */]: noise_logger_node_default,
+  ["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,
+  ["noise-ridged-multi" /* noiseRidgedMulti */]: noise_ridgedmulti_node_default,
+  ["noise-spheres" /* noiseSpheres */]: noise_spheres_node_default,
+  ["noise-voronoi" /* noiseVoronoi */]: noise_voronoi_node_default,
+  ["noise-combiner" /* noiseCombine */]: noise_combine_node_default,
+  ["noise-clamp" /* noiseClamp */]: noise_clamp_node_default,
+  ["noise-abs" /* noiseAbs */]: noise_abs_node_default,
+  ["noise-normalize" /* noiseNormalize */]: noise_normalize_node_default,
+  ["noise-curve" /* noiseCurve */]: noise_curve_node_default,
+  ["noise-exponent" /* noiseExponent */]: noise_exponent_node_default,
+  ["noise-invert" /* noiseInvert */]: noise_invert_node_default,
+  ["noise-scale-bias" /* noiseScaleBias */]: noise_scale_bias_node_default,
+  ["noise-terrace" /* noiseTerrace */]: noise_terrace_node_default,
+  ["noise-blend" /* noiseBlend */]: noise_blend_node_default,
+  ["noise-select" /* noiseSelect */]: noise_select_node_default,
+  ["noise-displace" /* noiseDisplace */]: noise_displace_node_default,
+  ["noise-rotate-point" /* noiseRotatePoint */]: noise_rotate_point_node_default,
+  ["noise-scale-point" /* noiseScalePoint */]: noise_scale_point_node_default,
+  ["noise-translate-point" /* noiseTranslatePoint */]: noise_translate_point_node_default,
+  ["noise-turbulence" /* noiseTurbulence */]: noise_turbulence_node_default
+};
+var noiseNodeTemplates = {
+  ["noise-output" /* noiseOutput */]: new NoiseOutputNodeTemplateFactory(),
+  ["noise-simplex" /* noiseSimplex */]: new NoiseSimplexNodeTemplateFactory(),
+  ["noise-billow" /* noiseBillow */]: new NoiseBillowNodeTemplateFactory(),
+  ["noise-checkerboard" /* noiseCheckerboard */]: new NoiseCheckerboardNodeTemplateFactory(),
+  ["noise-normalize" /* noiseNormalize */]: new NoiseNormalizeNodeTemplateFactory(),
+  ["noise-logger" /* noiseLogger */]: new NoiseLoggerNodeTemplateFactory(),
+  ["noise-constant" /* noiseConst */]: new NoiseConstNodeTemplateFactory(),
+  ["position" /* position */]: new PositionConstNodeTemplateFactory(),
+  ["position-logger" /* positionLogger */]: new PositionLoggerNodeTemplateFactory(),
+  ["grid" /* grid */]: new PositionGridNodeTemplateFactory(),
+  ["texture-data" /* textureData */]: new NoiseRawTextureTemplateFactory(),
+  ["noise-cylinders" /* noiseCylinders */]: new NoiseCylindersNodeTemplateFactory(),
+  ["noise-perlin" /* noisePerlin */]: new NoisePerlinNodeTemplateFactory(),
+  ["noise-ridged-multi" /* noiseRidgedMulti */]: new NoiseRidgedMultiNodeTemplateFactory(),
+  ["noise-spheres" /* noiseSpheres */]: new NoiseSpheresNodeTemplateFactory(),
+  ["noise-voronoi" /* noiseVoronoi */]: new NoiseVoronoiNodeTemplateFactory(),
+  ["noise-combiner" /* noiseCombine */]: new NoiseCombineNodeTemplateFactory(),
+  ["noise-clamp" /* noiseClamp */]: new NoiseClampNodeTemplateFactory(),
+  ["noise-abs" /* noiseAbs */]: new NoiseAbsNodeTemplateFactory(),
+  ["noise-curve" /* noiseCurve */]: new NoiseCurveNodeTemplateFactory(),
+  ["noise-exponent" /* noiseExponent */]: new NoiseExponentNodeTemplateFactory(),
+  ["noise-invert" /* noiseInvert */]: new NoiseInvertNodeTemplateFactory(),
+  ["noise-scale-bias" /* noiseScaleBias */]: new NoiseScaleBiasNodeTemplateFactory(),
+  ["noise-terrace" /* noiseTerrace */]: new NoiseTerraceNodeTemplateFactory(),
+  ["noise-blend" /* noiseBlend */]: new NoiseBlendNodeTemplateFactory(),
+  ["noise-select" /* noiseSelect */]: new NoiseSelectNodeTemplateFactory(),
+  ["noise-displace" /* noiseDisplace */]: new NoiseDisplaceNodeTemplateFactory(),
+  ["noise-rotate-point" /* noiseRotatePoint */]: new NoiseRotatePointNodeTemplateFactory(),
+  ["noise-scale-point" /* noiseScalePoint */]: new NoiseScalePointNodeTemplateFactory(),
+  ["noise-translate-point" /* noiseTranslatePoint */]: new NoiseTranslatePointNodeTemplateFactory(),
+  ["noise-turbulence" /* noiseTurbulence */]: new NoiseTurbulenceNodeTemplateFactory(),
+  ["variable-property" /* variableProperty */]: new VariablePropertyNodeTemplateFactory(),
+  ["variable-combine" /* variableCombine */]: new VariableCombineNodeTemplateFactory(),
+  ["variable-value" /* variableValue */]: new VariableValueNodeTemplateFactory(),
+  ["group-module" /* groupModule */]: new ModuleGroupNodeTemplateFactory()
+};
+export {
+  DisplacementModule,
+  NoiseCombineType,
+  NoiseHandleFlag,
+  NoiseNodeType,
+  VariableCombineType,
+  noiseCombineModuleMap,
+  noiseNodeTemplates,
+  noiseNodeTypes
+};
+//# sourceMappingURL=index.js.map