koffing 1.0.0 → 2.0.0

package/dist/index.cjs

@@ -0,0 +1,441 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_data = require("./data-CP51LAc9.cjs");
+//#region src/parse.ts
+const stats$1 = {
+	hp: "hp",
+	atk: "atk",
+	attack: "atk",
+	def: "def",
+	defense: "def",
+	spa: "spa",
+	spatk: "spa",
+	specialattack: "spa",
+	spd: "spd",
+	spdef: "spd",
+	specialdefense: "spd",
+	spe: "spe",
+	speed: "spe"
+};
+const numericFields = /* @__PURE__ */ new Map([
+	["level", "level"],
+	["happiness", "happiness"],
+	["friendship", "happiness"],
+	["dynamax level", "dynamaxLevel"]
+]);
+const stringFields = /* @__PURE__ */ new Map([
+	["ability", "ability"],
+	["trait", "ability"],
+	["item", "item"],
+	["nickname", "name"],
+	["species", "species"],
+	["tera type", "teraType"],
+	["hidden power", "hpType"],
+	["pokeball", "pokeball"],
+	["ball", "pokeball"]
+]);
+const natureStats = [
+	"atk",
+	"def",
+	"spe",
+	"spa",
+	"spd"
+];
+const natures = [
+	[
+		"Hardy",
+		"Lonely",
+		"Brave",
+		"Adamant",
+		"Naughty"
+	],
+	[
+		"Bold",
+		"Docile",
+		"Relaxed",
+		"Impish",
+		"Lax"
+	],
+	[
+		"Timid",
+		"Hasty",
+		"Serious",
+		"Jolly",
+		"Naive"
+	],
+	[
+		"Modest",
+		"Mild",
+		"Quiet",
+		"Bashful",
+		"Rash"
+	],
+	[
+		"Calm",
+		"Gentle",
+		"Sassy",
+		"Careful",
+		"Quirky"
+	]
+];
+const controlCharacters = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f\u2028\u2029]/;
+/** Parse Showdown text without silently clamping values or dropping extra moves. */
+function parse(input, options = {}) {
+	const limits = require_data.resolveLimits(options);
+	require_data.checkInput(input, limits);
+	const hasControls = controlCharacters.test(input);
+	const hasTabs = input.includes("	");
+	const hasPipes = input.includes("|");
+	const teams = [];
+	const diagnostics = [];
+	let team;
+	let pokemon;
+	let count = 0;
+	let seen = /* @__PURE__ */ new Set();
+	let explicitHpType = false;
+	let explicitHappiness = false;
+	let explicitNature = false;
+	let increased;
+	let decreased;
+	let lineNumber = 0;
+	const warn = (code, message) => {
+		require_data.report(diagnostics, {
+			code,
+			message,
+			severity: "warning",
+			line: lineNumber
+		}, limits);
+	};
+	const duplicate = (key) => {
+		if (seen.has(key)) warn("duplicate-field", `Repeated ${key}; the last value takes precedence`);
+		seen.add(key);
+	};
+	const addTeam = (value) => {
+		if (teams.length >= limits.maxTeams) require_data.fail("team-limit", "Too many teams", lineNumber);
+		teams.push(value);
+		team = value;
+	};
+	const move = (value) => {
+		if (!pokemon) return;
+		if (!value) {
+			warn("invalid-move", "Move name is empty");
+			return;
+		}
+		if (pokemon.moves.length >= limits.maxMoves) require_data.fail("move-limit", "Too many moves", lineNumber);
+		const hidden = /^Hidden Power\s*\[([^\]]+)\]$/i.exec(value);
+		if (hidden) {
+			value = `Hidden Power ${hidden[1].trim()}`;
+			if (!explicitHpType) pokemon.hpType = hidden[1].trim();
+		}
+		pokemon.moves.push(value);
+		if (pokemon.moves.length === 5) warn("move-count", "More than four moves; all moves were preserved");
+		if (/^Frustration$/i.test(value) && !explicitHappiness) pokemon.happiness = 0;
+	};
+	let nextCR = input.indexOf("\r");
+	let nextLF = input.indexOf("\n");
+	for (let start = 0; start <= input.length;) {
+		let end = nextLF < 0 ? input.length : nextLF;
+		if (nextCR >= 0 && nextCR < end) end = nextCR;
+		lineNumber++;
+		if (end - start > limits.maxLineLength) require_data.fail("line-limit", "Line is too long", lineNumber);
+		const rawLine = input.slice(start, end);
+		const line = (hasTabs ? rawLine.replace(/\t/g, " ") : rawLine).trim();
+		const separator = input[end];
+		start = end + (separator === "\r" && input[end + 1] === "\n" ? 2 : 1);
+		if (nextCR >= 0 && nextCR < start) nextCR = input.indexOf("\r", start);
+		if (nextLF >= 0 && nextLF < start) nextLF = input.indexOf("\n", start);
+		if (hasControls && controlCharacters.test(rawLine)) {
+			warn("invalid-character", "Control characters are not allowed");
+			continue;
+		}
+		if (!line || /^-{3,}$/.test(line)) {
+			pokemon = void 0;
+			continue;
+		}
+		if (hasPipes && line.includes("|")) require_data.fail("unsupported-packed-format", "Packed teams are not supported; import Showdown text instead", lineNumber);
+		if (pokemon && (line[0] === "-" || line[0] === "~")) {
+			move(line.slice(1).trimStart());
+			continue;
+		}
+		const header = line[0] === "=" ? /^===\s*(.*?)\s*===$/.exec(line) : null;
+		if (header) {
+			const value = { pokemon: [] };
+			let title = header[1].trim();
+			const format = /^\[([^\]]+)\]\s*/.exec(title);
+			if (format) {
+				value.format = format[1].trim();
+				title = title.slice(format[0].length);
+			}
+			const slash = title.lastIndexOf("/");
+			if (slash >= 0) {
+				value.folder = title.slice(0, slash).trim();
+				title = title.slice(slash + 1).trim();
+			}
+			if (title) value.name = title;
+			addTeam(value);
+			pokemon = void 0;
+			continue;
+		}
+		if (line.startsWith("===")) {
+			warn("invalid-header", "Malformed team header");
+			pokemon = void 0;
+			continue;
+		}
+		const colon = line.indexOf(":");
+		const hasDetail = colon > 0;
+		const nature = hasDetail || line.includes("@") || !/\sNature$/i.test(line) ? null : /^(.*?)\s+Nature$/i.exec(line);
+		const bare = !hasDetail && /^(Shiny|Gigantamax)$/i.test(line);
+		if (!pokemon) {
+			const typeNullHeader = hasDetail && /^(?:[^:]*\()?Type: Null\)?(?:\s+\([MFN]\))?(?:\s+\[[^\]]+\])?(?:\s+@\s+.+)?$/i.test(line);
+			if (line.startsWith("-") || hasDetail && !typeNullHeader || nature || bare) {
+				warn("orphan-detail", "Pokémon detail appears before a Pokémon header");
+				continue;
+			}
+			let identity = line;
+			let item;
+			const at = identity.lastIndexOf(" @ ");
+			if (at >= 0) {
+				item = identity.slice(at + 3).trim();
+				identity = identity.slice(0, at).trim();
+			}
+			let ability;
+			const bracket = /\s*\[([^\]]+)\]$/.exec(identity);
+			if (bracket) {
+				ability = bracket[1].trim();
+				identity = identity.slice(0, bracket.index).trim();
+			}
+			let gender;
+			const sex = /\s*\(([MFN])\)$/.exec(identity);
+			if (sex) {
+				gender = sex[1];
+				identity = identity.slice(0, sex.index).trim();
+			}
+			const named = /^(.*?)\s*\(([^()]+)\)$/.exec(identity);
+			const species = (named ? named[2] : identity).trim();
+			if (!species || /[\[\]@()=]/.test(species)) {
+				warn("invalid-header", "Malformed Pokémon header");
+				continue;
+			}
+			if (count >= limits.maxPokemon) require_data.fail("pokemon-limit", "Too many Pokémon", lineNumber);
+			count++;
+			pokemon = {
+				species,
+				moves: []
+			};
+			if (named?.[1]?.trim()) pokemon.name = named[1].trim();
+			if (item && !/^No Item$/i.test(item)) pokemon.item = item;
+			if (ability) pokemon.ability = ability;
+			if (gender) pokemon.gender = gender;
+			if (!team) addTeam({ pokemon: [] });
+			team.pokemon.push(pokemon);
+			seen.clear();
+			seen.add("species");
+			if (pokemon.name !== void 0) seen.add("name");
+			if (pokemon.item !== void 0) seen.add("item");
+			if (pokemon.ability !== void 0) seen.add("ability");
+			if (pokemon.gender !== void 0) seen.add("gender");
+			explicitHpType = false;
+			explicitHappiness = false;
+			explicitNature = false;
+			increased = void 0;
+			decreased = void 0;
+			continue;
+		}
+		const bracketDetail = line[0] === "[" ? /^\[([^\]]+)\](?:\s*@\s*(.+))?$/.exec(line) : null;
+		if (bracketDetail) {
+			duplicate("ability");
+			pokemon.ability = bracketDetail[1].trim();
+			if (bracketDetail[2]) {
+				duplicate("item");
+				if (/^No Item$/i.test(bracketDetail[2])) delete pokemon.item;
+				else pokemon.item = bracketDetail[2].trim();
+			}
+			continue;
+		}
+		if (nature) {
+			duplicate("nature");
+			pokemon.nature = nature[1].trim();
+			explicitNature = true;
+			continue;
+		}
+		const key = (hasDetail ? line.slice(0, colon).trim() : bare ? line : "").toLowerCase();
+		const value = hasDetail ? line.slice(colon + 1).trim() : "Yes";
+		if (key === "move") {
+			move(value);
+			continue;
+		}
+		if (key === "evs" || key === "ivs") {
+			duplicate(key);
+			const values = {};
+			let conflictingModifiers = false;
+			if (key === "evs") {
+				increased = void 0;
+				decreased = void 0;
+				if (!explicitNature) delete pokemon.nature;
+			}
+			for (const entry of value.split("/")) {
+				const match = /^\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)([+-]?)\s+([a-z .]+)\s*$/i.exec(entry);
+				const statName = match?.[3].toLowerCase().replace(/[ .]/g, "");
+				const stat = statName && Object.hasOwn(stats$1, statName) ? stats$1[statName] : void 0;
+				if (!match || !stat || !Number.isFinite(Number(match[1]))) {
+					warn("invalid-stat", `Invalid ${key} entry: ${entry.trim()}`);
+					continue;
+				}
+				if (values[stat] !== void 0) warn("duplicate-stat", `Repeated ${stat}; the last value takes precedence`);
+				values[stat] = Number(match[1]);
+				const max = key === "ivs" ? 31 : 255;
+				if (!Number.isInteger(values[stat]) || values[stat] < 0 || values[stat] > max) warn("stat-range", `${stat} is outside the traditional ${key} range; value preserved`);
+				if (match[2]) {
+					if (key !== "evs" || stat === "hp") warn("invalid-nature-modifier", "Nature modifiers apply only to non-HP EVs");
+					else if (match[2] === "+") {
+						if (increased) {
+							conflictingModifiers = true;
+							warn("invalid-nature-modifier", "More than one increased stat");
+						}
+						increased = stat;
+					} else {
+						if (decreased) {
+							conflictingModifiers = true;
+							warn("invalid-nature-modifier", "More than one decreased stat");
+						}
+						decreased = stat;
+					}
+				}
+			}
+			pokemon[key] = values;
+			if (key === "evs" && Object.values(values).reduce((sum, number) => sum + number, 0) > 510) warn("ev-total", "EV total exceeds 510; values preserved");
+			if (key === "evs" && increased && increased === decreased) {
+				conflictingModifiers = true;
+				warn("invalid-nature-modifier", "The same stat cannot be increased and decreased");
+			}
+			if (key === "evs" && !explicitNature && !conflictingModifiers && increased && decreased) pokemon.nature = natures[natureStats.indexOf(increased)][natureStats.indexOf(decreased)];
+			continue;
+		}
+		const numberKey = numericFields.get(key);
+		if (numberKey) {
+			duplicate(numberKey);
+			const number = Number(value);
+			if (!value || !Number.isFinite(number)) {
+				warn("invalid-number", `Invalid ${key}`);
+				continue;
+			}
+			pokemon[numberKey] = number;
+			if (numberKey === "happiness") explicitHappiness = true;
+			const min = numberKey === "level" ? 1 : 0;
+			const max = numberKey === "level" ? 100 : numberKey === "happiness" ? 255 : 10;
+			if (!Number.isInteger(number) || number < min || number > max) warn("number-range", `${key} is outside its traditional range; value preserved`);
+			continue;
+		}
+		if (key === "shiny" || key === "gigantamax") {
+			duplicate(key);
+			if (!/^(yes|no|true|false)$/i.test(value)) warn("invalid-boolean", `Invalid ${key}`);
+			else pokemon[key] = /^(yes|true)$/i.test(value);
+			continue;
+		}
+		if (key === "gender") {
+			duplicate("gender");
+			if (value === "M" || value === "F" || value === "N" || value === "") pokemon.gender = value;
+			else warn("invalid-gender", "Gender must be M, F, N or empty");
+			continue;
+		}
+		const stringKey = stringFields.get(key);
+		if (stringKey) {
+			duplicate(stringKey);
+			if (!value) {
+				warn("empty-field", `Empty ${key}`);
+				continue;
+			}
+			if (stringKey === "item" && /^No Item$/i.test(value)) delete pokemon.item;
+			else pokemon[stringKey] = value;
+			if (stringKey === "hpType") explicitHpType = true;
+			continue;
+		}
+		warn("unknown-line", `Unrecognized line: ${line}`);
+	}
+	require_data.finish(diagnostics, options);
+	return {
+		teams,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/serialize.ts
+const stats = [
+	["hp", "HP"],
+	["atk", "Atk"],
+	["def", "Def"],
+	["spa", "SpA"],
+	["spd", "SpD"],
+	["spe", "Spe"]
+];
+function decimal(value) {
+	const source = String(value);
+	if (!/[eE]/u.test(source)) return source;
+	const [mantissa, exponentText] = source.split(/[eE]/u);
+	const negative = mantissa.startsWith("-");
+	const [whole, fraction = ""] = (negative ? mantissa.slice(1) : mantissa).split(".");
+	const digits = whole + fraction;
+	const point = whole.length + Number(exponentText);
+	const expanded = point <= 0 ? `0.${"0".repeat(-point)}${digits}` : point >= digits.length ? `${digits}${"0".repeat(point - digits.length)}` : `${digits.slice(0, point)}.${digits.slice(point)}`;
+	return `${negative ? "-" : ""}${expanded}`;
+}
+function serializeSet(set) {
+	let title = set.name ? `${set.name} (${set.species})` : set.species;
+	if (set.gender === "M" || set.gender === "F") title += ` (${set.gender})`;
+	if (set.item) title += ` @ ${set.item}`;
+	let output = title;
+	const append = (label, value) => {
+		if (value !== void 0 && (typeof value !== "number" || Number.isFinite(value))) output += `\n${label}: ${value}`;
+	};
+	append("Ability", set.ability);
+	append("Level", set.level);
+	if (set.gender === "N" || set.gender === "") append("Gender", set.gender);
+	if (set.shiny !== void 0) append("Shiny", set.shiny ? "Yes" : "No");
+	append("Happiness", set.happiness);
+	append("Pokeball", set.pokeball);
+	append("Hidden Power", set.hpType);
+	append("Dynamax Level", set.dynamaxLevel);
+	if (set.gigantamax !== void 0) append("Gigantamax", set.gigantamax ? "Yes" : "No");
+	append("Tera Type", set.teraType);
+	const appendStats = (label, values) => {
+		if (values === void 0) return;
+		let entries = "";
+		for (const [key, name] of stats) {
+			const value = values[key];
+			if (value !== void 0 && Number.isFinite(value)) {
+				if (entries) entries += " / ";
+				entries += `${decimal(value)} ${name}`;
+			}
+		}
+		if (entries) append(label, entries);
+	};
+	appendStats("EVs", set.evs);
+	if (set.nature) output += `\n${set.nature} Nature`;
+	appendStats("IVs", set.ivs);
+	for (const move of set.moves) {
+		const hidden = /^Hidden Power ([a-z]+)$/iu.exec(move);
+		output += `\n- ${hidden ? `Hidden Power [${hidden[1]}]` : move}`;
+	}
+	return output;
+}
+/** Format trusted typed sets, like Showdown. Use parseJSON separately for untrusted data. */
+function exportTeam(pokemon) {
+	return pokemon.map(serializeSet).join("\n\n");
+}
+/** Collection export always includes headers, preserving team boundaries. */
+function exportTeams(teams) {
+	return teams.map((team) => {
+		const metadata = `${team.format ? `[${team.format}] ` : ""}${team.folder ? `${team.folder}/` : ""}${team.name ?? ""}`;
+		const body = team.pokemon.map(serializeSet).join("\n\n");
+		if (teams.length === 1 && !metadata && body) return body;
+		return `=== ${metadata} ===${body ? `\n\n${body}` : ""}`;
+	}).join("\n\n");
+}
+//#endregion
+exports.DEFAULT_LIMITS = require_data.DEFAULT_LIMITS;
+exports.KoffingError = require_data.KoffingError;
+exports.exportTeam = exportTeam;
+exports.exportTeams = exportTeams;
+exports.parse = parse;
+exports.parseJSON = require_data.parseJSON;
+exports.sanitizeTeam = require_data.sanitizeTeam;
+exports.validateTeam = require_data.validateTeam;

package/dist/index.d.cts

@@ -0,0 +1,29 @@
+import { a as PokemonSet, c as Stats, i as ParseResult, l as Team, n as Limits, o as SanitizeOptions, r as Options, s as StatID, t as Diagnostic } from "./types-BVzP_Ko4.cjs";
+//#region src/parse.d.ts
+/** Parse Showdown text without silently clamping values or dropping extra moves. */
+export declare function parse(input: string, options?: Options): ParseResult;
+//#endregion
+//#region src/data.d.ts
+/** Decode and copy known data only. Shape errors are fatal; unknown fields are diagnosed. */
+export declare function parseJSON(input: unknown, options?: Options): ParseResult;
+export declare function validateTeam(pokemon: readonly PokemonSet[], options?: Options): Diagnostic[];
+/** Explicit, deterministic traditional-range sanitization; never mutates its input. */
+export declare function sanitizeTeam(pokemon: readonly PokemonSet[], options?: SanitizeOptions): {
+  pokemon: PokemonSet[];
+  diagnostics: Diagnostic[];
+};
+//#endregion
+//#region src/serialize.d.ts
+/** Format trusted typed sets, like Showdown. Use parseJSON separately for untrusted data. */
+export declare function exportTeam(pokemon: readonly PokemonSet[]): string;
+/** Collection export always includes headers, preserving team boundaries. */
+export declare function exportTeams(teams: readonly Team[]): string;
+//#endregion
+//#region src/limits.d.ts
+export declare const DEFAULT_LIMITS: Readonly<Limits>;
+export declare class KoffingError extends Error {
+  readonly diagnostics: Diagnostic[];
+  constructor(message: string, diagnostics: Diagnostic[]);
+}
+//#endregion
+export type { Diagnostic, Limits, Options, ParseResult, PokemonSet, SanitizeOptions, StatID, Stats, Team };

package/dist/index.d.ts

@@ -1,106 +1,29 @@
-type PokemonStats = {
-    hp: number;
-    atk: number;
-    def: number;
-    spa: number;
-    spd: number;
-    spe: number;
+import { a as PokemonSet, c as Stats, i as ParseResult, l as Team, n as Limits, o as SanitizeOptions, r as Options, s as StatID, t as Diagnostic } from "./types-BVzP_Ko4.js";
+//#region src/parse.d.ts
+/** Parse Showdown text without silently clamping values or dropping extra moves. */
+export declare function parse(input: string, options?: Options): ParseResult;
+//#endregion
+//#region src/data.d.ts
+/** Decode and copy known data only. Shape errors are fatal; unknown fields are diagnosed. */
+export declare function parseJSON(input: unknown, options?: Options): ParseResult;
+export declare function validateTeam(pokemon: readonly PokemonSet[], options?: Options): Diagnostic[];
+/** Explicit, deterministic traditional-range sanitization; never mutates its input. */
+export declare function sanitizeTeam(pokemon: readonly PokemonSet[], options?: SanitizeOptions): {
+  pokemon: PokemonSet[];
+  diagnostics: Diagnostic[];
 };
-type PokemonGender = 'M' | 'F';
-declare class Pokemon {
-    name: string | undefined;
-    nickname: string | undefined;
-    gender: PokemonGender | undefined;
-    item: string | undefined;
-    pokeball: string | undefined;
-    ability: string | undefined;
-    level: number | undefined;
-    shiny: boolean | undefined;
-    happiness: number | undefined;
-    nature: string | undefined;
-    evs: PokemonStats | undefined;
-    ivs: PokemonStats | undefined;
-    dynamaxLevel: number | undefined;
-    gigantamax: boolean | undefined;
-    teraType: string | undefined;
-    moves: string[];
-    static fromObject(obj: Pokemon | Record<string, any>): Pokemon;
-    toJson(indentation?: number): string;
-    toShowdown(): string;
-    toString(): string;
+//#endregion
+//#region src/serialize.d.ts
+/** Format trusted typed sets, like Showdown. Use parseJSON separately for untrusted data. */
+export declare function exportTeam(pokemon: readonly PokemonSet[]): string;
+/** Collection export always includes headers, preserving team boundaries. */
+export declare function exportTeams(teams: readonly Team[]): string;
+//#endregion
+//#region src/limits.d.ts
+export declare const DEFAULT_LIMITS: Readonly<Limits>;
+export declare class KoffingError extends Error {
+  readonly diagnostics: Diagnostic[];
+  constructor(message: string, diagnostics: Diagnostic[]);
 }
-
-declare class PokemonTeam {
-    name: string;
-    format: string;
-    folder: string | undefined;
-    pokemon: Pokemon[];
-    constructor(format?: string, name?: string, folder?: string | undefined);
-    static fromObject(obj: PokemonTeam | Record<string, any>): PokemonTeam;
-    toJson(indentation?: number): string;
-    toShowdown(): string;
-    toString(): string;
-}
-
-declare class PokemonTeamSet {
-    teams: PokemonTeam[];
-    constructor(teams?: PokemonTeam[]);
-    static fromObject(obj: PokemonTeamSet | Record<string, any>): PokemonTeamSet;
-    toJson(indentation?: number): string;
-    toShowdown(): string;
-    toString(): string;
-}
-
-type ParserState = {
-    team: PokemonTeam | null;
-    pokemon: Pokemon | null;
-};
-/**
- * Ported from Pokemon Showdown Client's exportTeam/importTeam functions.
- *
- * @see https://github.com/Zarel/Pokemon-Showdown-Client/blob/master/js/storage.js
- */
-declare class ShowdownParser {
-    static regexes: Record<string, RegExp>;
-    code: string;
-    constructor(code: string);
-    parse(): PokemonTeamSet;
-    _parseTeam(line: string, team: PokemonTeam): void;
-    _parseNameLine(line: string, pokemon: Pokemon): void;
-    _parseEvsIvs(line: string, pokemon: Pokemon | any): boolean;
-    _parseKeyValuePairs(line: string, pokemon: Pokemon | any): boolean;
-    /**
-     * Saves the current state of the parsed team.
-     */
-    _saveCurrent(teams: PokemonTeam[], current: ParserState): ShowdownParser;
-    /**
-     * Sanitizes and re-formats / prettifies the Showdown code
-     */
-    format(): ShowdownParser;
-    /**
-     * @returns {string}
-     */
-    toString(): string;
-}
-
-type DataType = string | Pokemon | PokemonTeam | PokemonTeamSet | ShowdownParser;
-declare class Koffing {
-    /**
-     * Converts from Showdown to a PokemonTeamSet object.
-     */
-    static parse(data: DataType): Pokemon | PokemonTeam | PokemonTeamSet;
-    /**
-     * Prettifies and sanitizes the given Showdown code.
-     */
-    static format(data: DataType): string;
-    /**
-     * Converts from Showdown to JSON code.
-     */
-    static toJson(data: DataType): string;
-    /**
-     * Converts from JSON string or JSON object to Showdown code.
-     */
-    static toShowdown(data: DataType | object): string;
-}
-
-export { Koffing, Pokemon, PokemonGender, PokemonStats, PokemonTeam, PokemonTeamSet, ShowdownParser };
+//#endregion
+export type { Diagnostic, Limits, Options, ParseResult, PokemonSet, SanitizeOptions, StatID, Stats, Team };