Reformat with prettier

.prettierrc

@@ -0,0 +1,4 @@
+printWidth: 100
+trailingComma: "all"
+bracketSpacing: false
+arrowParens: "avoid"

js/api.js

@@ -1,105 +1,116 @@
 import {measureDistances} from "./compatibility.js";
 import {getMovementHistory} from "./movement_tracking.js";
-import {GenericSpeedProvider, SpeedProvider} from "./speed_provider.js"
+import {GenericSpeedProvider, SpeedProvider} from "./speed_provider.js";
-import {settingsKey} from "./settings.js"
+import {settingsKey} from "./settings.js";
 import {getAreaFromPositionAndShape, getTokenShape} from "./util.js";
 
-export const availableSpeedProviders = {}
+export const availableSpeedProviders = {};
-export let currentSpeedProvider = undefined
+export let currentSpeedProvider = undefined;
 
 function register(module, type, speedProvider) {
-	const id = `${type}.${module.id}`
+	const id = `${type}.${module.id}`;
-	let providerInstance
+	let providerInstance;
 	if (speedProvider.prototype instanceof SpeedProvider) {
-		providerInstance = new speedProvider(id)
+		providerInstance = new speedProvider(id);
-	}
+	} else {
-	else {
+		console.warn(
-		console.warn(`Drag Ruler | The ${type} '${module.id}' uses the old, deprecated version of the Drag Ruler API. ` +
+			`Drag Ruler | The ${type} '${module.id}' uses the old, deprecated version of the Drag Ruler API. ` +
 				"That old API will be removed in a future Drag Ruler version. " +
-		             `Please update the ${type} ${module.id} to stay compatible with future Drag Ruler versions.`);
+				`Please update the ${type} ${module.id} to stay compatible with future Drag Ruler versions.`,
-		speedProvider.id = id
+		);
-		speedProvider.usesRuler = () => true
+		speedProvider.id = id;
-		providerInstance = speedProvider
+		speedProvider.usesRuler = () => true;
+		providerInstance = speedProvider;
 	}
-	setupProvider(providerInstance)
+	setupProvider(providerInstance);
 }
 
 function setupProvider(speedProvider) {
 	if (speedProvider instanceof SpeedProvider) {
-		const unreachableColor = {id: "unreachable", default: speedProvider.defaultUnreachableColor, name: "drag-ruler.settings.speedProviderSettings.color.unreachable.name"}
+		const unreachableColor = {
+			id: "unreachable",
+			default: speedProvider.defaultUnreachableColor,
+			name: "drag-ruler.settings.speedProviderSettings.color.unreachable.name",
+		};
 		for (const color of speedProvider.colors.concat([unreachableColor])) {
 			game.settings.register(settingsKey, `speedProviders.${speedProvider.id}.color.${color.id}`, {
 				config: false,
 				scope: "client",
 				type: Number,
 				default: color.default,
-			})
+			});
 		}
 		for (const setting of speedProvider.settings) {
-			setting.config = false
+			setting.config = false;
-			game.settings.register(settingsKey, `speedProviders.${speedProvider.id}.setting.${setting.id}`, setting)
+			game.settings.register(
+				settingsKey,
+				`speedProviders.${speedProvider.id}.setting.${setting.id}`,
+				setting,
+			);
 		}
 	}
 
-	availableSpeedProviders[speedProvider.id] = speedProvider
+	availableSpeedProviders[speedProvider.id] = speedProvider;
-	game.settings.settings.get("drag-ruler.speedProvider").default = getDefaultSpeedProvider()
+	game.settings.settings.get("drag-ruler.speedProvider").default = getDefaultSpeedProvider();
-	updateSpeedProvider()
+	updateSpeedProvider();
 }
 
 export function getDefaultSpeedProvider() {
-	const providerIds = Object.keys(availableSpeedProviders)
+	const providerIds = Object.keys(availableSpeedProviders);
 	// Game systems take the highest precedence for the being the default
-	const gameSystem = providerIds.find(key => key.startsWith("system."))
+	const gameSystem = providerIds.find(key => key.startsWith("system."));
-	if (gameSystem)
+	if (gameSystem) return gameSystem;
-		return gameSystem
 
 	// If no game system is registered modules are next up.
 	// For lack of a method to select the best module we're just falling back to taking the next best module
 	// settingKeys should always be sorted the same way so this should achive a stable default
-	const module = providerIds.find(key => key.startsWith("module."))
+	const module = providerIds.find(key => key.startsWith("module."));
-	if (module)
+	if (module) return module;
-		return module
 
 	// If neither a game system or a module is found fall back to the native implementation
-	return providerIds[0]
+	return providerIds[0];
 }
 
 export function updateSpeedProvider() {
 	// If the configured provider is registered use that one. If not use the default provider
-	const configuredProvider = game.settings.get("drag-ruler", "speedProvider")
+	const configuredProvider = game.settings.get("drag-ruler", "speedProvider");
-	currentSpeedProvider = availableSpeedProviders[configuredProvider] ?? availableSpeedProviders[game.settings.settings.get("drag-ruler.speedProvider").default]
+	currentSpeedProvider =
+		availableSpeedProviders[configuredProvider] ??
+		availableSpeedProviders[game.settings.settings.get("drag-ruler.speedProvider").default];
 }
 
 export function initApi() {
-	const genericSpeedProviderInstance = new GenericSpeedProvider("native")
+	const genericSpeedProviderInstance = new GenericSpeedProvider("native");
-	setupProvider(genericSpeedProviderInstance)
+	setupProvider(genericSpeedProviderInstance);
 }
 
 export function getRangesFromSpeedProvider(token) {
 	try {
-		if (currentSpeedProvider instanceof Function)
+		if (currentSpeedProvider instanceof Function) return currentSpeedProvider(token, 0x00ff00);
-			return currentSpeedProvider(token, 0x00FF00)
+		const ranges = currentSpeedProvider.getRanges(token);
-		const ranges = currentSpeedProvider.getRanges(token)
 		for (const range of ranges) {
-			range.color = game.settings.get(settingsKey, `speedProviders.${currentSpeedProvider.id}.color.${range.color}`)
+			range.color = game.settings.get(
+				settingsKey,
+				`speedProviders.${currentSpeedProvider.id}.color.${range.color}`,
+			);
 		}
-		return ranges
+		return ranges;
-	}
+	} catch (e) {
-	catch (e) {
+		console.error(e);
-		console.error(e)
+		return [];
-		return []
 	}
 }
 
 export function getUnreachableColorFromSpeedProvider() {
-	if (currentSpeedProvider instanceof Function)
+	if (currentSpeedProvider instanceof Function) return 0xff0000;
-		return 0xFF0000
 	try {
-		return game.settings.get(settingsKey, `speedProviders.${currentSpeedProvider.id}.color.unreachable`)
+		return game.settings.get(
-	}
+			settingsKey,
-	catch (e) {
+			`speedProviders.${currentSpeedProvider.id}.color.unreachable`,
-		console.error(e)
+		);
-		return 0xFF0000
+	} catch (e) {
+		console.error(e);
+		return 0xff0000;
 	}
 }
 
@@ -109,8 +120,7 @@ export function getCostFromSpeedProvider(token, area, options) {
 			return SpeedProvider.prototype.getCostForStep.call(undefined, token, area, options);
 		}
 		return currentSpeedProvider.getCostForStep(token, area, options);
-	}
+	} catch (e) {
-	catch (e) {
 		console.error(e);
 		return 1;
 	}
@@ -120,66 +130,77 @@ export function getColorForDistanceAndToken(distance, token, ranges=null) {
 	if (!ranges) {
 		ranges = getRangesFromSpeedProvider(token);
 	}
-	if (ranges.length === 0)
+	if (ranges.length === 0) return null;
-		return null;
+	const currentRange = ranges.reduce(
-	const currentRange = ranges.reduce((minRange, currentRange) => {
+		(minRange, currentRange) => {
 			if (distance <= currentRange.range && currentRange.range < minRange.range)
 				return currentRange;
 			return minRange;
-	}, {range: Infinity, color: getUnreachableColorFromSpeedProvider()});
+		},
+		{range: Infinity, color: getUnreachableColorFromSpeedProvider()},
+	);
 	return currentRange.color;
 }
 
 export function getMovedDistanceFromToken(token) {
 	const terrainRulerAvailable = game.modules.get("terrain-ruler")?.active;
 	const history = getMovementHistory(token);
-	const segments = Ruler.dragRulerGetRaysFromWaypoints(history, {x: token.x, y: token.y}).map(ray => {return {ray}});
+	const segments = Ruler.dragRulerGetRaysFromWaypoints(history, {x: token.x, y: token.y}).map(
+		ray => {
+			return {ray};
+		},
+	);
 	const shape = getTokenShape(token);
-	const distances = measureDistances(segments, token, shape, {enableTerrainRuler: terrainRulerAvailable});
+	const distances = measureDistances(segments, token, shape, {
+		enableTerrainRuler: terrainRulerAvailable,
+	});
 	// Sum up the distances
 	return distances.reduce((acc, val) => acc + val, 0);
 }
 
 export function buildCostFunction(token, shape) {
-	return (x, y, costOptions={}) => getCostFromSpeedProvider(token, getAreaFromPositionAndShape({x, y}, shape), costOptions);
+	return (x, y, costOptions = {}) =>
+		getCostFromSpeedProvider(token, getAreaFromPositionAndShape({x, y}, shape), costOptions);
 }
 
 export function registerModule(moduleId, speedProvider) {
 	// Check if a module with the given id exists and is currently enabled
-	const module = game.modules.get(moduleId)
+	const module = game.modules.get(moduleId);
 	// If it doesn't the calling module did something wrong. Log a warning and ignore this module
 	if (!module) {
 		console.warn(
 			`Drag Ruler | A module tried to register with the id "${moduleId}". However no active module with this id was found.` +
 				"This api registration call was ignored. " +
 				"If you are the author of that module please check that the id passed to `registerModule` matches the id in your manifest exactly." +
-			"If this call was made form a game system instead of a module please use `registerSystem` instead.")
+				"If this call was made form a game system instead of a module please use `registerSystem` instead.",
-		return
+		);
+		return;
 	}
 	// Using Drag Ruler's id is not allowed
 	if (moduleId === "drag-ruler") {
 		console.warn(
 			`Drag Ruler | A module tried to register with the id "${moduleId}", which is not allowed. This api registration call was ignored. ` +
 				"If you're the author of the module please use the id of your own module as it's specified in your manifest to register to this api. " +
-			"If this call was made form a game system instead of a module please use `registerSystem` instead."
+				"If this call was made form a game system instead of a module please use `registerSystem` instead.",
-		)
+		);
-		return
+		return;
 	}
 
-	register(module, "module", speedProvider)
+	register(module, "module", speedProvider);
 }
 
 export function registerSystem(systemId, speedProvider) {
-	const system = game.system
+	const system = game.system;
 	// If the current system id doesn't match the provided id something went wrong. Log a warning and ignore this module
 	if (system.id != systemId) {
 		console.warn(
 			`Drag Ruler | A system tried to register with the id "${systemId}". However the active system has a different id.` +
 				"This api registration call was ignored. " +
 				"If you are the author of that system please check that the id passed to `registerSystem` matches the id in your manifest exactly." +
-			"If this call was made form a module instead of a game system please use `registerModule` instead.")
+				"If this call was made form a module instead of a game system please use `registerModule` instead.",
-		return
+		);
+		return;
 	}
 
-	register(system, "system", speedProvider)
+	register(system, "system", speedProvider);
 }

js/compatibility.js

@@ -3,19 +3,24 @@ import {settingsKey} from "./settings.js";
 import {highlightTokenShape} from "./util.js";
 
 export function getHexSizeSupportTokenGridCenter(token) {
-	const tokenCenterOffset = CONFIG.hexSizeSupport.getCenterOffset(token)
+	const tokenCenterOffset = CONFIG.hexSizeSupport.getCenterOffset(token);
-	return {x: token.x + tokenCenterOffset.x, y: token.y + tokenCenterOffset.y}
+	return {x: token.x + tokenCenterOffset.x, y: token.y + tokenCenterOffset.y};
 }
 
-export function highlightMeasurementTerrainRuler(ray, startDistance, tokenShape=[{x: 0, y: 0}], alpha=1) {
+export function highlightMeasurementTerrainRuler(
+	ray,
+	startDistance,
+	tokenShape = [{x: 0, y: 0}],
+	alpha = 1,
+) {
 	for (const space of ray.terrainRulerVisitedSpaces.reverse()) {
 		const color = this.dragRulerGetColorForDistance(startDistance + space.distance);
-		highlightTokenShape.call(this, space, tokenShape, color, alpha)
+		highlightTokenShape.call(this, space, tokenShape, color, alpha);
 	}
 }
 
 export function measureDistances(segments, entity, shape, options = {}) {
-	const opts = duplicate(options)
+	const opts = duplicate(options);
 	if (canvas.grid.diagonalRule === "EUCL") {
 		opts.ignoreGrid = true;
 		opts.gridSpaes = false;
@@ -25,14 +30,20 @@ export function measureDistances(segments, entity, shape, options={}) {
 		const firstNewSegmentIndex = segments.findIndex(segment => !segment.ray.dragRulerVisitedSpaces);
 		const previousSegments = segments.slice(0, firstNewSegmentIndex);
 		const newSegments = segments.slice(firstNewSegmentIndex);
-		const distances = previousSegments.map(segment => segment.ray.dragRulerVisitedSpaces[segment.ray.dragRulerVisitedSpaces.length - 1].distance);
+		const distances = previousSegments.map(
-		previousSegments.forEach(segment => segment.ray.terrainRulerVisitedSpaces = duplicate(segment.ray.dragRulerVisitedSpaces));
+			segment =>
+				segment.ray.dragRulerVisitedSpaces[segment.ray.dragRulerVisitedSpaces.length - 1].distance,
+		);
+		previousSegments.forEach(
+			segment =>
+				(segment.ray.terrainRulerVisitedSpaces = duplicate(segment.ray.dragRulerVisitedSpaces)),
+		);
 		opts.costFunction = buildCostFunction(entity, shape);
 		if (previousSegments.length > 0)
-			opts.terrainRulerInitialState = previousSegments[previousSegments.length - 1].ray.dragRulerFinalState;
+			opts.terrainRulerInitialState =
+				previousSegments[previousSegments.length - 1].ray.dragRulerFinalState;
 		return distances.concat(terrainRuler.measureDistances(newSegments, opts));
-	}
+	} else {
-	else {
 		// If another module wants to enable grid measurements but disable grid highlighting,
 		// manually set the *duplicate* option's gridSpaces value to true for the Foundry logic to work properly
 		if (!opts.ignoreGrid) {
@@ -44,23 +55,31 @@ export function measureDistances(segments, entity, shape, options={}) {
 
 export function checkDependencies() {
 	if (!game.modules.get("socketlib")?.active) {
-		console.error("Drag Ruler | The `socketlib` module isn't enabled, but it's required for Drag Ruler to operate properly.");
+		console.error(
+			"Drag Ruler | The `socketlib` module isn't enabled, but it's required for Drag Ruler to operate properly.",
+		);
 		if (game.user.isGM) {
 			new Dialog({
 				title: game.i18n.localize("drag-ruler.dependencies.socketlib.title"),
-				content: `<h2>${game.i18n.localize("drag-ruler.dependencies.socketlib.title")}</h2><p>${game.i18n.localize("drag-ruler.dependencies.socketlib.text")}</p>`,
+				content: `<h2>${game.i18n.localize(
+					"drag-ruler.dependencies.socketlib.title",
+				)}</h2><p>${game.i18n.localize("drag-ruler.dependencies.socketlib.text")}</p>`,
 				buttons: {
 					ok: {
 						icon: '<i class="fas fa-check"></i>',
-						label: game.i18n.localize("drag-ruler.dependencies.ok")
+						label: game.i18n.localize("drag-ruler.dependencies.ok"),
-					}
+					},
 				},
 			}).render(true);
 		}
-	}
+	} else if (
-	else if (!game.modules.get("terrain-ruler")?.active && game.user.isGM && !game.settings.get(settingsKey, "neverShowTerrainRulerHint")) {
+		!game.modules.get("terrain-ruler")?.active &&
+		game.user.isGM &&
+		!game.settings.get(settingsKey, "neverShowTerrainRulerHint")
+	) {
 		const lastHint = game.settings.get(settingsKey, "lastTerrainRulerHintTime");
-		if (Date.now() - lastHint > 604800000) { // One week
+		if (Date.now() - lastHint > 604800000) {
+			// One week
 			let enabledTerrainModule;
 			if (game.modules.get("enhanced-terrain-layer")?.active) {
 				enabledTerrainModule = game.modules.get("enhanced-terrain-layer").data.title;
@@ -68,20 +87,25 @@ export function checkDependencies() {
 			if (enabledTerrainModule) {
 				new Dialog({
 					title: game.i18n.localize("drag-ruler.dependencies.terrain-ruler.title"),
-					content: `<h2>${game.i18n.localize("drag-ruler.dependencies.terrain-ruler.title")}</h2><p>${game.i18n.format("drag-ruler.dependencies.terrain-ruler.text", {moduleName: enabledTerrainModule})}</p>`,
+					content: `<h2>${game.i18n.localize(
+						"drag-ruler.dependencies.terrain-ruler.title",
+					)}</h2><p>${game.i18n.format("drag-ruler.dependencies.terrain-ruler.text", {
+						moduleName: enabledTerrainModule,
+					})}</p>`,
 					buttons: {
 						ok: {
 							icon: '<i class="fas fa-check"></i>',
 							label: game.i18n.localize("drag-ruler.dependencies.ok"),
-							callback: () => game.settings.set(settingsKey, "lastTerrainRulerHintTime", Date.now()),
+							callback: () =>
+								game.settings.set(settingsKey, "lastTerrainRulerHintTime", Date.now()),
 						},
 						neverShowAgain: {
 							icon: '<i class="fas fa-times"></i>',
 							label: game.i18n.localize("drag-ruler.dependencies.terrain-ruler.neverShowAgain"),
 							callback: () => game.settings.set(settingsKey, "neverShowTerrainRulerHint", true),
-						}
 						},
-					close: () => game.settings.set(settingsKey, "lastTerrainRulerHintTime", Date.now())
+					},
+					close: () => game.settings.set(settingsKey, "lastTerrainRulerHintTime", Date.now()),
 				}).render(true);
 			}
 		}

js/data_structures.js

@@ -110,8 +110,8 @@ export class ProcessOnceQueue {
 		const newNode = {
 			value: element,
 			next: null,
-			previous: null
+			previous: null,
-		}
+		};
 
 		if (!this.first) {
 			this.first = newNode;

js/foundry_fixes.js

@@ -3,18 +3,17 @@
 // https://gitlab.com/foundrynet/foundryvtt/-/issues/4705
 export function getPixelsFromGridPosition(xGrid, yGrid) {
 	if (canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS) {
-		return canvas.grid.grid.getPixelsFromGridPosition(yGrid, xGrid)
+		return canvas.grid.grid.getPixelsFromGridPosition(yGrid, xGrid);
 	}
-	return canvas.grid.grid.getPixelsFromGridPosition(xGrid, yGrid)
+	return canvas.grid.grid.getPixelsFromGridPosition(xGrid, yGrid);
 }
 
 // Wrapper to fix a FoundryVTT bug that causes the return values of canvas.grid.grid.getPixelsFromGridPosition to be ordered inconsistently
 // https://gitlab.com/foundrynet/foundryvtt/-/issues/4705
 export function getGridPositionFromPixels(xPixel, yPixel) {
-	const [x, y] = canvas.grid.grid.getGridPositionFromPixels(xPixel, yPixel)
+	const [x, y] = canvas.grid.grid.getGridPositionFromPixels(xPixel, yPixel);
-	if (canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS)
+	if (canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS) return [y, x];
-		return [y, x]
+	return [x, y];
-	return [x, y]
 }
 
 export function getGridPositionFromPixelsObj(o) {

js/foundry_imports.js

@@ -1,12 +1,25 @@
 import {highlightMeasurementTerrainRuler, measureDistances} from "./compatibility.js";
-import {getGridPositionFromPixels, getGridPositionFromPixelsObj, getPixelsFromGridPositionObj} from "./foundry_fixes.js";
+import {
+	getGridPositionFromPixels,
+	getGridPositionFromPixelsObj,
+	getPixelsFromGridPositionObj,
+} from "./foundry_fixes.js";
 import {Line} from "./geometry.js";
 import {disableSnap, moveWithoutAnimation} from "./keybindings.js";
-import {trackRays} from "./movement_tracking.js"
+import {trackRays} from "./movement_tracking.js";
 import {findPath, isPathfindingEnabled} from "./pathfinding.js";
 import {settingsKey} from "./settings.js";
 import {recalculate} from "./socket.js";
-import {applyTokenSizeOffset, enumeratedZip, getSnapPointForEntity, getSnapPointForToken, getSnapPointForTokenObj, getTokenShape, highlightTokenShape, sum} from "./util.js";
+import {
+	applyTokenSizeOffset,
+	enumeratedZip,
+	getSnapPointForEntity,
+	getSnapPointForToken,
+	getSnapPointForTokenObj,
+	getTokenShape,
+	highlightTokenShape,
+	sum,
+} from "./util.js";
 
 // This is a modified version of Ruler.moveToken from foundry 0.7.9
 export async function moveEntities(draggedEntity, selectedEntities) {
@@ -27,12 +40,14 @@ export async function moveEntities(draggedEntity, selectedEntities) {
 	if (!game.user.isGM && draggedEntity instanceof Token) {
 		const hasCollision = selectedEntities.some(token => {
 			const offset = calculateEntityOffset(token, draggedEntity);
-			const offsetRays = rays.filter(ray => !ray.isPrevious).map(ray => applyOffsetToRay(ray, offset))
+			const offsetRays = rays
+				.filter(ray => !ray.isPrevious)
+				.map(ray => applyOffsetToRay(ray, offset));
 			if (window.WallHeight) {
 				window.WallHeight.addBoundsToRays(offsetRays, draggedEntity);
 			}
 			return offsetRays.some(r => canvas.walls.checkCollision(r));
-		})
+		});
 		if (hasCollision) {
 			ui.notifications.error(game.i18n.localize("ERROR.TokenCollide"));
 			this._endMeasurement();
@@ -46,8 +61,7 @@ export async function moveEntities(draggedEntity, selectedEntities) {
 	await animateEntities.call(this, selectedEntities, draggedEntity, rays, wasPaused);
 
 	// Once all animations are complete we can clear the ruler
-	if (this.draggedEntity?.id === draggedEntity.id)
+	if (this.draggedEntity?.id === draggedEntity.id) this._endMeasurement();
-		this._endMeasurement();
 }
 
 // This is a modified version code extracted from Ruler.moveToken from foundry 0.7.9
@@ -65,8 +79,7 @@ async function animateEntities(entities, draggedEntity, draggedRays, wasPaused)
 		if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
 			dx = entity.data.x - origin[0];
 			dy = entity.data.y - origin[1];
-		}
+		} else {
-		else {
 			dx = entity.data.x - origin[0];
 			dy = entity.data.y - origin[1];
 		}
@@ -92,18 +105,29 @@ async function animateEntities(entities, draggedEntity, draggedRays, wasPaused)
 		const updates = entityPaths.map(({entity, path}) => {
 			return {x: path.B.x, y: path.B.y, _id: entity.id};
 		});
-		await draggedEntity.scene.updateEmbeddedDocuments(draggedEntity.constructor.embeddedName, updates, {animate});
+		await draggedEntity.scene.updateEmbeddedDocuments(
+			draggedEntity.constructor.embeddedName,
+			updates,
+			{animate},
+		);
 		if (animate)
-			await Promise.all(entityPaths.map(({entity}) => CanvasAnimation.getAnimation(entity.movementAnimationName)?.promise));
+			await Promise.all(
+				entityPaths.map(
+					({entity}) => CanvasAnimation.getAnimation(entity.movementAnimationName)?.promise,
+				),
+			);
 
 		// This is a flag of the "Monk's Active Tile Triggers" module that signals that the movement should be cancelled early
 		if (this.cancelMovement) {
-			entityAnimationData.forEach(ead => ead.rays = ead.rays.slice(0, i + 1));
+			entityAnimationData.forEach(ead => (ead.rays = ead.rays.slice(0, i + 1)));
 			break;
 		}
 	}
 	if (isToken)
-		trackRays(entities, entityAnimationData.map(({rays}) => rays)).then(() => recalculate(entities));
+		trackRays(
+			entities,
+			entityAnimationData.map(({rays}) => rays),
+		).then(() => recalculate(entities));
 }
 
 function calculateEntityOffset(entityA, entityB) {
@@ -111,7 +135,10 @@ function calculateEntityOffset(entityA, entityB) {
 }
 
 function applyOffsetToRay(ray, offset) {
-	const newRay = new Ray({x: ray.A.x + offset.x, y: ray.A.y + offset.y}, {x: ray.B.x + offset.x, y: ray.B.y + offset.y});
+	const newRay = new Ray(
+		{x: ray.A.x + offset.x, y: ray.A.y + offset.y},
+		{x: ray.B.x + offset.x, y: ray.B.y + offset.y},
+	);
 	newRay.isPrevious = ray.isPrevious;
 	return newRay;
 }
@@ -121,7 +148,10 @@ export function onMouseMove(event) {
 	if (this._state === Ruler.STATES.MOVING) return;
 
 	// Extract event data
-	const destination = {x: event.data.destination.x + this.rulerOffset.x, y: event.data.destination.y + this.rulerOffset.y}
+	const destination = {
+		x: event.data.destination.x + this.rulerOffset.x,
+		y: event.data.destination.y + this.rulerOffset.y,
+	};
 
 	// Hide any existing Token HUD
 	canvas.hud.token.clear();
@@ -140,12 +170,21 @@ function scheduleMeasurement(destination, event) {
 		event._measureTime = Date.now();
 		this._state = Ruler.STATES.MEASURING;
 		cancelScheduledMeasurement.call(this);
-	}
+	} else {
-	else {
 		this.deferredMeasurementData = {destination, event};
 		if (!this.deferredMeasurementTimeout) {
-			this.deferredMeasurementPromise = new Promise((resolve, reject) => this.deferredMeasurementResolve = resolve);
+			this.deferredMeasurementPromise = new Promise(
-			this.deferredMeasurementTimeout = window.setTimeout(() => scheduleMeasurement.call(this, this.deferredMeasurementData.destination, this.deferredMeasurementData.event), measurementInterval);
+				(resolve, reject) => (this.deferredMeasurementResolve = resolve),
+			);
+			this.deferredMeasurementTimeout = window.setTimeout(
+				() =>
+					scheduleMeasurement.call(
+						this,
+						this.deferredMeasurementData.destination,
+						this.deferredMeasurementData.event,
+					),
+				measurementInterval,
+			);
 		}
 	}
 }
@@ -158,10 +197,8 @@ export function cancelScheduledMeasurement() {
 
 // This is a modified version of Ruler.measure form foundry 0.7.9
 export function measure(destination, options = {}) {
-
 	const isToken = this.draggedEntity instanceof Token;
-	if (isToken && !this.draggedEntity.isVisible)
+	if (isToken && !this.draggedEntity.isVisible) return [];
-		return []
 
 	options.snap = options.snap ?? !disableSnap;
 
@@ -175,26 +212,28 @@ export function measure(destination, options={}) {
 		const from = getGridPositionFromPixelsObj(this.waypoints[this.waypoints.length - 1]);
 		const to = getGridPositionFromPixelsObj(destination);
 		let path = findPath(from, to, this.draggedEntity, this.waypoints);
-		if (path)
+		if (path) path.shift();
-			path.shift();
 		if (path && path.length > 0) {
-			path = path.map(point => getSnapPointForTokenObj(getPixelsFromGridPositionObj(point), this.draggedEntity));
+			path = path.map(point =>
+				getSnapPointForTokenObj(getPixelsFromGridPositionObj(point), this.draggedEntity),
+			);
 
 			// If the token is snapped to the grid, the first point of the path is already handled by the ruler
-			if (path[0].x === this.waypoints[this.waypoints.length - 1].x && path[0].y === this.waypoints[this.waypoints.length - 1].y)
+			if (
+				path[0].x === this.waypoints[this.waypoints.length - 1].x &&
+				path[0].y === this.waypoints[this.waypoints.length - 1].y
+			)
 				path = path.slice(1);
 
 			// If snapping is enabled, the last point of the path is already handled by the ruler
-			if (options.snap)
+			if (options.snap) path = path.slice(0, path.length - 1);
-				path = path.slice(0, path.length - 1);
 
 			for (const point of path) {
 				point.isPathfinding = true;
 				this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
 			}
 			this.waypoints = this.waypoints.concat(path);
-		}
+		} else {
-		else {
 			// Don't show a path if the pathfinding yields no result to show the user that the destination is unreachable
 			destination = this.waypoints[this.waypoints.length - 1];
 		}
@@ -217,24 +256,26 @@ export function measure(destination, options={}) {
 
 	const waypoints = this.waypoints.concat([destination]);
 	// Move the waypoints to the center of the grid if a size is used that measures from edge to edge
-	const centeredWaypoints = isToken ? applyTokenSizeOffset(waypoints, this.draggedEntity) : duplicate(waypoints);
+	const centeredWaypoints = isToken
+		? applyTokenSizeOffset(waypoints, this.draggedEntity)
+		: duplicate(waypoints);
 	// Foundries native ruler requires the waypoints to sit in the dead center of the square to work properly
 	if (!options.enableTerrainRuler && !options.ignoreGrid)
-		centeredWaypoints.forEach(w => [w.x, w.y] = canvas.grid.getCenter(w.x, w.y));
+		centeredWaypoints.forEach(w => ([w.x, w.y] = canvas.grid.getCenter(w.x, w.y)));
 
 	const r = this.ruler;
 	this.destination = destination;
 
 	// Iterate over waypoints and construct segment rays
 	const segments = [];
-	const centeredSegments = []
+	const centeredSegments = [];
 	for (let [i, dest] of waypoints.slice(1).entries()) {
-		const centeredDest = centeredWaypoints[i + 1]
+		const centeredDest = centeredWaypoints[i + 1];
 		const origin = waypoints[i];
-		const centeredOrigin = centeredWaypoints[i]
+		const centeredOrigin = centeredWaypoints[i];
 		const label = this.labels.children[i];
 		const ray = new Ray(origin, dest);
-		const centeredRay = new Ray(centeredOrigin, centeredDest)
+		const centeredRay = new Ray(centeredOrigin, centeredDest);
 		ray.isPrevious = Boolean(origin.isPrevious);
 		centeredRay.isPrevious = ray.isPrevious;
 		ray.dragRulerVisitedSpaces = origin.dragRulerVisitedSpaces;
@@ -246,10 +287,9 @@ export function measure(destination, options={}) {
 			continue;
 		}
 		segments.push({ray, label});
-		centeredSegments.push({ray: centeredRay, label})
+		centeredSegments.push({ray: centeredRay, label});
 	}
 
-
 	const shape = isToken ? getTokenShape(this.draggedEntity) : null;
 
 	// Compute measured distance
@@ -258,9 +298,9 @@ export function measure(destination, options={}) {
 	let totalDistance = 0;
 	for (let [i, d] of distances.entries()) {
 		let s = centeredSegments[i];
-		s.startDistance = totalDistance
+		s.startDistance = totalDistance;
 		totalDistance += d;
-		s.last = i === (centeredSegments.length - 1);
+		s.last = i === centeredSegments.length - 1;
 		s.distance = d;
 		s.text = this._getSegmentLabel(d, totalDistance, s.last);
 	}
@@ -271,18 +311,24 @@ export function measure(destination, options={}) {
 
 	// Draw measured path
 	r.clear();
-	let rulerColor
+	let rulerColor;
 	if (!options.gridSpaces || canvas.grid.type === CONST.GRID_TYPES.GRIDLESS)
 		rulerColor = this.dragRulerGetColorForDistance(totalDistance);
-	else
+	else rulerColor = this.color;
-		rulerColor = this.color
+	for (const [i, s, cs] of enumeratedZip(
-	for (const [i, s, cs] of enumeratedZip([...segments].reverse(), [...centeredSegments].reverse())) {
+		[...segments].reverse(),
+		[...centeredSegments].reverse(),
+	)) {
 		const {label, text, last} = cs;
 
 		// Draw line segment
 		const opacityMultiplier = s.ray.isPrevious ? 0.33 : 1;
-		r.lineStyle(6, 0x000000, 0.5 * opacityMultiplier).moveTo(s.ray.A.x, s.ray.A.y).lineTo(s.ray.B.x, s.ray.B.y)
+		r.lineStyle(6, 0x000000, 0.5 * opacityMultiplier)
-			.lineStyle(4, rulerColor, 0.25 * opacityMultiplier).moveTo(s.ray.A.x, s.ray.A.y).lineTo(s.ray.B.x, s.ray.B.y);
+			.moveTo(s.ray.A.x, s.ray.A.y)
+			.lineTo(s.ray.B.x, s.ray.B.y)
+			.lineStyle(4, rulerColor, 0.25 * opacityMultiplier)
+			.moveTo(s.ray.A.x, s.ray.A.y)
+			.lineTo(s.ray.B.x, s.ray.B.y);
 
 		// Draw the distance label just after the endpoint of the segment
 		if (label) {
@@ -296,11 +342,14 @@ export function measure(destination, options={}) {
 			const rayLabelXHitY = rayLine.calcY(labelPosition.x);
 			let innerDistance;
 			// If ray hits top or bottom side of label
-			if (rayLine.isVertical || rayLabelXHitY < labelPosition.y || rayLabelXHitY > labelPosition.y + label.height)
+			if (
-				innerDistance = Math.abs((label.height / 2) / Math.sin(s.ray.angle));
+				rayLine.isVertical ||
+				rayLabelXHitY < labelPosition.y ||
+				rayLabelXHitY > labelPosition.y + label.height
+			)
+				innerDistance = Math.abs(label.height / 2 / Math.sin(s.ray.angle));
 			// If ray hits left or right side of label
-			else
+			else innerDistance = Math.abs(label.width / 2 / Math.cos(s.ray.angle));
-				innerDistance = Math.abs((label.width / 2) / Math.cos(s.ray.angle));
 			labelPosition = s.ray.project((s.ray.distance + 50 + innerDistance) / s.ray.distance);
 			labelPosition.x -= label.width / 2;
 			labelPosition.y -= label.height / 2;
@@ -310,9 +359,14 @@ export function measure(destination, options={}) {
 		// Highlight grid positions
 		if (isToken && canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS && options.gridSpaces) {
 			if (options.enableTerrainRuler) {
-				highlightMeasurementTerrainRuler.call(this, cs.ray, cs.startDistance, shape, opacityMultiplier)
+				highlightMeasurementTerrainRuler.call(
-			}
+					this,
-			else {
+					cs.ray,
+					cs.startDistance,
+					shape,
+					opacityMultiplier,
+				);
+			} else {
 				const previousSegments = centeredSegments.slice(0, segments.length - 1 - i);
 				highlightMeasurementNative.call(this, cs.ray, previousSegments, shape, opacityMultiplier);
 			}
@@ -328,9 +382,17 @@ export function measure(destination, options={}) {
 	return segments;
 }
 
-export function highlightMeasurementNative(ray, previousSegments, tokenShape=[{x: 0, y: 0}], alpha=1) {
+export function highlightMeasurementNative(
+	ray,
+	previousSegments,
+	tokenShape = [{x: 0, y: 0}],
+	alpha = 1,
+) {
 	const spacer = canvas.scene.data.gridType === CONST.GRID_TYPES.SQUARE ? 1.41 : 1;
-	const nMax = Math.max(Math.floor(ray.distance / (spacer * Math.min(canvas.grid.w, canvas.grid.h))), 1);
+	const nMax = Math.max(
+		Math.floor(ray.distance / (spacer * Math.min(canvas.grid.w, canvas.grid.h))),
+		1,
+	);
 	const tMax = Array.fromRange(nMax + 1).map(t => t / nMax);
 
 	// Track prior position
@@ -341,7 +403,7 @@ export function highlightMeasurementNative(ray, previousSegments, tokenShape=[{x
 		let {x, y} = ray.project(t);
 
 		// Get grid position
-		let [x0, y0] = (i === 0) ? [null, null] : prior;
+		let [x0, y0] = i === 0 ? [null, null] : prior;
 		let [x1, y1] = canvas.grid.grid.getGridPositionFromPixels(x, y);
 		if (x0 === x1 && y0 === y1) continue;
 
@@ -358,7 +420,7 @@ export function highlightMeasurementNative(ray, previousSegments, tokenShape=[{x
 
 		// If the positions are not neighbors, also highlight their halfway point
 		if (i > 0 && !canvas.grid.isNeighbor(x0, y0, x1, y1)) {
-			let th = tMax[i - 1] - (0.5 / nMax);
+			let th = tMax[i - 1] - 0.5 / nMax;
 			let {x, y} = ray.project(th);
 			let [x1h, y1h] = canvas.grid.grid.getGridPositionFromPixels(x, y);
 			let [xghtl, yghtl] = canvas.grid.grid.getPixelsFromGridPosition(x1h, y1h);

js/hex_support.js

@@ -18,76 +18,73 @@ export function findVertexSnapPoint(x, y, altOrientationFlag) {
 }
 
 function findSnapPointRows(x, y, h, w, alt) {
-	let xOffset = 0.0
+	let xOffset = 0.0;
 	if (canvas.grid.grid.even) {
-		xOffset = -0.5
+		xOffset = -0.5;
 	}
 
-	let yOffset1 = 0.75
+	let yOffset1 = 0.75;
-	let yOffset2 = 0.00
+	let yOffset2 = 0.0;
 	if (alt) {
-		yOffset1 = 0.25
+		yOffset1 = 0.25;
-		yOffset2 = 1.00
+		yOffset2 = 1.0;
 	}
 
 	let row1 = calculateSnapPointsRows(x, y, h, w, 0.5 + xOffset, yOffset1);
 	let row2 = calculateSnapPointsRows(x, y, h, w, 1.0 + xOffset, yOffset2);
 
-	let dist1 = Math.pow((row1.x - x), 2) + Math.pow((row1.y - y), 2)
+	let dist1 = Math.pow(row1.x - x, 2) + Math.pow(row1.y - y, 2);
-	let dist2 = Math.pow((row2.x - x), 2) + Math.pow((row2.y - y), 2)
+	let dist2 = Math.pow(row2.x - x, 2) + Math.pow(row2.y - y, 2);
 
 	if (dist1 < dist2) {
-		return row1
+		return row1;
-	}
+	} else {
-	else {
+		return row2;
-		return row2
 	}
 }
 
 function calculateSnapPointsRows(x, y, h, w, xOff, yOff) {
-	let c = Math.floor(((x + ((0.5 - xOff) * w)) / w) + 1)
+	let c = Math.floor((x + (0.5 - xOff) * w) / w + 1);
-	let r = Math.floor(((y + ((0.75 - yOff) * h)) / (1.5 * h)) + 1)
+	let r = Math.floor((y + (0.75 - yOff) * h) / (1.5 * h) + 1);
 
-	let snapX = (c * w) - ((1 - xOff) * w)
+	let snapX = c * w - (1 - xOff) * w;
-	let snapY = (r * h * 1.5) - ((1.5 - yOff) * h)
+	let snapY = r * h * 1.5 - (1.5 - yOff) * h;
 
-	return {x: snapX, y: snapY}
+	return {x: snapX, y: snapY};
 }
 
 function findSnapPointCols(x, y, h, w, alt) {
-	let yOffset = 0.0
+	let yOffset = 0.0;
 	if (canvas.grid.grid.even) {
-		yOffset = -0.5
+		yOffset = -0.5;
 	}
 
-	let xOffset1 = 0.25
+	let xOffset1 = 0.25;
-	let xOffset2 = 1.00
+	let xOffset2 = 1.0;
 	if (alt) {
-		xOffset1 = 0.75
+		xOffset1 = 0.75;
-		xOffset2 = 0.00
+		xOffset2 = 0.0;
 	}
 
 	let row1 = calculateSnapPointsCols(x, y, h, w, xOffset1, 0.5 + yOffset);
 	let row2 = calculateSnapPointsCols(x, y, h, w, xOffset2, 1.0 + yOffset);
 
-	let dist1 = Math.pow((row1.x - x), 2) + Math.pow((row1.y - y), 2)
+	let dist1 = Math.pow(row1.x - x, 2) + Math.pow(row1.y - y, 2);
-	let dist2 = Math.pow((row2.x - x), 2) + Math.pow((row2.y - y), 2)
+	let dist2 = Math.pow(row2.x - x, 2) + Math.pow(row2.y - y, 2);
 
 	if (dist1 < dist2) {
-		return row1
+		return row1;
+	} else {
+		return row2;
 	}
-	else {
-		return row2
-	}
-
 }
 
 function calculateSnapPointsCols(x, y, h, w, xOff, yOff) {
-	let c = Math.floor(((x + ((0.75 - xOff) * w)) / (1.5 * w)) + 1)
+	let c = Math.floor((x + (0.75 - xOff) * w) / (1.5 * w) + 1);
-	let r = Math.floor(((y + ((0.5 - yOff) * h)) / h) + 1)
+	let r = Math.floor((y + (0.5 - yOff) * h) / h + 1);
 
-	let snapX = (c * w * 1.5) - ((1.5 - xOff) * w)
+	let snapX = c * w * 1.5 - (1.5 - xOff) * w;
-	let snapY = (r * h) - ((1 - yOff) * h)
+	let snapY = r * h - (1 - yOff) * h;
 
-	return {x: snapX, y: snapY}
+	return {x: snapX, y: snapY};
 }

js/keybindings.js

@@ -9,18 +9,22 @@ export function registerKeybindings() {
 	game.keybindings.register(settingsKey, "cancelDrag", {
 		name: "drag-ruler.keybindings.cancelDrag",
 		onDown: cancelDrag,
-		uneditable: [{
+		uneditable: [
+			{
 				key: "Escape",
-		}],
+			},
+		],
 		precedence: -1,
 	});
 
 	game.keybindings.register(settingsKey, "createWaypoint", {
 		name: "drag-ruler.keybindings.createWaypoint",
 		onDown: handleCreateWaypoint,
-		editable: [{
+		editable: [
-			key: "Space"
+			{
-		}],
+				key: "Space",
+			},
+		],
 		precedence: -1,
 	});
 
@@ -35,9 +39,11 @@ export function registerKeybindings() {
 		hint: "drag-ruler.keybindings.disableSnap.hint",
 		onDown: handleDisableSnap,
 		onUp: handleDisableSnap,
-		editable: [{
+		editable: [
+			{
 				key: "ShiftLeft",
-		}],
+			},
+		],
 		precedence: -1,
 	});
 
@@ -46,9 +52,11 @@ export function registerKeybindings() {
 		hint: "drag-ruler.keybindings.moveWithoutAnimation.hint",
 		onDown: handleMoveWithoutAnimation,
 		onUp: handleMoveWithoutAnimation,
-		editable: [{
+		editable: [
+			{
 				key: "AltLeft",
-		}],
+			},
+		],
 		precedence: -1,
 	});
 
@@ -64,8 +72,7 @@ export function registerKeybindings() {
 
 function handleDeleteWaypoint() {
 	const ruler = canvas.controls.ruler;
-	if (!ruler?.draggedEntity)
+	if (!ruler?.draggedEntity) return false;
-		return false;
 	ruler.dragRulerDeleteWaypoint();
 	return true;
 }
@@ -74,16 +81,14 @@ function handleCreateWaypoint() {
 	const ruler = canvas.controls.ruler;
 	// .draggedEntity is used here because .isDragRuler only returns true once the ruler started measuring
 	// Ruler can end up being undefined here if no canvas is active
-	if (!ruler?.draggedEntity)
+	if (!ruler?.draggedEntity) return false;
-		return false;
 
 	let options = {};
 	setSnapParameterOnOptions(ruler, options);
 
 	if (ruler._state === Ruler.STATES.INACTIVE) {
 		ruler.dragRulerStart(options);
-	}
+	} else {
-	else {
 		ruler.dragRulerAddWaypoint(getMeasurePosition(), options);
 	}
 	return true;
@@ -91,8 +96,7 @@ function handleCreateWaypoint() {
 
 function cancelDrag() {
 	const ruler = canvas.controls.ruler;
-	if (!ruler?.draggedEntity)
+	if (!ruler?.draggedEntity) return false;
-		return false;
 	ruler.dragRulerAbortDrag();
 	return true;
 }
@@ -101,10 +105,8 @@ function handleDisableSnap(event) {
 	disableSnap = !event.up;
 
 	const ruler = canvas.controls.ruler;
-	if (!ruler?.isDragRuler)
+	if (!ruler?.isDragRuler) return false;
-		return false;
+	if (ruler._state !== Ruler.STATES.MEASURING) return false;
-	if (ruler._state !== Ruler.STATES.MEASURING)
-		return false;
 
 	ruler.measure(getMeasurePosition(), {snap: !disableSnap});
 	ruler.dragRulerSendState();
@@ -115,10 +117,8 @@ function handleMoveWithoutAnimation(event) {
 	moveWithoutAnimation = !event.up;
 
 	const ruler = canvas.controls.ruler;
-	if (!ruler?.isDragRuler)
+	if (!ruler?.isDragRuler) return false;
-		return false;
+	if (ruler._state !== Ruler.STATES.MEASURING) return false;
-	if (ruler._state !== Ruler.STATES.MEASURING)
-		return false;
 
 	ruler.measure(getMeasurePosition(), {snap: !disableSnap});
 	ruler.dragRulerSendState();
@@ -129,10 +129,8 @@ function handleTogglePathfinding(event) {
 	togglePathfinding = !event.up;
 
 	const ruler = canvas.controls.ruler;
-	if (!ruler?.isDragRuler)
+	if (!ruler?.isDragRuler) return false;
-		return false;
+	if (ruler._state !== Ruler.STATES.MEASURING) return false;
-	if (ruler._state !== Ruler.STATES.MEASURING)
-		return false;
 
 	ruler.measure(getMeasurePosition(), {snap: !disableSnap});
 	ruler.dragRulerSendState();

js/libwrapper_shim.js

@@ -1,18 +1,20 @@
 // SPDX-License-Identifier: MIT
 // Copyright © 2021 fvtt-lib-wrapper Rui Pinheiro
 
-
+"use strict";
-'use strict';
 
 // A shim for the libWrapper library
 export let libWrapper = undefined;
 
 export const VERSIONS = [1, 11, 0];
-export const TGT_SPLIT_RE   = new RegExp("([^.[]+|\\[('([^'\\\\]|\\\\.)+?'|\"([^\"\\\\]|\\\\.)+?\")\\])", 'g');
+export const TGT_SPLIT_RE = new RegExp(
-export const TGT_CLEANUP_RE = new RegExp("(^\\['|'\\]$|^\\[\"|\"\\]$)", 'g');
+	"([^.[]+|\\[('([^'\\\\]|\\\\.)+?'|\"([^\"\\\\]|\\\\.)+?\")\\])",
+	"g",
+);
+export const TGT_CLEANUP_RE = new RegExp("(^\\['|'\\]$|^\\[\"|\"\\]$)", "g");
 
 // Main shim code
-Hooks.once('init', () => {
+Hooks.once("init", () => {
 	// Check if the real module is already loaded - if so, use it
 	if (globalThis.libWrapper && !(globalThis.libWrapper.is_fallback ?? true)) {
 		libWrapper = globalThis.libWrapper;
@@ -21,24 +23,33 @@ Hooks.once('init', () => {
 
 	// Fallback implementation
 	libWrapper = class {
-		static get is_fallback() { return true };
+		static get is_fallback() {
+			return true;
+		}
 
-		static get WRAPPER()  { return 'WRAPPER'  };
+		static get WRAPPER() {
-		static get MIXED()    { return 'MIXED'    };
+			return "WRAPPER";
-		static get OVERRIDE() { return 'OVERRIDE' };
+		}
+		static get MIXED() {
+			return "MIXED";
+		}
+		static get OVERRIDE() {
+			return "OVERRIDE";
+		}
 
 		static register(package_id, target, fn, type = "MIXED", {chain = undefined} = {}) {
-			const is_setter = target.endsWith('#set');
+			const is_setter = target.endsWith("#set");
 			target = !is_setter ? target : target.slice(0, -4);
-			const split = target.match(TGT_SPLIT_RE).map((x)=>x.replace(/\\(.)/g, '$1').replace(TGT_CLEANUP_RE,''));
+			const split = target
+				.match(TGT_SPLIT_RE)
+				.map(x => x.replace(/\\(.)/g, "$1").replace(TGT_CLEANUP_RE, ""));
 			const root_nm = split.splice(0, 1)[0];
 
 			let obj, fn_name;
 			if (split.length == 0) {
 				obj = globalThis;
 				fn_name = root_nm;
-			}
+			} else {
-			else {
 				const _eval = eval;
 				fn_name = split.pop();
 				obj = split.reduce((x, y) => x[y], globalThis[root_nm] ?? _eval(root_nm));
@@ -51,22 +62,28 @@ Hooks.once('init', () => {
 				if (descriptor) break;
 				iObj = Object.getPrototypeOf(iObj);
 			}
-			if(!descriptor || descriptor?.configurable === false) throw `libWrapper Shim: '${target}' does not exist, could not be found, or has a non-configurable descriptor.`;
+			if (!descriptor || descriptor?.configurable === false)
+				throw `libWrapper Shim: '${target}' does not exist, could not be found, or has a non-configurable descriptor.`;
 
 			let original = null;
-			const wrapper = (chain ?? (type.toUpperCase?.() != 'OVERRIDE' && type != 3)) ? function() { return fn.call(this, original.bind(this), ...arguments); } : function() { return fn.apply(this, arguments); };
+			const wrapper =
+				chain ?? (type.toUpperCase?.() != "OVERRIDE" && type != 3)
+					? function () {
+							return fn.call(this, original.bind(this), ...arguments);
+					  }
+					: function () {
+							return fn.apply(this, arguments);
+					  };
 
 			if (!is_setter) {
 				if (descriptor.value) {
 					original = descriptor.value;
 					descriptor.value = wrapper;
-				}
+				} else {
-				else {
 					original = descriptor.get;
 					descriptor.get = wrapper;
 				}
-			}
+			} else {
-			else {
 				if (!descriptor.set) throw `libWrapper Shim: '${target}' does not have a setter`;
 				original = descriptor.set;
 				descriptor.set = wrapper;
@@ -75,5 +92,5 @@ Hooks.once('init', () => {
 			descriptor.configurable = true;
 			Object.defineProperty(obj, fn_name, descriptor);
 		}
-	}
+	};
 });

js/main.js

@@ -1,20 +1,31 @@
-"use strict"
+"use strict";
 
-import {getColorForDistanceAndToken, getMovedDistanceFromToken, getRangesFromSpeedProvider, initApi, registerModule, registerSystem} from "./api.js";
+import {
+	getColorForDistanceAndToken,
+	getMovedDistanceFromToken,
+	getRangesFromSpeedProvider,
+	initApi,
+	registerModule,
+	registerSystem,
+} from "./api.js";
 import {checkDependencies, getHexSizeSupportTokenGridCenter} from "./compatibility.js";
-import {moveEntities, onMouseMove} from "./foundry_imports.js"
+import {moveEntities, onMouseMove} from "./foundry_imports.js";
 import {disableSnap, registerKeybindings} from "./keybindings.js";
 import {libWrapper} from "./libwrapper_shim.js";
-import {performMigrations} from "./migration.js"
+import {performMigrations} from "./migration.js";
 import {removeLastHistoryEntryIfAt, resetMovementHistory} from "./movement_tracking.js";
-import {wipePathfindingCache, initializePathfinding, startBackgroundCaching} from "./pathfinding.js";
+import {
+	wipePathfindingCache,
+	initializePathfinding,
+	startBackgroundCaching,
+} from "./pathfinding.js";
 import {extendRuler} from "./ruler.js";
-import {registerSettings, RightClickAction, settingsKey} from "./settings.js"
+import {registerSettings, RightClickAction, settingsKey} from "./settings.js";
 import {recalculate} from "./socket.js";
-import {SpeedProvider} from "./speed_provider.js"
+import {SpeedProvider} from "./speed_provider.js";
 import {setSnapParameterOnOptions} from "./util.js";
 
-import initGridlessPathfinding, * as GridlessPathfinding from "../wasm/gridless_pathfinding.js"
+import initGridlessPathfinding, * as GridlessPathfinding from "../wasm/gridless_pathfinding.js";
 
 CONFIG.debug.dragRuler = false;
 export let debugGraphics = undefined;
@@ -37,7 +48,7 @@ initGridlessPathfinding().then(() => {
 	});
 
 	// Whenever a token the current user controls updates, start caching
-	Hooks.on("updateToken", (document) => {
+	Hooks.on("updateToken", document => {
 		const token = document.object;
 		if (token._controlled) {
 			startBackgroundCaching(token);
@@ -46,12 +57,17 @@ initGridlessPathfinding().then(() => {
 });
 
 Hooks.once("init", () => {
-	registerSettings()
+	registerSettings();
-	registerKeybindings()
+	registerKeybindings();
-	initApi()
+	initApi();
 	hookDragHandlers(Token);
 	hookDragHandlers(MeasuredTemplate);
-	libWrapper.register("drag-ruler", "TokenLayer.prototype.undoHistory", tokenLayerUndoHistory, "WRAPPER");
+	libWrapper.register(
+		"drag-ruler",
+		"TokenLayer.prototype.undoHistory",
+		tokenLayerUndoHistory,
+		"WRAPPER",
+	);
 
 	extendRuler();
 
@@ -62,16 +78,15 @@ Hooks.once("init", () => {
 		registerSystem,
 		recalculate,
 		resetMovementHistory,
-	}
+	};
-})
+});
 
 Hooks.once("ready", () => {
-	performMigrations()
+	performMigrations();
 	checkDependencies();
-	Hooks.callAll("dragRuler.ready", SpeedProvider)
+	Hooks.callAll("dragRuler.ready", SpeedProvider);
-	if (CONFIG.debug.dragRuler)
+	if (CONFIG.debug.dragRuler) debugGraphics = canvas.controls.addChild(new PIXI.Container());
-		debugGraphics = canvas.controls.addChild(new PIXI.Container());
+});
-})
 
 Hooks.on("canvasReady", () => {
 	canvas.controls.rulers.children.forEach(ruler => {
@@ -79,16 +94,16 @@ Hooks.on("canvasReady", () => {
 		Object.defineProperty(ruler, "isDragRuler", {
 			get: function isDragRuler() {
 				return Boolean(this.draggedEntity) && this._state !== Ruler.STATES.INACTIVE;
-			}
+			},
-		})
+		});
-	})
+	});
-})
+});
 
 Hooks.on("getCombatTrackerEntryContext", function (html, menu) {
 	const entry = {
 		name: "drag-ruler.resetMovementHistory",
 		icon: '<i class="fas fa-undo-alt"></i>',
-		callback: li => resetMovementHistory(ui.combat.viewed, li.data('combatant-id')),
+		callback: li => resetMovementHistory(ui.combat.viewed, li.data("combatant-id")),
 	};
 	menu.splice(1, 0, entry);
 });
@@ -96,20 +111,44 @@ Hooks.on("getCombatTrackerEntryContext", function (html, menu) {
 function forwardIfUnahndled(newFn) {
 	return function (oldFn, ...args) {
 		const eventHandled = newFn(...args);
-		if (!eventHandled)
+		if (!eventHandled) oldFn(...args);
-			oldFn(...args);
 	};
 }
 
 function hookDragHandlers(entityType) {
-	const entityName = entityType.name
+	const entityName = entityType.name;
-	libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftStart`, onEntityLeftDragStart, "WRAPPER");
+	libWrapper.register(
+		"drag-ruler",
+		`${entityName}.prototype._onDragLeftStart`,
+		onEntityLeftDragStart,
+		"WRAPPER",
+	);
 	if (entityType === Token)
-		libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftMove`, onEntityLeftDragMoveSnap, "WRAPPER");
+		libWrapper.register(
+			"drag-ruler",
+			`${entityName}.prototype._onDragLeftMove`,
+			onEntityLeftDragMoveSnap,
+			"WRAPPER",
+		);
 	else
-		libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftMove`, onEntityLeftDragMove, "WRAPPER");
+		libWrapper.register(
-	libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftDrop`, forwardIfUnahndled(onEntityDragLeftDrop), "MIXED");
+			"drag-ruler",
-	libWrapper.register("drag-ruler", `${entityName}.prototype._onDragLeftCancel`, forwardIfUnahndled(onEntityDragLeftCancel), "MIXED");
+			`${entityName}.prototype._onDragLeftMove`,
+			onEntityLeftDragMove,
+			"WRAPPER",
+		);
+	libWrapper.register(
+		"drag-ruler",
+		`${entityName}.prototype._onDragLeftDrop`,
+		forwardIfUnahndled(onEntityDragLeftDrop),
+		"MIXED",
+	);
+	libWrapper.register(
+		"drag-ruler",
+		`${entityName}.prototype._onDragLeftCancel`,
+		forwardIfUnahndled(onEntityDragLeftCancel),
+		"MIXED",
+	);
 }
 
 async function tokenLayerUndoHistory(wrapped) {
@@ -127,14 +166,21 @@ async function tokenLayerUndoHistory(wrapped) {
 function onEntityLeftDragStart(wrapped, event) {
 	wrapped(event);
 	const isToken = this instanceof Token;
-	const ruler = canvas.controls.ruler
+	const ruler = canvas.controls.ruler;
 	ruler.draggedEntity = this;
 	let entityCenter;
-	if (isToken && canvas.grid.isHex && game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(this))
+	if (
+		isToken &&
+		canvas.grid.isHex &&
+		game.modules.get("hex-size-support")?.active &&
+		CONFIG.hexSizeSupport.getAltSnappingFlag(this)
+	)
 		entityCenter = getHexSizeSupportTokenGridCenter(this);
-	else
+	else entityCenter = this.center;
-		entityCenter = this.center;
+	ruler.rulerOffset = {
-	ruler.rulerOffset = {x: entityCenter.x - event.data.origin.x, y: entityCenter.y - event.data.origin.y};
+		x: entityCenter.x - event.data.origin.x,
+		y: entityCenter.y - event.data.origin.y,
+	};
 	if (game.settings.get(settingsKey, "autoStartMeasurement")) {
 		let options = {};
 		setSnapParameterOnOptions(ruler, options);
@@ -149,48 +195,42 @@ function onEntityLeftDragMoveSnap(wrapped, event) {
 
 function onEntityLeftDragMove(wrapped, event) {
 	wrapped(event);
-	const ruler = canvas.controls.ruler
+	const ruler = canvas.controls.ruler;
-	if (ruler.isDragRuler)
+	if (ruler.isDragRuler) onMouseMove.call(ruler, event);
-		onMouseMove.call(ruler, event)
 }
 
 function onEntityDragLeftDrop(event) {
-	const ruler = canvas.controls.ruler
+	const ruler = canvas.controls.ruler;
 	if (!ruler.isDragRuler) {
 		ruler.draggedEntity = undefined;
-		return false
+		return false;
 	}
 	// When we're dragging a measured template no token will ever be selected,
 	// resulting in only the dragged template to be moved as would be expected
-	const selectedTokens = canvas.tokens.controlled
+	const selectedTokens = canvas.tokens.controlled;
 	// This can happen if the user presses ESC during drag (maybe there are other ways too)
-	if (selectedTokens.length === 0)
+	if (selectedTokens.length === 0) selectedTokens.push(ruler.draggedEntity);
-		selectedTokens.push(ruler.draggedEntity);
 	// This can happen if the ruler is being dragged so rapidly that the drag move handler hasn't been called before dropping
-	if (ruler._state === Ruler.STATES.STARTING)
+	if (ruler._state === Ruler.STATES.STARTING) onMouseMove.call(ruler, event);
-		onMouseMove.call(ruler, event);
+	ruler._state = Ruler.STATES.MOVING;
-	ruler._state = Ruler.STATES.MOVING
 	moveEntities.call(ruler, ruler.draggedEntity, selectedTokens);
-	return true
+	return true;
 }
 
 function onEntityDragLeftCancel(event) {
 	// This function is invoked by right clicking
-	const ruler = canvas.controls.ruler
+	const ruler = canvas.controls.ruler;
-	if (!ruler.draggedEntity || ruler._state === Ruler.STATES.MOVING)
+	if (!ruler.draggedEntity || ruler._state === Ruler.STATES.MOVING) return false;
-		return false
 
 	const rightClickAction = game.settings.get(settingsKey, "rightClickAction");
 	let options = {};
 	setSnapParameterOnOptions(ruler, options);
 
 	if (ruler._state === Ruler.STATES.INACTIVE) {
-		if (rightClickAction !== RightClickAction.CREATE_WAYPOINT)
+		if (rightClickAction !== RightClickAction.CREATE_WAYPOINT) return false;
-			return false;
 		ruler.dragRulerStart(options);
 		event.preventDefault();
-	}
+	} else if (ruler._state === Ruler.STATES.MEASURING) {
-	else if (ruler._state === Ruler.STATES.MEASURING) {
 		switch (rightClickAction) {
 			case RightClickAction.CREATE_WAYPOINT:
 				event.preventDefault();
@@ -209,14 +249,10 @@ function onEntityDragLeftCancel(event) {
 
 function applyGridlessSnapping(event) {
 	const ruler = canvas.controls.ruler;
-	if (!game.settings.get(settingsKey, "useGridlessRaster"))
+	if (!game.settings.get(settingsKey, "useGridlessRaster")) return;
-		return;
+	if (!ruler.isDragRuler) return;
-	if (!ruler.isDragRuler)
+	if (disableSnap) return;
-		return;
+	if (canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS) return;
-	if (disableSnap)
-		return;
-	if (canvas.grid.type !== CONST.GRID_TYPES.GRIDLESS)
-		return;
 
 	const rasterWidth = 35 / canvas.stage.scale.x;
 	const tokenX = event.data.destination.x;
@@ -226,7 +262,9 @@ function applyGridlessSnapping(event) {
 
 	const terrainRulerAvailable = game.modules.get("terrain-ruler")?.active;
 	if (terrainRulerAvailable) {
-		const segments = Ruler.dragRulerGetRaysFromWaypoints(ruler.waypoints, destination).map(ray => {return {ray}});
+		const segments = Ruler.dragRulerGetRaysFromWaypoints(ruler.waypoints, destination).map(ray => {
+			return {ray};
+		});
 		const pinpointDistances = new Map();
 		for (const range of ranges) {
 			pinpointDistances.set(range.range, null);
@@ -234,7 +272,7 @@ function applyGridlessSnapping(event) {
 		terrainRuler.measureDistances(segments, {pinpointDistances});
 		const targetDistance = Array.from(pinpointDistances.entries())
 			.filter(([_key, val]) => val)
-			.reduce((value, current) => value[0] > current[0] ? value : current, [0, null]);
+			.reduce((value, current) => (value[0] > current[0] ? value : current), [0, null]);
 		const rasterLocation = targetDistance[1];
 		if (rasterLocation) {
 			const deltaX = destination.x - rasterLocation.x;
@@ -245,12 +283,15 @@ function applyGridlessSnapping(event) {
 				event.data.destination.y = rasterLocation.y - ruler.rulerOffset.y;
 			}
 		}
-	}
+	} else {
-	else {
 		let waypointDistance = 0;
 		let origin = event.data.origin;
 		if (ruler.waypoints.length > 1) {
-			const segments = Ruler.dragRulerGetRaysFromWaypoints(ruler.waypoints, destination).map(ray => {return {ray}});
+			const segments = Ruler.dragRulerGetRaysFromWaypoints(ruler.waypoints, destination).map(
+				ray => {
+					return {ray};
+				},
+			);
 			origin = segments.pop().ray.A;
 			waypointDistance = canvas.grid.measureDistances(segments).reduce((a, b) => a + b);
 			origin = {x: origin.x - ruler.rulerOffset.x, y: origin.y - ruler.rulerOffset.y};
@@ -263,13 +304,13 @@ function applyGridlessSnapping(event) {
 		let targetDistance = ranges
 			.map(range => range.range)
 			.map(range => range - waypointDistance)
-			.map(range => range * canvas.dimensions.size / canvas.dimensions.distance)
+			.map(range => (range * canvas.dimensions.size) / canvas.dimensions.distance)
 			.filter(range => range < distance)
 			.reduce((a, b) => Math.max(a, b), 0);
 		if (targetDistance) {
 			if (distance < targetDistance + rasterWidth) {
-				event.data.destination.x = origin.x + deltaX * targetDistance / distance;
+				event.data.destination.x = origin.x + (deltaX * targetDistance) / distance;
-				event.data.destination.y = origin.y + deltaY * targetDistance / distance;
+				event.data.destination.y = origin.y + (deltaY * targetDistance) / distance;
 			}
 		}
 	}

js/migration.js

@@ -1,26 +1,24 @@
-import {RightClickAction, settingsKey} from "./settings.js"
+import {RightClickAction, settingsKey} from "./settings.js";
 
-const currentDataVersion = "1.10.0"
+const currentDataVersion = "1.10.0";
 
 export async function performMigrations() {
-	if (game.user.isGM)
+	if (game.user.isGM) await performWorldMigraionts();
-		await performWorldMigraionts()
+	await performClientMigrations();
-	await performClientMigrations()
 }
 
 async function performWorldMigraionts() {
 	let dataVersion = game.settings.get(settingsKey, "dataVersion");
 
-	if (dataVersion === currentDataVersion)
+	if (dataVersion === currentDataVersion) return;
-		return;
 
 	if (dataVersion === "fresh install") {
-		game.settings.set(settingsKey, "dataVersion", currentDataVersion)
+		game.settings.set(settingsKey, "dataVersion", currentDataVersion);
-		return
+		return;
 	}
 
 	if (dataVersion === "1.3.0") {
-		dataVersion = "1.10.0"
+		dataVersion = "1.10.0";
 	}
 
 	game.settings.set(settingsKey, "dataVersion", dataVersion);
@@ -31,13 +29,15 @@ async function performClientMigrations() {
 
 	if (dataVersion === "fresh install") {
 		// Start of migration from unnamed version (< 1.10.0). TODO Remove in a future version
-		const swapSpacebarRightClick = game.settings.storage.get("client").getItem(`${settingsKey}.swapSpacebarRightClick`);
+		const swapSpacebarRightClick = game.settings.storage
+			.get("client")
+			.getItem(`${settingsKey}.swapSpacebarRightClick`);
 		if (swapSpacebarRightClick) {
 			game.settings.set(settingsKey, "rightClickAction", RightClickAction.CREATE_WAYPOINT);
 			await game.keybindings.set(settingsKey, "createWaypoint", []);
 			await game.keybindings.set(settingsKey, "deleteWaypoint", [{key: "Space"}]);
 		}
 		// End of migration from unnamed version
-		game.settings.set(settingsKey, "clientDataVersion", currentDataVersion)
+		game.settings.set(settingsKey, "clientDataVersion", currentDataVersion);
 	}
 }

js/movement_tracking.js

@@ -9,38 +9,35 @@ function initTrackingFlag(combatant) {
 		if (isNaN(dragRulerFlag.trackedRound)) {
 			mergeObject(dragRulerFlag, initialFlag);
 		}
-	}
+	} else {
-	else {
 		combatant.data.flags.dragRuler = initialFlag;
 	}
 }
 
 function getInitializedCombatant(token, combat) {
 	const combatant = combat.getCombatantByToken(token.id);
-	if (!combatant)
+	if (!combatant) return undefined;
-		return undefined;
 	initTrackingFlag(combatant);
 	return combatant;
 }
 
 export async function trackRays(tokens, tokenRays) {
 	const combat = game.combat;
-	if (!combat)
+	if (!combat) return;
-		return;
+	if (!combat.started) return;
-	if (!combat.started)
-		return;
 	if (!(tokens instanceof Array)) {
 		tokens = [tokens];
 		tokenRays = [tokenRays];
 	}
-	const updates = Array.from(zip(tokens, tokenRays)).map(([token, rays]) => calculateUpdate(combat, token, rays)).filter(Boolean);
+	const updates = Array.from(zip(tokens, tokenRays))
+		.map(([token, rays]) => calculateUpdate(combat, token, rays))
+		.filter(Boolean);
 	await updateCombatantDragRulerFlags(combat, updates);
 }
 
 function calculateUpdate(combat, token, rays) {
 	const combatant = getInitializedCombatant(token, combat);
-	if (!combatant)
+	if (!combatant) return;
-		return;
 
 	// Check if we have entered a new round. If so, remove the currently stored path
 	if (combat.data.round > combatant.data.flags.dragRuler.trackedRound) {
@@ -56,7 +53,10 @@ function calculateUpdate(combat, token, rays) {
 		// Ignore rays that have the same start and end coordinates
 		if (ray.A.x !== ray.B.x || ray.A.y !== ray.B.y) {
 			if (terrainRulerAvailable) {
-				measureDistances([{ray}], token, getTokenShape(token), {terrainRulerInitialState: waypoints[waypoints.length - 1]?.dragRulerFinalState, enableTerrainRuler: terrainRulerAvailable});
+				measureDistances([{ray}], token, getTokenShape(token), {
+					terrainRulerInitialState: waypoints[waypoints.length - 1]?.dragRulerFinalState,
+					enableTerrainRuler: terrainRulerAvailable,
+				});
 				ray.A.dragRulerVisitedSpaces = ray.terrainRulerVisitedSpaces;
 				ray.A.dragRulerFinalState = ray.terrainRulerFinalState;
 			}
@@ -68,23 +68,18 @@ function calculateUpdate(combat, token, rays) {
 
 export function getMovementHistory(token) {
 	const combat = game.combat;
-	if (!combat)
+	if (!combat) return [];
-		return [];
 	const combatant = combat.getCombatantByToken(token.id);
-	if (!combatant)
+	if (!combatant) return [];
-		return [];
 	const dragRulerFlags = combatant.data.flags.dragRuler;
-	if (!dragRulerFlags)
+	if (!dragRulerFlags) return [];
-		return [];
+	if (combat.data.round > dragRulerFlags.trackedRound) return [];
-	if (combat.data.round > dragRulerFlags.trackedRound)
-		return [];
 	return dragRulerFlags.passedWaypoints ?? [];
 }
 
 export async function removeLastHistoryEntryIfAt(token, x, y) {
 	const history = getMovementHistory(token);
-	if (history.length === 0)
+	if (history.length === 0) return;
-		return;
 	const entry = history[history.length - 1];
 	if (!isClose(x + token.w / 2, entry.x, 0.1) || !isClose(y + token.h / 2, entry.y, 0.1)) {
 		return;
@@ -92,14 +87,15 @@ export async function removeLastHistoryEntryIfAt(token, x, y) {
 	history.pop();
 	const combat = game.combat;
 	const combatant = combat.getCombatantByToken(token.id);
-	await updateCombatantDragRulerFlags(combat, [{_id: combatant.id, dragRulerFlags: combatant.data.flags.dragRuler}]);
+	await updateCombatantDragRulerFlags(combat, [
+		{_id: combatant.id, dragRulerFlags: combatant.data.flags.dragRuler},
+	]);
 }
 
 export async function resetMovementHistory(combat, combatantId) {
 	const combatant = combat.combatants.get(combatantId);
 	const dragRulerFlags = combatant.data.flags.dragRuler;
-	if (!dragRulerFlags)
+	if (!dragRulerFlags) return;
-		return;
 	dragRulerFlags.passedWaypoints = null;
 	dragRulerFlags.trackedRound = null;
 	dragRulerFlags.rulerState = null;

js/pathfinding.js

@@ -1,8 +1,19 @@
-import {getCenterFromGridPositionObj, getGridPositionFromPixelsObj, getPixelsFromGridPositionObj} from "./foundry_fixes.js";
+import {
+	getCenterFromGridPositionObj,
+	getGridPositionFromPixelsObj,
+	getPixelsFromGridPositionObj,
+} from "./foundry_fixes.js";
 import {moveWithoutAnimation, togglePathfinding} from "./keybindings.js";
 import {debugGraphics} from "./main.js";
 import {settingsKey} from "./settings.js";
-import {buildSnapPointTokenData, getSnapPointForTokenDataObj, getTokenShape, getTokenShapeForTokenData, isModuleActive, iterPairs} from "./util.js";
+import {
+	buildSnapPointTokenData,
+	getSnapPointForTokenDataObj,
+	getTokenShape,
+	getTokenShapeForTokenData,
+	isModuleActive,
+	iterPairs,
+} from "./util.js";
 
 import * as GridlessPathfinding from "../wasm/gridless_pathfinding.js";
 import {PriorityQueueSet, ProcessOnceQueue} from "./data_structures.js";
@@ -60,8 +71,8 @@ class Cache {
 		this.background = {
 			nextJobId: null,
 			nextTimeoutId: null,
-			nextAnimationFrameId: null
+			nextAnimationFrameId: null,
-		}
+		};
 	}
 
 	clear() {
@@ -98,8 +109,10 @@ class Cache {
 			// Check if we already have the max number of layers. If we do,
 			// get rid of the one that hasn't been used for the longest
 			if (this.layers.size >= Cache.maxCacheLayers) {
-				const oldestCache = Array.from(this.layers.values())
+				const oldestCache = Array.from(this.layers.values()).reduce(
-					.reduce((layer1, layer2) => (layer1?.lastUsed < layer2.lastUsed) ? layer1 : layer2, null);
+					(layer1, layer2) => (layer1?.lastUsed < layer2.lastUsed ? layer1 : layer2),
+					null,
+				);
 				this.layers.delete(oldestCache.cacheId);
 			}
 
@@ -119,7 +132,7 @@ class Cache {
 	 */
 	startBackgroundCaching(token) {
 		const cacheLayer = this.getCacheLayer(token);
-		const tokenPosition = getGridPositionFromPixelsObj(token.position)
+		const tokenPosition = getGridPositionFromPixelsObj(token.position);
 
 		cacheLayer.queue.push(cacheLayer.nodes[tokenPosition.y][tokenPosition.x]);
 
@@ -137,8 +150,8 @@ class Cache {
 		// Find the latest-used cache that has nodes left to cache
 		const latestCache = this.getLatestCacheWithNonEmptyQueue();
 		if (latestCache) {
-			this.background.nextJobId = window.requestIdleCallback(
+			this.background.nextJobId = window.requestIdleCallback(() =>
-				() => this.runBackgroundCache(latestCache)
+				this.runBackgroundCache(latestCache),
 			);
 			this.resetAnimationFrameTimeout();
 		}
@@ -152,13 +165,10 @@ class Cache {
 		this.cancelTimeout();
 		this.cancelAnimationFrame();
 
-		this.background.nextTimeoutId = window.setTimeout(
+		this.background.nextTimeoutId = window.setTimeout(() => {
-			() => {
 			this.scheduleAnimationFrameCache();
 			this.background.nextTimeoutId = null;
-			},
+		}, Cache.backgroundCachingTimeoutMillis);
-			Cache.backgroundCachingTimeoutMillis
-		);
 	}
 
 	/**
@@ -167,8 +177,8 @@ class Cache {
 	scheduleAnimationFrameCache() {
 		const latestCache = this.getLatestCacheWithNonEmptyQueue();
 		if (latestCache) {
-			this.background.nextAnimationFrameId = window.requestAnimationFrame(
+			this.background.nextAnimationFrameId = window.requestAnimationFrame(() =>
-				() => this.runAnimationCache(latestCache)
+				this.runAnimationCache(latestCache),
 			);
 		}
 	}
@@ -179,7 +189,7 @@ class Cache {
 	getLatestCacheWithNonEmptyQueue() {
 		return Array.from(this.layers.values())
 			.filter(layer => layer.queue.hasNext())
-			.reduce((layer1, layer2) => (layer1?.lastUsed > layer2.lastUsed) ? layer1 : layer2, null);
+			.reduce((layer1, layer2) => (layer1?.lastUsed > layer2.lastUsed ? layer1 : layer2), null);
 	}
 
 	/**
@@ -238,12 +248,9 @@ let gridlessPathfinders = new Map();
 let gridWidth, gridHeight;
 
 export function isPathfindingEnabled() {
-	if (this.user !== game.user)
+	if (this.user !== game.user) return false;
-		return false;
+	if (!game.user.isGM && !game.settings.get(settingsKey, "allowPathfinding")) return false;
-	if (!game.user.isGM && !game.settings.get(settingsKey, "allowPathfinding"))
+	if (moveWithoutAnimation) return false;
-		return false;
-	if (moveWithoutAnimation)
-		return false;
 	return game.settings.get(settingsKey, "autoPathfinding") != togglePathfinding;
 }
 
@@ -253,7 +260,12 @@ export function findPath(from, to, token, previousWaypoints) {
 		let pathfinder = gridlessPathfinders.get(tokenSize);
 		if (!pathfinder) {
 			let radiusMultiplier = game.settings.get(settingsKey, "pathfindingRadius");
-			pathfinder = GridlessPathfinding.initialize(canvas.walls.placeables, tokenSize * radiusMultiplier, token.data.elevation, Boolean(game.modules.get("wall-height")?.active));
+			pathfinder = GridlessPathfinding.initialize(
+				canvas.walls.placeables,
+				tokenSize * radiusMultiplier,
+				token.data.elevation,
+				Boolean(game.modules.get("wall-height")?.active),
+			);
 			gridlessPathfinders.set(tokenSize, pathfinder);
 		}
 		paintGridlessPathfindingDebug(pathfinder);
@@ -261,30 +273,36 @@ export function findPath(from, to, token, previousWaypoints) {
 	} else {
 		const cacheLayer = cache.getCacheLayer(token);
 		const firstNode = calculatePath(from, to, cacheLayer, previousWaypoints);
-		if (!firstNode)
+		if (!firstNode) return null;
-			return null;
 		paintGriddedPathfindingDebug(firstNode, cacheLayer.tokenData);
 		const path = [];
 		let currentNode = firstNode;
 		while (currentNode) {
-			if (path.length >= 2 && !stepCollidesWithWall(path[path.length - 2], currentNode.node, cacheLayer.tokenData)) {
+			if (
+				path.length >= 2 &&
+				!stepCollidesWithWall(path[path.length - 2], currentNode.node, cacheLayer.tokenData)
+			) {
 				// Replace last waypoint if the current waypoint leads to a valid path that isn't longer than the old path
 				if (window.terrainRuler) {
 					let startNode = getCenterFromGridPositionObj(path[path.length - 2]);
 					let middleNode = getCenterFromGridPositionObj(path[path.length - 1]);
 					let endNode = getCenterFromGridPositionObj(currentNode.node);
-					let oldPath = [{ray: new Ray(startNode, middleNode)}, {ray: new Ray(middleNode, endNode)}];
+					let oldPath = [
+						{ray: new Ray(startNode, middleNode)},
+						{ray: new Ray(middleNode, endNode)},
+					];
 					let newPath = [{ray: new Ray(startNode, endNode)}];
 					let costFunction = buildCostFunction(token, getTokenShape(token));
 					// TODO Cache the used measurement for use in the next loop to improve performance
-					let oldDistance = terrainRuler.measureDistances(oldPath, {costFunction}).reduce((a, b) => a + b);
+					let oldDistance = terrainRuler
+						.measureDistances(oldPath, {costFunction})
+						.reduce((a, b) => a + b);
 					let newDistance = terrainRuler.measureDistances(newPath, {costFunction})[0];
 
 					// TODO We might need to check if the diagonal count has increased on 5-10-5
 					if (newDistance < oldDistance) {
 						path.pop();
-					}
+					} else if (newDistance === oldDistance) {
-					else if (newDistance === oldDistance) {
 						let oldNoDiagonals = oldPath[1].ray.terrainRulerFinalState?.noDiagonals;
 						let newNoDiagonals = newPath[0].ray.terrainRulerFinalState?.noDiagonals;
 						// This uses === && < instead of <= because the variables might be undefined (which shall lead to a true result)
@@ -292,8 +310,7 @@ export function findPath(from, to, token, previousWaypoints) {
 							path.pop();
 						}
 					}
-				}
+				} else {
-				else {
 					path.pop();
 				}
 			}
@@ -323,18 +340,36 @@ function getNode(pos, cacheLayer, initialize = true) {
 	const node = cacheLayer.nodes[pos.y][pos.x];
 	if (initialize && !node.edges) {
 		node.edges = [];
-		for (const neighborPos of canvas.grid.grid.getNeighbors(pos.y, pos.x).map(([y, x]) => {return {x, y};})) {
+		for (const neighborPos of canvas.grid.grid.getNeighbors(pos.y, pos.x).map(([y, x]) => {
-			if (neighborPos.x < 0 || neighborPos.y < 0 || neighborPos.x >= gridWidth || neighborPos.y >= gridHeight) {
+			return {x, y};
+		})) {
+			if (
+				neighborPos.x < 0 ||
+				neighborPos.y < 0 ||
+				neighborPos.x >= gridWidth ||
+				neighborPos.y >= gridHeight
+			) {
 				continue;
 			}
 
 			// TODO Work with pixels instead of grid locations
 			if (!stepCollidesWithWall(pos, neighborPos, cacheLayer.tokenData)) {
-				const isDiagonal = node.x !== neighborPos.x && node.y !== neighborPos.y && canvas.grid.type === CONST.GRID_TYPES.SQUARE;
+				const isDiagonal =
+					node.x !== neighborPos.x &&
+					node.y !== neighborPos.y &&
+					canvas.grid.type === CONST.GRID_TYPES.SQUARE;
 				let edgeCost;
 				if (window.terrainRuler) {
-					let ray = new Ray(getCenterFromGridPositionObj(pos), getCenterFromGridPositionObj(neighborPos));
+					let ray = new Ray(
-					let measuredDistance = terrainRuler.measureDistances([{ray}], {costFunction: buildCostFunction(cacheLayer.tokenData, getTokenShapeForTokenData(cacheLayer.tokenData))})[0];
+						getCenterFromGridPositionObj(pos),
+						getCenterFromGridPositionObj(neighborPos),
+					);
+					let measuredDistance = terrainRuler.measureDistances([{ray}], {
+						costFunction: buildCostFunction(
+							cacheLayer.tokenData,
+							getTokenShapeForTokenData(cacheLayer.tokenData),
+						),
+					})[0];
 					edgeCost = Math.round(measuredDistance / canvas.dimensions.distance);
 					if (ray.terrainRulerFinalState?.noDiagonals === 1) {
 						edgeCost = 1.5;
@@ -343,8 +378,7 @@ function getNode(pos, cacheLayer, initialize = true) {
 					if (isDiagonal && edgeCost == 1) {
 						edgeCost = 1.0001;
 					}
-				}
+				} else {
-				else {
 					// Count 5-10-5 diagonals as 1.5 (so two add up to 3) and 5-5-5 diagonals as 1.0001 (to discourage unnecessary diagonals)
 					// TODO Account for difficult terrain
 					edgeCost = isDiagonal ? (use5105 ? 1.5 : 1.0001) : 1;
@@ -365,17 +399,18 @@ function calculatePath(from, to, cacheLayer, previousWaypoints) {
 		startCost = (calcNoDiagonals(previousWaypoints) % 2) * 0.5;
 	}
 
-	const nextNodes = new PriorityQueueSet((node1, node2) => node1.node === node2.node, node => node.estimated);
+	const nextNodes = new PriorityQueueSet(
+		(node1, node2) => node1.node === node2.node,
+		node => node.estimated,
+	);
 	const previousNodes = new Set();
 
-	nextNodes.pushWithPriority(
+	nextNodes.pushWithPriority({
-		{
 		node: getNode(from, cacheLayer),
 		cost: startCost,
 		estimated: startCost + estimateCost(from, to),
-			previous: null
+		previous: null,
-		}
+	});
-	);
 
 	while (nextNodes.hasNext()) {
 		// Get node with cheapest estimate
@@ -394,7 +429,7 @@ function calculatePath(from, to, cacheLayer, previousWaypoints) {
 				node: neighborNode,
 				cost: currentNode.cost + edge.cost,
 				estimated: currentNode.cost + edge.cost + estimateCost(neighborNode, to),
-				previous: currentNode
+				previous: currentNode,
 			};
 			nextNodes.pushWithPriority(neighbor);
 		}
@@ -412,8 +447,8 @@ function buildPathNodes(lastNode) {
 		const pathNode = {
 			node: currentNode.node,
 			cost: currentNode.cost,
-			next: previousNode
+			next: previousNode,
-		}
+		};
 		previousNode = pathNode;
 		currentNode = currentNode.previous;
 	}
@@ -444,7 +479,7 @@ function stepCollidesWithWall(from, to, tokenData) {
 	if (isModuleActive("levels")) {
 		stepStart.z = tokenData.elevation;
 		stepEnd.z = tokenData.elevation;
-		return _levels.testCollision(stepStart, stepEnd, "collision")
+		return _levels.testCollision(stepStart, stepEnd, "collision");
 	} else {
 		return canvas.walls.checkCollision(new Ray(stepStart, stepEnd));
 	}
@@ -456,8 +491,7 @@ export function wipePathfindingCache() {
 		GridlessPathfinding.free(pathfinder);
 	}
 	gridlessPathfinders.clear();
-	if (debugGraphics)
+	if (debugGraphics) debugGraphics.removeChildren().forEach(c => c.destroy());
-		debugGraphics.removeChildren().forEach(c => c.destroy());
 }
 
 export function initializePathfinding() {
@@ -467,22 +501,23 @@ export function initializePathfinding() {
 
 export function startBackgroundCaching(token) {
 	// Background caching isn't yet supported for gridless scenes
-	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS)
+	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) return;
-		return;
 	if (game.user.isGM || game.settings.get(settingsKey, "allowPathfinding")) {
 		cache.startBackgroundCaching(token);
 	}
 }
 
 function paintGriddedPathfindingDebug(firstNode, tokenData) {
-	if (!CONFIG.debug.dragRuler)
+	if (!CONFIG.debug.dragRuler) return;
-		return;
 
 	debugGraphics.removeChildren().forEach(c => c.destroy());
 	let currentNode = firstNode;
 	while (currentNode) {
 		let text = new PIXI.Text(currentNode.cost.toFixed(1));
-		let pixels = getSnapPointForTokenDataObj(getPixelsFromGridPositionObj(currentNode.node), tokenData);
+		let pixels = getSnapPointForTokenDataObj(
+			getPixelsFromGridPositionObj(currentNode.node),
+			tokenData,
+		);
 		text.anchor.set(0.5, 1.0);
 		text.x = pixels.x;
 		text.y = pixels.y;
@@ -492,8 +527,7 @@ function paintGriddedPathfindingDebug(firstNode, tokenData) {
 }
 
 function paintGridlessPathfindingDebug(pathfinder) {
-	if (!CONFIG.debug.dragRuler)
+	if (!CONFIG.debug.dragRuler) return;
-		return;
 
 	debugGraphics.removeChildren().forEach(c => c.destroy());
 	let graphic = new PIXI.Graphics();

js/ruler.js

@@ -1,6 +1,10 @@
-import {currentSpeedProvider, getColorForDistanceAndToken, getRangesFromSpeedProvider} from "./api.js";
+import {
+	currentSpeedProvider,
+	getColorForDistanceAndToken,
+	getRangesFromSpeedProvider,
+} from "./api.js";
 import {getHexSizeSupportTokenGridCenter} from "./compatibility.js";
-import {cancelScheduledMeasurement, measure} from "./foundry_imports.js"
+import {cancelScheduledMeasurement, measure} from "./foundry_imports.js";
 import {getMovementHistory} from "./movement_tracking.js";
 import {settingsKey} from "./settings.js";
 import {getSnapPointForEntity} from "./util.js";
@@ -24,8 +28,7 @@ export function extendRuler() {
 
 		async moveToken(event) {
 			// Disable moveToken if Drag Ruler is active
-			if (!this.isDragRuler)
+			if (!this.isDragRuler) return await super.moveToken(event);
-				return await super.moveToken(event);
 		}
 
 		toJSON() {
@@ -45,16 +48,18 @@ export function extendRuler() {
 
 		update(data) {
 			// Don't show a GMs drag ruler to non GM players
-			if (data.draggedEntity && this.user.isGM && !game.user.isGM && !game.settings.get(settingsKey, "showGMRulerToPlayers"))
+			if (
+				data.draggedEntity &&
+				this.user.isGM &&
+				!game.user.isGM &&
+				!game.settings.get(settingsKey, "showGMRulerToPlayers")
+			)
 				return;
 
 			if (data.draggedEntity) {
-				if (data.draggedEntityIsToken)
+				if (data.draggedEntityIsToken) this.draggedEntity = canvas.tokens.get(data.draggedEntity);
-					this.draggedEntity = canvas.tokens.get(data.draggedEntity);
+				else this.draggedEntity = canvas.templates.get(data.draggedEntity);
-				else
+			} else {
-					this.draggedEntity = canvas.templates.get(data.draggedEntity);
-			}
-			else {
 				this.draggedEntity = undefined;
 			}
 
@@ -64,11 +69,9 @@ export function extendRuler() {
 		measure(destination, options = {}) {
 			if (this.isDragRuler) {
 				// If this is the ruler of a remote user take the waypoints as they were transmitted and don't apply any additional snapping to them
-				if (this.user !== game.user)
+				if (this.user !== game.user) options.snap = false;
-					options.snap = false;
 				return measure.call(this, destination, options);
-			}
+			} else {
-			else {
 				return super.measure(destination, options);
 			}
 		}
@@ -86,11 +89,13 @@ export function extendRuler() {
 			}
 			this.waypoints.push(new PIXI.Point(point.x, point.y));
 			this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
-			this.waypoints.filter(waypoint => waypoint.isPathfinding).forEach(waypoint => waypoint.isPathfinding = false);
+			this.waypoints
+				.filter(waypoint => waypoint.isPathfinding)
+				.forEach(waypoint => (waypoint.isPathfinding = false));
 		}
 
 		dragRulerAddWaypointHistory(waypoints) {
-			waypoints.forEach(waypoint => waypoint.isPrevious = true);
+			waypoints.forEach(waypoint => (waypoint.isPrevious = true));
 			this.waypoints = this.waypoints.concat(waypoints);
 			for (const waypoint of waypoints) {
 				this.labels.addChild(new PreciseText("", CONFIG.canvasTextStyle));
@@ -102,30 +107,51 @@ export function extendRuler() {
 			this.labels.removeChildren().forEach(c => c.destroy());
 		}
 
-		dragRulerDeleteWaypoint(event={preventDefault: () => {return}}, options={}) {
+		dragRulerDeleteWaypoint(
+			event = {
+				preventDefault: () => {
+					return;
+				},
+			},
+			options = {},
+		) {
 			this.dragRulerRemovePathfindingWaypoints();
 			options.snap = options.snap ?? true;
 			if (this.waypoints.filter(w => !w.isPrevious).length > 1) {
 				event.preventDefault();
-				const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens);
+				const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(
+					canvas.tokens,
+				);
 				const rulerOffset = this.rulerOffset;
 
 				// Options are not passed to _removeWaypoint in vanilla Foundry.
 				// Send them in case other modules have overriden that behavior and accept an options parameter (Toggle Snap to Grid)
-				this._removeWaypoint({x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y}, options);
+				this._removeWaypoint(
+					{x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y},
+					options,
+				);
 				game.user.broadcastActivity({ruler: this});
-			}
+			} else {
-			else {
 				this.dragRulerAbortDrag(event);
 			}
 		}
 
 		dragRulerRemovePathfindingWaypoints() {
-			this.waypoints.filter(waypoint => waypoint.isPathfinding).forEach(_ => this.labels.removeChild(this.labels.children[this.labels.children.length - 1]).destroy());
+			this.waypoints
+				.filter(waypoint => waypoint.isPathfinding)
+				.forEach(_ =>
+					this.labels.removeChild(this.labels.children[this.labels.children.length - 1]).destroy(),
+				);
 			this.waypoints = this.waypoints.filter(waypoint => !waypoint.isPathfinding);
 		}
 
-		dragRulerAbortDrag(event={preventDefault: () => {return}}) {
+		dragRulerAbortDrag(
+			event = {
+				preventDefault: () => {
+					return;
+				},
+			},
+		) {
 			const token = this.draggedEntity;
 			this._endMeasurement();
 
@@ -139,10 +165,8 @@ export function extendRuler() {
 		}
 
 		async dragRulerRecalculate(tokenIds) {
-			if (this._state !== Ruler.STATES.MEASURING)
+			if (this._state !== Ruler.STATES.MEASURING) return;
-				return;
+			if (tokenIds && !tokenIds.includes(this.draggedEntity.id)) return;
-			if (tokenIds && !tokenIds.includes(this.draggedEntity.id))
-				return;
 			const waypoints = this.waypoints.filter(waypoint => !waypoint.isPrevious);
 			this.dragRulerClearWaypoints();
 			if (game.settings.get(settingsKey, "enableMovementHistory"))
@@ -155,8 +179,7 @@ export function extendRuler() {
 		}
 
 		static dragRulerGetRaysFromWaypoints(waypoints, destination) {
-			if ( destination )
+			if (destination) waypoints = waypoints.concat([destination]);
-				waypoints = waypoints.concat([destination]);
 			return waypoints.slice(1).map((wp, i) => {
 				const ray = new Ray(waypoints[i], wp);
 				ray.isPrevious = Boolean(waypoints[i].isPrevious);
@@ -165,48 +188,62 @@ export function extendRuler() {
 		}
 
 		dragRulerGetColorForDistance(distance) {
-			if (!this.isDragRuler)
+			if (!this.isDragRuler) return this.color;
-				return this.color;
 			if (!this.draggedEntity.actor) {
 				return this.color;
 			}
 			// Don't apply colors if the current user doesn't have at least observer permissions
 			if (this.draggedEntity.actor.permission < 2) {
 				// If this is a pc and alwaysShowSpeedForPCs is enabled we show the color anyway
-				if (!(this.draggedEntity.actor.data.type === "character" && game.settings.get(settingsKey, "alwaysShowSpeedForPCs")))
+				if (
+					!(
+						this.draggedEntity.actor.data.type === "character" &&
+						game.settings.get(settingsKey, "alwaysShowSpeedForPCs")
+					)
+				)
 					return this.color;
 			}
 			distance = Math.round(distance * 100) / 100;
 			if (!this.dragRulerRanges)
 				this.dragRulerRanges = getRangesFromSpeedProvider(this.draggedEntity);
-			return getColorForDistanceAndToken(distance, this.draggedEntity, this.dragRulerRanges) ?? this.color;
+			return (
+				getColorForDistanceAndToken(distance, this.draggedEntity, this.dragRulerRanges) ??
+				this.color
+			);
 		}
 
 		dragRulerStart(options, measureImmediately = true) {
 			const entity = this.draggedEntity;
 			const isToken = entity instanceof Token;
-			if (isToken && !currentSpeedProvider.usesRuler(entity))
+			if (isToken && !currentSpeedProvider.usesRuler(entity)) return;
-				return;
 			const ruler = canvas.controls.ruler;
 			ruler.clear();
 			ruler._state = Ruler.STATES.STARTING;
 			let entityCenter;
-			if (isToken && canvas.grid.isHex && game.modules.get("hex-size-support")?.active && CONFIG.hexSizeSupport.getAltSnappingFlag(entity))
+			if (
+				isToken &&
+				canvas.grid.isHex &&
+				game.modules.get("hex-size-support")?.active &&
+				CONFIG.hexSizeSupport.getAltSnappingFlag(entity)
+			)
 				entityCenter = getHexSizeSupportTokenGridCenter(entity);
-			else
+			else entityCenter = entity.center;
-				entityCenter = entity.center;
 			if (isToken && game.settings.get(settingsKey, "enableMovementHistory"))
 				ruler.dragRulerAddWaypointHistory(getMovementHistory(entity));
 			ruler.dragRulerAddWaypoint(entityCenter, {snap: false});
-			const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens);
+			const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(
-			const destination = {x: mousePosition.x + ruler.rulerOffset.x, y: mousePosition.y + ruler.rulerOffset.y};
+				canvas.tokens,
-			if (measureImmediately)
+			);
-				ruler.measure(destination, options);
+			const destination = {
+				x: mousePosition.x + ruler.rulerOffset.x,
+				y: mousePosition.y + ruler.rulerOffset.y,
+			};
+			if (measureImmediately) ruler.measure(destination, options);
 		}
 
 		dragRulerSendState() {
 			game.user.broadcastActivity({
-				ruler: this.toJSON()
+				ruler: this.toJSON(),
 			});
 		}
 	}

js/settings.js

@@ -1,6 +1,11 @@
-import {availableSpeedProviders, currentSpeedProvider, getDefaultSpeedProvider, updateSpeedProvider} from "./api.js";
+import {
-import {SpeedProvider} from "./speed_provider.js"
+	availableSpeedProviders,
-import {wipePathfindingCache} from "./pathfinding.js"
+	currentSpeedProvider,
+	getDefaultSpeedProvider,
+	updateSpeedProvider,
+} from "./api.js";
+import {SpeedProvider} from "./speed_provider.js";
+import {wipePathfindingCache} from "./pathfinding.js";
 import {early_isGM} from "./util.js";
 
 export const settingsKey = "drag-ruler";
@@ -20,14 +25,14 @@ export function registerSettings() {
 		scope: "world",
 		config: false,
 		type: String,
-		default: "fresh install"
+		default: "fresh install",
-	})
+	});
 
 	game.settings.register(settingsKey, "clientDataVersion", {
 		scope: "client",
 		config: false,
 		type: String,
-		default: "fresh install"
+		default: "fresh install",
 	});
 
 	game.settings.register(settingsKey, "rightClickAction", {
@@ -68,7 +73,7 @@ export function registerSettings() {
 		config: true,
 		type: Boolean,
 		default: true,
-	})
+	});
 
 	game.settings.register(settingsKey, "showGMRulerToPlayers", {
 		name: "drag-ruler.settings.showGMRulerToPlayers.name",
@@ -77,7 +82,7 @@ export function registerSettings() {
 		config: true,
 		type: Boolean,
 		default: true,
-	})
+	});
 
 	game.settings.register(settingsKey, "enableMovementHistory", {
 		name: "drag-ruler.settings.enableMovementHistory.name",
@@ -134,7 +139,7 @@ export function registerSettings() {
 		type: String,
 		default: getDefaultSpeedProvider(),
 		onChange: updateSpeedProvider,
-	})
+	});
 
 	game.settings.registerMenu(settingsKey, "speedProviderSettings", {
 		name: "drag-ruler.settings.speedProviderSettings.name",
@@ -143,7 +148,7 @@ export function registerSettings() {
 		icon: "fas fa-tachometer-alt",
 		type: SpeedProviderSettings,
 		restricted: false,
-	})
+	});
 }
 
 class SpeedProviderSettings extends FormApplication {
@@ -153,43 +158,44 @@ class SpeedProviderSettings extends FormApplication {
 			title: game.i18n.localize("drag-ruler.settings.speedProviderSettings.windowTitle"),
 			template: "modules/drag-ruler/templates/speed_provider_settings.html",
 			width: 600,
-		})
+		});
 	}
 
 	getData(options = {}) {
-		const data = {}
+		const data = {};
-		data.isGM = game.user.isGM
+		data.isGM = game.user.isGM;
-		const selectedProvider = currentSpeedProvider.id
+		const selectedProvider = currentSpeedProvider.id;
 
 		// Insert all speed providers into the template data
 		data.providers = Object.values(availableSpeedProviders).map(speedProvider => {
-			const provider = {}
+			const provider = {};
-			provider.id = speedProvider.id
+			provider.id = speedProvider.id;
-			provider.hasSettings = speedProvider instanceof SpeedProvider
+			provider.hasSettings = speedProvider instanceof SpeedProvider;
-			if (provider.hasSettings)
+			if (provider.hasSettings) provider.settings = enumerateProviderSettings(speedProvider);
-				provider.settings = enumerateProviderSettings(speedProvider)
+			let dotPosition = provider.id.indexOf(".");
-			let dotPosition = provider.id.indexOf(".")
+			if (dotPosition === -1) dotPosition = provider.id.length;
-			if (dotPosition === -1)
+			const type = provider.id.substring(0, dotPosition);
-				dotPosition = provider.id.length
+			const id = provider.id.substring(dotPosition + 1);
-			const type = provider.id.substring(0, dotPosition)
-			const id = provider.id.substring(dotPosition + 1)
 			if (type === "native") {
-				provider.selectTitle = game.i18n.localize("drag-ruler.settings.speedProviderSettings.speedProvider.choices.native")
+				provider.selectTitle = game.i18n.localize(
-			}
+					"drag-ruler.settings.speedProviderSettings.speedProvider.choices.native",
-			else {
+				);
-				let name
+			} else {
+				let name;
 				if (type === "module") {
-					name = game.modules.get(id).data.title
+					name = game.modules.get(id).data.title;
+				} else {
+					name = game.system.data.title;
 				}
-				else {
+				provider.selectTitle = game.i18n.format(
-					name = game.system.data.title
+					`drag-ruler.settings.speedProviderSettings.speedProvider.choices.${type}`,
+					{name},
+				);
 			}
-				provider.selectTitle = game.i18n.format(`drag-ruler.settings.speedProviderSettings.speedProvider.choices.${type}`, {name})
+			provider.isSelected = provider.id === selectedProvider;
-			}
+			return provider;
-			provider.isSelected = provider.id === selectedProvider
+		});
-			return provider
+		data.selectedProviderName = data.providers.find(provider => provider.isSelected).selectTitle;
-		})
-		data.selectedProviderName = data.providers.find(provider => provider.isSelected).selectTitle
 
 		data.providerSelection = {
 			id: "speedProvider",
@@ -197,122 +203,126 @@ class SpeedProviderSettings extends FormApplication {
 			hint: game.i18n.localize("drag-ruler.settings.speedProviderSettings.speedProvider.hint"),
 			type: String,
 			choices: data.providers.reduce((choices, provider) => {
-				choices[provider.id] = provider.selectTitle
+				choices[provider.id] = provider.selectTitle;
-				return choices
+				return choices;
 			}, {}),
 			value: selectedProvider,
 			isCheckbox: false,
 			isSelect: true,
 			isRange: false,
-		}
+		};
-		return data
+		return data;
 	}
 
 	async _updateObject(event, formData) {
-		const selectedSpeedProvider = game.user.isGM ? formData.speedProvider : game.settings.get(settingsKey, "speedProvider")
+		const selectedSpeedProvider = game.user.isGM
+			? formData.speedProvider
+			: game.settings.get(settingsKey, "speedProvider");
 		for (let [key, value] of Object.entries(formData)) {
 			// Check if this is color, convert the value to an integer
-			const splitKey = key.split(".", 3)
+			const splitKey = key.split(".", 3);
-			if (splitKey[0] !== "native")
+			if (splitKey[0] !== "native") splitKey.shift();
-				splitKey.shift()
 			if (splitKey.length >= 2 && splitKey[1] == "color") {
-				value = parseInt(value.substring(1), 16)
+				value = parseInt(value.substring(1), 16);
 			}
 
 			// Don't change settings for speed providers that aren't currently active
-			if (key !== "speedProvider" && !key.startsWith(selectedSpeedProvider))
+			if (key !== "speedProvider" && !key.startsWith(selectedSpeedProvider)) continue;
-				continue
 
 			// Get the key for the current setting
-			let setting
+			let setting;
-			if (key === "speedProvider")
+			if (key === "speedProvider") setting = "speedProvider";
-				setting = "speedProvider"
+			else setting = `speedProviders.${key}`;
-			else
-				setting = `speedProviders.${key}`
 
 			// Get the old setting value
-			const oldValue = game.settings.get(settingsKey, setting)
+			const oldValue = game.settings.get(settingsKey, setting);
 
 			// Only update the setting if it has been changed (this leaves the default in place if it hasn't been touched)
-			if (value !== oldValue)
+			if (value !== oldValue) game.settings.set(settingsKey, setting, value);
-				game.settings.set(settingsKey, setting, value)
 		}
 
 		// Activate the configured speed provider
-		updateSpeedProvider()
+		updateSpeedProvider();
 	}
 
 	activateListeners(html) {
-		super.activateListeners(html)
+		super.activateListeners(html);
-		html.find("select[name=speedProvider]").change(this.onSpeedProviderChange.bind(this))
+		html.find("select[name=speedProvider]").change(this.onSpeedProviderChange.bind(this));
 	}
 
 	onSpeedProviderChange(event) {
 		// Hide all module settings
-		document.querySelectorAll(".drag-ruler-provider-settings").forEach(element => element.style.display = "none")
+		document
+			.querySelectorAll(".drag-ruler-provider-settings")
+			.forEach(element => (element.style.display = "none"));
 		// Show the settings block for the currently selected module
-		document.getElementById(`drag-ruler.provider.${event.currentTarget.value}`).style.display = ""
+		document.getElementById(`drag-ruler.provider.${event.currentTarget.value}`).style.display = "";
 
 		// Recalculate window height
-		this.element[0].style.height = null
+		this.element[0].style.height = null;
-		this.position.height = undefined
+		this.position.height = undefined;
 	}
 }
 
 function toDomHex(value) {
-	const hex = value.toString(16)
+	const hex = value.toString(16);
-	return "#" + "0".repeat(Math.max(0, 6 - hex.length)) + hex
+	return "#" + "0".repeat(Math.max(0, 6 - hex.length)) + hex;
 }
 
 function enumerateProviderSettings(provider) {
-	const colorSettings = []
+	const colorSettings = [];
-	const unreachableColor = {id: "unreachable", name: "drag-ruler.settings.speedProviderSettings.color.unreachable.name"}
+	const unreachableColor = {
+		id: "unreachable",
+		name: "drag-ruler.settings.speedProviderSettings.color.unreachable.name",
+	};
 
 	// Resolve settings for the colors
 	for (const color of provider.colors.concat([unreachableColor])) {
 		// Localize the name, if avaliable. If no name is available use the id as name
-		const colorName = color.name ? game.i18n.localize(color.name) : color.id
+		const colorName = color.name ? game.i18n.localize(color.name) : color.id;
-		let hint
+		let hint;
 		if (color === unreachableColor)
-			hint = game.i18n.localize("drag-ruler.settings.speedProviderSettings.color.unreachable.hint")
+			hint = game.i18n.localize("drag-ruler.settings.speedProviderSettings.color.unreachable.hint");
 		else
-			hint = game.i18n.format("drag-ruler.settings.speedProviderSettings.color.hint", {colorName})
+			hint = game.i18n.format("drag-ruler.settings.speedProviderSettings.color.hint", {colorName});
 		colorSettings.push({
 			id: `${provider.id}.color.${color.id}`,
 			name: game.i18n.format("drag-ruler.settings.speedProviderSettings.color.name", {colorName}),
 			hint: hint,
 			type: Number,
-			value: toDomHex(game.settings.get(settingsKey, `speedProviders.${provider.id}.color.${color.id}`)),
+			value: toDomHex(
+				game.settings.get(settingsKey, `speedProviders.${provider.id}.color.${color.id}`),
+			),
 			isCheckbox: false,
 			isSelect: false,
 			isRange: false,
 			isColor: true,
-		})
+		});
 	}
 
 	// Prepare regular settings
-	const settings = []
+	const settings = [];
 	for (const setting of provider.settings) {
 		try {
-			if (setting.scope === "world" && !game.user.isGM)
+			if (setting.scope === "world" && !game.user.isGM) continue;
-				continue
+			const s = duplicate(setting);
-			const s = duplicate(setting)
+			s.id = `${provider.id}.setting.${s.id}`;
-			s.id = `${provider.id}.setting.${s.id}`
+			s.name = game.i18n.localize(s.name);
-			s.name = game.i18n.localize(s.name)
+			s.hint = game.i18n.localize(s.hint);
-			s.hint = game.i18n.localize(s.hint)
+			s.value = provider.getSetting(setting.id);
-			s.value = provider.getSetting(setting.id)
+			s.type = setting.type instanceof Function ? setting.type.name : "String";
-			s.type = setting.type instanceof Function ? setting.type.name : "String"
+			s.isCheckbox = setting.type === Boolean;
-			s.isCheckbox = setting.type === Boolean
+			s.isSelect = s.choices !== undefined;
-			s.isSelect = s.choices !== undefined
+			s.isRange = setting.type === Number && s.range;
-			s.isRange = (setting.type === Number) && s.range
+			s.isColor = false;
-			s.isColor = false
+			settings.push(s);
-			settings.push(s)
+		} catch (e) {
-		}
+			console.warn(
-		catch (e) {
+				`Drag Ruler | The following error occured while rendering setting "${setting.id}" of module/system "${this.id}. It won't be displayed.`,
-			console.warn(`Drag Ruler | The following error occured while rendering setting "${setting.id}" of module/system "${this.id}. It won't be displayed.`)
+			);
-			console.error(e)
+			console.error(e);
 		}
 	}
 
-	return settings.concat(colorSettings)
+	return settings.concat(colorSettings);
 }

js/socket.js

@@ -11,8 +11,13 @@ Hooks.once("socketlib.ready", () => {
 export function updateCombatantDragRulerFlags(combat, updates) {
 	const combatId = combat.id;
 	// TODO Check if canvas.tokens.get is still neccessary in future foundry versions
-	return socket.executeAsGM(_socketUpdateCombatantDragRulerFlags, combatId, updates)
+	return socket
-	             .then(() => currentSpeedProvider.onMovementHistoryUpdate(updates.map(update => canvas.tokens.get(combat.combatants.get(update._id).token.id))));
+		.executeAsGM(_socketUpdateCombatantDragRulerFlags, combatId, updates)
+		.then(() =>
+			currentSpeedProvider.onMovementHistoryUpdate(
+				updates.map(update => canvas.tokens.get(combat.combatants.get(update._id).token.id)),
+			),
+		);
 }
 
 async function _socketUpdateCombatantDragRulerFlags(combatId, updates) {
@@ -21,12 +26,15 @@ async function _socketUpdateCombatantDragRulerFlags(combatId, updates) {
 	const requestedUpdates = updates.length;
 	updates = updates.filter(update => {
 		const actor = combat.combatants.get(update._id).actor;
-		if (!actor)
+		if (!actor) return false;
-			return false;
 		return actor.testUserPermission(user, "OWNER");
 	});
 	if (updates.length !== requestedUpdates) {
-		console.warn(`Some of the movement history updates requested by user '${game.users.get(this.socketdata.userId).name}' were not performed because the user lacks owner permissions for those tokens`);
+		console.warn(
+			`Some of the movement history updates requested by user '${
+				game.users.get(this.socketdata.userId).name
+			}' were not performed because the user lacks owner permissions for those tokens`,
+		);
 	}
 	updates = updates.map(update => {
 		return {_id: update._id, flags: {dragRuler: update.dragRulerFlags}};
@@ -40,6 +48,5 @@ export function recalculate(tokens) {
 
 function _socketRecalculate(tokenIds) {
 	const ruler = canvas.controls.ruler;
-	if (ruler.isDragRuler)
+	if (ruler.isDragRuler) ruler.dragRulerRecalculate(tokenIds);
-		ruler.dragRulerRecalculate(tokenIds);
 }

js/speed_provider.js

@@ -1,5 +1,5 @@
-import {settingsKey} from "./settings.js"
+import {settingsKey} from "./settings.js";
-import {getDefaultDashMultiplier, getDefaultSpeedAttribute} from "./systems.js"
+import {getDefaultDashMultiplier, getDefaultSpeedAttribute} from "./systems.js";
 
 /**
  * Base class for all speed providers.
@@ -19,7 +19,7 @@ export class SpeedProvider {
 	 * Implementing this method is required for all speed providers
 	 */
 	get colors() {
-		throw new Error("A SpeedProvider must implement the colors function")
+		throw new Error("A SpeedProvider must implement the colors function");
 	}
 
 	/**
@@ -31,7 +31,7 @@ export class SpeedProvider {
 	 * Implementing this method is required for all speed providers
 	 */
 	getRanges(token) {
-		throw new Error("A SpeedProvider must implement the getRanges function")
+		throw new Error("A SpeedProvider must implement the getRanges function");
 	}
 
 	/**
@@ -44,7 +44,7 @@ export class SpeedProvider {
 	 * Implementing this method is optional and only needs to be done if you want to provide custom provider settings
 	 */
 	get settings() {
-		return []
+		return [];
 	}
 
 	/**
@@ -53,7 +53,7 @@ export class SpeedProvider {
 	 * Implementing this method is optional and only needs to be done if you want to provide a custom default for that color.
 	 */
 	get defaultUnreachableColor() {
-		return 0xFF0000
+		return 0xff0000;
 	}
 
 	/**
@@ -74,7 +74,7 @@ export class SpeedProvider {
 		options.token = token;
 		const costs = area.map(space => terrainRuler.getCost(space.x, space.y, options));
 		// Return the maximum of the costs
-		return costs.reduce((max, current) => Math.max(max, current))
+		return costs.reduce((max, current) => Math.max(max, current));
 	}
 
 	/**
@@ -86,7 +86,7 @@ export class SpeedProvider {
 	 * Implementing this method is optional and only needs to be done if you want to disable Drag Ruler for some tokens.
 	 */
 	usesRuler(token) {
-		return true
+		return true;
 	}
 
 	/**
@@ -104,13 +104,14 @@ export class SpeedProvider {
 	 */
 	getSetting(settingId) {
 		try {
-			return game.settings.get(settingsKey, `speedProviders.${this.id}.setting.${settingId}`)
+			return game.settings.get(settingsKey, `speedProviders.${this.id}.setting.${settingId}`);
-		}
+		} catch (e) {
-		catch (e) {
 			if (this.settings.some(setting => setting.id === settingId)) {
-				throw e
+				throw e;
 			}
-			throw new Error(`Drag Ruler | "${settingId}" is not a registered setting for "${this.id}". If you're the module/system developer, please add it to the return values of your Speed Providers "get settings()" function.`)
+			throw new Error(
+				`Drag Ruler | "${settingId}" is not a registered setting for "${this.id}". If you're the module/system developer, please add it to the return values of your Speed Providers "get settings()" function.`,
+			);
 		}
 	}
 
@@ -120,32 +121,34 @@ export class SpeedProvider {
 	 * This function should neither be called or overridden by speed provider implementations
 	 */
 	constructor(id) {
-		this.id = id
+		this.id = id;
 	}
 }
 
-
 export class GenericSpeedProvider extends SpeedProvider {
 	get colors() {
 		return [
-			{id: "walk", default: 0x00FF00, name: "drag-ruler.genericSpeedProvider.speeds.walk"},
+			{id: "walk", default: 0x00ff00, name: "drag-ruler.genericSpeedProvider.speeds.walk"},
-			{id: "dash", default: 0xFFFF00, name: "drag-ruler.genericSpeedProvider.speeds.dash"}
+			{id: "dash", default: 0xffff00, name: "drag-ruler.genericSpeedProvider.speeds.dash"},
-		]
+		];
 	}
 
 	getRanges(token) {
-		const speedAttribute = this.getSetting("speedAttribute")
+		const speedAttribute = this.getSetting("speedAttribute");
-		if (!speedAttribute)
+		if (!speedAttribute) return [];
-			return []
 		const tokenSpeed = parseFloat(getProperty(token, speedAttribute));
 		if (tokenSpeed === undefined) {
-			console.warn(`Drag Ruler (Generic Speed Provider) | The configured token speed attribute "${speedAttribute}" didn't return a speed value. To use colors based on drag distance set the setting to the correct value (or clear the box to disable this feature).`)
+			console.warn(
-			return []
+				`Drag Ruler (Generic Speed Provider) | The configured token speed attribute "${speedAttribute}" didn't return a speed value. To use colors based on drag distance set the setting to the correct value (or clear the box to disable this feature).`,
+			);
+			return [];
 		}
-		const dashMultiplier = this.getSetting("dashMultiplier")
+		const dashMultiplier = this.getSetting("dashMultiplier");
-		if (!dashMultiplier)
+		if (!dashMultiplier) return [{range: tokenSpeed, color: "walk"}];
-			return [{range: tokenSpeed, color: "walk"}]
+		return [
-		return [{range: tokenSpeed, color: "walk"}, {range: tokenSpeed * dashMultiplier, color: "dash"}]
+			{range: tokenSpeed, color: "walk"},
+			{range: tokenSpeed * dashMultiplier, color: "dash"},
+		];
 	}
 
 	get settings() {
@@ -167,7 +170,7 @@ export class GenericSpeedProvider extends SpeedProvider {
 				config: true,
 				type: Number,
 				default: getDefaultDashMultiplier(),
-			}
+			},
-		]
+		];
 	}
 }

js/systems.js

@@ -24,13 +24,13 @@ export function getDefaultSpeedAttribute() {
 		case "splittermond":
 			return "actor.derivedValues.speed.value";
 	}
-	return ""
+	return "";
 }
 
 export function getDefaultDashMultiplier() {
 	switch (game.system.id) {
 		case "swade":
-			return 0
+			return 0;
 		case "dcc":
 		case "dnd4e":
 		case "dnd5e":

js/util.js

@@ -1,10 +1,10 @@
-import {getPixelsFromGridPosition} from "./foundry_fixes.js"
+import {getPixelsFromGridPosition} from "./foundry_fixes.js";
 import {findVertexSnapPoint} from "./hex_support.js";
 import {disableSnap} from "./keybindings.js";
 
 export function* zip(it1, it2) {
 	for (let i = 0; i < Math.min(it1.length, it2.length); i++) {
-		yield [it1[i], it2[i]]
+		yield [it1[i], it2[i]];
 	}
 }
 
@@ -29,13 +29,14 @@ export function sum(arr) {
 export function buildSnapPointTokenData(token) {
 	const tokenData = {
 		width: token.data.width,
-		height: token.data.height
+		height: token.data.height,
 	};
 
 	if (isModuleActive("hex-size-support")) {
 		tokenData.hexSizeSupport = {};
 		tokenData.hexSizeSupport.altSnappingFlag = CONFIG.hexSizeSupport.getAltSnappingFlag(token);
-		tokenData.hexSizeSupport.altOrientationFlag = CONFIG.hexSizeSupport.getAltOrientationFlag(token);
+		tokenData.hexSizeSupport.altOrientationFlag =
+			CONFIG.hexSizeSupport.getAltOrientationFlag(token);
 		tokenData.hexSizeSupport.borderSize = token.document.getFlag("hex-size-support", "borderSize");
 	}
 
@@ -58,27 +59,21 @@ function getSnapPointForTokenData(x, y, tokenData) {
 		if (tokenData.hexSizeSupport?.altSnappingFlag) {
 			if (tokenData.hexSizeSupport.borderSize % 2 === 0) {
 				const snapPoint = findVertexSnapPoint(x, y, tokenData.hexSizeSupport.altOrientationFlag);
-				return new PIXI.Point(snapPoint.x, snapPoint.y)
+				return new PIXI.Point(snapPoint.x, snapPoint.y);
+			} else {
+				return new PIXI.Point(...canvas.grid.getCenter(x, y));
 			}
-			else {
+		} else {
-				return new PIXI.Point(...canvas.grid.getCenter(x, y))
-			}
-		}
-		else {
 			return new PIXI.Point(...canvas.grid.getCenter(x, y));
 		}
 	}
 
 	const [topLeftX, topLeftY] = canvas.grid.getTopLeft(x, y);
 	let cellX, cellY;
-	if (tokenData.width % 2 === 0)
+	if (tokenData.width % 2 === 0) cellX = x - canvas.grid.h / 2;
-		cellX = x - canvas.grid.h / 2;
+	else cellX = x;
-	else
+	if (tokenData.height % 2 === 0) cellY = y - canvas.grid.h / 2;
-		cellX = x;
+	else cellY = y;
-	if (tokenData.height % 2 === 0)
-		cellY = y - canvas.grid.h / 2;
-	else
-		cellY = y;
 	const [centerX, centerY] = canvas.grid.getCenter(cellX, cellY);
 	let snapX, snapY;
 	// Tiny tokens can snap to the cells corners
@@ -101,11 +96,9 @@ function getSnapPointForTokenData(x, y, tokenData) {
 		const subGridHeight = Math.floor(canvas.grid.h / 2);
 		const subGridPosY = Math.floor(offsetY / subGridHeight);
 		snapY = topLeftY + (subGridPosY + 0.5) * subGridHeight;
-	}
+	} else if (Math.round(tokenData.height) % 2 === 1 || tokenData.height < 1) {
-	else if (Math.round(tokenData.height) % 2 === 1 || tokenData.height < 1) {
 		snapY = centerY;
-	}
+	} else {
-	else {
 		snapY = centerY + canvas.grid.h / 2;
 	}
 	return new PIXI.Point(snapX, snapY);
@@ -124,16 +117,13 @@ export function getSnapPointForMeasuredTemplate(x, y) {
 
 export function getSnapPointForEntity(x, y, entity) {
 	const isToken = entity instanceof Token;
-	if (isToken)
+	if (isToken) return getSnapPointForToken(x, y, entity);
-		return getSnapPointForToken(x, y, entity);
+	else return getSnapPointForMeasuredTemplate(x, y);
-	else
-		return getSnapPointForMeasuredTemplate(x, y);
 }
 
 export function highlightTokenShape(position, shape, color, alpha) {
 	const layer = canvas.grid.highlightLayers[this.name];
-    if ( !layer )
+	if (!layer) return false;
-		return false;
 	const area = getAreaFromPositionAndShape(position, shape);
 	for (const space of area) {
 		const [x, y] = getPixelsFromGridPosition(space.x, space.y);
@@ -147,22 +137,19 @@ export function getAreaFromPositionAndShape(position, shape) {
 		let y = position.y + space.y;
 		if (canvas.grid.isHex) {
 			let shiftedRow;
-			if (canvas.grid.grid.options.even)
+			if (canvas.grid.grid.options.even) shiftedRow = 1;
-				shiftedRow = 1
+			else shiftedRow = 0;
-			else
-				shiftedRow = 0
 			if (canvas.grid.grid.options.columns) {
 				if (space.x % 2 !== 0 && position.x % 2 !== shiftedRow) {
 					y += 1;
 				}
-			}
+			} else {
-			else {
 				if (space.y % 2 !== 0 && position.y % 2 !== shiftedRow) {
 					x += 1;
 				}
 			}
 		}
-		return {x, y}
+		return {x, y};
 	});
 }
 
@@ -172,38 +159,51 @@ export function getTokenShape(token) {
 
 export function getTokenShapeForTokenData(tokenData, scene = canvas.scene) {
 	if (scene.data.gridType === CONST.GRID_TYPES.GRIDLESS) {
-		return [{x: 0, y: 0}]
+		return [{x: 0, y: 0}];
-	}
+	} else if (scene.data.gridType === CONST.GRID_TYPES.SQUARE) {
-	else if (scene.data.gridType === CONST.GRID_TYPES.SQUARE) {
+		const topOffset = -Math.floor(tokenData.height / 2);
-		const topOffset = -Math.floor(tokenData.height / 2)
+		const leftOffset = -Math.floor(tokenData.width / 2);
-		const leftOffset = -Math.floor(tokenData.width / 2)
+		const shape = [];
-		const shape = []
 		for (let y = 0; y < tokenData.height; y++) {
 			for (let x = 0; x < tokenData.width; x++) {
-				shape.push({x: x + leftOffset, y: y + topOffset})
+				shape.push({x: x + leftOffset, y: y + topOffset});
 			}
 		}
-		return shape
+		return shape;
-	}
+	} else {
-	else {
 		// Hex grids
 		if (game.modules.get("hex-size-support")?.active && tokenData.hexSizeSupport.altSnappingFlag) {
 			const borderSize = tokenData.hexSizeSupport.borderSize;
 			let shape = [{x: 0, y: 0}];
 			if (borderSize >= 2)
-				shape = shape.concat([{x: 0, y: -1}, {x: -1, y: -1}]);
+				shape = shape.concat([
+					{x: 0, y: -1},
+					{x: -1, y: -1},
+				]);
 			if (borderSize >= 3)
-				shape = shape.concat([{x: 0, y: 1}, {x: -1, y: 1}, {x: -1, y: 0}, {x: 1, y: 0}]);
+				shape = shape.concat([
+					{x: 0, y: 1},
+					{x: -1, y: 1},
+					{x: -1, y: 0},
+					{x: 1, y: 0},
+				]);
 			if (borderSize >= 4)
-				shape = shape.concat([{x: -2, y: -1}, {x: 1, y: -1}, {x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}])
+				shape = shape.concat([
+					{x: -2, y: -1},
+					{x: 1, y: -1},
+					{x: -1, y: -2},
+					{x: 0, y: -2},
+					{x: 1, y: -2},
+				]);
 
 			if (Boolean(tokenData.hexSizeSupport.altOrientationFlag) !== canvas.grid.grid.options.columns)
-				shape.forEach(space => space.y *= -1);
+				shape.forEach(space => (space.y *= -1));
 			if (canvas.grid.grid.options.columns)
-				shape = shape.map(space => {return {x: space.y, y: space.x}});
+				shape = shape.map(space => {
+					return {x: space.y, y: space.x};
+				});
 			return shape;
-		}
+		} else {
-		else {
 			return [{x: 0, y: 0}];
 		}
 	}
@@ -213,11 +213,10 @@ export function getTokenSize(token) {
 	let w, h;
 	const hexSizeSupportBorderSize = token.data.flags["hex-size-support"]?.borderSize;
 	if (hexSizeSupportBorderSize > 0) {
-		w = h = hexSizeSupportBorderSize
+		w = h = hexSizeSupportBorderSize;
-	}
+	} else {
-	else {
+		w = token.data.width;
-		w = token.data.width
+		h = token.data.height;
-		h = token.data.height
 	}
 	return {w, h};
 }
@@ -226,7 +225,7 @@ export function getTokenSize(token) {
 // This function applies an offset to to the waypoints that will move the ruler from the edge to the center of the cell
 export function applyTokenSizeOffset(waypoints, token) {
 	if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
-		return waypoints
+		return waypoints;
 	}
 
 	const tokenSize = getTokenSize(token);
@@ -237,21 +236,17 @@ export function applyTokenSizeOffset(waypoints, token) {
 			if (canvas.grid.grid.options.columns) {
 				if (tokenSize.w % 2 === 0) {
 					waypointOffset.x = canvas.grid.w / 2;
-					if (!isAltOrientation)
+					if (!isAltOrientation) waypointOffset.x *= -1;
-						waypointOffset.x *= -1;
 				}
-			}
+			} else {
-			else {
 				if (tokenSize.h % 2 === 0) {
 					waypointOffset.y = canvas.grid.h / 2;
-					if (isAltOrientation)
+					if (isAltOrientation) waypointOffset.y *= -1;
-						waypointOffset.y *= -1;
 				}
 			}
 		}
 		// If hex size support isn't active leave the waypoints like they are
-	}
+	} else {
-	else {
 		if (tokenSize.w % 2 === 0) {
 			waypointOffset.x = canvas.grid.w / 2;
 		}
@@ -260,7 +255,7 @@ export function applyTokenSizeOffset(waypoints, token) {
 		}
 	}
 
-	return waypoints.map(w => new PIXI.Point(w.x + waypointOffset.x, w.y + waypointOffset.y))
+	return waypoints.map(w => new PIXI.Point(w.x + waypointOffset.x, w.y + waypointOffset.y));
 }
 
 export function setSnapParameterOnOptions(sourceObject, options) {
@@ -269,8 +264,7 @@ export function setSnapParameterOnOptions(sourceObject, options) {
 		options.snapOverrideActive = true;
 		options.snap = sourceObject.snapOverride.snap;
 		sourceObject.snapOverride = undefined; // remove it to prevent any lingering data issues
-	}
+	} else {
-	else {
 		options.snap = !disableSnap;
 	}
 }
@@ -280,7 +274,9 @@ export function isClose(a, b, delta) {
 }
 
 export function getMeasurePosition() {
-	const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(canvas.tokens);
+	const mousePosition = canvas.app.renderer.plugins.interaction.mouse.getLocalPosition(
+		canvas.tokens,
+	);
 	const rulerOffset = canvas.controls.ruler.rulerOffset;
 	const measurePosition = {x: mousePosition.x + rulerOffset.x, y: mousePosition.y + rulerOffset.y};
 	return measurePosition;
@@ -294,5 +290,5 @@ export function early_isGM() {
 }
 
 export function isModuleActive(moduleName) {
-	return game.modules.get(moduleName)?.active
+	return game.modules.get(moduleName)?.active;
 }