chore: reformat with 2 spaces

2023-07-10 22:23:13 +02:00 · 2023-07-10 22:23:13 +02:00 · 7670d7f808
commit 7670d7f808
parent d659e4bed9
1577 changed files with 70010 additions and 70042 deletions
--- a/src/migration/001.js
+++ b/src/migration/001.js
@ -6,31 +6,31 @@ import { getSceneMigrator, migrateCollection, migrateCompendiums, getCompendiumM

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return actorsResult === "error" || scenesResult === "error" || compendiumsResult === "error" ? "error" : "success";
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return actorsResult === "error" || scenesResult === "error" || compendiumsResult === "error" ? "error" : "success";
 }

 /** @type {import('./migrationHelpers.js').Migrator<Actor>} */
 async function migrateActor(actor) {
-    await actor.update({
-        system: {
-            combatValues: [
-                "hitPoints",
-                "defense",
-                "initiative",
-                "movement",
-                "meleeAttack",
-                "rangedAttack",
-                "spellcasting",
-                "targetedSpellcasting",
-            ].reduce((acc, curr) => {
-                acc[curr] = { "-=base": null };
-                return acc;
-            }, {}),
-        },
-    });
+  await actor.update({
+    system: {
+      combatValues: [
+        "hitPoints",
+        "defense",
+        "initiative",
+        "movement",
+        "meleeAttack",
+        "rangedAttack",
+        "spellcasting",
+        "targetedSpellcasting",
+      ].reduce((acc, curr) => {
+        acc[curr] = { "-=base": null };
+        return acc;
+      }, {}),
+    },
+  });
 }

 const migrateScene = getSceneMigrator(migrateActor);
@ -39,6 +39,6 @@ const migrateCompendium = getCompendiumMigrator({ migrateActor, migrateScene });

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/002.js
+++ b/src/migration/002.js
@ -3,43 +3,43 @@
 // SPDX-License-Identifier: MIT

 import {
-    getSceneMigrator,
-    migrateCollection,
-    migrateCompendiums,
-    getCompendiumMigrator,
-    getActorMigrator,
+  getSceneMigrator,
+  migrateCollection,
+  migrateCompendiums,
+  getCompendiumMigrator,
+  getActorMigrator,
 } from "./migrationHelpers.js";

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const itemsResult = await migrateCollection(game.items, migrateItem);
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return itemsResult === "error" ||
-        actorsResult === "error" ||
-        scenesResult === "error" ||
-        compendiumsResult === "error"
-        ? "error"
-        : "success";
+  const itemsResult = await migrateCollection(game.items, migrateItem);
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return itemsResult === "error" ||
+    actorsResult === "error" ||
+    scenesResult === "error" ||
+    compendiumsResult === "error"
+    ? "error"
+    : "success";
 }

 /** @type {import('./migrationHelpers.js').Migrator<Item>} */
 async function migrateItem(item) {
-    if (item.type === "equipment" || item.type === "trinket") {
-        await item.update({ type: item.type === "equipment" ? "loot" : "equipment" });
-    }
+  if (item.type === "equipment" || item.type === "trinket") {
+    await item.update({ type: item.type === "equipment" ? "loot" : "equipment" });
+  }
 }

 const migrateActor = getActorMigrator(migrateItem);
 const migrateScene = getSceneMigrator(migrateActor);
 const migrateCompendium = getCompendiumMigrator(
-    { migrateItem, migrateActor, migrateScene },
-    { migrateToTemplateEarly: false },
+  { migrateItem, migrateActor, migrateScene },
+  { migrateToTemplateEarly: false },
 );

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/003.js
+++ b/src/migration/003.js
@ -3,43 +3,43 @@
 // SPDX-License-Identifier: MIT

 import {
-    getSceneMigrator,
-    migrateCollection,
-    migrateCompendiums,
-    getCompendiumMigrator,
-    getActorMigrator,
+  getSceneMigrator,
+  migrateCollection,
+  migrateCompendiums,
+  getCompendiumMigrator,
+  getActorMigrator,
 } from "./migrationHelpers.js";

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const itemsResult = await migrateCollection(game.items, migrateItem);
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return itemsResult === "error" ||
-        actorsResult === "error" ||
-        scenesResult === "error" ||
-        compendiumsResult === "error"
-        ? "error"
-        : "success";
+  const itemsResult = await migrateCollection(game.items, migrateItem);
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return itemsResult === "error" ||
+    actorsResult === "error" ||
+    scenesResult === "error" ||
+    compendiumsResult === "error"
+    ? "error"
+    : "success";
 }

 /** @type {import("./migrationHelpers.js").Migrator<Item>} */
 async function migrateItem(item) {
-    if (item.type === "loot") {
-        await item.update({ system: { "-=equipped": null } });
-    }
+  if (item.type === "loot") {
+    await item.update({ system: { "-=equipped": null } });
+  }
 }

 const migrateActor = getActorMigrator(migrateItem);
 const migrateScene = getSceneMigrator(migrateActor);
 const migrateCompendium = getCompendiumMigrator(
-    { migrateItem, migrateActor, migrateScene },
-    { migrateToTemplateEarly: false },
+  { migrateItem, migrateActor, migrateScene },
+  { migrateToTemplateEarly: false },
 );

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/004.js
+++ b/src/migration/004.js
@ -3,43 +3,43 @@
 // SPDX-License-Identifier: MIT

 import {
-    getSceneMigrator,
-    migrateCollection,
-    migrateCompendiums,
-    getCompendiumMigrator,
-    getActorMigrator,
+  getSceneMigrator,
+  migrateCollection,
+  migrateCompendiums,
+  getCompendiumMigrator,
+  getActorMigrator,
 } from "./migrationHelpers.js";

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const itemsResult = await migrateCollection(game.items, migrateItem);
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return itemsResult === "error" ||
-        actorsResult === "error" ||
-        scenesResult === "error" ||
-        compendiumsResult === "error"
-        ? "error"
-        : "success";
+  const itemsResult = await migrateCollection(game.items, migrateItem);
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return itemsResult === "error" ||
+    actorsResult === "error" ||
+    scenesResult === "error" ||
+    compendiumsResult === "error"
+    ? "error"
+    : "success";
 }

 /** @type {import('./migrationHelpers.js').Migrator<Item>} */
 async function migrateItem(item) {
-    if (item.type === "spell") {
-        const cooldownDurationUnit = item.system?.cooldownDuration.unit;
-        await item.update({
-            system: {
-                "-=scrollPrice": null,
-                minimumLevels: { healer: null, wizard: null, sorcerer: null },
-                cooldownDuration: {
-                    unit: cooldownDurationUnit === "custom" ? "rounds" : cooldownDurationUnit,
-                },
-            },
-        });
-    }
+  if (item.type === "spell") {
+    const cooldownDurationUnit = item.system?.cooldownDuration.unit;
+    await item.update({
+      system: {
+        "-=scrollPrice": null,
+        minimumLevels: { healer: null, wizard: null, sorcerer: null },
+        cooldownDuration: {
+          unit: cooldownDurationUnit === "custom" ? "rounds" : cooldownDurationUnit,
+        },
+      },
+    });
+  }

-    return updateData;
+  return updateData;
 }

 const migrateActor = getActorMigrator(migrateItem);
@ -48,6 +48,6 @@ const migrateCompendium = getCompendiumMigrator({ migrateItem, migrateActor, mig

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/005.js
+++ b/src/migration/005.js
@ -3,11 +3,11 @@
 // SPDX-License-Identifier: MIT

 import {
-    getSceneMigrator,
-    migrateCollection,
-    migrateCompendiums,
-    getCompendiumMigrator,
-    getActorMigrator,
+  getSceneMigrator,
+  migrateCollection,
+  migrateCompendiums,
+  getCompendiumMigrator,
+  getActorMigrator,
 } from "./migrationHelpers.js";

 const secondsPerRound = 5;
@ -21,70 +21,70 @@ const secondsPerDay = secondsPerMinute * minutesPerHour * hoursPerDay;

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const itemsResult = await migrateCollection(game.items, migrateItem);
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return itemsResult === "error" ||
-        actorsResult === "error" ||
-        scenesResult === "error" ||
-        compendiumsResult === "error"
-        ? "error"
-        : "success";
+  const itemsResult = await migrateCollection(game.items, migrateItem);
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return itemsResult === "error" ||
+    actorsResult === "error" ||
+    scenesResult === "error" ||
+    compendiumsResult === "error"
+    ? "error"
+    : "success";
 }

 /** @type {import('./migrationHelpers.js').Migrator<Item>} */
 async function migrateItem(item) {
-    if (item.type === "spell") {
-        const cooldownDurationUnit = item.system?.cooldownDuration.unit;
-        const cooldownDurationValue = item.system?.cooldownDuration.value;
-        const cooldownDuration = migrateCooldownDuration(cooldownDurationValue, cooldownDurationUnit);
-        await item.update({ system: { cooldownDuration } });
-    }
+  if (item.type === "spell") {
+    const cooldownDurationUnit = item.system?.cooldownDuration.unit;
+    const cooldownDurationValue = item.system?.cooldownDuration.value;
+    const cooldownDuration = migrateCooldownDuration(cooldownDurationValue, cooldownDurationUnit);
+    await item.update({ system: { cooldownDuration } });
+  }
 }

 function migrateCooldownDuration(cooldownDurationValue = "", cooldownDurationUnit = "") {
-    if (Number.isNumeric(cooldownDurationValue)) {
-        const value = Number.fromString(cooldownDurationValue);
-        const rounds = getRounds(cooldownDurationUnit, value);
+  if (Number.isNumeric(cooldownDurationValue)) {
+    const value = Number.fromString(cooldownDurationValue);
+    const rounds = getRounds(cooldownDurationUnit, value);

-        if (rounds * secondsPerRound > secondsPerDay) {
-            return "d20d";
-        } else if (rounds > 100) {
-            return "1d";
-        } else if (rounds > 10) {
-            return "100r";
-        } else if (rounds > 5) {
-            return "10r";
-        } else if (rounds > 2) {
-            return "5r";
-        } else if (rounds > 1) {
-            return "2r";
-        } else if (rounds > 0) {
-            return "1r";
-        } else {
-            return "0r";
-        }
+    if (rounds * secondsPerRound > secondsPerDay) {
+      return "d20d";
+    } else if (rounds > 100) {
+      return "1d";
+    } else if (rounds > 10) {
+      return "100r";
+    } else if (rounds > 5) {
+      return "10r";
+    } else if (rounds > 2) {
+      return "5r";
+    } else if (rounds > 1) {
+      return "2r";
+    } else if (rounds > 0) {
+      return "1r";
    } else {
-        // if the value is not numeric, we can only make a best guess
-        switch (cooldownDurationUnit) {
-            case "rounds": {
-                return "10r";
-            }
-            case "minutes": {
-                return "100r";
-            }
-            case "hours": {
-                return "1d";
-            }
-            case "days": {
-                return "d20d";
-            }
-            default: {
-                return "0r";
-            }
-        }
+      return "0r";
    }
+  } else {
+    // if the value is not numeric, we can only make a best guess
+    switch (cooldownDurationUnit) {
+      case "rounds": {
+        return "10r";
+      }
+      case "minutes": {
+        return "100r";
+      }
+      case "hours": {
+        return "1d";
+      }
+      case "days": {
+        return "d20d";
+      }
+      default: {
+        return "0r";
+      }
+    }
+  }
 }

 /**
@ -94,23 +94,23 @@ function migrateCooldownDuration(cooldownDurationValue = "", cooldownDurationUni
 * @returns {number} The number of rounds
 */
 function getRounds(unit, value) {
-    switch (unit) {
-        case "rounds": {
-            return value;
-        }
-        case "minutes": {
-            return value * roundsPerMinute;
-        }
-        case "hours": {
-            return value * roundsPerHour;
-        }
-        case "days": {
-            return value * roundsPerDay;
-        }
-        default: {
-            return 0;
-        }
+  switch (unit) {
+    case "rounds": {
+      return value;
    }
+    case "minutes": {
+      return value * roundsPerMinute;
+    }
+    case "hours": {
+      return value * roundsPerHour;
+    }
+    case "days": {
+      return value * roundsPerDay;
+    }
+    default: {
+      return 0;
+    }
+  }
 }

 const migrateActor = getActorMigrator(migrateItem);
@ -119,6 +119,6 @@ const migrateCompendium = getCompendiumMigrator({ migrateItem, migrateActor, mig

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/006.js
+++ b/src/migration/006.js
@ -3,43 +3,43 @@
 // SPDX-License-Identifier: MIT

 import {
-    getSceneMigrator,
-    migrateCollection,
-    migrateCompendiums,
-    getCompendiumMigrator,
-    getActorMigrator,
+  getSceneMigrator,
+  migrateCollection,
+  migrateCompendiums,
+  getCompendiumMigrator,
+  getActorMigrator,
 } from "./migrationHelpers.js";

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const itemsResult = await migrateCollection(game.items, migrateItem);
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return itemsResult === "error" ||
-        actorsResult === "error" ||
-        scenesResult === "error" ||
-        compendiumsResult === "error"
-        ? "error"
-        : "success";
+  const itemsResult = await migrateCollection(game.items, migrateItem);
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return itemsResult === "error" ||
+    actorsResult === "error" ||
+    scenesResult === "error" ||
+    compendiumsResult === "error"
+    ? "error"
+    : "success";
 }

 /** @type {import('./migrationHelpers.js').Migrator<Item>} */
 async function migrateItem(item) {
-    if (item.type === "spell") {
-        const spellCategory = item.system?.spellCategory;
-        const spellGroups = migrateSpellCategory(spellCategory);
-        const bonus = itemData.system?.bonus;
-        const spellModifier = migrateBonus(bonus);
-        await item.update({
-            system: {
-                spellGroups,
-                "-=spellCategory": null,
-                spellModifier,
-                "-=bonus": null,
-            },
-        });
-    }
+  if (item.type === "spell") {
+    const spellCategory = item.system?.spellCategory;
+    const spellGroups = migrateSpellCategory(spellCategory);
+    const bonus = itemData.system?.bonus;
+    const spellModifier = migrateBonus(bonus);
+    await item.update({
+      system: {
+        spellGroups,
+        "-=spellCategory": null,
+        spellModifier,
+        "-=bonus": null,
+      },
+    });
+  }
 }

 /**
@ -48,56 +48,56 @@ async function migrateItem(item) {
 * @returns {import("../documents/item/spell/spell-data-source").DS4SpellDataSourceData["spellGroups"]} The spell groups for the given category
 */
 function migrateSpellCategory(spellCategory) {
-    const spellGroups = {
-        lightning: false,
-        earth: false,
-        water: false,
-        ice: false,
-        fire: false,
-        healing: false,
-        light: false,
-        air: false,
-        transport: false,
-        damage: false,
-        shadow: false,
-        protection: false,
-        mindAffecting: false,
-        demonology: false,
-        necromancy: false,
-        transmutation: false,
-        area: false,
-    };
-    switch (spellCategory) {
-        case "healing": {
-            spellGroups.healing = true;
-            break;
-        }
-        case "fire": {
-            spellGroups.fire = true;
-            break;
-        }
-        case "ice": {
-            spellGroups.ice = true;
-            break;
-        }
-        case "light": {
-            spellGroups.light = true;
-            break;
-        }
-        case "darkness": {
-            spellGroups.shadow = true;
-            break;
-        }
-        case "mindAffecting": {
-            spellGroups.mindAffecting = true;
-            break;
-        }
-        case "electricity": {
-            spellGroups.lightning = true;
-            break;
-        }
+  const spellGroups = {
+    lightning: false,
+    earth: false,
+    water: false,
+    ice: false,
+    fire: false,
+    healing: false,
+    light: false,
+    air: false,
+    transport: false,
+    damage: false,
+    shadow: false,
+    protection: false,
+    mindAffecting: false,
+    demonology: false,
+    necromancy: false,
+    transmutation: false,
+    area: false,
+  };
+  switch (spellCategory) {
+    case "healing": {
+      spellGroups.healing = true;
+      break;
    }
-    return spellGroups;
+    case "fire": {
+      spellGroups.fire = true;
+      break;
+    }
+    case "ice": {
+      spellGroups.ice = true;
+      break;
+    }
+    case "light": {
+      spellGroups.light = true;
+      break;
+    }
+    case "darkness": {
+      spellGroups.shadow = true;
+      break;
+    }
+    case "mindAffecting": {
+      spellGroups.mindAffecting = true;
+      break;
+    }
+    case "electricity": {
+      spellGroups.lightning = true;
+      break;
+    }
+  }
+  return spellGroups;
 }

 /**
@ -106,15 +106,15 @@ function migrateSpellCategory(spellCategory) {
 * @returns {import("../documents/item/spell/spell-data-source").DS4SpellDataSourceData["spellModifier"]}   The spell modifier
 */
 function migrateBonus(bonus) {
-    const spellModifier = { numerical: 0, complex: "" };
-    if (bonus) {
-        if (Number.isNumeric(bonus)) {
-            spellModifier.numerical = +bonus;
-        } else {
-            spellModifier.complex = bonus;
-        }
+  const spellModifier = { numerical: 0, complex: "" };
+  if (bonus) {
+    if (Number.isNumeric(bonus)) {
+      spellModifier.numerical = +bonus;
+    } else {
+      spellModifier.complex = bonus;
    }
-    return spellModifier;
+  }
+  return spellModifier;
 }

 const migrateActor = getActorMigrator(migrateItem);
@ -123,6 +123,6 @@ const migrateCompendium = getCompendiumMigrator({ migrateItem, migrateActor, mig

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/007.js
+++ b/src/migration/007.js
@ -3,32 +3,32 @@
 // SPDX-License-Identifier: MIT

 import {
-    getSceneMigrator,
-    migrateCollection,
-    migrateCompendiums,
-    getCompendiumMigrator,
-    getActorMigrator,
+  getSceneMigrator,
+  migrateCollection,
+  migrateCompendiums,
+  getCompendiumMigrator,
+  getActorMigrator,
 } from "./migrationHelpers.js";

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const itemsResult = await migrateCollection(game.items, migrateItem);
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return itemsResult === "error" ||
-        actorsResult === "error" ||
-        scenesResult === "error" ||
-        compendiumsResult === "error"
-        ? "error"
-        : "success";
+  const itemsResult = await migrateCollection(game.items, migrateItem);
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return itemsResult === "error" ||
+    actorsResult === "error" ||
+    scenesResult === "error" ||
+    compendiumsResult === "error"
+    ? "error"
+    : "success";
 }

 /** @type {import('./migrationHelpers.js').Migrator<Item>} */
 async function migrateItem(item) {
-    if (item.type === "spell") {
-        await item.update({ system: { allowsDefense: false } });
-    }
+  if (item.type === "spell") {
+    await item.update({ system: { allowsDefense: false } });
+  }
 }

 const migrateActor = getActorMigrator(migrateItem);
@ -37,6 +37,6 @@ const migrateCompendium = getCompendiumMigrator({ migrateItem, migrateActor, mig

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/008.js
+++ b/src/migration/008.js
@ -3,55 +3,55 @@
 // SPDX-License-Identifier: MIT

 import {
-    getSceneMigrator,
-    migrateCollection,
-    migrateCompendiums,
-    getCompendiumMigrator,
-    getActorMigrator,
-    getItemMigrator,
+  getSceneMigrator,
+  migrateCollection,
+  migrateCompendiums,
+  getCompendiumMigrator,
+  getActorMigrator,
+  getItemMigrator,
 } from "./migrationHelpers.js";

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const itemsResult = await migrateCollection(game.items, migrateItem);
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return itemsResult === "error" ||
-        actorsResult === "error" ||
-        scenesResult === "error" ||
-        compendiumsResult === "error"
-        ? "error"
-        : "success";
+  const itemsResult = await migrateCollection(game.items, migrateItem);
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return itemsResult === "error" ||
+    actorsResult === "error" ||
+    scenesResult === "error" ||
+    compendiumsResult === "error"
+    ? "error"
+    : "success";
 }

 /** @type {import('./migrationHelpers.js').Migrator<ActiveEffect>} */
 async function migrateActiveEffect(activeEffect) {
-    const data = activeEffect.toObject();
-    let hasUpdates = false;
+  const data = activeEffect.toObject();
+  let hasUpdates = false;

-    if ("changes" in data) {
-        for (const change of data.changes) {
-            const newValue = change.value.replaceAll(/@data\./g, "@system.");
-            if (newValue !== change.value) {
-                hasUpdates = true;
-                change.value = newValue;
-            }
-        }
+  if ("changes" in data) {
+    for (const change of data.changes) {
+      const newValue = change.value.replaceAll(/@data\./g, "@system.");
+      if (newValue !== change.value) {
+        hasUpdates = true;
+        change.value = newValue;
+      }
    }
+  }

-    /** @type {string | undefined} */
-    const condition = data.flags?.ds4?.itemEffectConfig?.condition;
-    if (condition !== undefined) {
-        const newCondition = condition.replaceAll(/(@actor|@item|@effect)\.data/g, "$1.system");
-        if (newCondition !== condition) {
-            hasUpdates = true;
-            data.flags.ds4.itemEffectConfig.condition = newCondition;
-        }
-    }
-    if (hasUpdates) {
-        await activeEffect.update(data);
+  /** @type {string | undefined} */
+  const condition = data.flags?.ds4?.itemEffectConfig?.condition;
+  if (condition !== undefined) {
+    const newCondition = condition.replaceAll(/(@actor|@item|@effect)\.data/g, "$1.system");
+    if (newCondition !== condition) {
+      hasUpdates = true;
+      data.flags.ds4.itemEffectConfig.condition = newCondition;
    }
+  }
+  if (hasUpdates) {
+    await activeEffect.update(data);
+  }
 }

 const migrateItem = getItemMigrator(migrateActiveEffect);
@ -61,6 +61,6 @@ const migrateCompendium = getCompendiumMigrator({ migrateItem, migrateActor, mig

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/009.js
+++ b/src/migration/009.js
@ -3,31 +3,31 @@
 // SPDX-License-Identifier: MIT

 import {
-    getSceneMigrator,
-    migrateCollection,
-    migrateCompendiums,
-    getCompendiumMigrator,
-    getActorMigrator,
+  getSceneMigrator,
+  migrateCollection,
+  migrateCompendiums,
+  getCompendiumMigrator,
+  getActorMigrator,
 } from "./migrationHelpers.js";

 /** @type {import("./migration.js").Migration["migrate"]} */
 async function migrate() {
-    const actorsResult = await migrateCollection(game.actors, migrateActor);
-    const scenesResult = await migrateCollection(game.scenes, migrateScene);
-    const compendiumsResult = await migrateCompendiums(migrateCompendium);
-    return actorsResult === "error" || scenesResult === "error" || compendiumsResult === "error" ? "error" : "success";
+  const actorsResult = await migrateCollection(game.actors, migrateActor);
+  const scenesResult = await migrateCollection(game.scenes, migrateScene);
+  const compendiumsResult = await migrateCompendiums(migrateCompendium);
+  return actorsResult === "error" || scenesResult === "error" || compendiumsResult === "error" ? "error" : "success";
 }

 const itemIdRegex = /Item\.([a-zA-Z0-9]+)/;

 /** @type {import('./migrationHelpers.js').Migrator<ActiveEffect>} */
 async function migrateActiveEffect(activeEffect) {
-    if (activeEffect.parent instanceof Actor) {
-        const itemId = activeEffect.origin?.match(itemIdRegex)?.[1];
-        if (activeEffect.parent.items.has(itemId)) {
-            await activeEffect.delete();
-        }
+  if (activeEffect.parent instanceof Actor) {
+    const itemId = activeEffect.origin?.match(itemIdRegex)?.[1];
+    if (activeEffect.parent.items.has(itemId)) {
+      await activeEffect.delete();
    }
+  }
 }

 const migrateActor = getActorMigrator(undefined, migrateActiveEffect);
@ -36,6 +36,6 @@ const migrateCompendium = getCompendiumMigrator({ migrateActor, migrateScene });

 /** @type {import("./migration.js").Migration} */
 export const migration = {
-    migrate,
-    migrateCompendium,
+  migrate,
+  migrateCompendium,
 };
--- a/src/migration/migration.js
+++ b/src/migration/migration.js
@ -20,20 +20,20 @@ import { migration as migration009 } from "./009.js";
 * @returns {Promise<void>} A promise that resolves once all migrations have completed
 */
 async function migrate() {
-    if (!getGame().user?.isGM) {
-        return;
-    }
+  if (!getGame().user?.isGM) {
+    return;
+  }

-    const oldMigrationVersion = getCurrentMigrationVersion();
+  const oldMigrationVersion = getCurrentMigrationVersion();

-    const targetMigrationVersion = migrations.length;
+  const targetMigrationVersion = migrations.length;

-    if (isFirstWorldStart(oldMigrationVersion)) {
-        getGame().settings.set("ds4", "systemMigrationVersion", targetMigrationVersion);
-        return;
-    }
+  if (isFirstWorldStart(oldMigrationVersion)) {
+    getGame().settings.set("ds4", "systemMigrationVersion", targetMigrationVersion);
+    return;
+  }

-    return migrateFromTo(oldMigrationVersion, targetMigrationVersion);
+  return migrateFromTo(oldMigrationVersion, targetMigrationVersion);
 }

 /**
@ -43,64 +43,64 @@ async function migrate() {
 * @returns {Promise<void>} A promise the resolves once the migration is complete
 */
 async function migrateFromTo(oldMigrationVersion, targetMigrationVersion) {
-    if (!getGame().user?.isGM) {
-        return;
-    }
+  if (!getGame().user?.isGM) {
+    return;
+  }

-    const migrationsToExecute = migrations.slice(oldMigrationVersion, targetMigrationVersion);
+  const migrationsToExecute = migrations.slice(oldMigrationVersion, targetMigrationVersion);

-    if (migrationsToExecute.length > 0) {
-        notifications.info(
-            getGame().i18n.format("DS4.InfoSystemUpdateStart", {
-                currentVersion: oldMigrationVersion,
-                targetVersion: targetMigrationVersion,
-            }),
-            { permanent: true },
+  if (migrationsToExecute.length > 0) {
+    notifications.info(
+      getGame().i18n.format("DS4.InfoSystemUpdateStart", {
+        currentVersion: oldMigrationVersion,
+        targetVersion: targetMigrationVersion,
+      }),
+      { permanent: true },
+    );
+
+    /** @type {Result} */
+    let result = "success";
+    for (const [i, { migrate }] of migrationsToExecute.entries()) {
+      const currentMigrationVersion = oldMigrationVersion + i + 1;
+      logger.info("executing migration script", currentMigrationVersion);
+      try {
+        const r = await migrate();
+        getGame().settings.set("ds4", "systemMigrationVersion", currentMigrationVersion);
+        if (r === "error") {
+          result = "error";
+        }
+      } catch (err) {
+        notifications.error(
+          getGame().i18n.format("DS4.ErrorDuringMigration", {
+            currentVersion: oldMigrationVersion,
+            targetVersion: targetMigrationVersion,
+            migrationVersion: currentMigrationVersion,
+          }),
+          { permanent: true },
        );
-
-        /** @type {Result} */
-        let result = "success";
-        for (const [i, { migrate }] of migrationsToExecute.entries()) {
-            const currentMigrationVersion = oldMigrationVersion + i + 1;
-            logger.info("executing migration script", currentMigrationVersion);
-            try {
-                const r = await migrate();
-                getGame().settings.set("ds4", "systemMigrationVersion", currentMigrationVersion);
-                if (r === "error") {
-                    result = "error";
-                }
-            } catch (err) {
-                notifications.error(
-                    getGame().i18n.format("DS4.ErrorDuringMigration", {
-                        currentVersion: oldMigrationVersion,
-                        targetVersion: targetMigrationVersion,
-                        migrationVersion: currentMigrationVersion,
-                    }),
-                    { permanent: true },
-                );
-                logger.error("Failed ds4 system migration:", err);
-                return;
-            }
-        }
-
-        if (result === "success") {
-            notifications.info(
-                getGame().i18n.format("DS4.InfoSystemUpdateCompletedSuccessfully", {
-                    currentVersion: oldMigrationVersion,
-                    targetVersion: targetMigrationVersion,
-                }),
-                { permanent: true },
-            );
-        } else {
-            notifications.warn(
-                getGame().i18n.format("DS4.WarningSystemUpdateCompletedWithErrors", {
-                    currentVersion: oldMigrationVersion,
-                    targetVersion: targetMigrationVersion,
-                }),
-                { permanent: true },
-            );
-        }
+        logger.error("Failed ds4 system migration:", err);
+        return;
+      }
    }
+
+    if (result === "success") {
+      notifications.info(
+        getGame().i18n.format("DS4.InfoSystemUpdateCompletedSuccessfully", {
+          currentVersion: oldMigrationVersion,
+          targetVersion: targetMigrationVersion,
+        }),
+        { permanent: true },
+      );
+    } else {
+      notifications.warn(
+        getGame().i18n.format("DS4.WarningSystemUpdateCompletedWithErrors", {
+          currentVersion: oldMigrationVersion,
+          targetVersion: targetMigrationVersion,
+        }),
+        { permanent: true },
+      );
+    }
+  }
 }

 /**
@ -111,51 +111,51 @@ async function migrateFromTo(oldMigrationVersion, targetMigrationVersion) {
 * @returns {Promise<void>} A promise that resolves once the migration is complete
 */
 async function migrateCompendiumFromTo(pack, oldMigrationVersion, targetMigrationVersion) {
-    if (!getGame().user?.isGM) {
+  if (!getGame().user?.isGM) {
+    return;
+  }
+
+  const migrationsToExecute = migrations.slice(oldMigrationVersion, targetMigrationVersion);
+
+  if (migrationsToExecute.length > 0) {
+    notifications.info(
+      getGame().i18n.format("DS4.InfoCompendiumMigrationStart", {
+        pack: pack.title,
+        currentVersion: oldMigrationVersion,
+        targetVersion: targetMigrationVersion,
+      }),
+      { permanent: true },
+    );
+
+    for (const [i, { migrateCompendium }] of migrationsToExecute.entries()) {
+      const currentMigrationVersion = oldMigrationVersion + i + 1;
+      logger.info("executing compendium migration ", currentMigrationVersion);
+      try {
+        await migrateCompendium(pack);
+      } catch (err) {
+        notifications.error(
+          getGame().i18n.format("DS4.ErrorDuringCompendiumMigration", {
+            pack: pack.title,
+            currentVersion: oldMigrationVersion,
+            targetVersion: targetMigrationVersion,
+            migrationVersion: currentMigrationVersion,
+          }),
+          { permanent: true },
+        );
+        logger.error("Failed ds4 compendium migration:", err);
        return;
+      }
    }

-    const migrationsToExecute = migrations.slice(oldMigrationVersion, targetMigrationVersion);
-
-    if (migrationsToExecute.length > 0) {
-        notifications.info(
-            getGame().i18n.format("DS4.InfoCompendiumMigrationStart", {
-                pack: pack.title,
-                currentVersion: oldMigrationVersion,
-                targetVersion: targetMigrationVersion,
-            }),
-            { permanent: true },
-        );
-
-        for (const [i, { migrateCompendium }] of migrationsToExecute.entries()) {
-            const currentMigrationVersion = oldMigrationVersion + i + 1;
-            logger.info("executing compendium migration ", currentMigrationVersion);
-            try {
-                await migrateCompendium(pack);
-            } catch (err) {
-                notifications.error(
-                    getGame().i18n.format("DS4.ErrorDuringCompendiumMigration", {
-                        pack: pack.title,
-                        currentVersion: oldMigrationVersion,
-                        targetVersion: targetMigrationVersion,
-                        migrationVersion: currentMigrationVersion,
-                    }),
-                    { permanent: true },
-                );
-                logger.error("Failed ds4 compendium migration:", err);
-                return;
-            }
-        }
-
-        notifications.info(
-            getGame().i18n.format("DS4.InfoCompendiumMigrationCompleted", {
-                pack: pack.title,
-                currentVersion: oldMigrationVersion,
-                targetVersion: targetMigrationVersion,
-            }),
-            { permanent: true },
-        );
-    }
+    notifications.info(
+      getGame().i18n.format("DS4.InfoCompendiumMigrationCompleted", {
+        pack: pack.title,
+        currentVersion: oldMigrationVersion,
+        targetVersion: targetMigrationVersion,
+      }),
+      { permanent: true },
+    );
+  }
 }

 /**
@ -163,7 +163,7 @@ async function migrateCompendiumFromTo(pack, oldMigrationVersion, targetMigratio
 * @returns {number} The current migration version
 */
 function getCurrentMigrationVersion() {
-    return getGame().settings.get("ds4", "systemMigrationVersion");
+  return getGame().settings.get("ds4", "systemMigrationVersion");
 }

 /**
@ -171,7 +171,7 @@ function getCurrentMigrationVersion() {
 * @returns {number} The target migration version
 */
 function getTargetMigrationVersion() {
-    return migrations.length;
+  return migrations.length;
 }

 /** @typedef {"success" | "error"} Result */
@ -186,15 +186,15 @@ function getTargetMigrationVersion() {
 * @type {Migration[]}
 */
 const migrations = [
-    migration001,
-    migration002,
-    migration003,
-    migration004,
-    migration005,
-    migration006,
-    migration007,
-    migration008,
-    migration009,
+  migration001,
+  migration002,
+  migration003,
+  migration004,
+  migration005,
+  migration006,
+  migration007,
+  migration008,
+  migration009,
 ];

 /**
@ -203,13 +203,13 @@ const migrations = [
 * @returns {boolean} Whether the migration version indicates it is the first start of the world
 */
 function isFirstWorldStart(migrationVersion) {
-    return migrationVersion < 0;
+  return migrationVersion < 0;
 }

 export const migration = {
-    migrate,
-    migrateFromTo,
-    getCurrentMigrationVersion,
-    getTargetMigrationVersion,
-    migrateCompendiumFromTo,
+  migrate,
+  migrateFromTo,
+  getCurrentMigrationVersion,
+  getTargetMigrationVersion,
+  migrateCompendiumFromTo,
 };
--- a/src/migration/migrationHelpers.js
+++ b/src/migration/migrationHelpers.js
@ -18,22 +18,22 @@ import { getGame } from "../utils/utils.js";
 * @returns {Promise<import("./migration.js").Result>} A promise that resolves once the migration is complete
 */
 export async function migrateCollection(collection, migrateDocument) {
-    /** @type {import("./migration.js").Result} */
-    let result = "success";
-    const { documentName } = collection.constructor;
-    for (const document of collection) {
-        logger.info(`Migrating ${documentName} document ${document.name} (${document.id})`);
-        try {
-            await migrateDocument(document);
-        } catch (err) {
-            logger.error(
-                `Error during migration of ${documentName} document ${document.name} (${document.id}), continuing anyways.`,
-                err,
-            );
-            result = "error";
-        }
+  /** @type {import("./migration.js").Result} */
+  let result = "success";
+  const { documentName } = collection.constructor;
+  for (const document of collection) {
+    logger.info(`Migrating ${documentName} document ${document.name} (${document.id})`);
+    try {
+      await migrateDocument(document);
+    } catch (err) {
+      logger.error(
+        `Error during migration of ${documentName} document ${document.name} (${document.id}), continuing anyways.`,
+        err,
+      );
+      result = "error";
    }
-    return result;
+  }
+  return result;
 }

 /**
@ -41,16 +41,16 @@ export async function migrateCollection(collection, migrateDocument) {
 * @returns {Migrator<Scene>}
 */
 export function getItemMigrator(migrateActiveEffect) {
-    /**
-     * @param {Item} item
-     */
-    return async (item) => {
-        if (migrateActiveEffect) {
-            for (const effect of item.effects) {
-                await migrateActiveEffect(effect);
-            }
-        }
-    };
+  /**
+   * @param {Item} item
+   */
+  return async (item) => {
+    if (migrateActiveEffect) {
+      for (const effect of item.effects) {
+        await migrateActiveEffect(effect);
+      }
+    }
+  };
 }

 /**
@ -59,21 +59,21 @@ export function getItemMigrator(migrateActiveEffect) {
 * @returns {Migrator<Scene>}
 */
 export function getActorMigrator(migrateItem, migrateActiveEffect) {
-    /**
-     * @param {Actor} actor
-     */
-    return async (actor) => {
-        if (migrateItem) {
-            for (const item of actor.items) {
-                await migrateItem(item);
-            }
-        }
-        if (migrateActiveEffect) {
-            for (const effect of actor.effects) {
-                await migrateActiveEffect(effect);
-            }
-        }
-    };
+  /**
+   * @param {Actor} actor
+   */
+  return async (actor) => {
+    if (migrateItem) {
+      for (const item of actor.items) {
+        await migrateItem(item);
+      }
+    }
+    if (migrateActiveEffect) {
+      for (const effect of actor.effects) {
+        await migrateActiveEffect(effect);
+      }
+    }
+  };
 }

 /**
@ -81,18 +81,18 @@ export function getActorMigrator(migrateItem, migrateActiveEffect) {
 * @returns {Migrator<Scene>}
 */
 export function getSceneMigrator(migrateActor) {
-    /**
-     * @param {Scene} scene
-     */
-    return async (scene) => {
-        if (migrateActor) {
-            for (const token of scene.tokens) {
-                if (!token.actorLink && token.actor) {
-                    await migrateActor(token.actor);
-                }
-            }
+  /**
+   * @param {Scene} scene
+   */
+  return async (scene) => {
+    if (migrateActor) {
+      for (const token of scene.tokens) {
+        if (!token.actorLink && token.actor) {
+          await migrateActor(token.actor);
        }
-    };
+      }
+    }
+  };
 }

 /** @typedef {(pack: CompendiumCollection) => Promise<import("./migration.js").Result>} CompendiumMigrator */
@ -103,17 +103,17 @@ export function getSceneMigrator(migrateActor) {
 * @returns {Promise<import("./migration.js").Result>} A promise that resolves once the migration is complete
 */
 export async function migrateCompendiums(migrateCompendium) {
-    /** @type {import("./migration.js").Result} */
-    let result = "success";
-    for (const compendium of getGame().packs ?? []) {
-        if (compendium.metadata.package !== "world") continue;
-        if (!["Actor", "Item", "Scene"].includes(compendium.metadata.type)) continue;
-        const r = await migrateCompendium(compendium);
-        if (r === "error") {
-            result = "error";
-        }
+  /** @type {import("./migration.js").Result} */
+  let result = "success";
+  for (const compendium of getGame().packs ?? []) {
+    if (compendium.metadata.package !== "world") continue;
+    if (!["Actor", "Item", "Scene"].includes(compendium.metadata.type)) continue;
+    const r = await migrateCompendium(compendium);
+    if (r === "error") {
+      result = "error";
    }
-    return result;
+  }
+  return result;
 }

 /**
@ -130,48 +130,48 @@ export async function migrateCompendiums(migrateCompendium) {
 * @returns {CompendiumMigrator} The resulting compendium migrator
 */
 export function getCompendiumMigrator(
-    { migrateItem, migrateActor, migrateScene } = {},
-    { migrateToTemplateEarly = true } = {},
+  { migrateItem, migrateActor, migrateScene } = {},
+  { migrateToTemplateEarly = true } = {},
 ) {
-    return async (pack) => {
-        /** @type {import("./migration.js").Result} */
-        let result = "success";
+  return async (pack) => {
+    /** @type {import("./migration.js").Result} */
+    let result = "success";

-        const type = pack.metadata.type;
-        const migrateDocument = {
-            Item: migrateItem,
-            Actor: migrateActor,
-            Scene: migrateScene,
-        }[type];
+    const type = pack.metadata.type;
+    const migrateDocument = {
+      Item: migrateItem,
+      Actor: migrateActor,
+      Scene: migrateScene,
+    }[type];

-        if (migrateDocument) {
-            const wasLocked = pack.locked;
-            await pack.configure({ locked: false });
-            if (migrateToTemplateEarly) {
-                await pack.migrate();
-            }
+    if (migrateDocument) {
+      const wasLocked = pack.locked;
+      await pack.configure({ locked: false });
+      if (migrateToTemplateEarly) {
+        await pack.migrate();
+      }

-            const documents = await pack.getDocuments();
+      const documents = await pack.getDocuments();

-            for (const doc of documents) {
-                try {
-                    logger.info(`Migrating document ${doc.name} (${doc.id}) in compendium ${pack.collection}`);
-                    await migrateDocument(doc);
-                } catch (err) {
-                    logger.error(
-                        `Error during migration of document ${doc.name} (${doc.id}) in compendium ${pack.collection}, continuing anyways.`,
-                        err,
-                    );
-                    result = "error";
-                }
-            }
-
-            if (!migrateToTemplateEarly) {
-                await pack.migrate();
-            }
-            await pack.configure({ locked: wasLocked });
+      for (const doc of documents) {
+        try {
+          logger.info(`Migrating document ${doc.name} (${doc.id}) in compendium ${pack.collection}`);
+          await migrateDocument(doc);
+        } catch (err) {
+          logger.error(
+            `Error during migration of document ${doc.name} (${doc.id}) in compendium ${pack.collection}, continuing anyways.`,
+            err,
+          );
+          result = "error";
        }
+      }

-        return result;
-    };
+      if (!migrateToTemplateEarly) {
+        await pack.migrate();
+      }
+      await pack.configure({ locked: wasLocked });
+    }
+
+    return result;
+  };
 }