powergrid-engine 1.9.7

package/src/maps.ts

@@ -0,0 +1,123 @@
+import seedrandom from 'seedrandom';
+import { PowerPlant } from './gamestate';
+import { map as america, mapRecharged as americaRecharged } from './maps/america';
+import { map as benelux } from './maps/benelux';
+import { map as brazil } from './maps/brazil';
+import { map as centraleurope } from './maps/centraleurope';
+import { map as china } from './maps/china';
+import { map as france } from './maps/france';
+import { map as germany, mapRecharged as germanyRecharged } from './maps/germany';
+import { map as indian } from './maps/indian';
+import { map as italy } from './maps/italy';
+import { map as middleeast } from './maps/middleeast';
+import { map as quebec } from './maps/quebec';
+import { map as russia } from './maps/russia';
+import { map as spainportugal } from './maps/spainportugal';
+// import { map as australia } from './maps/australia';
+// import { map as badenwurttemberg } from './maps/badenwurttemberg';
+// import { map as japan } from './maps/japan';
+// import { map as korea } from './maps/korea';
+// import { map as northerneurope } from './maps/northerneurope';
+// import { map as southafrica } from './maps/southafrica';
+// import { map as ukireland } from './maps/ukireland';
+
+export interface City {
+    name: string;
+    region: string;
+    x: number;
+    y: number;
+}
+
+export interface Connection {
+    nodes: string[];
+    cost: number;
+}
+
+export interface Polygon {
+    region: string;
+    points: number[][];
+}
+
+export interface GameMap {
+    name: string;
+    cities: City[];
+    connections: Connection[];
+    polygons?: Polygon[];
+    layout?: 'Portrait' | 'Landscape';
+    adjustRatio?: [number, number];
+    viewBox?: [number, number];
+    playerOrderPosition?: [number, number];
+    cityCountPosition?: [number, number];
+    powerPlantMarketPosition?: [number, number];
+    actualMarketWidth?: number;
+    mapPosition?: [number, number];
+    buttonsPosition?: [number, number];
+    playerBoardsPosition?: [number, number];
+    supplyPosition?: [number, number];
+    roundInfoPosition?: [number, number];
+    resupply?: number[][][];
+    startingResources?: number[];
+    startingSupply?: number[];
+    maxPriceAvailable?: number[]; // For India, only limited sections of the supply are available in step 1 and 2.
+    coalPrices?: number[];
+    oilPrices?: number[];
+    garbagePrices?: number[];
+    uraniumPrices?: number[];
+    setupDeck?: (
+        numPlayers: number,
+        variant: string,
+        rng: seedrandom.prng
+    ) => {
+        actualMarket: PowerPlant[];
+        futureMarket: PowerPlant[];
+        powerPlantsDeck: PowerPlant[];
+    };
+    mapSpecificRules?: string;
+}
+
+export const maps: GameMap[] = [
+    america,
+    germany,
+    brazil,
+    spainportugal,
+    france,
+    indian,
+    italy,
+    quebec,
+    middleeast,
+    china,
+    benelux,
+    russia,
+    centraleurope,
+    // australia,
+    // badenwurttemberg,
+    // japan,
+    // korea,
+    // northerneurope,
+    // southafrica,
+    // ukireland,
+];
+
+export const mapsRecharged: GameMap[] = [
+    americaRecharged,
+    germanyRecharged,
+    brazil,
+    spainportugal,
+    france,
+    indian,
+    italy,
+    quebec,
+    middleeast,
+    china,
+    benelux,
+    russia,
+    centraleurope,
+    // australia,
+    // badenwurttemberg,
+    // china,
+    // japan,
+    // korea,
+    // northerneurope,
+    // southafrica,
+    // ukireland,
+];

package/src/move.ts

@@ -0,0 +1,83 @@
+import { ResourceType } from './gamestate';
+
+export declare namespace Moves {
+    export interface MoveChoosePowerPlant {
+        name: MoveName.ChoosePowerPlant;
+        data: number;
+        usedPlantDiscount?: boolean;
+    }
+
+    export interface MoveBid {
+        name: MoveName.Bid;
+        data: number;
+    }
+
+    export interface MoveDiscardPowerPlant {
+        name: MoveName.DiscardPowerPlant;
+        data: number;
+        extra?: number[];
+    }
+
+    export interface MoveDiscardResources {
+        name: MoveName.DiscardResources;
+        data: ResourceType;
+    }
+
+    export interface MoveBuyResource {
+        name: MoveName.BuyResource;
+        data: {
+            resource: ResourceType;
+        };
+        fromSupply?: boolean;
+    }
+
+    export interface MoveBuild {
+        name: MoveName.Build;
+        data: {
+            name: string;
+            price: number;
+        };
+    }
+
+    export interface MoveUsePowerPlant {
+        name: MoveName.UsePowerPlant;
+        data: {
+            powerPlant: number;
+            resourcesSpent: ResourceType[];
+            citiesPowered: number;
+        };
+    }
+
+    export interface MovePass {
+        name: MoveName.Pass;
+        data: true;
+    }
+
+    export interface MoveUndo {
+        name: MoveName.Undo;
+        data: boolean;
+    }
+}
+
+export type Move =
+    | Moves.MoveChoosePowerPlant
+    | Moves.MoveBid
+    | Moves.MoveDiscardPowerPlant
+    | Moves.MoveDiscardResources
+    | Moves.MoveBuyResource
+    | Moves.MoveBuild
+    | Moves.MoveUsePowerPlant
+    | Moves.MovePass
+    | Moves.MoveUndo;
+
+export enum MoveName {
+    ChoosePowerPlant = 'ChoosePowerPlant',
+    Bid = 'Bid',
+    DiscardPowerPlant = 'DiscardPowerPlant',
+    DiscardResources = 'DiscardResources',
+    BuyResource = 'BuyResource',
+    Build = 'Build',
+    UsePowerPlant = 'UsePowerPlant',
+    Pass = 'Pass',
+    Undo = 'Undo',
+}

package/src/powerPlants.ts

@@ -0,0 +1,59 @@
+import { cloneDeep } from 'lodash';
+import { PowerPlant, PowerPlantType } from './gamestate';
+
+const powerPlants: PowerPlant[] = [
+    { number: 3, type: PowerPlantType.Oil, cost: 2, citiesPowered: 1 },
+    { number: 4, type: PowerPlantType.Coal, cost: 2, citiesPowered: 1 },
+    { number: 5, type: PowerPlantType.Hybrid, cost: 2, citiesPowered: 1 },
+    { number: 6, type: PowerPlantType.Garbage, cost: 1, citiesPowered: 1 },
+    { number: 7, type: PowerPlantType.Oil, cost: 3, citiesPowered: 2 },
+    { number: 8, type: PowerPlantType.Coal, cost: 3, citiesPowered: 2 },
+    { number: 9, type: PowerPlantType.Oil, cost: 1, citiesPowered: 1 },
+    { number: 10, type: PowerPlantType.Coal, cost: 2, citiesPowered: 2 },
+    { number: 11, type: PowerPlantType.Uranium, cost: 1, citiesPowered: 2 },
+    { number: 12, type: PowerPlantType.Hybrid, cost: 2, citiesPowered: 2 },
+    { number: 13, type: PowerPlantType.Wind, cost: 0, citiesPowered: 1 },
+    { number: 14, type: PowerPlantType.Garbage, cost: 2, citiesPowered: 2 },
+    { number: 15, type: PowerPlantType.Coal, cost: 2, citiesPowered: 3 },
+    { number: 16, type: PowerPlantType.Oil, cost: 2, citiesPowered: 3 },
+    { number: 17, type: PowerPlantType.Uranium, cost: 1, citiesPowered: 2 },
+    { number: 18, type: PowerPlantType.Wind, cost: 0, citiesPowered: 2 },
+    { number: 19, type: PowerPlantType.Garbage, cost: 2, citiesPowered: 3 },
+    { number: 20, type: PowerPlantType.Coal, cost: 3, citiesPowered: 5 },
+    { number: 21, type: PowerPlantType.Hybrid, cost: 2, citiesPowered: 4 },
+    { number: 22, type: PowerPlantType.Wind, cost: 0, citiesPowered: 2 },
+    { number: 23, type: PowerPlantType.Uranium, cost: 1, citiesPowered: 3 },
+    { number: 24, type: PowerPlantType.Garbage, cost: 2, citiesPowered: 4 },
+    { number: 25, type: PowerPlantType.Coal, cost: 2, citiesPowered: 5 },
+    { number: 26, type: PowerPlantType.Oil, cost: 2, citiesPowered: 5 },
+    { number: 27, type: PowerPlantType.Wind, cost: 0, citiesPowered: 3 },
+    { number: 28, type: PowerPlantType.Uranium, cost: 1, citiesPowered: 4 },
+    { number: 29, type: PowerPlantType.Hybrid, cost: 1, citiesPowered: 4 },
+    { number: 30, type: PowerPlantType.Garbage, cost: 3, citiesPowered: 6 },
+    { number: 31, type: PowerPlantType.Coal, cost: 3, citiesPowered: 6 },
+    { number: 32, type: PowerPlantType.Oil, cost: 3, citiesPowered: 6 },
+    { number: 33, type: PowerPlantType.Wind, cost: 0, citiesPowered: 4 },
+    { number: 34, type: PowerPlantType.Uranium, cost: 1, citiesPowered: 5 },
+    { number: 35, type: PowerPlantType.Oil, cost: 1, citiesPowered: 5 },
+    { number: 36, type: PowerPlantType.Coal, cost: 3, citiesPowered: 7 },
+    { number: 37, type: PowerPlantType.Wind, cost: 0, citiesPowered: 4 },
+    { number: 38, type: PowerPlantType.Garbage, cost: 3, citiesPowered: 7 },
+    { number: 39, type: PowerPlantType.Uranium, cost: 1, citiesPowered: 6 },
+    { number: 40, type: PowerPlantType.Oil, cost: 2, citiesPowered: 6 },
+    { number: 42, type: PowerPlantType.Coal, cost: 2, citiesPowered: 6 },
+    { number: 44, type: PowerPlantType.Wind, cost: 0, citiesPowered: 5 },
+    { number: 46, type: PowerPlantType.Hybrid, cost: 3, citiesPowered: 7 },
+    { number: 50, type: PowerPlantType.Nuclear, cost: 0, citiesPowered: 6 },
+    { number: 99, type: PowerPlantType.Step3, cost: 0, citiesPowered: 6 },
+];
+
+const indiaPowerPlants = cloneDeep(powerPlants).filter((pp) => pp.number != 11);
+// Garbage plants cost one more garbage to run, but have no additional storage.
+indiaPowerPlants.forEach((pp) => {
+    if (pp.type == PowerPlantType.Garbage) {
+        pp.storage = 2 * pp.cost;
+        pp.cost++;
+    }
+});
+
+export { powerPlants, indiaPowerPlants };

package/src/prices.ts

@@ -0,0 +1,10 @@
+import { ResourceType } from './gamestate';
+
+const prices = {
+    [ResourceType.Coal]: [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8],
+    [ResourceType.Oil]: [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8],
+    [ResourceType.Garbage]: [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8],
+    [ResourceType.Uranium]: [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16],
+};
+
+export default prices;

package/src/randomizeMap.ts

@@ -0,0 +1,288 @@
+import Delaunator from 'delaunator';
+import { upperFirst } from 'lodash';
+import seedrandom from 'seedrandom';
+import { City, Connection, GameMap } from './maps';
+
+export function createRandomizedMap(map: GameMap, regionCount: number, rng: seedrandom.prng): GameMap {
+    const regions = [...new Set(map.cities.map((c) => c.region))];
+    const cities = Array(7 * regionCount)
+        .fill(0)
+        .map((_) => ({ name: '', region: '', x: 0, y: 0 }));
+    const widthByRegions = [420, 490, 490];
+    const heightByRegions = [490, 560, 700];
+    const width = widthByRegions[regionCount - 3];
+    const height = heightByRegions[regionCount - 3];
+    const gridCellSize = 70;
+    const gridWidth = Math.ceil(width / gridCellSize);
+    const gridHeight = Math.ceil(height / gridCellSize);
+    const gridLength = gridWidth * gridHeight;
+    const grid = Array(gridLength).fill(-1);
+
+    map.mapPosition = [100, 200];
+    map.layout = 'Portrait';
+
+    let emptyGrids = Array(gridLength)
+        .fill(0)
+        .map((_, i) => i);
+    cities.forEach((city, i) => {
+        const emptyGrid = emptyGrids[Math.floor(rng() * emptyGrids.length)];
+        const emptyGridY = Math.floor(emptyGrid / gridWidth);
+        const emptyGridX = emptyGrid % gridWidth;
+        city.x = Math.floor(emptyGridX * 2 * gridCellSize);
+        city.y = Math.floor(emptyGridY * gridCellSize);
+        if (emptyGridY % 2 === 0) {
+            city.x += gridCellSize;
+        }
+
+        const t = rng() * 2 * Math.PI;
+        const r = (rng() * gridCellSize) / 2;
+        city.x += r * Math.cos(t);
+        city.y += r * Math.sin(t);
+
+        emptyGrids = emptyGrids.filter((g) => g !== emptyGrid);
+        grid[emptyGrid] = i;
+    });
+
+    const cityDists: number[][] = Array(cities.length)
+        .fill(0)
+        .map((_) => Array(cities.length).fill(0));
+    const cityConnections: boolean[][] = Array(cities.length)
+        .fill(0)
+        .map((_) => Array(cities.length).fill(null));
+    const d = Delaunator.from(
+        cities,
+        (c: City) => c.x,
+        (c: City) => c.y
+    );
+    for (let i = 0; i < d.triangles.length; i += 3) {
+        const city1 = cities[d.triangles[i]];
+        const city2 = cities[d.triangles[i + 1]];
+        const city3 = cities[d.triangles[i + 2]];
+
+        let dist = cityDists[d.triangles[i]][d.triangles[i + 1]];
+        const dist12Squared = dist
+            ? Math.pow(dist, 2)
+            : Math.pow(city1.x - city2.x, 2) + Math.pow(city1.y - city2.y, 2);
+        const dist12 =
+            dist ||
+            (cityDists[d.triangles[i + 1]][d.triangles[i]] = cityDists[d.triangles[i]][d.triangles[i + 1]] =
+                Math.sqrt(dist12Squared));
+
+        dist = cityDists[d.triangles[i]][d.triangles[i + 2]];
+        const dist13Squared = dist
+            ? Math.pow(dist, 2)
+            : Math.pow(city1.x - city3.x, 2) + Math.pow(city1.y - city3.y, 2);
+        const dist13 =
+            dist ||
+            (cityDists[d.triangles[i + 2]][d.triangles[i]] = cityDists[d.triangles[i]][d.triangles[i + 2]] =
+                Math.sqrt(dist13Squared));
+
+        dist = cityDists[d.triangles[i + 1]][d.triangles[i + 2]];
+        const dist23Squared = dist
+            ? Math.pow(dist, 2)
+            : Math.pow(city2.x - city3.x, 2) + Math.pow(city2.y - city3.y, 2);
+        const dist23 =
+            dist ||
+            (cityDists[d.triangles[i + 2]][d.triangles[i + 1]] = cityDists[d.triangles[i + 1]][d.triangles[i + 2]] =
+                Math.sqrt(dist23Squared));
+
+        // arccos((P122 + P132 - P232) / (2 * P12 * P13))
+        const angle1 = Math.acos((dist12Squared + dist13Squared - dist23Squared) / (2 * dist12 * dist13));
+        const angle2 = Math.acos((dist12Squared + dist23Squared - dist13Squared) / (2 * dist12 * dist23));
+        const angle3 = Math.PI - angle1 - angle2;
+
+        const maxAngle = (105 * Math.PI) / 180;
+        if (cityConnections[d.triangles[i]][d.triangles[i + 1]] !== false && angle3 < maxAngle) {
+            cityConnections[d.triangles[i]][d.triangles[i + 1]] = true;
+            cityConnections[d.triangles[i + 1]][d.triangles[i]] = true;
+        } else {
+            cityConnections[d.triangles[i]][d.triangles[i + 1]] = false;
+            cityConnections[d.triangles[i + 1]][d.triangles[i]] = false;
+        }
+
+        if (cityConnections[d.triangles[i]][d.triangles[i + 2]] !== false && angle2 < maxAngle) {
+            cityConnections[d.triangles[i]][d.triangles[i + 2]] = true;
+            cityConnections[d.triangles[i + 2]][d.triangles[i]] = true;
+        } else {
+            cityConnections[d.triangles[i]][d.triangles[i + 2]] = false;
+            cityConnections[d.triangles[i + 2]][d.triangles[i]] = false;
+        }
+
+        if (cityConnections[d.triangles[i + 1]][d.triangles[i + 2]] !== false && angle1 < maxAngle) {
+            cityConnections[d.triangles[i + 1]][d.triangles[i + 2]] = true;
+            cityConnections[d.triangles[i + 2]][d.triangles[i + 1]] = true;
+        } else {
+            cityConnections[d.triangles[i + 1]][d.triangles[i + 2]] = false;
+            cityConnections[d.triangles[i + 2]][d.triangles[i + 1]] = false;
+        }
+    }
+
+    let maxDist = 0;
+    let minDist = 1000;
+    for (let i = 0; i < cities.length; i++) {
+        for (let j = 0; j < i; j++) {
+            if (cityConnections[i][j]) {
+                const dist = cityDists[i][j];
+                maxDist = Math.max(maxDist, dist);
+                minDist = Math.min(minDist, dist);
+            }
+        }
+    }
+
+    const centroids =
+        regionCount === 5
+            ? [
+                  [width / 4, height / 4],
+                  [width / 4, (3 * height) / 4],
+                  [width / 2, height / 2],
+                  [(3 * width) / 4, height / 4],
+                  [(3 * width) / 4, (3 * height) / 4],
+              ]
+            : regionCount === 4
+            ? [
+                  [width / 4, height / 4],
+                  [width / 4, (3 * height) / 4],
+                  [(3 * width) / 4, height / 4],
+                  [(3 * width) / 4, (3 * height) / 4],
+              ]
+            : [
+                  [width / 4, height / 4],
+                  [width / 2, height / 2],
+                  [(3 * width) / 4, (3 * height) / 4],
+              ];
+    const indexes = bkmeans(
+        cities.map((c) => [c.x, c.y]),
+        regionCount,
+        centroids,
+        cityConnections
+    );
+    const countRegions = Array(regionCount).fill(0);
+    cities.forEach((city, index) => {
+        city.region = regions[indexes[index]];
+        city.name = upperFirst(city.region) + ' ' + (countRegions[indexes[index]]++ + 1);
+    });
+
+    const connections: Connection[] = [];
+    for (let i = 0; i < cities.length; i++) {
+        for (let j = 0; j < i; j++) {
+            if (cityConnections[i][j]) {
+                const city1 = cities[i];
+                const city2 = cities[j];
+                const dist = cityDists[i][j];
+                connections.push({
+                    nodes: [city1.name, city2.name],
+                    cost: Math.floor((5 * dist) / gridCellSize),
+                });
+            }
+        }
+    }
+
+    map.cities = cities;
+    map.connections = connections;
+
+    return map;
+}
+
+function bkmeans(
+    points: number[][],
+    regions: number,
+    centroids: number[][],
+    connections: boolean[][],
+    iterations = 100
+): number[] {
+    const indexes = Array(points.length).fill(0);
+    const pointsPerRegion = Math.ceil(points.length / regions);
+
+    let conv = false;
+    do {
+        // Assign
+        const regionsCount = Array(regions).fill(0);
+        const pointCentDists = Array(points.length)
+            .fill(0)
+            .map((_) => Array(regions).fill(0));
+        points.forEach((point, pi) => {
+            let minDist: number | null = null;
+            let index = 0;
+            centroids.forEach((centroid, ci) => {
+                const d = dist(point, centroid);
+                if (minDist === null || d < minDist) {
+                    if (regionsCount[ci] < pointsPerRegion) {
+                        minDist = d;
+                        index = ci;
+                    }
+                }
+
+                pointCentDists[pi][ci] = d;
+            });
+
+            indexes[pi] = index;
+            regionsCount[index]++;
+        });
+
+        // Update
+        const newCentroids = Array(centroids.length)
+            .fill(0)
+            .map((_) => [0, 0]);
+        const centroidsCount = Array(centroids.length).fill(0);
+        points.forEach((point, pi) => {
+            newCentroids[indexes[pi]][0] += point[0];
+            newCentroids[indexes[pi]][1] += point[1];
+            centroidsCount[indexes[pi]]++;
+        });
+
+        conv = true;
+        centroids.forEach((centroid, ci) => {
+            newCentroids[ci][0] = newCentroids[ci][0] / centroidsCount[ci];
+            newCentroids[ci][1] = newCentroids[ci][1] / centroidsCount[ci];
+
+            if (centroid[0] !== newCentroids[ci][0] || centroid[1] !== newCentroids[ci][1]) {
+                conv = false;
+            }
+        });
+
+        centroids = newCentroids;
+
+        console.log('iterations', iterations);
+        console.log('centroids', centroids);
+
+        conv = conv || --iterations === 0;
+    } while (!conv);
+
+    // Refine
+    let maxRefine = 10;
+    do {
+        console.log('Refining');
+        conv = true;
+        points.forEach((_, p1) => {
+            const index = indexes[p1];
+            const hasSameColorNeighbor = connections[p1].some((connection, p2) => connection && index === indexes[p2]);
+            if (!hasSameColorNeighbor) {
+                const centroid = centroids[index];
+                let minDist: number | null = null;
+                let closestNeighbor: number | null = null;
+                connections[p1].forEach((connection, p2) => {
+                    if (connection) {
+                        const neighbor = points[p2];
+                        const d = dist(neighbor, centroid);
+                        if (minDist === null || d < minDist) {
+                            minDist = d;
+                            closestNeighbor = p2;
+                        }
+                    }
+                });
+
+                indexes[p1] = indexes[closestNeighbor!];
+                indexes[closestNeighbor!] = index;
+
+                conv = false;
+            }
+        });
+        conv = conv || --maxRefine === 0;
+    } while (!conv);
+
+    return indexes;
+}
+
+function dist(p1: number[], p2: number[]): number {
+    return (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]);
+}

package/src/rankings.spec.ts

@@ -0,0 +1,18 @@
+import { expect } from 'chai';
+import { rankings } from '../wrapper';
+import { GameState } from './gamestate';
+
+describe('rankings', () => {
+    it('should rank players correctly', () => {
+        const players: any[] = [
+            { id: 0, citiesPowered: 20, money: 30, cities: { length: 21 } },
+            { id: 1, citiesPowered: 20, money: 20, cities: { length: 21 } },
+            { id: 2, citiesPowered: 20, money: 30, cities: { length: 21 } },
+            { id: 4, citiesPowered: 18, money: 30, cities: { length: 21 } },
+            { id: 3, citiesPowered: 18, money: 30, cities: { length: 20 } },
+            { id: 5, citiesPowered: 19, money: 30, cities: { length: 21 } },
+        ];
+
+        expect(rankings({ players } as GameState)).to.have.ordered.members([1, 3, 1, 5, 6, 4]);
+    });
+});

package/src/utils.spec.ts

@@ -0,0 +1,13 @@
+import { expect } from 'chai';
+import { shuffle } from './utils';
+
+describe('utils', () => {
+    describe('shuffle', () => {
+        it('should shuffle the same way based on the seed', () => {
+            expect(shuffle([1, 2, 3, 4], 'a')).to.have.ordered.members([4, 2, 3, 1]);
+            expect(shuffle([1, 2, 3, 4], 'b')).to.have.ordered.members([3, 1, 2, 4]);
+            expect(shuffle([1, 2, 3, 4], 'b')).to.have.ordered.members([3, 1, 2, 4]);
+            expect(shuffle([1, 2, 3, 4], 'a')).to.have.ordered.members([4, 2, 3, 1]);
+        });
+    });
+});

package/src/utils.ts

@@ -0,0 +1,23 @@
+import seedrandom from 'seedrandom';
+
+/* eslint-disable */
+export function asserts<T>(move: any): asserts move is T {}
+
+/* eslint-enable */
+
+export function shuffle<T>(array: T[], seed: string): T[] {
+    const rng = seedrandom.alea(seed);
+    const reverse = new Map<number, number>();
+
+    array.forEach((item, i) => {
+        let n = rng.int32();
+
+        while (reverse.has(n)) {
+            n = rng.int32();
+        }
+
+        reverse.set(n, i);
+    });
+
+    return [...reverse.keys()].sort().map((n) => array[reverse.get(n)!]);
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "compilerOptions": {
+        /* Basic Options */
+        "target": "es2018",
+        "module": "commonjs",
+        "esModuleInterop": true,
+        "strictNullChecks": true,
+        "declaration": true /* Generates corresponding '.d.ts' file. */,
+        "sourceMap": false /* Generates corresponding '.map' file. */,
+        // "outFile": "./",                       /* Concatenate and emit output to single file. */
+        "outDir": "./dist" /* Redirect output structure to the directory. */,
+        "resolveJsonModule": true
+    },
+    "types": ["node"],
+    "include": ["src/**/*.ts", "index.ts", "wrapper.ts"],
+    "exclude": ["node_modules", "dist", "**/*.spec.ts"]
+}