@awesome-flow/noise 0.7.0 → 0.8.0

package/dist/chunk-TZCT2GZV.cjs

@@ -0,0 +1,522 @@
+"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 _chunkUNMRBZ5Xcjs = require('./chunk-UNMRBZ5X.cjs');
+
+// src/nodes/modifiers/noise-abs-node.tsx
+var _hooks = require('@awesome-flow/core/hooks');
+var _layout = require('@awesome-flow/core/layout');
+var _libnoisesimplexts = require('libnoise-simplex-ts');
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+function NoiseAbsNode({ id, selected, data, type }) {
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([incoming, 'optionalAccess', _ => _.length]) > 0) {
+      const module = new (0, _libnoisesimplexts.Abs)(incoming[0].module);
+      updateComputedData(id, { module });
+    }
+  }, [incoming]);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" }) });
+}
+var noise_abs_node_default = NoiseAbsNode;
+
+// src/nodes/modifiers/noise-clamp-node.tsx
+
+
+
+
+
+
+var _core = require('@mantine/core');
+
+
+
+function NoiseClampNode({ id, selected, data, type }) {
+  const [lowerBound, setLowerBound] = _react.useState.call(void 0, data.lowerBound);
+  const [upperBound, setUpperBound] = _react.useState.call(void 0, data.upperBound);
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateNodeData = _hooks.useUpdateNodeData.call(void 0, );
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([incoming, 'optionalAccess', _2 => _2.length])) {
+      const module = new (0, _libnoisesimplexts.Clamp)(incoming[0].module, lowerBound, upperBound);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { lowerBound, upperBound });
+  }, [incoming, lowerBound, upperBound]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Stack, { children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _core.NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: lowerBound,
+          onChange: (e) => setLowerBound(Number(e)),
+          step: 0.1
+        }
+      ),
+      /* @__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, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_clamp_node_default = NoiseClampNode;
+
+// src/nodes/modifiers/noise-combine-node.tsx
+
+
+
+
+
+
+
+
+
+
+
+
+var _iconsreact = require('@tabler/icons-react');
+
+
+// src/abstract/operations.ts
+
+var NoiseCombineType = /* @__PURE__ */ ((NoiseCombineType3) => {
+  NoiseCombineType3["add"] = "add";
+  NoiseCombineType3["max"] = "max";
+  NoiseCombineType3["min"] = "min";
+  NoiseCombineType3["multiply"] = "multiply";
+  NoiseCombineType3["power"] = "power";
+  return NoiseCombineType3;
+})(NoiseCombineType || {});
+var noiseCombineModuleMap = {
+  ["add" /* add */]: _libnoisesimplexts.Add,
+  ["max" /* max */]: _libnoisesimplexts.Max,
+  ["min" /* min */]: _libnoisesimplexts.Min,
+  ["multiply" /* multiply */]: _libnoisesimplexts.Multiply,
+  ["power" /* power */]: _libnoisesimplexts.Power
+};
+
+// src/nodes/modifiers/noise-combine-node.tsx
+
+var options = {
+  add: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsreact.IconPlus, {}),
+  min: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsreact.IconChevronLeft, {}),
+  max: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsreact.IconChevronRight, {}),
+  multiply: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsreact.IconAsterisk, {}),
+  power: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsreact.IconChevronUp, {})
+};
+function NoiseCombineNode({ id, selected, data, type }) {
+  const updateNodeData = _hooks.useUpdateNodeData.call(void 0, );
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  _react.useEffect.call(void 0, () => {
+    const ModuleFactory = noiseCombineModuleMap[data.operation];
+    if (_optionalChain([incoming, 'optionalAccess', _3 => _3.length]) > 1) {
+      const module = new ModuleFactory(incoming[0].module, incoming[1].module);
+      updateComputedData(id, { module });
+    }
+  }, [data.operation, incoming]);
+  const onChange = _react.useCallback.call(void 0, (operation) => {
+    updateNodeData(id, { operation });
+  }, []);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeCombobox, { options, selected: data.operation, onChange, width: 150 }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_combine_node_default = NoiseCombineNode;
+
+// src/nodes/modifiers/noise-curve-node.tsx
+var _abstract = require('@awesome-flow/core/abstract');
+
+
+
+
+
+
+
+var _form = require('@mantine/form');
+var _hooks3 = require('@mantine/hooks');
+
+
+
+
+function NoiseCurveNode({ id, selected, data, type }) {
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateNodeData = _hooks.useUpdateNodeData.call(void 0, );
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  const [values, setValues] = _react.useState.call(void 0, []);
+  const form = _form.useForm.call(void 0, {
+    mode: "uncontrolled",
+    initialValues: {
+      points: []
+    },
+    validateInputOnChange: [`points.${_form.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: _react.useCallback.call(void 0, (values2) => {
+      form.validate();
+      if (form.isValid()) {
+        const points = values2.points.map((v) => ({ input: v.input, output: v.output }));
+        setValues(points);
+        updateNodeData(id, { points });
+      }
+    }, [])
+  });
+  _react.useEffect.call(void 0, () => {
+    const points = _optionalChain([data, 'access', _4 => _4.points, 'optionalAccess', _5 => _5.length]) ? data.points.map((v) => ({ input: v.input, output: v.output, key: _hooks3.randomId.call(void 0, ) })) : [1, 2, 3, 4].map(() => ({ input: 0, output: 0, key: _hooks3.randomId.call(void 0, ) }));
+    form.initialize({ points });
+  }, []);
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([incoming, 'optionalAccess', _6 => _6.length]) && _optionalChain([values, 'optionalAccess', _7 => _7.length]) >= 4) {
+      const module = new (0, _libnoisesimplexts.Curve)(
+        incoming[0].module,
+        values.map((p) => new (0, _libnoisesimplexts.Tuple)(p.input, p.output))
+      );
+      updateComputedData(id, { module });
+    }
+  }, [values, incoming]);
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { mt: "xs", children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _core.NumberInput,
+      {
+        size: "xs",
+        w: 100,
+        placeholder: "Input Value",
+        ...form.getInputProps(`points.${index}.input`),
+        step: 0.1
+      },
+      form.key(`points.${index}.input`)
+    ),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _core.NumberInput,
+      {
+        size: "xs",
+        w: 100,
+        placeholder: "Output Value",
+        ...form.getInputProps(`points.${index}.output`),
+        step: 0.1
+      },
+      form.key(`points.${index}.output`)
+    ),
+    data.state === _abstract.NodeState.edit && values.length > 4 && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _core.ActionIcon,
+      {
+        color: "red",
+        variant: "outline",
+        size: "sm",
+        onClick: () => form.removeListItem("points", index),
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsreact.IconX, { size: "1rem" })
+      }
+    )
+  ] }, item.key));
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, type, data, children: [
+    fields,
+    data.state === _abstract.NodeState.edit && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Space, { h: 10 }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _core.Button,
+        {
+          variant: "outline",
+          size: "xs",
+          fullWidth: true,
+          onClick: () => form.insertListItem("points", { input: 0, output: 0, key: _hooks3.randomId.call(void 0, ) }),
+          children: "Add control point"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_curve_node_default = NoiseCurveNode;
+
+// src/nodes/modifiers/noise-exponent-node.tsx
+
+
+
+
+
+
+
+
+
+
+function NoiseExponentNode({ id, selected, data, type }) {
+  const [exponent, setExponent] = _react.useState.call(void 0, data.exponent);
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateNodeData = _hooks.useUpdateNodeData.call(void 0, );
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([incoming, 'optionalAccess', _8 => _8.length]) > 0) {
+      const module = new (0, _libnoisesimplexts.Exponent)(incoming[0].module, exponent);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { exponent });
+  }, [incoming, exponent]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Stack, { children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+      "Exponent:",
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _core.NumberInput,
+        {
+          size: "xs",
+          value: exponent,
+          onChange: (e) => setExponent(Number(e)),
+          step: 0.1
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_exponent_node_default = NoiseExponentNode;
+
+// src/nodes/modifiers/noise-invert-node.tsx
+
+
+
+
+
+function NoiseInvertNode({ id, selected, data, type }) {
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([incoming, 'optionalAccess', _9 => _9.length]) > 0) {
+      const module = new (0, _libnoisesimplexts.Invert)(incoming[0].module);
+      updateComputedData(id, { module });
+    }
+  }, [incoming]);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" }) });
+}
+var noise_invert_node_default = NoiseInvertNode;
+
+// src/nodes/modifiers/noise-normalize-node.tsx
+
+
+
+
+
+
+
+
+
+function NoiseNormalizeNode({ id, selected, data, type }) {
+  const [intervalStart, setIntervalStart] = _react.useState.call(void 0, data.intervalStart);
+  const [intervalEnd, setIntervalEnd] = _react.useState.call(void 0, data.intervalEnd);
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateNodeData = _hooks.useUpdateNodeData.call(void 0, );
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([incoming, 'optionalAccess', _10 => _10.length])) {
+      const source = incoming[0].module;
+      const module = new (0, _chunkUNMRBZ5Xcjs.NormalizeNoiseModule)(source, intervalStart, intervalEnd);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { intervalStart, intervalEnd });
+  }, [incoming, intervalStart, intervalEnd]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Stack, { children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _core.NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: intervalStart,
+          onChange: (e) => setIntervalStart(Number(e))
+        }
+      ),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _core.NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: intervalEnd,
+          onChange: (e) => setIntervalEnd(Number(e))
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_normalize_node_default = NoiseNormalizeNode;
+
+// src/nodes/modifiers/noise-scale-bias-node.tsx
+
+
+
+
+
+
+
+
+
+
+function NoiseScaleBiasNode({ id, selected, data, type }) {
+  const [scale, setScale] = _react.useState.call(void 0, data.scale);
+  const [bias, setBias] = _react.useState.call(void 0, data.bias);
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateNodeData = _hooks.useUpdateNodeData.call(void 0, );
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([incoming, 'optionalAccess', _11 => _11.length]) > 0) {
+      const module = new (0, _libnoisesimplexts.ScaleBias)(incoming[0].module, scale, bias);
+      updateComputedData(id, { module });
+    }
+    updateNodeData(id, { scale, bias });
+  }, [incoming, scale, bias]);
+  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: [
+        "Scale:",
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _core.NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: scale,
+            onChange: (e) => setScale(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { children: [
+        "Bias:",
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _core.NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: bias,
+            onChange: (e) => setBias(Number(e)),
+            step: 0.1
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_scale_bias_node_default = NoiseScaleBiasNode;
+
+// src/nodes/modifiers/noise-terrace-node.tsx
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function NoiseTerraceNode({ id, selected, data, type }) {
+  const incoming = _hooks.useIncomingComputedData.call(void 0, id);
+  const updateNodeData = _hooks.useUpdateNodeData.call(void 0, );
+  const updateComputedData = _hooks.useUpdateNodeComputedData.call(void 0, );
+  const [values, setValues] = _react.useState.call(void 0, []);
+  const form = _form.useForm.call(void 0, {
+    mode: "uncontrolled",
+    initialValues: {
+      points: []
+    },
+    validateInputOnChange: [`points.${_form.FORM_INDEX}.input`],
+    clearInputErrorOnChange: true,
+    onValuesChange: _react.useCallback.call(void 0, (values2) => {
+      if (form.isValid()) {
+        const points = values2.points.map((v) => v.value);
+        setValues(points);
+        updateNodeData(id, { points });
+      }
+      form.validate();
+    }, [])
+  });
+  _react.useEffect.call(void 0, () => {
+    const points = _optionalChain([data, 'access', _12 => _12.points, 'optionalAccess', _13 => _13.length]) ? data.points.map((v) => ({ value: v, key: _hooks3.randomId.call(void 0, ) })) : [1, 2].map(() => ({ value: 0, key: _hooks3.randomId.call(void 0, ) }));
+    form.initialize({ points });
+  }, []);
+  _react.useEffect.call(void 0, () => {
+    if (_optionalChain([incoming, 'optionalAccess', _14 => _14.length]) && _optionalChain([values, 'optionalAccess', _15 => _15.length]) >= 2) {
+      const module = new (0, _libnoisesimplexts.Terrace)(incoming[0].module, values);
+      updateComputedData(id, { module });
+    }
+  }, [values, incoming]);
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _core.Group, { mt: "xs", children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _core.NumberInput,
+      {
+        size: "xs",
+        placeholder: "Input Value",
+        ...form.getInputProps(`points.${index}.value`),
+        step: 0.1
+      },
+      form.key(`points.${index}.value`)
+    ),
+    data.state === _abstract.NodeState.edit && values.length > 2 && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _core.ActionIcon,
+      {
+        color: "red",
+        variant: "outline",
+        size: "sm",
+        onClick: () => form.removeListItem("points", index),
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _iconsreact.IconX, { size: "1rem" })
+      }
+    )
+  ] }, item.key));
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _layout.NodeContainer, { id, selected, type, data, children: [
+    fields,
+    data.state === _abstract.NodeState.edit && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _core.Space, { h: 10 }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _core.Button,
+        {
+          variant: "outline",
+          size: "xs",
+          fullWidth: true,
+          onClick: () => form.insertListItem("points", { value: 0, key: _hooks3.randomId.call(void 0, ) }),
+          children: "Add control point"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_terrace_node_default = NoiseTerraceNode;
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.noise_abs_node_default = noise_abs_node_default; exports.noise_clamp_node_default = noise_clamp_node_default; exports.NoiseCombineType = NoiseCombineType; exports.noiseCombineModuleMap = noiseCombineModuleMap; exports.noise_combine_node_default = noise_combine_node_default; exports.noise_curve_node_default = noise_curve_node_default; exports.noise_exponent_node_default = noise_exponent_node_default; exports.noise_invert_node_default = noise_invert_node_default; exports.noise_normalize_node_default = noise_normalize_node_default; exports.noise_scale_bias_node_default = noise_scale_bias_node_default; exports.noise_terrace_node_default = noise_terrace_node_default;

package/dist/chunk-UNMRBZ5X.cjs

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/modules/normalize-noise-module.ts
+var _libnoisesimplexts = require('libnoise-simplex-ts');
+var NormalizeNoiseModule = class extends _libnoisesimplexts.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);
+}
+
+
+
+exports.NormalizeNoiseModule = NormalizeNoiseModule;

package/dist/chunk-WOJTKQKO.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/modules/index.cjs

@@ -1,44 +1,6 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/modules/index.ts
-var modules_exports = {};
-__export(modules_exports, {
-  NormalizeNoiseModule: () => NormalizeNoiseModule
-});
-module.exports = __toCommonJS(modules_exports);
+var _chunkUNMRBZ5Xcjs = require('../chunk-UNMRBZ5X.cjs');
 
-// src/modules/normalize-noise-module.ts
-var import_libnoise_simplex_ts = require("libnoise-simplex-ts");
-var NormalizeNoiseModule = class extends import_libnoise_simplex_ts.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);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  NormalizeNoiseModule
-});
+
+exports.NormalizeNoiseModule = _chunkUNMRBZ5Xcjs.NormalizeNoiseModule;

package/dist/modules/index.js

@@ -1,18 +1,6 @@
-// src/modules/normalize-noise-module.ts
-import { ModifierModule } from "libnoise-simplex-ts";
-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);
-}
+import {
+  NormalizeNoiseModule
+} from "../chunk-SGHEOOLW.js";
 export {
   NormalizeNoiseModule
 };