pict-section-flow 1.4.0 → 2.0.1

package/source/providers/layouts/Layout-Circular.js

@@ -1,203 +0,0 @@
-const libCoerce = require('./Layout-Coerce.js');
-
-/**
- * Layout-Circular
- *
- * Concentric-ring layout.
- *
- * Two modes, decided by the presence of connections:
- *
- *   With connections: BFS from the root nodes (in-degree 0; or all
- *   nodes if every node has incoming edges). Each BFS depth becomes
- *   one ring. Roots cluster near the center, leaves on the outer rings.
- *
- *   Without connections: all nodes share a single ring with equal
- *   angular spacing.
- *
- * Within each ring, nodes are placed at equal angles starting from
- * `StartAngle` (in degrees, 0 = +X axis), going clockwise or
- * counter-clockwise per `Direction`.
- */
-module.exports =
-{
-	Name: 'Circular',
-	Label: 'Circular',
-	Description: 'Concentric rings; uses connections for ring assignment when available.',
-	DefaultEdgeTheme: 'Perimeter',
-
-	Apply: function (pNodes, pConnections, pParameters)
-	{
-		if (!pNodes || pNodes.length === 0) return;
-
-		let tmpParams = pParameters || {};
-		let tmpSpacing     = libCoerce.toFloat(tmpParams.Spacing, 1.0);
-		let tmpCenterX     = libCoerce.toFloat(tmpParams.CenterX, 1000);
-		let tmpCenterY     = libCoerce.toFloat(tmpParams.CenterY, 750);
-		let tmpRingSpacing = libCoerce.toFloat(tmpParams.RingSpacing, 220) * tmpSpacing;
-		let tmpInnerRadius = libCoerce.toFloat(tmpParams.InnerRadius, 0) * tmpSpacing;
-		let tmpStartAngle  = libCoerce.toFloat(tmpParams.StartAngle, -90);
-		let tmpDirection   = (tmpParams.Direction === 'ccw') ? 'ccw' : 'cw';
-
-		let tmpConnections = Array.isArray(pConnections) ? pConnections : [];
-
-		// Build in-degree map and adjacency
-		let tmpInDegree = {};
-		let tmpAdjacency = {};
-		let tmpNodeMap = {};
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			tmpNodeMap[pNodes[i].Hash] = pNodes[i];
-			tmpInDegree[pNodes[i].Hash] = 0;
-			tmpAdjacency[pNodes[i].Hash] = [];
-		}
-		for (let i = 0; i < tmpConnections.length; i++)
-		{
-			let tmpConn = tmpConnections[i];
-			if (tmpInDegree.hasOwnProperty(tmpConn.TargetNodeHash))
-			{
-				tmpInDegree[tmpConn.TargetNodeHash]++;
-			}
-			if (tmpAdjacency.hasOwnProperty(tmpConn.SourceNodeHash))
-			{
-				tmpAdjacency[tmpConn.SourceNodeHash].push(tmpConn.TargetNodeHash);
-			}
-		}
-
-		// Identify roots
-		let tmpRoots = [];
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			if (tmpInDegree[pNodes[i].Hash] === 0)
-			{
-				tmpRoots.push(pNodes[i].Hash);
-			}
-		}
-
-		let tmpRings = [];
-
-		if (tmpConnections.length === 0 || tmpRoots.length === 0)
-		{
-			tmpRings.push(pNodes.map((pNode) => pNode.Hash));
-		}
-		else
-		{
-			// BFS by depth
-			let tmpVisited = {};
-			let tmpCurrent = tmpRoots.slice();
-			while (tmpCurrent.length > 0)
-			{
-				let tmpRing = [];
-				let tmpNext = [];
-				for (let i = 0; i < tmpCurrent.length; i++)
-				{
-					let tmpHash = tmpCurrent[i];
-					if (tmpVisited[tmpHash]) continue;
-					tmpVisited[tmpHash] = true;
-					tmpRing.push(tmpHash);
-
-					let tmpChildren = tmpAdjacency[tmpHash] || [];
-					for (let j = 0; j < tmpChildren.length; j++)
-					{
-						if (!tmpVisited[tmpChildren[j]])
-						{
-							tmpNext.push(tmpChildren[j]);
-						}
-					}
-				}
-				if (tmpRing.length > 0) tmpRings.push(tmpRing);
-				tmpCurrent = tmpNext;
-			}
-
-			let tmpRemaining = [];
-			for (let i = 0; i < pNodes.length; i++)
-			{
-				if (!tmpVisited[pNodes[i].Hash]) tmpRemaining.push(pNodes[i].Hash);
-			}
-			if (tmpRemaining.length > 0) tmpRings.push(tmpRemaining);
-		}
-
-		// Place nodes
-		let tmpAngleSign = (tmpDirection === 'cw') ? 1 : -1;
-		let tmpStartRad = tmpStartAngle * Math.PI / 180;
-
-		for (let tmpRingIdx = 0; tmpRingIdx < tmpRings.length; tmpRingIdx++)
-		{
-			let tmpRing = tmpRings[tmpRingIdx];
-			let tmpRadius = tmpInnerRadius + tmpRingIdx * tmpRingSpacing;
-
-			if (tmpRing.length === 1 && tmpRingIdx === 0 && tmpInnerRadius === 0)
-			{
-				let tmpNode = tmpNodeMap[tmpRing[0]];
-				if (tmpNode)
-				{
-					tmpNode.X = tmpCenterX - (tmpNode.Width || 180) / 2;
-					tmpNode.Y = tmpCenterY - (tmpNode.Height || 80) / 2;
-				}
-				continue;
-			}
-
-			let tmpAngleStep = (2 * Math.PI) / tmpRing.length;
-			for (let i = 0; i < tmpRing.length; i++)
-			{
-				let tmpNode = tmpNodeMap[tmpRing[i]];
-				if (!tmpNode) continue;
-				let tmpAngle = tmpStartRad + tmpAngleSign * i * tmpAngleStep;
-				let tmpW = tmpNode.Width || 180;
-				let tmpH = tmpNode.Height || 80;
-				tmpNode.X = tmpCenterX + Math.cos(tmpAngle) * tmpRadius - tmpW / 2;
-				tmpNode.Y = tmpCenterY + Math.sin(tmpAngle) * tmpRadius - tmpH / 2;
-			}
-		}
-	},
-
-	DefaultParameters:
-	{
-		Spacing: 1.0,
-		CenterX: 1000,
-		CenterY: 750,
-		RingSpacing: 220,
-		InnerRadius: 0,
-		StartAngle: -90,
-		Direction: 'cw'
-	},
-
-	ParameterSchema:
-	{
-		Spacing:     { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
-		CenterX:     { Type: 'PreciseNumber', Label: 'Center X',     Default: 1000, Min: -10000, Max: 10000 },
-		CenterY:     { Type: 'PreciseNumber', Label: 'Center Y',     Default: 750,  Min: -10000, Max: 10000 },
-		RingSpacing: { Type: 'PreciseNumber', Label: 'Ring spacing', Default: 220,  Min: 1, Max: 5000 },
-		InnerRadius: { Type: 'PreciseNumber', Label: 'Inner radius', Default: 0,    Min: 0, Max: 5000 },
-		StartAngle:  { Type: 'PreciseNumber', Label: 'Start angle (deg)', Default: -90, Min: -360, Max: 360 },
-		Direction:   { Type: 'enum',          Label: 'Direction',    Default: 'cw', Options: ['cw', 'ccw'] }
-	},
-
-	ParameterManifest:
-	{
-		Scope: 'PictFlowLayout-Circular',
-		Sections:
-		[
-			{ Name: 'Circular Parameters', Hash: 'PFLCircularSection', Groups: [{ Name: 'Defaults', Hash: 'PFLCircularGroup' }] }
-		],
-		Descriptors:
-		{
-			'PictFlowLayoutEditor.Parameters.Spacing':
-			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 } },
-			'PictFlowLayoutEditor.Parameters.CenterX':
-			{ Name: 'Center X', Hash: 'CenterX', DataType: 'PreciseNumber', Default: 1000, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.CenterY':
-			{ Name: 'Center Y', Hash: 'CenterY', DataType: 'PreciseNumber', Default: 750, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.RingSpacing':
-			{ Name: 'Ring spacing', Hash: 'RingSpacing', DataType: 'PreciseNumber', Default: 220, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 2, Width: 6, Min: 1, Max: 5000 } },
-			'PictFlowLayoutEditor.Parameters.InnerRadius':
-			{ Name: 'Inner radius', Hash: 'InnerRadius', DataType: 'PreciseNumber', Default: 0, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 2, Width: 6, Min: 0, Max: 5000 } },
-			'PictFlowLayoutEditor.Parameters.StartAngle':
-			{ Name: 'Start angle (deg)', Hash: 'StartAngle', DataType: 'PreciseNumber', Default: -90, PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 3, Width: 6, Min: -360, Max: 360 } },
-			'PictFlowLayoutEditor.Parameters.Direction':
-			{
-				Name: 'Direction', Hash: 'Direction', DataType: 'String', Default: 'cw',
-				PictForm: { Section: 'PFLCircularSection', Group: 'PFLCircularGroup', Row: 3, Width: 6, InputType: 'Option', SelectOptions: [{ Value: 'cw', Name: 'Clockwise' }, { Value: 'ccw', Name: 'Counter-clockwise' }] }
-			}
-		}
-	}
-};

package/source/providers/layouts/Layout-Coerce.js

@@ -1,40 +0,0 @@
-/**
- * Layout-Coerce
- *
- * Tiny coercion helpers for layout-algorithm parameters. Manyfest's
- * `PreciseNumber` DataType stores values as strings (so big.js /
- * fable.ExpressionParser can do arbitrary-precision math on them
- * without float drift). The simulation code in each layout algorithm
- * uses native JS Math, so we coerce at the entry point.
- *
- * Apply functions accept either format (number or string) and use
- * these helpers to normalize.
- */
-
-function _toFloat(pValue, pDefault)
-{
-	if (typeof pValue === 'number' && !isNaN(pValue)) return pValue;
-	if (typeof pValue === 'string' && pValue !== '')
-	{
-		let tmpNum = parseFloat(pValue);
-		if (!isNaN(tmpNum)) return tmpNum;
-	}
-	return pDefault;
-}
-
-function _toInt(pValue, pDefault)
-{
-	if (typeof pValue === 'number' && !isNaN(pValue)) return Math.floor(pValue);
-	if (typeof pValue === 'string' && pValue !== '')
-	{
-		let tmpNum = parseInt(pValue, 10);
-		if (!isNaN(tmpNum)) return tmpNum;
-	}
-	return pDefault;
-}
-
-module.exports =
-{
-	toFloat: _toFloat,
-	toInt: _toInt
-};

package/source/providers/layouts/Layout-Columnar.js

@@ -1,134 +0,0 @@
-const libCoerce = require('./Layout-Coerce.js');
-
-/**
- * Layout-Columnar
- *
- * N-column layout with deterministic fill order. Distinct from Grid in
- * two ways:
- *   - Columns is always explicit (no 'auto')
- *   - FillOrder controls whether nodes flow row-first or column-first
- *
- * The column count is `Number` (integer index); spacing/origin values
- * are `PreciseNumber` so they survive solver chains.
- */
-module.exports =
-{
-	Name: 'Columnar',
-	Label: 'Columnar (N Columns)',
-	Description: 'Explicit N columns; flow row-first or column-first.',
-	DefaultEdgeTheme: 'Orthogonal',
-
-	Apply: function (pNodes, pConnections, pParameters)
-	{
-		if (!pNodes || pNodes.length === 0) return;
-
-		let tmpParams = pParameters || {};
-		let tmpSpacing         = libCoerce.toFloat(tmpParams.Spacing, 1.0);
-		let tmpColumns         = Math.max(1, libCoerce.toInt(tmpParams.Columns, 3));
-		let tmpColumnSpacing   = libCoerce.toFloat(tmpParams.ColumnSpacing, 40) * tmpSpacing;
-		let tmpRowSpacing      = libCoerce.toFloat(tmpParams.RowSpacing, 40) * tmpSpacing;
-		let tmpStartX          = libCoerce.toFloat(tmpParams.StartX, 100);
-		let tmpStartY          = libCoerce.toFloat(tmpParams.StartY, 100);
-		let tmpFillOrder       = (tmpParams.FillOrder === 'column') ? 'column' : 'row';
-		let tmpOrderBy         = tmpParams.OrderBy || 'index';
-
-		// Compute cell dimensions from largest node
-		let tmpMaxWidth = 0;
-		let tmpMaxHeight = 0;
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			tmpMaxWidth = Math.max(tmpMaxWidth, pNodes[i].Width || 180);
-			tmpMaxHeight = Math.max(tmpMaxHeight, pNodes[i].Height || 80);
-		}
-		let tmpCellWidth  = tmpMaxWidth + tmpColumnSpacing;
-		let tmpCellHeight = tmpMaxHeight + tmpRowSpacing;
-
-		let tmpOrdered = pNodes.slice();
-		if (tmpOrderBy === 'hash')
-		{
-			tmpOrdered.sort((pA, pB) => String(pA.Hash).localeCompare(String(pB.Hash)));
-		}
-		else if (tmpOrderBy === 'title')
-		{
-			tmpOrdered.sort((pA, pB) => String(pA.Title || pA.Hash).localeCompare(String(pB.Title || pB.Hash)));
-		}
-
-		let tmpRows = Math.ceil(tmpOrdered.length / tmpColumns);
-
-		for (let i = 0; i < tmpOrdered.length; i++)
-		{
-			let tmpRow;
-			let tmpCol;
-			if (tmpFillOrder === 'column')
-			{
-				tmpCol = Math.floor(i / tmpRows);
-				tmpRow = i % tmpRows;
-			}
-			else
-			{
-				tmpRow = Math.floor(i / tmpColumns);
-				tmpCol = i % tmpColumns;
-			}
-			tmpOrdered[i].X = tmpStartX + tmpCol * tmpCellWidth;
-			tmpOrdered[i].Y = tmpStartY + tmpRow * tmpCellHeight;
-		}
-	},
-
-	DefaultParameters:
-	{
-		Spacing: 1.0,
-		Columns: 3,
-		ColumnSpacing: 40,
-		RowSpacing: 40,
-		StartX: 100,
-		StartY: 100,
-		FillOrder: 'row',
-		OrderBy: 'index'
-	},
-
-	ParameterSchema:
-	{
-		Spacing:       { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
-		Columns:       { Type: 'Number',        Label: 'Columns',        Default: 3,   Min: 1, Max: 50 },
-		ColumnSpacing: { Type: 'PreciseNumber', Label: 'Column spacing', Default: 40,  Min: 0, Max: 1000 },
-		RowSpacing:    { Type: 'PreciseNumber', Label: 'Row spacing',    Default: 40,  Min: 0, Max: 1000 },
-		StartX:        { Type: 'PreciseNumber', Label: 'Start X',        Default: 100, Min: -10000, Max: 10000 },
-		StartY:        { Type: 'PreciseNumber', Label: 'Start Y',        Default: 100, Min: -10000, Max: 10000 },
-		FillOrder:     { Type: 'enum',          Label: 'Fill order',     Default: 'row', Options: ['row', 'column'] },
-		OrderBy:       { Type: 'enum',          Label: 'Order by',       Default: 'index', Options: ['index', 'hash', 'title'] }
-	},
-
-	ParameterManifest:
-	{
-		Scope: 'PictFlowLayout-Columnar',
-		Sections:
-		[
-			{ Name: 'Columnar Parameters', Hash: 'PFLColumnarSection', Groups: [{ Name: 'Defaults', Hash: 'PFLColumnarGroup' }] }
-		],
-		Descriptors:
-		{
-			'PictFlowLayoutEditor.Parameters.Spacing':
-			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 } },
-			'PictFlowLayoutEditor.Parameters.Columns':
-			{ Name: 'Columns', Hash: 'Columns', DataType: 'Number', Default: 3, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 1, Width: 6, Min: 1, Max: 50 } },
-			'PictFlowLayoutEditor.Parameters.FillOrder':
-			{
-				Name: 'Fill order', Hash: 'FillOrder', DataType: 'String', Default: 'row',
-				PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 1, Width: 6, InputType: 'Option', SelectOptions: [{ Value: 'row', Name: 'Row-first' }, { Value: 'column', Name: 'Column-first' }] }
-			},
-			'PictFlowLayoutEditor.Parameters.ColumnSpacing':
-			{ Name: 'Column spacing', Hash: 'ColumnSpacing', DataType: 'PreciseNumber', Default: 40, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 2, Width: 6, Min: 0, Max: 1000 } },
-			'PictFlowLayoutEditor.Parameters.RowSpacing':
-			{ Name: 'Row spacing', Hash: 'RowSpacing', DataType: 'PreciseNumber', Default: 40, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 2, Width: 6, Min: 0, Max: 1000 } },
-			'PictFlowLayoutEditor.Parameters.StartX':
-			{ Name: 'Start X', Hash: 'StartX', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 3, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.StartY':
-			{ Name: 'Start Y', Hash: 'StartY', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 3, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.OrderBy':
-			{
-				Name: 'Order by', Hash: 'OrderBy', DataType: 'String', Default: 'index',
-				PictForm: { Section: 'PFLColumnarSection', Group: 'PFLColumnarGroup', Row: 4, Width: 12, InputType: 'Option', SelectOptions: [{ Value: 'index', Name: 'Index' }, { Value: 'hash', Name: 'Hash' }, { Value: 'title', Name: 'Title' }] }
-			}
-		}
-	}
-};

package/source/providers/layouts/Layout-Custom.js

@@ -1,27 +0,0 @@
-/**
- * Layout-Custom
- *
- * No-op layout algorithm. Preserves the X/Y values currently on each
- * node so users can hand-place nodes without an algorithm clobbering
- * positions on the next render.
- *
- * Selecting "Custom" with auto-apply enabled is effectively a no-op
- * on every structural change — useful as a way to disable the
- * configured algorithm without unsetting it.
- */
-module.exports =
-{
-	Name: 'Custom',
-	Label: 'Custom (Hand-placed)',
-	Description: 'Preserve hand-placed positions. No automatic arrangement.',
-	DefaultEdgeTheme: 'Bezier',
-
-	Apply: function (pNodes, pConnections, pParameters)
-	{
-		// Intentionally empty — Custom is a no-op.
-	},
-
-	DefaultParameters: {},
-
-	ParameterSchema: {}
-};

package/source/providers/layouts/Layout-ForcedFromCenter.js

@@ -1,256 +0,0 @@
-const libCoerce = require('./Layout-Coerce.js');
-
-/**
- * Layout-ForcedFromCenter
- *
- * Force-directed simulation in the Fruchterman-Reingold style:
- *   - Spring (attractive) forces along each connection
- *   - Coulomb-style repulsion between every pair of nodes
- *   - Center-attraction force pulling all nodes toward (CenterX, CenterY)
- *   - Cooling schedule: max displacement per iteration shrinks over time
- *
- * Deterministic by default — initial positions for unplaced nodes are
- * generated from a seedable Mulberry32 PRNG (inline implementation, no
- * new dependencies). Tests pin `Seed` to assert byte-identical output.
- *
- * Performance: O(n^2) per iteration. With Iterations=200 this is fine
- * for ~100 nodes; keep ForcedFromCenter for moderate-sized graphs.
- *
- * Numeric parameters (other than Iterations and Seed) are typed
- * `PreciseNumber` so they round-trip cleanly through the
- * ExpressionParser; the simulation coerces back to JS floats via
- * Layout-Coerce. Iterations and Seed stay `Number` because they're
- * loop counters / bitwise-PRNG state.
- */
-module.exports =
-{
-	Name: 'ForcedFromCenter',
-	Label: 'Forced from Center',
-	Description: 'Spring + repulsion simulation pulling toward a center point.',
-	DefaultEdgeTheme: 'Bezier',
-
-	Apply: function (pNodes, pConnections, pParameters)
-	{
-		if (!pNodes || pNodes.length === 0) return;
-
-		let tmpParams = pParameters || {};
-		let tmpSpacing            = libCoerce.toFloat(tmpParams.Spacing,            1.0);
-		let tmpIterations         = libCoerce.toInt(tmpParams.Iterations,         200);
-		let tmpCenterX            = libCoerce.toFloat(tmpParams.CenterX,            1000);
-		let tmpCenterY            = libCoerce.toFloat(tmpParams.CenterY,            750);
-		let tmpSpringLength       = libCoerce.toFloat(tmpParams.SpringLength,       200) * tmpSpacing;
-		let tmpSpringStiffness    = libCoerce.toFloat(tmpParams.SpringStiffness,    0.05);
-		let tmpRepulsion          = libCoerce.toFloat(tmpParams.Repulsion,          8000);
-		let tmpCenterAttraction   = libCoerce.toFloat(tmpParams.CenterAttraction,   0.01);
-		let tmpCoolingFactor      = libCoerce.toFloat(tmpParams.CoolingFactor,      0.95);
-		let tmpInitialTemperature = libCoerce.toFloat(tmpParams.InitialTemperature, 100);
-		let tmpSeed               = libCoerce.toInt(tmpParams.Seed,               42);
-		let tmpPreservePositions  = !!tmpParams.PreservePositions;
-		let tmpInitialSpread      = libCoerce.toFloat(tmpParams.InitialSpread,      400);
-
-		let tmpConnections = Array.isArray(pConnections) ? pConnections : [];
-
-		// Mulberry32 seeded PRNG — deterministic initial-position generator.
-		let tmpRand = _makeMulberry32(tmpSeed >>> 0);
-
-		// Initial positions
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			let tmpNode = pNodes[i];
-			let tmpHasPosition = (typeof tmpNode.X === 'number' && typeof tmpNode.Y === 'number');
-			if (tmpPreservePositions && tmpHasPosition) continue;
-			tmpNode.X = tmpCenterX + (tmpRand() - 0.5) * tmpInitialSpread;
-			tmpNode.Y = tmpCenterY + (tmpRand() - 0.5) * tmpInitialSpread;
-		}
-
-		// Index nodes by hash for connection lookup
-		let tmpNodeMap = {};
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			tmpNodeMap[pNodes[i].Hash] = pNodes[i];
-		}
-
-		let tmpTemperature = tmpInitialTemperature;
-
-		for (let tmpIter = 0; tmpIter < tmpIterations; tmpIter++)
-		{
-			// Force accumulators
-			let tmpForceX = new Array(pNodes.length).fill(0);
-			let tmpForceY = new Array(pNodes.length).fill(0);
-
-			// Repulsion between every pair of nodes
-			for (let i = 0; i < pNodes.length; i++)
-			{
-				let tmpA = pNodes[i];
-				for (let j = i + 1; j < pNodes.length; j++)
-				{
-					let tmpB = pNodes[j];
-					let tmpDX = tmpA.X - tmpB.X;
-					let tmpDY = tmpA.Y - tmpB.Y;
-					let tmpDistSq = tmpDX * tmpDX + tmpDY * tmpDY;
-					if (tmpDistSq < 1) tmpDistSq = 1; // avoid singularities
-					let tmpDist = Math.sqrt(tmpDistSq);
-					let tmpForce = tmpRepulsion / tmpDistSq;
-					let tmpFX = (tmpDX / tmpDist) * tmpForce;
-					let tmpFY = (tmpDY / tmpDist) * tmpForce;
-					tmpForceX[i] += tmpFX;
-					tmpForceY[i] += tmpFY;
-					tmpForceX[j] -= tmpFX;
-					tmpForceY[j] -= tmpFY;
-				}
-			}
-
-			// Spring forces along connections
-			for (let i = 0; i < tmpConnections.length; i++)
-			{
-				let tmpConn = tmpConnections[i];
-				let tmpSource = tmpNodeMap[tmpConn.SourceNodeHash];
-				let tmpTarget = tmpNodeMap[tmpConn.TargetNodeHash];
-				if (!tmpSource || !tmpTarget) continue;
-
-				let tmpSourceIdx = pNodes.indexOf(tmpSource);
-				let tmpTargetIdx = pNodes.indexOf(tmpTarget);
-				if (tmpSourceIdx < 0 || tmpTargetIdx < 0) continue;
-
-				let tmpDX = tmpTarget.X - tmpSource.X;
-				let tmpDY = tmpTarget.Y - tmpSource.Y;
-				let tmpDist = Math.sqrt(tmpDX * tmpDX + tmpDY * tmpDY);
-				if (tmpDist < 0.0001) tmpDist = 0.0001;
-
-				let tmpDelta = tmpDist - tmpSpringLength;
-				let tmpForce = tmpSpringStiffness * tmpDelta;
-				let tmpFX = (tmpDX / tmpDist) * tmpForce;
-				let tmpFY = (tmpDY / tmpDist) * tmpForce;
-
-				tmpForceX[tmpSourceIdx] += tmpFX;
-				tmpForceY[tmpSourceIdx] += tmpFY;
-				tmpForceX[tmpTargetIdx] -= tmpFX;
-				tmpForceY[tmpTargetIdx] -= tmpFY;
-			}
-
-			// Center attraction
-			for (let i = 0; i < pNodes.length; i++)
-			{
-				let tmpNode = pNodes[i];
-				tmpForceX[i] += (tmpCenterX - tmpNode.X) * tmpCenterAttraction;
-				tmpForceY[i] += (tmpCenterY - tmpNode.Y) * tmpCenterAttraction;
-			}
-
-			// Apply forces with temperature clamp
-			for (let i = 0; i < pNodes.length; i++)
-			{
-				let tmpNode = pNodes[i];
-				let tmpFX = tmpForceX[i];
-				let tmpFY = tmpForceY[i];
-				let tmpMag = Math.sqrt(tmpFX * tmpFX + tmpFY * tmpFY);
-				if (tmpMag > tmpTemperature)
-				{
-					tmpFX = (tmpFX / tmpMag) * tmpTemperature;
-					tmpFY = (tmpFY / tmpMag) * tmpTemperature;
-				}
-				tmpNode.X += tmpFX;
-				tmpNode.Y += tmpFY;
-			}
-
-			tmpTemperature *= tmpCoolingFactor;
-		}
-
-		// Round to whole pixels for stable rendering and predictable tests
-		for (let i = 0; i < pNodes.length; i++)
-		{
-			pNodes[i].X = Math.round(pNodes[i].X);
-			pNodes[i].Y = Math.round(pNodes[i].Y);
-		}
-	},
-
-	DefaultParameters:
-	{
-		Spacing: 1.0,
-		Iterations: 200,
-		CenterX: 1000,
-		CenterY: 750,
-		SpringLength: 200,
-		SpringStiffness: 0.05,
-		Repulsion: 8000,
-		CenterAttraction: 0.01,
-		CoolingFactor: 0.95,
-		InitialTemperature: 100,
-		Seed: 42,
-		PreservePositions: false,
-		InitialSpread: 400
-	},
-
-	ParameterSchema:
-	{
-		Spacing:            { Type: 'PreciseNumber', Label: 'Spacing (multiplier)', Default: 1.0, Min: 0.1, Max: 5 },
-		Iterations:         { Type: 'Number',        Label: 'Iterations',         Default: 200,   Min: 1,    Max: 2000  },
-		CenterX:            { Type: 'PreciseNumber', Label: 'Center X',           Default: 1000,  Min: -10000, Max: 10000 },
-		CenterY:            { Type: 'PreciseNumber', Label: 'Center Y',           Default: 750,   Min: -10000, Max: 10000 },
-		SpringLength:       { Type: 'PreciseNumber', Label: 'Spring length',      Default: 200,   Min: 1,    Max: 2000  },
-		SpringStiffness:    { Type: 'PreciseNumber', Label: 'Spring stiffness',   Default: 0.05,  Min: 0,    Max: 1     },
-		Repulsion:          { Type: 'PreciseNumber', Label: 'Repulsion',          Default: 8000,  Min: 0,    Max: 100000 },
-		CenterAttraction:   { Type: 'PreciseNumber', Label: 'Center attraction',  Default: 0.01,  Min: 0,    Max: 1     },
-		CoolingFactor:      { Type: 'PreciseNumber', Label: 'Cooling factor',     Default: 0.95,  Min: 0.5,  Max: 1     },
-		InitialTemperature: { Type: 'PreciseNumber', Label: 'Initial temperature', Default: 100,  Min: 1,    Max: 1000  },
-		Seed:               { Type: 'Number',        Label: 'Random seed',        Default: 42,    Min: 0,    Max: 2147483647 },
-		PreservePositions:  { Type: 'boolean',       Label: 'Preserve positions', Default: false },
-		InitialSpread:      { Type: 'PreciseNumber', Label: 'Initial spread',     Default: 400,   Min: 0,    Max: 5000  }
-	},
-
-	ParameterManifest:
-	{
-		Scope: 'PictFlowLayout-ForcedFromCenter',
-		Sections:
-		[
-			{ Name: 'Center', Hash: 'PFLCenterSection', Groups: [{ Name: 'Defaults', Hash: 'PFLCenterGroup' }] },
-			{ Name: 'Forces', Hash: 'PFLForcesSection', Groups: [{ Name: 'Defaults', Hash: 'PFLForcesGroup' }] },
-			{ Name: 'Simulation', Hash: 'PFLSimSection', Groups: [{ Name: 'Defaults', Hash: 'PFLSimGroup' }] },
-			{ Name: 'Initialization', Hash: 'PFLInitSection', Groups: [{ Name: 'Defaults', Hash: 'PFLInitGroup' }] }
-		],
-		Descriptors:
-		{
-			'PictFlowLayoutEditor.Parameters.Spacing':
-			{ Name: 'Spacing (multiplier)', Hash: 'Spacing', DataType: 'PreciseNumber', Default: 1.0, PictForm: { Section: 'PFLCenterSection', Group: 'PFLCenterGroup', Row: 0, Width: 12, Min: 0.1, Max: 5 } },
-			'PictFlowLayoutEditor.Parameters.CenterX':
-			{ Name: 'Center X', Hash: 'CenterX', DataType: 'PreciseNumber', Default: 1000, PictForm: { Section: 'PFLCenterSection', Group: 'PFLCenterGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.CenterY':
-			{ Name: 'Center Y', Hash: 'CenterY', DataType: 'PreciseNumber', Default: 750, PictForm: { Section: 'PFLCenterSection', Group: 'PFLCenterGroup', Row: 1, Width: 6, Min: -10000, Max: 10000 } },
-			'PictFlowLayoutEditor.Parameters.CenterAttraction':
-			{ Name: 'Center attraction', Hash: 'CenterAttraction', DataType: 'PreciseNumber', Default: 0.01, PictForm: { Section: 'PFLCenterSection', Group: 'PFLCenterGroup', Row: 2, Width: 12, Min: 0, Max: 1 } },
-
-			'PictFlowLayoutEditor.Parameters.SpringLength':
-			{ Name: 'Spring length', Hash: 'SpringLength', DataType: 'PreciseNumber', Default: 200, PictForm: { Section: 'PFLForcesSection', Group: 'PFLForcesGroup', Row: 1, Width: 6, Min: 1, Max: 2000 } },
-			'PictFlowLayoutEditor.Parameters.SpringStiffness':
-			{ Name: 'Spring stiffness', Hash: 'SpringStiffness', DataType: 'PreciseNumber', Default: 0.05, PictForm: { Section: 'PFLForcesSection', Group: 'PFLForcesGroup', Row: 1, Width: 6, Min: 0, Max: 1 } },
-			'PictFlowLayoutEditor.Parameters.Repulsion':
-			{ Name: 'Repulsion', Hash: 'Repulsion', DataType: 'PreciseNumber', Default: 8000, PictForm: { Section: 'PFLForcesSection', Group: 'PFLForcesGroup', Row: 2, Width: 12, Min: 0, Max: 100000 } },
-
-			'PictFlowLayoutEditor.Parameters.Iterations':
-			{ Name: 'Iterations', Hash: 'Iterations', DataType: 'Number', Default: 200, PictForm: { Section: 'PFLSimSection', Group: 'PFLSimGroup', Row: 1, Width: 6, Min: 1, Max: 2000 } },
-			'PictFlowLayoutEditor.Parameters.CoolingFactor':
-			{ Name: 'Cooling factor', Hash: 'CoolingFactor', DataType: 'PreciseNumber', Default: 0.95, PictForm: { Section: 'PFLSimSection', Group: 'PFLSimGroup', Row: 1, Width: 6, Min: 0.5, Max: 1 } },
-			'PictFlowLayoutEditor.Parameters.InitialTemperature':
-			{ Name: 'Initial temperature', Hash: 'InitialTemperature', DataType: 'PreciseNumber', Default: 100, PictForm: { Section: 'PFLSimSection', Group: 'PFLSimGroup', Row: 2, Width: 12, Min: 1, Max: 1000 } },
-
-			'PictFlowLayoutEditor.Parameters.Seed':
-			{ Name: 'Random seed', Hash: 'Seed', DataType: 'Number', Default: 42, PictForm: { Section: 'PFLInitSection', Group: 'PFLInitGroup', Row: 1, Width: 6, Min: 0, Max: 2147483647 } },
-			'PictFlowLayoutEditor.Parameters.InitialSpread':
-			{ Name: 'Initial spread', Hash: 'InitialSpread', DataType: 'PreciseNumber', Default: 400, PictForm: { Section: 'PFLInitSection', Group: 'PFLInitGroup', Row: 1, Width: 6, Min: 0, Max: 5000 } },
-			'PictFlowLayoutEditor.Parameters.PreservePositions':
-			{ Name: 'Preserve existing positions', Hash: 'PreservePositions', DataType: 'Boolean', Default: false, PictForm: { Section: 'PFLInitSection', Group: 'PFLInitGroup', Row: 2, Width: 12, InputType: 'Boolean' } }
-		}
-	}
-};
-
-function _makeMulberry32(pSeed)
-{
-	let tmpState = pSeed >>> 0;
-	return function ()
-	{
-		tmpState = (tmpState + 0x6D2B79F5) >>> 0;
-		let tmpT = tmpState;
-		tmpT = Math.imul(tmpT ^ (tmpT >>> 15), tmpT | 1);
-		tmpT ^= tmpT + Math.imul(tmpT ^ (tmpT >>> 7), tmpT | 61);
-		return ((tmpT ^ (tmpT >>> 14)) >>> 0) / 4294967296;
-	};
-}