@awesome-flow/noise 0.9.4 → 0.10.0

package/dist/index-BgWB8f25.d.cts

@@ -0,0 +1,53 @@
+import { C as NodeTranslatePointNoiseData, _ as NodeRotatePointNoiseData, w as NodeTurbulenceNoiseData, y as NodeScalePointNoiseData } from "./node-props-CoXzPLD6.cjs";
+import { BasicNodeData } from "@awesome-flow/core/abstract";
+import { Node, NodeProps } from "@xyflow/react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react from "react";
+
+//#region src/nodes/transformers/noise-displace-node.d.ts
+declare function NoiseDisplaceNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<BasicNodeData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$4: react.MemoExoticComponent<typeof NoiseDisplaceNode>;
+//#endregion
+//#region src/nodes/transformers/noise-rotate-point-node.d.ts
+declare function NoiseRotatePointNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeRotatePointNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$3: react.MemoExoticComponent<typeof NoiseRotatePointNode>;
+//#endregion
+//#region src/nodes/transformers/noise-scale-point-node.d.ts
+declare function NoiseScalePointNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeScalePointNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$2: react.MemoExoticComponent<typeof NoiseScalePointNode>;
+//#endregion
+//#region src/nodes/transformers/noise-translate-point-node.d.ts
+declare function NoiseTranslatePointNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeTranslatePointNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$1: react.MemoExoticComponent<typeof NoiseTranslatePointNode>;
+//#endregion
+//#region src/nodes/transformers/noise-turbulence-node.d.ts
+declare function NoiseTurbulenceNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeTurbulenceNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default: react.MemoExoticComponent<typeof NoiseTurbulenceNode>;
+//#endregion
+export { _default$4 as a, _default$3 as i, _default$1 as n, _default$2 as r, _default as t };
+//# sourceMappingURL=index-BgWB8f25.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BgWB8f25.d.cts","names":[],"sources":["../src/nodes/transformers/noise-displace-node.tsx","../src/nodes/transformers/noise-rotate-point-node.tsx","../src/nodes/transformers/noise-scale-point-node.tsx","../src/nodes/transformers/noise-translate-point-node.tsx","../src/nodes/transformers/noise-turbulence-node.tsx"],"mappings":";;;;;;;iBAMS,iBAAA,CAAA;EAAoB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,aAAA,KAAe,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCC9E,oBAAA,CAAA;EAAuB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,wBAAA,KAA0B,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCA5F,mBAAA,CAAA;EAAsB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,uBAAA,KAAyB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCA1F,uBAAA,CAAA;EAA0B,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,2BAAA,KAA6B,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCDlG,mBAAA,CAAA;EAAsB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,uBAAA,KAAyB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,QAAA"}

package/dist/index-BhJiS2YS.d.mts

@@ -0,0 +1,496 @@
+import { a as NoiseHandleType, i as DisplacementModuleHandle, n as ModuleGroupNodeTemplateFactory, o as NoiseSourceControlHandle, r as DisplacementHandle } from "./module-group-template-D5doDEoa.mjs";
+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-GcUBDDY0.mjs";
+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-FY_7BJcV.mjs";
+import { t as NormalizeNoiseModule } from "./index-C0hF9uhX.mjs";
+import * as react from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+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 _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-BhJiS2YS.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BhJiS2YS.d.mts","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-BwLhWefF.d.cts

@@ -0,0 +1,43 @@
+import { BasicNodeData } from "@awesome-flow/core/abstract";
+import { Node, NodeProps } from "@xyflow/react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react from "react";
+
+//#region src/nodes/output/noise-logger-node.d.ts
+declare function NoiseLoggerNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<BasicNodeData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$3: react.MemoExoticComponent<typeof NoiseLoggerNode>;
+//#endregion
+//#region src/nodes/output/noise-output-node.d.ts
+declare function NoiseOutputNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<BasicNodeData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$2: react.MemoExoticComponent<typeof NoiseOutputNode>;
+//#endregion
+//#region src/nodes/output/noise-texture-data-node.d.ts
+declare function NoiseTextureDataNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<BasicNodeData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$1: react.MemoExoticComponent<typeof NoiseTextureDataNode>;
+//#endregion
+//#region src/nodes/output/positions-logger-node.d.ts
+declare function PositionsLoggerNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<BasicNodeData>>): react_jsx_runtime0.JSX.Element;
+declare const _default: react.MemoExoticComponent<typeof PositionsLoggerNode>;
+//#endregion
+export { _default$3 as i, _default$1 as n, _default$2 as r, _default as t };
+//# sourceMappingURL=index-BwLhWefF.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BwLhWefF.d.cts","names":[],"sources":["../src/nodes/output/noise-logger-node.tsx","../src/nodes/output/noise-output-node.tsx","../src/nodes/output/noise-texture-data-node.tsx","../src/nodes/output/positions-logger-node.tsx"],"mappings":";;;;;;iBASS,eAAA,CAAA;EAAkB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,aAAA,KAAe,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCA5E,eAAA,CAAA;EAAkB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,aAAA,KAAe,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCD5E,oBAAA,CAAA;EAAuB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,aAAA,KAAe,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCCjF,mBAAA,CAAA;EAAsB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,aAAA,KAAe,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,QAAA"}

package/dist/index-Bxg8IB-v.d.cts

@@ -0,0 +1,26 @@
+import { b as NodeSelectNoiseData } from "./node-props-CoXzPLD6.cjs";
+import { BasicNodeData } from "@awesome-flow/core/abstract";
+import { Node, NodeProps } from "@xyflow/react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react from "react";
+
+//#region src/nodes/selectors/noise-blend-node.d.ts
+declare function NoiseBlendNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<BasicNodeData>>): react_jsx_runtime0.JSX.Element;
+declare const _default$1: react.MemoExoticComponent<typeof NoiseBlendNode>;
+//#endregion
+//#region src/nodes/selectors/noise-select-node.d.ts
+declare function NoiseSelectNode({
+  id,
+  selected,
+  data,
+  type
+}: NodeProps<Node<NodeSelectNoiseData>>): react_jsx_runtime0.JSX.Element;
+declare const _default: react.MemoExoticComponent<typeof NoiseSelectNode>;
+//#endregion
+export { _default$1 as n, _default as t };
+//# sourceMappingURL=index-Bxg8IB-v.d.cts.map

package/dist/index-Bxg8IB-v.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Bxg8IB-v.d.cts","names":[],"sources":["../src/nodes/selectors/noise-blend-node.tsx","../src/nodes/selectors/noise-select-node.tsx"],"mappings":";;;;;;;iBAMS,cAAA,CAAA;EAAiB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,aAAA,KAAe,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,UAAA;;;iBCE3E,eAAA,CAAA;EAAkB,EAAA;EAAI,QAAA;EAAU,IAAA;EAAM;AAAA,GAAQ,SAAA,CAAU,IAAA,CAAK,mBAAA,KAAqB,kBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,cAAA,QAAA"}

package/dist/index-C0hF9uhX.d.mts

@@ -0,0 +1,12 @@
+import { ModifierModule, Module } from "libnoise-simplex-ts";
+
+//#region src/modules/normalize-noise-module.d.ts
+declare class NormalizeNoiseModule extends ModifierModule {
+  lowerBound: number;
+  upperBound: number;
+  constructor(source: Module, lowerBound: number, upperBound: number);
+  getValue(x: number, y: number, z: number): number;
+}
+//#endregion
+export { NormalizeNoiseModule as t };
+//# sourceMappingURL=index-C0hF9uhX.d.mts.map