@awesome-flow/noise 0.1.0

package/dist/nodes/modifiers/index.cjs

@@ -0,0 +1,1593 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = __commonJS({
+  "../../node_modules/fast-deep-equal/index.js"(exports2, module2) {
+    "use strict";
+    module2.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/nodes/modifiers/index.ts
+var modifiers_exports = {};
+__export(modifiers_exports, {
+  NoiseAbsNode: () => noise_abs_node_default,
+  NoiseClampNode: () => noise_clamp_node_default,
+  NoiseCombineNode: () => noise_combine_node_default,
+  NoiseCurveNode: () => noise_curve_node_default,
+  NoiseExponentNode: () => noise_exponent_node_default,
+  NoiseInvertNode: () => noise_invert_node_default,
+  NoiseNormalizeNode: () => noise_normalize_node_default,
+  NoiseScaleBiasNode: () => noise_scale_bias_node_default,
+  NoiseTerraceNode: () => noise_terrace_node_default,
+  VariableCombineNode: () => variable_combine_node_default
+});
+module.exports = __toCommonJS(modifiers_exports);
+
+// src/nodes/modifiers/noise-abs-node.tsx
+var import_layout = require("@awesome-flow/core/layout");
+var import_react = require("react");
+var import_hooks = require("@awesome-flow/core/hooks");
+var import_modifier = require("libnoise-ts/module/modifier");
+var import_jsx_runtime = require("react/jsx-runtime");
+function NoiseAbsNode({ id, selected, data, type }) {
+  const incoming = (0, import_hooks.useIncomingComputedData)(id);
+  const updateComputedData = (0, import_hooks.useUpdateNodeComputedData)();
+  (0, import_react.useEffect)(() => {
+    if (incoming?.length > 0) {
+      const module2 = new import_modifier.Abs(incoming[0].module);
+      updateComputedData(id, { module: module2 });
+    }
+  }, [incoming]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_layout.NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_layout.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" }) });
+}
+var noise_abs_node_default = NoiseAbsNode;
+
+// src/nodes/modifiers/noise-clamp-node.tsx
+var import_layout2 = require("@awesome-flow/core/layout");
+var import_react2 = require("react");
+var import_core = require("@mantine/core");
+var import_hooks2 = require("@awesome-flow/core/hooks");
+var import_modifier2 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function NoiseClampNode({ id, selected, data, type }) {
+  const [lowerBound, setLowerBound] = (0, import_react2.useState)(data.lowerBound);
+  const [upperBound, setUpperBound] = (0, import_react2.useState)(data.upperBound);
+  const incoming = (0, import_hooks2.useIncomingComputedData)(id);
+  const updateNodeData = (0, import_hooks2.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks2.useUpdateNodeComputedData)();
+  (0, import_react2.useEffect)(() => {
+    if (incoming?.length) {
+      const module2 = new import_modifier2.Clamp(incoming[0].module, lowerBound, upperBound);
+      updateComputedData(id, { module: module2 });
+    }
+    updateNodeData(id, { lowerBound, upperBound });
+  }, [incoming, lowerBound, upperBound]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_layout2.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_core.Stack, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_core.Group, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_core.NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: lowerBound,
+          onChange: (e) => setLowerBound(Number(e)),
+          step: 0.1
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_core.NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: upperBound,
+          onChange: (e) => setUpperBound(Number(e)),
+          step: 0.1
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_layout2.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_clamp_node_default = NoiseClampNode;
+
+// src/nodes/modifiers/noise-combine-node.tsx
+var import_layout3 = require("@awesome-flow/core/layout");
+var import_react3 = require("react");
+var import_hooks3 = require("@awesome-flow/core/hooks");
+var import_icons_react = require("@tabler/icons-react");
+
+// src/abstract/operations.ts
+var import_combiner = require("libnoise-ts/module/combiner");
+var noiseCombineModuleMap = {
+  ["add" /* add */]: import_combiner.Add,
+  ["max" /* max */]: import_combiner.Max,
+  ["min" /* min */]: import_combiner.Min,
+  ["multiply" /* multiply */]: import_combiner.Multiply,
+  ["power" /* power */]: import_combiner.Power
+};
+
+// src/nodes/modifiers/noise-combine-node.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var options = {
+  add: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_icons_react.IconPlus, {}),
+  min: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_icons_react.IconChevronLeft, {}),
+  max: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_icons_react.IconChevronRight, {}),
+  multiply: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_icons_react.IconAsterisk, {}),
+  power: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_icons_react.IconChevronUp, {})
+};
+function NoiseCombineNode({ id, selected, data, type }) {
+  const updateNodeData = (0, import_hooks3.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks3.useUpdateNodeComputedData)();
+  const incoming = (0, import_hooks3.useIncomingComputedData)(id);
+  (0, import_react3.useEffect)(() => {
+    const ModuleFactory = noiseCombineModuleMap[data.operation];
+    if (incoming?.length > 1) {
+      const module2 = new ModuleFactory(incoming[0].module, incoming[1].module);
+      updateComputedData(id, { module: module2 });
+    }
+  }, [data.operation, incoming]);
+  const onChange = (0, import_react3.useCallback)((operation) => {
+    updateNodeData(id, { operation });
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_layout3.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_layout3.NodeCombobox, { options, selected: data.operation, onChange }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_layout3.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_combine_node_default = NoiseCombineNode;
+
+// src/nodes/modifiers/noise-curve-node.tsx
+var import_layout4 = require("@awesome-flow/core/layout");
+var import_core2 = require("@mantine/core");
+var import_hooks4 = require("@awesome-flow/core/hooks");
+
+// ../../node_modules/@mantine/form/esm/use-form.mjs
+var import_react10 = require("react");
+
+// ../../node_modules/@mantine/form/esm/actions/actions.mjs
+var import_react4 = require("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" ? import_react4.useLayoutEffect : import_react4.useEffect;
+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
+var import_react5 = require("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] = (0, import_react5.useState)(filterErrors(initialErrors));
+  const setErrors = (0, import_react5.useCallback)((errors) => {
+    setErrorsState(
+      (current) => filterErrors(typeof errors === "function" ? errors(current) : errors)
+    );
+  }, []);
+  const clearErrors = (0, import_react5.useCallback)(() => setErrorsState({}), []);
+  const clearFieldError = (0, import_react5.useCallback)(
+    (path) => {
+      if (errorsState[path] === void 0) {
+        return;
+      }
+      setErrors((current) => {
+        const errors = { ...current };
+        delete errors[path];
+        return errors;
+      });
+    },
+    [errorsState]
+  );
+  const setFieldError = (0, import_react5.useCallback)(
+    (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
+var import_react6 = require("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 = (0, import_react6.useCallback)((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 = (0, import_react6.useCallback)((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 = (0, import_react6.useCallback)((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_react7 = require("react");
+var import_fast_deep_equal = __toESM(require_fast_deep_equal(), 1);
+
+// ../../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] = (0, import_react7.useState)(initialTouched);
+  const [dirtyState, setDirtyState] = (0, import_react7.useState)(initialDirty);
+  const touchedRef = (0, import_react7.useRef)(initialTouched);
+  const dirtyRef = (0, import_react7.useRef)(initialDirty);
+  const setTouched = (0, import_react7.useCallback)((values) => {
+    const resolvedValues = typeof values === "function" ? values(touchedRef.current) : values;
+    touchedRef.current = resolvedValues;
+    if (mode === "controlled") {
+      setTouchedState(resolvedValues);
+    }
+  }, []);
+  const setDirty = (0, import_react7.useCallback)((values) => {
+    const resolvedValues = typeof values === "function" ? values(dirtyRef.current) : values;
+    dirtyRef.current = resolvedValues;
+    if (mode === "controlled") {
+      setDirtyState(resolvedValues);
+    }
+  }, []);
+  const resetTouched = (0, import_react7.useCallback)(() => setTouched({}), []);
+  const resetDirty = (values) => {
+    const newSnapshot = values ? { ...values, ...$values.refValues.current } : $values.refValues.current;
+    $values.setValuesSnapshot(newSnapshot);
+    setDirty({});
+  };
+  const setFieldTouched = (0, import_react7.useCallback)((path, touched) => {
+    setTouched((currentTouched) => {
+      if (getStatus(currentTouched, path) === touched) {
+        return currentTouched;
+      }
+      return { ...currentTouched, [path]: touched };
+    });
+  }, []);
+  const setFieldDirty = (0, import_react7.useCallback)((path, dirty) => {
+    setDirty((currentDirty) => {
+      if (getStatus(currentDirty, path) === dirty) {
+        return currentDirty;
+      }
+      return { ...currentDirty, [path]: dirty };
+    });
+  }, []);
+  const isTouched = (0, import_react7.useCallback)(
+    (path) => getStatus(touchedRef.current, path),
+    []
+  );
+  const clearFieldDirty = (0, import_react7.useCallback)(
+    (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 = (0, import_react7.useCallback)((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 = (0, import_react7.useCallback)(() => dirtyRef.current, []);
+  const getTouched = (0, import_react7.useCallback)(() => 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
+var import_react8 = require("react");
+function useFormValues({
+  initialValues,
+  onValuesChange,
+  mode
+}) {
+  const initialized = (0, import_react8.useRef)(false);
+  const [stateValues, setStateValues] = (0, import_react8.useState)(initialValues || {});
+  const refValues = (0, import_react8.useRef)(stateValues);
+  const valuesSnapshot = (0, import_react8.useRef)(stateValues);
+  const setValues = (0, import_react8.useCallback)(
+    ({
+      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 = (0, import_react8.useCallback)((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 = (0, import_react8.useCallback)((payload) => {
+    valuesSnapshot.current = payload;
+  }, []);
+  const initialize = (0, import_react8.useCallback)((values, onInitialize) => {
+    if (!initialized.current) {
+      initialized.current = true;
+      setValues({ values, updateState: mode === "controlled" });
+      setValuesSnapshot(values);
+      onInitialize();
+    }
+  }, []);
+  const resetValues = (0, import_react8.useCallback)(() => {
+    setValues({
+      values: valuesSnapshot.current,
+      updateState: true,
+      mergeWithPreviousValues: false
+    });
+  }, []);
+  const getValues = (0, import_react8.useCallback)(() => 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
+var import_react9 = require("react");
+function useFormWatch({
+  $status
+}) {
+  const subscribers = (0, import_react9.useRef)(
+    {}
+  );
+  const watch = (0, import_react9.useCallback)((path, callback) => {
+    (0, import_react9.useEffect)(() => {
+      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 = (0, import_react9.useCallback)((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] = (0, import_react10.useState)(0);
+  const [fieldKeys, setFieldKeys] = (0, import_react10.useState)({});
+  const reset = (0, import_react10.useCallback)(() => {
+    $values.resetValues();
+    $errors.clearErrors();
+    $status.resetDirty();
+    $status.resetTouched();
+    mode === "uncontrolled" && setFormKey((key2) => key2 + 1);
+  }, []);
+  const initialize = (0, import_react10.useCallback)((values) => {
+    $values.initialize(values, () => mode === "uncontrolled" && setFormKey((key2) => key2 + 1));
+  }, []);
+  const setFieldValue = (0, import_react10.useCallback)(
+    (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 = (0, import_react10.useCallback)(
+    (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 = (0, import_react10.useCallback)(() => {
+    const results = validateValues(rules, $values.refValues.current);
+    $errors.setErrors(results.errors);
+    return results;
+  }, [rules]);
+  const validateField = (0, import_react10.useCallback)(
+    (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 = (0, import_react10.useCallback)((event) => {
+    event.preventDefault();
+    reset();
+  }, []);
+  const isValid = (0, import_react10.useCallback)(
+    (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
+var import_react11 = require("react");
+var import_modifier3 = require("libnoise-ts/module/modifier");
+var import_util = require("libnoise-ts/util");
+var import_icons_react2 = require("@tabler/icons-react");
+var import_hooks5 = require("@mantine/hooks");
+var import_abstract = require("@awesome-flow/core/abstract");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function NoiseCurveNode({ id, selected, data, type }) {
+  const incoming = (0, import_hooks4.useIncomingComputedData)(id);
+  const updateNodeData = (0, import_hooks4.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks4.useUpdateNodeComputedData)();
+  const [values, setValues] = (0, import_react11.useState)([]);
+  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: (0, import_react11.useCallback)((values2) => {
+      if (form.isValid()) {
+        const points = values2.points.map((v) => ({ input: v.input, output: v.output }));
+        setValues(points);
+        updateNodeData(id, { points });
+      }
+      form.validate();
+    }, [])
+  });
+  (0, import_react11.useEffect)(() => {
+    const points = data.points?.length ? data.points.map((v) => ({ input: v.input, output: v.output, key: (0, import_hooks5.randomId)() })) : [1, 2, 3, 4].map(() => ({ input: 0, output: 0, key: (0, import_hooks5.randomId)() }));
+    form.initialize({ points });
+  }, []);
+  (0, import_react11.useEffect)(() => {
+    if (incoming?.length && values?.length >= 4) {
+      const module2 = new import_modifier3.Curve(
+        incoming[0].module,
+        values.map((p) => new import_util.Tuple(p.input, p.output))
+      );
+      updateComputedData(id, { module: module2 });
+    }
+  }, [values, incoming]);
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_core2.Group, { mt: "xs", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      import_core2.NumberInput,
+      {
+        size: "xs",
+        w: 100,
+        placeholder: "Input Value",
+        ...form.getInputProps(`points.${index}.input`),
+        step: 0.1
+      },
+      form.key(`points.${index}.input`)
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      import_core2.NumberInput,
+      {
+        size: "xs",
+        w: 100,
+        placeholder: "Output Value",
+        ...form.getInputProps(`points.${index}.output`),
+        step: 0.1
+      },
+      form.key(`points.${index}.output`)
+    ),
+    data.state === import_abstract.NodeState.edit && values.length > 4 && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      import_core2.ActionIcon,
+      {
+        color: "red",
+        variant: "outline",
+        size: "sm",
+        onClick: () => form.removeListItem("points", index),
+        children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_icons_react2.IconX, { size: "1rem" })
+      }
+    )
+  ] }, item.key));
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_layout4.NodeContainer, { id, selected, type, data, children: [
+    fields,
+    data.state === import_abstract.NodeState.edit && /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_core2.Space, { h: 10 }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        import_core2.Button,
+        {
+          variant: "outline",
+          size: "xs",
+          fullWidth: true,
+          onClick: () => form.insertListItem("points", { input: 0, output: 0, key: (0, import_hooks5.randomId)() }),
+          children: "Add control point"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_layout4.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_curve_node_default = NoiseCurveNode;
+
+// src/nodes/modifiers/noise-exponent-node.tsx
+var import_layout5 = require("@awesome-flow/core/layout");
+var import_react12 = require("react");
+var import_core3 = require("@mantine/core");
+var import_hooks6 = require("@awesome-flow/core/hooks");
+var import_modifier4 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function NoiseExponentNode({ id, selected, data, type }) {
+  const [exponent, setExponent] = (0, import_react12.useState)(data.exponent);
+  const incoming = (0, import_hooks6.useIncomingComputedData)(id);
+  const updateNodeData = (0, import_hooks6.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks6.useUpdateNodeComputedData)();
+  (0, import_react12.useEffect)(() => {
+    if (incoming?.length > 0) {
+      const module2 = new import_modifier4.Exponent(incoming[0].module, exponent);
+      updateComputedData(id, { module: module2 });
+    }
+    updateNodeData(id, { exponent });
+  }, [incoming, exponent]);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_layout5.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_core3.Stack, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_core3.Group, { children: [
+      "Exponent:",
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        import_core3.NumberInput,
+        {
+          size: "xs",
+          value: exponent,
+          onChange: (e) => setExponent(Number(e)),
+          step: 0.1
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_layout5.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_exponent_node_default = NoiseExponentNode;
+
+// src/nodes/modifiers/noise-invert-node.tsx
+var import_layout6 = require("@awesome-flow/core/layout");
+var import_react13 = require("react");
+var import_hooks7 = require("@awesome-flow/core/hooks");
+var import_modifier5 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function NoiseInvertNode({ id, selected, data, type }) {
+  const incoming = (0, import_hooks7.useIncomingComputedData)(id);
+  const updateComputedData = (0, import_hooks7.useUpdateNodeComputedData)();
+  (0, import_react13.useEffect)(() => {
+    if (incoming?.length > 0) {
+      const module2 = new import_modifier5.Invert(incoming[0].module);
+      updateComputedData(id, { module: module2 });
+    }
+  }, [incoming]);
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_layout6.NodeContainer, { id, selected, data, type, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_layout6.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" }) });
+}
+var noise_invert_node_default = NoiseInvertNode;
+
+// src/nodes/modifiers/noise-normalize-node.tsx
+var import_layout7 = require("@awesome-flow/core/layout");
+var import_react14 = require("react");
+var import_core4 = require("@mantine/core");
+var import_hooks8 = require("@awesome-flow/core/hooks");
+
+// src/modules/normalize-noise-module.ts
+var import_modifier6 = __toESM(require("libnoise-ts/module/modifier"), 1);
+var NormalizeNoiseModule = class extends import_modifier6.default {
+  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
+var import_jsx_runtime7 = require("react/jsx-runtime");
+function NoiseNormalizeNode({ id, selected, data, type }) {
+  const [intervalStart, setIntervalStart] = (0, import_react14.useState)(data.intervalStart);
+  const [intervalEnd, setIntervalEnd] = (0, import_react14.useState)(data.intervalEnd);
+  const incoming = (0, import_hooks8.useIncomingComputedData)(id);
+  const updateNodeData = (0, import_hooks8.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks8.useUpdateNodeComputedData)();
+  (0, import_react14.useEffect)(() => {
+    if (incoming?.length) {
+      const source = incoming[0].module;
+      const module2 = new NormalizeNoiseModule(source, intervalStart, intervalEnd);
+      updateComputedData(id, { module: module2 });
+    }
+    updateNodeData(id, { intervalStart, intervalEnd });
+  }, [incoming, intervalStart, intervalEnd]);
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_layout7.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_core4.Stack, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_core4.Group, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+        import_core4.NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: intervalStart,
+          onChange: (e) => setIntervalStart(Number(e))
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+        import_core4.NumberInput,
+        {
+          size: "xs",
+          w: 100,
+          value: intervalEnd,
+          onChange: (e) => setIntervalEnd(Number(e))
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_layout7.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_normalize_node_default = NoiseNormalizeNode;
+
+// src/nodes/modifiers/noise-scale-bias-node.tsx
+var import_layout8 = require("@awesome-flow/core/layout");
+var import_react15 = require("react");
+var import_core5 = require("@mantine/core");
+var import_hooks9 = require("@awesome-flow/core/hooks");
+var import_modifier7 = require("libnoise-ts/module/modifier");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function NoiseScaleBiasNode({ id, selected, data, type }) {
+  const [scale, setScale] = (0, import_react15.useState)(data.scale);
+  const [bias, setBias] = (0, import_react15.useState)(data.bias);
+  const incoming = (0, import_hooks9.useIncomingComputedData)(id);
+  const updateNodeData = (0, import_hooks9.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks9.useUpdateNodeComputedData)();
+  (0, import_react15.useEffect)(() => {
+    if (incoming?.length > 0) {
+      const module2 = new import_modifier7.ScaleBias(incoming[0].module, scale, bias);
+      updateComputedData(id, { module: module2 });
+    }
+    updateNodeData(id, { scale, bias });
+  }, [incoming, scale, bias]);
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_layout8.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_core5.Stack, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_core5.Group, { children: [
+        "Scale:",
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          import_core5.NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: scale,
+            onChange: (e) => setScale(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_core5.Group, { children: [
+        "Bias:",
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          import_core5.NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: bias,
+            onChange: (e) => setBias(Number(e)),
+            step: 0.1
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_layout8.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_scale_bias_node_default = NoiseScaleBiasNode;
+
+// src/nodes/modifiers/noise-terrace-node.tsx
+var import_layout9 = require("@awesome-flow/core/layout");
+var import_core6 = require("@mantine/core");
+var import_hooks10 = require("@awesome-flow/core/hooks");
+var import_react16 = require("react");
+var import_modifier8 = require("libnoise-ts/module/modifier");
+var import_icons_react3 = require("@tabler/icons-react");
+var import_hooks11 = require("@mantine/hooks");
+var import_abstract2 = require("@awesome-flow/core/abstract");
+var import_jsx_runtime9 = require("react/jsx-runtime");
+function NoiseTerraceNode({ id, selected, data, type }) {
+  const incoming = (0, import_hooks10.useIncomingComputedData)(id);
+  const updateNodeData = (0, import_hooks10.useUpdateNodeData)();
+  const updateComputedData = (0, import_hooks10.useUpdateNodeComputedData)();
+  const [values, setValues] = (0, import_react16.useState)([]);
+  const form = useForm({
+    mode: "uncontrolled",
+    initialValues: {
+      points: []
+    },
+    validateInputOnChange: [`points.${FORM_INDEX}.input`],
+    clearInputErrorOnChange: true,
+    onValuesChange: (0, import_react16.useCallback)((values2) => {
+      if (form.isValid()) {
+        const points = values2.points.map((v) => v.value);
+        setValues(points);
+        updateNodeData(id, { points });
+      }
+      form.validate();
+    }, [])
+  });
+  (0, import_react16.useEffect)(() => {
+    const points = data.points?.length ? data.points.map((v) => ({ value: v, key: (0, import_hooks11.randomId)() })) : [1, 2].map(() => ({ value: 0, key: (0, import_hooks11.randomId)() }));
+    form.initialize({ points });
+  }, []);
+  (0, import_react16.useEffect)(() => {
+    if (incoming?.length && values?.length >= 2) {
+      const module2 = new import_modifier8.Terrace(incoming[0].module, values);
+      updateComputedData(id, { module: module2 });
+    }
+  }, [values, incoming]);
+  const fields = form.getValues().points.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_core6.Group, { mt: "xs", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+      import_core6.NumberInput,
+      {
+        size: "xs",
+        placeholder: "Input Value",
+        ...form.getInputProps(`points.${index}.value`),
+        step: 0.1
+      },
+      form.key(`points.${index}.value`)
+    ),
+    data.state === import_abstract2.NodeState.edit && values.length > 2 && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+      import_core6.ActionIcon,
+      {
+        color: "red",
+        variant: "outline",
+        size: "sm",
+        onClick: () => form.removeListItem("points", index),
+        children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_icons_react3.IconX, { size: "1rem" })
+      }
+    )
+  ] }, item.key));
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_layout9.NodeContainer, { id, selected, type, data, children: [
+    fields,
+    data.state === import_abstract2.NodeState.edit && /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_core6.Space, { h: 10 }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+        import_core6.Button,
+        {
+          variant: "outline",
+          size: "xs",
+          fullWidth: true,
+          onClick: () => form.insertListItem("points", { value: 0, key: (0, import_hooks11.randomId)() }),
+          children: "Add control point"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_layout9.NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_terrace_node_default = NoiseTerraceNode;
+
+// src/nodes/modifiers/variable-combine-node.tsx
+var import_layout10 = require("@awesome-flow/core/layout");
+var import_react18 = require("react");
+var import_hooks13 = require("@awesome-flow/core/hooks");
+var import_icons_react4 = require("@tabler/icons-react");
+
+// src/layout/node-value-input.tsx
+var import_core7 = require("@mantine/core");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+function NodeValueInput({ value, disabled, step, onChange }) {
+  if (value === void 0 || value === null) {
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_jsx_runtime10.Fragment, {});
+  }
+  switch (typeof value) {
+    case "boolean": {
+      return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+        import_core7.Switch,
+        {
+          checked: value,
+          disabled,
+          onChange: (e) => onChange(e.currentTarget.checked)
+        }
+      );
+    }
+    case "number": {
+      return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_core7.NumberInput, { value, disabled, step, onChange: (e) => onChange(e) });
+    }
+    case "string": {
+      return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+        import_core7.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
+var import_jsx_runtime11 = require("react/jsx-runtime");
+
+// src/layout/node-property-variables.tsx
+var import_hooks12 = require("@awesome-flow/core/hooks");
+var import_react17 = require("react");
+var import_core8 = require("@mantine/core");
+var import_utils = require("@awesome-flow/core/utils");
+var import_abstract3 = require("@awesome-flow/core/abstract");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+
+// src/nodes/modifiers/variable-combine-node.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var options2 = {
+  add: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_icons_react4.IconPlus, {}),
+  divide: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_icons_react4.IconDivide, {}),
+  min: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_icons_react4.IconChevronLeft, {}),
+  max: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_icons_react4.IconChevronRight, {}),
+  multiply: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_icons_react4.IconAsterisk, {}),
+  power: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_icons_react4.IconChevronUp, {})
+};
+function VariableCombineNode({
+  id,
+  selected,
+  data,
+  type
+}) {
+  const [operation, setOperation] = (0, import_react18.useState)(data.operation);
+  const [value, setValue] = (0, import_react18.useState)(data.value);
+  const updateNodeData = (0, import_hooks13.useUpdateNodeData)();
+  const incoming = (0, import_hooks13.useIncomingNodeData)(id);
+  (0, import_react18.useEffect)(() => {
+    if (incoming?.length > 1) {
+      const result = getOperationResult(operation, incoming[0].value, incoming[1].value);
+      setValue(result);
+      updateNodeData(id, { value: result });
+    }
+  }, [operation, incoming]);
+  const onChange = (0, import_react18.useCallback)((op) => {
+    updateNodeData(id, { operation: op });
+    setOperation(op);
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_layout10.NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_layout10.NodeCombobox, { options: options2, selected: operation, onChange }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(node_value_input_default, { value, onChange: () => {
+    }, disabled: true }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_layout10.NodeTrackConnections, { 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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoiseAbsNode,
+  NoiseClampNode,
+  NoiseCombineNode,
+  NoiseCurveNode,
+  NoiseExponentNode,
+  NoiseInvertNode,
+  NoiseNormalizeNode,
+  NoiseScaleBiasNode,
+  NoiseTerraceNode,
+  VariableCombineNode
+});
+//# sourceMappingURL=index.cjs.map