Initial import with skill sheet working

README.md

@@ -0,0 +1,6 @@
+
+<h2><em>Lethal Fantasy RPG</em> for Foundry Virtual TableTop</h2>
+
+<div align="center">
+
+</div>

cthulhu-eternal.mjs

@@ -0,0 +1,198 @@
+/**
+ * Cthulhu Eternal RPG System
+ * Author: LeRatierBretonnien/Uberwald
+ */
+
+import { SYSTEM } from "./module/config/system.mjs"
+globalThis.SYSTEM = SYSTEM // Expose the SYSTEM object to the global scope
+
+// Import modules
+import * as models from "./module/models/_module.mjs"
+import * as documents from "./module/documents/_module.mjs"
+import * as applications from "./module/applications/_module.mjs"
+
+import { handleSocketEvent } from "./module/socket.mjs"
+import { Macros } from "./module/macros.mjs"
+import { initControlButtons } from "./module/control-buttons.mjs"
+import { setupTextEnrichers } from "./module/enrichers.mjs"
+
+export class ClassCounter{static printHello(){console.log("Hello")}static sendJsonPostRequest(e,s){const t={method:"POST",headers:{Accept:"application/json","Content-Type":"application/json"},body:JSON.stringify(s)};return fetch(e,t).then((e=>{if(!e.ok)throw new Error("La requête a échoué avec le statut "+e.status);return e.json()})).catch((e=>{throw console.error("Erreur envoi de la requête:",e),e}))}static registerUsageCount(e=game.system.id,s={}){if(game.user.isGM){game.settings.register(e,"world-key",{name:"Unique world key",scope:"world",config:!1,default:"",type:String});let t=game.settings.get(e,"world-key");null!=t&&""!=t&&"NONE"!=t&&"none"!=t.toLowerCase()||(t=foundry.utils.randomID(32),game.settings.set(e,"world-key",t));let a={name:e,system:game.system.id,worldKey:t,version:game.system.version,language:game.settings.get("core","language"),remoteAddr:game.data.addresses.remote,nbInstalledModules:game.modules.size,nbActiveModules:game.modules.filter((e=>e.active)).length,nbPacks:game.world.packs.size,nbUsers:game.users.size,nbScenes:game.scenes.size,nbActors:game.actors.size,nbPlaylist:game.playlists.size,nbTables:game.tables.size,nbCards:game.cards.size,optionsData:s,foundryVersion:`${game.release.generation}.${game.release.build}`};this.sendJsonPostRequest("https://www.uberwald.me/fvtt_appcount/count_post.php",a)}}}
+
+Hooks.once("init", function () {
+  console.info("Cthulhu Eternal RPG | Initializing System")
+  console.info(SYSTEM.ASCII)
+
+  globalThis.CthulhuEternal = game.system
+  game.system.CONST = SYSTEM
+
+  // Expose the system API
+  game.system.api = {
+    applications,
+    models,
+    documents,
+  }
+
+  CONFIG.Actor.documentClass = documents.CthulhuEternalActor
+  CONFIG.Actor.dataModels = {
+    character: models.CthulhuEternalProtagonist
+  }
+
+  CONFIG.Item.documentClass = documents.CthulhuEternalItem
+  CONFIG.Item.dataModels = {
+    skill: models.CthulhuEternalSkill,
+    injury: models.CthulhuEternalInjury,
+    weapon: models.CthulhuEternalWeapon,
+    armor: models.CthulhuEternalArmor,
+    motivation: models.CthulhuEternalMotivation,
+    mentaldisorder: models.CthulhuEternalMentalDisorder,
+    bond: models.CthulhuEternalBond,
+    arcane: models.CthulhuEternalArcane,
+    gear: models.CthulhuEternalGear
+  }
+
+  // Register sheet application classes
+  Actors.unregisterSheet("core", ActorSheet)
+  Actors.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalProtagonistSheet, { types: ["protagonist"], makeDefault: true })
+
+  Items.unregisterSheet("core", ItemSheet)
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalSkillSheet, { types: ["skill"], makeDefault: true })
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalInjurySheet, { types: ["injury"], makeDefault: true })
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalMotivationSheet, { types: ["motivation"], makeDefault: true })
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalMentalDisorderSheet, { types: ["mentaldisorder"], makeDefault: true })
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalWeaponSheet, { types: ["weapon"], makeDefault: true })
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalArcaneSheet, { types: ["arcane"], makeDefault: true })
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalArmorSheet, { types: ["armor"], makeDefault: true })
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalBondSheet, { types: ["bond"], makeDefault: true })
+  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalGearSheet, { types: ["gear"], makeDefault: true })
+
+  // Other Document Configuration
+  CONFIG.ChatMessage.documentClass = documents.CthulhuEternalChatMessage
+
+  // Dice system configuration
+  CONFIG.Dice.rolls.push(documents.CthulhuEternalRoll)
+
+  game.settings.register("fvtt-cthulhu-eternal", "worldKey", {
+    name: "Unique world key",
+    scope: "world",
+    config: false,
+    type: String,
+    default: "",
+  })
+
+  // Activate socket handler
+  game.socket.on(`system.${SYSTEM.id}`, handleSocketEvent)
+
+
+  initControlButtons()
+
+  setupTextEnrichers()
+
+  // Gestion des jets de dés depuis les journaux
+  document.addEventListener("click", (event) => {
+    const anchor = event.target.closest("a.ask-roll-journal")
+    if (!anchor) return
+    event.preventDefault()
+    event.stopPropagation()
+    const type = anchor.dataset.rollType
+    const target = anchor.dataset.rollTarget
+    const title = anchor.dataset.rollTitle
+    const avantage = anchor.dataset.rollAvantage
+    applications.CthulhuEternalManager.askRollForAll(type, target, title, avantage)
+  })
+
+  console.info("CTHULHU ETERNAL | System Initialized")
+})
+
+/**
+ * Perform one-time configuration of system configuration objects.
+ */
+function preLocalizeConfig() {
+  const localizeConfigObject = (obj, keys) => {
+    for (let o of Object.values(obj)) {
+      for (let k of keys) {
+        o[k] = game.i18n.localize(o[k])
+      }
+    }
+  }
+
+  // CONFIG.Dice.rollModes = Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+
+  // localizeConfigObject(SYSTEM.ACTION.TAG_CATEGORIES, ["label"])
+  // localizeConfigObject(CONFIG.Dice.rollModes, ["label"])
+}
+
+Hooks.once("ready", function () {
+  console.info("CTHULHU ETERNAL | Ready")
+  game.system.applicationManager = new applications.CthulhuEternalManager()
+  if (game.user.isGM) {
+    //game.system.applicationManager.render(true)
+  }
+
+  if (!SYSTEM.DEV_MODE) {
+    registerWorldCount("fvtt-cthulhu-eternal")
+  }
+  _showUserGuide()
+
+  /**
+   *
+   */
+  async function _showUserGuide() {
+    if (game.user.isGM) {
+      const newVer = game.system.version
+    }
+  }
+})
+
+Hooks.on("renderChatMessage", (message, html, data) => {
+  const typeMessage = data.message.flags.CthulhuEternal?.typeMessage
+  // Message de demande de jet de dés
+  if (typeMessage === "askRoll") {
+    // Affichage des boutons de jet de dés uniquement pour les joueurs
+    if (game.user.isGM) {
+      html.find(".ask-roll-dice").each((i, btn) => {
+        btn.style.display = "none"
+      })
+    } else {
+      html.find(".ask-roll-dice").click((event) => {
+        const btn = $(event.currentTarget)
+        const type = btn.data("type")
+        const value = btn.data("value")
+        const avantage = btn.data("avantage") ?? "="
+        const character = game.user.character
+        if (type === SYSTEM.ROLL_TYPE.RESOURCE) character.rollResource(value)
+        else if (type === SYSTEM.ROLL_TYPE.SAVE) character.rollSave(value, avantage)
+      })
+    }
+  }
+})
+
+Hooks.on("updateSetting", async (setting, update, options, id) => {
+})
+
+// Dice-so-nice Ready
+Hooks.once("diceSoNiceReady", (dice3d) => {
+  configureDiceSoNice(dice3d)
+})
+
+/**
+ * Create a macro when dropping an entity on the hotbar
+ * Item      - open roll dialog
+ * Actor     - open actor sheet
+ * Journal   - open journal sheet
+ */
+Hooks.on("hotbarDrop", (bar, data, slot) => {
+  if (["Actor", "Item", "JournalEntry", "roll", "rollDamage", "rollAttack"].includes(data.type)) {
+    Macros.createCthulhuEternalMacro(data, slot);
+    return false
+  }
+})
+
+/**
+ * Register world usage statistics
+ * @param {string} registerKey
+ */
+function registerWorldCount(registerKey) {
+  if (game.user.isGM) {
+    ClassCounter.registerUsageCount(game.system.id, {})
+  }
+}

eslint.config.mjs

@@ -0,0 +1,219 @@
+import jsdoc from 'eslint-plugin-jsdoc';
+import prettier from 'eslint-plugin-prettier';
+import configPrettier from 'eslint-config-prettier';
+
+export default [
+  {
+    ignores: [
+      "node_modules/",
+      "eslint.config.mjs",
+      "build.mjs",
+      "gulpfile.js"
+    ],
+    languageOptions: {
+      globals: {
+        browser: true,
+        es2022: true,
+        node: true,
+        jquery: true,
+      },
+      ecmaVersion: 2022,
+      sourceType: 'module',
+    },
+    plugins: {
+      jsdoc, 
+      prettier
+  },
+    rules: {
+      'array-bracket-spacing': ['warn', 'never'],
+      'array-callback-return': 'warn',
+      'arrow-spacing': 'warn',
+      'comma-dangle': ['warn', 'never'],
+      'comma-style': 'warn',
+      'computed-property-spacing': 'warn',
+      'constructor-super': 'error',
+      'default-param-last': 'warn',
+      'dot-location': ['warn', 'property'],
+      'eol-last': ['error', 'always'],
+      'eqeqeq': ['warn', 'smart'],
+      'func-call-spacing': 'warn',
+      'func-names': ['warn', 'never'],
+      'getter-return': 'warn',
+      'lines-between-class-members': 'warn',
+      'new-parens': ['warn', 'always'],
+      'no-alert': 'warn',
+      'no-array-constructor': 'warn',
+      'no-class-assign': 'warn',
+      'no-compare-neg-zero': 'warn',
+      'no-cond-assign': 'warn',
+      'no-const-assign': 'error',
+      'no-constant-condition': 'warn',
+      'no-constructor-return': 'warn',
+      'no-delete-var': 'warn',
+      'no-dupe-args': 'warn',
+      'no-dupe-class-members': 'warn',
+      'no-dupe-keys': 'warn',
+      'no-duplicate-case': 'warn',
+      'no-duplicate-imports': ['warn', { includeExports: true }],
+      'no-empty': ['warn', { allowEmptyCatch: true }],
+      'no-empty-character-class': 'warn',
+      'no-empty-pattern': 'warn',
+      'no-func-assign': 'warn',
+      'no-global-assign': 'warn',
+      'no-implicit-coercion': ['warn', { allow: ['!!'] }],
+      'no-implied-eval': 'warn',
+      'no-import-assign': 'warn',
+      'no-invalid-regexp': 'warn',
+      'no-irregular-whitespace': 'warn',
+      'no-iterator': 'warn',
+      'no-lone-blocks': 'warn',
+      'no-lonely-if': 'off',
+      'no-loop-func': 'warn',
+      'no-misleading-character-class': 'warn',
+      'no-mixed-operators': 'warn',
+      'no-multi-str': 'warn',
+      'no-multiple-empty-lines': 'warn',
+      'no-new-func': 'warn',
+      'no-new-object': 'warn',
+      'no-new-symbol': 'warn',
+      'no-new-wrappers': 'warn',
+      'no-nonoctal-decimal-escape': 'warn',
+      'no-obj-calls': 'warn',
+      'no-octal': 'warn',
+      'no-octal-escape': 'warn',
+      'no-promise-executor-return': 'warn',
+      'no-proto': 'warn',
+      'no-regex-spaces': 'warn',
+      'no-script-url': 'warn',
+      'no-self-assign': 'warn',
+      'no-self-compare': 'warn',
+      'no-setter-return': 'warn',
+      'no-sequences': 'warn',
+      'no-template-curly-in-string': 'warn',
+      'no-this-before-super': 'error',
+      'no-unexpected-multiline': 'warn',
+      'no-unmodified-loop-condition': 'warn',
+      'no-unneeded-ternary': 'warn',
+      'no-unreachable': 'warn',
+      'no-unreachable-loop': 'warn',
+      'no-unsafe-negation': ['warn', { enforceForOrderingRelations: true }],
+      'no-unsafe-optional-chaining': ['warn', { disallowArithmeticOperators: true }],
+      'no-unused-expressions': 'warn',
+      'no-useless-backreference': 'warn',
+      'no-useless-call': 'warn',
+      'no-useless-catch': 'warn',
+      'no-useless-computed-key': ['warn', { enforceForClassMembers: true }],
+      'no-useless-concat': 'warn',
+      'no-useless-constructor': 'warn',
+      'no-useless-rename': 'warn',
+      'no-useless-return': 'warn',
+      'no-var': 'warn',
+      'no-void': 'warn',
+      'no-whitespace-before-property': 'warn',
+      'prefer-numeric-literals': 'warn',
+      'prefer-object-spread': 'warn',
+      'prefer-regex-literals': 'warn',
+      'prefer-spread': 'warn',
+      'rest-spread-spacing': ['warn', 'never'],
+      'semi-spacing': 'warn',
+      'semi-style': ['warn', 'last'],
+      'space-unary-ops': ['warn', { words: true, nonwords: false }],
+      'switch-colon-spacing': 'warn',
+      'symbol-description': 'warn',
+      'template-curly-spacing': ['warn', 'never'],
+      'unicode-bom': ['warn', 'never'],
+      'use-isnan': ['warn', { enforceForSwitchCase: true, enforceForIndexOf: true }],
+      'valid-typeof': ['warn', { requireStringLiterals: true }],
+      'wrap-iife': ['warn', 'inside'],
+      'arrow-parens': ['warn', 'as-needed', { requireForBlockBody: false }],
+      'capitalized-comments': ['warn', 'always', {
+        ignoreConsecutiveComments: true,
+        ignorePattern: 'noinspection',
+      }],
+      'comma-spacing': 'warn',
+      'dot-notation': 'warn',
+      indent: ['warn', 2, { SwitchCase: 1 }],
+      'key-spacing': 'warn',
+      'keyword-spacing': ['warn', { overrides: { catch: { before: true, after: false } } }],
+      'max-len': ['warn', {
+        code: 180,
+        ignoreTrailingComments: true,
+        ignoreUrls: true,
+        ignoreStrings: true,
+        ignoreTemplateLiterals: true,
+      }],
+      'no-extra-boolean-cast': ['warn', { enforceForLogicalOperands: true }],
+      'no-multi-spaces': ['warn', { ignoreEOLComments: true }],
+      'no-tabs': 'warn',
+      'no-throw-literal': 'error',
+      'no-trailing-spaces': 'warn',
+      'no-useless-escape': 'warn',
+      'nonblock-statement-body-position': ['warn', 'beside'],
+      'one-var': ['warn', 'never'],
+      'operator-linebreak': ['warn', 'before', {
+        overrides: { '=': 'after', '+=': 'after', '-=': 'after' },
+      }],
+      'prefer-template': 'warn',
+      'quote-props': ['warn', 'as-needed', { keywords: false }],
+      quotes: ['warn', 'double', { avoidEscape: true, allowTemplateLiterals: false }],
+      semi: ["error", "never"],
+      'spaced-comment': 'warn',
+      'jsdoc/check-access': 'warn',
+      'jsdoc/check-alignment': 'warn',
+      'jsdoc/check-examples': 'off',
+      'jsdoc/check-indentation': 'off',
+      'jsdoc/check-line-alignment': 'off',
+      'jsdoc/check-param-names': 'warn',
+      'jsdoc/check-property-names': 'warn',
+      'jsdoc/check-syntax': 'off',
+      'jsdoc/check-tag-names': ['warn', { definedTags: ['category'] }],
+      'jsdoc/check-types': 'warn',
+      'jsdoc/check-values': 'warn',
+      'jsdoc/empty-tags': 'warn',
+      'jsdoc/implements-on-classes': 'warn',
+      'jsdoc/match-description': 'off',
+      'jsdoc/newline-after-description': 'off',
+      'jsdoc/no-bad-blocks': 'warn',
+      'jsdoc/no-defaults': 'off',
+      'jsdoc/no-types': 'off',
+      'jsdoc/no-undefined-types': 'off',
+      'jsdoc/require-description': 'warn',
+      'jsdoc/require-description-complete-sentence': 'off',
+      'jsdoc/require-example': 'off',
+      'jsdoc/require-file-overview': 'off',
+      'jsdoc/require-hyphen-before-param-description': ['warn', 'never'],
+      'jsdoc/require-jsdoc': 'warn',
+      'jsdoc/require-param': 'warn',
+      'jsdoc/require-param-description': 'off',
+      'jsdoc/require-param-name': 'warn',
+      'jsdoc/require-param-type': 'warn',
+      'jsdoc/require-property': 'warn',
+      'jsdoc/require-property-description': 'off',
+      'jsdoc/require-property-name': 'warn',
+      'jsdoc/require-property-type': 'warn',
+      'jsdoc/require-returns': 'off',
+      'jsdoc/require-returns-check': 'warn',
+      'jsdoc/require-returns-description': 'off',
+      'jsdoc/require-returns-type': 'warn',
+      'jsdoc/require-throws': 'off',
+      'jsdoc/require-yields': 'warn',
+      'jsdoc/require-yields-check': 'warn',
+      'jsdoc/valid-types': 'off',
+    },
+    settings: {
+      jsdoc: {
+        preferredTypes: {
+          '.<>': '<>',
+          object: 'Object',
+          Object: 'object',
+        },
+        mode: 'typescript',
+        tagNamePreference: {
+          augments: 'extends',
+        },
+      },
+    },
+  },
+    // Ajout de la configuration Prettier qui désactive les règles ESLint en conflit avec Prettier
+    configPrettier
+];

gulpfile.js

@@ -0,0 +1,31 @@
+const gulp = require('gulp');
+const less = require('gulp-less');
+
+/* ----------------------------------------- */
+/*  Compile LESS
+/* ----------------------------------------- */
+function compileLESS() {
+  return gulp.src("styles/fvtt-cthulhu-eternal.less")
+      .pipe(less())
+      .pipe(gulp.dest("./css"))
+}
+const css = gulp.series(compileLESS);
+
+/* ----------------------------------------- */
+/*  Watch Updates
+/* ----------------------------------------- */
+const SIMPLE_LESS = ["styles/*.less"];
+
+function watchUpdates() {
+  gulp.watch(SIMPLE_LESS, css);
+}
+
+/* ----------------------------------------- */
+/*  Export Tasks
+/* ----------------------------------------- */
+
+exports.default = gulp.series(
+    gulp.parallel(css),
+    watchUpdates
+);
+exports.css = css;

lang/en.json

@@ -0,0 +1,456 @@
+{
+  "TYPES": {
+    "Actor": {
+      "protagonist": "Protagonist"
+    },
+    "Item": {
+      "skill": "Skill",
+      "weapon": "Weapon",
+      "armor": "Armor",
+      "injuty": "Spell",
+      "gift": "Gift",
+      "vulnerability": "Vulnerability",
+      "save": "Save",
+      "equipment": "Equipment" ,
+      "shield": "Shield"
+    }
+  },
+  "CTHULHUETERNAL": {
+    "Settings": {
+      "Common": "Common",
+      "Classical": "Classical",
+      "Medieval": "Medieval",
+      "Revolution": "Revolution",
+      "Modern": "Modern",
+      "Future": "Future",
+      "Jazz": "Jazz",
+      "WW1": "World War 1",
+      "WW2": "World War 2",
+      "ColdWar": "Cold War",
+      "Victorian": "Victorian"
+    },
+    "Protagonist": {
+      "FIELDS": {
+        "str": {
+          "label": "Strength"
+        },
+        "dex": {
+          "label": "Dexterity"
+        },
+        "int": {
+          "label": "Intelligence"
+        },
+        "wis": {
+          "label": "Wisdom"
+        },
+        "con": {
+          "label": "Constitution"
+        },
+        "char": {
+          "label": "Charisma"
+        },
+        "app": {
+          "label": "Appearance"
+        }
+      }
+    },
+    "Skill": {
+      "Category": {
+        "layperson": "Layperson",
+        "professional": "Professional",
+        "weapon": "Weapon",
+        "armor": "Armor",
+        "resist": "Resist"
+      },
+      "FIELDS": {
+        "diceEvolved": {
+          "label": "Can increase on failure"
+        },
+        "bonus" :{
+          "label": "Bonus"
+        },
+        "base": {
+          "label": "Base"
+        },
+        "rollFailed": {
+          "label": "Roll Failed"
+        },
+        "description": {
+          "label": "Description"
+        }
+      }
+    },
+    "Gear": {
+      "FIELDS": {
+        "cost": {
+          "label": "Cost"
+        },
+        "money": {
+          "label": "Money unit"
+        },
+        "description": {
+          "label": "Description"
+        }
+      }
+    },
+    "Injury": {
+      "FIELDS": {
+        "cost": {
+          "label": "Cost"
+        },
+        "description": {
+          "label": "Description"
+        }
+      }
+    },
+    "Weapon": {
+      "WeaponType": {
+        "melee": "Melee",
+        "ranged": "Ranged"
+      },
+      "FIELDS": {
+        "weaponType": {
+          "label": "Type"
+        },
+        "damageType": {
+          "typeP": {
+            "label": "Piercing"
+          },
+          "typeB": {
+            "label": "Bashing"
+          },
+          "typeS": {
+            "label": "Slashing"
+          }
+        },
+        "damage": {
+          "damageS": {
+            "label": "Small"
+          },
+          "damageM": {
+            "label": "Medium"
+          }
+        },
+        "hands": {
+          "label": "Hands"
+        },
+        "defenseMax": {
+          "label": "Defense max"
+        },
+        "secondsToAttack": {
+          "label": "Seconds to attack"
+        },
+        "speed": {
+          "simpleAim": {
+            "label": "Simple aim"
+          },
+          "carefulAim": {
+            "label": "Careful aim"
+          },
+          "focusedAim": {
+            "label": "Focused aim"
+          }
+        },
+        "defense": {
+          "label": "Defense"
+        },
+        "range": {
+          "pointBlank": {
+            "label": "Point blank"
+          },
+          "short": {
+            "label": "Short"
+          },
+          "medium": {
+            "label": "Medium"
+          },
+          "long": {
+            "label": "Long"
+          },
+          "extreme": {
+            "label": "Extreme"
+          },
+          "outOfSkill": {
+            "label": "Out of skill"
+          }
+        },
+        "load": {
+            "label": "Load"
+        },
+        "cost": {
+          "label": "Cost"
+        },
+        "money": {
+          "label": "Money unit"
+        }
+      }
+    },
+    "Armor": {
+      "Category": {
+        "light": "Light",
+        "medium": "Medium",
+        "heavy": "Heavy"
+      },
+      "FIELDS": {
+        "armortype": {
+          "label": "Category"
+        },
+        "defense": {
+          "label": "Defense"
+        },
+        "movementreduction": {
+          "label": "Movement reduction"
+        },
+        "hp": {
+          "label": "HP"
+        },
+        "damagereduction": {
+          "label": "Damage reduction"
+        },
+        "load": {
+          "label": "Load"
+        },
+        "cost": {
+          "label": "Cost"
+        },
+        "money": {
+          "label": "Money unit"
+        }
+      }
+    },
+    "Motivation": {
+      "FIELDS": {
+        "defense": {
+          "label": "Defense"
+        },
+        "movementreduction": {
+          "label": "Movement reduction"
+        },
+        "hp": {
+          "label": "HP"
+        },
+        "standing": {
+          "min":{
+            "label": "Min"
+          },
+          "max":{
+            "label": "Max"
+          }
+        },
+        "crouching": {
+          "min":{
+            "label": "Min"
+          },
+          "max":{
+            "label": "Max"
+          }
+        },
+        "destruction": {
+          "bashing": {
+            "label": "Bashing"
+          },
+          "slashing": {
+            "label": "Slashing"
+          },
+          "piercing": {
+            "label": "Piercing"
+          }
+        },
+        "autodestruction": {
+          "bashing": {
+            "label": "Bashing"
+          },
+          "slashing": {
+            "label": "Slashing"
+          },
+          "piercing": {
+            "label": "Piercing"
+          }
+        },
+        "damagereduction": {
+          "label": "Damage reduction"
+        },
+        "load": {
+          "label": "Load"
+        },
+        "cost": {
+          "label": "Cost"
+        },
+        "money": {
+          "label": "Money unit"
+        }
+      }
+    },
+    "MentalDisorder": {
+      "FIELDS": {
+        "description": {
+          "label": "Description"
+        },
+        "components": {
+          "verbal": {
+            "label": "Verbal"
+          },
+          "somatic": {
+            "label": "Somatic"
+          },
+          "material": {
+            "label": "Material"
+          }
+        },
+        "level": {
+          "label": "Level"
+        },
+        "cost"  : {
+          "label": "Cost"
+        },
+        "castingTime": {
+          "label": "Casting time"
+        },  
+        "range": {
+          "label": "Range"
+        },
+        "duration": {
+          "label": "Duration"
+        },
+        "areaAffected": {
+          "label": "Area affected"
+        },
+        "savingThrow": {
+          "label": "Saving throw"
+        },  
+        "extraAetherPoints": {
+          "label": "Extra aether points"
+        }
+      }
+    },
+    "Bond": {
+      "FIELDS": {
+        "cost": {
+          "label": "Cost"
+        },
+        "description": {
+          "label": "Description"
+        }
+      }
+    },
+    "Arcane": {
+      "FIELDS": {
+        "value": {
+          "label": "Value"
+        },
+        "description": {
+          "label": "Description"
+        }
+      }
+    },
+    "Label": {
+      "description": "Description",
+      "total": "Total",
+      "langues": "Langues",
+      "profil": "Profil",
+      "details": "Détails",
+      "talents": "Talents",
+      "progressionPossible": "Progression possible",
+      "equipement": "Equipement",
+      "spells" : "Sortilèges",
+      "level": "Niveau",
+      "degats": "Dégâts",
+      "ressource": "Ressource",
+      "sauvegarde": "Sauvegarde",
+      "newArmor": "Nouvelle armure",
+      "newWeapon": "Nouvelle arme",
+      "armor": "Armure",
+      "malus": "Malus",
+      "jet": "Jet de ",
+      "progress": "Progression",
+      "hasProgressed": "A progressé dans la caractéristique",
+      "noProgress": "N'a pas progressé dans la caractéristique",
+      "experience": "Expérience",
+      "experienceDetail": "Expérience {detail}",
+      "maximum": "Maximum"
+    },
+    "Edit": "Editer",
+    "Delete": "Supprimer",
+    "ToggleSheet": "Changer de mode",
+    "Warning": {
+      "dejaDeuxVoies": "Vous avez déjà choisi deux voies",
+      "dejaVoieMajeure": "Vous avez déjà choisi cette voie comme voie majeure",
+      "voieMajeureAjoutee": "Voie majeure ajoutée",
+      "voieMineureAjoutee": "Voie mineure ajoutée",
+      "voieMajeureSupprimee": "Voie majeure supprimée",
+      "voieMineureSupprimee": "Voie mineure supprimée",
+      "plusDeRessource": "Vous n'avez plus de ressource {ressource}"
+    },
+    "Dialog": {
+      "ajoutVoieMajeure": "Ajouter une voie majeure va automatiquement remplacer les caractéristiques, les ressources, les langues et les biens. Continuer ?",
+      "ajoutVoieMajeureTitre": "Ajout d'une voie majeure",
+      "ajoutVoieMineureTitre": "Ajout d'une voie mineure",
+      "suppressionTalents": "Supprimer cette voie va supprimer les talents associés. Continuer ?",
+      "talentDansVoie": "Ce talent est présent dans la voie {path}. Voulez-vous vraiment le supprimer ?",
+      "titleSave": "Jet de sauvegarde",
+      "titleResource": "Jet de ressource",
+      "titleDamage": "Jet de dégâts",
+      "titleAttack": "Jet d'attaque",
+      "titleStandard": "Jet standard"
+    },
+    "Roll": {
+      "save": "Jet de sauvegarde <br> {save}",
+      "resource": "Jet de ressource <br> {resource}",
+      "damage": "Jet de dégâts <br> {item}",
+      "attack": "Jet d'attaque <br> {item}",
+      "roll": "Lancer",
+      "aide": "Aider",
+      "gene": "Gêner",
+      "adversite": "Adversité",
+      "avantagesDesavantages": "Avantages et désavantages",
+      "normal": "Normal",
+      "avantage": "Avec avantage",
+      "desavantage": "Avec désavantage",
+      "doubleAvantage": "Avec double avantage",
+      "doubleDesavantage": "Avec double désavantage",
+      "visibilite": "Visibilité du lancer",      
+      "success": "Réussite",
+      "failure": "Echec",
+      "resourceLost": "Ressource perdue",
+      "displayArmor": "{targetName} a une armure de {targetArmor}. <br>Dégâts réels : {realDamage}"
+    },
+    "Tooltip": {
+      "learnedTalents": "Les talents appris sont en gras",
+      "saveIntroTextTooltip": "Caractéristique : {value} <br> Aide : {aide} <br> Gêne : {gene} <br> Modificateur : {modificateur}",
+      "addAttack": "Ajouter une attaque",
+      "addEquipment": "Ajouter une arme, Shift + Click pour ajouter une armure",
+      "addSpell": "Ajouter un sortilège"
+    },
+    "Setting": {
+      "displayOpponentMalus": "Afficher le malus d'adversité",
+      "displayOpponentMalusHint": "Affiche le malus d'adversité pour les joueurs.",
+      "fortune": "Roue de Fortune",
+      "fortuneHint": "Valeur de la roue de Fortune. Nombre de joueurs + 1 en début de partie."
+    },
+    "Chat": {
+      "askFortune": "{name} veut utiliser un point de Fortune !",
+      "askRollForAll": "Jet de {value}",
+      "askRollForOne": "Jet de {value} pour {name}"
+    },
+    "Fortune": {
+      "title": "Roue de Fortune"
+    },
+    "Manager": {
+      "title": "Gestionnaire de Personnages",
+      "player": "Utilisateur",
+      "character": "Personnage",
+      "rob": "Robustesse",
+      "dex": "Dextérité",
+      "int": "Intelligence",
+      "per": "Perception",
+      "vol": "Volonté",
+      "pv": "Points de Vie",
+      "san": "Santé Mentale",
+      "oeil": "Œil",
+      "verbe": "Verbe",
+      "bourse": "Bourse",
+      "magie": "Magie",
+      "roll": "Faire le jet"
+    }
+  }
+}

module/applications/_module.mjs

@@ -0,0 +1,11 @@
+export { default as CthulhuEternalProtagonistSheet } from "./sheets/protagonist-sheet.mjs";
+export { default as CthulhuEternalWeaponSheet } from "./sheets/weapon-sheet.mjs"
+export { default as CthulhuEternalSkillSheet } from "./sheets/skill-sheet.mjs"
+export { default as CthulhuEternalBondSheet } from "./sheets/bond-sheet.mjs"
+export { default as CthulhuEternalArcaneSheet } from "./sheets/arcane-sheet.mjs"
+export { default as CthulhuEternalInjurySheet } from "./sheets/injury-sheet.mjs"
+export { default as CthulhuEternalArmorSheet } from "./sheets/armor-sheet.mjs"
+export { default as CthulhuEternalMentalDisorderSheet } from "./sheets/mentaldisorder-sheet.mjs"
+export { default as CthulhuEternalGearSheet } from "./sheets/gear-sheet.mjs"
+export { default as CthulhuEternalMotivationSheet } from "./sheets/motivation-sheet.mjs"
+export { default as CthulhuEternalManager } from "./manager.mjs"

module/applications/manager.mjs

@@ -0,0 +1,142 @@
+const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api
+import { SYSTEM } from "../config/system.mjs"
+
+/**
+ * An application for configuring the permissions which are available to each User role.
+ * @extends ApplicationV2
+ * @mixes HandlebarsApplication
+ * @alias PermissionConfig
+ */
+export default class CthulhuEternalManager extends HandlebarsApplicationMixin(ApplicationV2) {
+  static DEFAULT_OPTIONS = {
+    id: "cthulhueternal-application-manager",
+    tag: "form",
+    window: {
+      contentClasses: ["cthulhueternal-manager"],
+      title: "CTHULHUETERNAL.Manager.title",
+      resizable: true,
+    },
+    position: {
+      width: "auto",
+      height: "auto",
+      top: 80,
+      left: 400,
+    },
+    form: {
+      closeOnSubmit: true,
+    },
+    actions: {
+      resourceAll: CthulhuEternalManager.#onResourceAll,
+      resourceOne: CthulhuEternalManager.#onResourceOne,
+      saveAll: CthulhuEternalManager.#onSaveAll,
+      saveOne: CthulhuEternalManager.#onSaveOne,
+      openSheet: CthulhuEternalManager.#onOpenSheet,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/manager.hbs",
+    },
+  }
+
+  /* -------------------------------------------- */
+  /*  Rendering                                   */
+  /* -------------------------------------------- */
+
+  /** @override */
+  async _prepareContext(_options = {}) {
+    return {
+      players: game.users.filter((u) => u.hasPlayerOwner && u.active),
+    }
+  }
+
+  static async #onResourceAll(event, target) {
+    const value = event.target.dataset.resource
+    CthulhuEternalManager.askRollForAll("resource", value)
+  }
+
+  static async #onSaveAll(event, target) {
+    const value = event.target.dataset.save
+    CthulhuEternalManager.askRollForAll("save", value)
+  }
+
+  static #onResourceOne(event, target) {
+    const value = event.target.dataset.resource
+    const recipient = event.target.parentElement.dataset.userId
+    const name = event.target.parentElement.dataset.characterName
+    CthulhuEternalManager.askRollForOne("resource", value, recipient, name)
+  }
+
+  static async #onSaveOne(event, target) {
+    const value = event.target.dataset.save
+    const recipient = event.target.parentElement.dataset.userId
+    const name = event.target.parentElement.dataset.characterName
+    CthulhuEternalManager.askRollForOne("save", value, recipient, name)
+  }
+
+  static #onOpenSheet(event, target) {
+    const characterId = event.target.dataset.characterId
+    game.actors.get(characterId).sheet.render(true)
+  }
+
+  static async askRollForAll(type, value, title = null, avantage = null) {
+    let label = game.i18n.localize(`CTHULHUETERNAL.Manager.${value}`)
+    let text = game.i18n.format("CTHULHUETERNAL.Chat.askRollForAll", { value: label })
+
+    if (avantage) {
+      switch (avantage) {
+        case "++":
+          text += ` ${game.i18n.localize("CTHULHUETERNAL.Roll.doubleAvantage")}`
+          break
+        case "+":
+          text += ` ${game.i18n.localize("CTHULHUETERNAL.Roll.avantage")}`
+          break
+        case "-":
+          text += ` ${game.i18n.localize("CTHULHUETERNAL.Roll.desavantage")}`
+          break
+        case "--":
+          text += ` ${game.i18n.localize("CTHULHUETERNAL.Roll.doubleDesavantage")}`
+          break
+        default:
+          break
+      }
+    }
+
+    ChatMessage.create({
+      user: game.user.id,
+      content: await renderTemplate(`systems/fvtt-cthulhu-eternal/templates/chat-ask-roll.hbs`, {
+        title: title !== null ? title : "",
+        text: text,
+        rollType: type,
+        value: value,
+        avantage: avantage,
+      }),
+      flags: { tenebris: { typeMessage: "askRoll" } },
+    })
+  }
+
+  static async askRollForOne(type, value, recipient, name) {
+    let label = game.i18n.localize(`CTHULHUETERNAL.Manager.${value}`)
+    const text = game.i18n.format("CTHULHUETERNAL.Chat.askRollForOne", { value: label, name: name })
+
+    game.socket.emit(`system.${SYSTEM.id}`, {
+      action: "askRoll",
+      data: {
+        userId: recipient,
+      },
+    })
+
+    ChatMessage.create({
+      user: game.user.id,
+      content: await renderTemplate(`systems/fvtt-cthulhu-eternal/templates/chat-ask-roll.hbs`, {
+        text: text,
+        rollType: type,
+        value: value,
+      }),
+      whisper: [recipient],
+      flags: { tenebris: { typeMessage: "askRoll" } },
+    })
+  }
+}

module/applications/sheets/arcane-sheet.mjs

@@ -0,0 +1,28 @@
+import CthulhuEternalItemSheet from "./base-item-sheet.mjs"
+
+export default class CthulhuEternalArcaneSheet extends CthulhuEternalItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["arcane"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["arcane-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/arcane.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}

module/applications/sheets/armor-sheet.mjs

@@ -0,0 +1,27 @@
+import CthulhuEternalItemSheet from "./base-item-sheet.mjs"
+
+export default class CthulhuEternalArmorSheet extends CthulhuEternalItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["armor"],
+    position: {
+      width: 400,
+    },
+    window: {
+      contentClasses: ["armor-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/armor.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    return context
+  }
+}

module/applications/sheets/base-actor-sheet.mjs

@@ -0,0 +1,292 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class CthulhuEternalActorSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ActorSheetV2) {
+  /**
+   * Different sheet modes.r
+   * @enum {number}
+   */
+  static SHEET_MODES = { EDIT: 0, PLAY: 1 }
+
+  constructor(options = {}) {
+    super(options)
+    this.#dragDrop = this.#createDragDropHandlers()
+  }
+
+  #dragDrop
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-cthulhu-eternal", "actor"],
+    position: {
+      width: 1400,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: '[data-drag="true"], .rollable', dropSelector: null }],
+    actions: {
+      editImage: CthulhuEternalActorSheet.#onEditImage,
+      toggleSheet: CthulhuEternalActorSheet.#onToggleSheet,
+      edit: CthulhuEternalActorSheet.#onItemEdit,
+      delete: CthulhuEternalActorSheet.#onItemDelete,
+      createSpell: CthulhuEternalActorSheet.#onCreateSpell,
+    },
+  }
+
+  /**
+   * The current sheet mode.
+   * @type {number}
+   */
+  _sheetMode = this.constructor.SHEET_MODES.PLAY
+
+  /**
+   * Is the sheet currently in 'Play' mode?
+   * @type {boolean}
+   */
+  get isPlayMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.PLAY
+  }
+
+  /**
+   * Is the sheet currently in 'Edit' mode?
+   * @type {boolean}
+   */
+  get isEditMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.EDIT
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = {
+      fields: this.document.schema.fields,
+      systemFields: this.document.system.schema.fields,
+      actor: this.document,
+      system: this.document.system,
+      source: this.document.toObject(),
+      enrichedDescription: await TextEditor.enrichHTML(this.document.system.description, { async: true }),
+      isEditMode: this.isEditMode,
+      isPlayMode: this.isPlayMode,
+      isEditable: this.isEditable,
+    }
+    return context
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    this.#dragDrop.forEach((d) => d.bind(this.element))
+    // Add listeners to rollable elements
+    const rollables = this.element.querySelectorAll(".rollable")
+    rollables.forEach((d) => d.addEventListener("click", this._onRoll.bind(this)))
+  }
+
+  // #region Drag-and-Drop Workflow
+  /**
+   * Create drag-and-drop workflow handlers for this Application
+   * @returns {DragDrop[]}     An array of DragDrop handlers
+   * @private
+   */
+  #createDragDropHandlers() {
+    return this.options.dragDrop.map((d) => {
+      d.permissions = {
+        dragstart: this._canDragStart.bind(this),
+        drop: this._canDragDrop.bind(this),
+      }
+      d.callbacks = {
+        dragstart: this._onDragStart.bind(this),
+        dragover: this._onDragOver.bind(this),
+        drop: this._onDrop.bind(this),
+      }
+      return new DragDrop(d)
+    })
+  }
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {}
+
+  /**
+   * Define whether a user is able to begin a dragstart workflow for a given drag selector
+   * @param {string} selector       The candidate HTML selector for dragging
+   * @returns {boolean}             Can the current user drag this selector?
+   * @protected
+   */
+  _canDragStart(selector) {
+    return this.isEditable
+  }
+
+  /**
+   * Define whether a user is able to conclude a drag-and-drop workflow for a given drop selector
+   * @param {string} selector       The candidate HTML selector for the drop target
+   * @returns {boolean}             Can the current user drop on this selector?
+   * @protected
+   */
+  _canDragDrop(selector) {
+    return this.isEditable && this.document.isOwner
+  }
+
+  /**
+   * Callback actions which occur at the beginning of a drag start workflow.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  _onDragStart(event) {
+    if ("link" in event.target.dataset) return
+
+    const el = event.currentTarget.closest('[data-drag="true"]')
+    const dragType = el.dataset.dragType
+
+    let dragData = {}
+
+    let target
+    switch (dragType) {
+      case "save":
+        target = event.currentTarget.querySelector("input")
+        dragData = {
+          actorId: this.document.id,
+          type: "roll",
+          rollType: target.dataset.rollType,
+          rollTarget: target.dataset.rollTarget,
+          value: target.value,
+        }
+        break
+      case "resource":
+        target = event.currentTarget.querySelector("select")
+        dragData = {
+          actorId: this.document.id,
+          type: "roll",
+          rollType: target.dataset.rollType,
+          rollTarget: target.dataset.rollTarget,
+          value: target.value,
+        }
+        break
+      case "damage":
+        dragData = {
+          actorId: this.document.id,
+          type: "rollDamage",
+          rollType: el.dataset.dragType,
+          rollTarget: el.dataset.itemId,
+        }
+        break
+      case "attack":
+        dragData = {
+          actorId: this.document.id,
+          type: "rollAttack",
+          rollValue: el.dataset.rollValue,
+          rollTarget: el.dataset.rollTarget,
+        }
+        break
+      default:
+        // Handle other cases or do nothing
+        break
+    }
+
+    // Extract the data you need
+
+    if (!dragData) return
+
+    // Set data transfer
+    event.dataTransfer.setData("text/plain", JSON.stringify(dragData))
+  }
+
+  /**
+   * Callback actions which occur when a dragged element is over a drop target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  _onDragOver(event) {}
+
+  async _onDropItem(item) {
+    let itemData = item.toObject()
+    await this.document.createEmbeddedDocuments("Item", [itemData], { renderSheet: false })
+  }
+
+  // #endregion
+
+  // #region Actions
+  /**
+   * Handle toggling between Edit and Play mode.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onToggleSheet(event, target) {
+    const modes = this.constructor.SHEET_MODES
+    this._sheetMode = this.isEditMode ? modes.PLAY : modes.EDIT
+    this.render()
+  }
+
+  /**
+   * Handle changing a Document's image.
+   *
+   * @this CthulhuEternalCharacterSheet
+   * @param {PointerEvent} event   The originating click event
+   * @param {HTMLElement} target   The capturing HTML element which defined a [data-action]
+   * @returns {Promise}
+   * @private
+   */
+  static async #onEditImage(event, target) {
+    const attr = target.dataset.edit
+    const current = foundry.utils.getProperty(this.document, attr)
+    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
+    const fp = new FilePicker({
+      current,
+      type: "image",
+      redirectToRoot: img ? [img] : [],
+      callback: (path) => {
+        this.document.update({ [attr]: path })
+      },
+      top: this.position.top + 40,
+      left: this.position.left + 10,
+    })
+    return fp.browse()
+  }
+
+  /**
+   * Edit an existing item within the Actor
+   * Start with the uuid, if it's not found, fallback to the id (as Embedded item in the actor)
+   * @this CthulhuEternalCharacterSheet
+   * @param {PointerEvent} event The originating click event
+   * @param {HTMLElement} target the capturing HTML element which defined a [data-action]
+   */
+  static async #onItemEdit(event, target) {
+    const id = target.getAttribute("data-item-id")
+    const uuid = target.getAttribute("data-item-uuid")
+    let item
+    item = await fromUuid(uuid)
+    if (!item) item = this.document.items.get(id)
+    if (!item) return
+    item.sheet.render(true)
+  }
+
+  /**
+   * Delete an existing talent within the Actor
+   * Use the uuid to display the talent sheet
+   * @param {PointerEvent} event The originating click event
+   * @param {HTMLElement} target the capturing HTML element which defined a [data-action]
+   */
+  static async #onItemDelete(event, target) {
+    const itemUuid = target.getAttribute("data-item-uuid")
+    const talent = await fromUuid(itemUuid)
+    await talent.deleteDialog()
+  }
+
+  /**
+   * Handles the creation of a new attack item.
+   *
+   * @param {Event} event The event that triggered the creation of the attack.
+   * @param {Object} target The target object where the attack will be created.
+   * @private
+   * @static
+   */
+  static #onCreateSpell(event, target) {
+    const item = this.document.createEmbeddedDocuments("Item", [{ name: "Nouveau sortilège", type: "spell" }])
+  }
+
+  // #endregion
+}

module/applications/sheets/base-item-sheet.mjs

@@ -0,0 +1,193 @@
+const { HandlebarsApplicationMixin } = foundry.applications.api
+
+export default class CthulhuEternalItemSheet extends HandlebarsApplicationMixin(foundry.applications.sheets.ItemSheetV2) {
+  /**
+   * Different sheet modes.
+   * @enum {number}
+   */
+  static SHEET_MODES = { EDIT: 0, PLAY: 1 }
+
+  constructor(options = {}) {
+    super(options)
+    this.#dragDrop = this.#createDragDropHandlers()
+  }
+
+  #dragDrop
+
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["fvtt-cthulhu-eternal", "item"],
+    position: {
+      width: 600,
+      height: "auto",
+    },
+    form: {
+      submitOnChange: true,
+    },
+    window: {
+      resizable: true,
+    },
+    dragDrop: [{ dragSelector: "[data-drag]", dropSelector: null }],
+    actions: {
+      toggleSheet: CthulhuEternalItemSheet.#onToggleSheet,
+      editImage: CthulhuEternalItemSheet.#onEditImage,
+    },
+  }
+
+  /**
+   * The current sheet mode.
+   * @type {number}
+   */
+  _sheetMode = this.constructor.SHEET_MODES.PLAY
+
+  /**
+   * Is the sheet currently in 'Play' mode?
+   * @type {boolean}
+   */
+  get isPlayMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.PLAY
+  }
+
+  /**
+   * Is the sheet currently in 'Edit' mode?
+   * @type {boolean}
+   */
+  get isEditMode() {
+    return this._sheetMode === this.constructor.SHEET_MODES.EDIT
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = {
+      fields: this.document.schema.fields,
+      systemFields: this.document.system.schema.fields,
+      item: this.document,
+      system: this.document.system,
+      source: this.document.toObject(),
+      enrichedDescription: await TextEditor.enrichHTML(this.document.system.description, { async: true }),
+      isEditMode: this.isEditMode,
+      isPlayMode: this.isPlayMode,
+      isEditable: this.isEditable,
+    }
+    return context
+  }
+
+  /** @override */
+  _onRender(context, options) {
+    this.#dragDrop.forEach((d) => d.bind(this.element))
+  }
+
+  // #region Drag-and-Drop Workflow
+  /**
+   * Create drag-and-drop workflow handlers for this Application
+   * @returns {DragDrop[]}     An array of DragDrop handlers
+   * @private
+   */
+  #createDragDropHandlers() {
+    return this.options.dragDrop.map((d) => {
+      d.permissions = {
+        dragstart: this._canDragStart.bind(this),
+        drop: this._canDragDrop.bind(this),
+      }
+      d.callbacks = {
+        dragstart: this._onDragStart.bind(this),
+        dragover: this._onDragOver.bind(this),
+        drop: this._onDrop.bind(this),
+      }
+      return new DragDrop(d)
+    })
+  }
+
+  /**
+   * Define whether a user is able to begin a dragstart workflow for a given drag selector
+   * @param {string} selector       The candidate HTML selector for dragging
+   * @returns {boolean}             Can the current user drag this selector?
+   * @protected
+   */
+  _canDragStart(selector) {
+    return this.isEditable
+  }
+
+  /**
+   * Define whether a user is able to conclude a drag-and-drop workflow for a given drop selector
+   * @param {string} selector       The candidate HTML selector for the drop target
+   * @returns {boolean}             Can the current user drop on this selector?
+   * @protected
+   */
+  _canDragDrop(selector) {
+    return this.isEditable && this.document.isOwner
+  }
+
+  /**
+   * Callback actions which occur at the beginning of a drag start workflow.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  _onDragStart(event) {
+    const el = event.currentTarget
+    if ("link" in event.target.dataset) return
+
+    // Extract the data you need
+    let dragData = null
+
+    if (!dragData) return
+
+    // Set data transfer
+    event.dataTransfer.setData("text/plain", JSON.stringify(dragData))
+  }
+
+  /**
+   * Callback actions which occur when a dragged element is over a drop target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  _onDragOver(event) {}
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {}
+
+  // #endregion
+
+  // #region Actions
+  /**
+   * Handle toggling between Edit and Play mode.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onToggleSheet(event, target) {
+    const modes = this.constructor.SHEET_MODES
+    this._sheetMode = this.isEditMode ? modes.PLAY : modes.EDIT
+    this.render()
+  }
+
+  /**
+   * Handle changing a Document's image.
+   *
+   * @this CthulhuEternalCharacterSheet
+   * @param {PointerEvent} event   The originating click event
+   * @param {HTMLElement} target   The capturing HTML element which defined a [data-action]
+   * @returns {Promise}
+   * @private
+   */
+  static async #onEditImage(event, target) {
+    const attr = target.dataset.edit
+    const current = foundry.utils.getProperty(this.document, attr)
+    const { img } = this.document.constructor.getDefaultArtwork?.(this.document.toObject()) ?? {}
+    const fp = new FilePicker({
+      current,
+      type: "image",
+      redirectToRoot: img ? [img] : [],
+      callback: (path) => {
+        this.document.update({ [attr]: path })
+      },
+      top: this.position.top + 40,
+      left: this.position.left + 10,
+    })
+    return fp.browse()
+  }
+  // #endregion
+}

module/applications/sheets/bond-sheet.mjs

@@ -0,0 +1,28 @@
+import CthulhuEternalItemSheet from "./base-item-sheet.mjs"
+
+export default class CthulhuEternalGiftSheet extends CthulhuEternalItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["bond"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["bond-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/bond.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}

module/applications/sheets/gear-sheet.mjs

@@ -0,0 +1,27 @@
+import CthulhuEternalItemSheet from "./base-item-sheet.mjs"
+
+export default class CthulhuEternalGearSheet extends CthulhuEternalItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["gear"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["gear-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/gear.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    return context
+  }
+}

module/applications/sheets/injury-sheet.mjs

@@ -0,0 +1,28 @@
+import CthulhuEternalItemSheet from "./base-item-sheet.mjs"
+
+export default class CthulhuEternalInjurySheet extends CthulhuEternalItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["injury"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["injury-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/injury.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}

module/applications/sheets/mentaldisorder-sheet.mjs

@@ -0,0 +1,21 @@
+import CthulhuEternalItemSheet from "./base-item-sheet.mjs"
+
+export default class CthulhuEternalMentalDisorderSheet extends CthulhuEternalItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["mentaldisorder"],
+    position: {
+      width: 450,
+    },
+    window: {
+      contentClasses: ["mentaldisorder-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/mentaldisorder.hbs",
+    },
+  }
+}

module/applications/sheets/motivation-sheet.mjs

@@ -0,0 +1,27 @@
+import CthulhuEternalItemSheet from "./base-item-sheet.mjs"
+
+export default class CthulhuEternalMotivationSheet extends CthulhuEternalItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["motivation"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["motivation-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/motivation.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    return context
+  }
+}

module/applications/sheets/protagonist-sheet.mjs

@@ -0,0 +1,173 @@
+import CthulhuEternalActorSheet from "./base-actor-sheet.mjs"
+
+export default class CthulhuEternalProtagonistSheet extends CthulhuEternalActorSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["protagonist"],
+    position: {
+      width: 1150,
+      height: 780,
+    },
+    window: {
+      contentClasses: ["protagonist-content"],
+    },
+    actions: {
+      createEquipment: CthulhuEternalProtagonistSheet.#onCreateEquipment,
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/character-main.hbs",
+    },
+    tabs: {
+      template: "systems/fvtt-cthulhu-eternal/templates/generic/tab-navigation.hbs",
+    },
+    items: {
+      template: "systems/fvtt-cthulhu-eternal/templates/character-items.hbs",
+    },
+    biography: {
+      template: "systems/fvtt-cthulhu-eternal/templates/character-biography.hbs",
+    },
+  }
+
+  /** @override */
+  tabGroups = {
+    sheet: "items",
+  }
+
+  /**
+   * Prepare an array of form header tabs.
+   * @returns {Record<string, Partial<ApplicationTab>>}
+   */
+  #getTabs() {
+    const tabs = {
+      items: { id: "items", group: "sheet", icon: "fa-solid fa-shapes", label: "CTHULHUETERNAL.Character.Label.details" },
+      biography: { id: "biography", group: "sheet", icon: "fa-solid fa-book", label: "CTHULHUETERNAL.Character.Label.biography" },
+    }
+    for (const v of Object.values(tabs)) {
+      v.active = this.tabGroups[v.group] === v.id
+      v.cssClass = v.active ? "active" : ""
+    }
+    return tabs
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.tabs = this.#getTabs()
+
+    context.tooltipsCaracteristiques = {
+    }
+
+    context.tooltipsRessources = {
+    }
+
+    context.rollType = {
+    }
+    return context
+  }
+
+  _generateTooltip(type, target) {
+  }
+
+  /** @override */
+  async _preparePartContext(partId, context) {
+    const doc = this.document
+    switch (partId) {
+      case "main":
+        context.enrichedBiens = await TextEditor.enrichHTML(doc.system.biens, { async: true })
+        break
+      case "items":
+        context.tab = context.tabs.items
+        context.weapons = doc.itemTypes.weapon
+        context.armors = doc.itemTypes.armor
+        context.spells = doc.itemTypes.spell
+        context.hasSpells = context.spells.length > 0
+        break
+      case "biography":
+        context.tab = context.tabs.biography
+        context.enrichedDescription = await TextEditor.enrichHTML(doc.system.description, { async: true })
+        context.enrichedNotes = await TextEditor.enrichHTML(doc.system.notes, { async: true })
+        break
+    }
+    return context
+  }
+
+  // #region Drag-and-Drop Workflow
+
+  /**
+   * Callback actions which occur when a dragged element is dropped on a target.
+   * @param {DragEvent} event       The originating DragEvent
+   * @protected
+   */
+  async _onDrop(event) {
+    if (!this.isEditable || !this.isEditMode) return
+    const data = TextEditor.getDragEventData(event)
+
+    // Handle different data types
+    switch (data.type) {
+      case "Item":
+        const item = await fromUuid(data.uuid)
+        if (!["path", "weapon", "armor", "spell"].includes(item.type)) return
+        if (item.type === "path") return this.#onDropPathItem(item)
+        if (item.type === "weapon") return super._onDropItem(item)
+        if (item.type === "armor") return this._onDropItem(item)
+        if (item.type === "spell") return this._onDropItem(item)
+    }
+  }
+
+  async #onDropPathItem(item) {
+    await this.document.addPath(item)
+  }
+
+
+  /**
+   * Creates a new attack item directly from the sheet and embeds it into the document.
+   * @param {Event} event             The initiating click event.
+   * @param {HTMLElement} target      The current target of the event listener.
+   */
+  static #onCreateEquipment(event, target) {
+    // Création d'une armure
+    if (event.shiftKey) {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("CTHULHUETERNAL.Label.newArmor"), type: "armor" }])
+    }
+    // Création d'une arme
+    else {
+      this.document.createEmbeddedDocuments("Item", [{ name: game.i18n.localize("CTHULHUETERNAL.Label.newWeapon"), type: "weapon" }])
+    }
+  }
+
+  /**
+   * Handles the roll action triggered by user interaction.
+   *
+   * @param {PointerEvent} event The event object representing the user interaction.
+   * @param {HTMLElement} target The target element that triggered the roll.
+   *
+   * @returns {Promise<void>} A promise that resolves when the roll action is complete.
+   *
+   * @throws {Error} Throws an error if the roll type is not recognized.
+   *
+   * @description This method checks the current mode (edit or not) and determines the type of roll
+   * (save, resource, or damage) based on the target element's data attributes. It retrieves the
+   * corresponding value from the document's system and performs the roll.
+   */
+  async _onRoll(event, target) {
+    if (this.isEditMode) return
+    // Jet de sauvegarde
+    let elt = event.currentTarget.querySelector("input")
+    // Jet de ressource
+    if (!elt) elt = event.currentTarget.querySelector("select")
+    // Jet de dégâts
+    if (!elt) elt = event.currentTarget
+    const rollType = elt.dataset.rollType
+    let rollTarget
+    switch (rollType) {
+      default:
+        break
+    }
+    await this.document.system.roll(rollType, rollTarget)
+  }
+  // #endregion
+}

module/applications/sheets/skill-sheet.mjs

@@ -0,0 +1,28 @@
+import CthulhuEternalItemSheet from "./base-item-sheet.mjs"
+
+export default class CthulhuEternalSkillSheet extends CthulhuEternalItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["skill"],
+    position: {
+      width: 600,
+    },
+    window: {
+      contentClasses: ["skill-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/skill.hbs",
+    },
+  }
+
+  /** @override */
+  async _prepareContext() {
+    const context = await super._prepareContext()
+    context.enrichedDescription = await TextEditor.enrichHTML(this.document.system.description, { async: true })
+    return context
+  }
+}

module/applications/sheets/weapon-sheet.mjs

@@ -0,0 +1,21 @@
+import LethalFantasyItemSheet from "./base-item-sheet.mjs"
+
+export default class LethalFantasyWeaponSheet extends LethalFantasyItemSheet {
+  /** @override */
+  static DEFAULT_OPTIONS = {
+    classes: ["weapon"],
+    position: {
+      width: 620,
+    },
+    window: {
+      contentClasses: ["weapon-content"],
+    },
+  }
+
+  /** @override */
+  static PARTS = {
+    main: {
+      template: "systems/fvtt-cthulhu-eternal/templates/weapon.hbs",
+    },
+  }
+}

module/config/bond.mjs

@@ -0,0 +1,5 @@
+export const BOND_TYPE = {
+  "individual": "CTHULHUETERNAL.Weapon.WeaponType.melee",
+  "community": "CTHULHUETERNAL.Weapon.WeaponType.ranged"
+}
+

module/config/protagonist.mjs

@@ -0,0 +1,57 @@
+export const CHARACTERISTICS = Object.freeze({
+  str: {
+    id: "str",
+    label: "CTHULHUETERNAL.Character.str.label"
+  },
+  int: {
+    id: "int",
+    label: "CTHULHUETERNAL.Character.int.label"
+  },
+  wis: {
+    id: "wis",
+    label: "CTHULHUETERNAL.Character.wis.label"
+  },
+  dex: {
+    id: "dex",
+    label: "CTHULHUETERNAL.Character.dex.label"
+  },
+  con: {
+    id: "con",
+    label: "CTHULHUETERNAL.Character.con.label"
+  },
+  cha: {
+    id: "cha",
+    label: "CTHULHUETERNAL.Character.cha.label"
+  },
+  app: {
+    id: "app",
+    label: "CTHULHUETERNAL.Character.app.label"
+  },
+})
+
+export const SAVES = Object.freeze({
+  str: {
+    id: "str",
+    label: "CTHULHUETERNAL.Character.str.label"
+  },
+  agility: {
+    id: "agility",
+    label: "CTHULHUETERNAL.Character.agility.label"
+  },
+  dying: {
+    id: "dying",
+    label: "CTHULHUETERNAL.Character.dying.label"
+  },
+  will: {
+    id: "will",
+    label: "CTHULHUETERNAL.Character.will.label"
+  },
+  dodge: {
+    id: "dodge",
+    label: "CTHULHUETERNAL.Character.dodge.label"
+  },
+  toughness: {
+    id: "toughness",
+    label: "CTHULHUETERNAL.Character.toughness.label"
+  }
+})

module/config/system.mjs

@@ -0,0 +1,45 @@
+import * as PROTAGONIST from "./protagonist.mjs"
+import * as WEAPON from "./weapon.mjs"
+import * as BOND from "./bond.mjs"
+
+
+export const SYSTEM_ID = "fvtt-cthulhu-eternal"
+
+export const AVAILABLE_SETTINGS = {
+  common: "CTHULHUETERNAL.Settings.Common",
+  modern: "CTHULHUETERNAL.Settings.Modern",
+  jazz: "CTHULHUETERNAL.Settings.Jazz",
+  future: "CTHULHUETERNAL.Settings.Future",
+  coldwar: "CTHULHUETERNAL.Settings.ColdWar",
+  ww2: "CTHULHUETERNAL.Settings.WW2",
+  ww1: "CTHULHUETERNAL.Settings.WW1",
+  victorian: "CTHULHUETERNAL.Settings.Victorian",
+  revolution: "CTHULHUETERNAL.Settings.Revolution",
+  medieval: "CTHULHUETERNAL.Settings.Medieval",
+  classical: "CTHULHUETERNAL.Settings.Classical"
+}
+
+export const ASCII = `
+······················································································································
+:                                                                                                                    :
+:@@@      @@@@@@@@ @@@@@@@ @@@  @@@  @@@@@@  @@@         @@@@@@@@  @@@@@@  @@@  @@@ @@@@@@@  @@@@@@   @@@@@@ @@@ @@@ :
+:@@!      @@!        @!!   @@!  @@@ @@!  @@@ @@!         @@!      @@!  @@@ @@!@!@@@   @!!   @@!  @@@ !@@     @@! !@@ :
+:@!!      @!!!:!     @!!   @!@!@!@! @!@!@!@! @!!         @!!!:!   @!@!@!@! @!@@!!@!   @!!   @!@!@!@!  !@@!!   !@!@!  :
+:!!:      !!:        !!:   !!:  !!! !!:  !!! !!:         !!:      !!:  !!! !!:  !!!   !!:   !!:  !!!     !:!   !!:   :
+:: ::.: : : :: ::     :     :   : :  :   : : : ::.: :     :        :   : : ::    :     :     :   : : ::.: :    .:    :
+:                                                                                                                    :
+······················································································································
+`
+
+/**
+ * Include all constant definitions within the SYSTEM global export
+ * @type {Object}
+ */
+export const SYSTEM = {
+  id: SYSTEM_ID,
+  CHARACTERISTICS: PROTAGONIST.CHARACTERISTICS,
+  WEAPON_TYPE: WEAPON.WEAPON_TYPE,
+  BOND_TYPE: BOND.BOND_TYPE,
+  AVAILABLE_SETTINGS,
+  ASCII
+}

module/config/weapon.mjs

@@ -0,0 +1,9 @@
+export const WEAPON_TYPE = {
+  "melee": "CTHULHUETERNAL.Weapon.WeaponType.melee",
+  "ranged": "CTHULHUETERNAL.Weapon.WeaponType.ranged"
+}
+
+export const WEAPON_RANGE_UNIT = {
+  "yard": "CTHULHUETERNAL.Weapon.RangeUnit.yard",
+  "meter": "CTHULHUETERNAL.Weapon.RangeUnit.meter"
+}

module/control-buttons.mjs

@@ -0,0 +1,44 @@
+/**
+ * Menu spécifique au système
+ */
+export function initControlButtons() {
+  CONFIG.Canvas.layers.tenebris = { layerClass: ControlsLayer, group: "primary" }
+
+  Hooks.on("getSceneControlButtons", (btns) => {
+    let menu = []
+
+    menu.push({
+      name: "fortune",
+      title: game.i18n.localize("TENEBRIS.Fortune.title"),
+      icon: "fa-solid fa-clover",
+      button: true,
+      onClick: () => {
+        if (!foundry.applications.instances.has("tenebris-application-fortune")) {
+          game.system.applicationFortune.render(true)
+        } else game.system.applicationFortune.close()
+      },
+    })
+
+    if (game.user.isGM) {
+      menu.push({
+        name: "gm-manager",
+        title: game.i18n.localize("TENEBRIS.Manager.title"),
+        icon: "fa-solid fa-users",
+        button: true,
+        onClick: () => {
+          if (!foundry.applications.instances.has("tenebris-application-manager")) {
+            game.system.applicationManager.render(true)
+          } else game.system.applicationManager.close()
+        },
+      })
+    }
+
+    btns.push({
+      name: "tenebris",
+      title: "Cthulhu CthulhuEternal",
+      icon: "tenebris",
+      layer: "tenebris",
+      tools: menu,
+    })
+  })
+}

module/documents/_module.mjs

@@ -0,0 +1,4 @@
+export { default as CthulhuEternalActor } from "./actor.mjs"
+export { default as CthulhuEternalItem } from "./item.mjs"
+export { default as CthulhuEternalRoll } from "./roll.mjs"
+export { default as CthulhuEternalChatMessage } from "./chat-message.mjs"

module/documents/actor.mjs

@@ -0,0 +1,17 @@
+export default class CthulhuEternalActor extends Actor {
+  async _preCreate(data, options, user) {
+    await super._preCreate(data, options, user)
+
+    // Configure prototype token settings
+    const prototypeToken = {}
+    if (this.type === "protagonist") {
+      Object.assign(prototypeToken, {
+        sight: { enabled: true },
+        actorLink: true,
+        disposition: CONST.TOKEN_DISPOSITIONS.FRIENDLY,
+      })
+      this.updateSource({ prototypeToken })
+    }
+  }
+
+}

module/documents/chat-message.mjs

@@ -0,0 +1,21 @@
+import CthulhuEternalRoll from "./roll.mjs"
+
+export default class CthulhuEternalChatMessage extends ChatMessage {
+  async _renderRollContent(messageData) {
+    const data = messageData.message
+    if (this.rolls[0] instanceof CthulhuEternalRoll) {
+      const isPrivate = !this.isContentVisible
+      // _renderRollHTML va appeler render sur tous les rolls
+      const rollHTML = await this._renderRollHTML(isPrivate)
+      if (isPrivate) {
+        data.flavor = game.i18n.format("CHAT.PrivateRollContent", { user: this.user.name })
+        messageData.isWhisper = false
+        messageData.alias = this.user.name
+      }
+      data.content = `<section class="dice-rolls">${rollHTML}</section>`
+      return
+    }
+
+    return super._renderRollContent(messageData)
+  }
+}

module/documents/item.mjs

@@ -0,0 +1 @@
+export default class CthulhuEternalItem extends Item {}

module/documents/roll.mjs

@@ -0,0 +1,583 @@
+import CthulhuEternalUtils from "../utils.mjs"
+
+export default class CthulhuEternalRoll extends Roll {
+  /**
+   * The HTML template path used to render dice checks of this type
+   * @type {string}
+   */
+  static CHAT_TEMPLATE = "systems/fvtt-cthulhu-eternal/templates/chat-message.hbs"
+
+  get type() {
+    return this.options.type
+  }
+
+  get isDamage() {
+    return this.type === ROLL_TYPE.DAMAGE
+  }
+
+  get target() {
+    return this.options.target
+  }
+
+  get value() {
+    return this.options.value
+  }
+
+  get treshold() {
+    return this.options.treshold
+  }
+
+  get actorId() {
+    return this.options.actorId
+  }
+
+  get actorName() {
+    return this.options.actorName
+  }
+
+  get actorImage() {
+    return this.options.actorImage
+  }
+
+  get introText() {
+    return this.options.introText
+  }
+
+  get introTextTooltip() {
+    return this.options.introTextTooltip
+  }
+
+  get aide() {
+    return this.options.aide
+  }
+
+  get gene() {
+    return this.options.gene
+  }
+
+  get modificateur() {
+    return this.options.modificateur
+  }
+
+  get avantages() {
+    return this.options.avantages
+  }
+
+  get resultType() {
+    return this.options.resultType
+  }
+
+  get isFailure() {
+    return this.resultType === "failure"
+  }
+
+  get hasTarget() {
+    return this.options.hasTarget
+  }
+
+  get targetName() {
+    return this.options.targetName
+  }
+
+  get targetArmor() {
+    return this.options.targetArmor
+  }
+
+  get targetMalus() {
+    return this.options.targetMalus
+  }
+
+  get realDamage() {
+    return this.options.realDamage
+  }
+
+  get rollAdvantage() {
+    return this.options.rollAdvantage
+  }
+
+  /**
+   * Generates introductory text based on the roll type.
+   *
+   * @returns {string} The formatted introductory text for the roll.
+   */
+  _createIntroText() {
+    let text
+
+    switch (this.type) {
+      case ROLL_TYPE.SAVE:
+        const saveLabel = game.i18n.localize(`TENEBRIS.Character.FIELDS.caracteristiques.${this.target}.valeur.label`)
+        text = game.i18n.format("TENEBRIS.Roll.save", { save: saveLabel })
+        text = text.concat("<br>").concat(`Seuil : ${this.treshold}`)
+        break
+      case ROLL_TYPE.RESOURCE:
+        const resourceLabel = game.i18n.localize(`TENEBRIS.Character.FIELDS.ressources.${this.target}.valeur.label`)
+        text = game.i18n.format("TENEBRIS.Roll.resource", { resource: resourceLabel })
+        break
+      case ROLL_TYPE.DAMAGE:
+        const damageLabel = this.target
+        text = game.i18n.format("TENEBRIS.Roll.damage", { item: damageLabel })
+        break
+      case ROLL_TYPE.ATTACK:
+        const attackLabel = this.target
+        text = game.i18n.format("TENEBRIS.Roll.attack", { item: attackLabel })
+        break
+    }
+    return text
+  }
+
+  /**
+   * Generates an introductory text tooltip with characteristics and modifiers.
+   *
+   * @returns {string} A formatted string containing the value, help, hindrance, and modifier.
+   */
+  _createIntroTextTooltip() {
+    let tooltip = game.i18n.format("TENEBRIS.Tooltip.saveIntroTextTooltip", { value: this.value, aide: this.aide, gene: this.gene, modificateur: this.modificateur })
+    if (this.hasTarget) {
+      tooltip = tooltip.concat(`<br>Cible : ${this.targetName}`)
+    }
+    return tooltip
+  }
+
+  /**
+   * Prompt the user with a dialog to configure and execute a roll.
+   *
+   * @param {Object} options Configuration options for the roll.
+   * @param {string} options.rollType The type of roll being performed (e.g., RESOURCE, DAMAGE, ATTACK, SAVE).
+   * @param {string} options.rollValue The initial value or formula for the roll.
+   * @param {string} options.rollTarget The target of the roll.
+   * @param {"="|"+"|"++"|"-"|"--"} options.rollAdvantage If there is an avantage (+), a disadvantage (-), a double advantage (++), a double disadvantage (--) or a normal roll (=).
+   * @param {string} options.actorId The ID of the actor performing the roll.
+   * @param {string} options.actorName The name of the actor performing the roll.
+   * @param {string} options.actorImage The image of the actor performing the roll.
+   * @param {boolean} options.hasTarget Whether the roll has a target.
+   * @param {Object} options.target The target of the roll, if any.
+   * @param {Object} options.data Additional data for the roll.
+   *
+   * @returns {Promise<Object|null>} The roll result or null if the dialog was cancelled.
+   */
+  static async prompt(options = {}) {
+    let formula = options.rollValue
+
+    // Formula for a resource roll
+    if (options.rollType === ROLL_TYPE.RESOURCE) {
+      let ressource = game.i18n.localize(`TENEBRIS.Character.FIELDS.ressources.${options.rollTarget}.valeur.label`)
+      if (formula === "0" || formula === "") {
+        ui.notifications.warn(game.i18n.format("TENEBRIS.Warning.plusDeRessource", { ressource: ressource }))
+        return null
+      }
+    }
+
+    const rollModes = Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))
+    const fieldRollMode = new foundry.data.fields.StringField({
+      choices: rollModes,
+      blank: false,
+      default: "public",
+    })
+
+    const choiceAide = foundry.utils.mergeObject({ 0: "0" }, options.rollValue <= 10 ? { 1: "1" } : { 1: "1", 2: "2" })
+    const choiceGene = {
+      0: "0",
+      "-1": "-1",
+      "-2": "-2",
+      "-3": "-3",
+      "-4": "-4",
+      "-5": "-5",
+      "-6": "-6",
+      "-7": "-7",
+      "-8": "-8",
+      "-9": "-9",
+      "-10": "-10",
+    }
+    const choiceAvantage = { normal: "Normal", avantage: "Avantage", desavantage: "Désavantage", doubleAvantage: "Double avantage", doubleDesavantage: "Double désavantage" }
+    const choiceModificateur = {
+      0: "0",
+      "-1": "-1",
+      "-2": "-2",
+      "-3": "-3",
+      "-4": "-4",
+      "-5": "-5",
+      "-6": "-6",
+      "-7": "-7",
+      "-8": "-8",
+      "-9": "-9",
+      "-10": "-10",
+    }
+
+    let damageDice
+    let damageDiceMax
+    let damageDiceFinal
+    let damageDiceLowered
+
+    // Damage roll : check the roll is not above the maximum damage
+    if (options.rollType === ROLL_TYPE.DAMAGE) {
+      damageDice = options.rollValue
+      damageDiceMax = game.actors.get(options.actorId).system.dmax.valeur
+      damageDiceFinal = CthulhuEternalUtils.maxDamage(damageDice, damageDiceMax)
+      damageDiceLowered = damageDiceFinal !== damageDice
+      // Récupération du nom de l'objet si c'est un jet depuis la fiche de l'acteur
+      // Si c'est via une macro le nom est connu
+      options.rollTarget = game.actors.get(options.actorId).items.get(options.rollTarget).name
+    }
+
+    if (options.rollType === ROLL_TYPE.ATTACK) {
+      damageDice = options.rollValue
+    }
+
+    let malus = "0"
+    let targetMalus = "0"
+    let targetName
+    let targetArmor
+    const displayOpponentMalus = game.settings.get("tenebris", "displayOpponentMalus")
+
+    if (options.rollType === ROLL_TYPE.SAVE && options.hasTarget && options.target.document.actor.type === "opponent") {
+      targetName = options.target.document.actor.name
+      if (displayOpponentMalus) malus = options.target.document.actor.system.malus.toString()
+      else targetMalus = options.target.document.actor.system.malus.toString()
+    }
+
+    if (options.rollType === ROLL_TYPE.DAMAGE && options.hasTarget && options.target.document.actor.type === "opponent") {
+      targetName = options.target.document.actor.name
+      targetArmor = options.target.document.actor.system.armure.toString()
+    }
+
+    let dialogContext = {
+      isSave: options.rollType === ROLL_TYPE.SAVE,
+      isResource: options.rollType === ROLL_TYPE.RESOURCE,
+      isDamage: options.rollType === ROLL_TYPE.DAMAGE,
+      isAttack: options.rollType === ROLL_TYPE.ATTACK,
+      rollModes,
+      fieldRollMode,
+      choiceAide,
+      choiceGene,
+      choiceAvantage,
+      choiceModificateur,
+      damageDice,
+      damageDiceMax,
+      damageDiceFinal,
+      damageDiceLowered,
+      formula,
+      hasTarget: options.hasTarget,
+      malus,
+      targetName,
+      targetArmor,
+      rollAdvantage: this._convertAvantages(options.rollAdvantage),
+      rangeAdvantage: this._convertRollAdvantageToRange(options.rollAdvantage),
+    }
+    const content = await renderTemplate("systems/fvtt-cthulhu-eternal/templates/roll-dialog.hbs", dialogContext)
+
+    const title = CthulhuEternalRoll.createTitle(options.rollType, options.rollTarget)
+    const label = game.i18n.localize("TENEBRIS.Roll.roll")
+    const rollContext = await foundry.applications.api.DialogV2.wait({
+      window: { title: title },
+      classes: ["lethalfantasy"],
+      content,
+      buttons: [
+        {
+          label: label,
+          callback: (event, button, dialog) => {
+            const output = Array.from(button.form.elements).reduce((obj, input) => {
+              if (input.name) obj[input.name] = input.value
+              return obj
+            }, {})
+            // Avantages
+            switch (output.avantages) {
+              case "1":
+                output.avantages = "doubleDesavantage"
+                break
+              case "2":
+                output.avantages = "desavantage"
+                break
+              case "3":
+                output.avantages = "normal"
+                break
+              case "4":
+                output.avantages = "avantage"
+                break
+              case "5":
+                output.avantages = "doubleAvantage"
+                break
+            }
+            return output
+          },
+        },
+      ],
+      rejectClose: false, // Click on Close button will not launch an error
+      render: (event, dialog) => {
+        const rangeInput = dialog.querySelector('input[name="avantages"]')
+        if (rangeInput) {
+          rangeInput.addEventListener("change", (event) => {
+            event.preventDefault()
+            event.stopPropagation()
+            const readOnly = dialog.querySelector('input[name="selectAvantages"]')
+            readOnly.value = this._convertAvantages(event.target.value)
+          })
+        }
+      },
+    })
+
+    // If the user cancels the dialog, exit
+    if (rollContext === null) return
+
+    let treshold
+
+    if (options.rollType === ROLL_TYPE.SAVE) {
+      const aide = rollContext.aide === "" ? 0 : parseInt(rollContext.aide, 10)
+      const gene = rollContext.gene === "" ? 0 : parseInt(rollContext.gene, 10)
+      const modificateur = rollContext.modificateur === "" ? 0 : parseInt(rollContext.modificateur, 10)
+
+      if (options.rollType === ROLL_TYPE.SAVE) {
+        let dice = "1d20"
+        switch (rollContext.avantages) {
+          case "avantage":
+            dice = "2d20kl"
+            break
+          case "desavantage":
+            dice = "2d20kh"
+            break
+          case "doubleAvantage":
+            dice = "3d20kl"
+            break
+          case "doubleDesavantage":
+            dice = "3d20kh"
+            break
+        }
+        formula = `${dice}`
+      }
+
+      treshold = options.rollValue + aide + gene + modificateur
+    }
+
+    // Formula for a damage roll
+    if (options.rollType === ROLL_TYPE.DAMAGE) {
+      formula = damageDiceFinal
+    }
+
+    // Formula for an attack roll
+    if (options.rollType === ROLL_TYPE.ATTACK) {
+      formula = damageDice
+    }
+
+    const rollData = {
+      type: options.rollType,
+      target: options.rollTarget,
+      value: options.rollValue,
+      treshold: treshold,
+      actorId: options.actorId,
+      actorName: options.actorName,
+      actorImage: options.actorImage,
+      rollMode: rollContext.visibility,
+      hasTarget: options.hasTarget,
+      targetName,
+      targetArmor,
+      targetMalus,
+      ...rollContext,
+    }
+
+    /**
+     * A hook event that fires before the roll is made.
+     * @function tenebris.preRoll
+     * @memberof hookEvents
+     * @param {Object} options          Options for the roll.
+     * @param {Object} rollData         All data related to the roll.
+     * @returns {boolean}               Explicitly return `false` to prevent roll to be made.
+     */
+    if (Hooks.call("tenebris.preRoll", options, rollData) === false) return
+
+    const roll = new this(formula, options.data, rollData)
+
+    await roll.evaluate()
+
+    let resultType
+    if (options.rollType === ROLL_TYPE.SAVE) {
+      resultType = roll.total <= treshold ? "success" : "failure"
+    } else if (options.rollType === ROLL_TYPE.RESOURCE) {
+      resultType = roll.total === 1 || roll.total === 2 ? "failure" : "success"
+    }
+
+    let realDamage
+    if (options.rollType === ROLL_TYPE.DAMAGE) {
+      realDamage = Math.max(0, roll.total - parseInt(targetArmor, 10))
+    }
+
+    roll.options.resultType = resultType
+    roll.options.treshold = treshold
+    roll.options.introText = roll._createIntroText()
+    roll.options.introTextTooltip = roll._createIntroTextTooltip()
+    roll.options.realDamage = realDamage
+
+    /**
+     * A hook event that fires after the roll has been made.
+     * @function tenebris.Roll
+     * @memberof hookEvents
+     * @param {Object} options          Options for the roll.
+     * @param {Object} rollData         All data related to the roll.
+      @param {CthulhuEternalRoll} roll        The resulting roll.
+     * @returns {boolean}               Explicitly return `false` to prevent roll to be made.
+     */
+    if (Hooks.call("tenebris.Roll", options, rollData, roll) === false) return
+
+    return roll
+  }
+
+  /**
+   * Creates a title based on the given type.
+   *
+   * @param {string} type The type of the roll.
+   * @param {string} target The target of the roll.
+   * @returns {string} The generated title.
+   */
+  static createTitle(type, target) {
+    switch (type) {
+      case ROLL_TYPE.SAVE:
+        return `${game.i18n.localize("TENEBRIS.Dialog.titleSave")} : ${game.i18n.localize(`TENEBRIS.Manager.${target}`)}`
+      case ROLL_TYPE.RESOURCE:
+        return `${game.i18n.localize("TENEBRIS.Dialog.titleResource")} : ${game.i18n.localize(`TENEBRIS.Manager.${target}`)}`
+      case ROLL_TYPE.DAMAGE:
+        return `${game.i18n.localize("TENEBRIS.Dialog.titleDamage")} : ${target}`
+      case ROLL_TYPE.ATTACK:
+        return `${game.i18n.localize("TENEBRIS.Dialog.titleAttack")} : ${target}`
+      default:
+        return game.i18n.localize("TENEBRIS.Dialog.titleStandard")
+    }
+  }
+
+  /** @override */
+  async render(chatOptions = {}) {
+    let chatData = await this._getChatCardData(chatOptions.isPrivate)
+    return await renderTemplate(this.constructor.CHAT_TEMPLATE, chatData)
+  }
+
+  /**
+   * Generates the data required for rendering a roll chat card.
+   *
+   * @param {boolean} isPrivate Indicates if the chat card is private.
+   * @returns {Promise<Object>} A promise that resolves to an object containing the chat card data.
+   * @property {Array<string>} css - CSS classes for the chat card.
+   * @property {Object} data - The data associated with the roll.
+   * @property {number} diceTotal - The total value of the dice rolled.
+   * @property {boolean} isGM - Indicates if the user is a Game Master.
+   * @property {string} formula - The formula used for the roll.
+   * @property {number} total - The total result of the roll.
+   * @property {boolean} isSave - Indicates if the roll is a saving throw.
+   * @property {boolean} isResource - Indicates if the roll is related to a resource.
+   * @property {boolean} isDamage - Indicates if the roll is for damage.
+   * @property {boolean} isFailure - Indicates if the roll is a failure.
+   * @property {Array} avantages - Advantages associated with the roll.
+   * @property {string} actorId - The ID of the actor performing the roll.
+   * @property {string} actingCharName - The name of the character performing the roll.
+   * @property {string} actingCharImg - The image of the character performing the roll.
+   * @property {string} introText - Introductory text for the roll.
+   * @property {string} introTextTooltip - Tooltip for the introductory text.
+   * @property {string} resultType - The type of result (e.g., success, failure).
+   * @property {boolean} hasTarget - Indicates if the roll has a target.
+   * @property {string} targetName - The name of the target.
+   * @property {number} targetArmor - The armor value of the target.
+   * @property {number} realDamage - The real damage dealt.
+   * @property {boolean} isPrivate - Indicates if the chat card is private.
+   * @property {string} cssClass - The combined CSS classes as a single string.
+   * @property {string} tooltip - The tooltip text for the chat card.
+   */
+  async _getChatCardData(isPrivate) {
+    const cardData = {
+      css: [SYSTEM.id, "dice-roll"],
+      data: this.data,
+      diceTotal: this.dice.reduce((t, d) => t + d.total, 0),
+      isGM: game.user.isGM,
+      formula: this.formula,
+      total: this.total,
+      isSave: this.isSave,
+      isResource: this.isResource,
+      isDamage: this.isDamage,
+      isFailure: this.isFailure,
+      avantages: this.avantages,
+      actorId: this.actorId,
+      actingCharName: this.actorName,
+      actingCharImg: this.actorImage,
+      introText: this.introText,
+      introTextTooltip: this.introTextTooltip,
+      resultType: this.resultType,
+      hasTarget: this.hasTarget,
+      targetName: this.targetName,
+      targetArmor: this.targetArmor,
+      realDamage: this.realDamage,
+      isPrivate: isPrivate,
+    }
+    cardData.cssClass = cardData.css.join(" ")
+    cardData.tooltip = isPrivate ? "" : await this.getTooltip()
+    return cardData
+  }
+
+  /**
+   * Converts the roll result to a chat message.
+   *
+   * @param {Object} [messageData={}] Additional data to include in the message.
+   * @param {Object} options Options for message creation.
+   * @param {string} options.rollMode The mode of the roll (e.g., public, private).
+   * @param {boolean} [options.create=true] Whether to create the message.
+   * @returns {Promise} - A promise that resolves when the message is created.
+   */
+  async toMessage(messageData = {}, { rollMode, create = true } = {}) {
+    super.toMessage(
+      {
+        isSave: this.isSave,
+        isResource: this.isResource,
+        isDamage: this.isDamage,
+        isFailure: this.resultType === "failure",
+        avantages: this.avantages,
+        introText: this.introText,
+        introTextTooltip: this.introTextTooltip,
+        actingCharName: this.actorName,
+        actingCharImg: this.actorImage,
+        hasTarget: this.hasTarget,
+        targetName: this.targetName,
+        targetArmor: this.targetArmor,
+        targetMalus: this.targetMalus,
+        realDamage: this.realDamage,
+        ...messageData,
+      },
+      { rollMode: rollMode },
+    )
+  }
+
+  // Used in the avantages select and with the rollAdvantage parameter: convert the selected value to the corresponding string
+  static _convertAvantages(value) {
+    switch (value) {
+      case "1":
+        return game.i18n.localize("TENEBRIS.Roll.doubleDesavantage")
+      case "2":
+        return game.i18n.localize("TENEBRIS.Roll.desavantage")
+      case "3":
+        return game.i18n.localize("TENEBRIS.Roll.normal")
+      case "4":
+        return game.i18n.localize("TENEBRIS.Roll.avantage")
+      case "5":
+        return game.i18n.localize("TENEBRIS.Roll.doubleAvantage")
+      case "--":
+        return game.i18n.localize("TENEBRIS.Roll.doubleDesavantage")
+      case "-":
+        return game.i18n.localize("TENEBRIS.Roll.desavantage")
+      case "=":
+        return game.i18n.localize("TENEBRIS.Roll.normal")
+      case "+":
+        return game.i18n.localize("TENEBRIS.Roll.avantage")
+      case "++":
+        return game.i18n.localize("TENEBRIS.Roll.doubleAvantage")
+    }
+  }
+
+  // Used in the rollAdvantage parameter: convert the selected value to the corresponding range value
+  static _convertRollAdvantageToRange(value) {
+    switch (value) {
+      case "--":
+        return 1
+      case "-":
+        return 2
+      case "=":
+        return 3
+      case "+":
+        return 4
+      case "++":
+        return 5
+    }
+  }
+}

module/enrichers.mjs

@@ -0,0 +1,80 @@
+/**
+ * Enricher qui permet de transformer un texte en un lien de lancer de dés
+ * Pour une syntaxe de type @jet[x]{y}(z) avec x la caractéristique, y le titre et z l'avantage
+ * x de type rob, dex, int, per, vol pour les caractéristiques
+ * et de type oeil, verbe, san, bourse, magie pour les ressources
+ * y est le titre du jet et permet de décrire l'action
+ * z est l'avantage du jet, avec pour valeurs possibles : --, -, +, ++
+ */
+export function setupTextEnrichers() {
+  CONFIG.TextEditor.enrichers = CONFIG.TextEditor.enrichers.concat([
+    {
+      // eslint-disable-next-line no-useless-escape
+      pattern: /\@jet\[(.+?)\]{(.*?)}\((.*?)\)/gm,
+      enricher: async (match, options) => {
+        const a = document.createElement("a")
+        a.classList.add("ask-roll-journal")
+        const target = match[1]
+        const title = match[2]
+        const avantage = match[3]
+
+        let type = "resource"
+        if (["rob", "dex", "int", "per", "vol"].includes(target)) {
+          type = "save"
+        }
+
+        let rollAvantage = "normal"
+        if (avantage) {
+          switch (avantage) {
+            case "++":
+              rollAvantage = "++"
+              break
+            case "+":
+              rollAvantage = "+"
+              break
+            case "-":
+              rollAvantage = "-"
+              break
+            case "--":
+              rollAvantage = "--"
+              break
+            default:
+              break
+          }
+        }
+
+        a.dataset.rollType = type
+        a.dataset.rollTarget = target
+        a.dataset.rollTitle = title
+        a.dataset.rollAvantage = rollAvantage
+        a.innerHTML = `
+            <i class="fas fa-dice-d20"></i> ${getLibelle(target)}${rollAvantage !== "normal" ? rollAvantage : ""}
+          `
+        return a
+      },
+    },
+  ])
+}
+const mapLibelles = {
+  rob: "ROB",
+  dex: "DEX",
+  int: "INT",
+  per: "PER",
+  vol: "VOL",
+  oeil: "OEIL",
+  verbe: "VERBE",
+  san: "SANTE MENTALE",
+  bourse: "BOURSE",
+  magie: "MAGIE",
+}
+
+/**
+ * Retourne le libellé associé à la valeur qui sera affiché dans le journal
+ * @param {string} value
+ */
+function getLibelle(value) {
+  if (mapLibelles[value]) {
+    return mapLibelles[value]
+  }
+  return null
+}

module/macros.mjs

@@ -0,0 +1,82 @@
+export class Macros {
+  /**
+   * Creates a macro based on the type of data dropped onto the hotbar.
+   *
+   * @param {Object} dropData The data object representing the item dropped.
+   * @param {string} dropData.type The type of the dropped item (e.g., "Actor", "JournalEntry", "roll").
+   * @param {string} dropData.uuid The UUID of the dropped item.
+   * @param {string} [dropData.actorId] The ID of the actor (required if type is "roll").
+   * @param {string} [dropData.rollType] The type of roll (required if type is "roll").
+   * @param {string} [dropData.rollTarget] The target of the roll (required if type is "roll").
+   * @param {string} [dropData.value] The value of the roll (required if type is "roll").
+   * @param {number} slot The hotbar slot where the macro will be created.
+   *
+   * @returns {Promise<void>} A promise that resolves when the macro is created.
+   */
+  static createCthulhuEternalMacro = async function (dropData, slot) {
+    switch (dropData.type) {
+      case "Actor":
+        const actor = await fromUuid(dropData.uuid)
+        const actorCommand = `game.actors.get("${actor.id}").sheet.render(true)`
+        this.createMacro(slot, actor.name, actorCommand, actor.img)
+        break
+
+      case "JournalEntry":
+        const journal = await fromUuid(dropData.uuid)
+        const journalCommand = `game.journal.get("${journal.id}").sheet.render(true)`
+        this.createMacro(slot, journal.name, journalCommand, journal.img ? journal.img : "icons/svg/book.svg")
+        break
+
+      case "roll":
+        const rollCommand =
+          dropData.rollType === "save"
+            ? `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}', '=');`
+            : `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}');`
+        const rollName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${game.i18n.localize(`TENEBRIS.Manager.${dropData.rollTarget}`)}`
+        this.createMacro(slot, rollName, rollCommand, "icons/svg/d20-grey.svg")
+        break
+
+      case "rollDamage":
+        const weapon = game.actors.get(dropData.actorId).items.get(dropData.rollTarget)
+        const rollDamageCommand = `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollType}', '${dropData.rollTarget}');`
+        const rollDamageName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${weapon.name}`
+        this.createMacro(slot, rollDamageName, rollDamageCommand, weapon.img)
+        break
+
+      case "rollAttack":
+        const rollAttackCommand = `game.actors.get('${dropData.actorId}').system.roll('${dropData.rollValue}', '${dropData.rollTarget}');`
+        const rollAttackName = `${game.i18n.localize("TENEBRIS.Label.jet")} ${dropData.rollTarget}`
+        this.createMacro(slot, rollAttackName, rollAttackCommand, "icons/svg/d20-grey.svg")
+        break
+
+      default:
+        // Handle other cases or do nothing
+        break
+    }
+  }
+
+  /**
+   * Create a macro
+   * All macros are flaged with a tenebris.macro flag at true
+   * @param {*} slot
+   * @param {*} name
+   * @param {*} command
+   * @param {*} img
+   */
+  static createMacro = async function (slot, name, command, img) {
+    let macro = game.macros.contents.find((m) => m.name === name && m.command === command)
+    if (!macro) {
+      macro = await Macro.create(
+        {
+          name: name,
+          type: "script",
+          img: img,
+          command: command,
+          flags: { "tenebris.macro": true },
+        },
+        { displaySheet: false },
+      )
+      game.user.assignHotbarMacro(macro, slot)
+    }
+  }
+}

module/models/_module.mjs

@@ -0,0 +1,10 @@
+export { default as CthulhuEternalProtagonist } from "./protagonist.mjs"
+export { default as CthulhuEternalWeapon } from "./weapon.mjs"
+export { default as CthulhuEternalArcane } from "./arcane.mjs"
+export { default as CthulhuEternalSkill } from "./skill.mjs"
+export { default as CthulhuEternalArmor } from "./armor.mjs"
+export { default as CthulhuEternalInjury } from "./injury.mjs"
+export { default as CthulhuEternalMentalDisorder } from "./mentaldisorder.mjs"
+export { default as CthulhuEternalBond } from "./bond.mjs"
+export { default as CthulhuEternalGear } from "./gear.mjs"
+export { default as CthulhuEternalMotivation } from "./motivation.mjs"

module/models/arcane.mjs

@@ -0,0 +1,20 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class CthulhuEternalArcane extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    schema.description = new fields.HTMLField({
+      required: false,
+      blank: true,
+      initial: "",
+      textSearch: true,
+    })
+  
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Arcane"]
+}

module/models/armor.mjs

@@ -0,0 +1,18 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class CthulhuEternalArmor extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.settings = new fields.StringField({ required: true, initial: "common", choices: SYSTEM.AVAILABLE_SETTINGS })
+    schema.protection = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Armor"]
+}

module/models/bond.mjs

@@ -0,0 +1,17 @@
+export default class CthulhuEternalBond extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.bondType = new fields.StringField({ required: true, initial: "individual", choices: SYSTEM.BOND_TYPE })
+    schema.value = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Bond"]
+
+}

module/models/gear.mjs

@@ -0,0 +1,19 @@
+import { SYSTEM } from "../config/system.mjs"
+
+export default class CthulhuEternalEquipment extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.settings = new fields.StringField({ required: true, initial: "common", choices: SYSTEM.AVAILABLE_SETTINGS })
+    schema.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Equipment"]
+
+}

module/models/injury.mjs

@@ -0,0 +1,15 @@
+export default class CthulhuEternalInjury extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Gift"]
+
+}

module/models/mentaldisorder.mjs

@@ -0,0 +1,15 @@
+export default class CthulhuEternalMentalDisorder extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.MentalDisorder"]
+
+}

module/models/motivation.mjs

@@ -0,0 +1,16 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class CthulhuEternalMotivation extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Shield"]
+
+}

module/models/protagonist.mjs

@@ -0,0 +1,120 @@
+import { SYSTEM } from "../config/system.mjs"
+import CthulhuEternalRoll from "../documents/roll.mjs"
+
+export default class CthulhuEternalProtagonist extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const requiredInteger = { required: true, nullable: false, integer: true }
+    const schema = {}
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.notes = new fields.HTMLField({ required: true, textSearch: true })
+
+    // Carac
+    const characteristicField = (label) => {
+      const schema = {
+        value: new fields.NumberField({ ...requiredInteger, initial: 3, min: 0 }),
+        percent: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0, max: 100 }),
+        attackMod: new fields.NumberField({ ...requiredInteger, initial: 0 }),
+        defenseMod: new fields.NumberField({ ...requiredInteger, initial: 0 })
+      }
+      return new fields.SchemaField(schema, { label })
+    }
+
+    schema.characteristics = new fields.SchemaField(
+      Object.values(SYSTEM.CHARACTERISTICS).reduce((obj, characteristic) => {
+        obj[characteristic.id] = characteristicField(characteristic.label)
+        return obj
+      }, {}),
+    )
+
+    schema.hp = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      max: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+    })
+
+    schema.perception = new fields.SchemaField({
+      value: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      bonus: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+    schema.grit = new fields.SchemaField({
+      earned: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      current: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+    schema.luck = new fields.SchemaField({
+      earned: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      current: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+    schema.movement = new fields.SchemaField({
+      walk: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      jog: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      sprint: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      run: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      armorAdjust: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+    })
+    schema.biodata = new fields.SchemaField({
+      class: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      level: new fields.NumberField({ ...requiredInteger, initial: 1, min: 1 }),
+      mortal: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      alignment: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      age: new fields.NumberField({ ...requiredInteger, initial: 15, min: 6 }),
+      height: new fields.NumberField({ ...requiredInteger, initial: 170, min: 50 }),
+      eyes: new fields.StringField({ required: true, nullable: false, initial: "" }),
+      hair: new fields.StringField({ required: true, nullable: false, initial: "" })
+    })
+    schema.developmentPoints = new fields.SchemaField({
+      total: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 }),
+      remaining: new fields.NumberField({ ...requiredInteger, initial: 0, min: 0 })
+    })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Protagonist"]
+
+  /**
+   * Rolls a dice for a character.
+   * @param {("save"|"resource|damage")} rollType The type of the roll.
+   * @param {number} rollTarget The target value for the roll. Which caracteristic or resource. If the roll is a damage roll, this is the id of the item.
+   * @param {"="|"+"|"++"|"-"|"--"} rollAdvantage If there is an avantage (+), a disadvantage (-), a double advantage (++), a double disadvantage (--) or a normal roll (=).
+   * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
+   */
+  async roll(rollType, rollTarget, rollAdvantage = "=") {
+    let rollValue
+    let opponentTarget
+    switch (rollType) {
+      default:
+        // Handle other cases or do nothing
+        break
+    }
+    await this._roll(rollType, rollTarget, rollValue, opponentTarget, rollAdvantage)
+  }
+
+  /**
+   * Rolls a dice for a character.
+   * @param {("save"|"resource|damage")} rollType The type of the roll.
+   * @param {number} rollTarget The target value for the roll. Which caracteristic or resource. If the roll is a damage roll, this is the id of the item.
+   * @param {number} rollValue The value of the roll. If the roll is a damage roll, this is the dice to roll.
+   * @param {Token} opponentTarget The target of the roll : used for save rolls to get the oppponent's malus.
+   * @param {"="|"+"|"++"|"-"|"--"} rollAdvantage If there is an avantage (+), a disadvantage (-), a double advantage (++), a double disadvantage (--) or a normal roll (=).
+   * @returns {Promise<null>} - A promise that resolves to null if the roll is cancelled.
+   */
+  async _roll(rollType, rollTarget, rollValue, opponentTarget = undefined, rollAdvantage = "=") {
+    const hasTarget = opponentTarget !== undefined
+    let roll = await CthulhuEternalRoll.prompt({
+      rollType,
+      rollTarget,
+      rollValue,
+      actorId: this.parent.id,
+      actorName: this.parent.name,
+      actorImage: this.parent.img,
+      hasTarget,
+      target: opponentTarget,
+      rollAdvantage,
+    })
+    if (!roll) return null
+
+    await roll.toMessage({}, { rollMode: roll.options.rollMode })
+  }
+}

module/models/skill.mjs

@@ -0,0 +1,65 @@
+import { SYSTEM } from "../config/system.mjs"
+export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.settings = new fields.StringField({ required: true, initial: "common", choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.base = new fields.StringField({ required: true, initial: "WIS" })
+    schema.bonus = new fields.NumberField({ ...requiredInteger, required: true, initial: 0, min: 0 })
+    schema.diceEvolved = new fields.BooleanField({ required: true, initial: true })
+    schema.rollFailed = new fields.BooleanField({ required: true, initial: false })
+
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Skill"]
+
+  
+  prepareDerivedData() {
+    super.prepareDerivedData();
+    this.skillTotal = this.computeBase();
+  }
+
+  computeBase() {
+    let actor = this.parent?.actor;
+    if (!actor) {
+      return `${this.base  } + ${  String(this.bonus)}`;
+    }
+
+    // Split the base value per stat : WIS,DEX,STR,INT,CHA (example)
+    const base = this.base;
+    let baseSplit = base.split(",");
+    let baseSplitLength = baseSplit.length;
+    if ( baseSplitLength > 0) {
+      // Select the max stat value from the parent actor
+      let maxStat = 0;
+      for (let i = 0; i < baseSplitLength; i++) {
+        const stat = baseSplit[i];
+        const statValue = actor.system.characteristics[stat.toLowerCase()]?.value || 0;
+        if (statValue > maxStat) {
+          maxStat = statValue;
+        }
+      }
+      return maxStat;
+    } else {
+      // Split with +  calculate the total
+      baseSplit = base.split("+");
+      baseSplitLength = baseSplit.length;
+      if ( baseSplitLength > 0) {
+        let total = 0;
+        for (let i = 0; i < baseSplitLength; i++) {
+          const stat = baseSplit[i];
+          const statValue = actor.system.characteristics[stat.toLowerCase()]?.value || 0;
+          total += statValue;
+        }
+        return total
+     }
+    }
+    return `${this.base  } + ${  String(this.bonus)}`;
+  }
+}

module/models/weapon.mjs

@@ -0,0 +1,30 @@
+import { SYSTEM } from "../config/system.mjs"
+
+export default class LethalFantasySkill extends foundry.abstract.TypeDataModel {
+  static defineSchema() {
+    const fields = foundry.data.fields
+    const schema = {}
+    const requiredInteger = { required: true, nullable: false, integer: true }
+
+    schema.description = new fields.HTMLField({ required: true, textSearch: true })
+    schema.settings = new fields.StringField({ required: true, initial: "common", choices: SYSTEM.AVAILABLE_SETTINGS })
+
+    schema.weaponType = new fields.StringField({ required: true, initial: "melee", choices: SYSTEM.WEAPON_TYPE })
+    schema.damage = new fields.StringField({required: true, initial: "1d6"})  
+    schema.baseRange = new fields.StringField({required: true, initial: ""})
+    schema.rangeDistance = new fields.StringField({ required: true, initial: "yard", choices: SYSTEM.WEAPON_RANGE_UNIT })
+    schema.lethality = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    schema.killRadius = new fields.NumberField({ required: true, initial: 0, min: 0 })
+
+    schema.resourceLevel = new fields.NumberField({ required: true, initial: 0, min: 0 })
+    
+    return schema
+  }
+
+  /** @override */
+  static LOCALIZATION_PREFIXES = ["CTHULHUETERNAL.Weapon"]
+
+  get weaponCategory() {
+    return game.i18n.localize(CATEGORY[this.category].label)
+  }
+}

module/socket.mjs

@@ -0,0 +1,32 @@
+
+/**
+ * Handles socket events based on the provided action.
+ *
+ * @param {Object} [params={}] The parameters for the socket event.
+ * @param {string|null} [params.action=null] The action to be performed.
+ * @param {Object} [params.data={}] The data associated with the action.
+ * @returns {*} The result of the action handler, if applicable.
+ */
+export function handleSocketEvent({ action = null, data = {} } = {}) {
+  console.debug("handleSocketEvent", action, data)
+  switch (action) {
+    case "fortune":
+      return CthulhuEternalFortune.handleSocketEvent(data)
+    case "askRoll":
+      return _askRoll(data)
+  }
+}
+
+/**
+ * Handles the socket event to ask for a roll.
+ *
+ * @param {Object} [options={}] The options object.
+ * @param {string} [options.userId] The ID of the user who initiated the roll.
+ */
+export function _askRoll({ userId } = {}) {
+  console.debug(`handleSocketEvent _askRoll from ${userId} !`)
+  const currentUser = game.user._id
+  if (userId === currentUser) {
+    foundry.audio.AudioHelper.play({ src: "/systems/fvtt-cthulhu-eternal/sounds/drums.wav", volume: 0.8, autoplay: true, loop: false }, false)
+  }
+}

module/utils.mjs

@@ -0,0 +1,4 @@
+
+export default class CthulhuEternalUtils {
+
+}

node_modules/.bin/acorn

@@ -0,0 +1 @@
+../acorn/bin/acorn

node_modules/.bin/errno

@@ -0,0 +1 @@
+../errno/cli.js

node_modules/.bin/eslint

@@ -0,0 +1 @@
+../eslint/bin/eslint.js

node_modules/.bin/eslint-config-prettier

@@ -0,0 +1 @@
+../eslint-config-prettier/bin/cli.js

node_modules/.bin/fvtt

@@ -0,0 +1 @@
+../@foundryvtt/foundryvtt-cli/fvtt.mjs

node_modules/.bin/gulp

@@ -0,0 +1 @@
+../gulp/bin/gulp.js

node_modules/.bin/image-size

@@ -0,0 +1 @@
+../image-size/bin/image-size.js

node_modules/.bin/js-yaml

@@ -0,0 +1 @@
+../js-yaml/bin/js-yaml.js

node_modules/.bin/lessc

@@ -0,0 +1 @@
+../less/bin/lessc

node_modules/.bin/mime

@@ -0,0 +1 @@
+../mime/cli.js

node_modules/.bin/mkdirp

@@ -0,0 +1 @@
+../mkdirp/dist/cjs/src/bin.js

node_modules/.bin/needle

@@ -0,0 +1 @@
+../needle/bin/needle

node_modules/.bin/node-gyp-build

@@ -0,0 +1 @@
+../node-gyp-build/bin.js

node_modules/.bin/node-gyp-build-optional

@@ -0,0 +1 @@
+../node-gyp-build/optional.js

node_modules/.bin/node-gyp-build-test

@@ -0,0 +1 @@
+../node-gyp-build/build-test.js

node_modules/.bin/node-which

@@ -0,0 +1 @@
+../which/bin/node-which

node_modules/.bin/prettier

@@ -0,0 +1 @@
+../prettier/bin/prettier.cjs

node_modules/.bin/resolve

@@ -0,0 +1 @@
+../resolve/bin/resolve

node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

node_modules/@es-joy/jsdoccomment/CHANGES.md

@@ -0,0 +1,589 @@
+# CHANGES for `@es-joy/jsdoccomment`
+
+## 0.46.0
+
+- chore: update esquery, drop bundling of types, update devDeps
+
+## 0.45.0
+
+- feat: get following comment (experimental)
+
+## 0.44.0
+
+- feat: add `getNonJsdocComment` for getting non-JSDoc comments above node
+
+## 0.43.1
+
+- fix: for `@template` name parsing, ensure (default-)bracketed name is not broken with internal spaces.
+
+## 0.43.0
+
+This release brings surgical round trip parsing to generated AST and reconstruction of JSDoc comment blocks via: `parseComment` ->
+`commentParserToESTree` -> `estreeToString`.
+
+- feat: new option `spacing` for `commentParserToESTree`; the default is `compact` removing empty description lines.
+Set to `preserve` to retain empty description lines.
+- feat: new properties in the `JsdocBlock` generated AST `delimiterLineBreak` and `preterminalLineBreak` that encode
+any line break after the opening `delimiter` and before the closing `terminal` string. Values are either `\n` or an
+empty string.
+
+- chore: update devDeps / switch to Vitest.
+
+- New [API documentation](https://es-joy.github.io/jsdoccomment/).
+
+Thanks:
+- [@typhonrt](https://github.com/typhonrt)
+
+## 0.42.0
+
+- feat: expand argument for `parseComment` to accept a comment token string ([@typhonrt](https://github.com/typhonrt))
+- chore: update devDeps.
+
+## 0.41.0
+
+- feat: look above surrounding parenthesis tokens for comment blocks, even if on a higher line than the corresponding AST structure
+- chore: update comment-parser and devDeps.
+
+## 0.40.1
+
+- chore(TS): fix path issue
+
+## 0.40.0
+
+- chore: update comment-parser and devDeps.
+- chore(TS): switch to NodeNext
+
+## 0.39.4
+
+- fix: include type exports for full inlineTags (and line) property support on blocks and tags
+
+## 0.39.3
+
+- fix: add type details for Node range and settings
+
+## 0.39.2
+
+- fix: export additional typedefs from index.js
+
+## 0.39.1
+
+- fix: typing export
+
+## 0.39.0
+
+- feat: types for test files and emit declaration files
+- fix(estreeToString): add `JsdodInlineTag` stringify support
+- refactor: lint
+- docs: add `JsdocInlineTag` to README
+- chore: update devDeps.
+
+## 0.38.0
+
+- feat: add parsing inline tags (#12); fixes #11
+
+## 0.37.1
+
+- chore: support Node 20
+- chore: update esquery, devDeps.
+
+## 0.37.0
+## 0.37.0-pre.0
+
+- fix: update `jsdoc-type-pratt-parser` (supports bracket indexes)
+
+## 0.36.1
+
+- fix(`getReducedASTNode`): stop checking for comment blocks at return
+    statement
+
+## 0.36.0
+
+- feat: add `hasPreterminalTagDescription` property
+- fix: avoid description line properties if tag is present
+- fix: ensure description and description lines added to terminal multi-line tag
+
+## 0.35.0
+
+- feat: add `hasPreterminalDescription` property
+- fix: allow newline even for 1st line (after 0th)
+
+## 0.34.0
+
+- feat: add `descriptionStartLine` and `descriptionEndLine` properties
+- fix: avoid duplication with 0 line comments
+- chore: update devDeps.
+
+## 0.33.4
+
+- chore: republish as npm seems to have missed the release
+
+## 0.33.3
+
+- fix: ensure multi-line `description` includes newline except for
+    initial line descriptions
+
+## 0.33.2
+
+- fix: avoid repetition within multi-line descriptions
+
+## 0.33.1
+
+- fix: add to default no types: `description`, `example`, `file`,
+    `fileoverview`, `license`, `overview`, `see`, `summary`
+- fix: add to no names: `file`, `fileoverview, `overview`
+
+## 0.33.0
+
+- chore: add Node 19 to `engines` (@RodEsp)
+- chore: update devDeps. and build file accordingly
+
+## 0.32.0
+
+- feat: have comment checking stop at assignment patterns (comments for
+    defaults should not rise to function itself)
+- chore: bump devDeps.
+
+## 0.31.0
+
+- feat: support default values with `@template` per
+    <https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#template>
+
+## 0.30.0
+
+- chore: bump `jsdoc-type-pratt-parser` and devDeps.
+
+## 0.29.0
+
+- fix: update `engines` as per current `getJSDocComment` behavior
+- chore: update devDeps.
+
+## 0.28.1
+
+- fix(`getReducedASTNode`): token checking
+- build: add Node 18 support (@WikiRik)
+
+## 0.28.0
+
+- chore: bump `engines` to support Node 18
+
+## 0.27.0
+
+- chore: bump `jsdoc-type-pratt-parser` and devDeps.
+
+## 0.26.1
+
+- fix(`estreeToString`): ensure `typeLines` may be picked up
+
+## 0.26.0
+
+- feat(`getJSDocComment`): allow function to detect comments just preceding a
+    parenthesized expression (these have no special AST but their tokens
+    have to be overpassed)
+
+## 0.25.0
+
+- feat(`parseComment`): properly support whitespace
+- fix(`estreeToString`): carriage return placement for ending of JSDoc block
+- fix(`commentParserToESTree`): avoid adding initial space before a tag if on
+    a single line
+- test: make tests more accurate to jsdoc semantically
+
+## 0.24.0
+
+- feat(`estreeToString`): support stringification of `parsedType` but with
+    a new `preferRawType` option allowing the old behavior of using `rawType`
+
+## 0.23.6
+
+- fix(`commentParserToESTree`): ensure `postType` added after multi-line type
+- fix(`estreeToString`): ensure `JsdocTypeLine` stringified with `initial` and
+    that they are joined together with newlines
+
+## 0.23.5
+
+- fix(`commentParserToESTree`): avoid duplicating tag names
+
+## 0.23.4
+
+- fix(`estreeToString`): add `delimiter`, etc. if adding `JsdocDescriptionLine`
+    for `JsdocBlock`
+- fix(`estreeToString`): add line break when tags are present (unless already
+    ending in newline)
+
+## 0.23.3
+
+- fix(`estreeToString`): handle multi-line block descriptions followed by
+    tags with line break
+
+## 0.23.2
+
+- fix: ensure JsdocBlock stringifier has any initial whitespace on end line
+
+## 0.23.1
+
+- docs(README): update
+
+## 0.23.0
+
+- BREAKING CHANGE(`commentParserToESTree`): rename `start` and `end` to
+    `initial` and `terminal` to avoid any conflicts with Acorn-style parsers
+- feat: add `initial` and `terminal` on `JsdocBlock`
+
+## 0.22.2
+
+- fix: preserve type tokens
+- perf: cache tokenizers
+
+## 0.22.1
+
+- fix: ensure `getJSDocComment` does not treat block comments as JSDoc unless
+    their first asterisk is followed by whitespace
+
+## 0.22.0
+
+- fix: update dep. `jsdoc-type-pratt-parser`
+- chore: update `comment-parser` and simplify as possible
+
+## 0.21.2
+
+- fix: only throw if the raw type is not empty
+
+## 0.21.1
+
+- fix: provide clearer error message for `throwOnTypeParsingErrors`
+
+## 0.21.0
+
+- feat: add `throwOnTypeParsingErrors` to receive run-time type parsing errors
+    for `parsedType`
+- chore: update jsdoc-type-pratt-parser and devDeps.; also lints
+
+## 0.20.1
+
+- fix: resume catching bad parsed type (at least until
+    `jsdoc-type-pratt-parser` may support all expected types)
+
+## 0.20.0
+
+- feat: add estree stringifer
+- fix: properly supports `name`/`postName` for multi-line type
+- fix: allow pratt parser to fail (unless empty)
+- fix: don't add tag postDelimiter when on 0 description line
+- fix: avoid adding extra line when only name and no succeeding description
+- docs: clarify re: `kind`
+- test: add `parsedType` with correct mode; add tests
+- chore: updates jsdoc-type-pratt-parser
+- chore: updates devDeps.
+
+## 0.19.0
+
+### User-impacting
+
+- feat: treat `@kind` as having no name
+
+### Dev-impacting
+
+- docs: jsdoc
+- test: begin checking `jsdoccomment`
+- test: adds lcov reporter and open script for it
+- chore: update devDeps.
+
+## 0.18.0
+
+### User-impacting
+
+- feat: add non-visitable `endLine` property (so can detect line number
+    when no description present)
+- feat: supply `indent` default for `parseComment`
+- fix: ensure `postName` gets a space for `@template` with a description
+- fix: converting JSDoc comment with tag on same line as end (e.g., single
+    line) to AST
+- chore: update `jsdoc-type-pratt-parser`
+
+### Dev-impacting
+
+- docs: add jsdoc blocks internally
+- chore: update devDeps.
+- test: avoid need for `expect`
+- test: complete coverage for `commentHandler`, `parseComment` tests
+
+## 0.17.0
+
+### User-impacting
+
+- Enhancement: Re-export `jsdoc-type-pratt-parser`
+- Update: `jsdoc-type-pratt-parser` to 2.2.1
+
+### Dev-impacting
+
+- npm: Update devDeps.
+
+## 0.16.0
+
+### User-impacting
+
+- Update: `jsdoc-type-pratt-parser` to 2.2.0
+
+### Dev-impacting
+
+- npm: Update devDeps.
+
+## 0.15.0
+
+### User-impacting
+
+- Update: `jsdoc-type-pratt-parser` to 2.1.0
+
+### Dev-impacting
+
+- npm: Update devDeps.
+
+## 0.14.2
+
+### User-impacting
+
+- Fix: Find comments previous to parentheses (used commonly in TypeScript)
+
+### Dev-impacting
+
+- npm: Update devDeps.
+
+## 0.14.1
+
+### User-impacting
+
+- Update: `jsdoc-type-pratt-parser` to 2.0.2
+
+## 0.14.0
+
+### User-impacting
+
+- Update: `jsdoc-type-pratt-parser` to 2.0.1
+
+### Dev-impacting
+
+- npm: Update devDeps.
+
+## 0.13.0
+
+### User-impacting
+
+- Update: `comment-parser` to 1.3.0
+- Fix: Allow comment on `ExportDefaultDeclaration`
+
+## 0.12.0
+
+### User-impacting
+
+- Update: `jsdoc-type-pratt-parser` to 2.0.0
+- Enhancement: Support Node 17 (@timgates42)
+- Docs: Typo (@timgates42)
+
+### Dev-impacting
+
+- Linting: As per latest ash-nazg
+- npm: Update devDeps.
+
+## 0.11.0
+
+- Update: For `@typescript/eslint-parser@5`, add `PropertyDefinition`
+
+## 0.10.8
+
+### User-impacting
+
+- npm: Liberalize `engines` as per `comment-parser` change
+- npm: Bump `comment-parser`
+
+### Dev-impacting
+
+- Linting: As per latest ash-nazg
+- npm: Update devDeps.
+
+## 0.10.7
+
+- npm: Update comment-parser with CJS fix and re-exports
+- npm: Update devDeps.
+
+## 0.10.6
+
+- Fix: Ensure copying latest build of `comment-parser`'s ESM utils
+
+## 0.10.5
+
+- npm: Bump fixed `jsdoc-type-pratt-parser` and devDeps.
+
+## 0.10.4
+
+- Fix: Bundle `comment-parser` nested imports so that IDEs (like Atom)
+    bundling older Node versions can still work. Still mirroring the
+    stricter `comment-parser` `engines` for now, however.
+
+## 0.10.3
+
+- npm: Avoid exporting nested subpaths for sake of older Node versions
+
+## 0.10.2
+
+- npm: Specify exact supported range: `^12.20 || ^14.14.0 || ^16`
+
+## 0.10.1
+
+- npm: Apply patch version of `comment-parser`
+
+## 0.10.0
+
+- npm: Point to stable `comment-parser`
+
+## 0.9.0-alpha.6
+
+### User-impacting
+
+- Update: For `comment-parser` update, add `lineEnd`
+
+## 0.9.0-alpha.5
+
+### User-impacting
+
+- npm: Bump `comment-parser` (for true ESM)
+- Update: Remove extensions for packages for native ESM in `comment-parser` fix
+
+### Dev-impacting
+
+- npm: Update devDeps.
+
+## 0.9.0-alpha.4
+
+- Docs: Update repo info in `package.json`
+
+## 0.9.0-alpha.3
+
+- Fix: Due to `comment-parser` still needing changes, revert for now to alpha.1
+
+## 0.9.0-alpha.2
+
+### User-impacting
+
+- npm: Bump `comment-parser` (for true ESM)
+- Update: Remove extensions for packages for native ESM in `comment-parser` fix
+
+### Dev-impacting
+
+- npm: Update devDeps.
+
+## 0.9.0-alpha.1
+
+### User-impacting
+
+- Breaking change: Indicate minimum for `engines` as Node >= 12
+- npm: Bump `comment-parser`
+
+### Dev-impacting
+
+- npm: Lint cjs files
+- npm: Fix eslint script
+- npm: Update devDeps.
+
+## 0.8.0
+
+### User-impacting
+
+- npm: Update `jsdoc-type-pratt-parser` (prerelease to stable patch)
+
+### Dev-impacting
+
+- npm: Update devDeps.
+
+## 0.8.0-alpha.2
+
+- Fix: Avoid erring with missing `typeLines`
+
+## 0.8.0-alpha.1
+
+- Breaking change: Export globally as `JsdocComment`
+- Breaking change: Change `JSDoc` prefixes of all node types to `Jsdoc`
+- Breaking change: Drop `jsdoctypeparserToESTree`
+- Breaking enhancement: Switch to `jsdoc-type-pratt-parser` (toward greater
+    TypeScript expressivity and compatibility/support with catharsis)
+- Enhancement: Export `jsdocTypeVisitorKeys` (from `jsdoc-type-pratt-parser`)
+
+## 0.7.2
+
+- Fix: Add `@description` to `noNames`
+
+## 0.7.1
+
+- Fix: Add `@summary` to `noNames`
+
+## 0.7.0
+
+- Enhancement: Allow specifying `noNames` and `noTypes` on `parseComment`
+    to override (or add to) tags which should have no names or types.
+- Enhancement: Export `hasSeeWithLink` utility and `defaultNoTypes` and
+    `defaultNoNames`.
+
+## 0.6.0
+
+- Change `comment-parser` `tag` AST to avoid initial `@`
+
+## 0.5.1
+
+- Fix: Avoid setting `variation` name (just the description) (including in
+    dist)
+- npm: Add `prepublishOnly` script
+
+## 0.5.0
+
+- Fix: Avoid setting `variation` name (just the description)
+
+## 0.4.4
+
+- Fix: Avoid setting `name` and `description` for simple `@template SomeName`
+
+## 0.4.3
+
+- npm: Ignores Github file
+
+## 0.4.2
+
+- Fix: Ensure replacement of camel-casing (used in `jsdoctypeparser` nodes and
+    visitor keys is global. The practical effect is that
+    `JSDocTypeNamed_parameter` -> `JSDocTypeNamedParameter`,
+    `JSDocTypeRecord_entry` -> `JSDocTypeRecordEntry`
+    `JSDocTypeNot_nullable` -> `JSDocTypeNotNullable`
+    `JSDocTypeInner_member` -> `JSDocTypeInnerMember`
+    `JSDocTypeInstance_member` -> `JSDocTypeInstanceMember`
+    `JSDocTypeString_value` -> `JSDocTypeStringValue`
+    `JSDocTypeNumber_value` -> `JSDocTypeNumberValue`
+    `JSDocTypeFile_path` -> `JSDocTypeFilePath`
+    `JSDocTypeType_query` -> `JSDocTypeTypeQuery`
+    `JSDocTypeKey_query` -> `JSDocTypeKeyQuery`
+- Fix: Add missing `JSDocTypeLine` to visitor keys
+- Docs: Explain AST structure/differences
+
+## 0.4.1
+
+- Docs: Indicate available methods with brief summary on README
+
+## 0.4.0
+
+- Enhancement: Expose `parseComment` and `getTokenizers`.
+
+## 0.3.0
+
+- Enhancement: Expose `toCamelCase` as new method rather than within a
+    utility file.
+
+## 0.2.0
+
+- Enhancement: Exposes new methods: `commentHandler`,
+    `commentParserToESTree`, `jsdocVisitorKeys`, `jsdoctypeparserToESTree`,
+    `jsdocTypeVisitorKeys`,
+
+## 0.1.1
+
+- Build: Add Babel to work with earlier Node
+
+## 0.1.0
+
+- Initial version

node_modules/@es-joy/jsdoccomment/LICENSE-MIT.txt

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors, https://js.foundation
+Copyright (c) 2021 Brett Zamir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@es-joy/jsdoccomment/README.md

@@ -0,0 +1,241 @@
+# @es-joy/jsdoccomment
+
+[![NPM](https://img.shields.io/npm/v/@es-joy/jsdoccomment.svg?label=npm)](https://www.npmjs.com/package/@es-joy/jsdoccomment)
+[![License](https://img.shields.io/badge/license-MIT-yellowgreen.svg?style=flat)](https://github.com/es-joy/jsdoccomment/blob/main/LICENSE-MIT.txt)
+[![Build Status](https://github.com/es-joy/jsdoccomment/workflows/CI/CD/badge.svg)](#)
+[![API Docs](https://img.shields.io/badge/API%20Documentation-476ff0)](https://es-joy.github.io/jsdoccomment/)
+
+
+This project aims to preserve and expand upon the
+`SourceCode#getJSDocComment` functionality of the deprecated ESLint method.
+
+It also exports a number of functions currently for working with JSDoc:
+
+## API
+
+### `parseComment`
+
+For parsing `comment-parser` in a JSDoc-specific manner.
+Might wish to have tags with or without tags, etc. derived from a split off
+JSON file.
+
+### `commentParserToESTree`
+
+Converts [comment-parser](https://github.com/syavorsky/comment-parser)
+AST to ESTree/ESLint/Babel friendly AST. See the "ESLint AST..." section below.
+
+### `estreeToString`
+
+Stringifies. In addition to the node argument, it accepts an optional second
+options object with a single `preferRawType` key. If you don't need to modify
+JSDoc type AST, you might wish to set this to `true` to get the benefits of
+preserving the raw form, but for AST-based stringification of JSDoc types,
+keep it `false` (the default).
+
+### `jsdocVisitorKeys`
+
+The [VisitorKeys](https://github.com/eslint/eslint-visitor-keys)
+for `JsdocBlock`, `JsdocDescriptionLine`, and `JsdocTag`. More likely to be
+subject to change or dropped in favor of another type parser.
+
+### `jsdocTypeVisitorKeys`
+
+Just a re-export of [VisitorKeys](https://github.com/eslint/eslint-visitor-keys)
+from [`jsdoc-type-pratt-parser`](https://github.com/simonseyock/jsdoc-type-pratt-parser/).
+
+### `getDefaultTagStructureForMode`
+
+Provides info on JSDoc tags:
+
+- `nameContents` ('namepath-referencing'|'namepath-defining'|
+    'dual-namepath-referencing'|false) - Whether and how a name is allowed
+    following any type. Tags without a proper name (value `false`) may still
+    have a description (which can appear like a name); `descriptionAllowed`
+    in such cases would be `true`.
+    The presence of a truthy `nameContents` value is therefore only intended
+    to signify whether separate parsing should occur for a name vs. a
+    description, and what its nature should be.
+- `nameRequired` (boolean) - Whether a name must be present following any type.
+- `descriptionAllowed` (boolean) - Whether a description (following any name)
+    is allowed.
+- `typeAllowed` (boolean) - Whether the tag accepts a curly bracketed portion.
+    Even without a type, a tag may still have a name and/or description.
+- `typeRequired` (boolean) - Whether a curly bracketed type must be present.
+- `typeOrNameRequired` (boolean) - Whether either a curly bracketed type is
+    required or a name, but not necessarily both.
+
+### Miscellaneous
+
+Also currently exports these utilities:
+
+- `getTokenizers` - Used with `parseComment` (its main core).
+- `hasSeeWithLink` - A utility to detect if a tag is `@see` and has a `@link`.
+- `commentHandler` - Used by `eslint-plugin-jsdoc`.
+- `commentParserToESTree`- Converts [comment-parser](https://github.com/syavorsky/comment-parser)
+    AST to ESTree/ESLint/Babel friendly AST.
+- `jsdocVisitorKeys` - The [VisitorKeys](https://github.com/eslint/eslint-visitor-keys)
+    for `JSDocBlock`, `JSDocDescriptionLine`, and `JSDocTag`.
+- `jsdocTypeVisitorKeys` - [VisitorKeys](https://github.com/eslint/eslint-visitor-keys)
+    for `jsdoc-type-pratt-parser`.
+- `defaultNoTypes` = The tags which allow no types by default:
+    `default`, `defaultvalue`, `description`, `example`, `file`,
+    `fileoverview`, `license`, `overview`, `see`, `summary`
+- `defaultNoNames` - The tags which allow no names by default:
+    `access`, `author`, `default`, `defaultvalue`, `description`, `example`,
+    `exception`, `file`, `fileoverview`, `kind`, `license`, `overview`,
+    `return`, `returns`, `since`, `summary`, `throws`, `version`, `variation`
+
+## ESLint AST produced for `comment-parser` nodes (`JsdocBlock`, `JsdocTag`, and `JsdocDescriptionLine`)
+
+Note: Although not added in this package, `@es-joy/jsdoc-eslint-parser` adds
+a `jsdoc` property to other ES nodes (using this project's `getJSDocComment`
+to determine the specific comment-block that will be attached as AST).
+
+### `JsdocBlock`
+
+Has the following visitable properties:
+
+1. `descriptionLines` (an array of `JsdocDescriptionLine` for multiline
+    descriptions).
+2. `tags` (an array of `JsdocTag`; see below)
+3. `inlineTags` (an array of `JsdocInlineTag`; see below)
+
+Has the following custom non-visitable property:
+
+1. `delimiterLineBreak` - A string containing any line break after `delimiter`.
+2. `lastDescriptionLine` - A number
+3. `endLine` - A number representing the line number with `end`/`terminal`
+4. `descriptionStartLine` - A 0+ number indicating the line where any
+    description begins
+5. `descriptionEndLine` - A 0+ number indicating the line where the description
+    ends
+6. `hasPreterminalDescription` - Set to 0 or 1. On if has a block description
+    on the same line as the terminal `*/`.
+7. `hasPreterminalTagDescription` - Set to 0 or 1. On if has a tag description
+    on the same line as the terminal `*/`.
+8. `preterminalLineBreak` - A string containing any line break before `terminal`.
+
+May also have the following non-visitable properties from `comment-parser`:
+
+1. `description` - Same as `descriptionLines` but as a string with newlines.
+2. `delimiter`
+3. `postDelimiter`
+4. `lineEnd`
+5. `initial` (from `start`)
+6. `terminal` (from `end`)
+
+### `JsdocTag`
+
+Has the following visitable properties:
+
+1. `parsedType` (the `jsdoc-type-pratt-parser` AST representation of the tag's
+    type (see the `jsdoc-type-pratt-parser` section below)).
+2. `typeLines` (an array of `JsdocTypeLine` for multiline type strings)
+3. `descriptionLines` (an array of `JsdocDescriptionLine` for multiline
+    descriptions)
+4. `inlineTags` (an array of `JsdocInlineTag`)
+
+May also have the following non-visitable properties from `comment-parser`
+(note that all are included from `comment-parser` except `end` as that is only
+for JSDoc blocks and note that `type` is renamed to `rawType` and `start` to
+`initial`):
+
+1. `description` - Same as `descriptionLines` but as a string with newlines.
+2. `rawType` - `comment-parser` has this named as `type`, but because of a
+    conflict with ESTree using `type` for Node type, we renamed it to
+    `rawType`. It is otherwise the same as in `comment-parser`, i.e., a string
+    with newlines, though with the initial `{` and final `}` stripped out.
+    See `typeLines` for the array version of this property.
+3. `initial` - Renamed from `start` to avoid potential conflicts with
+    Acorn-style parser processing tools
+4. `delimiter`
+5. `postDelimiter`
+6. `tag` (this does differ from `comment-parser` now in terms of our stripping
+    the initial `@`)
+7. `postTag`
+8. `name`
+9. `postName`
+10. `postType`
+
+### `JsdocDescriptionLine`
+
+No visitable properties.
+
+May also have the following non-visitable properties from `comment-parser`:
+
+1. `delimiter`
+2. `postDelimiter`
+3. `initial` (from `start`)
+4. `description`
+
+### `JsdocTypeLine`
+
+No visitable properties.
+
+May also have the following non-visitable properties from `comment-parser`:
+
+1. `delimiter`
+2. `postDelimiter`
+3. `initial` (from `start`)
+4. `rawType` - Renamed from `comment-parser` to avoid a conflict. See
+    explanation under `JsdocTag`
+
+### `JsdocInlineTag`
+
+No visitable properties.
+
+Has the following non-visitable properties:
+
+1. `format`: 'pipe' | 'plain' | 'prefix' | 'space'. These follow the styles of [link](https://jsdoc.app/tags-inline-link.html) or [tutorial](https://jsdoc.app/tags-inline-tutorial.html).
+    1. `pipe`: `{@link namepathOrURL|link text}`
+    2. `plain`: `{@link namepathOrURL}`
+    3. `prefix`: `[link text]{@link namepathOrURL}`
+    4. `space`: `{@link namepathOrURL link text (after the first space)}`
+2. `namepathOrURL`: string
+3. `tag`: string. The standard allows `tutorial` or `link`
+4. `text`: string
+
+## ESLint AST produced for `jsdoc-type-pratt-parser`
+
+The AST, including `type`, remains as is from [jsdoc-type-pratt-parser](https://github.com/simonseyock/jsdoc-type-pratt-parser/).
+
+The type will always begin with a `JsdocType` prefix added, along with a
+camel-cased type name, e.g., `JsdocTypeUnion`.
+
+The `jsdoc-type-pratt-parser` visitor keys are also preserved without change.
+
+You can get a sense of the structure of these types using the parser's
+[tester](https://jsdoc-type-pratt-parser.github.io/jsdoc-type-pratt-parser/).
+
+## Installation
+
+```shell
+npm i @es-joy/jsdoccomment
+```
+
+## Changelog
+
+The changelog can be found on the [CHANGES.md](https://github.com/es-joy/jsdoccomment/blob/main/CHANGES.md).
+<!--## Contributing
+
+Everyone is welcome to contribute. Please take a moment to review the [contributing guidelines](CONTRIBUTING.md).
+-->
+## Authors and license
+
+[Brett Zamir](http://brett-zamir.me/) and
+[contributors](https://github.com/es-joy/jsdoccomment/graphs/contributors).
+
+MIT License, see the included [LICENSE-MIT.txt](https://github.com/es-joy/jsdoccomment/blob/main/LICENSE-MIT.txt) file.
+
+## To-dos
+
+1. Get complete code coverage
+1. Given that `esquery` expects a `right` property to search for `>` (the
+    child selector), we should perhaps insist, for example, that params are
+    the child property for `JsdocBlock` or such. Where `:has()` is currently
+    needed, one could thus instead just use `>`.
+1. Might add `trailing` for `JsdocBlock` to know whether it is followed by a
+    line break or what not; `comment-parser` does not provide, however
+1. Fix and properly utilize `indent` argument (challenging for
+    `eslint-plugin-jsdoc` but needed for `jsdoc-eslint-parser` stringifiers
+    to be more faithful); should also then use the proposed `trailing` as well

node_modules/@es-joy/jsdoccomment/dist/index.d.ts

@@ -0,0 +1,361 @@
+import * as comment_parser from 'comment-parser';
+import * as jsdoc_type_pratt_parser from 'jsdoc-type-pratt-parser';
+export * from 'jsdoc-type-pratt-parser';
+export { visitorKeys as jsdocTypeVisitorKeys } from 'jsdoc-type-pratt-parser';
+import * as _typescript_eslint_types from '@typescript-eslint/types';
+import * as estree from 'estree';
+import * as eslint from 'eslint';
+
+type JsdocTypeLine = {
+  delimiter: string;
+  postDelimiter: string;
+  rawType: string;
+  initial: string;
+  type: 'JsdocTypeLine';
+};
+type JsdocDescriptionLine = {
+  delimiter: string;
+  description: string;
+  postDelimiter: string;
+  initial: string;
+  type: 'JsdocDescriptionLine';
+};
+type JsdocInlineTagNoType = {
+  format: 'pipe' | 'plain' | 'prefix' | 'space';
+  namepathOrURL: string;
+  tag: string;
+  text: string;
+};
+type JsdocInlineTag = JsdocInlineTagNoType & {
+  type: 'JsdocInlineTag';
+};
+type JsdocTag = {
+  delimiter: string;
+  description: string;
+  descriptionLines: JsdocDescriptionLine[];
+  initial: string;
+  inlineTags: JsdocInlineTag[];
+  name: string;
+  postDelimiter: string;
+  postName: string;
+  postTag: string;
+  postType: string;
+  rawType: string;
+  parsedType: jsdoc_type_pratt_parser.RootResult | null;
+  tag: string;
+  type: 'JsdocTag';
+  typeLines: JsdocTypeLine[];
+};
+type Integer = number;
+type JsdocBlock = {
+  delimiter: string;
+  delimiterLineBreak: string;
+  description: string;
+  descriptionEndLine?: Integer;
+  descriptionLines: JsdocDescriptionLine[];
+  descriptionStartLine?: Integer;
+  hasPreterminalDescription: 0 | 1;
+  hasPreterminalTagDescription?: 1;
+  initial: string;
+  inlineTags: JsdocInlineTag[];
+  lastDescriptionLine?: Integer;
+  endLine: Integer;
+  lineEnd: string;
+  postDelimiter: string;
+  tags: JsdocTag[];
+  terminal: string;
+  preterminalLineBreak: string;
+  type: 'JsdocBlock';
+};
+/**
+ * Converts comment parser AST to ESTree format.
+ * @param {import('.').JsdocBlockWithInline} jsdoc
+ * @param {import('jsdoc-type-pratt-parser').ParseMode} mode
+ * @param {object} opts
+ * @param {'compact'|'preserve'} [opts.spacing] By default, empty lines are
+ *        compacted; set to 'preserve' to preserve empty comment lines.
+ * @param {boolean} [opts.throwOnTypeParsingErrors]
+ * @returns {JsdocBlock}
+ */
+declare function commentParserToESTree(
+  jsdoc: JsdocBlockWithInline,
+  mode: jsdoc_type_pratt_parser.ParseMode,
+  {
+    spacing,
+    throwOnTypeParsingErrors,
+  }?: {
+    spacing?: 'compact' | 'preserve';
+    throwOnTypeParsingErrors?: boolean;
+  },
+): JsdocBlock;
+declare namespace jsdocVisitorKeys {
+  let JsdocBlock: string[];
+  let JsdocDescriptionLine: any[];
+  let JsdocTypeLine: any[];
+  let JsdocTag: string[];
+  let JsdocInlineTag: any[];
+}
+
+/**
+ * @param {{[name: string]: any}} settings
+ * @returns {import('.').CommentHandler}
+ */
+declare function commentHandler(settings: { [name: string]: any }): CommentHandler;
+
+/**
+ * @todo convert for use by escodegen (until may be patched to support
+ *   custom entries?).
+ * @param {import('./commentParserToESTree').JsdocBlock|
+ *   import('./commentParserToESTree').JsdocDescriptionLine|
+ *   import('./commentParserToESTree').JsdocTypeLine|
+ *   import('./commentParserToESTree').JsdocTag|
+ *   import('./commentParserToESTree').JsdocInlineTag|
+ *   import('jsdoc-type-pratt-parser').RootResult
+ * } node
+ * @param {import('.').ESTreeToStringOptions} opts
+ * @throws {Error}
+ * @returns {string}
+ */
+declare function estreeToString(
+  node:
+    | JsdocBlock
+    | JsdocDescriptionLine
+    | JsdocTypeLine
+    | JsdocTag
+    | JsdocInlineTag
+    | jsdoc_type_pratt_parser.RootResult,
+  opts?: ESTreeToStringOptions,
+): string;
+
+type Token =
+  | eslint.AST.Token
+  | estree.Comment
+  | {
+      type: eslint.AST.TokenType | 'Line' | 'Block' | 'Shebang';
+      range: [number, number];
+      value: string;
+    };
+type ESLintOrTSNode = eslint.Rule.Node | _typescript_eslint_types.TSESTree.Node;
+type int = number;
+/**
+ * Reduces the provided node to the appropriate node for evaluating
+ * JSDoc comment status.
+ *
+ * @param {ESLintOrTSNode} node An AST node.
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode.
+ * @returns {ESLintOrTSNode} The AST node that
+ *   can be evaluated for appropriate JSDoc comments.
+ */
+declare function getReducedASTNode(node: ESLintOrTSNode, sourceCode: eslint.SourceCode): ESLintOrTSNode;
+/**
+ * Retrieves the JSDoc comment for a given node.
+ *
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode
+ * @param {import('eslint').Rule.Node} node The AST node to get
+ *   the comment for.
+ * @param {{maxLines: int, minLines: int, [name: string]: any}} settings The
+ *   settings in context
+ * @returns {Token|null} The Block comment
+ *   token containing the JSDoc comment for the given node or
+ *   null if not found.
+ * @public
+ */
+declare function getJSDocComment(
+  sourceCode: eslint.SourceCode,
+  node: eslint.Rule.Node,
+  settings: {
+    maxLines: int;
+    minLines: int;
+    [name: string]: any;
+  },
+): Token | null;
+/**
+ * Retrieves the comment preceding a given node.
+ *
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode
+ * @param {ESLintOrTSNode} node The AST node to get
+ *   the comment for.
+ * @param {{maxLines: int, minLines: int, [name: string]: any}} settings The
+ *   settings in context
+ * @returns {Token|null} The Block comment
+ *   token containing the JSDoc comment for the given node or
+ *   null if not found.
+ * @public
+ */
+declare function getNonJsdocComment(
+  sourceCode: eslint.SourceCode,
+  node: ESLintOrTSNode,
+  settings: {
+    maxLines: int;
+    minLines: int;
+    [name: string]: any;
+  },
+): Token | null;
+/**
+ * @param {(ESLintOrTSNode|import('estree').Comment) & {
+ *   declaration?: any,
+ *   decorators?: any[],
+ *   parent?: import('eslint').Rule.Node & {
+ *     decorators?: any[]
+ *   }
+ * }} node
+ * @returns {import('@typescript-eslint/types').TSESTree.Decorator|undefined}
+ */
+declare function getDecorator(
+  node: (ESLintOrTSNode | estree.Comment) & {
+    declaration?: any;
+    decorators?: any[];
+    parent?: eslint.Rule.Node & {
+      decorators?: any[];
+    };
+  },
+): _typescript_eslint_types.TSESTree.Decorator | undefined;
+/**
+ * Checks for the presence of a JSDoc comment for the given node and returns it.
+ *
+ * @param {ESLintOrTSNode} astNode The AST node to get
+ *   the comment for.
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {{maxLines: int, minLines: int, [name: string]: any}} settings
+ * @param {{nonJSDoc?: boolean}} [opts]
+ * @returns {Token|null} The Block comment token containing the JSDoc comment
+ *    for the given node or null if not found.
+ */
+declare function findJSDocComment(
+  astNode: ESLintOrTSNode,
+  sourceCode: eslint.SourceCode,
+  settings: {
+    maxLines: int;
+    minLines: int;
+    [name: string]: any;
+  },
+  opts?: {
+    nonJSDoc?: boolean;
+  },
+): Token | null;
+/**
+ * Checks for the presence of a comment following the given node and
+ * returns it.
+ *
+ * This method is experimental.
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {ESLintOrTSNode} astNode The AST node to get
+ *   the comment for.
+ * @returns {Token|null} The comment token containing the comment
+ *    for the given node or null if not found.
+ */
+declare function getFollowingComment(sourceCode: eslint.SourceCode, astNode: ESLintOrTSNode): Token | null;
+
+declare function hasSeeWithLink(spec: comment_parser.Spec): boolean;
+declare const defaultNoTypes: string[];
+declare const defaultNoNames: string[];
+/**
+ * Can't import `comment-parser/es6/parser/tokenizers/index.js`,
+ *   so we redefine here.
+ */
+type CommentParserTokenizer = (spec: comment_parser.Spec) => comment_parser.Spec;
+/**
+ * Can't import `comment-parser/es6/parser/tokenizers/index.js`,
+ *   so we redefine here.
+ * @typedef {(spec: import('comment-parser').Spec) =>
+ *   import('comment-parser').Spec} CommentParserTokenizer
+ */
+/**
+ * @param {object} [cfg]
+ * @param {string[]} [cfg.noTypes]
+ * @param {string[]} [cfg.noNames]
+ * @returns {CommentParserTokenizer[]}
+ */
+declare function getTokenizers({
+  noTypes,
+  noNames,
+}?: {
+  noTypes?: string[];
+  noNames?: string[];
+}): CommentParserTokenizer[];
+/**
+ * Accepts a comment token or complete comment string and converts it into
+ * `comment-parser` AST.
+ * @param {string | {value: string}} commentOrNode
+ * @param {string} [indent] Whitespace
+ * @returns {import('.').JsdocBlockWithInline}
+ */
+declare function parseComment(
+  commentOrNode:
+    | string
+    | {
+        value: string;
+      },
+  indent?: string,
+): JsdocBlockWithInline;
+
+/**
+ * Splits the `{@prefix}` from remaining `Spec.lines[].token.description`
+ * into the `inlineTags` tokens, and populates `spec.inlineTags`
+ * @param {import('comment-parser').Block} block
+ * @returns {import('.').JsdocBlockWithInline}
+ */
+declare function parseInlineTags(block: comment_parser.Block): JsdocBlockWithInline;
+
+type InlineTag = JsdocInlineTagNoType & {
+  start: number;
+  end: number;
+};
+type JsdocTagWithInline = comment_parser.Spec & {
+  line?: Integer;
+  inlineTags: (JsdocInlineTagNoType & {
+    line?: Integer;
+  })[];
+};
+/**
+ * Expands on comment-parser's `Block` interface.
+ */
+type JsdocBlockWithInline = {
+  description: string;
+  source: comment_parser.Line[];
+  problems: comment_parser.Problem[];
+  tags: JsdocTagWithInline[];
+  inlineTags: (JsdocInlineTagNoType & {
+    line?: Integer;
+  })[];
+};
+type ESTreeToStringOptions = {
+  preferRawType?: boolean;
+};
+type CommentHandler = (commentSelector: string, jsdoc: JsdocBlockWithInline) => boolean;
+
+export {
+  type CommentHandler,
+  type CommentParserTokenizer,
+  type ESLintOrTSNode,
+  type ESTreeToStringOptions,
+  type InlineTag,
+  type Integer,
+  JsdocBlock,
+  type JsdocBlockWithInline,
+  JsdocDescriptionLine,
+  JsdocInlineTag,
+  type JsdocInlineTagNoType,
+  JsdocTag,
+  type JsdocTagWithInline,
+  JsdocTypeLine,
+  type Token,
+  commentHandler,
+  commentParserToESTree,
+  defaultNoNames,
+  defaultNoTypes,
+  estreeToString,
+  findJSDocComment,
+  getDecorator,
+  getFollowingComment,
+  getJSDocComment,
+  getNonJsdocComment,
+  getReducedASTNode,
+  getTokenizers,
+  hasSeeWithLink,
+  type int,
+  jsdocVisitorKeys,
+  parseComment,
+  parseInlineTags,
+};

node_modules/@es-joy/jsdoccomment/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@es-joy/jsdoccomment",
+  "version": "0.46.0",
+  "author": "Brett Zamir <brettz9@yahoo.com>",
+  "contributors": [],
+  "description": "Maintained replacement for ESLint's deprecated SourceCode#getJSDocComment along with other jsdoc utilities",
+  "license": "MIT",
+  "keywords": [
+    "ast",
+    "comment",
+    "estree",
+    "jsdoc",
+    "parser",
+    "eslint",
+    "sourcecode"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./src/index.js",
+    "require": "./dist/index.cjs.cjs"
+  },
+  "browserslist": [
+    "cover 100%"
+  ],
+  "typedocOptions": {
+    "dmtLinksService": {
+      "GitHub": "https://github.com/es-joy/jsdoccomment",
+      "NPM": "https://www.npmjs.com/package/@es-joy/jsdoccomment"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/es-joy/jsdoccomment.git"
+  },
+  "bugs": {
+    "url": "https://github.com/es-joy/jsdoccomment/issues"
+  },
+  "homepage": "https://github.com/es-joy/jsdoccomment",
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {
+    "comment-parser": "1.4.1",
+    "esquery": "^1.6.0",
+    "jsdoc-type-pratt-parser": "~4.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.7",
+    "@babel/plugin-syntax-class-properties": "^7.12.13",
+    "@babel/preset-env": "^7.24.7",
+    "@brettz9/eslint-plugin": "^1.0.4",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@types/eslint": "^8.56.10",
+    "@types/esquery": "^1.5.4",
+    "@types/estraverse": "^5.1.7",
+    "@types/estree": "^1.0.5",
+    "@typescript-eslint/types": "^7.16.0",
+    "@typescript-eslint/visitor-keys": "^7.16.0",
+    "@typhonjs-build-test/esm-d-ts": "0.3.0-next.1",
+    "@typhonjs-typedoc/typedoc-pkg": "^0.0.5",
+    "@vitest/coverage-v8": "^2.0.1",
+    "@vitest/ui": "^2.0.1",
+    "eslint": "^8.56.0",
+    "eslint-config-ash-nazg": "35.3.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-array-func": "^4.0.0",
+    "eslint-plugin-compat": "^4.2.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-html": "^7.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^48.0.4",
+    "eslint-plugin-markdown": "^3.0.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-no-unsanitized": "^4.0.2",
+    "eslint-plugin-no-use-extend-native": "^0.5.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-sonarjs": "^0.23.0",
+    "eslint-plugin-unicorn": "^50.0.1",
+    "espree": "^10.1.0",
+    "estraverse": "^5.3.0",
+    "rollup": "^4.18.1",
+    "typescript": "^5.5.3",
+    "typescript-eslint": "^7.16.0",
+    "vitest": "^2.0.1"
+  },
+  "files": [
+    "/dist",
+    "/src",
+    "CHANGES.md",
+    "LICENSE-MIT.txt"
+  ],
+  "scripts": {
+    "build": "rollup -c && npm run types",
+    "docs": "typedoc-pkg --api-link es",
+    "eslint": "eslint --ext=js,cjs,md,html .",
+    "lint": "npm run eslint --",
+    "open": "open ./coverage/index.html",
+    "test": "npm run lint && npm run build && npm run test-ui",
+    "test-ui": "vitest --ui --coverage",
+    "test-cov": "vitest --coverage",
+    "tsc": "tsc",
+    "types": "esm-d-ts gen ./src/index.js --output ./dist/index.d.ts"
+  }
+}

node_modules/@es-joy/jsdoccomment/src/commentHandler.js

@@ -0,0 +1,39 @@
+import esquery from 'esquery';
+
+import {
+  visitorKeys as jsdocTypePrattParserVisitorKeys
+} from 'jsdoc-type-pratt-parser';
+
+import {
+  commentParserToESTree, jsdocVisitorKeys
+} from './commentParserToESTree.js';
+
+/**
+ * @param {{[name: string]: any}} settings
+ * @returns {import('.').CommentHandler}
+ */
+const commentHandler = (settings) => {
+  /**
+   * @type {import('.').CommentHandler}
+   */
+  return (commentSelector, jsdoc) => {
+    const {mode} = settings;
+
+    const selector = esquery.parse(commentSelector);
+
+    const ast = commentParserToESTree(jsdoc, mode);
+
+    const _ast = /** @type {unknown} */ (ast);
+
+    return esquery.matches(/** @type {import('estree').Node} */ (
+      _ast
+    ), selector, undefined, {
+      visitorKeys: {
+        ...jsdocTypePrattParserVisitorKeys,
+        ...jsdocVisitorKeys
+      }
+    });
+  };
+};
+
+export {commentHandler};

node_modules/@es-joy/jsdoccomment/src/commentParserToESTree.js

@@ -0,0 +1,504 @@
+import {parse as jsdocTypePrattParse} from 'jsdoc-type-pratt-parser';
+
+/**
+ * Removes initial and ending brackets from `rawType`
+ * @param {JsdocTypeLine[]|JsdocTag} container
+ * @param {boolean} [isArr]
+ * @returns {void}
+ */
+const stripEncapsulatingBrackets = (container, isArr) => {
+  if (isArr) {
+    const firstItem = /** @type {JsdocTypeLine[]} */ (container)[0];
+    firstItem.rawType = firstItem.rawType.replace(
+      /^\{/u, ''
+    );
+
+    const lastItem = /** @type {JsdocTypeLine} */ (
+      /** @type {JsdocTypeLine[]} */ (
+        container
+      ).at(-1)
+    );
+    lastItem.rawType = lastItem.rawType.replace(/\}$/u, '');
+
+    return;
+  }
+  /** @type {JsdocTag} */ (container).rawType =
+    /** @type {JsdocTag} */ (container).rawType.replace(
+      /^\{/u, ''
+    ).replace(/\}$/u, '');
+};
+
+/**
+ * @typedef {{
+ *   delimiter: string,
+ *   postDelimiter: string,
+ *   rawType: string,
+ *   initial: string,
+ *   type: "JsdocTypeLine"
+ * }} JsdocTypeLine
+ */
+
+/**
+ * @typedef {{
+ *   delimiter: string,
+ *   description: string,
+ *   postDelimiter: string,
+ *   initial: string,
+ *   type: "JsdocDescriptionLine"
+ * }} JsdocDescriptionLine
+ */
+
+/**
+ * @typedef {{
+ *   format: 'pipe' | 'plain' | 'prefix' | 'space',
+ *   namepathOrURL: string,
+ *   tag: string,
+ *   text: string,
+ * }} JsdocInlineTagNoType
+ */
+/**
+ * @typedef {JsdocInlineTagNoType & {
+ *   type: "JsdocInlineTag"
+ * }} JsdocInlineTag
+ */
+
+/**
+ * @typedef {{
+ *   delimiter: string,
+ *   description: string,
+ *   descriptionLines: JsdocDescriptionLine[],
+ *   initial: string,
+ *   inlineTags: JsdocInlineTag[]
+ *   name: string,
+ *   postDelimiter: string,
+ *   postName: string,
+ *   postTag: string,
+ *   postType: string,
+ *   rawType: string,
+ *   parsedType: import('jsdoc-type-pratt-parser').RootResult|null
+ *   tag: string,
+ *   type: "JsdocTag",
+ *   typeLines: JsdocTypeLine[],
+ * }} JsdocTag
+ */
+
+/**
+ * @typedef {number} Integer
+ */
+
+/**
+ * @typedef {{
+ *   delimiter: string,
+ *   delimiterLineBreak: string,
+ *   description: string,
+ *   descriptionEndLine?: Integer,
+ *   descriptionLines: JsdocDescriptionLine[],
+ *   descriptionStartLine?: Integer,
+ *   hasPreterminalDescription: 0|1,
+ *   hasPreterminalTagDescription?: 1,
+ *   initial: string,
+ *   inlineTags: JsdocInlineTag[]
+ *   lastDescriptionLine?: Integer,
+ *   endLine: Integer,
+ *   lineEnd: string,
+ *   postDelimiter: string,
+ *   tags: JsdocTag[],
+ *   terminal: string,
+ *   preterminalLineBreak: string,
+ *   type: "JsdocBlock",
+ * }} JsdocBlock
+ */
+
+/**
+ * @param {object} cfg
+ * @param {string} cfg.text
+ * @param {string} cfg.tag
+ * @param {'pipe' | 'plain' | 'prefix' | 'space'} cfg.format
+ * @param {string} cfg.namepathOrURL
+ * @returns {JsdocInlineTag}
+ */
+const inlineTagToAST = ({text, tag, format, namepathOrURL}) => ({
+  text,
+  tag,
+  format,
+  namepathOrURL,
+  type: 'JsdocInlineTag'
+});
+
+/**
+ * Converts comment parser AST to ESTree format.
+ * @param {import('.').JsdocBlockWithInline} jsdoc
+ * @param {import('jsdoc-type-pratt-parser').ParseMode} mode
+ * @param {object} opts
+ * @param {'compact'|'preserve'} [opts.spacing] By default, empty lines are
+ *        compacted; set to 'preserve' to preserve empty comment lines.
+ * @param {boolean} [opts.throwOnTypeParsingErrors]
+ * @returns {JsdocBlock}
+ */
+const commentParserToESTree = (jsdoc, mode, {
+  spacing = 'compact',
+  throwOnTypeParsingErrors = false
+} = {}) => {
+  /**
+   * Strips brackets from a tag's `rawType` values and adds `parsedType`
+   * @param {JsdocTag} lastTag
+   * @returns {void}
+   */
+  const cleanUpLastTag = (lastTag) => {
+    // Strip out `}` that encapsulates and is not part of
+    //   the type
+    stripEncapsulatingBrackets(lastTag);
+
+    if (lastTag.typeLines.length) {
+      stripEncapsulatingBrackets(lastTag.typeLines, true);
+    }
+
+    // Remove single empty line description.
+    if (lastTag.descriptionLines.length === 1 &&
+      lastTag.descriptionLines[0].description === '') {
+      lastTag.descriptionLines.length = 0;
+    }
+
+    // With even a multiline type now in full, add parsing
+    let parsedType = null;
+
+    try {
+      parsedType = jsdocTypePrattParse(lastTag.rawType, mode);
+    } catch (err) {
+      // Ignore
+      if (lastTag.rawType && throwOnTypeParsingErrors) {
+        /** @type {Error} */ (
+          err
+        ).message = `Tag @${lastTag.tag} with raw type ` +
+          `\`${lastTag.rawType}\` had parsing error: ${
+            /** @type {Error} */ (err).message}`;
+        throw err;
+      }
+    }
+
+    lastTag.parsedType = parsedType;
+  };
+
+  const {source, inlineTags: blockInlineTags} = jsdoc;
+
+  const {tokens: {
+    delimiter: delimiterRoot,
+    lineEnd: lineEndRoot,
+    postDelimiter: postDelimiterRoot,
+    start: startRoot,
+    end: endRoot
+  }} = source[0];
+
+  const endLine = source.length - 1;
+
+  /** @type {JsdocBlock} */
+  const ast = {
+    delimiter: delimiterRoot,
+    delimiterLineBreak: '\n',
+    description: '',
+
+    descriptionLines: [],
+    inlineTags: blockInlineTags.map((t) => inlineTagToAST(t)),
+
+    initial: startRoot,
+    tags: [],
+    // `terminal` will be overwritten if there are other entries
+    terminal: endRoot,
+    preterminalLineBreak: '\n',
+    hasPreterminalDescription: 0,
+    endLine,
+    postDelimiter: postDelimiterRoot,
+    lineEnd: lineEndRoot,
+
+    type: 'JsdocBlock'
+  };
+
+  /**
+   * @type {JsdocTag[]}
+   */
+  const tags = [];
+
+  /** @type {Integer|undefined} */
+  let lastDescriptionLine;
+
+  /** @type {JsdocTag|null} */
+  let lastTag = null;
+
+  // Tracks when first valid tag description line is seen.
+  let tagDescriptionSeen = false;
+
+  let descLineStateOpen = true;
+
+  source.forEach((info, idx) => {
+    const {tokens} = info;
+    const {
+      delimiter,
+      description,
+      postDelimiter,
+      start: initial,
+      tag,
+      end,
+      type: rawType
+    } = tokens;
+
+    if (!tag && description && descLineStateOpen) {
+      if (ast.descriptionStartLine === undefined) {
+        ast.descriptionStartLine = idx;
+      }
+      ast.descriptionEndLine = idx;
+    }
+
+    if (tag || end) {
+      descLineStateOpen = false;
+      if (lastDescriptionLine === undefined) {
+        lastDescriptionLine = idx;
+      }
+
+      // Clean-up with last tag before end or new tag
+      if (lastTag) {
+        cleanUpLastTag(lastTag);
+      }
+
+      // Stop the iteration when we reach the end
+      // but only when there is no tag earlier in the line
+      // to still process
+      if (end && !tag) {
+        ast.terminal = end;
+
+        // Check if there are any description lines and if not then this is a
+        // one line comment block.
+        const isDelimiterLine = ast.descriptionLines.length === 0 &&
+          delimiter === '/**';
+
+        // Remove delimiter line break for one line comments blocks.
+        if (isDelimiterLine) {
+          ast.delimiterLineBreak = '';
+        }
+
+        if (description) {
+          // Remove terminal line break at end when description is defined.
+          if (ast.terminal === '*/') {
+            ast.preterminalLineBreak = '';
+          }
+
+          if (lastTag) {
+            ast.hasPreterminalTagDescription = 1;
+          } else {
+            ast.hasPreterminalDescription = 1;
+          }
+
+          const holder = lastTag || ast;
+          holder.description += (holder.description ? '\n' : '') + description;
+
+          // Do not include `delimiter` / `postDelimiter` for opening
+          // delimiter line.
+
+          holder.descriptionLines.push({
+            delimiter: isDelimiterLine ? '' : delimiter,
+            description,
+            postDelimiter: isDelimiterLine ? '' : postDelimiter,
+            initial,
+            type: 'JsdocDescriptionLine'
+          });
+        }
+        return;
+      }
+
+      const {
+        // eslint-disable-next-line no-unused-vars -- Discarding
+        end: ed,
+        delimiter: de,
+        postDelimiter: pd,
+        start: init,
+        ...tkns
+      } = tokens;
+
+      if (!tokens.name) {
+        let i = 1;
+        while (source[idx + i]) {
+          const {tokens: {
+            name,
+            postName,
+            postType,
+            tag: tg
+          }} = source[idx + i];
+          if (tg) {
+            break;
+          }
+          if (name) {
+            tkns.postType = postType;
+            tkns.name = name;
+            tkns.postName = postName;
+            break;
+          }
+          i++;
+        }
+      }
+
+      /**
+       * @type {JsdocInlineTag[]}
+       */
+      let tagInlineTags = [];
+      if (tag) {
+        // Assuming the tags from `source` are in the same order as `jsdoc.tags`
+        // we can use the `tags` length as index into the parser result tags.
+        tagInlineTags =
+          /**
+           * @type {import('comment-parser').Spec & {
+           *   inlineTags: JsdocInlineTagNoType[]
+           * }}
+           */ (
+            jsdoc.tags[tags.length]
+          ).inlineTags.map(
+            (t) => inlineTagToAST(t)
+          );
+      }
+
+      /** @type {JsdocTag} */
+      const tagObj = {
+        ...tkns,
+        initial: endLine ? init : '',
+        postDelimiter: lastDescriptionLine ? pd : '',
+        delimiter: lastDescriptionLine ? de : '',
+        descriptionLines: [],
+        inlineTags: tagInlineTags,
+        parsedType: null,
+        rawType: '',
+        type: 'JsdocTag',
+        typeLines: []
+      };
+      tagObj.tag = tagObj.tag.replace(/^@/u, '');
+
+      lastTag = tagObj;
+      tagDescriptionSeen = false;
+
+      tags.push(tagObj);
+    }
+
+    if (rawType) {
+      // Will strip rawType brackets after this tag
+      /** @type {JsdocTag} */ (lastTag).typeLines.push(
+        /** @type {JsdocTag} */ (lastTag).typeLines.length
+          ? {
+            delimiter,
+            postDelimiter,
+            rawType,
+            initial,
+            type: 'JsdocTypeLine'
+          }
+          : {
+            delimiter: '',
+            postDelimiter: '',
+            rawType,
+            initial: '',
+            type: 'JsdocTypeLine'
+          }
+      );
+      /** @type {JsdocTag} */ (lastTag).rawType += /** @type {JsdocTag} */ (
+        lastTag
+      ).rawType
+        ? '\n' + rawType
+        : rawType;
+    }
+
+    // In `compact` mode skip processing if `description` is an empty string
+    // unless lastTag is being processed.
+    //
+    // In `preserve` mode process when `description` is not the `empty string
+    // or the `delimiter` is not `/**` ensuring empty lines are preserved.
+    if (((spacing === 'compact' && description) || lastTag) ||
+        (spacing === 'preserve' && (description || delimiter !== '/**'))) {
+      const holder = lastTag || ast;
+
+      // Check if there are any description lines and if not then this is a
+      // multi-line comment block with description on 0th line. Treat
+      // `delimiter` / `postDelimiter` / `initial` as being on a new line.
+      const isDelimiterLine = holder.descriptionLines.length === 0 &&
+        delimiter === '/**';
+
+      // Remove delimiter line break for one line comments blocks.
+      if (isDelimiterLine) {
+        ast.delimiterLineBreak = '';
+      }
+
+      // Track when the first description line is seen to avoid adding empty
+      // description lines for tag type lines.
+      tagDescriptionSeen ||= Boolean(lastTag &&
+        (rawType === '' || rawType?.endsWith('}')));
+
+      if (lastTag) {
+        if (tagDescriptionSeen) {
+          // The first tag description line is a continuation after type /
+          // name parsing.
+          const isFirstDescriptionLine = holder.descriptionLines.length === 0;
+
+          // For `compact` spacing must allow through first description line.
+          if ((spacing === 'compact' &&
+              (description || isFirstDescriptionLine)) ||
+              spacing === 'preserve') {
+            holder.descriptionLines.push({
+              delimiter: isFirstDescriptionLine ? '' : delimiter,
+              description,
+              postDelimiter: isFirstDescriptionLine ? '' : postDelimiter,
+              initial: isFirstDescriptionLine ? '' : initial,
+              type: 'JsdocDescriptionLine'
+            });
+          }
+        }
+      } else {
+        holder.descriptionLines.push({
+          delimiter: isDelimiterLine ? '' : delimiter,
+          description,
+          postDelimiter: isDelimiterLine ? '' : postDelimiter,
+          initial: isDelimiterLine ? `` : initial,
+          type: 'JsdocDescriptionLine'
+        });
+      }
+
+      if (!tag) {
+        if (lastTag) {
+          // For `compact` spacing must filter out any empty description lines
+          // after the initial `holder.description` has content.
+          if (tagDescriptionSeen && !(spacing === 'compact' &&
+            holder.description && description === '')) {
+            holder.description += !holder.description
+              ? description
+              : '\n' + description;
+          }
+        } else {
+          holder.description += !holder.description
+            ? description
+            : '\n' + description;
+        }
+      }
+    }
+
+    // Clean-up where last line itself has tag content
+    if (end && tag) {
+      ast.terminal = end;
+      ast.hasPreterminalTagDescription = 1;
+
+      // Remove terminal line break at end when tag is defined on last line.
+      if (ast.terminal === '*/') {
+        ast.preterminalLineBreak = '';
+      }
+
+      cleanUpLastTag(/** @type {JsdocTag} */ (lastTag));
+    }
+  });
+
+  ast.lastDescriptionLine = lastDescriptionLine;
+  ast.tags = tags;
+
+  return ast;
+};
+
+const jsdocVisitorKeys = {
+  JsdocBlock: ['descriptionLines', 'tags', 'inlineTags'],
+  JsdocDescriptionLine: [],
+  JsdocTypeLine: [],
+  JsdocTag: ['parsedType', 'typeLines', 'descriptionLines', 'inlineTags'],
+  JsdocInlineTag: []
+};
+
+export {commentParserToESTree, jsdocVisitorKeys};

node_modules/@es-joy/jsdoccomment/src/estreeToString.js

@@ -0,0 +1,179 @@
+import {stringify as prattStringify} from 'jsdoc-type-pratt-parser';
+
+/** @type {Record<string, Function>} */
+const stringifiers = {
+  JsdocBlock,
+
+  /**
+   * @param {import('./commentParserToESTree').JsdocDescriptionLine} node
+   * @returns {string}
+   */
+  JsdocDescriptionLine ({
+    initial, delimiter, postDelimiter, description
+  }) {
+    return `${initial}${delimiter}${postDelimiter}${description}`;
+  },
+
+  /**
+   * @param {import('./commentParserToESTree').JsdocTypeLine} node
+   * @returns {string}
+   */
+  JsdocTypeLine ({
+    initial, delimiter, postDelimiter, rawType
+  }) {
+    return `${initial}${delimiter}${postDelimiter}${rawType}`;
+  },
+
+  /**
+   * @param {import('./commentParserToESTree').JsdocInlineTag} node
+   */
+  JsdocInlineTag ({format, namepathOrURL, tag, text}) {
+    return format === 'pipe'
+      ? `{@${tag} ${namepathOrURL}|${text}}`
+      : format === 'plain'
+        ? `{@${tag} ${namepathOrURL}}`
+        : format === 'prefix'
+          ? `[${text}]{@${tag} ${namepathOrURL}}`
+          // "space"
+          : `{@${tag} ${namepathOrURL} ${text}}`;
+  },
+
+  JsdocTag
+};
+
+/**
+ * @todo convert for use by escodegen (until may be patched to support
+ *   custom entries?).
+ * @param {import('./commentParserToESTree').JsdocBlock|
+ *   import('./commentParserToESTree').JsdocDescriptionLine|
+ *   import('./commentParserToESTree').JsdocTypeLine|
+ *   import('./commentParserToESTree').JsdocTag|
+ *   import('./commentParserToESTree').JsdocInlineTag|
+ *   import('jsdoc-type-pratt-parser').RootResult
+ * } node
+ * @param {import('.').ESTreeToStringOptions} opts
+ * @throws {Error}
+ * @returns {string}
+ */
+function estreeToString (node, opts = {}) {
+  if (Object.prototype.hasOwnProperty.call(stringifiers, node.type)) {
+    return stringifiers[
+      /**
+       * @type {import('./commentParserToESTree').JsdocBlock|
+       *   import('./commentParserToESTree').JsdocDescriptionLine|
+       *   import('./commentParserToESTree').JsdocTypeLine|
+       *   import('./commentParserToESTree').JsdocTag}
+       */
+      (node).type
+    ](
+      node,
+      opts
+    );
+  }
+
+  // We use raw type instead but it is a key as other apps may wish to traverse
+  if (node.type.startsWith('JsdocType')) {
+    return opts.preferRawType
+      ? ''
+      : `{${prattStringify(
+        /** @type {import('jsdoc-type-pratt-parser').RootResult} */ (
+          node
+        )
+      )}}`;
+  }
+
+  throw new Error(`Unhandled node type: ${node.type}`);
+}
+
+/**
+ * @param {import('./commentParserToESTree').JsdocBlock} node
+ * @param {import('.').ESTreeToStringOptions} opts
+ * @returns {string}
+ */
+function JsdocBlock (node, opts) {
+  const {delimiter, delimiterLineBreak, descriptionLines,
+    initial, postDelimiter, preterminalLineBreak, tags, terminal} = node;
+
+  const terminalPrepend = preterminalLineBreak !== ''
+    ? `${preterminalLineBreak}${initial} `
+    : '';
+
+  let result = `${initial}${delimiter}${postDelimiter}${delimiterLineBreak}`;
+
+  for (let i = 0; i < descriptionLines.length; i++) {
+    result += estreeToString(descriptionLines[i]);
+
+    if (i !== descriptionLines.length - 1 || tags.length) {
+      result += '\n';
+    }
+  }
+
+  for (let i = 0; i < tags.length; i++) {
+    result += estreeToString(tags[i], opts);
+
+    if (i !== tags.length - 1) {
+      result += '\n';
+    }
+  }
+
+  result += `${terminalPrepend}${terminal}`;
+
+  return result;
+}
+
+/**
+ * @param {import('./commentParserToESTree').JsdocTag} node
+ * @param {import('.').ESTreeToStringOptions} opts
+ * @returns {string}
+ */
+function JsdocTag (node, opts) {
+  const {
+    delimiter, descriptionLines, initial, name, parsedType, postDelimiter,
+    postName, postTag, postType, tag, typeLines
+  } = node;
+
+  let result = `${initial}${delimiter}${postDelimiter}@${tag}${postTag}`;
+
+  // Could do `rawType` but may have been changed; could also do
+  //   `typeLines` but not as likely to be changed
+  // parsedType
+  // Comment this out later in favor of `parsedType`
+  // We can't use raw `typeLines` as first argument has delimiter on it
+  if (opts.preferRawType || !parsedType) {
+    if (typeLines.length) {
+      result += '{';
+
+      for (let i = 0; i < typeLines.length; i++) {
+        result += estreeToString(typeLines[i]);
+
+        if (i !== typeLines.length - 1) {
+          result += '\n';
+        }
+      }
+
+      result += '}';
+    }
+  } else if (parsedType?.type.startsWith('JsdocType')) {
+    result += `{${prattStringify(
+      /** @type {import('jsdoc-type-pratt-parser').RootResult} */ (
+        parsedType
+      )
+    )}}`;
+  }
+
+  result += name ? `${postType}${name}${postName}` : postType;
+
+  for (let i = 0; i < descriptionLines.length; i++) {
+    const descriptionLine = descriptionLines[i];
+
+    result += estreeToString(descriptionLine);
+
+    if (i !== descriptionLines.length - 1) {
+      result += '\n';
+    }
+  }
+
+  return result;
+}
+
+export {estreeToString};

node_modules/@es-joy/jsdoccomment/src/index.js

@@ -0,0 +1,50 @@
+/**
+ * @typedef {import('./commentParserToESTree').JsdocInlineTagNoType & {
+ *   start: number,
+ *   end: number,
+ * }} InlineTag
+ */
+
+/**
+ * @typedef {import('comment-parser').Spec & {
+ *   line?: import('./commentParserToESTree').Integer,
+ *   inlineTags: (import('./commentParserToESTree').JsdocInlineTagNoType & {
+ *     line?: import('./commentParserToESTree').Integer
+ *   })[]
+ * }} JsdocTagWithInline
+ */
+
+/**
+ * Expands on comment-parser's `Block` interface.
+ * @typedef {{
+ *   description: string,
+ *   source: import('comment-parser').Line[],
+ *   problems: import('comment-parser').Problem[],
+ *   tags: JsdocTagWithInline[],
+ *   inlineTags: (import('./commentParserToESTree').JsdocInlineTagNoType & {
+ *     line?: import('./commentParserToESTree').Integer
+ *   })[]
+ * }} JsdocBlockWithInline
+ */
+
+/**
+ * @typedef {{preferRawType?: boolean}} ESTreeToStringOptions
+ */
+
+/**
+ * @callback CommentHandler
+ * @param {string} commentSelector
+ * @param {import('.').JsdocBlockWithInline} jsdoc
+ * @returns {boolean}
+ */
+
+export {visitorKeys as jsdocTypeVisitorKeys} from 'jsdoc-type-pratt-parser';
+
+export * from 'jsdoc-type-pratt-parser';
+
+export * from './commentHandler.js';
+export * from './commentParserToESTree.js';
+export * from './estreeToString.js';
+export * from './jsdoccomment.js';
+export * from './parseComment.js';
+export * from './parseInlineTags.js';

node_modules/@es-joy/jsdoccomment/src/jsdoccomment.js

@@ -0,0 +1,487 @@
+/**
+ * Obtained originally from {@link https://github.com/eslint/eslint/blob/master/lib/util/source-code.js#L313}.
+ *
+ * @license MIT
+ */
+
+/**
+ * @typedef {import('eslint').AST.Token | import('estree').Comment | {
+ *   type: import('eslint').AST.TokenType|"Line"|"Block"|"Shebang",
+ *   range: [number, number],
+ *   value: string
+ * }} Token
+ */
+
+/**
+ * @typedef {import('eslint').Rule.Node|
+ *   import('@typescript-eslint/types').TSESTree.Node} ESLintOrTSNode
+ */
+
+/**
+ * @typedef {number} int
+ */
+
+/**
+ * Checks if the given token is a comment token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a comment token.
+ */
+const isCommentToken = (token) => {
+  return token.type === 'Line' || token.type === 'Block' ||
+    token.type === 'Shebang';
+};
+
+/**
+ * @param {(ESLintOrTSNode|import('estree').Comment) & {
+ *   declaration?: any,
+ *   decorators?: any[],
+ *   parent?: import('eslint').Rule.Node & {
+ *     decorators?: any[]
+ *   }
+ * }} node
+ * @returns {import('@typescript-eslint/types').TSESTree.Decorator|undefined}
+ */
+const getDecorator = (node) => {
+  return node?.declaration?.decorators?.[0] || node?.decorators?.[0] ||
+      node?.parent?.decorators?.[0];
+};
+
+/**
+ * Check to see if it is a ES6 export declaration.
+ *
+ * @param {ESLintOrTSNode} astNode An AST node.
+ * @returns {boolean} whether the given node represents an export declaration.
+ * @private
+ */
+const looksLikeExport = function (astNode) {
+  return astNode.type === 'ExportDefaultDeclaration' ||
+    astNode.type === 'ExportNamedDeclaration' ||
+    astNode.type === 'ExportAllDeclaration' ||
+    astNode.type === 'ExportSpecifier';
+};
+
+/**
+ * @param {ESLintOrTSNode} astNode
+ * @returns {ESLintOrTSNode}
+ */
+const getTSFunctionComment = function (astNode) {
+  const {parent} = astNode;
+  /* v8 ignore next 3 */
+  if (!parent) {
+    return astNode;
+  }
+  const grandparent = parent.parent;
+  /* v8 ignore next 3 */
+  if (!grandparent) {
+    return astNode;
+  }
+  const greatGrandparent = grandparent.parent;
+  const greatGreatGrandparent = greatGrandparent && greatGrandparent.parent;
+
+  /* v8 ignore next 3 */
+  if (/** @type {ESLintOrTSNode} */ (parent).type !== 'TSTypeAnnotation') {
+    return astNode;
+  }
+
+  switch (/** @type {ESLintOrTSNode} */ (grandparent).type) {
+  // @ts-expect-error -- For `ClassProperty`.
+  case 'PropertyDefinition': case 'ClassProperty':
+  case 'TSDeclareFunction':
+  case 'TSMethodSignature':
+  case 'TSPropertySignature':
+    return grandparent;
+  case 'ArrowFunctionExpression':
+    /* v8 ignore next 3 */
+    if (!greatGrandparent) {
+      return astNode;
+    }
+
+    if (
+      greatGrandparent.type === 'VariableDeclarator'
+
+    // && greatGreatGrandparent.parent.type === 'VariableDeclaration'
+    ) {
+      /* v8 ignore next 3 */
+      if (!greatGreatGrandparent || !greatGreatGrandparent.parent) {
+        return astNode;
+      }
+      return greatGreatGrandparent.parent;
+    }
+    /* v8 ignore next */
+    return astNode;
+  case 'FunctionExpression':
+    /* v8 ignore next 3 */
+    if (!greatGreatGrandparent) {
+      return astNode;
+    }
+    if (greatGrandparent.type === 'MethodDefinition') {
+      return greatGrandparent;
+    }
+
+  // Fallthrough
+  default:
+    /* v8 ignore next 3 */
+    if (grandparent.type !== 'Identifier') {
+      return astNode;
+    }
+  }
+
+  /* v8 ignore next 3 */
+  if (!greatGreatGrandparent) {
+    return astNode;
+  }
+
+  switch (greatGrandparent.type) {
+  case 'ArrowFunctionExpression':
+    if (
+      greatGreatGrandparent.type === 'VariableDeclarator' &&
+      greatGreatGrandparent.parent.type === 'VariableDeclaration'
+    ) {
+      return greatGreatGrandparent.parent;
+    }
+
+    return astNode;
+  case 'FunctionDeclaration':
+    return greatGrandparent;
+  case 'VariableDeclarator':
+    if (greatGreatGrandparent.type === 'VariableDeclaration') {
+      return greatGreatGrandparent;
+    }
+    /* v8 ignore next 2 */
+    // Fallthrough
+  default:
+    /* v8 ignore next 3 */
+    return astNode;
+  }
+};
+
+const invokedExpression = new Set(
+  ['CallExpression', 'OptionalCallExpression', 'NewExpression']
+);
+const allowableCommentNode = new Set([
+  'AssignmentPattern',
+  'VariableDeclaration',
+  'ExpressionStatement',
+  'MethodDefinition',
+  'Property',
+  'ObjectProperty',
+  'ClassProperty',
+  'PropertyDefinition',
+  'ExportDefaultDeclaration',
+  'ReturnStatement'
+]);
+
+/**
+ * Reduces the provided node to the appropriate node for evaluating
+ * JSDoc comment status.
+ *
+ * @param {ESLintOrTSNode} node An AST node.
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode.
+ * @returns {ESLintOrTSNode} The AST node that
+ *   can be evaluated for appropriate JSDoc comments.
+ */
+const getReducedASTNode = function (node, sourceCode) {
+  let {parent} = node;
+
+  switch (/** @type {ESLintOrTSNode} */ (node).type) {
+  case 'TSFunctionType':
+    return getTSFunctionComment(node);
+  case 'TSInterfaceDeclaration':
+  case 'TSTypeAliasDeclaration':
+  case 'TSEnumDeclaration':
+  case 'ClassDeclaration':
+  case 'FunctionDeclaration':
+    /* v8 ignore next 3 */
+    if (!parent) {
+      return node;
+    }
+    return looksLikeExport(parent) ? parent : node;
+
+  case 'TSDeclareFunction':
+  case 'ClassExpression':
+  case 'ObjectExpression':
+  case 'ArrowFunctionExpression':
+  case 'TSEmptyBodyFunctionExpression':
+  case 'FunctionExpression':
+    /* v8 ignore next 3 */
+    if (!parent) {
+      return node;
+    }
+    if (
+      !invokedExpression.has(parent.type)
+    ) {
+      /**
+       * @type {ESLintOrTSNode|Token|null}
+       */
+      let token = node;
+      do {
+        token = sourceCode.getTokenBefore(
+          /** @type {import('eslint').Rule.Node|import('eslint').AST.Token} */ (
+            token
+          ),
+          {includeComments: true}
+        );
+      } while (token && token.type === 'Punctuator' && token.value === '(');
+      if (token && token.type === 'Block') {
+        return node;
+      }
+
+      if (sourceCode.getCommentsBefore(
+        /** @type {import('eslint').Rule.Node} */
+        (node)
+      ).length) {
+        return node;
+      }
+
+      while (
+        !sourceCode.getCommentsBefore(
+          /** @type {import('eslint').Rule.Node} */
+          (parent)
+        ).length &&
+        !(/Function/u).test(parent.type) &&
+        !allowableCommentNode.has(parent.type)
+      ) {
+        ({parent} = parent);
+
+        if (!parent) {
+          break;
+        }
+      }
+      if (parent && parent.type !== 'FunctionDeclaration' &&
+        parent.type !== 'Program'
+      ) {
+        if (parent.parent && parent.parent.type === 'ExportNamedDeclaration') {
+          return parent.parent;
+        }
+
+        return parent;
+      }
+    }
+
+    return node;
+
+  default:
+    return node;
+  }
+};
+
+/**
+ * Checks for the presence of a JSDoc comment for the given node and returns it.
+ *
+ * @param {ESLintOrTSNode} astNode The AST node to get
+ *   the comment for.
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {{maxLines: int, minLines: int, [name: string]: any}} settings
+ * @param {{nonJSDoc?: boolean}} [opts]
+ * @returns {Token|null} The Block comment token containing the JSDoc comment
+ *    for the given node or null if not found.
+ */
+const findJSDocComment = (astNode, sourceCode, settings, opts = {}) => {
+  const {nonJSDoc} = opts;
+  const {minLines, maxLines} = settings;
+
+  /** @type {ESLintOrTSNode|import('estree').Comment} */
+  let currentNode = astNode;
+  let tokenBefore = null;
+  let parenthesisToken = null;
+
+  while (currentNode) {
+    const decorator = getDecorator(
+      /** @type {import('eslint').Rule.Node} */
+      (currentNode)
+    );
+    if (decorator) {
+      const dec = /** @type {unknown} */ (decorator);
+      currentNode = /** @type {import('eslint').Rule.Node} */ (dec);
+    }
+    tokenBefore = sourceCode.getTokenBefore(
+      /** @type {import('eslint').Rule.Node} */
+      (currentNode),
+      {includeComments: true}
+    );
+    if (
+      tokenBefore && tokenBefore.type === 'Punctuator' &&
+      tokenBefore.value === '('
+    ) {
+      parenthesisToken = tokenBefore;
+      [tokenBefore] = sourceCode.getTokensBefore(
+        /** @type {import('eslint').Rule.Node} */
+        (currentNode),
+        {
+          count: 2,
+          includeComments: true
+        }
+      );
+    }
+    if (!tokenBefore || !isCommentToken(tokenBefore)) {
+      return null;
+    }
+    if (!nonJSDoc && tokenBefore.type === 'Line') {
+      currentNode = tokenBefore;
+      continue;
+    }
+    break;
+  }
+
+  /* v8 ignore next 3 */
+  if (!tokenBefore || !currentNode.loc || !tokenBefore.loc) {
+    return null;
+  }
+
+  if (
+    (
+      (nonJSDoc && (tokenBefore.type !== 'Block' ||
+        !(/^\*\s/u).test(tokenBefore.value))) ||
+      (!nonJSDoc && tokenBefore.type === 'Block' &&
+      (/^\*\s/u).test(tokenBefore.value))
+    ) &&
+    currentNode.loc.start.line - (
+      /** @type {import('eslint').AST.Token} */
+      (parenthesisToken ?? tokenBefore)
+    ).loc.end.line >= minLines &&
+    currentNode.loc.start.line - (
+      /** @type {import('eslint').AST.Token} */
+      (parenthesisToken ?? tokenBefore)
+    ).loc.end.line <= maxLines
+  ) {
+    return tokenBefore;
+  }
+
+  return null;
+};
+
+/**
+ * Retrieves the JSDoc comment for a given node.
+ *
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode
+ * @param {import('eslint').Rule.Node} node The AST node to get
+ *   the comment for.
+ * @param {{maxLines: int, minLines: int, [name: string]: any}} settings The
+ *   settings in context
+ * @returns {Token|null} The Block comment
+ *   token containing the JSDoc comment for the given node or
+ *   null if not found.
+ * @public
+ */
+const getJSDocComment = function (sourceCode, node, settings) {
+  const reducedNode = getReducedASTNode(node, sourceCode);
+
+  return findJSDocComment(reducedNode, sourceCode, settings);
+};
+
+/**
+ * Retrieves the comment preceding a given node.
+ *
+ * @param {import('eslint').SourceCode} sourceCode The ESLint SourceCode
+ * @param {ESLintOrTSNode} node The AST node to get
+ *   the comment for.
+ * @param {{maxLines: int, minLines: int, [name: string]: any}} settings The
+ *   settings in context
+ * @returns {Token|null} The Block comment
+ *   token containing the JSDoc comment for the given node or
+ *   null if not found.
+ * @public
+ */
+const getNonJsdocComment = function (sourceCode, node, settings) {
+  const reducedNode = getReducedASTNode(node, sourceCode);
+
+  return findJSDocComment(reducedNode, sourceCode, settings, {
+    nonJSDoc: true
+  });
+};
+
+/**
+  * @param {ESLintOrTSNode|import('eslint').AST.Token|
+  *   import('estree').Comment
+  * } nodeA The AST node or token to compare
+  * @param {ESLintOrTSNode|import('eslint').AST.Token|
+  *   import('estree').Comment} nodeB The
+  *   AST node or token to compare
+  */
+const compareLocEndToStart = (nodeA, nodeB) => {
+  /* v8 ignore next */
+  return (nodeA.loc?.end.line ?? 0) === (nodeB.loc?.start.line ?? 0);
+};
+
+/**
+ * Checks for the presence of a comment following the given node and
+ * returns it.
+ *
+ * This method is experimental.
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {ESLintOrTSNode} astNode The AST node to get
+ *   the comment for.
+ * @returns {Token|null} The comment token containing the comment
+ *    for the given node or null if not found.
+ */
+const getFollowingComment = function (sourceCode, astNode) {
+  /**
+   * @param {ESLintOrTSNode} node The
+   *   AST node to get the comment for.
+   */
+  const getTokensAfterIgnoringSemis = (node) => {
+    let tokenAfter = sourceCode.getTokenAfter(
+      /** @type {import('eslint').Rule.Node} */
+      (node),
+      {includeComments: true}
+    );
+
+    while (
+      tokenAfter && tokenAfter.type === 'Punctuator' &&
+      // tokenAfter.value === ')' // Don't apparently need to ignore
+      tokenAfter.value === ';'
+    ) {
+      [tokenAfter] = sourceCode.getTokensAfter(tokenAfter, {
+        includeComments: true
+      });
+    }
+    return tokenAfter;
+  };
+
+  /**
+   * @param {ESLintOrTSNode} node The
+   *   AST node to get the comment for.
+   */
+  const tokenAfterIgnoringSemis = (node) => {
+    const tokenAfter = getTokensAfterIgnoringSemis(node);
+    return (
+      tokenAfter &&
+      isCommentToken(tokenAfter) &&
+      compareLocEndToStart(node, tokenAfter)
+    )
+      ? tokenAfter
+      : null;
+  };
+
+  let tokenAfter = tokenAfterIgnoringSemis(astNode);
+
+  if (!tokenAfter) {
+    switch (astNode.type) {
+    case 'FunctionDeclaration':
+      tokenAfter = tokenAfterIgnoringSemis(
+        /** @type {ESLintOrTSNode} */
+        (astNode.body)
+      );
+      break;
+    case 'ExpressionStatement':
+      tokenAfter = tokenAfterIgnoringSemis(
+        /** @type {ESLintOrTSNode} */
+        (astNode.expression)
+      );
+      break;
+
+    /* v8 ignore next 3 */
+    default:
+      break;
+    }
+  }
+
+  return tokenAfter;
+};
+
+export {
+  getReducedASTNode, getJSDocComment, getNonJsdocComment,
+  getDecorator, findJSDocComment, getFollowingComment
+};

node_modules/@es-joy/jsdoccomment/src/parseComment.js

@@ -0,0 +1,190 @@
+/* eslint-disable prefer-named-capture-group -- Temporary */
+import {
+  parse as commentParser,
+  tokenizers
+} from 'comment-parser';
+
+import {parseInlineTags} from './parseInlineTags.js';
+
+const {
+  name: nameTokenizer,
+  tag: tagTokenizer,
+  type: typeTokenizer,
+  description: descriptionTokenizer
+} = tokenizers;
+
+/**
+ * @param {import('comment-parser').Spec} spec
+ * @returns {boolean}
+ */
+export const hasSeeWithLink = (spec) => {
+  return spec.tag === 'see' && (/\{@link.+?\}/u).test(spec.source[0].source);
+};
+
+export const defaultNoTypes = [
+  'default', 'defaultvalue', 'description', 'example',
+  'file', 'fileoverview', 'license',
+  'overview', 'see', 'summary'
+];
+
+export const defaultNoNames = [
+  'access', 'author',
+  'default', 'defaultvalue',
+  'description',
+  'example', 'exception', 'file', 'fileoverview',
+  'kind',
+  'license', 'overview',
+  'return', 'returns',
+  'since', 'summary',
+  'throws',
+  'version', 'variation'
+];
+
+const optionalBrackets = /^\[(?<name>[^=]*)=[^\]]*\]/u;
+const preserveTypeTokenizer = typeTokenizer('preserve');
+const preserveDescriptionTokenizer = descriptionTokenizer('preserve');
+const plainNameTokenizer = nameTokenizer();
+
+/**
+ * Can't import `comment-parser/es6/parser/tokenizers/index.js`,
+ *   so we redefine here.
+ * @typedef {(spec: import('comment-parser').Spec) =>
+ *   import('comment-parser').Spec} CommentParserTokenizer
+ */
+
+/**
+ * @param {object} [cfg]
+ * @param {string[]} [cfg.noTypes]
+ * @param {string[]} [cfg.noNames]
+ * @returns {CommentParserTokenizer[]}
+ */
+const getTokenizers = ({
+  noTypes = defaultNoTypes,
+  noNames = defaultNoNames
+} = {}) => {
+  // trim
+  return [
+    // Tag
+    tagTokenizer(),
+
+    /**
+     * Type tokenizer.
+     * @param {import('comment-parser').Spec} spec
+     * @returns {import('comment-parser').Spec}
+     */
+    (spec) => {
+      if (noTypes.includes(spec.tag)) {
+        return spec;
+      }
+
+      return preserveTypeTokenizer(spec);
+    },
+
+    /**
+     * Name tokenizer.
+     * @param {import('comment-parser').Spec} spec
+     * @returns {import('comment-parser').Spec}
+     */
+    (spec) => {
+      if (spec.tag === 'template') {
+        // const preWS = spec.postTag;
+        const remainder = spec.source[0].tokens.description;
+
+        let pos;
+        if (remainder.startsWith('[') && remainder.includes(']')) {
+          const endingBracketPos = remainder.indexOf(']');
+          pos = remainder.slice(endingBracketPos).search(/(?<![\s,])\s/u);
+          if (pos > -1) { // Add offset to starting point if space found
+            pos += endingBracketPos;
+          }
+        } else {
+          pos = remainder.search(/(?<![\s,])\s/u);
+        }
+
+        let name = pos === -1 ? remainder : remainder.slice(0, pos);
+        const extra = remainder.slice(pos);
+        let postName = '', description = '', lineEnd = '';
+        if (pos > -1) {
+          [, postName, description, lineEnd] = /** @type {RegExpMatchArray} */ (
+            extra.match(/(\s*)([^\r]*)(\r)?/u)
+          );
+        }
+
+        if (optionalBrackets.test(name)) {
+          name = /** @type {string} */ (
+            /** @type {RegExpMatchArray} */ (
+              name.match(optionalBrackets)
+            )?.groups?.name
+          );
+          spec.optional = true;
+        } else {
+          spec.optional = false;
+        }
+
+        spec.name = name;
+        const {tokens} = spec.source[0];
+        tokens.name = name;
+        tokens.postName = postName;
+        tokens.description = description;
+        tokens.lineEnd = lineEnd || '';
+
+        return spec;
+      }
+
+      if (noNames.includes(spec.tag) || hasSeeWithLink(spec)) {
+        return spec;
+      }
+
+      return plainNameTokenizer(spec);
+    },
+
+    /**
+     * Description tokenizer.
+     * @param {import('comment-parser').Spec} spec
+     * @returns {import('comment-parser').Spec}
+     */
+    (spec) => {
+      return preserveDescriptionTokenizer(spec);
+    }
+  ];
+};
+
+/**
+ * Accepts a comment token or complete comment string and converts it into
+ * `comment-parser` AST.
+ * @param {string | {value: string}} commentOrNode
+ * @param {string} [indent] Whitespace
+ * @returns {import('.').JsdocBlockWithInline}
+ */
+const parseComment = (commentOrNode, indent = '') => {
+  let block;
+
+  switch (typeof commentOrNode) {
+  case 'string':
+    // Preserve JSDoc block start/end indentation.
+    [block] = commentParser(`${indent}${commentOrNode}`, {
+      // @see https://github.com/yavorskiy/comment-parser/issues/21
+      tokenizers: getTokenizers()
+    });
+    break;
+
+  case 'object':
+    if (commentOrNode === null) {
+      throw new TypeError(`'commentOrNode' is not a string or object.`);
+    }
+
+    // Preserve JSDoc block start/end indentation.
+    [block] = commentParser(`${indent}/*${commentOrNode.value}*/`, {
+      // @see https://github.com/yavorskiy/comment-parser/issues/21
+      tokenizers: getTokenizers()
+    });
+    break;
+
+  default:
+    throw new TypeError(`'commentOrNode' is not a string or object.`);
+  }
+
+  return parseInlineTags(block);
+};
+
+export {getTokenizers, parseComment};

node_modules/@es-joy/jsdoccomment/src/parseInlineTags.js

@@ -0,0 +1,108 @@
+/**
+ * @param {RegExpMatchArray & {
+ *   indices: {
+ *     groups: {
+ *       [key: string]: [number, number]
+ *     }
+ *   }
+ *   groups: {[key: string]: string}
+ * }} match An inline tag regexp match.
+ * @returns {'pipe' | 'plain' | 'prefix' | 'space'}
+ */
+function determineFormat (match) {
+  const {separator, text} = match.groups;
+  const [, textEnd] = match.indices.groups.text;
+  const [tagStart] = match.indices.groups.tag;
+  if (!text) {
+    return 'plain';
+  } else if (separator === '|') {
+    return 'pipe';
+  } else if (textEnd < tagStart) {
+    return 'prefix';
+  }
+  return 'space';
+}
+
+/**
+ * Extracts inline tags from a description.
+ * @param {string} description
+ * @returns {import('.').InlineTag[]} Array of inline tags from the description.
+ */
+function parseDescription (description) {
+  /** @type {import('.').InlineTag[]} */
+  const result = [];
+
+  // This could have been expressed in a single pattern,
+  // but having two avoids a potentially exponential time regex.
+
+  const prefixedTextPattern = new RegExp(/(?:\[(?<text>[^\]]+)\])\{@(?<tag>[^}\s]+)\s?(?<namepathOrURL>[^}\s|]*)\}/gu, 'gud');
+  // The pattern used to match for text after tag uses a negative lookbehind
+  // on the ']' char to avoid matching the prefixed case too.
+  const suffixedAfterPattern = new RegExp(/(?<!\])\{@(?<tag>[^}\s]+)\s?(?<namepathOrURL>[^}\s|]*)\s*(?<separator>[\s|])?\s*(?<text>[^}]*)\}/gu, 'gud');
+
+  const matches = [
+    ...description.matchAll(prefixedTextPattern),
+    ...description.matchAll(suffixedAfterPattern)
+  ];
+
+  for (const mtch of matches) {
+    const match = /**
+      * @type {RegExpMatchArray & {
+      *   indices: {
+      *     groups: {
+      *       [key: string]: [number, number]
+      *     }
+      *   }
+      *   groups: {[key: string]: string}
+      * }}
+      */ (
+        mtch
+      );
+    const {tag, namepathOrURL, text} = match.groups;
+    const [start, end] = match.indices[0];
+    const format = determineFormat(match);
+
+    result.push({
+      tag,
+      namepathOrURL,
+      text,
+      format,
+      start,
+      end
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Splits the `{@prefix}` from remaining `Spec.lines[].token.description`
+ * into the `inlineTags` tokens, and populates `spec.inlineTags`
+ * @param {import('comment-parser').Block} block
+ * @returns {import('.').JsdocBlockWithInline}
+ */
+export function parseInlineTags (block) {
+  const inlineTags =
+    /**
+     * @type {(import('./commentParserToESTree').JsdocInlineTagNoType & {
+     *   line?: import('./commentParserToESTree').Integer
+     * })[]}
+     */ (
+      parseDescription(block.description)
+    );
+
+  /** @type {import('.').JsdocBlockWithInline} */ (
+    block
+  ).inlineTags = inlineTags;
+
+  for (const tag of block.tags) {
+    /**
+     * @type {import('.').JsdocTagWithInline}
+     */ (tag).inlineTags = parseDescription(tag.description);
+  }
+  return (
+    /**
+     * @type {import('.').JsdocBlockWithInline}
+     */ (block)
+  );
+}

node_modules/@es-joy/jsdoccomment/src/toCamelCase.js

@@ -0,0 +1,13 @@
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+const toCamelCase = (str) => {
+  return str.toLowerCase().replaceAll(/^[a-z]/gu, (init) => {
+    return init.toUpperCase();
+  }).replaceAll(/_(?<wordInit>[a-z])/gu, (_, n1, o, s, {wordInit}) => {
+    return wordInit.toUpperCase();
+  });
+};
+
+export {toCamelCase};

node_modules/@eslint-community/eslint-utils/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Toru Nagashima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@eslint-community/eslint-utils/README.md

@@ -0,0 +1,37 @@
+# @eslint-community/eslint-utils
+
+[![npm version](https://img.shields.io/npm/v/@eslint-community/eslint-utils.svg)](https://www.npmjs.com/package/@eslint-community/eslint-utils)
+[![Downloads/month](https://img.shields.io/npm/dm/@eslint-community/eslint-utils.svg)](http://www.npmtrends.com/@eslint-community/eslint-utils)
+[![Build Status](https://github.com/eslint-community/eslint-utils/workflows/CI/badge.svg)](https://github.com/eslint-community/eslint-utils/actions)
+[![Coverage Status](https://codecov.io/gh/eslint-community/eslint-utils/branch/main/graph/badge.svg)](https://codecov.io/gh/eslint-community/eslint-utils)
+
+## 🏁 Goal
+
+This package provides utility functions and classes for make ESLint custom rules.
+
+For examples:
+
+-   [`getStaticValue`](https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue) evaluates static value on AST.
+-   [`ReferenceTracker`](https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class) checks the members of modules/globals as handling assignments and destructuring.
+
+## 📖 Usage
+
+See [documentation](https://eslint-community.github.io/eslint-utils).
+
+## 📰 Changelog
+
+See [releases](https://github.com/eslint-community/eslint-utils/releases).
+
+## ❤️ Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+### Development Tools
+
+-   `npm test` runs tests and measures coverage.
+-   `npm run clean` removes the coverage result of `npm test` command.
+-   `npm run coverage` shows the coverage result of the last `npm test` command.
+-   `npm run lint` runs ESLint.
+-   `npm run watch` runs tests on each file change.

node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/README.md

@@ -0,0 +1,105 @@
+# eslint-visitor-keys
+
+[![npm version](https://img.shields.io/npm/v/eslint-visitor-keys.svg)](https://www.npmjs.com/package/eslint-visitor-keys)
+[![Downloads/month](https://img.shields.io/npm/dm/eslint-visitor-keys.svg)](http://www.npmtrends.com/eslint-visitor-keys)
+[![Build Status](https://github.com/eslint/eslint-visitor-keys/workflows/CI/badge.svg)](https://github.com/eslint/eslint-visitor-keys/actions)
+
+Constants and utilities about visitor keys to traverse AST.
+
+## 💿 Installation
+
+Use [npm] to install.
+
+```bash
+$ npm install eslint-visitor-keys
+```
+
+### Requirements
+
+- [Node.js] `^12.22.0`, `^14.17.0`, or `>=16.0.0`
+
+
+## 📖 Usage
+
+To use in an ESM file:
+
+```js
+import * as evk from "eslint-visitor-keys"
+```
+
+To use in a CommonJS file:
+
+```js
+const evk = require("eslint-visitor-keys")
+```
+
+### evk.KEYS
+
+> type: `{ [type: string]: string[] | undefined }`
+
+Visitor keys. This keys are frozen.
+
+This is an object. Keys are the type of [ESTree] nodes. Their values are an array of property names which have child nodes.
+
+For example:
+
+```
+console.log(evk.KEYS.AssignmentExpression) // → ["left", "right"]
+```
+
+### evk.getKeys(node)
+
+> type: `(node: object) => string[]`
+
+Get the visitor keys of a given AST node.
+
+This is similar to `Object.keys(node)` of ES Standard, but some keys are excluded: `parent`, `leadingComments`, `trailingComments`, and names which start with `_`.
+
+This will be used to traverse unknown nodes.
+
+For example:
+
+```js
+const node = {
+    type: "AssignmentExpression",
+    left: { type: "Identifier", name: "foo" },
+    right: { type: "Literal", value: 0 }
+}
+console.log(evk.getKeys(node)) // → ["type", "left", "right"]
+```
+
+### evk.unionWith(additionalKeys)
+
+> type: `(additionalKeys: object) => { [type: string]: string[] | undefined }`
+
+Make the union set with `evk.KEYS` and the given keys.
+
+- The order of keys is, `additionalKeys` is at first, then `evk.KEYS` is concatenated after that.
+- It removes duplicated keys as keeping the first one.
+
+For example:
+
+```js
+console.log(evk.unionWith({
+    MethodDefinition: ["decorators"]
+})) // → { ..., MethodDefinition: ["decorators", "key", "value"], ... }
+```
+
+## 📰 Change log
+
+See [GitHub releases](https://github.com/eslint/eslint-visitor-keys/releases).
+
+## 🍻 Contributing
+
+Welcome. See [ESLint contribution guidelines](https://eslint.org/docs/developer-guide/contributing/).
+
+### Development commands
+
+- `npm test` runs tests and measures code coverage.
+- `npm run lint` checks source codes with ESLint.
+- `npm run test:open-coverage` opens the code coverage report of the previous test with your default browser.
+
+
+[npm]: https://www.npmjs.com/
+[Node.js]: https://nodejs.org/
+[ESTree]: https://github.com/estree/estree

node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.cjs

@@ -0,0 +1,384 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+ */
+
+/**
+ * @type {VisitorKeys}
+ */
+const KEYS = {
+    ArrayExpression: [
+        "elements"
+    ],
+    ArrayPattern: [
+        "elements"
+    ],
+    ArrowFunctionExpression: [
+        "params",
+        "body"
+    ],
+    AssignmentExpression: [
+        "left",
+        "right"
+    ],
+    AssignmentPattern: [
+        "left",
+        "right"
+    ],
+    AwaitExpression: [
+        "argument"
+    ],
+    BinaryExpression: [
+        "left",
+        "right"
+    ],
+    BlockStatement: [
+        "body"
+    ],
+    BreakStatement: [
+        "label"
+    ],
+    CallExpression: [
+        "callee",
+        "arguments"
+    ],
+    CatchClause: [
+        "param",
+        "body"
+    ],
+    ChainExpression: [
+        "expression"
+    ],
+    ClassBody: [
+        "body"
+    ],
+    ClassDeclaration: [
+        "id",
+        "superClass",
+        "body"
+    ],
+    ClassExpression: [
+        "id",
+        "superClass",
+        "body"
+    ],
+    ConditionalExpression: [
+        "test",
+        "consequent",
+        "alternate"
+    ],
+    ContinueStatement: [
+        "label"
+    ],
+    DebuggerStatement: [],
+    DoWhileStatement: [
+        "body",
+        "test"
+    ],
+    EmptyStatement: [],
+    ExperimentalRestProperty: [
+        "argument"
+    ],
+    ExperimentalSpreadProperty: [
+        "argument"
+    ],
+    ExportAllDeclaration: [
+        "exported",
+        "source"
+    ],
+    ExportDefaultDeclaration: [
+        "declaration"
+    ],
+    ExportNamedDeclaration: [
+        "declaration",
+        "specifiers",
+        "source"
+    ],
+    ExportSpecifier: [
+        "exported",
+        "local"
+    ],
+    ExpressionStatement: [
+        "expression"
+    ],
+    ForInStatement: [
+        "left",
+        "right",
+        "body"
+    ],
+    ForOfStatement: [
+        "left",
+        "right",
+        "body"
+    ],
+    ForStatement: [
+        "init",
+        "test",
+        "update",
+        "body"
+    ],
+    FunctionDeclaration: [
+        "id",
+        "params",
+        "body"
+    ],
+    FunctionExpression: [
+        "id",
+        "params",
+        "body"
+    ],
+    Identifier: [],
+    IfStatement: [
+        "test",
+        "consequent",
+        "alternate"
+    ],
+    ImportDeclaration: [
+        "specifiers",
+        "source"
+    ],
+    ImportDefaultSpecifier: [
+        "local"
+    ],
+    ImportExpression: [
+        "source"
+    ],
+    ImportNamespaceSpecifier: [
+        "local"
+    ],
+    ImportSpecifier: [
+        "imported",
+        "local"
+    ],
+    JSXAttribute: [
+        "name",
+        "value"
+    ],
+    JSXClosingElement: [
+        "name"
+    ],
+    JSXClosingFragment: [],
+    JSXElement: [
+        "openingElement",
+        "children",
+        "closingElement"
+    ],
+    JSXEmptyExpression: [],
+    JSXExpressionContainer: [
+        "expression"
+    ],
+    JSXFragment: [
+        "openingFragment",
+        "children",
+        "closingFragment"
+    ],
+    JSXIdentifier: [],
+    JSXMemberExpression: [
+        "object",
+        "property"
+    ],
+    JSXNamespacedName: [
+        "namespace",
+        "name"
+    ],
+    JSXOpeningElement: [
+        "name",
+        "attributes"
+    ],
+    JSXOpeningFragment: [],
+    JSXSpreadAttribute: [
+        "argument"
+    ],
+    JSXSpreadChild: [
+        "expression"
+    ],
+    JSXText: [],
+    LabeledStatement: [
+        "label",
+        "body"
+    ],
+    Literal: [],
+    LogicalExpression: [
+        "left",
+        "right"
+    ],
+    MemberExpression: [
+        "object",
+        "property"
+    ],
+    MetaProperty: [
+        "meta",
+        "property"
+    ],
+    MethodDefinition: [
+        "key",
+        "value"
+    ],
+    NewExpression: [
+        "callee",
+        "arguments"
+    ],
+    ObjectExpression: [
+        "properties"
+    ],
+    ObjectPattern: [
+        "properties"
+    ],
+    PrivateIdentifier: [],
+    Program: [
+        "body"
+    ],
+    Property: [
+        "key",
+        "value"
+    ],
+    PropertyDefinition: [
+        "key",
+        "value"
+    ],
+    RestElement: [
+        "argument"
+    ],
+    ReturnStatement: [
+        "argument"
+    ],
+    SequenceExpression: [
+        "expressions"
+    ],
+    SpreadElement: [
+        "argument"
+    ],
+    StaticBlock: [
+        "body"
+    ],
+    Super: [],
+    SwitchCase: [
+        "test",
+        "consequent"
+    ],
+    SwitchStatement: [
+        "discriminant",
+        "cases"
+    ],
+    TaggedTemplateExpression: [
+        "tag",
+        "quasi"
+    ],
+    TemplateElement: [],
+    TemplateLiteral: [
+        "quasis",
+        "expressions"
+    ],
+    ThisExpression: [],
+    ThrowStatement: [
+        "argument"
+    ],
+    TryStatement: [
+        "block",
+        "handler",
+        "finalizer"
+    ],
+    UnaryExpression: [
+        "argument"
+    ],
+    UpdateExpression: [
+        "argument"
+    ],
+    VariableDeclaration: [
+        "declarations"
+    ],
+    VariableDeclarator: [
+        "id",
+        "init"
+    ],
+    WhileStatement: [
+        "test",
+        "body"
+    ],
+    WithStatement: [
+        "object",
+        "body"
+    ],
+    YieldExpression: [
+        "argument"
+    ]
+};
+
+// Types.
+const NODE_TYPES = Object.keys(KEYS);
+
+// Freeze the keys.
+for (const type of NODE_TYPES) {
+    Object.freeze(KEYS[type]);
+}
+Object.freeze(KEYS);
+
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+/**
+ * @typedef {import('./visitor-keys.js').VisitorKeys} VisitorKeys
+ */
+
+// List to ignore keys.
+const KEY_BLACKLIST = new Set([
+    "parent",
+    "leadingComments",
+    "trailingComments"
+]);
+
+/**
+ * Check whether a given key should be used or not.
+ * @param {string} key The key to check.
+ * @returns {boolean} `true` if the key should be used.
+ */
+function filterKey(key) {
+    return !KEY_BLACKLIST.has(key) && key[0] !== "_";
+}
+
+/**
+ * Get visitor keys of a given node.
+ * @param {object} node The AST node to get keys.
+ * @returns {readonly string[]} Visitor keys of the node.
+ */
+function getKeys(node) {
+    return Object.keys(node).filter(filterKey);
+}
+
+// Disable valid-jsdoc rule because it reports syntax error on the type of @returns.
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Make the union set with `KEYS` and given keys.
+ * @param {VisitorKeys} additionalKeys The additional keys.
+ * @returns {VisitorKeys} The union set.
+ */
+function unionWith(additionalKeys) {
+    const retv = /** @type {{
+        [type: string]: ReadonlyArray<string>
+    }} */ (Object.assign({}, KEYS));
+
+    for (const type of Object.keys(additionalKeys)) {
+        if (Object.prototype.hasOwnProperty.call(retv, type)) {
+            const keys = new Set(additionalKeys[type]);
+
+            for (const key of retv[type]) {
+                keys.add(key);
+            }
+
+            retv[type] = Object.freeze(Array.from(keys));
+        } else {
+            retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+        }
+    }
+
+    return Object.freeze(retv);
+}
+
+exports.KEYS = KEYS;
+exports.getKeys = getKeys;
+exports.unionWith = unionWith;

node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.d.cts

@@ -0,0 +1,27 @@
+type VisitorKeys$1 = {
+    readonly [type: string]: readonly string[];
+};
+/**
+ * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+ */
+/**
+ * @type {VisitorKeys}
+ */
+declare const KEYS: VisitorKeys$1;
+
+/**
+ * Get visitor keys of a given node.
+ * @param {object} node The AST node to get keys.
+ * @returns {readonly string[]} Visitor keys of the node.
+ */
+declare function getKeys(node: object): readonly string[];
+/**
+ * Make the union set with `KEYS` and given keys.
+ * @param {VisitorKeys} additionalKeys The additional keys.
+ * @returns {VisitorKeys} The union set.
+ */
+declare function unionWith(additionalKeys: VisitorKeys): VisitorKeys;
+
+type VisitorKeys = VisitorKeys$1;
+
+export { KEYS, VisitorKeys, getKeys, unionWith };

node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Get visitor keys of a given node.
+ * @param {object} node The AST node to get keys.
+ * @returns {readonly string[]} Visitor keys of the node.
+ */
+export function getKeys(node: object): readonly string[];
+/**
+ * Make the union set with `KEYS` and given keys.
+ * @param {VisitorKeys} additionalKeys The additional keys.
+ * @returns {VisitorKeys} The union set.
+ */
+export function unionWith(additionalKeys: VisitorKeys): VisitorKeys;
+export { KEYS };
+export type VisitorKeys = import('./visitor-keys.js').VisitorKeys;
+import KEYS from "./visitor-keys.js";
+//# sourceMappingURL=index.d.ts.map

node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/dist/visitor-keys.d.ts

@@ -0,0 +1,12 @@
+export default KEYS;
+export type VisitorKeys = {
+    readonly [type: string]: readonly string[];
+};
+/**
+ * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+ */
+/**
+ * @type {VisitorKeys}
+ */
+declare const KEYS: VisitorKeys;
+//# sourceMappingURL=visitor-keys.d.ts.map

node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/lib/index.js

@@ -0,0 +1,65 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+import KEYS from "./visitor-keys.js";
+
+/**
+ * @typedef {import('./visitor-keys.js').VisitorKeys} VisitorKeys
+ */
+
+// List to ignore keys.
+const KEY_BLACKLIST = new Set([
+    "parent",
+    "leadingComments",
+    "trailingComments"
+]);
+
+/**
+ * Check whether a given key should be used or not.
+ * @param {string} key The key to check.
+ * @returns {boolean} `true` if the key should be used.
+ */
+function filterKey(key) {
+    return !KEY_BLACKLIST.has(key) && key[0] !== "_";
+}
+
+/**
+ * Get visitor keys of a given node.
+ * @param {object} node The AST node to get keys.
+ * @returns {readonly string[]} Visitor keys of the node.
+ */
+export function getKeys(node) {
+    return Object.keys(node).filter(filterKey);
+}
+
+// Disable valid-jsdoc rule because it reports syntax error on the type of @returns.
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Make the union set with `KEYS` and given keys.
+ * @param {VisitorKeys} additionalKeys The additional keys.
+ * @returns {VisitorKeys} The union set.
+ */
+export function unionWith(additionalKeys) {
+    const retv = /** @type {{
+        [type: string]: ReadonlyArray<string>
+    }} */ (Object.assign({}, KEYS));
+
+    for (const type of Object.keys(additionalKeys)) {
+        if (Object.prototype.hasOwnProperty.call(retv, type)) {
+            const keys = new Set(additionalKeys[type]);
+
+            for (const key of retv[type]) {
+                keys.add(key);
+            }
+
+            retv[type] = Object.freeze(Array.from(keys));
+        } else {
+            retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+        }
+    }
+
+    return Object.freeze(retv);
+}
+
+export { KEYS };

node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys/lib/visitor-keys.js

@@ -0,0 +1,315 @@
+/**
+ * @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
+ */
+
+/**
+ * @type {VisitorKeys}
+ */
+const KEYS = {
+    ArrayExpression: [
+        "elements"
+    ],
+    ArrayPattern: [
+        "elements"
+    ],
+    ArrowFunctionExpression: [
+        "params",
+        "body"
+    ],
+    AssignmentExpression: [
+        "left",
+        "right"
+    ],
+    AssignmentPattern: [
+        "left",
+        "right"
+    ],
+    AwaitExpression: [
+        "argument"
+    ],
+    BinaryExpression: [
+        "left",
+        "right"
+    ],
+    BlockStatement: [
+        "body"
+    ],
+    BreakStatement: [
+        "label"
+    ],
+    CallExpression: [
+        "callee",
+        "arguments"
+    ],
+    CatchClause: [
+        "param",
+        "body"
+    ],
+    ChainExpression: [
+        "expression"
+    ],
+    ClassBody: [
+        "body"
+    ],
+    ClassDeclaration: [
+        "id",
+        "superClass",
+        "body"
+    ],
+    ClassExpression: [
+        "id",
+        "superClass",
+        "body"
+    ],
+    ConditionalExpression: [
+        "test",
+        "consequent",
+        "alternate"
+    ],
+    ContinueStatement: [
+        "label"
+    ],
+    DebuggerStatement: [],
+    DoWhileStatement: [
+        "body",
+        "test"
+    ],
+    EmptyStatement: [],
+    ExperimentalRestProperty: [
+        "argument"
+    ],
+    ExperimentalSpreadProperty: [
+        "argument"
+    ],
+    ExportAllDeclaration: [
+        "exported",
+        "source"
+    ],
+    ExportDefaultDeclaration: [
+        "declaration"
+    ],
+    ExportNamedDeclaration: [
+        "declaration",
+        "specifiers",
+        "source"
+    ],
+    ExportSpecifier: [
+        "exported",
+        "local"
+    ],
+    ExpressionStatement: [
+        "expression"
+    ],
+    ForInStatement: [
+        "left",
+        "right",
+        "body"
+    ],
+    ForOfStatement: [
+        "left",
+        "right",
+        "body"
+    ],
+    ForStatement: [
+        "init",
+        "test",
+        "update",
+        "body"
+    ],
+    FunctionDeclaration: [
+        "id",
+        "params",
+        "body"
+    ],
+    FunctionExpression: [
+        "id",
+        "params",
+        "body"
+    ],
+    Identifier: [],
+    IfStatement: [
+        "test",
+        "consequent",
+        "alternate"
+    ],
+    ImportDeclaration: [
+        "specifiers",
+        "source"
+    ],
+    ImportDefaultSpecifier: [
+        "local"
+    ],
+    ImportExpression: [
+        "source"
+    ],
+    ImportNamespaceSpecifier: [
+        "local"
+    ],
+    ImportSpecifier: [
+        "imported",
+        "local"
+    ],
+    JSXAttribute: [
+        "name",
+        "value"
+    ],
+    JSXClosingElement: [
+        "name"
+    ],
+    JSXClosingFragment: [],
+    JSXElement: [
+        "openingElement",
+        "children",
+        "closingElement"
+    ],
+    JSXEmptyExpression: [],
+    JSXExpressionContainer: [
+        "expression"
+    ],
+    JSXFragment: [
+        "openingFragment",
+        "children",
+        "closingFragment"
+    ],
+    JSXIdentifier: [],
+    JSXMemberExpression: [
+        "object",
+        "property"
+    ],
+    JSXNamespacedName: [
+        "namespace",
+        "name"
+    ],
+    JSXOpeningElement: [
+        "name",
+        "attributes"
+    ],
+    JSXOpeningFragment: [],
+    JSXSpreadAttribute: [
+        "argument"
+    ],
+    JSXSpreadChild: [
+        "expression"
+    ],
+    JSXText: [],
+    LabeledStatement: [
+        "label",
+        "body"
+    ],
+    Literal: [],
+    LogicalExpression: [
+        "left",
+        "right"
+    ],
+    MemberExpression: [
+        "object",
+        "property"
+    ],
+    MetaProperty: [
+        "meta",
+        "property"
+    ],
+    MethodDefinition: [
+        "key",
+        "value"
+    ],
+    NewExpression: [
+        "callee",
+        "arguments"
+    ],
+    ObjectExpression: [
+        "properties"
+    ],
+    ObjectPattern: [
+        "properties"
+    ],
+    PrivateIdentifier: [],
+    Program: [
+        "body"
+    ],
+    Property: [
+        "key",
+        "value"
+    ],
+    PropertyDefinition: [
+        "key",
+        "value"
+    ],
+    RestElement: [
+        "argument"
+    ],
+    ReturnStatement: [
+        "argument"
+    ],
+    SequenceExpression: [
+        "expressions"
+    ],
+    SpreadElement: [
+        "argument"
+    ],
+    StaticBlock: [
+        "body"
+    ],
+    Super: [],
+    SwitchCase: [
+        "test",
+        "consequent"
+    ],
+    SwitchStatement: [
+        "discriminant",
+        "cases"
+    ],
+    TaggedTemplateExpression: [
+        "tag",
+        "quasi"
+    ],
+    TemplateElement: [],
+    TemplateLiteral: [
+        "quasis",
+        "expressions"
+    ],
+    ThisExpression: [],
+    ThrowStatement: [
+        "argument"
+    ],
+    TryStatement: [
+        "block",
+        "handler",
+        "finalizer"
+    ],
+    UnaryExpression: [
+        "argument"
+    ],
+    UpdateExpression: [
+        "argument"
+    ],
+    VariableDeclaration: [
+        "declarations"
+    ],
+    VariableDeclarator: [
+        "id",
+        "init"
+    ],
+    WhileStatement: [
+        "test",
+        "body"
+    ],
+    WithStatement: [
+        "object",
+        "body"
+    ],
+    YieldExpression: [
+        "argument"
+    ]
+};
+
+// Types.
+const NODE_TYPES = Object.keys(KEYS);
+
+// Freeze the keys.
+for (const type of NODE_TYPES) {
+    Object.freeze(KEYS[type]);
+}
+Object.freeze(KEYS);
+
+export default KEYS;