@statelyai/layout 0.1.3 → 0.3.0

package/dist/layout-engine-Dn1PiFwP.cjs

@@ -0,0 +1,712 @@
+const require_layered = require('./layered-B2buJqMf.cjs');
+let _statelyai_graph_layout = require("@statelyai/graph/layout");
+
+//#region src/fixed.ts
+function defaultRoute(source, target) {
+	return [{
+		x: source.x + source.width / 2,
+		y: source.y + source.height / 2
+	}, {
+		x: target.x + target.width / 2,
+		y: target.y + target.height / 2
+	}];
+}
+/** Preserve authored positions and routes while completing visual geometry. */
+function getFixedLayout(graph, options = {}) {
+	const direction = options.direction ?? graph.direction ?? "down";
+	const nodes = graph.nodes.map((node) => {
+		const size = (0, _statelyai_graph_layout.getNodeSize)(node, options);
+		const rect = {
+			x: node.x ?? 0,
+			y: node.y ?? 0,
+			...size
+		};
+		const ports = require_layered.placePorts(node.ports, rect, direction);
+		return {
+			...node,
+			...rect,
+			...ports === void 0 ? {} : { ports }
+		};
+	});
+	const nodeById = new Map(nodes.map((node) => [node.id, node]));
+	const edges = graph.edges.map((edge) => {
+		const source = nodeById.get(edge.sourceId);
+		const target = nodeById.get(edge.targetId);
+		const points = edge.points ? [...edge.points] : source && target ? defaultRoute(source, target) : [];
+		const midpoint = require_layered.getPolylineMidpoint(points);
+		const width = edge.width ?? 0;
+		const height = edge.height ?? 0;
+		return {
+			...edge,
+			x: edge.x ?? midpoint.x - width / 2,
+			y: edge.y ?? midpoint.y - height / 2,
+			width,
+			height,
+			points,
+			routing: edge.routing ?? "polyline"
+		};
+	});
+	return {
+		...graph,
+		direction,
+		nodes,
+		edges
+	};
+}
+const fixedAlgorithm = {
+	id: "fixed",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: true,
+		ports: true
+	},
+	layout(graph, options) {
+		return getFixedLayout(graph, options ?? {});
+	}
+};
+
+//#endregion
+//#region src/internal/elkjs-compatibility.ts
+const elkjs0111ResultPolicy = Symbol("elkjs0111ResultPolicy");
+function setElkjs0111ResultPolicy(graph, policy) {
+	Object.defineProperty(graph, elkjs0111ResultPolicy, { value: policy });
+	return graph;
+}
+
+//#endregion
+//#region src/box.ts
+function getPadding$3(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	return {
+		top: value?.top ?? 15,
+		right: value?.right ?? 15,
+		bottom: value?.bottom ?? 15,
+		left: value?.left ?? 15
+	};
+}
+function standardDeviation(values, mean) {
+	if (values.length < 2) return 0;
+	const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0);
+	return Math.sqrt(variance / (values.length - 1));
+}
+/** ELK Box SIMPLE packing translated onto `@statelyai/graph`. */
+function getBoxLayout(graph, options = {}) {
+	const spacing = Math.fround(options.spacing ?? 15);
+	const padding = getPadding$3(options.padding);
+	const aspectRatio = (options.aspectRatio ?? 1.3) > 0 ? options.aspectRatio ?? 1.3 : 1.3;
+	const sizes = new Map(graph.nodes.map((node) => [node.id, (0, _statelyai_graph_layout.getNodeSize)(node, options)]));
+	const sortedNodes = [...graph.nodes].sort((first, second) => {
+		const priorityDifference = (options.priority?.(second) ?? 0) - (options.priority?.(first) ?? 0);
+		if (priorityDifference !== 0) return priorityDifference;
+		if (options.interactive) {
+			const yDifference = (first.y ?? 0) - (second.y ?? 0);
+			if (yDifference !== 0) return yDifference;
+			const xDifference = (first.x ?? 0) - (second.x ?? 0);
+			if (xDifference !== 0) return xDifference;
+		}
+		const firstSize = sizes.get(first.id) ?? {
+			width: 0,
+			height: 0
+		};
+		const secondSize = sizes.get(second.id) ?? {
+			width: 0,
+			height: 0
+		};
+		return firstSize.width * firstSize.height - secondSize.width * secondSize.height;
+	});
+	const areas = sortedNodes.map((node) => {
+		const size = sizes.get(node.id) ?? {
+			width: 0,
+			height: 0
+		};
+		return size.width * size.height;
+	});
+	let totalArea = areas.reduce((sum, area) => sum + area, 0);
+	const mean = areas.length === 0 ? 0 : totalArea / areas.length;
+	totalArea += areas.length * standardDeviation(areas, mean);
+	totalArea += Math.sqrt(totalArea) * (padding.bottom + padding.top);
+	totalArea += Math.sqrt(totalArea) * padding.right;
+	const widestNode = Math.max(0, ...sortedNodes.map((node) => sizes.get(node.id)?.width ?? 0));
+	const maximumRowWidth = Math.max(widestNode, Math.sqrt(totalArea * aspectRatio)) + padding.left;
+	let x = padding.left;
+	let y = padding.top;
+	let rowHeight = 0;
+	let rowStart = 0;
+	const rows = [];
+	const nodes = [];
+	for (const node of sortedNodes) {
+		const size = sizes.get(node.id) ?? {
+			width: 0,
+			height: 0
+		};
+		if (x + size.width > maximumRowWidth) {
+			rows.push({
+				start: rowStart,
+				end: nodes.length,
+				height: rowHeight
+			});
+			rowStart = nodes.length;
+			x = padding.left;
+			y += rowHeight + spacing;
+			rowHeight = 0;
+		}
+		nodes.push({
+			...node,
+			x,
+			y,
+			...size
+		});
+		x += size.width + spacing;
+		rowHeight = Math.max(rowHeight, size.height);
+	}
+	rows.push({
+		start: rowStart,
+		end: nodes.length,
+		height: rowHeight
+	});
+	if (options.expandNodes) {
+		const broadestRow = Math.max(padding.left + padding.right, ...nodes.map((node) => node.x + node.width + padding.right));
+		for (const row of rows) for (let index = row.start; index < row.end; index++) {
+			const node = nodes[index];
+			if (!node) continue;
+			node.height = row.height;
+			if (index === row.end - 1) node.width = broadestRow - node.x - padding.right;
+		}
+	}
+	const placedById = new Map(nodes.map((node) => [node.id, node]));
+	return getFixedLayout({
+		...graph,
+		nodes: graph.nodes.map((node) => placedById.get(node.id) ?? node)
+	}, { direction: options.direction ?? graph.direction });
+}
+const boxAlgorithm = {
+	id: "box",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: false,
+		ports: true
+	},
+	layout(graph, options) {
+		return getBoxLayout(graph, options ?? {});
+	}
+};
+/** Pinned behavior used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111BoxAlgorithm = {
+	...boxAlgorithm,
+	layout(graph, options = {}) {
+		const result = getBoxLayout(graph, options);
+		const padding = getPadding$3(options.padding);
+		return setElkjs0111ResultPolicy(result, {
+			providerBounds: result.nodes.length === 0 ? {
+				width: 0,
+				height: 0
+			} : {
+				width: Math.max(...result.nodes.map((node) => node.x + node.width)) + padding.right,
+				height: Math.max(...result.nodes.map((node) => node.y + node.height)) + padding.bottom
+			},
+			preserveEdgeSections: true,
+			skipBoundsNormalization: true
+		});
+	}
+};
+
+//#endregion
+//#region src/packing.ts
+function getPadding$2(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	return {
+		top: value?.top ?? 0,
+		right: value?.right ?? 0,
+		bottom: value?.bottom ?? 0,
+		left: value?.left ?? 0
+	};
+}
+/** Deterministic shelf-based rectangle packing for `@statelyai/graph`. */
+function getRectanglePackingLayout(graph, options = {}) {
+	const spacing = options.spacing ?? 20;
+	const padding = getPadding$2(options.padding);
+	const sizes = new Map(graph.nodes.map((node) => [node.id, (0, _statelyai_graph_layout.getNodeSize)(node, options)]));
+	const totalArea = [...sizes.values()].reduce((area, size) => area + (size.width + spacing) * (size.height + spacing), 0);
+	const targetWidth = options.targetWidth ?? Math.max(1, Math.sqrt(totalArea) * 1.5);
+	let x = padding.left;
+	let y = padding.top;
+	let rowHeight = 0;
+	const nodes = [];
+	for (const node of graph.nodes) {
+		const size = sizes.get(node.id) ?? {
+			width: 0,
+			height: 0
+		};
+		if (x > padding.left && x + size.width > padding.left + targetWidth) {
+			x = padding.left;
+			y += rowHeight + spacing;
+			rowHeight = 0;
+		}
+		nodes.push({
+			...node,
+			x,
+			y,
+			...size
+		});
+		x += size.width + spacing;
+		rowHeight = Math.max(rowHeight, size.height);
+	}
+	return getFixedLayout({
+		...graph,
+		nodes
+	}, { direction: options.direction ?? graph.direction });
+}
+const rectanglePackingAlgorithm = {
+	id: "rectpacking",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: false,
+		ports: true
+	},
+	layout(graph, options) {
+		return getRectanglePackingLayout(graph, options ?? {});
+	}
+};
+/** Pinned output policy used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111RectanglePackingAlgorithm = {
+	...rectanglePackingAlgorithm,
+	layout(graph, options = {}) {
+		const result = getRectanglePackingLayout(graph, options);
+		const padding = getPadding$2(options.padding);
+		return setElkjs0111ResultPolicy(result, {
+			providerBounds: result.nodes.length === 0 ? {
+				width: 0,
+				height: 0
+			} : {
+				width: Math.max(...result.nodes.map((node) => node.x + node.width)) + padding.right,
+				height: Math.max(...result.nodes.map((node) => node.y + node.height)) + padding.bottom
+			},
+			preserveEdgeSections: true,
+			skipBoundsNormalization: true
+		});
+	}
+};
+
+//#endregion
+//#region src/random.ts
+const nativeBehavior = {
+	elkjs0111EdgeTargetBug: false,
+	preserveProviderBounds: false
+};
+const elkjs0111Behavior = {
+	elkjs0111EdgeTargetBug: true,
+	preserveProviderBounds: true
+};
+function getPadding$1(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	return {
+		top: value?.top ?? 15,
+		right: value?.right ?? 15,
+		bottom: value?.bottom ?? 15,
+		left: value?.left ?? 15
+	};
+}
+function borderPoint(source, target) {
+	const sourceCenter = {
+		x: source.x + source.width / 2,
+		y: source.y + source.height / 2
+	};
+	const targetCenter = {
+		x: target.x + target.width / 2,
+		y: target.y + target.height / 2
+	};
+	const dx = targetCenter.x - sourceCenter.x;
+	const dy = targetCenter.y - sourceCenter.y;
+	if (dx === 0 && dy === 0) return {
+		x: source.x + source.width,
+		y: sourceCenter.y
+	};
+	const scale = Math.min(dx === 0 ? Infinity : source.width / 2 / Math.abs(dx), dy === 0 ? Infinity : source.height / 2 / Math.abs(dy));
+	return {
+		x: sourceCenter.x + dx * scale,
+		y: sourceCenter.y + dy * scale
+	};
+}
+/** Seeded random distribution using Java's 48-bit `Random` sequence. */
+function getRandomLayout(graph, options = {}) {
+	return getRandomLayoutWithBehavior(graph, options, nativeBehavior);
+}
+function getRandomLayoutWithBehavior(graph, options, behavior) {
+	if (graph.nodes.length === 0) return getFixedLayout(graph, options);
+	const random = new require_layered.JavaRandom(options.seed && options.seed !== 0 ? options.seed : Date.now());
+	const aspectRatio = Math.fround(options.aspectRatio ?? 1.6);
+	const spacing = Math.fround(options.spacing ?? 15);
+	const padding = getPadding$1(options.padding);
+	const sizes = new Map(graph.nodes.map((node) => [node.id, (0, _statelyai_graph_layout.getNodeSize)(node, options)]));
+	const nodeArea = [...sizes.values()].reduce((sum, size) => sum + size.width * size.height, 0);
+	const maximumWidth = Math.max(...[...sizes.values()].map((size) => size.width));
+	const maximumHeight = Math.max(...[...sizes.values()].map((size) => size.height));
+	const edgeFactor = 1 + graph.edges.length;
+	const drawArea = nodeArea + 2 * spacing * spacing * edgeFactor * graph.nodes.length;
+	const areaRoot = Math.sqrt(drawArea);
+	const drawWidth = Math.max(areaRoot * aspectRatio, maximumWidth);
+	const drawHeight = Math.max(areaRoot / aspectRatio, maximumHeight);
+	const nodes = graph.nodes.map((node) => {
+		const size = sizes.get(node.id) ?? {
+			width: 0,
+			height: 0
+		};
+		return {
+			...node,
+			x: padding.left + random.nextDouble() * (drawWidth - size.width),
+			y: padding.left + random.nextDouble() * (drawHeight - size.height),
+			...size
+		};
+	});
+	const nodeById = new Map(nodes.map((node) => [node.id, node]));
+	const totalWidth = drawWidth + padding.left + padding.right;
+	const totalHeight = drawHeight + padding.top + padding.bottom;
+	const layoutEdge = (edge) => {
+		const source = nodeById.get(edge.sourceId);
+		const target = nodeById.get(edge.targetId);
+		if (!source || !target) return edge;
+		if (behavior.elkjs0111EdgeTargetBug) {
+			const start$1 = {
+				x: source.x + source.width,
+				y: source.y + source.height / 2
+			};
+			const end$1 = {
+				x: source.x + source.width / 2,
+				y: source.y + source.height
+			};
+			const bendCount$1 = random.nextInt(5) + 1;
+			const xDifference = end$1.x - start$1.x;
+			const yDifference = end$1.y - start$1.y;
+			const maximumDeviation$1 = Math.hypot(xDifference, yDifference) * Math.fround(.2);
+			const xIncrement = xDifference / (bendCount$1 + 1);
+			const yIncrement = yDifference / (bendCount$1 + 1);
+			let x = start$1.x;
+			let y = start$1.y;
+			const points$1 = [start$1];
+			for (let index = 0; index < bendCount$1; index++) {
+				x += xIncrement;
+				y += yIncrement;
+				let randomX = x + random.nextFloat() * maximumDeviation$1 - maximumDeviation$1 / 2;
+				if (randomX < 0) randomX = 1;
+				else if (randomX > totalWidth) randomX = totalWidth - 1;
+				let randomY = y + random.nextFloat() * maximumDeviation$1 - maximumDeviation$1 / 2;
+				if (randomY < 0) randomY = 1;
+				else if (randomY > totalHeight) randomY = totalHeight - 1;
+				points$1.push({
+					x: randomX,
+					y: randomY
+				});
+			}
+			points$1.push(end$1);
+			return {
+				...edge,
+				points: points$1,
+				routing: "polyline"
+			};
+		}
+		const start = borderPoint(source, target);
+		const end = borderPoint(target, source);
+		const bendCount = random.nextInt(5) + (source === target ? 1 : 0);
+		const maximumDeviation = Math.hypot(end.x - start.x, end.y - start.y) * .2;
+		const points = [start];
+		for (let index = 1; index <= bendCount; index++) {
+			const progress = index / (bendCount + 1);
+			points.push({
+				x: Math.min(totalWidth - 1, Math.max(1, start.x + (end.x - start.x) * progress + random.nextFloat() * maximumDeviation - maximumDeviation / 2)),
+				y: Math.min(totalHeight - 1, Math.max(1, start.y + (end.y - start.y) * progress + random.nextFloat() * maximumDeviation - maximumDeviation / 2))
+			});
+		}
+		points.push(end);
+		return {
+			...edge,
+			points,
+			routing: "polyline"
+		};
+	};
+	const edges = behavior.elkjs0111EdgeTargetBug ? graph.nodes.flatMap((node) => graph.edges.filter((edge) => edge.sourceId === node.id).map(layoutEdge)) : graph.edges.map(layoutEdge);
+	const result = getFixedLayout({
+		...graph,
+		nodes,
+		edges
+	}, { direction: options.direction ?? graph.direction });
+	if (behavior.preserveProviderBounds) setElkjs0111ResultPolicy(result, { providerBounds: {
+		width: drawWidth + 2 * (padding.left + padding.right),
+		height: drawHeight + 2 * (padding.top + padding.bottom)
+	} });
+	return result;
+}
+const randomAlgorithm = {
+	id: "random",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: false,
+		ports: false
+	},
+	layout(graph, options) {
+		return getRandomLayout(graph, options ?? {});
+	}
+};
+/** Pinned behavior used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111RandomAlgorithm = {
+	...randomAlgorithm,
+	layout(graph, options) {
+		return getRandomLayoutWithBehavior(graph, options ?? {}, elkjs0111Behavior);
+	}
+};
+
+//#endregion
+//#region src/spore.ts
+function getPadding(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	return {
+		top: value?.top ?? 0,
+		right: value?.right ?? 0,
+		bottom: value?.bottom ?? 0,
+		left: value?.left ?? 0
+	};
+}
+function getSporeLayout(graph, options, compact) {
+	const spacing = options.spacing ?? 20;
+	const padding = getPadding(options.padding);
+	const nodes = [];
+	graph.nodes.forEach((node, index) => {
+		const size = (0, _statelyai_graph_layout.getNodeSize)(node, options);
+		const previous = graph.nodes[index - 1];
+		const placedPrevious = nodes[index - 1];
+		if (!previous || !placedPrevious) {
+			nodes.push({
+				...node,
+				x: padding.left,
+				y: padding.top,
+				...size
+			});
+			return;
+		}
+		const deltaX = (node.x ?? 0) - (previous.x ?? 0);
+		const deltaY = (node.y ?? 0) - (previous.y ?? 0);
+		const requiredX = placedPrevious.width + spacing;
+		const requiredY = placedPrevious.height + spacing;
+		const distance = (delta, required) => {
+			if (delta === 0) return 0;
+			const magnitude = compact ? required : Math.max(Math.abs(delta), required);
+			return Math.sign(delta) * magnitude;
+		};
+		nodes.push({
+			...node,
+			x: placedPrevious.x + distance(deltaX, requiredX),
+			y: placedPrevious.y + distance(deltaY, requiredY),
+			...size
+		});
+	});
+	return getFixedLayout({
+		...graph,
+		nodes
+	}, { direction: options.direction ?? graph.direction });
+}
+/** Compact an existing layout while preserving its relative directions. */
+function getSporeCompactionLayout(graph, options = {}) {
+	return getSporeLayout(graph, options, true);
+}
+/** Remove overlap while preserving existing distances that already fit. */
+function getSporeOverlapRemovalLayout(graph, options = {}) {
+	return getSporeLayout(graph, options, false);
+}
+function algorithm(id, compact) {
+	return {
+		id,
+		capabilities: {
+			full: true,
+			incremental: false,
+			partial: false,
+			routeOnly: false,
+			hierarchy: false,
+			ports: true
+		},
+		layout(graph, options) {
+			return getSporeLayout(graph, options ?? {}, compact);
+		}
+	};
+}
+const sporeCompactionAlgorithm = algorithm("sporeCompaction", true);
+const sporeOverlapRemovalAlgorithm = algorithm("sporeOverlap", false);
+
+//#endregion
+//#region src/internal/layout-engine.ts
+const builtInLayoutAlgorithms = {
+	box: boxAlgorithm,
+	fixed: fixedAlgorithm,
+	layered: require_layered.layeredAlgorithm,
+	random: randomAlgorithm,
+	rectpacking: rectanglePackingAlgorithm,
+	sporeCompaction: sporeCompactionAlgorithm,
+	sporeOverlap: sporeOverlapRemovalAlgorithm
+};
+const elkjs0111LayoutAlgorithms = {
+	...builtInLayoutAlgorithms,
+	box: elkjs0111BoxAlgorithm,
+	random: elkjs0111RandomAlgorithm,
+	rectpacking: elkjs0111RectanglePackingAlgorithm
+};
+function getBuiltInLayoutAlgorithm(id) {
+	if (!Object.hasOwn(builtInLayoutAlgorithms, id)) return void 0;
+	return builtInLayoutAlgorithms[id];
+}
+/** Execute one algorithm through the shared engine seam. */
+function executeLayoutAlgorithm({ algorithm: algorithm$1, graph, options, context }) {
+	return algorithm$1.layout(graph, options, context);
+}
+function createDirectExecutionContext() {
+	return {
+		scope: { mode: "full" },
+		diagnostics: [],
+		measurePhase(_id, run) {
+			return run();
+		},
+		throwIfAborted() {}
+	};
+}
+/** Execute through the pinned elkjs 0.11.1 compatibility policy. */
+function executeElkjs0111Layout({ algorithm: algorithm$1, graph, options }) {
+	return executeLayoutAlgorithm({
+		algorithm: elkjs0111LayoutAlgorithms[algorithm$1],
+		graph,
+		options,
+		context: createDirectExecutionContext()
+	});
+}
+
+//#endregion
+Object.defineProperty(exports, 'boxAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return boxAlgorithm;
+  }
+});
+Object.defineProperty(exports, 'builtInLayoutAlgorithms', {
+  enumerable: true,
+  get: function () {
+    return builtInLayoutAlgorithms;
+  }
+});
+Object.defineProperty(exports, 'elkjs0111ResultPolicy', {
+  enumerable: true,
+  get: function () {
+    return elkjs0111ResultPolicy;
+  }
+});
+Object.defineProperty(exports, 'executeElkjs0111Layout', {
+  enumerable: true,
+  get: function () {
+    return executeElkjs0111Layout;
+  }
+});
+Object.defineProperty(exports, 'executeLayoutAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return executeLayoutAlgorithm;
+  }
+});
+Object.defineProperty(exports, 'fixedAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return fixedAlgorithm;
+  }
+});
+Object.defineProperty(exports, 'getBoxLayout', {
+  enumerable: true,
+  get: function () {
+    return getBoxLayout;
+  }
+});
+Object.defineProperty(exports, 'getBuiltInLayoutAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return getBuiltInLayoutAlgorithm;
+  }
+});
+Object.defineProperty(exports, 'getFixedLayout', {
+  enumerable: true,
+  get: function () {
+    return getFixedLayout;
+  }
+});
+Object.defineProperty(exports, 'getRandomLayout', {
+  enumerable: true,
+  get: function () {
+    return getRandomLayout;
+  }
+});
+Object.defineProperty(exports, 'getRectanglePackingLayout', {
+  enumerable: true,
+  get: function () {
+    return getRectanglePackingLayout;
+  }
+});
+Object.defineProperty(exports, 'getSporeCompactionLayout', {
+  enumerable: true,
+  get: function () {
+    return getSporeCompactionLayout;
+  }
+});
+Object.defineProperty(exports, 'getSporeOverlapRemovalLayout', {
+  enumerable: true,
+  get: function () {
+    return getSporeOverlapRemovalLayout;
+  }
+});
+Object.defineProperty(exports, 'randomAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return randomAlgorithm;
+  }
+});
+Object.defineProperty(exports, 'rectanglePackingAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return rectanglePackingAlgorithm;
+  }
+});
+Object.defineProperty(exports, 'sporeCompactionAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return sporeCompactionAlgorithm;
+  }
+});
+Object.defineProperty(exports, 'sporeOverlapRemovalAlgorithm', {
+  enumerable: true,
+  get: function () {
+    return sporeOverlapRemovalAlgorithm;
+  }
+});