@archivist-gg/dnd5e 0.1.0

package/dist/chunk-R2ZV233X.js

@@ -0,0 +1,233 @@
+// src/pc/pc.conditions.ts
+var ZERO_EFFECTS = {
+  speed_multiplier: 1,
+  speed_reduction_ft: 0,
+  speed_floor_zero: false,
+  hp_max_multiplier: 1,
+  d20_test_penalty: 0,
+  exhaustion_level: 0,
+  attack_disadvantage: false,
+  attack_advantage: false,
+  attack_advantage_against: false,
+  ability_check_disadvantage: false,
+  save_disadvantage_dex: false,
+  save_autofail_str: false,
+  save_autofail_dex: false,
+  saves_disadvantage_all: false,
+  actions_disabled: false,
+  reactions_disabled: false,
+  sources: []
+};
+var CONDITION_EFFECTS_2014 = {
+  blinded: { attack_disadvantage: true, attack_advantage_against: true },
+  charmed: {},
+  deafened: {},
+  frightened: { attack_disadvantage: true, ability_check_disadvantage: true },
+  grappled: { speed_floor_zero: true },
+  incapacitated: { actions_disabled: true, reactions_disabled: true },
+  invisible: { attack_advantage: true },
+  paralyzed: {
+    speed_floor_zero: true,
+    save_autofail_str: true,
+    save_autofail_dex: true,
+    attack_advantage_against: true,
+    actions_disabled: true,
+    reactions_disabled: true
+  },
+  petrified: {
+    speed_floor_zero: true,
+    save_autofail_str: true,
+    save_autofail_dex: true,
+    attack_advantage_against: true,
+    actions_disabled: true,
+    reactions_disabled: true
+  },
+  poisoned: { attack_disadvantage: true, ability_check_disadvantage: true },
+  prone: { attack_disadvantage: true },
+  restrained: {
+    speed_floor_zero: true,
+    attack_disadvantage: true,
+    attack_advantage_against: true,
+    save_disadvantage_dex: true
+  },
+  stunned: {
+    save_autofail_str: true,
+    save_autofail_dex: true,
+    attack_advantage_against: true,
+    actions_disabled: true,
+    reactions_disabled: true
+  },
+  unconscious: {
+    speed_floor_zero: true,
+    save_autofail_str: true,
+    save_autofail_dex: true,
+    attack_advantage_against: true,
+    actions_disabled: true,
+    reactions_disabled: true
+  }
+};
+var CONDITION_EFFECTS_2024 = {
+  ...CONDITION_EFFECTS_2014,
+  grappled: { speed_floor_zero: true, attack_disadvantage: true }
+};
+var EXHAUSTION_EFFECTS_2014 = {
+  0: {},
+  1: { ability_check_disadvantage: true },
+  2: { ability_check_disadvantage: true, speed_multiplier: 0.5 },
+  3: {
+    ability_check_disadvantage: true,
+    speed_multiplier: 0.5,
+    attack_disadvantage: true,
+    saves_disadvantage_all: true
+  },
+  4: {
+    ability_check_disadvantage: true,
+    speed_multiplier: 0.5,
+    attack_disadvantage: true,
+    saves_disadvantage_all: true,
+    hp_max_multiplier: 0.5
+  },
+  5: {
+    ability_check_disadvantage: true,
+    speed_multiplier: 0.5,
+    attack_disadvantage: true,
+    saves_disadvantage_all: true,
+    hp_max_multiplier: 0.5,
+    speed_floor_zero: true
+  },
+  6: {
+    ability_check_disadvantage: true,
+    speed_multiplier: 0.5,
+    attack_disadvantage: true,
+    saves_disadvantage_all: true,
+    hp_max_multiplier: 0.5,
+    speed_floor_zero: true
+  }
+};
+function exhaustionEffects2024(level) {
+  if (level <= 0) return {};
+  return {
+    d20_test_penalty: -2 * level,
+    speed_reduction_ft: 5 * level
+  };
+}
+var CONDITION_TOOLTIPS_2014 = {
+  blinded: ["Auto-fail any check requiring sight."],
+  charmed: [
+    "Can't attack the charmer or target them with harmful effects.",
+    "Charmer has advantage on social checks against you."
+  ],
+  deafened: ["Auto-fail any check requiring hearing."],
+  frightened: [
+    "Disadvantage on attacks/checks while source in line of sight.",
+    "Can't willingly move closer to source."
+  ],
+  grappled: ["Speed = 0. Ends if grappler is incapacitated or you're moved out of reach."],
+  incapacitated: ["Can't take actions or reactions."],
+  invisible: [
+    "Heavily obscured for hiding.",
+    "Your attacks have advantage; attacks against you have disadvantage.",
+    "Detectable by noise/tracks."
+  ],
+  paralyzed: [
+    "Incapacitated. Speed 0.",
+    "Auto-fail STR/DEX saves.",
+    "Attacks against have advantage; melee within 5ft auto-crit."
+  ],
+  petrified: [
+    "Incapacitated. Speed 0.",
+    "Resist all damage. Immune to poison/disease.",
+    "Auto-fail STR/DEX saves."
+  ],
+  poisoned: ["Disadvantage on attack rolls and ability checks."],
+  prone: [
+    "Attacks against within 5ft have advantage; beyond 5ft have disadvantage.",
+    "Your attacks have disadvantage."
+  ],
+  restrained: [
+    "Speed 0. Disadvantage on attacks and DEX saves.",
+    "Attacks against have advantage."
+  ],
+  stunned: [
+    "Incapacitated. Auto-fail STR/DEX saves.",
+    "Attacks against have advantage."
+  ],
+  unconscious: [
+    "Incapacitated, prone, dropped held items. Speed 0.",
+    "Auto-fail STR/DEX saves.",
+    "Attacks against have advantage; melee within 5ft auto-crit."
+  ]
+};
+var CONDITION_TOOLTIPS_2024 = {
+  ...CONDITION_TOOLTIPS_2014,
+  grappled: [
+    "Speed = 0. Disadvantage on attack rolls against creatures other than the grappler.",
+    "Ends if grappler is incapacitated or you're moved out of reach."
+  ]
+};
+function computeConditionEffects(state, edition, _scores) {
+  var _a, _b;
+  const out = { ...ZERO_EFFECTS, sources: [] };
+  const conditionTable = edition === "2024" ? CONDITION_EFFECTS_2024 : CONDITION_EFFECTS_2014;
+  const tooltipTable = edition === "2024" ? CONDITION_TOOLTIPS_2024 : CONDITION_TOOLTIPS_2014;
+  const sortedConditions = [...new Set(state.conditions)].sort();
+  for (const slug of sortedConditions) {
+    const partial = conditionTable[slug];
+    if (!partial) continue;
+    mergePartial(out, partial);
+    out.sources.push({
+      condition: slug,
+      effects: (_a = tooltipTable[slug]) != null ? _a : []
+    });
+  }
+  const exhLevel = clamp((_b = state.exhaustion) != null ? _b : 0, 0, 6);
+  out.exhaustion_level = exhLevel;
+  if (exhLevel > 0) {
+    const exhPartial = edition === "2024" ? exhaustionEffects2024(exhLevel) : EXHAUSTION_EFFECTS_2014[exhLevel];
+    mergePartial(out, exhPartial);
+    out.sources.push({
+      condition: "exhaustion",
+      level: exhLevel,
+      effects: exhaustionTooltip(exhLevel, edition)
+    });
+  }
+  return out;
+}
+function mergePartial(out, partial) {
+  for (const k of Object.keys(partial)) {
+    const v = partial[k];
+    if (typeof v === "boolean") {
+      out[k] = out[k] || v;
+    } else if (typeof v === "number") {
+      if (k === "speed_multiplier" || k === "hp_max_multiplier") {
+        out[k] = Math.min(out[k], v);
+      } else {
+        out[k] = out[k] + v;
+      }
+    }
+  }
+}
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(hi, Math.floor(n)));
+}
+function exhaustionTooltip(level, edition) {
+  if (edition === "2024") {
+    return [
+      `\u2212${2 * level} on all d20 tests (attacks, saves, ability checks).`,
+      `Speed reduced by ${5 * level} ft.`,
+      level >= 6 ? "Death." : `Long rest reduces by 1 level.`
+    ];
+  }
+  const lines = [];
+  if (level >= 1) lines.push("Disadvantage on ability checks.");
+  if (level >= 2) lines.push("Speed halved.");
+  if (level >= 3) lines.push("Disadvantage on attack rolls and saving throws.");
+  if (level >= 4) lines.push("Hit point maximum halved.");
+  if (level >= 5) lines.push("Speed reduced to 0.");
+  if (level >= 6) lines.push("Death.");
+  return lines;
+}
+
+export {
+  computeConditionEffects
+};

package/dist/chunk-RAWJTA45.js

@@ -0,0 +1,271 @@
+import {
+  abilityModifier
+} from "./chunk-NAEPSZAM.js";
+
+// src/dnd/srd-tag-converter.ts
+var ABILITY_KEYS = ["str", "dex", "con", "int", "wis", "cha"];
+var STATIC_FALLBACK_CONTEXT = {
+  abilities: { str: 0, dex: 0, con: 0, int: 0, wis: 0, cha: 0 },
+  profBonus: 0,
+  actionName: "",
+  actionCategory: "trait"
+};
+var NATURAL_MELEE_NAMES = /\b(bite|claws?|slam|gore|tail|hooves|tusks?|talons?|fist|horns?)\b/i;
+var FINESSE_WEAPON_NAMES = /\b(shortsword|rapier|dagger|whip|scimitar)\b/i;
+var RANGED_WEAPON_NAMES = /\b(bow|crossbow|sling|dart|blowgun|javelin)\b/i;
+var SPELL_ATTACK_PHRASES = /\bspell\s+attack\b/i;
+function preferredAbilitiesForAttack(actionName, desc, spellAbility) {
+  const combined = `${actionName} ${desc}`;
+  if (SPELL_ATTACK_PHRASES.test(combined) && spellAbility) return [spellAbility];
+  if (RANGED_WEAPON_NAMES.test(actionName)) return ["dex"];
+  if (FINESSE_WEAPON_NAMES.test(actionName)) return ["str", "dex"];
+  if (NATURAL_MELEE_NAMES.test(actionName)) return ["str", "dex"];
+  return ["str", "dex"];
+}
+function identifyAbility(damageBonus, preferred, mods) {
+  if (damageBonus === null) return null;
+  const candidates = ABILITY_KEYS.filter((k) => mods[k] === damageBonus);
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0];
+  for (const p of preferred) {
+    if (candidates.includes(p)) return p;
+  }
+  return [...candidates].sort()[0];
+}
+function parseDamageBonusFromHitText(desc, attackPos) {
+  const window = desc.slice(attackPos, attackPos + 250);
+  const damageRe = /Hit:\s*(?:\d+\s*\()?\d+d\d+(?:\s*([+-])\s*(\d+))?\s*\)?\s*\w*\s+damage/i;
+  const m = window.match(damageRe);
+  if (!m) return null;
+  if (m[1] === void 0 || m[2] === void 0) return 0;
+  return m[1] === "-" ? -Number(m[2]) : Number(m[2]);
+}
+function parseDamageBonusFor2024(desc, attackPos) {
+  const window = desc.slice(attackPos, attackPos + 250);
+  const damageRe = /(?:\d+\s*\()?\d+d\d+(?:\s*([+-])\s*(\d+))?\s*\)?\s*\w*\s+damage/i;
+  const m = window.match(damageRe);
+  if (!m) return null;
+  if (m[1] === void 0 || m[2] === void 0) return 0;
+  return m[1] === "-" ? -Number(m[2]) : Number(m[2]);
+}
+function convertDescToTags(desc, ctx) {
+  try {
+    if (!ctx.abilities) return desc;
+    const mods = computeMods(ctx.abilities);
+    const dcTargets = computeDcTargets(mods, ctx.profBonus);
+    let result = desc;
+    result = result.replace(
+      /(Strength|Dexterity|Constitution|Intelligence|Wisdom|Charisma)\s+Saving\s+Throw:\s+DC\s+(\d+)/gi,
+      (_match, abilityWord, n) => {
+        const dc = Number(n);
+        const abil = abilityWordToKey(abilityWord);
+        if (abil && dcTargets[abil] === dc) {
+          return `${abilityWord} Saving Throw: \`dc:${abil.toUpperCase()}\``;
+        }
+        return `${abilityWord} Saving Throw: \`dc:${dc}\``;
+      }
+    );
+    result = result.replace(
+      /DC (\d+)\s+(Strength|Dexterity|Constitution|Intelligence|Wisdom|Charisma)/gi,
+      (_match, n, abilityWord) => {
+        const dc = Number(n);
+        const abil = abilityWordToKey(abilityWord);
+        if (abil && dcTargets[abil] === dc) {
+          return `\`dc:${abil.toUpperCase()}\` ${abilityWord}`;
+        }
+        return `\`dc:${dc}\` ${abilityWord}`;
+      }
+    );
+    result = result.replace(
+      /(Melee|Ranged|Spell)\s+Attack\s+Roll:\s+([+-])(\d+),/g,
+      (match, kind, sign, n, offset) => {
+        const attackBonus = sign === "-" ? -Number(n) : Number(n);
+        const before = desc.slice(Math.max(0, offset - 200), offset);
+        const actionMatch = before.match(/(?:^|\.\s+)([A-Z][\w\s,'-]{1,40})\./);
+        const actionName = actionMatch ? actionMatch[1] : ctx.actionName;
+        const damageBonus = parseDamageBonusFor2024(desc, offset + match.length);
+        const preferred = kind.toLowerCase() === "spell" && ctx.spellAbility ? [ctx.spellAbility] : preferredAbilitiesForAttack(actionName, desc, ctx.spellAbility);
+        const ability = identifyAbility(damageBonus, preferred, mods);
+        const literal = attackBonus >= 0 ? `+${attackBonus}` : `${attackBonus}`;
+        if (ability === null) {
+          return `${kind} Attack Roll: \`atk:${literal}\`,`;
+        }
+        if (attackBonus === mods[ability] + ctx.profBonus) {
+          return `${kind} Attack Roll: \`atk:${ability.toUpperCase()}+PB\`,`;
+        }
+        if (attackBonus === mods[ability]) {
+          return `${kind} Attack Roll: \`atk:${ability.toUpperCase()}\`,`;
+        }
+        return `${kind} Attack Roll: \`atk:${literal}\`,`;
+      }
+    );
+    result = result.replace(
+      /([+-])(\d+)\s+to\s+hit/g,
+      (_match, sign, n, attackPos) => {
+        const attackBonus = sign === "-" ? -Number(n) : Number(n);
+        const before = desc.slice(Math.max(0, attackPos - 200), attackPos);
+        const actionMatch = before.match(/(?:^|\.\s+)([A-Z][\w\s,'-]{1,40})\./);
+        const actionName = actionMatch ? actionMatch[1] : ctx.actionName;
+        const damageBonus = parseDamageBonusFromHitText(desc, attackPos);
+        const preferred = preferredAbilitiesForAttack(actionName, desc, ctx.spellAbility);
+        const ability = identifyAbility(damageBonus, preferred, mods);
+        if (ability === null) {
+          const literal2 = attackBonus >= 0 ? `+${attackBonus}` : `${attackBonus}`;
+          return `\`atk:${literal2}\``;
+        }
+        if (attackBonus === mods[ability] + ctx.profBonus) {
+          return `\`atk:${ability.toUpperCase()}+PB\``;
+        }
+        if (attackBonus === mods[ability]) {
+          return `\`atk:${ability.toUpperCase()}\``;
+        }
+        const literal = attackBonus >= 0 ? `+${attackBonus}` : `${attackBonus}`;
+        return `\`atk:${literal}\``;
+      }
+    );
+    result = result.replace(
+      /(?:(\d+)\s*\()?(\d+d\d+)(?:\s*([+-])\s*(\d+))?\s*\)?(?:\s+(\w+))?\s+damage/gi,
+      (_match, _average, dice, sign, bonusStr, typeWord) => {
+        var _a;
+        let inner = dice;
+        if (bonusStr != null) {
+          const bonus = sign === "-" ? -Number(bonusStr) : Number(bonusStr);
+          const matchingAbilities = ABILITY_KEYS.filter((k) => mods[k] === bonus);
+          if (matchingAbilities.length > 0) {
+            const preferred = preferredAbilitiesForAttack(ctx.actionName, "", ctx.spellAbility);
+            const pick = (_a = preferred.find((p) => matchingAbilities.includes(p))) != null ? _a : [...matchingAbilities].sort()[0];
+            inner = `${dice}+${pick.toUpperCase()}`;
+          } else {
+            inner = `${dice}${bonus >= 0 ? "+" : ""}${bonus}`;
+          }
+        }
+        const typeSuffix = typeWord ? ` ${typeWord} damage` : " damage";
+        return `\`dmg:${inner}\`${typeSuffix}`;
+      }
+    );
+    result = result.replace(
+      /Hit:\s*(\d+)\s+(\w+)?\s*damage/gi,
+      (_match, n, typeWord) => {
+        const tt = typeWord ? ` ${typeWord} damage` : " damage";
+        return `Hit: \`dmg:${n}\`${tt}`;
+      }
+    );
+    result = result.replace(
+      /(?<!`)DC (\d+)(?!\s*(?:Strength|Dexterity|Constitution|Intelligence|Wisdom|Charisma))/gi,
+      (_match, n) => {
+        const dc = Number(n);
+        const candidates = ABILITY_KEYS.filter((k) => dcTargets[k] === dc);
+        if (ctx.spellAbility && candidates.includes(ctx.spellAbility)) {
+          return `\`dc:${ctx.spellAbility.toUpperCase()}\``;
+        }
+        if (candidates.length === 1) {
+          return `\`dc:${candidates[0].toUpperCase()}\``;
+        }
+        if (candidates.length > 1) {
+          const abil = disambiguateAbility(candidates, ctx, desc);
+          return `\`dc:${abil.toUpperCase()}\``;
+        }
+        return `\`dc:${dc}\``;
+      }
+    );
+    result = result.replace(
+      /`[^`]*`|(?<!\w)(\d+d\d+(?:\s*[+-]\s*\d+)?)(?!\w)/g,
+      (match, dice) => {
+        if (dice) return `\`dice:${dice.replace(/\s+/g, "")}\``;
+        return match;
+      }
+    );
+    return result;
+  } catch (e) {
+    return desc;
+  }
+}
+function computeMods(abilities) {
+  return {
+    str: abilityModifier(abilities.str),
+    dex: abilityModifier(abilities.dex),
+    con: abilityModifier(abilities.con),
+    int: abilityModifier(abilities.int),
+    wis: abilityModifier(abilities.wis),
+    cha: abilityModifier(abilities.cha)
+  };
+}
+function computeDcTargets(mods, profBonus) {
+  return {
+    str: 8 + profBonus + mods.str,
+    dex: 8 + profBonus + mods.dex,
+    con: 8 + profBonus + mods.con,
+    int: 8 + profBonus + mods.int,
+    wis: 8 + profBonus + mods.wis,
+    cha: 8 + profBonus + mods.cha
+  };
+}
+function disambiguateAbility(candidates, ctx, desc) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (candidates.length === 1) return candidates[0];
+  const combined = `${desc} ${ctx.actionName}`.toLowerCase();
+  const prefers = (abil) => candidates.includes(abil) ? abil : void 0;
+  if (/melee\s+or\s+ranged\s+weapon\s+attack/.test(combined)) {
+    return (_b = (_a = prefers("str")) != null ? _a : prefers("dex")) != null ? _b : candidates[0];
+  }
+  if (/melee\s+weapon\s+attack/.test(combined)) {
+    return (_d = (_c = prefers("str")) != null ? _c : prefers("dex")) != null ? _d : candidates[0];
+  }
+  if (/ranged\s+weapon\s+attack/.test(combined)) {
+    return (_e = prefers("dex")) != null ? _e : candidates[0];
+  }
+  if (/spell\s+attack/.test(combined)) {
+    if (ctx.spellAbility && candidates.includes(ctx.spellAbility)) {
+      return ctx.spellAbility;
+    }
+    return (_f = prefers("wis")) != null ? _f : candidates[0];
+  }
+  const rangedWords = /\b(bow|crossbow|dart|sling)\b/;
+  const meleeWords = /\b(bite|claw|slam|tail|gore|horns?|fist|hoof|talons?)\b/;
+  if (rangedWords.test(ctx.actionName.toLowerCase())) {
+    return (_g = prefers("dex")) != null ? _g : candidates[0];
+  }
+  if (meleeWords.test(ctx.actionName.toLowerCase())) {
+    return (_h = prefers("str")) != null ? _h : candidates[0];
+  }
+  return [...candidates].sort()[0];
+}
+function abilityWordToKey(word) {
+  const lower = word.toLowerCase();
+  switch (lower) {
+    case "strength":
+      return "str";
+    case "dexterity":
+      return "dex";
+    case "constitution":
+      return "con";
+    case "intelligence":
+      return "int";
+    case "wisdom":
+      return "wis";
+    case "charisma":
+      return "cha";
+  }
+  return void 0;
+}
+function detectSpellcastingAbility(traits) {
+  if (!traits) return void 0;
+  for (const trait of traits) {
+    for (const entry of trait.entries) {
+      const match = entry.match(/spellcasting ability is (intelligence|wisdom|charisma)/i);
+      if (match) {
+        const name = match[1].toLowerCase();
+        if (name === "intelligence") return "int";
+        if (name === "wisdom") return "wis";
+        if (name === "charisma") return "cha";
+      }
+    }
+  }
+  return void 0;
+}
+
+export {
+  STATIC_FALLBACK_CONTEXT,
+  convertDescToTags,
+  detectSpellcastingAbility
+};

package/dist/chunk-RSDRMH54.js

@@ -0,0 +1,18 @@
+import {
+  parseOptionalFeature
+} from "./chunk-4F6AIZ36.js";
+
+// src/optional-feature/optional-feature.codec.ts
+import yaml from "js-yaml";
+var optionalFeatureCodec = {
+  parse(doc) {
+    return parseOptionalFeature(doc.body);
+  },
+  serialize(entity) {
+    return yaml.dump(entity, { lineWidth: -1, sortKeys: false });
+  }
+};
+
+export {
+  optionalFeatureCodec
+};

package/dist/chunk-RVYYKYFL.js

@@ -0,0 +1,18 @@
+import {
+  parseClass
+} from "./chunk-FUK7QSN5.js";
+
+// src/class/class.codec.ts
+import yaml from "js-yaml";
+var classCodec = {
+  parse(doc) {
+    return parseClass(doc.body);
+  },
+  serialize(entity) {
+    return yaml.dump(entity, { lineWidth: -1, sortKeys: false });
+  }
+};
+
+export {
+  classCodec
+};

package/dist/chunk-SSXBYF3P.js

@@ -0,0 +1,18 @@
+import {
+  parseSubclass
+} from "./chunk-PMADYMUI.js";
+
+// src/subclass/subclass.codec.ts
+import yaml from "js-yaml";
+var subclassCodec = {
+  parse(doc) {
+    return parseSubclass(doc.body);
+  },
+  serialize(entity) {
+    return yaml.dump(entity, { lineWidth: -1, sortKeys: false });
+  }
+};
+
+export {
+  subclassCodec
+};