@archivist-gg/dnd5e 0.3.19 → 0.3.26

package/dist/chunk-NZO7M5GV.js

@@ -1,18 +0,0 @@
-import {
-  parseSubclass
-} from "./chunk-UNYR5GLI.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
-};

package/dist/chunk-OOL4KMG2.js

@@ -1,71 +0,0 @@
-import {
-  featureEffectSchema
-} from "./chunk-JXWNXIIZ.js";
-
-// src/schemas/choice-schema.ts
-import { z } from "zod";
-var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
-var entityFilterSchema = z.object({
-  feature_type: z.string().min(1).optional(),
-  category: z.string().min(1).optional(),
-  parent_class: z.literal("self").optional(),
-  available_to: z.literal("self").optional(),
-  weapon_category: z.enum(["simple", "martial"]).optional(),
-  armor_category: z.enum(["light", "medium", "heavy", "shield"]).optional(),
-  item_type: z.array(z.string().min(1)).nonempty().optional(),
-  mundane: z.boolean().optional(),
-  list: z.string().min(1).optional(),
-  level: z.number().int().min(0).max(9).optional(),
-  edition: z.string().min(1).optional(),
-  // D2b-A (design §2.2 step 1): Pact of the Tome's "level 1 ritual spells".
-  ritual: z.boolean().optional()
-}).strict();
-var inlineOptionSchema = z.lazy(() => z.object({
-  value: z.string().min(1),
-  label: z.string().min(1),
-  description: z.string().optional(),
-  effects: z.array(featureEffectSchema).optional(),
-  choices: z.array(choiceSchema).optional()
-}).strict());
-var choiceSchema = z.lazy(() => z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("select-inline"),
-    id: z.string().min(1),
-    label: z.string().optional(),
-    count: z.number().int().positive().optional(),
-    options: z.array(inlineOptionSchema).nonempty()
-  }).strict(),
-  z.object({
-    kind: z.literal("select-entity"),
-    id: z.string().min(1),
-    label: z.string().optional(),
-    count: z.number().int().positive().optional(),
-    entity_type: z.string().min(1),
-    from: z.array(z.string().min(1)).nonempty().optional(),
-    where: entityFilterSchema.optional(),
-    // D2b-A: a pick that names a target (a blast's cantrip), never a grant.
-    target: z.literal(true).optional()
-  }).strict(),
-  z.object({
-    kind: z.literal("select-proficiency"),
-    id: z.string().min(1),
-    label: z.string().optional(),
-    count: z.number().int().positive(),
-    domain: z.enum(["skill", "tool", "language", "save"]),
-    from: z.array(z.string().min(1)).nonempty().optional(),
-    from_proficient: z.boolean().optional(),
-    expertise: z.boolean().optional()
-  }).strict(),
-  z.object({
-    kind: z.literal("ability-points"),
-    id: z.string().min(1),
-    label: z.string().optional(),
-    points: z.number().int().positive(),
-    max_per: z.number().int().positive(),
-    pool: z.array(abilityEnum).nonempty().optional()
-  }).strict()
-]));
-
-export {
-  choiceSchema
-};

package/dist/chunk-OOSRUJBI.js

@@ -1,19 +0,0 @@
-import {
-  parseSpell
-} from "./chunk-7Q2VPKCD.js";
-
-// src/spell/spell.codec.ts
-import yaml from "js-yaml";
-var spellCodec = {
-  parse(doc) {
-    return parseSpell(doc.body);
-  },
-  serialize(spell) {
-    const { material: _material, ...doc } = spell;
-    return yaml.dump(doc, { lineWidth: -1, sortKeys: false });
-  }
-};
-
-export {
-  spellCodec
-};

package/dist/chunk-PDJSUH24.js

@@ -1,110 +0,0 @@
-import {
-  ABILITY_KEYS,
-  CR_PROFICIENCY,
-  CR_XP,
-  DAMAGE_TYPES,
-  SIZE_HIT_DICE
-} from "./chunk-WELIKLZF.js";
-
-// src/dnd/math.ts
-function abilityModifier(score) {
-  return Math.floor((score - 10) / 2);
-}
-function formatModifier(mod) {
-  return mod >= 0 ? `+${mod}` : `${mod}`;
-}
-function proficiencyBonusFromCR(cr) {
-  var _a;
-  return (_a = CR_PROFICIENCY[cr]) != null ? _a : 2;
-}
-function proficiencyFromLevel(level) {
-  if (level < 5) return 2;
-  if (level < 9) return 3;
-  if (level < 13) return 4;
-  if (level < 17) return 5;
-  return 6;
-}
-function crToXP(cr) {
-  var _a;
-  return (_a = CR_XP[cr]) != null ? _a : 0;
-}
-function hitDiceSizeFromCreatureSize(size) {
-  var _a;
-  return (_a = SIZE_HIT_DICE[size.toLowerCase()]) != null ? _a : 8;
-}
-function hpFromHitDice(hitDiceCount, hitDiceSize, conMod) {
-  const avg = Math.floor(hitDiceCount * (hitDiceSize + 1) / 2 + hitDiceCount * conMod);
-  return Math.max(1, avg);
-}
-function parseHitDiceFormula(formula) {
-  const match = formula.match(/^(\d+)d(\d+)/i);
-  if (!match) return null;
-  return { count: parseInt(match[1], 10), size: parseInt(match[2], 10) };
-}
-function savingThrow(abilityScore, isProficient, profBonus) {
-  return abilityModifier(abilityScore) + (isProficient ? profBonus : 0);
-}
-function skillBonus(abilityScore, proficiency, profBonus) {
-  const mod = abilityModifier(abilityScore);
-  if (proficiency === "expertise") return mod + profBonus * 2;
-  if (proficiency === "proficient") return mod + profBonus;
-  return mod;
-}
-function passive(abilityScore, proficiency, profBonus) {
-  return 10 + skillBonus(abilityScore, proficiency, profBonus);
-}
-function passivePerception(wisScore, perceptionProf, profBonus) {
-  return passive(wisScore, perceptionProf, profBonus);
-}
-function attackBonus(abilityScore, profBonus) {
-  return abilityModifier(abilityScore) + profBonus;
-}
-function saveDC(abilityScore, profBonus) {
-  return 8 + profBonus + abilityModifier(abilityScore);
-}
-function abilityNameToKey(name) {
-  const lower = name.toLowerCase();
-  if (ABILITY_KEYS.includes(lower)) {
-    return lower;
-  }
-  return null;
-}
-var CANONICAL_DAMAGE_TYPES = new Set(DAMAGE_TYPES.map((t) => t.toLowerCase()));
-function isCanonicalDamageType(type) {
-  return CANONICAL_DAMAGE_TYPES.has(type.trim().toLowerCase());
-}
-var CHOSEN_DAMAGE_TYPE = "chosen";
-var CHOSEN_DAMAGE_TYPE_NOTE = "damage type of your choice";
-function isChosenDamageType(type) {
-  return type !== void 0 && type.trim().toLowerCase() === CHOSEN_DAMAGE_TYPE;
-}
-function isRenderableDamageText(text) {
-  var _a;
-  const m = /^(?:\d*d\d+(?:\s*[+-]\s*\d+)?|[+-]?\d+)(?:\s+(.*))?$/i.exec(text.trim());
-  if (!m) return false;
-  const type = ((_a = m[1]) != null ? _a : "").trim();
-  return type === "" || isCanonicalDamageType(type);
-}
-
-export {
-  abilityModifier,
-  formatModifier,
-  proficiencyBonusFromCR,
-  proficiencyFromLevel,
-  crToXP,
-  hitDiceSizeFromCreatureSize,
-  hpFromHitDice,
-  parseHitDiceFormula,
-  savingThrow,
-  skillBonus,
-  passive,
-  passivePerception,
-  attackBonus,
-  saveDC,
-  abilityNameToKey,
-  isCanonicalDamageType,
-  CHOSEN_DAMAGE_TYPE,
-  CHOSEN_DAMAGE_TYPE_NOTE,
-  isChosenDamageType,
-  isRenderableDamageText
-};

package/dist/chunk-PTXBIDG7.js

@@ -1,63 +0,0 @@
-// src/monster/monster.ai-schema.ts
-import { z } from "zod";
-var abilitiesSchema = z.object({
-  str: z.number().min(1).max(30),
-  dex: z.number().min(1).max(30),
-  con: z.number().min(1).max(30),
-  int: z.number().min(1).max(30),
-  wis: z.number().min(1).max(30),
-  cha: z.number().min(1).max(30)
-});
-var acSchema = z.object({
-  ac: z.number(),
-  from: z.array(z.string()).optional(),
-  condition: z.string().optional()
-});
-var hpSchema = z.object({
-  average: z.number(),
-  formula: z.string()
-});
-var speedSchema = z.object({
-  walk: z.number().optional(),
-  fly: z.number().optional(),
-  swim: z.number().optional(),
-  climb: z.number().optional(),
-  burrow: z.number().optional()
-});
-var featureSchema = z.object({
-  name: z.string(),
-  entries: z.array(z.string().describe(
-    "Inline tag forms: `atk:ABILITY` for non-proficient attacks (ability mod alone), `atk:ABILITY+PB` for proficient attacks (ability mod + proficiency), `atk:+N` for literal attack bonuses, `dmg:DICE+ABILITY` for damage rolls (PB never added to damage), `dc:ABILITY` for save DCs (proficiency always included implicitly)."
-  ))
-});
-var monsterInputSchema = z.object({
-  name: z.string().describe("Monster name"),
-  size: z.enum(["Tiny", "Small", "Medium", "Large", "Huge", "Gargantuan"]),
-  type: z.string().describe("Creature type (e.g., aberration, beast, dragon)"),
-  subtype: z.string().optional(),
-  alignment: z.string(),
-  cr: z.string().describe('Challenge rating (e.g., "0", "1/8", "1/4", "1/2", "1" through "30")'),
-  abilities: abilitiesSchema,
-  ac: z.array(acSchema),
-  hp: hpSchema,
-  speed: speedSchema,
-  saves: z.record(z.string(), z.number()).optional(),
-  skills: z.record(z.string(), z.number()).optional(),
-  damage_vulnerabilities: z.array(z.string()).optional(),
-  damage_resistances: z.array(z.string()).optional(),
-  damage_immunities: z.array(z.string()).optional(),
-  condition_immunities: z.array(z.string()).optional(),
-  senses: z.array(z.string()).optional(),
-  passive_perception: z.number().optional(),
-  languages: z.array(z.string()).optional(),
-  traits: z.array(featureSchema).optional(),
-  actions: z.array(featureSchema).optional(),
-  reactions: z.array(featureSchema).optional(),
-  legendary_actions: z.array(featureSchema).optional(),
-  legendary_action_uses: z.number().optional(),
-  legendary_resistance: z.number().optional()
-});
-
-export {
-  monsterInputSchema
-};

package/dist/chunk-PVCEA4HZ.js

@@ -1,6 +0,0 @@
-// src/race/race.structural.ts
-var RACE_STRUCTURAL_PSEUDO = /* @__PURE__ */ new Set(["size", "speed", "darkvision"]);
-
-export {
-  RACE_STRUCTURAL_PSEUDO
-};

package/dist/chunk-QA3YCOML.js

@@ -1,101 +0,0 @@
-import {
-  ALL_TOOLS,
-  ARTISANS_TOOLS,
-  GAMING_SETS,
-  MUSICAL_INSTRUMENTS
-} from "./chunk-KU3YLF6D.js";
-import {
-  toProfSlug
-} from "./chunk-5JXFJ5AU.js";
-
-// src/pc/pc.tool-picks.ts
-var TOOL_CATEGORIES = {
-  "musical-instrument": { pool: MUSICAL_INSTRUMENTS, itemType: "instrument", label: "a musical instrument" },
-  "artisan's-tools": { pool: ARTISANS_TOOLS, itemType: "artisan's tools", label: "artisan's tools" },
-  "gaming-set": { pool: GAMING_SETS, itemType: "gaming set", label: "a gaming set" }
-};
-function categoryWords(token) {
-  return token.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase().replace(/['’ʼ]/g, "").split(/[\s_-]+/).filter(Boolean).map((w) => w.length > 3 && w.endsWith("s") && !w.endsWith("ss") ? w.slice(0, -1) : w);
-}
-var CATEGORY_BY_WORDS = /* @__PURE__ */ new Map([
-  ["musical instrument", "musical-instrument"],
-  ["artisan tool", "artisan's-tools"],
-  ["gaming set", "gaming-set"]
-]);
-function toolCategoriesOf(token) {
-  const parts = [[]];
-  for (const w of categoryWords(token)) {
-    if (w === "or") parts.push([]);
-    else parts[parts.length - 1].push(w);
-  }
-  const out = [];
-  for (const p of parts) {
-    const c = CATEGORY_BY_WORDS.get(p.filter((w) => w !== "any" && w !== "one").join(" "));
-    if (!c) return void 0;
-    if (!out.includes(c)) out.push(c);
-  }
-  return out;
-}
-function expandToolPool(from) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (v) => {
-    const k = toProfSlug(v);
-    if (seen.has(k)) return;
-    seen.add(k);
-    out.push(v);
-  };
-  for (const v of from) {
-    const cats = toolCategoriesOf(v);
-    if (cats) for (const c of cats) for (const t of TOOL_CATEGORIES[c].pool) add(t);
-    else add(v);
-  }
-  return out;
-}
-var EMPTY = { decisions: [], grants: [] };
-var poolOf = (from) => Array.isArray(from) ? from.filter((v) => typeof v === "string" && v.length > 0) : typeof from === "string" && from.length > 0 ? [from] : [];
-var countOf = (count) => {
-  const n = Number(count != null ? count : 1);
-  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 1;
-};
-var KNOWN_TOOLS = new Set(ALL_TOOLS.map(toProfSlug));
-var namesToolsOutright = (from) => from.every((v) => !toolCategoriesOf(v) && KNOWN_TOOLS.has(toProfSlug(v)));
-var authorsToolPick = (choices) => Array.isArray(choices) && choices.some((c) => !!c && typeof c === "object" && c.kind === "select-proficiency" && c.domain === "tool");
-function toolPick(count, from, id, allowDecision) {
-  const authored = poolOf(from);
-  const pool = expandToolPool(authored);
-  const n = countOf(count);
-  if (pool.length === 0) return EMPTY;
-  if (n >= pool.length && namesToolsOutright(authored)) return { decisions: [], grants: pool };
-  if (!allowDecision) return EMPTY;
-  return { decisions: [{ kind: "select-proficiency", id, count: n, domain: "tool", from: pool }], grants: [] };
-}
-function classToolPicks(entity) {
-  var _a;
-  const tools = (_a = entity == null ? void 0 : entity.proficiencies) == null ? void 0 : _a.tools;
-  const choice = tools == null ? void 0 : tools.choice;
-  if (!choice || typeof choice !== "object") return EMPTY;
-  return toolPick(choice.count, choice.from, "tool", !authorsToolPick(entity == null ? void 0 : entity.choices));
-}
-function backgroundToolPicks(bg) {
-  const entries = Array.isArray(bg == null ? void 0 : bg.tool_proficiencies) ? bg.tool_proficiencies : [];
-  const allowDecision = !authorsToolPick(bg == null ? void 0 : bg.choices);
-  const out = { decisions: [], grants: [] };
-  for (const e of entries) {
-    if (!e || typeof e !== "object" || e.kind !== "choice") continue;
-    const id = out.decisions.length === 0 ? "tool" : `tool-${out.decisions.length + 1}`;
-    const r = toolPick(e.count, e.from, id, allowDecision);
-    out.decisions.push(...r.decisions);
-    out.grants.push(...r.grants);
-  }
-  return out;
-}
-
-export {
-  TOOL_CATEGORIES,
-  categoryWords,
-  toolCategoriesOf,
-  expandToolPool,
-  classToolPicks,
-  backgroundToolPicks
-};

package/dist/chunk-QFWQKS3M.js

@@ -1,110 +0,0 @@
-import {
-  startingEquipmentEntrySchema
-} from "./chunk-IN4M4X7P.js";
-import {
-  choiceSchema
-} from "./chunk-OOL4KMG2.js";
-import {
-  additionalSpellsEntrySchema,
-  imageField
-} from "./chunk-UA5KS2PL.js";
-
-// src/background/background.schema.ts
-import { z } from "zod";
-var abilityEnum = z.enum(["str", "dex", "con", "int", "wis", "cha"]);
-var editionEnum = z.enum(["2014", "2024"]);
-var skillEnum = z.enum([
-  "acrobatics",
-  "animal-handling",
-  "arcana",
-  "athletics",
-  "deception",
-  "history",
-  "insight",
-  "intimidation",
-  "investigation",
-  "medicine",
-  "nature",
-  "perception",
-  "performance",
-  "persuasion",
-  "religion",
-  "sleight-of-hand",
-  "stealth",
-  "survival"
-]);
-var wikilinkRegex = /^\[\[[^[\]]+\]\]$/;
-var toolProfSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("fixed"), items: z.array(z.string()).nonempty() }),
-  z.object({
-    kind: z.literal("choice"),
-    count: z.number().int().positive(),
-    from: z.array(z.string()).nonempty()
-  })
-]);
-var langProfSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("fixed"), languages: z.array(z.string()).nonempty() }),
-  z.object({
-    kind: z.literal("choice"),
-    count: z.number().int().positive(),
-    from: z.union([z.string(), z.array(z.string())])
-  })
-]);
-var suggestedCharSchema = z.object({
-  personality_traits: z.record(z.string(), z.string()).optional(),
-  ideals: z.record(z.string(), z.object({
-    name: z.string().optional(),
-    desc: z.string(),
-    alignment: z.string().optional()
-  })).optional(),
-  bonds: z.record(z.string(), z.string()).optional(),
-  flaws: z.record(z.string(), z.string()).optional()
-});
-var backgroundEntitySchema = z.object({
-  slug: z.string().min(1),
-  name: z.string().min(1),
-  edition: editionEnum,
-  source: z.string().min(1),
-  description: z.string(),
-  skill_proficiencies: z.array(skillEnum),
-  tool_proficiencies: z.array(toolProfSchema),
-  language_proficiencies: z.array(langProfSchema),
-  equipment: z.array(startingEquipmentEntrySchema),
-  feature: z.object({
-    name: z.string().min(1),
-    description: z.string().min(1)
-  }),
-  ability_score_increases: z.object({
-    pool: z.array(abilityEnum).length(3)
-  }).nullable(),
-  origin_feat: z.string().regex(wikilinkRegex).nullable(),
-  suggested_characteristics: suggestedCharSchema.nullable(),
-  choices: z.array(choiceSchema).optional(),
-  rendering_hint: z.string().optional(),
-  // 175
-  has_fluff_images: z.boolean().optional(),
-  // 87
-  tables: z.array(z.object({
-    // 88 tables / 67 docs; key-sets EXACT (finding 6)
-    name: z.string().min(1),
-    dice: z.string().min(1),
-    rows: z.array(z.object({ roll: z.string(), text: z.string() }))
-  })).optional(),
-  additional_spells: z.array(additionalSpellsEntrySchema).optional(),
-  // 15
-  prerequisites: z.array(z.object({
-    // 4 docs; kind CLOSED AT THE EMITTER
-    kind: z.literal("campaign"),
-    slug: z.string().min(1)
-    // (background-mapper.ts pushes
-  })).optional(),
-  //  {kind:"campaign", slug} literally — finding 24)
-  // The one-arm union STAYS (§2.6 adjudication): it is closed by CONSTRUCTION at the converter's
-  // only push site, and a future kind turns into a visible census REFUSAL — the correct loud failure.
-  image: imageField
-});
-
-export {
-  langProfSchema,
-  backgroundEntitySchema
-};

package/dist/chunk-QS5L5YTJ.js

@@ -1,24 +0,0 @@
-// src/item/item.ai-schema.ts
-import { z } from "zod";
-var itemInputSchema = z.object({
-  name: z.string().describe("Item name"),
-  type: z.enum(["weapon", "armor", "potion", "ring", "rod", "scroll", "staff", "wand", "wondrous item", "shield"]),
-  rarity: z.enum(["common", "uncommon", "rare", "very rare", "legendary", "artifact"]),
-  entries: z.array(z.string()).optional().describe(
-    "Item description and properties. Use inline formula tags for attack rolls, damage, and save DCs: `atk:ABILITY` for attack bonus, `damage:DICE+ABILITY` for damage (e.g. `damage:2d6`), `dc:ABILITY` for save DCs. Valid abilities: STR, DEX, CON, INT, WIS, CHA."
-  ),
-  weight: z.number().optional(),
-  value: z.number().optional(),
-  attunement: z.union([z.boolean(), z.string()]).optional(),
-  properties: z.array(z.string()).optional(),
-  damage: z.string().optional(),
-  damage_type: z.string().optional(),
-  ac: z.number().optional(),
-  charges: z.number().optional(),
-  recharge: z.string().optional(),
-  curse: z.boolean().optional()
-});
-
-export {
-  itemInputSchema
-};

package/dist/chunk-QYZV2MQA.js

@@ -1,97 +0,0 @@
-// src/dnd/tag-grammar.ts
-var TAG_TYPE_ALIASES = {
-  atk: "atk",
-  attack: "atk",
-  dmg: "dmg",
-  damage: "dmg",
-  dc: "dc",
-  dice: "dice"
-};
-function normalizeTagType(input) {
-  var _a;
-  const lower = input.toLowerCase().trim();
-  return (_a = TAG_TYPE_ALIASES[lower]) != null ? _a : null;
-}
-var ABILITY_RE = /^(str|dex|con|int|wis|cha)$/i;
-var PB_RE = /^pb$/i;
-var DICE_RE = /^(\d+)d(\d+)$/;
-var LITERAL_RE = /^([+-]?\d+)$/;
-var SLUG_RE = /^\[\[([^[\]]+)\]\]$/;
-function parseTagTerms(content) {
-  const out = {
-    pbTerm: false,
-    literalTerms: [],
-    diceTerms: [],
-    slugTerms: []
-  };
-  const trimmed = content.trim();
-  if (trimmed.length === 0) return { error: "empty content" };
-  const tokens = [];
-  let i = 0;
-  const advancePastTerm = (start) => {
-    let j = start;
-    while (j < trimmed.length && trimmed[j] !== "+" && trimmed[j] !== "-") {
-      if (trimmed[j] === "[" && trimmed[j + 1] === "[") {
-        const close = trimmed.indexOf("]]", j + 2);
-        if (close === -1) return trimmed.length;
-        j = close + 2;
-        continue;
-      }
-      j++;
-    }
-    return j;
-  };
-  while (i < trimmed.length) {
-    if (trimmed[i] === "+" || trimmed[i] === "-") {
-      const j = advancePastTerm(i + 1);
-      tokens.push(trimmed.slice(i, j));
-      i = j;
-    } else {
-      const j = advancePastTerm(i);
-      tokens.push(trimmed.slice(i, j));
-      i = j;
-    }
-  }
-  for (let raw of tokens) {
-    raw = raw.trim();
-    if (raw.length === 0) return { error: "empty term" };
-    let signed = raw;
-    let body = raw;
-    if (raw[0] === "+" || raw[0] === "-") {
-      body = raw.slice(1).trim();
-    } else {
-      signed = "+" + raw;
-    }
-    if (DICE_RE.test(body)) {
-      const m = body.match(DICE_RE);
-      out.diceTerms.push({ count: Number.parseInt(m[1], 10), sides: Number.parseInt(m[2], 10) });
-      continue;
-    }
-    if (ABILITY_RE.test(body)) {
-      if (out.abilityTerm) return { error: `multiple ability terms (${out.abilityTerm}, ${body.toLowerCase()})` };
-      out.abilityTerm = body.toLowerCase();
-      continue;
-    }
-    if (PB_RE.test(body)) {
-      if (out.pbTerm) return { error: "duplicate PB term" };
-      out.pbTerm = true;
-      continue;
-    }
-    const slugMatch = body.match(SLUG_RE);
-    if (slugMatch) {
-      out.slugTerms.push(slugMatch[1]);
-      continue;
-    }
-    if (LITERAL_RE.test(signed)) {
-      out.literalTerms.push(Number.parseInt(signed, 10));
-      continue;
-    }
-    return { error: `unrecognized term: ${raw}` };
-  }
-  return out;
-}
-
-export {
-  normalizeTagType,
-  parseTagTerms
-};