@awesome-flow/noise 0.7.0 → 0.8.0

package/dist/chunk-ACWBUUZ7.cjs

@@ -0,0 +1,1376 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28; var _class29; var _class30; var _class31;
+
+
+
+
+
+var _chunkRKTZQUWRcjs = require('./chunk-RKTZQUWR.cjs');
+
+
+
+
+
+
+
+
+
+
+
+var _chunkD5JM4EYQcjs = require('./chunk-D5JM4EYQ.cjs');
+
+
+var _chunkM67JHEU2cjs = require('./chunk-M67JHEU2.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkTZCT2GZVcjs = require('./chunk-TZCT2GZV.cjs');
+
+// src/nodes/output/noise-logger-node.tsx
+var _hooks = require('@awesome-flow/core/hooks');
+var _layout = require('@awesome-flow/core/layout');
+var _core = require('@mantine/core');
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+function NoiseLoggerNode({ id, selected, data, type }) {
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const noise = _react.useMemo.call(void 0, () => _optionalChain([incoming, 'optionalAccess', _ => _.map, 'call', _2 => _2((p) => p.noise), 'access', _3 => _3.flat, 'call', _4 => _4()]), [incoming]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Text, { children: [
+      "Size: ",
+      _optionalChain([noise, 'optionalAccess', _5 => _5.length]) || 0
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Divider, { h: 5 }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Stack, { children: _optionalChain([noise, 'optionalAccess', _6 => _6.map, 'call', _7 => _7((v, i) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Text, { children: [
+      _optionalChain([v, 'access', _8 => _8.position, 'optionalAccess', _9 => _9.x]),
+      ":",
+      _optionalChain([v, 'access', _10 => _10.position, 'optionalAccess', _11 => _11.y]),
+      ":",
+      _optionalChain([v, 'access', _12 => _12.position, 'optionalAccess', _13 => _13.z]),
+      ": ",
+      v.value
+    ] }, i))]) }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_logger_node_default = NoiseLoggerNode;
+
+// src/nodes/output/noise-output-node.tsx
+var _components = require('@awesome-flow/core/components');
+
+
+
+
+
+// src/nodes/selectors/noise-blend-node.tsx
+
+
+
+var _libnoisesimplexts = require('libnoise-simplex-ts');
+
+
+function NoiseBlendNode({ id, selected, data, type }) {
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  const onDataUpdated = _react.useCallback.call(void 0, 
+    (incomingData) => {
+      const incomingSources = incomingData["source" /* source */];
+      const incomingControl = incomingData["control" /* control */];
+      if (_optionalChain([incomingSources, 'optionalAccess', _14 => _14.length]) >= 2 && _optionalChain([incomingControl, 'optionalAccess', _15 => _15.length])) {
+        const module = new (0, _libnoisesimplexts.Blend)(
+          incomingSources[0].module,
+          incomingSources[1].module,
+          incomingControl[0].module
+        );
+        updateComputedData(id, { module });
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _components.HandlesIncomingDataStatus,
+      {
+        nodeId: id,
+        handles: data.handles,
+        handleKey: "dataId",
+        onDataUpdated,
+        type: "target",
+        resetComputedData: true
+      }
+    ),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_blend_node_default = NoiseBlendNode;
+
+// src/nodes/selectors/noise-select-node.tsx
+
+
+
+
+
+
+
+function NoiseSelectNode({ id, selected, data, type }) {
+  const [edgeFalloff, setEdgeFalloff] = _react.useState.call(void 0, data.edgeFalloff);
+  const [lowerBound, setLowerBound] = _react.useState.call(void 0, data.lowerBound);
+  const [upperBound, setUpperBound] = _react.useState.call(void 0, data.upperBound);
+  const updateNodeData = _hooks.useUpdateNodeData.call(void 0, );
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    updateNodeData(id, { edgeFalloff, lowerBound, upperBound });
+  }, [edgeFalloff, lowerBound, upperBound]);
+  const onDataUpdated = _react.useCallback.call(void 0, 
+    (incomingData) => {
+      const incomingSources = incomingData["source" /* source */];
+      const incomingControl = incomingData["control" /* control */];
+      if (_optionalChain([incomingSources, 'optionalAccess', _16 => _16.length]) >= 2 && _optionalChain([incomingControl, 'optionalAccess', _17 => _17.length])) {
+        const module = new (0, _libnoisesimplexts.Select)(
+          incomingSources[0].module,
+          incomingSources[1].module,
+          incomingControl[0].module,
+          edgeFalloff,
+          lowerBound,
+          upperBound
+        );
+        updateComputedData(id, { module });
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Stack, { children: [
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+        "Edge Falloff:",
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _core.NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: edgeFalloff,
+            onChange: (e) => setEdgeFalloff(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+        "Lower Bound:",
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _core.NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: lowerBound,
+            onChange: (e) => setLowerBound(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+        "Upper Bound:",
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _core.NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: upperBound,
+            onChange: (e) => setUpperBound(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _components.HandlesIncomingDataStatus,
+        {
+          nodeId: id,
+          handles: data.handles,
+          handleKey: "dataId",
+          onDataUpdated,
+          type: "target",
+          resetComputedData: true
+        }
+      )
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_select_node_default = NoiseSelectNode;
+
+// src/nodes/output/noise-raw-texture-node.tsx
+
+
+
+
+
+function NoiseRawTextureNode({ id, selected, data, type }) {
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  const [dataLength, setDataLength] = _react.useState.call(void 0, 0);
+  const [resolution, setResolution] = _react.useState.call(void 0, 0);
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const noise = _react.useMemo.call(void 0, () => _optionalChain([incoming, 'optionalAccess', _18 => _18.map, 'call', _19 => _19((p) => p.noise), 'access', _20 => _20.flat, 'call', _21 => _21()]), [incoming]);
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([noise, 'optionalAccess', _22 => _22.length])) {
+      const size = Math.ceil(Math.sqrt(noise.length));
+      const colors = noise.map((n) => [n.value * 255, n.value * 255, n.value * 255, 255]).flat();
+      const dataArray = new Uint8Array(size * size * 4);
+      dataArray.set(colors);
+      setResolution(size);
+      setDataLength(dataArray.length);
+      updateComputedData(id, {
+        textureData: dataArray,
+        textureResolutionX: size,
+        textureResolutionY: size
+      });
+    }
+  }, [noise]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Stack, { children: [
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+        "Resolution: ",
+        resolution,
+        "x",
+        resolution
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+        "Input Length: ",
+        _optionalChain([noise, 'optionalAccess', _23 => _23.length]) || 0
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+        "Output Length (",
+        resolution,
+        "*",
+        resolution,
+        "*4): ",
+        dataLength
+      ] })
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_raw_texture_node_default = NoiseRawTextureNode;
+
+// src/nodes/output/positions-logger-node.tsx
+
+
+
+
+
+function PositionsLoggerNode({ id, selected, data, type }) {
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const positions = _react.useMemo.call(void 0, () => {
+    return _optionalChain([incoming, 'optionalAccess', _24 => _24.map, 'call', _25 => _25((p) => p.positions), 'access', _26 => _26.flat, 'call', _27 => _27()]);
+  }, [incoming]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Text, { children: [
+      "Size: ",
+      _optionalChain([positions, 'optionalAccess', _28 => _28.length]) || 0
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Divider, { h: 5 }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Stack, { children: _optionalChain([positions, 'optionalAccess', _29 => _29.map, 'call', _30 => _30((v, i) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Text, { children: [
+      v.x,
+      ":",
+      v.y,
+      ":",
+      v.z
+    ] }, i))]) }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var positions_logger_node_default = PositionsLoggerNode;
+
+// src/templates/generators/noise-billow-template.ts
+var _abstract = require('@awesome-flow/core/abstract');
+var _utils = require('@awesome-flow/core/utils');
+var _system = require('@xyflow/system');
+
+// src/abstract/templates.ts
+var NoiseTemplateGroup = /* @__PURE__ */ ((NoiseTemplateGroup2) => {
+  NoiseTemplateGroup2["positions"] = "Positions";
+  NoiseTemplateGroup2["output"] = "Output";
+  NoiseTemplateGroup2["noiseGenerators"] = "Noise Generators";
+  NoiseTemplateGroup2["noiseModifiers"] = "Noise Modifiers";
+  NoiseTemplateGroup2["noiseSelectors"] = "Noise Selectors";
+  NoiseTemplateGroup2["noiseTransformers"] = "Noise Transformers";
+  return NoiseTemplateGroup2;
+})(NoiseTemplateGroup || {});
+
+// src/templates/generators/noise-billow-template.ts
+var NoiseBillowNodeTemplateFactory = (_class = class {constructor() { _class.prototype.__init.call(this); }
+  __init() {this.template = {
+    id: _utils.IDGenerator.template(),
+    type: "noise-billow" /* noiseBillow */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Billow Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 5,
+      persistence: 0.5,
+      seed: 0
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: _abstract.CoreHandleType.variableProperty,
+        connection: "target"
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class);
+
+// src/templates/generators/noise-checkerboard-template.ts
+
+var NoiseCheckerboardNodeTemplateFactory = (_class2 = class {constructor() { _class2.prototype.__init2.call(this); }
+  __init2() {this.template = {
+    type: "noise-checkerboard" /* noiseCheckerboard */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Checkerboard Noise"
+    },
+    handles: [
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class2);
+
+// src/templates/generators/noise-const-template.ts
+
+var NoiseConstNodeTemplateFactory = (_class3 = class {constructor() { _class3.prototype.__init3.call(this); }
+  __init3() {this.template = {
+    type: "noise-constant" /* noiseConst */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Const Value Noise",
+      noise: 0,
+      min: -1,
+      max: 1
+    },
+    handles: [
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class3);
+
+// src/templates/generators/noise-cylinders-template.ts
+
+
+var NoiseCylindersNodeTemplateFactory = (_class4 = class {constructor() { _class4.prototype.__init4.call(this); }
+  __init4() {this.template = {
+    type: "noise-cylinders" /* noiseCylinders */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Cylinders Noise",
+      frequency: 0.1
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: _abstract.CoreHandleType.variableProperty,
+        connection: "target"
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class4);
+
+// src/templates/generators/noise-perlin-template.ts
+
+
+var NoisePerlinNodeTemplateFactory = (_class5 = class {constructor() { _class5.prototype.__init5.call(this); }
+  __init5() {this.template = {
+    type: "noise-perlin" /* noisePerlin */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Perlin Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 5,
+      persistence: 0.5,
+      seed: 0
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: _abstract.CoreHandleType.variableProperty,
+        connection: "target"
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class5);
+
+// src/templates/generators/noise-ridgedmulti-template.ts
+
+
+var NoiseRidgedMultiNodeTemplateFactory = (_class6 = class {constructor() { _class6.prototype.__init6.call(this); }
+  __init6() {this.template = {
+    type: "noise-ridged-multi" /* noiseRidgedMulti */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Ridged Multi Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 6,
+      offset: 1,
+      gain: 2,
+      seed: 0
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: _abstract.CoreHandleType.variableProperty,
+        connection: "target"
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class6);
+
+// src/templates/generators/noise-spheres-template.ts
+
+
+var NoiseSpheresNodeTemplateFactory = (_class7 = class {constructor() { _class7.prototype.__init7.call(this); }
+  __init7() {this.template = {
+    type: "noise-spheres" /* noiseSpheres */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Spheres Noise",
+      frequency: 0.1
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: _abstract.CoreHandleType.variableProperty,
+        connection: "target"
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class7);
+
+// src/templates/generators/noise-voronoi-template.ts
+
+
+var NoiseVoronoiNodeTemplateFactory = (_class8 = class {constructor() { _class8.prototype.__init8.call(this); }
+  __init8() {this.template = {
+    type: "noise-voronoi" /* noiseVoronoi */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Voronoi Noise",
+      frequency: 0.1,
+      displacement: 1,
+      distance: true,
+      seed: 0
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: _abstract.CoreHandleType.variableProperty,
+        connection: "target"
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class8);
+
+// src/templates/generators/position-const-template.ts
+
+var PositionConstNodeTemplateFactory = (_class9 = class {constructor() { _class9.prototype.__init9.call(this); }
+  __init9() {this.template = {
+    type: "position" /* position */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Position Output",
+      position: { x: 0, y: 0, z: 0 }
+    },
+    handles: [
+      {
+        position: _system.Position.Right,
+        dataType: "position" /* position */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class9);
+
+// src/templates/generators/position-grid-template.ts
+
+var PositionGridNodeTemplateFactory = (_class10 = class {constructor() { _class10.prototype.__init10.call(this); }
+  __init10() {this.template = {
+    type: "grid" /* grid */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Grid Output",
+      center: { x: 0, y: 0, z: 0 },
+      radius: 1
+    },
+    handles: [
+      {
+        position: _system.Position.Right,
+        dataType: "position" /* position */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class10);
+
+// src/templates/groups/module-group-template.ts
+
+
+
+
+
+var ModuleGroupNodeTemplateFactory = (_class11 = class {constructor() { _class11.prototype.__init11.call(this); }
+  __init11() {this.template = {
+    id: _utils.IDGenerator.template(),
+    type: "group-module" /* groupModule */,
+    group: _abstract.CoreTemplateGroup.groups,
+    data: {
+      title: "Modules Group",
+      isGroup: true,
+      initialSize: {
+        width: 300,
+        height: 200
+      },
+      collapsedSize: {
+        width: 300,
+        height: 80
+      }
+    },
+    handles: [
+      {
+        position: _system.Position.Bottom,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1,
+        hideOnCollapse: true
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class11);
+
+// src/templates/modifiers/noise-abs-template.ts
+
+var NoiseAbsNodeTemplateFactory = (_class12 = class {constructor() { _class12.prototype.__init12.call(this); }
+  __init12() {this.template = {
+    type: "noise-abs" /* noiseAbs */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Abs Noise"
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class12);
+
+// src/templates/modifiers/noise-clamp-template.ts
+
+var NoiseClampNodeTemplateFactory = (_class13 = class {constructor() { _class13.prototype.__init13.call(this); }
+  __init13() {this.template = {
+    type: "noise-clamp" /* noiseClamp */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Clamp Noise",
+      lowerBound: -1,
+      upperBound: 1
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class13);
+
+// src/templates/modifiers/noise-combine-template.ts
+
+var NoiseCombineNodeTemplateFactory = (_class14 = class {constructor() { _class14.prototype.__init14.call(this); }
+  __init14() {this.template = {
+    type: "noise-combiner" /* noiseCombine */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Combine Noise",
+      operation: "add" /* add */
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 2
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class14);
+
+// src/templates/modifiers/noise-curve-template.ts
+
+var NoiseCurveNodeTemplateFactory = (_class15 = class {constructor() { _class15.prototype.__init15.call(this); }
+  __init15() {this.template = {
+    type: "noise-curve" /* noiseCurve */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Curve",
+      points: []
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      // {
+      //   position: Position.Left,
+      //   dataType: CoreHandleType.variableProperty,
+      //   connection: 'target',
+      // },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class15);
+
+// src/templates/modifiers/noise-exponent-template.ts
+
+var NoiseExponentNodeTemplateFactory = (_class16 = class {constructor() { _class16.prototype.__init16.call(this); }
+  __init16() {this.template = {
+    type: "noise-exponent" /* noiseExponent */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Exponent",
+      exponent: 1
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class16);
+
+// src/templates/modifiers/noise-invert-template.ts
+
+var NoiseInvertNodeTemplateFactory = (_class17 = class {constructor() { _class17.prototype.__init17.call(this); }
+  __init17() {this.template = {
+    type: "noise-invert" /* noiseInvert */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Invert Noise"
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class17);
+
+// src/templates/modifiers/noise-normalize-template.ts
+
+
+var NoiseNormalizeNodeTemplateFactory = (_class18 = class {constructor() { _class18.prototype.__init18.call(this); }
+  __init18() {this.template = {
+    id: _utils.IDGenerator.template(),
+    type: "noise-normalize" /* noiseNormalize */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Normalize Noise",
+      intervalStart: -1,
+      intervalEnd: 1
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class18);
+
+// src/templates/modifiers/noise-scalebias-template.ts
+
+var NoiseScaleBiasNodeTemplateFactory = (_class19 = class {constructor() { _class19.prototype.__init19.call(this); }
+  __init19() {this.template = {
+    type: "noise-scale-bias" /* noiseScaleBias */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Scale/Bias Noise",
+      scale: 1,
+      bias: 0
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class19);
+
+// src/templates/modifiers/noise-terrace-template.ts
+
+var NoiseTerraceNodeTemplateFactory = (_class20 = class {constructor() { _class20.prototype.__init20.call(this); }
+  __init20() {this.template = {
+    type: "noise-terrace" /* noiseTerrace */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Terrace",
+      points: []
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class20);
+
+// src/templates/output/noise-logger-template.ts
+
+var NoiseLoggerNodeTemplateFactory = (_class21 = class {constructor() { _class21.prototype.__init21.call(this); }
+  __init21() {this.template = {
+    type: "noise-logger" /* noiseLogger */,
+    group: "Output" /* output */,
+    data: {
+      title: "Noise Logger"
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "noise" /* noise */,
+        connection: "target"
+      }
+    ]
+  }}
+}, _class21);
+
+// src/templates/output/noise-output-template.ts
+
+var NoiseOutputNodeTemplateFactory = (_class22 = class {constructor() { _class22.prototype.__init22.call(this); }
+  __init22() {this.template = {
+    type: "noise-output" /* noiseOutput */,
+    group: "Output" /* output */,
+    data: {
+      title: "Noise Output"
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "position" /* position */,
+        connection: "target"
+      },
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "noise" /* noise */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class22);
+
+// src/templates/output/noise-raw-texture-template.ts
+
+var NoiseRawTextureTemplateFactory = (_class23 = class {constructor() { _class23.prototype.__init23.call(this); }
+  __init23() {this.template = {
+    type: "texture-data" /* textureData */,
+    group: "Output" /* output */,
+    data: {
+      title: "Texture Data"
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "noise" /* noise */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "texture" /* texture */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class23);
+
+// src/templates/output/position-logger-template.ts
+
+var PositionLoggerNodeTemplateFactory = (_class24 = class {constructor() { _class24.prototype.__init24.call(this); }
+  __init24() {this.template = {
+    type: "position-logger" /* positionLogger */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Position Logger"
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "position" /* position */,
+        connection: "target"
+      }
+    ]
+  }}
+}, _class24);
+
+// src/templates/selectors/noise-blend-template.ts
+
+var NoiseBlendNodeTemplateFactory = (_class25 = class {constructor() { _class25.prototype.__init25.call(this); }
+  __init25() {this.template = {
+    type: "noise-blend" /* noiseBlend */,
+    group: "Noise Selectors" /* noiseSelectors */,
+    data: {
+      title: "Noise Blend"
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Modules",
+        dataId: "source" /* source */,
+        maxConnections: 2,
+        minConnections: 2
+      },
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        dataId: "control" /* control */,
+        connection: "target",
+        label: "Control Module",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class25);
+
+// src/templates/selectors/noise-select-template.ts
+
+var NoiseSelectNodeTemplateFactory = (_class26 = class {constructor() { _class26.prototype.__init26.call(this); }
+  __init26() {this.template = {
+    type: "noise-select" /* noiseSelect */,
+    group: "Noise Selectors" /* noiseSelectors */,
+    data: {
+      title: "Noise Select",
+      edgeFalloff: 0,
+      lowerBound: -1,
+      upperBound: 1
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        dataId: "source" /* source */,
+        connection: "target",
+        label: "Source Modules",
+        maxConnections: 2,
+        minConnections: 2
+      },
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        dataId: "control" /* control */,
+        connection: "target",
+        label: "Control Module",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class26);
+
+// src/templates/transformers/noise-displace-template.ts
+
+var NoiseDisplaceNodeTemplateFactory = (_class27 = class {constructor() { _class27.prototype.__init27.call(this); }
+  __init27() {this.template = {
+    type: "noise-displace" /* noiseDisplace */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Displace"
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        connection: "target",
+        label: "Source Module",
+        dataType: "module" /* module */,
+        dataId: "source" /* sourceModule */,
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Left,
+        connection: "target",
+        label: "X Module",
+        dataType: "module" /* module */,
+        dataId: "x-module" /* xModule */,
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Left,
+        connection: "target",
+        label: "Y Module",
+        dataType: "module" /* module */,
+        dataId: "y-module" /* yModule */,
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Left,
+        connection: "target",
+        label: "Z Module",
+        dataType: "module" /* module */,
+        dataId: "z-module" /* zModule */,
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class27);
+
+// src/templates/transformers/noise-rotate-point-template.ts
+
+var NoiseRotatePointNodeTemplateFactory = (_class28 = class {constructor() { _class28.prototype.__init28.call(this); }
+  __init28() {this.template = {
+    type: "noise-rotate-point" /* noiseRotatePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Rotate Point",
+      xAngle: 0,
+      yAngle: 0,
+      zAngle: 0
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class28);
+
+// src/templates/transformers/noise-scale-point-template.ts
+
+var NoiseScalePointNodeTemplateFactory = (_class29 = class {constructor() { _class29.prototype.__init29.call(this); }
+  __init29() {this.template = {
+    type: "noise-scale-point" /* noiseScalePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Scale Point",
+      xScale: 1,
+      yScale: 1,
+      zScale: 1
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class29);
+
+// src/templates/transformers/noise-translate-point-template.ts
+
+var NoiseTranslatePointNodeTemplateFactory = (_class30 = class {constructor() { _class30.prototype.__init30.call(this); }
+  __init30() {this.template = {
+    type: "noise-translate-point" /* noiseTranslatePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Translate Point",
+      translateX: 0,
+      translateY: 0,
+      translateZ: 0
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class30);
+
+// src/templates/transformers/noise-turbulence-template.ts
+
+
+var NoiseTurbulenceNodeTemplateFactory = (_class31 = class {constructor() { _class31.prototype.__init31.call(this); }
+  __init31() {this.template = {
+    type: "noise-turbulence" /* noiseTurbulence */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Turbulence",
+      frequency: 1,
+      power: 1,
+      roughness: 1,
+      seed: 0
+    },
+    handles: [
+      {
+        position: _system.Position.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: _system.Position.Left,
+        dataType: _abstract.CoreHandleType.variableProperty,
+        label: "Variable Properties",
+        connection: "target"
+      },
+      {
+        position: _system.Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  }}
+}, _class31);
+
+// src/abstract/node-types.ts
+var NoiseNodeType = /* @__PURE__ */ ((NoiseNodeType2) => {
+  NoiseNodeType2["position"] = "position";
+  NoiseNodeType2["grid"] = "grid";
+  NoiseNodeType2["textureData"] = "texture-data";
+  NoiseNodeType2["groupModule"] = "group-module";
+  NoiseNodeType2["positionLogger"] = "position-logger";
+  NoiseNodeType2["noiseLogger"] = "noise-logger";
+  NoiseNodeType2["noiseOutput"] = "noise-output";
+  NoiseNodeType2["noiseConst"] = "noise-constant";
+  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["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";
+  return NoiseNodeType2;
+})(NoiseNodeType || {});
+var noiseNodeTypes = {
+  ["group-module" /* groupModule */]: _chunkM67JHEU2cjs.module_group_node_default,
+  ["position" /* position */]: _chunkD5JM4EYQcjs.position_const_node_default,
+  ["grid" /* grid */]: _chunkD5JM4EYQcjs.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 */]: _chunkD5JM4EYQcjs.noise_const_node_default,
+  ["noise-billow" /* noiseBillow */]: _chunkD5JM4EYQcjs.noise_billow_node_default,
+  ["noise-checkerboard" /* noiseCheckerboard */]: _chunkD5JM4EYQcjs.noise_checkerboard_node_default,
+  ["noise-cylinders" /* noiseCylinders */]: _chunkD5JM4EYQcjs.noise_cylinders_node_default,
+  ["noise-perlin" /* noisePerlin */]: _chunkD5JM4EYQcjs.noise_perlin_node_default,
+  ["noise-ridged-multi" /* noiseRidgedMulti */]: _chunkD5JM4EYQcjs.noise_ridgedmulti_node_default,
+  ["noise-spheres" /* noiseSpheres */]: _chunkD5JM4EYQcjs.noise_spheres_node_default,
+  ["noise-voronoi" /* noiseVoronoi */]: _chunkD5JM4EYQcjs.noise_voronoi_node_default,
+  ["noise-combiner" /* noiseCombine */]: _chunkTZCT2GZVcjs.noise_combine_node_default,
+  ["noise-clamp" /* noiseClamp */]: _chunkTZCT2GZVcjs.noise_clamp_node_default,
+  ["noise-abs" /* noiseAbs */]: _chunkTZCT2GZVcjs.noise_abs_node_default,
+  ["noise-normalize" /* noiseNormalize */]: _chunkTZCT2GZVcjs.noise_normalize_node_default,
+  ["noise-curve" /* noiseCurve */]: _chunkTZCT2GZVcjs.noise_curve_node_default,
+  ["noise-exponent" /* noiseExponent */]: _chunkTZCT2GZVcjs.noise_exponent_node_default,
+  ["noise-invert" /* noiseInvert */]: _chunkTZCT2GZVcjs.noise_invert_node_default,
+  ["noise-scale-bias" /* noiseScaleBias */]: _chunkTZCT2GZVcjs.noise_scale_bias_node_default,
+  ["noise-terrace" /* noiseTerrace */]: _chunkTZCT2GZVcjs.noise_terrace_node_default,
+  ["noise-blend" /* noiseBlend */]: noise_blend_node_default,
+  ["noise-select" /* noiseSelect */]: noise_select_node_default,
+  ["noise-displace" /* noiseDisplace */]: _chunkRKTZQUWRcjs.noise_displace_node_default,
+  ["noise-rotate-point" /* noiseRotatePoint */]: _chunkRKTZQUWRcjs.noise_rotate_point_node_default,
+  ["noise-scale-point" /* noiseScalePoint */]: _chunkRKTZQUWRcjs.noise_scale_point_node_default,
+  ["noise-translate-point" /* noiseTranslatePoint */]: _chunkRKTZQUWRcjs.noise_translate_point_node_default,
+  ["noise-turbulence" /* noiseTurbulence */]: _chunkRKTZQUWRcjs.noise_turbulence_node_default
+};
+var noiseNodeTemplates = {
+  ["noise-output" /* noiseOutput */]: new NoiseOutputNodeTemplateFactory(),
+  ["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(),
+  ["group-module" /* groupModule */]: new ModuleGroupNodeTemplateFactory()
+};
+
+// src/nodes/output/noise-output-node.tsx
+
+function NoiseOutputNode({ id, selected, data, type }) {
+  const [size, setSize] = _react.useState.call(void 0, 0);
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  const onDataUpdated = _react.useCallback.call(void 0, 
+    (handleData) => {
+      const incomingPositions = handleData["position" /* position */];
+      const incomingModule = handleData["module" /* module */];
+      if (_optionalChain([incomingPositions, 'optionalAccess', _31 => _31.length]) && _optionalChain([incomingModule, 'optionalAccess', _32 => _32.length]) && _optionalChain([incomingModule, 'access', _33 => _33[0], 'optionalAccess', _34 => _34.module])) {
+        const { module } = incomingModule[0];
+        const noise = [];
+        for (const input of incomingPositions) {
+          for (const position of input.positions) {
+            const value = module.getValue(position.x, position.y, position.z);
+            noise.push({
+              position,
+              value
+            });
+          }
+        }
+        updateComputedData(id, { noise, module });
+        setSize(noise.length);
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _components.HandlesIncomingDataStatus,
+      {
+        nodeId: id,
+        handles: data.handles,
+        handleKey: "dataType",
+        onDataUpdated,
+        type: "target",
+        resetComputedData: true
+      }
+    ),
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Text, { mt: 5, children: [
+      "Noise points: ",
+      size
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_output_node_default = NoiseOutputNode;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.noise_logger_node_default = noise_logger_node_default; exports.noise_output_node_default = noise_output_node_default; exports.noise_raw_texture_node_default = noise_raw_texture_node_default; exports.positions_logger_node_default = positions_logger_node_default; exports.noise_blend_node_default = noise_blend_node_default; exports.noise_select_node_default = noise_select_node_default; exports.NoiseTemplateGroup = NoiseTemplateGroup; exports.NoiseBillowNodeTemplateFactory = NoiseBillowNodeTemplateFactory; exports.NoiseCheckerboardNodeTemplateFactory = NoiseCheckerboardNodeTemplateFactory; exports.NoiseConstNodeTemplateFactory = NoiseConstNodeTemplateFactory; exports.NoiseCylindersNodeTemplateFactory = NoiseCylindersNodeTemplateFactory; exports.NoisePerlinNodeTemplateFactory = NoisePerlinNodeTemplateFactory; exports.NoiseRidgedMultiNodeTemplateFactory = NoiseRidgedMultiNodeTemplateFactory; exports.NoiseSpheresNodeTemplateFactory = NoiseSpheresNodeTemplateFactory; exports.NoiseVoronoiNodeTemplateFactory = NoiseVoronoiNodeTemplateFactory; exports.PositionConstNodeTemplateFactory = PositionConstNodeTemplateFactory; exports.PositionGridNodeTemplateFactory = PositionGridNodeTemplateFactory; exports.ModuleGroupNodeTemplateFactory = ModuleGroupNodeTemplateFactory; exports.NoiseAbsNodeTemplateFactory = NoiseAbsNodeTemplateFactory; exports.NoiseClampNodeTemplateFactory = NoiseClampNodeTemplateFactory; exports.NoiseCombineNodeTemplateFactory = NoiseCombineNodeTemplateFactory; exports.NoiseCurveNodeTemplateFactory = NoiseCurveNodeTemplateFactory; exports.NoiseExponentNodeTemplateFactory = NoiseExponentNodeTemplateFactory; exports.NoiseInvertNodeTemplateFactory = NoiseInvertNodeTemplateFactory; exports.NoiseNormalizeNodeTemplateFactory = NoiseNormalizeNodeTemplateFactory; exports.NoiseScaleBiasNodeTemplateFactory = NoiseScaleBiasNodeTemplateFactory; exports.NoiseTerraceNodeTemplateFactory = NoiseTerraceNodeTemplateFactory; exports.NoiseLoggerNodeTemplateFactory = NoiseLoggerNodeTemplateFactory; exports.NoiseOutputNodeTemplateFactory = NoiseOutputNodeTemplateFactory; exports.NoiseRawTextureTemplateFactory = NoiseRawTextureTemplateFactory; exports.PositionLoggerNodeTemplateFactory = PositionLoggerNodeTemplateFactory; exports.NoiseBlendNodeTemplateFactory = NoiseBlendNodeTemplateFactory; exports.NoiseSelectNodeTemplateFactory = NoiseSelectNodeTemplateFactory; exports.NoiseDisplaceNodeTemplateFactory = NoiseDisplaceNodeTemplateFactory; exports.NoiseRotatePointNodeTemplateFactory = NoiseRotatePointNodeTemplateFactory; exports.NoiseScalePointNodeTemplateFactory = NoiseScalePointNodeTemplateFactory; exports.NoiseTranslatePointNodeTemplateFactory = NoiseTranslatePointNodeTemplateFactory; exports.NoiseTurbulenceNodeTemplateFactory = NoiseTurbulenceNodeTemplateFactory; exports.NoiseNodeType = NoiseNodeType; exports.noiseNodeTypes = noiseNodeTypes; exports.noiseNodeTemplates = noiseNodeTemplates;