ogamejs 3.0.0 → 4.0.1

package/types/buildings/storage.d.ts

@@ -0,0 +1,29 @@
+/**
+ *
+ * Return the capacity of a storage building at a given level
+ *
+ * Level 0 is the free 10.000 units every planet starts with.
+ * @param {number} level The storage level, >= 0
+ * @returns {number} The protected capacity, in resource units
+ */
+declare function getStorageCapacity(level: number): number;
+/**
+ *
+ * Return the cost and the capacity of a storage building at a given level
+ * @param {import('../types.js').BuildingEntry} storage A storage entry of models/buildings.js (22, 23 or 24)
+ * @param {number} targetLevel The level to reach, >= 1
+ * @returns {import('../types.js').Cost & {capacity: number}} The cost of that level plus the capacity
+ */
+declare function getStorage(storage: import('../types.js').BuildingEntry, targetLevel: number): import('../types.js').Cost & {
+    capacity: number;
+};
+/**
+ *
+ * Return the lowest storage level able to protect a given amount of resources
+ * @param {number} amount The amount of resources to protect
+ * @returns {number} The required storage level
+ */
+declare function getStorageLevelFor(amount: number): number;
+export { getStorageCapacity, getStorageLevelFor };
+export default getStorage;
+//# sourceMappingURL=storage.d.ts.map

package/types/buildings/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/buildings/storage.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,iBAAS,kBAAkB,CAAC,KAAK,EAHtB,MAGsB,GAFpB,MAAM,CAQlB;AAED;;;;;;GAMG;AACH,iBAAS,UAAU,CAAC,OAAO,EAJhB,OAAO,aAAa,EAAE,aAIN,EAAE,WAAW,EAH7B,MAG6B,GAF3B,OAAO,aAAa,EAAE,IAAI,GAAG;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAa3D;AAED;;;;;GAKG;AACH,iBAAS,kBAAkB,CAAC,MAAM,EAHvB,MAGuB,GAFrB,MAAM,CAalB;AAED,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;eACnC,UAAU"}

package/types/cost.d.ts

@@ -0,0 +1,25 @@
+declare function assertLevel(targetLevel: any): void;
+/**
+ * Guard against the pre-4.0 habit of passing `Buildings[id].base` around.
+ * Every calculator now needs the whole entry, because the cost `factor` lives
+ * on it and not on its `base`.
+ */
+declare function assertEntry(entry: any, targetLevel: any): void;
+/**
+ *
+ * Return the cost of a building or a technology at a given level
+ *
+ * Works for anything carrying a `base` and a `factor`, so both
+ * `models/buildings.js` and `models/research.js` entries are accepted.
+ * Use the dedicated `getMetalMine`/`getCrystalMine`/... helpers when you also
+ * need the production or the consumption of a mine or a plant.
+ *
+ * @param {import('./types.js').BuildingEntry|import('./types.js').ResearchEntry} entry A Buildings or
+ *   Research entry (not its `base`)
+ * @param {number} targetLevel The level to reach, >= 1
+ * @returns {import('./types.js').Cost} The resources, and the energy, paid to reach that level
+ */
+declare function getCost(entry: import('./types.js').BuildingEntry | import('./types.js').ResearchEntry, targetLevel: number): import('./types.js').Cost;
+export { assertLevel, assertEntry };
+export default getCost;
+//# sourceMappingURL=cost.d.ts.map

package/types/cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../src/cost.js"],"names":[],"mappings":"AAAA,iBAAS,WAAW,CAAC,WAAW,KAAA,QAI/B;AAED;;;;GAIG;AACH,iBAAS,WAAW,CAAC,KAAK,KAAA,EAAE,WAAW,KAAA,QAgBtC;AAYD;;;;;;;;;;;;;GAaG;AACH,iBAAS,OAAO,CAAC,KAAK,EALX,OAAO,YAAY,EAAE,aAAa,GAAC,OAAO,YAAY,EAAE,aAK7C,EAAE,WAAW,EAHxB,MAGwB,GAFtB,OAAO,YAAY,EAAE,IAAI,CAerC;AAED,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;eACrB,OAAO"}

package/types/fleets/combat.d.ts

@@ -0,0 +1,57 @@
+declare const ROUNDS = 6;
+/**
+ * A tiny deterministic PRNG (mulberry32), so a battle can be replayed.
+ */
+declare function createRandom(seed: any): () => number;
+/**
+ *
+ * Simulate a battle between two fleets
+ *
+ * Follows the game rules: up to six rounds, every unit fires once per round at a
+ * random enemy, rapid fire grants extra shots, shots below 1% of the target
+ * shield bounce off, shields come back every round, and a unit under 70% hull
+ * may explode at the end of the round.
+ *
+ * A battle is random, so one run is one possible outcome. The `seed` makes a run
+ * reproducible; average several seeds to get a feel for the likely result.
+ * @param {object} attacker The attacking side
+ * @param {import('../types.js').FleetEntry[]} attacker.fleet Its ships
+ * @param {import('../types.js').CombatTechs} [attacker.techs] Its combat technology levels
+ * @param {object} defender The defending side, same shape, defenses included
+ * @param {object} [options] Simulation options
+ * @param {number} [options.seed] The PRNG seed, for a reproducible battle
+ * @param {number} [options.debrisFactor] The universe debris factor
+ * @param {number} [options.deuteriumDebrisFactor] The universe deuterium debris factor
+ * @param {boolean} [options.defenseDebris] Whether destroyed defenses leave debris
+ * @returns {{
+ *   winner: 'attacker'|'defender'|'draw', rounds: number, seed: number,
+ *   attacker: {survivors: import('../types.js').FleetEntry[], losses: import('../types.js').FleetEntry[]},
+ *   defender: {survivors: import('../types.js').FleetEntry[], losses: import('../types.js').FleetEntry[]},
+ *   debris: import('../types.js').Resources,
+ * }} Who won, how long it took, what is left on each side, and the debris field
+ */
+declare function simulateCombat(attacker: {
+    fleet: import('../types.js').FleetEntry[];
+    techs?: import('../types.js').CombatTechs;
+}, defender: object, options?: {
+    seed?: number;
+    debrisFactor?: number;
+    deuteriumDebrisFactor?: number;
+    defenseDebris?: boolean;
+}): {
+    winner: 'attacker' | 'defender' | 'draw';
+    rounds: number;
+    seed: number;
+    attacker: {
+        survivors: import('../types.js').FleetEntry[];
+        losses: import('../types.js').FleetEntry[];
+    };
+    defender: {
+        survivors: import('../types.js').FleetEntry[];
+        losses: import('../types.js').FleetEntry[];
+    };
+    debris: import('../types.js').Resources;
+};
+export { createRandom, ROUNDS };
+export default simulateCombat;
+//# sourceMappingURL=combat.d.ts.map

package/types/fleets/combat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combat.d.ts","sourceRoot":"","sources":["../../src/fleets/combat.js"],"names":[],"mappings":"AAGA,QAAA,MAAM,MAAM,IAAI,CAAC;AAmCjB;;GAEG;AACH,iBAAS,YAAY,CAAC,IAAI,KAAA,gBAWzB;AAqJD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,iBAAS,cAAc,CAAC,QAAQ,EAf7B;IAAqD,KAAK,EAAlD,OAAO,aAAa,EAAE,UAAU,EAAE,CAC1C;IAAqD,KAAK,AAA1D,CACA,EADQ,OAAO,aAAa,EAAE,WAAW,CACzC;CAa6B,EAAE,QAAQ,EAb/B,MAa+B,EAAE,OAAO,AAZhD,CAKA,EAJA;IAAyB,IAAI,AAA7B,CACA,EADQ,MAAM,CACd;IAAyB,YAAY,AAArC,CACA,EADQ,MAAM,CACd;IAAyB,qBAAqB,AAA9C,CACA,EADQ,MAAM,CACd;IAA0B,aAAa,AAAvC,CACA,EADQ,OAAO,CACf;CAOqD,GAP3C;IACR,MAAM,EAAE,UAAU,GAAC,UAAU,GAAC,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IACnE,QAAQ,EAAE;QAAC,SAAS,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAA;KAAC,CAAC;IACtG,QAAQ,EAAE;QAAC,SAAS,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;QAAC,MAAM,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAA;KAAC,CAAC;IACtG,MAAM,EAAE,OAAO,aAAa,EAAE,SAAS,CAAC;CACzC,CA6DH;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;eACjB,cAAc"}

package/types/fleets/distance.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * Return the distance between two coordinates, in OGame distance units
+ *
+ * The scale is not linear: crossing a galaxy costs far more than crossing a
+ * system, which costs far more than moving inside one.
+ * @param {import('../types.js').Coordinates} origin Where the fleet leaves from
+ * @param {import('../types.js').Coordinates} target Where it goes
+ * @returns {number} The distance
+ */
+declare function getDistance(origin: import('../types.js').Coordinates, target: import('../types.js').Coordinates): number;
+export default getDistance;
+//# sourceMappingURL=distance.d.ts.map

package/types/fleets/distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance.d.ts","sourceRoot":"","sources":["../../src/fleets/distance.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,iBAAS,WAAW,CAAC,MAAM,EAJhB,OAAO,aAAa,EAAE,WAIN,EAAE,MAAM,EAHxB,OAAO,aAAa,EAAE,WAGE,GAFtB,MAAM,CAoBlB;eAEc,WAAW"}

package/types/fleets/flight.d.ts

@@ -0,0 +1,57 @@
+/**
+ *
+ * Return the one way flight time of a fleet
+ *
+ * `(10 + 35000 / speedPercent * sqrt(distance * 10 / fleetSpeed)) / universeFleetSpeed`
+ * @param {number} distance The distance to cross, from `getDistance`
+ * @param {number} fleetSpeed The speed of the slowest ship, from `getFleetSpeed`
+ * @param {number} [speedPercent] The fleet speed slider, 10 to 100 in game
+ * @param {number} [universeFleetSpeed] The universe fleet speed
+ * @returns {number} The flight time, in seconds
+ */
+declare function getFlightTime(distance: number, fleetSpeed: number, speedPercent?: number, universeFleetSpeed?: number): number;
+/**
+ *
+ * Return the deuterium a fleet burns for a one way trip
+ *
+ * `1 + round(sum(consumption * count) * distance / 35000 * (speedPercent / 100 + 1) ** 2)`
+ * @param {import('../types.js').FleetEntry[]} fleet The ships taking off
+ * @param {number} distance The distance to cross, from `getDistance`
+ * @param {number} [speedPercent] The fleet speed slider, 10 to 100 in game
+ * @param {import('../types.js').Drives} [drives] Drive levels, needed because a
+ *   ship that switched drive also changed its consumption
+ * @returns {number} The fuel needed, in deuterium
+ */
+declare function getFuelConsumption(fleet: import('../types.js').FleetEntry[], distance: number, speedPercent?: number, drives?: import('../types.js').Drives): number;
+/**
+ *
+ * Return everything about a trip: distance, duration, fuel and cargo left
+ * @param {import('../types.js').FleetEntry[]} fleet The ships taking off
+ * @param {import('../types.js').Coordinates} origin Where the fleet leaves from
+ * @param {import('../types.js').Coordinates} target Where it goes
+ * @param {object} [options] Trip options
+ * @param {number} [options.speedPercent] The fleet speed slider, 10 to 100 in game
+ * @param {number} [options.universeFleetSpeed] The universe fleet speed
+ * @param {import('../types.js').Drives} [options.drives] The drive technology levels
+ * @param {boolean} [options.roundTrip] Whether to account for the way back too
+ * @returns {{
+ *   distance: number, fleetSpeed: number, duration: number, fuel: number,
+ *   cargo: number, cargoAfterFuel: number,
+ * }} The trip, with durations in seconds and `cargoAfterFuel` the room left once
+ *   the fuel is loaded
+ */
+declare function getTrip(fleet: import('../types.js').FleetEntry[], origin: import('../types.js').Coordinates, target: import('../types.js').Coordinates, options?: {
+    speedPercent?: number;
+    universeFleetSpeed?: number;
+    drives?: import('../types.js').Drives;
+    roundTrip?: boolean;
+}): {
+    distance: number;
+    fleetSpeed: number;
+    duration: number;
+    fuel: number;
+    cargo: number;
+    cargoAfterFuel: number;
+};
+export { getFlightTime, getFuelConsumption, getTrip };
+//# sourceMappingURL=flight.d.ts.map

package/types/fleets/flight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flight.d.ts","sourceRoot":"","sources":["../../src/fleets/flight.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,iBAAS,aAAa,CAAC,QAAQ,EANpB,MAMoB,EAAE,UAAU,EALhC,MAKgC,EAAE,YAAY,AAJtD,CACA,EADQ,MAIoD,EAAE,kBAAkB,AAHhF,CACA,EADQ,MAG4E,GAF1E,MAAM,CAYlB;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,kBAAkB,CAAC,KAAK,EAPtB,OAAO,aAAa,EAAE,UAAU,EAOV,EAAE,QAAQ,EANhC,MAMgC,EAAE,YAAY,AALtD,CACA,EADQ,MAKoD,EAAE,MAAM,AAJpE,CAEA,EAFQ,OAAO,aAAa,EAAE,MAI2C,GAF/D,MAAM,CAmBlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,iBAAS,OAAO,CAAC,KAAK,EAdX,OAAO,aAAa,EAAE,UAAU,EAcrB,EAAE,MAAM,EAbnB,OAAO,aAAa,EAAE,WAaH,EAAE,MAAM,EAZ3B,OAAO,aAAa,EAAE,WAYK,EAAE,OAAO,AAX5C,CAKA,EAJA;IAAyB,YAAY,AAArC,CACA,EADQ,MAAM,CACd;IAAyB,kBAAkB,AAA3C,CACA,EADQ,MAAM,CACd;IAA+C,MAAM,AAArD,CACA,EADQ,OAAO,aAAa,EAAE,MAAM,CACpC;IAA0B,SAAS,AAAnC,CACA,EADQ,OAAO,CACf;CAMiD,GANvC;IACR,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IACrE,KAAK,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;CACvC,CAyBH;AAED,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,OAAO,EAAE,CAAC"}

package/types/fleets/getDebris.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * Return the debris field left behind by destroyed ships or defenses
+ * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
+ * @param {number} number The number of destroyed units
+ * @param {number} factor The universe debris factor, e.g. 0.3 for 30%
+ * @param {number} [deuteriumFactor] The universe deuterium debris factor, 0 on most universes
+ * @return {import('../types.js').Resources} The debris generated
+ */
+declare function getDebris(ship: import('../types.js').DestroyableEntry, number: number, factor: number, deuteriumFactor?: number): import('../types.js').Resources;
+export default getDebris;
+//# sourceMappingURL=getDebris.d.ts.map

package/types/fleets/getDebris.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDebris.d.ts","sourceRoot":"","sources":["../../src/fleets/getDebris.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,iBAAS,SAAS,CAAC,IAAI,EANZ,OAAO,aAAa,EAAE,gBAMV,EAAE,MAAM,EALpB,MAKoB,EAAE,MAAM,EAJ5B,MAI4B,EAAE,eAAe,AAHrD,CACA,EADQ,MAGiD,GAFhD,OAAO,aAAa,EAAE,SAAS,CAW1C;eAEc,SAAS"}

package/types/fleets/index.d.ts

@@ -0,0 +1,18 @@
+import getDebris from './getDebris.js';
+import getDistance from './distance.js';
+import getShipSpeed, { getActiveDrive, getFleetSpeed } from './speed.js';
+import { getFlightTime, getFuelConsumption, getTrip } from './flight.js';
+import simulateCombat from './combat.js';
+declare const Fleets: {
+    getDebris: typeof getDebris;
+    getDistance: typeof getDistance;
+    getShipSpeed: typeof getShipSpeed;
+    getActiveDrive: typeof getActiveDrive;
+    getFleetSpeed: typeof getFleetSpeed;
+    getFlightTime: typeof getFlightTime;
+    getFuelConsumption: typeof getFuelConsumption;
+    getTrip: typeof getTrip;
+    simulateCombat: typeof simulateCombat;
+};
+export default Fleets;
+//# sourceMappingURL=index.d.ts.map

package/types/fleets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fleets/index.js"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,WAAW,MAAM,eAAe,CAAC;AACxC,OAAO,YAAY,EAAE,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,cAAc,MAAM,aAAa,CAAC;AAEzC,QAAA,MAAM,MAAM;;;;;;;;;;CAUX,CAAC;eAEa,MAAM"}

package/types/fleets/speed.d.ts

@@ -0,0 +1,54 @@
+declare const DRIVES: {
+    COMBUSTION: string;
+    IMPULSE: string;
+    HYPERSPACE: string;
+    NONE: string;
+};
+/** Each drive level adds that share of the ship base speed. */
+declare const DRIVE_BONUS: Readonly<{
+    [DRIVES.COMBUSTION]: 0.1;
+    [DRIVES.IMPULSE]: 0.2;
+    [DRIVES.HYPERSPACE]: 0.3;
+    [DRIVES.NONE]: 0;
+}>;
+/** The research id backing each drive, handy to look the level up. */
+declare const DRIVE_RESEARCH: Readonly<{
+    [DRIVES.COMBUSTION]: 115;
+    [DRIVES.IMPULSE]: 117;
+    [DRIVES.HYPERSPACE]: 118;
+}>;
+/**
+ *
+ * Return the drive a ship actually flies on, and the speed it reaches
+ *
+ * A few ships switch to a better drive once the matching technology is high
+ * enough — a small cargo moves to the impulse drive at Impulse 5. When several
+ * drives are available the ship uses whichever ends up fastest.
+ * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
+ * @param {import('../types.js').Drives} [drives] Drive levels
+ * @returns {{drive: string, speed: number, fuelConsumption: number}} The active drive
+ */
+declare function getActiveDrive(ship: import('../types.js').DestroyableEntry, drives?: import('../types.js').Drives): {
+    drive: string;
+    speed: number;
+    fuelConsumption: number;
+};
+/**
+ *
+ * Return the speed of a ship, drive technologies included
+ * @param {import('../types.js').DestroyableEntry} ship An entry of models/destroyable.js
+ * @param {import('../types.js').Drives} [drives] Drive levels
+ * @returns {number} The speed the ship flies at
+ */
+declare function getShipSpeed(ship: import('../types.js').DestroyableEntry, drives?: import('../types.js').Drives): number;
+/**
+ *
+ * Return the speed of a whole fleet, which is the speed of its slowest ship
+ * @param {import('../types.js').FleetEntry[]} fleet The ships taking off
+ * @param {import('../types.js').Drives} [drives] Drive levels
+ * @returns {number} The fleet speed
+ */
+declare function getFleetSpeed(fleet: import('../types.js').FleetEntry[], drives?: import('../types.js').Drives): number;
+export { getActiveDrive, getFleetSpeed, DRIVE_BONUS, DRIVE_RESEARCH, };
+export default getShipSpeed;
+//# sourceMappingURL=speed.d.ts.map

package/types/fleets/speed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speed.d.ts","sourceRoot":"","sources":["../../src/fleets/speed.js"],"names":[],"mappings":"AAEA,QAAA,MAAQ,MAAM;;;;;CAAe,CAAC;AAE9B,+DAA+D;AAC/D,QAAA,MAAM,WAAW;IACf,CAAC,MAAM,CAAC,UAAU,CAAC,MAAK;IACxB,CAAC,MAAM,CAAC,OAAO,CAAC,MAAK;IACrB,CAAC,MAAM,CAAC,UAAU,CAAC,MAAK;IACxB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAG;EAChB,CAAC;AAEH,sEAAsE;AACtE,QAAA,MAAM,cAAc;IAClB,CAAC,MAAM,CAAC,UAAU,CAAC,MAAK;IACxB,CAAC,MAAM,CAAC,OAAO,CAAC,MAAK;IACrB,CAAC,MAAM,CAAC,UAAU,CAAC,MAAK;EACxB,CAAC;AAsBH;;;;;;;;;;GAUG;AACH,iBAAS,cAAc,CAAC,IAAI,EAJjB,OAAO,aAAa,EAAE,gBAIL,EAAE,MAAM,AAHjC,CACA,EADQ,OAAO,aAAa,EAAE,MAGQ,GAF5B;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAC,CAoBnE;AAED;;;;;;GAMG;AACH,iBAAS,YAAY,CAAC,IAAI,EAJf,OAAO,aAAa,EAAE,gBAIP,EAAE,MAAM,AAH/B,CACA,EADQ,OAAO,aAAa,EAAE,MAGM,GAF1B,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,iBAAS,aAAa,CAAC,KAAK,EAJjB,OAAO,aAAa,EAAE,UAAU,EAIf,EAAE,MAAM,AAHjC,CACA,EADQ,OAAO,aAAa,EAAE,MAGQ,GAF5B,MAAM,CAgBlB;AAED,OAAO,EACL,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,GAC3D,CAAC;eACa,YAAY"}

package/types/i18n.d.ts

@@ -0,0 +1,23 @@
+declare const LANGS: readonly string[];
+/**
+ *
+ * Return the localised name of a model entry
+ * @param {{names: import('./types.js').Names}} entry An entry of Buildings, Destroyable or Research
+ * @param {import('./types.js').Lang} [lang] 'en' or 'fr', defaults to 'en'
+ * @returns {string} The localised name
+ */
+declare function getName(entry: {
+    names: import('./types.js').Names;
+}, lang?: import('./types.js').Lang): string;
+/**
+ *
+ * Look an entry up by any of its localised names, case and accent insensitive
+ * @param {Record<string|number, {names: import('./types.js').Names}>} model Buildings, Destroyable or Research
+ * @param {string} name The name to look for, in any supported language
+ * @returns {object|undefined} The matching entry, or undefined
+ */
+declare function findByName(model: Record<string | number, {
+    names: import('./types.js').Names;
+}>, name: string): object | undefined;
+export { getName, findByName, LANGS };
+//# sourceMappingURL=i18n.d.ts.map

package/types/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/i18n.js"],"names":[],"mappings":"AAEA,QAAA,MAAM,KAAK,mBAA8B,CAAC;AAE1C;;;;;;GAMG;AACH,iBAAS,OAAO,CAAC,KAAK,EAJX;IAAC,KAAK,EAAE,OAAO,YAAY,EAAE,KAAK,CAAA;CAIvB,EAAE,IAAI,AAHzB,CACA,EADQ,OAAO,YAAY,EAAE,IAGW,GAF9B,MAAM,CASlB;AAED;;;;;;GAMG;AACH,iBAAS,UAAU,CAAC,KAAK,EAJd,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE;IAAC,KAAK,EAAE,OAAO,YAAY,EAAE,KAAK,CAAA;CAAC,CAI3C,EAAE,IAAI,EAHpB,MAGoB,GAFlB,MAAM,GAAC,SAAS,CAe5B;AAED,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC"}