@awesome-flow/noise 0.9.4 → 0.10.0

package/dist/index-B09XEo3I.d.cts

@@ -0,0 +1,496 @@
+import { a as NoiseHandleType, i as DisplacementModuleHandle, n as ModuleGroupNodeTemplateFactory, o as NoiseSourceControlHandle, r as DisplacementHandle } from "./module-group-template-CE4b0J24.cjs";
+import { C as NodeTranslatePointNoiseData, D as NoiseModuleContext, E as NoiseGeneratorContext, S as NodeTerraceNoiseData, T as NodeVoronoiNoiseData, _ as NodeRotatePointNoiseData, b as NodeSelectNoiseData, c as NodeConstNoiseData, d as NodeExponentNoiseData, f as NodeFBMNoiseData, g as NodeRidgedNoiseData, h as NodePositionData, i as ComputedPositionsData, l as NodeCurveNoiseData, m as NodeNormalizeNoiseData, n as ComputedNoiseData, o as NodeClampNoiseData, p as NodeGridData, r as ComputedNoiseTextureData, s as NodeCombineNoiseData, t as ComputedModuleData, u as NodeCylindersNoiseData, v as NodeScaleBiasNoiseData, w as NodeTurbulenceNoiseData, x as NodeSpheresNoiseData, y as NodeScalePointNoiseData } from "./node-props-CoXzPLD6.cjs";
+import { b as NoiseBillowNodeTemplateFactory, c as NoiseSpheresNodeTemplateFactory, f as NoisePerlinNodeTemplateFactory, g as NoiseConstNodeTemplateFactory, i as PositionConstNodeTemplateFactory, m as NoiseCylindersNodeTemplateFactory, n as PositionGridNodeTemplateFactory, o as NoiseVoronoiNodeTemplateFactory, u as NoiseRidgedMultiNodeTemplateFactory, v as NoiseCheckerboardNodeTemplateFactory } from "./position-grid-template-Da_-z-NN.cjs";
+import { t as NormalizeNoiseModule } from "./index-BbHM1kxc.cjs";
+import * as _awesome_flow_core_abstract0 from "@awesome-flow/core/abstract";
+import { BasicNodeData, CoreHandleType, ITemplateFactory, NodeTemplate } from "@awesome-flow/core/abstract";
+import { Blend, CombinerModule, Displace, Exponent, Invert, ModifierModule, RotatePoint, ScaleBias, ScalePoint, Select, Terrace, TranslatePoint, Turbulence } from "libnoise-simplex-ts";
+import * as _xyflow_react0 from "@xyflow/react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react from "react";
+import * as _awesome_ecs_abstract_pipelines0 from "@awesome-ecs/abstract/pipelines";
+import { IPipeline } from "@awesome-ecs/abstract/pipelines";
+import { NodeContext as NodeContext$1 } from "@awesome-flow/core/abstract/pipelines";
+import { NodeVariablePropertyContext } from "@awesome-flow/core/templates";
+
+//#region src/templates/modifiers/noise-abs-template.d.ts
+type NoiseAbsNodeContext = NodeContext$1<BasicNodeData, ComputedModuleData<ModifierModule>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseAbsNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<BasicNodeData>;
+  readonly pipeline?: IPipeline<NoiseAbsNodeContext>;
+}
+//#endregion
+//#region src/templates/modifiers/noise-clamp-template.d.ts
+type NoiseClampNodeContext = NodeContext$1<NodeClampNoiseData, ComputedModuleData<ModifierModule>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseClampNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeClampNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeClampNoiseData, ComputedModuleData<ModifierModule>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/modifiers/noise-combine-template.d.ts
+type NoiseCombineNodeContext = NodeContext$1<NodeCombineNoiseData, ComputedModuleData<CombinerModule>, {
+  [NoiseHandleType.module]: NoiseModuleContext[];
+}>;
+declare class NoiseCombineNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeCombineNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeCombineNoiseData, ComputedModuleData<CombinerModule>, {
+    module: NoiseModuleContext[];
+  }>>;
+}
+//#endregion
+//#region src/templates/modifiers/noise-curve-template.d.ts
+type NoiseCurveNodeContext = NodeContext$1<NodeCurveNoiseData, ComputedModuleData<ModifierModule>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseCurveNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeCurveNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeCurveNoiseData, ComputedModuleData<ModifierModule>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/modifiers/noise-exponent-template.d.ts
+type NoiseExponentNodeContext = NodeContext$1<NodeExponentNoiseData, ComputedModuleData<Exponent>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseExponentNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeExponentNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeExponentNoiseData, ComputedModuleData<Exponent>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/modifiers/noise-invert-template.d.ts
+type NoiseInvertNodeContext = NodeContext$1<BasicNodeData, ComputedModuleData<Invert>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseInvertNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<BasicNodeData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<BasicNodeData, ComputedModuleData<Invert>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/modifiers/noise-normalize-template.d.ts
+type NoiseNormalizeNodeContext = NodeContext$1<NodeNormalizeNoiseData, ComputedModuleData<NormalizeNoiseModule>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseNormalizeNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeNormalizeNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeNormalizeNoiseData, ComputedModuleData<NormalizeNoiseModule>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/modifiers/noise-scalebias-template.d.ts
+type NoiseScaleBiasNodeContext = NodeContext$1<NodeScaleBiasNoiseData, ComputedModuleData<ScaleBias>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseScaleBiasNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeScaleBiasNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeScaleBiasNoiseData, ComputedModuleData<ScaleBias>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/modifiers/noise-terrace-template.d.ts
+type NoiseTerraceNodeContext = NodeContext$1<NodeTerraceNoiseData, ComputedModuleData<Terrace>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseTerraceNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeTerraceNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeTerraceNoiseData, ComputedModuleData<Terrace>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/output/noise-logger-template.d.ts
+type NoiseLoggerContext = NodeContext$1<BasicNodeData, never, {
+  [NoiseHandleType.noise]: NodeContext$1<any, ComputedNoiseData>[];
+}>;
+declare class NoiseLoggerNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<BasicNodeData>;
+}
+//#endregion
+//#region src/templates/output/noise-output-template.d.ts
+type NoiseOutputContext = NodeContext$1<BasicNodeData, ComputedNoiseData, {
+  [NoiseHandleType.position]: NodeContext$1<any, ComputedPositionsData>[];
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseOutputNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<BasicNodeData>;
+  readonly pipeline?: IPipeline<NoiseOutputContext>;
+}
+//#endregion
+//#region src/templates/output/noise-texture-data-template.d.ts
+type NoiseTextureDataContext = NodeContext$1<BasicNodeData, ComputedNoiseTextureData, {
+  [NoiseHandleType.noise]: NodeContext$1<any, ComputedNoiseData>;
+}>;
+declare class NoiseTextureDataTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<BasicNodeData>;
+  readonly pipeline?: IPipeline<NoiseTextureDataContext>;
+}
+//#endregion
+//#region src/templates/output/position-logger-template.d.ts
+type PositionLoggerNodeContext = NodeContext$1<BasicNodeData, never, {
+  [NoiseNodeType.position]: NodeContext$1<any, ComputedPositionsData>[];
+}>;
+declare class PositionLoggerNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<BasicNodeData>;
+}
+//#endregion
+//#region src/templates/selectors/noise-blend-template.d.ts
+type NoiseBlendNodeContext = NodeContext$1<BasicNodeData, ComputedModuleData<Blend>, {
+  [NoiseSourceControlHandle.source]: NoiseModuleContext[];
+  [NoiseSourceControlHandle.control]: NoiseModuleContext;
+}>;
+declare class NoiseBlendNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<BasicNodeData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<BasicNodeData, ComputedModuleData<Blend>, {
+    source: NoiseModuleContext[];
+    control: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/selectors/noise-select-template.d.ts
+type NoiseSelectNodeContext = NodeContext$1<NodeSelectNoiseData, ComputedModuleData<Select>, {
+  [NoiseSourceControlHandle.source]: NoiseModuleContext[];
+  [NoiseSourceControlHandle.control]: NoiseModuleContext;
+}>;
+declare class NoiseSelectNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeSelectNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeSelectNoiseData, ComputedModuleData<Select>, {
+    source: NoiseModuleContext[];
+    control: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/transformers/noise-displace-template.d.ts
+type NoiseDisplaceNodeContext = NodeContext$1<BasicNodeData, ComputedModuleData<Displace>, {
+  [DisplacementHandle.sourceModule]: NoiseModuleContext;
+  [DisplacementHandle.xModule]: NoiseModuleContext;
+  [DisplacementHandle.yModule]: NoiseModuleContext;
+  [DisplacementHandle.zModule]: NoiseModuleContext;
+}>;
+declare class NoiseDisplaceNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<BasicNodeData, Omit<DisplacementModuleHandle, 'handleId'>>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<BasicNodeData, ComputedModuleData<Displace>, {
+    source: NoiseModuleContext;
+    "x-module": NoiseModuleContext;
+    "y-module": NoiseModuleContext;
+    "z-module": NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/transformers/noise-rotate-point-template.d.ts
+type NoiseRotatePointNodeContext = NodeContext$1<NodeRotatePointNoiseData, ComputedModuleData<RotatePoint>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseRotatePointNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeRotatePointNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeRotatePointNoiseData, ComputedModuleData<RotatePoint>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/transformers/noise-scale-point-template.d.ts
+type NoiseScalePointNodeContext = NodeContext$1<NodeScalePointNoiseData, ComputedModuleData<ScalePoint>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseScalePointNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeScalePointNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeScalePointNoiseData, ComputedModuleData<ScalePoint>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/transformers/noise-translate-point-template.d.ts
+type NoiseTranslatePointNodeContext = NodeContext$1<NodeTranslatePointNoiseData, ComputedModuleData<TranslatePoint>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+}>;
+declare class NoiseTranslatePointNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeTranslatePointNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<NodeContext$1<NodeTranslatePointNoiseData, ComputedModuleData<TranslatePoint>, {
+    module: NoiseModuleContext;
+  }>>;
+}
+//#endregion
+//#region src/templates/transformers/noise-turbulence-template.d.ts
+type NoiseTurbulenceNodeContext = NodeContext$1<NodeTurbulenceNoiseData, ComputedModuleData<Turbulence>, {
+  [NoiseHandleType.module]: NoiseModuleContext;
+  [CoreHandleType.variableProperty]: NodeVariablePropertyContext[];
+}> & NoiseGeneratorContext<NodeTurbulenceNoiseData>;
+declare class NoiseTurbulenceNodeTemplateFactory implements ITemplateFactory {
+  readonly template: NodeTemplate<NodeTurbulenceNoiseData>;
+  readonly pipeline: _awesome_ecs_abstract_pipelines0.IPipeline<any>;
+}
+//#endregion
+//#region src/abstract/node-types.d.ts
+declare enum NoiseNodeType {
+  position = "position",
+  grid = "grid",
+  textureData = "texture-data",
+  groupModule = "group-module",
+  positionLogger = "position-logger",
+  noiseLogger = "noise-logger",
+  noiseOutput = "noise-output",
+  noiseConst = "noise-constant",
+  noiseBillow = "noise-billow",
+  noiseCheckerboard = "noise-checkerboard",
+  noiseNormalize = "noise-normalize",
+  noiseCylinders = "noise-cylinders",
+  noisePerlin = "noise-perlin",
+  noiseRidgedMulti = "noise-ridged-multi",
+  noiseSpheres = "noise-spheres",
+  noiseVoronoi = "noise-voronoi",
+  noiseCombine = "noise-combiner",
+  noiseClamp = "noise-clamp",
+  noiseAbs = "noise-abs",
+  noiseCurve = "noise-curve",
+  noiseExponent = "noise-exponent",
+  noiseInvert = "noise-invert",
+  noiseScaleBias = "noise-scale-bias",
+  noiseTerrace = "noise-terrace",
+  noiseBlend = "noise-blend",
+  noiseSelect = "noise-select",
+  noiseDisplace = "noise-displace",
+  noiseRotatePoint = "noise-rotate-point",
+  noiseScalePoint = "noise-scale-point",
+  noiseTranslatePoint = "noise-translate-point",
+  noiseTurbulence = "noise-turbulence"
+}
+declare const noiseNodeTypes: {
+  "group-module": react.MemoExoticComponent<(props: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  position: react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodePositionData>>) => react_jsx_runtime0.JSX.Element>;
+  grid: react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeGridData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-output": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "texture-data": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-logger": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "position-logger": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-constant": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeConstNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-billow": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeFBMNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-checkerboard": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-cylinders": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeCylindersNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-perlin": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeFBMNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-ridged-multi": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeRidgedNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-spheres": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeSpheresNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-voronoi": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeVoronoiNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-combiner": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeCombineNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-clamp": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeClampNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-abs": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-normalize": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeNormalizeNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-curve": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeCurveNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-exponent": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeExponentNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-invert": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-scale-bias": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeScaleBiasNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-terrace": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeTerraceNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-blend": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-select": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeSelectNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-displace": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<_awesome_flow_core_abstract0.BasicNodeData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-rotate-point": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeRotatePointNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-scale-point": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeScalePointNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-translate-point": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeTranslatePointNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+  "noise-turbulence": react.MemoExoticComponent<({
+    id,
+    selected,
+    data,
+    type
+  }: _xyflow_react0.NodeProps<_xyflow_react0.Node<NodeTurbulenceNoiseData>>) => react_jsx_runtime0.JSX.Element>;
+};
+declare const noiseNodeTemplates: {
+  "noise-output": NoiseOutputNodeTemplateFactory;
+  "noise-billow": NoiseBillowNodeTemplateFactory;
+  "noise-checkerboard": NoiseCheckerboardNodeTemplateFactory;
+  "noise-normalize": NoiseNormalizeNodeTemplateFactory;
+  "noise-logger": NoiseLoggerNodeTemplateFactory;
+  "noise-constant": NoiseConstNodeTemplateFactory;
+  position: PositionConstNodeTemplateFactory;
+  "position-logger": PositionLoggerNodeTemplateFactory;
+  grid: PositionGridNodeTemplateFactory;
+  "texture-data": NoiseTextureDataTemplateFactory;
+  "noise-cylinders": NoiseCylindersNodeTemplateFactory;
+  "noise-perlin": NoisePerlinNodeTemplateFactory;
+  "noise-ridged-multi": NoiseRidgedMultiNodeTemplateFactory;
+  "noise-spheres": NoiseSpheresNodeTemplateFactory;
+  "noise-voronoi": NoiseVoronoiNodeTemplateFactory;
+  "noise-combiner": NoiseCombineNodeTemplateFactory;
+  "noise-clamp": NoiseClampNodeTemplateFactory;
+  "noise-abs": NoiseAbsNodeTemplateFactory;
+  "noise-curve": NoiseCurveNodeTemplateFactory;
+  "noise-exponent": NoiseExponentNodeTemplateFactory;
+  "noise-invert": NoiseInvertNodeTemplateFactory;
+  "noise-scale-bias": NoiseScaleBiasNodeTemplateFactory;
+  "noise-terrace": NoiseTerraceNodeTemplateFactory;
+  "noise-blend": NoiseBlendNodeTemplateFactory;
+  "noise-select": NoiseSelectNodeTemplateFactory;
+  "noise-displace": NoiseDisplaceNodeTemplateFactory;
+  "noise-rotate-point": NoiseRotatePointNodeTemplateFactory;
+  "noise-scale-point": NoiseScalePointNodeTemplateFactory;
+  "noise-translate-point": NoiseTranslatePointNodeTemplateFactory;
+  "noise-turbulence": NoiseTurbulenceNodeTemplateFactory;
+  "group-module": ModuleGroupNodeTemplateFactory;
+};
+//#endregion
+//#region src/abstract/templates.d.ts
+declare enum NoiseTemplateGroup {
+  positions = "Positions",
+  output = "Output",
+  noiseGenerators = "Noise Generators",
+  noiseModifiers = "Noise Modifiers",
+  noiseSelectors = "Noise Selectors",
+  noiseTransformers = "Noise Transformers"
+}
+//#endregion
+export { NoiseScaleBiasNodeTemplateFactory as A, NoiseCombineNodeTemplateFactory as B, NoiseOutputContext as C, NoiseTerraceNodeContext as D, NoiseLoggerNodeTemplateFactory as E, NoiseExponentNodeContext as F, NoiseClampNodeTemplateFactory as H, NoiseExponentNodeTemplateFactory as I, NoiseCurveNodeContext as L, NoiseNormalizeNodeTemplateFactory as M, NoiseInvertNodeContext as N, NoiseTerraceNodeTemplateFactory as O, NoiseInvertNodeTemplateFactory as P, NoiseCurveNodeTemplateFactory as R, NoiseTextureDataTemplateFactory as S, NoiseLoggerContext as T, NoiseAbsNodeContext as U, NoiseClampNodeContext as V, NoiseAbsNodeTemplateFactory as W, NoiseBlendNodeContext as _, NoiseTurbulenceNodeContext as a, PositionLoggerNodeTemplateFactory as b, NoiseTranslatePointNodeTemplateFactory as c, NoiseRotatePointNodeContext as d, NoiseRotatePointNodeTemplateFactory as f, NoiseSelectNodeTemplateFactory as g, NoiseSelectNodeContext as h, noiseNodeTypes as i, NoiseNormalizeNodeContext as j, NoiseScaleBiasNodeContext as k, NoiseScalePointNodeContext as l, NoiseDisplaceNodeTemplateFactory as m, NoiseNodeType as n, NoiseTurbulenceNodeTemplateFactory as o, NoiseDisplaceNodeContext as p, noiseNodeTemplates as r, NoiseTranslatePointNodeContext as s, NoiseTemplateGroup as t, NoiseScalePointNodeTemplateFactory as u, NoiseBlendNodeTemplateFactory as v, NoiseOutputNodeTemplateFactory as w, NoiseTextureDataContext as x, PositionLoggerNodeContext as y, NoiseCombineNodeContext as z };
+//# sourceMappingURL=index-B09XEo3I.d.cts.map

package/dist/index-B09XEo3I.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-B09XEo3I.d.cts","names":[],"sources":["../src/templates/modifiers/noise-abs-template.ts","../src/templates/modifiers/noise-clamp-template.ts","../src/templates/modifiers/noise-combine-template.ts","../src/templates/modifiers/noise-curve-template.ts","../src/templates/modifiers/noise-exponent-template.ts","../src/templates/modifiers/noise-invert-template.ts","../src/templates/modifiers/noise-normalize-template.ts","../src/templates/modifiers/noise-scalebias-template.ts","../src/templates/modifiers/noise-terrace-template.ts","../src/templates/output/noise-logger-template.ts","../src/templates/output/noise-output-template.ts","../src/templates/output/noise-texture-data-template.ts","../src/templates/output/position-logger-template.ts","../src/templates/selectors/noise-blend-template.ts","../src/templates/selectors/noise-select-template.ts","../src/templates/transformers/noise-displace-template.ts","../src/templates/transformers/noise-rotate-point-template.ts","../src/templates/transformers/noise-scale-point-template.ts","../src/templates/transformers/noise-translate-point-template.ts","../src/templates/transformers/noise-turbulence-template.ts","../src/abstract/node-types.ts","../src/abstract/templates.ts"],"mappings":"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"}

package/dist/index-BGF1mgi8.d.mts

@@ -0,0 +1,98 @@
+import { T as NodeVoronoiNoiseData, c as NodeConstNoiseData, f as NodeFBMNoiseData, g as NodeRidgedNoiseData, h as NodePositionData, p as NodeGridData, u as NodeCylindersNoiseData, x as NodeSpheresNoiseData } from "./node-props-GcUBDDY0.mjs";
+import * as react from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { BasicNodeData } from "@awesome-flow/core/abstract";
+import { Node, NodeProps } from "@xyflow/react";
+
+//#region src/nodes/generators/noise-billow-node.d.ts
+declare function NoiseBillowNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeFBMNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$9: react.MemoExoticComponent<typeof NoiseBillowNode>;
+//#endregion
+//#region src/nodes/generators/noise-checkerboard-node.d.ts
+declare function NoiseCheckerboardNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<BasicNodeData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$8: react.MemoExoticComponent<typeof NoiseCheckerboardNode>;
+//#endregion
+//#region src/nodes/generators/noise-const-node.d.ts
+declare function NoiseConstNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeConstNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$7: react.MemoExoticComponent<typeof NoiseConstNode>;
+//#endregion
+//#region src/nodes/generators/noise-cylinders-node.d.ts
+declare function NoiseCylindersNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeCylindersNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$6: react.MemoExoticComponent<typeof NoiseCylindersNode>;
+//#endregion
+//#region src/nodes/generators/noise-perlin-node.d.ts
+declare function NoisePerlinNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeFBMNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$5: react.MemoExoticComponent<typeof NoisePerlinNode>;
+//#endregion
+//#region src/nodes/generators/noise-ridgedmulti-node.d.ts
+declare function NoiseRidgedMultiNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeRidgedNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$4: react.MemoExoticComponent<typeof NoiseRidgedMultiNode>;
+//#endregion
+//#region src/nodes/generators/noise-spheres-node.d.ts
+declare function NoiseSpheresNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeSpheresNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$3: react.MemoExoticComponent<typeof NoiseSpheresNode>;
+//#endregion
+//#region src/nodes/generators/noise-voronoi-node.d.ts
+declare function NoiseVoronoiNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeVoronoiNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$2: react.MemoExoticComponent<typeof NoiseVoronoiNode>;
+//#endregion
+//#region src/nodes/generators/position-const-node.d.ts
+declare function PositionConstNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodePositionData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$1: react.MemoExoticComponent<typeof PositionConstNode>;
+//#endregion
+//#region src/nodes/generators/position-grid-node.d.ts
+declare function PositionGridNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeGridData>>): react_jsx_runtime0.JSX.Element;
+declare const _default: react.MemoExoticComponent<typeof PositionGridNode>;
+//#endregion
+export { _default$4 as a, _default$7 as c, _default$3 as i, _default$8 as l, _default$1 as n, _default$5 as o, _default$2 as r, _default$6 as s, _default as t, _default$9 as u };
+//# sourceMappingURL=index-BGF1mgi8.d.mts.map

package/dist/index-BGF1mgi8.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BGF1mgi8.d.mts","names":[],"sources":["../src/nodes/generators/noise-billow-node.tsx","../src/nodes/generators/noise-checkerboard-node.tsx","../src/nodes/generators/noise-const-node.tsx","../src/nodes/generators/noise-cylinders-node.tsx","../src/nodes/generators/noise-perlin-node.tsx","../src/nodes/generators/noise-ridgedmulti-node.tsx","../src/nodes/generators/noise-spheres-node.tsx","../src/nodes/generators/noise-voronoi-node.tsx","../src/nodes/generators/position-const-node.tsx","../src/nodes/generators/position-grid-node.tsx"],"mappings":";;;;;;;iBAMS,eAAA,CAAA;EAAkB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,gBAAA,KAAkB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCD/E,qBAAA,CAAA;EAAwB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,aAAA,KAAe,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCElF,cAAA,CAAA;EAAiB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,kBAAA,KAAoB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCDhF,kBAAA,CAAA;EAAqB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,sBAAA,KAAwB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCAxF,eAAA,CAAA;EAAkB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,gBAAA,KAAkB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCA/E,oBAAA,CAAA;EAAuB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,mBAAA,KAAqB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCAvF,gBAAA,CAAA;EAAmB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,oBAAA,KAAsB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCApF,gBAAA,CAAA;EAAmB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,oBAAA,KAAsB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCCpF,iBAAA,CAAA;EAAoB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,gBAAA,KAAkB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCAjF,gBAAA,CAAA;EAAmB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,YAAA,KAAc,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,QAAA"}

package/dist/{modules/index.d.ts → index-BbHM1kxc.d.cts}

@@ -7,9 +7,6 @@ declare class NormalizeNoiseModule extends ModifierModule {
   constructor(source: Module, lowerBound: number, upperBound: number);
   getValue(x: number, y: number, z: number): number;
 }
-
 //#endregion
-//# sourceMappingURL=normalize-noise-module.d.ts.map
-
-export { NormalizeNoiseModule };
-//# sourceMappingURL=index.d.ts.map
+export { NormalizeNoiseModule as t };
+//# sourceMappingURL=index-BbHM1kxc.d.cts.map

package/dist/index-BbHM1kxc.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BbHM1kxc.d.cts","names":[],"sources":["../src/modules/normalize-noise-module.ts"],"mappings":";;;cAEa,oBAAA,SAA6B,cAAA;EAG/B,UAAA;EACA,UAAA;cAFP,MAAA,EAAQ,MAAA,EACD,UAAA,UACA,UAAA;EAKT,QAAA,CAAS,CAAA,UAAW,CAAA,UAAW,CAAA;AAAA"}