koffing 1.0.0 → 2.0.0

package/dist/data-CRHBhbCJ.js

@@ -0,0 +1,345 @@
+//#region src/limits.ts
+const DEFAULT_LIMITS = Object.freeze({
+	maxInputLength: 2e6,
+	maxLineLength: 16384,
+	maxTeams: 1e3,
+	maxPokemon: 1e4,
+	maxMoves: 256,
+	maxDiagnostics: 1e3
+});
+var KoffingError = class extends Error {
+	diagnostics;
+	constructor(message, diagnostics) {
+		super(message);
+		this.name = "KoffingError";
+		this.diagnostics = diagnostics;
+	}
+};
+function resolveLimits(options = {}) {
+	if (options.mode !== void 0 && options.mode !== "strict" && options.mode !== "permissive") throw new TypeError("mode must be strict or permissive");
+	if (options.limits === void 0) return DEFAULT_LIMITS;
+	const limits = {
+		...DEFAULT_LIMITS,
+		...options.limits
+	};
+	for (const [key, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${key} must be a positive safe integer`);
+	return limits;
+}
+function fail(code, message, line) {
+	throw new KoffingError(message, [{
+		code,
+		message,
+		severity: "error",
+		...line === void 0 ? {} : { line }
+	}]);
+}
+function checkInput(input, limits) {
+	if (typeof input !== "string") throw new TypeError("Input must be a string");
+	if (input.length > limits.maxInputLength) fail("input-limit", `Input exceeds ${limits.maxInputLength} code units`);
+}
+function finish(diagnostics, options) {
+	if (options.mode === "strict" && diagnostics.length) throw new KoffingError(diagnostics[0].message, diagnostics);
+}
+function report(diagnostics, diagnostic, limits) {
+	if (diagnostics.length >= limits.maxDiagnostics) fail("diagnostic-limit", "Too many parsing issues", diagnostic.line);
+	diagnostics.push(diagnostic);
+}
+//#endregion
+//#region src/data.ts
+const strings = [
+	"species",
+	"name",
+	"item",
+	"ability",
+	"nature",
+	"pokeball",
+	"hpType",
+	"teraType"
+];
+const numbers = [
+	"level",
+	"happiness",
+	"dynamaxLevel"
+];
+const flags = ["shiny", "gigantamax"];
+const stats = [
+	"hp",
+	"atk",
+	"def",
+	"spa",
+	"spd",
+	"spe"
+];
+const statKeys = new Set(stats);
+const teamKeys = /* @__PURE__ */ new Set([
+	"name",
+	"format",
+	"folder",
+	"pokemon"
+]);
+const collectionKeys = /* @__PURE__ */ new Set(["teams"]);
+const setKeys = /* @__PURE__ */ new Set([
+	...strings,
+	...numbers,
+	...flags,
+	"gender",
+	"evs",
+	"ivs",
+	"moves"
+]);
+function objectKeys(value, path, limits) {
+	if (typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) fail("invalid-json", `${path} must be a plain object`);
+	const keys = Reflect.ownKeys(value);
+	if (keys.length > limits.maxDiagnostics + 32) fail("property-limit", `${path} contains too many properties`);
+	return keys;
+}
+function property(value, key, path, limits) {
+	const descriptor = Object.getOwnPropertyDescriptor(value, key);
+	if (typeof key !== "string" || !("value" in descriptor)) fail("invalid-json", `${path} contains an accessor or symbol`);
+	if (key.length > Math.max(32, limits.maxLineLength)) fail("property-limit", `${path} contains an oversized property name`);
+	return descriptor.value;
+}
+function object(value, path, limits) {
+	const keys = objectKeys(value, path, limits);
+	const result = Object.create(null);
+	for (const key of keys) result[key] = property(value, key, path, limits);
+	return result;
+}
+function array(value, path, maximum) {
+	if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) fail("invalid-json", `${path} must be an array`);
+	if (value.length > maximum) fail("collection-limit", `${path} exceeds ${maximum} entries`);
+	if (Reflect.ownKeys(value).length !== value.length + 1) fail("invalid-json", `${path} contains non-index properties or holes`);
+	const result = [];
+	for (let i = 0; i < value.length; i++) {
+		const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+		if (!descriptor || !("value" in descriptor)) fail("invalid-json", `${path} must not contain holes or accessors`);
+		result.push(descriptor.value);
+	}
+	return result;
+}
+function text(value, path, limits, budget) {
+	if (typeof value !== "string" || /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/u.test(value) || value !== value.trim()) fail("invalid-text", `${path} must be trimmed text without control characters`);
+	if (value.length > limits.maxLineLength) fail("line-limit", `${path} exceeds ${limits.maxLineLength} code units`);
+	budget.used += value.length + 32;
+	if (budget.used > limits.maxInputLength) fail("input-limit", "Aggregate data exceeds configured input limit");
+	return value;
+}
+function finite(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) fail("invalid-number", `${path} must be finite`);
+	return value;
+}
+function unknownKeys(source, known, path, diagnostics, limits) {
+	for (const key of Object.keys(source)) if (!known.has(key)) report(diagnostics, {
+		code: "unknown-field",
+		severity: "warning",
+		path: `${path}.${key}`,
+		message: `Unknown field ${path}.${key}`
+	}, limits);
+}
+function readSet(value, path, diagnostics, limits, budget) {
+	const keys = objectKeys(value, path, limits);
+	budget.used += 512;
+	if (budget.used > limits.maxInputLength) fail("input-limit", "Aggregate data exceeds configured input limit");
+	const result = {
+		species: "",
+		moves: []
+	};
+	let hasMoves = false;
+	for (const rawKey of keys) {
+		const entry = property(value, rawKey, path, limits);
+		const key = rawKey;
+		if (!setKeys.has(key)) {
+			report(diagnostics, {
+				code: "unknown-field",
+				severity: "warning",
+				path: `${path}.${key}`,
+				message: `Unknown field ${path}.${key}`
+			}, limits);
+			continue;
+		}
+		if (entry === void 0 && key !== "species" && key !== "moves") continue;
+		switch (key) {
+			case "species":
+			case "name":
+			case "item":
+			case "ability":
+			case "nature":
+			case "pokeball":
+			case "hpType":
+			case "teraType":
+				result[key] = text(entry, `${path}.${key}`, limits, budget);
+				break;
+			case "level":
+			case "happiness":
+			case "dynamaxLevel":
+				result[key] = finite(entry, `${path}.${key}`);
+				break;
+			case "shiny":
+			case "gigantamax":
+				if (typeof entry !== "boolean") fail("invalid-boolean", `${path}.${key} must be boolean`);
+				result[key] = entry;
+				break;
+			case "gender":
+				if (entry !== "M" && entry !== "F" && entry !== "N" && entry !== "") fail("invalid-gender", `${path}.gender must be M, F, N or empty`);
+				result.gender = entry;
+				break;
+			case "evs":
+			case "ivs": {
+				const statPath = `${path}.${key}`;
+				const values = {};
+				for (const rawStat of objectKeys(entry, statPath, limits)) {
+					const number = property(entry, rawStat, statPath, limits);
+					const stat = rawStat;
+					if (!statKeys.has(stat)) report(diagnostics, {
+						code: "unknown-field",
+						severity: "warning",
+						path: `${statPath}.${stat}`,
+						message: `Unknown field ${statPath}.${stat}`
+					}, limits);
+					else if (number !== void 0) values[stat] = finite(number, `${statPath}.${stat}`);
+				}
+				result[key] = values;
+				break;
+			}
+			case "moves": {
+				hasMoves = true;
+				const moves = array(entry, `${path}.moves`, limits.maxMoves);
+				for (let index = 0; index < moves.length; index++) if (!text(moves[index], `${path}.moves[${index}]`, limits, budget)) fail("invalid-move", `${path}.moves[${index}] cannot be empty`);
+				result.moves = moves;
+				break;
+			}
+		}
+	}
+	if (!result.species) fail("invalid-species", `${path}.species is required`);
+	if (!hasMoves) fail("invalid-json", `${path}.moves must be an array`);
+	return result;
+}
+/** Decode and copy known data only. Shape errors are fatal; unknown fields are diagnosed. */
+function parseJSON(input, options = {}) {
+	const limits = resolveLimits(options);
+	let value = input;
+	if (typeof value === "string") {
+		checkInput(value, limits);
+		try {
+			value = JSON.parse(value);
+		} catch {
+			fail("invalid-json", "Invalid JSON syntax");
+		}
+	}
+	const diagnostics = [];
+	const budget = { used: 0 };
+	let rawTeams;
+	if (Array.isArray(value)) rawTeams = [{ pokemon: value }];
+	else {
+		const source = object(value, "input", limits);
+		if (Object.hasOwn(source, "teams")) {
+			unknownKeys(source, collectionKeys, "input", diagnostics, limits);
+			rawTeams = array(source.teams, "teams", limits.maxTeams);
+		} else if (Object.hasOwn(source, "pokemon")) rawTeams = [source];
+		else rawTeams = [{ pokemon: [source] }];
+	}
+	if (rawTeams.length > limits.maxTeams) fail("collection-limit", "Too many teams");
+	let total = 0;
+	const teams = rawTeams.map((raw, index) => {
+		const path = `teams[${index}]`;
+		const source = object(raw, path, limits);
+		unknownKeys(source, teamKeys, path, diagnostics, limits);
+		const members = array(source.pokemon, `${path}.pokemon`, limits.maxPokemon - total);
+		total += members.length;
+		const team = { pokemon: members.map((member, i) => readSet(member, `${path}.pokemon[${i}]`, diagnostics, limits, budget)) };
+		for (const key of [
+			"name",
+			"format",
+			"folder"
+		]) if (source[key] !== void 0) team[key] = text(source[key], `${path}.${key}`, limits, budget);
+		return team;
+	});
+	for (const [index, team] of teams.entries()) checkRanges(team.pokemon, `teams[${index}].pokemon`, diagnostics, limits);
+	finish(diagnostics, options);
+	return {
+		teams,
+		diagnostics
+	};
+}
+/** Generic traditional-format checks, not species or format legality validation. */
+function checkRanges(pokemon, path, diagnostics, limits) {
+	const add = (code, path, message) => report(diagnostics, {
+		code,
+		severity: "warning",
+		path,
+		message
+	}, limits);
+	for (const [i, set] of pokemon.entries()) {
+		const prefix = `${path}[${i}]`;
+		const range = (value, min, max, field, code = "number-range") => {
+			if (value !== void 0 && (!Number.isInteger(value) || value < min || value > max)) add(code, `${prefix}.${field}`, `Expected an integer from ${min} to ${max}; value preserved`);
+		};
+		range(set.level, 1, 100, "level");
+		range(set.happiness, 0, 255, "happiness");
+		range(set.dynamaxLevel, 0, 10, "dynamaxLevel");
+		let evTotal = 0;
+		for (const stat of stats) {
+			const ev = set.evs?.[stat];
+			const iv = set.ivs?.[stat];
+			if (ev !== void 0) {
+				evTotal += ev;
+				range(ev, 0, 255, `evs.${stat}`, "stat-range");
+			}
+			if (iv !== void 0) range(iv, 0, 31, `ivs.${stat}`, "stat-range");
+		}
+		if (evTotal > 510) add("ev-total", `${prefix}.evs`, "Traditional EV total exceeds 510");
+		if (set.moves.length > 4) add("move-count", `${prefix}.moves`, "Traditional sets contain at most four moves");
+	}
+}
+function validateTeam(pokemon, options = {}) {
+	return parseJSON(pokemon, options).diagnostics;
+}
+/** Explicit, deterministic traditional-range sanitization; never mutates its input. */
+function sanitizeTeam(pokemon, options = {}) {
+	const maxLevel = options.maxLevel ?? 100;
+	const maxMoves = options.maxMovesPerPokemon ?? 4;
+	if (!Number.isSafeInteger(maxLevel) || maxLevel < 1 || !Number.isSafeInteger(maxMoves) || maxMoves < 0) throw new TypeError("Sanitization limits must be valid nonnegative integers (maxLevel >= 1)");
+	const parsed = parseJSON(pokemon, {
+		...options,
+		mode: "permissive"
+	});
+	const result = parsed.teams[0].pokemon;
+	const diagnostics = parsed.diagnostics;
+	const limits = resolveLimits(options);
+	const changed = (path) => report(diagnostics, {
+		code: "sanitized",
+		severity: "warning",
+		path,
+		message: `Sanitized ${path}`
+	}, limits);
+	const clamp = (value, min, max, path) => {
+		const next = Math.max(min, Math.min(max, Math.trunc(value)));
+		if (next !== value) changed(path);
+		return next;
+	};
+	for (const [i, set] of result.entries()) {
+		const path = `pokemon[${i}]`;
+		if (set.level !== void 0) set.level = clamp(set.level, 1, maxLevel, `${path}.level`);
+		if (set.happiness !== void 0) set.happiness = clamp(set.happiness, 0, 255, `${path}.happiness`);
+		if (set.dynamaxLevel !== void 0) set.dynamaxLevel = clamp(set.dynamaxLevel, 0, 10, `${path}.dynamaxLevel`);
+		let evBudget = 510;
+		for (const stat of stats) {
+			if (set.evs?.[stat] !== void 0) {
+				set.evs[stat] = clamp(set.evs[stat], 0, Math.min(255, evBudget), `${path}.evs.${stat}`);
+				evBudget -= set.evs[stat];
+			}
+			if (set.ivs?.[stat] !== void 0) set.ivs[stat] = clamp(set.ivs[stat], 0, 31, `${path}.ivs.${stat}`);
+		}
+		if (set.moves.length > maxMoves) {
+			set.moves = set.moves.slice(0, maxMoves);
+			changed(`${path}.moves`);
+		}
+	}
+	finish(diagnostics, options);
+	return {
+		pokemon: result,
+		diagnostics
+	};
+}
+//#endregion
+export { KoffingError as a, finish as c, DEFAULT_LIMITS as i, report as l, sanitizeTeam as n, checkInput as o, validateTeam as r, fail as s, parseJSON as t, resolveLimits as u };