===================================================================
--- original.js
+++ change.js
@@ -829,143 +829,8 @@
 
 /**** 
 * Game Code
 ****/ 
-function _typeof2(o) {
-	"@babel/helpers - typeof";
-	return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-		return typeof o;
-	} : function (o) {
-		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-	}, _typeof2(o);
-}
-function _slicedToArray2(r, e) {
-	return _arrayWithHoles2(r) || _iterableToArrayLimit2(r, e) || _unsupportedIterableToArray2(r, e) || _nonIterableRest2();
-}
-function _nonIterableRest2() {
-	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _iterableToArrayLimit2(r, l) {
-	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-	if (null != t) {
-		var e,
-			n,
-			i,
-			u,
-			a = [],
-			f = !0,
-			o = !1;
-		try {
-			if (i = (t = t.call(r)).next, 0 === l) {
-				if (Object(t) !== t) {
-					return;
-				}
-				f = !1;
-			} else {
-				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
-					;
-				}
-			}
-		} catch (r) {
-			o = !0, n = r;
-		} finally {
-			try {
-				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
-					return;
-				}
-			} finally {
-				if (o) {
-					throw n;
-				}
-			}
-		}
-		return a;
-	}
-}
-function _arrayWithHoles2(r) {
-	if (Array.isArray(r)) {
-		return r;
-	}
-}
-function _toConsumableArray(r) {
-	return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray2(r) || _nonIterableSpread();
-}
-function _nonIterableSpread() {
-	throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _unsupportedIterableToArray2(r, a) {
-	if (r) {
-		if ("string" == typeof r) {
-			return _arrayLikeToArray2(r, a);
-		}
-		var t = {}.toString.call(r).slice(8, -1);
-		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0;
-	}
-}
-function _iterableToArray(r) {
-	if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) {
-		return Array.from(r);
-	}
-}
-function _arrayWithoutHoles(r) {
-	if (Array.isArray(r)) {
-		return _arrayLikeToArray2(r);
-	}
-}
-function _arrayLikeToArray2(r, a) {
-	(null == a || a > r.length) && (a = r.length);
-	for (var e = 0, n = Array(a); e < a; e++) {
-		n[e] = r[e];
-	}
-	return n;
-}
-function ownKeys(e, r) {
-	var t = Object.keys(e);
-	if (Object.getOwnPropertySymbols) {
-		var o = Object.getOwnPropertySymbols(e);
-		r && (o = o.filter(function (r) {
-			return Object.getOwnPropertyDescriptor(e, r).enumerable;
-		})), t.push.apply(t, o);
-	}
-	return t;
-}
-function _objectSpread(e) {
-	for (var r = 1; r < arguments.length; r++) {
-		var t = null != arguments[r] ? arguments[r] : {};
-		r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
-			_defineProperty2(e, r, t[r]);
-		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
-			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-		});
-	}
-	return e;
-}
-function _defineProperty2(e, r, t) {
-	return (r = _toPropertyKey2(r)) in e ? Object.defineProperty(e, r, {
-		value: t,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : e[r] = t, e;
-}
-function _toPropertyKey2(t) {
-	var i = _toPrimitive2(t, "string");
-	return "symbol" == _typeof2(i) ? i : i + "";
-}
-function _toPrimitive2(t, r) {
-	if ("object" != _typeof2(t) || !t) {
-		return t;
-	}
-	var e = t[Symbol.toPrimitive];
-	if (void 0 !== e) {
-		var i = e.call(t, r || "default");
-		if ("object" != _typeof2(i)) {
-			return i;
-		}
-		throw new TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return ("string" === r ? String : Number)(t);
-}
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
 		return typeof o;
@@ -1844,92 +1709,98 @@
 	}
 }
 // Start the game
 initializeGame();
-// Level generator function that creates progressively challenging levels
-function generateNextLevel(existingLevels) {
-	// Get the last level configuration as base
-	if (!existingLevels || existingLevels.length === 0) {
-		throw new Error("No existing levels to base the new level on.");
+/////////
+// Helper function to check if a tile is start or end
+var isStartOrEnd = function isStartOrEnd(tileType) {
+	return tileType === 'start' || tileType === 'end';
+};
+// Helper function to deep clone a level configuration
+var cloneLevelConfig = function cloneLevelConfig(level) {
+	var newTiles = [];
+	var i, j;
+	for (i = 0; i < level.tiles.length; i++) {
+		newTiles[i] = [];
+		for (j = 0; j < level.tiles[i].length; j++) {
+			newTiles[i][j] = level.tiles[i][j];
+		}
 	}
-	var lastLevel = existingLevels && existingLevels.length > 0 ? existingLevels[existingLevels.length - 1] : null;
-	if (!lastLevel || !lastLevel.tiles || !lastLevel.rotations || !lastLevel.fixedTiles) {
-		throw new Error("No valid last level found to base the new level on.");
+	var newRotations = {};
+	for (var key in level.rotations) {
+		if (level.rotations.hasOwnProperty(key)) {
+			newRotations[key] = level.rotations[key];
+		}
 	}
-	// Deep clone the last level to avoid modifying it
-	var newLevel = {
-		tiles: JSON.parse(JSON.stringify(lastLevel.tiles)),
-		rotations: _objectSpread({}, lastLevel.rotations),
-		fixedTiles: _toConsumableArray(lastLevel.fixedTiles)
+	var newFixedTiles = level.fixedTiles.slice();
+	return {
+		tiles: newTiles,
+		rotations: newRotations,
+		fixedTiles: newFixedTiles
 	};
-	// Find empty spaces in the grid
+};
+// Level generator function
+var generateNextLevel = function generateNextLevel(existingLevels) {
+	var lastLevel = existingLevels[existingLevels.length - 1];
+	var newLevel = cloneLevelConfig(lastLevel);
+	var gridSize = 4;
 	var emptySpaces = [];
-	for (var y = 0; y < 4; y++) {
-		for (var x = 0; x < 4; x++) {
+	var x, y, i;
+	// Find empty spaces
+	for (y = 0; y < gridSize; y++) {
+		for (x = 0; x < gridSize; x++) {
 			if (!newLevel.tiles[y][x] && !isStartOrEnd(newLevel.tiles[y][x])) {
 				emptySpaces.push([x, y]);
 			}
 		}
 	}
-	// Add 1-2 new pipes in empty spaces
+	// Add 1-2 new pipes
 	var numNewPipes = Math.min(1 + Math.floor(Math.random() * 2), emptySpaces.length);
-	for (var i = 0; i < numNewPipes; i++) {
-		var spaceIndex = Math.floor(Math.random() * emptySpaces.length);
-		var _emptySpaces$spaceInd = _slicedToArray2(emptySpaces[spaceIndex], 2),
-			x = _emptySpaces$spaceInd[0],
-			y = _emptySpaces$spaceInd[1];
+	var pipeTypes = ['straightPipeH', 'straightPipeV', 'cornerPipe'];
+	var spaceIndex, selectedSpace, newPipe;
+	for (i = 0; i < numNewPipes; i++) {
+		spaceIndex = Math.floor(Math.random() * emptySpaces.length);
+		selectedSpace = emptySpaces[spaceIndex];
 		emptySpaces.splice(spaceIndex, 1);
-		// Add either straightPipeH, straightPipeV, or cornerPipe
-		var pipeTypes = ['straightPipeH', 'straightPipeV', 'cornerPipe'];
-		var newPipe = pipeTypes[Math.floor(Math.random() * pipeTypes.length)];
-		newLevel.tiles[y][x] = newPipe;
-		// If it's a corner pipe, add rotation
+		// Add new pipe
+		newPipe = pipeTypes[Math.floor(Math.random() * pipeTypes.length)];
+		newLevel.tiles[selectedSpace[1]][selectedSpace[0]] = newPipe;
+		// Add rotation for corner pipes
 		if (newPipe === 'cornerPipe') {
-			newLevel.rotations["".concat(y, ",").concat(x)] = Math.random() < 0.5 ? 'left' : 'right';
+			newLevel.rotations[selectedSpace[1] + ',' + selectedSpace[0]] = Math.random() < 0.5 ? 'left' : 'right';
 		}
 		// 70% chance to make it fixed
 		if (Math.random() < 0.7) {
-			newLevel.fixedTiles.push("".concat(y, ",").concat(x));
+			newLevel.fixedTiles.push(selectedSpace[1] + ',' + selectedSpace[0]);
 		}
 	}
-	// Randomly unfix one previously fixed tile to increase difficulty
+	// Unfix one existing tile to increase difficulty
 	var removableFixed = newLevel.fixedTiles.filter(function (pos) {
-		var _pos$split$map2 = pos.split(',').map(Number),
-			_pos$split$map3 = _slicedToArray2(_pos$split$map2, 2),
-			y = _pos$split$map3[0],
-			x = _pos$split$map3[1];
-		return !isStartOrEnd(newLevel.tiles[y][x]);
+		var coords = pos.split(',');
+		return !isStartOrEnd(newLevel.tiles[coords[0]][coords[1]]);
 	});
 	if (removableFixed.length > 0) {
 		var indexToRemove = Math.floor(Math.random() * removableFixed.length);
 		newLevel.fixedTiles = newLevel.fixedTiles.filter(function (pos) {
 			return pos !== removableFixed[indexToRemove];
 		});
 	}
 	return newLevel;
-}
-// Helper function to check if a tile is start or end
-function isStartOrEnd(tileType) {
-	return tileType === 'start' || tileType === 'end';
-}
-// Get existing levels from the PuzzleManager
-var existingLevels = [
-// Level 1
-{
+};
+// Test data - existing levels
+var testLevels = [{
 	tiles: [['start', 'straightPipeV', 'straightPipeV', 'cornerPipe'], [null, null, null, 'straightPipeH'], [null, null, 'straightPipeH', null], [null, null, null, 'end']],
 	rotations: {
 		'0,3': 'right',
 		'3,3': 'left'
 	},
 	fixedTiles: ['0,0', '0,1', '0,2', '0,3', '1,3', '3,3']
-},
-// Level 2
-{
+}, {
 	tiles: [[null, 'straightPipeH', 'end', null], [null, 'cornerPipe', 'straightPipeH', null], [null, null, null, null], ['start', 'straightPipeV', null, null]],
 	rotations: {
 		'0,2': 'right',
 		'1,1': 'left'
 	},
 	fixedTiles: ['3,0', '3,1', '0,2', '1,2']
 }];
 // Generate and log a new level
-console.log("Generated Level:", generateNextLevel(existingLevels));
\ No newline at end of file
+console.log("Generated Level:", generateNextLevel(testLevels));
\ No newline at end of file